@loaders.gl/tile-converter 4.0.0-alpha.22 → 4.0.0-alpha.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/tile-converter",
-  "version": "4.0.0-alpha.22",
+  "version": "4.0.0-alpha.24",
   "description": "Converter",
   "license": "MIT",
   "publishConfig": {
@@ -45,18 +45,18 @@
     "build-i3s-server-bundle": "esbuild src/i3s-server/bin/www.ts --outfile=dist/esm/i3s-server/bin/i3s-server.min.js --platform=node --target=esnext,node14 --external:join-images --minify --bundle --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/3d-tiles": "4.0.0-alpha.22",
-    "@loaders.gl/crypto": "4.0.0-alpha.22",
-    "@loaders.gl/draco": "4.0.0-alpha.22",
-    "@loaders.gl/gltf": "4.0.0-alpha.22",
-    "@loaders.gl/i3s": "4.0.0-alpha.22",
-    "@loaders.gl/images": "4.0.0-alpha.22",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.22",
-    "@loaders.gl/polyfills": "4.0.0-alpha.22",
-    "@loaders.gl/textures": "4.0.0-alpha.22",
-    "@loaders.gl/tiles": "4.0.0-alpha.22",
-    "@loaders.gl/worker-utils": "4.0.0-alpha.22",
-    "@loaders.gl/zip": "4.0.0-alpha.22",
+    "@loaders.gl/3d-tiles": "4.0.0-alpha.24",
+    "@loaders.gl/crypto": "4.0.0-alpha.24",
+    "@loaders.gl/draco": "4.0.0-alpha.24",
+    "@loaders.gl/gltf": "4.0.0-alpha.24",
+    "@loaders.gl/i3s": "4.0.0-alpha.24",
+    "@loaders.gl/images": "4.0.0-alpha.24",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.24",
+    "@loaders.gl/polyfills": "4.0.0-alpha.24",
+    "@loaders.gl/textures": "4.0.0-alpha.24",
+    "@loaders.gl/tiles": "4.0.0-alpha.24",
+    "@loaders.gl/worker-utils": "4.0.0-alpha.24",
+    "@loaders.gl/zip": "4.0.0-alpha.24",
     "@math.gl/core": "^3.5.1",
     "@math.gl/culling": "^3.5.1",
     "@math.gl/geoid": "^3.5.1",
@@ -80,7 +80,7 @@
     "join-images": "^1.1.3",
     "sharp": "^0.31.3"
   },
-  "gitHead": "0da838c506d1275383f2fd3d244d9c72b25397d2",
+  "gitHead": "97a8990595c132fb14e3445a8768d9f4cb98ff05",
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/node": "^20.4.2"

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

@@ -47,5 +47,6 @@ export const loadI3SContent = async (
   };
   const tileContent = await load(sourceTile.contentUrl, I3SLoader, loadOptions);
 
+  // @ts-expect-error
   return tileContent;
 };

package/src/constants.ts

@@ -1,5 +1,2 @@
 export const BROWSER_ERROR_MESSAGE =
   'Tile converter does not work in browser, only in node js environment';
-
-export const EXT_MESH_FEATURES = 'EXT_mesh_features';
-export const EXT_FEATURE_METADATA = 'EXT_feature_metadata';

package/src/i3s-converter/helpers/batch-ids-extensions.ts

@@ -3,11 +3,16 @@ import type {NumericArray} from '@loaders.gl/loader-utils';
 import type {
   GLTF_EXT_feature_metadata_FeatureIdTexture,
   GLTF_EXT_feature_metadata_GLTF,
-  GLTF_EXT_feature_metadata_Primitive
+  GLTF_EXT_feature_metadata_Primitive,
+  GLTF_EXT_structural_metadata
 } from '@loaders.gl/gltf';
+
+import type {GLTF_EXT_mesh_features} from '@loaders.gl/gltf';
+
 import {TypedArray} from '@math.gl/core';
 import {TextureImageProperties} from '../types';
