@loaders.gl/tile-converter 3.2.12 → 3.3.0-alpha.10

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

@@ -0,0 +1,11 @@
+import { GLTFAccessorPostprocessed, GLTFImagePostprocessed, GLTFMeshPrimitivePostprocessed } from '@loaders.gl/gltf';
+/**
+ * Getting batchIds from 3DTilesNext extensions.
+ * @param attributes - gltf accessors
+ * @param primitive - gltf primitive data
+ * @param images - gltf texture images
+ */
+export declare function handleBatchIdsExtensions(attributes: {
+    [key: string]: GLTFAccessorPostprocessed;
+}, primitive: GLTFMeshPrimitivePostprocessed, images: GLTFImagePostprocessed[]): 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,EACL,yBAAyB,EACzB,sBAAsB,EACtB,8BAA8B,EAC/B,MAAM,kBAAkB,CAAC;AAS1B;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE;IACV,CAAC,GAAG,EAAE,MAAM,GAAG,yBAAyB,CAAC;CAC1C,EACD,SAAS,EAAE,8BAA8B,EACzC,MAAM,EAAE,sBAAsB,EAAE,GAC/B,MAAM,EAAE,CAwBV"}

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

@@ -0,0 +1,141 @@
+"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 - gltf accessors
+ * @param primitive - gltf primitive data
+ * @param images - gltf texture images
+ */
+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) {
+    if (!images?.length) {
+        return [];
+    }
+    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/coordinate-converter.d.ts

@@ -1,7 +1,7 @@
 import type { BoundingVolumes, FullExtent, Mbs, Obb } from '@loaders.gl/i3s';
 import { Vector3 } from '@math.gl/core';
 import { OrientedBoundingBox, BoundingSphere } from '@math.gl/culling';
-import TileHeader from '@loaders.gl/tiles/src/tileset/tile-3d';
+import { Tile3D } from '@loaders.gl/tiles';
 import { Geoid } from '@math.gl/geoid';
 /**
  * Create bounding volumes object from tile and geoid height model.
@@ -9,7 +9,7 @@ import { Geoid } from '@math.gl/geoid';
  * @param geoidHeightModel
  * @returns - Bounding volumes object
  */
-export declare function createBoundingVolumes(tile: TileHeader, geoidHeightModel: Geoid): BoundingVolumes;
+export declare function createBoundingVolumes(tile: Tile3D, geoidHeightModel: Geoid): BoundingVolumes;
 /**
  * Generates bounding volumes from geometry positions
  * @param cartesianPositions

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

@@ -1 +1 @@
-{"version":3,"file":"coordinate-converter.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/coordinate-converter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,eAAe,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,EAAC,MAAM,iBAAiB,CAAC;AAE3E,OAAO,EAAsB,OAAO,EAAC,MAAM,eAAe,CAAC;AAE3D,OAAO,EACL,mBAAmB,EAGnB,cAAc,EACf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,UAAU,MAAM,uCAAuC,CAAC;AAC/D,OAAO,EAAC,KAAK,EAAC,MAAM,gBAAgB,CAAC;AAErC;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,UAAU,EAAE,gBAAgB,EAAE,KAAK,GAAG,eAAe,CAiChG;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC/C,kBAAkB,EAAE,YAAY,EAChC,gBAAgB,EAAE,KAAK,GACtB;IAAC,GAAG,EAAE,GAAG,CAAC;IAAC,GAAG,EAAE,GAAG,CAAA;CAAC,CAoBtB;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,EAAE,CAW5E;AAED;;;;;GAKG;AACH,wBAAgB,oCAAoC,CAClD,cAAc,EAAE,mBAAmB,GAAG,cAAc,GACnD,UAAU,CA4BZ;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAK9C"}
+{"version":3,"file":"coordinate-converter.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/coordinate-converter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,eAAe,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,EAAC,MAAM,iBAAiB,CAAC;AAE3E,OAAO,EAAsB,OAAO,EAAC,MAAM,eAAe,CAAC;AAE3D,OAAO,EACL,mBAAmB,EAGnB,cAAc,EACf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAC,KAAK,EAAC,MAAM,gBAAgB,CAAC;AAErC;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,KAAK,GAAG,eAAe,CAiC5F;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC/C,kBAAkB,EAAE,YAAY,EAChC,gBAAgB,EAAE,KAAK,GACtB;IAAC,GAAG,EAAE,GAAG,CAAC;IAAC,GAAG,EAAE,GAAG,CAAA;CAAC,CAoBtB;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,EAAE,CAW5E;AAED;;;;;GAKG;AACH,wBAAgB,oCAAoC,CAClD,cAAc,EAAE,mBAAmB,GAAG,cAAc,GACnD,UAAU,CA4BZ;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAK9C"}

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

@@ -0,0 +1,56 @@
+import type { FeatureTableJson } from '@loaders.gl/3d-tiles';
+import { Attribute, AttributeStorageInfo, ESRIField, Field, PopupInfo } from '@loaders.gl/i3s';
+/**
+ * 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;
+/**
+ * Get the attribute type for attributeStorageInfo https://github.com/Esri/i3s-spec/blob/master/docs/1.7/attributeStorageInfo.cmn.md
+ * @param key - attribute's key
+ * @param attribute - attribute's type in propertyTable
+ */
+export declare function getAttributeType(key: string, attribute: string): string;
+/**
+ * Generate storage attribute for map segmentation.
+ * @param attributeIndex - order index of attribute (f_0, f_1 ...).
+ * @param key - attribute key from propertyTable.
+ * @param attributeType - attribute type.
+ * @return Updated storageAttribute.
+ */
+export declare function createdStorageAttribute(attributeIndex: number, key: string, attributeType: Attribute): AttributeStorageInfo;
+/**
+ * Find and return attribute type based on key form propertyTable.
+ * @param attributeType
+ */
+export declare function getFieldAttributeType(attributeType: Attribute): ESRIField;
+/**
+ * Setup field attribute for map segmentation.
+ * @param key - attribute for map segmentation.
+ * @param fieldAttributeType - esri attribute type ('esriFieldTypeString' or 'esriFieldTypeOID').
+ */
+export declare function createFieldAttribute(key: string, fieldAttributeType: ESRIField): Field;
+/**
+ * Generate popup info to show metadata on the map.
+ * @param propertyTable - table data with OBJECTID.
+ * @return data for correct rendering of popup.
+ */
+export declare function createPopupInfo(propertyTable: FeatureTableJson): PopupInfo;
+//# 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;AAC3D,OAAO,EACL,SAAS,EACT,oBAAoB,EACpB,SAAS,EACT,KAAK,EAEL,SAAS,EACV,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;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;AAUD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAUvE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,MAAM,EACtB,GAAG,EAAE,MAAM,EACX,aAAa,EAAE,SAAS,GACvB,oBAAoB,CA0BtB;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,SAAS,GAAG,SAAS,CAazE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,kBAAkB,EAAE,SAAS,GAAG,KAAK,CAMtF;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,aAAa,EAAE,gBAAgB,GAAG,SAAS,CA8B1E"}

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

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPopupInfo = exports.createFieldAttribute = exports.getFieldAttributeType = exports.createdStorageAttribute = exports.getAttributeType = 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;
+/** String data type name for feature attributes */
+const STRING_TYPE = 'string';
+/** Integer data type name for feature attributes */
+const SHORT_INT_TYPE = 'Int32';
+/** Double data type name for feature attributes */
+const DOUBLE_TYPE = 'double';
+/** Type of attribute that is linked with feature ids */
+const OBJECT_ID_TYPE = 'OBJECTID';
+/**
+ * Get the attribute type for attributeStorageInfo https://github.com/Esri/i3s-spec/blob/master/docs/1.7/attributeStorageInfo.cmn.md
+ * @param key - attribute's key
+ * @param attribute - attribute's type in propertyTable
+ */
+function getAttributeType(key, attribute) {
+    if (key === OBJECT_ID_TYPE) {
+        return OBJECT_ID_TYPE;
+    }
+    if (typeof attribute === STRING_TYPE) {
+        return STRING_TYPE;
+    }
+    else if (typeof attribute === 'number') {
+        return Number.isInteger(attribute) ? SHORT_INT_TYPE : DOUBLE_TYPE;
+    }
+    return STRING_TYPE;
+}
+exports.getAttributeType = getAttributeType;
+/**
+ * Generate storage attribute for map segmentation.
+ * @param attributeIndex - order index of attribute (f_0, f_1 ...).
+ * @param key - attribute key from propertyTable.
+ * @param attributeType - attribute type.
+ * @return Updated storageAttribute.
+ */
+function createdStorageAttribute(attributeIndex, key, attributeType) {
+    const storageAttribute = {
+        key: `f_${attributeIndex}`,
+        name: key,
+        ordering: ['attributeValues'],
+        header: [{ property: 'count', valueType: 'UInt32' }],
+        attributeValues: { valueType: 'Int32', valuesPerElement: 1 }
+    };
+    switch (attributeType) {
+        case OBJECT_ID_TYPE:
+            setupIdAttribute(storageAttribute);
+            break;
+        case STRING_TYPE:
+            setupStringAttribute(storageAttribute);
+            break;
+        case DOUBLE_TYPE:
+            setupDoubleAttribute(storageAttribute);
+            break;
+        case SHORT_INT_TYPE:
+            break;
+        default:
+            setupStringAttribute(storageAttribute);
+    }
+    return storageAttribute;
+}
+exports.createdStorageAttribute = createdStorageAttribute;
+/**
+ * Find and return attribute type based on key form propertyTable.
+ * @param attributeType
+ */
+function getFieldAttributeType(attributeType) {
+    switch (attributeType) {
+        case OBJECT_ID_TYPE:
+            return 'esriFieldTypeOID';
+        case STRING_TYPE:
+            return 'esriFieldTypeString';
+        case SHORT_INT_TYPE:
+            return 'esriFieldTypeInteger';
+        case DOUBLE_TYPE:
+            return 'esriFieldTypeDouble';
+        default:
+            return 'esriFieldTypeString';
+    }
+}
+exports.getFieldAttributeType = getFieldAttributeType;
+/**
+ * Setup field attribute for map segmentation.
+ * @param key - attribute for map segmentation.
+ * @param fieldAttributeType - esri attribute type ('esriFieldTypeString' or 'esriFieldTypeOID').
+ */
+function createFieldAttribute(key, fieldAttributeType) {
+    return {
+        name: key,
+        type: fieldAttributeType,
+        alias: key
+    };
+}
+exports.createFieldAttribute = createFieldAttribute;
+/**
+ * Generate popup info to show metadata on the map.
+ * @param propertyTable - table data with OBJECTID.
+ * @return data for correct rendering of popup.
+ */
+function createPopupInfo(propertyTable) {
+    const title = '{OBJECTID}';
+    const mediaInfos = [];
+    const fieldInfos = [];
+    const popupElements = [];
+    const expressionInfos = [];
+    for (const key in propertyTable) {
+        fieldInfos.push({
+            fieldName: key,
+            visible: true,
+            isEditable: false,
+            label: key
+        });
+    }
+    popupElements.push({
+        fieldInfos,
+        type: 'fields'
+    });
+    return {
+        title,
+        mediaInfos,
+        popupElements,
+        fieldInfos,
+        expressionInfos
+    };
+}
+exports.createPopupInfo = createPopupInfo;
+/**
+ * Setup storage attribute as string.
+ * @param storageAttribute - attribute for map segmentation.
+ */
+function setupStringAttribute(storageAttribute) {
+    // @ts-expect-error
+    storageAttribute.ordering.unshift('attributeByteCounts');
+    storageAttribute.header.push({ property: 'attributeValuesByteCount', valueType: 'UInt32' });
+    storageAttribute.attributeValues = {
+        valueType: 'String',
+        encoding: 'UTF-8',
+        valuesPerElement: 1
+    };
+    storageAttribute.attributeByteCounts = {
+        valueType: 'UInt32',
+        valuesPerElement: 1
+    };
+}
+/**
+ * Setup Id attribute for map segmentation.
+ * @param storageAttribute - attribute for map segmentation .
+ */
+function setupIdAttribute(storageAttribute) {
+    storageAttribute.attributeValues = {
+        valueType: 'Oid32',
+        valuesPerElement: 1
+    };
+}
+/**
+ * Setup double attribute for map segmentation.
+ * @param storageAttribute - attribute for map segmentation .
+ */
+function setupDoubleAttribute(storageAttribute) {
+    storageAttribute.attributeValues = {
+        valueType: 'Float64',
+        valuesPerElement: 1
+    };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"geometry-attributes.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/geometry-attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAE,mBAAmB,EAA+B,MAAM,UAAU,CAAC;AAMpG;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,mBAAmB,GAAG,kBAAkB,CAwBtF"}
+{"version":3,"file":"geometry-attributes.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/geometry-attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAE,mBAAmB,EAA+B,MAAM,UAAU,CAAC;AAMpG;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,mBAAmB,GAAG,kBAAkB,CAyBtF"}

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

@@ -10,7 +10,7 @@ const POSITIONS_AND_NORMALS_PER_TRIANGLE = 9;
  * @returns attirbutes with featureCount, featureIds and changed faceRange.
  */
 function generateAttributes(attributes) {
-    const { positions, normals, texCoords, colors, featureIndices } = attributes;
+    const { positions, normals, texCoords, colors, uvRegions, featureIndices } = attributes;
     const triangleCount = positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE;
     if (!featureIndices.length) {
         return {
@@ -20,7 +20,8 @@ function generateAttributes(attributes) {
             positions,
             normals,
             texCoords,
-            colors
+            colors,
+            uvRegions
         };
     }
     const data = calculateFaceRangesAndFeaturesCount(featureIndices);
@@ -38,62 +39,83 @@ 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
  * @returns sorted list of attribute objects.
  */
 function makeAttributeObjects(attributes) {
-    const { featureIds, positions, normals, colors, texCoords, faceRange = new Uint32Array(0) } = attributes;
+    const { featureIds, positions, normals, colors, uvRegions, texCoords, faceRange = new Uint32Array(0) } = attributes;
     const groupedData = [];
     let positionsList = new Float32Array(positions);
     let normalsList = new Float32Array(normals);
     let colorsList = new Uint8Array(colors);
     let texCoordsList = new Float32Array(texCoords);
-    let faceRangeIndex = 0;
+    let uvRegionsList = new Uint16Array(uvRegions);
     for (let index = 0; index < featureIds.length; index++) {
-        const startIndex = faceRange[index + faceRangeIndex];
-        const endIndex = faceRange[index + faceRangeIndex + 1];
+        const startIndex = faceRange[index * 2];
+        const endIndex = faceRange[index * 2 + 1];
         const positionsCount = getSliceAttributeCount('positions', startIndex, endIndex);
         const normalsCount = getSliceAttributeCount('normals', startIndex, endIndex);
         const colorsCount = getSliceAttributeCount('colors', startIndex, endIndex);
+        const uvRegionsCount = getSliceAttributeCount('uvRegions', startIndex, endIndex);
         const texCoordsCount = getSliceAttributeCount('texCoords', startIndex, endIndex);
         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)
         });
         positionsList = positionsList.slice(positionsCount);
         normalsList = normalsList.slice(normalsCount);
         colorsList = colorsList.slice(colorsCount);
+        uvRegionsList = uvRegionsList.slice(uvRegionsCount);
         texCoordsList = texCoordsList.slice(texCoordsCount);
-        faceRangeIndex += 1;
     }
     return groupedData.sort((first, second) => first.featureId - second.featureId);
 }
