@loaders.gl/tile-converter 4.0.0-alpha.23 → 4.0.0-alpha.24

package/dist/3d-tiles-converter/3d-tiles-converter.js

@@ -1,279 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const process_1 = __importDefault(require("process"));
-const json_map_transform_1 = __importDefault(require("json-map-transform"));
-const core_1 = require("@loaders.gl/core");
-const i3s_1 = require("@loaders.gl/i3s");
-const pgm_loader_1 = require("../pgm-loader");
-const i3s_obb_to_3d_tiles_obb_1 = require("./helpers/i3s-obb-to-3d-tiles-obb");
-const lod_conversion_utils_1 = require("../lib/utils/lod-conversion-utils");
-const file_utils_1 = require("../lib/utils/file-utils");
-const statistic_utills_1 = require("../lib/utils/statistic-utills");
-const tileset_1 = require("./json-templates/tileset");
-const coordinate_converter_1 = require("../i3s-converter/helpers/coordinate-converter");
-const worker_utils_1 = require("@loaders.gl/worker-utils");
-const constants_1 = require("../constants");
-const b3dm_converter_1 = __importDefault(require("./helpers/b3dm-converter"));
-const load_i3s_1 = require("./helpers/load-i3s");
-const I3S = 'I3S';
-/**
- * Converter from i3s to 3d-tiles
- */
-class Tiles3DConverter {
-    constructor() {
-        this.workerSource = {};
-        this.loaderOptions = {
-            _nodeWorkers: true,
-            reuseWorkers: true,
-            i3s: { coordinateSystem: i3s_1.COORDINATE_SYSTEM.LNGLAT_OFFSETS, decodeTextures: false },
-            // We need to load local fs workers because nodejs can't load workers from the Internet
-            'i3s-content': {
-                workerUrl: './modules/i3s/dist/i3s-content-worker-node.js'
-            }
-        };
-        this.options = {};
-        this.tilesetPath = '';
-        this.vertexCounter = 0;
-        this.conversionStartTime = [0, 0];
-        this.geoidHeightModel = null;
-        this.sourceTileset = null;
-        this.attributeStorageInfo = null;
-        this.workerSource = {};
-    }
-    /**
-     * Convert i3s format data to 3dTiles
-     * @param options
-     * @param options.inputUrl the url to read the tileset from
-     * @param options.outputPath the output filename
-     * @param options.tilesetName the output name of the tileset
-     * @param options.egmFilePath location of *.pgm file to convert heights from ellipsoidal to gravity-related format
-     * @param options.maxDepth The max tree depth of conversion
-     */
-    async convert(options) {
-        if (core_1.isBrowser) {
-            console.log(constants_1.BROWSER_ERROR_MESSAGE);
-            return constants_1.BROWSER_ERROR_MESSAGE;
-        }
-        const { inputUrl, outputPath, tilesetName, maxDepth, egmFilePath } = options;
-        this.conversionStartTime = process_1.default.hrtime();
-        this.options = { maxDepth };
-        console.log('Loading egm file...'); // eslint-disable-line
-        this.geoidHeightModel = await (0, core_1.load)(egmFilePath, pgm_loader_1.PGMLoader);
-        console.log('Loading egm file completed!'); // eslint-disable-line
-        this.sourceTileset = await (0, core_1.load)(inputUrl, i3s_1.I3SLoader, this.loaderOptions);
-        if (!this.sourceTileset) {
-            return;
-        }
-        const rootNode = this.sourceTileset?.root;
-        if (!rootNode.obb) {
-            rootNode.obb = (0, coordinate_converter_1.createObbFromMbs)(rootNode.mbs);
-        }
-        this.tilesetPath = (0, path_1.join)(`${outputPath}`, `${tilesetName}`);
-        this.attributeStorageInfo = this.sourceTileset.attributeStorageInfo;
-        // Removing the tilesetPath needed to exclude erroneous files after conversion
-        try {
-            await (0, file_utils_1.removeDir)(this.tilesetPath);
-        }
-        catch (e) {
-            // do nothing
-        }
-        const rootTile = {
-            boundingVolume: {
-                box: (0, i3s_obb_to_3d_tiles_obb_1.i3sObbTo3dTilesObb)(rootNode.obb, this.geoidHeightModel)
-            },
-            geometricError: (0, lod_conversion_utils_1.convertScreenThresholdToGeometricError)(rootNode),
-            children: []
-        };
-        await this._addChildren(rootNode, rootTile, 1);
-        const tileset = (0, json_map_transform_1.default)({ root: rootTile }, (0, tileset_1.TILESET)());
-        await (0, file_utils_1.writeFile)(this.tilesetPath, JSON.stringify(tileset), 'tileset.json');
-        this._finishConversion({ slpk: false, outputPath, tilesetName });
-        // Clean up worker pools
-        const workerFarm = worker_utils_1.WorkerFarm.getWorkerFarm({});
-        workerFarm.destroy();
-    }
-    /**
-     * Convert particular I3S Node
-     * @param parentSourceNode the parent node tile object (@loaders.gl/tiles/Tile3D)
-     * @param parentNode object in resulting tileset
-     * @param level a current level of a tree depth
-     * @param childNodeInfo child node to convert
-     */
-    async convertChildNode(parentSourceNode, parentNode, level, childNodeInfo) {
-        const sourceChild = await this._loadChildNode(parentSourceNode, childNodeInfo);
-        if (sourceChild.contentUrl) {
-            const content = await (0, load_i3s_1.loadI3SContent)(this.sourceTileset, sourceChild, this.loaderOptions);
-            if (!content) {
-                await this._addChildren(sourceChild, parentNode, level + 1);
-                return;
-            }
-            this.vertexCounter += content?.vertexCount || 0;
-            let featureAttributes = null;
-            if (this.attributeStorageInfo) {
-                featureAttributes = await this._loadChildAttributes(sourceChild, this.attributeStorageInfo);
-            }
-            if (!sourceChild.obb) {
-                sourceChild.obb = (0, coordinate_converter_1.createObbFromMbs)(sourceChild.mbs);
-            }
-            const boundingVolume = {
-                box: (0, i3s_obb_to_3d_tiles_obb_1.i3sObbTo3dTilesObb)(sourceChild.obb, this.geoidHeightModel)
-            };
-            const child = {
-                boundingVolume,
-                geometricError: (0, lod_conversion_utils_1.convertScreenThresholdToGeometricError)(sourceChild),
-                children: []
-            };
-            const i3sAttributesData = {
-                tileContent: content,
-                box: boundingVolume.box,
-                textureFormat: sourceChild.textureFormat
-            };
-            const b3dmConverter = new b3dm_converter_1.default();
-            const b3dm = await b3dmConverter.convert(i3sAttributesData, featureAttributes);
-            child.content = {
-                uri: `${sourceChild.id}.b3dm`,
-                boundingVolume
-            };
-            await (0, file_utils_1.writeFile)(this.tilesetPath, new Uint8Array(b3dm), `${sourceChild.id}.b3dm`);
-            parentNode.children.push(child);
-            await this._addChildren(sourceChild, child, level + 1);
-        }
-        else {
-            await this._addChildren(sourceChild, parentNode, level + 1);
-        }
-    }
-    /**
-     * The recursive function of traversal of a nodes tree
-     * @param parentSourceNode the parent node tile object (@loaders.gl/tiles/Tile3D)
-     * @param parentNode object in resulting tileset
-     * @param level a current level of a tree depth
-     */
-    async _addChildren(parentSourceNode, parentNode, level) {
-        if (this.options.maxDepth && level > this.options.maxDepth) {
-            return;
-        }
-        const promises = [];
-        for (const childNodeInfo of parentSourceNode.children || []) {
-            promises.push(this.convertChildNode(parentSourceNode, parentNode, level, childNodeInfo));
-        }
-        await Promise.all(promises);
-    }
-    /**
-     * Load a child node having information from the node header
-     * @param parentNode a parent node tile object (@loaders.gl/tiles/Tile3D)
-     * @param childNodeInfo child information from 3DNodeIndexDocument
-     *   (https://github.com/Esri/i3s-spec/blob/master/docs/1.7/nodeReference.cmn.md)
-     */
-    async _loadChildNode(parentNode, childNodeInfo) {
-        let header;
-        if (this.sourceTileset?.nodePagesTile) {
-            console.log(`Node conversion: ${childNodeInfo.id}`); // eslint-disable-line no-console,no-undef
-            header = await this.sourceTileset.nodePagesTile.formTileFromNodePages(parseInt(childNodeInfo.id));
-        }
-        else {
-            const nodeUrl = this._relativeUrlToFullUrl(parentNode.url, childNodeInfo.href);
-            // load metadata
-            const options = {
-                i3s: {
-                    ...this.loaderOptions,
-                    isTileHeader: true,
-                    loadContent: false
-                }
-            };
-            console.log(`Node conversion: ${nodeUrl}`); // eslint-disable-line no-console,no-undef
-            header = await (0, core_1.load)(nodeUrl, i3s_1.I3SLoader, options);
-        }
-        return header;
-    }
-    /**
-     * Make an url of a resource from its relative url having the base url
-     * @param baseUrl the base url. A resulting url will be related from this url
-     * @param relativeUrl a realtive url of a resource
-     */
-    _relativeUrlToFullUrl(baseUrl = '', relativeUrl) {
-        let resultArray = baseUrl.split('/');
-        const relativeUrlArray = relativeUrl.split('/');
-        for (const folder of relativeUrlArray) {
-            switch (folder) {
-                case '.':
-                    continue; // eslint-disable-line no-continue
-                case '..':
-                    resultArray = resultArray.slice(0, -1);
-                    break;
-                default:
-                    resultArray.push(folder);
-            }
-        }
-        return resultArray.join('/');
-    }
-    /**
-     * Do loading all attributes related to particular node.
-     * @param sourceChild
-     * @param attributeStorageInfo
-     * @returns Promise of attributes object.
-     */
-    async _loadChildAttributes(sourceChild, attributeStorageInfo) {
-        const promises = [];
-        const { attributeUrls = [] } = sourceChild;
-        for (let index = 0; index < attributeUrls.length; index++) {
-            const inputUrl = attributeUrls[index];
-            const attribute = attributeStorageInfo[index];
-            const options = {
-                attributeName: attribute.name,
-                attributeType: this._getAttributeType(attribute)
-            };
-            promises.push((0, core_1.load)(inputUrl, i3s_1.I3SAttributeLoader, options));
-        }
-        const attributesList = await Promise.all(promises);
-        this._replaceNestedArrays(attributesList);
-        return Object.assign({}, ...attributesList);
-    }
-    /**
-     * Returns attribute type for loading attributes
-     * @param attribute
-     * Workaround for I3S v1.6. There is no attribute.attributeValues.valueType field in attribute.
-     * There is an 'Oid32' type if attribute has objectIds property.
-     * Doc: https://github.com/Esri/i3s-spec/blob/master/docs/1.6/attributeStorageInfo.cmn.md
-     */
-    _getAttributeType(attribute) {
-        if (attribute.attributeValues) {
-            return attribute.attributeValues.valueType;
-        }
-        else if (attribute.objectIds) {
-            return 'Oid32';
-        }
-        return '';
-    }
-    /**
-     * Make simple arrays from attribute typed arrays.
-     * @param attributesList
-     */
-    _replaceNestedArrays(attributesList) {
-        for (let index = 0; index < attributesList.length; index++) {
-            const attributeObject = attributesList[index];
-            for (const key in attributeObject) {
-                attributeObject[key] = Array.from(attributeObject[key]);
-            }
-        }
-    }
-    /**
-     * Print statistics in the end of conversion
-     * @param params - output files data
-     */
-    async _finishConversion(params) {
-        const filesSize = await (0, statistic_utills_1.calculateFilesSize)(params);
-        const diff = process_1.default.hrtime(this.conversionStartTime);
-        const conversionTime = (0, statistic_utills_1.timeConverter)(diff);
-        console.log(`------------------------------------------------`); // eslint-disable-line
-        console.log(`Finish conversion of ${I3S}`); // eslint-disable-line
-        console.log(`Total conversion time: ${conversionTime}`); // eslint-disable-line
-        console.log(`Vertex count: `, this.vertexCounter); // eslint-disable-line
-        console.log(`File(s) size: `, filesSize, ' bytes'); // eslint-disable-line
-        console.log(`------------------------------------------------`); // eslint-disable-line
-    }
-}
-exports.default = Tiles3DConverter;

