@loaders.gl/pointclouds 5.0.0-beta.1 → 5.0.0-beta.10

package/src/las/las-loader.ts

@@ -2,9 +2,11 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {LoaderWithParser} from '@loaders.gl/core/loader-utils';
+import {paceBatchIterator, type LoaderWithParser} from '@loaders.gl/core/loader-utils';
+import type {Table, RecordBatch} from 'apache-arrow';
+import {makeArrowMetadataBatch} from '@loaders.gl/core/schema-utils';
 import type {MeshArrowTable} from '@loaders.gl/core/schema';
-import {convertMeshToTable, convertTableToMesh} from '@loaders.gl/core/schema-utils';
+import {convertMeshToArrowTableWrapper, convertTableToMesh} from '@loaders.gl/core/schema-utils';
 import {
   formatLASMeshColors,
   getLASShape,
@@ -14,7 +16,7 @@ import {
 import {
   serializeArrowWorkerTable,
   deserializeArrowWorkerTable
-} from '@loaders.gl/core/schema-utils/arrow-transport';
+} from '@loaders.gl/core/arrow-worker-transport';
 import type {LASMesh} from './lib/las-types';
 import {
   decodeLAZChunkToArrowTable,
@@ -35,8 +37,10 @@ type LASWorkerOptions = LASLoaderOptions & {
 };
 
 /** Parser-bearing TypeScript-only LAS loader implementation. */
-export const LASLoaderWithParser = {
+export const LASColumnLoader = {
   ...LAS_LOADER_METADATA,
+  dataType: null as unknown as LASMesh | MeshArrowTable,
+  batchType: null as unknown as LASMesh | MeshArrowTable,
   worker: true,
   workerInBatches: true,
   serializeWorkerResult: serializeArrowWorkerTable,
@@ -72,15 +76,14 @@ function convertLASMesh(
     options?.las?.colorFormat === undefined || options.las.colorFormat === 'uint8norm'
       ? table
       : {
-          ...convertMeshToTable(
-            formatLASMeshColors(convertTableToMesh(table) as LASMesh, options.las.colorFormat),
-            'arrow-table'
+          ...convertMeshToArrowTableWrapper(
+            formatLASMeshColors(convertTableToMesh(table) as LASMesh, options.las.colorFormat)
           ),
           loader: table.loader,
           loaderData: table.loaderData,
           progress: table.progress
         };
-  if (getLASShape(options) === 'arrow-table') {
+  if (getLASShape(options) === 'arrow') {
     return formattedTable;
   }
   return {
@@ -95,7 +98,11 @@ async function* convertLASMeshBatches(
   tableBatches: AsyncIterable<LASArrowTable>,
   options?: LASLoaderOptions
 ): AsyncIterable<LASMesh | MeshArrowTable> {
-  for await (const table of tableBatches) {
+  for await (const table of paceBatchIterator(tableBatches, {
+    batchMaxRowsPerSecond: options?.core?.batchMaxRowsPerSecond,
+    getRowCount: batch => batch.data.numRows,
+    signal: options?.signal
+  })) {
     yield convertLASMesh(table, options);
   }
 }
@@ -107,3 +114,50 @@ function deserializeLASWorkerTable(
 ): LASMesh | MeshArrowTable {
   return convertLASMesh(deserializeArrowWorkerTable(result), options);
 }
+
+/** Exposes native Arrow while retaining the column worker and mesh compatibility paths. */
+export const LASLoaderWithParser = {
+  ...LASColumnLoader,
+  dataType: LAS_LOADER_METADATA.dataType,
+  batchType: LAS_LOADER_METADATA.batchType,
+  parse: async (input: ArrayBuffer, options?: LASLoaderOptions) =>
+    toPublicLASResult(await LASColumnLoader.parse(input, options)),
+  parseSync: (input: ArrayBuffer, options?: LASLoaderOptions) =>
+    toPublicLASResult(LASColumnLoader.parseSync(input, options)),
+  async *parseInBatches(input, options) {
+    for await (const result of LASColumnLoader.parseInBatches(input, options)) {
+      if ('shape' in result) yield* getLASRecordBatches(result);
+      else yield result;
+    }
+  },
+  deserializeWorkerResult: (result: unknown, options?: LASLoaderOptions) =>
+    toPublicLASResult(deserializeLASWorkerTable(result, options)),
+  deserializeWorkerBatch(result: unknown, options?: LASLoaderOptions) {
+    const decoded = deserializeLASWorkerTable(result, options);
+    return 'shape' in decoded ? getLASRecordBatches(decoded)[0] : decoded;
+  }
+} as const satisfies LoaderWithParser<LASMesh | Table, LASMesh | RecordBatch, LASLoaderOptions>;
+
+/** Unwraps the Arrow table with its complete file header. */
+export function toPublicLASResult(result: LASMesh | MeshArrowTable): LASMesh | Table {
+  if (!('shape' in result)) return result;
+  const header = JSON.stringify((result as LASArrowTable).loaderData, (_key, value) =>
+    typeof value === 'bigint'
+      ? value.toString()
+      : ArrayBuffer.isView(value)
+        ? Array.from(value as Uint8Array)
+        : value
+  );
+  if (header) {
+    result.data.schema.metadata.set('loaders.gl.las.header', header);
+    for (const batch of result.data.batches)
+      batch.schema.metadata.set('loaders.gl.las.header', header);
+  }
+  return result.data;
+}
+
+/** Unwraps the record batches, retaining schema on empty LAS results. */
+export function getLASRecordBatches(result: MeshArrowTable): RecordBatch[] {
+  const table = toPublicLASResult(result) as Table;
+  return table.batches.length ? table.batches : [makeArrowMetadataBatch(table.schema)];
+}

package/src/las/las-writer.ts

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import type {Table} from 'apache-arrow';
 import {
   encodeLASzipVLR,
   encodeLAZChunk,
@@ -11,7 +12,7 @@ import {
   type WriterWithEncoder
 } from '@loaders.gl/core/loader-utils';
 import type {Mesh, MeshArrowTable, MeshAttribute} from '@loaders.gl/core/schema';
-import {convertMeshToTable, convertTableToMesh} from '@loaders.gl/core/schema-utils';
+import {convertMeshToArrowTableWrapper, convertTableToMesh} from '@loaders.gl/core/schema-utils';
 import {LASFormat} from './las-format';
 
 // __VERSION__ is injected by babel-plugin-version-inline
@@ -86,7 +87,7 @@ export type LASWriterOptions = WriterOptions & {
  */
 export const LASWriter = {
   ...LASFormat,
-  dataType: null as unknown as Mesh | MeshArrowTable,
+  dataType: null as unknown as Mesh | MeshArrowTable | Table,
   batchType: null as never,
   version: VERSION,
   extensions: ['las', 'laz'],
@@ -96,16 +97,19 @@ export const LASWriter = {
   encode: async (data, options) => encodeLASSync(data, options),
   encodeSync: encodeLASSync,
   encodeInBatches: async function* (dataIterator, options) {
-    const batches: (Mesh | MeshArrowTable)[] = [];
-    for await (const batch of dataIterator as AsyncIterable<Mesh | MeshArrowTable>) {
+    const batches: (Mesh | MeshArrowTable | Table)[] = [];
+    for await (const batch of dataIterator as AsyncIterable<Mesh | MeshArrowTable | Table>) {
       batches.push(batch);
     }
     yield encodeLASSync(mergeMeshBatches(batches), options);
   }
-} as const satisfies WriterWithEncoder<Mesh | MeshArrowTable, never, LASWriterOptions>;
+} as const satisfies WriterWithEncoder<Mesh | MeshArrowTable | Table, never, LASWriterOptions>;
 
 /** Encode mesh category data as LAS or LAZ bytes. */
-function encodeLASSync(data: Mesh | MeshArrowTable, options: LASWriterOptions = {}): ArrayBuffer {
+function encodeLASSync(
+  data: Mesh | MeshArrowTable | Table,
+  options: LASWriterOptions = {}
+): ArrayBuffer {
   const format = options.las?.format || 'las';
   const colorDepth = options.las?.colorDepth;
   if (colorDepth !== undefined && colorDepth !== 'auto' && colorDepth !== 8 && colorDepth !== 16)
@@ -652,22 +656,22 @@ function validateLAZOptions(
 }
 
 /** Return mesh data as a Mesh, converting MeshArrowTable input first. */
-function normalizeMesh(data: Mesh | MeshArrowTable): Mesh {
-  if ('shape' in data && data.shape === 'arrow-table') {
+function normalizeMesh(data: Mesh | MeshArrowTable | Table): Mesh {
+  if (!('attributes' in data)) {
     return convertTableToMesh(data);
   }
   return data as Mesh;
 }
 
 /** Return mesh data as a MeshArrowTable, converting plain Mesh data first. */
-function normalizeMeshArrowTable(data: Mesh | MeshArrowTable): MeshArrowTable {
-  return 'shape' in data && data.shape === 'arrow-table'
-    ? data
-    : convertMeshToTable(data as Mesh, 'arrow-table');
+function normalizeMeshArrowTable(data: Mesh | MeshArrowTable | Table): MeshArrowTable | Table {
+  return !('attributes' in data) ? data : convertMeshToArrowTableWrapper(data as Mesh);
 }
 
 /** Merge buffered mesh batches for `encodeInBatches`. */
-function mergeMeshBatches(batches: (Mesh | MeshArrowTable)[]): Mesh | MeshArrowTable {
+function mergeMeshBatches(
+  batches: (Mesh | MeshArrowTable | Table)[]
+): Mesh | MeshArrowTable | Table {
   if (batches.length === 0) {
     throw new Error('LASWriter: at least one input batch is required');
   }

package/src/las/laz-rs-loader-types.ts

@@ -4,7 +4,7 @@
 
 // LASER (LAS) FILE FORMAT
 import type {Loader} from '@loaders.gl/core/loader-utils';
-import type {MeshArrowTable} from '@loaders.gl/core/schema';
+import type {Table, RecordBatch} from 'apache-arrow';
 import {LAS_LOADER_METADATA, type LASLoaderOptions} from './las-loader-shared';
 import type {LASMesh} from './lib/las-types';
 
@@ -15,7 +15,7 @@ export const LAZRsLoader = {
   ...LAS_LOADER_METADATA,
   name: 'LAS (laz-rs)',
   preload: async () => {
-    const {LAZRsLoaderWithParser} = await import('@loaders.gl/pointclouds/las/laz-rs-loader');
+    const {LAZRsLoaderWithParser} = await import('@loaders.gl/pointclouds/laz-rs-loader');
     return LAZRsLoaderWithParser;
   }
-} as const satisfies Loader<LASMesh | MeshArrowTable, LASMesh | MeshArrowTable, LASLoaderOptions>;
+} as const satisfies Loader<LASMesh | Table, LASMesh | RecordBatch, LASLoaderOptions>;

package/src/las/laz-rs-loader.ts

@@ -4,8 +4,10 @@
 
 // LASER (LAS) FILE FORMAT
 import type {LoaderWithParser} from '@loaders.gl/core/loader-utils';
+import type {Table, RecordBatch} from 'apache-arrow';
+import {getLASRecordBatches, toPublicLASResult} from './las-loader';
 import type {MeshArrowTable} from '@loaders.gl/core/schema';
-import {convertMeshToTable, convertTableToMesh} from '@loaders.gl/core/schema-utils';
+import {convertMeshToArrowTableWrapper, convertTableToMesh} from '@loaders.gl/core/schema-utils';
 import {
   formatLASMeshColors,
   getLASShape,
@@ -24,25 +26,23 @@ export const LAZRsLoaderWithParser = {
   name: 'LAS (laz-rs)',
   parse: async (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) => {
     await initLazRsWasm();
-    return convertLASMesh(parseLAS(arrayBuffer, {...options}), options);
+    return toPublicLASResult(convertLASMesh(parseLAS(arrayBuffer, {...options}), options));
   },
   parseInBatches: async function* (arrayBufferIterator, options?: LASLoaderOptions) {
     await initLazRsWasm();
     for await (const mesh of parseLASInBatches(arrayBufferIterator, options)) {
-      yield convertLASMesh(mesh, options);
+      const result = convertLASMesh(mesh, options);
+      if ('shape' in result) yield* getLASRecordBatches(result);
+      else yield result;
     }
   }
-} as const satisfies LoaderWithParser<
-  LASMesh | MeshArrowTable,
-  LASMesh | MeshArrowTable,
-  LASLoaderOptions
->;
+} as const satisfies LoaderWithParser<LASMesh | Table, LASMesh | RecordBatch, LASLoaderOptions>;
 
 function convertLASMesh(mesh: LASMesh, options?: LASLoaderOptions): LASMesh | MeshArrowTable {
   const formattedMesh = formatLASMeshColors(mesh, options?.las?.colorFormat || 'uint8norm');
-  const table = convertMeshToTable(formattedMesh, 'arrow-table') as MeshArrowTable;
-  if (getLASShape(options) === 'arrow-table') {
-    return table;
+  const table = convertMeshToArrowTableWrapper(formattedMesh) as MeshArrowTable;
+  if (getLASShape(options) === 'arrow') {
+    return {...table, loaderData: mesh.loaderData};
   }
   return {
     ...(convertTableToMesh(table) as LASMesh),

package/src/las/lazperf-loader-types.ts

@@ -4,7 +4,7 @@
 
 // LASER (LAS) FILE FORMAT
 import type {Loader} from '@loaders.gl/core/loader-utils';
-import type {MeshArrowTable} from '@loaders.gl/core/schema';
+import type {Table, RecordBatch} from 'apache-arrow';
 import {LAS_LOADER_METADATA, type LASLoaderOptions} from './las-loader-shared';
 import type {LASMesh} from './lib/las-types';
 
@@ -16,7 +16,7 @@ export const LAZPerfLoader = {
   ...LAS_LOADER_METADATA,
   name: 'LAS (laz-perf)',
   preload: async () => {
-    const {LAZPerfLoaderWithParser} = await import('@loaders.gl/pointclouds/las/lazperf-loader');
+    const {LAZPerfLoaderWithParser} = await import('@loaders.gl/pointclouds/lazperf-loader');
     return LAZPerfLoaderWithParser;
   }
-} as const satisfies Loader<LASMesh | MeshArrowTable, LASMesh | MeshArrowTable, LASLoaderOptions>;
+} as const satisfies Loader<LASMesh | Table, LASMesh | RecordBatch, LASLoaderOptions>;

package/src/las/lazperf-loader.ts

@@ -4,8 +4,10 @@
 
 // LASER (LAS) FILE FORMAT
 import type {LoaderWithParser} from '@loaders.gl/core/loader-utils';
+import type {Table, RecordBatch} from 'apache-arrow';
+import {getLASRecordBatches, toPublicLASResult} from './las-loader';
 import type {MeshArrowTable} from '@loaders.gl/core/schema';
-import {convertMeshToTable, convertTableToMesh} from '@loaders.gl/core/schema-utils';
+import {convertMeshToArrowTableWrapper, convertTableToMesh} from '@loaders.gl/core/schema-utils';
 import {
   formatLASMeshColors,
   getLASShape,
@@ -23,23 +25,19 @@ export const LAZPerfLoaderWithParser = {
   ...LAS_LOADER_METADATA,
   name: 'LAS (laz-perf)',
   parse: async (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) =>
-    convertLASMesh(parseLAS(arrayBuffer, options), options),
+    toPublicLASResult(convertLASMesh(parseLAS(arrayBuffer, options), options)),
   parseSync: (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) =>
-    convertLASMesh(parseLAS(arrayBuffer, options), options),
+    toPublicLASResult(convertLASMesh(parseLAS(arrayBuffer, options), options)),
   parseInBatches: async function* (arrayBufferIterator, options?: LASLoaderOptions) {
     yield* convertLASMeshBatches(parseLASInBatches(arrayBufferIterator, options), options);
   }
-} as const satisfies LoaderWithParser<
-  LASMesh | MeshArrowTable,
-  LASMesh | MeshArrowTable,
-  LASLoaderOptions
->;
+} as const satisfies LoaderWithParser<LASMesh | Table, LASMesh | RecordBatch, LASLoaderOptions>;
 
 function convertLASMesh(mesh: LASMesh, options?: LASLoaderOptions): LASMesh | MeshArrowTable {
   const formattedMesh = formatLASMeshColors(mesh, options?.las?.colorFormat || 'uint8norm');
-  const table = convertMeshToTable(formattedMesh, 'arrow-table') as MeshArrowTable;
-  if (getLASShape(options) === 'arrow-table') {
-    return table;
+  const table = convertMeshToArrowTableWrapper(formattedMesh) as MeshArrowTable;
+  if (getLASShape(options) === 'arrow') {
+    return {...table, loaderData: mesh.loaderData};
   }
   return {
     ...(convertTableToMesh(table) as LASMesh),
@@ -58,8 +56,10 @@ function convertLASMesh(mesh: LASMesh, options?: LASLoaderOptions): LASMesh | Me
 async function* convertLASMeshBatches(
   meshBatches: AsyncIterable<LASMesh>,
   options?: LASLoaderOptions
-): AsyncIterable<LASMesh | MeshArrowTable> {
+): AsyncIterable<LASMesh | RecordBatch> {
   for await (const mesh of meshBatches) {
-    yield convertLASMesh(mesh, options);
+    const result = convertLASMesh(mesh, options);
+    if ('shape' in result) yield* getLASRecordBatches(result);
+    else yield result;
   }
 }

package/src/las/lib/copc/parse-las.ts

@@ -260,6 +260,6 @@ function detectTwoByteColors(
  * @returns Point count per decoded batch
  */
 function getBatchSize(options: LASLoaderOptions): number {
-  const batchSize = options.batchSize ?? options.core?.batchSize;
+  const batchSize = options.core?.batchSize;
   return typeof batchSize === 'number' ? batchSize : DEFAULT_BATCH_SIZE;
 }

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

@@ -46,5 +46,10 @@ export function makeMetadataFromLasHeader(lasHeader: LASHeader): Record<string,
   if (lasHeader.isCompressed !== undefined) {
     metadata.las_isCompressed = lasHeader.isCompressed.toString();
   }
+  if (lasHeader.metadata?.wkt) metadata.las_wkt = lasHeader.metadata.wkt;
+  if (lasHeader.metadata?.wktMathTransform)
+    metadata.las_wktMathTransform = lasHeader.metadata.wktMathTransform;
+  if (lasHeader.metadata?.geotiff)
+    metadata.las_geotiff = JSON.stringify(lasHeader.metadata.geotiff);
   return metadata;
 }

package/src/las/lib/las-extra-bytes.ts

@@ -166,10 +166,12 @@ export function populateLASTypedExtraBytes(
 }
 
 function readLASString(bytes: Uint8Array, offset: number, length: number): string {
-  return new TextDecoder()
-    .decode(bytes.subarray(offset, offset + length))
-    .replace(/\0+$/, '')
-    .trim();
+  const decoded = new TextDecoder().decode(bytes.subarray(offset, offset + length));
+  let end = decoded.length;
+  while (end > 0 && decoded[end - 1] === '\0') {
+    end--;
+  }
+  return decoded.slice(0, end).trim();
 }
 
 function sanitizeExtraBytesName(name: string): string {

package/src/las/lib/laz-perf/parse-las.ts

@@ -3,11 +3,11 @@
 // Copyright (c) vis.gl contributors
 
 // ported and es6-ified from https://github.com/verma/plasio/
-// import type {ArrowTable, ColumnarTable} from '@loaders.gl/core/schema';
+import {getLoaderLog} from '@loaders.gl/core/loader-utils';
 import type {LASLoaderOptions} from '../../las-loader-types';
 import type {LASMesh, LASHeader} from '../las-types';
 import type {MeshAttributes} from '@loaders.gl/core/schema';
-import {getMeshBoundingBox /* , convertMeshToTable */} from '@loaders.gl/core/schema-utils';
+import {getMeshBoundingBox} from '@loaders.gl/core/schema-utils';
 import {concatenateArrayBuffersAsync} from '@loaders.gl/core/loader-utils';
 import {getLASSchema} from '../get-las-schema';
 import {LASFile} from './laslaz-decoder';
@@ -133,7 +133,7 @@ function parseLASMesh(arrayBuffer: ArrayBuffer, options: LASLoaderOptions = {}):
       offset: [offsetX, offsetY, offsetZ]
     } = lasHeader;
 
-    const twoByteColor = detectTwoByteColors(decoder, batchSize, options.las?.colorDepth);
+    const twoByteColor = detectTwoByteColors(decoder, batchSize, options);
 
     for (let i = 0; i < batchSize; i++) {
       const {position, color, intensity, classification} = decoder.getPoint(i);
@@ -270,7 +270,7 @@ function populateLASAttributes(
     scale: [scaleX, scaleY, scaleZ],
     offset: [offsetX, offsetY, offsetZ]
   } = lasHeader;
-  const twoByteColor = detectTwoByteColors(decoder, batchSize, options.las?.colorDepth);
+  const twoByteColor = detectTwoByteColors(decoder, batchSize, options);
 
   for (let i = 0; i < batchSize; i++) {
     const {position, color, intensity, classification} = decoder.getPoint(i);
@@ -369,7 +369,7 @@ function* parseLASChunkedIterator(
  * @returns Point count per decoded batch
  */
 function getBatchSize(options: LASLoaderOptions): number {
-  const batchSize = options.batchSize ?? options.core?.batchSize;
+  const batchSize = options.core?.batchSize;
   return typeof batchSize === 'number' ? batchSize : DEFAULT_BATCH_SIZE;
 }
 
@@ -382,10 +382,10 @@ function getBatchSize(options: LASLoaderOptions): number {
 function detectTwoByteColors(
   decoder: any = {},
   batchSize: number,
-  colorDepth?: number | string
+  options: LASLoaderOptions
 ): boolean {
   let twoByteColor = false;
-  switch (colorDepth) {
+  switch (options.las?.colorDepth) {
     case 8:
       twoByteColor = false;
       break;
@@ -404,8 +404,7 @@ function detectTwoByteColors(
       }
       break;
     default:
-      // eslint-disable-next-line
-      console.warn('las: illegal value for options.las.colorDepth');
+      getLoaderLog(options).warn('las: illegal value for options.las.colorDepth')();
       break;
   }
   return twoByteColor;

package/src/las/lib/laz-rs-wasm/parse-las.ts

@@ -3,11 +3,11 @@
 // Copyright (c) vis.gl contributors
 
 // ported and es6-ified from https://github.com/verma/plasio/
-// import type {ArrowTable, ColumnarTable} from '@loaders.gl/core/schema';
+import {getLoaderLog} from '@loaders.gl/core/loader-utils';
 import type {LASLoaderOptions} from '../../las-loader-types';
 import type {LASMesh, LASHeader} from '../las-types';
 import type {MeshAttributes} from '@loaders.gl/core/schema';
-import {getMeshBoundingBox /* , convertMeshToTable */} from '@loaders.gl/core/schema-utils';
+import {getMeshBoundingBox} from '@loaders.gl/core/schema-utils';
 import {concatenateArrayBuffersAsync} from '@loaders.gl/core/loader-utils';
 import {getLASSchema} from '../get-las-schema';
 import {LASFile} from './laslaz-decoder';
@@ -133,7 +133,7 @@ function parseLASMesh(arrayBuffer: ArrayBuffer, options: LASLoaderOptions = {}):
       offset: [offsetX, offsetY, offsetZ]
     } = lasHeader;
 
-    const twoByteColor = detectTwoByteColors(decoder, batchSize, options.las?.colorDepth);
+    const twoByteColor = detectTwoByteColors(decoder, batchSize, options);
 
     for (let i = 0; i < batchSize; i++) {
       const {position, color, intensity, classification} = decoder.getPoint(i);
@@ -270,7 +270,7 @@ function populateLASAttributes(
     scale: [scaleX, scaleY, scaleZ],
     offset: [offsetX, offsetY, offsetZ]
   } = lasHeader;
-  const twoByteColor = detectTwoByteColors(decoder, batchSize, options.las?.colorDepth);
+  const twoByteColor = detectTwoByteColors(decoder, batchSize, options);
 
   for (let i = 0; i < batchSize; i++) {
     const {position, color, intensity, classification} = decoder.getPoint(i);
@@ -369,7 +369,7 @@ function* parseLASChunkedIterator(
  * @returns Point count per decoded batch
  */
 function getBatchSize(options: LASLoaderOptions): number {
-  const batchSize = options.batchSize ?? options.core?.batchSize;
+  const batchSize = options.core?.batchSize;
   return typeof batchSize === 'number' ? batchSize : DEFAULT_BATCH_SIZE;
 }
 
@@ -382,10 +382,10 @@ function getBatchSize(options: LASLoaderOptions): number {
 function detectTwoByteColors(
   decoder: any = {},
   batchSize: number,
-  colorDepth?: number | string
+  options: LASLoaderOptions
 ): boolean {
   let twoByteColor = false;
-  switch (colorDepth) {
+  switch (options.las?.colorDepth) {
     case 8:
       twoByteColor = false;
       break;
@@ -404,8 +404,7 @@ function detectTwoByteColors(
       }
       break;
     default:
-      // eslint-disable-next-line
-      console.warn('las: illegal value for options.las.colorDepth');
+      getLoaderLog(options).warn('las: illegal value for options.las.colorDepth')();
       break;
   }
   return twoByteColor;