@loaders.gl/tile-converter 3.2.12 → 3.3.0-alpha.10

package/src/i3s-converter/helpers/batch-ids-extensions.ts

@@ -0,0 +1,206 @@
+import {
+  GLTFAccessorPostprocessed,
+  GLTFImagePostprocessed,
+  GLTFMeshPrimitivePostprocessed
+} from '@loaders.gl/gltf';
+import type {
+  GLTF_EXT_feature_metadata_attribute,
+  GLTF_EXT_feature_metadata_primitive
+} from 'modules/gltf/src/lib/types/gltf-json-schema';
+
+const EXT_MESH_FEATURES = 'EXT_mesh_features';
+const EXT_FEATURE_METADATA = 'EXT_feature_metadata';
+
+/**
+ * Getting batchIds from 3DTilesNext extensions.
+ * @param attributes - gltf accessors
+ * @param primitive - gltf primitive data
+ * @param images - gltf texture images
+ */
+export function handleBatchIdsExtensions(
+  attributes: {
+    [key: string]: GLTFAccessorPostprocessed;
+  },
+  primitive: GLTFMeshPrimitivePostprocessed,
+  images: GLTFImagePostprocessed[]
+): number[] {
+  const extensions = primitive?.extensions;
+
+  if (!extensions) {
+    return [];
+  }
+
+  for (const [extensionName, extensionData] of Object.entries(extensions || {})) {
+    switch (extensionName) {
+      case EXT_FEATURE_METADATA:
+        return handleExtFeatureMetadataExtension(
+          attributes,
+          extensionData as GLTF_EXT_feature_metadata_primitive,
+          images
+        );
+      case EXT_MESH_FEATURES:
+        console.warn('EXT_mesh_features extension is not supported yet');
+        return [];
+      default:
+        return [];
+    }
+  }
+
+  return [];
+}
+
+/**
+ * Get batchIds from EXT_feature_metadata extension.
+ * Docs - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata
+ * @param attributes
+ * @param extFeatureMetadata
+ * @param textures
+ */
+function handleExtFeatureMetadataExtension(
+  attributes: {
+    [key: string]: GLTFAccessorPostprocessed;
+  },
+  extFeatureMetadata: GLTF_EXT_feature_metadata_primitive,
+  images: GLTFImagePostprocessed[]
+): number[] {
+  // Take only first extension object to get batchIds attribute name.
+  const featureIdAttribute = extFeatureMetadata?.featureIdAttributes?.[0];
+
+  if (featureIdAttribute?.featureIds?.attribute) {
+    const batchIdsAttribute = attributes[featureIdAttribute.featureIds.attribute];
+    return batchIdsAttribute.value;
+  }
+
+  if (
+    featureIdAttribute?.featureIds?.hasOwnProperty('constant') &&
+    featureIdAttribute?.featureIds?.hasOwnProperty('divisor')
+  ) {
+    const featuresCount = attributes?.POSITIONS?.value.length / 3 || 0;
+    return generateImplicitFeatureIds(
+      featuresCount,
+      featureIdAttribute.featureIds.constant,
+      featureIdAttribute.featureIds.divisor
+    );
+  }
+
+  // Take only first extension object to get batchIds attribute name.
+  const featureIdTexture =
+    extFeatureMetadata?.featureIdTextures && extFeatureMetadata?.featureIdTextures[0];
+
+  if (featureIdTexture) {
+    const textureAttributeIndex = featureIdTexture?.featureIds?.texture?.texCoord || 0;
+    const textCoordAttribute = `TEXCOORD_${textureAttributeIndex}`;
+    const textureCoordinates = attributes[textCoordAttribute].value;
+    return generateBatchIdsFromTexture(featureIdTexture, textureCoordinates, images);
+  }
+
+  // Take only first extension texture to get batchIds from the root EXT_feature_metadata object.
+  const featureTexture =
+    extFeatureMetadata?.featureTextures && extFeatureMetadata?.featureTextures[0];
+
+  /**
+   * TODO need to get batchIds from root extension
+   */
+  if (featureTexture) {
+    console.warn("EXT_feature_metadata doesn't yet support featureTextures in primitive");
+    return [];
+  }
+
+  return [];
+}
+
+/**
+ * Generates implicit feature ids
+ * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#implicit-feature-ids
+ * @param featuresCount
+ * @param constant
+ * @param devisor
+ */
+function generateImplicitFeatureIds(
+  featuresCount: number,
+  constant: number = 0,
+  divisor: number = 0
+): number[] {
+  let featureIds: number[] = [];
+
+  if (divisor > 0) {
+    let currentValue = constant;
+    let devisorCounter = divisor;
+
+    for (let index = 0; index < featuresCount; index++) {
+      featureIds.push(currentValue);
+
+      devisorCounter -= 1;
+
+      if (devisorCounter === 0) {
+        currentValue++;
+        devisorCounter = divisor;
+      }
+    }
+  } else {
+    featureIds = Array<number>(featuresCount).fill(constant, 0, featuresCount);
+  }
+
+  return featureIds;
+}
+
+/**
+ * Get batchIds from texture.
+ * @param primitive
+ * @param featureIdTextures
+ */
+function generateBatchIdsFromTexture(
+  featureIdTexture: GLTF_EXT_feature_metadata_attribute,
+  textureCoordinates: Float32Array,
+  images: GLTFImagePostprocessed[]
+) {
+  if (!images?.length) {
+    return [];
+  }
+
+  const CHANNELS_MAP = {
+    r: 0,
+    g: 1,
+    b: 2,
+    a: 3
+  };
+
+  const textureIndex = featureIdTexture?.featureIds?.texture?.index;
+  const featureChannel = featureIdTexture?.featureIds?.channels;
+
+  if (!featureChannel || textureIndex === undefined) {
+    return [];
+  }
+
+  const image = images[textureIndex];
+  const batchIds: number[] = [];
+  const channels = CHANNELS_MAP[featureChannel];
+
+  if (!image.compressed) {
+    for (let index = 0; index < textureCoordinates.length; index += 2) {
+      const u = textureCoordinates[index];
+      const v = textureCoordinates[index + 1];
+
+      const tx = Math.min((emod(u) * image.width) | 0, image.width - 1);
+      const ty = Math.min((emod(v) * image.height) | 0, image.height - 1);
+
+      const offset = (ty * image.width + tx) * image.components + channels;
+      const batchId = new Uint8Array(image.data)[offset];
+
+      batchIds.push(batchId);
+    }
+  } else {
+    console.warn(`Can't get batch Ids from ${image.mimeType} compressed texture`);
+  }
+
+  return batchIds;
+}
+
+/**
+ * Handle UVs if they are out of range [0,1].
+ * @param n
+ * @param m
+ */
+function emod(n: number): number {
+  return ((n % 1) + 1) % 1;
+}

