@loaders.gl/tile-converter 3.1.8 → 3.2.0-alpha.3

package/dist/i3s-converter/helpers/gltf-attributes.d.ts

@@ -0,0 +1,9 @@
+import type { B3DMContent } from '@loaders.gl/3d-tiles';
+import type { B3DMAttributesData } from '../../i3s-attributes-worker';
+/**
+ * Prepare attributes for conversion to avoid binary data breaking in worker thread.
+ * @param tileContent
+ * @returns
+ */
+export declare function prepareDataForAttributesConversion(tileContent: B3DMContent): B3DMAttributesData;
+//# sourceMappingURL=gltf-attributes.d.ts.map

package/dist/i3s-converter/helpers/gltf-attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-attributes.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/gltf-attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,6BAA6B,CAAC;AAsBpE;;;;GAIG;AACH,wBAAgB,kCAAkC,CAAC,WAAW,EAAE,WAAW,GAAG,kBAAkB,CAsC/F"}

package/dist/i3s-converter/helpers/gltf-attributes.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareDataForAttributesConversion = void 0;
+/**
+ * Keep only values for B3DM attributes to pass data to worker thread.
+ * @param attributes
+ */
+function getB3DMAttributesWithoutBufferView(attributes) {
+    const attributesWithoutBufferView = {};
+    for (const attributeName in attributes) {
+        attributesWithoutBufferView[attributeName] = {
+            value: attributes[attributeName].value
+        };
+    }
+    return attributesWithoutBufferView;
+}
+/**
+ * Prepare attributes for conversion to avoid binary data breaking in worker thread.
+ * @param tileContent
+ * @returns
+ */
+function prepareDataForAttributesConversion(tileContent) {
+    const gltfMaterials = tileContent.gltf?.materials?.map((material) => ({ id: material.id }));
+    let nodes = tileContent.gltf?.scene?.nodes ||
+        tileContent.gltf?.scenes?.[0]?.nodes ||
+        tileContent.gltf?.nodes ||
+        [];
+    const prepearedNodes = nodes.map((node) => {
+        if (!node.mesh) {
+            return node;
+        }
+        return {
+            ...node,
+            mesh: {
+                ...node.mesh,
+                primitives: node.mesh?.primitives.map((primitive) => ({
+                    ...primitive,
+                    indices: { value: primitive?.indices?.value },
+                    attributes: getB3DMAttributesWithoutBufferView(primitive.attributes),
+                    material: {
+                        id: primitive?.material?.id
+                    }
+                }))
+            }
+        };
+    });
+    const cartographicOrigin = tileContent.cartographicOrigin;
+    const cartesianModelMatrix = tileContent.cartesianModelMatrix;
+    return {
+        gltfMaterials,
+        nodes: prepearedNodes,
+        cartographicOrigin,
+        cartesianModelMatrix
+    };
+}
+exports.prepareDataForAttributesConversion = prepareDataForAttributesConversion;

package/dist/i3s-converter/helpers/node-debug.d.ts

@@ -0,0 +1,8 @@
+import type { Node3DIndexDocument } from '@loaders.gl/i3s';
+/**
+ * Do validation of bounding volumes for particular node.
+ * Generates special warnings if there are some issues.
+ * @param node
+ */
+export declare function validateNodeBoundingVolumes(node: Node3DIndexDocument): string[];
+//# sourceMappingURL=node-debug.d.ts.map

package/dist/i3s-converter/helpers/node-debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-debug.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/node-debug.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAM,mBAAmB,EAAM,MAAM,iBAAiB,CAAC;AASnE;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,mBAAmB,GAAG,MAAM,EAAE,CAW/E"}

