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

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

@@ -0,0 +1,41 @@
+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 { Geoid } from '@math.gl/geoid';
+/**
+ * Create bounding volumes object from tile and geoid height model.
+ * @param tile
+ * @param geoidHeightModel
+ * @returns - Bounding volumes object
+ */
+export declare function createBoundingVolumes(tile: TileHeader, geoidHeightModel: Geoid): BoundingVolumes;
+/**
+ * Generates bounding volumes from geometry positions
+ * @param cartesianPositions
+ * @param geoidHeightModel
+ */
+export declare function createBoundingVolumesFromGeometry(cartesianPositions: Float32Array, geoidHeightModel: Geoid): {
+    mbs: Mbs;
+    obb: Obb;
+};
+/**
+ * Create array of posisitons where each vertex is vector
+ * @param {array} positions
+ * @returns {Vector3[]}
+ */
+export declare function convertPositionsToVectors(positions: Float32Array): Vector3[];
+/**
+ * Convert common coordinate to fullExtent https://github.com/Esri/i3s-spec/blob/master/docs/1.8/fullExtent.cmn.md
+ * @param
+ * @param boundingVolume
+ * @returns - fullExtent object
+ */
+export declare function convertBoundingVolumeToI3SFullExtent(boundingVolume: OrientedBoundingBox | BoundingSphere): FullExtent;
+/**
+ * Creates oriented boundinb box from mbs.
+ * @param mbs - Minimum Bounding Sphere
+ * @returns - Oriented BOunding Box
+ */
+export declare function createObbFromMbs(mbs: Mbs): Obb;
+//# sourceMappingURL=coordinate-converter.d.ts.map

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

@@ -0,0 +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,CA0BZ;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAK9C"}

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createObbFromMbs = exports.convertBoundingVolumeToI3SFullExtent = 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 fullExtent https://github.com/Esri/i3s-spec/blob/master/docs/1.8/fullExtent.cmn.md
+ * @param
+ * @param boundingVolume
+ * @returns - fullExtent object
+ */
+function convertBoundingVolumeToI3SFullExtent(boundingVolume) {
+    let sphere;
+    if (boundingVolume instanceof culling_1.BoundingSphere) {
+        sphere = boundingVolume;
+    }
+    else {
+        sphere = boundingVolume.getBoundingSphere();
+    }
+    const center = sphere.center;
+    const radius = sphere.radius;
+    const vertexMax = geospatial_1.Ellipsoid.WGS84.cartesianToCartographic(new core_1.Vector3(center[0] + radius, center[1] + radius, center[2] + radius), new core_1.Vector3());
+    const vertexMin = geospatial_1.Ellipsoid.WGS84.cartesianToCartographic(new core_1.Vector3(center[0] - radius, center[1] - radius, center[2] - radius), new core_1.Vector3());
+    return {
+        xmin: vertexMin[0],
+        xmax: vertexMax[0],
+        ymin: vertexMin[1],
+        ymax: vertexMax[1],
+        zmin: vertexMin[2],
+        zmax: vertexMax[2]
+    };
+}
+exports.convertBoundingVolumeToI3SFullExtent = convertBoundingVolumeToI3SFullExtent;
+/**
+ * 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, ConvertedAttributes } from '../types';
+/**
+ * Generate geometry attributes with faceRange and featureCount
+ * @param attributes
+ * @returns attirbutes with featureCount, featureIds and changed faceRange.
+ */
+export declare function generateAttributes(attributes: ConvertedAttributes): 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,mBAAmB,EAA+B,MAAM,UAAU,CAAC;AAMpG;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,mBAAmB,GAAG,kBAAkB,CAwBtF"}

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

@@ -0,0 +1,177 @@
+"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 } = 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
+        };
+    }
+    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,29 @@
+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';
+/**
+ * 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 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 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: {
+    [key: string]: string;
+}): Promise<I3SConvertedResources[] | null>;
+/**
+ * Convert attributes from the gltf nodes tree to i3s plain geometry
+ * @param tileContent - 3d tile 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>>;
+//# 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.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"}