@loaders.gl/tile-converter 4.0.0-alpha.4 → 4.0.0-alpha.5

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

@@ -1,7 +1,7 @@
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import { load, encode } from '@loaders.gl/core';
 import { Tileset3D } from '@loaders.gl/tiles';
-import { CesiumIonLoader } from '@loaders.gl/3d-tiles';
+import { CesiumIonLoader, Tiles3DLoader } from '@loaders.gl/3d-tiles';
 import { join } from 'path';
 import { v4 as uuidv4 } from 'uuid';
 import process from 'process';
@@ -18,9 +18,10 @@ import { convertGeometricErrorToScreenThreshold } from '../lib/utils/lod-convers
 import { PGMLoader } from '../pgm-loader';
 import { LAYERS as layersTemplate } from './json-templates/layers';
 import { NODE as nodeTemplate } from './json-templates/node';
-import { SHARED_RESOURCES_TEMPLATE } from './json-templates/shared-resources';
+import { SHARED_RESOURCES as sharedResourcesTemplate } from './json-templates/shared-resources';
 import { validateNodeBoundingVolumes } from './helpers/node-debug';
 import { KTX2BasisUniversalTextureWriter } from '@loaders.gl/textures';
+import { ImageWriter } from '@loaders.gl/images';
 const ION_DEFAULT_TOKEN = process.env.IonToken || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJlYWMxMzcyYy0zZjJkLTQwODctODNlNi01MDRkZmMzMjIxOWIiLCJpZCI6OTYyMCwic2NvcGVzIjpbImFzbCIsImFzciIsImdjIl0sImlhdCI6MTU2Mjg2NjI3M30.1FNiClUyk00YH_nWfSGpiQAjR5V2OvREDq1PJ5QMjWQ';
 const HARDCODED_NODES_PER_PAGE = 64;
 const _3D_TILES = '3DTILES';
@@ -30,6 +31,7 @@ const SHORT_INT_TYPE = 'Int32';
 const DOUBLE_TYPE = 'double';
 const OBJECT_ID_TYPE = 'OBJECTID';
 const REFRESH_TOKEN_TIMEOUT = 1800;
