@loaders.gl/tile-converter 3.1.8 → 3.2.0-alpha.1

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createObbFromMbs = exports.convertCommonToI3SExtentCoordinate = exports.convertPositionsToVectors = exports.createBoundingVolumesFromGeometry = exports.createBoundingVolumes = void 0;
+const core_1 = require("@math.gl/core");
+const geospatial_1 = require("@math.gl/geospatial");
+const culling_1 = require("@math.gl/culling");
+/**
+ * Create bounding volumes object from tile and geoid height model.
+ * @param tile
+ * @param geoidHeightModel
+ * @returns - Bounding volumes object
+ */
+function createBoundingVolumes(tile, geoidHeightModel) {
+    let radius;
+    let halfSize;
+    let quaternion;
+    const boundingVolume = tile.boundingVolume;
+    const cartographicCenter = geospatial_1.Ellipsoid.WGS84.cartesianToCartographic(boundingVolume.center, new core_1.Vector3());
+    cartographicCenter[2] =
+        cartographicCenter[2] -
+            geoidHeightModel.getHeight(cartographicCenter[1], cartographicCenter[0]);
+    if (boundingVolume instanceof culling_1.OrientedBoundingBox) {
+        halfSize = boundingVolume.halfSize;
+        radius = new core_1.Vector3(halfSize[0], halfSize[1], halfSize[2]).len();
+        quaternion = boundingVolume.quaternion;
+    }
+    else {
+        radius = tile.boundingVolume.radius;
+        halfSize = [radius, radius, radius];
+        quaternion = new core_1.Quaternion()
+            .fromMatrix3(new core_1.Matrix3([halfSize[0], 0, 0, 0, halfSize[1], 0, 0, 0, halfSize[2]]))
+            .normalize();
+    }
+    return {
+        mbs: [cartographicCenter[0], cartographicCenter[1], cartographicCenter[2], radius],
+        obb: {
+            center: [cartographicCenter[0], cartographicCenter[1], cartographicCenter[2]],
+            halfSize,
+            quaternion
+        }
+    };
+}
+exports.createBoundingVolumes = createBoundingVolumes;
+/**
+ * Generates bounding volumes from geometry positions
+ * @param cartesianPositions
+ * @param geoidHeightModel
+ */
+function createBoundingVolumesFromGeometry(cartesianPositions, geoidHeightModel) {
+    const positionVectors = convertPositionsToVectors(cartesianPositions);
+    const geometryObb = (0, culling_1.makeOrientedBoundingBoxFromPoints)(positionVectors);
+    const geometryMbs = (0, culling_1.makeBoundingSphereFromPoints)(positionVectors);
+    let mbsCenter = geospatial_1.Ellipsoid.WGS84.cartesianToCartographic(geometryMbs.center, new core_1.Vector3());
+    let obbCenter = geospatial_1.Ellipsoid.WGS84.cartesianToCartographic(geometryObb.center, new core_1.Vector3());
+    mbsCenter[2] = mbsCenter[2] - geoidHeightModel.getHeight(mbsCenter[1], mbsCenter[0]);
+    obbCenter[2] = obbCenter[2] - geoidHeightModel.getHeight(obbCenter[1], obbCenter[0]);
+    return {
+        mbs: [mbsCenter[0], mbsCenter[1], mbsCenter[2], geometryMbs.radius],
+        obb: {
+            center: obbCenter,
+            halfSize: geometryObb.halfSize,
+            quaternion: geometryObb.quaternion
+        }
+    };
+}
+exports.createBoundingVolumesFromGeometry = createBoundingVolumesFromGeometry;
+/**
+ * Create array of posisitons where each vertex is vector
+ * @param {array} positions
+ * @returns {Vector3[]}
+ */
+function convertPositionsToVectors(positions) {
+    const result = [];
+    for (let i = 0; i < positions.length; i += 3) {
+        // TODO: (perf) new Vector3 is not optimal but required in `makeOrientedBoundingBoxFromPoints`.
+        // modify `makeOrientedBoundingBoxFromPoints` to use scratch vectors
+        const positionVector = new core_1.Vector3([positions[i], positions[i + 1], positions[i + 2]]);
+        result.push(positionVector);
+    }
+    return result;
+}
+exports.convertPositionsToVectors = convertPositionsToVectors;
+/**
+ * Convert common coordinate to extent coordinate
+ * @param tileset
+ * @returns - Extent
+ * @todo why lodMetricValue is radius? need to check this function
+ */
+function convertCommonToI3SExtentCoordinate(tileset) {
+    const cartesianCenter = tileset?.cartesianCenter;
+    if (!cartesianCenter) {
+        return null;
+    }
+    const radius = tileset?.lodMetricValue;
+    const rightTop = geospatial_1.Ellipsoid.WGS84.cartesianToCartographic(new core_1.Vector3(cartesianCenter[0] + radius, cartesianCenter[1] + radius, cartesianCenter[2]), new core_1.Vector3());
+    const leftBottom = geospatial_1.Ellipsoid.WGS84.cartesianToCartographic(new core_1.Vector3(cartesianCenter[0] - radius, cartesianCenter[1] - radius, cartesianCenter[2]), new core_1.Vector3());
+    const isFirstRight = rightTop[0] < leftBottom[0];
+    const isFirstTop = rightTop[1] < leftBottom[1];
+    return [
+        isFirstRight ? rightTop[0] : leftBottom[0],
+        isFirstTop ? rightTop[1] : leftBottom[1],
+        isFirstRight ? leftBottom[0] : rightTop[0],
+        isFirstTop ? leftBottom[1] : rightTop[1]
+    ];
+}
+exports.convertCommonToI3SExtentCoordinate = convertCommonToI3SExtentCoordinate;
+/**
+ * Creates oriented boundinb box from mbs.
+ * @param mbs - Minimum Bounding Sphere
+ * @returns - Oriented BOunding Box
+ */
+function createObbFromMbs(mbs) {
+    const radius = mbs[3];
+    const center = new core_1.Vector3(mbs[0], mbs[1], mbs[2]);
+    const halfAxex = new core_1.Matrix3([radius, 0, 0, 0, radius, 0, 0, 0, radius]);
+    return new culling_1.OrientedBoundingBox(center, halfAxex);
+}
+exports.createObbFromMbs = createObbFromMbs;

