@loaders.gl/gltf 4.0.0-alpha.9 → 4.0.0-beta.1

package/src/lib/extensions/deprecated/EXT_feature_metadata.ts

@@ -1,24 +1,35 @@
 /* eslint-disable camelcase */
-import type {GLTF} from '../../types/gltf-json-schema';
+import type {GLTF, GLTFTextureInfoMetadata} from '../../types/gltf-json-schema';
+import type {
+  GLTF_EXT_feature_metadata_Class,
+  GLTF_EXT_feature_metadata_ClassProperty,
+  GLTF_EXT_feature_metadata_FeatureTable,
+  GLTF_EXT_feature_metadata_FeatureTableProperty,
+  GLTF_EXT_feature_metadata_FeatureTexture,
+  GLTF_EXT_feature_metadata_GLTF,
+  GLTF_EXT_feature_metadata_TextureAccessor,
+  GLTF_EXT_feature_metadata_Schema
+} from '../../types/gltf-ext-feature-metadata-schema';
+import type {BigTypedArray, TypedArray} from '@loaders.gl/schema';
+import type {FeatureTableJson} from '../../types/gltf-types';
 import {GLTFScenegraph} from '../../api/gltf-scenegraph';
-import {getImageData} from '@loaders.gl/images';
-import {
-  ClassProperty,
-  EXT_feature_metadata_class_object,
-  EXT_feature_metadata_feature_table,
-  FeatureTableProperty,
-  GLTF_EXT_feature_metadata,
-  EXT_feature_metadata_feature_texture,
-  FeatureTextureProperty,
-  GLTFMeshPrimitive
-} from '../../types/gltf-json-schema';
-import {getComponentTypeFromArray} from '../../gltf-utils/gltf-utils';
+import {GLTFMeshPrimitive} from '../../types/gltf-json-schema';
 import {GLTFLoaderOptions} from '../../../gltf-loader';
+import {
+  convertRawBufferToMetadataArray,
+  getPrimitiveTextureData,
+  primitivePropertyDataToAttributes,
+  getArrayElementByteSize,
+  NumericComponentType,
+  getOffsetsForProperty,
+  parseVariableLengthArrayNumeric,
+  parseFixedLengthArrayNumeric,
+  getPropertyDataString
+} from '../utils/3d-tiles-utils';
 
 /** Extension name */
-const EXT_FEATURE_METADATA = 'EXT_feature_metadata';
-
-export const name = EXT_FEATURE_METADATA;
+const EXT_FEATURE_METADATA_NAME = 'EXT_feature_metadata';
+export const name = EXT_FEATURE_METADATA_NAME;
 
 export async function decode(gltfData: {json: GLTF}, options: GLTFLoaderOptions): Promise<void> {
   const scenegraph = new GLTFScenegraph(gltfData);
@@ -26,32 +37,108 @@ export async function decode(gltfData: {json: GLTF}, options: GLTFLoaderOptions)
 }
 
 /**
- * Decodes feature metadata from extension
- * @param scenegraph
+ * Handles EXT_feature_metadata to get property table.
+ * @param extension - Global level of EXT_FEATURE_METADATA extension.
+ * @param metadataClass - User selected feature metadata class name.
+ * @returns {FeatureTableJson | null} Property table or null if the extension can't be handled properly.
  */