package/src/i3s-converter/helpers/coordinate-converter.ts

@@ -8,7 +8,7 @@ import {
   makeBoundingSphereFromPoints,
   BoundingSphere
 } from '@math.gl/culling';
-import TileHeader from '@loaders.gl/tiles/src/tileset/tile-3d';
+import {Tile3D} from '@loaders.gl/tiles';
 import {Geoid} from '@math.gl/geoid';
 
 /**
@@ -17,7 +17,7 @@ import {Geoid} from '@math.gl/geoid';
  * @param geoidHeightModel
  * @returns - Bounding volumes object
  */
-export function createBoundingVolumes(tile: TileHeader, geoidHeightModel: Geoid): BoundingVolumes {
+export function createBoundingVolumes(tile: Tile3D, geoidHeightModel: Geoid): BoundingVolumes {
   let radius;
   let halfSize;
   let quaternion;

package/src/i3s-converter/helpers/feature-attributes.ts

@@ -0,0 +1,247 @@
+import type {FeatureTableJson} from '@loaders.gl/3d-tiles';
+import {
+  Attribute,
+  AttributeStorageInfo,
+  ESRIField,
+  Field,
+  FieldInfo,
+  PopupInfo
+} from '@loaders.gl/i3s';
+
+/**
+ * Takes attributes from property table based on featureIds.
+ * If there is no property value for particular featureId (index) the property will be null.
+ * Example:
+ * Initial data:
+ *   OBJECTID: [0, 1, 5]
+ *   component: ['Windows', 'Frames', 'Wall', 'Roof', 'Skylight']
+ * Result:
+ *   OBJECTID: [0, 1, 5]
+ *   component: ['Windows', 'Frames', 'null']
+ * @param featureIds
+ * @param propertyTable
+ */
+export function flattenPropertyTableByFeatureIds(
+  featureIds: number[],
+  propertyTable: FeatureTableJson
+): FeatureTableJson {
+  const resultPropertyTable: FeatureTableJson = {};
+  for (const propertyName in propertyTable) {
+    const properties = propertyTable[propertyName];
+    resultPropertyTable[propertyName] = getPropertiesByFeatureIds(properties, featureIds);
+  }
+
+  return resultPropertyTable;
+}
+
+/**
+ * Getting properties by featureId index
+ * @param properties
+ * @param featureIds
+ */
+function getPropertiesByFeatureIds(properties: any[], featureIds: number[]): any[] {
+  const resultProperties: any = [];
+
+  for (const featureId of featureIds) {
+    const property = properties[featureId] || null;
+    resultProperties.push(property);
+  }
+
+  return resultProperties;
+}
+
+/**
+ * Check that all attributes in propertyTable have the same length as FeatureIds.
+ * If there are differencies between lengths we should flatten property table based on exiesting featureIds.
+ * @param featureIds
+ * @param propertyTable
+ * @returns
+ */
+export function checkPropertiesLength(
+  featureIds: number[],
+  propertyTable: FeatureTableJson
+): boolean {
+  let needFlatten = false;
+
+  for (const attribute of Object.values(propertyTable)) {
+    if (featureIds.length !== attribute.length) {
+      needFlatten = true;
+    }
+  }
+
+  return needFlatten;
+}
+
+/** String data type name for feature attributes */
+const STRING_TYPE = 'string';
+/** Integer data type name for feature attributes */
+const SHORT_INT_TYPE = 'Int32';
+/** Double data type name for feature attributes */
+const DOUBLE_TYPE = 'double';
+/** Type of attribute that is linked with feature ids */
+const OBJECT_ID_TYPE = 'OBJECTID';
+/**
+ * Get the attribute type for attributeStorageInfo https://github.com/Esri/i3s-spec/blob/master/docs/1.7/attributeStorageInfo.cmn.md
+ * @param key - attribute's key
+ * @param attribute - attribute's type in propertyTable
+ */
+export function getAttributeType(key: string, attribute: string): string {
+  if (key === OBJECT_ID_TYPE) {
+    return OBJECT_ID_TYPE;
+  }
+  if (typeof attribute === STRING_TYPE) {
+    return STRING_TYPE;
+  } else if (typeof attribute === 'number') {
+    return Number.isInteger(attribute) ? SHORT_INT_TYPE : DOUBLE_TYPE;
+  }
+  return STRING_TYPE;
+}
+
+/**
+ * Generate storage attribute for map segmentation.
+ * @param attributeIndex - order index of attribute (f_0, f_1 ...).
+ * @param key - attribute key from propertyTable.
+ * @param attributeType - attribute type.
+ * @return Updated storageAttribute.
+ */
+export function createdStorageAttribute(
+  attributeIndex: number,
+  key: string,
+  attributeType: Attribute
+): AttributeStorageInfo {
+  const storageAttribute = {
+    key: `f_${attributeIndex}`,
+    name: key,
+    ordering: ['attributeValues'],
+    header: [{property: 'count', valueType: 'UInt32'}],
+    attributeValues: {valueType: 'Int32', valuesPerElement: 1}
+  };
+
+  switch (attributeType) {
+    case OBJECT_ID_TYPE:
+      setupIdAttribute(storageAttribute);
+      break;
+    case STRING_TYPE:
+      setupStringAttribute(storageAttribute);
+      break;
+    case DOUBLE_TYPE:
+      setupDoubleAttribute(storageAttribute);
+      break;
+    case SHORT_INT_TYPE:
+      break;
+    default:
+      setupStringAttribute(storageAttribute);
+  }
+
+  return storageAttribute;
+}
+
+/**
+ * Find and return attribute type based on key form propertyTable.
+ * @param attributeType
+ */
+export function getFieldAttributeType(attributeType: Attribute): ESRIField {
+  switch (attributeType) {
+    case OBJECT_ID_TYPE:
+      return 'esriFieldTypeOID';
+    case STRING_TYPE:
+      return 'esriFieldTypeString';
+    case SHORT_INT_TYPE:
+      return 'esriFieldTypeInteger';
+    case DOUBLE_TYPE:
+      return 'esriFieldTypeDouble';
+    default:
+      return 'esriFieldTypeString';
+  }
+}
+
+/**
+ * Setup field attribute for map segmentation.
+ * @param key - attribute for map segmentation.
+ * @param fieldAttributeType - esri attribute type ('esriFieldTypeString' or 'esriFieldTypeOID').
+ */
+export function createFieldAttribute(key: string, fieldAttributeType: ESRIField): Field {
+  return {
+    name: key,
+    type: fieldAttributeType,
+    alias: key
+  };
+}
+
+/**
+ * Generate popup info to show metadata on the map.
+ * @param propertyTable - table data with OBJECTID.
+ * @return data for correct rendering of popup.
+ */
+export function createPopupInfo(propertyTable: FeatureTableJson): PopupInfo {
+  const title = '{OBJECTID}';
+  const mediaInfos = [];
+  const fieldInfos: FieldInfo[] = [];
+  const popupElements: {
+    fieldInfos: FieldInfo[];
+    type: string;
+  }[] = [];
+  const expressionInfos = [];
+
+  for (const key in propertyTable) {
+    fieldInfos.push({
+      fieldName: key,
+      visible: true,
+      isEditable: false,
+      label: key
+    });
+  }
+  popupElements.push({
+    fieldInfos,
+    type: 'fields'
+  });
+
+  return {
+    title,
+    mediaInfos,
+    popupElements,
+    fieldInfos,
+    expressionInfos
+  };
+}
+
+/**
+ * Setup storage attribute as string.
+ * @param storageAttribute - attribute for map segmentation.
+ */
+function setupStringAttribute(storageAttribute: AttributeStorageInfo): void {
+  // @ts-expect-error
+  storageAttribute.ordering.unshift('attributeByteCounts');
+  storageAttribute.header.push({property: 'attributeValuesByteCount', valueType: 'UInt32'});
+  storageAttribute.attributeValues = {
+    valueType: 'String',
+    encoding: 'UTF-8',
+    valuesPerElement: 1
+  };
+  storageAttribute.attributeByteCounts = {
+    valueType: 'UInt32',
+    valuesPerElement: 1
+  };
+}
+
+/**
+ * Setup Id attribute for map segmentation.
+ * @param storageAttribute - attribute for map segmentation .
+ */
+function setupIdAttribute(storageAttribute: AttributeStorageInfo): void {
+  storageAttribute.attributeValues = {
+    valueType: 'Oid32',
+    valuesPerElement: 1
+  };
+}
+
+/**
+ * Setup double attribute for map segmentation.
+ * @param storageAttribute - attribute for map segmentation .
+ */
+function setupDoubleAttribute(storageAttribute: AttributeStorageInfo): void {
+  storageAttribute.attributeValues = {
+    valueType: 'Float64',
+    valuesPerElement: 1
+  };
+}

package/src/i3s-converter/helpers/geometry-attributes.ts

@@ -10,7 +10,7 @@ const POSITIONS_AND_NORMALS_PER_TRIANGLE = 9;
  * @returns attirbutes with featureCount, featureIds and changed faceRange.
  */
 export function generateAttributes(attributes: ConvertedAttributes): GeometryAttributes {
-  const {positions, normals, texCoords, colors, featureIndices} = attributes;
+  const {positions, normals, texCoords, colors, uvRegions, featureIndices} = attributes;
   const triangleCount = positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE;
 
   if (!featureIndices.length) {
@@ -21,7 +21,8 @@ export function generateAttributes(attributes: ConvertedAttributes): GeometryAtt
       positions,
       normals,
       texCoords,
-      colors
+      colors,
+      uvRegions
     };
   }
 
@@ -47,7 +48,7 @@ function calculateFaceRangesAndFeaturesCount(featureIndices: number[]): {
 } {
   let rangeIndex = 1;
   let featureIndex = 1;
-  let currentFeatureId = featureIndices[0];
+  let currentFeatureId = getFrequentValue(featureIndices.slice(0, VALUES_PER_VERTEX));
   const faceRangeList: any[] = [];
   const featureIds: any[] = [];
   const uniqueFeatureIds = [currentFeatureId];
@@ -55,20 +56,21 @@ function calculateFaceRangesAndFeaturesCount(featureIndices: number[]): {
   faceRangeList[0] = 0;
   featureIds[0] = currentFeatureId;
 
-  for (let index = 1; index < featureIndices.length; index++) {
-    if (currentFeatureId !== featureIndices[index]) {
+  for (let index = VALUES_PER_VERTEX; index < featureIndices.length; index += VALUES_PER_VERTEX) {
+    const newFeatureId = getFrequentValue(featureIndices.slice(index, index + VALUES_PER_VERTEX));
+    if (currentFeatureId !== newFeatureId) {
       faceRangeList[rangeIndex] = index / VALUES_PER_VERTEX - 1;
       faceRangeList[rangeIndex + 1] = index / VALUES_PER_VERTEX;
-      featureIds[featureIndex] = featureIndices[index];
+      featureIds[featureIndex] = newFeatureId;
 
-      if (!uniqueFeatureIds.includes(featureIndices[index])) {
-        uniqueFeatureIds.push(featureIndices[index]);
+      if (!uniqueFeatureIds.includes(newFeatureId)) {
+        uniqueFeatureIds.push(newFeatureId);
       }
 
       rangeIndex += 2;
       featureIndex += 1;
     }
-    currentFeatureId = featureIndices[index];
+    currentFeatureId = newFeatureId;
   }
 
   faceRangeList[rangeIndex] = featureIndices.length / VALUES_PER_VERTEX - 1;
@@ -79,6 +81,28 @@ function calculateFaceRangesAndFeaturesCount(featureIndices: number[]): {
   return {faceRange, featureCount, featureIds};
 }
 
+/**
+ * Find most frequent value to avoid situation where one vertex can be part of multiple features (objects).
+ * @param values
+ */
+function getFrequentValue(values: number[]): number {
+  const map: {[key: number]: number} = {};
+
+  let mostFrequentValue = values[0];
+  let maxCount = 1;
+
+  for (const value of values) {
+    // Save item and it's frequency count to the map.
+    map[value] = (map[value] || 0) + 1;
+    // Find max count of frequency.
+    maxCount = maxCount > map[value] ? maxCount : map[value];
+    // Find the most frequent value.
+    mostFrequentValue = maxCount > map[value] ? mostFrequentValue : value;
+  }
+
+  return mostFrequentValue;
+}
+
 /**
  * Generate list of attribute object grouped by feature ids.
  * @param  attributes
@@ -90,6 +114,7 @@ function makeAttributeObjects(attributes: GeometryAttributes): GroupedByFeatureI
     positions,
     normals,
     colors,
+    uvRegions,
     texCoords,
     faceRange = new Uint32Array(0)
   } = attributes;
@@ -99,16 +124,16 @@ function makeAttributeObjects(attributes: GeometryAttributes): GroupedByFeatureI
   let normalsList = new Float32Array(normals);
   let colorsList = new Uint8Array(colors);
   let texCoordsList = new Float32Array(texCoords);
-
-  let faceRangeIndex = 0;
+  let uvRegionsList = new Uint16Array(uvRegions);
 
   for (let index = 0; index < featureIds.length; index++) {
-    const startIndex = faceRange[index + faceRangeIndex];
-    const endIndex = faceRange[index + faceRangeIndex + 1];
+    const startIndex = faceRange[index * 2];
+    const endIndex = faceRange[index * 2 + 1];
 
     const positionsCount = getSliceAttributeCount('positions', startIndex, endIndex);
     const normalsCount = getSliceAttributeCount('normals', startIndex, endIndex);
     const colorsCount = getSliceAttributeCount('colors', startIndex, endIndex);
+    const uvRegionsCount = getSliceAttributeCount('uvRegions', startIndex, endIndex);
     const texCoordsCount = getSliceAttributeCount('texCoords', startIndex, endIndex);
 
     groupedData.push({
@@ -116,15 +141,15 @@ function makeAttributeObjects(attributes: GeometryAttributes): GroupedByFeatureI
       positions: positionsList.slice(0, positionsCount),
       normals: normalsList.slice(0, normalsCount),
       colors: colorsList.slice(0, colorsCount),
+      uvRegions: uvRegionsList.slice(0, uvRegionsCount),
       texCoords: texCoordsList.slice(0, texCoordsCount)
     });
 
     positionsList = positionsList.slice(positionsCount);
     normalsList = normalsList.slice(normalsCount);
     colorsList = colorsList.slice(colorsCount);
+    uvRegionsList = uvRegionsList.slice(uvRegionsCount);
     texCoordsList = texCoordsList.slice(texCoordsCount);
-
-    faceRangeIndex += 1;
   }
 
   return groupedData.sort((first, second) => first.featureId - second.featureId);
@@ -142,7 +167,7 @@ function getSliceAttributeCount(
   startIndex: number,
   endIndex: number
 ): number {
-  const colorsPerVertex = 4;
+  const itemsPerVertex4 = 4;
   const texCoordsPerVertex = 2;
 
   const trianglesCount = endIndex - startIndex + 1;
@@ -153,7 +178,8 @@ function getSliceAttributeCount(
     case 'normals':
       return trianglesCount * POSITIONS_AND_NORMALS_PER_TRIANGLE;
     case 'colors':
-      return vertexCount * colorsPerVertex;
+    case 'uvRegions':
+      return vertexCount * itemsPerVertex4;
     case 'texCoords':
       return vertexCount * texCoordsPerVertex;
     default:
@@ -209,6 +235,7 @@ function groupAttributesAndRangesByFeatureId(
   let positions = new Float32Array(firstAttributeObject.positions);
   let normals = new Float32Array(firstAttributeObject.normals);
   let colors = new Uint8Array(firstAttributeObject.colors);
+  let uvRegions = new Uint16Array(firstAttributeObject.uvRegions);
   let texCoords = new Float32Array(firstAttributeObject.texCoords);
   const range = [0];
 
@@ -222,6 +249,7 @@ function groupAttributesAndRangesByFeatureId(
     positions = concatenateTypedArrays(positions, currentAttributesObject.positions);
     normals = concatenateTypedArrays(normals, currentAttributesObject.normals);
     colors = concatenateTypedArrays(colors, currentAttributesObject.colors);
+    uvRegions = concatenateTypedArrays(uvRegions, currentAttributesObject.uvRegions);
     texCoords = concatenateTypedArrays(texCoords, currentAttributesObject.texCoords);
 
     const groupedObject = unifiedObjects[objIndex];
@@ -235,5 +263,5 @@ function groupAttributesAndRangesByFeatureId(
   range.push(positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1);
 
   const faceRange = new Uint32Array(range);
-  return {faceRange, featureIds, positions, normals, colors, texCoords, featureCount};
+  return {faceRange, featureIds, positions, normals, colors, uvRegions, texCoords, featureCount};
 }