package/dist/i3s-converter/helpers/create-scene-server-path.d.ts

@@ -0,0 +1,9 @@
+import type { SceneLayer3D } from '@loaders.gl/i3s';
+/**
+ * Form and save sceneServer meta data into a file
+ * @param layerName - layer name to display
+ * @param layers0 - layer object embedded into sceneServer meta data
+ * @param rootPath - root path of new converted tileset
+ */
+export declare function createSceneServerPath(layerName: string, layers0: SceneLayer3D, rootPath: string): Promise<void>;
+//# sourceMappingURL=create-scene-server-path.d.ts.map

package/dist/i3s-converter/helpers/create-scene-server-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-scene-server-path.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/create-scene-server-path.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAQlD;;;;;GAKG;AACH,wBAAsB,qBAAqB,CACzC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CAUf"}

package/dist/i3s-converter/helpers/create-scene-server-path.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSceneServerPath = void 0;
+const uuid_1 = require("uuid");
+const json_map_transform_1 = __importDefault(require("json-map-transform"));
+const path_1 = require("path");
+const scene_server_1 = require("../json-templates/scene-server");
+const file_utils_1 = require("../../lib/utils/file-utils");
+/**
+ * Form and save sceneServer meta data into a file
+ * @param layerName - layer name to display
+ * @param layers0 - layer object embedded into sceneServer meta data
+ * @param rootPath - root path of new converted tileset
+ */
+async function createSceneServerPath(layerName, layers0, rootPath) {
+    const sceneServerData = {
+        serviceItemId: (0, uuid_1.v4)().replace(/-/gi, ''),
+        layerName,
+        layers0
+    };
+    const sceneServer = (0, json_map_transform_1.default)(sceneServerData, (0, scene_server_1.SCENE_SERVER)());
+    const nodePagePath = (0, path_1.join)(rootPath, 'SceneServer');
+    await (0, file_utils_1.writeFile)(nodePagePath, JSON.stringify(sceneServer));
+}
+exports.createSceneServerPath = createSceneServerPath;

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