package/dist/i3s-converter/helpers/node-debug.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateNodeBoundingVolumes = void 0;
+const culling_1 = require("@math.gl/culling");
+const engine_1 = require("@luma.gl/engine");
+const core_1 = require("@math.gl/core");
+const geospatial_1 = require("@math.gl/geospatial");
+// TODO Unite Tile validation logic in i3s-17-and-debug with this code.
+/**
+ * Do validation of bounding volumes for particular node.
+ * Generates special warnings if there are some issues.
+ * @param node
+ */
+function validateNodeBoundingVolumes(node) {
+    if (!node?.parentNode?.obb || !node?.parentNode?.mbs) {
+        return [];
+    }
+    const tileWarnings = [];
+    validateObb(tileWarnings, node);
+    validateMbs(tileWarnings, node);
+    return tileWarnings;
+}
+exports.validateNodeBoundingVolumes = validateNodeBoundingVolumes;
+/**
+ * Check if child Obb fit into parent Obb.
+ * @param tileWarnings
+ * @param node
+ */
+function validateObb(tileWarnings, node) {
+    // @ts-expect-error
+    const parentObb = createBoundingBoxFromTileObb(node.parentNode.obb);
+    const tileVertices = getTileObbVertices(node);
+    const isTileObbInsideParentObb = isAllVerticesInsideBoundingVolume(parentObb, tileVertices);
+    if (isTileObbInsideParentObb) {
+        return;
+    }
+    const title = `OBB of Tile (${node.id}) doesn't fit into Parent (${node.parentNode?.id}) tile OBB`;
+    tileWarnings.push(title);
+}
+/**
+ * Check if child Mbs fit into parent Mbs.
+ * @param tileWarnings
+ * @param node
+ */
+function validateMbs(tileWarnings, node) {
+    // @ts-expect-error
+    const tileMbs = createBoundingSphereFromTileMbs(node.mbs);
+    // @ts-expect-error
+    const parentMbs = createBoundingSphereFromTileMbs(node.parentNode.mbs);
+    const distanceBetweenCenters = tileMbs.center.distanceTo(parentMbs.center);
+    if (distanceBetweenCenters + tileMbs.radius > parentMbs.radius) {
+        const title = `MBS of Tile (${node.id}) doesn't fit into Parent (${node.parentNode?.id}) tile MBS`;
+        tileWarnings.push(title);
+    }
+}
+/**
+ * Generates bounding sphere from mbs
+ * @param mbs
+ */
+function createBoundingSphereFromTileMbs(mbs) {
+    return new culling_1.BoundingSphere([mbs[0], mbs[1], mbs[2]], mbs[3]);
+}
+/**
+ * Generates oriented bounding box from tile obb
+ * @param obb
+ * @returns
+ */
+function createBoundingBoxFromTileObb(obb) {
+    const { center, halfSize, quaternion } = obb;
+    return new culling_1.OrientedBoundingBox().fromCenterHalfSizeQuaternion(center, halfSize, quaternion);
+}
+/**
+ * Get vertices fromnode obb
+ * TODO check if Obb generates properly
+ * @param node
+ */
+function getTileObbVertices(node) {
+    const geometry = new engine_1.CubeGeometry();
+    // @ts-expect-error
+    const halfSize = node.obb.halfSize;
+    const attributes = geometry.getAttributes();
+    const positions = new Float32Array(attributes.POSITION.value);
+    // @ts-expect-error
+    const obbCenterCartesian = geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(node.obb.center);
+    let vertices = [];
+    for (let i = 0; i < positions.length; i += 3) {
+        const positionsVector = new core_1.Vector3((positions[i] *= halfSize[0]), (positions[i + 1] *= halfSize[1]), (positions[i + 2] *= halfSize[2]));
+        const rotatedPositions = positionsVector
+            // @ts-expect-error
+            .transformByQuaternion(node.obb.quaternion)
+            .add(obbCenterCartesian);
+        // @ts-expect-error
+        vertices = vertices.concat(rotatedPositions);
+    }
+    return vertices;
+}
+/**
+ * Check if all vertices inside bounding volume
+ * @param boundingVolume
+ * @param positions
+ */
+function isAllVerticesInsideBoundingVolume(boundingVolume, positions) {
+    let isVerticesInsideObb = true;
+    for (let index = 0; index < positions.length / 3; index += 3) {
+        const point = [positions[index], positions[index + 1], positions[index + 2]];
+        const cartographicPoint = geospatial_1.Ellipsoid.WGS84.cartesianToCartographic(point);
+        const distance = boundingVolume.distanceTo(cartographicPoint);
+        if (distance > 0) {
+            isVerticesInsideObb = false;
+            break;
+        }
+    }
+    return isVerticesInsideObb;
+}

package/dist/i3s-converter/helpers/node-pages.d.ts

