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

package/dist/pcd-loader.cjs

@@ -0,0 +1,203 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/pcd-loader.ts
+var pcd_loader_exports = {};
+__export(pcd_loader_exports, {
+  PCDColumnLoader: () => PCDColumnLoader,
+  PCDLoaderWithParser: () => PCDLoaderWithParser
+});
+module.exports = __toCommonJS(pcd_loader_exports);
+
+// src/pcd/pcd-loader.ts
+var import_schema_utils = require("@loaders.gl/core/schema-utils");
+var import_loader_utils = require("@loaders.gl/core/loader-utils");
+var import_arrow_worker_transport = require("@loaders.gl/core/arrow-worker-transport");
+var import_schema_utils2 = require("@loaders.gl/core/schema-utils");
+var import_parse_pcd = require("./lib/parse-pcd.cjs");
+var import_pcd_loader_types = require("./pcd-loader-types.cjs");
+var { preload: _PCDLoaderPreload, ...PCDLoaderMetadataWithoutPreload } = import_pcd_loader_types.PCDLoader;
+function convertPCDMesh(mesh, options) {
+  const table = (0, import_schema_utils2.convertMeshToArrowTableWrapper)(mesh);
+  return options?.pcd?.shape === "mesh" ? convertPCDTableToMesh(table, mesh) : { ...table, loader: mesh.loader, loaderData: mesh.loaderData };
+}
+var PCDColumnLoader = {
+  ...PCDLoaderMetadataWithoutPreload,
+  dataType: null,
+  batchType: null,
+  parse: async (arrayBuffer, options) => convertPCDMesh((0, import_parse_pcd.parsePCD)(arrayBuffer, options), options),
+  parseSync: (arrayBuffer, options) => convertPCDMesh((0, import_parse_pcd.parsePCD)(arrayBuffer, options), options),
+  parseInBatches: (input, options) => (0, import_schema_utils.refineArrowTableBatches)(parsePCDWithMetadataInBatches(input, options)),
+  serializeWorkerResult: import_arrow_worker_transport.serializeArrowWorkerTable,
+  deserializeWorkerResult: deserializePCDWorkerResult,
+  serializeWorkerBatch: import_arrow_worker_transport.serializeArrowWorkerTable,
+  deserializeWorkerBatch: deserializePCDWorkerBatch
+};
+function getNumericBatchSize(options) {
+  const batchSize = options?.core?.batchSize;
+  return typeof batchSize === "number" ? batchSize : void 0;
+}
+function* parsePCDASCIIInBatches(data, options, batchSize) {
+  const textData = new TextDecoder().decode(data);
+  const pcdHeader = (0, import_parse_pcd.parsePCDHeader)(textData);
+  const lines = textData.slice(pcdHeader.headerLen).split(/\r?\n/).filter((line) => line.trim().length > 0);
+  const normalizedBatchSize = batchSize || lines.length || 1;
+  for (let rowIndex = 0; rowIndex < lines.length; rowIndex += normalizedBatchSize) {
+    const batchLines = lines.slice(rowIndex, rowIndex + normalizedBatchSize);
+    const batchText = `${makePCDHeaderText(pcdHeader, batchLines.length)}${batchLines.join("\n")}
+`;
+    yield makePCDBatch((0, import_parse_pcd.parsePCD)(new TextEncoder().encode(batchText).buffer, options), options);
+  }
+}
+function* parsePCDBinaryInBatches(data, options, batchSize) {
+  const textData = new TextDecoder().decode(data);
+  const pcdHeader = (0, import_parse_pcd.parsePCDHeader)(textData);
+  const normalizedBatchSize = batchSize || pcdHeader.points || 1;
+  const dataBytes = new Uint8Array(data);
+  for (let pointIndex = 0; pointIndex < pcdHeader.points; pointIndex += normalizedBatchSize) {
+    const pointCount = Math.min(normalizedBatchSize, pcdHeader.points - pointIndex);
+    const headerBytes = new TextEncoder().encode(makePCDHeaderText(pcdHeader, pointCount));
+    const rowByteOffset = pcdHeader.headerLen + pointIndex * pcdHeader.rowSize;
+    const rowByteLength = pointCount * pcdHeader.rowSize;
+    const batchBytes = new Uint8Array(headerBytes.length + rowByteLength);
+    batchBytes.set(headerBytes, 0);
+    batchBytes.set(
+      dataBytes.subarray(rowByteOffset, rowByteOffset + rowByteLength),
+      headerBytes.length
+    );
+    yield makePCDBatch((0, import_parse_pcd.parsePCD)(batchBytes.buffer, options), options);
+  }
+}
+function makePCDBatch(mesh, options) {
+  const table = (0, import_schema_utils2.convertMeshToArrowTableWrapper)(mesh);
+  if (options?.pcd?.shape === "mesh") {
+    return convertPCDTableToMesh(table, mesh);
+  }
+  return (0, import_loader_utils.makeTableScanBatch)({
+    ...table,
+    loader: mesh.loader,
+    loaderData: mesh.loaderData
+  });
+}
+function convertPCDTableToMesh(table, sourceMesh) {
+  return {
+    ...(0, import_schema_utils2.convertTableToMesh)(table),
+    loader: sourceMesh.loader,
+    loaderData: sourceMesh.loaderData
+  };
+}
+function makePCDHeaderText(pcdHeader, pointCount) {
+  const lines = pcdHeader.str.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => {
+    if (/^WIDTH\s+/i.test(line)) {
+      return `WIDTH ${pointCount}`;
+    }
+    if (/^HEIGHT\s+/i.test(line)) {
+      return "HEIGHT 1";
+    }
+    if (/^POINTS\s+/i.test(line)) {
+      return `POINTS ${pointCount}`;
+    }
+    return line;
+  });
+  if (!lines.some((line) => /^POINTS\s+/i.test(line))) {
+    const dataLineIndex = lines.findIndex((line) => /^DATA\s+/i.test(line));
+    lines.splice(dataLineIndex >= 0 ? dataLineIndex : lines.length, 0, `POINTS ${pointCount}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function deserializePCDWorkerResult(result, options) {
+  const table = (0, import_arrow_worker_transport.deserializeArrowWorkerTable)(result);
+  return options?.pcd?.shape === "mesh" ? convertPCDTableToMesh(table, table) : table;
+}
+function deserializePCDWorkerBatch(result, options) {
+  return deserializePCDWorkerResult(result, options);
+}
+async function* parsePCDWithMetadataInBatches(arrayBuffer, options) {
+  const batchSize = getNumericBatchSize(options);
+  const data = await (0, import_loader_utils.concatenateArrayBuffersAsync)(arrayBuffer);
+  const textData = new TextDecoder().decode(data);
+  const pcdHeader = (0, import_parse_pcd.parsePCDHeader)(textData);
+  if (pcdHeader.data === "ascii") {
+    yield* parsePCDASCIIInBatches(data, options, batchSize);
+    return;
+  }
+  if (pcdHeader.data === "binary") {
+    yield* parsePCDBinaryInBatches(data, options, batchSize);
+    return;
+  }
+  yield makePCDBatch((0, import_parse_pcd.parsePCD)(data, options), options);
+}
+var PCDLoaderWithParser = {
+  ...PCDColumnLoader,
+  dataType: import_pcd_loader_types.PCDLoader.dataType,
+  batchType: import_pcd_loader_types.PCDLoader.batchType,
+  parse: async (input, options) => unwrapPCDTable(await PCDColumnLoader.parse(input, options)),
+  parseSync: (input, options) => unwrapPCDTable(PCDColumnLoader.parseSync(input, options)),
+  async *parseInBatches(input, options) {
+    for await (const batch of PCDColumnLoader.parseInBatches(input, options)) {
+      if (isColumnBatch(batch)) {
+        batch.data.schema.metadata.set(
+          "loaders.gl.pcd.header",
+          JSON.stringify(batch.loaderData)
+        );
+        for (const recordBatch of batch.data.batches) {
+          recordBatch.schema.metadata.set(
+            "loaders.gl.pcd.header",
+            batch.data.schema.metadata.get("loaders.gl.pcd.header")
+          );
+        }
+        if (batch.data.batches.length) yield* batch.data.batches;
+        else yield (0, import_schema_utils.makeArrowMetadataBatch)(batch.data.schema);
+      } else yield batch;
+    }
+  },
+  deserializeWorkerResult: (result, options) => unwrapPCDTable(PCDColumnLoader.deserializeWorkerResult(result, options)),
+  deserializeWorkerBatch(result, options) {
+    const batch = PCDColumnLoader.deserializeWorkerBatch(result, options);
+    if (isColumnBatch(batch)) {
+      const recordBatch = batch.data.batches[0] ?? (0, import_schema_utils.makeArrowMetadataBatch)(batch.data.schema);
+      recordBatch.schema.metadata.set(
+        "loaders.gl.pcd.header",
+        JSON.stringify(batch.loaderData)
+      );
+      return recordBatch;
+    }
+    return batch;
+  }
+};
+function unwrapPCDTable(result) {
+  if ("shape" in result && result.shape === "arrow-table") {
+    result.data.schema.metadata.set(
+      "loaders.gl.pcd.header",
+      JSON.stringify(result.loaderData)
+    );
+    return result.data;
+  }
+  return result;
+}
+function isColumnBatch(batch) {
+  return "shape" in batch && batch.shape === "arrow-table";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PCDColumnLoader,
+  PCDLoaderWithParser
+});
+//# sourceMappingURL=pcd-loader.cjs.map

package/dist/pcd-loader.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/pcd-loader.ts", "../src/pcd/pcd-loader.ts"],
+  "sourcesContent": ["export * from './pcd/pcd-loader.js';\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport {refineArrowTableBatches, makeArrowMetadataBatch} from '@loaders.gl/core/schema-utils';\nimport type {Table, RecordBatch} from 'apache-arrow';\nimport type {PCDLoaderOptions} from './pcd-loader-types';\n\nimport {\n  concatenateArrayBuffersAsync,\n  makeTableScanBatch,\n  type LoaderWithParser\n} from '@loaders.gl/core/loader-utils';\nimport type {ArrowTableBatch, MeshArrowTable} from '@loaders.gl/core/schema';\nimport {\n  deserializeArrowWorkerTable,\n  serializeArrowWorkerTable\n} from '@loaders.gl/core/arrow-worker-transport';\nimport {convertMeshToArrowTableWrapper, convertTableToMesh} from '@loaders.gl/core/schema-utils';\nimport type {PCDMesh} from './lib/pcd-types';\nimport {parsePCD, parsePCDHeader} from './lib/parse-pcd';\nimport {PCDLoader as PCDLoaderMetadata} from './pcd-loader-types';\n\nconst {preload: _PCDLoaderPreload, ...PCDLoaderMetadataWithoutPreload} = PCDLoaderMetadata;\n\ntype PCDParsedBatch = PCDMesh | ArrowTableBatch;\n\nfunction convertPCDMesh(mesh: PCDMesh, options?: PCDLoaderOptions): PCDMesh | MeshArrowTable {\n  const table = convertMeshToArrowTableWrapper(mesh);\n  return options?.pcd?.shape === 'mesh'\n    ? convertPCDTableToMesh(table, mesh)\n    : {...table, loader: mesh.loader, loaderData: mesh.loaderData};\n}\n\n/**\n * Loader for PCD - Point Cloud Data\n */\nexport const PCDColumnLoader = {\n  ...PCDLoaderMetadataWithoutPreload,\n  dataType: null as unknown as PCDMesh | MeshArrowTable,\n  batchType: null as unknown as PCDMesh | ArrowTableBatch,\n  parse: async (arrayBuffer, options) => convertPCDMesh(parsePCD(arrayBuffer, options), options),\n  parseSync: (arrayBuffer, options) => convertPCDMesh(parsePCD(arrayBuffer, options), options),\n  parseInBatches: (input, options) =>\n    refineArrowTableBatches(parsePCDWithMetadataInBatches(input, options)),\n  serializeWorkerResult: serializeArrowWorkerTable,\n  deserializeWorkerResult: deserializePCDWorkerResult,\n  serializeWorkerBatch: serializeArrowWorkerTable,\n  deserializeWorkerBatch: deserializePCDWorkerBatch\n} as const satisfies LoaderWithParser<PCDMesh | MeshArrowTable, PCDParsedBatch, PCDLoaderOptions>;\n\n/** Returns a numeric batch size when batching has an explicit row count. */\nfunction getNumericBatchSize(options?: PCDLoaderOptions): number | undefined {\n  const batchSize = options?.core?.batchSize;\n  return typeof batchSize === 'number' ? batchSize : undefined;\n}\n\nfunction* parsePCDASCIIInBatches(\n  data: ArrayBuffer,\n  options?: PCDLoaderOptions,\n  batchSize?: number\n): Iterable<PCDParsedBatch> {\n  const textData = new TextDecoder().decode(data);\n  const pcdHeader = parsePCDHeader(textData);\n  const lines = textData\n    .slice(pcdHeader.headerLen)\n    .split(/\\r?\\n/)\n    .filter(line => line.trim().length > 0);\n  const normalizedBatchSize = batchSize || lines.length || 1;\n\n  for (let rowIndex = 0; rowIndex < lines.length; rowIndex += normalizedBatchSize) {\n    const batchLines = lines.slice(rowIndex, rowIndex + normalizedBatchSize);\n    const batchText = `${makePCDHeaderText(pcdHeader, batchLines.length)}${batchLines.join('\\n')}\\n`;\n    yield makePCDBatch(parsePCD(new TextEncoder().encode(batchText).buffer, options), options);\n  }\n}\n\nfunction* parsePCDBinaryInBatches(\n  data: ArrayBuffer,\n  options?: PCDLoaderOptions,\n  batchSize?: number\n): Iterable<PCDParsedBatch> {\n  const textData = new TextDecoder().decode(data);\n  const pcdHeader = parsePCDHeader(textData);\n  const normalizedBatchSize = batchSize || pcdHeader.points || 1;\n  const dataBytes = new Uint8Array(data);\n\n  for (let pointIndex = 0; pointIndex < pcdHeader.points; pointIndex += normalizedBatchSize) {\n    const pointCount = Math.min(normalizedBatchSize, pcdHeader.points - pointIndex);\n    const headerBytes = new TextEncoder().encode(makePCDHeaderText(pcdHeader, pointCount));\n    const rowByteOffset = pcdHeader.headerLen + pointIndex * pcdHeader.rowSize;\n    const rowByteLength = pointCount * pcdHeader.rowSize;\n    const batchBytes = new Uint8Array(headerBytes.length + rowByteLength);\n    batchBytes.set(headerBytes, 0);\n    batchBytes.set(\n      dataBytes.subarray(rowByteOffset, rowByteOffset + rowByteLength),\n      headerBytes.length\n    );\n    yield makePCDBatch(parsePCD(batchBytes.buffer, options), options);\n  }\n}\n\nfunction makePCDBatch(mesh: PCDMesh, options?: PCDLoaderOptions): PCDParsedBatch {\n  const table = convertMeshToArrowTableWrapper(mesh);\n  if (options?.pcd?.shape === 'mesh') {\n    return convertPCDTableToMesh(table, mesh);\n  }\n\n  return makeTableScanBatch({\n    ...table,\n    loader: mesh.loader,\n    loaderData: mesh.loaderData\n  } as MeshArrowTable);\n}\n\n/** Convert the parser's Arrow table to legacy PCD mesh output. */\nfunction convertPCDTableToMesh(table: MeshArrowTable, sourceMesh: PCDMesh): PCDMesh {\n  return {\n    ...(convertTableToMesh(table) as PCDMesh),\n    loader: sourceMesh.loader,\n    loaderData: sourceMesh.loaderData\n  };\n}\n\nfunction makePCDHeaderText(pcdHeader: any, pointCount: number): string {\n  const lines = pcdHeader.str\n    .split(/\\r?\\n/)\n    .filter(line => line.trim().length > 0)\n    .map(line => {\n      if (/^WIDTH\\s+/i.test(line)) {\n        return `WIDTH ${pointCount}`;\n      }\n      if (/^HEIGHT\\s+/i.test(line)) {\n        return 'HEIGHT 1';\n      }\n      if (/^POINTS\\s+/i.test(line)) {\n        return `POINTS ${pointCount}`;\n      }\n      return line;\n    });\n\n  if (!lines.some(line => /^POINTS\\s+/i.test(line))) {\n    const dataLineIndex = lines.findIndex(line => /^DATA\\s+/i.test(line));\n    lines.splice(dataLineIndex >= 0 ? dataLineIndex : lines.length, 0, `POINTS ${pointCount}`);\n  }\n\n  return `${lines.join('\\n')}\\n`;\n}\n\n/** Hydrates worker columns before reconstructing legacy PCD meshes on the caller. */\nfunction deserializePCDWorkerResult(\n  result: unknown,\n  options?: PCDLoaderOptions\n): PCDMesh | MeshArrowTable {\n  const table = deserializeArrowWorkerTable(result);\n  return options?.pcd?.shape === 'mesh' ? convertPCDTableToMesh(table, table) : table;\n}\n\n/** Restores the existing PCD batch shape after caller-side hydration. */\nfunction deserializePCDWorkerBatch(result: unknown, options?: PCDLoaderOptions): PCDParsedBatch {\n  return deserializePCDWorkerResult(result, options) as PCDParsedBatch;\n}\n\n/** Parses PCD batches before shared cumulative metadata refinement. */\nasync function* parsePCDWithMetadataInBatches(\n  arrayBuffer:\n    | AsyncIterable<ArrayBufferLike | ArrayBufferView>\n    | Iterable<ArrayBufferLike | ArrayBufferView>,\n  options?: PCDLoaderOptions\n): AsyncIterable<PCDParsedBatch> {\n  const batchSize = getNumericBatchSize(options);\n  const data = await concatenateArrayBuffersAsync(arrayBuffer);\n  const textData = new TextDecoder().decode(data);\n  const pcdHeader = parsePCDHeader(textData);\n\n  if (pcdHeader.data === 'ascii') {\n    yield* parsePCDASCIIInBatches(data, options, batchSize);\n    return;\n  }\n\n  if (pcdHeader.data === 'binary') {\n    yield* parsePCDBinaryInBatches(data, options, batchSize);\n    return;\n  }\n\n  yield makePCDBatch(parsePCD(data, options), options);\n}\n\n/** Exposes native Arrow output while retaining the worker's column protocol. */\nexport const PCDLoaderWithParser = {\n  ...PCDColumnLoader,\n  dataType: PCDLoaderMetadata.dataType,\n  batchType: PCDLoaderMetadata.batchType,\n  parse: async (input: ArrayBuffer, options?: PCDLoaderOptions) =>\n    unwrapPCDTable(await PCDColumnLoader.parse(input, options)),\n  parseSync: (input: ArrayBuffer, options?: PCDLoaderOptions) =>\n    unwrapPCDTable(PCDColumnLoader.parseSync(input, options)),\n  async *parseInBatches(input, options) {\n    for await (const batch of PCDColumnLoader.parseInBatches(input, options)) {\n      if (isColumnBatch(batch)) {\n        batch.data.schema.metadata.set(\n          'loaders.gl.pcd.header',\n          JSON.stringify((batch as ArrowTableBatch & {loaderData?: unknown}).loaderData)\n        );\n        for (const recordBatch of batch.data.batches) {\n          recordBatch.schema.metadata.set(\n            'loaders.gl.pcd.header',\n            batch.data.schema.metadata.get('loaders.gl.pcd.header')!\n          );\n        }\n        if (batch.data.batches.length) yield* batch.data.batches;\n        else yield makeArrowMetadataBatch(batch.data.schema);\n      } else yield batch;\n    }\n  },\n  deserializeWorkerResult: (result: unknown, options?: PCDLoaderOptions) =>\n    unwrapPCDTable(PCDColumnLoader.deserializeWorkerResult(result, options)),\n  deserializeWorkerBatch(result: unknown, options?: PCDLoaderOptions) {\n    const batch = PCDColumnLoader.deserializeWorkerBatch(result, options);\n    if (isColumnBatch(batch)) {\n      const recordBatch = batch.data.batches[0] ?? makeArrowMetadataBatch(batch.data.schema);\n      recordBatch.schema.metadata.set(\n        'loaders.gl.pcd.header',\n        JSON.stringify((batch as ArrowTableBatch & {loaderData?: unknown}).loaderData)\n      );\n      return recordBatch;\n    }\n    return batch;\n  }\n} as const satisfies LoaderWithParser<PCDMesh | Table, PCDMesh | RecordBatch, PCDLoaderOptions>;\n\n/** Returns the Arrow table with its file metadata or the requested mesh. */\nfunction unwrapPCDTable(result: PCDMesh | MeshArrowTable): PCDMesh | Table {\n  if ('shape' in result && result.shape === 'arrow-table') {\n    result.data.schema.metadata.set(\n      'loaders.gl.pcd.header',\n      JSON.stringify((result as MeshArrowTable & {loaderData?: unknown}).loaderData)\n    );\n    return result.data;\n  }\n  return result as PCDMesh;\n}\n\n/** Identifies the private Arrow batch envelope. */\nfunction isColumnBatch(batch: PCDMesh | ArrowTableBatch): batch is ArrowTableBatch {\n  return 'shape' in batch && batch.shape === 'arrow-table';\n}\n"],
+  "mappings": "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",
+  "names": ["import_schema_utils", "PCDLoaderMetadata"]
+}

package/dist/pcd-loader.d.ts

@@ -0,0 +1,2 @@
+export * from './pcd/pcd-loader.js';
+//# sourceMappingURL=pcd-loader.d.ts.map

package/dist/pcd-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcd-loader.d.ts","sourceRoot":"","sources":["../src/pcd-loader.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/pcd-loader.js

@@ -0,0 +1,2 @@
+export * from './pcd/pcd-loader.js';
+//# sourceMappingURL=pcd-loader.js.map

package/dist/pcd-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcd-loader.js","sourceRoot":"","sources":["../src/pcd-loader.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}