@loaders.gl/tile-converter 4.0.0-alpha.1 → 4.0.0-alpha.10

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

@@ -1,10 +1,23 @@
-import { Vector3 } from '@math.gl/core';
-import { Ellipsoid } from '@math.gl/geospatial';
-import { OrientedBoundingBox } from '@math.gl/culling';
-export 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 = Ellipsoid.WGS84.cartographicToCartesian(tiles3DCenter, new Vector3());
-  const tiles3DObb = new OrientedBoundingBox().fromCenterHalfSizeQuaternion(cartesianCenter, i3SObb.halfSize, i3SObb.quaternion);
-  return [...tiles3DObb.center, ...tiles3DObb.halfAxes.toArray()];
+"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()];
 }
-//# sourceMappingURL=i3s-obb-to-3d-tiles-obb.js.map
+exports.i3sObbTo3dTilesObb = i3sObbTo3dTilesObb;

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

@@ -0,0 +1,9 @@
+/**
+ * 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
+ */
+export declare function convertTextureAtlas(texCoords: Float32Array, uvRegions: Uint16Array): Float32Array;
+//# sourceMappingURL=texture-atlas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"texture-atlas.d.ts","sourceRoot":"","sources":["../../../src/3d-tiles-converter/helpers/texture-atlas.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,GAAG,YAAY,CAwBjG"}

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

@@ -1,33 +1,52 @@
-export 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);
-    const fractatedUV = fract(uv);
-    const subtracted = [regions[2] - regions[0], regions[3] - regions[1]];
-    const multiplicationResult = [fractatedUV[0] * subtracted[0], fractatedUV[1] * subtracted[1]];
-    const convertedUV = [multiplicationResult[0] + regions[0], multiplicationResult[1] + regions[1]];
-    convertedTexCoords[index] = convertedUV[0];
-    convertedTexCoords[index + 1] = convertedUV[1];
-  }
-
-  return convertedTexCoords;
+"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])];
+    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) {
-  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;
+    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;
 }
-//# sourceMappingURL=texture-atlas.js.map

package/dist/3d-tiles-converter/json-templates/tileset.d.ts

@@ -0,0 +1,15 @@
+export declare const TILESET: () => {
+    asset: {
+        path: string;
+        transform: (val: any) => any;
+    };
+    geometricError: {
+        path: string;
+        transform: (val: any) => any;
+    };
+    root: {
+        path: string;
+        transform: (val: any) => any;
+    };
+};
+//# sourceMappingURL=tileset.d.ts.map

package/dist/3d-tiles-converter/json-templates/tileset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tileset.d.ts","sourceRoot":"","sources":["../../../src/3d-tiles-converter/json-templates/tileset.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,OAAO;;;;;;;;;;;;;CAalB,CAAC"}

package/dist/3d-tiles-converter/json-templates/tileset.js