package/dist/3d-tiles-converter/helpers/b3dm-converter.js

@@ -1,271 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@loaders.gl/core");
-const gltf_1 = require("@loaders.gl/gltf");
-const _3d_tiles_1 = require("@loaders.gl/3d-tiles");
-const core_2 = require("@math.gl/core");
-const geospatial_1 = require("@math.gl/geospatial");
-const texture_atlas_1 = require("./texture-atlas");
-const geometry_utils_1 = require("../../lib/utils/geometry-utils");
-const Z_UP_TO_Y_UP_MATRIX = new core_2.Matrix4([1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1]);
-const scratchVector = new core_2.Vector3();
-/**
- * Converts content of an I3S node to *.b3dm's file content
- */
-class B3dmConverter {
-    /**
-     * The starter of content conversion
-     * @param i3sTile - Tile3D instance for I3S node
-     * @returns - encoded content
-     */
-    async convert(i3sAttributesData, featureAttributes = null) {
-        const gltf = await this.buildGltf(i3sAttributesData, featureAttributes);
-        const b3dm = (0, core_1.encodeSync)({
-            gltfEncoded: new Uint8Array(gltf),
-            type: 'b3dm',
-            featuresLength: this._getFeaturesLength(featureAttributes),
-            batchTable: featureAttributes
-        }, _3d_tiles_1.Tile3DWriter);
-        return b3dm;
-    }
-    /**
-     * Build and encode gltf
-     * @param i3sTile - Tile3D instance for I3S node
-     * @returns - encoded glb content
-     */
-    async buildGltf(i3sAttributesData, featureAttributes) {
-        const { tileContent, textureFormat, box } = i3sAttributesData;
-        const { material, attributes, indices: originalIndices, modelMatrix } = tileContent;
-        const gltfBuilder = new gltf_1.GLTFScenegraph();
-        const textureIndex = await this._addI3sTextureToGltf(tileContent, textureFormat, gltfBuilder);
-        const pbrMaterialInfo = this._convertI3sMaterialToGltfMaterial(material, textureIndex);
-        const materialIndex = gltfBuilder.addMaterial(pbrMaterialInfo);
-        const positions = attributes.positions;
-        const positionsValue = positions.value;
-        if (attributes.uvRegions && attributes.texCoords) {
-            attributes.texCoords.value = (0, texture_atlas_1.convertTextureAtlas)(attributes.texCoords.value, attributes.uvRegions.value);
-        }
-        const cartesianOrigin = new core_2.Vector3(box);
-        const cartographicOrigin = geospatial_1.Ellipsoid.WGS84.cartesianToCartographic(cartesianOrigin, new core_2.Vector3());
-        attributes.positions.value = this._normalizePositions(positionsValue, cartesianOrigin, cartographicOrigin, modelMatrix);
-        this._createBatchIds(tileContent, featureAttributes);
-        if (attributes.normals && !this._checkNormals(attributes.normals.value)) {
-            delete attributes.normals;
-        }
-        const indices = originalIndices || (0, geometry_utils_1.generateSyntheticIndices)(positionsValue.length / positions.size);
-        const meshIndex = gltfBuilder.addMesh({
-            attributes,
-            indices,
-            material: materialIndex,
-            mode: 4
-        });
-        const transformMatrix = this._generateTransformMatrix(cartesianOrigin);
-        const nodeIndex = gltfBuilder.addNode({ meshIndex, matrix: transformMatrix });
-        const sceneIndex = gltfBuilder.addScene({ nodeIndices: [nodeIndex] });
-        gltfBuilder.setDefaultScene(sceneIndex);
-        gltfBuilder.createBinaryChunk();
-        const gltfBuffer = (0, core_1.encodeSync)(gltfBuilder.gltf, gltf_1.GLTFWriter);
-        return gltfBuffer;
-    }
-    /**
-     * Update gltfBuilder with texture from I3S tile
-     * @param {object} i3sTile - Tile3D object
-     * @param {GLTFScenegraph} gltfBuilder - gltfScenegraph instance to construct GLTF
-     * @returns {Promise<number | null>} - GLTF texture index
-     */
-    async _addI3sTextureToGltf(tileContent, textureFormat, gltfBuilder) {
-        const { texture, material, attributes } = tileContent;
-        let textureIndex = null;
-        let selectedTexture = texture;
-        if (!texture && material) {
-            selectedTexture =
-                material.pbrMetallicRoughness &&
-                    material.pbrMetallicRoughness.baseColorTexture &&
-                    material.pbrMetallicRoughness.baseColorTexture.texture.source.image;
-        }
-        if (selectedTexture) {
-            const mimeType = this._deduceMimeTypeFromFormat(textureFormat);
-            const imageIndex = gltfBuilder.addImage(selectedTexture, mimeType);
-            textureIndex = gltfBuilder.addTexture({ imageIndex });
-            delete attributes.colors;
-        }
-        return textureIndex;
-    }
-    /**
-     * Generate a positions array which is correct for 3DTiles/GLTF format
-     * @param {Float64Array} positionsValue - the input geometry positions array
-     * @param {number[]} cartesianOrigin - the tile center in the cartesian coordinate system
-     * @param {number[]} cartographicOrigin - the tile center in the cartographic coordinate system
-     * @param {number[]} modelMatrix - the model matrix of geometry
-     * @returns {Float32Array} - the output geometry positions array
-     */
-    _normalizePositions(positionsValue, cartesianOrigin, cartographicOrigin, modelMatrix) {
-        const newPositionsValue = new Float32Array(positionsValue.length);
-        for (let index = 0; index < positionsValue.length; index += 3) {
-            const vertex = positionsValue.subarray(index, index + 3);
-            const cartesianOriginVector = new core_2.Vector3(cartesianOrigin);
-            let vertexVector = new core_2.Vector3(Array.from(vertex))
-                .transform(modelMatrix)
-                .add(cartographicOrigin);
-            geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(vertexVector, scratchVector);
-            vertexVector = scratchVector.subtract(cartesianOriginVector);
-            newPositionsValue.set(vertexVector, index);
-        }
-        return newPositionsValue;
-    }
-    /**
-     * Generate the transformation matrix for GLTF node:
-     * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-node
-     * 1. Create the translate transformation from cartesianOrigin (the positions array stores offsets from this cartesianOrigin)
-     * 2. Create the rotation transformation to rotate model from z-up coordinates (I3S specific) to y-up coordinates (GLTF specific)
-     * @param {number[]} cartesianOrigin - the tile center in the cartesian coordinate system
-     * @returns {Matrix4} - an array of 16 numbers (4x4 matrix)
-     */
-    _generateTransformMatrix(cartesianOrigin) {
-        const translateOriginMatrix = new core_2.Matrix4().translate(cartesianOrigin);
-        const result = translateOriginMatrix.multiplyLeft(Z_UP_TO_Y_UP_MATRIX);
-        return result;
-    }
-    /**
-     * Create _BATCHID attribute
-     * @param {Object} i3sContent - the source object
-     * @returns {void}
-     */
-    _createBatchIds(i3sContent, featureAttributes) {
-        const { featureIds } = i3sContent;
-        const { OBJECTID: objectIds } = featureAttributes || {};
-        if (!featureIds || !objectIds) {
-            return;
-        }
-        for (let i = 0; i < featureIds.length; i++) {
-            const featureId = featureIds[i];
-            const batchId = objectIds.indexOf(featureId);
-            featureIds[i] = batchId;
-        }
-        i3sContent.attributes._BATCHID = {
-            size: 1,
-            byteOffset: 0,
-            value: featureIds
-        };
-    }
-    /**
-     * Deduce mime type by format from `textureSetDefinition.formats[0].format`
-     * https://github.com/Esri/i3s-spec/blob/master/docs/1.7/textureSetDefinitionFormat.cmn.md
-     * @param {string} format - format name
-     * @returns {string} mime type.
-     */
-    _deduceMimeTypeFromFormat(format) {
-        switch (format) {
-            case 'jpg':
-                return 'image/jpeg';
-            case 'png':
-                return 'image/png';
-            case 'ktx2':
-                return 'image/ktx2';
-            default:
-                console.warn(`Unexpected texture format in I3S: ${format}`); // eslint-disable-line no-console, no-undef
-                return 'image/jpeg';
-        }
-    }
-    /**
-     * Convert i3s material to GLTF compatible material
-     * @param {object} material - i3s material definition
-     * @param {number | null} textureIndex - texture index in GLTF
-     * @returns {object} GLTF material
-     */
-    _convertI3sMaterialToGltfMaterial(material, textureIndex) {
-        const isTextureIndexExists = textureIndex !== null;
-        if (!material) {
-            material = {
-                alphaMode: 'OPAQUE',
-                doubleSided: false,
-                pbrMetallicRoughness: {
-                    metallicFactor: 0,
-                    roughnessFactor: 1
-                }
-            };
-            if (isTextureIndexExists) {
-                material.pbrMetallicRoughness.baseColorTexture = {
-                    index: textureIndex,
-                    texCoord: 0
-                };
-            }
-            else {
-                material.pbrMetallicRoughness.baseColorFactor = [1, 1, 1, 1];
-            }
-            return material;
-        }
-        if (textureIndex !== null) {
-            material = this._setGltfTexture(material, textureIndex);
-        }
-        return material;
-    }
-    /**
-     * Set texture properties in material with GLTF textureIndex
-     * @param {object} materialDefinition - i3s material definition
-     * @param {number} textureIndex - texture index in GLTF
-     * @returns {void}
-     */
-    _setGltfTexture(materialDefinition, textureIndex) {
-        const material = {
-            ...materialDefinition,
-            pbrMetallicRoughness: { ...materialDefinition.pbrMetallicRoughness }
-        };
-        // I3SLoader now support loading only one texture. This elseif sequence will assign this texture to one of
-        // properties defined in materialDefinition
-        if (materialDefinition.pbrMetallicRoughness &&
-            materialDefinition.pbrMetallicRoughness.baseColorTexture) {
-            material.pbrMetallicRoughness.baseColorTexture = {
-                index: textureIndex,
-                texCoord: 0
-            };
-        }
-        else if (materialDefinition.emissiveTexture) {
-            material.emissiveTexture = {
-                index: textureIndex,
-                texCoord: 0
-            };
-        }
-        else if (materialDefinition.pbrMetallicRoughness &&
-            materialDefinition.pbrMetallicRoughness.metallicRoughnessTexture) {
-            material.pbrMetallicRoughness.metallicRoughnessTexture = {
-                index: textureIndex,
-                texCoord: 0
-            };
-        }
-        else if (materialDefinition.normalTexture) {
-            material.normalTexture = {
-                index: textureIndex,
-                texCoord: 0
-            };
-        }
-        else if (materialDefinition.occlusionTexture) {
-            material.occlusionTexture = {
-                index: textureIndex,
-                texCoord: 0
-            };
-        }
-        return material;
-    }
-    /*
-     * Returns Features length based on attribute array in attribute object.
-     * @param {Object} attributes
-     * @returns {Number} Features length .
-     */
-    _getFeaturesLength(attributes) {
-        if (!attributes) {
-            return 0;
-        }
-        const firstKey = Object.keys(attributes)[0];
-        return firstKey ? attributes[firstKey].length : 0;
-    }
-    /* Checks that normals buffer is correct
-     * @param {TypedArray} normals
-     * @returns {boolean} true - normals are correct; false - normals are incorrect
-     */
-    _checkNormals(normals) {
-        // If all normals === 0, the resulting tileset is all in black colors on Cesium
-        return normals.find((value) => value);
-    }
-}
-exports.default = B3dmConverter;

