@openglobus/og 0.19.4 → 0.20.0

package/lib/@openglobus/js/utils/GeoImageCreator.d.ts

@@ -0,0 +1,34 @@
+import { BaseGeoImage } from "../layer/BaseGeoImage";
+import { Framebuffer } from '../webgl/Framebuffer';
+import { LonLat } from '../LonLat';
+import { Planet } from "../scene/Planet";
+import { WebGLBufferExt, WebGLTextureExt } from "../webgl/Handler";
+export declare class GeoImageCreator {
+    MAX_FRAMES: number;
+    protected _gridSize: number;
+    protected _planet: Planet;
+    _framebuffer: Framebuffer | null;
+    protected _framebufferMercProj: Framebuffer | null;
+    _texCoordsBuffer: WebGLBufferExt | null;
+    _indexBuffer: WebGLBufferExt | null;
+    protected _currentFrame: number;
+    protected _queue: BaseGeoImage[];
+    protected _animate: BaseGeoImage[];
+    protected _quadTexCoordsBuffer: WebGLBufferExt | null;
+    protected _quadVertexBuffer: WebGLTextureExt | null;
+    constructor(planet: Planet, maxFrames?: number);
+    init(): void;
+    /**
+     * Creates geoImage corners coordinates grid buffer.
+     * @public
+     * @param{Array.<LonLat>} c - GeoImage corners coordinates.
+     * @param{boolean} [toMerc=false] - Transform to web mercator.
+     * @return{WebGLBuffer} Grid coordinates buffer.
+     */
+    createGridBuffer(c: LonLat[], toMerc?: boolean): [WebGLBufferExt, WebGLBufferExt];
+    frame(): void;
+    add(geoImage: BaseGeoImage): void;
+    remove(geoImage: BaseGeoImage): void;
+    protected _initBuffers(): void;
+    protected _initShaders(): void;
+}

package/lib/@openglobus/js/utils/ImagesCacheManager.d.ts

@@ -0,0 +1,22 @@
+import { QueueArray } from '../QueueArray';
+export type HTMLImageElementExt = HTMLImageElement & {
+    __nodeIndex?: number;
+    atlasWidth?: number;
+    atlasHeight?: number;
+};
+export type ImagesCacheManagerCallback = (image: HTMLImageElementExt) => void;
+interface IImagesCacheRequest {
+    "src": string;
+    "success": ImagesCacheManagerCallback;
+}
+declare class ImagesCacheManager {
+    imagesCache: Record<string, HTMLImageElementExt>;
+    protected _counter: number;
+    protected _pendingsQueue: QueueArray<IImagesCacheRequest>;
+    protected _imageIndexCounter: number;
+    constructor();
+    load(src: string, success: ImagesCacheManagerCallback): void;
+    protected _exec(req: IImagesCacheRequest): void;
+    protected _dequeueRequest(): void;
+}
+export { ImagesCacheManager };

package/lib/@openglobus/js/utils/Loader.d.ts

@@ -0,0 +1,63 @@
+import { EventsHandler } from '../Events';
+import { Planet } from "../scene/Planet";
+import { Segment } from "../segment/Segment";
+type LoaderEventsList = ["loadend", "layerloadend"];
+export interface IResponse {
+    status: string;
+    data?: any;
+    msg?: string;
+}
+type IResponseCallback = (response: IResponse) => void;
+interface Obj<T> {
+    __id: number;
+    isIdle: boolean;
+    isEqual: (obj: T) => boolean;
+    events: EventsHandler<any>;
+    _planet: Planet | null;
+}
+type QueryParams<T> = {
+    sender?: T;
+    src: string;
+    type: string;
+    filter?: (val: QueryParams<T>) => boolean;
+    options?: any;
+    segment?: Segment;
+};
+type QueueData<T> = {
+    params: QueryParams<T>;
+    callback: IResponseCallback;
+};
+type RequestCounter<T> = {
+    sender: T;
+    counter: number;
+    __requestCounterFrame__: number;
+};
+export declare class Loader<T extends Obj<T>> {
+    MAX_REQUESTS: number;
+    events: EventsHandler<LoaderEventsList>;
+    protected _loading: number;
+    protected _queue: QueueData<T>[];
+    protected _senderRequestCounter: RequestCounter<T>[];
+    protected _promises: {
+        [key: string]: (r: Response) => Promise<any>;
+    };
+    constructor(maxRequests?: number);
+    load(params: QueryParams<T>, callback: IResponseCallback): void;
+    fetch(params: QueryParams<T>): Promise<{
+        status: string;
+        data: any;
+    } | {
+        status: string;
+        msg: string;
+    }>;
+    getRequestCounter(sender: T): number;
+    isIdle(sender: T): boolean;
+    protected _checkLoadend(request: RequestCounter<T>, sender: T): void;
+    protected _handleResponse(q: QueueData<T>, response: IResponse): void;
+    protected _exec(): Promise<void> | undefined;
+    abort(sender: T): void;
+    abortAll(): void;
+    get loading(): number;
+    get queue(): QueueData<T>[];
+}
+export {};

