@loaders.gl/pcd 4.3.1 → 4.4.0-alpha.1

package/dist/pcd-loader.d.ts

@@ -1,5 +1,6 @@
 import type { LoaderOptions } from '@loaders.gl/loader-utils';
-import { PCDMesh } from "./lib/pcd-types.js";
+import type { PCDMesh } from "./lib/pcd-types.js";
+import { parsePCD } from "./lib/parse-pcd.js";
 export type PCDLoaderOptions = LoaderOptions & {
     pcd?: {
         /** Override the URL to the worker bundle (by default loads from unpkg.com) */
@@ -9,18 +10,43 @@ export type PCDLoaderOptions = LoaderOptions & {
 /**
  * Worker loader for PCD - Point Cloud Data
  */
-export declare const PCDLoader: {
+export declare const PCDWorkerLoader: {
     readonly dataType: PCDMesh;
     readonly batchType: never;
+    readonly version: any;
+    readonly worker: true;
+    readonly options: {
+        readonly pcd: {};
+    };
     readonly name: "PCD (Point Cloud Data)";
     readonly id: "pcd";
     readonly module: "pcd";
-    readonly version: any;
-    readonly worker: true;
     readonly extensions: ["pcd"];
     readonly mimeTypes: ["text/plain"];
+    readonly category: "pointcloud";
+    readonly text: true;
+    readonly binary: true;
+};
+/**
+ * Loader for PCD - Point Cloud Data
+ */
+export declare const PCDLoader: {
+    readonly parse: (arrayBuffer: ArrayBuffer) => Promise<PCDMesh>;
+    readonly parseSync: typeof parsePCD;
+    readonly dataType: PCDMesh;
+    readonly batchType: never;
+    readonly version: any;
+    readonly worker: true;
     readonly options: {
         readonly pcd: {};
     };
+    readonly name: "PCD (Point Cloud Data)";
+    readonly id: "pcd";
+    readonly module: "pcd";
+    readonly extensions: ["pcd"];
+    readonly mimeTypes: ["text/plain"];
+    readonly category: "pointcloud";
+    readonly text: true;
+    readonly binary: true;
 };
 //# sourceMappingURL=pcd-loader.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pcd-loader.d.ts","sourceRoot":"","sources":["../src/pcd-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAS,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAC,OAAO,EAAC,2BAAwB;AAMxC,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE;QACJ,8EAA8E;QAC9E,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS;uBACS,OAAO;wBACjB,KAAK;;;;;;;;;;;CAYmC,CAAC"}
+{"version":3,"file":"pcd-loader.d.ts","sourceRoot":"","sources":["../src/pcd-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAS,aAAa,EAAmB,MAAM,0BAA0B,CAAC;AACtF,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAC7C,OAAO,EAAC,QAAQ,EAAC,2BAAwB;AAOzC,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE;QACJ,8EAA8E;QAC9E,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe;uBAEG,OAAO;wBACjB,KAAK;;;;;;;;;;;;;;CAMmC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,SAAS;;;uBAZS,OAAO;wBACjB,KAAK;;;;;;;;;;;;;;CAe0C,CAAC"}

package/dist/pcd-loader.js

@@ -1,23 +1,29 @@
 // loaders.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
+import { parsePCD } from "./lib/parse-pcd.js";
+import { PCDFormat } from "./pcd-format.js";
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "4.3.0" !== 'undefined' ? "4.3.0" : 'latest';
+const VERSION = typeof "4.4.0-alpha.0" !== 'undefined' ? "4.4.0-alpha.0" : 'latest';
 /**
  * Worker loader for PCD - Point Cloud Data
  */
-export const PCDLoader = {
+export const PCDWorkerLoader = {
+    ...PCDFormat,
     dataType: null,
     batchType: null,
-    name: 'PCD (Point Cloud Data)',
-    id: 'pcd',
-    module: 'pcd',
     version: VERSION,
     worker: true,
-    extensions: ['pcd'],
-    mimeTypes: ['text/plain'],
     options: {
         pcd: {}
     }
 };
+/**
+ * Loader for PCD - Point Cloud Data
+ */
+export const PCDLoader = {
+    ...PCDWorkerLoader,
+    parse: async (arrayBuffer) => parsePCD(arrayBuffer),
+    parseSync: parsePCD
+};

package/dist/pcd-worker.js

@@ -199,7 +199,7 @@
     return await parser(data, { ...options }, context, loader);
   }
 
-  // ../schema/src/lib/mesh/mesh-utils.ts
+  // ../schema-utils/src/lib/mesh/mesh-utils.ts
   function getMeshBoundingBox(attributes) {
     let minX = Infinity;
     let minY = Infinity;
@@ -280,25 +280,38 @@
 
   // src/lib/get-pcd-schema.ts
   function getPCDSchema(PCDheader, metadata) {
-    const offset = PCDheader.offset;
     const fields = [];
-    if (offset.x !== void 0) {
-      fields.push({
-        name: "POSITION",
-        type: { type: "fixed-size-list", listSize: 3, children: [{ name: "xyz", type: "float32" }] }
-      });
-    }
-    if (offset.normal_x !== void 0) {
-      fields.push({
-        name: "NORMAL",
-        type: { type: "fixed-size-list", listSize: 3, children: [{ name: "xyz", type: "float32" }] }
-      });
-    }
-    if (offset.rgb !== void 0) {
-      fields.push({
-        name: "COLOR_0",
-        type: { type: "fixed-size-list", listSize: 3, children: [{ name: "rgb", type: "uint8" }] }
-      });
+    for (const key of Object.keys(PCDheader.offset)) {
+      switch (key) {
+        case "x":
+          fields.push({
+            name: "POSITION",
+            type: { type: "fixed-size-list", listSize: 3, children: [{ name: "xyz", type: "float32" }] },
+            metadata: { attribute: "POSITION" }
+          });
+          break;
+        case "y":
+        case "z":
+          break;
+        case "normal_x":
+          fields.push({
+            name: "NORMAL",
+            type: { type: "fixed-size-list", listSize: 3, children: [{ name: "xyz", type: "float32" }] },
+            metadata: { attribute: "NORMAL" }
+          });
+          break;
+        case "normal_y":
+        case "normal_z":
+          break;
+        case "rgb":
+          fields.push({
+            name: "COLOR_0",
+            type: { type: "fixed-size-list", listSize: 3, children: [{ name: "rgb", type: "uint8" }] },
+            metadata: { attribute: "COLOR" }
+          });
+          break;
+        default:
+      }
     }
     return { fields, metadata };
   }
@@ -324,19 +337,20 @@
     }
     attributes = getMeshAttributes(attributes);
     const header = getMeshHeader(pcdHeader, attributes);
-    const metadata = Object.fromEntries([
+    const schemaMetadata = Object.fromEntries([
+      ["topology", "point-list"],
       ["mode", "0"],
       ["boundingBox", JSON.stringify(header.boundingBox)]
     ]);
-    const schema = getPCDSchema(pcdHeader, metadata);
+    const schema = getPCDSchema(pcdHeader, schemaMetadata);
     return {
       loader: "pcd",
       loaderData: pcdHeader,
       header,
       schema,
-      mode: 0,
-      // POINTS
       topology: "point-list",
+      mode: 0,
+      // POINTS (deprecated)
       attributes
     };
   }
@@ -617,32 +631,38 @@
     };
   }
 
-  // src/pcd-loader.ts
-  var VERSION = true ? "4.3.0" : "latest";
-  var PCDLoader = {
-    dataType: null,
-    batchType: null,
+  // src/pcd-format.ts
+  var PCDFormat = {
     name: "PCD (Point Cloud Data)",
     id: "pcd",
     module: "pcd",
-    version: VERSION,
-    worker: true,
     extensions: ["pcd"],
     mimeTypes: ["text/plain"],
+    category: "pointcloud",
+    text: true,
+    binary: true
+  };
+
+  // src/pcd-loader.ts
+  var VERSION = true ? "4.4.0-alpha.0" : "latest";
+  var PCDWorkerLoader = {
+    ...PCDFormat,
+    dataType: null,
+    batchType: null,
+    version: VERSION,
+    worker: true,
     options: {
       pcd: {}
     }
   };
-
-  // src/index.ts
-  var PCDLoader2 = {
-    ...PCDLoader,
+  var PCDLoader = {
+    ...PCDWorkerLoader,
     parse: async (arrayBuffer) => parsePCD(arrayBuffer),
     parseSync: parsePCD
   };
 
   // src/workers/pcd-worker.ts
-  createLoaderWorker(PCDLoader2);
+  createLoaderWorker(PCDLoader);
 })();
 /** Parse compressed PCD data in in binary_compressed form ( https://pointclouds.org/documentation/tutorials/pcd_file_format.html)
  * from https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/PCDLoader.js

package/dist/workers/pcd-worker.js

@@ -1,3 +1,6 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { createLoaderWorker } from '@loaders.gl/loader-utils';
 import { PCDLoader } from "../index.js";
 createLoaderWorker(PCDLoader);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/pcd",
-  "version": "4.3.1",
+  "version": "4.4.0-alpha.1",
   "description": "Framework-independent loader for the PCD format",
   "license": "MIT",
   "type": "module",
@@ -42,11 +42,12 @@
     "build-worker": "esbuild src/workers/pcd-worker.ts --bundle --outfile=dist/pcd-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/loader-utils": "4.3.1",
-    "@loaders.gl/schema": "4.3.1"
+    "@loaders.gl/loader-utils": "4.4.0-alpha.1",
+    "@loaders.gl/schema": "4.4.0-alpha.1",
+    "@loaders.gl/schema-utils": "4.4.0-alpha.1"
   },
   "peerDependencies": {
-    "@loaders.gl/core": "^4.3.0"
+    "@loaders.gl/core": "4.4.0-alpha.0"
   },
-  "gitHead": "70a883ab6bc84647c49963215dd6ff62d4d61de3"
+  "gitHead": "f1732de45907bd500bf4eedb4803beca8bf4bfb0"
 }

package/src/index.ts

@@ -2,20 +2,6 @@
 // SPDX-License-Identifier: MIT
 // Copyright vis.gl contributors
 
-import type {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';
-import parsePCDSync from './lib/parse-pcd';
-import {PCDLoader as PCDWorkerLoader} from './pcd-loader';
-import {PCDMesh} from './lib/pcd-types';
-
 export type {PCDLoaderOptions} from './pcd-loader';
-
-export {PCDWorkerLoader};
-
-/**
- * Loader for PCD - Point Cloud Data
- */
-export const PCDLoader = {
-  ...PCDWorkerLoader,
-  parse: async (arrayBuffer) => parsePCDSync(arrayBuffer),
-  parseSync: parsePCDSync
-} as const satisfies LoaderWithParser<PCDMesh, never, LoaderOptions>;
+export {PCDWorkerLoader, PCDLoader} from './pcd-loader';
+export {PCDArrowLoader} from './pcd-arrow-loader';

package/src/lib/decompress-lzf.ts

@@ -1,6 +1,10 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://gitlab.com/taketwo/three-pcd-loader/blob/master/decompress-lzf.js
+
 /* eslint-disable */
 /**
- * from https://gitlab.com/taketwo/three-pcd-loader/blob/master/decompress-lzf.js
  * @param inData
  * @param outLength
  * @returns

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

@@ -1,3 +1,7 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {Schema, Field} from '@loaders.gl/schema';
 import type {PCDHeader} from './pcd-types';
 
@@ -8,29 +12,45 @@ import type {PCDHeader} from './pcd-types';
  * @returns Schema
  */
 export function getPCDSchema(PCDheader: PCDHeader, metadata: Record<string, string>): Schema {
-  const offset = PCDheader.offset;
-
   const fields: Field[] = [];
 
-  if (offset.x !== undefined) {
-    fields.push({
-      name: 'POSITION',
-      type: {type: 'fixed-size-list', listSize: 3, children: [{name: 'xyz', type: 'float32'}]}
-    });
-  }
+  for (const key of Object.keys(PCDheader.offset)) {
+    switch (key) {
+      case 'x':
+        fields.push({
+          name: 'POSITION',
+          type: {type: 'fixed-size-list', listSize: 3, children: [{name: 'xyz', type: 'float32'}]},
+          metadata: {attribute: 'POSITION'}
+        });
+        break;
+      case 'y':
+      case 'z':
+        // ignore
+        break;
 
-  if (offset.normal_x !== undefined) {
-    fields.push({
-      name: 'NORMAL',
-      type: {type: 'fixed-size-list', listSize: 3, children: [{name: 'xyz', type: 'float32'}]}
-    });
-  }
+      case 'normal_x':
+        fields.push({
+          name: 'NORMAL',
+          type: {type: 'fixed-size-list', listSize: 3, children: [{name: 'xyz', type: 'float32'}]},
+          metadata: {attribute: 'NORMAL'}
+        });
+        break;
+      case 'normal_y':
+      case 'normal_z':
+        // ignore
+        break;
+
+      case 'rgb':
+        fields.push({
+          name: 'COLOR_0',
+          type: {type: 'fixed-size-list', listSize: 3, children: [{name: 'rgb', type: 'uint8'}]},
+          metadata: {attribute: 'COLOR'}
+        });
+        break;
 
-  if (offset.rgb !== undefined) {
-    fields.push({
-      name: 'COLOR_0',
-      type: {type: 'fixed-size-list', listSize: 3, children: [{name: 'rgb', type: 'uint8'}]}
-    });
+      default:
+      // TODO - push fields
+    }
   }
 
   return {fields, metadata};

package/src/lib/parse-pcd.ts

@@ -1,3 +1,7 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 // PCD Loader, adapted from THREE.js (MIT license)
 // Description: A loader for PCD ascii and binary files.
 // Limitations: Compressed binary files are not supported.
@@ -6,7 +10,8 @@
 // @author Filipe Caixeta / http://filipecaixeta.com.br
 // @author Mugen87 / https://github.com/Mugen87
 
-import {MeshAttribute, MeshAttributes, getMeshBoundingBox} from '@loaders.gl/schema';
+import {MeshAttribute, MeshAttributes} from '@loaders.gl/schema';
+import {getMeshBoundingBox} from '@loaders.gl/schema-utils';
 import {decompressLZF} from './decompress-lzf';
 import {getPCDSchema} from './get-pcd-schema';
 import type {PCDHeader, PCDMesh} from './pcd-types';
@@ -42,7 +47,7 @@ const LITTLE_ENDIAN: boolean = true;
  * @param data
  * @returns
  */
-export default function parsePCD(data: ArrayBufferLike): PCDMesh {
+export function parsePCD(data: ArrayBufferLike): PCDMesh {
   // parse header (always ascii format)
   const textData = new TextDecoder().decode(data);
   const pcdHeader = parsePCDHeader(textData);
@@ -71,20 +76,21 @@ export default function parsePCD(data: ArrayBufferLike): PCDMesh {
 
   const header = getMeshHeader(pcdHeader, attributes);
 
-  const metadata = Object.fromEntries([
+  const schemaMetadata = Object.fromEntries([
+    ['topology', 'point-list'],
     ['mode', '0'],
     ['boundingBox', JSON.stringify(header.boundingBox)]
   ]);
 
-  const schema = getPCDSchema(pcdHeader, metadata);
+  const schema = getPCDSchema(pcdHeader, schemaMetadata);
 
   return {
     loader: 'pcd',
     loaderData: pcdHeader,
     header,
     schema,
-    mode: 0, // POINTS
     topology: 'point-list',
+    mode: 0, // POINTS (deprecated)
     attributes
   };
 }

package/src/lib/pcd-types.ts

@@ -1,3 +1,7 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import type {Mesh} from '@loaders.gl/schema';
 
 type BoundingBox = [[number, number, number], [number, number, number]];

package/src/pcd-arrow-loader.ts

@@ -0,0 +1,25 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {LoaderWithParser} from '@loaders.gl/loader-utils';
+import type {ArrowTable} from '@loaders.gl/schema';
+
+import {PCDLoaderOptions, PCDWorkerLoader} from './pcd-loader';
+import {convertMeshToTable} from '@loaders.gl/schema-utils';
+import {parsePCD} from './lib/parse-pcd';
+
+/**
+ * Worker loader for PCD - Point Cloud Data
+ */
+export const PCDArrowLoader = {
+  ...PCDWorkerLoader,
+  dataType: null as unknown as ArrowTable,
+  batchType: null as never,
+  worker: false,
+  parse: async (arrayBuffer: ArrayBuffer) => {
+    const mesh = parsePCD(arrayBuffer);
+    const arrowTable = convertMeshToTable(mesh, 'arrow-table');
+    return arrowTable;
+  }
+} as const satisfies LoaderWithParser<ArrowTable, never, PCDLoaderOptions>;

package/src/pcd-format.ts

@@ -0,0 +1,19 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Format} from '@loaders.gl/loader-utils';
+
+/**
+ * PCD (Point Cloud Data) file format
+ */
+export const PCDFormat = {
+  name: 'PCD (Point Cloud Data)',
+  id: 'pcd',
+  module: 'pcd',
+  extensions: ['pcd'],
+  mimeTypes: ['text/plain'],
+  category: 'pointcloud',
+  text: true,
+  binary: true
+} as const satisfies Format;

package/src/pcd-loader.ts

@@ -2,8 +2,10 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Loader, LoaderOptions} from '@loaders.gl/loader-utils';
-import {PCDMesh} from './lib/pcd-types';
+import type {Loader, LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';
+import type {PCDMesh} from './lib/pcd-types';
+import {parsePCD} from './lib/parse-pcd';
+import {PCDFormat} from './pcd-format';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
@@ -19,18 +21,22 @@ export type PCDLoaderOptions = LoaderOptions & {
 /**
  * Worker loader for PCD - Point Cloud Data
  */
-export const PCDLoader = {
+export const PCDWorkerLoader = {
+  ...PCDFormat,
   dataType: null as unknown as PCDMesh,
   batchType: null as never,
-
-  name: 'PCD (Point Cloud Data)',
-  id: 'pcd',
-  module: 'pcd',
   version: VERSION,
   worker: true,
-  extensions: ['pcd'],
-  mimeTypes: ['text/plain'],
   options: {
     pcd: {}
   }
 } as const satisfies Loader<PCDMesh, never, PCDLoaderOptions>;
+
+/**
+ * Loader for PCD - Point Cloud Data
+ */
+export const PCDLoader = {
+  ...PCDWorkerLoader,
+  parse: async (arrayBuffer) => parsePCD(arrayBuffer),
+  parseSync: parsePCD
+} as const satisfies LoaderWithParser<PCDMesh, never, LoaderOptions>;

package/src/workers/pcd-worker.ts

@@ -1,3 +1,7 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {createLoaderWorker} from '@loaders.gl/loader-utils';
 import {PCDLoader} from '../index';