@loaders.gl/i3s 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/lib/parsers/parse-i3s.d.ts

@@ -0,0 +1,6 @@
+import { I3STilesetHeader, I3STileHeader, I3SMinimalNodeData, Node3DIndexDocument } from '../../types';
+import type { LoaderOptions, LoaderContext } from '@loaders.gl/loader-utils';
+export declare function normalizeTileData(tile: Node3DIndexDocument, context: LoaderContext): I3STileHeader;
+export declare function normalizeTileNonUrlData(tile: I3SMinimalNodeData): I3STileHeader;
+export declare function normalizeTilesetData(tileset: I3STilesetHeader, options: LoaderOptions, context: LoaderContext): Promise<void>;
+//# sourceMappingURL=parse-i3s.d.ts.map

package/dist/lib/parsers/parse-i3s.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-i3s.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-i3s.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,gBAAgB,EAChB,aAAa,EAEb,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAE3E,wBAAgB,iBAAiB,CAAC,IAAI,EAAG,mBAAmB,EAAE,OAAO,EAAE,aAAa,GAAG,aAAa,CAyBnG;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAG,kBAAkB,GAAG,aAAa,CAmChF;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAG,gBAAgB,EAAE,OAAO,EAAG,aAAa,EAAE,OAAO,EAAE,aAAa,iBA0BrH"}

package/dist/lib/parsers/parse-i3s.js

