@loaders.gl/pcd 3.1.0 → 3.1.4

package/dist/pcd-worker.js

@@ -594,6 +594,51 @@
     }
   };
 
+  // src/lib/decompress-lzf.ts
+  function decompressLZF(inData, outLength) {
+    const inLength = inData.length;
+    const outData = new Uint8Array(outLength);
+    let inPtr = 0;
+    let outPtr = 0;
+    let ctrl;
+    let len;
+    let ref;
+    do {
+      ctrl = inData[inPtr++];
+      if (ctrl < 1 << 5) {
+        ctrl++;
+        if (outPtr + ctrl > outLength)
+          throw new Error("Output buffer is not large enough");
+        if (inPtr + ctrl > inLength)
+          throw new Error("Invalid compressed data");
+        do {
+          outData[outPtr++] = inData[inPtr++];
+        } while (--ctrl);
+      } else {
+        len = ctrl >> 5;
+        ref = outPtr - ((ctrl & 31) << 8) - 1;
+        if (inPtr >= inLength)
+          throw new Error("Invalid compressed data");
+        if (len === 7) {
+          len += inData[inPtr++];
+          if (inPtr >= inLength)
+            throw new Error("Invalid compressed data");
+        }
+        ref -= inData[inPtr++];
+        if (outPtr + len + 2 > outLength)
+          throw new Error("Output buffer is not large enough");
+        if (ref < 0)
+          throw new Error("Invalid compressed data");
+        if (ref >= outPtr)
+          throw new Error("Invalid compressed data");
+        do {
+          outData[outPtr++] = outData[ref++];
+        } while (--len + 2);
+      }
+    } while (inPtr < inLength);
+    return outData;
+  }
+
   // src/lib/get-pcd-schema.ts
   function getPCDSchema(PCDheader, metadata) {
     const offset = PCDheader.offset;
@@ -624,6 +669,8 @@
         attributes = parsePCDBinary(pcdHeader, data);
         break;
       case "binary_compressed":
+        attributes = parsePCDBinaryCompressed(pcdHeader, data);
+        break;
       default:
         throw new Error(`PCD: ${pcdHeader.data} files are not supported`);
     }
@@ -804,9 +851,42 @@
     }
     return { position, normal, color };
   }
+  function parsePCDBinaryCompressed(PCDheader, data) {
+    const position = [];
+    const normal = [];
+    const color = [];
+    const sizes = new Uint32Array(data.slice(PCDheader.headerLen, PCDheader.headerLen + 8));
+    const compressedSize = sizes[0];
+    const decompressedSize = sizes[1];
+    const decompressed = decompressLZF(new Uint8Array(data, PCDheader.headerLen + 8, compressedSize), decompressedSize);
+    const dataview = new DataView(decompressed.buffer);
+    const offset = PCDheader.offset;
+    for (let i = 0; i < PCDheader.points; i++) {
+      if (offset.x !== void 0) {
+        position.push(dataview.getFloat32(PCDheader.points * offset.x + PCDheader.size[0] * i, LITTLE_ENDIAN));
+        position.push(dataview.getFloat32(PCDheader.points * offset.y + PCDheader.size[1] * i, LITTLE_ENDIAN));
+        position.push(dataview.getFloat32(PCDheader.points * offset.z + PCDheader.size[2] * i, LITTLE_ENDIAN));
+      }
+      if (offset.rgb !== void 0) {
+        color.push(dataview.getUint8(PCDheader.points * offset.rgb + PCDheader.size[3] * i + 0) / 255);
+        color.push(dataview.getUint8(PCDheader.points * offset.rgb + PCDheader.size[3] * i + 1) / 255);
+        color.push(dataview.getUint8(PCDheader.points * offset.rgb + PCDheader.size[3] * i + 2) / 255);
+      }
+      if (offset.normal_x !== void 0) {
+        normal.push(dataview.getFloat32(PCDheader.points * offset.normal_x + PCDheader.size[4] * i, LITTLE_ENDIAN));
+        normal.push(dataview.getFloat32(PCDheader.points * offset.normal_y + PCDheader.size[5] * i, LITTLE_ENDIAN));
+        normal.push(dataview.getFloat32(PCDheader.points * offset.normal_z + PCDheader.size[6] * i, LITTLE_ENDIAN));
+      }
+    }
+    return {
+      position,
+      normal,
+      color
+    };
+  }
 
   // src/pcd-loader.ts
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION = true ? "3.1.4" : "latest";
   var PCDLoader = {
     name: "PCD (Point Cloud Data)",
     id: "pcd",
@@ -830,3 +910,10 @@
   // src/workers/pcd-worker.ts
   createLoaderWorker(PCDLoader2);
 })();
