@loaders.gl/las 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/lib/parse-las.d.ts

@@ -0,0 +1,18 @@
+import type { LASLoaderOptions } from '../las-loader';
+import type { LASMesh } from './las-types';
+/**
+ * Parsing of .las file
+ * @param arrayBuffer
+ * @param options
+ * @returns LASHeader
+ */
+export declare function parseLAS(arrayBuffer: ArrayBuffer, options?: LASLoaderOptions): LASMesh;
+/**
+ * parse laz data
+ * @param rawData
+ * @param skip
+ * @param onParseData
+ * @return parsed point cloud
+ */
+export declare function parseLASChunked(rawData: ArrayBuffer, skip: number, onParseData?: any): void;
+//# sourceMappingURL=parse-las.d.ts.map

package/dist/lib/parse-las.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-las.d.ts","sourceRoot":"","sources":["../../src/lib/parse-las.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAC,OAAO,EAAY,MAAM,aAAa,CAAC;AAapD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAKtF;AAsHD;;;;;;GAMG;AAEH,wBAAgB,eAAe,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,GAAE,GAAQ,GAAG,IAAI,CAwC/F"}

package/dist/lib/parse-las.js

@@ -1,191 +1,191 @@
-import { Schema, getMeshBoundingBox, convertMesh } from '@loaders.gl/schema';
-import { LASFile } from './laslaz-decoder';
-import { getLASSchema } from './get-las-schema';
-export default function parseLAS(arrayBuffer, options) {
-  var _options$las;
-
-  const mesh = parseLASMesh(arrayBuffer, options);
-  return convertMesh(mesh, (options === null || options === void 0 ? void 0 : (_options$las = options.las) === null || _options$las === void 0 ? void 0 : _options$las.shape) || 'mesh');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLASChunked = exports.parseLAS = void 0;
+const schema_1 = require("@loaders.gl/schema");
+const laslaz_decoder_1 = require("./laslaz-decoder");
+const get_las_schema_1 = require("./get-las-schema");
+/**
+ * Parsing of .las file
+ * @param arrayBuffer
+ * @param options
+ * @returns LASHeader
+ */
+function parseLAS(arrayBuffer, options) {
+    return parseLASMesh(arrayBuffer, options);
+    // This code breaks pointcloud example on the website
+    // const mesh = parseLASMesh(arrayBuffer, options);
+    // return convertMesh(mesh, options?.las?.shape || 'mesh') as LASMesh | ArrowTable | ColumnarTable;
 }
-
+exports.parseLAS = parseLAS;
+/**
+ * Parsing of .las file
+ * @param arrayBuffer
+ * @param options
+ * @returns LASHeader
+ */
 function parseLASMesh(arrayBuffer, options = {}) {
-  var _options$las2;
-
-  let pointIndex = 0;
-  let positions;
-  let colors;
-  let intensities;
-  let classifications;
-  let originalHeader;
-  const lasMesh = {
-    loader: 'las',
-    loaderData: {},
-    schema: new Schema([]),
-    header: {
-      vertexCount: 0,
-      boundingBox: [[0, 0, 0], [0, 0, 0]]
-    },
-    attributes: {},
-    topology: 'point-list',
-    mode: 0
-  };
-  parseLASChunked(arrayBuffer, (_options$las2 = options.las) === null || _options$las2 === void 0 ? void 0 : _options$las2.skip, (decoder = {}, lasHeader) => {
-    var _options$las4, _options$onProgress;
-
-    if (!originalHeader) {
-      var _options$las3;
-
-      originalHeader = lasHeader;
-      const total = lasHeader.totalToRead;
-      const PositionsType = (_options$las3 = options.las) !== null && _options$las3 !== void 0 && _options$las3.fp64 ? Float64Array : Float32Array;
-      positions = new PositionsType(total * 3);
-      colors = lasHeader.pointsFormatId >= 2 ? new Uint8Array(total * 4) : null;
-      intensities = new Uint16Array(total);
-      classifications = new Uint8Array(total);
-      lasMesh.loaderData = lasHeader;
-      lasMesh.attributes = {
-        POSITION: {
-          value: positions,
-          size: 3
+    let pointIndex = 0;
+    let positions;
+    let colors;
+    let intensities;
+    let classifications;
+    let originalHeader;
+    const lasMesh = {
+        loader: 'las',
+        loaderData: {},
+        // shape: 'mesh',
+        schema: { fields: [], metadata: {} },
+        header: {
+            vertexCount: 0,
+            boundingBox: [
+                [0, 0, 0],
+                [0, 0, 0]
+            ]
         },
-        intensity: {
-          value: intensities,
-          size: 1
-        },
-        classification: {
-          value: classifications,
-          size: 1
+        attributes: {},
+        topology: 'point-list',
+        mode: 0 // GL.POINTS
+    };
+    /* eslint-disable max-statements */
+    // @ts-ignore Possibly undefined
+    parseLASChunked(arrayBuffer, options.las?.skip, (decoder = {}, lasHeader) => {
+        if (!originalHeader) {
+            originalHeader = lasHeader;
+            const total = lasHeader.totalToRead;
+            const PositionsType = options.las?.fp64 ? Float64Array : Float32Array;
+            positions = new PositionsType(total * 3);
+            // laslaz-decoder.js `pointFormatReaders`
+            colors = lasHeader.pointsFormatId >= 2 ? new Uint8Array(total * 4) : null;
+            intensities = new Uint16Array(total);
+            classifications = new Uint8Array(total);
+            lasMesh.loaderData = lasHeader;
+            lasMesh.attributes = {
+                POSITION: { value: positions, size: 3 },
+                // non-gltf attributes, use non-capitalized names for now
+                intensity: { value: intensities, size: 1 },
+                classification: { value: classifications, size: 1 }
+            };
+            if (colors) {
+                lasMesh.attributes.COLOR_0 = { value: colors, size: 4 };
+            }
+        }
+        const batchSize = decoder.pointsCount;
+        const { scale: [scaleX, scaleY, scaleZ], offset: [offsetX, offsetY, offsetZ] } = lasHeader;
+        const twoByteColor = detectTwoByteColors(decoder, batchSize, options.las?.colorDepth);
+        for (let i = 0; i < batchSize; i++) {
+            const { position, color, intensity, classification } = decoder.getPoint(i);
+            positions[pointIndex * 3] = position[0] * scaleX + offsetX;
+            positions[pointIndex * 3 + 1] = position[1] * scaleY + offsetY;
+            positions[pointIndex * 3 + 2] = position[2] * scaleZ + offsetZ;
+            if (color && colors) {
+                if (twoByteColor) {
+                    colors[pointIndex * 4] = color[0] / 256;
+                    colors[pointIndex * 4 + 1] = color[1] / 256;
+                    colors[pointIndex * 4 + 2] = color[2] / 256;
+                }
+                else {
+                    colors[pointIndex * 4] = color[0];
+                    colors[pointIndex * 4 + 1] = color[1];
+                    colors[pointIndex * 4 + 2] = color[2];
+                }
+                colors[pointIndex * 4 + 3] = 255;
+            }
+            intensities[pointIndex] = intensity;
+            classifications[pointIndex] = classification;
+            pointIndex++;
         }
-      };
-
-      if (colors) {
-        lasMesh.attributes.COLOR_0 = {
-          value: colors,
-          size: 4
+        const meshBatch = {
+            ...lasMesh,
+            header: {
+                vertexCount: lasHeader.totalRead
+            },
+            progress: lasHeader.totalRead / lasHeader.totalToRead
         };
-      }
+        options?.onProgress?.(meshBatch);
+    });
+    /* eslint-enable max-statements */
+    lasMesh.header = {
+        vertexCount: originalHeader.totalToRead,
+        boundingBox: (0, schema_1.getMeshBoundingBox)(lasMesh?.attributes || {})
+    };
+    if (lasMesh) {
+        lasMesh.schema = (0, get_las_schema_1.getLASSchema)(lasMesh.loaderData, lasMesh.attributes);
     }
-
-    const batchSize = decoder.pointsCount;
-    const {
-      scale: [scaleX, scaleY, scaleZ],
-      offset: [offsetX, offsetY, offsetZ]
-    } = lasHeader;
-    const twoByteColor = detectTwoByteColors(decoder, batchSize, (_options$las4 = options.las) === null || _options$las4 === void 0 ? void 0 : _options$las4.colorDepth);
-
-    for (let i = 0; i < batchSize; i++) {
-      const {
-        position,
-        color,
-        intensity,
-        classification
-      } = decoder.getPoint(i);
-      positions[pointIndex * 3] = position[0] * scaleX + offsetX;
-      positions[pointIndex * 3 + 1] = position[1] * scaleY + offsetY;
-      positions[pointIndex * 3 + 2] = position[2] * scaleZ + offsetZ;
-
-      if (color && colors) {
-        if (twoByteColor) {
-          colors[pointIndex * 4] = color[0] / 256;
-          colors[pointIndex * 4 + 1] = color[1] / 256;
-          colors[pointIndex * 4 + 2] = color[2] / 256;
-        } else {
-          colors[pointIndex * 4] = color[0];
-          colors[pointIndex * 4 + 1] = color[1];
-          colors[pointIndex * 4 + 2] = color[2];
+    return lasMesh;
+}
+/**
+ * parse laz data
+ * @param rawData
+ * @param skip
+ * @param onParseData
+ * @return parsed point cloud
+ */
+/* eslint-enable max-statements */
+function parseLASChunked(rawData, skip, onParseData = {}) {
+    const dataHandler = new laslaz_decoder_1.LASFile(rawData);
+    try {
+        // open data
+        dataHandler.open();
+        const header = dataHandler.getHeader();
+        // start loading
+        const Unpacker = dataHandler.getUnpacker();
+        const totalToRead = Math.ceil(header.pointsCount / Math.max(1, skip));
+        header.totalToRead = totalToRead;
+        let totalRead = 0;
+        /* eslint-disable no-constant-condition */
+        while (true) {
+            const chunk = dataHandler.readData(1000 * 100, 0, skip);
+            totalRead += chunk.count;
+            header.totalRead = totalRead;
+            header.versionAsString = chunk.versionAsString;
+            header.isCompressed = chunk.isCompressed;
+            const unpacker = new Unpacker(chunk.buffer, chunk.count, header);
+            // surface unpacker and progress via call back
+            // use unpacker.pointsCount and unpacker.getPoint(i) to handle data in app
+            onParseData(unpacker, header);
+            if (!chunk.hasMoreData || totalRead >= totalToRead) {
+                break;
+            }
         }
-
-        colors[pointIndex * 4 + 3] = 255;
-      }
-
-      intensities[pointIndex] = intensity;
-      classifications[pointIndex] = classification;
-      pointIndex++;
     }
-
-    const meshBatch = { ...lasMesh,
-      header: {
-        vertexCount: lasHeader.totalRead
-      },
-      progress: lasHeader.totalRead / lasHeader.totalToRead
-    };
-    options === null || options === void 0 ? void 0 : (_options$onProgress = options.onProgress) === null || _options$onProgress === void 0 ? void 0 : _options$onProgress.call(options, meshBatch);
-  });
-  lasMesh.header = {
-    vertexCount: originalHeader.totalToRead,
-    boundingBox: getMeshBoundingBox((lasMesh === null || lasMesh === void 0 ? void 0 : lasMesh.attributes) || {})
-  };
-
-  if (lasMesh) {
-    lasMesh.schema = getLASSchema(lasMesh.loaderData, lasMesh.attributes);
-  }
-
-  return lasMesh;
-}
-
-export function parseLASChunked(rawData, skip, onParseData = {}) {
-  const dataHandler = new LASFile(rawData);
-
-  try {
-    dataHandler.open();
-    const header = dataHandler.getHeader();
-    const Unpacker = dataHandler.getUnpacker();
-    const totalToRead = Math.ceil(header.pointsCount / Math.max(1, skip));
-    header.totalToRead = totalToRead;
-    let totalRead = 0;
-
-    while (true) {
-      const chunk = dataHandler.readData(1000 * 100, 0, skip);
-      totalRead += chunk.count;
-      header.totalRead = totalRead;
-      header.versionAsString = chunk.versionAsString;
-      header.isCompressed = chunk.isCompressed;
-      const unpacker = new Unpacker(chunk.buffer, chunk.count, header);
-      onParseData(unpacker, header);
-
-      if (!chunk.hasMoreData || totalRead >= totalToRead) {
-        break;
-      }
+    catch (e) {
+        throw e;
+    }
+    finally {
+        dataHandler.close();
     }
-  } catch (e) {
-    throw e;
-  } finally {
-    dataHandler.close();
-  }
 }
-
+exports.parseLASChunked = parseLASChunked;
+/**
+ * @param decoder
+ * @param batchSize
+ * @param colorDepth
+ * @returns boolean
+ */
 function detectTwoByteColors(decoder = {}, batchSize, colorDepth) {
-  let twoByteColor = false;
-
-  switch (colorDepth) {
-    case 8:
-      twoByteColor = false;
-      break;
-
-    case 16:
-      twoByteColor = true;
-      break;
-
-    case 'auto':
-      if (decoder.getPoint(0).color) {
-        for (let i = 0; i < batchSize; i++) {
-          const {
-            color
-          } = decoder.getPoint(i);
-
-          if (color[0] > 255 || color[1] > 255 || color[2] > 255) {
+    let twoByteColor = false;
+    switch (colorDepth) {
+        case 8:
+            twoByteColor = false;
+            break;
+        case 16:
             twoByteColor = true;
-          }
-        }
-      }
-
-      break;
-
-    default:
-      console.warn('las: illegal value for options.las.colorDepth');
-      break;
-  }
-
-  return twoByteColor;
+            break;
+        case 'auto':
+            if (decoder.getPoint(0).color) {
+                for (let i = 0; i < batchSize; i++) {
+                    const { color } = decoder.getPoint(i);
+                    // eslint-disable-next-line max-depth
+                    if (color[0] > 255 || color[1] > 255 || color[2] > 255) {
+                        twoByteColor = true;
+                    }
+                }
+            }
+            break;
+        default:
+            // eslint-disable-next-line
+            console.warn('las: illegal value for options.las.colorDepth');
+            break;
+    }
+    return twoByteColor;
 }
-//# sourceMappingURL=parse-las.js.map

package/dist/workers/las-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=las-worker.d.ts.map

package/dist/workers/las-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"las-worker.d.ts","sourceRoot":"","sources":["../../src/workers/las-worker.ts"],"names":[],"mappings":""}

package/dist/workers/las-worker.js

@@ -1,4 +1,5 @@
-import {createLoaderWorker} from '@loaders.gl/loader-utils';
-import {LASLoader} from '../index';
-
-createLoaderWorker(LASLoader);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const index_1 = require("../index");
+(0, loader_utils_1.createLoaderWorker)(index_1.LASLoader);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/las",
-  "version": "4.0.0-alpha.4",
+  "version": "4.0.0-alpha.6",
   "description": "Framework-independent loader for the LAS and LAZ formats",
   "license": "MIT",
   "publishConfig": {
@@ -19,9 +19,9 @@
     "LAS",
     "LAZ"
   ],
-  "types": "src/index.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "main": "dist/es5/index.js",
+  "module": "dist/esm/index.js",
   "sideEffects": false,
   "browser": {
     "fs": false,
@@ -36,14 +36,14 @@
   ],
   "scripts": {
     "pre-build": "npm run build-bundle && npm run build-worker",
-    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/bundle.js",
-    "build-worker": "esbuild src/workers/las-worker.js --bundle --outfile=dist/las-worker.js"
+    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js",
+    "build-worker": "esbuild src/workers/las-worker.ts --bundle --outfile=dist/las-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.4",
-    "@loaders.gl/schema": "4.0.0-alpha.4",
-    "apache-arrow": "^4.0.0"
+    "@loaders.gl/loader-utils": "4.0.0-alpha.6",
+    "@loaders.gl/schema": "4.0.0-alpha.6",
+    "apache-arrow": "^9.0.0"
   },
-  "gitHead": "53026061b3c8871f7e96d3a5826125cc6613bddc"
+  "gitHead": "acc1985050dfaa0f1f0c066f8da5bce7454a046c"
 }

package/src/index.ts

@@ -1,7 +1,8 @@
 import type {LoaderWithParser} from '@loaders.gl/loader-utils';
 import type {LASLoaderOptions} from './las-loader';
+import type {LASMesh} from './lib/las-types';
 import {LASLoader as LASWorkerLoader} from './las-loader';
-import parseLAS from './lib/parse-las';
+import {parseLAS} from './lib/parse-las';
 
 // LASLoader
 
@@ -11,12 +12,10 @@ export {LASWorkerLoader};
 /**
  * Loader for the LAS (LASer) point cloud format
  */
-export const LASLoader = {
+export const LASLoader: LoaderWithParser<LASMesh, never, LASLoaderOptions> = {
   ...LASWorkerLoader,
   parse: async (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) =>
     parseLAS(arrayBuffer, options),
   parseSync: (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) =>
     parseLAS(arrayBuffer, options)
 };
-
-export const _typecheckLoader: LoaderWithParser = LASLoader;

package/src/las-loader.ts

@@ -1,5 +1,6 @@
 // LASER (LAS) FILE FORMAT
 import type {Loader, LoaderOptions} from '@loaders.gl/loader-utils';
+import type {LASMesh} from './lib/las-types';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
@@ -12,6 +13,7 @@ export type LASLoaderOptions = LoaderOptions & {
     skip?: number;
     colorDepth?: number | string;
   };
+  onProgress?: Function;
 };
 
 const DEFAULT_LAS_OPTIONS: LASLoaderOptions = {
@@ -26,7 +28,7 @@ const DEFAULT_LAS_OPTIONS: LASLoaderOptions = {
 /**
  * Loader for the LAS (LASer) point cloud format
  */
-export const LASLoader = {
+export const LASLoader: Loader<LASMesh, never, LASLoaderOptions> = {
   name: 'LAS',
   id: 'las',
   module: 'las',
@@ -39,5 +41,3 @@ export const LASLoader = {
   tests: ['LAS'],
   options: DEFAULT_LAS_OPTIONS
 };
-
-export const _typecheckLoader: Loader = LASLoader;

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

@@ -18,27 +18,28 @@ export function getLASSchema(lasHeader: LASHeader, attributes: MeshAttributes):
  * @param lasHeader
  * @returns
  */
-export function makeMetadataFromLasHeader(lasHeader: LASHeader): Map<string, string> {
-  const metadataMap = new Map();
-  metadataMap.set('las_pointsOffset', lasHeader.pointsOffset.toString(10));
-  metadataMap.set('las_pointsFormatId', lasHeader.pointsFormatId.toString(10));
-  metadataMap.set('las_pointsStructSize', lasHeader.pointsStructSize.toString(10));
-  metadataMap.set('las_pointsCount', lasHeader.pointsCount.toString(10));
-  metadataMap.set('las_scale', JSON.stringify(lasHeader.scale));
-  metadataMap.set('las_offset', JSON.stringify(lasHeader.offset));
+export function makeMetadataFromLasHeader(lasHeader: LASHeader): Record<string, string> {
+  const metadata: Record<string, string> = {};
+  /* eslint-disable camelcase */
+  metadata.las_pointsOffset = lasHeader.pointsOffset.toString(10);
+  metadata.las_pointsFormatId = lasHeader.pointsFormatId.toString(10);
+  metadata.las_pointsStructSize = lasHeader.pointsStructSize.toString(10);
+  metadata.las_pointsCount = lasHeader.pointsCount.toString(10);
+  metadata.las_scale = JSON.stringify(lasHeader.scale);
+  metadata.las_offset = JSON.stringify(lasHeader.offset);
   if (lasHeader.maxs !== undefined) {
-    metadataMap.set('las_maxs', JSON.stringify(lasHeader.maxs));
+    metadata.las_maxs = JSON.stringify(lasHeader.maxs);
   }
   if (lasHeader.mins !== undefined) {
-    metadataMap.set('las_mins', JSON.stringify(lasHeader.mins));
+    metadata.las_mins = JSON.stringify(lasHeader.mins);
   }
-  metadataMap.set('las_totalToRead', lasHeader.totalToRead.toString(10));
-  metadataMap.set('las_pointsFortotalReadmatId', lasHeader.totalRead.toString(10));
+  metadata.las_totalToRead = lasHeader.totalToRead.toString(10);
+  metadata.las_pointsFortotalReadmatId = lasHeader.totalRead.toString(10);
   if (lasHeader.versionAsString !== undefined) {
-    metadataMap.set('las_versionAsString', lasHeader.versionAsString);
+    metadata.las_versionAsString = lasHeader.versionAsString;
   }
   if (lasHeader.isCompressed !== undefined) {
-    metadataMap.set('las_isCompressed', lasHeader.isCompressed.toString());
+    metadata.las_isCompressed = lasHeader.isCompressed.toString();
   }
-  return metadataMap;
+  return metadata;
 }

package/src/lib/laslaz-decoder.ts

@@ -5,7 +5,7 @@
 */
 // laslaz.js - treat as compiled code
 import type {LASHeader} from './las-types';
-import getModule from '../libs/laz-perf';
+import getModule from './libs/laz-perf';
 
 let Module: any = null;