@loaders.gl/tile-converter 4.0.0-alpha.4 → 4.0.0-alpha.6

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

@@ -1,11 +1,15 @@
-import type {BoundingVolumes, Extent, Mbs, Obb} from '@loaders.gl/i3s';
+import type {BoundingVolumes, FullExtent, Mbs, Obb} from '@loaders.gl/i3s';
 
 import {Matrix3, Quaternion, Vector3} from '@math.gl/core';
 import {Ellipsoid} from '@math.gl/geospatial';
-import {OrientedBoundingBox} from '@math.gl/culling';
-import TileHeader from '@loaders.gl/tiles/src/tileset/tile-3d';
-import {GeoidHeightModel} from '../../lib/geoid-height-model';
-import {Tileset3D} from '@loaders.gl/tiles';
+import {
+  OrientedBoundingBox,
+  makeOrientedBoundingBoxFromPoints,
+  makeBoundingSphereFromPoints,
+  BoundingSphere
+} from '@math.gl/culling';
+import {Tile3D} from '@loaders.gl/tiles';
+import {Geoid} from '@math.gl/geoid';
 
 /**
  * Create bounding volumes object from tile and geoid height model.
@@ -13,10 +17,7 @@ import {Tileset3D} from '@loaders.gl/tiles';
  * @param geoidHeightModel
  * @returns - Bounding volumes object
  */
