@loaders.gl/tile-converter 4.0.0-alpha.4 → 4.0.0-alpha.5

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);
@@ -174,19 +213,6 @@ function convertAttributes(tileContent) {
       attributesMap.delete(attrKey);
       continue; // eslint-disable-line no-continue
     }
-    const vertexCount = attributes.positions.length / VALUES_PER_VERTEX;
-    if (!attributes.colors.length) {
-      attributes.colors = new Uint8Array(vertexCount * VALUES_PER_COLOR_ELEMENT);
-      for (let index = 0; index < attributes.colors.length; index += 4) {
-        attributes.colors.set([255, 255, 255, 255], index);
-      }
-    }
-    if (!attributes.texCoords.length) {
-      attributes.texCoords = new Float32Array(vertexCount * VALUES_PER_TEX_COORD);
-      for (let index = 0; index < attributes.texCoords.length; index += 2) {
-        attributes.texCoords.set([1, 1], index);
-      }
-    }
     attributes.featureIndices = attributes.featureIndices.reduce((acc, value) => acc.concat(value));
   }
 
@@ -207,15 +233,46 @@ 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);
     }
   }
 }
 
+/**
+ * Generate transformation matrix for node
+ * Aapply all gltf transformations to initial transformation matrix.
+ * @param node
+ * @param matrix
+ */
+function getCompositeTransformationMatrix(node, matrix) {
+  let transformationMatrix = matrix;
+
+  const {matrix: nodeMatrix, rotation, scale, translation} = node;
+
+  if (nodeMatrix) {
+    transformationMatrix = matrix.multiplyRight(nodeMatrix);
+  }
+
+  if (rotation) {
+    transformationMatrix = transformationMatrix.rotateXYZ(rotation);
+  }
+
+  if (scale) {
+    transformationMatrix = transformationMatrix.scale(scale);
+  }
+
+  if (translation) {
+    transformationMatrix = transformationMatrix.translate(translation);
+  }
+
+  return transformationMatrix;
+}
+
 /**
  * Convert all primitives of node and all children nodes
  * @param {Object} node - gltf node
@@ -229,17 +286,23 @@ 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;
-  const compositeMatrix = nodeMatrix ? matrix.multiplyRight(nodeMatrix) : matrix;
+  const transformationMatrix = getCompositeTransformationMatrix(node, matrix);
 
   const mesh = node.mesh;
   if (mesh) {
-    convertMesh(mesh, tileContent, attributesMap, compositeMatrix);
+    convertMesh(mesh, tileContent, attributesMap, useCartesianPositions, transformationMatrix);
   }
 
-  convertNodes(node.children, tileContent, attributesMap, compositeMatrix);
+  convertNodes(
+    node.children,
+    tileContent,
+    attributesMap,
+    useCartesianPositions,
+    transformationMatrix
+  );
 }
 
 /**
@@ -255,6 +318,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) {
@@ -275,7 +339,8 @@ function convertMesh(
         cartesianModelMatrix: content.cartesianModelMatrix,
         nodeMatrix: matrix,
         indices: primitive.indices.value,
-        attributeSpecificTransformation: transformVertexPositions
+        attributeSpecificTransformation: transformVertexPositions,
+        useCartesianPositions
       })
     );
     outputAttributes.normals = concatenateTypedArrays(
@@ -286,7 +351,8 @@ function convertMesh(
         cartesianModelMatrix: content.cartesianModelMatrix,
         nodeMatrix: matrix,
         indices: primitive.indices.value,
-        attributeSpecificTransformation: transformVertexNormals
+        attributeSpecificTransformation: transformVertexNormals,
+        useCartesianPositions: false
       })
     );
     outputAttributes.texCoords = concatenateTypedArrays(
@@ -317,6 +383,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) {
@@ -340,13 +407,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
@@ -373,10 +445,13 @@ function transformVertexNormals(vertexVector, calleeArgs) {
  * @returns {Float32Array}
  */
 function flattenTexCoords(texCoords, indices) {
+  const newTexCoords = new Float32Array(indices.length * VALUES_PER_TEX_COORD);
   if (!texCoords) {
-    return new Float32Array(0);
+    // We need dummy UV0s because it is required in 1.6
+    // https://github.com/Esri/i3s-spec/blob/master/docs/1.6/vertexAttribute.cmn.md
+    newTexCoords.fill(1);
+    return newTexCoords;
   }
-  const newTexCoords = new Float32Array(indices.length * VALUES_PER_TEX_COORD);
   for (let i = 0; i < indices.length; i++) {
     const coordIndex = indices[i] * VALUES_PER_TEX_COORD;
     const texCoord = texCoords.subarray(coordIndex, coordIndex + VALUES_PER_TEX_COORD);
@@ -393,12 +468,14 @@ function flattenTexCoords(texCoords, indices) {
  * @returns {Uint8Array}
  */
 function flattenColors(colorsAttribute, indices) {
+  const components = colorsAttribute?.components || VALUES_PER_COLOR_ELEMENT;
+  const newColors = new Uint8Array(indices.length * components);
   if (!colorsAttribute) {
-    return new Uint8Array(0);
+    // Vertex color multiplies by material color so it must be normalized 1 by default
+    newColors.fill(255);
+    return newColors;
   }
-  const components = colorsAttribute.components;
   const colors = colorsAttribute.value;
-  const newColors = new Uint8Array(indices.length * components);
   for (let i = 0; i < indices.length; i++) {
     const colorIndex = indices[i] * components;
     const color = colors.subarray(colorIndex, colorIndex + components);

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,