@loaders.gl/tile-converter 3.1.6 → 3.2.0-alpha.1

package/dist/i3s-converter/json-templates/shared-resources.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHARED_RESOURCES = void 0;
+const json_map_transform_1 = __importDefault(require("json-map-transform"));
+const MATERIAL_DEFINITION_INFO_PARAMS = () => ({
+    renderMode: {
+        path: 'renderMode',
+        default: 'solid'
+    },
+    shininess: {
+        path: 'shininess',
+        default: 1
+    },
+    reflectivity: {
+        path: 'reflectivity',
+        default: 0
+    },
+    ambient: {
+        path: 'ambient',
+        default: [1, 1, 1, 1]
+    },
+    diffuse: {
+        path: 'diffuse',
+        default: [1, 1, 1, 1]
+    },
+    specular: {
+        path: 'specular',
+        default: [0, 0, 0, 0]
+    },
+    useVertexColorAlpha: {
+        path: 'useVertexColorAlpha',
+        default: false
+    },
+    vertexRegions: {
+        path: 'vertexRegions',
+        default: false
+    },
+    vertexColors: {
+        path: 'vertexColors',
+        default: true
+    }
+});
+const MATERIAL_DEFINITION_INFO = () => ({
+    name: {
+        path: 'name',
+        default: 'standard'
+    },
+    type: {
+        path: 'type',
+        default: 'standard'
+    },
+    params: {
+        path: 'params',
+        transform: (val, thisObject, originalObject) => (0, json_map_transform_1.default)(originalObject, MATERIAL_DEFINITION_INFO_PARAMS())
+    }
+});
+const TEXTURE_DEFINITION_IMAGE = () => ({
+    id: {
+        path: 'id'
+    },
+    size: {
+        path: 'size'
+    },
+    href: {
+        path: 'href',
+        default: ['../textures/0']
+    },
+    length: {
+        path: 'length'
+    }
+});
+const TEXTURE_DEFINITION_INFO = () => ({
+    encoding: {
+        path: 'encoding'
+    },
+    wrap: {
+        path: 'wrap',
+        default: ['none']
+    },
+    atlas: {
+        path: 'atlas',
+        default: false
+    },
+    uvSet: {
+        path: 'uvSet',
+        default: 'uv0'
+    },
+    channels: {
+        path: 'channels',
+        default: 'rgb'
+    },
+    images: {
+        path: 'images',
+        transform: (val, thisObject, originalObject) => val.map((image) => (0, json_map_transform_1.default)(image, TEXTURE_DEFINITION_IMAGE()))
+    }
+});
+const SHARED_RESOURCES = () => ({
+    materialDefinitions: {
+        path: 'materialDefinitionInfos',
+        transform: transfromMaterialDefinitions
+    },
+    textureDefinitions: {
+        path: 'textureDefinitionInfos',
+        transform: transfromTextureDefinitions
+    }
+});
+exports.SHARED_RESOURCES = SHARED_RESOURCES;
+function transfromMaterialDefinitions(materialDefinitionInfos, thisObject, originalObject) {
+    const result = {};
+    for (const [index, materialDefinitionInfo] of materialDefinitionInfos.entries()) {
+        result[`Mat${originalObject.nodePath}${index}`] = (0, json_map_transform_1.default)(materialDefinitionInfo, MATERIAL_DEFINITION_INFO());
+    }
+    return result;
+}
+function transfromTextureDefinitions(textureDefinitionInfos, thisObject, originalObject) {
+    if (!textureDefinitionInfos) {
+        return null;
+    }
+    const result = {};
+    for (const [index, textureDefinitionInfo] of textureDefinitionInfos.entries()) {
+        const imageIndex = `${originalObject.nodePath}${index}`;
+        textureDefinitionInfo.imageIndex = imageIndex;
+        result[imageIndex] = (0, json_map_transform_1.default)(textureDefinitionInfo, TEXTURE_DEFINITION_INFO());
+    }
+    return result;
+}

package/dist/i3s-converter/json-templates/store.d.ts

