@aibee/owlly 1.0.25 → 1.0.29

package/lib/owlly/utils/lru-cache.d.ts

@@ -0,0 +1,26 @@
+declare class LruCache<T> {
+    private values;
+    private capacity;
+    private totalCost;
+    private costCallback?;
+    constructor(capacity: number, costCallback?: (value: T) => number);
+    get(key: string, missedCallback?: {
+        (key: string): T | undefined;
+    }): T | undefined;
+    /**
+     *
+     * @param key
+     * @param value
+     * @param evictCallback
+     * @param abortIfFull
+     * @returns If some other item is evicted
+     */
+    put(key: string, value: T, evictCallback?: {
+        (key: string, value: T): void;
+    }, abortIfFull?: boolean | undefined): boolean;
+    recycle(key: string, disposeCallback?: (key: string, value: T) => void): boolean;
+    clear(disposeCallback: (key: string, value: T) => void): void;
+    getCapacity(): number;
+    getTotalCost(): number;
+}
+export { LruCache };

package/lib/owlly/utils/lru-cache.js

@@ -0,0 +1,109 @@
+// <script src="https://gist.github.com/dherges/86012049be7b1263b2e594134ff5816a.js"></script>
+class LruCache {
+    constructor(capacity, costCallback) {
+        this.values = new Map();
+        this.capacity = capacity;
+        this.totalCost = 0;
+        this.costCallback = costCallback;
+    }
+    get(key, missedCallback) {
+        const hasKey = this.values.has(key);
+        let entry;
+        if (hasKey) {
+            // peek the entry, re-insert for LRU strategy
+            // console.log(`#LruCache# Hit cache with key: '${key}'`);
+            entry = this.values.get(key);
+            if (entry) {
+                this.values.delete(key);
+                this.values.set(key, entry);
+            }
+        }
+        else if (missedCallback) {
+            // console.log(`#LruCache# Miss key: '${key}', will create one`);
+            entry = missedCallback(key);
+            if (entry) {
+                this.put(key, entry);
+            }
+        }
+        return entry;
+    }
+    /**
+     *
+     * @param key
+     * @param value
+     * @param evictCallback
+     * @param abortIfFull
+     * @returns If some other item is evicted
+     */
+    put(key, value, evictCallback, abortIfFull = false) {
+        let ret = false;
+        // console.log(`#LruCache# abortIfFull=${abortIfFull}`);
+        if (this.totalCost >= this.capacity) {
+            if (abortIfFull) {
+                // console.log(`#LruCache# abortIfFull, return. this.totalCost=${this.totalCost}, this.capacity=${this.capacity}`);
+                return ret;
+            }
+            // least-recently used cache eviction strategy
+            const keyToDelete = this.values.keys().next().value;
+            const recycled = this.values.get(keyToDelete);
+            if (recycled) {
+                const recycledIncome = this.costCallback === undefined ? 1 : this.costCallback(recycled);
+                this.totalCost -= recycledIncome;
+                // console.log(`#LruCache# Cost exceeds capacity, evict entry with key'${keyToDelete}', totalCost=${this.totalCost}`);
+                if (evictCallback) {
+                    // console.log('#LruCache# Will call evictCallback');
+                    evictCallback(keyToDelete, recycled);
+                }
+                this.values.delete(keyToDelete);
+            }
+            ret = true;
+        }
+        if (this.values.has(key)) {
+            let cost0 = 1;
+            const oldValue = this.values.get(key);
+            if (oldValue && this.costCallback) {
+                cost0 = this.costCallback(oldValue);
+            }
+            const cost1 = this.costCallback === undefined ? 1 : this.costCallback(value);
+            this.values.set(key, value);
+            this.totalCost += (cost1 - cost0);
+            // console.log(`#LruCache# Replace entry with key'${key}', totalCost=${this.totalCost}`);
+        }
+        else {
+            this.values.set(key, value);
+            const cost = this.costCallback === undefined ? 1 : this.costCallback(value);
+            this.totalCost += cost;
+            // console.log(`#LruCache# Add new entry with key'${key}', totalCost=${this.totalCost}`);
+        }
+        return ret;
+    }
+    recycle(key, disposeCallback) {
+        let ret = false;
+        const recycled = this.values.get(key);
+        if (recycled) {
+            ret = true;
+            const recycledIncome = this.costCallback === undefined ? 1 : this.costCallback(recycled);
+            this.totalCost -= recycledIncome;
+            // console.log(`#LruCache# Recycle entry with key'${key}', totalCost=${this.totalCost}`);
+            if (disposeCallback) {
+                // console.log('#LruCache# Will call disposeCallback');
+                disposeCallback(key, recycled);
+            }
+            this.values.delete(key);
+        }
+        return ret;
+    }
+    clear(disposeCallback) {
+        this.values.forEach((recycled, key) => {
+            if (recycled) {
+                // console.log('#LruCache# Will call disposeCallback');
+                disposeCallback(key, recycled);
+            }
+        });
+        this.totalCost = 0;
+        this.values.clear();
+    }
+    getCapacity() { return this.capacity; }
+    getTotalCost() { return this.totalCost; }
+}
+export { LruCache };

