@loaders.gl/tile-converter 4.0.0-beta.4 → 4.0.0-beta.6

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

@@ -7,7 +7,11 @@ import type {
   GLTFMeshPostprocessed,
   GLTFTexturePostprocessed,
   GLTF_EXT_feature_metadata_GLTF,
-  GLTF_EXT_structural_metadata_GLTF
+  GLTF_EXT_feature_metadata_FeatureTable,
+  GLTF_EXT_feature_metadata_FeatureTexture,
+  GLTF_EXT_structural_metadata_GLTF,
+  GLTF_EXT_structural_metadata_PropertyTable,
+  GLTF_EXT_structural_metadata_PropertyTexture
 } from '@loaders.gl/gltf';
 
 import {Vector3, Matrix4, Vector4} from '@math.gl/core';
@@ -49,12 +53,7 @@ import type {GLTFAttributesData, TextureImageProperties, TypedArrayConstructor}
 import {generateSyntheticIndices} from '../../lib/utils/geometry-utils';
 import {BoundingSphere, OrientedBoundingBox} from '@math.gl/culling';
 
-import {
-  EXT_FEATURE_METADATA,
-  EXT_STRUCTURAL_METADATA,
-  getPropertyTableFromExtFeatureMetadata,
-  getPropertyTableFromExtStructuralMetadata
-} from '@loaders.gl/gltf';
+import {EXT_FEATURE_METADATA, EXT_STRUCTURAL_METADATA} from '@loaders.gl/gltf';
 
 // Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.7/pbrMetallicRoughness.cmn.md
 const DEFAULT_ROUGHNESS_FACTOR = 1;
@@ -1648,6 +1647,99 @@ export function getPropertyTable(
   }
 }
 