@@ -0,0 +1,8 @@
+import type { GeometryAttributes, AttributesData } from '../types';
+/**
+ * Generate geometry attributes with faceRange and featureCount
+ * @param attributes
+ * @returns attirbutes with featureCount, featureIds and changed faceRange.
+ */
+export declare function generateAttributes(attributes: AttributesData): GeometryAttributes;
+//# sourceMappingURL=geometry-attributes.d.ts.map

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

@@ -0,0 +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,cAAc,EAA+B,MAAM,UAAU,CAAC;AAM/F;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,cAAc,GAAG,kBAAkB,CAuBjF"}

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

@@ -0,0 +1,176 @@
+"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, featureIndices, triangleCount } = attributes;
+    if (!featureIndices.length) {
+        return {
+            faceRange: new Uint32Array([0, triangleCount - 1]),
+            featureIds: [0],
+            featureCount: 1,
+            positions,
+            normals,
+            texCoords,
+            colors
+        };
+    }
+    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 = featureIndices[0];
+    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]) {
+            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]);
+            }
+            rangeIndex += 2;
+            featureIndex += 1;
+        }
+        currentFeatureId = featureIndices[index];
+    }
+    faceRangeList[rangeIndex] = featureIndices.length / VALUES_PER_VERTEX - 1;
+    const faceRange = new Uint32Array(faceRangeList);
+    const featureCount = uniqueFeatureIds.length;
+    return { faceRange, featureCount, featureIds };
+}
+/**
+ * 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 groupedData = [];
+    let positionsList = new Float32Array(positions);
+    let normalsList = new Float32Array(normals);
+    let colorsList = new Uint8Array(colors);
+    let texCoordsList = new Float32Array(texCoords);
+    let faceRangeIndex = 0;
+    for (let index = 0; index < featureIds.length; index++) {
+        const startIndex = faceRange[index + faceRangeIndex];
+        const endIndex = faceRange[index + faceRangeIndex + 1];
+        const positionsCount = getSliceAttributeCount('positions', startIndex, endIndex);
+        const normalsCount = getSliceAttributeCount('normals', startIndex, endIndex);
+        const colorsCount = getSliceAttributeCount('colors', 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),
+            texCoords: texCoordsList.slice(0, texCoordsCount)
+        });
+        positionsList = positionsList.slice(positionsCount);
+        normalsList = normalsList.slice(normalsCount);
+        colorsList = colorsList.slice(colorsCount);
+        texCoordsList = texCoordsList.slice(texCoordsCount);
+        faceRangeIndex += 1;
+    }
+    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 colorsPerVertex = 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':
+            return vertexCount * colorsPerVertex;
+        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 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);
+        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, texCoords, featureCount };
+}

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

@@ -0,0 +1,12 @@
+export default function convertB3dmToI3sGeometry(tileContent: any, nodeId: any, featuresHashArray: any, attributeStorageInfo: any, draco: any, generateBoundingVolumes: any, geoidHeightModel: any): Promise<{
+    geometry: Uint8Array;
+    compressedGeometry: any;
+    texture: any;
+    sharedResources: any;
+    meshMaterial: any;
+    vertexCount: number;
+    attributes: any[];
+    featureCount: number;
+    boundingVolumes: any;
+}[] | null>;
+//# sourceMappingURL=geometry-converter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-converter.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/geometry-converter.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;YAuDC"}