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

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

@@ -0,0 +1,105 @@
+import type { LoaderOptions } from '@loaders.gl/core/loader-utils';
+import type { MeshArrowTable, ArrowTableBatch } from '@loaders.gl/core/schema';
+import type { PCDMesh } from "./lib/pcd-types.js";
+import { serializeArrowWorkerTable } from '@loaders.gl/core/schema-utils/arrow-transport';
+export type PCDLoaderOptions = LoaderOptions & {
+    pcd?: {
+        /** Output shape. Defaults to a Mesh Arrow table. */
+        shape?: 'mesh' | 'arrow-table';
+        /** Color storage format. Defaults to uint8norm for backwards compatibility. */
+        colorFormat?: 'uint8norm' | 'float16' | 'float32';
+        /** Override the URL to the worker bundle (by default loads from unpkg.com) */
+        workerUrl?: string;
+    };
+};
+/**
+ * Preloads the parser-bearing PCD loader implementation.
+ */
+declare function preload(): Promise<{
+    readonly parse: (arrayBuffer: ArrayBuffer, options: PCDLoaderOptions | undefined) => Promise<MeshArrowTable | PCDMesh>;
+    readonly parseSync: (arrayBuffer: ArrayBuffer, options: PCDLoaderOptions | undefined) => MeshArrowTable | PCDMesh;
+    readonly parseInBatches: (arrayBuffer: AsyncIterable<ArrayBufferLike | ArrayBufferView> | Iterable<ArrayBufferLike | ArrayBufferView>, options: PCDLoaderOptions | undefined) => AsyncIterable<PCDMesh | ArrowTableBatch>;
+    readonly serializeWorkerResult: typeof serializeArrowWorkerTable;
+    readonly deserializeWorkerResult: (result: unknown, options?: PCDLoaderOptions) => PCDMesh | MeshArrowTable;
+    readonly serializeWorkerBatch: typeof serializeArrowWorkerTable;
+    readonly deserializeWorkerBatch: (result: unknown, options?: PCDLoaderOptions) => PCDMesh | ArrowTableBatch;
+    readonly dataType: PCDMesh | MeshArrowTable;
+    readonly batchType: PCDMesh | ArrowTableBatch;
+    readonly version: any;
+    readonly worker: true;
+    readonly workerInBatches: true;
+    readonly options: {
+        readonly pcd: {
+            readonly shape: "arrow-table";
+            readonly colorFormat: "uint8norm";
+        };
+    };
+    readonly name: "PCD (Point Cloud Data)";
+    readonly id: "pcd";
+    readonly module: "pointclouds";
+    readonly encoding: "text";
+    readonly format: "pcd";
+    readonly extensions: ["pcd"];
+    readonly mimeTypes: ["text/plain"];
+    readonly category: "pointcloud";
+    readonly text: true;
+    readonly binary: true;
+}>;
+/**
+ * Metadata-only worker loader for PCD - Point Cloud Data
+ */
+export declare const PCDLoader: {
+    readonly dataType: PCDMesh | MeshArrowTable;
+    readonly batchType: PCDMesh | ArrowTableBatch;
+    readonly version: any;
+    readonly worker: true;
+    /** Enables the stateful input/output batch protocol on the built-in worker. */
+    readonly workerInBatches: true;
+    readonly serializeWorkerResult: typeof serializeArrowWorkerTable;
+    readonly options: {
+        readonly pcd: {
+            readonly shape: "arrow-table";
+            readonly colorFormat: "uint8norm";
+        };
+    };
+    readonly preload: typeof preload;
+    readonly name: "PCD (Point Cloud Data)";
+    readonly id: "pcd";
+    readonly module: "pointclouds";
+    readonly encoding: "text";
+    readonly format: "pcd";
+    readonly extensions: ["pcd"];
+    readonly mimeTypes: ["text/plain"];
+    readonly category: "pointcloud";
+    readonly text: true;
+    readonly binary: true;
+};
+/** @deprecated Use PCDLoader. */
+export declare const PCDWorkerLoader: {
+    readonly dataType: PCDMesh | MeshArrowTable;
+    readonly batchType: PCDMesh | ArrowTableBatch;
+    readonly version: any;
+    readonly worker: true;
+    /** Enables the stateful input/output batch protocol on the built-in worker. */
+    readonly workerInBatches: true;
+    readonly serializeWorkerResult: typeof serializeArrowWorkerTable;
+    readonly options: {
+        readonly pcd: {
+            readonly shape: "arrow-table";
+            readonly colorFormat: "uint8norm";
+        };
+    };
+    readonly preload: typeof preload;
+    readonly name: "PCD (Point Cloud Data)";
+    readonly id: "pcd";
+    readonly module: "pointclouds";
+    readonly encoding: "text";
+    readonly format: "pcd";
+    readonly extensions: ["pcd"];
+    readonly mimeTypes: ["text/plain"];
+    readonly category: "pointcloud";
+    readonly text: true;
+    readonly binary: true;
+};
+export {};
+//# sourceMappingURL=pcd-loader-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pcd-loader-types.d.ts","sourceRoot":"","sources":["../../src/pcd/pcd-loader-types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAS,aAAa,EAAC,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAC,cAAc,EAAE,eAAe,EAAC,MAAM,yBAAyB,CAAC;AAC7E,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAE7C,OAAO,EAAC,yBAAyB,EAAC,MAAM,+CAA+C,CAAC;AAMxF,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE;QACJ,oDAAoD;QACpD,KAAK,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC;QAC/B,+EAA+E;QAC/E,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;QAClD,8EAA8E;QAC9E,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,iBAAe,OAAO;;;;;;;;uBAUS,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,eAAe;;;;;;;;;;;;;;;;;;;;GARxD;AAED;;GAEG;AACH,eAAO,MAAM,SAAS;uBAES,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,eAAe;;;IAGvD,+EAA+E;;;;;;;;;;;;;;;;;;;;CAOiB,CAAC;AAEnG,iCAAiC;AACjC,eAAO,MAAM,eAAe;uBAdG,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,eAAe;;;IAGvD,+EAA+E;;;;;;;;;;;;;;;;;;;;CAUzC,CAAC"}

