Merge pull request #2 from vojtatom/dev

Releasing 1.0.0

Author: vojtatom

README.md

@@ -13,11 +13,6 @@ TypeScript package for loading LAS/LAZ, primary developed for for WebGL applicat
 npm install lazts
 ```
 
-| Branch  |                                                                                                                                                                            |
-| ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Release | [![LAZts CI Release](https://github.com/vojtatom/laz.ts/actions/workflows/ci.yaml/badge.svg?branch=release)](https://github.com/vojtatom/laz.ts/actions/workflows/ci.yaml) |
-| Dev     | [![LAZts CI Dev](https://github.com/vojtatom/laz.ts/actions/workflows/ci.yaml/badge.svg?branch=dev)](https://github.com/vojtatom/laz.ts/actions/workflows/ci.yaml)         |
-
 ## Usage
 
 ```ts
@@ -53,3 +48,11 @@ interface LazData {
     };
 }
 ```
+
+When working with funky coordinates (e.g. the coordinates are too big and there is no offset), you can use the `adjustOffset` option:
+
+```ts
+const dataWithNonZeroOffset = await parse(buffer, {
+    adjustOffset: true,
+});
+```

lazts/src/adjust.ts

@@ -0,0 +1,29 @@
+import { LASData } from './types';
+
+export function adjust(data: LASData) {
+    //find centroid
+    const positions = data.attributes.position.value as Int32Array;
+    if (!positions) return;
+
+    const center = [0, 0, 0];
+    for (let i = 0; i < positions.length; i++) center[i % 3] += positions[i];
+
+    //update centroid so that it is only the non-decimal part shifted
+    const scale = data.header.scale;
+    center[0] /= positions.length / 3;
+    center[0] = Math.round(Math.round(center[0] * scale[0]) / scale[0]);
+    center[1] /= positions.length / 3;
+    center[1] = Math.round(Math.round(center[1] * scale[1]) / scale[1]);
+    center[2] /= positions.length / 3;
+    center[2] = Math.round(Math.round(center[2] * scale[2]) / scale[2]);
+
+    console.log(center);
+
+    //adjust
+    for (let i = 0; i < positions.length; i++) positions[i] -= center[i % 3];
+
+    //update header
+    data.header.offset[0] += Math.round(center[0] * scale[0]);
+    data.header.offset[1] += Math.round(center[1] * scale[1]);
+    data.header.offset[2] += Math.round(center[2] * scale[2]);
+}

lazts/src/parse.ts

@@ -1,14 +1,24 @@
 import { LASData, LASHeader } from './types';
 import { logStatistics } from './log';
 import { parseLASChunked } from './parseChunk';
+import { adjust } from './adjust';
 
-export async function parse(arrayBuffer: ArrayBuffer): Promise<LASData> {
+interface ParseOptions {
+    adjustOffset?: boolean;
+    skip?: number;
+}
+
+export async function parse(arrayBuffer: ArrayBuffer, options?: ParseOptions): Promise<LASData> {
     const lasData: LASData = {
         header: {} as LASHeader,
         attributes: {},
     };
 
-    await parseLASChunked(arrayBuffer, lasData, 1);
+    const { adjustOffset = false, skip = 1 } = options || {};
+
+    await parseLASChunked(arrayBuffer, lasData, skip);
+
+    if (adjustOffset) adjust(lasData);
     logStatistics(lasData, arrayBuffer.byteLength);
     return lasData;
 }

package.json

@@ -1,7 +1,7 @@
 {
     "name": "lazts",
     "private": false,
-    "version": "0.1.0",
+    "version": "1.0.0",
     "type": "module",
     "repository": {
         "type": "git",

test/test.test.ts

@@ -8,8 +8,22 @@ test('Basic test LAZ', async () => {
     console.log(data);
 });
 
-test('Basic test LAA', async () => {
+test('Basic test LAS', async () => {
     const buffer = openFileAsArray('testdata/test.las');
     const data = await parse(buffer);
     console.log(data);
 });
+
+test('Basic test no offset LAZ', async () => {
+    const buffer = openFileAsArray('testdata/testNoOffset.laz');
+    const data = await parse(buffer);
+    console.log(data);
+    data.header.offset.forEach((v) => expect(v).toBeCloseTo(0));
+
+    const dataAdjusted = await parse(buffer, {
+        adjustOffset: true,
+    });
+
+    console.log(dataAdjusted);
+    dataAdjusted.header.offset.forEach((v) => expect(v).not.toBeCloseTo(0));
+});