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

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

@@ -0,0 +1,47 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import type {Mesh, TypedArray} from '@loaders.gl/core/schema';
+
+/** A parsed PLY mesh */
+export type PLYMesh = Mesh & {
+  loader: 'ply';
+  loaderData: PLYHeader;
+};
+
+/** A PLY header */
+export type PLYHeader = {
+  format?: string;
+  comments: string[];
+  elements: PLYElement[];
+  version?: string;
+  headerLength?: number;
+};
+
+// INTERNAL TYPES
+
+/** A general mesh header */
+export type MeshHeader = {
+  vertexCount?: number;
+  boundingBox?: [[number, number, number], [number, number, number]];
+};
+
+/** The parsed columnar values */
+export type PLYAttributes = {
+  [index: string]: number[] | TypedArray;
+};
+
+/** A top level PLY element (vertex, face,  ...) */
+export type PLYElement = {
+  name: string;
+  count: number;
+  properties: PLYProperty[];
+};
+
+/** One property in a top-level PLY element */
+export type PLYProperty = {
+  name: string;
+  type: string;
+  countType?: string;
+  itemType?: string;
+};

package/src/ply/ply-format.ts

@@ -0,0 +1,24 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Format} from '@loaders.gl/core/loader-utils';
+
+/**
+ * PLY - Polygon File Format (aka Stanford Triangle Format)
+ * @see http://paulbourke.net/dataformats/ply/,
+ * @see https://en.wikipedia.org/wiki/PLY_(file_format)
+ */
+export const PLYFormat = {
+  name: 'PLY',
+  id: 'ply',
+  module: 'pointclouds',
+  encoding: 'text',
+  format: 'ply',
+  // shapes: ['mesh', 'gltf', 'columnar-table'],
+  extensions: ['ply'],
+  mimeTypes: ['text/plain', 'application/octet-stream'],
+  text: true,
+  binary: true,
+  tests: ['ply']
+} as const satisfies Format;

package/src/ply/ply-loader-types.ts

@@ -0,0 +1,60 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// PLY Loader
+import type {Table, RecordBatch} from 'apache-arrow';
+import type {Loader, LoaderOptions} from '@loaders.gl/core/loader-utils';
+import type {PLYMesh} from './lib/ply-types';
+import type {ParsePLYOptions} from './lib/parse-ply';
+import {PLYFormat} from './ply-format';
+import {serializeArrowWorkerTable} from '@loaders.gl/core/arrow-worker-transport';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+export type PLYLoaderOptions = LoaderOptions & {
+  ply?: ParsePLYOptions & {
+    /** Output shape. Defaults to a Mesh Arrow table. */
+    shape?: 'mesh' | 'arrow';
+    /** Color storage format. Defaults to uint8norm for backwards compatibility. */
+    colorFormat?: 'uint8norm' | 'float16' | 'float32';
+    /** Treat PLY data as a point cloud by reading only the leading vertex element. */
+    pointCloud?: boolean;
+    /** Override the URL to the worker bundle (by default loads from unpkg.com) */
+    workerUrl?: string;
+  };
+};
+
+/**
+ * Preloads the parser-bearing PLY loader implementation.
+ */
+async function preload() {
+  const {PLYLoaderWithParser} = await import('@loaders.gl/pointclouds/ply-loader');
+  return PLYLoaderWithParser;
+}
+
+/**
+ * Metadata-only worker loader for PLY - Polygon File Format (aka Stanford Triangle Format)'
+ * links: ['http://paulbourke.net/dataformats/ply/',
+ * 'https://en.wikipedia.org/wiki/PLY_(file_format)']
+ */
+export const PLYLoader = {
+  defaultShape: 'arrow',
+  supportsNativeArrow: true,
+  dataType: null as unknown as PLYMesh | Table,
+  batchType: null as unknown as PLYMesh | RecordBatch,
+
+  ...PLYFormat,
+  // shapes: ['mesh', 'gltf', 'columnar-table'],
+  version: VERSION,
+  worker: true,
+  /** Enables the stateful input/output batch protocol on the built-in worker. */
+  workerInBatches: true,
+  serializeWorkerResult: serializeArrowWorkerTable,
+  options: {
+    ply: {shape: 'arrow', colorFormat: 'uint8norm'}
+  },
+  preload
+} as const satisfies Loader<PLYMesh | Table, PLYMesh | RecordBatch, LoaderOptions>;