package/dist/pcd/pcd-loader-types.js

@@ -0,0 +1,35 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { PCDFormat } from "./pcd-format.js";
+import { serializeArrowWorkerTable } from '@loaders.gl/core/schema-utils/arrow-transport';
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof "5.0.0-beta.1" !== 'undefined' ? "5.0.0-beta.1" : 'latest';
+/**
+ * Preloads the parser-bearing PCD loader implementation.
+ */
+async function preload() {
+    const { PCDLoaderWithParser } = await import('@loaders.gl/pointclouds/pcd/pcd-loader');
+    return PCDLoaderWithParser;
+}
+/**
+ * Metadata-only worker loader for PCD - Point Cloud Data
+ */
+export const PCDLoader = {
+    ...PCDFormat,
+    dataType: null,
+    batchType: null,
+    version: VERSION,
+    worker: true,
+    /** Enables the stateful input/output batch protocol on the built-in worker. */
+    workerInBatches: true,
+    serializeWorkerResult: serializeArrowWorkerTable,
+    options: {
+        pcd: { shape: 'arrow-table', colorFormat: 'uint8norm' }
+    },
+    preload
+};
+/** @deprecated Use PCDLoader. */
+export const PCDWorkerLoader = PCDLoader;
+//# sourceMappingURL=pcd-loader-types.js.map