@@ -0,0 +1,117 @@
+import type { WriteQueueItem } from '../../lib/utils/write-queue';
+import { NodeInPage } from '@loaders.gl/i3s';
+import WriteQueue from '../../lib/utils/write-queue';
+/**
+ * class NodePages - wrapper of nodePages array
+ *
+ * @example
+ * import {writeFile} from './helpers/write-file';
+ *
+ * // create an instance of the class
+ * const nodePages = new NodePages(writeFile, HARDCODED_NODES_PER_PAGE);
+ * ...
+ * // push root node
+ * const parentId = nodePages.push({
+      lodThreshold: HARDCODED_MAX_SCREEN_THRESHOLD_SQ,
+      obb: coordinates.obb,
+      children: []
+    });
+ * ...
+ * // push node with parent relation
+ * const nodeInPage = {
+      lodThreshold: HARDCODED_MAX_SCREEN_THRESHOLD_SQ,
+      obb: coordinates.obb,
+      children: [],
+      mesh: {
+        geometry: {
+          definition: 0
+        }
+      }
+    };
+ * const nodeId = this.nodePages.push(nodeInPage, parentId);
+ * ...
+ * // save all the nodePages in the end of pushing all the nodes
+ * await this.nodePages.save(layers0path);
+ */
+export default class NodePages {
+    readonly nodesPerPage: number;
+    nodesCounter: number;
+    writeFile: Function;
+    readonly nodePages: {
+        nodes: NodeInPage[];
+    }[];
+    /**
+     * @constructs
+     * Create a nodePages instance.
+     * @param writeFileFunc - function to save one nodePage into a file
+     * @param nodesPerPage - length limit for one nodePage. An additional nodePage is created when this limit is met
+     */
+    constructor(writeFileFunc: any, nodesPerPage: any);
+    /**
+     * Setup function to save node pages
+     * @param func - function which should be used to save node pages
+     */
+    useWriteFunction(func: Function): void;
+    /**
+     * Get the node by its end-to-end index
+     * @param id - end-to-end index of the node
+     * @return the node object
+     */
+    getNodeById(id: number): NodeInPage;
+    /**
+     * Update material in node.mesh object by node id
+     * @param id - end-to-end index of the node
+     * @param materialId - id from scene layer materialDefinitions
+     */
+    updateMaterialByNodeId(id: number, materialId: number): void;
+    /**
+     * Update vertexCount in node.mesh.geometry object by node id
+     * @param id - end-to-end index of the node
+     * @param vertexCount - vertex count for particular node
+     */
+    updateVertexCountByNodeId(id: number, vertexCount: number): void;
+    /**
+     * Update resource in node.mesh.attribute object by node id
+     * @param id - end-to-end index of the node
+     */
+    updateNodeAttributeByNodeId(id: number): void;
+    /**
+     * Update featureCount in node.mesh.geometry object by node id
+     * @param id - end-to-end index of the node
+     * @param featureCount - features count of the node
+     */
+    updateFeatureCountByNodeId(id: number, featureCount: number): void;
+    /**
+     * Update texelCountHint in node.mesh.material object by node id
+     * @param id - end-to-end index of the node
+     * @param texelCountHint - texelCountHint of particular node
+     */
+    updateTexelCountHintByNodeId(id: number, texelCountHint: number): void;
+    /**
+     * Add a child id into the parent node.children array
+     * @param parentId - end-to-end parent node index
+     * @param childId - end-to-end child node index
+     */
+    addChildRelation(parentId: number | undefined, childId: number): void;
+    /**
+     * Update resource index in node.mesh object
+     * @param node - node object
+     */
+    updateResourceInMesh(node: NodeInPage): void;
+    /**
+     * Put new node in nodePages array
+     * @param node - node object
+     * @param parentId - index of parent node
+     * @return
+     */
+    push(node: NodeInPage, parentId?: number): number;
+    /**
+     * Save all the node pages
+     * Run this method when all nodes is pushed in nodePages
+     * @param layers0Path - path of layer
+     * @param writeQueue - write queue that controlls files write concurrency
+     * @param slpk
+     */
+    save(layers0Path: string, writeQueue: WriteQueue<WriteQueueItem>, slpk?: boolean): Promise<void>;
+}
+//# sourceMappingURL=node-pages.d.ts.map

