acmi-parser 1.0.0 → 1.1.0

package/dist/types/acmi-parser.d.ts

@@ -1,26 +1,19 @@
-import { Cartesian3 } from '@cesium/engine';
 import { Dayjs } from 'dayjs';
 import dayjs from 'dayjs';
-import { Quaternion } from '@cesium/engine';
 
 export declare class AcmiData {
     isValid: boolean;
-    header: AcmiHeader;
+    header: Header;
     globalProperties: GlobalProperties;
     timeSpan: TimeSpan;
-    entities: Map<number, IEntityProps>;
-    frames: Frames;
-    private readonly _fixedFrame;
+    entities: Map<number, Entity>;
+    frames: Array<Frame>;
+    private _searchFrameIndex;
     getFrame(time: Dayjs): Frame | undefined;
     private _addFrame;
     createSampledTrajectories(options?: ITrajectoryOptions): Trajectories;
 }
 
-export declare class AcmiHeader {
-    fileType: string;
-    fileVersion: string;
-}
-
 declare class AcmiParser {
     private _decoder;
     private _currentLine;
@@ -30,19 +23,16 @@ declare class AcmiParser {
     private _filteredIds;
     private _data;
     private _filter;
-    private _refLat;
-    private _refLong;
     private readonly _acmiVersions;
     private readonly _acmiType;
     private readonly _propertySeparator;
     private readonly _headerPattern;
-    constructor(geoidModel: Uint8Array);
+    constructor(geoidPgm?: Uint8Array);
     private _isValidVersion;
     private _isValidType;
     private _parseHeader;
     private _parseContent;
     private _parseLine;
-    private _isZipped;
     private _unzip;
     private _parseBuffer;
     parse(data: Uint8Array, options?: AcmiParserOptions): Promise<AcmiData>;
@@ -54,7 +44,17 @@ export declare interface AcmiParserOptions {
     controller?: AbortController;
 }
 
-export declare class EntityProps implements IEntityProps {
+declare type ConfigurationOptions = {
+    EPSILON: number;
+    debug?: boolean;
+    precision: number;
+    printTypes?: boolean;
+    printDegrees?: boolean;
+    printRowMajor?: boolean;
+    _cartographicRadians?: boolean;
+};
+
+export declare class Entity {
     id: number;
     timeSpan: TimeSpan;
     name?: string;
@@ -68,13 +68,102 @@ export declare class EntityProps implements IEntityProps {
     constructor(id: number);
 }
 
+declare class Euler extends MathArray {
+    static get ZYX(): RotationOrder;
+    static get YXZ(): RotationOrder;
+    static get XZY(): RotationOrder;
+    static get ZXY(): RotationOrder;
+    static get YZX(): RotationOrder;
+    static get XYZ(): RotationOrder;
+    static get RollPitchYaw(): RotationOrder;
+    static get DefaultOrder(): RotationOrder;
+    static get RotationOrders(): typeof RotationOrder;
+    static rotationOrder(order: RotationOrder): string;
+    get ELEMENTS(): number;
+    constructor(x?: number, y?: number, z?: number, order?: RotationOrder);
+    fromQuaternion(quaternion: Readonly<NumericArray_2>): this;
+    fromObject(_object: Record<string, unknown>): this;
+    copy(array: Readonly<NumericArray_2>): this;
+    set(x: number | undefined, y: number | undefined, z: number | undefined, order: RotationOrder): this;
+    validate(): boolean;
+    toArray(array?: NumericArray_2, offset?: number): NumericArray_2;
+    toArray4(array?: NumericArray_2, offset?: number): NumericArray_2;
+    toVector3(result?: NumericArray_2): NumericArray_2;
+    toHeadingPitchRoll(): NumericArray_2;
+    toHeadingPitchRoll<T extends NumericArray_2>(result: T): T;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get alpha(): number;
+    set alpha(value: number);
+    get beta(): number;
+    set beta(value: number);
+    get gamma(): number;
+    set gamma(value: number);
+    get phi(): number;
+    set phi(value: number);
+    get theta(): number;
+    set theta(value: number);
+    get psi(): number;
+    set psi(value: number);
+    get roll(): number;
+    set roll(value: number);
+    get pitch(): number;
+    set pitch(value: number);
+    get yaw(): number;
+    set yaw(value: number);
+    get order(): RotationOrder;
+    set order(value: RotationOrder);
+    fromVector3(v: Readonly<NumericArray_2>, order: RotationOrder): this;
+    fromArray(array: Readonly<NumericArray_2>, offset?: number): this;
+    fromRollPitchYaw(roll: number, pitch: number, yaw: number): this;
+    fromRotationMatrix(m: Readonly<NumericArray_2>, order?: RotationOrder): this;
+    getRotationMatrix(m: NumericArray_2): NumericArray_2;
+    getQuaternion(): Quaternion;
+    _fromRotationMatrix(m: Readonly<NumericArray_2>, order?: RotationOrder): this;
+    _getRotationMatrix(result: NumericArray_2): NumericArray_2;
+    toQuaternion(): Quaternion;
+}
+
 export declare class Frame {
     timeStamp: number;
     scene: Scene;
     constructor(timeStamp: number, scene?: Scene);
 }
 
-export declare type Frames = Array<Frame>;
+declare class Geoid {
+    private _v00;
+    private _v01;
+    private _v10;
+    private _v11;
+    private _t;
+    private _ix;
+    private _iy;
+    options: GeoidProps;
+    constructor(options: GeoidProps);
+    getHeight(lat: number, lon: number): number;
+    private _rawval;
+}
+
+declare type GeoidProps = {
+    cubic: boolean | undefined;
+    _width: number;
+    _height: number;
+    _rlonres: number;
+    _rlatres: number;
+    _offset: number;
+    _scale: number;
+    _swidth: number;
+    _datastart: number;
+    _maxerror: number;
+    _rmserror: number;
+    _description: string;
+    _datetime: string;
+    data: Uint8Array;
+};
 
 export declare class GlobalProperties {
     referenceTime: dayjs.Dayjs;
@@ -92,48 +181,139 @@ export declare class GlobalProperties {
     additionalProps?: Map<string, string>;
 }
 
-export declare interface IEntityProps {
-    id: number;
-    timeSpan: {
-        start: Dayjs;
-        end: Dayjs;
-    };
-    name?: string;
-    types?: string[];
-    callsign?: string;
-    pilot?: string;
-    group?: string;
-    country?: string;
-    coalition?: string;
-    color?: string;
-}
-
-export declare interface IStateVector {
-    position: Cartesian3;
-    orientation?: Quaternion;
+export declare class Header {
+    fileType: string;
+    fileVersion: string;
 }
 
 export declare interface ITrajectoryOptions {
     sampleRate?: number;
-    fixMslHeight?: boolean;
     emulateOrientation?: boolean;
 }
 
 export declare interface ITrajectorySample {
     time: Dayjs;
-    state: IStateVector;
+    stateVector: StateVector;
+}
+
+declare abstract class MathArray extends Array<number> {
+    abstract get ELEMENTS(): number;
+    abstract copy(vector: Readonly<NumericArray_2>): this;
+    abstract fromObject(object: Record<string, unknown>): this;
+    clone(): this;
+    fromArray(array: Readonly<NumericArray_2>, offset?: number): this;
+    toArray<TypedArray>(targetArray: TypedArray, offset?: number): TypedArray;
+    toArray(targetArray?: number[], offset?: number): NumericArray_2;
+    toObject(targetObject: Record<string, unknown>): Record<string, unknown>;
+    from(arrayOrObject: Readonly<NumericArray_2> | Record<string, unknown>): this;
+    to<T extends NumericArray_2 | Record<string, unknown>>(arrayOrObject: T): T;
+    toTarget(target: this): this;
+    toFloat32Array(): Float32Array;
+    toString(): string;
+    formatString(opts: ConfigurationOptions): string;
+    equals(array: Readonly<NumericArray_2>): boolean;
+    exactEquals(array: Readonly<NumericArray_2>): boolean;
+    negate(): this;
+    lerp(a: Readonly<NumericArray_2>, t: number): this;
+    lerp(a: Readonly<NumericArray_2>, b: Readonly<NumericArray_2>, t: number): this;
+    min(vector: Readonly<NumericArray_2>): this;
+    max(vector: Readonly<NumericArray_2>): this;
+    clamp(minVector: Readonly<NumericArray_2>, maxVector: Readonly<NumericArray_2>): this;
+    add(...vectors: Readonly<NumericArray_2>[]): this;
+    subtract(...vectors: Readonly<NumericArray_2>[]): this;
+    scale(scale: number | Readonly<NumericArray_2>): this;
+    multiplyByScalar(scalar: number): this;
+    check(): this;
+    validate(): boolean;
+    sub(a: Readonly<NumericArray_2>): this;
+    setScalar(a: number): this;
+    addScalar(a: number): this;
+    subScalar(a: number): this;
+    multiplyScalar(scalar: number): this;
+    divideScalar(a: number): this;
+    clampScalar(min: number, max: number): this;
+    get elements(): NumericArray_2;
 }
 
-export declare interface ITransform {
-    longitude: number;
-    latitude: number;
-    altitude: number;
-    roll?: number;
-    pitch?: number;
-    yaw?: number;
+declare type NumericArray_2 = TypedArray | number[];
+
+declare class Quaternion extends MathArray {
+    constructor(x?: number | Readonly<NumericArray_2>, y?: number, z?: number, w?: number);
+    copy(array: Readonly<NumericArray_2>): this;
+    set(x: number, y: number, z: number, w: number): this;
+    fromObject(object: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): this;
+    fromMatrix3(m: Readonly<NumericArray_2>): this;
+    fromAxisRotation(axis: Readonly<NumericArray_2>, rad: number): this;
+    fromEuler(e: Euler): this;
+    identity(): this;
+    setAxisAngle(axis: Readonly<NumericArray_2>, rad: number): this;
+    get ELEMENTS(): number;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get w(): number;
+    set w(value: number);
+    len(): number;
+    lengthSquared(): number;
+    dot(a: Readonly<NumericArray_2>): number;
+    rotationTo(vectorA: NumericArray_2, vectorB: NumericArray_2): this;
+    add(a: Readonly<NumericArray_2>): this;
+    calculateW(): this;
+    conjugate(): this;
+    invert(): this;
+    lerp(a: Readonly<NumericArray_2>, b: Readonly<NumericArray_2> | number, t?: number): this;
+    multiplyRight(a: Readonly<NumericArray_2>): this;
+    multiplyLeft(a: Readonly<NumericArray_2>): this;
+    normalize(): this;
+    rotateX(rad: number): this;
+    rotateY(rad: number): this;
+    rotateZ(rad: number): this;
+    scale(b: number): this;
+    slerp(target: Readonly<NumericArray_2>, ratio: number): this;
+    slerp(start: Readonly<NumericArray_2>, target: Readonly<NumericArray_2>, ratio: number): this;
+    slerp(params: {
+        start: Readonly<NumericArray_2>;
+        target: Readonly<NumericArray_2>;
+        ratio: number;
+    }): this;
+    transformVector4(vector: Readonly<NumericArray_2>, result?: NumericArray_2): NumericArray_2;
+    lengthSq(): number;
+    setFromAxisAngle(axis: Readonly<NumericArray_2>, rad: number): this;
+    premultiply(a: Readonly<NumericArray_2>): this;
+    multiply(a: Readonly<NumericArray_2>): this;
 }
 
-export declare type Scene = Map<number, ITransform>;
+declare enum RotationOrder {
+    ZYX = 0,
+    YXZ = 1,
+    XZY = 2,
+    ZXY = 3,
+    YZX = 4,
+    XYZ = 5
+}
+
+export declare type Scene = Map<number, Transform>;
+
+export declare class StateVector {
+    cartesian: Vector3;
+    quaternion?: Quaternion;
+    equals(stateVector: StateVector): boolean | undefined;
+    private static _scratchQuaternionX;
+    private static _scratchQuaternionY;
+    private static _scratchQuaternionZ;
+    private static _scratchHprMatrix;
+    private static _scratchTranslationMatrix;
+    private static _scratchRotation;
+    static fromTransform(transform: Transform, result?: StateVector): StateVector;
+}
 
 export declare class TimeSpan {
     start: dayjs.Dayjs;
@@ -146,34 +326,97 @@ export declare type Trajectories = Map<number, Trajectory>;
 
 export declare class Trajectory {
     samples: ITrajectorySample[];
-    private _mslHeightFixed;
-    private static _geoid?;
-    private readonly _fixedFrame;
-    static loadGeoidModel(model: Uint8Array): void;
     hasOrientations(): boolean;
     private _lastRoll;
     private _simpleSmooth;
-    private _m0;
-    private _m1;
-    private _hpr0;
-    private _hpr1;
-    private _alpha;
     private _computeRoll;
-    private _p0;
-    private _p1;
-    private _p2;
-    private _v0;
-    private _v1;
-    private _r0;
-    private _r1;
-    private _q0;
-    private _q1;
-    private _rollQuat;
-    private _defaultHpr;
     private _computeOrientation;
-    emulateOrientations(dt: number, withRoll?: boolean): void;
-    private _cartographicScratch;
-    fixMslHeight(): void;
+    emulateOrientations(withRoll?: boolean): void;
+}
+
+export declare class Transform {
+    position: Vector3;
+    orientation?: Euler;
+    static refLong: number;
+    static refLat: number;
+    static geoid: Geoid | undefined;
+    constructor(components: (number | undefined)[], previousTransform: Transform | undefined);
+}
+
+declare type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+
+declare abstract class Vector extends MathArray {
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    len(): number;
+    magnitude(): number;
+    lengthSquared(): number;
+    magnitudeSquared(): number;
+    distance(mathArray: Readonly<NumericArray_2>): number;
+    distanceSquared(mathArray: Readonly<NumericArray_2>): number;
+    dot(mathArray: Readonly<NumericArray_2>): number;
+    normalize(): this;
+    multiply(...vectors: Readonly<NumericArray_2>[]): this;
+    divide(...vectors: Readonly<NumericArray_2>[]): this;
+    lengthSq(): number;
+    distanceTo(vector: Readonly<NumericArray_2>): number;
+    distanceToSquared(vector: Readonly<NumericArray_2>): number;
+    getComponent(i: number): number;
+    setComponent(i: number, value: number): this;
+    addVectors(a: Readonly<NumericArray_2>, b: Readonly<NumericArray_2>): this;
+    subVectors(a: Readonly<NumericArray_2>, b: Readonly<NumericArray_2>): this;
+    multiplyVectors(a: Readonly<NumericArray_2>, b: Readonly<NumericArray_2>): this;
+    addScaledVector(a: Readonly<NumericArray_2>, b: number): this;
+}
+
+declare class Vector3 extends Vector {
+    static get ZERO(): Vector3;
+    static get X_AXIS(): Vector3;
+    static get Y_AXIS(): Vector3;
+    static get Z_AXIS(): Vector3;
+    constructor(x?: number | Readonly<NumericArray_2>, y?: number, z?: number);
+    set(x: number, y: number, z: number): this;
+    copy(array: Readonly<NumericArray_2>): this;
+    fromObject(object: {
+        x: number;
+        y: number;
+        z: number;
+    }): this;
+    toObject(object: {
+        x?: number;
+        y?: number;
+        z?: number;
+    }): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    get ELEMENTS(): number;
+    get z(): number;
+    set z(value: number);
+    angle(vector: Readonly<NumericArray_2>): number;
+    static cross<T extends NumericArray_2>(left: Readonly<NumericArray_2>, right: Readonly<NumericArray_2>, result?: T): T;
+    cross(vector: Readonly<NumericArray_2>): this;
+    rotateX({ radians, origin, }: {
+        radians: number;
+        origin?: Readonly<NumericArray_2>;
+    }): this;
+    rotateY({ radians, origin, }: {
+        radians: number;
+        origin?: Readonly<NumericArray_2>;
+    }): this;
+    rotateZ({ radians, origin, }: {
+        radians: number;
+        origin?: Readonly<NumericArray_2>;
+    }): this;
+    transform(matrix4: Readonly<NumericArray_2>): this;
+    transformAsPoint(matrix4: Readonly<NumericArray_2>): this;
+    transformAsVector(matrix4: Readonly<NumericArray_2>): this;
+    transformByMatrix3(matrix3: Readonly<NumericArray_2>): this;
+    transformByMatrix2(matrix2: Readonly<NumericArray_2>): this;
+    transformByQuaternion(quaternion: Readonly<NumericArray_2>): this;
 }
 
 export { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "acmi-parser",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "ACMI file format parser",
   "author": "jfayot",
   "repository": {
@@ -52,9 +52,6 @@
     ]
   },
   "dependencies": {
-    "@math.gl/geoid": "^4.0.0",
-    "binary-search-bounds": "^2.0.5",
-    "@cesium/engine": "^6.1.1",
     "dayjs": "^1.11.10",
     "unzipit": "^1.4.3"
   },