-function decodeExtFeatureMetadata(scenegraph: GLTFScenegraph, options: GLTFLoaderOptions): void {
-  const extension: GLTF_EXT_feature_metadata | null = scenegraph.getExtension(EXT_FEATURE_METADATA);
-  if (!extension) return;
+export function getPropertyTableFromExtFeatureMetadata(
+  extension: GLTF_EXT_feature_metadata_GLTF,
+  metadataClass?: string
+): FeatureTableJson | null {
+  if (extension.featureTables) {
+    /**
+     * Take only first feature table to generate attributes storage info object.
+     * TODO: Think about getting data from all feature tables?
+     * It can be tricky just because 3dTiles is able to have multiple featureId attributes and multiple feature tables.
+     * In I3S we should decide which featureIds attribute will be passed to geometry data.
+     */
+    const firstFeatureTableName = Object.keys(extension.featureTables)?.[0];
+
+    if (firstFeatureTableName) {
+      const featureTable = extension.featureTables[firstFeatureTableName];
+      const propertyTable = {};
+
+      for (const propertyName in featureTable.properties) {
+        propertyTable[propertyName] = featureTable.properties[propertyName].data;
+      }
 
-  const schemaClasses = extension.schema?.classes;
+      return propertyTable;
+    }
+  }
 
-  const {featureTables} = extension;
-  if (schemaClasses && featureTables) {
-    for (const schemaName in schemaClasses) {
-      const schemaClass = schemaClasses[schemaName];
-      const featureTable = findFeatureTableByName(featureTables, schemaName);
+  if (extension.featureTextures) {
+    let featureTexture: string | undefined;
+    for (const textureKey in extension.featureTextures) {
+      const texture = extension.featureTextures[textureKey];
+      if (texture.class === metadataClass) {
+        featureTexture = textureKey;
+      }
+    }
 
-      if (featureTable) {
-        handleFeatureTableProperties(scenegraph, featureTable, schemaClass);
+    if (typeof featureTexture === 'string') {
+      const featureTable = extension.featureTextures[featureTexture];
+      const propertyTable = {};
+
+      for (const propertyName in featureTable.properties) {
+        propertyTable[propertyName] = featureTable.properties[propertyName].data;
       }
+
+      return propertyTable;
     }
   }
 
+  // eslint-disable-next-line no-console
+  console.warn(
+    'Cannot get property table from EXT_feature_metadata extension. There is neither featureTables, nor featureTextures in the extension.'
+  );
+  return null;
+}
+
+/**
+ * Decodes feature metadata from extension.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param options - GLTFLoader options.
+ */
+function decodeExtFeatureMetadata(scenegraph: GLTFScenegraph, options: GLTFLoaderOptions): void {
+  // Decoding metadata involves buffers processing.
+  // So, if buffers have not been loaded, there is no reason to process metadata.
+  if (!options.gltf?.loadBuffers) {
+    return;
+  }
+  const extension: GLTF_EXT_feature_metadata_GLTF | null =
+    scenegraph.getExtension(EXT_FEATURE_METADATA_NAME);
+  if (!extension) {
+    return;
+  }
+
+  if (options.gltf?.loadImages) {
+    decodePropertyTextures(scenegraph, extension);
+  }
+
+  decodePropertyTables(scenegraph, extension);
+}
+
+/**
+ * Processes the data stored in the textures
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param extension - Top-level extension.
+ */
+function decodePropertyTextures(
+  scenegraph: GLTFScenegraph,
+  extension: GLTF_EXT_feature_metadata_GLTF
+): void {
+  const schema = extension.schema;
+  if (!schema) {
+    return;
+  }
+  const schemaClasses = schema.classes;
+
   const {featureTextures} = extension;
-  if (schemaClasses && featureTextures && options.gltf?.loadImages) {
+  if (schemaClasses && featureTextures) {
     for (const schemaName in schemaClasses) {
       const schemaClass = schemaClasses[schemaName];
-      const featureTexture = findFeatureTextureByName(featureTextures, schemaName);
+      const featureTexture = findFeatureTextureByClass(featureTextures, schemaName);
 
       if (featureTexture) {
         handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass);
@@ -61,44 +148,121 @@ function decodeExtFeatureMetadata(scenegraph: GLTFScenegraph, options: GLTFLoade
 }
 
 /**
- * Navigate throw all properies in feature table and gets properties data.
- * @param scenegraph
- * @param featureTable
- * @param schemaClass
+ * Processes the data stored in the property tables.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param extension - Top-level extension.
  */
-function handleFeatureTableProperties(
+function decodePropertyTables(
   scenegraph: GLTFScenegraph,
-  featureTable: EXT_feature_metadata_feature_table,
-  schemaClass: EXT_feature_metadata_class_object
+  extension: GLTF_EXT_feature_metadata_GLTF
 ): void {
+  const schema = extension.schema;
+  if (!schema) {
+    return;
+  }
+  const schemaClasses = schema.classes;
+  const propertyTables = extension.featureTables;
+  if (schemaClasses && propertyTables) {
+    for (const schemaName in schemaClasses) {
+      const propertyTable = findPropertyTableByClass(propertyTables, schemaName);
+      if (propertyTable) {
+        processPropertyTable(scenegraph, schema, propertyTable);
+      }
+    }
+  }
+}
+
+/**
+ * Finds the property table by class name.
+ * @param propertyTables - propertyTable definition taken from the top-level extension.
+ * @param schemaClassName - class name in the extension schema.
+ */
+function findPropertyTableByClass(
+  propertyTables: {[key: string]: GLTF_EXT_feature_metadata_FeatureTable},
+  schemaClassName: string
+): GLTF_EXT_feature_metadata_FeatureTable | null {
+  for (const propertyTableName in propertyTables) {
+    const propertyTable = propertyTables[propertyTableName];
+    if (propertyTable.class === schemaClassName) {
+      return propertyTable;
+    }
+  }
+
+  return null;
+}
+
+function findFeatureTextureByClass(
+  featureTextures: {[key: string]: GLTF_EXT_feature_metadata_FeatureTexture},
+  schemaClassName: string
+): GLTF_EXT_feature_metadata_FeatureTexture | null {
+  for (const featureTexturesName in featureTextures) {
+    const featureTable = featureTextures[featureTexturesName];
+
+    if (featureTable.class === schemaClassName) {
+      return featureTable;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Navigates through all properies in the property table, gets properties data,
+ * and put the data to `propertyTable.data` as an array.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param schema - schema object.
+ * @param propertyTable - propertyTable definition taken from the top-level extension.
+ */
+function processPropertyTable(
+  scenegraph: GLTFScenegraph,
+  schema: GLTF_EXT_feature_metadata_Schema,
+  propertyTable: GLTF_EXT_feature_metadata_FeatureTable
+): void {
+  // Though 'class' is not required by spec, it doesn't make any scence when it's not provided.
+  // So, bale out here.
+  if (!propertyTable.class) {
+    return;
+  }
+
+  const schemaClass = schema.classes?.[propertyTable.class];
+  if (!schemaClass) {
+    throw new Error(
+      `Incorrect data in the EXT_structural_metadata extension: no schema class with name ${propertyTable.class}`
+    );
+  }
+
+  const numberOfElements = propertyTable.count; // `propertyTable.count` is a number of elements in each property array.
+
   for (const propertyName in schemaClass.properties) {
-    const schemaProperty = schemaClass.properties[propertyName];
-    const featureTableProperty = featureTable?.properties?.[propertyName];
-    const numberOfFeatures = featureTable.count;
+    const classProperty = schemaClass.properties[propertyName];
+    const propertyTableProperty: GLTF_EXT_feature_metadata_FeatureTableProperty | undefined =
+      propertyTable.properties?.[propertyName];
 
-    if (featureTableProperty) {
+    if (propertyTableProperty) {
+      // Getting all elements (`numberOfElements`) of the array in the `propertyTableProperty`
       const data = getPropertyDataFromBinarySource(
         scenegraph,
-        schemaProperty,
-        numberOfFeatures,
-        featureTableProperty
+        schema,
+        classProperty,
+        numberOfElements,
+        propertyTableProperty
       );
-      featureTableProperty.data = data;
+      propertyTableProperty.data = data;
     }
   }
 }
 
 /**
- * Navigate throw all properies in feature texture and gets properties data.
- * Data will be stored in featureTexture.properties[propertyName].data
- * @param scenegraph
+ * Navigates through all properies in feature texture and gets properties data.
+ * Data will be stored in featureTexture.properties[propertyName].data.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
  * @param featureTexture
  * @param schemaClass
  */
 function handleFeatureTextureProperties(
   scenegraph: GLTFScenegraph,
-  featureTexture: EXT_feature_metadata_feature_texture,
-  schemaClass: EXT_feature_metadata_class_object
+  featureTexture: GLTF_EXT_feature_metadata_FeatureTexture,
+  schemaClass: GLTF_EXT_feature_metadata_Class
 ): void {
   const attributeName = featureTexture.class;
 
@@ -113,45 +277,201 @@ function handleFeatureTextureProperties(
 }
 
 /**
- * Decode properties from binary sourse based on property type.
- * @param scenegraph
+ * Decodes properties from binary sourse based on property type.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
  * @param schemaProperty
  * @param numberOfFeatures
  * @param featureTableProperty
  */
 function getPropertyDataFromBinarySource(
   scenegraph: GLTFScenegraph,
-  schemaProperty: ClassProperty,
+  schema: GLTF_EXT_feature_metadata_Schema,
+  classProperty: GLTF_EXT_feature_metadata_ClassProperty,
   numberOfFeatures: number,
-  featureTableProperty: FeatureTableProperty
-): Uint8Array | string[] {
+  featureTableProperty: GLTF_EXT_feature_metadata_FeatureTableProperty
+): string[] | BigTypedArray | string[][] | BigTypedArray[] {
+  let data: string[] | BigTypedArray | string[][] | BigTypedArray[] = [];
   const bufferView = featureTableProperty.bufferView;
-  // TODO think maybe we shouldn't get data only in Uint8Array format.
   const dataArray: Uint8Array = scenegraph.getTypedArrayForBufferView(bufferView);
 
-  switch (schemaProperty.type) {
-    case 'STRING': {
-      // stringOffsetBufferView should be available for string type.
-      const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView!;
-      const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
-      return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
+  const arrayOffsets = getArrayOffsetsForProperty(
+    scenegraph,
+    classProperty,
+    featureTableProperty,
+    numberOfFeatures
+  );
+  const stringOffsets = getStringOffsetsForProperty(
+    scenegraph,
+    classProperty,
+    featureTableProperty,
+    numberOfFeatures
+  );
+
+  if (classProperty.type === 'STRING' || classProperty.componentType === 'STRING') {
+    data = getPropertyDataString(numberOfFeatures, dataArray, arrayOffsets, stringOffsets);
+  } else if (isNumericProperty(classProperty)) {
+    data = getPropertyDataNumeric(classProperty, numberOfFeatures, dataArray, arrayOffsets);
+  }
+
+  return data;
+}
+
+/**
+ * Parses propertyTable.property.arrayOffsets that are offsets of sub-arrays in a flatten array of values.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param classProperty - class property object.
+ * @param propertyTableProperty - propertyTable's property metadata.
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @returns Typed array with offset values.
+ * @see https://github.com/CesiumGS/glTF/blob/2976f1183343a47a29e4059a70961371cd2fcee8/extensions/2.0/Vendor/EXT_structural_metadata/schema/propertyTable.property.schema.json#L21
+ */
+function getArrayOffsetsForProperty(
+  scenegraph: GLTFScenegraph,
+  classProperty: GLTF_EXT_feature_metadata_ClassProperty,
+  propertyTableProperty: GLTF_EXT_feature_metadata_FeatureTableProperty,
+  numberOfElements: number
+): TypedArray | null {
+  /*
+   If ARRAY is used, then componentType must also be specified.
+   ARRAY is a fixed-length array when componentCount is defined, and variable-length otherwise.
+*/
+  if (
+    classProperty.type === 'ARRAY' &&
+    // `componentCount` is a number of fixed-length array elements.
+    // If `componentCount` is NOT defined, it's a VARIABLE-length array
+    typeof classProperty.componentCount === 'undefined' &&
+    // `arrayOffsetBufferView` is an index of the buffer view containing offsets for variable-length arrays.
+    typeof propertyTableProperty.arrayOffsetBufferView !== 'undefined'
+  ) {
+    // Data are in a VARIABLE-length array
+    return getOffsetsForProperty(
+      scenegraph,
+      propertyTableProperty.arrayOffsetBufferView,
+      propertyTableProperty.offsetType || 'UINT32', // offsetType is used both for stringOffsetBufferView and arrayOffsetBufferView
+      numberOfElements
+    );
+  }
+  return null;
+}
+
+/**
+ * Parses featureTable.property.stringOffsetBufferView.
+ * String offsets is an array of offsets of strings in the united array of characters.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param propertyTableProperty - propertyTable's property metadata.
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @returns Typed array of offset values. The number of offsets in the array is equal to `numberOfElements` plus one.
+ * @see https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/featureTable.property.schema.json#L50C10-L50C32
+ */
+function getStringOffsetsForProperty(
+  scenegraph: GLTFScenegraph,
+  classProperty: GLTF_EXT_feature_metadata_ClassProperty,
+  propertyTableProperty: GLTF_EXT_feature_metadata_FeatureTableProperty,
+  numberOfElements: number
+): TypedArray | null {
+  if (
+    typeof propertyTableProperty.stringOffsetBufferView !== 'undefined' // `stringOffsetBufferView` is an index of the buffer view containing offsets for strings.
+  ) {
+    // Data are in a FIXED-length array
+    return getOffsetsForProperty(
+      scenegraph,
+      propertyTableProperty.stringOffsetBufferView,
+      propertyTableProperty.offsetType || 'UINT32', // offsetType is used both for stringOffsetBufferView and arrayOffsetBufferView
+      numberOfElements
+    );
+  }
+  return null;
+}
+
+/**
+ * Checks if the feature table property is of numeric type.
+ * @param schemaPropertyType - feature table property
+ * @returns true if property is numeric, else - false
+ */
+function isNumericProperty(schemaProperty: GLTF_EXT_feature_metadata_ClassProperty): boolean {
+  const types = [
+    'UINT8',
+    'INT16',
+    'UINT16',
+    'INT32',
+    'UINT32',
+    'INT64',
+    'UINT64',
+    'FLOAT32',
+    'FLOAT64'
+  ];
+  return (
+    types.includes(schemaProperty.type) ||
+    (typeof schemaProperty.componentType !== 'undefined' &&
+      types.includes(schemaProperty.componentType))
+  );
+}
+
+/**
+ * Decodes properties of numeric types from binary sourse.
+ * @param classProperty - class property object.
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @param valuesDataBytes - Data taken from values property of the property table property.
+ * @param arrayOffsets - Offsets for variable-length arrays. It's null for fixed-length arrays or scalar types.
+ * @returns Property values in a typed array or in an array of typed arrays.
+ */
+function getPropertyDataNumeric(
+  classProperty: GLTF_EXT_feature_metadata_ClassProperty,
+  numberOfElements: number,
+  valuesDataBytes: Uint8Array,
+  arrayOffsets: TypedArray | null
+): BigTypedArray | BigTypedArray[] {
+  const isArray = classProperty.type === 'ARRAY';
+  const arrayCount = classProperty.componentCount;
+
+  /*
+  We are getting Numeric data. So,
+    the component type can be one of NumericComponentType,
+    the attribute type should be 'SCALAR'
+  */
+  const attributeType = 'SCALAR';
+  const componentType = classProperty.componentType || classProperty.type;
+  const elementSize = getArrayElementByteSize(attributeType, componentType);
+  const elementCount = valuesDataBytes.byteLength / elementSize;
+
+  const valuesData: BigTypedArray = convertRawBufferToMetadataArray(
+    valuesDataBytes,
+    attributeType,
+    componentType as NumericComponentType,
+    elementCount
+  );
+
+  if (isArray) {
+    if (arrayOffsets) {
+      // VARIABLE-length array
+      return parseVariableLengthArrayNumeric(
+        valuesData,
+        numberOfElements,
+        arrayOffsets,
+        valuesDataBytes.length,
+        elementSize
+      );
+    }
+    if (arrayCount) {
+      // FIXED-length array
+      return parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
     }
-    default:
+    return [];
   }
 
-  return dataArray;
+  return valuesData;
 }
 
 /**
- * Get properties from texture associated with all mesh primitives.
- * @param scenegraph
+ * Gets properties from texture associated with all mesh primitives.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
  * @param featureTextureProperty
  * @param attributeName
  * @returns Feature texture data
  */
 function getPropertyDataFromTexture(
   scenegraph: GLTFScenegraph,
-  featureTextureProperty: FeatureTextureProperty,
+  featureTextureProperty: GLTF_EXT_feature_metadata_TextureAccessor,
   attributeName: string
 ): number[] {
   const json = scenegraph.gltf.json;
@@ -173,10 +493,9 @@ function getPropertyDataFromTexture(
   return featureTextureTable;
 }
 
-// eslint-disable-next-line max-statements
 /**
  * Processes data encoded in the texture associated with the primitive. This data will be accessible through the attributes.
- * @param scenegraph
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
  * @param attributeName
  * @param featureTextureProperty
  * @param featureTextureTable
@@ -185,220 +504,27 @@ function getPropertyDataFromTexture(
 function processPrimitiveTextures(
   scenegraph: GLTFScenegraph,
   attributeName: string,
-  featureTextureProperty: FeatureTextureProperty,
+  featureTextureProperty: GLTF_EXT_feature_metadata_TextureAccessor,
   featureTextureTable: number[],
   primitive: GLTFMeshPrimitive
 ): void {
-  /*
-    texture.index is an index for the "textures" array.
-    The texture object referenced by this index looks like this:
-    {
-    "sampler": 0,
-    "source": 0
-    }
-    "sampler" is an index for the "samplers" array
-    "source" is an index for the "images" array that contains data. These data are stored in rgba channels of the image.
-
-    texture.texCoord is a number-suffix (like 1) for an attribute like "TEXCOORD_1" in meshes.primitives
-    The value of "TEXCOORD_1" is an accessor that is used to get coordinates. These coordinates ared used to get data from the image.
-  */
-  const json = scenegraph.gltf.json;
-  const textureData: number[] = [];
-  const texCoordAccessorKey = `TEXCOORD_${featureTextureProperty.texture.texCoord}`;
-  const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
-  const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);
-  const texCoordArray: Uint8Array = scenegraph.getTypedArrayForBufferView(texCoordBufferView);
-
-  const textureCoordinates: Float32Array = new Float32Array(
-    texCoordArray.buffer,
-    texCoordArray.byteOffset,
-    texCoordArray.length / 4
-  );
-  // textureCoordinates contains UV coordinates of the actual data stored in the texture
-  // accessor.count is a number of UV pairs (they are stored as VEC2)
-
-  const textureIndex = featureTextureProperty.texture.index;
-  const texture = json.textures?.[textureIndex];
-  const imageIndex = texture?.source;
-  if (typeof imageIndex !== 'undefined') {
-    const image = json.images?.[imageIndex];
-    const mimeType = image?.mimeType;
-    const parsedImage = scenegraph.gltf.images?.[imageIndex];
-    if (parsedImage) {
-      for (let index = 0; index < textureCoordinates.length; index += 2) {
-        const value = getImageValueByCoordinates(
-          parsedImage,
-          mimeType,
-          textureCoordinates,
-          index,
-          featureTextureProperty.channels
-        );
-        textureData.push(value);
-      }
-    }
-  }
-  /*
-    featureTextureTable will contain unique values, e.g.
-      textureData = [24, 35, 28, 24]
-      featureTextureTable = [24, 35, 28]
-    featureIndices will contain indices hat refer featureTextureTable, e.g.
-      featureIndices = [0, 1, 2, 0]
-  */
-  const featureIndices: number[] = [];
-  for (const texelData of textureData) {
-    let index = featureTextureTable.findIndex((item) => item === texelData);
-    if (index === -1) {
-      index = featureTextureTable.push(texelData) - 1;
-    }
-    featureIndices.push(index);
-  }
-  const typedArray = new Uint32Array(featureIndices);
-  const bufferIndex =
-    scenegraph.gltf.buffers.push({
-      arrayBuffer: typedArray.buffer,
-      byteOffset: 0,
-      byteLength: typedArray.byteLength
-    }) - 1;
-  const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);
-  const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
-    size: 1,
-    componentType: getComponentTypeFromArray(typedArray),
-    count: typedArray.length
-  });
-  primitive.attributes[attributeName] = accessorIndex;
-}
-
-function getImageValueByCoordinates(
-  parsedImage: any,
-  mimeType: string | undefined,
-  textureCoordinates: Float32Array,
-  index: number,
-  channels: string
-) {
-  const CHANNELS_MAP = {
-    r: {offset: 0, shift: 0},
-    g: {offset: 1, shift: 8},
-    b: {offset: 2, shift: 16},
-    a: {offset: 3, shift: 24}
+  const textureInfoTopLevel: GLTFTextureInfoMetadata = {
+    channels: featureTextureProperty.channels,
+    ...featureTextureProperty.texture
   };
-
-  const u = textureCoordinates[index];
-  const v = textureCoordinates[index + 1];
-
-  let components = 1;
-  if (mimeType && (mimeType.indexOf('image/jpeg') !== -1 || mimeType.indexOf('image/png') !== -1))
-    components = 4;
-  const offset = coordinatesToOffset(u, v, parsedImage, components);
-  let value = 0;
-  for (const c of channels) {
-    const map = CHANNELS_MAP[c];
-    const val = getVal(parsedImage, offset + map.offset);
-    value |= val << map.shift;
-  }
-  return value;
-}
-
-function getVal(parsedImage: any, offset: number): number {
-  const imageData = getImageData(parsedImage);
-  if (imageData.data.length <= offset) {
-    throw new Error(`${imageData.data.length} <= ${offset}`);
-  }
-  return imageData.data[offset];
-}
-
-function coordinatesToOffset(
-  u: number,
-  v: number,
-  parsedImage: any,
-  componentsCount: number = 1
-): number {
-  const w = parsedImage.width;
-  const iX = emod(u) * (w - 1);
-  const indX = Math.round(iX);
-
-  const h = parsedImage.height;
-  const iY = emod(v) * (h - 1);
-  const indY = Math.round(iY);
-  const components = parsedImage.components ? parsedImage.components : componentsCount;
-  // components is a number of channels in the image
-  const offset = (indY * w + indX) * components;
-  return offset;
-}
-
-// The following is taken from tile-converter\src\i3s-converter\helpers\batch-ids-extensions.ts
-/**
- * Handle UVs if they are out of range [0,1].
- * @param n
- * @param m
- */
-function emod(n: number): number {
-  const a = ((n % 1) + 1) % 1;
-  return a;
-}
-
-/**
- * Find the feature table by class name.
- * @param featureTables
- * @param schemaClassName
- */
-function findFeatureTableByName(
-  featureTables: {[key: string]: EXT_feature_metadata_feature_table},
-  schemaClassName: string
-): EXT_feature_metadata_feature_table | null {
-  for (const featureTableName in featureTables) {
-    const featureTable = featureTables[featureTableName];
-
-    if (featureTable.class === schemaClassName) {
-      return featureTable;
-    }
-  }
-
-  return null;
-}
-
-function findFeatureTextureByName(
-  featureTextures: {[key: string]: EXT_feature_metadata_feature_texture},
-  schemaClassName: string
-): EXT_feature_metadata_feature_texture | null {
-  for (const featureTexturesName in featureTextures) {
-    const featureTable = featureTextures[featureTexturesName];
-
-    if (featureTable.class === schemaClassName) {
-      return featureTable;
-    }
-  }
-
-  return null;
-}
-
-/**
- * Getting string attributes from binary data.
- * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata#strings
- * @param data
- * @param offsetsData
- * @param stringsCount
- */
-function getStringAttributes(
-  data: Uint8Array,
-  offsetsData: Uint8Array,
-  stringsCount: number
-): string[] {
-  const stringsArray: string[] = [];
-  const textDecoder = new TextDecoder('utf8');
-
-  let stringOffset = 0;
-  const bytesPerStringSize = 4;
-
-  for (let index = 0; index < stringsCount; index++) {
-    // TODO check if it is multiplication on bytesPerStringSize is valid operation?
-    const stringByteSize =
-      offsetsData[(index + 1) * bytesPerStringSize] - offsetsData[index * bytesPerStringSize];
-    const stringData = data.subarray(stringOffset, stringByteSize + stringOffset);
-    const stringAttribute = textDecoder.decode(stringData);
-
-    stringsArray.push(stringAttribute);
-    stringOffset += stringByteSize;
+  const propertyData: number[] | null = getPrimitiveTextureData(
+    scenegraph,
+    textureInfoTopLevel,
+    primitive
+  );
+  if (!propertyData) {
+    return;
   }
-
-  return stringsArray;
+  primitivePropertyDataToAttributes(
+    scenegraph,
+    attributeName,
+    propertyData,
+    featureTextureTable,
+    primitive
+  );
 }