slimfits/dist/bundle.d.ts

Package for loading data stored in FITS data format

// Generated by dts-bundle v0.7.3

export class FitsReader {
    static readFitsAsync(file: IDataSource): Promise<IHdu[]>;
    static readHeaderAsync(file: IDataSource, offsetBytes: number): Promise<{
        header: Keyword[];
        bytesRead: number;
    }>;
    static readHduAsync(file: IDataSource, offsetBytes: number): Promise<IHdu>;
    static readDataAsync(file: IDataSource, offsetBytes: number, header: IKeyword[]): Promise<DataResult>;
    static readDataSize(header: IKeyword[]): number;
}

export class BlobFile implements IDataSource {
    url: string;
    constructor(file: File);
    initialize(): Promise<boolean>;
    getByteLength(): number;
    getStringAsync(start: number, length: number): Promise<string>;
    getDataAsync(start: number, length: number, bitPix: BitPix, changeEndian?: boolean): Promise<TypedArray>;
}

export class MultipleRequestFile implements IDataSource {
    url: string;
    constructor(url: string);
    initialize(): Promise<boolean>;
    getByteLength(): number;
    getStringAsync(start: number, byteLength: number): Promise<string>;
    getDataAsync(start: number, length: number, bitPix: BitPix, changeEndian?: boolean): Promise<TypedArray>;
}

export class SingleRequestFile implements IDataSource {
    url: string;
    constructor(url: string);
    initialize(): Promise<boolean>;
    getByteLength(): number;
    getStringAsync(start: number, length: number): Promise<any>;
    getDataAsync(start: number, length: number, bitPix: BitPix, changeEndian?: boolean): Promise<TypedArray>;
}

export class ArrayBufferFile implements IDataSource {
    constructor(data: ArrayBufferLike);
    initialize(): Promise<boolean>;
    getByteLength(): number;
    getStringAsync(start: number, length: number): Promise<any>;
    getDataAsync(start: number, length: number, bitPix: BitPix, changeEndian?: boolean): Promise<TypedArray>;
}

export class Keyword implements IKeyword {
    key: string;
    value: any;
    comment: string;
    static isLastLine(line: string): boolean;
    constructor(key: string, value?: any, comment?: string);
}
export class KeywordsManager {
    static single(header: Keyword[], key: string): IKeyword;
    static getValue<T>(header: Keyword[], key: string, defaultValue: T): T;
    static hasValue<T>(header: Keyword[], key: string, value: T): boolean;
    static hasValueFromList<T>(header: Keyword[], key: string, values: T[]): boolean;
    static convert(value: any): any;
    static convertBack(value: any, name: string): any;
    static parseKeyword(line: string): IKeyword;
}