package/lib/owlly/utils/map-utils.d.ts

@@ -0,0 +1,7 @@
+import { NS_THREE } from '../stage/externals';
+import { PathStep } from '../element/map-kit/shape';
+/** Block 专用类, 仅用于通过 Shape 生成 THREE 可用的路径格式 @ignore */
+declare class MapUtils {
+    static GenerateShapeFromSteps(steps: PathStep[]): NS_THREE.Shape;
+}
+export { MapUtils };

package/lib/owlly/utils/map-utils.js

@@ -0,0 +1,52 @@
+import { Externals } from '../stage/externals';
+import { PathCommand } from '../element/map-kit/shape';
+/** Block 专用类, 仅用于通过 Shape 生成 THREE 可用的路径格式 @ignore */
+class MapUtils {
+    static GenerateShapeFromSteps(steps) {
+        const { THREE } = Externals.getInstance();
+        const holes = [];
+        let hole = null;
+        let shapeCount = 0;
+        const result = new THREE.Shape();
+        steps.forEach(({ coords, command }) => {
+            switch (command) {
+                case PathCommand.MOVE:
+                    if (coords.length !== 1)
+                        throw new Error(`Parse path command error. Command: ${command}`);
+                    shapeCount += 1;
+                    if (shapeCount > 1) {
+                        hole = new THREE.Path();
+                        holes.push(hole);
+                        hole.moveTo(coords[0][0], coords[0][1]);
+                    }
+                    else {
+                        result.moveTo(coords[0][0], coords[0][1]);
+                    }
+                    break;
+                case PathCommand.LINE:
+                    if (coords.length !== 1)
+                        throw new Error(`Parse path command error. Command: ${command}`);
+                    if (hole && shapeCount > 1)
+                        hole.lineTo(coords[0][0], coords[0][1]);
+                    else
+                        result.lineTo(coords[0][0], coords[0][1]);
+                    break;
+                case PathCommand.CURVE:
+                    if (coords.length !== 3)
+                        throw new Error(`Parse path command error. Command: ${command}`);
+                    if (hole && shapeCount > 1) {
+                        hole.bezierCurveTo(coords[0][0], coords[0][1], coords[1][0], coords[1][1], coords[2][0], coords[2][1]);
+                    }
+                    else {
+                        result.bezierCurveTo(coords[0][0], coords[0][1], coords[1][0], coords[1][1], coords[2][0], coords[2][1]);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        });
+        result.holes = holes;
+        return result;
+    }
+}
+export { MapUtils };

package/lib/owlly/utils/number-utils.d.ts

@@ -0,0 +1,8 @@
+declare class NumberUtils {
+    static mergeRange(ranges: [number, number][], tolerance?: number): [number, number][];
+    static rangeSub(range: [number, number], subRanges: [number, number][], tolerance?: number): [number, number][];
+    static nearlyEquals(a: number, b: number, tolerance?: number): boolean;
+    static nearlyLess(a: number, b: number, include: boolean, tolerance?: number): boolean;
+    static nearlyThan(a: number, b: number, include: boolean, tolerance?: number): boolean;
+}
+export { NumberUtils };

package/lib/owlly/utils/number-utils.js

@@ -0,0 +1,72 @@
+class NumberUtils {
+    static mergeRange(ranges, tolerance = 0.0001) {
+        const t = [];
+        const s = Array.from(ranges);
+        s.sort((a, b) => b[0] - a[0]);
+        let cur = s.pop();
+        while (cur) {
+            const next = s.pop();
+            if (next) {
+                if ((next[0] >= cur[0] && next[0] <= cur[1])
+                    || NumberUtils.nearlyEquals(next[0], cur[0], tolerance)
+                    || NumberUtils.nearlyEquals(next[0], cur[1], tolerance)) {
+                    cur[1] = Math.max(cur[1], next[1]);
+                }
+                else {
+                    t.push(cur);
+                    cur = next;
+                }
+            }
+            else {
+                t.push(cur);
+                cur = next;
+            }
+        }
+        return t;
+    }
+    static rangeSub(range, subRanges, tolerance = 0.0001) {
+        const [start, end] = range;
+        const trs = [];
+        let tr = [];
+        trs.push(tr);
+        tr.push(start);
+        // eslint-disable-next-line no-param-reassign
+        subRanges = NumberUtils.mergeRange(subRanges, tolerance);
+        for (let i = 0; i < subRanges.length; i++) {
+            const subRange = subRanges[i];
+            const [subStart, subEnd] = subRange;
+            if (subStart <= end) {
+                tr.push(subStart);
+                tr = [];
+                trs.push(tr);
+            }
+            else {
+                break;
+            }
+            if (subEnd <= end) {
+                tr.push(subEnd);
+            }
+            else {
+                break;
+            }
+        }
+        if (tr.length === 1 && tr[0] < end) {
+            tr.push(end);
+        }
+        // const trsResult = [] as number[][];
+        const trsResult = trs.filter(([v1, v2]) => v2 !== undefined && !NumberUtils.nearlyEquals(v1, v2));
+        return trsResult;
+    }
+    static nearlyEquals(a, b, tolerance = 0.0001) {
+        return Math.abs(a - b) < tolerance;
+    }
+    static nearlyLess(a, b, include, tolerance = 0.0001) {
+        const equals = NumberUtils.nearlyEquals(a, b, tolerance);
+        return (include ? equals : false) || a < b;
+    }
+    static nearlyThan(a, b, include, tolerance = 0.0001) {
+        const equals = NumberUtils.nearlyEquals(a, b, tolerance);
+        return (include ? equals : false) || a > b;
+    }
+}
+export { NumberUtils };

package/lib/owlly/utils/panorama-model-util.d.ts

@@ -0,0 +1,46 @@
+import { NS_THREE } from '../stage/externals';
+declare class PanoramaModelUtil {
+    /**
+     * 获取模型的顶点着色器
+     * @ignore
+     */
+    static getModelVS(): string;
+    /**
+     * 获取穿梭的定点着色器
+     * @ignore
+     */
+    static getInstantTranslationVS(): string;
+    /**
+     * 获得模型片源着色器
+     * @ignore
+     * @returns {string} 片源着色器代码
+     */
+    static getModelFS(): string;
+    /**
+     * debug模型顶点着色器
+     * @ignore
+     */
+    static debugModelVS(): string;
+    /**
+     * debug模型片源着色器
+     * @ignore
+     */
+    static debugModelFS(): string;
+    static createModelUniforms(): {
+        [uniform: string]: NS_THREE.IUniform;
+    };
+    /**
+     * @ignore
+     */
+    static createInstantTranslationUniforms(): {
+        [uniform: string]: NS_THREE.IUniform;
+    };
+    /**
+     * 获取模型网格
+     * @ignore
+     * @param e 3d对象
+     * @returns
+     */
+    static getModelMeshInElement(e: NS_THREE.Object3D): NS_THREE.Mesh | undefined;
+}
+export { PanoramaModelUtil, };

package/lib/owlly/utils/panorama-model-util.js

@@ -0,0 +1,245 @@
+import { Externals } from '../stage/externals';
+/* eslint-disable max-len */
+class PanoramaModelUtil {
+    /**
+     * 获取模型的顶点着色器
+     * @ignore
+     */
+    static getModelVS() {
+        const vertexShader = `
+      uniform vec3 pano0Position;
+      uniform mat4 pano0Matrix;
+      uniform vec3 pano1Position;
+      uniform mat4 pano1Matrix;
+
+      varying vec3 vWorldPosition0;
+      varying vec3 vWorldPosition1;
+
+      void main() {
+
+      vec4 worldPosition = modelMatrix * vec4(position, 1.0);
+
+      vec3 positionLocalToPanoCenter0 = worldPosition.xyz - pano0Position;
+      vWorldPosition0 = (vec4(positionLocalToPanoCenter0, 1.0) * pano0Matrix).xyz;
+      vWorldPosition0.y *= -1.0;
+
+      vec3 positionLocalToPanoCenter1 = worldPosition.xyz - pano1Position;
+      vWorldPosition1 = (vec4(positionLocalToPanoCenter1, 1.0) * pano1Matrix).xyz;
+      vWorldPosition1.y *= -1.0;
+
+      gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+      }`;
+        return vertexShader;
+    }
+    /**
+     * 获取穿梭的定点着色器
+     * @ignore
+     */
+    static getInstantTranslationVS() {
+        const vertexShader = `
+      uniform mat4 matrixT;
+
+      uniform vec3 pano0Position;
+      uniform mat4 pano0Matrix;
+      uniform vec3 pano1Position;
+      uniform mat4 pano1Matrix;
+
+      varying vec3 vWorldPosition0;
+      varying vec3 vWorldPosition1;
+
+      void main() {
+
+      vec4 worldPosition = modelMatrix * vec4(position, 1.0);
+      vec4 worldPosition0 = matrixT * worldPosition;
+
+      vec3 positionLocalToPanoCenter1 = worldPosition.xyz - pano1Position;
+      vWorldPosition1 = (vec4(positionLocalToPanoCenter1, 1.0) * pano1Matrix).xyz;
+      vWorldPosition1.y *= -1.0;
+
+      vec3 positionLocalToPanoCenter0 = worldPosition0.xyz - pano0Position;
+      vWorldPosition0 = (vec4(positionLocalToPanoCenter0, 1.0) * pano0Matrix).xyz;
+      vWorldPosition0.y *= -1.0;
+
+      gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+      }`;
+        return vertexShader;
+    }
+    /**
+     * 获得模型片源着色器
+     * @ignore
+     * @returns {string} 片源着色器代码
+     */
+    static getModelFS() {
+        const fragmentShader = `
+      uniform float weight0;
+      uniform float weight1;
+
+      uniform samplerCube pano0Map;
+
+      uniform samplerCube pano1Map;
+
+      varying vec3 vWorldPosition0;
+      varying vec3 vWorldPosition1;
+
+      void main() {
+      vec3 cp0 = vWorldPosition0.xyz;
+      vec3 cp1 = vWorldPosition1.xyz;
+      vec4 colorFromPano0 = textureCube( pano0Map, cp0);
+      vec4 colorFromPano1 = textureCube( pano1Map, cp1);
+
+      vec4 colorFromPanos;
+      // 'colorFromPanos = mix(colorFromPano0, colorFromPano1, progress);
+      colorFromPanos = colorFromPano0 * weight0 + colorFromPano1 * weight1;
+      gl_FragColor = vec4(colorFromPanos.rgb, 1.0);
+      }`;
+        return fragmentShader;
+    }
+    /**
+     * debug模型顶点着色器
+     * @ignore
+     */
+    static debugModelVS() {
+        const vertexShader = `
+      uniform vec2 xRange;
+      uniform vec2 yRange;
+      uniform vec2 zRange;
+      varying vec4 vColor;
+
+      void main() {
+      float x = (position.x - xRange.x) / xRange.y;
+      float y = (position.y - yRange.x) / yRange.y;
+      float z = (position.z - zRange.x) / zRange.y;
+      vColor = vec4(x, y, z, 1.0);
+      gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+      }`;
+        return vertexShader;
+    }
+    /**
+     * debug模型片源着色器
+     * @ignore
+     */
+    static debugModelFS() {
+        const fragmentShader = `
+      varying vec4 vColor;
+
+      void main() {
+      gl_FragColor = vColor;
+      }`;
+        return fragmentShader;
+    }
+    static createModelUniforms() {
+        const { THREE } = Externals.getInstance();
+        const modelUniforms = {
+            weight0: {
+                type: 'f',
+                value: 0,
+            },
+            weight1: {
+                type: 'f',
+                value: 0,
+            },
+            // 源全景图立方体贴图
+            pano0Map: {
+                type: 't',
+                value: null,
+            },
+            // 源全景图位置
+            pano0Position: {
+                type: 'v3',
+                value: new THREE.Vector3(),
+            },
+            // 源全景图世界变换矩阵
+            pano0Matrix: {
+                type: 'm4',
+                value: new THREE.Matrix4(),
+            },
+            // 目标全景图立方体贴图
+            pano1Map: {
+                type: 't',
+                value: null,
+            },
+            // 目标全景图位置
+            pano1Position: {
+                type: 'v3',
+                value: new THREE.Vector3(),
+            },
+            // 目标全景图世界变换矩阵
+            pano1Matrix: {
+                type: 'm4',
+                value: new THREE.Matrix4(),
+            },
+        };
+        return modelUniforms;
+    }
+    /**
+     * @ignore
+     */
+    static createInstantTranslationUniforms() {
+        const { THREE } = Externals.getInstance();
+        const modelUniforms = {
+            weight0: {
+                type: 'f',
+                value: 0,
+            },
+            weight1: {
+                type: 'f',
+                value: 0,
+            },
+            // 源全景图立方体贴图
+            pano0Map: {
+                type: 't',
+                value: null,
+            },
+            pano0Position: {
+                type: 'v3',
+                value: new THREE.Vector3(),
+            },
+            // 源全景图世界变换矩阵
+            pano0Matrix: {
+                type: 'm4',
+                value: new THREE.Matrix4(),
+            },
+            // 目标全景图立方体贴图
+            pano1Map: {
+                type: 't',
+                value: null,
+            },
+            // 目标全景图位置
+            pano1Position: {
+                type: 'v3',
+                value: new THREE.Vector3(),
+            },
+            // 目标全景图世界变换矩阵
+            pano1Matrix: {
+                type: 'm4',
+                value: new THREE.Matrix4(),
+            },
+            matrixT: {
+                type: 'm4',
+                value: new THREE.Matrix4(),
+            },
+        };
+        return modelUniforms;
+    }
+    /**
+     * 获取模型网格
+     * @ignore
+     * @param e 3d对象
+     * @returns
+     */
+    static getModelMeshInElement(e) {
+        let ret;
+        const { THREE } = Externals.getInstance();
+        if (e instanceof THREE.Mesh)
+            return e;
+        if (e) {
+            e.traverse((obj) => {
+                if (obj instanceof THREE.Mesh) {
+                    ret = obj;
+                }
+            });
+        }
+        return ret;
+    }
+}
+export { PanoramaModelUtil, };

package/lib/owlly/utils/path-utils.d.ts

@@ -0,0 +1,80 @@
+import { NS_THREE } from '../stage/externals';
+import { FloorModel, GroundParameters } from '../element/floor-model';
+declare class PathUtils {
+    static PathMeshOffsetZ: number;
+    static ArrowMeshOffsetZ: number;
+    static getAngle(vec0: NS_THREE.Vector2, vec1: NS_THREE.Vector2): number;
+    /**
+     * 路径简化
+     * @param path 路径点集数组
+     * @param ignoreFirst 是否在简化过程中忽略第一个点
+     * @param smoothingOptimization 是否针对平滑对路径进行插值
+     * @param simplifyDistanceThreshold 简化时路径最短保留的距离, 默认为5
+     * @param maximumTurningDegree 简化时三点夹角认定为转弯的最大角度，默认为150
+     * @param smoothingDistance 平滑时使用的转角最大距离
+     */
+    static simplify(path: {
+        x: number;
+        y: number;
+    }[], ignoreFirst?: boolean, smoothingOptimization?: boolean, simplifyDistanceThreshold?: number, maximumTurningDegree?: number, smoothingDistance?: number): {
+        x: number;
+        y: number;
+    }[];
+    static averageStepLength(path: [number, number][]): number;
+    static smoothPath(path: [number, number][], threshold?: number): [number, number][];
+    static smoothPathBezier(path: [number, number][], bezierLength: number, segment?: number): [number, number][];
+    static getRenderHeight(expression: number[], x: number, y: number): number;
+    static getPointHash(x: number, y: number, minX: number, minY: number, dist?: number): [number, number];
+    /**
+     * @deprecated
+     * @param path 路径点二维坐标数组
+     * @param params 其它可选参数
+     * @param arrowImageRatio 箭头图像的宽高比，用于生成纹理坐标
+     * @param arrowImageURL 箭头图像URL
+     * @param floorModel FloorModel对象，用于计算地面高度坐标
+     * @param groundParams GroundParameters对象，用于计算地面高度坐标
+     * @param color 路劲的颜色
+     * 当存在groundParams时优先用它计算，忽略floorModel
+     */
+    static generatePathMesh(path: {
+        x: number;
+        y: number;
+    }[], params?: {
+        viewDistance?: number;
+        gradientDistance?: number;
+        arrowImageRatio?: number;
+        arrowImageURL?: string;
+        floorModel?: FloorModel;
+        groundParams?: GroundParameters;
+        color?: string;
+        dynamicPathEnabled?: boolean;
+        width?: number;
+    }): {
+        mesh: NS_THREE.Mesh;
+        arrowMeshes: {
+            arrowMesh: NS_THREE.Mesh;
+            index: number;
+        }[];
+        newPath: [number, number][];
+        pointMap: Map<string, Map<string, number[][]>>;
+        pathMinX: number;
+        pathMinY: number;
+        progressBuffer: Float32Array;
+        pathDistance: number[];
+    };
+    static nearlyEqualsV2(v1: NS_THREE.Vector2, v2: NS_THREE.Vector2, tolerance?: number): boolean;
+    static nearlyEqualsV3(v1: NS_THREE.Vector3, v2: NS_THREE.Vector3, tolerance?: number): boolean;
+    static mergePathSameVectorPoint3(path: NS_THREE.Vector3[], tolerance?: number): void;
+    static mergePathSameVectorPoint2(path: NS_THREE.Vector2[], tolerance?: number): void;
+    static mergeSamePoint3(path: NS_THREE.Vector3[], tolerance?: number): void;
+    static mergeSamePoint2(path: NS_THREE.Vector2[], tolerance?: number): void;
+    static splitPathByPoints(path: NS_THREE.Vector3[], closed: boolean, points: NS_THREE.Vector3[], widths: number | number[], tolerance?: number): {
+        paths: NS_THREE.Vector3[][];
+        split: boolean;
+    };
+    static invalidPath(path: NS_THREE.Vector3[]): boolean;
+    static getDistances(path: NS_THREE.Vector3[]): number[];
+    static findPointIndexByPath(path: NS_THREE.Vector3[], point: NS_THREE.Vector3, tolerance?: number): number[];
+    static pointInLine(point: NS_THREE.Vector3, lineP1: NS_THREE.Vector3, lineP2: NS_THREE.Vector3, tolerance?: number): boolean;
+}
+export { PathUtils };