+/** 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
+ * @license MIT (http://opensource.org/licenses/MIT)
+ * @param pcdHeader
+ * @param data
+ * @returns [attributes]
+ */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/pcd",
-  "version": "3.1.0",
+  "version": "3.1.4",
   "description": "Framework-independent loader for the PCD format",
   "license": "MIT",
   "publishConfig": {
@@ -29,12 +29,12 @@
   ],
   "scripts": {
     "pre-build": "npm run build-worker && npm run build-bundle",
-    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/bundle.js",
-    "build-worker": "esbuild src/workers/pcd-worker.ts --bundle --outfile=dist/pcd-worker.js"
+    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js",
+    "build-worker": "esbuild src/workers/pcd-worker.ts --bundle --outfile=dist/pcd-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/loader-utils": "3.1.0",
-    "@loaders.gl/schema": "3.1.0"
+    "@loaders.gl/loader-utils": "3.1.4",
+    "@loaders.gl/schema": "3.1.4"
   },
-  "gitHead": "b02a011b5a6d6aa6c5870819045c70db168cb930"
+  "gitHead": "4d27d3ac6023e53b562dcad83b9254b198e81ee5"
 }

package/src/lib/decompress-lzf.ts

@@ -0,0 +1,50 @@
+/* eslint-disable */
+/**
+ * from https://gitlab.com/taketwo/three-pcd-loader/blob/master/decompress-lzf.js
+ * @param inData
+ * @param outLength
+ * @returns
+ */
+export function decompressLZF(inData: Uint8Array, outLength: number): Uint8Array {
+  const inLength = inData.length;
+  const outData = new Uint8Array(outLength);
+  let inPtr = 0;
+  let outPtr = 0;
+  let ctrl;
+  let len;
+  let ref;
+
+  do {
+    ctrl = inData[inPtr++];
+
+    if (ctrl < 1 << 5) {
+      ctrl++;
+      if (outPtr + ctrl > outLength) throw new Error('Output buffer is not large enough');
+      if (inPtr + ctrl > inLength) throw new Error('Invalid compressed data');
+
+      do {
+        outData[outPtr++] = inData[inPtr++];
+      } while (--ctrl);
+    } else {
+      len = ctrl >> 5;
+      ref = outPtr - ((ctrl & 0x1f) << 8) - 1;
+      if (inPtr >= inLength) throw new Error('Invalid compressed data');
+
+      if (len === 7) {
+        len += inData[inPtr++];
+        if (inPtr >= inLength) throw new Error('Invalid compressed data');
+      }
+
+      ref -= inData[inPtr++];
+      if (outPtr + len + 2 > outLength) throw new Error('Output buffer is not large enough');
+      if (ref < 0) throw new Error('Invalid compressed data');
+      if (ref >= outPtr) throw new Error('Invalid compressed data');
+
+      do {
+        outData[outPtr++] = outData[ref++];
+      } while (--len + 2);
+    }
+  } while (inPtr < inLength);
+
+  return outData;
+}

package/src/lib/parse-pcd.ts

@@ -6,10 +6,11 @@
 // @author Filipe Caixeta / http://filipecaixeta.com.br
 // @author Mugen87 / https://github.com/Mugen87
 