-import {EXT_FEATURE_METADATA, EXT_MESH_FEATURES} from '../../constants';
+import {emod} from '@loaders.gl/math';
+import {EXT_STRUCTURAL_METADATA, EXT_MESH_FEATURES, EXT_FEATURE_METADATA} from '@loaders.gl/gltf';
 import {Tiles3DTileContent} from '@loaders.gl/3d-tiles';
 
 /**
@@ -52,7 +57,6 @@ export function handleBatchIdsExtensions(
   featureTexture: string | null
 ): NumericArray {
   const extensions = primitive?.extensions;
-
   if (!extensions) {
     return [];
   }
@@ -67,8 +71,13 @@ export function handleBatchIdsExtensions(
           featureTexture
         );
       case EXT_MESH_FEATURES:
-        console.warn('EXT_mesh_features extension is not supported yet');
-        return [];
+        return handleExtMeshFeaturesExtension(attributes, extensionData as GLTF_EXT_mesh_features);
+      case EXT_STRUCTURAL_METADATA:
+        return handleExtStructuralMetadataExtension(
+          attributes,
+          extensionData as GLTF_EXT_structural_metadata
+        );
+
       default:
         return [];
     }
@@ -77,6 +86,45 @@ export function handleBatchIdsExtensions(
   return [];
 }
 
+function handleExtStructuralMetadataExtension(
+  attributes: {
+    [key: string]: GLTFAccessorPostprocessed;
+  },
+  extStructuralMetadata: GLTF_EXT_structural_metadata
+): NumericArray {
+  // Take only first extension object to get batchIds attribute name.
+  const dataAttributeNames = extStructuralMetadata?.dataAttributeNames;
+  if (dataAttributeNames?.length) {
+    // Let's use the first element of the array
+    // TODO: What to do with others if any?
+    const batchIdsAttribute = attributes[dataAttributeNames[0]];
+    return batchIdsAttribute.value;
+  }
+  return [];
+}
+
+/**
+ * Getting batchIds from EXT_mesh_features extensions.
+ * @param attributes - gltf accessors
+ * @param extMeshFeatures - EXT_mesh_features extension
+ * @returns an array of attribute values
+ */
+function handleExtMeshFeaturesExtension(
+  attributes: {
+    [key: string]: GLTFAccessorPostprocessed;
+  },
+  extMeshFeatures: GLTF_EXT_mesh_features
+): NumericArray {
+  const dataAttributeNames = extMeshFeatures?.dataAttributeNames;
+  if (dataAttributeNames?.length) {
+    // Let's use the first element of the array
+    // TODO: What to do with others if any?
+    const batchIdsAttribute = attributes[dataAttributeNames[0]];
+    return batchIdsAttribute.value;
+  }
+  return [];
+}
+
 /**
  * Get batchIds from EXT_feature_metadata extension.
  * Docs - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata
@@ -218,12 +266,3 @@ function generateBatchIdsFromTexture(
 
   return batchIds;
 }
-
-/**
- * Handle UVs if they are out of range [0,1].
- * @param n
- * @param m
- */
-function emod(n: number): number {
-  return ((n % 1) + 1) % 1;
-}

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