package/dist/pcd/pcd-loader-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcd-loader-types.js","sourceRoot":"","sources":["../../src/pcd/pcd-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,SAAS,EAAC,wBAAqB;AACvC,OAAO,EAAC,yBAAyB,EAAC,MAAM,+CAA+C,CAAC;AAExF,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,qBAAkB,KAAK,WAAW,CAAC,CAAC,gBAAa,CAAC,CAAC,QAAQ,CAAC;AAa5E;;GAEG;AACH,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,mBAAmB,EAAC,GAAG,MAAM,MAAM,CAAC,wCAAwC,CAAC,CAAC;IACrF,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,GAAG,SAAS;IACZ,QAAQ,EAAE,IAA2C;IACrD,SAAS,EAAE,IAA4C;IACvD,OAAO,EAAE,OAAO;IAChB,MAAM,EAAE,IAAI;IACZ,+EAA+E;IAC/E,eAAe,EAAE,IAAI;IACrB,qBAAqB,EAAE,yBAAyB;IAChD,OAAO,EAAE;QACP,GAAG,EAAE,EAAC,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAC;KACtD;IACD,OAAO;CACyF,CAAC;AAEnG,iCAAiC;AACjC,MAAM,CAAC,MAAM,eAAe,GAAG,SAAS,CAAC"}

package/dist/pcd/pcd-loader.cjs

@@ -0,0 +1,144 @@
+"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/pcd-loader.ts
+var pcd_loader_exports = {};
+__export(pcd_loader_exports, {
+  PCDLoaderWithParser: () => PCDLoaderWithParser
+});
+module.exports = __toCommonJS(pcd_loader_exports);
+var import_loader_utils = require("@loaders.gl/core/loader-utils");
+var import_arrow_transport = require("@loaders.gl/core/schema-utils/arrow-transport");
+var import_schema_utils = 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_utils.convertMeshToTable)(mesh, "arrow-table");
+  return options?.pcd?.shape === "mesh" ? convertPCDTableToMesh(table, mesh) : { ...table, loader: mesh.loader, loaderData: mesh.loaderData };
+}
+var PCDLoaderWithParser = {
+  ...PCDLoaderMetadataWithoutPreload,
+  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: async function* (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);
+  },
+  serializeWorkerResult: import_arrow_transport.serializeArrowWorkerTable,
+  deserializeWorkerResult: deserializePCDWorkerResult,
+  serializeWorkerBatch: import_arrow_transport.serializeArrowWorkerTable,
+  deserializeWorkerBatch: deserializePCDWorkerBatch
+};
+function getNumericBatchSize(options) {
+  const batchSize = options?.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_utils.convertMeshToTable)(mesh, "arrow-table");
+  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_utils.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_transport.deserializeArrowWorkerTable)(result);
+  return options?.pcd?.shape === "mesh" ? convertPCDTableToMesh(table, table) : table;
+}
+function deserializePCDWorkerBatch(result, options) {
+  return deserializePCDWorkerResult(result, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PCDLoaderWithParser
+});
+//# sourceMappingURL=pcd-loader.cjs.map

package/dist/pcd/pcd-loader.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/pcd/pcd-loader.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\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/schema-utils/arrow-transport';\nimport {convertMeshToTable, 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 = convertMeshToTable(mesh, 'arrow-table');\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 PCDLoaderWithParser = {\n  ...PCDLoaderMetadataWithoutPreload,\n  parse: async (arrayBuffer, options) => convertPCDMesh(parsePCD(arrayBuffer, options), options),\n  parseSync: (arrayBuffer, options) => convertPCDMesh(parsePCD(arrayBuffer, options), options),\n  parseInBatches: async function* (\n    arrayBuffer:\n      | AsyncIterable<ArrayBufferLike | ArrayBufferView>\n      | Iterable<ArrayBufferLike | ArrayBufferView>,\n    options\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  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?.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 = convertMeshToTable(mesh, 'arrow-table');\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"],
+  "mappings": "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",
+  "names": ["PCDLoaderMetadata"]
+}

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