-import {getMeshBoundingBox} from '@loaders.gl/schema';
 import type {MeshAttribute, MeshAttributes} from '@loaders.gl/schema';
-import type {PCDHeader} from './pcd-types';
+import {getMeshBoundingBox} from '@loaders.gl/schema';
+import {decompressLZF} from './decompress-lzf';
 import {getPCDSchema} from './get-pcd-schema';
+import type {PCDHeader} from './pcd-types';
 
 type NormalizedAttributes = {
   POSITION: {
@@ -55,6 +56,9 @@ export default function parsePCD(data: ArrayBufferLike) {
       break;
 
     case 'binary_compressed':
+      attributes = parsePCDBinaryCompressed(pcdHeader, data);
+      break;
+
     default:
       throw new Error(`PCD: ${pcdHeader.data} files are not supported`);
   }
@@ -312,3 +316,95 @@ function parsePCDBinary(pcdHeader: PCDHeader, data: ArrayBufferLike): HeaderAttr
 
   return {position, normal, color};
 }
+
+/** 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
+ * @license MIT (http://opensource.org/licenses/MIT)
+ * @param pcdHeader
+ * @param data
+ * @returns [attributes]
+ */
+function parsePCDBinaryCompressed(PCDheader: PCDHeader, data: ArrayBufferLike): HeaderAttributes {
+  const position: number[] = [];
+  const normal: number[] = [];
+  const color: number[] = [];
+
+  const sizes = new Uint32Array(data.slice(PCDheader.headerLen, PCDheader.headerLen + 8));
+  const compressedSize = sizes[0];
+  const decompressedSize = sizes[1];
+  const decompressed = decompressLZF(
+    new Uint8Array(data, PCDheader.headerLen + 8, compressedSize),
+    decompressedSize
+  );
+  const dataview = new DataView(decompressed.buffer);
+
+  const offset = PCDheader.offset;
+
+  for (let i = 0; i < PCDheader.points; i++) {
+    if (offset.x !== undefined) {
+      position.push(
+        dataview.getFloat32(
+          (PCDheader.points as number) * offset.x + (PCDheader.size as number[])[0] * i,
+          LITTLE_ENDIAN
+        )
+      );
+      position.push(
+        dataview.getFloat32(
+          (PCDheader.points as number) * offset.y + (PCDheader.size as number[])[1] * i,
+          LITTLE_ENDIAN
+        )
+      );
+      position.push(
+        dataview.getFloat32(
+          (PCDheader.points as number) * offset.z + (PCDheader.size as number[])[2] * i,
+          LITTLE_ENDIAN
+        )
+      );
+    }
+
+    if (offset.rgb !== undefined) {
+      color.push(
+        dataview.getUint8(
+          (PCDheader.points as number) * offset.rgb + (PCDheader.size as number[])[3] * i + 0
+        ) / 255.0
+      );
+      color.push(
+        dataview.getUint8(
+          (PCDheader.points as number) * offset.rgb + (PCDheader.size as number[])[3] * i + 1
+        ) / 255.0
+      );
+      color.push(
+        dataview.getUint8(
+          (PCDheader.points as number) * offset.rgb + (PCDheader.size as number[])[3] * i + 2
+        ) / 255.0
+      );
+    }
+
+    if (offset.normal_x !== undefined) {
+      normal.push(
+        dataview.getFloat32(
+          (PCDheader.points as number) * offset.normal_x + (PCDheader.size as number[])[4] * i,
+          LITTLE_ENDIAN
+        )
+      );
+      normal.push(
+        dataview.getFloat32(
+          (PCDheader.points as number) * offset.normal_y + (PCDheader.size as number[])[5] * i,
+          LITTLE_ENDIAN
+        )
+      );
+      normal.push(
+        dataview.getFloat32(
+          (PCDheader.points as number) * offset.normal_z + (PCDheader.size as number[])[6] * i,
+          LITTLE_ENDIAN
+        )
+      );
+    }
+  }
+
+  return {
+    position,
+    normal,
+    color
+  };
+}