@loaders.gl/pointclouds 0.0.0-stage → 5.0.0-beta.10

package/src/ply/lib/get-ply-schema.ts

@@ -0,0 +1,133 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Schema, Field, MeshAttributes} from '@loaders.gl/core/schema';
+import {deduceMeshSchema} from '@loaders.gl/core/schema-utils';
+import type {PLYHeader} from './ply-types';
+
+/**
+ * Gets schema from PLY header
+ * @param plyHeader
+ * @param metadata
+ * @returns Schema
+ */
+export function getPLYSchema(plyHeader: PLYHeader, attributes: MeshAttributes): Schema {
+  const metadata = makeMetadataFromPlyHeader(plyHeader);
+  const schema = deduceMeshSchema(attributes, metadata);
+  addGaussianSplatSchemaMetadata(schema, plyHeader);
+  return schema;
+}
+
+/**
+ * Make arrow like schema metadata by PlyHeader properties
+ * @param plyHeader
+ * @returns
+ */
+export function makeMetadataFromPlyHeader(plyHeader: PLYHeader): Record<string, string> {
+  /* eslint-disable camelcase */
+  const metadata: Record<string, string> = {};
+  metadata.ply_comments = JSON.stringify(plyHeader.comments);
+  metadata.ply_elements = JSON.stringify(plyHeader.elements);
+  if (plyHeader.format !== undefined) {
+    metadata.ply_format = plyHeader.format;
+  }
+  if (plyHeader.version !== undefined) {
+    metadata.ply_version = plyHeader.version;
+  }
+  if (plyHeader.headerLength !== undefined) {
+    metadata.ply_headerLength = plyHeader.headerLength.toString(10);
+  }
+  return metadata;
+}
+
+/** Add Gaussian splat metadata conventions for GraphDECO-style PLY columns. */
+function addGaussianSplatSchemaMetadata(schema: Schema, plyHeader: PLYHeader): void {
+  const vertexPropertyNames = getVertexPropertyNames(plyHeader);
+  if (!isGaussianSplatPLY(vertexPropertyNames)) {
+    return;
+  }
+
+  schema.metadata['loaders_gl.semantic_type'] = 'gaussian-splats';
+  schema.metadata['loaders_gl.gaussian_splats.version'] = '1';
+
+  for (const field of schema.fields) {
+    addGaussianSplatFieldMetadata(field);
+  }
+}
+
+/** Return the property names for the PLY vertex element. */
+function getVertexPropertyNames(plyHeader: PLYHeader): Set<string> {
+  const vertexElement = plyHeader.elements.find(element => element.name === 'vertex');
+  return new Set(vertexElement?.properties.map(property => property.name) || []);
+}
+
+/** Return true if the PLY vertex properties match the de facto Gaussian splat layout. */
+function isGaussianSplatPLY(propertyNames: Set<string>): boolean {
+  const requiredPropertyNames = [
+    'x',
+    'y',
+    'z',
+    'f_dc_0',
+    'f_dc_1',
+    'f_dc_2',
+    'opacity',
+    'scale_0',
+    'scale_1',
+    'scale_2',
+    'rot_0',
+    'rot_1',
+    'rot_2',
+    'rot_3'
+  ];
+  return requiredPropertyNames.every(propertyName => propertyNames.has(propertyName));
+}
+
+/** Add loaders.gl Gaussian splat metadata to one schema field. */
+function addGaussianSplatFieldMetadata(field: Field): void {
+  field.metadata ||= {};
+  const metadata = field.metadata;
+
+  if (field.name === 'opacity') {
+    metadata['loaders_gl.gaussian_splats.semantic'] = 'opacity';
+    metadata['loaders_gl.gaussian_splats.encoding'] = 'logit';
+    return;
+  }
+
+  const scaleComponent = getNumberedPropertyComponent(field.name, 'scale');
+  if (scaleComponent !== undefined) {
+    metadata['loaders_gl.gaussian_splats.semantic'] = 'scale';
+    metadata['loaders_gl.gaussian_splats.component'] = scaleComponent;
+    metadata['loaders_gl.gaussian_splats.encoding'] = 'log';
+    return;
+  }
+
+  const rotationComponent = getNumberedPropertyComponent(field.name, 'rot');
+  if (rotationComponent !== undefined) {
+    metadata['loaders_gl.gaussian_splats.semantic'] = 'rotation';
+    metadata['loaders_gl.gaussian_splats.component'] = rotationComponent;
+    metadata['loaders_gl.gaussian_splats.encoding'] = 'quaternion';
+    return;
+  }
+
+  const sphericalHarmonicDCComponent = getNumberedPropertyComponent(field.name, 'f_dc');
+  if (sphericalHarmonicDCComponent !== undefined) {
+    metadata['loaders_gl.gaussian_splats.semantic'] = 'spherical_harmonic_dc';
+    metadata['loaders_gl.gaussian_splats.component'] = sphericalHarmonicDCComponent;
+    metadata['loaders_gl.gaussian_splats.encoding'] = 'coefficient';
+    return;
+  }
+
+  const sphericalHarmonicRestComponent = getNumberedPropertyComponent(field.name, 'f_rest');
+  if (sphericalHarmonicRestComponent !== undefined) {
+    metadata['loaders_gl.gaussian_splats.semantic'] = 'spherical_harmonic_rest';
+    metadata['loaders_gl.gaussian_splats.component'] = sphericalHarmonicRestComponent;
+    metadata['loaders_gl.gaussian_splats.encoding'] = 'coefficient';
+  }
+}
+
+/** Return the numeric suffix for a property such as scale_0. */
+function getNumberedPropertyComponent(name: string, prefix: string): string | undefined {
+  const match = name.match(new RegExp(`^${prefix}_(\\d+)$`));
+  return match?.[1];
+}