package/lib/@openglobus/js/utils/NormalMapCreator.d.ts

@@ -0,0 +1,52 @@
+import { Framebuffer } from "../webgl/Framebuffer";
+import { Lock, Key } from "../Lock";
+import { Planet } from "../scene/Planet";
+import { QueueArray } from "../QueueArray";
+import { Segment } from "../segment/Segment";
+import { WebGLBufferExt, WebGLTextureExt, Handler } from "../webgl/Handler";
+interface INormalMapCreatorParams {
+    minTableSize?: number;
+    maxTableSize?: number;
+    width?: number;
+    height?: number;
+}
+export declare class NormalMapCreator {
+    protected _minTabelSize: number;
+    protected _maxTableSize: number;
+    protected _planet: Planet;
+    protected _handler: Handler | null;
+    protected _verticesBufferArray: WebGLBufferExt[];
+    protected _indexBufferArray: WebGLBufferExt[];
+    protected _positionBuffer: WebGLBufferExt | null;
+    protected _framebuffer: Framebuffer | null;
+    protected _normalMapVerticesTexture: WebGLTextureExt | null;
+    protected _width: number;
+    protected _height: number;
+    protected _queue: QueueArray<Segment>;
+    protected _lock: Lock;
+    constructor(planet: Planet, options?: INormalMapCreatorParams);
+    get width(): number;
+    get height(): number;
+    init(): void;
+    protected _drawNormalMapBlur(segment: Segment): boolean;
+    protected _drawNormalMapNoBlur(segment: Segment): boolean;
+    protected _drawNormalMap(segment: Segment): boolean;
+    drawSingle(segment: Segment): void;
+    frame(): void;
+    get queueSize(): number;
+    queue(segment: Segment): void;
+    unshift(segment: Segment): void;
+    remove(segment: Segment): void;
+    clear(): void;
+    /**
+     * Set activity off
+     * @public
+     */
+    lock(key: Key): void;
+    /**
+     * Set activity on
+     * @public
+     */
+    free(key: Key): void;
+}
+export {};

package/lib/@openglobus/js/utils/PlainSegmentWorker.d.ts

@@ -0,0 +1,24 @@
+import { BaseWorker } from "./BaseWorker";
+import { Segment } from "../segment/Segment";
+import { Geoid } from "../terrain/Geoid";
+export interface IPlainSegmentWorkerData {
+    plainVertices: Float64Array | null;
+    plainVerticesHigh: Float32Array | null;
+    plainVerticesLow: Float32Array | null;
+    plainNormals: Float32Array | null;
+    plainRadius: number;
+    normalMapNormals: Float32Array | null;
+    normalMapVertices: Float64Array | null;
+    normalMapVerticesHigh: Float32Array | null;
+    normalMapVerticesLow: Float32Array | null;
+}
+type MessageEventExt = MessageEvent & {
+    data: IPlainSegmentWorkerData;
+};
+declare class PlainSegmentWorker extends BaseWorker<Segment> {
+    constructor(numWorkers?: number);
+    protected _onMessage(e: MessageEventExt): void;
+    setGeoid(geoid: Geoid): void;
+    make(segment: Segment): void;
+}
+export { PlainSegmentWorker };

package/lib/@openglobus/js/utils/TerrainWorker.d.ts