+const CESIUM_DATASET_PREFIX = 'https://';
 export default class I3SConverter {
   constructor() {
     _defineProperty(this, "nodePages", void 0);
@@ -54,15 +56,21 @@ export default class I3SConverter {
 
     _defineProperty(this, "validate", void 0);
 
-    _defineProperty(this, "boundingVolumeWarnings", void 0);
+    _defineProperty(this, "boundingVolumeWarnings", []);
 
-    _defineProperty(this, "conversionStartTime", void 0);
+    _defineProperty(this, "conversionStartTime", [0, 0]);
 
-    _defineProperty(this, "refreshTokenTime", void 0);
+    _defineProperty(this, "refreshTokenTime", [0, 0]);
 
-    _defineProperty(this, "sourceTileset", void 0);
+    _defineProperty(this, "sourceTileset", null);
 
-    _defineProperty(this, "geoidHeightModel", void 0);
+    _defineProperty(this, "geoidHeightModel", null);
+
+    _defineProperty(this, "Loader", Tiles3DLoader);
+
+    _defineProperty(this, "generateTextures", void 0);
+
+    _defineProperty(this, "generateBoundingVolumes", void 0);
 
     this.nodePages = new NodePages(writeFile, HARDCODED_NODES_PER_PAGE);
     this.fileMap = {};
@@ -78,7 +86,8 @@ export default class I3SConverter {
       tilesWithAddRefineCount: 0
     };
     this.validate = false;
-    this.boundingVolumeWarnings = null;
+    this.generateTextures = false;
+    this.generateBoundingVolumes = false;
   }
 
   async convert(options) {
@@ -93,7 +102,9 @@ export default class I3SConverter {
       draco,
       sevenZipExe,
       maxDepth,
-      token
+      token,
+      generateTextures,
+      generateBoundingVolumes
     } = options;
     this.options = {
       maxDepth,
@@ -104,7 +115,10 @@ export default class I3SConverter {
       token,
       inputUrl
     };
-    this.validate = validate;
+    this.validate = Boolean(validate);
+    this.Loader = inputUrl.indexOf(CESIUM_DATASET_PREFIX) !== -1 ? CesiumIonLoader : Tiles3DLoader;
+    this.generateTextures = Boolean(generateTextures);
+    this.generateBoundingVolumes = Boolean(generateBoundingVolumes);
     console.log('Loading egm file...');
     this.geoidHeightModel = await load(egmFilePath, PGMLoader);
     console.log('Loading egm file completed!');
@@ -115,7 +129,11 @@ export default class I3SConverter {
 
     const preloadOptions = await this._fetchPreloadOptions();
     const tilesetOptions = {
-      loadOptions: {}
+      loadOptions: {
+        basis: {
+          format: 'rgba32'
+        }
+      }
     };
 
     if (preloadOptions.headers) {
@@ -125,11 +143,11 @@ export default class I3SConverter {
     }
 
     Object.assign(tilesetOptions, preloadOptions);
-    const sourceTilesetJson = await load(inputUrl, CesiumIonLoader, tilesetOptions.loadOptions);
+    const sourceTilesetJson = await load(inputUrl, this.Loader, tilesetOptions.loadOptions);
     this.sourceTileset = new Tileset3D(sourceTilesetJson, tilesetOptions);
     await this._createAndSaveTileset(outputPath, tilesetName);
     await this._finishConversion({
-      slpk,
+      slpk: Boolean(slpk),
       outputPath,
       tilesetName
     });
@@ -152,6 +170,7 @@ export default class I3SConverter {
     const sourceRootTile = this.sourceTileset.root;
     const boundingVolumes = createBoundingVolumes(sourceRootTile, this.geoidHeightModel);
     const parentId = this.nodePages.push({
+      index: 0,
       lodThreshold: 0,
       obb: boundingVolumes.obb,
       children: []
@@ -185,7 +204,7 @@ export default class I3SConverter {
       },
       compressGeometry: this.options.draco
     };
-    this.layers0 = transform(layers0data, layersTemplate);
+    this.layers0 = transform(layers0data, layersTemplate());
   }
 
   _formRootNodeIndexDocument(boundingVolumes) {
@@ -203,13 +222,14 @@ export default class I3SConverter {
       ...boundingVolumes,
       children: []
     };
-    return transform(root0data, nodeTemplate);
+    return transform(root0data, nodeTemplate());
   }
 
   async _convertNodesTree(root0, sourceRootTile, parentId, boundingVolumes) {
     await this.sourceTileset._loadTile(sourceRootTile);
 
-    if (sourceRootTile.content && sourceRootTile.content.type === 'b3dm') {
+    if (this.isContentSupported(sourceRootTile)) {
+      root0.children = root0.children || [];
       root0.children.push({
         id: '1',
         href: './1',
@@ -296,14 +316,15 @@ export default class I3SConverter {
         });
         await sourceTile.unloadContent();
       } else {
-        const boundingVolumes = createBoundingVolumes(sourceTile, this.geoidHeightModel);
         const children = await this._createNode(parentNode, sourceTile, parentId, level);
+        parentNode.children = parentNode.children || [];
 
         for (const child of children) {
           parentNode.children.push({
             id: child.id,
             href: "../".concat(child.path),
-            ...boundingVolumes
+            obb: child.obb,
+            mbs: child.mbs
           });
           childNodes.push(child);
         }
@@ -317,18 +338,22 @@ export default class I3SConverter {
 
   async _addNeighborsAndWriteFile(parentNode, childNodes) {
     for (const node of childNodes) {
+      var _parentNode$children;
+
       const childPath = join(this.layers0Path, 'nodes', node.path);
       const nodePath = node.path;
       delete node.path;
 
-      if (parentNode.children.length < 1000) {
-        for (const neighbor of parentNode.children) {
+      if (Number(parentNode === null || parentNode === void 0 ? void 0 : (_parentNode$children = parentNode.children) === null || _parentNode$children === void 0 ? void 0 : _parentNode$children.length) < 1000) {
+        for (const neighbor of parentNode.children || []) {
           if (node.id === neighbor.id) {
             continue;
           }
 
-          node.neighbors.push({ ...neighbor
-          });
+          if (node.neighbors) {
+            node.neighbors.push({ ...neighbor
+            });
+          }
         }
       } else {
         console.warn("Node ".concat(node.id, ": neighbors attribute is omited because of large number of neigbors"));
@@ -349,11 +374,7 @@ export default class I3SConverter {
 
     await this._updateTilesetOptions();
     await this.sourceTileset._loadTile(sourceTile);
-    const boundingVolumes = createBoundingVolumes(sourceTile, this.geoidHeightModel);
-    const lodSelection = convertGeometricErrorToScreenThreshold(sourceTile, boundingVolumes);
-    const maxScreenThresholdSQ = lodSelection.find(val => val.metricType === 'maxScreenThresholdSQ') || {
-      maxError: 0
-    };
+    let boundingVolumes = createBoundingVolumes(sourceTile, this.geoidHeightModel);
     const batchTable = sourceTile === null || sourceTile === void 0 ? void 0 : (_sourceTile$content = sourceTile.content) === null || _sourceTile$content === void 0 ? void 0 : _sourceTile$content.batchTableJson;
 
     if (batchTable) {
@@ -362,6 +383,7 @@ export default class I3SConverter {
 
     const resourcesData = await this._convertResources(sourceTile);
     const nodes = [];
+    const nodesInPage = [];
     const emptyResources = {
       geometry: null,
       compressedGeometry: null,
@@ -370,10 +392,20 @@ export default class I3SConverter {
       meshMaterial: null,
       vertexCount: null,
       attributes: null,
-      featureCount: null
+      featureCount: null,
+      boundingVolumes: null
     };
 
     for (const resources of resourcesData || [emptyResources]) {
+      if (this.generateBoundingVolumes && resources.boundingVolumes) {
+        boundingVolumes = resources.boundingVolumes;
+      }
+
+      const lodSelection = convertGeometricErrorToScreenThreshold(sourceTile, boundingVolumes);
+      const maxScreenThresholdSQ = lodSelection.find(val => val.metricType === 'maxScreenThresholdSQ') || {
+        maxError: 0
+      };
+
       const nodeInPage = this._createNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources);
 
       const node = this._createNodeIndexDocument(parentTile, boundingVolumes, lodSelection, nodeInPage, resources);
@@ -391,33 +423,37 @@ export default class I3SConverter {
       }
 
       nodes.push(node);
+      nodesInPage.push(nodeInPage);
     }
 
     sourceTile.unloadContent();
-    const firstNode = nodes[0];
     await this._addChildrenWithNeighborsAndWriteFile({
-      parentNode: firstNode,
+      parentNode: nodes[0],
       sourceTiles: sourceTile.children,
-      parentId: firstNode.id,
+      parentId: nodesInPage[0].index,
       level: level + 1
     });
     return nodes;
   }
 
   _convertAttributeStorageInfo(sourceTileContent) {
+    var _this$layers, _this$layers$attribut;
+
     const batchTable = sourceTileContent && sourceTileContent.batchTableJson;
 
-    if (batchTable && !this.layers0.attributeStorageInfo.length) {
+    if (batchTable && !((_this$layers = this.layers0) !== null && _this$layers !== void 0 && (_this$layers$attribut = _this$layers.attributeStorageInfo) !== null && _this$layers$attribut !== void 0 && _this$layers$attribut.length)) {
       this._convertBatchTableInfoToNodeAttributes(batchTable);
     }
   }
 
   async _convertResources(sourceTile) {
-    if (!sourceTile.content || sourceTile.content.type !== 'b3dm') {
+    var _this$layers2;
+
+    if (!this.isContentSupported(sourceTile)) {
       return null;
     }
 
-    const resourcesData = await convertB3dmToI3sGeometry(sourceTile.content, Number(this.nodePages.nodesCounter), this.featuresHashArray, this.layers0.attributeStorageInfo, this.options.draco);
+    const resourcesData = await convertB3dmToI3sGeometry(sourceTile.content, Number(this.nodePages.nodesCounter), this.featuresHashArray, (_this$layers2 = this.layers0) === null || _this$layers2 === void 0 ? void 0 : _this$layers2.attributeStorageInfo, this.options.draco, this.generateBoundingVolumes, this.geoidHeightModel);
     return resourcesData;
   }
 
@@ -430,18 +466,24 @@ export default class I3SConverter {
       geometry
     } = resources;
     const nodeInPage = {
+      index: 0,
       lodThreshold: maxScreenThresholdSQ.maxError,
       obb: boundingVolumes.obb,
-      children: [],
-      mesh: null
+      children: []
     };
 
-    if (geometry && sourceTile.content && sourceTile.content.type === 'b3dm') {
+    if (geometry && this.isContentSupported(sourceTile)) {
       nodeInPage.mesh = {
         geometry: {
-          definition: texture ? 0 : 1
+          definition: texture ? 0 : 1,
+          resource: 0
         },
-        attribute: {}
+        attribute: {
+          resource: 0
+        },
+        material: {
+          definition: 0
+        }
       };
     }
 
@@ -492,9 +534,11 @@ export default class I3SConverter {
       children: [],
       neighbors: []
     };
-    const node = transform(nodeData, nodeTemplate);
+    const node = transform(nodeData, nodeTemplate());
 
     if (nodeInPage.mesh) {
+      var _this$layers3, _this$layers3$attribu;
+
       node.geometryData = [{
         href: './geometries/0'
       }];
@@ -510,7 +554,7 @@ export default class I3SConverter {
         }];
       }
 
-      if (attributes && attributes.length && this.layers0.attributeStorageInfo && this.layers0.attributeStorageInfo.length) {
+      if (attributes && attributes.length && (_this$layers3 = this.layers0) !== null && _this$layers3 !== void 0 && (_this$layers3$attribu = _this$layers3.attributeStorageInfo) !== null && _this$layers3$attribu !== void 0 && _this$layers3$attribu.length) {
         node.attributeData = [];
 
         for (let index = 0; index < attributes.length; index++) {
@@ -563,7 +607,7 @@ export default class I3SConverter {
 
   async _writeShared(sharedResources, childPath, slpkChildPath, nodePath) {
     sharedResources.nodePath = nodePath;
-    const sharedData = transform(sharedResources, SHARED_RESOURCES_TEMPLATE);
+    const sharedData = transform(sharedResources, sharedResourcesTemplate());
     const sharedDataStr = JSON.stringify(sharedData);
 
     if (this.options.slpk) {
@@ -577,39 +621,75 @@ export default class I3SConverter {
 
   async _writeTexture(texture, childPath, slpkChildPath) {
     if (texture) {
-      const format = this._getFormatByMimeType(texture.mimeType);
+      const format = this._getFormatByMimeType(texture === null || texture === void 0 ? void 0 : texture.mimeType);
+
+      const formats = [];
+      const textureData = texture.bufferView.data;
+
+      switch (format) {
+        case 'jpg':
+        case 'png':
+          {
+            formats.push({
+              name: '0',
+              format
+            });
+            await this.writeTextureFile(textureData, '0', format, childPath, slpkChildPath);
+
+            if (this.generateTextures) {
+              formats.push({
+                name: '1',
+                format: 'ktx2'
+              });
+              const ktx2TextureData = new Uint8Array(await encode(texture.image, KTX2BasisUniversalTextureWriter));
+              await this.writeTextureFile(ktx2TextureData, '1', 'ktx2', childPath, slpkChildPath);
+            }
+
+            break;
+          }
+
+        case 'ktx2':
+          {
+            formats.push({
+              name: '1',
+              format
+            });
+            await this.writeTextureFile(textureData, '1', format, childPath, slpkChildPath);
+
+            if (this.generateTextures) {
+              formats.push({
+                name: '0',
+                format: 'jpg'
+              });
+              const decodedFromKTX2TextureData = new Uint8Array(await encode(texture.image.data[0], ImageWriter));
+              await this.writeTextureFile(decodedFromKTX2TextureData, '0', 'jpg', childPath, slpkChildPath);
+            }
+          }
+      }
 
       if (!this.layers0.textureSetDefinitions.length) {
         this.layers0.textureSetDefinitions.push({
-          formats: [{
-            name: '0',
-            format
-          }, {
-            name: '1',
-            format: 'ktx2'
-          }]
+          formats
         });
       }
+    }
+  }
 
-      const textureData = texture.bufferView.data;
-      const ktx2TextureData = await encode(texture.image, KTX2BasisUniversalTextureWriter);
+  async writeTextureFile(textureData, name, format, childPath, slpkChildPath) {
+    const texturePath = join(childPath, "textures/".concat(name, "/"));
+    await writeFile(texturePath, textureData, "index.".concat(format));
 
-      if (this.options.slpk) {
-        const slpkTexturePath = join(childPath, 'textures');
-        const compress = false;
-        this.fileMap["".concat(slpkChildPath, "/textures/0.").concat(format)] = await writeFileForSlpk(slpkTexturePath, textureData, "0.".concat(format), compress);
-        this.fileMap["".concat(slpkChildPath, "/textures/1.ktx2")] = await writeFileForSlpk(slpkTexturePath, ktx2TextureData, "1.ktx2", compress);
-      } else {
-        const texturePath = join(childPath, 'textures/0/');
-        await writeFile(texturePath, textureData, "index.".concat(format));
-        const ktx2TexturePath = join(childPath, 'textures/1/');
-        await writeFile(ktx2TexturePath, ktx2TextureData, "index.ktx2");
-      }
+    if (this.options.slpk) {
+      const slpkTexturePath = join(childPath, 'textures');
+      const compress = false;
+      this.fileMap["".concat(slpkChildPath, "/textures/").concat(name, ".").concat(format)] = await writeFileForSlpk(slpkTexturePath, textureData, "".concat(name, ".").concat(format), compress);
     }
   }
 
   async _writeAttributes(attributes, childPath, slpkChildPath) {
-    if (attributes.length && this.layers0.attributeStorageInfo && this.layers0.attributeStorageInfo.length) {
+    var _this$layers4, _this$layers4$attribu;
+
+    if (attributes.length && (_this$layers4 = this.layers0) !== null && _this$layers4 !== void 0 && (_this$layers4$attribu = _this$layers4.attributeStorageInfo) !== null && _this$layers4$attribu !== void 0 && _this$layers4$attribu.length) {
       for (let index = 0; index < attributes.length; index++) {
         const folderName = this.layers0.attributeStorageInfo[index].key;
         const fileBuffer = new Uint8Array(attributes[index]);
@@ -633,6 +713,9 @@ export default class I3SConverter {
       case 'image/png':
         return 'png';
 
+      case 'image/ktx2':
+        return 'ktx2';
+
       default:
         return 'jpg';
     }
@@ -839,12 +922,16 @@ export default class I3SConverter {
   }
 
   async _fetchPreloadOptions() {
+    if (!this.Loader.preload) {
+      return {};
+    }
+
     const options = {
       'cesium-ion': {
         accessToken: this.options.token || ION_DEFAULT_TOKEN
       }
     };
-    const preloadOptions = await CesiumIonLoader.preload(this.options.inputUrl, options);
+    const preloadOptions = await this.Loader.preload(this.options.inputUrl, options);
     this.refreshTokenTime = process.hrtime();
     return { ...options,
       ...preloadOptions
@@ -883,5 +970,11 @@ export default class I3SConverter {
     this.refinementCounter.tilesCount += 1;
   }
 
+  isContentSupported(sourceRootTile) {
+    var _sourceRootTile$conte;
+
+    return ['b3dm', 'glTF'].includes(sourceRootTile === null || sourceRootTile === void 0 ? void 0 : (_sourceRootTile$conte = sourceRootTile.content) === null || _sourceRootTile$conte === void 0 ? void 0 : _sourceRootTile$conte.type);
+  }
+
 }
 //# sourceMappingURL=i3s-converter.js.map