export interface IPlaneProjectionDefinition {
    frame_reference_point: {
        x: number;
        y: number;
    };
    sky_reference_point: {
        alpha: number;
        delta: number;
    };
    transform_matrix: number[][];
    distortion_matrix: number[][];
    celestial_pole: {
        latitude: number;
        longitude: number;
    };
}
export interface ISphericalProjectionConverter {
    convert(coords: {
        x: number;
        y: number;
    }): {
        alpha: number;
        delta: number;
    };
    convertBack(coords: {
        alpha: number;
        delta: number;
    }): {
        x: number;
        y: number;
    };
}
export abstract class SphericalProjectionConverterBase {
    protected ra2de: number;
    protected de2ra: number;
    protected phi_0: number;
    protected theta_0: number;
    protected alpha_0: number;
    protected delta_0: number;
    protected theta_p: number;
    protected phi_p: number;
    protected ctypes: string[];
    protected wcslen: number;
    protected cdelts: number[];
    protected crpixs: number[];
    protected crvals: number[];
    protected crotas: number[];
    protected transform_matrix: number[][];
    protected inverse_transform_matrix: number[][];
    protected projection: string;
    protected axes_types: Array<{
        name: string;
        isLongitudal: boolean;
    }>;
    constructor(obj: any[] | IPlaneProjectionDefinition);
    convert(coords: {
        x: number;
        y: number;
    }): {
        alpha: number;
        delta: number;
    };
    convertBack(coords: {
        alpha: number;
        delta: number;
    }): {
        x: number;
        y: number;
    };
    abstract convertToSpherical(coords: {
        x: number;
        y: number;
    }): {
        r: number;
        phi: number;
        theta: number;
    };
    abstract calculate_alphap_deltap(): {
        alpha_p: number;
        delta_p: number;
    };
    abstract calculate_phi0_theta0(): {
        phi_0: number;
        theta_0: number;
    };
    abstract convertFromCelestial(coords: {
        alpha: number;
        delta: number;
    }): {
        r: number;
        phi: number;
        theta: number;
    };
    protected multiplyMatrices(arr1: number[][], arr2: number[][]): number[][];
    protected convertToRelative(coords: {
        x: number;
        y: number;
    }): {
        u: number;
        v: number;
    };
    protected convertFromRelative(coords: {
        u: number;
        v: number;
    }): {
        x: number;
        y: number;
    };
    protected convertToIntermediate(coords: {
        u: number;
        v: number;
    }): {
        x: number;
        y: number;
    };
    protected convertFromIntermediate(coords: {
        x: number;
        y: number;
    }): {
        u: number;
        v: number;
    };
    protected convertFromSpherical(coords: {
        r: number;
        phi: number;
        theta: number;
    }): {
        x: number;
        y: number;
    };
    protected convertToCelestial(coords: {
        r: number;
        phi: number;
        theta: number;
    }): {
        alpha: number;
        delta: number;
    };
    protected convertFromCelestialToAngles(coords: {
        alpha: number;
        delta: number;
    }): {
        phi: number;
        theta: number;
    };
    protected constructFromHeader(header: any[]): void;
    protected constructFromDefinition(definition: IPlaneProjectionDefinition): void;
}
export abstract class ZenithalProjectionConverterBase extends SphericalProjectionConverterBase {
    calculate_alphap_deltap(): {
        alpha_p: number;
        delta_p: number;
    };
    calculate_phi0_theta0(): {
        phi_0: number;
        theta_0: number;
    };
}
export abstract class NonPolarProjectionConverterBase extends SphericalProjectionConverterBase {
    calculate_alphap_deltap(): {
        alpha_p: number;
        delta_p: number;
    };
}
export class GnomonicProjectionConverter extends ZenithalProjectionConverterBase implements ISphericalProjectionConverter {
    convertToSpherical(coords: {
        x: number;
        y: number;
    }): {
        r: number;
        phi: number;
        theta: number;
    };
    convertFromCelestial(coords: {
        alpha: number;
        delta: number;
    }): {
        r: number;
        phi: number;
        theta: number;
    };
}
export class TpvGnomonicProjectionConverter extends GnomonicProjectionConverter implements ISphericalProjectionConverter {
    protected pvs: number[][];
    convert(coords: {
        x: number;
        y: number;
    }): {
        alpha: number;
        delta: number;
    };
    convertBack(coords: {
        alpha: number;
        delta: number;
    }): {
        x: number;
        y: number;
    };
    protected constructFromHeader(header: any[]): void;
    protected constructFromDefinition(definition: IPlaneProjectionDefinition): void;
    protected convertToDistorted(coords: {
        x: number;
        y: number;
    }): {
        x: number;
        y: number;
    };
    protected getDistortedParam(xi: number, eta: number, pv: number[]): number;
    protected convertFromDistorted(coords: {
        x: number;
        y: number;
    }): {
        x: number;
        y: number;
    };
}
export class SipGnomonicProjectionConverter extends GnomonicProjectionConverter implements ISphericalProjectionConverter {
    protected a: number[][];
    protected b: number[][];
    protected a_order: number;
    protected b_order: number;
    protected ab_inv: number[][];
    protected inv_a_order: number;
    protected inv_b_order: number;
    convert(coords: {
        x: number;
        y: number;
    }): {
        alpha: number;
        delta: number;
    };
    convertBack(coords: {
        alpha: number;
        delta: number;
    }): {
        x: number;
        y: number;
    };
    protected constructFromHeader(header: any[]): void;
    protected constructFromDefinition(definition: IPlaneProjectionDefinition): void;
    protected convertToDistorted(coords: {
        u: number;
        v: number;
    }): {
        u: number;
        v: number;
    };
    protected getDistortedParam(u: number, v: number, arr: number[][], order: number): number;
    protected convertFromDistorted(coords: {
        u: number;
        v: number;
    }): {
        u: number;
        v: number;
    };
}
export class SlantOrtographicProjectionConverter extends ZenithalProjectionConverterBase implements ISphericalProjectionConverter {
    convertToSpherical(coords: {
        x: number;
        y: number;
    }): {
        r: number;
        phi: number;
        theta: number;
    };
    convertFromCelestial(coords: {
        alpha: number;
        delta: number;
    }): {
        r: number;
        phi: number;
        theta: number;
    };
}
export class ZenithalEquidistantProjectionConverter extends ZenithalProjectionConverterBase implements ISphericalProjectionConverter {
    convertToSpherical(coords: {
        x: number;
        y: number;
    }): {
        r: number;
        phi: number;
        theta: number;
    };
    convertFromCelestial(coords: {
        alpha: number;
        delta: number;
    }): {
        r: number;
        phi: number;
        theta: number;
    };
}
export class StereographicProjectionConverter extends ZenithalProjectionConverterBase implements ISphericalProjectionConverter {
    convertToSpherical(coords: {
        x: number;
        y: number;
    }): {
        r: number;
        phi: number;
        theta: number;
    };
    convertFromCelestial(coords: {
        alpha: number;
        delta: number;
    }): {
        r: number;
        phi: number;
        theta: number;
    };
}
export class ZenithalEqualAreaProjectionConverter extends ZenithalProjectionConverterBase implements ISphericalProjectionConverter {
    convertToSpherical(coords: {
        x: number;
        y: number;
    }): {
        r: number;
        phi: number;
        theta: number;
    };
    convertFromCelestial(coords: {
        alpha: number;
        delta: number;
    }): {
        r: number;
        phi: number;
        theta: number;
    };
}
export class SphericalProjectionConvertersBuilder {
    constructor();
    canBuild(obj: any[] | string): boolean;
    build(obj: any[] | {
        projection: string;
        definition: IPlaneProjectionDefinition;
    }): ISphericalProjectionConverter;
    registerConverter(projection: string, converter: (header: any[]) => ISphericalProjectionConverter): void;
}