@@ -0,0 +1,28 @@
+import { BaseWorker } from "./BaseWorker";
+import { Segment } from "../segment/Segment";
+import { NumberArray6 } from "../bv/Sphere";
+interface TerrainInfo {
+    segment: Segment;
+    elevations: Float32Array;
+}
+export interface ITerrainWorkerData {
+    id: number;
+    normalMapNormals: Float32Array | null;
+    normalMapVertices: Float64Array | null;
+    normalMapVerticesHigh: Float32Array | null;
+    normalMapVerticesLow: Float32Array | null;
+    terrainVertices: Float64Array | null;
+    terrainVerticesHigh: Float32Array | null;
+    terrainVerticesLow: Float32Array | null;
+    noDataVertices: Uint8Array | null;
+    bounds: NumberArray6;
+}
+type MessageEventExt = MessageEvent & {
+    data: ITerrainWorkerData;
+};
+declare class TerrainWorker extends BaseWorker<TerrainInfo> {
+    constructor(numWorkers?: number);
+    protected _onMessage(e: MessageEventExt): void;
+    make(info: TerrainInfo): void;
+}
+export { TerrainWorker };

package/lib/@openglobus/js/utils/TextureAtlas.d.ts

@@ -0,0 +1,113 @@
+import { ImageCanvas } from "../ImageCanvas";
+import { Rectangle } from "../Rectangle";
+import { ImagesCacheManager, HTMLImageElementExt, ImagesCacheManagerCallback } from "./ImagesCacheManager";
+import { Handler, WebGLTextureExt } from "../webgl/Handler";
+/**
+ * Texture atlas stores images in one texture. Each image has its own
+ * atlas texture coordinates.
+ * @class
+ * @param {number} [width=1024] - Texture atlas width, if it hasn't 1024 default.
+ * @param {number} [height=1024] - Texture atlas height, if it hasn't 1024 default.
+ */
+declare class TextureAtlas {
+    /**
+     * Atlas nodes where input images store. It can be accessed by image.__nodeIndex.
+     * @public
+     * @type {Map<number, TextureAtlasNode>}
+     */
+    nodes: Map<number, TextureAtlasNode>;
+    /**
+     * Created gl texture.
+     * @public
+     */
+    texture: WebGLTextureExt | null;
+    /**
+     * Atlas canvas.
+     * @public
+     * @type {ImageCanvas}
+     */
+    canvas: ImageCanvas;
+    borderSize: number;
+    protected _handler: Handler | null;
+    protected _images: HTMLImageElementExt[];
+    protected _btree: TextureAtlasNode | null;
+    protected _imagesCacheManager: ImagesCacheManager;
+    constructor(width?: number, height?: number);
+    /**
+     * Returns atlas javascript image object.
+     * @public
+     * @returns {HTMLImageElement} -
+     */
+    getImage(): HTMLImageElement;
+    /**
+     * Returns canvas object.
+     * @public
+     * @returns {HTMLCanvasElement} -
+     */
+    getCanvas(): HTMLCanvasElement;
+    /**
+     * Clear atlas with black.
+     * @public
+     */
+    clearCanvas(): void;
+    /**
+     * Sets openglobus gl handler that creates gl texture.
+     * @public
+     * @param {Handler} handler - WebGL handler.
+     */
+    assignHandler(handler: Handler): void;
+    /**
+     * Returns image diagonal size.
+     * @param {HTMLImageElementExt} image - Image object.
+     * @returns {number} -
+     */
+    getDiagonal(image: HTMLImageElementExt): number;
+    /**
+     * Adds image to the atlas and returns created node with texture coordinates of the stored image.
+     * @public
+     * @param {HTMLImageElementExt} image - Input javascript image object.
+     * @param {boolean} [fastInsert] - If it's true atlas doesn't restore all images again
+     * and store image in the current atlas scheme.
+     * @returns {TextureAtlasNode | undefined} -
+     */
+    addImage(image: HTMLImageElementExt, fastInsert?: boolean): TextureAtlasNode | undefined;
+    protected _completeNode(nodes: Map<number, TextureAtlasNode>, node?: TextureAtlasNode | null): void;
+    /**
+     * Main atlas making function.
+     * @protected
+     * @param {boolean} [fastInsert] - If it's true atlas doesn't restore all images again
+     * and store image in the current atlas scheme.
+     */
+    protected _makeAtlas(fastInsert?: boolean): void;
+    get(key: number): TextureAtlasNode | undefined;
+    set(key: number, value: TextureAtlasNode): void;
+    /**
+     * Creates atlas gl texture.
+     * @public
+     */
+    createTexture(img?: HTMLImageElement | null, internalFormat?: number): void;
+    /**
+     * Asynchronous function that loads and creates image to the image cache, and call success callback when it's done.
+     * @public
+     * @param {string} src - Image object src string.
+     * @param {ImagesCacheManagerCallback} success - The callback that handles the image loads done.
+     */
+    loadImage(src: string, success: ImagesCacheManagerCallback): void;
+    getImageTexCoordinates(img: HTMLImageElementExt): number[] | undefined;
+}
+/**
+ * Atlas binary tree node.
+ * @class
+ * @param {Rectangle} rect - Node image rectangle.
+ * @param {number[]} texCoords - Node image rectangle.
+ */
+declare class TextureAtlasNode {
+    childNodes: TextureAtlasNode[] | null;
+    image: HTMLImageElementExt | null;
+    rect: Rectangle;
+    texCoords: number[];
+    atlas: TextureAtlas | null;
+    constructor(rect?: Rectangle, texCoords?: number[]);
+    insert(img: HTMLImageElementExt): TextureAtlasNode | undefined;
+}
+export { TextureAtlas, TextureAtlasNode };