@@ -9,26 +9,26 @@ import {
 } from '@loaders.gl/i3s';
 
 /**
- * Takes attributes from property table based on featureIds.
+ * Takes attributes from property table based on featureIdsMap.
  * If there is no property value for particular featureId (index) the property will be null.
  * Example:
  * Initial data:
- *   OBJECTID: [0, 1, 5]
+ *   OBJECTID: {0: 0, 3: 33, 4: 333}
  *   component: ['Windows', 'Frames', 'Wall', 'Roof', 'Skylight']
  * Result:
- *   OBJECTID: [0, 1, 5]
- *   component: ['Windows', 'Frames', 'null']
- * @param featureIds
+ *   OBJECTID: [0, 33, 333]
+ *   component: ['Windows', 'Roof', 'Skylight']
+ * @param featureIdsMap
  * @param propertyTable
  */
 export function flattenPropertyTableByFeatureIds(
-  featureIds: number[],
+  featureIdsMap: Record<string, number>,
   propertyTable: FeatureTableJson
 ): FeatureTableJson {
   const resultPropertyTable: FeatureTableJson = {};
   for (const propertyName in propertyTable) {
     const properties = propertyTable[propertyName];
-    resultPropertyTable[propertyName] = getPropertiesByFeatureIds(properties, featureIds);
+    resultPropertyTable[propertyName] = getPropertiesByFeatureIds(properties, featureIdsMap);
   }
 
   return resultPropertyTable;
@@ -37,14 +37,19 @@ export function flattenPropertyTableByFeatureIds(
 /**
  * Getting properties by featureId index
  * @param properties
- * @param featureIds
+ * @param featureIdsMap
  */
-function getPropertiesByFeatureIds(properties: any[], featureIds: number[]): any[] {
-  const resultProperties: any = [];
-
-  for (const featureId of featureIds) {
-    const property = properties[featureId] || null;
-    resultProperties.push(property);
+function getPropertiesByFeatureIds(
+  properties: unknown[],
+  featureIdsMap: Record<string, number>
+): unknown[] {
+  const resultProperties: unknown[] = [];
+
+  if (properties) {
+    for (const featureIdKey in featureIdsMap) {
+      const property = properties[featureIdKey] || null;
+      resultProperties.push(property);
+    }
   }
 
   return resultProperties;
@@ -64,7 +69,7 @@ export function checkPropertiesLength(
   let needFlatten = false;
 
   for (const attribute of Object.values(propertyTable)) {
-    if (featureIds.length !== attribute.length) {
+    if (!featureIds || !attribute || featureIds.length !== attribute.length) {
       needFlatten = true;
     }
   }

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

@@ -1,4 +1,9 @@
-import type {GeometryAttributes, ConvertedAttributes, GroupedByFeatureIdAttributes} from '../types';
+import type {
+  GeometryAttributes,
+  ConvertedAttributes,
+  GroupedByFeatureIdAttributes,
+  GroupedAttributes
+} from '../types';
 import {concatenateTypedArrays} from '@loaders.gl/loader-utils';
 
 const VALUES_PER_VERTEX = 3;
@@ -125,6 +130,11 @@ function makeAttributeObjects(attributes: GeometryAttributes): GroupedByFeatureI
   let colorsList = new Uint8Array(colors);
   let texCoordsList = new Float32Array(texCoords);
   let uvRegionsList = new Uint16Array(uvRegions);
+  let positionsOffset = 0;
+  let normalsOffset = 0;
+  let colorsOffset = 0;
+  let uvRegionsOffset = 0;
+  let texCoordsOffset = 0;
 
   for (let index = 0; index < featureIds.length; index++) {
     const startIndex = faceRange[index * 2];
@@ -138,21 +148,21 @@ function makeAttributeObjects(attributes: GeometryAttributes): GroupedByFeatureI
 
     groupedData.push({
       featureId: featureIds[index],
-      positions: positionsList.slice(0, positionsCount),
-      normals: normalsList.slice(0, normalsCount),
-      colors: colorsList.slice(0, colorsCount),
-      uvRegions: uvRegionsList.slice(0, uvRegionsCount),
-      texCoords: texCoordsList.slice(0, texCoordsCount)
+      positions: positionsList.subarray(positionsOffset, positionsOffset + positionsCount),
+      normals: normalsList.subarray(normalsOffset, normalsOffset + normalsCount),
+      colors: colorsList.subarray(colorsOffset, colorsOffset + colorsCount),
+      uvRegions: uvRegionsList.subarray(uvRegionsOffset, uvRegionsOffset + uvRegionsCount),
+      texCoords: texCoordsList.subarray(texCoordsOffset, texCoordsOffset + texCoordsCount)
     });
 
-    positionsList = positionsList.slice(positionsCount);
-    normalsList = normalsList.slice(normalsCount);
-    colorsList = colorsList.slice(colorsCount);
-    uvRegionsList = uvRegionsList.slice(uvRegionsCount);
-    texCoordsList = texCoordsList.slice(texCoordsCount);
+    positionsOffset += positionsCount;
+    normalsOffset += normalsCount;
+    colorsOffset += colorsCount;
+    uvRegionsOffset += uvRegionsCount;
+    texCoordsOffset += texCoordsCount;
   }
 
-  return groupedData.sort((first, second) => first.featureId - second.featureId);
+  return groupedData;
 }
 
 /**
@@ -195,35 +205,32 @@ function getSliceAttributeCount(
 function unifyObjectsByFeatureId(
   sortedData: GroupedByFeatureIdAttributes[]
 ): GroupedByFeatureIdAttributes[] {
-  const uniqueObjects: GroupedByFeatureIdAttributes[] = [];
-
-  for (let index = 0; index < sortedData.length; index++) {
-    const currentObject = sortedData[index];
-    const existingObject = uniqueObjects.find((obj) => obj.featureId === currentObject.featureId);
-
+  const groupedMetadata: {
+    featureId: number;
+    attributes: GroupedByFeatureIdAttributes[];
+  }[] = [];
+  for (const data of sortedData) {
+    const existingObject = groupedMetadata.find((obj) => obj.featureId === data.featureId);
     if (existingObject) {
-      existingObject.positions = concatenateTypedArrays(
-        existingObject.positions,
-        currentObject.positions
-      );
-      existingObject.normals = concatenateTypedArrays(
-        existingObject.normals,
-        currentObject.normals
-      );
-      existingObject.colors = concatenateTypedArrays(existingObject.colors, currentObject.colors);
-      existingObject.texCoords = concatenateTypedArrays(
-        existingObject.texCoords,
-        currentObject.texCoords
-      );
-      existingObject.uvRegions = concatenateTypedArrays(
-        existingObject.uvRegions,
-        currentObject.uvRegions
-      );
+      existingObject.attributes.push(data);
     } else {
-      uniqueObjects.push(currentObject);
+      groupedMetadata.push({
+        featureId: data.featureId,
+        attributes: [data]
+      });
     }
   }
 
+  const uniqueObjects: GroupedByFeatureIdAttributes[] = [];
+  for (const metatada of groupedMetadata) {
+    const attributes = concatenateAttributes(metatada.attributes);
+
+    uniqueObjects.push({
+      featureId: metatada.featureId,
+      ...attributes
+    });
+  }
+
   return uniqueObjects;
 }
 
@@ -238,12 +245,6 @@ function groupAttributesAndRangesByFeatureId(
 ): GeometryAttributes {
   const firstAttributeObject = unifiedObjects[0];
   const featureIds = [firstAttributeObject.featureId || 0];
-
-  let positions = new Float32Array(firstAttributeObject.positions);
-  let normals = new Float32Array(firstAttributeObject.normals);
-  let colors = new Uint8Array(firstAttributeObject.colors);
-  let uvRegions = new Uint16Array(firstAttributeObject.uvRegions);
-  let texCoords = new Float32Array(firstAttributeObject.texCoords);
   const range = [0];
 
   let objIndex = 0;
@@ -253,12 +254,6 @@ function groupAttributesAndRangesByFeatureId(
     const currentAttributesObject = unifiedObjects[index];
     featureIds.push(currentAttributesObject.featureId || 0);
 
-    positions = concatenateTypedArrays(positions, currentAttributesObject.positions);
-    normals = concatenateTypedArrays(normals, currentAttributesObject.normals);
-    colors = concatenateTypedArrays(colors, currentAttributesObject.colors);
-    uvRegions = concatenateTypedArrays(uvRegions, currentAttributesObject.uvRegions);
-    texCoords = concatenateTypedArrays(texCoords, currentAttributesObject.texCoords);
-
     const groupedObject = unifiedObjects[objIndex];
     range.push(groupedObject.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1 + sum);
     range.push(groupedObject.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE + sum);
@@ -267,8 +262,43 @@ function groupAttributesAndRangesByFeatureId(
     objIndex += 1;
   }
 
-  range.push(positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1);
+  const attributes = concatenateAttributes(unifiedObjects);
+
+  range.push(attributes.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1);
 
   const faceRange = new Uint32Array(range);
-  return {faceRange, featureIds, positions, normals, colors, uvRegions, texCoords, featureCount};
+  return {faceRange, featureIds, featureCount, ...attributes};
+}
+
+/**
+ * Concatenate attributes typed arrays
+ * @param attributes - grouped by featureId typed arrays
+ * @returns - concatenated typed array list
+ */
+function concatenateAttributes(attributes: GroupedByFeatureIdAttributes[]): GroupedAttributes {
+  const positionGroups = attributes.map(({positions}) => positions);
+  const positions =
+    positionGroups.length > 1 ? concatenateTypedArrays(...positionGroups) : positionGroups[0];
+
+  const normalGroups = attributes.map(({normals}) => normals);
+  const normals =
+    normalGroups.length > 1 ? concatenateTypedArrays(...normalGroups) : normalGroups[0];
+
+  const colorGroups = attributes.map(({colors}) => colors);
+  const colors = colorGroups.length > 1 ? concatenateTypedArrays(...colorGroups) : colorGroups[0];
+
+  const texCoordGroups = attributes.map(({texCoords}) => texCoords);
+  const texCoords =
+    texCoordGroups.length > 1 ? concatenateTypedArrays(...texCoordGroups) : texCoordGroups[0];
+
+  const uvRegionGroups = attributes.map(({uvRegions}) => uvRegions);
+  const uvRegions =
+    uvRegionGroups.length > 1 ? concatenateTypedArrays(...uvRegionGroups) : uvRegionGroups[0];
+  return {
+    positions,
+    normals,
+    colors,
+    texCoords,
+    uvRegions
+  };
 }