@loaders.gl/i3s 3.1.0-beta.2 → 3.1.1

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

@@ -2,49 +2,39 @@ import type {TypedArray} from '@loaders.gl/schema';
 import {load, parse} from '@loaders.gl/core';
 import {Vector3, Matrix4} from '@math.gl/core';
 import {Ellipsoid} from '@math.gl/geospatial';
-
-import type {GLTFMaterial} from '@loaders.gl/gltf';
 import type {LoaderOptions, LoaderContext} from '@loaders.gl/loader-utils';
 import {ImageLoader} from '@loaders.gl/images';
-import {DracoLoader} from '@loaders.gl/draco';
+import {DracoLoader, DracoMesh} from '@loaders.gl/draco';
 import {BasisLoader, CompressedTextureLoader} from '@loaders.gl/textures';
 
-import type {
-  Tileset,
-  Tile,
+import {
+  I3STilesetHeader,
+  I3STileHeader,
   FeatureAttribute,
-  TileContent,
   VertexAttribute,
-  NormalizedAttribute,
-  NormalizedAttributes,
-  TileContentTexture
+  I3SMeshAttributes,
+  I3SMeshAttribute,
+  TileContentTexture,
+  HeaderAttributeProperty,
+  I3SMaterialDefinition
 } from '../../types';
 import {getUrlWithToken} from '../utils/url-utils';
 
-import {
-  GL_TYPE_MAP,
-  getConstructorForDataFormat,
-  sizeOf,
-  I3S_NAMED_HEADER_ATTRIBUTES,
-  I3S_NAMED_VERTEX_ATTRIBUTES,
-  I3S_NAMED_GEOMETRY_ATTRIBUTES,
-  COORDINATE_SYSTEM
-} from './constants';
+import {GL_TYPE_MAP, getConstructorForDataFormat, sizeOf, COORDINATE_SYSTEM} from './constants';
 
 const scratchVector = new Vector3([0, 0, 0]);
 
-function getLoaderForTextureFormat(textureFormat: 'jpeg' | 'png' | 'ktx-etc2' | 'dds' | 'ktx2') {
+function getLoaderForTextureFormat(textureFormat?: 'jpg' | 'png' | 'ktx-etc2' | 'dds' | 'ktx2') {
   switch (textureFormat) {
-    case 'jpeg':
-    case 'png':
-      return ImageLoader;
     case 'ktx-etc2':
     case 'dds':
       return CompressedTextureLoader;
     case 'ktx2':
       return BasisLoader;
+    case 'jpg':
+    case 'png':
     default:
-      return null;
+      return ImageLoader;
   }
 }
 
@@ -52,22 +42,19 @@ const I3S_ATTRIBUTE_TYPE = 'i3s-attribute-type';
 
 export async function parseI3STileContent(
   arrayBuffer: ArrayBuffer,
-  tile: Tile,
-  tileset: Tileset,
+  tile: I3STileHeader,
+  tileset: I3STilesetHeader,
   options?: LoaderOptions,
   context?: LoaderContext
 ) {
   tile.content = tile.content || {};
   tile.content.featureIds = tile.content.featureIds || null;
 
-  // construct featureData from defaultGeometrySchema;
-  tile.content.featureData = constructFeatureDataStruct(tileset);
   tile.content.attributes = {};
 
   if (tile.textureUrl) {
     const url = getUrlWithToken(tile.textureUrl, options?.i3s?.token);
-    const loader = getLoaderForTextureFormat(tile.textureFormat) || ImageLoader;
-    // @ts-ignore context must be defined
+    const loader = getLoaderForTextureFormat(tile.textureFormat);
     const response = await fetch(url);
     const arrayBuffer = await response.arrayBuffer();
 
@@ -104,30 +91,36 @@ export async function parseI3STileContent(
     tile.content.texture = null;
   }
 
-  return await parseI3SNodeGeometry(arrayBuffer, tile, options);
+  return await parseI3SNodeGeometry(arrayBuffer, tile, tileset, options);
 }
 
 /* eslint-disable max-statements */
-async function parseI3SNodeGeometry(arrayBuffer: ArrayBuffer, tile: Tile, options?: LoaderOptions) {
+async function parseI3SNodeGeometry(
+  arrayBuffer: ArrayBuffer,
+  tile: I3STileHeader,
+  tileset: I3STilesetHeader,
+  options?: LoaderOptions
+) {
   if (!tile.content) {
     return tile;
   }
 
   const content = tile.content;
-  let attributes: NormalizedAttributes;
+  let attributes: I3SMeshAttributes;
   let vertexCount: number;
   let byteOffset: number = 0;
   let featureCount: number = 0;
+  let indices: TypedArray | undefined;
 
   if (tile.isDracoGeometry) {
-    const decompressedGeometry = await parse(arrayBuffer, DracoLoader, {
+    const decompressedGeometry: DracoMesh = await parse(arrayBuffer, DracoLoader, {
       draco: {
         attributeNameEntry: I3S_ATTRIBUTE_TYPE
       }
     });
-
+    // @ts-expect-error
     vertexCount = decompressedGeometry.header.vertexCount;
-    const indices = decompressedGeometry.indices.value;
+    indices = decompressedGeometry.indices?.value;
     const {
       POSITION,
       NORMAL,
@@ -143,8 +136,7 @@ async function parseI3SNodeGeometry(arrayBuffer: ArrayBuffer, tile: Tile, option
       color: COLOR_0,
       uv0: TEXCOORD_0,
       uvRegion,
-      id: featureIndex,
-      indices
+      id: featureIndex
     };
 
     updateAttributesMetadata(attributes, decompressedGeometry);
@@ -155,10 +147,14 @@ async function parseI3SNodeGeometry(arrayBuffer: ArrayBuffer, tile: Tile, option
       flattenFeatureIdsByFeatureIndices(attributes, featureIds);
     }
   } else {
-    const {vertexAttributes, attributesOrder, featureAttributes, featureAttributeOrder} =
-      content.featureData;
+    const {
+      vertexAttributes,
+      ordering: attributesOrder,
+      featureAttributes,
+      featureAttributeOrder
+    } = tileset.store.defaultGeometrySchema;
     // First 8 bytes reserved for header (vertexCount and featureCount)
-    const headers = parseHeaders(content, arrayBuffer);
+    const headers = parseHeaders(tileset, arrayBuffer);
     byteOffset = headers.byteOffset;
     vertexCount = headers.vertexCount;
     featureCount = headers.featureCount;
@@ -168,7 +164,6 @@ async function parseI3SNodeGeometry(arrayBuffer: ArrayBuffer, tile: Tile, option
       byteOffset,
       vertexAttributes,
       vertexCount,
-      // @ts-expect-error
       attributesOrder
     );
 
@@ -204,7 +199,7 @@ async function parseI3SNodeGeometry(arrayBuffer: ArrayBuffer, tile: Tile, option
     texCoords: attributes.uv0,
     uvRegions: normalizeAttribute(attributes.uvRegion) // Normalize from UInt16
   };
-  content.indices = attributes.indices || null;
+  content.indices = indices || null;
 
   if (attributes.id && attributes.id.value) {
     tile.content.featureIds = attributes.id.value;
@@ -228,7 +223,10 @@ async function parseI3SNodeGeometry(arrayBuffer: ArrayBuffer, tile: Tile, option
  * @param decompressedGeometry
  * @param attributes
  */
-function updateAttributesMetadata(attributes: NormalizedAttributes, decompressedGeometry): void {
+function updateAttributesMetadata(
+  attributes: I3SMeshAttributes,
+  decompressedGeometry: DracoMesh
+): void {
   for (const key in decompressedGeometry.loaderData.attributes) {
     const dracoAttribute = decompressedGeometry.loaderData.attributes[key];
 
@@ -253,9 +251,9 @@ function updateAttributesMetadata(attributes: NormalizedAttributes, decompressed
  * @returns - result of attributes concatenation.
  */
 function concatAttributes(
-  normalizedVertexAttributes: NormalizedAttributes,
-  normalizedFeatureAttributes: NormalizedAttributes
-): NormalizedAttributes {
+  normalizedVertexAttributes: I3SMeshAttributes,
+  normalizedFeatureAttributes: I3SMeshAttributes
+): I3SMeshAttributes {
   return {...normalizedVertexAttributes, ...normalizedFeatureAttributes};
 }
 
@@ -264,7 +262,7 @@ function concatAttributes(
  * @param attribute - geometry attribute
  * @returns - geometry attribute in right format
  */
-function normalizeAttribute(attribute: NormalizedAttribute): NormalizedAttribute {
+function normalizeAttribute(attribute: I3SMeshAttribute): I3SMeshAttribute {
   if (!attribute) {
     return attribute;
   }
@@ -272,49 +270,26 @@ function normalizeAttribute(attribute: NormalizedAttribute): NormalizedAttribute
   return attribute;
 }
 
-function constructFeatureDataStruct(tileset: Tileset) {
-  // seed featureData from defaultGeometrySchema
-  const defaultGeometrySchema = tileset.store.defaultGeometrySchema;
-  const featureData = defaultGeometrySchema;
-  // populate the vertex attributes value types and values per element
-  for (const geometryAttribute in I3S_NAMED_GEOMETRY_ATTRIBUTES) {
-    for (const namedAttribute in I3S_NAMED_VERTEX_ATTRIBUTES) {
-      const attribute = defaultGeometrySchema[geometryAttribute][namedAttribute];
-      if (attribute) {
-        const {byteOffset = 0, count = 0, valueType, valuesPerElement} = attribute;
-
-        featureData[geometryAttribute][namedAttribute] = {
-          valueType,
-          valuesPerElement,
-          byteOffset,
-          count
-        };
-      }
-    }
-  }
-
-  featureData.attributesOrder = defaultGeometrySchema.ordering;
-  return featureData;
-}
-
-function parseHeaders(content: TileContent, arrayBuffer: ArrayBuffer) {
+function parseHeaders(tileset: I3STilesetHeader, arrayBuffer: ArrayBuffer) {
   let byteOffset = 0;
   // First 8 bytes reserved for header (vertexCount and featurecount)
   let vertexCount = 0;
   let featureCount = 0;
-  content.featureData.header.forEach(({property, type}) => {
+  for (const {property, type} of tileset.store.defaultGeometrySchema.header) {
     const TypedArrayTypeHeader = getConstructorForDataFormat(type);
-    if (property === I3S_NAMED_HEADER_ATTRIBUTES.vertexCount) {
-      // @ts-expect-error
-      vertexCount = new TypedArrayTypeHeader(arrayBuffer, 0, 4)[0];
-      byteOffset += sizeOf(type);
-    }
-    if (property === I3S_NAMED_HEADER_ATTRIBUTES.featureCount) {
-      // @ts-expect-error
-      featureCount = new TypedArrayTypeHeader(arrayBuffer, 4, 4)[0];
-      byteOffset += sizeOf(type);
+    switch (property) {
+      case HeaderAttributeProperty.vertexCount:
+        vertexCount = new TypedArrayTypeHeader(arrayBuffer, 0, 4)[0];
+        byteOffset += sizeOf(type);
+        break;
+      case HeaderAttributeProperty.featureCount:
+        featureCount = new TypedArrayTypeHeader(arrayBuffer, 4, 4)[0];
+        byteOffset += sizeOf(type);
+        break;
+      default:
+        break;
     }
-  });
+  }
 
   return {
     vertexCount,
@@ -332,7 +307,7 @@ function normalizeAttributes(
   vertexCount: number,
   attributesOrder: string[]
 ) {
-  const attributes: NormalizedAttributes = {};
+  const attributes: I3SMeshAttributes = {};
 
   // the order of attributes depend on the order being added to the vertexAttributes object
   for (const attribute of attributesOrder) {
@@ -351,13 +326,12 @@ function normalizeAttributes(
         break;
       }
       const buffer = arrayBuffer.slice(byteOffset);
-      let value: number[] | TypedArray = [];
+      let value: TypedArray;
 
       if (valueType === 'UInt64') {
         value = parseUint64Values(buffer, count * valuesPerElement, sizeOf(valueType));
       } else {
         const TypedArrayType = getConstructorForDataFormat(valueType);
-        // @ts-expect-error
         value = new TypedArrayType(buffer, 0, count * valuesPerElement);
       }
 
@@ -395,7 +369,7 @@ function parseUint64Values(
   buffer: ArrayBuffer,
   elementsCount: number,
   attributeSize: number
-): number[] {
+): Uint32Array {
   const values: number[] = [];
   const dataView = new DataView(buffer);
   let offset = 0;
@@ -411,10 +385,10 @@ function parseUint64Values(
     offset += attributeSize;
   }
 
-  return values;
+  return new Uint32Array(values);
 }
 
-function parsePositions(attribute: NormalizedAttribute, tile: Tile): Matrix4 {
+function parsePositions(attribute: I3SMeshAttribute, tile: I3STileHeader): Matrix4 {
   const mbs = tile.mbs;
   const value = attribute.value;
   const metadata = attribute.metadata;
@@ -466,7 +440,7 @@ function offsetsToCartesians(
  * @param positions positions attribute
  * @returns Matrix4 - model matrix for geometry transformation
  */
-function getModelMatrix(positions: NormalizedAttribute): Matrix4 {
+function getModelMatrix(positions: I3SMeshAttribute): Matrix4 {
   const metadata = positions.metadata;
   const scaleX: number = metadata?.['i3s-scale_x']?.double || 1;
   const scaleY: number = metadata?.['i3s-scale_y']?.double || 1;
@@ -483,7 +457,7 @@ function getModelMatrix(positions: NormalizedAttribute): Matrix4 {
  * @param texture - texture image
  * @returns {object}
  */
-function makePbrMaterial(materialDefinition: GLTFMaterial, texture: TileContentTexture) {
+function makePbrMaterial(materialDefinition?: I3SMaterialDefinition, texture?: TileContentTexture) {
   let pbrMaterial;
   if (materialDefinition) {
     pbrMaterial = {
@@ -521,7 +495,9 @@ function makePbrMaterial(materialDefinition: GLTFMaterial, texture: TileContentT
     );
   }
 
-  setMaterialTexture(pbrMaterial, texture);
+  if (texture) {
+    setMaterialTexture(pbrMaterial, texture);
+  }
 
   return pbrMaterial;
 }
@@ -576,7 +552,7 @@ function setMaterialTexture(material, image: TileContentTexture): void {
  * @param normalizedFeatureAttributes
  * @returns
  */
-function flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes: NormalizedAttributes): void {
+function flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes: I3SMeshAttributes): void {
   const {id, faceRange} = normalizedFeatureAttributes;
 
   if (!id || !faceRange) {
@@ -614,7 +590,7 @@ function flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes: NormalizedAt
  * @returns
  */
 function flattenFeatureIdsByFeatureIndices(
-  attributes: NormalizedAttributes,
+  attributes: I3SMeshAttributes,
   featureIds: Int32Array
 ): void {
   const featureIndices = attributes.id.value;
@@ -633,12 +609,7 @@ function flattenFeatureIdsByFeatureIndices(
  * @returns
  */
 function getFeatureIdsFromFeatureIndexMetadata(
-  featureIndex: NormalizedAttribute
+  featureIndex: I3SMeshAttribute
 ): Int32Array | undefined {
-  return (
-    featureIndex &&
-    featureIndex.metadata &&
-    featureIndex.metadata['i3s-feature-ids'] &&
-    featureIndex.metadata['i3s-feature-ids'].intArray
-  );
+  return featureIndex?.metadata?.['i3s-feature-ids']?.intArray;
 }

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

@@ -4,69 +4,80 @@ 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';
+import {
+  I3STilesetHeader,
+  I3STileHeader,
+  Mbs,
+  I3SMinimalNodeData,
+  Node3DIndexDocument
+} from '../../types';
+import type {LoaderOptions, LoaderContext} from '@loaders.gl/loader-utils';
 
-export function normalizeTileData(tile, options, context) {
-  tile.url = context.url;
-
-  if (tile.featureData) {
-    tile.featureUrl = `${tile.url}/${tile.featureData[0].href}`;
-  }
-
+export function normalizeTileData(tile : Node3DIndexDocument, options : LoaderOptions, context: LoaderContext): I3STileHeader {
+  const url: string = context.url || '';
+  let contentUrl: string | undefined;
   if (tile.geometryData) {
-    tile.contentUrl = `${tile.url}/${tile.geometryData[0].href}`;
+    contentUrl = `${url}/${tile.geometryData[0].href}`;
   }
 
+  let textureUrl: string | undefined;
   if (tile.textureData) {
-    tile.textureUrl = `${tile.url}/${tile.textureData[0].href}`;
+    textureUrl = `${url}/${tile.textureData[0].href}`;
   }
 
+  let attributeUrls: string[] | undefined;
   if (tile.attributeData) {
-    tile.attributeUrls = generateTileAttributeUrls(tile);
+    attributeUrls = generateTileAttributeUrls(url, tile);
   }
 
-  return normalizeTileNonUrlData(tile);
+  return normalizeTileNonUrlData({
+    ...tile,
+    url,
+    contentUrl,
+    textureUrl,
+    attributeUrls,
+    isDracoGeometry: false
+  });
 }
 
-export function normalizeTileNonUrlData(tile) {
-  const box = tile.obb
-    ? [
-      ...Ellipsoid.WGS84.cartographicToCartesian(tile.obb.center), // cartesian center of box
-      ...tile.obb.halfSize, // halfSize
-      ...tile.obb.quaternion // quaternion
-    ]
-    : undefined;
-  let sphere;
+export function normalizeTileNonUrlData(tile : I3SMinimalNodeData): I3STileHeader {
+  const boundingVolume: {box?: number[]; sphere?: number[]} = {};
+  let mbs: Mbs = [0, 0, 0, 1];
   if (tile.mbs) {
-    sphere = [
+    mbs = tile.mbs;
+    boundingVolume.sphere = [
       ...Ellipsoid.WGS84.cartographicToCartesian(tile.mbs.slice(0, 3)), // cartesian center of sphere
       tile.mbs[3] // radius of sphere
+    ] as Mbs;
+  } else if (tile.obb) {
+    boundingVolume.box = [
+      ...Ellipsoid.WGS84.cartographicToCartesian(tile.obb.center), // cartesian center of box
+      ...tile.obb.halfSize, // halfSize
+      ...tile.obb.quaternion // quaternion
     ];
-  } else if (box) {
     const obb = new OrientedBoundingBox().fromCenterHalfSizeQuaternion(
-      box.slice(0, 3),
+      boundingVolume.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];
+    boundingVolume.sphere = [...boundingSphere.center , boundingSphere.radius] as Mbs;
+    mbs = [...tile.obb.center, boundingSphere.radius] as Mbs;
   }
 
-  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;
-  // TODO only support replacement for now
-  tile.refine = TILE_REFINEMENT.REPLACE;
+  const lodMetricType = tile.lodSelection?.[0].metricType;
+  const lodMetricValue = tile.lodSelection?.[0].maxError;
+  const transformMatrix = tile.transform;
+  const type = TILE_TYPE.MESH;
+  /**
+   * I3S specification supports only REPLACE
+   */
+  const refine = TILE_REFINEMENT.REPLACE;
 
-  return tile;
+  return {...tile, mbs, boundingVolume, lodMetricType, lodMetricValue, transformMatrix, type, refine};
 }
 
-export async function normalizeTilesetData(tileset, options, context) {
+export async function normalizeTilesetData(tileset : I3STilesetHeader, options : LoaderOptions, context: LoaderContext) {
   tileset.url = context.url;
 
   if (tileset.nodePages) {

package/src/lib/utils/url-utils.ts

@@ -1,12 +1,12 @@
-import {Tile} from '../../types';
+import {Node3DIndexDocument} from '../../types';
 
 /**
  * Generates url with token if it is exists.
- * @param {String} url
- * @param {any} token
- * @returns {string}
+ * @param url
+ * @param token
+ * @returns
  */
-export function getUrlWithToken(url: string, token = null): string {
+export function getUrlWithToken(url: string, token: string | null = null): string {
   return token ? `${url}?token=${token}` : url;
 }
 
@@ -15,8 +15,8 @@ export function getUrlWithToken(url: string, token = null): string {
  * @param tile
  * @returns list of attribute urls
  */
-export function generateTileAttributeUrls(tile: Tile): string[] {
-  const {url, attributeData} = tile;
+export function generateTileAttributeUrls(url: string, tile: Node3DIndexDocument): string[] {
+  const {attributeData = []} = tile;
   const attributeUrls: string[] = [];
 
   for (let index = 0; index < attributeData.length; index++) {