+/**
+ * Handles EXT_structural_metadata to get property table.
+ * @param extension - Global level of EXT_STRUCTURAL_METADATA extension.
+ * @param metadataClass - User selected feature metadata class name.
+ * @returns {FeatureTableJson | null} Property table or null if the extension can't be handled properly.
+ */
+function getPropertyTableFromExtStructuralMetadata(
+  extension: GLTF_EXT_structural_metadata_GLTF,
+  metadataClass?: string
+): FeatureTableJson | null {
+  /**
+   * Note, 3dTiles is able to have multiple featureId attributes and multiple feature tables.
+   * In I3S we should decide which featureIds attribute will be passed to geometry data.
+   * So, we take only the feature table / feature texture to generate attributes storage info object.
+   * If the user has selected the metadataClass, the table with the corresponding class will be used,
+   * or just the first one otherwise.
+   */
+  if (extension.propertyTables) {
+    for (const propertyTable of extension.propertyTables) {
+      if (propertyTable.class === metadataClass || !metadataClass) {
+        return getPropertyData(propertyTable);
+      }
+    }
+  }
+
+  if (extension.propertyTextures) {
+    for (const propertyTexture of extension.propertyTextures) {
+      if (propertyTexture.class === metadataClass || !metadataClass) {
+        return getPropertyData(propertyTexture);
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Handles EXT_feature_metadata to get property table.
+ * @param extension - Global level of EXT_FEATURE_METADATA extension.
+ * @param metadataClass - User selected feature metadata class name.
+ * @returns {FeatureTableJson | null} Property table or null if the extension can't be handled properly.
+ */
+function getPropertyTableFromExtFeatureMetadata(
+  extension: GLTF_EXT_feature_metadata_GLTF,
+  metadataClass?: string
+): FeatureTableJson | null {
+  /**
+   * Note, 3dTiles is able to have multiple featureId attributes and multiple feature tables.
+   * In I3S we should decide which featureIds attribute will be passed to geometry data.
+   * So, we take only the feature table / feature texture to generate attributes storage info object.
+   * If the user has selected the metadataClass, the table with the corresponding class will be used,
+   * or just the first one otherwise.
+   */
+  if (extension.featureTables) {
+    for (const featureTableName in extension.featureTables) {
+      const featureTable = extension.featureTables[featureTableName];
+      if (featureTable.class === metadataClass || !metadataClass) {
+        return getPropertyData(featureTable);
+      }
+    }
+  }
+
+  if (extension.featureTextures) {
+    for (const featureTextureName in extension.featureTextures) {
+      const featureTexture = extension.featureTextures[featureTextureName];
+      if (featureTexture.class === metadataClass || !metadataClass) {
+        return getPropertyData(featureTexture);
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Gets data from Property Table or Property Texture
+ * @param featureObject - property table or texture from the extension
+ * @returns Table containing property data
+ */
+function getPropertyData<
+  Type extends
+    | GLTF_EXT_structural_metadata_PropertyTable
+    | GLTF_EXT_structural_metadata_PropertyTexture
+    | GLTF_EXT_feature_metadata_FeatureTable
+    | GLTF_EXT_feature_metadata_FeatureTexture
+>(featureObject: Type) {
+  const propertyTableWithData = {};
+  for (const propertyName in featureObject.properties) {
+    propertyTableWithData[propertyName] = featureObject.properties[propertyName].data;
+  }
+  return propertyTableWithData;
+}
+
 /**
  * Check extensions which can be with property table inside.
  * @param tileContent - 3DTiles tile content

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

@@ -62,6 +62,7 @@ export const loadTile3DContent = async (
   const loadOptions = {
     ...tilesetLoadOptions,
     [sourceTileset.loader.id]: {
+      // @ts-ignore
       ...(tilesetLoadOptions[sourceTileset.loader.id] || {}),
       isTileset,
       assetGltfUpAxis: (sourceTileset.asset && sourceTileset.asset.gltfUpAxis) || 'Y'

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

@@ -13,7 +13,7 @@ import type {
   BoundingVolumes,
   MaxScreenThresholdSQ,
   NodeInPage,
-  AttributeStorageInfo
+  Attribute
 } from '@loaders.gl/i3s';
 import {load, encode, isBrowser} from '@loaders.gl/core';
 import {CesiumIonLoader, Tiles3DLoader} from '@loaders.gl/3d-tiles';
@@ -61,11 +61,12 @@ import {WorkerFarm} from '@loaders.gl/worker-utils';
 import WriteQueue from '../lib/utils/write-queue';
 import {BROWSER_ERROR_MESSAGE} from '../constants';
 import {
+  getAttributeTypesFromPropertyTable,
+  getAttributeTypesFromSchema,
   createdStorageAttribute,
+  getFieldAttributeType,
   createFieldAttribute,
-  createPopupInfo,
-  getAttributeType,
-  getFieldAttributeType
+  createPopupInfo
 } from './helpers/feature-attributes';
 import {NodeIndexDocument} from './helpers/node-index-document';
 import {
@@ -663,16 +664,7 @@ export default class I3SConverter {
     let boundingVolumes = createBoundingVolumes(sourceBoundingVolume, this.geoidHeightModel!);
 
     const propertyTable = getPropertyTable(tileContent, this.options.metadataClass);
-
-    if (propertyTable) {
-      /*
-        Call the convertion procedure even if the node attributes have been already created.
-        We will append new attributes only in case the property table is updated.
-        According to ver 1.9 (see https://github.com/Esri/i3s-spec/blob/master/docs/1.9/attributeStorageInfo.cmn.md):
-        "The attributeStorageInfo object describes the structure of the binary attribute data resource of a layer, which is the same for every node in the layer."
-      */
-      this._convertPropertyTableToNodeAttributes(propertyTable);
-    }
+    this.createAttributeStorageInfo(tileContent, propertyTable);
 
     const resourcesData = await this._convertResources(
       sourceTile,
@@ -1165,42 +1157,83 @@ export default class I3SConverter {
   }
 
   /**
-   * Do conversion of 3DTiles property table to I3s node attributes.
-   * @param propertyTable - Table with layer meta data.
+   * Creates attribute storage info based on either extension schema or property table.
+   * @param tileContent - content of the source tile
+   * @param propertyTable - feature properties from EXT_FEATURE_METADATA, EXT_STRUCTURAL_METADATA
    */
-  private _convertPropertyTableToNodeAttributes(propertyTable: FeatureTableJson): void {
-    let attributeIndex = 0;
-    const propertyTableWithObjectId = {
-      OBJECTID: [0],
-      ...propertyTable
+  private createAttributeStorageInfo(
+    tileContent: Tiles3DTileContent | null,
+    propertyTable: FeatureTableJson | null
+  ): void {
+    /*
+    In case the tileset doesn't have either EXT_structural_metadata or EXT_feature_metadata
+    that can be a source of attribute information so metadataClass is not specified
+    we will collect attribute information for node attributes from the property table
+    taken from each tile.
+    */
+    let attributeTypesMap: Record<string, Attribute> | null = null;
+    if (this.options.metadataClass) {
+      if (!this.layers0!.attributeStorageInfo!.length && tileContent?.gltf) {
+        attributeTypesMap = getAttributeTypesFromSchema(
+          tileContent.gltf,
+          this.options.metadataClass
+        );
+      }
+    } else if (propertyTable) {
+      attributeTypesMap = getAttributeTypesFromPropertyTable(propertyTable);
+    }
+
+    if (attributeTypesMap) {
+      this.createStorageAttributes(attributeTypesMap);
+    }
+  }
+
+  /**
+   * Creates Attribute Storage Info objects based on attribute's types
+   * @param attributeTypesMap - set of attribute's types
+   */
+  private createStorageAttributes(attributeTypesMap: Record<string, Attribute>): void {
+    if (!Object.keys(attributeTypesMap).length) {
+      return;
+    }
+    const attributeTypes: Record<string, Attribute> = {
+      OBJECTID: 'OBJECTID',
+      ...attributeTypesMap
     };
 
-    for (const key in propertyTableWithObjectId) {
+    let isUpdated = false;
+    let attributeIndex = this.layers0!.attributeStorageInfo!.length;
+    for (const key in attributeTypes) {
       /*
-        We will append new attributes only in case the property table is updated.
-        According to ver 1.9 (see https://github.com/Esri/i3s-spec/blob/master/docs/1.9/attributeStorageInfo.cmn.md):
-        "The attributeStorageInfo object describes the structure of the binary attribute data resource of a layer, which is the same for every node in the layer."
+      We will append a new attribute only in case it has not been added to the attribute storage info yet.
       */
-      const found = this.layers0!.attributeStorageInfo!.find((element) => element.name === key);
-      if (!found) {
-        const firstAttribute = propertyTableWithObjectId[key][0];
-        const attributeType = getAttributeType(key, firstAttribute);
-
-        const storageAttribute: AttributeStorageInfo = createdStorageAttribute(
-          attributeIndex,
-          key,
-          attributeType
-        );
+      const elementFound = this.layers0!.attributeStorageInfo!.find(
+        (element) => element.name === key
+      );
+      if (!elementFound) {
+        const attributeType = attributeTypes[key];
+
+        const storageAttribute = createdStorageAttribute(attributeIndex, key, attributeType);
         const fieldAttributeType = getFieldAttributeType(attributeType);
         const fieldAttribute = createFieldAttribute(key, fieldAttributeType);
-        const popupInfo = createPopupInfo(propertyTableWithObjectId);
 
         this.layers0!.attributeStorageInfo!.push(storageAttribute);
         this.layers0!.fields!.push(fieldAttribute);
-        this.layers0!.popupInfo = popupInfo;
-        this.layers0!.layerType = _3D_OBJECT_LAYER_TYPE;
+        attributeIndex += 1;
+        isUpdated = true;
+      }
+    }
+    if (isUpdated) {
+      /*
+      The attributeStorageInfo is updated. So, popupInfo should be recreated.
+      Use attributeStorageInfo as a source of attribute names to create the popupInfo.
+    */
+      const attributeNames: string[] = [];
+      for (let info of this.layers0!.attributeStorageInfo!) {
+        attributeNames.push(info.name);
       }
-      attributeIndex += 1;
+      this.layers0!.popupInfo = createPopupInfo(attributeNames);
+      this.layers0!.layerType = _3D_OBJECT_LAYER_TYPE;
     }
   }
 

package/src/i3s-converter/types.ts

@@ -188,7 +188,7 @@ export type PreprocessData = {
   /** Mesh topology types used in gltf primitives of the tileset */
   meshTopologyTypes: Set<GLTFPrimitiveModeString>;
   /**
-   * Featrue metadata classes found in glTF extensions
+   * Feature metadata classes found in glTF extensions
    * The tileset might contain multiple metadata classes provided by EXT_feature_metadata and EXT_structural_metadata extensions.
    * Every class is a set of properties. But I3S can consume only one set of properties.
    * On the pre-process we collect all classes from the tileset in order to show the prompt to select one class for conversion to I3S.