package/lib/@openglobus/js/utils/VectorTileCreator.d.ts

@@ -0,0 +1,18 @@
+import { Framebuffer } from '../webgl/Framebuffer';
+import { Handler } from "../webgl/Handler";
+import { Material } from "../layer/Material";
+import { Planet } from "../scene/Planet";
+export declare class VectorTileCreator {
+    protected _width: number;
+    protected _height: number;
+    protected _planet: Planet;
+    protected _framebuffer: Framebuffer | null;
+    protected _queue: Material[];
+    protected _handler: Handler | null;
+    constructor(planet: Planet, width?: number, height?: number);
+    init(): void;
+    frame(): void;
+    add(material: Material): void;
+    remove(material: Material): void;
+    get queueSize(): number;
+}

package/lib/@openglobus/js/utils/colorTable.d.ts

@@ -0,0 +1,3 @@
+export declare const colorTable: {
+    [id: string]: string;
+};

package/lib/@openglobus/js/utils/earcut.d.ts

@@ -0,0 +1,7 @@
+declare function earcut(data: any, holeIndices: any, dim: any): any[];
+declare function flatten(data: any): {
+    vertices: never[];
+    holes: never[];
+    dimensions: any;
+};
+export { earcut, flatten };

package/lib/@openglobus/js/utils/objParser.d.ts

@@ -0,0 +1,24 @@
+interface IObjGeometryData {
+    vertices: number[];
+    textures: number[];
+    normals: number[];
+}
+interface IObjGeometry {
+    object: string;
+    groups: string[];
+    material: string;
+    data: IObjGeometryData;
+}
+interface IObjData {
+    geometries: IObjGeometry[];
+    materialLibs: string[];
+}
+export declare function objParser(text: string): {
+    geometries: IObjGeometry[];
+    materialLibs: string[];
+};
+export declare function transformLeftToRightCoordinateSystem(objData: IObjData): {
+    geometries: IObjGeometry[];
+    materialLibs: string[];
+};
+export {};

package/lib/@openglobus/js/utils/shared.d.ts