@@ -0,0 +1,95 @@
+export declare const STORE: {
+    id: {
+        path: string;
+        transform: (val: any) => any;
+    };
+    profile: {
+        path: string;
+        default: string;
+    };
+    version: {
+        path: string;
+        default: string;
+    };
+    resourcePattern: {
+        path: string;
+        default: string[];
+    };
+    rootNode: {
+        path: string;
+        default: string;
+    };
+    extent: {
+        path: string;
+    };
+    indexCRS: {
+        path: string;
+        default: string;
+    };
+    vertexCRS: {
+        path: string;
+        default: string;
+    };
+    normalReferenceFrame: {
+        path: string;
+        default: string;
+    };
+    attributeEncoding: {
+        path: string;
+        default: string;
+    };
+    textureEncoding: {
+        path: string;
+        default: string[];
+    };
+    lodType: {
+        path: string;
+        default: string;
+    };
+    lodModel: {
+        path: string;
+        default: string;
+    };
+    defaultGeometrySchema: {
+        path: string;
+        default: {
+            geometryType: string;
+            header: {
+                property: string;
+                type: string;
+            }[];
+            topology: string;
+            ordering: string[];
+            vertexAttributes: {
+                position: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+                normal: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+                uv0: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+                color: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+            };
+            featureAttributeOrder: string[];
+            featureAttributes: {
+                id: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+                faceRange: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=store.d.ts.map

package/dist/i3s-converter/json-templates/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/json-templates/store.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmGjB,CAAC"}

package/dist/i3s-converter/json-templates/store.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STORE = void 0;
+exports.STORE = {
+    id: {
+        path: 'id',
+        transform: (val) => val.toUpperCase()
+    },
+    profile: {
+        path: 'profile',
+        default: 'meshpyramids'
+    },
+    version: {
+        path: 'version',
+        default: '1.8'
+    },
+    resourcePattern: {
+        path: 'resourcePattern',
+        default: ['3dNodeIndexDocument', 'Attributes', 'SharedResource', 'Geometry']
+    },
+    rootNode: {
+        path: 'rootNode',
+        default: './nodes/root'
+    },
+    extent: {
+        path: 'extent'
+    },
+    indexCRS: {
+        path: 'indexCRS',
+        default: 'http://www.opengis.net/def/crs/EPSG/0/4326'
+    },
+    vertexCRS: {
+        path: 'vertexCRS',
+        default: 'http://www.opengis.net/def/crs/EPSG/0/4326'
+    },
+    normalReferenceFrame: {
+        path: 'normalReferenceFrame',
+        default: 'east-north-up'
+    },
+    attributeEncoding: {
+        path: 'attributeEncoding',
+        default: 'application/octet-stream; version=1.6'
+    },
+    textureEncoding: {
+        path: 'textureEncoding',
+        default: ['image/jpeg', 'image/ktx2']
+    },
+    lodType: {
+        path: 'lodType',
+        default: 'MeshPyramid'
+    },
+    lodModel: {
+        path: 'lodModel',
+        default: 'node-switching'
+    },
+    defaultGeometrySchema: {
+        path: 'defaultGeometrySchema',
+        default: {
+            geometryType: 'triangles',
+            header: [
+                {
+                    property: 'vertexCount',
+                    type: 'UInt32'
+                },
+                {
+                    property: 'featureCount',
+                    type: 'UInt32'
+                }
+            ],
+            topology: 'PerAttributeArray',
+            ordering: ['position', 'normal', 'uv0', 'color'],
+            vertexAttributes: {
+                position: {
+                    valueType: 'Float32',
+                    valuesPerElement: 3
+                },
+                normal: {
+                    valueType: 'Float32',
+                    valuesPerElement: 3
+                },
+                uv0: {
+                    valueType: 'Float32',
+                    valuesPerElement: 2
+                },
+                color: {
+                    valueType: 'UInt8',
+                    valuesPerElement: 4
+                }
+            },
+            featureAttributeOrder: ['id', 'faceRange'],
+            featureAttributes: {
+                id: {
+                    valueType: 'UInt64',
+                    valuesPerElement: 1
+                },
+                faceRange: {
+                    valueType: 'UInt32',
+                    valuesPerElement: 2
+                }
+            }
+        }
+    }
+};

package/dist/i3s-converter/types.d.ts

@@ -0,0 +1,39 @@
+import { BoundingVolumes, I3SMaterialDefinition, SharedResources } from '@loaders.gl/i3s';
+export declare type I3SConvertedResources = {
+    geometry: ArrayBuffer | null;
+    compressedGeometry?: ArrayBuffer | null;
+    texture: any | null;
+    sharedResources: SharedResources | null;
+    meshMaterial?: I3SMaterialDefinition | null;
+    vertexCount: number | null;
+    attributes: any | null;
+    featureCount: number | null;
+    geometryBuffer?: ArrayBuffer;
+    boundingVolumes: BoundingVolumes | null;
+};
+export declare type AttributesData = {
+    positions: Float32Array;
+    normals: Float32Array;
+    texCoords: Float32Array;
+    colors: Uint8Array;
+    featureIndices: number[];
+    triangleCount: number;
+    boundingVolumes?: BoundingVolumes | null;
+};
+export declare type GeometryAttributes = {
+    positions: Float32Array;
+    normals: Float32Array;
+    texCoords: Float32Array;
+    colors: Uint8Array;
+    faceRange: Uint32Array;
+    featureIds: number[];
+    featureCount: number;
+};
+export declare type GroupedByFeatureIdAttributes = {
+    featureId: number;
+    positions: Float32Array;
+    normals: Float32Array;
+    colors: Uint8Array;
+    texCoords: Float32Array;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/i3s-converter/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/i3s-converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAE,qBAAqB,EAAE,eAAe,EAAC,MAAM,iBAAiB,CAAC;AAExF,oBAAY,qBAAqB,GAAG;IAClC,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAC;IAC7B,kBAAkB,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IACxC,OAAO,EAAE,GAAG,GAAG,IAAI,CAAC;IACpB,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACxC,YAAY,CAAC,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAC5C,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,EAAE,GAAG,GAAG,IAAI,CAAC;IACvB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,cAAc,CAAC,EAAE,WAAW,CAAC;IAC7B,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;CACzC,CAAC;AAEF,oBAAY,cAAc,GAAG;IAC3B,SAAS,EAAE,YAAY,CAAC;IACxB,OAAO,EAAE,YAAY,CAAC;IACtB,SAAS,EAAE,YAAY,CAAC;IACxB,MAAM,EAAE,UAAU,CAAC;IACnB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;CAC1C,CAAC;AAEF,oBAAY,kBAAkB,GAAG;IAC/B,SAAS,EAAE,YAAY,CAAC;IACxB,OAAO,EAAE,YAAY,CAAC;IACtB,SAAS,EAAE,YAAY,CAAC;IACxB,MAAM,EAAE,UAAU,CAAC;IACnB,SAAS,EAAE,WAAW,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,oBAAY,4BAA4B,GAAG;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,YAAY,CAAC;IACxB,OAAO,EAAE,YAAY,CAAC;IACtB,MAAM,EAAE,UAAU,CAAC;IACnB,SAAS,EAAE,YAAY,CAAC;CACzB,CAAC"}

package/dist/i3s-converter/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/i3s-server/app.d.ts

@@ -0,0 +1,3 @@
+export = app;
+declare const app: any;
+//# sourceMappingURL=app.d.ts.map

package/dist/i3s-server/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../src/i3s-server/app.js"],"names":[],"mappings":";AAOA,uBAAsB"}

package/dist/i3s-server/app.js

@@ -0,0 +1,14 @@
+"use strict";
+const express = require('express');
+const path = require('path');
+const logger = require('morgan');
+const cors = require('cors');
+const indexRouter = require('./routes/index');
+const app = express();
+app.use(logger('dev'));
+app.use(express.json());
+app.use(express.urlencoded({ extended: false }));
+app.use(express.static(path.join(__dirname, 'public')));
+app.use(cors());
+app.use('/', indexRouter);
+module.exports = app;

package/dist/i3s-server/controllers/index-controller.d.ts

@@ -0,0 +1,2 @@
+export function getFileNameByUrl(url: any): Promise<string | null>;
+//# sourceMappingURL=index-controller.d.ts.map

package/dist/i3s-server/controllers/index-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-controller.d.ts","sourceRoot":"","sources":["../../../src/i3s-server/controllers/index-controller.js"],"names":[],"mappings":"AAQA,mEAYC"}

package/dist/i3s-server/controllers/index-controller.js

@@ -0,0 +1,23 @@
+"use strict";
+const path = require('path');
+const fs = require('fs');
+const { promises } = fs;
+const I3S_LAYER_PATH = process.env.I3sLayerPath || ''; // eslint-disable-line no-process-env, no-undef
+const FULL_LAYER_PATH = path.join(process.cwd(), I3S_LAYER_PATH); // eslint-disable-line no-undef
+async function getFileNameByUrl(url) {
+    const extensions = ['json', 'bin', 'jpg', 'jpeg', 'png', 'bin.dds', 'ktx2'];
+    for (const ext of extensions) {
+        const fileName = `${FULL_LAYER_PATH}${url}/index.${ext}`;
+        try {
+            await promises.access(fileName);
+            return fileName;
+        }
+        catch {
+            continue; // eslint-disable-line no-continue
+        }
+    }
+    return null;
+}
+module.exports = {
+    getFileNameByUrl
+};

package/dist/i3s-server/routes/index.d.ts

@@ -0,0 +1,3 @@
+export = router;
+declare const router: any;
+//# sourceMappingURL=index.d.ts.map

package/dist/i3s-server/routes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/i3s-server/routes/index.js"],"names":[],"mappings":";AACA,0BAAgC"}

package/dist/i3s-server/routes/index.js

@@ -0,0 +1,16 @@
+"use strict";
+const express = require('express');
+const router = express.Router();
+const { getFileNameByUrl } = require('../controllers/index-controller');
+/* GET home page. */
+router.get('*', async function (req, res, next) {
+    const fileName = await getFileNameByUrl(req.path);
+    if (fileName) {
+        res.sendFile(fileName);
+    }
+    else {
+        res.status(404);
+        res.send('File not found');
+    }
+});
+module.exports = router;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { default as I3SConverter } from './i3s-converter/i3s-converter';
+export { default as NodePages } from './i3s-converter/helpers/node-pages';
+export { default as Tiles3DConverter } from './3d-tiles-converter/3d-tiles-converter';
+export { DepsInstaller } from './deps-installer/deps-installer';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,MAAM,oCAAoC,CAAC;AAExE,OAAO,EAAC,OAAO,IAAI,gBAAgB,EAAC,MAAM,yCAAyC,CAAC;AAEpF,OAAO,EAAC,aAAa,EAAC,MAAM,iCAAiC,CAAC"}

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DepsInstaller = exports.Tiles3DConverter = exports.NodePages = exports.I3SConverter = void 0;
+var i3s_converter_1 = require("./i3s-converter/i3s-converter");
+Object.defineProperty(exports, "I3SConverter", { enumerable: true, get: function () { return __importDefault(i3s_converter_1).default; } });
+var node_pages_1 = require("./i3s-converter/helpers/node-pages");
+Object.defineProperty(exports, "NodePages", { enumerable: true, get: function () { return __importDefault(node_pages_1).default; } });
+var _3d_tiles_converter_1 = require("./3d-tiles-converter/3d-tiles-converter");
+Object.defineProperty(exports, "Tiles3DConverter", { enumerable: true, get: function () { return __importDefault(_3d_tiles_converter_1).default; } });
+var deps_installer_1 = require("./deps-installer/deps-installer");
+Object.defineProperty(exports, "DepsInstaller", { enumerable: true, get: function () { return deps_installer_1.DepsInstaller; } });

package/dist/lib/utils/compress-util.d.ts

@@ -0,0 +1,6 @@
+export function compressFileWithGzip(pathFile: any): Promise<any>;
+export function compressFilesWithZip(fileMap: any, outputFile: any, level?: number): Promise<any>;
+export function compressWithChildProcess(...args: any[]): Promise<void>;
+export function generateHash128FromZip(inputZipFile: any, outputFile: any): Promise<any>;
+export function addFileToZip(inputFolder: any, fileName: any, zipFile: any, sevenZipExe: any): Promise<void>;
+//# sourceMappingURL=compress-util.d.ts.map

package/dist/lib/utils/compress-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compress-util.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/compress-util.js"],"names":[],"mappings":"AAWA,kEAiBC;AAED,kGAoDC;AAED,wEAOC;AA0CD,yFA6CC;AASD,6GAGC"}