@@ -1,76 +1,95 @@
-import { OrientedBoundingBox } from '@math.gl/culling';
-import { Ellipsoid } from '@math.gl/geospatial';
-import { load } from '@loaders.gl/core';
-import { TILE_TYPE, TILE_REFINEMENT, TILESET_TYPE } from '@loaders.gl/tiles';
-import I3SNodePagesTiles from '../helpers/i3s-nodepages-tiles';
-import { generateTileAttributeUrls, getUrlWithToken } from '../utils/url-utils';
-export function normalizeTileData(tile, options, context) {
-  tile.url = context.url;
-
-  if (tile.featureData) {
-    tile.featureUrl = "".concat(tile.url, "/").concat(tile.featureData[0].href);
-  }
-
-  if (tile.geometryData) {
-    tile.contentUrl = "".concat(tile.url, "/").concat(tile.geometryData[0].href);
-  }
-
-  if (tile.textureData) {
-    tile.textureUrl = "".concat(tile.url, "/").concat(tile.textureData[0].href);
-  }
-
-  if (tile.attributeData) {
-    tile.attributeUrls = generateTileAttributeUrls(tile);
-  }
-
-  return normalizeTileNonUrlData(tile);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeTilesetData = exports.normalizeTileNonUrlData = exports.normalizeTileData = void 0;
+const culling_1 = require("@math.gl/culling");
+const geospatial_1 = require("@math.gl/geospatial");
+const core_1 = require("@loaders.gl/core");
+const tiles_1 = require("@loaders.gl/tiles");
+const i3s_nodepages_tiles_1 = __importDefault(require("../helpers/i3s-nodepages-tiles"));
+const url_utils_1 = require("../utils/url-utils");
+function normalizeTileData(tile, context) {
+    const url = context.url || '';
+    let contentUrl;
+    if (tile.geometryData) {
+        contentUrl = `${url}/${tile.geometryData[0].href}`;
+    }
+    let textureUrl;
+    if (tile.textureData) {
+        textureUrl = `${url}/${tile.textureData[0].href}`;
+    }
+    let attributeUrls;
+    if (tile.attributeData) {
+        attributeUrls = (0, url_utils_1.generateTileAttributeUrls)(url, tile);
+    }
+    return normalizeTileNonUrlData({
+        ...tile,
+        url,
+        contentUrl,
+        textureUrl,
+        attributeUrls,
+        isDracoGeometry: false
+    });
 }
-export function normalizeTileNonUrlData(tile) {
-  const box = tile.obb ? [...Ellipsoid.WGS84.cartographicToCartesian(tile.obb.center), ...tile.obb.halfSize, ...tile.obb.quaternion] : undefined;
-  let sphere;
-
-  if (tile.mbs) {
-    sphere = [...Ellipsoid.WGS84.cartographicToCartesian(tile.mbs.slice(0, 3)), tile.mbs[3]];
-  } else if (box) {
-    const obb = new OrientedBoundingBox().fromCenterHalfSizeQuaternion(box.slice(0, 3), tile.obb.halfSize, tile.obb.quaternion);
-    const boundingSphere = obb.getBoundingSphere();
-    sphere = [...boundingSphere.center, boundingSphere.radius];
-    tile.mbs = [...tile.obb.center, boundingSphere.radius];
-  }
-
-  tile.boundingVolume = {
-    sphere,
-    box
-  };
-  tile.lodMetricType = tile.lodSelection[0].metricType;
-  tile.lodMetricValue = tile.lodSelection[0].maxError;
-  tile.transformMatrix = tile.transform;
-  tile.type = TILE_TYPE.MESH;
-  tile.refine = TILE_REFINEMENT.REPLACE;
-  return tile;
+exports.normalizeTileData = normalizeTileData;
+function normalizeTileNonUrlData(tile) {
+    const boundingVolume = {};
+    let mbs = [0, 0, 0, 1];
+    if (tile.mbs) {
+        mbs = tile.mbs;
+        boundingVolume.sphere = [
+            ...geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(tile.mbs.slice(0, 3)),
+            tile.mbs[3] // radius of sphere
+        ];
+    }
+    else if (tile.obb) {
+        boundingVolume.box = [
+            ...geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(tile.obb.center),
+            ...tile.obb.halfSize,
+            ...tile.obb.quaternion // quaternion
+        ];
+        const obb = new culling_1.OrientedBoundingBox().fromCenterHalfSizeQuaternion(boundingVolume.box.slice(0, 3), tile.obb.halfSize, tile.obb.quaternion);
+        const boundingSphere = obb.getBoundingSphere();
+        boundingVolume.sphere = [...boundingSphere.center, boundingSphere.radius];
+        mbs = [...tile.obb.center, boundingSphere.radius];
+    }
+    const lodMetricType = tile.lodSelection?.[0].metricType;
+    const lodMetricValue = tile.lodSelection?.[0].maxError;
+    const transformMatrix = tile.transform;
+    const type = tiles_1.TILE_TYPE.MESH;
+    /**
+     * I3S specification supports only REPLACE
+     */
+    const refine = tiles_1.TILE_REFINEMENT.REPLACE;
+    return { ...tile, mbs, boundingVolume, lodMetricType, lodMetricValue, transformMatrix, type, refine };
 }
-export async function normalizeTilesetData(tileset, options, context) {
-  tileset.url = context.url;
-
-  if (tileset.nodePages) {
-    tileset.nodePagesTile = new I3SNodePagesTiles(tileset, options);
-    tileset.root = await tileset.nodePagesTile.formTileFromNodePages(0);
-  } else {
-    var _options$i3s;
-
-    const rootNodeUrl = getUrlWithToken("".concat(tileset.url, "/nodes/root"), (_options$i3s = options.i3s) === null || _options$i3s === void 0 ? void 0 : _options$i3s.token);
-    tileset.root = await load(rootNodeUrl, tileset.loader, {
-      i3s: {
-        loadContent: false,
-        isTileHeader: true,
-        isTileset: false
-      }
-    });
-  }
-
-  tileset.basePath = tileset.url;
-  tileset.type = TILESET_TYPE.I3S;
-  tileset.lodMetricType = tileset.root.lodMetricType;
-  tileset.lodMetricValue = tileset.root.lodMetricValue;
+exports.normalizeTileNonUrlData = normalizeTileNonUrlData;
+async function normalizeTilesetData(tileset, options, context) {
+    tileset.url = context.url;
+    if (tileset.nodePages) {
+        tileset.nodePagesTile = new i3s_nodepages_tiles_1.default(tileset, options);
+        tileset.root = tileset.nodePagesTile.formTileFromNodePages(0);
+    }
+    else {
+        // @ts-expect-error options is not properly typed
+        const rootNodeUrl = (0, url_utils_1.getUrlWithToken)(`${tileset.url}/nodes/root`, options.i3s?.token);
+        // eslint-disable-next-line no-use-before-define
+        tileset.root = await (0, core_1.load)(rootNodeUrl, tileset.loader, {
+            ...options,
+            i3s: {
+                // @ts-expect-error options is not properly typed
+                ...options.i3s,
+                loadContent: false, isTileHeader: true, isTileset: false
+            }
+        });
+    }
+    // base path that non-absolute paths in tileset are relative to.
+    tileset.basePath = tileset.url;
+    tileset.type = tiles_1.TILESET_TYPE.I3S;
+    // populate from root node
+    tileset.lodMetricType = tileset.root.lodMetricType;
+    tileset.lodMetricValue = tileset.root.lodMetricValue;
 }
-//# sourceMappingURL=parse-i3s.js.map
+exports.normalizeTilesetData = normalizeTilesetData;

package/dist/lib/utils/convert-i3s-obb-to-mbs.d.ts

@@ -0,0 +1,2 @@
+export declare function convertI3SObbToMbs(obb: any): any[];
+//# sourceMappingURL=convert-i3s-obb-to-mbs.d.ts.map

package/dist/lib/utils/convert-i3s-obb-to-mbs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-i3s-obb-to-mbs.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/convert-i3s-obb-to-mbs.ts"],"names":[],"mappings":"AAGA,wBAAgB,kBAAkB,CAAC,GAAG,KAAA,SAgBrC"}

package/dist/lib/utils/convert-i3s-obb-to-mbs.js

@@ -1,9 +1,20 @@
-import { BoundingSphere } from '@math.gl/culling';
-import { Ellipsoid } from '@math.gl/geospatial';
-export function convertI3SObbToMbs(obb) {
-  const halfSize = obb.halfSize;
-  const centerCartesian = Ellipsoid.WGS84.cartographicToCartesian(obb.center);
-  const sphere = new BoundingSphere().fromCornerPoints([centerCartesian[0] - halfSize[0], centerCartesian[1] - halfSize[1], centerCartesian[2] - halfSize[2]], [centerCartesian[0] + halfSize[0], centerCartesian[1] + halfSize[1], centerCartesian[2] + halfSize[2]]);
-  return [...obb.center, sphere.radius];
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertI3SObbToMbs = void 0;
+const culling_1 = require("@math.gl/culling");
+const geospatial_1 = require("@math.gl/geospatial");
+function convertI3SObbToMbs(obb) {
+    const halfSize = obb.halfSize;
+    const centerCartesian = geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(obb.center);
+    const sphere = new culling_1.BoundingSphere().fromCornerPoints([
+        centerCartesian[0] - halfSize[0],
+        centerCartesian[1] - halfSize[1],
+        centerCartesian[2] - halfSize[2]
+    ], [
+        centerCartesian[0] + halfSize[0],
+        centerCartesian[1] + halfSize[1],
+        centerCartesian[2] + halfSize[2]
+    ]);
+    return [...obb.center, sphere.radius];
 }
-//# sourceMappingURL=convert-i3s-obb-to-mbs.js.map
+exports.convertI3SObbToMbs = convertI3SObbToMbs;

package/dist/lib/utils/customizeColors.d.ts

@@ -0,0 +1,14 @@
+import type { MeshAttribute } from '@loaders.gl/schema';
+import type { I3STileOptions, I3STilesetOptions } from '../../types';
+import { I3SLoaderOptions } from '../../i3s-loader';
+/**
+ * Modify vertex colors array to visualize 3D objects in a attribute driven way
+ * @param colors - vertex colors attribute
+ * @param featureIds - feature Ids attribute
+ * @param tileOptions - tile - related options
+ * @param tilesetOptions - tileset-related options
+ * @param options - loader options
+ * @returns midified colors attribute
+ */
+export declare function customizeColors(colors: MeshAttribute, featureIds: MeshAttribute, tileOptions: I3STileOptions, tilesetOptions: I3STilesetOptions, options?: I3SLoaderOptions): Promise<MeshAttribute>;
+//# sourceMappingURL=customizeColors.d.ts.map

package/dist/lib/utils/customizeColors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customizeColors.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/customizeColors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAQ,cAAc,EAAE,iBAAiB,EAAC,MAAM,aAAa,CAAC;AAI1E,OAAO,EAAC,gBAAgB,EAAC,MAAM,kBAAkB,CAAC;AAGlD;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,aAAa,EACzB,WAAW,EAAE,cAAc,EAC3B,cAAc,EAAE,iBAAiB,EACjC,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,aAAa,CAAC,CA8DxB"}

package/dist/lib/utils/customizeColors.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customizeColors = void 0;
+const core_1 = require("@loaders.gl/core");
+const i3s_attribute_loader_1 = require("../../i3s-attribute-loader");
+const url_utils_1 = require("../utils/url-utils");
+/**
+ * Modify vertex colors array to visualize 3D objects in a attribute driven way
+ * @param colors - vertex colors attribute
+ * @param featureIds - feature Ids attribute
+ * @param tileOptions - tile - related options
+ * @param tilesetOptions - tileset-related options
+ * @param options - loader options
+ * @returns midified colors attribute
+ */
+async function customizeColors(colors, featureIds, tileOptions, tilesetOptions, options) {
+    if (!options?.i3s?.colorsByAttribute) {
+        return colors;
+    }
+    const colorizeAttributeField = tilesetOptions.fields.find(({ name }) => name === options?.i3s?.colorsByAttribute?.attributeName);
+    if (!colorizeAttributeField ||
+        !['esriFieldTypeDouble', 'esriFieldTypeInteger', 'esriFieldTypeSmallInteger'].includes(colorizeAttributeField.type)) {
+        return colors;
+    }
+    const colorizeAttributeData = await loadFeatureAttributeData(colorizeAttributeField.name, tileOptions, tilesetOptions, options);
+    if (!colorizeAttributeData) {
+        return colors;
+    }
+    const objectIdField = tilesetOptions.fields.find(({ type }) => type === 'esriFieldTypeOID');
+    if (!objectIdField) {
+        return colors;
+    }
+    const objectIdAttributeData = await loadFeatureAttributeData(objectIdField.name, tileOptions, tilesetOptions, options);
+    if (!objectIdAttributeData) {
+        return colors;
+    }
+    const attributeValuesMap = {};
+    // @ts-expect-error
+    for (let i = 0; i < objectIdAttributeData[objectIdField.name].length; i++) {
+        // @ts-expect-error
+        attributeValuesMap[objectIdAttributeData[objectIdField.name][i]] = calculateColorForAttribute(
+        // @ts-expect-error
+        colorizeAttributeData[colorizeAttributeField.name][i], options);
+    }
+    for (let i = 0; i < featureIds.value.length; i++) {
+        const color = attributeValuesMap[featureIds.value[i]];
+        if (!color) {
+            continue; // eslint-disable-line no-continue
+        }
+        colors.value.set(color, i * 4);
+    }
+    return colors;
+}
+exports.customizeColors = customizeColors;
+/**
+ * Calculate rgba color from the attribute value
+ * @param attributeValue - value of the attribute
+ * @param options - loader options
+ * @returns - color array for a specific attribute value
+ */
+function calculateColorForAttribute(attributeValue, options) {
+    if (!options?.i3s?.colorsByAttribute) {
+        return [255, 255, 255, 255];
+    }
+    const { minValue, maxValue, minColor, maxColor } = options.i3s.colorsByAttribute;
+    const rate = (attributeValue - minValue) / (maxValue - minValue);
+    const color = [255, 255, 255, 255];
+    for (let i = 0; i < minColor.length; i++) {
+        color[i] = Math.round((maxColor[i] - minColor[i]) * rate + minColor[i]);
+    }
+    return color;
+}
+/**
+ * Load feature attribute data from the ArcGIS rest service
+ * @param attributeName - attribute name
+ * @param tileOptions - tile-related options
+ * @param tilesetOptions - tileset-related options
+ * @param options - loader options
+ * @returns - Array-like list of the attribute values
+ */
+async function loadFeatureAttributeData(attributeName, { attributeUrls }, { attributeStorageInfo }, options) {
+    const attributeIndex = attributeStorageInfo.findIndex(({ name }) => attributeName === name);
+    if (attributeIndex === -1) {
+        return null;
+    }
+    const objectIdAttributeUrl = (0, url_utils_1.getUrlWithToken)(attributeUrls[attributeIndex], options?.i3s?.token);
+    const attributeType = (0, i3s_attribute_loader_1.getAttributeValueType)(attributeStorageInfo[attributeIndex]);
+    const objectIdAttributeData = await (0, core_1.load)(objectIdAttributeUrl, i3s_attribute_loader_1.I3SAttributeLoader, {
+        attributeName,
+        attributeType
+    });
+    // @ts-expect-error TODO action engine
+    return objectIdAttributeData;
+}

package/dist/lib/utils/url-utils.d.ts

@@ -0,0 +1,22 @@
+import { Node3DIndexDocument } from '../../types';
+/**
+ * Generates url with token if it is exists.
+ * @param url
+ * @param token
+ * @returns
+ */
+export declare function getUrlWithToken(url: string, token?: string | null): string;
+/**
+ * Generates attribute urls for tile.
+ * @param tile
+ * @returns list of attribute urls
+ */
+export declare function generateTileAttributeUrls(url: string, tile: Node3DIndexDocument): string[];
+/**
+ * Generates attribute urls for tileset based on tileset and resource
+ * @param {Object} tileset
+ * @param {number} resource
+ * @returns {Array}
+ */
+export declare function generateTilesetAttributeUrls(tileset: any, resource: any): string[];
+//# sourceMappingURL=url-utils.d.ts.map

package/dist/lib/utils/url-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/url-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,mBAAmB,EAAC,MAAM,aAAa,CAAC;AAEhD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,GAAE,MAAM,GAAG,IAAW,GAAG,MAAM,CAEhF;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,GAAG,MAAM,EAAE,CAU1F;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,KAAA,EAAE,QAAQ,KAAA,YAU7D"}

package/dist/lib/utils/url-utils.js

@@ -1,32 +1,44 @@
-export function getUrlWithToken(url, token = null) {
-  return token ? "".concat(url, "?token=").concat(token) : url;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTilesetAttributeUrls = exports.generateTileAttributeUrls = exports.getUrlWithToken = void 0;
+/**
+ * Generates url with token if it is exists.
+ * @param url
+ * @param token
+ * @returns
+ */
+function getUrlWithToken(url, token = null) {
+    return token ? `${url}?token=${token}` : url;
 }
-export function generateTileAttributeUrls(tile) {
-  const {
-    url,
-    attributeData
-  } = tile;
-  const attributeUrls = [];
-
-  for (let index = 0; index < attributeData.length; index++) {
-    const attributeUrl = attributeData[index].href.replace('./', '');
-    attributeUrls.push("".concat(url, "/").concat(attributeUrl));
-  }
-
-  return attributeUrls;
+exports.getUrlWithToken = getUrlWithToken;
+/**
+ * Generates attribute urls for tile.
+ * @param tile
+ * @returns list of attribute urls
+ */
+function generateTileAttributeUrls(url, tile) {
+    const { attributeData = [] } = tile;
+    const attributeUrls = [];
+    for (let index = 0; index < attributeData.length; index++) {
+        const attributeUrl = attributeData[index].href.replace('./', '');
+        attributeUrls.push(`${url}/${attributeUrl}`);
+    }
+    return attributeUrls;
 }
-export function generateTilesetAttributeUrls(tileset, resource) {
-  const attributeUrls = [];
-  const {
-    attributeStorageInfo,
-    url
-  } = tileset;
-
-  for (let index = 0; index < attributeStorageInfo.length; index++) {
-    const fileName = attributeStorageInfo[index].key;
-    attributeUrls.push("".concat(url, "/nodes/").concat(resource, "/attributes/").concat(fileName, "/0"));
-  }
-
-  return attributeUrls;
+exports.generateTileAttributeUrls = generateTileAttributeUrls;
+/**
+ * Generates attribute urls for tileset based on tileset and resource
+ * @param {Object} tileset
+ * @param {number} resource
+ * @returns {Array}
+ */
+function generateTilesetAttributeUrls(tileset, resource) {
+    const attributeUrls = [];
+    const { attributeStorageInfo, url } = tileset;
+    for (let index = 0; index < attributeStorageInfo.length; index++) {
+        const fileName = attributeStorageInfo[index].key;
+        attributeUrls.push(`${url}/nodes/${resource}/attributes/${fileName}/0`);
+    }
+    return attributeUrls;
 }
-//# sourceMappingURL=url-utils.js.map
+exports.generateTilesetAttributeUrls = generateTilesetAttributeUrls;