package/dist/3d-tiles-converter/helpers/i3s-obb-to-3d-tiles-obb.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.i3sObbTo3dTilesObb = void 0;
-const core_1 = require("@math.gl/core");
-const geospatial_1 = require("@math.gl/geospatial");
-const culling_1 = require("@math.gl/culling");
-/**
- * Convert quaternion-based OBB to half-axes-based OBB
- * @param i3SObb quaternion based OBB
- * @param geoidHeightModel the Earth Gravity Model instance
- * @returns number[12] 3DTiles OBB https://github.com/CesiumGS/3d-tiles/tree/master/specification#box
- */
-function i3sObbTo3dTilesObb(i3SObb, geoidHeightModel) {
-    const tiles3DCenter = [
-        i3SObb.center[0],
-        i3SObb.center[1],
-        i3SObb.center[2] + geoidHeightModel.getHeight(i3SObb.center[1], i3SObb.center[0])
-    ];
-    const cartesianCenter = geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(tiles3DCenter, new core_1.Vector3());
-    const tiles3DObb = new culling_1.OrientedBoundingBox().fromCenterHalfSizeQuaternion(cartesianCenter, i3SObb.halfSize, i3SObb.quaternion);
-    return [...tiles3DObb.center, ...tiles3DObb.halfAxes.toArray()];
-}
-exports.i3sObbTo3dTilesObb = i3sObbTo3dTilesObb;