@@ -0,0 +1,44 @@
+import type { PCDLoaderOptions } from "./pcd-loader-types.js";
+import type { ArrowTableBatch, MeshArrowTable } from '@loaders.gl/core/schema';
+import { serializeArrowWorkerTable } from '@loaders.gl/core/schema-utils/arrow-transport';
+import type { PCDMesh } from "./lib/pcd-types.js";
+type PCDParsedBatch = PCDMesh | ArrowTableBatch;
+/**
+ * Loader for PCD - Point Cloud Data
+ */
+export declare const PCDLoaderWithParser: {
+    readonly parse: (arrayBuffer: ArrayBuffer, options: PCDLoaderOptions | undefined) => Promise<MeshArrowTable | PCDMesh>;
+    readonly parseSync: (arrayBuffer: ArrayBuffer, options: PCDLoaderOptions | undefined) => MeshArrowTable | PCDMesh;
+    readonly parseInBatches: (arrayBuffer: AsyncIterable<ArrayBufferLike | ArrayBufferView> | Iterable<ArrayBufferLike | ArrayBufferView>, options: PCDLoaderOptions | undefined) => AsyncIterable<PCDParsedBatch>;
+    readonly serializeWorkerResult: typeof serializeArrowWorkerTable;
+    readonly deserializeWorkerResult: typeof deserializePCDWorkerResult;
+    readonly serializeWorkerBatch: typeof serializeArrowWorkerTable;
+    readonly deserializeWorkerBatch: typeof deserializePCDWorkerBatch;
+    readonly dataType: PCDMesh | MeshArrowTable;
+    readonly batchType: PCDMesh | ArrowTableBatch;
+    readonly version: any;
+    readonly worker: true;
+    readonly workerInBatches: true;
+    readonly options: {
+        readonly pcd: {
+            readonly shape: "arrow-table";
+            readonly colorFormat: "uint8norm";
+        };
+    };
+    readonly name: "PCD (Point Cloud Data)";
+    readonly id: "pcd";
+    readonly module: "pointclouds";
+    readonly encoding: "text";
+    readonly format: "pcd";
+    readonly extensions: ["pcd"];
+    readonly mimeTypes: ["text/plain"];
+    readonly category: "pointcloud";
+    readonly text: true;
+    readonly binary: true;
+};
+/** Hydrates worker columns before reconstructing legacy PCD meshes on the caller. */
+declare function deserializePCDWorkerResult(result: unknown, options?: PCDLoaderOptions): PCDMesh | MeshArrowTable;
+/** Restores the existing PCD batch shape after caller-side hydration. */
+declare function deserializePCDWorkerBatch(result: unknown, options?: PCDLoaderOptions): PCDParsedBatch;
+export {};
+//# sourceMappingURL=pcd-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pcd-loader.d.ts","sourceRoot":"","sources":["../../src/pcd/pcd-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,gBAAgB,EAAC,8BAA2B;AAOzD,OAAO,KAAK,EAAC,eAAe,EAAE,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EAEL,yBAAyB,EAC1B,MAAM,+CAA+C,CAAC;AAEvD,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAM7C,KAAK,cAAc,GAAG,OAAO,GAAG,eAAe,CAAC;AAShD;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;2CAMxB,aAAa,CAAC,eAAe,GAAG,eAAe,CAAC,GAChD,QAAQ,CAAC,eAAe,GAAG,eAAe,CAAC,4CAE9C,aAAa,CAAC,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CAsB+D,CAAC;AAoGlG,qFAAqF;AACrF,iBAAS,0BAA0B,CACjC,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,GAAG,cAAc,CAG1B;AAED,yEAAyE;AACzE,iBAAS,yBAAyB,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,cAAc,CAE9F"}

package/dist/pcd/pcd-loader.js

