@loaders.gl/tile-converter 3.2.5 → 3.3.0-alpha.1

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

@@ -0,0 +1,182 @@
+import type {GLTFAccessorPostprocessed} from 'modules/gltf/src/lib/types/gltf-types';
+import type {Image, MeshPrimitive} from 'modules/gltf/src/lib/types/gltf-postprocessed-schema';
+import type {ExtFeatureMetadata, ExtFeatureMetadataAttribute} from '../types';
+
+const EXT_MESH_FEATURES = 'EXT_mesh_features';
+const EXT_FEATURE_METADATA = 'EXT_feature_metadata';
+
+/**
+ * Getting batchIds from 3DTilesNext extensions.
+ * @param attributes
+ * @param primitive
+ * @param textures
+ */
+export function handleBatchIdsExtensions(
+  attributes: {
+    [key: string]: GLTFAccessorPostprocessed;
+  },
+  primitive: MeshPrimitive,
+  images: Image[]
+): number[] {
+  const extensions = primitive?.extensions;
+
+  if (!extensions) {
+    return [];
+  }
+
+  for (const [extensionName, extensionData] of Object.entries(extensions || {})) {
+    switch (extensionName) {
+      case EXT_FEATURE_METADATA:
+        return handleExtFeatureMetadataExtension(
+          attributes,
+          extensionData as ExtFeatureMetadata,
+          images
+        );
+      case EXT_MESH_FEATURES:
+        console.warn('EXT_mesh_features extension is not supported yet');
+        return [];
+      default:
+        return [];
+    }
+  }
+
+  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
+ * @param attributes
+ * @param extFeatureMetadata
+ * @param textures
+ */
+function handleExtFeatureMetadataExtension(
+  attributes: {
+    [key: string]: GLTFAccessorPostprocessed;
+  },
+  extFeatureMetadata: ExtFeatureMetadata,
+  images: Image[]
+): number[] {
+  // Take only first extension object to get batchIds attribute name.
+  const featureIdAttribute = extFeatureMetadata?.featureIdAttributes?.[0];
+
+  if (featureIdAttribute?.featureIds?.attribute) {
+    const batchIdsAttribute = attributes[featureIdAttribute.featureIds.attribute];
+    return batchIdsAttribute.value;
+  }
+
+  if (
+    featureIdAttribute?.featureIds?.hasOwnProperty('constant') &&
+    featureIdAttribute?.featureIds?.hasOwnProperty('divisor')
+  ) {
+    const featuresCount = attributes?.POSITIONS?.value.length / 3 || 0;
+    return generateImplicitFeatureIds(
+      featuresCount,
+      featureIdAttribute.featureIds.constant,
+      featureIdAttribute.featureIds.divisor
+    );
+  }
+
+  // Take only first extension object to get batchIds attribute name.
+  const featureIdTexture =
+    extFeatureMetadata?.featureIdTextures && extFeatureMetadata?.featureIdTextures[0];
+
+  if (featureIdTexture) {
+    const textureCoordinates = attributes.TEXCOORD_0.value;
+    return generateBatchIdsFromTexture(featureIdTexture, textureCoordinates, images);
+  }
+
+  return [];
+}
+
+/**
+ * Generates implicit feature ids
+ * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#implicit-feature-ids
+ * @param featuresCount
+ * @param constant
+ * @param devisor
+ */
+function generateImplicitFeatureIds(
+  featuresCount: number,
+  constant: number = 0,
+  divisor: number = 0
+): number[] {
+  let featureIds: number[] = [];
+
+  if (divisor > 0) {
+    let currentValue = constant;
+    let devisorCounter = divisor;
+
+    for (let index = 0; index < featuresCount; index++) {
+      featureIds.push(currentValue);
+
+      devisorCounter -= 1;
+
+      if (devisorCounter === 0) {
+        currentValue++;
+        devisorCounter = divisor;
+      }
+    }
+  } else {
+    featureIds = Array<number>(featuresCount).fill(constant, 0, featuresCount);
+  }
+
+  return featureIds;
+}
+
+/**
+ * Get batchIds from texture.
+ * @param primitive
+ * @param featureIdTextures
+ */
+function generateBatchIdsFromTexture(
+  featureIdTexture: ExtFeatureMetadataAttribute,
+  textureCoordinates: Float32Array,
+  images: Image[]
+) {
+  const CHANNELS_MAP = {
+    r: 0,
+    g: 1,
+    b: 2,
+    a: 3
+  };
+
+  const textureIndex = featureIdTexture?.featureIds?.texture?.index;
+  const featureChannel = featureIdTexture?.featureIds?.channels;
+
+  if (!featureChannel || textureIndex === undefined) {
+    return [];
+  }
+
+  const image = images[textureIndex];
+  const batchIds: number[] = [];
+  const channels = CHANNELS_MAP[featureChannel];
+
+  if (!image.compressed) {
+    for (let index = 0; index < textureCoordinates.length; index += 2) {
+      const u = textureCoordinates[index];
+      const v = textureCoordinates[index + 1];
+
+      const tx = Math.min((emod(u) * image.width) | 0, image.width - 1);
+      const ty = Math.min((emod(v) * image.height) | 0, image.height - 1);
+
+      const offset = (ty * image.width + tx) * image.components + channels;
+      const batchId = new Uint8Array(image.data)[offset];
+
+      batchIds.push(batchId);
+    }
+  } else {
+    console.warn(`Can't get batch Ids from ${image.mimeType} compressed texture`);
+  }
+
+  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/geometry-converter.ts

@@ -1,3 +1,5 @@
+import type {Image, MeshPrimitive} from 'modules/gltf/src/lib/types/gltf-postprocessed-schema';
+
 import {Vector3, Matrix4, Vector4} from '@math.gl/core';
 import {Ellipsoid} from '@math.gl/geospatial';
 
@@ -30,6 +32,7 @@ import {
 } from 'modules/gltf/src/lib/types/gltf-types';
 import {B3DMAttributesData /*transformI3SAttributesOnWorker */} from '../../i3s-attributes-worker';
 import {prepareDataForAttributesConversion} from './gltf-attributes';
+import {handleBatchIdsExtensions} from './batch-ids-extensions';
 
 // Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.7/pbrMetallicRoughness.cmn.md
 const DEFAULT_ROUGHNESS_FACTOR = 1;
@@ -407,9 +410,12 @@ function convertNode(
   const transformationMatrix = getCompositeTransformationMatrix(node, matrix);
 
   const mesh = node.mesh;
+  const images = node.images;
+
   if (mesh) {
     convertMesh(
       mesh,
+      images,
       cartographicOrigin,
       cartesianModelMatrix,
       attributesMap,
@@ -441,6 +447,7 @@ function convertNode(
  */
 function convertMesh(
   mesh: GLTFMeshPostprocessed,
+  images: Image[],
   cartographicOrigin: Vector3,
   cartesianModelMatrix: Matrix4,
   attributesMap: Map<string, ConvertedAttributes>,
@@ -498,7 +505,7 @@ function convertMesh(
 
     outputAttributes.featureIndicesGroups = outputAttributes.featureIndicesGroups || [];
     outputAttributes.featureIndicesGroups.push(
-      flattenBatchIds(getBatchIdsByAttributeName(attributes), primitive.indices?.value)
+      flattenBatchIds(getBatchIds(attributes, primitive, images), primitive.indices?.value)
     );
   }
 }
@@ -665,14 +672,23 @@ function flattenBatchIds(batchedIds: number[], indices: Uint8Array): number[] {
 }
 
 /**
- * Return batchIds based on possible attribute names for different kind of maps.
- * @param attributes - the gltf primitive attributes
- * @returns batch ids attribute
+ * Get batchIds for featureIds creation
+ * @param attributes
+ * @param primitive
+ * @param textures
  */
-function getBatchIdsByAttributeName(attributes: {
-  [key: string]: GLTFAccessorPostprocessed;
-}): number[] {
-  let batchIds: number[] = [];
+function getBatchIds(
+  attributes: {
+    [key: string]: GLTFAccessorPostprocessed;
+  },
+  primitive: MeshPrimitive,
+  images: Image[]
+): number[] {
+  const batchIds: number[] = handleBatchIdsExtensions(attributes, primitive, images);
+
+  if (batchIds.length) {
+    return batchIds;
+  }
 
   for (let index = 0; index < BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES.length; index++) {
     const possibleBatchIdAttributeName = BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES[index];
@@ -680,12 +696,11 @@ function getBatchIdsByAttributeName(attributes: {
       attributes[possibleBatchIdAttributeName] &&
       attributes[possibleBatchIdAttributeName].value
     ) {
-      batchIds = attributes[possibleBatchIdAttributeName].value;
-      break;
+      return attributes[possibleBatchIdAttributeName].value;
     }
   }
 
-  return batchIds;
+  return [];
 }
 
 /**

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

@@ -35,6 +35,20 @@ export function prepareDataForAttributesConversion(tileContent: B3DMContent): B3
     tileContent.gltf?.nodes ||
     [];
 
+  const images =
+    tileContent.gltf?.images?.map((imageObject) => {
+      // Need data only for uncompressed images because we can't get batchIds from compressed textures.
+      const data = imageObject?.image?.compressed ? null : imageObject?.image?.data.subarray();
+      return {
+        data,
+        compressed: Boolean(imageObject?.image?.compressed),
+        height: imageObject.image.height,
+        width: imageObject.image.width,
+        components: imageObject.image.components,
+        mimeType: imageObject.mimeType
+      };
+    }) || [];
+
   const prepearedNodes = nodes.map((node) => {
     if (!node.mesh) {
       return node;
@@ -42,6 +56,7 @@ export function prepareDataForAttributesConversion(tileContent: B3DMContent): B3
 
     return {
       ...node,
+      images,
       mesh: {
         ...node.mesh,
         primitives: node.mesh?.primitives.map((primitive) => ({

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

@@ -938,12 +938,19 @@ export default class I3SConverter {
 
           if (this.generateTextures) {
             formats.push({name: '1', format: 'ktx2'});
-            const ktx2TextureData = encode(texture.image, KTX2BasisWriterWorker, {
-              ...KTX2BasisWriterWorker.options,
-              source: this.workerSource.ktx2,
-              reuseWorkers: true,
-              _nodeWorkers: true
-            });
+            // For Node.js texture.image.data is type of Buffer
+            const copyArrayBuffer = texture.image.data.subarray();
+            const arrayToEncode = new Uint8Array(copyArrayBuffer);
+            const ktx2TextureData = encode(
+              {...texture.image, data: arrayToEncode},
+              KTX2BasisWriterWorker,
+              {
+                ...KTX2BasisWriterWorker.options,
+                source: this.workerSource.ktx2,
+                reuseWorkers: true,
+                _nodeWorkers: true
+              }
+            );
 
             await this.writeTextureFile(ktx2TextureData, '1', 'ktx2', childPath, slpkChildPath);
           }

package/src/i3s-converter/types.ts

@@ -122,3 +122,54 @@ export type I3SMaterialWithTexture = {
   /** Texture content (image) */
   texture?: ImageDataType;
 };
+
+/**
+ * 3DTilesNext EXT_feature_metadata extension
+ * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata
+ */
+export type ExtFeatureMetadata = {
+  /** Feature ids definition in attributes */
+  featureIdAttributes?: ExtFeatureMetadataAttribute[];
+  /** Feature ids definition in textures */
+  featureIdTextures?: ExtFeatureMetadataAttribute[];
+};
+
+/**
+ * Attribute which described featureIds definition.
+ */
+export type ExtFeatureMetadataAttribute = {
+  /** Name of feature table */
+  featureTable: string;
+  /** Described how feature ids are defined */
+  featureIds: ExtFeatureMetadataFeatureIds;
+};
+
+/**
+ * Defining featureIds by attributes or implicitly.
+ */
+type ExtFeatureMetadataFeatureIds = {
+  /** Name of attribute where featureIds are defined */
+  attribute?: string;
+  /** Sets a constant feature ID for each vertex. The default is 0. */
+  constant?: number;
+  /** Sets the rate at which feature IDs increment.
+   * If divisor is zero then constant is used.
+   * If divisor is greater than zero the feature ID increments once per divisor sets of vertices, starting at constant.
+   * The default is 0
+   */
+  divisor?: number;
+  /** gLTF textureInfo object - https://github.com/CesiumGS/glTF/blob/3d-tiles-next/specification/2.0/schema/textureInfo.schema.json */
+  texture?: ExtFeatureMetadataTexture;
+  /** Must be a single channel ("r", "g", "b", or "a") */
+  channels?: 'r' | 'g' | 'b' | 'a';
+};
+
+/**
+ * Reference to a texture.
+ */
+type ExtFeatureMetadataTexture = {
+  /** The set index of texture's TEXCOORD attribute used for texture coordinate mapping.*/
+  texCoord: number;
+  /** The index of the texture. */
+  index: number;
+};

package/src/lib/utils/write-queue.ts

@@ -57,19 +57,21 @@ export default class WriteQueue<T extends WriteQueueItem> extends Queue<T> {
         archiveKeys.push(archiveKey);
         promises.push(writePromise);
       }
-      const writeResults = await Promise.all(promises);
+      const writeResults = await Promise.allSettled(promises);
       this.updateFileMap(archiveKeys, writeResults);
     }
     this.writePromise = null;
   }
 
-  private updateFileMap(archiveKeys: (string | undefined)[], writeResults: string[]) {
+  private updateFileMap(
+    archiveKeys: (string | undefined)[],
+    writeResults: PromiseSettledResult<string>[]
+  ) {
     for (let i = 0; i < archiveKeys.length; i++) {
       const archiveKey = archiveKeys[i];
-      if (!archiveKey) {
-        continue;
+      if (archiveKey && 'value' in writeResults[i]) {
+        this.fileMap[archiveKey] = (writeResults[i] as PromiseFulfilledResult<string>).value;
       }
-      this.fileMap[archiveKey] = writeResults[i];
     }
   }
 }