@@ -1,37 +1,43 @@
-import transform from 'json-map-transform';
-const ASSET = {
-  version: {
-    path: 'version',
-    default: '1.0'
-  }
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-const TILE = {
-  boundingVolume: {
-    path: 'boundingVolume'
-  },
-  geometricError: {
-    path: 'geometricError'
-  },
-  content: {
-    path: 'content'
-  },
-  children: {
-    path: 'children',
-    transform: val => val.map(tile => transform(tile, TILE))
-  }
-};
-export const TILESET = {
-  asset: {
-    path: 'asset',
-    transform: val => transform(val, ASSET)
-  },
-  geometricError: {
-    path: 'root',
-    transform: val => val.geometricError
-  },
-  root: {
-    path: 'root',
-    transform: val => transform(val, TILE)
-  }
-};
-//# sourceMappingURL=tileset.js.map
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TILESET = void 0;
+const json_map_transform_1 = __importDefault(require("json-map-transform"));
+const ASSET = () => ({
+    version: {
+        path: 'version',
+        default: '1.0'
+    }
+});
+const TILE = () => ({
+    boundingVolume: {
+        path: 'boundingVolume'
+    },
+    geometricError: {
+        path: 'geometricError'
+    },
+    content: {
+        path: 'content'
+    },
+    children: {
+        path: 'children',
+        transform: (val) => val.map((tile) => (0, json_map_transform_1.default)(tile, TILE()))
+    }
+});
+const TILESET = () => ({
+    asset: {
+        path: 'asset',
+        transform: (val) => (0, json_map_transform_1.default)(val, ASSET())
+    },
+    geometricError: {
+        path: 'root',
+        transform: (val) => val.geometricError
+    },
+    root: {
+        path: 'root',
+        transform: (val) => (0, json_map_transform_1.default)(val, TILE())
+    }
+});
+exports.TILESET = TILESET;

package/dist/bundle.d.ts

@@ -0,0 +1,2 @@
+declare const moduleExports: any;
+//# sourceMappingURL=bundle.d.ts.map

package/dist/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,aAAa,KAAqB,CAAC"}

package/dist/bundle.js

@@ -1,5 +1,5 @@
+"use strict";
+// @ts-nocheck
 const moduleExports = require('./index');
-
 globalThis.loaders = globalThis.loaders || {};
 module.exports = Object.assign(globalThis.loaders, moduleExports);
-//# sourceMappingURL=bundle.js.map

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const BROWSER_ERROR_MESSAGE = "Tile converter does not work in browser, only in node js environment";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,yEACsC,CAAC"}

package/dist/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BROWSER_ERROR_MESSAGE = void 0;
+exports.BROWSER_ERROR_MESSAGE = 'Tile converter does not work in browser, only in node js environment';

package/dist/converter-cli.d.ts

@@ -0,0 +1,2 @@
+import '@loaders.gl/polyfills';
+//# sourceMappingURL=converter-cli.d.ts.map

package/dist/converter-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter-cli.d.ts","sourceRoot":"","sources":["../src/converter-cli.ts"],"names":[],"mappings":"AACA,OAAO,uBAAuB,CAAC"}

package/dist/converter-cli.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+require("@loaders.gl/polyfills");
+const path_1 = require("path");
+const tile_converter_1 = require("@loaders.gl/tile-converter");
+const deps_installer_1 = require("./deps-installer/deps-installer");
+const TILESET_TYPE = {
+    I3S: 'I3S',
+    _3DTILES: '3DTILES'
+};
+/**
+ * CLI entry
+ * @returns
+ */
+async function main() {
+    const [, , ...args] = process.argv;
+    if (args.length === 0) {
+        printHelp();
+    }
+    const validatedOptionsArr = validateOptionsWithEqual(args);
+    const options = parseOptions(validatedOptionsArr);
+    if (options.installDependencies) {
+        const depthInstaller = new deps_installer_1.DepsInstaller();
+        depthInstaller.install('deps');
+        return;
+    }
+    const validatedOptions = validateOptions(options);
+    await convert(validatedOptions);
+}
+main().catch((error) => {
+    console.log(error);
+    process.exit(1); // eslint-disable-line
+});
+/**
+ * Output for `npx tile-converter --help`
+ */
+function printHelp() {
+    console.log('cli: converter 3dTiles to I3S or I3S to 3dTiles...');
+    console.log('--install-dependencies [Run the script for installing dependencies. Run this options separate from others. Now "*.pgm" file installation is implemented]');
+    console.log('--max-depth [Maximal depth of hierarchical tiles tree traversal, default: infinite]');
+    console.log('--name [Tileset name]');
+    console.log('--output [Output folder, default: "data" folder]');
+    console.log('--instant-node-writing [Keep created 3DNodeIndexDocument files on disk instead of memory. This option reduce memory usage but decelerates conversion speed]');
+    console.log('--split-nodes [Prevent to merge similar materials that could lead to incorrect visualization (I3S to 3DTiles conversion only)]');
+    console.log('--slpk [Generate slpk (Scene Layer Packages) I3S output file]');
+    console.log('--tileset [tileset.json file (3DTiles) / http://..../SceneServer/layers/0 resource (I3S)]');
+    console.log('--input-type [tileset input type: I3S or 3DTILES]');
+    console.log('--7zExe [location of 7z.exe archiver to create slpk on Windows, default: "C:\\Program Files\\7-Zip\\7z.exe"]');
+    console.log('--egm [location of Earth Gravity Model *.pgm file to convert heights from ellipsoidal to gravity-related format. A model file can be loaded from GeographicLib https://geographiclib.sourceforge.io/html/geoid.html], default: "./deps/egm2008-5.zip"');
+    console.log('--token [Token for Cesium ION tilesets authentication]');
+    console.log('--no-draco [Disable draco compression for geometry]');
+    console.log('--generate-textures [Enable KTX2 textures generation if only one of (JPG, PNG) texture is provided or generate JPG texture if only KTX2 is provided]');
+    console.log('--generate-bounding-volumes [Will generate obb and mbs bounding volumes from geometry]');
+    console.log('--validate [Enable validation]');
+    process.exit(0); // eslint-disable-line
+}
+/**
+ * Run conversion process
+ * @param options validated tile-converter options
+ */
+async function convert(options) {
+    console.log(`------------------------------------------------`); // eslint-disable-line
+    console.log(`Starting conversion of ${options.inputType}`); // eslint-disable-line
+    console.log(`------------------------------------------------`); // eslint-disable-line
+    const inputType = options.inputType.toUpperCase();
+    switch (inputType) {
+        case TILESET_TYPE.I3S:
+            const tiles3DConverter = new tile_converter_1.Tiles3DConverter();
+            tiles3DConverter.convert({
+                inputUrl: options.tileset,
+                outputPath: options.output,
+                tilesetName: options.name,
+                maxDepth: options.maxDepth,
+                egmFilePath: options.egm
+            });
+            break;
+        case TILESET_TYPE._3DTILES:
+            const converter = new tile_converter_1.I3SConverter();
+            await converter.convert({
+                inputUrl: options.tileset,
+                outputPath: options.output,
+                tilesetName: options.name,
+                maxDepth: options.maxDepth,
+                slpk: options.slpk,
+                sevenZipExe: options.sevenZipExe,
+                egmFilePath: options.egm,
+                token: options.token,
+                draco: options.draco,
+                mergeMaterials: options.mergeMaterials,
+                generateTextures: options.generateTextures,
+                generateBoundingVolumes: options.generateBoundingVolumes,
+                validate: options.validate,
+                instantNodeWriting: options.instantNodeWriting
+            });
+            break;
+        default:
+            printHelp();
+    }
+}
+// OPTIONS
+/**
+ * Validate input options of the CLI command
+ * @param options - input options of the CLI command
+ * @returns validated options
+ */
+function validateOptions(options) {
+    const mandatoryOptionsWithExceptions = {
+        name: () => console.log('Missed: --name [Tileset name]'),
+        output: () => console.log('Missed: --output [Output path name]'),
+        sevenZipExe: () => console.log('Missed: --7zExe [7z archiver executable path]'),
+        egm: () => console.log('Missed: --egm [*.pgm earth gravity model file path]'),
+        tileset: () => console.log('Missed: --tileset [tileset.json file]'),
+        inputType: () => console.log('Missed/Incorrect: --input-type [tileset input type: I3S or 3DTILES]')
+    };
+    const exceptions = [];
+    for (const mandatoryOption in mandatoryOptionsWithExceptions) {
+        const optionValue = options[mandatoryOption];
+        const isWrongInputType = Boolean(optionValue) &&
+            mandatoryOption === 'inputType' &&
+            !Object.values(TILESET_TYPE).includes(optionValue.toUpperCase());
+        if (!optionValue || isWrongInputType) {
+            exceptions.push(mandatoryOptionsWithExceptions[mandatoryOption]);
+        }
+    }
+    if (exceptions.length) {
+        exceptions.forEach((exeption) => exeption());
+        process.exit(1);
+    }
+    return options;
+}
+function validateOptionsWithEqual(args) {
+    return args.reduce((acc, curr) => {
+        const equalSignIndex = curr.indexOf('=');
+        const beforeEqual = curr.slice(0, equalSignIndex);
+        const afterEqual = curr.slice(equalSignIndex + 1, curr.length);
+        const condition = curr.includes('=') && curr.startsWith('--') && afterEqual;
+        if (condition) {
+            return acc.concat(beforeEqual, afterEqual);
+        }
+        return acc.concat(curr);
+    }, []);
+}
+/**
+ * Parse option from the cli arguments array
+ * @param args
+ * @returns
+ */
+function parseOptions(args) {
+    const opts = {
+        output: 'data',
+        instantNodeWriting: false,
+        mergeMaterials: true,
+        sevenZipExe: 'C:\\Program Files\\7-Zip\\7z.exe',
+        egm: (0, path_1.join)(process.cwd(), 'deps', 'egm2008-5.pgm'),
+        draco: true,
+        installDependencies: false,
+        generateTextures: false,
+        generateBoundingVolumes: false,
+        validate: false,
+        slpk: false
+    };
+    // eslint-disable-next-line complexity
+    args.forEach((arg, index) => {
+        if (arg.indexOf('--') === 0) {
+            switch (arg) {
+                case '--input-type':
+                    opts.inputType = getStringValue(index, args);
+                    break;
+                case '--tileset':
+                    opts.tileset = getURLValue(index, args);
+                    break;
+                case '--name':
+                    opts.name = getStringValue(index, args);
+                    break;
+                case '--output':
+                    opts.output = getStringValue(index, args);
+                    break;
+                case '--instant-node-writing':
+                    opts.instantNodeWriting = getBooleanValue(index, args);
+                    break;
+                case '--split-nodes':
+                    opts.mergeMaterials = getBooleanValue(index, args);
+                    break;
+                case '--max-depth':
+                    opts.maxDepth = getIntegerValue(index, args);
+                    break;
+                case '--slpk':
+                    opts.slpk = getBooleanValue(index, args);
+                    break;
+                case '--7zExe':
+                    opts.sevenZipExe = getStringValue(index, args);
+                    break;
+                case '--egm':
+                    opts.egm = getStringValue(index, args);
+                    break;
+                case '--token':
+                    opts.token = getStringValue(index, args);
+                    break;
+                case '--no-draco':
+                    opts.draco = getBooleanValue(index, args);
+                    break;
+                case '--validate':
+                    opts.validate = getBooleanValue(index, args);
+                    break;
+                case '--install-dependencies':
+                    opts.installDependencies = getBooleanValue(index, args);
+                    break;
+                case '--generate-textures':
+                    opts.generateTextures = getBooleanValue(index, args);
+                    break;
+                case '--generate-bounding-volumes':
+                    opts.generateBoundingVolumes = getBooleanValue(index, args);
+                    break;
+                case '--help':
+                    printHelp();
+                    break;
+                default:
+                    console.warn(`Unknown option ${arg}`);
+                    process.exit(0); // eslint-disable-line
+            }
+        }
+    });
+    return opts;
+}
+/**
+ * Get string option value from cli arguments
+ * @param index - option's name index in the argument's array.
+ *                The value of the option should be next to name of the option.
+ * @param args - cli arguments array
+ * @returns - string value of the option
+ */
+function getStringValue(index, args) {
+    if (index + 1 >= args.length) {
+        return '';
+    }
+    const value = args[index + 1];
+    if (value.indexOf('--') === 0) {
+        return '';
+    }
+    return value;
+}
+/**
+ * Modyfy URL path to be compatible with fetch
+ * @param index - option's name index in the argument's array.
+ *                The value of the option should be next to name of the option.
+ * @param args - cli arguments array
+ * @returns - string value of the option
+ */
+function getURLValue(index, args) {
+    const value = getStringValue(index, args);
+    console.log(`Input tileset value: ${value}`);
+    console.log(`Modified tileset value: ${value.replace(/\\/g, '/')}`);
+    return value.replace(/\\/g, '/');
+}
+/**
+ * Get integer option value from cli arguments
+ * @param index - option's name index in the argument's array
+ *                The value of the option should be next to name of the option.
+ * @param args - cli arguments array
+ * @returns - number value of the option
+ */
+function getIntegerValue(index, args) {
+    const stringValue = getStringValue(index, args);
+    const result = Number.parseInt(stringValue);
+    if (isFinite(result)) {
+        return result;
+    }
+    return NaN;
+}
+function getBooleanValue(index, args) {
+    const stringValue = getStringValue(index, args).toLowerCase().trim();
+    if (['--no-draco', '--split-nodes'].includes(args[index]) && !stringValue) {
+        return false;
+    }
+    if (!stringValue || stringValue === 'true') {
+        return true;
+    }
+    return false;
+}