-export function createBoundingVolumes(
-  tile: TileHeader,
-  geoidHeightModel: GeoidHeightModel
-): BoundingVolumes {
+export function createBoundingVolumes(tile: Tile3D, geoidHeightModel: Geoid): BoundingVolumes {
   let radius;
   let halfSize;
   let quaternion;
@@ -52,30 +53,89 @@ export function createBoundingVolumes(
 }
 
 /**
- * Convert common coordinate to extent coordinate
- * @param tileset
- * @returns - Extent
+ * Generates bounding volumes from geometry positions
+ * @param cartesianPositions
+ * @param geoidHeightModel
+ */
+export function createBoundingVolumesFromGeometry(
+  cartesianPositions: Float32Array,
+  geoidHeightModel: Geoid
+): {mbs: Mbs; obb: Obb} {
+  const positionVectors = convertPositionsToVectors(cartesianPositions);
+
+  const geometryObb = makeOrientedBoundingBoxFromPoints(positionVectors);
+  const geometryMbs = makeBoundingSphereFromPoints(positionVectors);
+
+  let mbsCenter = Ellipsoid.WGS84.cartesianToCartographic(geometryMbs.center, new Vector3());
+  let obbCenter = Ellipsoid.WGS84.cartesianToCartographic(geometryObb.center, new Vector3());
+
+  mbsCenter[2] = mbsCenter[2] - geoidHeightModel.getHeight(mbsCenter[1], mbsCenter[0]);
+  obbCenter[2] = obbCenter[2] - geoidHeightModel.getHeight(obbCenter[1], obbCenter[0]);
+
+  return {
+    mbs: [mbsCenter[0], mbsCenter[1], mbsCenter[2], geometryMbs.radius],
+    obb: {
+      center: obbCenter,
+      halfSize: geometryObb.halfSize,
+      quaternion: geometryObb.quaternion
+    }
+  };
+}
+
+/**
+ * Create array of posisitons where each vertex is vector
+ * @param {array} positions
+ * @returns {Vector3[]}
+ */
+export function convertPositionsToVectors(positions: Float32Array): Vector3[] {
+  const result: Vector3[] = [];
+
+  for (let i = 0; i < positions.length; i += 3) {
+    // TODO: (perf) new Vector3 is not optimal but required in `makeOrientedBoundingBoxFromPoints`.
+    // modify `makeOrientedBoundingBoxFromPoints` to use scratch vectors
+    const positionVector = new Vector3([positions[i], positions[i + 1], positions[i + 2]]);
+    result.push(positionVector);
+  }
+
+  return result;
+}
+
+/**
+ * Convert common coordinate to fullExtent https://github.com/Esri/i3s-spec/blob/master/docs/1.8/fullExtent.cmn.md
+ * @param
+ * @param boundingVolume
+ * @returns - fullExtent object
  */
-export function convertCommonToI3SExtentCoordinate(tileset: Tileset3D): Extent {
-  const cartesianCenter = tileset.cartesianCenter;
-  const radius = tileset.lodMetricValue;
-  const rightTop = Ellipsoid.WGS84.cartesianToCartographic(
-    new Vector3(cartesianCenter[0] + radius, cartesianCenter[1] + radius, cartesianCenter[2]),
+export function convertBoundingVolumeToI3SFullExtent(
+  boundingVolume: OrientedBoundingBox | BoundingSphere
+): FullExtent {
+  let sphere: BoundingSphere;
+  if (boundingVolume instanceof BoundingSphere) {
+    sphere = boundingVolume;
+  } else {
+    sphere = boundingVolume.getBoundingSphere();
+  }
+  const center: Vector3 = sphere.center;
+  const radius: number = sphere.radius;
+  const vertexMax = Ellipsoid.WGS84.cartesianToCartographic(
+    new Vector3(center[0] + radius, center[1] + radius, center[2] + radius),
     new Vector3()
   );
-  const leftBottom = Ellipsoid.WGS84.cartesianToCartographic(
-    new Vector3(cartesianCenter[0] - radius, cartesianCenter[1] - radius, cartesianCenter[2]),
+  const vertexMin = Ellipsoid.WGS84.cartesianToCartographic(
+    new Vector3(center[0] - radius, center[1] - radius, center[2] - radius),
     new Vector3()
   );
-  const isFirstRight = rightTop[0] < leftBottom[0];
-  const isFirstTop = rightTop[1] < leftBottom[1];
 
-  return [
-    isFirstRight ? rightTop[0] : leftBottom[0],
-    isFirstTop ? rightTop[1] : leftBottom[1],
-    isFirstRight ? leftBottom[0] : rightTop[0],
-    isFirstTop ? leftBottom[1] : rightTop[1]
-  ];
+  // Converter sometimes returns min values that are bigger then max,
+  // so we should check and take bigger value from max and smaller for nim
+  return {
+    xmin: Math.min(vertexMin[0], vertexMax[0]),
+    xmax: Math.max(vertexMin[0], vertexMax[0]),
+    ymin: Math.min(vertexMin[1], vertexMax[1]),
+    ymax: Math.max(vertexMin[1], vertexMax[1]),
+    zmin: Math.min(vertexMin[2], vertexMax[2]),
+    zmax: Math.max(vertexMin[2], vertexMax[2])
+  };
 }
 
 /**

package/src/i3s-converter/helpers/create-scene-server-path.ts

@@ -0,0 +1,29 @@
+import type {SceneLayer3D} from '@loaders.gl/i3s';
+import {v4 as uuidv4} from 'uuid';
+import transform from 'json-map-transform';
+import {join} from 'path';
+
+import {SCENE_SERVER as sceneServerTemplate} from '../json-templates/scene-server';
+import {writeFile} from '../../lib/utils/file-utils';
+
+/**
+ * Form and save sceneServer meta data into a file
+ * @param layerName - layer name to display
+ * @param layers0 - layer object embedded into sceneServer meta data
+ * @param rootPath - root path of new converted tileset
+ */
+export async function createSceneServerPath(
+  layerName: string,
+  layers0: SceneLayer3D,
+  rootPath: string
+): Promise<void> {
+  const sceneServerData = {
+    serviceItemId: uuidv4().replace(/-/gi, ''),
+    layerName,
+    layers0
+  };
+
+  const sceneServer = transform(sceneServerData, sceneServerTemplate());
+  const nodePagePath = join(rootPath, 'SceneServer');
+  await writeFile(nodePagePath, JSON.stringify(sceneServer));
+}

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
+  };
+}