@loaders.gl/tile-converter 3.1.1 → 3.1.5

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

@@ -1,3 +1,4 @@
+import type {GeometryAttributes, AttributesData, GroupedByFeatureIdAttributes} from '../types';
 import {concatenateTypedArrays} from '@loaders.gl/loader-utils';
 
 const VALUES_PER_VERTEX = 3;
@@ -5,10 +6,10 @@ const POSITIONS_AND_NORMALS_PER_TRIANGLE = 9;
 
 /**
  * Generate geometry attributes with faceRange and featureCount
- * @param {Object} attributes
- * @returns {Object} Object with featureCount, reordered attributes and changed faceRange.
+ * @param attributes
+ * @returns attirbutes with featureCount, featureIds and changed faceRange.
  */
-export function generateAttributes(attributes) {
+export function generateAttributes(attributes: AttributesData): GeometryAttributes {
   const {positions, normals, texCoords, colors, featureIndices, triangleCount} = attributes;
 
   if (!featureIndices.length) {
@@ -23,21 +24,26 @@ export function generateAttributes(attributes) {
     };
   }
 
-  const {faceRange, featureCount, featureIds} = calculateFaceRangesAndFeaturesCount(featureIndices);
-  const attributeObjects = makeAttributeObjects({faceRange, featureIds, ...attributes});
+  const data = calculateFaceRangesAndFeaturesCount(featureIndices);
+  const attributeObjects = makeAttributeObjects({...data, ...attributes});
   const unifiedAttributeObjectsByFeatureIds = unifyObjectsByFeatureId(attributeObjects);
   const groupedAttributes = groupAttributesAndRangesByFeatureId(
-    unifiedAttributeObjectsByFeatureIds
+    unifiedAttributeObjectsByFeatureIds,
+    data.featureCount
   );
-  return {featureCount, ...groupedAttributes};
+  return groupedAttributes;
 }
 
 /**
  * Calculates face Ranges and feature count based on featureIndices.
- * @param {Object} featureIndices
- * @returns {Object} Object with featureCount, reordered attributes and changed faceRange.
+ * @param featureIndices
+ * @returns Object with featureCount, reordered attributes and changed faceRange.
  */
-function calculateFaceRangesAndFeaturesCount(featureIndices) {
+function calculateFaceRangesAndFeaturesCount(featureIndices: number[]): {
+  faceRange: Uint32Array;
+  featureCount: number;
+  featureIds: number[];
+} {
   let rangeIndex = 1;
   let featureIndex = 1;
   let currentFeatureId = featureIndices[0];
@@ -74,12 +80,19 @@ function calculateFaceRangesAndFeaturesCount(featureIndices) {
 
 /**
  * Generate list of attribute object grouped by feature ids.
- * @param {Object} attributes
- * @returns {Array} sorted list of attribute objects.
+ * @param  attributes
+ * @returns sorted list of attribute objects.
  */
-function makeAttributeObjects(attributes) {
-  const {featureIds, positions, normals, colors, texCoords, faceRange} = attributes;
-  const groupedData: any[] = [];
+function makeAttributeObjects(attributes: GeometryAttributes): GroupedByFeatureIdAttributes[] {
+  const {
+    featureIds,
+    positions,
+    normals,
+    colors,
+    texCoords,
+    faceRange = new Uint32Array(0)
+  } = attributes;
+  const groupedData: GroupedByFeatureIdAttributes[] = [];
 
   let positionsList = new Float32Array(positions);
   let normalsList = new Float32Array(normals);
@@ -118,12 +131,16 @@ function makeAttributeObjects(attributes) {
 
 /**
  * Generate sliced count for generating attribute objects depends on attribute name and range.
- * @param {String} attributeName
- * @param {Number} startIndex
- * @param {Number} endIndex
- * @returns {Number} - sliced count
+ * @param attributeName
+ * @param startIndex
+ * @param endIndex
+ * @returns sliced count
  */
-function getSliceAttributeCount(attributeName, startIndex, endIndex) {
+function getSliceAttributeCount(
+  attributeName: string,
+  startIndex: number,
+  endIndex: number
+): number {
   const colorsPerVertex = 4;
   const texCoordsPerVertex = 2;
 
@@ -145,11 +162,13 @@ function getSliceAttributeCount(attributeName, startIndex, endIndex) {
 
 /**
  * Generates unique object list depends on feature ids and concantenate their attributes.
- * @param {Array} sortedData
- * @returns {Array} - unique list of objects
+ * @param sortedData
+ * @returns unique list of objects
  */
-function unifyObjectsByFeatureId(sortedData) {
-  const uniqueObjects: any[] = [];
+function unifyObjectsByFeatureId(
+  sortedData: GroupedByFeatureIdAttributes[]
+): GroupedByFeatureIdAttributes[] {
+  const uniqueObjects: GroupedByFeatureIdAttributes[] = [];
 
   for (let index = 0; index < sortedData.length; index++) {
     const currentObject = sortedData[index];
@@ -176,12 +195,15 @@ function unifyObjectsByFeatureId(sortedData) {
 
 /**
  * Generates attribute objects with new faceRange and reordered attributes.
- * @param {Array} unifiedObjects
- * @returns {Object} - ugenerated attributes with new faceRange.
+ * @param unifiedObjects
+ * @returns generated attributes with new faceRange.
  */
-function groupAttributesAndRangesByFeatureId(unifiedObjects) {
+function groupAttributesAndRangesByFeatureId(
+  unifiedObjects: GroupedByFeatureIdAttributes[],
+  featureCount: number
+): GeometryAttributes {
   const firstAttributeObject = unifiedObjects[0];
-  const featureIds = [firstAttributeObject.featureId];
+  const featureIds = [firstAttributeObject.featureId || 0];
 
   let positions = new Float32Array(firstAttributeObject.positions);
   let normals = new Float32Array(firstAttributeObject.normals);
@@ -194,7 +216,7 @@ function groupAttributesAndRangesByFeatureId(unifiedObjects) {
 
   for (let index = 1; index < unifiedObjects.length; index++) {
     const currentAttributesObject = unifiedObjects[index];
-    featureIds.push(currentAttributesObject.featureId);
+    featureIds.push(currentAttributesObject.featureId || 0);
 
     positions = concatenateTypedArrays(positions, currentAttributesObject.positions);
     normals = concatenateTypedArrays(normals, currentAttributesObject.normals);
@@ -212,5 +234,5 @@ function groupAttributesAndRangesByFeatureId(unifiedObjects) {
   range.push(positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1);
 
   const faceRange = new Uint32Array(range);
-  return {faceRange, featureIds, positions, normals, colors, texCoords};
+  return {faceRange, featureIds, positions, normals, colors, texCoords, featureCount};
 }

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

@@ -243,6 +243,36 @@ function convertNodes(
   }
 }
 
+/**
+ * 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
@@ -259,15 +289,20 @@ function convertNode(
   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, useCartesianPositions, compositeMatrix);
+    convertMesh(mesh, tileContent, attributesMap, useCartesianPositions, transformationMatrix);
   }
 
-  convertNodes(node.children, tileContent, attributesMap, useCartesianPositions, compositeMatrix);
+  convertNodes(
+    node.children,
+    tileContent,
+    attributesMap,
+    useCartesianPositions,
+    transformationMatrix
+  );
 }
 
 /**

package/src/i3s-converter/helpers/node-debug.ts

@@ -1,14 +1,23 @@
+import type {Mbs, Node3DIndexDocument, Obb} from '@loaders.gl/i3s';
+
 import {OrientedBoundingBox, BoundingSphere} from '@math.gl/culling';
 import {CubeGeometry} from '@luma.gl/engine';
 import {Vector3} from '@math.gl/core';
 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) {
+
+/**
+ * Do validation of bounding volumes for particular node.
+ * Generates special warnings if there are some issues.
+ * @param node
+ */
+export function validateNodeBoundingVolumes(node: Node3DIndexDocument): string[] {
+  if (!node?.parentNode?.obb || !node?.parentNode?.mbs) {
     return [];
   }
-  const tileWarnings = [];
+
+  const tileWarnings: string[] = [];
 
   validateObb(tileWarnings, node);
   validateMbs(tileWarnings, node);
@@ -16,7 +25,13 @@ export function validateNodeBoundingVolumes(node) {
   return tileWarnings;
 }
 
-function validateObb(tileWarnings, node) {
+/**
+ * Check if child Obb fit into parent Obb.
+ * @param tileWarnings
+ * @param node
+ */
+function validateObb(tileWarnings: string[], node: Node3DIndexDocument): void {
+  // @ts-expect-error
   const parentObb = createBoundingBoxFromTileObb(node.parentNode.obb);
   const tileVertices = getTileObbVertices(node);
   const isTileObbInsideParentObb = isAllVerticesInsideBoundingVolume(parentObb, tileVertices);
@@ -25,36 +40,58 @@ function validateObb(tileWarnings, node) {
     return;
   }
 
-  const title = `OBB of Tile (${node.id}) doesn't fit into Parent (${node.parentNode.id}) tile OBB`;
+  const title = `OBB of Tile (${node.id}) doesn't fit into Parent (${node.parentNode?.id}) tile OBB`;
   tileWarnings.push(title);
 }
 
-function validateMbs(tileWarnings, node) {
+/**
+ * Check if child Mbs fit into parent Mbs.
+ * @param tileWarnings
+ * @param node
+ */
+function validateMbs(tileWarnings: string[], node: Node3DIndexDocument): void {
+  // @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`;
+    const title = `MBS of Tile (${node.id}) doesn't fit into Parent (${node.parentNode?.id}) tile MBS`;
     tileWarnings.push(title);
   }
 }
 
-function createBoundingSphereFromTileMbs(mbs) {
+/**
+ * Generates bounding sphere from mbs
+ * @param mbs
+ */
+function createBoundingSphereFromTileMbs(mbs: Mbs): BoundingSphere {
   return new BoundingSphere([mbs[0], mbs[1], mbs[2]], mbs[3]);
 }
 
-function createBoundingBoxFromTileObb(obb) {
+/**
+ * Generates oriented bounding box from tile obb
+ * @param obb
+ * @returns
+ */
+function createBoundingBoxFromTileObb(obb: Obb): OrientedBoundingBox {
   const {center, halfSize, quaternion} = obb;
   return new OrientedBoundingBox().fromCenterHalfSizeQuaternion(center, halfSize, quaternion);
 }
 
-// TODO check if Obb generates properly
-function getTileObbVertices(node) {
+/**
+ * Get vertices fromnode obb
+ * TODO check if Obb generates properly
+ * @param node
+ */
+function getTileObbVertices(node: Node3DIndexDocument): number[] {
   const geometry = new 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 = Ellipsoid.WGS84.cartographicToCartesian(node.obb.center);
 
   let vertices = [];
@@ -66,6 +103,7 @@ function getTileObbVertices(node) {
       (positions[i + 2] *= halfSize[2])
     );
     const rotatedPositions = positionsVector
+      // @ts-expect-error
       .transformByQuaternion(node.obb.quaternion)
       .add(obbCenterCartesian);
     // @ts-expect-error
@@ -75,7 +113,15 @@ function getTileObbVertices(node) {
   return vertices;
 }
 
-function isAllVerticesInsideBoundingVolume(boundingVolume, positions) {
+/**
+ * Check if all vertices inside bounding volume
+ * @param boundingVolume
+ * @param positions
+ */
+function isAllVerticesInsideBoundingVolume(
+  boundingVolume: OrientedBoundingBox,
+  positions: number[]
+): boolean {
   let isVerticesInsideObb = true;
 
   for (let index = 0; index < positions.length / 3; index += 3) {

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

@@ -227,7 +227,7 @@ export default class I3SConverter {
 
     this.layers0!.materialDefinitions = this.materialDefinitions;
     await this._writeLayers0();
-    createSceneServerPath(tilesetName, this.layers0, tilesetPath);
+    createSceneServerPath(tilesetName, this.layers0!, tilesetPath);
     await this._writeNodeIndexDocument(root0, 'root', join(this.layers0Path, 'nodes', 'root'));
     await this.nodePages.save(this.layers0Path, this.fileMap, isCreateSlpk);
     await this._createSlpk(tilesetPath);
@@ -942,9 +942,6 @@ export default class I3SConverter {
     childPath: string,
     slpkChildPath: string
   ): Promise<void> {
-    const texturePath = join(childPath, `textures/${name}/`);
-    await writeFile(texturePath, textureData, `index.${format}`);
-
     if (this.options.slpk) {
       const slpkTexturePath = join(childPath, 'textures');
       const compress = false;
@@ -955,6 +952,9 @@ export default class I3SConverter {
         `${name}.${format}`,
         compress
       );
+    } else {
+      const texturePath = join(childPath, `textures/${name}/`);
+      await writeFile(texturePath, textureData, `index.${format}`);
     }
   }
 

package/src/i3s-converter/types.ts

@@ -12,3 +12,31 @@ export type I3SConvertedResources = {
   geometryBuffer?: ArrayBuffer;
   boundingVolumes: BoundingVolumes | null;
 };
+
+export type AttributesData = {
+  positions: Float32Array;
+  normals: Float32Array;
+  texCoords: Float32Array;
+  colors: Uint8Array;
+  featureIndices: number[];
+  triangleCount: number;
+  boundingVolumes?: BoundingVolumes | null;
+};
+
+export type GeometryAttributes = {
+  positions: Float32Array;
+  normals: Float32Array;
+  texCoords: Float32Array;
+  colors: Uint8Array;
+  faceRange: Uint32Array;
+  featureIds: number[];
+  featureCount: number;
+};
+
+export type GroupedByFeatureIdAttributes = {
+  featureId: number;
+  positions: Float32Array;
+  normals: Float32Array;
+  colors: Uint8Array;
+  texCoords: Float32Array;
+};