package/dist/3d-tiles-converter/helpers/load-i3s.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadI3SContent = void 0;
-const core_1 = require("@loaders.gl/core");
-const i3s_1 = require("@loaders.gl/i3s");
-/**
- * Load I3S node content
- * @param sourceTileset - source layer JSON
- * @param sourceTile - source I3S node metadata
- * @param tilesetLoadOptions - load options for Tiles3DLoader
- * @returns - 3DTiles tile content or null
- */
-const loadI3SContent = async (sourceTileset, sourceTile, tilesetLoadOptions) => {
-    if (!sourceTileset || !sourceTile.contentUrl) {
-        return null;
-    }
-    const loadOptions = {
-        ...tilesetLoadOptions,
-        i3s: {
-            ...tilesetLoadOptions.i3s,
-            isTileset: false,
-            isTileHeader: false,
-            _tileOptions: {
-                attributeUrls: sourceTile.attributeUrls,
-                textureUrl: sourceTile.textureUrl,
-                textureFormat: sourceTile.textureFormat,
-                textureLoaderOptions: sourceTile.textureLoaderOptions,
-                materialDefinition: sourceTile.materialDefinition,
-                isDracoGeometry: sourceTile.isDracoGeometry,
-                mbs: sourceTile.mbs
-            },
-            _tilesetOptions: {
-                store: sourceTileset.store,
-                attributeStorageInfo: sourceTileset.attributeStorageInfo,
-                fields: sourceTileset.fields
-            }
-        }
-    };
-    const tileContent = await (0, core_1.load)(sourceTile.contentUrl, i3s_1.I3SLoader, loadOptions);
-    return tileContent;
-};
-exports.loadI3SContent = loadI3SContent;

