@loaders.gl/tile-converter 3.4.6 → 4.0.0-alpha.10

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

@@ -1,33 +1,27 @@
-import type {B3DMContent} from '@loaders.gl/3d-tiles';
+import type {Tiles3DTileContent} from '@loaders.gl/3d-tiles';
 import type {GLTFAccessorPostprocessed, GLTFNodePostprocessed} from '@loaders.gl/gltf';
 import type {B3DMAttributesData} from '../../i3s-attributes-worker';
+import {Matrix4, Vector3} from '@math.gl/core';
+import {BoundingSphere, OrientedBoundingBox} from '@math.gl/culling';
+import {Ellipsoid} from '@math.gl/geospatial';
 
 type AttributesObject = {
   [k: string]: GLTFAccessorPostprocessed;
 };
 
-/**
- * Keep only values for B3DM attributes to pass data to worker thread.
- * @param attributes
- */
-function getB3DMAttributesWithoutBufferView(attributes: AttributesObject): AttributesObject {
-  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
+ * @param tileContent - 3DTiles tile content
+ * @param tileTransform - transformation matrix of the tile, calculated recursively multiplying
+ *                        transform of all parent tiles and transform of the current tile
+ * @param boundingVolume - initialized bounding volume of the source tile
  * @returns
  */
-export function prepareDataForAttributesConversion(tileContent: B3DMContent): B3DMAttributesData {
+export function prepareDataForAttributesConversion(
+  tileContent: Tiles3DTileContent,
+  tileTransform: Matrix4,
+  boundingVolume: OrientedBoundingBox | BoundingSphere
+): B3DMAttributesData {
   let nodes =
     tileContent.gltf?.scene?.nodes ||
     tileContent.gltf?.scenes?.[0]?.nodes ||
@@ -38,10 +32,7 @@ export function prepareDataForAttributesConversion(tileContent: B3DMContent): B3
     tileContent.gltf?.images?.map((imageObject) => {
       // Need data only for uncompressed images because we can't get batchIds from compressed textures.
       if (imageObject?.image?.compressed) {
-        return {
-          data: null,
-          compressed: true
-        };
+        return null;
       } else {
         const data = imageObject?.image?.data;
         const dataCopy = new Uint8Array(data.length);
@@ -59,8 +50,11 @@ export function prepareDataForAttributesConversion(tileContent: B3DMContent): B3
 
   prepareNodes(nodes);
 
-  const cartographicOrigin = tileContent.cartographicOrigin;
-  const cartesianModelMatrix = tileContent.cartesianModelMatrix;
+  const {cartographicOrigin, modelMatrix: cartesianModelMatrix} = calculateTransformProps(
+    tileContent,
+    tileTransform,
+    boundingVolume
+  );
 
   return {
     nodes,
@@ -70,6 +64,72 @@ export function prepareDataForAttributesConversion(tileContent: B3DMContent): B3
   };
 }
 
+/**
+ * Keep only values for glTF attributes to pass data to worker thread.
+ * @param attributes - geometry attributes
+ */
+function getB3DMAttributesWithoutBufferView(attributes: AttributesObject): AttributesObject {
+  const attributesWithoutBufferView = {};
+
+  for (const attributeName in attributes) {
+    attributesWithoutBufferView[attributeName] = {
+      value: attributes[attributeName].value
+    };
+  }
+
+  return attributesWithoutBufferView;
+}
+
+/**
+ * Calculate transformation properties to transform vertex attributes (POSITION, NORMAL, etc.)
+ * from METER_OFFSET coorditantes to LNGLAT_OFFSET coordinates
+ * @param tileContent - 3DTiles tile content
+ * @param tileTransform - transformation matrix of the tile, calculated recursively multiplying
+ *                        transform of all parent tiles and transform of the current tile
+ * @param boundingVolume - initialized bounding volume of the source tile
+ * @returns modelMatrix - transformation matrix to transform coordinates to cartographic coordinates
+ *          cartographicOrigin - tile origin coordinates to calculate offsets
+ */
+export function calculateTransformProps(
+  tileContent: Tiles3DTileContent,
+  tileTransform: Matrix4,
+  boundingVolume: OrientedBoundingBox | BoundingSphere
+): {modelMatrix: Matrix4; cartographicOrigin: Vector3} {
+  const {rtcCenter, gltfUpAxis} = tileContent;
+  const {center} = boundingVolume;
+
+  let modelMatrix = new Matrix4(tileTransform);
+
+  // Translate if appropriate
+  if (rtcCenter) {
+    modelMatrix.translate(rtcCenter);
+  }
+
+  // glTF models need to be rotated from Y to Z up
+  // https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/specification#y-up-to-z-up
+  switch (gltfUpAxis) {
+    case 'Z':
+      break;
+    case 'Y':
+      const rotationY = new Matrix4().rotateX(Math.PI / 2);
+      modelMatrix = modelMatrix.multiplyRight(rotationY);
+      break;
+    case 'X':
+      const rotationX = new Matrix4().rotateY(-Math.PI / 2);
+      modelMatrix = modelMatrix.multiplyRight(rotationX);
+      break;
+    default:
+      break;
+  }
+
+  const cartesianOrigin = new Vector3(center);
+  const cartographicOrigin = Ellipsoid.WGS84.cartesianToCartographic(
+    cartesianOrigin,
+    new Vector3()
+  );
+  return {modelMatrix, cartographicOrigin};
+}
+
 /**
  * Traverse all nodes to replace all sensible data with copy to avoid data corruption in worker.
  * @param nodes

package/src/i3s-converter/helpers/load-3d-tiles.ts

@@ -0,0 +1,68 @@
+import type {
+  Tiles3DLoaderOptions,
+  Tiles3DTileContent,
+  Tiles3DTileJSONPostprocessed,
+  Tiles3DTilesetJSONPostprocessed
+} from '@loaders.gl/3d-tiles';
+import {load} from '@loaders.gl/core';
+
+/**
+ * Load nested 3DTiles tileset. If the sourceTile is not nested tileset - do nothing
+ * @param sourceTileset - source root tileset JSON
+ * @param sourceTile - source tile JSON that is supposed to has link to nested tileset
+ * @param tilesetLoadOptions - load options for Tiles3DLoader
+ * @returns nothing
+ */
+export const loadNestedTileset = async (
+  sourceTileset: Tiles3DTilesetJSONPostprocessed | null,
+  sourceTile: Tiles3DTileJSONPostprocessed,
+  tilesetLoadOptions: Tiles3DLoaderOptions
+): Promise<void> => {
+  const isTileset = sourceTile.type === 'json';
+  if (!sourceTileset || !sourceTile.contentUrl || !isTileset) {
+    return;
+  }
+
+  const loadOptions = {
+    ...tilesetLoadOptions,
+    [sourceTileset.loader.id]: {
+      isTileset,
+      assetGltfUpAxis: (sourceTileset.asset && sourceTileset.asset.gltfUpAxis) || 'Y'
+    }
+  };
+  const tileContent = await load(sourceTile.contentUrl, sourceTileset.loader, loadOptions);
+
+  if (tileContent.root) {
+    sourceTile.children = [tileContent.root];
+  }
+};
+
+/**
+ * Load 3DTiles tile content, that includes glTF object
+ * @param sourceTileset - source root tileset JSON
+ * @param sourceTile - source tile JSON that has link to content data
+ * @param tilesetLoadOptions - load options for Tiles3DLoader
+ * @returns - 3DTiles tile content or null
+ */
+export const loadTile3DContent = async (
+  sourceTileset: Tiles3DTilesetJSONPostprocessed | null,
+  sourceTile: Tiles3DTileJSONPostprocessed,
+  tilesetLoadOptions: Tiles3DLoaderOptions
+): Promise<Tiles3DTileContent | null> => {
+  const isTileset = sourceTile.type === 'json';
+  if (!sourceTileset || !sourceTile.contentUrl || isTileset) {
+    return null;
+  }
+
+  const loadOptions = {
+    ...tilesetLoadOptions,
+    [sourceTileset.loader.id]: {
+      ...(tilesetLoadOptions[sourceTileset.loader.id] || {}),
+      isTileset,
+      assetGltfUpAxis: (sourceTileset.asset && sourceTileset.asset.gltfUpAxis) || 'Y'
+    }
+  };
+  const tileContent = await load(sourceTile.contentUrl, sourceTileset.loader, loadOptions);
+
+  return tileContent;
+};

package/src/i3s-converter/helpers/node-index-document.ts

@@ -31,6 +31,15 @@ export class NodeIndexDocument {
   /** converter instance */
   private converter: I3SConverter;
 
+  /**
+   * Finalized property. It means that all child nodes are saved and their data
+   * is unloaded
+   */
+  private _finalized: boolean = false;
+  get finalized(): boolean {
+    return this._finalized;
+  }
+
   /**
    * Constructor
    * @param id - id of the node in node pages
@@ -90,6 +99,9 @@ export class NodeIndexDocument {
    * Add neighbors to child nodes of this node
    */
   public async addNeighbors(): Promise<void> {
+    if (this.finalized) {
+      return;
+    }
     const nodeData = await this.load();
     for (const childNode of this.children) {
       const childNodeData = await childNode.load();
@@ -116,9 +128,9 @@ export class NodeIndexDocument {
         await childNode.write(childNodeData);
       }
       await childNode.save();
-      // The save after adding neighbors is the last one. Flush the the node
-      childNode.flush();
     }
+    // The save after adding neighbors is the last one. Finalize the the node
+    this.finalize();
   }
 
   /** Save 3DNodeIndexDocument in file on disk */
@@ -128,6 +140,14 @@ export class NodeIndexDocument {
     }
   }
 
+  /** Finalize the node */
+  private finalize(): void {
+    this._finalized = true;
+    for (const child of this.children) {
+      child.flush();
+    }
+  }
+
   /**
    * Write 3DNodeIndexDocument https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DNodeIndexDocument.cmn.md
    * @param node - Node3DIndexDocument object

package/src/i3s-converter/helpers/preprocess-3d-tiles.ts

@@ -0,0 +1,81 @@
+import {Tiles3DTileContent, Tiles3DTileJSONPostprocessed} from '@loaders.gl/3d-tiles';
+import {GltfPrimitiveModeString, PreprocessData} from '../types';
+import {GLTF, GLTFLoader} from '@loaders.gl/gltf';
+import {parse} from '@loaders.gl/core';
+
+/**
+ * glTF primitive modes
+ * @see https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#_mesh_primitive_mode
+ */
+export const GLTF_PRIMITIVE_MODES = [
+  GltfPrimitiveModeString.POINTS, // 0
+  GltfPrimitiveModeString.LINES, // 1
+  GltfPrimitiveModeString.LINE_LOOP, // 2
+  GltfPrimitiveModeString.LINE_STRIP, // 3
+  GltfPrimitiveModeString.TRIANGLES, // 4
+  GltfPrimitiveModeString.TRIANGLE_STRIP, // 5
+  GltfPrimitiveModeString.TRIANGLE_FAN // 6
+];
+
+/**
+ * Analyze tile content. This function is used during preprocess stage of
+ * conversion
+ * @param tile - 3DTiles tile JSON metadata
+ * @param tileContent - 3DTiles tile content ArrayBuffer
+ * @returns
+ */
+export const analyzeTileContent = async (
+  tile: Tiles3DTileJSONPostprocessed,
+  tileContent: Tiles3DTileContent | null
+): Promise<PreprocessData> => {
+  const result: PreprocessData = {
+    meshTopologyTypes: new Set()
+  };
+  if (!tileContent?.gltfArrayBuffer) {
+    return result;
+  }
+
+  const gltfData = await parse(tileContent.gltfArrayBuffer, GLTFLoader, {
+    gltf: {normalize: false, loadBuffers: false, loadImages: false, decompressMeshes: false}
+  });
+  const gltf = gltfData.json;
+
+  if (!gltf) {
+    return result;
+  }
+  const meshTypes = getMeshTypesFromGltf(gltf);
+  result.meshTopologyTypes = meshTypes;
+  return result;
+};
+
+/**
+ * Get mesh topology types that the glb content has
+ * @param gltfJson - JSON part of GLB content
+ * @returns array of mesh types found
+ */
+const getMeshTypesFromGltf = (gltfJson: GLTF): Set<GltfPrimitiveModeString> => {
+  const result: Set<GltfPrimitiveModeString> = new Set();
+  for (const mesh of gltfJson.meshes || []) {
+    for (const primitive of mesh.primitives) {
+      let {mode} = primitive;
+      if (typeof mode !== 'number') {
+        mode = 4; // Default is 4 - TRIANGLES
+      }
+      result.add(GLTF_PRIMITIVE_MODES[mode]);
+    }
+  }
+  return result;
+};
+
+/**
+ * Merge object2 into object1
+ * @param object1
+ * @param object2
+ * @returns nothing
+ */
+export const mergePreprocessData = (object1: PreprocessData, object2: PreprocessData): void => {
+  // Merge topology mesh types info
+  for (const type of object2.meshTopologyTypes) {
+    object1.meshTopologyTypes.add(type);
+  }
+};

package/src/i3s-converter/helpers/tileset-traversal.ts

@@ -0,0 +1,51 @@
+import {Tiles3DTileJSONPostprocessed} from '@loaders.gl/3d-tiles';
+import {NodeIndexDocument} from './node-index-document';
+import {Matrix4} from '@math.gl/core';
+
+/** Traversal props for the conversion stage */
+export type TraversalConversionProps = {
+  /** Transformation matrix for the specific tile */
+  transform: Matrix4;
+  /** Parent nodes of the converted tile. Multiple nodes can be if one tile is converted to multiple nodes*/
+  parentNodes: NodeIndexDocument[];
+};
+
+/**
+ * Travesal of 3DTile tiles tree with making specific actions with each tile
+ * @param tile - 3DTiles tile JSON metadata
+ * @param traversalProps - traversal props used to pass data through recursive calls
+ * @param processTile - callback to make some actions with the current tile
+ * @param postprocessTile - callback to make some action after processing of the current tile and all the subtree
+ * @param maxDepth - max recursive calls number the travesal function will do. If not set, the traversal function will
+ *                   go through all the tree.
+ *                   This value is used to limit the convertion with only partial number of levels of the tileset
+ * @param level - counter to keep recursive calls number of the tiles tree. This value used to be able to break
+ *                traversal at the some level of the tree
+ * @returns void
+ */
+export const traverseDatasetWith = async <TProps>(
+  tile: Tiles3DTileJSONPostprocessed,
+  traversalProps: TProps,
+  processTile: (tile: Tiles3DTileJSONPostprocessed, traversalProps: TProps) => Promise<TProps>,
+  postprocessTile?: (processResults: TProps[], currentTraversalProps: TProps) => Promise<void>,
+  maxDepth?: number,
+  level = 0
+): Promise<void> => {
+  if (maxDepth && level > maxDepth) {
+    return;
+  }
+  const processResults: TProps[] = [];
+  const newTraversalProps: TProps = await processTile(tile, traversalProps);
+  processResults.push(newTraversalProps);
+  for (const childTile of tile.children) {
+    await traverseDatasetWith(
+      childTile,
+      newTraversalProps,
+      processTile,
+      postprocessTile,
+      maxDepth,
+      level + 1
+    );
+  }
+  postprocessTile && (await postprocessTile(processResults, traversalProps));
+};