export interface IKeyword {
        key: string;
        value: any;
        comment: string;
}
export type TypedArray = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array | Float64Array;
export interface IDataReader {
        name: string;
        canReadData(header: IKeyword[]): boolean;
        readDataAsync(file: IDataSource, offsetBytes: number, header: IKeyword[]): Promise<any>;
        readDataSize(header: IKeyword[]): number;
}
export interface IDataSource {
        initialize(): Promise<boolean>;
        getByteLength(): number;
        getStringAsync(start: number, length: number): Promise<string>;
        getDataAsync(start: number, length: number, bitPix: BitPix, changeEndian?: boolean): Promise<TypedArray>;
}
export interface IHdu {
        data: () => Promise<any | void>;
        header: IKeyword[];
        bytesRead: number;
}
export interface IHeaderResult {
        header: IKeyword[];
        bytesRead: number;
}
export interface IAsciiConverter {
        array: TypedArray | string[];
        converter: (x: string) => any;
}
export class DataResult {
        data: any;
        name: string;
        constructor(data: any, name: string);
}
/**
    *  Contains constants describing basic structure of FITS file. Each unit of organization,
    *  be it header of payload is padded to be a multiple of 2880, which defined to be a block length.
    *
    *  In header each line has constant length of 80 ASCII characters, with 8 bytes for the keyword,
    *  hence abbreviated key names.
    *
    *  Block length divided by line length gives the maximal count of lines per block: 36.
    */
export const Constants: {
        blockLength: number;
        lineLength: number;
        keyLength: number;
        maxKeywordsInBlock: number;
};
export enum BitPix {
        Uint8 = 8,
        Char = 8,
        Int16 = 16,
        Int32 = 32,
        Int64 = 64,
        Float32 = -32,
        Float64 = -64,
        Unknown = 0
}
export class BitPixUtils {
        /**
            *  Gets size of type in bytes
            *  @static
            *  @public
            *  @param {BitPix} type - The type.
            *  @return {number} - size in bytes
            */
        static getByteSize(type: BitPix): number;
        static getBitPixForLetter(format: string): BitPix.Uint8 | BitPix.Int16 | BitPix.Int32 | BitPix.Int64 | BitPix.Float32 | BitPix.Float64;
}