package/dist/3d-tiles-converter/helpers/texture-atlas.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertTextureAtlas = void 0;
-/**
- * Apply uvRegions to texture coordinates.
- * Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.7/geometryUVRegion.cmn.md
- * Shader formula vec2 uv = fract(texCoords) * (uvRegions.zw - uvRegions.xy) + uvRegions.xy;
- * @param texCoords
- * @param uvRegions
- */
-function convertTextureAtlas(texCoords, uvRegions) {
-    const convertedTexCoords = new Float32Array(texCoords.length);
-    const normalisedRegions = normalizeRegions(uvRegions);
-    for (let index = 0; index < texCoords.length; index += 2) {
-        const uv = texCoords.subarray(index, index + 2);
-        const regions = normalisedRegions.slice(index * 2, index * 2 + 4);
-        // fract(texCoords)
-        const fractatedUV = fract([uv[0], uv[1]]);
-        // (uvRegions.zw - uvRegions.xy)
-        const subtracted = [regions[2] - regions[0], regions[3] - regions[1]];
-        // fract(texCoords) * (uvRegions.zw - uvRegions.xy)
-        const multiplicationResult = [fractatedUV[0] * subtracted[0], fractatedUV[1] * subtracted[1]];
-        // fract(texCoords) * (uvRegions.zw - uvRegions.xy) + uvRegions.xy;
-        const convertedUV = [
-            multiplicationResult[0] + regions[0],
-            multiplicationResult[1] + regions[1]
-        ];
-        convertedTexCoords[index] = convertedUV[0];
-        convertedTexCoords[index + 1] = convertedUV[1];
-    }
-    return convertedTexCoords;
-}
-exports.convertTextureAtlas = convertTextureAtlas;
-/**
- * Do fractation of UV array.
- * @param uv
- */
-function fract(uv) {
-    return [uv[0] - Math.floor(uv[0]), uv[1] - Math.floor(uv[1])];
-}
-/**
- * Normalize uvRegions by dividing by the maximum Uint16 value
- * @param regions
- */
-function normalizeRegions(regions) {
-    // The code is for Uint16Array because it is the spec requirement
-    // https://github.com/Esri/i3s-spec/blob/master/docs/1.8/geometryUVRegion.cmn.md
-    const MAX_UINT_16_VALUE = 65535;
-    const normalizedRegions = [];
-    for (let index = 0; index < regions.length; index++) {
-        normalizedRegions[index] = regions[index] / MAX_UINT_16_VALUE;
-    }
-    return normalizedRegions;
-}