@loaders.gl/tile-converter 3.4.11 → 3.4.12

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

@@ -1,216 +0,0 @@
-"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.js

@@ -1,202 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateAttributes = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const VALUES_PER_VERTEX = 3;
-const POSITIONS_AND_NORMALS_PER_TRIANGLE = 9;
-/**
- * Generate geometry attributes with faceRange and featureCount
- * @param attributes
- * @returns attirbutes with featureCount, featureIds and changed faceRange.
- */
-function generateAttributes(attributes) {
-    const { positions, normals, texCoords, colors, uvRegions, featureIndices } = attributes;
-    const triangleCount = positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE;
-    if (!featureIndices.length) {
-        return {
-            faceRange: new Uint32Array([0, triangleCount - 1]),
-            featureIds: [0],
-            featureCount: 1,
-            positions,
-            normals,
-            texCoords,
-            colors,
-            uvRegions
-        };
-    }
-    const data = calculateFaceRangesAndFeaturesCount(featureIndices);
-    const attributeObjects = makeAttributeObjects({ ...data, ...attributes });
-    const unifiedAttributeObjectsByFeatureIds = unifyObjectsByFeatureId(attributeObjects);
-    const groupedAttributes = groupAttributesAndRangesByFeatureId(unifiedAttributeObjectsByFeatureIds, data.featureCount);
-    return groupedAttributes;
-}
-exports.generateAttributes = generateAttributes;
-/**
- * Calculates face Ranges and feature count based on featureIndices.
- * @param featureIndices
- * @returns Object with featureCount, reordered attributes and changed faceRange.
- */
-function calculateFaceRangesAndFeaturesCount(featureIndices) {
-    let rangeIndex = 1;
-    let featureIndex = 1;
-    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 = 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] = newFeatureId;
-            if (!uniqueFeatureIds.includes(newFeatureId)) {
-                uniqueFeatureIds.push(newFeatureId);
-            }
-            rangeIndex += 2;
-            featureIndex += 1;
-        }
-        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, 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 uvRegionsList = new Uint16Array(uvRegions);
-    for (let index = 0; index < featureIds.length; index++) {
-        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);
-    }
-    return groupedData.sort((first, second) => first.featureId - second.featureId);
-}
-/**
- * Generate sliced count for generating attribute objects depends on attribute name and range.
- * @param attributeName
- * @param startIndex
- * @param endIndex
- * @returns sliced count
- */
-function getSliceAttributeCount(attributeName, startIndex, endIndex) {
-    const itemsPerVertex4 = 4;
-    const texCoordsPerVertex = 2;
-    const trianglesCount = endIndex - startIndex + 1;
-    const vertexCount = trianglesCount * 3;
-    switch (attributeName) {
-        case 'positions':
-        case 'normals':
-            return trianglesCount * POSITIONS_AND_NORMALS_PER_TRIANGLE;
-        case 'colors':
-        case 'uvRegions':
-            return vertexCount * itemsPerVertex4;
-        case 'texCoords':
-            return vertexCount * texCoordsPerVertex;
-        default:
-            return 0;
-    }
-}
-/**
- * Generates unique object list depends on feature ids and concantenate their attributes.
- * @param sortedData
- * @returns unique list of objects
- */
-function unifyObjectsByFeatureId(sortedData) {
-    const uniqueObjects = [];
-    for (let index = 0; index < sortedData.length; index++) {
-        const currentObject = sortedData[index];
-        const existedObject = uniqueObjects.find((obj) => obj.featureId === currentObject.featureId);
-        if (existedObject) {
-            existedObject.positions = (0, loader_utils_1.concatenateTypedArrays)(existedObject.positions, currentObject.positions);
-            existedObject.normals = (0, loader_utils_1.concatenateTypedArrays)(existedObject.normals, currentObject.normals);
-            existedObject.colors = (0, loader_utils_1.concatenateTypedArrays)(existedObject.colors, currentObject.colors);
-            existedObject.texCoords = (0, loader_utils_1.concatenateTypedArrays)(existedObject.texCoords, currentObject.texCoords);
-        }
-        else {
-            uniqueObjects.push(currentObject);
-        }
-    }
-    return uniqueObjects;
-}
-/**
- * Generates attribute objects with new faceRange and reordered attributes.
- * @param unifiedObjects
- * @returns generated attributes with new faceRange.
- */
-function groupAttributesAndRangesByFeatureId(unifiedObjects, featureCount) {
-    const firstAttributeObject = unifiedObjects[0];
-    const featureIds = [firstAttributeObject.featureId || 0];
-    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;
-    let sum = 0;
-    for (let index = 1; index < unifiedObjects.length; index++) {
-        const currentAttributesObject = unifiedObjects[index];
-        featureIds.push(currentAttributesObject.featureId || 0);
-        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);
-        range.push(groupedObject.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE + sum);
-        sum += groupedObject.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE;
-        objIndex += 1;
-    }
-    range.push(positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1);
-    const faceRange = new Uint32Array(range);
-    return { faceRange, featureIds, positions, normals, colors, uvRegions, texCoords, featureCount };
-}