@loaders.gl/tile-converter 3.2.7 → 3.3.0-alpha.3

package/dist/i3s-converter/helpers/batch-ids-extensions.d.ts

@@ -0,0 +1,12 @@
+import type { GLTFAccessorPostprocessed } from 'modules/gltf/src/lib/types/gltf-types';
+import type { Image, MeshPrimitive } from 'modules/gltf/src/lib/types/gltf-postprocessed-schema';
+/**
+ * Getting batchIds from 3DTilesNext extensions.
+ * @param attributes
+ * @param primitive
+ * @param textures
+ */
+export declare function handleBatchIdsExtensions(attributes: {
+    [key: string]: GLTFAccessorPostprocessed;
+}, primitive: MeshPrimitive, images: Image[]): number[];
+//# sourceMappingURL=batch-ids-extensions.d.ts.map

package/dist/i3s-converter/helpers/batch-ids-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-ids-extensions.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/batch-ids-extensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,yBAAyB,EAAC,MAAM,uCAAuC,CAAC;AACrF,OAAO,KAAK,EAAC,KAAK,EAAE,aAAa,EAAC,MAAM,sDAAsD,CAAC;AAS/F;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE;IACV,CAAC,GAAG,EAAE,MAAM,GAAG,yBAAyB,CAAC;CAC1C,EACD,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,KAAK,EAAE,GACd,MAAM,EAAE,CAwBV"}

package/dist/i3s-converter/helpers/batch-ids-extensions.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleBatchIdsExtensions = void 0;
+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
+ */
+function handleBatchIdsExtensions(attributes, primitive, images) {
+    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, images);
+            case EXT_MESH_FEATURES:
+                console.warn('EXT_mesh_features extension is not supported yet');
+                return [];
+            default:
+                return [];
+        }
+    }
+    return [];
+}
+exports.handleBatchIdsExtensions = handleBatchIdsExtensions;
+/**
+ * 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, extFeatureMetadata, images) {
+    // 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 textureAttributeIndex = featureIdTexture?.featureIds?.texture?.texCoord || 0;
+        const textCoordAttribute = `TEXCOORD_${textureAttributeIndex}`;
+        const textureCoordinates = attributes[textCoordAttribute].value;
+        return generateBatchIdsFromTexture(featureIdTexture, textureCoordinates, images);
+    }
+    // Take only first extension texture to get batchIds from the root EXT_feature_metadata object.
+    const featureTexture = extFeatureMetadata?.featureTextures && extFeatureMetadata?.featureTextures[0];
+    /**
+     * TODO need to get batchIds from root extension
+     */
+    if (featureTexture) {
+        console.warn("EXT_feature_metadata doesn't yet support featureTextures in primitive");
+        return [];
+    }
+    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, constant = 0, divisor = 0) {
+    let featureIds = [];
+    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(featuresCount).fill(constant, 0, featuresCount);
+    }
+    return featureIds;
+}
+/**
+ * Get batchIds from texture.
+ * @param primitive
+ * @param featureIdTextures
+ */
+function generateBatchIdsFromTexture(featureIdTexture, textureCoordinates, images) {
+    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 = [];
+    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) {
+    return ((n % 1) + 1) % 1;
+}

package/dist/i3s-converter/helpers/feature-attributes.d.ts

@@ -0,0 +1,24 @@
+import type { FeatureTableJson } from '@loaders.gl/3d-tiles';
+/**
+ * Takes attributes from property table based on featureIds.
+ * If there is no property value for particular featureId (index) the property will be null.
+ * Example:
+ * Initial data:
+ *   OBJECTID: [0, 1, 5]
+ *   component: ['Windows', 'Frames', 'Wall', 'Roof', 'Skylight']
+ * Result:
+ *   OBJECTID: [0, 1, 5]
+ *   component: ['Windows', 'Frames', 'null']
+ * @param featureIds
+ * @param propertyTable
+ */
+export declare function flattenPropertyTableByFeatureIds(featureIds: number[], propertyTable: FeatureTableJson): FeatureTableJson;
+/**
+ * Check that all attributes in propertyTable have the same length as FeatureIds.
+ * If there are differencies between lengths we should flatten property table based on exiesting featureIds.
+ * @param featureIds
+ * @param propertyTable
+ * @returns
+ */
+export declare function checkPropertiesLength(featureIds: number[], propertyTable: FeatureTableJson): boolean;
+//# sourceMappingURL=feature-attributes.d.ts.map

