@loaders.gl/tile-converter 4.0.0-beta.3 → 4.0.0-beta.5

package/dist/index.cjs

@@ -1078,6 +1078,7 @@ function generateBatchIdsFromTexture(featureIdTexture, textureCoordinates, image
 }
 
 // src/i3s-converter/helpers/feature-attributes.ts
+var import_gltf2 = require("@loaders.gl/gltf");
 function flattenPropertyTableByFeatureIds(featureIdsMap, propertyTable) {
   const resultPropertyTable = {};
   for (const propertyName in propertyTable) {
@@ -1109,10 +1110,7 @@ var STRING_TYPE = "string";
 var SHORT_INT_TYPE = "Int32";
 var DOUBLE_TYPE = "double";
 var OBJECT_ID_TYPE = "OBJECTID";
-function getAttributeType(key, attribute) {
-  if (key === OBJECT_ID_TYPE) {
-    return OBJECT_ID_TYPE;
-  }
+function getAttributeType(attribute) {
   if (typeof attribute === STRING_TYPE || typeof attribute === "bigint") {
     return STRING_TYPE;
   } else if (typeof attribute === "number") {
@@ -1166,18 +1164,18 @@ function createFieldAttribute(key, fieldAttributeType) {
     alias: key
   };
 }
-function createPopupInfo(propertyTable) {
+function createPopupInfo(propertyNames) {
   const title = "{OBJECTID}";
   const mediaInfos = [];
   const fieldInfos = [];
   const popupElements = [];
   const expressionInfos = [];
-  for (const key in propertyTable) {
+  for (const propertyName of propertyNames) {
     fieldInfos.push({
-      fieldName: key,
+      fieldName: propertyName,
       visible: true,
       isEditable: false,
-      label: key
+      label: propertyName
     });
   }
   popupElements.push({
@@ -1217,6 +1215,96 @@ function setupDoubleAttribute(storageAttribute) {
     valuesPerElement: 1
   };
 }
+function getAttributeTypesFromPropertyTable(propertyTable) {
+  const attributeTypesMap = {};
+  for (const key in propertyTable) {
+    const firstAttribute = propertyTable[key][0];
+    const attributeType = getAttributeType(firstAttribute);
+    attributeTypesMap[key] = attributeType;
+  }
+  return attributeTypesMap;
+}
+var getAttributeTypesFromSchema = (gltfJson, metadataClass) => {
+  var _a2, _b, _c, _d, _e, _f, _g, _h;
+  const attributeTypesMap = {};
+  const extFeatureMetadataSchemaClass = (_d = (_c = (_b = (_a2 = gltfJson.extensions) == null ? void 0 : _a2[import_gltf2.EXT_FEATURE_METADATA]) == null ? void 0 : _b.schema) == null ? void 0 : _c.classes) == null ? void 0 : _d[metadataClass];
+  if (extFeatureMetadataSchemaClass) {
+    for (let propertyName in extFeatureMetadataSchemaClass.properties) {
+      const property = extFeatureMetadataSchemaClass.properties[propertyName];
+      const attributeProperty = getAttributeTypeFromExtFeatureMetadata(property);
+      attributeTypesMap[propertyName] = attributeProperty;
+    }
+    return attributeTypesMap;
+  }
+  const extStructuralMetadataSchemaClass = (_h = (_g = (_f = (_e = gltfJson.extensions) == null ? void 0 : _e[import_gltf2.EXT_STRUCTURAL_METADATA]) == null ? void 0 : _f.schema) == null ? void 0 : _g.classes) == null ? void 0 : _h[metadataClass];
+  if (extStructuralMetadataSchemaClass) {
+    for (let propertyName in extStructuralMetadataSchemaClass.properties) {
+      const property = extStructuralMetadataSchemaClass.properties[propertyName];
+      const attributeProperty = getAttributeTypeFromExtStructuralMetadata(property);
+      attributeTypesMap[propertyName] = attributeProperty;
+    }
+    return attributeTypesMap;
+  }
+  return null;
+};
+var getAttributeTypeFromExtFeatureMetadata = (property) => {
+  let attributeType;
+  switch (property.type) {
+    case "INT8":
+    case "UINT8":
+    case "INT16":
+    case "UINT16":
+    case "INT32":
+    case "UINT32":
+      attributeType = SHORT_INT_TYPE;
+      break;
+    case "FLOAT32":
+    case "FLOAT64":
+      attributeType = DOUBLE_TYPE;
+      break;
+    case "INT64":
+    case "UINT64":
+    case "BOOLEAN":
+    case "ENUM":
+    case "STRING":
+    case "ARRAY":
+      attributeType = STRING_TYPE;
+      break;
+    default:
+      attributeType = STRING_TYPE;
+      break;
+  }
+  return attributeType;
+};
+var getAttributeTypeFromExtStructuralMetadata = (property) => {
+  let attributeType;
+  if (property.array) {
+    attributeType = STRING_TYPE;
+  } else {
+    switch (property.componentType) {
+      case "INT8":
+      case "UINT8":
+      case "INT16":
+      case "UINT16":
+      case "INT32":
+      case "UINT32":
+        attributeType = SHORT_INT_TYPE;
+        break;
+      case "FLOAT32":
+      case "FLOAT64":
+        attributeType = DOUBLE_TYPE;
+        break;
+      case "INT64":
+      case "UINT64":
+        attributeType = STRING_TYPE;
+        break;
+      default:
+        attributeType = STRING_TYPE;
+        break;
+    }
+  }
+  return attributeType;
+};
 
 // src/i3s-converter/helpers/geometry-converter.ts
 var import_math2 = require("@loaders.gl/math");
@@ -1231,7 +1319,7 @@ var generateSyntheticIndices = (vertexCount) => {
 };
 
 // src/i3s-converter/helpers/geometry-converter.ts
-var import_gltf2 = require("@loaders.gl/gltf");
+var import_gltf3 = require("@loaders.gl/gltf");
 var DEFAULT_ROUGHNESS_FACTOR = 1;
 var DEFAULT_METALLIC_FACTOR = 1;
 var VALUES_PER_VERTEX2 = 3;
@@ -2137,15 +2225,15 @@ function getPropertyTable(tileContent, metadataClass) {
   }
   const { extensionName, extension } = getPropertyTableExtension(tileContent);
   switch (extensionName) {
-    case import_gltf2.EXT_STRUCTURAL_METADATA: {
-      propertyTable = (0, import_gltf2.getPropertyTableFromExtStructuralMetadata)(
+    case import_gltf3.EXT_STRUCTURAL_METADATA: {
+      propertyTable = getPropertyTableFromExtStructuralMetadata(
         extension,
         metadataClass
       );
       return propertyTable;
     }
-    case import_gltf2.EXT_FEATURE_METADATA: {
-      propertyTable = (0, import_gltf2.getPropertyTableFromExtFeatureMetadata)(
+    case import_gltf3.EXT_FEATURE_METADATA: {
+      propertyTable = getPropertyTableFromExtFeatureMetadata(
         extension,
         metadataClass
       );
@@ -2155,9 +2243,52 @@ function getPropertyTable(tileContent, metadataClass) {
       return null;
   }
 }
+function getPropertyTableFromExtStructuralMetadata(extension, metadataClass) {
+  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;
+}
+function getPropertyTableFromExtFeatureMetadata(extension, metadataClass) {
+  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;
+}
+function getPropertyData(featureObject) {
+  const propertyTableWithData = {};
+  for (const propertyName in featureObject.properties) {
+    propertyTableWithData[propertyName] = featureObject.properties[propertyName].data;
+  }
+  return propertyTableWithData;
+}
 function getPropertyTableExtension(tileContent) {
   var _a2, _b, _c, _d;
-  const extensionsWithPropertyTables = [import_gltf2.EXT_FEATURE_METADATA, import_gltf2.EXT_STRUCTURAL_METADATA];
+  const extensionsWithPropertyTables = [import_gltf3.EXT_FEATURE_METADATA, import_gltf3.EXT_STRUCTURAL_METADATA];
   const extensionsUsed = (_a2 = tileContent == null ? void 0 : tileContent.gltf) == null ? void 0 : _a2.extensionsUsed;
   if (!extensionsUsed) {
     return { extensionName: null, extension: null };
@@ -3359,6 +3490,7 @@ var loadTile3DContent = async (sourceTileset, sourceTile, tilesetLoadOptions) =>
   const loadOptions = {
     ...tilesetLoadOptions,
     [sourceTileset.loader.id]: {
+      // @ts-ignore
       ...tilesetLoadOptions[sourceTileset.loader.id] || {},
       isTileset,
       assetGltfUpAxis: sourceTileset.asset && sourceTileset.asset.gltfUpAxis || "Y"
@@ -3426,9 +3558,9 @@ var traverseDatasetWith = async (tile, traversalProps, processTile, postprocessT
 };
 
 // src/i3s-converter/helpers/preprocess-3d-tiles.ts
-var import_gltf3 = require("@loaders.gl/gltf");
-var import_core8 = require("@loaders.gl/core");
 var import_gltf4 = require("@loaders.gl/gltf");
+var import_core8 = require("@loaders.gl/core");
+var import_gltf5 = require("@loaders.gl/gltf");
 var GLTF_PRIMITIVE_MODES = [
   "POINTS" /* POINTS */,
   // 0
@@ -3453,7 +3585,7 @@ var analyzeTileContent = async (tileContent) => {
   if (!(tileContent == null ? void 0 : tileContent.gltfArrayBuffer)) {
     return defaultResult;
   }
-  const gltfData = await (0, import_core8.parse)(tileContent.gltfArrayBuffer, import_gltf3.GLTFLoader, {
+  const gltfData = await (0, import_core8.parse)(tileContent.gltfArrayBuffer, import_gltf4.GLTFLoader, {
     gltf: { normalize: false, loadBuffers: false, loadImages: false, decompressMeshes: false }
   });
   const gltf = gltfData.json;
@@ -3483,13 +3615,13 @@ var getMeshTypesFromGLTF = (gltfJson) => {
 var getMetadataClassesFromGLTF = (gltfJson) => {
   var _a2, _b, _c, _d, _e, _f;
   const result = /* @__PURE__ */ new Set();
-  const extFeatureMetadataClasses = (_c = (_b = (_a2 = gltfJson.extensions) == null ? void 0 : _a2[import_gltf4.EXT_FEATURE_METADATA]) == null ? void 0 : _b.schema) == null ? void 0 : _c.classes;
+  const extFeatureMetadataClasses = (_c = (_b = (_a2 = gltfJson.extensions) == null ? void 0 : _a2[import_gltf5.EXT_FEATURE_METADATA]) == null ? void 0 : _b.schema) == null ? void 0 : _c.classes;
   if (extFeatureMetadataClasses) {
     for (const classKey of Object.keys(extFeatureMetadataClasses)) {
       result.add(classKey);
     }
   }
-  const extStructuralMetadataClasses = (_f = (_e = (_d = gltfJson.extensions) == null ? void 0 : _d[import_gltf3.EXT_STRUCTURAL_METADATA]) == null ? void 0 : _e.schema) == null ? void 0 : _f.classes;
+  const extStructuralMetadataClasses = (_f = (_e = (_d = gltfJson.extensions) == null ? void 0 : _d[import_gltf4.EXT_STRUCTURAL_METADATA]) == null ? void 0 : _e.schema) == null ? void 0 : _f.classes;
   if (extStructuralMetadataClasses) {
     for (const classKey of Object.keys(extStructuralMetadataClasses)) {
       result.add(classKey);
@@ -3965,9 +4097,7 @@ var I3SConverter = class {
     );
     let boundingVolumes = createBoundingVolumes(sourceBoundingVolume, this.geoidHeightModel);
     const propertyTable = getPropertyTable(tileContent, this.options.metadataClass);
-    if (propertyTable) {
-      this._convertPropertyTableToNodeAttributes(propertyTable);
-    }
+    this.createAttributeStorageInfo(tileContent, propertyTable);
     const resourcesData = await this._convertResources(
       sourceTile,
       transformationMatrix,
@@ -4378,34 +4508,62 @@ var I3SConverter = class {
     return newGeometryId;
   }
   /**
-   * 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
    */
-  _convertPropertyTableToNodeAttributes(propertyTable) {
-    let attributeIndex = 0;
-    const propertyTableWithObjectId = {
-      OBJECTID: [0],
-      ...propertyTable
-    };
-    for (const key in propertyTableWithObjectId) {
-      const found = this.layers0.attributeStorageInfo.find((element) => element.name === key);
-      if (!found) {
-        const firstAttribute = propertyTableWithObjectId[key][0];
-        const attributeType = getAttributeType(key, firstAttribute);
-        const storageAttribute = createdStorageAttribute(
-          attributeIndex,
-          key,
-          attributeType
+  createAttributeStorageInfo(tileContent, propertyTable) {
+    let attributeTypesMap = null;
+    if (this.options.metadataClass) {
+      if (!this.layers0.attributeStorageInfo.length && (tileContent == null ? void 0 : 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
+   */
+  createStorageAttributes(attributeTypesMap) {
+    if (!Object.keys(attributeTypesMap).length) {
+      return;
+    }
+    const attributeTypes = {
+      OBJECTID: "OBJECTID",
+      ...attributeTypesMap
+    };
+    let isUpdated = false;
+    let attributeIndex = this.layers0.attributeStorageInfo.length;
+    for (const key in attributeTypes) {
+      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) {
+      const attributeNames = [];
+      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;
     }
   }
   /**
@@ -4548,7 +4706,7 @@ var import_worker_utils3 = require("@loaders.gl/worker-utils");
 
 // src/3d-tiles-converter/helpers/b3dm-converter.ts
 var import_core12 = require("@loaders.gl/core");
-var import_gltf5 = require("@loaders.gl/gltf");
+var import_gltf6 = require("@loaders.gl/gltf");
 var import_d_tiles3 = require("@loaders.gl/3d-tiles");
 var import_core13 = require("@math.gl/core");
 var import_geospatial6 = require("@math.gl/geospatial");
@@ -4614,7 +4772,7 @@ var B3dmConverter = class {
   async buildGLTF(i3sAttributesData, featureAttributes) {
     const { tileContent, textureFormat, box } = i3sAttributesData;
     const { material, attributes, indices: originalIndices, modelMatrix } = tileContent;
-    const gltfBuilder = new import_gltf5.GLTFScenegraph();
+    const gltfBuilder = new import_gltf6.GLTFScenegraph();
     const textureIndex = await this._addI3sTextureToGLTF(tileContent, textureFormat, gltfBuilder);
     const pbrMaterialInfo = this._convertI3sMaterialToGLTFMaterial(material, textureIndex);
     const materialIndex = gltfBuilder.addMaterial(pbrMaterialInfo);
@@ -4653,7 +4811,7 @@ var B3dmConverter = class {
     const sceneIndex = gltfBuilder.addScene({ nodeIndices: [nodeIndex] });
     gltfBuilder.setDefaultScene(sceneIndex);
     gltfBuilder.createBinaryChunk();
-    const gltfBuffer = (0, import_core12.encodeSync)(gltfBuilder.gltf, import_gltf5.GLTFWriter);
+    const gltfBuffer = (0, import_core12.encodeSync)(gltfBuilder.gltf, import_gltf6.GLTFWriter);
     return gltfBuffer;
   }
   /**