package/src/ply/ply-loader.ts

@@ -0,0 +1,255 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {refineArrowTableBatches, makeArrowMetadataBatch} from '@loaders.gl/core/schema-utils';
+import type {Table, RecordBatch} from 'apache-arrow';
+import type {PLYLoaderOptions} from './ply-loader-types';
+
+// PLY Loader
+import {makeTableScanBatch, type LoaderWithParser} from '@loaders.gl/core/loader-utils';
+import {convertColorArrayToFloat16, convertColorArrayToFloat32} from '@loaders.gl/core/schema';
+import type {MeshArrowTable, ArrowTableBatch} from '@loaders.gl/core/schema';
+import {
+  deserializeArrowWorkerTable,
+  serializeArrowWorkerTable
+} from '@loaders.gl/core/arrow-worker-transport';
+import type {PLYHeader, PLYMesh} from './lib/ply-types';
+import {
+  convertMeshToArrowTableWrapper,
+  convertTableToMesh,
+  deduceMeshSchema
+} from '@loaders.gl/core/schema-utils';
+import {parsePLY, parsePLYHeader, parsePLYToArrowTable} from './lib/parse-ply';
+import {
+  convertPLYElementTablesToMeshArrowTable,
+  parsePLYToElementTables
+} from './lib/parse-ply-arrow';
+import {parsePLYInBatches} from './lib/parse-ply-in-batches';
+import {PLYLoader as PLYLoaderMetadata} from './ply-loader-types';
+
+const {preload: _PLYLoaderPreload, ...PLYLoaderMetadataWithoutPreload} = PLYLoaderMetadata;
+
+function convertPLYMesh(mesh: PLYMesh, options?: PLYLoaderOptions): PLYMesh | MeshArrowTable {
+  const table = convertMeshToArrowTableWrapper(mesh);
+  return convertPLYTable(table, options, mesh.loaderData);
+}
+
+/** Parse PLY data using a direct Arrow path when requested and supported. */
+function parsePLYData(
+  data: ArrayBuffer | string,
+  options?: PLYLoaderOptions
+): PLYMesh | MeshArrowTable {
+  if (options?.ply?._useLegacyParser) {
+    return convertPLYMesh(parsePLY(data, options?.ply), options);
+  }
+
+  const arrowTable = parsePLYToArrowTable(data, options?.ply);
+  if (arrowTable) {
+    return convertPLYTable(arrowTable, options, parsePLYHeader(data, options?.ply));
+  }
+
+  const elementTables = parsePLYToElementTables(data, options?.ply);
+  return convertPLYTable(
+    convertPLYElementTablesToMeshArrowTable(elementTables),
+    options,
+    elementTables.header
+  );
+}
+
+/**
+ * Loader for PLY - Polygon File Format
+ */
+export const PLYColumnLoader = {
+  ...PLYLoaderMetadataWithoutPreload,
+  dataType: null as unknown as PLYMesh | MeshArrowTable,
+  batchType: null as unknown as PLYMesh | ArrowTableBatch,
+  parse: async (arrayBuffer, options) => parsePLYData(arrayBuffer, options),
+  parseTextSync: (arrayBuffer, options) => parsePLYData(arrayBuffer, options),
+  parseSync: (arrayBuffer, options) => parsePLYData(arrayBuffer, options),
+  parseInBatches: (input, options) =>
+    refineArrowTableBatches(parsePLYWithMetadataInBatches(input, options)),
+  serializeWorkerResult: serializeArrowWorkerTable,
+  deserializeWorkerResult: deserializePLYWorkerResult,
+  serializeWorkerBatch: serializeArrowWorkerTable,
+  deserializeWorkerBatch: deserializePLYWorkerBatch
+} as const satisfies LoaderWithParser<
+  PLYMesh | MeshArrowTable,
+  PLYMesh | ArrowTableBatch,
+  PLYLoaderOptions
+>;
+
+/** Return requested public PLY shape from the parser's Arrow table. */
+function convertPLYTable(
+  table: MeshArrowTable & {
+    /** Original source header retained by the streaming parser. */
+    loaderData?: PLYHeader;
+  },
+  options?: PLYLoaderOptions,
+  header?: PLYHeader
+): PLYMesh | MeshArrowTable {
+  const loaderData = header || table.loaderData || {comments: [], elements: []};
+  const result =
+    options?.ply?.shape === 'arrow'
+      ? {...table, loader: 'ply' as const, loaderData}
+      : {
+          ...(convertTableToMesh(table) as PLYMesh),
+          loader: 'ply',
+          loaderData
+        };
+  const colorFormat = options?.ply?.colorFormat || 'uint8norm';
+  if (colorFormat === 'uint8norm') {
+    return result as PLYMesh | MeshArrowTable;
+  }
+
+  const resultData = result as PLYMesh | MeshArrowTable;
+  const formattedMesh = formatPLYMeshColors(
+    (isMeshArrowTable(resultData) ? convertTableToMesh(resultData) : resultData) as PLYMesh,
+    colorFormat
+  );
+  return options?.ply?.shape === 'arrow'
+    ? {
+        ...convertMeshToArrowTableWrapper(formattedMesh),
+        loader: 'ply' as const,
+        loaderData
+      }
+    : (formattedMesh as PLYMesh);
+}
+
+/** Apply the requested normalized color representation to a decoded PLY mesh. */
+function formatPLYMeshColors(
+  mesh: PLYMesh,
+  colorFormat: 'uint8norm' | 'float16' | 'float32'
+): PLYMesh {
+  const colorAttribute = mesh.attributes.COLOR_0;
+  if (!colorAttribute) {
+    return mesh;
+  }
+
+  const sourceScale = colorAttribute.value instanceof Uint16Array ? 65535 : 255;
+  const value =
+    colorFormat === 'float16'
+      ? convertColorArrayToFloat16(colorAttribute.value, sourceScale)
+      : convertColorArrayToFloat32(colorAttribute.value, sourceScale);
+  const attributes = {...mesh.attributes};
+  for (const [attributeName, attribute] of Object.entries(attributes)) {
+    if (attribute.value === colorAttribute.value) {
+      attributes[attributeName] = {
+        ...attribute,
+        value,
+        normalized: false,
+        ...(colorFormat === 'float16' ? {componentType: 'float16' as const} : {})
+      };
+    }
+  }
+  return {
+    ...mesh,
+    attributes,
+    schema: deduceMeshSchema(attributes, mesh.schema.metadata)
+  };
+}
+
+/** Return true if a parsed PLY batch is already a Mesh Arrow table. */
+function isMeshArrowTable(data: PLYMesh | MeshArrowTable): data is MeshArrowTable {
+  return 'shape' in data && data.shape === 'arrow-table';
+}
+
+/** Hydrates worker columns and applies the requested PLY shape on the caller. */
+function deserializePLYWorkerResult(
+  result: unknown,
+  options?: PLYLoaderOptions
+): PLYMesh | MeshArrowTable {
+  const table = deserializeArrowWorkerTable(result);
+  return options?.ply?.shape === 'mesh'
+    ? {...convertTableToMesh(table), loader: 'ply', loaderData: table.loaderData}
+    : table;
+}
+
+/** Converts mesh batches only after the Arrow column buffers reach the caller. */
+function deserializePLYWorkerBatch(
+  result: unknown,
+  options?: PLYLoaderOptions
+): PLYMesh | ArrowTableBatch {
+  return deserializePLYWorkerResult(result, options) as PLYMesh | ArrowTableBatch;
+}
+
+/** Parses PLY batches before shared cumulative metadata refinement. */
+async function* parsePLYWithMetadataInBatches(
+  arrayBuffer:
+    | AsyncIterable<ArrayBufferLike | ArrayBufferView>
+    | Iterable<ArrayBufferLike | ArrayBufferView>,
+  options?: PLYLoaderOptions
+) {
+  const plyOptions = {
+    ...options?.ply,
+    batchSize: options?.core?.batchSize
+  };
+  for await (const meshOrTable of parsePLYInBatches(arrayBuffer, plyOptions)) {
+    const convertedData = isMeshArrowTable(meshOrTable)
+      ? convertPLYTable(meshOrTable, options)
+      : convertPLYMesh(meshOrTable, options);
+    yield isMeshArrowTable(convertedData) ? makeTableScanBatch(convertedData) : convertedData;
+  }
+}
+
+/** Exposes native Arrow output while retaining the worker's column protocol. */
+export const PLYLoaderWithParser = {
+  ...PLYColumnLoader,
+  dataType: PLYLoaderMetadata.dataType,
+  batchType: PLYLoaderMetadata.batchType,
+  parse: async (input: ArrayBuffer, options?: PLYLoaderOptions) =>
+    unwrapPLYTable(await PLYColumnLoader.parse(input, options)),
+  parseTextSync: (input: string, options?: PLYLoaderOptions) =>
+    unwrapPLYTable(PLYColumnLoader.parseTextSync(input, options)),
+  parseSync: (input: ArrayBuffer, options?: PLYLoaderOptions) =>
+    unwrapPLYTable(PLYColumnLoader.parseSync(input, options)),
+  async *parseInBatches(input, options) {
+    for await (const batch of PLYColumnLoader.parseInBatches(input, options)) {
+      if (isColumnBatch(batch)) {
+        batch.data.schema.metadata.set(
+          'loaders.gl.ply.header',
+          JSON.stringify((batch as ArrowTableBatch & {loaderData?: unknown}).loaderData)
+        );
+        for (const recordBatch of batch.data.batches) {
+          recordBatch.schema.metadata.set(
+            'loaders.gl.ply.header',
+            batch.data.schema.metadata.get('loaders.gl.ply.header')!
+          );
+        }
+        if (batch.data.batches.length) yield* batch.data.batches;
+        else yield makeArrowMetadataBatch(batch.data.schema);
+      } else yield batch;
+    }
+  },
+  deserializeWorkerResult: (result: unknown, options?: PLYLoaderOptions) =>
+    unwrapPLYTable(PLYColumnLoader.deserializeWorkerResult(result, options)),
+  deserializeWorkerBatch(result: unknown, options?: PLYLoaderOptions) {
+    const batch = PLYColumnLoader.deserializeWorkerBatch(result, options);
+    if (isColumnBatch(batch)) {
+      const recordBatch = batch.data.batches[0] ?? makeArrowMetadataBatch(batch.data.schema);
+      recordBatch.schema.metadata.set(
+        'loaders.gl.ply.header',
+        JSON.stringify((batch as ArrowTableBatch & {loaderData?: unknown}).loaderData)
+      );
+      return recordBatch;
+    }
+    return batch;
+  }
+} as const satisfies LoaderWithParser<PLYMesh | Table, PLYMesh | RecordBatch, PLYLoaderOptions>;
+
+/** Returns the Arrow table with its file metadata or the requested mesh. */
+function unwrapPLYTable(result: PLYMesh | MeshArrowTable): PLYMesh | Table {
+  if ('shape' in result && result.shape === 'arrow-table') {
+    result.data.schema.metadata.set(
+      'loaders.gl.ply.header',
+      JSON.stringify((result as MeshArrowTable & {loaderData?: unknown}).loaderData)
+    );
+    return result.data;
+  }
+  return result as PLYMesh;
+}
+
+/** Identifies the private Arrow batch envelope. */
+function isColumnBatch(batch: PLYMesh | ArrowTableBatch): batch is ArrowTableBatch {
+  return 'shape' in batch && batch.shape === 'arrow-table';
+}

