@loaders.gl/i3s 3.1.0-alpha.3 → 4.0.0-alpha.4

package/src/lib/helpers/i3s-nodepages-tiles.ts

@@ -1,5 +1,5 @@
 import {load} from '@loaders.gl/core';
-import {getSupportedGPUTextureFormats} from '@loaders.gl/textures';
+import {getSupportedGPUTextureFormats, selectSupportedBasisFormat} from '@loaders.gl/textures';
 import {Tileset, NodePage} from '../../types';
 import {I3SNodePageLoader} from '../../i3s-node-page-loader';
 import {normalizeTileNonUrlData} from '../parsers/parse-i3s';
@@ -16,6 +16,7 @@ export default class I3SNodePagesTiles {
   options: {[key: string]: any};
   lodSelectionMetricType: any;
   textureDefinitionsSelectedFormats: any[] = [];
+  private textureLoaderOptions: {[key: string]: any} = {};
 
   /**
    * @constructs
@@ -29,7 +30,7 @@ export default class I3SNodePagesTiles {
     this.lodSelectionMetricType = tileset.nodePages.lodSelectionMetricType;
     this.options = options;
 
-    this._initSelectedFormatsForTextureDefinitions(tileset);
+    this.initSelectedFormatsForTextureDefinitions(tileset);
   }
 
   /**
@@ -83,11 +84,11 @@ export default class I3SNodePagesTiles {
     if (node && node.mesh) {
       // Get geometry resource URL and type (compressed / non-compressed)
       const {url, isDracoGeometry: isDracoGeometryResult} = (node.mesh.geometry &&
-        this._getContentUrl(node.mesh.geometry)) || {url: null, isDracoGeometry: null};
+        this.getContentUrl(node.mesh.geometry)) || {url: null, isDracoGeometry: null};
       contentUrl = url;
       isDracoGeometry = isDracoGeometryResult;
 
-      const [textureData, nodeMaterialDefinition] = this._getInformationFromMaterial(
+      const [textureData, nodeMaterialDefinition] = this.getInformationFromMaterial(
         node.mesh.material
       );
       materialDefinition = nodeMaterialDefinition;
@@ -101,7 +102,7 @@ export default class I3SNodePagesTiles {
       }
     }
 
-    const lodSelection = this._getLodSelection(node);
+    const lodSelection = this.getLodSelection(node);
 
     return normalizeTileNonUrlData({
       id,
@@ -112,6 +113,7 @@ export default class I3SNodePagesTiles {
       attributeUrls,
       materialDefinition,
       textureFormat,
+      textureLoaderOptions: this.textureLoaderOptions,
       children,
       isDracoGeometry
     });
@@ -124,7 +126,7 @@ export default class I3SNodePagesTiles {
    *   {string} url - url to the geometry resource
    *   {boolean} isDracoGeometry - whether the geometry resource contain DRACO compressed geometry
    */
-  _getContentUrl(meshGeometryData) {
+  private getContentUrl(meshGeometryData) {
     let result = {};
     const geometryDefinition = this.tileset.geometryDefinitions[meshGeometryData.definition];
     let geometryIndex = -1;
@@ -159,7 +161,7 @@ export default class I3SNodePagesTiles {
    *   {string} metricType - the label of the LOD metric
    *   {number} maxError - the value of the metric
    */
-  _getLodSelection(node): object[] {
+  private getLodSelection(node): object[] {
     const lodSelection: object[] = [];
     if (this.lodSelectionMetricType === 'maxScreenThresholdSQ') {
       lodSelection.push({
@@ -182,7 +184,7 @@ export default class I3SNodePagesTiles {
    * {string} textureData.format - format of the texture
    * materialDefinition - PBR-like material definition from `materialDefinitions`
    */
-  _getInformationFromMaterial(material) {
+  private getInformationFromMaterial(material) {
     const textureDataDefault = {name: null, format: null};
     if (material) {
       const materialDefinition = this.tileset.materialDefinitions[material.definition];
@@ -206,13 +208,13 @@ export default class I3SNodePagesTiles {
    * @param {Object} tileset - I3S layer data
    * @returns {void}
    */
-  _initSelectedFormatsForTextureDefinitions(tileset) {
+  private initSelectedFormatsForTextureDefinitions(tileset) {
     this.textureDefinitionsSelectedFormats = [];
-    const possibleI3sFormats = this._getSupportedTextureFormats();
+    const possibleI3sFormats = this.getSupportedTextureFormats();
     const textureSetDefinitions = tileset.textureSetDefinitions || [];
     for (const textureSetDefinition of textureSetDefinitions) {
       const formats = (textureSetDefinition && textureSetDefinition.formats) || [];
-      let selectedFormat = null;
+      let selectedFormat: {format: string; name: string} | null = null;
       for (const i3sFormat of possibleI3sFormats) {
         const format = formats.find((value) => value.format === i3sFormat);
         if (format) {
@@ -220,6 +222,15 @@ export default class I3SNodePagesTiles {
           break;
         }
       }
+      // For I3S 1.8 need to define basis target format to decode
+      if (selectedFormat && selectedFormat.format === 'ktx2') {
+        this.textureLoaderOptions.basis = {
+          format: selectSupportedBasisFormat(),
+          containerFormat: 'ktx2',
+          module: 'encoder'
+        };
+      }
+
       this.textureDefinitionsSelectedFormats.push(selectedFormat);
     }
   }
@@ -228,9 +239,10 @@ export default class I3SNodePagesTiles {
    * Returns the array of supported texture format
    * @returns list of format strings
    */
-  _getSupportedTextureFormats(): string[] {
+  private getSupportedTextureFormats(): string[] {
     const formats: string[] = [];
     if (!this.options.i3s || this.options.i3s.useCompressedTextures) {
+      // I3S 1.7 selection
       const supportedCompressedFormats = getSupportedGPUTextureFormats();
       // List of possible in i3s formats:
       // https://github.com/Esri/i3s-spec/blob/master/docs/1.7/textureSetDefinitionFormat.cmn.md
@@ -240,6 +252,10 @@ export default class I3SNodePagesTiles {
       if (supportedCompressedFormats.has('dxt')) {
         formats.push('dds');
       }
+
+      // I3S 1.8 selection
+      // ktx2 wraps basis texture which at the edge case can be decoded as uncompressed image
+      formats.push('ktx2');
     }
 
     formats.push('jpg');

package/src/lib/parsers/constants.ts

@@ -47,3 +47,25 @@ export const SIZEOF = {
 export const STRING_ATTRIBUTE_TYPE = 'String';
 export const OBJECT_ID_ATTRIBUTE_TYPE = 'Oid32';
 export const FLOAT_64_TYPE = 'Float64';
+export const INT_16_ATTRIBUTE_TYPE = 'Int16';
+
+// https://github.com/visgl/deck.gl/blob/9548f43cba2234a1f4877b6b17f6c88eb35b2e08/modules/core/src/lib/constants.js#L27
+// Describes the format of positions
+export const COORDINATE_SYSTEM = {
+  // `LNGLAT` if rendering into a geospatial viewport, `CARTESIAN` otherwise
+  DEFAULT: -1,
+  // Positions are interpreted as [lng, lat, elevation]
+  // lng lat are degrees, elevation is meters. distances as meters.
+  LNGLAT: 1,
+
+  // Positions are interpreted as meter offsets, distances as meters
+  METER_OFFSETS: 2,
+
+  // Positions are interpreted as lng lat offsets: [deltaLng, deltaLat, elevation]
+  // deltaLng, deltaLat are delta degrees, elevation is meters.
+  // distances as meters.
+  LNGLAT_OFFSETS: 3,
+
+  // Non-geospatial
+  CARTESIAN: 0
+};

package/src/lib/parsers/parse-i3s-attribute.ts

@@ -1,4 +1,9 @@
-import {STRING_ATTRIBUTE_TYPE, OBJECT_ID_ATTRIBUTE_TYPE, FLOAT_64_TYPE} from './constants';
+import {
+  STRING_ATTRIBUTE_TYPE,
+  OBJECT_ID_ATTRIBUTE_TYPE,
+  FLOAT_64_TYPE,
+  INT_16_ATTRIBUTE_TYPE
+} from './constants';
 
 /**
  * Get particular tile and creates attribute object inside.
@@ -31,6 +36,8 @@ function parseAttribute(attributeType, arrayBuffer) {
       return parseShortNumberAttribute(arrayBuffer);
     case FLOAT_64_TYPE:
       return parseFloatAttribute(arrayBuffer);
+    case INT_16_ATTRIBUTE_TYPE:
+      return parseInt16ShortNumberAttribute(arrayBuffer);
     default:
       return parseShortNumberAttribute(arrayBuffer);
   }
@@ -47,6 +54,17 @@ function parseShortNumberAttribute(arrayBuffer) {
   return new Uint32Array(arrayBuffer, countOffset);
 }
 
+/**
+ * Parse Int16 short number attribute.
+ * Parsing of such data is not documented. Added to handle Building Scene Layer Tileset attributes data.
+ * @param {ArrayBuffer} arrayBuffer
+ * @returns {Int16Array}
+ */
+function parseInt16ShortNumberAttribute(arrayBuffer) {
+  const countOffset = 4;
+  return new Int16Array(arrayBuffer, countOffset);
+}
+
 /**
  * Parse float attribute.
  * Double Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.7/attributeStorageInfo.cmn.md

package/src/lib/parsers/parse-i3s-building-scene-layer.ts

@@ -0,0 +1,57 @@
+import type {BuildingSceneLayerTileset, BuildingSceneSublayer} from '../../types';
+
+const OBJECT_3D_LAYER_TYPE = '3DObject';
+
+/**
+ * Parses Builiding Scene Layer and creates tileset
+ * @param data
+ * @param options
+ * @param context
+ */
+export async function parseBuildingSceneLayer(
+  data: ArrayBuffer,
+  url: string
+): Promise<BuildingSceneLayerTileset> {
+  const layer0 = JSON.parse(new TextDecoder().decode(data));
+  const {sublayers} = layer0;
+
+  return {
+    header: layer0,
+    sublayers: parseSublayersTree(sublayers, url)
+  };
+}
+
+/**
+ * Recursively parses Building Scene Layer sublayers.
+ * @param sublayers
+ * @param url
+ */
+function parseSublayersTree(
+  sublayers: BuildingSceneSublayer[],
+  url: string
+): BuildingSceneSublayer[] {
+  let layers: BuildingSceneSublayer[] = [];
+
+  for (let index = 0; index < sublayers.length; index++) {
+    const subLayer = sublayers[index];
+    const {id, layerType, ...rest} = subLayer;
+
+    // Add support only for 3DObject layer type for I3S purposes.
+    if (layerType === OBJECT_3D_LAYER_TYPE) {
+      const sublayerUrl = `${url}/sublayers/${id}`;
+
+      layers.push({
+        url: sublayerUrl,
+        id,
+        layerType,
+        ...rest
+      });
+    }
+
+    if (subLayer?.sublayers?.length) {
+      layers = [...layers, ...parseSublayersTree(subLayer.sublayers, url)];
+    }
+  }
+
+  return layers;
+}

package/src/lib/parsers/parse-i3s-tile-content.ts

@@ -17,7 +17,8 @@ import {
   SIZEOF,
   I3S_NAMED_HEADER_ATTRIBUTES,
   I3S_NAMED_VERTEX_ATTRIBUTES,
-  I3S_NAMED_GEOMETRY_ATTRIBUTES
+  I3S_NAMED_GEOMETRY_ATTRIBUTES,
+  COORDINATE_SYSTEM
 } from './constants';
 
 const scratchVector = new Vector3([0, 0, 0]);
@@ -53,22 +54,26 @@ export async function parseI3STileContent(
     const response = await fetch(url);
     const arrayBuffer = await response.arrayBuffer();
 
-    if (loader === ImageLoader) {
-      const options = {...tile.textureLoaderOptions, image: {type: 'data'}};
-      // @ts-ignore context must be defined
-      // Image constructor is not supported in worker thread.
-      // Do parsing image data on the main thread by using context to avoid worker issues.
-      tile.content.texture = await context.parse(arrayBuffer, options);
-    } else if (loader === CompressedTextureLoader || loader === BasisLoader) {
-      // @ts-ignore context must be defined
-      const texture = await load(arrayBuffer, loader, tile.textureLoaderOptions);
-      tile.content.texture = {
-        compressed: true,
-        mipmaps: false,
-        width: texture[0].width,
-        height: texture[0].height,
-        data: texture
-      };
+    if (options?.i3s.decodeTextures) {
+      if (loader === ImageLoader) {
+        const options = {...tile.textureLoaderOptions, image: {type: 'data'}};
+        // @ts-ignore context must be defined
+        // Image constructor is not supported in worker thread.
+        // Do parsing image data on the main thread by using context to avoid worker issues.
+        tile.content.texture = await context.parse(arrayBuffer, options);
+      } else if (loader === CompressedTextureLoader || loader === BasisLoader) {
+        // @ts-ignore context must be defined
+        const texture = await load(arrayBuffer, loader, tile.textureLoaderOptions);
+        tile.content.texture = {
+          compressed: true,
+          mipmaps: false,
+          width: texture[0].width,
+          height: texture[0].height,
+          data: texture
+        };
+      }
+    } else {
+      tile.content.texture = arrayBuffer;
     }
   }
 
@@ -77,13 +82,14 @@ export async function parseI3STileContent(
     tile.content.texture = null;
   }
 
-  return await parseI3SNodeGeometry(arrayBuffer, tile, context);
+  return await parseI3SNodeGeometry(arrayBuffer, tile, options, context);
 }
 
 /* eslint-disable max-statements */
 async function parseI3SNodeGeometry(
   arrayBuffer: ArrayBuffer,
   tile: Tile = {},
+  options?: LoaderOptions,
   context?: LoaderContext
 ) {
   if (!tile.content) {
@@ -161,12 +167,17 @@ async function parseI3SNodeGeometry(
     attributes = concatAttributes(normalizedVertexAttributes, normalizedFeatureAttributes);
   }
 
-  const {enuMatrix, cartographicOrigin, cartesianOrigin} = parsePositions(
-    attributes.position,
-    tile
-  );
-
-  const matrix = new Matrix4().multiplyRight(enuMatrix);
+  if (
+    !options?.i3s?.coordinateSystem ||
+    options.i3s.coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS
+  ) {
+    const {enuMatrix} = parsePositions(attributes.position, tile);
+    content.modelMatrix = enuMatrix.invert();
+    content.coordinateSystem = COORDINATE_SYSTEM.METER_OFFSETS;
+  } else {
+    content.modelMatrix = getModelMatrix(attributes.position);
+    content.coordinateSystem = COORDINATE_SYSTEM.LNGLAT_OFFSETS;
+  }
 
   content.attributes = {
     positions: attributes.position,
@@ -189,9 +200,6 @@ async function parseI3SNodeGeometry(
   }
 
   content.vertexCount = vertexCount;
-  content.cartographicCenter = cartographicOrigin;
-  content.cartesianOrigin = cartesianOrigin;
-  content.modelMatrix = matrix.invert();
   content.byteLength = arrayBuffer.byteLength;
 
   return tile;
@@ -395,10 +403,7 @@ function parsePositions(attribute, tile) {
   attribute.value = offsetsToCartesians(value, metadata, cartographicOrigin);
 
   return {
-    enuMatrix,
-    fixedFrameToENUMatrix: enuMatrix.invert(),
-    cartographicOrigin,
-    cartesianOrigin
+    enuMatrix
   };
 }
 
@@ -431,6 +436,21 @@ function offsetsToCartesians(vertices, metadata = {}, cartographicOrigin) {
   return positions;
 }
 
+/**
+ * Get model matrix for loaded vertices
+ * @param positions positions attribute
+ * @returns Matrix4 - model matrix for geometry transformation
+ */
+function getModelMatrix(positions) {
+  const metadata = positions.metadata;
+  const scaleX = metadata?.['i3s-scale_x']?.double || 1;
+  const scaleY = metadata?.['i3s-scale_y']?.double || 1;
+  const modelMatrix = new Matrix4();
+  modelMatrix[0] = scaleX;
+  modelMatrix[5] = scaleY;
+  return modelMatrix;
+}
+
 /**
  * Makes a glTF-compatible PBR material from an I3S material definition
  * @param {object} materialDefinition - i3s material definition

package/src/types.ts

@@ -26,12 +26,7 @@ export type SceneLayer3D = {
   id: number;
   href?: string;
   layerType: string;
-  spatialReference?: {
-    wkid: number;
-    latestWkid: number;
-    vcsWkid: number;
-    latestVcsWkid: number;
-  };
+  spatialReference?: SpatialReference;
   heightModelInfo?: HeightModelInfo;
   version: string;
   name?: string;
@@ -180,6 +175,106 @@ export type Extent = [number, number, number, number];
 
 export type FeatureAttribute = {[key: string]: any};
 
+export type BuildingSceneLayerTileset = {
+  header: BuildingSceneLayer;
+  sublayers: BuildingSceneSublayer[];
+};
+
+export type BuildingSceneLayer = {
+  id: number;
+  name: string;
+  version: string;
+  alias?: string;
+  layerType: 'Building';
+  description?: string;
+  copyrightText?: string;
+  fullExtent: FullExtent;
+  spatialReference: SpatialReference;
+  heightModelInfo?: HeightModelInfo;
+  sublayers: BuildingSceneSublayer[];
+  filters?: Filter[];
+  activeFilterID?: string;
+  statisticsHRef?: string;
+};
+
+export type BuildingSceneSublayer = {
+  id: number;
+  name: string;
+  alias?: string;
+  discipline?: 'Mechanical' | 'Architectural' | 'Piping' | 'Electrical' | 'Structural';
+  modelName?: string;
+  layerType: 'group' | '3DObject' | 'Point';
+  visibility?: boolean;
+  sublayers?: BuildingSceneSublayer[];
+  isEmpty?: boolean;
+  url?: string;
+};
+
+type Filter = {
+  id: string;
+  name: string;
+  description: string;
+  isDefaultFilter?: boolean;
+  isVisible?: boolean;
+  filterBlocks: FilterBlock[];
+  filterAuthoringInfo?: FilterAuthoringInfo;
+};
+
+type FilterAuthoringInfo = {
+  type: string;
+  filterBlocks: FilterBlockAuthoringInfo[];
+};
+
+type FilterBlockAuthoringInfo = {
+  filterTypes: FilterType[];
+};
+
+type FilterType = {
+  filterType: string;
+  filterValues: string[];
+};
+
+type FilterBlock = {
+  title: string;
+  filterMode: FilterModeSolid | FilterModeWireFrame;
+  filterExpression: string;
+};
+
+type Edges = {
+  type: string;
+  color: number[];
+  size: number;
+  transparency: number;
+  extensionLength: number;
+};
+
+type FilterModeSolid = {
+  type: 'solid';
+};
+
+type FilterModeWireFrame = {
+  type: 'wireFrame';
+  edges: Edges;
+};
+
+type SpatialReference = {
+  wkid: number;
+  latestWkid: number;
+  vcsWkid: number;
+  latestVcsWkid: number;
+  wkt?: string;
+};
+
+type FullExtent = {
+  xmin: number; // left
+  xmax: number; // right
+  ymin: number; // bottom
+  ymax: number; // top
+  zmin: number; // lowest elevation
+  zmax: number; // highest elevation
+  spatialReference?: SpatialReference;
+};
+
 type TextureDefinitionInfo = {
   encoding: string[];
   wrap?: string[];
@@ -229,6 +324,7 @@ type DefaultGeometrySchema = {
   region: Uint16Array;
 };
 
+// TODO change string to possible values from https://github.com/Esri/i3s-spec/blob/master/docs/1.8/heightModelInfo.cmn.md
 type HeightModelInfo = {
   heightModel: string;
   vertCRS: string;