@openglobus/og 0.18.0 → 0.18.1

package/lib/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/{src/utils/objParser.ts → lib/js/utils/objParser.js}

@@ -1,48 +1,25 @@
-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 function objParser(text: string) {
-    const objPositions: number[][] = [[0, 0, 0]];
-    const objTexcoords: number[][] = [[0, 0]];
-    const objNormals: number[][] = [[0, 0, 0]];
-
+export function objParser(text) {
+    const objPositions = [[0, 0, 0]];
+    const objTexcoords = [[0, 0]];
+    const objNormals = [[0, 0, 0]];
     // same order as `f` indices
-    const objVertexData: [number[][], number[][], number[][]] = [
+    const objVertexData = [
         objPositions,
         objTexcoords,
         objNormals,
     ];
-
     // same order as `f` indices
-    let vertexData: [number[], number[], number[]] = [
-        [],   // positions
-        [],   // texcoords
-        [],   // normals
+    let vertexData = [
+        [],
+        [],
+        [], // normals
     ];
-
-    const materialLibs: string[] = [];
-    const geometries: IObjGeometry[] = [];
-    let geometry: IObjGeometry | null;
-
-    let groups: string[] = ['default'];
-    let material: string = 'default';
-    let object: string = 'default';
-
+    const materialLibs = [];
+    const geometries = [];
+    let geometry;
+    let groups = ['default'];
+    let material = 'default';
+    let object = 'default';
     function newGeometry() {
         // If there is an existing geometry and it's
         // not empty then start a new one.
@@ -50,20 +27,16 @@ export function objParser(text: string) {
             geometry = null;
         }
     }
-
     function setGeometry() {
         if (!geometry) {
-
-            const vertices: number[] = [];
-            const textures: number[] = [];
-            const normals: number[] = [];
-
+            const vertices = [];
+            const textures = [];
+            const normals = [];
             vertexData = [
                 vertices,
                 textures,
                 normals,
             ];
-
             geometry = {
                 object,
                 groups,
@@ -74,14 +47,12 @@ export function objParser(text: string) {
                     normals,
                 },
             };
-
             geometries.push(geometry);
         }
     }
-
-    function addVertex(vert: string) {
+    function addVertex(vert) {
         const ptn = vert.split('/');
-        ptn.forEach((objIndexStr: string, i: number) => {
+        ptn.forEach((objIndexStr, i) => {
             if (!objIndexStr) {
                 return;
             }
@@ -90,19 +61,18 @@ export function objParser(text: string) {
             vertexData[i].push(...objVertexData[i][index]);
         });
     }
-
-    const keywords: Record<string, (parts: string[], unparsedArgs: string) => void> = {
-        v(parts: string[]) {
+    const keywords = {
+        v(parts) {
             objPositions.push(parts.map(parseFloat));
         },
-        vn(parts: string[]) {
+        vn(parts) {
             objNormals.push(parts.map(parseFloat));
         },
-        vt(parts: string[]) {
+        vt(parts) {
             // should check for missing v and extra w?
             objTexcoords.push(parts.map(parseFloat));
         },
-        f(parts: string[]) {
+        f(parts) {
             setGeometry();
             const numTriangles = parts.length - 2;
             for (let tri = 0; tri < numTriangles; ++tri) {
@@ -112,26 +82,25 @@ export function objParser(text: string) {
             }
         },
         s: () => {
-        },    // smoothing group
-        mtllib(parts: string[], unparsedArgs: string) {
+        },
+        mtllib(parts, unparsedArgs) {
             // the spec says there can be multiple filenames here
             // but many exist with spaces in a single filename
             materialLibs.push(unparsedArgs);
         },
-        usemtl(parts: string[], unparsedArgs: string) {
+        usemtl(parts, unparsedArgs) {
             material = unparsedArgs;
             newGeometry();
         },
-        g(parts: string[]) {
+        g(parts) {
             groups = parts;
             newGeometry();
         },
-        o(parts: string[], unparsedArgs: string) {
+        o(parts, unparsedArgs) {
             object = unparsedArgs;
             newGeometry();
         },
     };
-
     const keywordRE = /(\w*)(?: )*(.*)/;
     const lines = text.split('\n');
     for (let lineNo = 0; lineNo < lines.length; ++lineNo) {
@@ -147,41 +116,29 @@ export function objParser(text: string) {
         const parts = line.split(/\s+/).slice(1);
         const handler = keywords[keyword];
         if (!handler) {
-            console.warn('unhandled keyword:', keyword);  // eslint-disable-line no-console
+            console.warn('unhandled keyword:', keyword); // eslint-disable-line no-console
             continue;
         }
         handler(parts, unparsedArgs);
     }
-
     // remove any arrays that have no entries.
     for (const geometry of geometries) {
-        geometry.data = Object.fromEntries(
-            Object.entries(geometry.data).filter(([key, array]) => array.length > 0)
-        ) as IObjGeometryData;
+        geometry.data = Object.fromEntries(Object.entries(geometry.data).filter(([key, array]) => array.length > 0));
     }
-
     return {
         geometries,
         materialLibs,
     };
 }
-
-export function transformLeftToRightCoordinateSystem(objData: IObjData): {
-    geometries: IObjGeometry[],
-    materialLibs: string[]
-} {
-
-    const convertedGeometries: IObjGeometry[] = objData.geometries.map(geometry => {
+export function transformLeftToRightCoordinateSystem(objData) {
+    const convertedGeometries = objData.geometries.map(geometry => {
         const vertices = geometry.data.vertices;
         const normals = geometry.data.normals;
         const textures = geometry.data.textures;
-
         rotateObject(geometry.data, 0);
-
-        let convertedVertices: number[] = [];
-        let convertedNormals: number[] = [];
-        let convertedTextures: number[] = [];
-
+        let convertedVertices = [];
+        let convertedNormals = [];
+        let convertedTextures = [];
         // Convert positions
         for (let i = 0; i < vertices.length; i += 3) {
             const x = vertices[i];
@@ -189,7 +146,6 @@ export function transformLeftToRightCoordinateSystem(objData: IObjData): {
             const z = vertices[i + 2];
             convertedVertices.push(x, y, z);
         }
-
         // Convert normals
         for (let i = 0; i < normals.length; i += 3) {
             const x = normals[i];
@@ -197,14 +153,12 @@ export function transformLeftToRightCoordinateSystem(objData: IObjData): {
             const z = normals[i + 2];
             convertedNormals.push(x, y, -z);
         }
-
         // Convert textures
         for (let i = 0; i < textures.length; i += 2) {
             const s = textures[i];
             const t = 1 - textures[i + 1];
             convertedTextures.push(s, t);
         }
-
         return {
             object: geometry.object,
             groups: geometry.groups,
@@ -216,41 +170,32 @@ export function transformLeftToRightCoordinateSystem(objData: IObjData): {
             }
         };
     });
-
     return {
         geometries: convertedGeometries,
         materialLibs: objData.materialLibs
     };
 }
-
-function rotateObject(obj: IObjGeometryData, angle: number): { vertices: number[], normals: number[] } {
+function rotateObject(obj, angle) {
     const cosA = Math.cos(angle);
     const sinA = Math.sin(angle);
-
     const vertices = obj.vertices;
     const normals = obj.normals;
-
     for (let i = 0; i < vertices.length; i += 3) {
         const x = vertices[i];
         const y = vertices[i + 1];
         const z = vertices[i + 2];
-
         vertices[i] = x * cosA + z * sinA;
         vertices[i + 1] = y;
         vertices[i + 2] = -x * sinA + z * cosA;
-
         const nx = normals[i];
         const ny = normals[i + 1];
         const nz = normals[i + 2];
-
         normals[i] = nx * cosA + nz * sinA;
         normals[i + 1] = ny;
         normals[i + 2] = -nx * sinA + nz * cosA;
     }
-
     return {
         vertices: vertices,
         normals: normals
     };
 }
-

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

@@ -0,0 +1,267 @@
+/**
+ * @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;
+/**
+ * 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 defaultString(str?: string, def?: string): string;
+export declare function createVector3(v?: 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;
+/**
+ * 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.
+ * @static
+ * @param {Array.<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.
+ * @param {object} outBounds - Output bounds.
+ * @return{Array.<number>} Triangle coordinates array from the source 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 getUrlParam(paramName: string): number | undefined;