package/dist/i3s-converter/helpers/feature-attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-attributes.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/feature-attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AAE3D;;;;;;;;;;;;GAYG;AACH,wBAAgB,gCAAgC,CAC9C,UAAU,EAAE,MAAM,EAAE,EACpB,aAAa,EAAE,gBAAgB,GAC9B,gBAAgB,CAQlB;AAkBD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAAE,EACpB,aAAa,EAAE,gBAAgB,GAC9B,OAAO,CAUT"}

package/dist/i3s-converter/helpers/feature-attributes.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPropertiesLength = exports.flattenPropertyTableByFeatureIds = void 0;
+/**
+ * Takes attributes from property table based on featureIds.
+ * If there is no property value for particular featureId (index) the property will be null.
+ * Example:
+ * Initial data:
+ *   OBJECTID: [0, 1, 5]
+ *   component: ['Windows', 'Frames', 'Wall', 'Roof', 'Skylight']
+ * Result:
+ *   OBJECTID: [0, 1, 5]
+ *   component: ['Windows', 'Frames', 'null']
+ * @param featureIds
+ * @param propertyTable
+ */
+function flattenPropertyTableByFeatureIds(featureIds, propertyTable) {
+    const resultPropertyTable = {};
+    for (const propertyName in propertyTable) {
+        const properties = propertyTable[propertyName];
+        resultPropertyTable[propertyName] = getPropertiesByFeatureIds(properties, featureIds);
+    }
+    return resultPropertyTable;
+}
+exports.flattenPropertyTableByFeatureIds = flattenPropertyTableByFeatureIds;
+/**
+ * Getting properties by featureId index
+ * @param properties
+ * @param featureIds
+ */
+function getPropertiesByFeatureIds(properties, featureIds) {
+    const resultProperties = [];
+    for (const featureId of featureIds) {
+        const property = properties[featureId] || null;
+        resultProperties.push(property);
+    }
+    return resultProperties;
+}
+/**
+ * Check that all attributes in propertyTable have the same length as FeatureIds.
+ * If there are differencies between lengths we should flatten property table based on exiesting featureIds.
+ * @param featureIds
+ * @param propertyTable
+ * @returns
+ */
+function checkPropertiesLength(featureIds, propertyTable) {
+    let needFlatten = false;
+    for (const attribute of Object.values(propertyTable)) {
+        if (featureIds.length !== attribute.length) {
+            needFlatten = true;
+        }
+    }
+    return needFlatten;
+}
+exports.checkPropertiesLength = checkPropertiesLength;

package/dist/i3s-converter/helpers/geometry-attributes.js