package/dist/i3s-converter/helpers/node-pages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-pages.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/node-pages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAC;AAKhE,OAAO,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAC3C,OAAO,UAAU,MAAM,6BAA6B,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,QAAQ,CAAC;IACpB,QAAQ,CAAC,SAAS,EAAE;QAAC,KAAK,EAAE,UAAU,EAAE,CAAA;KAAC,EAAE,CAAC;IAE5C;;;;;OAKG;gBACS,aAAa,KAAA,EAAE,YAAY,KAAA;IASvC;;;OAGG;IACH,gBAAgB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;IAItC;;;;OAIG;IACH,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU;IAMnC;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAW5D;;;;OAIG;IACH,yBAAyB,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAQhE;;;OAGG;IACH,2BAA2B,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAQ7C;;;;OAIG;IACH,0BAA0B,CAAC,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAQlE;;;;OAIG;IACH,4BAA4B,CAAC,EAAE,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI;IAQtE;;;;OAIG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAQrE;;;OAGG;IACH,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAM5C;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM;IAajD;;;;;;OAMG;IACG,IAAI,CACR,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,UAAU,CAAC,cAAc,CAAC,EACtC,IAAI,GAAE,OAAe,GACpB,OAAO,CAAC,IAAI,CAAC;CA6BjB"}

