@loaders.gl/tile-converter 4.1.1 → 4.2.0-alpha.2

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

@@ -166,7 +166,6 @@ export default class I3SConverter {
     if (slpk) {
       this.nodePages.useWriteFunction(writeFileForSlpk);
     }
-    await this.conversionDump.createDumpFile(options);
     try {
       const preloadOptions = await this._fetchPreloadOptions();
       let tilesetUrl = inputUrl;
@@ -279,12 +278,34 @@ export default class I3SConverter {
   async _createAndSaveTileset(outputPath, tilesetName) {
     var _this$sourceTileset, _this$sourceTileset$r, _this$sourceTileset$r2;
     const tilesetPath = join(`${outputPath}`, `${tilesetName}`);
+    await this.conversionDump.createDump(this.options);
+    if (this.conversionDump.restored && this.options.inquirer) {
+      const result = await this.options.inquirer.prompt([{
+        name: 'resumeConversion',
+        type: 'confirm',
+        message: 'Dump file of the previous conversion exists, do you want to resume that conversion?'
+      }]);
+      if (!result.resumeConversion) {
+        this.conversionDump.reset();
+      }
+    }
+    this.layers0Path = join(tilesetPath, 'SceneServer', 'layers', '0');
+    const removePath = this.conversionDump.restored ? join(this.layers0Path, 'nodepages') : tilesetPath;
     try {
-      await removeDir(tilesetPath);
+      await removeDir(removePath);
     } catch (e) {}
-    this.layers0Path = join(tilesetPath, 'SceneServer', 'layers', '0');
+    if (this.conversionDump.restored && this.conversionDump.attributeMetadataInfo) {
+      this.attributeMetadataInfo.fromObject(this.conversionDump.attributeMetadataInfo);
+    }
     this.materialDefinitions = [];
     this.materialMap = new Map();
+    if (this.conversionDump.restored && this.conversionDump.materialDefinitions) {
+      for (let i = 0; i < this.conversionDump.materialDefinitions.length; i++) {
+        const hash = md5(JSON.stringify(this.conversionDump.materialDefinitions[i]));
+        this.materialMap.set(hash, i);
+      }
+      this.materialDefinitions = this.conversionDump.materialDefinitions;
+    }
     const sourceRootTile = this.sourceTileset.root;
     const sourceBoundingVolume = createBoundingVolume(sourceRootTile.boundingVolume, new Matrix4(sourceRootTile.transform), null);
     this._formLayers0(tilesetName, sourceBoundingVolume, (_this$sourceTileset = this.sourceTileset) === null || _this$sourceTileset === void 0 ? void 0 : (_this$sourceTileset$r = _this$sourceTileset.root) === null || _this$sourceTileset$r === void 0 ? void 0 : (_this$sourceTileset$r2 = _this$sourceTileset$r.boundingVolume) === null || _this$sourceTileset$r2 === void 0 ? void 0 : _this$sourceTileset$r2.region);
@@ -309,6 +330,9 @@ export default class I3SConverter {
     if (this.attributeMetadataInfo.attributeStorageInfo.length) {
       this.layers0.layerType = _3D_OBJECT_LAYER_TYPE;
     }
+    if (this.conversionDump.restored && this.conversionDump.textureSetDefinitions) {
+      this.layers0.textureSetDefinitions = this.conversionDump.textureSetDefinitions;
+    }
     this.layers0.materialDefinitions = this.materialDefinitions;
     this.layers0.geometryDefinitions = transform(this.geometryConfigs.map(config => ({
       geometryConfig: {
@@ -406,7 +430,13 @@ export default class I3SConverter {
       transformationMatrix = transformationMatrix.multiplyRight(sourceTile.transform);
     }
     const parentNode = parentNodes[0];
-    const childNodes = await this._createNode(parentNode, sourceTile, transformationMatrix);
+    const restoreResult = await this._restoreNode(parentNode, sourceTile, transformationMatrix);
+    let childNodes;
+    if (restoreResult === null) {
+      childNodes = await this._createNode(parentNode, sourceTile, transformationMatrix);
+    } else {
+      childNodes = restoreResult;
+    }
     await parentNode.addChildren(childNodes);
     const newTraversalProps = {
       transform: transformationMatrix,
@@ -435,6 +465,57 @@ export default class I3SConverter {
       await node.save();
     }
   }
+  async _generateNodeIndexDocument(boundingVolumes, resources, parentNode, sourceTile, isDumped) {
+    this.layersHasTexture = this.layersHasTexture || Boolean('texture' in resources && resources.texture || 'texelCountHint' in resources && resources.texelCountHint);
+    if (this.generateBoundingVolumes && resources.boundingVolumes) {
+      boundingVolumes = resources.boundingVolumes;
+    }
+    const lodSelection = convertGeometricErrorToScreenThreshold(sourceTile, boundingVolumes);
+    const maxScreenThresholdSQ = lodSelection.find(val => val.metricType === 'maxScreenThresholdSQ') || {
+      maxError: 0
+    };
+    if (isDumped) {
+      const draftObb = {
+        center: [],
+        halfSize: [],
+        quaternion: []
+      };
+      await this.nodePages.push({
+        index: 0,
+        obb: draftObb
+      }, parentNode.inPageId);
+    }
+    const nodeInPage = await this._updateNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentNode.inPageId, resources);
+    const nodeData = await NodeIndexDocument.createNodeIndexDocument(parentNode, boundingVolumes, lodSelection, nodeInPage, resources);
+    const node = await new NodeIndexDocument(nodeInPage.index, this).addData(nodeData);
+    return {
+      node,
+      nodeInPage,
+      nodeData
+    };
+  }
+  async _restoreNode(parentNode, sourceTile, transformationMatrix) {
+    this._checkAddRefinementTypeForTile(sourceTile);
+    await this._updateTilesetOptions();
+    if (this.conversionDump.restored && sourceTile.id && this.conversionDump.isFileConversionComplete(sourceTile.id)) {
+      const sourceBoundingVolume = createBoundingVolume(sourceTile.boundingVolume, transformationMatrix, null);
+      let boundingVolumes = createBoundingVolumes(sourceBoundingVolume, this.geoidHeightModel);
+      const nodes = [];
+      for (const convertedNode of this.conversionDump.tilesConverted[sourceTile.id].nodes) {
+        const {
+          node
+        } = await this._generateNodeIndexDocument(boundingVolumes, {
+          ...convertedNode.dumpMetadata,
+          nodeId: convertedNode.nodeId
+        }, parentNode, sourceTile, true);
+        nodes.push(node);
+      }
+      return nodes;
+    } else if (this.conversionDump.restored && sourceTile.id) {
+      this.conversionDump.clearDumpRecord(sourceTile.id);
+    }
+    return null;
+  }
   async _createNode(parentNode, sourceTile, transformationMatrix) {
     this._checkAddRefinementTypeForTile(sourceTile);
     await this._updateTilesetOptions();
@@ -448,6 +529,11 @@ export default class I3SConverter {
     let boundingVolumes = createBoundingVolumes(sourceBoundingVolume, this.geoidHeightModel);
     const propertyTable = getPropertyTable(tileContent, this.options.metadataClass);
     this.createAttributeStorageInfo(tileContent, propertyTable);
+    this.conversionDump.attributeMetadataInfo = {
+      attributeStorageInfo: this.attributeMetadataInfo.attributeStorageInfo,
+      fields: this.attributeMetadataInfo.fields,
+      popupInfo: this.attributeMetadataInfo.popupInfo
+    };
     const resourcesData = await this._convertResources(sourceTile, transformationMatrix, sourceBoundingVolume, tileContent, parentNode.inPageId, propertyTable);
     const nodes = [];
     const nodeIds = [];
@@ -465,21 +551,27 @@ export default class I3SConverter {
       boundingVolumes: null
     };
     for (const resources of resourcesData || [emptyResources]) {
-      this.layersHasTexture = this.layersHasTexture || Boolean(resources.texture);
-      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 = await this._updateNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentNode.inPageId, resources);
-      const nodeData = await NodeIndexDocument.createNodeIndexDocument(parentNode, boundingVolumes, lodSelection, nodeInPage, resources);
-      const node = await new NodeIndexDocument(nodeInPage.index, this).addData(nodeData);
+      const {
+        node,
+        nodeInPage,
+        nodeData
+      } = await this._generateNodeIndexDocument(boundingVolumes, resources, parentNode, sourceTile, false);
       nodes.push(node);
       if (nodeInPage.mesh) {
         if (sourceTile.id) {
-          await this.conversionDump.addNode(sourceTile.id, nodeInPage.index);
+          var _resources$attributes;
+          const dumpMetadata = {
+            boundingVolumes: resources.boundingVolumes,
+            attributesCount: (_resources$attributes = resources.attributes) === null || _resources$attributes === void 0 ? void 0 : _resources$attributes.length,
+            featureCount: resources.featureCount,
+            geometry: Boolean(resources.geometry),
+            hasUvRegions: resources.hasUvRegions,
+            materialId: nodeInPage.mesh.material.definition,
+            texelCountHint: nodeInPage.mesh.material.texelCountHint,
+            vertexCount: resources.vertexCount
+          };
+          this.conversionDump.setMaterialsDefinitions(this.materialDefinitions);
+          await this.conversionDump.addNode(sourceTile.id, nodeInPage.index, dumpMetadata);
         }
         await this._writeResources(resources, node.id, sourceTile);
       }
@@ -511,8 +603,6 @@ export default class I3SConverter {
   }
   async _updateNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources) {
     const {
-      meshMaterial,
-      texture,
       vertexCount,
       featureCount,
       geometry,
@@ -527,7 +617,7 @@ export default class I3SConverter {
     if (geometry && this.isContentSupported(sourceTile)) {
       nodeInPage.mesh = {
         geometry: {
-          definition: this.findOrCreateGeometryDefinition(Boolean(texture), hasUvRegions),
+          definition: this.findOrCreateGeometryDefinition(Boolean('texture' in resources && resources.texture || 'texelCountHint' in resources && resources.texelCountHint), hasUvRegions),
           resource: 0
         },
         attribute: {
@@ -538,7 +628,7 @@ export default class I3SConverter {
         }
       };
     }
-    let nodeId = resources.nodeId;
+    let nodeId = 'nodeId' in resources ? resources.nodeId : undefined;
     let node;
     if (!nodeId) {
       node = await this.nodePages.push(nodeInPage, parentId);
@@ -549,12 +639,16 @@ export default class I3SConverter {
       console.log(`[warning]: node ${node.index} is created with empty content`);
     }
     NodePages.updateAll(node, nodeInPage);
-    if (meshMaterial) {
-      NodePages.updateMaterialByNodeId(node, this._findOrCreateMaterial(meshMaterial));
+    if ('meshMaterial' in resources && resources.meshMaterial) {
+      NodePages.updateMaterialByNodeId(node, this._findOrCreateMaterial(resources.meshMaterial));
+    } else if ('materialId' in resources && resources.materialId !== null) {
+      NodePages.updateMaterialByNodeId(node, resources.materialId);
     }
-    if (texture) {
-      const texelCountHint = texture.image.height * texture.image.width;
+    if ('texture' in resources && resources.texture) {
+      const texelCountHint = resources.texture.image.height * resources.texture.image.width;
       NodePages.updateTexelCountHintByNodeId(node, texelCountHint);
+    } else if ('texelCountHint' in resources && resources.texelCountHint) {
+      NodePages.updateTexelCountHintByNodeId(node, resources.texelCountHint);
     }
     if (vertexCount) {
       this.vertexCounter += vertexCount;
@@ -717,6 +811,9 @@ export default class I3SConverter {
           formats,
           atlas: true
         });
+        if (this.layers0.textureSetDefinitions) {
+          this.conversionDump.addTexturesDefinitions(this.layers0.textureSetDefinitions);
+        }
       }
     }
   }