@@ -38,30 +38,49 @@ exports.generateAttributes = generateAttributes;
 function calculateFaceRangesAndFeaturesCount(featureIndices) {
     let rangeIndex = 1;
     let featureIndex = 1;
-    let currentFeatureId = featureIndices[0];
+    let currentFeatureId = getFrequentValue(featureIndices.slice(0, VALUES_PER_VERTEX));
     const faceRangeList = [];
     const featureIds = [];
     const uniqueFeatureIds = [currentFeatureId];
     faceRangeList[0] = 0;
     featureIds[0] = currentFeatureId;
-    for (let index = 1; index < featureIndices.length; index++) {
-        if (currentFeatureId !== featureIndices[index]) {
+    for (let index = VALUES_PER_VERTEX; index < featureIndices.length; index += VALUES_PER_VERTEX) {
+        const newFeatureId = getFrequentValue(featureIndices.slice(index, index + VALUES_PER_VERTEX));
+        if (currentFeatureId !== newFeatureId) {
             faceRangeList[rangeIndex] = index / VALUES_PER_VERTEX - 1;
             faceRangeList[rangeIndex + 1] = index / VALUES_PER_VERTEX;
-            featureIds[featureIndex] = featureIndices[index];
-            if (!uniqueFeatureIds.includes(featureIndices[index])) {
-                uniqueFeatureIds.push(featureIndices[index]);
+            featureIds[featureIndex] = newFeatureId;
+            if (!uniqueFeatureIds.includes(newFeatureId)) {
+                uniqueFeatureIds.push(newFeatureId);
             }
             rangeIndex += 2;
             featureIndex += 1;
         }
-        currentFeatureId = featureIndices[index];
+        currentFeatureId = newFeatureId;
     }
     faceRangeList[rangeIndex] = featureIndices.length / VALUES_PER_VERTEX - 1;
     const faceRange = new Uint32Array(faceRangeList);
     const featureCount = uniqueFeatureIds.length;
     return { faceRange, featureCount, featureIds };
 }
+/**
+ * Find most frequent value to avoid situation where one vertex can be part of multiple features (objects).
+ * @param values
+ */
+function getFrequentValue(values) {
+    const map = {};
+    let mostFrequentValue = values[0];
+    let maxCount = 1;
+    for (const value of values) {
+        // Save item and it's frequency count to the map.
+        map[value] = (map[value] || 0) + 1;
+        // Find max count of frequency.
+        maxCount = maxCount > map[value] ? maxCount : map[value];
+        // Find the most frequent value.
+        mostFrequentValue = maxCount > map[value] ? mostFrequentValue : value;
+    }
+    return mostFrequentValue;
+}
 /**
  * Generate list of attribute object grouped by feature ids.
  * @param  attributes

package/dist/i3s-converter/helpers/geometry-converter.d.ts

@@ -1,5 +1,6 @@
+import type { B3DMContent, FeatureTableJson } from '@loaders.gl/3d-tiles';
+import { Tile3D } from '@loaders.gl/tiles';
 import { ConvertedAttributes, I3SConvertedResources } from '../types';
-import { B3DMContent } from '@loaders.gl/3d-tiles';
 import { AttributeStorageInfo } from '@loaders.gl/i3s';
 import { Geoid } from '@math.gl/geoid';
 import { B3DMAttributesData } from '../../i3s-attributes-worker';
@@ -15,7 +16,7 @@ import { B3DMAttributesData } from '../../i3s-attributes-worker';
  * @param geoidHeightModel - model to convert elevation from elipsoidal to geoid
  * @returns Array of node resources to create one or more i3s nodes
  */
-export default function convertB3dmToI3sGeometry(tileContent: B3DMContent, nodeId: number, featuresHashArray: string[], attributeStorageInfo: AttributeStorageInfo[] | undefined, draco: boolean, generateBoundingVolumes: boolean, geoidHeightModel: Geoid, workerSource: {
+export default function convertB3dmToI3sGeometry(tileContent: B3DMContent, nodeId: number, propertyTable: FeatureTableJson | null, featuresHashArray: string[], attributeStorageInfo: AttributeStorageInfo[] | undefined, draco: boolean, generateBoundingVolumes: boolean, geoidHeightModel: Geoid, workerSource: {
     [key: string]: string;
 }): Promise<I3SConvertedResources[] | null>;
 /**
@@ -26,4 +27,10 @@ export default function convertB3dmToI3sGeometry(tileContent: B3DMContent, nodeI
  * @returns map of converted geometry attributes
  */
 export declare function convertAttributes(attributesData: B3DMAttributesData, useCartesianPositions: boolean): Promise<Map<string, ConvertedAttributes>>;
+/**
+ * Find property table in tile
+ * For example it can be batchTable for b3dm files or property table in gLTF extension.
+ * @param sourceTile
+ */
+export declare function getPropertyTable(sourceTile: Tile3D): FeatureTableJson | null;
 //# sourceMappingURL=geometry-converter.d.ts.map

package/dist/i3s-converter/helpers/geometry-converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry-converter.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/geometry-converter.ts"],"names":[],"mappings":"AASA,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EAGtB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAC,WAAW,EAAC,MAAM,sBAAsB,CAAC;AAEjD,OAAO,EACL,oBAAoB,EAIrB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAC,KAAK,EAAC,MAAM,gBAAgB,CAAC;AAMrC,OAAO,EAAC,kBAAkB,EAAqC,MAAM,6BAA6B,CAAC;AAwBnG;;;;;;;;;;;GAWG;AACH,wBAA8B,wBAAwB,CACpD,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,MAAM,EAAE,EAC3B,oBAAoB,EAAE,oBAAoB,EAAE,GAAG,SAAS,EACxD,KAAK,EAAE,OAAO,EACd,uBAAuB,EAAE,OAAO,EAChC,gBAAgB,EAAE,KAAK,EACvB,YAAY,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAC,2CAoEtC;AAiID;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,cAAc,EAAE,kBAAkB,EAClC,qBAAqB,EAAE,OAAO,GAC7B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CA0C3C"}
+{"version":3,"file":"geometry-converter.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/geometry-converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,WAAW,EAAE,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AAQxE,OAAO,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AAKzC,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EAGtB,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,oBAAoB,EAIrB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAC,KAAK,EAAC,MAAM,gBAAgB,CAAC;AAMrC,OAAO,EAAC,kBAAkB,EAAqC,MAAM,6BAA6B,CAAC;AA6BnG;;;;;;;;;;;GAWG;AACH,wBAA8B,wBAAwB,CACpD,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,gBAAgB,GAAG,IAAI,EACtC,iBAAiB,EAAE,MAAM,EAAE,EAC3B,oBAAoB,EAAE,oBAAoB,EAAE,GAAG,SAAS,EACxD,KAAK,EAAE,OAAO,EACd,uBAAuB,EAAE,OAAO,EAChC,gBAAgB,EAAE,KAAK,EACvB,YAAY,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAC,2CAqEtC;AAuID;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,cAAc,EAAE,kBAAkB,EAClC,qBAAqB,EAAE,OAAO,GAC7B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CA0C3C;AAu7BD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAoB5E"}

package/dist/i3s-converter/helpers/geometry-converter.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertAttributes = void 0;
+exports.getPropertyTable = exports.convertAttributes = void 0;
 const core_1 = require("@math.gl/core");
 const geospatial_1 = require("@math.gl/geospatial");
 const draco_1 = require("@loaders.gl/draco");
@@ -13,6 +13,8 @@ const md5_1 = __importDefault(require("md5"));
 const geometry_attributes_1 = require("./geometry-attributes");
 const coordinate_converter_1 = require("./coordinate-converter");
 const gltf_attributes_1 = require("./gltf-attributes");
+const batch_ids_extensions_1 = require("./batch-ids-extensions");
+const feature_attributes_1 = require("./feature-attributes");
 // Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.7/pbrMetallicRoughness.cmn.md
 const DEFAULT_ROUGHNESS_FACTOR = 1;
 const DEFAULT_METALLIC_FACTOR = 1;
@@ -29,6 +31,8 @@ const OBJECT_ID_TYPE = 'Oid32';
  * BATCHID - Legacy attribute name which includes batch info.
  */
 const BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES = ['CUSTOM_ATTRIBUTE_2', '_BATCHID', 'BATCHID'];
+const EXT_FEATURE_METADATA = 'EXT_feature_metadata';
+const EXT_MESH_FEATURES = 'EXT_mesh_features';
 let scratchVector = new core_1.Vector3();
 /**
  * Convert binary data from b3dm file to i3s resources
@@ -42,7 +46,7 @@ let scratchVector = new core_1.Vector3();
  * @param geoidHeightModel - model to convert elevation from elipsoidal to geoid
  * @returns Array of node resources to create one or more i3s nodes
  */
-async function convertB3dmToI3sGeometry(tileContent, nodeId, featuresHashArray, attributeStorageInfo, draco, generateBoundingVolumes, geoidHeightModel, workerSource) {
+async function convertB3dmToI3sGeometry(tileContent, nodeId, propertyTable, featuresHashArray, attributeStorageInfo, draco, generateBoundingVolumes, geoidHeightModel, workerSource) {
     const useCartesianPositions = generateBoundingVolumes;
     const materialAndTextureList = convertMaterials(tileContent.gltf?.materials);
     const dataForAttributesConversion = (0, gltf_attributes_1.prepareDataForAttributesConversion)(tileContent);
@@ -86,6 +90,7 @@ async function convertB3dmToI3sGeometry(tileContent, nodeId, featuresHashArray,
             tileContent,
             nodeId: nodesCounter,
             featuresHashArray,
+            propertyTable,
             attributeStorageInfo,
             draco,
             workerSource
@@ -131,7 +136,7 @@ function _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeigh
  * @param params.draco - is converter should create draco compressed geometry
  * @returns Array of I3S node resources
  */
-async function _makeNodeResources({ convertedAttributes, material, texture, tileContent, nodeId, featuresHashArray, attributeStorageInfo, draco, workerSource }) {
+async function _makeNodeResources({ convertedAttributes, material, texture, tileContent, nodeId, featuresHashArray, propertyTable, attributeStorageInfo, draco, workerSource }) {
     const boundingVolumes = convertedAttributes.boundingVolumes;
     const vertexCount = convertedAttributes.positions.length / VALUES_PER_VERTEX;
     const { faceRange, featureIds, positions, normals, colors, texCoords, featureCount } = (0, geometry_attributes_1.generateAttributes)(convertedAttributes);
@@ -152,7 +157,10 @@ async function _makeNodeResources({ convertedAttributes, material, texture, tile
             faceRange
         }, workerSource.draco)
         : null;
-    const attributes = convertBatchTableToAttributeBuffers(tileContent.batchTableJson, featureIds, attributeStorageInfo);
+    let attributes = [];
+    if (attributeStorageInfo && propertyTable) {
+        attributes = convertPropertyTableToAttributeBuffers(featureIds, propertyTable, attributeStorageInfo);
+    }
     return {
         geometry: fileBuffer,
         compressedGeometry,
@@ -258,8 +266,9 @@ function getCompositeTransformationMatrix(node, matrix) {
 function convertNode(node, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new core_1.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
     const transformationMatrix = getCompositeTransformationMatrix(node, matrix);
     const mesh = node.mesh;
+    const images = node.images;
     if (mesh) {
-        convertMesh(mesh, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, transformationMatrix);
+        convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, transformationMatrix);
     }
     convertNodes(node.children || [], cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, transformationMatrix);
 }
@@ -274,7 +283,7 @@ function convertNode(node, cartographicOrigin, cartesianModelMatrix, attributesM
  
  * @param {Matrix4} matrix - transformation matrix - cumulative transformation matrix formed from all parent node matrices
  */
-function convertMesh(mesh, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions = false, matrix = new core_1.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
+function convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions = false, matrix = new core_1.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
     for (const primitive of mesh.primitives) {
         let outputAttributes = null;
         if (primitive.material) {
@@ -309,7 +318,7 @@ function convertMesh(mesh, cartographicOrigin, cartesianModelMatrix, attributesM
         outputAttributes.texCoords = (0, loader_utils_1.concatenateTypedArrays)(outputAttributes.texCoords, flattenTexCoords(attributes.TEXCOORD_0 && attributes.TEXCOORD_0.value, primitive.indices?.value));
         outputAttributes.colors = (0, loader_utils_1.concatenateTypedArrays)(outputAttributes.colors, flattenColors(attributes.COLOR_0, primitive.indices?.value));
         outputAttributes.featureIndicesGroups = outputAttributes.featureIndicesGroups || [];
-        outputAttributes.featureIndicesGroups.push(flattenBatchIds(getBatchIdsByAttributeName(attributes), primitive.indices?.value));
+        outputAttributes.featureIndicesGroups.push(flattenBatchIds(getBatchIds(attributes, primitive, images), primitive.indices?.value));
     }
 }
 /**
@@ -446,21 +455,24 @@ function flattenBatchIds(batchedIds, indices) {
     return newBatchIds;
 }
 /**
- * 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) {
-    let batchIds = [];
+function getBatchIds(attributes, primitive, images) {
+    const batchIds = (0, batch_ids_extensions_1.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];
         if (attributes[possibleBatchIdAttributeName] &&
             attributes[possibleBatchIdAttributeName].value) {
-            batchIds = attributes[possibleBatchIdAttributeName].value;
-            break;
+            return attributes[possibleBatchIdAttributeName].value;
         }
     }
-    return batchIds;
+    return [];
 }
 /**
  * Convert GLTF material to I3S material definitions and textures
@@ -738,43 +750,53 @@ function replaceIndicesByUnique(indicesArray, featureMap) {
     }
 }
 /**
- * Convert batch table data to attribute buffers.
- * @param {Object} batchTable - table with metadata for particular feature.
+ * Convert property table data to attribute buffers.
+ * @param {Object} propertyTable - table with metadata for particular feature.
  * @param {Array} featureIds
  * @param {Array} attributeStorageInfo
  * @returns {Array} - Array of file buffers.
  */
-function convertBatchTableToAttributeBuffers(batchTable, featureIds, attributeStorageInfo) {
+function convertPropertyTableToAttributeBuffers(featureIds, propertyTable, attributeStorageInfo) {
     const attributeBuffers = [];
-    if (batchTable) {
-        const batchTableWithFeatureIds = {
-            OBJECTID: featureIds,
-            ...batchTable
-        };
-        for (const key in batchTableWithFeatureIds) {
-            const type = getAttributeType(key, attributeStorageInfo);
-            let attributeBuffer = null;
-            switch (type) {
-                case OBJECT_ID_TYPE:
-                case SHORT_INT_TYPE:
-                    attributeBuffer = generateShortIntegerAttributeBuffer(batchTableWithFeatureIds[key]);
-                    break;
-                case DOUBLE_TYPE:
-                    attributeBuffer = generateDoubleAttributeBuffer(batchTableWithFeatureIds[key]);
-                    break;
-                case STRING_TYPE:
-                    attributeBuffer = generateStringAttributeBuffer(batchTableWithFeatureIds[key]);
-                    break;
-                default:
-                    attributeBuffer = generateStringAttributeBuffer(batchTableWithFeatureIds[key]);
-            }
-            if (attributeBuffer) {
-                attributeBuffers.push(attributeBuffer);
-            }
-        }
+    const needFlattenPropertyTable = (0, feature_attributes_1.checkPropertiesLength)(featureIds, propertyTable);
+    const properties = needFlattenPropertyTable
+        ? (0, feature_attributes_1.flattenPropertyTableByFeatureIds)(featureIds, propertyTable)
+        : propertyTable;
+    const propertyTableWithObjectIds = {
+        OBJECTID: featureIds,
+        ...properties
+    };
+    for (const propertyName in propertyTableWithObjectIds) {
+        const type = getAttributeType(propertyName, attributeStorageInfo);
+        const value = propertyTableWithObjectIds[propertyName];
+        const attributeBuffer = generateAttributeBuffer(type, value);
+        attributeBuffers.push(attributeBuffer);
     }
     return attributeBuffers;
 }
+/**
+ * Generates attribute buffer based on attribute type
+ * @param type
+ * @param value
+ */
+function generateAttributeBuffer(type, value) {
+    let attributeBuffer;
+    switch (type) {
+        case OBJECT_ID_TYPE:
+        case SHORT_INT_TYPE:
+            attributeBuffer = generateShortIntegerAttributeBuffer(value);
+            break;
+        case DOUBLE_TYPE:
+            attributeBuffer = generateDoubleAttributeBuffer(value);
+            break;
+        case STRING_TYPE:
+            attributeBuffer = generateStringAttributeBuffer(value);
+            break;
+        default:
+            attributeBuffer = generateStringAttributeBuffer(value);
+    }
+    return attributeBuffer;
+}
 /**
  * Return attribute type.
  * @param {String} key
@@ -899,3 +921,77 @@ function generateFeatureIndexAttribute(featureIndex, faceRange) {
     }
     return orderedFeatureIndices;
 }
+/**
+ * Find property table in tile
+ * For example it can be batchTable for b3dm files or property table in gLTF extension.
+ * @param sourceTile
+ */
+function getPropertyTable(sourceTile) {
+    const batchTableJson = sourceTile?.content?.batchTableJson;
+    if (batchTableJson) {
+        return batchTableJson;
+    }
+    const { extensionName, extension } = getPropertyTableExtension(sourceTile);
+    switch (extensionName) {
+        case EXT_MESH_FEATURES: {
+            console.warn('The I3S converter does not yet support the EXT_mesh_features extension');
+            return null;
+        }
+        case EXT_FEATURE_METADATA: {
+            return getPropertyTableFromExtFeatureMetadata(extension);
+        }
+        default:
+            return null;
+    }
+}
+exports.getPropertyTable = getPropertyTable;
+/**
+ * Check extensions which can be with property table inside.
+ * @param sourceTile
+ */
+function getPropertyTableExtension(sourceTile) {
+    const extensionsWithPropertyTables = [EXT_FEATURE_METADATA, EXT_MESH_FEATURES];
+    const extensionsUsed = sourceTile?.content?.gltf?.extensionsUsed;
+    if (!extensionsUsed) {
+        return { extensionName: null, extension: null };
+    }
+    let extensionName = '';
+    for (const extensionItem of sourceTile?.content?.gltf?.extensionsUsed) {
+        if (extensionsWithPropertyTables.includes(extensionItem)) {
+            extensionName = extensionItem;
+            break;
+        }
+    }
+    const extension = sourceTile?.content?.gltf?.extensions?.[extensionName];
+    return { extensionName, extension };
+}
+/**
+ * Handle EXT_feature_metadata to get property table
+ * @param extension
+ * TODO add EXT_feature_metadata feature textures support.
+ */
+function getPropertyTableFromExtFeatureMetadata(extension) {
+    if (extension?.featureTextures) {
+        console.warn('The I3S converter does not yet support the EXT_feature_metadata feature textures');
+        return null;
+    }
+    if (extension?.featureTables) {
+        /**
+         * Take only first feature table to generate attributes storage info object.
+         * TODO: Think about getting data from all feature tables?
+         * It can be tricky just because 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.
+         */
+        const firstFeatureTableName = Object.keys(extension.featureTables)?.[0];
+        if (firstFeatureTableName) {
+            const featureTable = extension?.featureTables[firstFeatureTableName];
+            const propertyTable = {};
+            for (const propertyName in featureTable.properties) {
+                propertyTable[propertyName] = featureTable.properties[propertyName].data;
+            }
+            return propertyTable;
+        }
+    }
+    console.warn("The I3S converter couldn't handle EXT_feature_metadata extension");
+    return null;
+}

package/dist/i3s-converter/helpers/gltf-attributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf-attributes.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/gltf-attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,6BAA6B,CAAC;AAsBpE;;;;GAIG;AACH,wBAAgB,kCAAkC,CAAC,WAAW,EAAE,WAAW,GAAG,kBAAkB,CAsC/F"}
+{"version":3,"file":"gltf-attributes.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/gltf-attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,6BAA6B,CAAC;AAsBpE;;;;GAIG;AACH,wBAAgB,kCAAkC,CAAC,WAAW,EAAE,WAAW,GAAG,kBAAkB,CAqD/F"}

package/dist/i3s-converter/helpers/gltf-attributes.js

@@ -25,12 +25,25 @@ function prepareDataForAttributesConversion(tileContent) {
         tileContent.gltf?.scenes?.[0]?.nodes ||
         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;
         }
         return {
             ...node,
+            images,
             mesh: {
                 ...node.mesh,
                 primitives: node.mesh?.primitives.map((primitive) => ({