@loaders.gl/tile-converter 3.1.0-beta.7 → 3.1.3

package/src/i3s-converter/helpers/coordinate-converter.ts

@@ -2,9 +2,13 @@ import type {BoundingVolumes, Extent, Mbs, Obb} from '@loaders.gl/i3s';
 
 import {Matrix3, Quaternion, Vector3} from '@math.gl/core';
 import {Ellipsoid} from '@math.gl/geospatial';
-import {OrientedBoundingBox} from '@math.gl/culling';
+import {
+  OrientedBoundingBox,
+  makeOrientedBoundingBoxFromPoints,
+  makeBoundingSphereFromPoints
+} from '@math.gl/culling';
 import TileHeader from '@loaders.gl/tiles/src/tileset/tile-3d';
-import {GeoidHeightModel} from '../../lib/geoid-height-model';
+import {Geoid} from '@math.gl/geoid';
 import {Tileset3D} from '@loaders.gl/tiles';
 
 /**
@@ -13,10 +17,7 @@ import {Tileset3D} from '@loaders.gl/tiles';
  * @param geoidHeightModel
  * @returns - Bounding volumes object
  */
-export function createBoundingVolumes(
-  tile: TileHeader,
-  geoidHeightModel: GeoidHeightModel
-): BoundingVolumes {
+export function createBoundingVolumes(tile: TileHeader, geoidHeightModel: Geoid): BoundingVolumes {
   let radius;
   let halfSize;
   let quaternion;
@@ -51,14 +52,66 @@ export function createBoundingVolumes(
   };
 }
 
+/**
+ * Generates bounding volumes from geometry positions
+ * @param cartesianPositions
+ * @param geoidHeightModel
+ */
+export function createBoundingVolumesFromGeometry(
+  cartesianPositions: Float32Array,
+  geoidHeightModel: Geoid
+): {mbs: Mbs; obb: Obb} {
+  const positionVectors = convertPositionsToVectors(cartesianPositions);
+
+  const geometryObb = makeOrientedBoundingBoxFromPoints(positionVectors);
+  const geometryMbs = makeBoundingSphereFromPoints(positionVectors);
+
+  let mbsCenter = Ellipsoid.WGS84.cartesianToCartographic(geometryMbs.center, new Vector3());
+  let obbCenter = Ellipsoid.WGS84.cartesianToCartographic(geometryObb.center, new Vector3());
+
+  mbsCenter[2] = mbsCenter[2] - geoidHeightModel.getHeight(mbsCenter[1], mbsCenter[0]);
+  obbCenter[2] = obbCenter[2] - geoidHeightModel.getHeight(obbCenter[1], obbCenter[0]);
+
+  return {
+    mbs: [mbsCenter[0], mbsCenter[1], mbsCenter[2], geometryMbs.radius],
+    obb: {
+      center: obbCenter,
+      halfSize: geometryObb.halfSize,
+      quaternion: geometryObb.quaternion
+    }
+  };
+}
+
+/**
+ * Create array of posisitons where each vertex is vector
+ * @param {array} positions
+ * @returns {Vector3[]}
+ */
+export function convertPositionsToVectors(positions: Float32Array): Vector3[] {
+  const result: Vector3[] = [];
+
+  for (let i = 0; i < positions.length; i += 3) {
+    // TODO: (perf) new Vector3 is not optimal but required in `makeOrientedBoundingBoxFromPoints`.
+    // modify `makeOrientedBoundingBoxFromPoints` to use scratch vectors
+    const positionVector = new Vector3([positions[i], positions[i + 1], positions[i + 2]]);
+    result.push(positionVector);
+  }
+
+  return result;
+}
+
 /**
  * Convert common coordinate to extent coordinate
  * @param tileset
  * @returns - Extent
+ * @todo why lodMetricValue is radius? need to check this function
  */
-export function convertCommonToI3SExtentCoordinate(tileset: Tileset3D): Extent {
-  const cartesianCenter = tileset.cartesianCenter;
-  const radius = tileset.lodMetricValue;
+export function convertCommonToI3SExtentCoordinate(tileset: Tileset3D | null): Extent | null {
+  const cartesianCenter = tileset?.cartesianCenter;
+  if (!cartesianCenter) {
+    return null;
+  }
+  const radius = tileset?.lodMetricValue;
   const rightTop = Ellipsoid.WGS84.cartesianToCartographic(
     new Vector3(cartesianCenter[0] + radius, cartesianCenter[1] + radius, cartesianCenter[2]),
     new Vector3()

package/src/i3s-converter/helpers/{create-scene-server-path.js → create-scene-server-path.ts}

@@ -2,7 +2,7 @@ import {v4 as uuidv4} from 'uuid';
 import transform from 'json-map-transform';
 import {join} from 'path';
 
-import {SCENE_SERVER_TEMPLATE} from '../json-templates/scene-server';
+import {SCENE_SERVER as sceneServerTemplate} from '../json-templates/scene-server';
 import {writeFile} from '../../lib/utils/file-utils';
 
 /**
@@ -19,7 +19,7 @@ export async function createSceneServerPath(layerName, layers0, rootPath) {
     layers0
   };
 
-  const sceneServer = transform(sceneServerData, SCENE_SERVER_TEMPLATE);
+  const sceneServer = transform(sceneServerData, sceneServerTemplate());
   const nodePagePath = join(rootPath, 'SceneServer');
   await writeFile(nodePagePath, JSON.stringify(sceneServer));
 }

package/src/i3s-converter/helpers/{geometry-attributes.js → geometry-attributes.ts}

@@ -41,8 +41,8 @@ function calculateFaceRangesAndFeaturesCount(featureIndices) {
   let rangeIndex = 1;
   let featureIndex = 1;
   let currentFeatureId = featureIndices[0];
-  const faceRangeList = [];
-  const featureIds = [];
+  const faceRangeList: any[] = [];
+  const featureIds: any[] = [];
   const uniqueFeatureIds = [currentFeatureId];
 
   faceRangeList[0] = 0;
@@ -79,7 +79,7 @@ function calculateFaceRangesAndFeaturesCount(featureIndices) {
  */
 function makeAttributeObjects(attributes) {
   const {featureIds, positions, normals, colors, texCoords, faceRange} = attributes;
-  const groupedData = [];
+  const groupedData: any[] = [];
 
   let positionsList = new Float32Array(positions);
   let normalsList = new Float32Array(normals);
@@ -149,7 +149,7 @@ function getSliceAttributeCount(attributeName, startIndex, endIndex) {
  * @returns {Array} - unique list of objects
  */
 function unifyObjectsByFeatureId(sortedData) {
-  const uniqueObjects = [];
+  const uniqueObjects: any[] = [];
 
   for (let index = 0; index < sortedData.length; index++) {
     const currentObject = sortedData[index];

package/src/i3s-converter/helpers/geometry-converter.d.ts

@@ -1,4 +1,5 @@
 import {Vector3, Matrix4} from '@math.gl/core';
+import {GeoidHeightModel} from '../../lib/geoid-height-model';
 /**
  * Convert binary data from b3dm file to i3s resources
  *
@@ -25,7 +26,9 @@ export default function convertB3dmToI3sGeometry(
   nodeId: number,
   featuresHashArray: any,
   attributeStorageInfo: any,
-  draco: boolean
+  draco: boolean,
+  generateBoundingVolumes: boolean,
+  geoidHeightModel: GeoidHeightModel
 ): Promise<
   {
     geometry: ArrayBuffer;
@@ -36,5 +39,6 @@ export default function convertB3dmToI3sGeometry(
     vertexCount: number;
     attributes: any;
     featureCount: number;
+    boundingVolumes: any;
   }[]
 >;

package/src/i3s-converter/helpers/geometry-converter.js

@@ -6,6 +6,7 @@ import {encode, assert} from '@loaders.gl/core';
 import {concatenateArrayBuffers, concatenateTypedArrays} from '@loaders.gl/loader-utils';
 import md5 from 'md5';
 import {generateAttributes} from './geometry-attributes';
+import {createBoundingVolumesFromGeometry} from './coordinate-converter';
 
 const VALUES_PER_VERTEX = 3;
 const VALUES_PER_TEX_COORD = 2;
@@ -22,15 +23,24 @@ const OBJECT_ID_TYPE = 'Oid32';
  */
 const BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES = ['CUSTOM_ATTRIBUTE_2', '_BATCHID', 'BATCHID'];
 
+let scratchVector = new Vector3();
+
 export default async function convertB3dmToI3sGeometry(
   tileContent,
   nodeId,
   featuresHashArray,
   attributeStorageInfo,
-  draco
+  draco,
+  generateBoundingVolumes,
+  geoidHeightModel
 ) {
+  const useCartesianPositions = generateBoundingVolumes;
   const materialAndTextureList = convertMaterials(tileContent);
-  const convertedAttributesMap = convertAttributes(tileContent);
+  const convertedAttributesMap = convertAttributes(tileContent, useCartesianPositions);
+
+  if (generateBoundingVolumes) {
+    _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeightModel);
+  }
 
   if (convertedAttributesMap.has('default')) {
     materialAndTextureList.push({
@@ -41,7 +51,7 @@ export default async function convertB3dmToI3sGeometry(
   const result = [];
   let nodesCounter = nodeId;
   let {materials = []} = tileContent.gltf;
-  if (!materials.length === 0) {
+  if (!materials?.length) {
     materials.push({id: 'default'});
   }
   for (let i = 0; i < materials.length; i++) {
@@ -72,6 +82,32 @@ export default async function convertB3dmToI3sGeometry(
   return result;
 }
 
+/**
+ * Create bounding volumes based on positions
+ * @param convertedAttributesMap
+ * @param geoidHeightModel
+ */
+function _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeightModel) {
+  for (const attributes of convertedAttributesMap.values()) {
+    const boundingVolumes = createBoundingVolumesFromGeometry(
+      attributes.positions,
+      geoidHeightModel
+    );
+
+    attributes.boundingVolumes = boundingVolumes;
+    const cartographicOrigin = boundingVolumes.obb.center;
+
+    for (let index = 0; index < attributes.positions.length; index += VALUES_PER_VERTEX) {
+      const vertex = attributes.positions.subarray(index, index + VALUES_PER_VERTEX);
+      Ellipsoid.WGS84.cartesianToCartographic(Array.from(vertex), scratchVector);
+      scratchVector[2] =
+        scratchVector[2] - geoidHeightModel.getHeight(scratchVector[1], scratchVector[0]);
+      scratchVector = scratchVector.subtract(cartographicOrigin);
+      attributes.positions.set(scratchVector, index);
+    }
+  }
+}
+
 async function _makeNodeResources({
   convertedAttributes,
   material,
@@ -82,6 +118,7 @@ async function _makeNodeResources({
   attributeStorageInfo,
   draco
 }) {
+  const boundingVolumes = convertedAttributes.boundingVolumes;
   const vertexCount = convertedAttributes.positions.length / VALUES_PER_VERTEX;
   const triangleCount = vertexCount / 3;
   const {faceRange, featureIds, positions, normals, colors, texCoords, featureCount} =
@@ -136,7 +173,8 @@ async function _makeNodeResources({
     meshMaterial: material,
     vertexCount,
     attributes,
-    featureCount
+    featureCount,
+    boundingVolumes
   };
 }
 
@@ -152,7 +190,7 @@ async function _makeNodeResources({
  * }>
  * @todo implement colors support (if applicable for gltf format)
  */
-function convertAttributes(tileContent) {
+function convertAttributes(tileContent, useCartesianPositions) {
   const attributesMap = new Map();
 
   for (const material of tileContent.gltf.materials || [{id: 'default'}]) {
@@ -161,12 +199,13 @@ function convertAttributes(tileContent) {
       normals: new Float32Array(0),
       texCoords: new Float32Array(0),
       colors: new Uint8Array(0),
-      featureIndices: []
+      featureIndices: [],
+      boundingVolumes: null
     });
   }
 
   const nodes = (tileContent.gltf.scene || tileContent.gltf.scenes?.[0] || tileContent.gltf).nodes;
-  convertNodes(nodes, tileContent, attributesMap);
+  convertNodes(nodes, tileContent, attributesMap, useCartesianPositions);
 
   for (const attrKey of attributesMap.keys()) {
     const attributes = attributesMap.get(attrKey);
@@ -194,11 +233,12 @@ function convertNodes(
   nodes,
   tileContent,
   attributesMap,
+  useCartesianPositions,
   matrix = new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
 ) {
   if (nodes) {
     for (const node of nodes) {
-      convertNode(node, tileContent, attributesMap, matrix);
+      convertNode(node, tileContent, attributesMap, useCartesianPositions, matrix);
     }
   }
 }
@@ -216,6 +256,7 @@ function convertNode(
   node,
   tileContent,
   attributesMap,
+  useCartesianPositions,
   matrix = new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
 ) {
   const nodeMatrix = node.matrix;
@@ -223,10 +264,10 @@ function convertNode(
 
   const mesh = node.mesh;
   if (mesh) {
-    convertMesh(mesh, tileContent, attributesMap, compositeMatrix);
+    convertMesh(mesh, tileContent, attributesMap, useCartesianPositions, compositeMatrix);
   }
 
-  convertNodes(node.children, tileContent, attributesMap, compositeMatrix);
+  convertNodes(node.children, tileContent, attributesMap, useCartesianPositions, compositeMatrix);
 }
 
 /**
@@ -242,6 +283,7 @@ function convertMesh(
   mesh,
   content,
   attributesMap,
+  useCartesianPositions = false,
   matrix = new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
 ) {
   for (const primitive of mesh.primitives) {
@@ -262,7 +304,8 @@ function convertMesh(
         cartesianModelMatrix: content.cartesianModelMatrix,
         nodeMatrix: matrix,
         indices: primitive.indices.value,
-        attributeSpecificTransformation: transformVertexPositions
+        attributeSpecificTransformation: transformVertexPositions,
+        useCartesianPositions
       })
     );
     outputAttributes.normals = concatenateTypedArrays(
@@ -273,7 +316,8 @@ function convertMesh(
         cartesianModelMatrix: content.cartesianModelMatrix,
         nodeMatrix: matrix,
         indices: primitive.indices.value,
-        attributeSpecificTransformation: transformVertexNormals
+        attributeSpecificTransformation: transformVertexNormals,
+        useCartesianPositions: false
       })
     );
     outputAttributes.texCoords = concatenateTypedArrays(
@@ -304,6 +348,7 @@ function convertMesh(
  * @param {Matrix4} args.nodeMatrix - a gltf node transformation matrix - cumulative transformation matrix formed from all parent node matrices
  * @param {Uint8Array} args.indices - gltf primitive indices
  * @param {Function} args.attributeSpecificTransformation - function to do attribute - specific transformations
+ * @param {Boolean} args.useCartesianPositions - use coordinates as it is.
  * @returns {Float32Array}
  */
 function transformVertexArray(args) {
@@ -327,13 +372,18 @@ function transformVertexArray(args) {
 }
 
 function transformVertexPositions(vertexVector, calleeArgs) {
-  const {cartesianModelMatrix, cartographicOrigin, nodeMatrix} = calleeArgs;
+  const {cartesianModelMatrix, cartographicOrigin, nodeMatrix, useCartesianPositions} = calleeArgs;
 
   if (nodeMatrix) {
     vertexVector = vertexVector.transform(nodeMatrix);
   }
 
   vertexVector = vertexVector.transform(cartesianModelMatrix);
+
+  if (useCartesianPositions) {
+    return vertexVector;
+  }
+
   Ellipsoid.WGS84.cartesianToCartographic(
     [vertexVector[0], vertexVector[1], vertexVector[2]],
     vertexVector

package/src/i3s-converter/helpers/{node-debug.js → node-debug.ts}

@@ -6,7 +6,7 @@ import {Ellipsoid} from '@math.gl/geospatial';
 // TODO Unite Tile validation logic in i3s-17-and-debug with this code.
 export function validateNodeBoundingVolumes(node) {
   if (!node.parentNode.obb || !node.parentNode.mbs) {
-    return null;
+    return [];
   }
   const tileWarnings = [];
 
@@ -53,7 +53,7 @@ function createBoundingBoxFromTileObb(obb) {
 function getTileObbVertices(node) {
   const geometry = new CubeGeometry();
   const halfSize = node.obb.halfSize;
-  const {attributes} = geometry;
+  const attributes = geometry.getAttributes();
   const positions = new Float32Array(attributes.POSITION.value);
   const obbCenterCartesian = Ellipsoid.WGS84.cartographicToCartesian(node.obb.center);
 
@@ -68,6 +68,7 @@ function getTileObbVertices(node) {
     const rotatedPositions = positionsVector
       .transformByQuaternion(node.obb.quaternion)
       .add(obbCenterCartesian);
+    // @ts-expect-error
     vertices = vertices.concat(rotatedPositions);
   }
 

package/src/i3s-converter/helpers/{node-pages.js → node-pages.ts}

@@ -1,7 +1,9 @@
 import {join} from 'path';
 import transform from 'json-map-transform';
 import {METADATA as metadataTemplate} from '../json-templates/metadata';
+import {NodeInPage} from '@loaders.gl/i3s';
 
+// @ts-nocheck
 /**
  * class NodePages - wrapper of nodePages array
  *
@@ -35,6 +37,11 @@ import {METADATA as metadataTemplate} from '../json-templates/metadata';
  * 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.
@@ -44,21 +51,26 @@ export default class NodePages {
   constructor(writeFileFunc, nodesPerPage) {
     this.nodesPerPage = nodesPerPage;
     this.nodesCounter = 0;
+    // @ts-expect-error
     this.nodePages = [{}];
     this.nodePages[0].nodes = [];
     this.writeFile = writeFileFunc;
   }
 
-  useWriteFunction(func) {
+  /**
+   * Setup function to save node pages
+   * @param func - function which should be used to save node pages
+   */
+  useWriteFunction(func: Function): void {
     this.writeFile = func;
   }
 
   /**
    * Get the node by its end-to-end index
-   * @param {number} id - end-to-end index of the node
-   * @return {object} the node object
+   * @param id - end-to-end index of the node
+   * @return the node object
    */
-  getNodeById(id) {
+  getNodeById(id: number): NodeInPage {
     const pageIndex = Math.floor(id / this.nodesPerPage);
     const nodeIndex = id % this.nodesPerPage;
     return this.nodePages[pageIndex].nodes[nodeIndex];
@@ -69,7 +81,7 @@ export default class NodePages {
    * @param id - end-to-end index of the node
    * @param materialId - id from scene layer materialDefinitions
    */
-  updateMaterialByNodeId(id, materialId) {
+  updateMaterialByNodeId(id: number, materialId: number): void {
     const node = this.getNodeById(id);
     if (!node.mesh) {
       return;
@@ -85,7 +97,7 @@ export default class NodePages {
    * @param id - end-to-end index of the node
    * @param vertexCount - vertex count for particular node
    */
-  updateVertexCountByNodeId(id, vertexCount) {
+  updateVertexCountByNodeId(id: number, vertexCount: number): void {
     const node = this.getNodeById(id);
     if (!node.mesh) {
       return;
@@ -97,7 +109,7 @@ export default class NodePages {
    * Update resource in node.mesh.attribute object by node id
    * @param id - end-to-end index of the node
    */
-  updateNodeAttributeByNodeId(id) {
+  updateNodeAttributeByNodeId(id: number): void {
     const node = this.getNodeById(id);
     if (!node.mesh) {
       return;
@@ -110,7 +122,7 @@ export default class NodePages {
    * @param id - end-to-end index of the node
    * @param featureCount - features count of the node
    */
-  updateFeatureCountByNodeId(id, featureCount) {
+  updateFeatureCountByNodeId(id: number, featureCount: number): void {
     const node = this.getNodeById(id);
     if (!node.mesh) {
       return;
@@ -118,7 +130,12 @@ export default class NodePages {
     node.mesh.geometry.featureCount = featureCount;
   }
 
-  updateTexelCountHintByNodeId(id, texelCountHint) {
+  /**
+   * 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 {
     const node = this.getNodeById(id);
     if (!node.mesh || !node.mesh.material) {
       return;
@@ -128,24 +145,22 @@ export default class NodePages {
 
   /**
    * Add a child id into the parent node.children array
-   * @param {number | null} parentId - end-to-end parent node index
-   * @param {number} childId - end-to-end child node index
-   * @return {void}
+   * @param parentId - end-to-end parent node index
+   * @param childId - end-to-end child node index
    */
-  addChildRelation(parentId, childId) {
-    if (parentId === null) {
+  addChildRelation(parentId: number | undefined, childId: number): void {
+    if (parentId === null || parentId === undefined) {
       return;
     }
     const parentNode = this.getNodeById(parentId);
-    parentNode.children.push(childId);
+    parentNode.children?.push(childId);
   }
 
   /**
    * Update resource index in node.mesh object
-   * @param {object} node - node object
-   * @return {void}
+   * @param node - node object
    */
-  updateResourceInMesh(node) {
+  updateResourceInMesh(node: NodeInPage): void {
     if (node.mesh) {
       node.mesh.geometry.resource = node.index;
     }
@@ -153,11 +168,11 @@ export default class NodePages {
 
   /**
    * Put new node in nodePages array
-   * @param {object} node - node object
-   * @param {number | null} parentId - index of parent node
-   * @return {number}
+   * @param node - node object
+   * @param parentId - index of parent node
+   * @return
    */
-  push(node, parentId = null) {
+  push(node: NodeInPage, parentId?: number): number {
     let currentNodePage = this.nodePages[this.nodePages.length - 1];
     if (currentNodePage.nodes.length === this.nodesPerPage) {
       currentNodePage = {nodes: []};
@@ -174,12 +189,12 @@ export default class NodePages {
    * Save all the node pages
    * Run this method when all nodes is pushed in nodePages
    * @param {string} layers0Path - path of layer
-   * @param {Object} fileMap
+   * @param {Object} fileMap - fileMap which keep info for slpk archive
    * @param {boolean} slpk
    * @return {promise}
    */
-  async save(layers0Path, fileMap, slpk = false) {
-    const promises = [];
+  async save(layers0Path: string, fileMap: Object, slpk: boolean = false): Promise<void> {
+    const promises: Promise<any>[] = [];
     if (slpk) {
       for (const [index, nodePage] of this.nodePages.entries()) {
         const nodePageStr = JSON.stringify(nodePage);
@@ -187,7 +202,7 @@ export default class NodePages {
         promises.push(this.writeFile(slpkPath, nodePageStr, `${index.toString()}.json`));
         fileMap[`nodePages/${index.toString()}.json.gz`] = `${slpkPath}.json.gz`;
       }
-      const metadata = transform({nodeCount: this.nodesCounter}, metadataTemplate);
+      const metadata = transform({nodeCount: this.nodesCounter}, metadataTemplate());
       const compress = false;
       fileMap['metadata.json'] = await this.writeFile(
         layers0Path,