package/src/ply/ply-writer.ts

@@ -0,0 +1,219 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Table} from 'apache-arrow';
+import type {WriterOptions, WriterWithEncoder} from '@loaders.gl/core/loader-utils';
+import type {Mesh, MeshArrowTable, MeshAttribute} from '@loaders.gl/core/schema';
+import {convertMeshToArrowTableWrapper, convertTableToMesh} from '@loaders.gl/core/schema-utils';
+import {PLYFormat} from './ply-format';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+/** Options for `PLYWriter`. */
+export type PLYWriterOptions = WriterOptions & {
+  /** Reserved for future PLY writer options. */
+  ply?: Record<string, never>;
+};
+
+/**
+ * Writer for the PLY geometry format.
+ */
+export const PLYWriter = {
+  ...PLYFormat,
+  dataType: null as unknown as Mesh | MeshArrowTable | Table,
+  batchType: null as never,
+  version: VERSION,
+  options: {
+    ply: {}
+  },
+  text: true,
+  encode: async (data, options) => encodePLYSync(data, options),
+  encodeSync: encodePLYSync,
+  encodeTextSync: encodePLY
+} as const satisfies WriterWithEncoder<Mesh | MeshArrowTable | Table, never, PLYWriterOptions>;
+
+/** Encode mesh category data as PLY bytes. */
+function encodePLYSync(
+  data: Mesh | MeshArrowTable | Table,
+  options?: PLYWriterOptions
+): ArrayBuffer {
+  const text = encodePLY(data, options);
+  return new TextEncoder().encode(text).buffer;
+}
+
+/** Encode mesh category data as ASCII PLY text. */
+function encodePLY(data: Mesh | MeshArrowTable | Table, options?: PLYWriterOptions): string {
+  const mesh = convertTableToMesh(normalizeMeshArrowTable(data));
+  const positionAttribute = getRequiredAttribute(mesh, 'POSITION');
+  const normalAttribute = mesh.attributes.NORMAL;
+  const textureCoordinateAttribute = mesh.attributes.TEXCOORD_0;
+  const colorAttribute = mesh.attributes.COLOR_0;
+  const customScalarAttributes = getCustomScalarAttributes(mesh);
+  const vertexCount = positionAttribute.value.length / positionAttribute.size;
+  const triangleIndices = getTriangleIndices(mesh, vertexCount);
+  const header = getPLYHeader(
+    vertexCount,
+    triangleIndices.length / 3,
+    Boolean(normalAttribute),
+    Boolean(textureCoordinateAttribute),
+    Boolean(colorAttribute),
+    customScalarAttributes
+  );
+  const rows: string[] = [];
+
+  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+    const row = [
+      getComponent(positionAttribute, vertexIndex, 0),
+      getComponent(positionAttribute, vertexIndex, 1),
+      getComponent(positionAttribute, vertexIndex, 2)
+    ];
+
+    if (normalAttribute) {
+      row.push(
+        getComponent(normalAttribute, vertexIndex, 0),
+        getComponent(normalAttribute, vertexIndex, 1),
+        getComponent(normalAttribute, vertexIndex, 2)
+      );
+    }
+
+    if (textureCoordinateAttribute) {
+      row.push(
+        getComponent(textureCoordinateAttribute, vertexIndex, 0),
+        getComponent(textureCoordinateAttribute, vertexIndex, 1)
+      );
+    }
+
+    if (colorAttribute) {
+      row.push(
+        getColorByte(colorAttribute, vertexIndex, 0),
+        getColorByte(colorAttribute, vertexIndex, 1),
+        getColorByte(colorAttribute, vertexIndex, 2)
+      );
+    }
+
+    for (const [, attribute] of customScalarAttributes) {
+      row.push(getComponent(attribute, vertexIndex, 0));
+    }
+
+    rows.push(row.join(' '));
+  }
+
+  for (let triangleIndex = 0; triangleIndex < triangleIndices.length; triangleIndex += 3) {
+    rows.push(
+      `3 ${triangleIndices[triangleIndex]} ${triangleIndices[triangleIndex + 1]} ${
+        triangleIndices[triangleIndex + 2]
+      }`
+    );
+  }
+
+  return `${header.concat(rows).join('\n')}\n`;
+}
+
+/** Return mesh data as a MeshArrowTable, converting plain Mesh data first. */
+function normalizeMeshArrowTable(data: Mesh | MeshArrowTable | Table): MeshArrowTable | Table {
+  if (!('attributes' in data)) {
+    return data;
+  }
+  return convertMeshToArrowTableWrapper(data as Mesh);
+}
+
+/** Return a required mesh attribute or throw a format-specific error. */
+function getRequiredAttribute(mesh: Mesh, attributeName: string): MeshAttribute {
+  const attribute = mesh.attributes[attributeName];
+  if (!attribute) {
+    throw new Error(`PLYWriter: ${attributeName} attribute is required`);
+  }
+  return attribute;
+}
+
+/** Return the ASCII PLY header lines. */
+function getPLYHeader(
+  vertexCount: number,
+  faceCount: number,
+  hasNormals: boolean,
+  hasTextureCoordinates: boolean,
+  hasColors: boolean,
+  customScalarAttributes: [string, MeshAttribute][]
+): string[] {
+  const header = [
+    'ply',
+    'format ascii 1.0',
+    'comment generated by loaders.gl',
+    `element vertex ${vertexCount}`,
+    'property float x',
+    'property float y',
+    'property float z'
+  ];
+
+  if (hasNormals) {
+    header.push('property float nx', 'property float ny', 'property float nz');
+  }
+
+  if (hasTextureCoordinates) {
+    header.push('property float s', 'property float t');
+  }
+
+  if (hasColors) {
+    header.push('property uchar red', 'property uchar green', 'property uchar blue');
+  }
+
+  for (const [attributeName] of customScalarAttributes) {
+    header.push(`property float ${attributeName}`);
+  }
+
+  if (faceCount > 0) {
+    header.push(`element face ${faceCount}`, 'property list uchar int vertex_indices');
+  }
+
+  header.push('end_header');
+  return header;
+}
+
+/** Return additional one-component attributes that can be represented as scalar PLY properties. */
+function getCustomScalarAttributes(mesh: Mesh): [string, MeshAttribute][] {
+  const reservedAttributeNames = new Set(['POSITION', 'NORMAL', 'TEXCOORD_0', 'COLOR_0']);
+  return Object.entries(mesh.attributes).filter(
+    ([attributeName, attribute]) =>
+      !reservedAttributeNames.has(attributeName) && attribute.size === 1
+  );
+}
+
+/** Return a single attribute component with 0 as the missing component fallback. */
+function getComponent(
+  attribute: MeshAttribute,
+  vertexIndex: number,
+  componentIndex: number
+): number {
+  return attribute.value[vertexIndex * attribute.size + componentIndex] || 0;
+}
+
+/** Return one color component as an unsigned byte. */
+function getColorByte(
+  attribute: MeshAttribute,
+  vertexIndex: number,
+  componentIndex: number
+): number {
+  const value = getComponent(attribute, vertexIndex, componentIndex);
+  const byteValue = attribute.normalized || value <= 1 ? value * 255 : value;
+  return Math.max(0, Math.min(255, Math.round(byteValue)));
+}
+
+/** Return triangle indices for indexed or sequential triangle-list meshes. */
+function getTriangleIndices(mesh: Mesh, vertexCount: number): number[] {
+  if (mesh.indices?.value?.length) {
+    return Array.from(mesh.indices.value);
+  }
+
+  if (mesh.mode !== 4 && mesh.topology !== 'triangle-list') {
+    return [];
+  }
+
+  const triangleIndices: number[] = [];
+  for (let vertexIndex = 0; vertexIndex + 2 < vertexCount; vertexIndex += 3) {
+    triangleIndices.push(vertexIndex, vertexIndex + 1, vertexIndex + 2);
+  }
+  return triangleIndices;
+}