@@ -0,0 +1,128 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { concatenateArrayBuffersAsync, makeTableScanBatch } from '@loaders.gl/core/loader-utils';
+import { deserializeArrowWorkerTable, serializeArrowWorkerTable } from '@loaders.gl/core/schema-utils/arrow-transport';
+import { convertMeshToTable, convertTableToMesh } from '@loaders.gl/core/schema-utils';
+import { parsePCD, parsePCDHeader } from "./lib/parse-pcd.js";
+import { PCDLoader as PCDLoaderMetadata } from "./pcd-loader-types.js";
+const { preload: _PCDLoaderPreload, ...PCDLoaderMetadataWithoutPreload } = PCDLoaderMetadata;
+function convertPCDMesh(mesh, options) {
+    const table = convertMeshToTable(mesh, 'arrow-table');
+    return options?.pcd?.shape === 'mesh'
+        ? convertPCDTableToMesh(table, mesh)
+        : { ...table, loader: mesh.loader, loaderData: mesh.loaderData };
+}
+/**
+ * Loader for PCD - Point Cloud Data
+ */
+export const PCDLoaderWithParser = {
+    ...PCDLoaderMetadataWithoutPreload,
+    parse: async (arrayBuffer, options) => convertPCDMesh(parsePCD(arrayBuffer, options), options),
+    parseSync: (arrayBuffer, options) => convertPCDMesh(parsePCD(arrayBuffer, options), options),
+    parseInBatches: async function* (arrayBuffer, options) {
+        const batchSize = getNumericBatchSize(options);
+        const data = await concatenateArrayBuffersAsync(arrayBuffer);
+        const textData = new TextDecoder().decode(data);
+        const pcdHeader = parsePCDHeader(textData);
+        if (pcdHeader.data === 'ascii') {
+            yield* parsePCDASCIIInBatches(data, options, batchSize);
+            return;
+        }
+        if (pcdHeader.data === 'binary') {
+            yield* parsePCDBinaryInBatches(data, options, batchSize);
+            return;
+        }
+        yield makePCDBatch(parsePCD(data, options), options);
+    },
+    serializeWorkerResult: serializeArrowWorkerTable,
+    deserializeWorkerResult: deserializePCDWorkerResult,
+    serializeWorkerBatch: serializeArrowWorkerTable,
+    deserializeWorkerBatch: deserializePCDWorkerBatch
+};
+/** Returns a numeric batch size when batching has an explicit row count. */
+function getNumericBatchSize(options) {
+    const batchSize = options?.batchSize ?? options?.core?.batchSize;
+    return typeof batchSize === 'number' ? batchSize : undefined;
+}
+function* parsePCDASCIIInBatches(data, options, batchSize) {
+    const textData = new TextDecoder().decode(data);
+    const pcdHeader = 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')}\n`;
+        yield makePCDBatch(parsePCD(new TextEncoder().encode(batchText).buffer, options), options);
+    }
+}
+function* parsePCDBinaryInBatches(data, options, batchSize) {
+    const textData = new TextDecoder().decode(data);
+    const pcdHeader = 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(parsePCD(batchBytes.buffer, options), options);
+    }
+}
+function makePCDBatch(mesh, options) {
+    const table = convertMeshToTable(mesh, 'arrow-table');
+    if (options?.pcd?.shape === 'mesh') {
+        return convertPCDTableToMesh(table, mesh);
+    }
+    return makeTableScanBatch({
+        ...table,
+        loader: mesh.loader,
+        loaderData: mesh.loaderData
+    });
+}
+/** Convert the parser's Arrow table to legacy PCD mesh output. */
+function convertPCDTableToMesh(table, sourceMesh) {
+    return {
+        ...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')}\n`;
+}
+/** Hydrates worker columns before reconstructing legacy PCD meshes on the caller. */
+function deserializePCDWorkerResult(result, options) {
+    const table = deserializeArrowWorkerTable(result);
+    return options?.pcd?.shape === 'mesh' ? convertPCDTableToMesh(table, table) : table;
+}
+/** Restores the existing PCD batch shape after caller-side hydration. */
+function deserializePCDWorkerBatch(result, options) {
+    return deserializePCDWorkerResult(result, options);
+}
+//# sourceMappingURL=pcd-loader.js.map

package/dist/pcd/pcd-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcd-loader.js","sourceRoot":"","sources":["../../src/pcd/pcd-loader.ts"],"names":[],"mappings":"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"}

package/dist/pcd/pcd-writer.cjs

@@ -0,0 +1,134 @@
+"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/pcd-writer.ts
+var pcd_writer_exports = {};
+__export(pcd_writer_exports, {
+  PCDWriter: () => PCDWriter
+});
+module.exports = __toCommonJS(pcd_writer_exports);
+var import_schema_utils = require("@loaders.gl/core/schema-utils");
+var import_pcd_format = require("./pcd-format.cjs");
+var VERSION = true ? "5.0.0-beta.1" : "latest";
+var PCDWriter = {
+  ...import_pcd_format.PCDFormat,
+  dataType: null,
+  batchType: null,
+  version: VERSION,
+  options: {
+    pcd: {}
+  },
+  text: true,
+  encode: async (data, options) => encodePCDSync(data, options),
+  encodeSync: encodePCDSync,
+  encodeTextSync: encodePCD
+};
+function encodePCDSync(data, options) {
+  const text = encodePCD(data, options);
+  return new TextEncoder().encode(text).buffer;
+}
+function encodePCD(data, options) {
+  const mesh = (0, import_schema_utils.convertTableToMesh)(normalizeMeshArrowTable(data));
+  const positionAttribute = getRequiredAttribute(mesh, "POSITION");
+  const normalAttribute = mesh.attributes.NORMAL;
+  const colorAttribute = mesh.attributes.COLOR_0;
+  const vertexCount = positionAttribute.value.length / positionAttribute.size;
+  const fieldNames = ["x", "y", "z"];
+  const fieldSizes = ["4", "4", "4"];
+  const fieldTypes = ["F", "F", "F"];
+  const fieldCounts = ["1", "1", "1"];
+  if (normalAttribute) {
+    fieldNames.push("normal_x", "normal_y", "normal_z");
+    fieldSizes.push("4", "4", "4");
+    fieldTypes.push("F", "F", "F");
+    fieldCounts.push("1", "1", "1");
+  }
+  if (colorAttribute) {
+    fieldNames.push("rgb");
+    fieldSizes.push("4");
+    fieldTypes.push("F");
+    fieldCounts.push("1");
+  }
+  const lines = [
+    "# .PCD v0.7 - Point Cloud Data file generated by loaders.gl",
+    "VERSION 0.7",
+    `FIELDS ${fieldNames.join(" ")}`,
+    `SIZE ${fieldSizes.join(" ")}`,
+    `TYPE ${fieldTypes.join(" ")}`,
+    `COUNT ${fieldCounts.join(" ")}`,
+    `WIDTH ${vertexCount}`,
+    "HEIGHT 1",
+    "VIEWPOINT 0 0 0 1 0 0 0",
+    `POINTS ${vertexCount}`,
+    "DATA ascii"
+  ];
+  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 (colorAttribute) {
+      row.push(getPackedRGB(colorAttribute, vertexIndex));
+    }
+    lines.push(row.join(" "));
+  }
+  return `${lines.join("\n")}
+`;
+}
+function normalizeMeshArrowTable(data) {
+  if ("shape" in data && data.shape === "arrow-table") {
+    return data;
+  }
+  return (0, import_schema_utils.convertMeshToTable)(data, "arrow-table");
+}
+function getRequiredAttribute(mesh, attributeName) {
+  const attribute = mesh.attributes[attributeName];
+  if (!attribute) {
+    throw new Error(`PCDWriter: ${attributeName} attribute is required`);
+  }
+  return attribute;
+}
+function getComponent(attribute, vertexIndex, componentIndex) {
+  return attribute.value[vertexIndex * attribute.size + componentIndex] || 0;
+}
+function getPackedRGB(attribute, vertexIndex) {
+  const bytes = new Uint8Array(4);
+  bytes[0] = getColorByte(attribute, vertexIndex, 0);
+  bytes[1] = getColorByte(attribute, vertexIndex, 1);
+  bytes[2] = getColorByte(attribute, vertexIndex, 2);
+  return new DataView(bytes.buffer).getFloat32(0, true);
+}
+function getColorByte(attribute, vertexIndex, componentIndex) {
+  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)));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PCDWriter
+});
+//# sourceMappingURL=pcd-writer.cjs.map