package/dist/i3s-converter/helpers/node-pages.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const json_map_transform_1 = __importDefault(require("json-map-transform"));
+const metadata_1 = require("../json-templates/metadata");
+// @ts-nocheck
+/**
+ * class NodePages - wrapper of nodePages array
+ *
+ * @example
+ * import {writeFile} from './helpers/write-file';
+ *
+ * // create an instance of the class
+ * const nodePages = new NodePages(writeFile, HARDCODED_NODES_PER_PAGE);
+ * ...
+ * // push root node
+ * const parentId = nodePages.push({
+      lodThreshold: HARDCODED_MAX_SCREEN_THRESHOLD_SQ,
+      obb: coordinates.obb,
+      children: []
+    });
+ * ...
+ * // push node with parent relation
+ * const nodeInPage = {
+      lodThreshold: HARDCODED_MAX_SCREEN_THRESHOLD_SQ,
+      obb: coordinates.obb,
+      children: [],
+      mesh: {
+        geometry: {
+          definition: 0
+        }
+      }
+    };
+ * const nodeId = this.nodePages.push(nodeInPage, parentId);
+ * ...
+ * // save all the nodePages in the end of pushing all the nodes
+ * await this.nodePages.save(layers0path);
+ */
+class NodePages {
+    /**
+     * @constructs
+     * Create a nodePages instance.
+     * @param writeFileFunc - function to save one nodePage into a file
+     * @param nodesPerPage - length limit for one nodePage. An additional nodePage is created when this limit is met
+     */
+    constructor(writeFileFunc, nodesPerPage) {
+        this.nodesPerPage = nodesPerPage;
+        this.nodesCounter = 0;
+        // @ts-expect-error
+        this.nodePages = [{}];
+        this.nodePages[0].nodes = [];
+        this.writeFile = writeFileFunc;
+    }
+    /**
+     * Setup function to save node pages
+     * @param func - function which should be used to save node pages
+     */
+    useWriteFunction(func) {
+        this.writeFile = func;
+    }
+    /**
+     * Get the node by its end-to-end index
+     * @param id - end-to-end index of the node
+     * @return the node object
+     */
+    getNodeById(id) {
+        const pageIndex = Math.floor(id / this.nodesPerPage);
+        const nodeIndex = id % this.nodesPerPage;
+        return this.nodePages[pageIndex].nodes[nodeIndex];
+    }
+    /**
+     * Update material in node.mesh object by node id
+     * @param id - end-to-end index of the node
+     * @param materialId - id from scene layer materialDefinitions
+     */
+    updateMaterialByNodeId(id, materialId) {
+        const node = this.getNodeById(id);
+        if (!node.mesh) {
+            return;
+        }
+        node.mesh.material = {
+            definition: materialId,
+            resource: node.index
+        };
+    }
+    /**
+     * Update vertexCount in node.mesh.geometry object by node id
+     * @param id - end-to-end index of the node
+     * @param vertexCount - vertex count for particular node
+     */
+    updateVertexCountByNodeId(id, vertexCount) {
+        const node = this.getNodeById(id);
+        if (!node.mesh) {
+            return;
+        }
+        node.mesh.geometry.vertexCount = vertexCount;
+    }
+    /**
+     * Update resource in node.mesh.attribute object by node id
+     * @param id - end-to-end index of the node
+     */
+    updateNodeAttributeByNodeId(id) {
+        const node = this.getNodeById(id);
+        if (!node.mesh) {
+            return;
+        }
+        node.mesh.attribute.resource = node.index;
+    }
+    /**
+     * Update featureCount in node.mesh.geometry object by node id
+     * @param id - end-to-end index of the node
+     * @param featureCount - features count of the node
+     */
+    updateFeatureCountByNodeId(id, featureCount) {
+        const node = this.getNodeById(id);
+        if (!node.mesh) {
+            return;
+        }
+        node.mesh.geometry.featureCount = featureCount;
+    }
+    /**
+     * Update texelCountHint in node.mesh.material object by node id
+     * @param id - end-to-end index of the node
+     * @param texelCountHint - texelCountHint of particular node
+     */
+    updateTexelCountHintByNodeId(id, texelCountHint) {
+        const node = this.getNodeById(id);
+        if (!node.mesh || !node.mesh.material) {
+            return;
+        }
+        node.mesh.material.texelCountHint = texelCountHint;
+    }
+    /**
+     * Add a child id into the parent node.children array
+     * @param parentId - end-to-end parent node index
+     * @param childId - end-to-end child node index
+     */
+    addChildRelation(parentId, childId) {
+        if (parentId === null || parentId === undefined) {
+            return;
+        }
+        const parentNode = this.getNodeById(parentId);
+        parentNode.children?.push(childId);
+    }
+    /**
+     * Update resource index in node.mesh object
+     * @param node - node object
+     */
+    updateResourceInMesh(node) {
+        if (node.mesh) {
+            node.mesh.geometry.resource = node.index;
+        }
+    }
+    /**
+     * Put new node in nodePages array
+     * @param node - node object
+     * @param parentId - index of parent node
+     * @return
+     */
+    push(node, parentId) {
+        let currentNodePage = this.nodePages[this.nodePages.length - 1];
+        if (currentNodePage.nodes.length === this.nodesPerPage) {
+            currentNodePage = { nodes: [] };
+            this.nodePages.push(currentNodePage);
+        }
+        node.index = this.nodesCounter++;
+        currentNodePage.nodes.push(node);
+        this.addChildRelation(parentId, node.index);
+        this.updateResourceInMesh(node);
+        return node.index;
+    }
+    /**
+     * Save all the node pages
+     * Run this method when all nodes is pushed in nodePages
+     * @param layers0Path - path of layer
+     * @param writeQueue - write queue that controlls files write concurrency
+     * @param slpk
+     */
+    async save(layers0Path, writeQueue, slpk = false) {
+        if (slpk) {
+            for (const [index, nodePage] of this.nodePages.entries()) {
+                const nodePageStr = JSON.stringify(nodePage);
+                const slpkPath = (0, path_1.join)(layers0Path, 'nodepages');
+                writeQueue.enqueue({
+                    archiveKey: `nodePages/${index.toString()}.json.gz`,
+                    writePromise: this.writeFile(slpkPath, nodePageStr, `${index.toString()}.json`)
+                });
+            }
+            const metadata = (0, json_map_transform_1.default)({ nodeCount: this.nodesCounter }, (0, metadata_1.METADATA)());
+            const compress = false;
+            writeQueue.enqueue({
+                archiveKey: 'metadata.json',
+                writePromise: this.writeFile(layers0Path, JSON.stringify(metadata), 'metadata.json', compress)
+            });
+        }
+        else {
+            for (const [index, nodePage] of this.nodePages.entries()) {
+                const nodePageStr = JSON.stringify(nodePage);
+                const nodePagePath = (0, path_1.join)(layers0Path, 'nodepages', index.toString());
+                writeQueue.enqueue({ writePromise: this.writeFile(nodePagePath, nodePageStr) });
+            }
+        }
+    }
+}
+exports.default = NodePages;