package/src/ply/unbundled.ts

@@ -0,0 +1,6 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export type {PLYLoaderOptions} from './ply-loader-types';
+export {PLYLoader} from './ply-loader-types';

package/src/ply/workers/ply-worker.ts

@@ -0,0 +1,40 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {createLoaderWorker, makeTableScanBatch} from '@loaders.gl/core/loader-utils';
+import type {MeshArrowTable} from '@loaders.gl/core/schema';
+import {convertMeshToArrowTableWrapper} from '@loaders.gl/core/schema-utils';
+import type {PLYMesh} from '../lib/ply-types';
+import type {PLYLoaderOptions} from '../ply-loader-types';
+import {PLYColumnLoader} from '../ply-loader';
+
+createLoaderWorker({
+  ...PLYColumnLoader,
+  /** Always returns columnar data; legacy mesh conversion runs on the caller. */
+  parse(input, options) {
+    return PLYColumnLoader.parse(input, {
+      ...options,
+      ply: {...options?.ply, shape: 'arrow'}
+    });
+  },
+  /** Preserves full-mesh parsing while streaming point-cloud vertices as Arrow batches. */
+  async *parseInBatches(input, options?: PLYLoaderOptions) {
+    const parseMesh = options?.ply?.shape === 'mesh' && !options?.ply?.pointCloud;
+    const parserOptions = parseMesh
+      ? options
+      : {...options, ply: {...options?.ply, shape: 'arrow' as const}};
+    for await (const batch of PLYColumnLoader.parseInBatches(input, parserOptions)) {
+      if ('shape' in batch && batch.shape === 'arrow-table') {
+        yield batch;
+      } else {
+        const mesh = batch as PLYMesh;
+        yield makeTableScanBatch({
+          ...convertMeshToArrowTableWrapper(mesh),
+          loader: mesh.loader,
+          loaderData: mesh.loaderData
+        } as MeshArrowTable);
+      }
+    }
+  }
+});

package/src/ply-loader-types.ts

@@ -0,0 +1 @@
+export * from './ply/ply-loader-types.js';

package/src/ply-loader.ts

@@ -0,0 +1 @@
+export * from './ply/ply-loader.js';

package/src/ply-writer.ts

@@ -0,0 +1 @@
+export * from './ply/ply-writer.js';

package/third-party-licenses/plasio-LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Uday Verma, uday.karan@gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.