package/src/ply/lib/normalize-ply.ts

@@ -0,0 +1,110 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {MeshAttributes} from '@loaders.gl/core/schema';
+import {getMeshBoundingBox} from '@loaders.gl/core/schema-utils';
+import type {PLYMesh, PLYHeader, PLYAttributes, MeshHeader} from './ply-types';
+import {getPLYSchema} from './get-ply-schema';
+
+/**
+ * @param header
+ * @param attributes
+ * @returns data and header
+ */
+export default function normalizePLY(
+  plyHeader: MeshHeader & PLYHeader,
+  plyAttributes: PLYAttributes,
+  options?: {}
+): PLYMesh {
+  const attributes = getMeshAttributes(plyAttributes);
+  const boundingBox = getMeshBoundingBox(attributes);
+  const vertexCount = plyAttributes.indices.length || plyAttributes.vertices.length / 3;
+
+  // TODO - how to detect POINT CLOUDS vs MESHES?
+  // TODO - For Meshes, PLY quadrangles must be split?
+  const isTriangles = plyAttributes.indices && plyAttributes.indices.length > 0;
+  const mode = isTriangles ? 4 : 0; // TRIANGLES vs POINTS
+  const topology = isTriangles ? 'triangle-list' : 'point-list';
+
+  const schema = getPLYSchema(plyHeader, attributes);
+
+  const plyMesh: PLYMesh = {
+    loader: 'ply',
+    loaderData: plyHeader,
+    header: {
+      vertexCount,
+      boundingBox: boundingBox ?? undefined
+    },
+    schema,
+    attributes,
+    indices: {value: new Uint32Array(0), size: 0},
+    mode,
+    topology
+  };
+
+  if (plyAttributes.indices.length > 0) {
+    plyMesh.indices = {value: new Uint32Array(plyAttributes.indices), size: 1};
+  }
+
+  return plyMesh;
+}
+
+/**
+ * @param attributes
+ * @returns accessors []
+ */
+// eslint-disable-next-line complexity
+function getMeshAttributes(attributes: PLYAttributes): MeshAttributes {
+  const accessors: MeshAttributes = {};
+
+  for (const attributeName of Object.keys(attributes)) {
+    switch (attributeName) {
+      case 'vertices':
+        if (attributes.vertices.length > 0) {
+          accessors.POSITION = {value: getFloat32Array(attributes.vertices), size: 3};
+        }
+        break;
+
+      // optional attributes data
+      case 'normals':
+        if (attributes.normals.length > 0) {
+          accessors.NORMAL = {value: getFloat32Array(attributes.normals), size: 3};
+        }
+        break;
+
+      case 'uvs':
+        if (attributes.uvs.length > 0) {
+          accessors.TEXCOORD_0 = {value: getFloat32Array(attributes.uvs), size: 2};
+        }
+        break;
+
+      case 'colors':
+        if (attributes.colors.length > 0) {
+          // TODO - normalized shoud be based on `uchar` flag in source data?
+          accessors.COLOR_0 = {value: getUint8Array(attributes.colors), size: 3, normalized: true};
+        }
+        break;
+
+      case 'indices':
+        break;
+
+      default:
+        if (attributes[attributeName].length > 0) {
+          accessors[attributeName] = {value: getFloat32Array(attributes[attributeName]), size: 1};
+        }
+        break;
+    }
+  }
+  return accessors;
+}
+
+/** Return a Float32Array without copying when the parser already produced one. */
+function getFloat32Array(attribute: PLYAttributes[string]): Float32Array {
+  return attribute instanceof Float32Array ? attribute : new Float32Array(attribute);
+}
+
+/** Return a Uint8Array without copying when the parser already produced one. */
+function getUint8Array(attribute: PLYAttributes[string]): Uint8Array {
+  return attribute instanceof Uint8Array ? attribute : new Uint8Array(attribute);
+}