@@ -105,7 +127,7 @@ function makeAttributeObjects(attributes) {
  * @returns sliced count
  */
 function getSliceAttributeCount(attributeName, startIndex, endIndex) {
-    const colorsPerVertex = 4;
+    const itemsPerVertex4 = 4;
     const texCoordsPerVertex = 2;
     const trianglesCount = endIndex - startIndex + 1;
     const vertexCount = trianglesCount * 3;
@@ -114,7 +136,8 @@ function getSliceAttributeCount(attributeName, startIndex, endIndex) {
         case 'normals':
             return trianglesCount * POSITIONS_AND_NORMALS_PER_TRIANGLE;
         case 'colors':
-            return vertexCount * colorsPerVertex;
+        case 'uvRegions':
+            return vertexCount * itemsPerVertex4;
         case 'texCoords':
             return vertexCount * texCoordsPerVertex;
         default:
@@ -154,6 +177,7 @@ function groupAttributesAndRangesByFeatureId(unifiedObjects, featureCount) {
     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;
@@ -164,6 +188,7 @@ function groupAttributesAndRangesByFeatureId(unifiedObjects, featureCount) {
         positions = (0, loader_utils_1.concatenateTypedArrays)(positions, currentAttributesObject.positions);
         normals = (0, loader_utils_1.concatenateTypedArrays)(normals, currentAttributesObject.normals);
         colors = (0, loader_utils_1.concatenateTypedArrays)(colors, currentAttributesObject.colors);
+        uvRegions = (0, loader_utils_1.concatenateTypedArrays)(uvRegions, currentAttributesObject.uvRegions);
         texCoords = (0, loader_utils_1.concatenateTypedArrays)(texCoords, currentAttributesObject.texCoords);
         const groupedObject = unifiedObjects[objIndex];
         range.push(groupedObject.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1 + sum);
@@ -173,5 +198,5 @@ function groupAttributesAndRangesByFeatureId(unifiedObjects, featureCount) {
     }
     range.push(positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1);
     const faceRange = new Uint32Array(range);
-    return { faceRange, featureIds, positions, normals, colors, texCoords, featureCount };
+    return { faceRange, featureIds, positions, normals, colors, uvRegions, texCoords, featureCount };
 }

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

@@ -1,29 +1,41 @@
-import { ConvertedAttributes, I3SConvertedResources } from '../types';
-import { B3DMContent } from '@loaders.gl/3d-tiles';
+import type { B3DMContent, FeatureTableJson } from '@loaders.gl/3d-tiles';
+import { ConvertedAttributes, I3SConvertedResources, I3SMaterialWithTexture } from '../types';
 import { AttributeStorageInfo } from '@loaders.gl/i3s';
 import { Geoid } from '@math.gl/geoid';
+/** Usage of worker here brings more overhead than advantage */
 import { B3DMAttributesData } from '../../i3s-attributes-worker';
 /**
  * Convert binary data from b3dm file to i3s resources
  *
  * @param tileContent - 3d tile content
- * @param nodeId - target nodeId. If a few nodes will be created - ids will be nodeId+n where n - index in the resulting array
+ * @param addNodeToNodePage - function to add new node to node pages
+ * @param propertyTable - batch table (corresponding to feature attributes data)
  * @param featuresHashArray - hash array of features that is needed to not to mix up same features in parent and child nodes
  * @param attributeStorageInfo - attributes metadata from 3DSceneLayer json
  * @param draco - is converter should create draco compressed geometry
  * @param generateBoundingVolumes - is converter should create accurate bounding voulmes from geometry attributes
+ * @param shouldMergeMaterials - Try to merge similar materials to be able to merge meshes into one node
  * @param geoidHeightModel - model to convert elevation from elipsoidal to geoid
+ * @param workerSource - source code of used workers
  * @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, addNodeToNodePage: () => Promise<number>, propertyTable: FeatureTableJson | null, featuresHashArray: string[], attributeStorageInfo: AttributeStorageInfo[] | undefined, draco: boolean, generateBoundingVolumes: boolean, shouldMergeMaterials: boolean, geoidHeightModel: Geoid, workerSource: {
     [key: string]: string;
 }): Promise<I3SConvertedResources[] | null>;
 /**
  * Convert attributes from the gltf nodes tree to i3s plain geometry
- * @param tileContent - 3d tile content
+ * @param attributesData - geometry attributes from gltf
+ * @param materialAndTextureList - array of data about materials and textures of the content
  * @param useCartesianPositions - convert positions to absolute cartesian coordinates instead of cartographic offsets.
  * Cartesian coordinates will be required for creating bounding voulmest from geometry positions
  * @returns map of converted geometry attributes
  */
-export declare function convertAttributes(attributesData: B3DMAttributesData, useCartesianPositions: boolean): Promise<Map<string, ConvertedAttributes>>;
+export declare function convertAttributes(attributesData: B3DMAttributesData, materialAndTextureList: I3SMaterialWithTexture[], 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
+ * @return batch table from b3dm / feature properties from EXT_FEATURE_METADATA
+ */
+export declare function getPropertyTable(tileContent: B3DMContent): FeatureTableJson | null;
 //# sourceMappingURL=geometry-converter.d.ts.map