@@ -0,0 +1,263 @@
+/**
+ * @module og/utils/shared
+ */
+import { Extent } from "../Extent";
+import { LonLat } from "../LonLat";
+import { Vec2 } from "../math/Vec2";
+import { NumberArray2 } from "../math/Vec2";
+import { NumberArray3, Vec3 } from "../math/Vec3";
+import { NumberArray4, Vec4 } from "../math/Vec4";
+export declare function getDefault(param?: any, def?: any): boolean;
+export declare function isEmpty(v: any): boolean;
+/**
+ * Returns true if the object pointer is undefined.
+ * @function
+ * @param {Object} obj - Object pointer.
+ * @returns {boolean} Returns true if object is undefined.
+ */
+export declare function isUndef(obj?: any): boolean;
+export declare function isUndefExt(obj: any, defVal: any): any;
+export declare function stamp(obj: any): number;
+export declare function isString(s: any): boolean;
+export declare function rgbToStringHTML(rgb: NumberArray3 | Vec3): string;
+/**
+ * Convert html color string to the RGBA number vector.
+ * @param {string} htmlColor - HTML string("#C6C6C6" or "#EF5" or "rgb(8,8,8)" or "rgba(8,8,8)") color.
+ * @param {number} [opacity] - Opacity for the output vector.
+ * @returns {Vec4} -
+ */
+export declare function htmlColorToRgba(htmlColor: string, opacity?: number): Vec4;
+export declare function htmlColorToFloat32Array(htmlColor: string, opacity?: number): Float32Array;
+/**
+ * Convert html color string to the RGB number vector.
+ * @param {string} htmlColor - HTML string("#C6C6C6" or "#EF5" or "rgb(8,8,8)" or "rgba(8,8,8)") color.
+ * @returns {Vec3} -
+ */
+export declare function htmlColorToRgb(htmlColor: string): Vec3;
+/**
+ * Replace template substrings between '{' and '}' tokens.
+ * @param {string} template - String with templates in "{" and "}"
+ * @param {Object} params - Template named object with subsrtings.
+ * @returns {string} -
+ *
+ * @example <caption>Example from og.terrain that replaces tile indexes in url:</caption>
+ * var substrings = {
+ *       "x": 12,
+ *       "y": 15,
+ *       "z": 8
+ * }
+ * og.utils.stringTemplate("http://earth3.openglobus.org/{z}/{y}/{x}.ddm", substrings);
+ * //returns http://earth3.openglobus.org/8/15/12.ddm
+ */
+export declare function stringTemplate(template: string, params?: any): string;
+export declare function getHTML(template: string, params?: any): string;
+export declare function parseHTML(htmlStr: string): HTMLElement[];
+export declare function print2d(id: string, text: string, x: number, y: number): void;
+export declare function isNumber(value: any): boolean;
+export declare function defaultString(str?: string, def?: string): string;
+export declare function createVector3(v?: number | Vec3 | Vec2 | NumberArray3 | NumberArray2 | null, def?: Vec3): Vec3;
+export declare function createVector4(v?: Vec4 | NumberArray4 | null, def?: Vec4): Vec4;
+export declare function createColorRGBA(c?: string | NumberArray4 | Vec4 | null, def?: Vec4): Vec4;
+export declare function createColorRGB(c?: string | NumberArray3 | Vec3 | null, def?: Vec3): Vec3;
+export declare function createExtent(e?: Extent | [[number, number], [number, number]] | null, def?: Extent): Extent;
+export declare function createLonLat(l?: LonLat | NumberArray2 | NumberArray3, def?: LonLat): LonLat;
+export declare function binarySearchFast(arr: number[] | TypedArray, x: number): number;
+/**
+ * Finds an item in a sorted array.
+ * @param {any[]} ar The sorted array to search.
+ * @param {any} el The item to find in the array.
+ * @param {Function} compare_fn comparator The function to use to compare the item to
+ *        elements in the array.
+ * @returns {number} a negative number  if 'a' is less than 'b'; 0 if 'a' is equal to 'b'; 'a' positive number of 'a' is greater than 'b'.
+ *
+ * @example
+ * // Create a comparator function to search through an array of numbers.
+ * function comparator(a, b) {
+ *     return a - b;
+ * };
+ * var numbers = [0, 2, 4, 6, 8];
+ * var index = og.utils.binarySearch(numbers, 6, comparator); // 3
+ */
+export declare function binarySearch(ar: any[], el: any, compare_fn: Function): number;
+/**
+ * @todo: replace any with generic
+ * Binary insertion that uses binarySearch algorithm.
+ * @param {any[]} ar - The sorted array to insert.
+ * @param {any} el - The item to insert.
+ * @param {Function} compare_fn - comparator The function to use to compare the item to
+ *        elements in the array.
+ * @returns {number} Array index position in which item inserted in.
+ */
+export declare function binaryInsert(ar: any[], el: any, compare_fn: Function): number;
+/**
+ * Returns two segment lines intersection coordinate.
+ * @static
+ * @param {Vec2} start1 - First line first coordinate.
+ * @param {Vec2} end1 - First line second coordinate.
+ * @param {Vec2} start2 - Second line first coordinate.
+ * @param {Vec2} end2 - Second line second coordinate.
+ * @param {boolean} [isSegment] - Lines are segments.
+ * @return {Vec2} - Intersection coordinate.
+ */
+export declare function getLinesIntersection2v(start1: Vec2, end1: Vec2, start2: Vec2, end2: Vec2, isSegment: boolean): Vec2 | undefined;
+/**
+ * Returns two segment lines intersection coordinate.
+ * @static
+ * @param {Vec2} start1 - First line first coordinate.
+ * @param {Vec2} end1 - First line second coordinate.
+ * @param {Vec2} start2 - Second line first coordinate.
+ * @param {Vec2} end2 - Second line second coordinate.
+ * @param {boolean} [isSegment=false] - Lines are segments.
+ * @return {Vec2} - Intersection coordinate.
+ */
+export declare function getLinesIntersectionLonLat(start1: LonLat, end1: LonLat, start2: LonLat, end2: LonLat, isSegment?: boolean): LonLat | undefined;
+/**
+ * Converts XML to JSON
+ * @static
+ * @param {Object} xml - Xml object
+ * @return {Object} - Json converted object.
+ */
+export declare function xmlToJson(xml: any): any;
+export declare const castType: {
+    string: (v: any) => any;
+    date: (v: any) => any;
+    datetime: (v: any) => any;
+    time: (v: any) => any;
+    integer: (v: any) => any;
+    float: (v: any) => any;
+    boolean: (str: any) => any;
+};
+export declare function base64toBlob(base64Data: string, contentType?: string): Blob;
+export declare function base64StringToBlog(string: string): Blob;
+/**
+ * Callback throttling
+ * @param {any} func
+ * @param {Number} limit
+ * @param {boolean} [skip]
+ */
+export declare function throttle(func: Function, limit: number, skip?: boolean): () => void;
+/**
+ *
+ * y2-----Q12--------------Q22---
+ * |       |     |          |
+ * |       |     |          |
+ * y-------|-----P----------|----
+ * |       |     |          |
+ * |       |     |          |
+ * |       |     |          |
+ * |       |     |          |
+ * |       |     |          |
+ * y1-----Q11----|---------Q21---
+ *         |     |          |
+ *         |     |          |
+ *         x1    x          x2
+ *
+ *
+ * @param {Number} x -
+ * @param {Number} y -
+ * @param {Number} fQ11 -
+ * @param {Number} fQ21 -
+ * @param {Number} fQ12 -
+ * @param {Number} fQ22 -
+ * @param {Number} [x1=0.0] -
+ * @param {Number} [x2=1.0] -
+ * @param {Number} [y1=0.0] -
+ * @param {Number} [y2=1.0] -
+ */
+export declare function blerp(x: number, y: number, fQ11: number, fQ21: number, fQ12: number, fQ22: number, x1?: number, x2?: number, y1?: number, y2?: number): number;
+export declare function blerp2(x: number, y: number, fQ11: number, fQ21: number, fQ12: number, fQ22: number): number;
+export declare function extractElevationTiles(rgbaData: number[] | TypedArray, outCurrenElevations: number[] | TypedArray, outChildrenElevations: number[][][] | TypedArray[][]): void;
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+/**
+ * Concatenates two the same type arrays
+ * @param {TypedArray} a
+ * @param {TypedArray | number[]} b
+ */
+export declare function concatTypedArrays(a: TypedArray, b: TypedArray | number[]): TypedArray;
+/**
+ * Concatenates two the same  arrays
+ * @param {TypedArray | number[]} [a=[]] - First array
+ * @param {TypedArray | number[]} [b=[]] - Second array
+ * @return {TypedArray | number[]} -
+ */
+export declare function concatArrays(a?: TypedArray | number[], b?: TypedArray | number[]): TypedArray | number[];
+/**
+ * Convert simple array to typed
+ * @param arr {number[]}
+ * @param ctor {Float32Array}
+ * @returns {TypedArray}
+ */
+export declare function makeArrayTyped(arr: TypedArray | number[], ctor?: Function): any;
+/**
+ * Convert typed array to array
+ * @param arr {TypedArray | number[]}
+ * @returns {number[]}
+ */
+export declare function makeArray(arr: TypedArray | number[]): number[];
+/**
+ *
+ * @param {TypedArray | Array} arr
+ * @param {Number} starting
+ * @param {Number} deleteCount
+ * @param {{ result: number[] }} [out]
+ */
+export declare function spliceArray(arr: TypedArray | number[], starting: number, deleteCount: number, out?: {
+    result: number[];
+} | {
+    result: TypedArray;
+}): TypedArray | number[];
+/**
+ *
+ * @param {TypedArray} arr
+ * @param {Number} starting
+ * @param {Number} deleteCount
+ * @param {{ result: TypedArray }} [out]
+ */
+export declare function spliceTypedArray<T extends TypedArray>(arr: T, starting: number, deleteCount: number, out?: {
+    result: T;
+}): T;
+/**
+ * Returns 64-bit triangle coordinate array from inside of the source triangle array.
+ * @static
+ * @param {TypedArray | number[]} sourceArr - Source array
+ * @param {number} gridSize - Source array square matrix size
+ * @param {number} i0 - First row index source array matrix
+ * @param {number} j0 - First column index
+ * @param {number} size - Square matrix result size.
+ * @return {Float64Array} Triangle coordinates array from the source array.
+ * @TODO: optimization
+ */
+export declare function getMatrixSubArray64(sourceArr: TypedArray | number[], gridSize: number, i0: number, j0: number, size: number): Float64Array;
+/**
+ * Returns 32-bit triangle coordinate array from inside of the source triangle array.
+ * @static
+ * @param {TypedArray | number[]} sourceArr - Source array
+ * @param {number} gridSize - Source array square matrix size
+ * @param {number} i0 - First row index source array matrix
+ * @param {number} j0 - First column index
+ * @param {number} size - Square matrix result size.
+ * @return {Float32Array} Triangle coordinates array from the source array.
+ */
+export declare function getMatrixSubArray32(sourceArr: TypedArray | number[], gridSize: number, i0: number, j0: number, size: number): Float32Array;
+/**
+ * Returns two float32 triangle coordinate arrays from inside of the source triangle array.
+ * @TODO: optimization
+ */
+export declare function getMatrixSubArrayBoundsExt(sourceArr: TypedArray | number[], sourceArrHigh: TypedArray | number[], sourceArrLow: TypedArray | number[], noDataVertices: TypedArray | number[] | undefined, gridSize: number, i0: number, j0: number, size: number, outArr: TypedArray | number[], outArrHigh: TypedArray | number[], outArrLow: TypedArray | number[], outBounds: any, outNoDataVertices: TypedArray | number[]): void;
+export declare function cloneArray(items: any[]): any[];
+/**
+ * Promise for load images
+ * @function
+ * @param {string} url - link to image.
+ * @returns {Promise<Image>} Returns promise.
+ */
+export declare function loadImage(url: string): Promise<HTMLImageElement>;
+/**
+ * Gets image is loaded
+ * @param {HTMLImageElement} image
+ * @returns {boolean} Returns true is the image is loaded
+ */
+export declare function isImageLoaded(image: HTMLImageElement): boolean;
+export declare function distanceFormat(v: number): string;
+export declare function distanceFormatExt(v: number): [string, string];
+export declare function getUrlParam(paramName: string): number | undefined;

package/lib/@openglobus/js/utils/units.d.ts

@@ -0,0 +1,16 @@
+export declare const ELL = 0;
+export declare const MSL = 1;
+export declare const GND = 2;
+export declare const heightMode: Record<string, number>;
+export declare const m = 0;
+export declare const km = 1;
+export declare const ft = 2;
+export declare const s = 3;
+export declare const h = 4;
+export declare const ms = 5;
+export declare const kmh = 6;
+export declare const fts = 7;
+export declare const _tenth: number[];
+export declare function convert(from: number, to: number, val: number): number;
+export declare function convertExt(isNotNaN: boolean, unitFrom: number, unitTo: number, val: number, fixed?: number): string;
+export declare function toString(u: number): string;