@cognite/reveal-components 1.0.2 → 1.48552.0

package/dist/domains/terrain/geometry/ContouringService.d.ts

@@ -1,12 +1,12 @@
-import { RegularGrid2 } from './RegularGrid2';
+import { type RegularGrid2 } from "./RegularGrid2";
 export declare class ContouringService {
-    private readonly _tempRange;
-    private readonly _increment;
-    private readonly _tolerance;
-    private readonly _positions;
-    constructor(increment: number);
-    createContoursAsPositions(grid: RegularGrid2): number[];
-    private addTriangle;
-    private addLevelAt;
-    private addLinearInterpolation;
+	private readonly _tempRange;
+	private readonly _increment;
+	private readonly _tolerance;
+	private readonly _positions;
+	constructor(increment: number);
+	createContoursAsPositions(grid: RegularGrid2): number[];
+	private addTriangle;
+	private addLevelAt;
+	private addLinearInterpolation;
 }

package/dist/domains/terrain/geometry/ContouringService.js

@@ -1,39 +1,109 @@
-import { isAbsEqual as e, isBetween as t } from "../../../foundation/utilities/extensions/mathUtils.js";
-import { Range1 as n } from "../../../foundation/utilities/geometry/Range1.js";
-import { Vector3 as r } from "three";
-//#region libs/shared/reveal-components/src/domains/terrain/geometry/ContouringService.ts
-var i = class {
-	_tempRange = new n();
-	_increment;
-	_tolerance;
-	_positions = [];
-	constructor(e) {
-		this._increment = e, this._tolerance = this._increment / 1e3;
-	}
-	createContoursAsPositions(e) {
-		let t = new r(), n = new r(), i = new r(), a = new r();
-		for (let r = 0; r < e.nodeSize.i - 1; r++) for (let o = 0; o < e.nodeSize.j - 1; o++) {
-			let s = e.getRelativeNodePosition(r + 0, o + 0, t), c = e.getRelativeNodePosition(r + 1, o + 0, n), l = e.getRelativeNodePosition(r + 1, o + 1, i), u = e.getRelativeNodePosition(r + 0, o + 1, a), d = 0;
-			s && (d += 1), l && (d += 1), l && (d += 1), u && (d += 1), !(d < 3) && (s || this.addTriangle(n, i, a), (d === 4 || !c) && this.addTriangle(t, i, a), l || this.addTriangle(t, n, a), (d === 4 || !u) && this.addTriangle(t, n, i));
-		}
-		return this._positions;
-	}
-	addTriangle(e, t, n) {
-		this._tempRange.set(Math.min(e.z, t.z, n.z), Math.max(e.z, t.z, n.z));
-		for (let r of this._tempRange.getFastTicks(this._increment, this._tolerance)) {
-			let i = Number(r);
-			this.addLevelAt(i, e, t, n);
-		}
-	}
-	addLevelAt(n, r, i, a) {
-		e(r.z, n, this._tolerance) && (r.z = n + this._tolerance), e(i.z, n, this._tolerance) && (i.z = n + this._tolerance), e(a.z, n, this._tolerance) && (a.z = n + this._tolerance), e(r.z, i.z, this._tolerance) && (i.z = r.z + this._tolerance);
-		let o = t(r.z, n, i.z), s = t(i.z, n, a.z), c = t(a.z, n, r.z), l = 0;
-		return o && l++, s && l++, c && l++, l === 2 && (o && this.addLinearInterpolation(r, i, n), s && this.addLinearInterpolation(i, a, n), c && this.addLinearInterpolation(a, r, n), !0);
-	}
-	addLinearInterpolation(e, t, n) {
-		let r = (n - e.z) / (t.z - e.z);
-		this._positions.push((t.x - e.x) * r + e.x, (t.y - e.y) * r + e.y, n);
-	}
-};
-//#endregion
-export { i as ContouringService };
+import { Vector3 } from "three";
+import { isAbsEqual, isBetween } from "../../../foundation/utilities/extensions/mathUtils.js";
+import { Range1 } from "../../../foundation/utilities/geometry/Range1.js";
+export class ContouringService {
+    // ==================================================
+    // CONSTRUCTOR
+    // ==================================================
+    constructor(increment){
+        // ==================================================
+        // INSTANCE FIELDS
+        // ==================================================
+        this._tempRange = new Range1();
+        this._positions = [];
+        this._increment = increment;
+        this._tolerance = this._increment / 1000;
+    }
+    // ==================================================
+    // INSTANCE METHODS: Create functions
+    // ==================================================
+    createContoursAsPositions(grid) {
+        const p0 = new Vector3();
+        const p1 = new Vector3();
+        const p2 = new Vector3();
+        const p3 = new Vector3();
+        for(let i = 0; i < grid.nodeSize.i - 1; i++){
+            for(let j = 0; j < grid.nodeSize.j - 1; j++){
+                const isDef0 = grid.getRelativeNodePosition(i + 0, j + 0, p0);
+                const isDef1 = grid.getRelativeNodePosition(i + 1, j + 0, p1);
+                const isDef2 = grid.getRelativeNodePosition(i + 1, j + 1, p2);
+                const isDef3 = grid.getRelativeNodePosition(i + 0, j + 1, p3);
+                let triangleCount = 0;
+                if (isDef0) triangleCount += 1;
+                if (isDef2) triangleCount += 1;
+                if (isDef2) triangleCount += 1;
+                if (isDef3) triangleCount += 1;
+                if (triangleCount < 3) {
+                    continue;
+                }
+                // (i,j+1)     (i+1,j+1)
+                //     3------2
+                //     |      |
+                //     0------1
+                // (i,j)       (i+1,j)
+                if (!isDef0) {
+                    this.addTriangle(p1, p2, p3);
+                }
+                if (triangleCount === 4 || !isDef1) {
+                    this.addTriangle(p0, p2, p3);
+                }
+                if (!isDef2) {
+                    this.addTriangle(p0, p1, p3);
+                }
+                if (triangleCount === 4 || !isDef3) {
+                    this.addTriangle(p0, p1, p2);
+                }
+            }
+        }
+        return this._positions;
+    }
+    // ==================================================
+    // INSTANCE METHODS: Helpers
+    // ==================================================
+    addTriangle(a, b, c) {
+        this._tempRange.set(Math.min(a.z, b.z, c.z), Math.max(a.z, b.z, c.z));
+        for (const anyTick of this._tempRange.getFastTicks(this._increment, this._tolerance)){
+            const z = Number(anyTick);
+            this.addLevelAt(z, a, b, c);
+        }
+    }
+    addLevelAt(z, a, b, c) {
+        // Make sure we don't run into numerical problems
+        if (isAbsEqual(a.z, z, this._tolerance)) {
+            a.z = z + this._tolerance;
+        }
+        if (isAbsEqual(b.z, z, this._tolerance)) {
+            b.z = z + this._tolerance;
+        }
+        if (isAbsEqual(c.z, z, this._tolerance)) {
+            c.z = z + this._tolerance;
+        }
+        if (isAbsEqual(a.z, b.z, this._tolerance)) {
+            b.z = a.z + this._tolerance;
+        }
+        // Intersection of two of the edges
+        const ab = isBetween(a.z, z, b.z);
+        const bc = isBetween(b.z, z, c.z);
+        const ca = isBetween(c.z, z, a.z);
+        let numPoints = 0;
+        if (ab) numPoints++;
+        if (bc) numPoints++;
+        if (ca) numPoints++;
+        if (numPoints !== 2) {
+            return false; // should never come here, but this is a safety value
+        }
+        if (ab) this.addLinearInterpolation(a, b, z);
+        if (bc) this.addLinearInterpolation(b, c, z);
+        if (ca) this.addLinearInterpolation(c, a, z);
+        return true;
+    }
+    addLinearInterpolation(a, b, z) {
+        // Z is assumed to be on or between a.Z and b.Z, used by the function below
+        // a.Z and b.Z is assumed to be different (Check by yourself)
+        // Returns  a + (b-a)*(z-a.Z)/(b.Z-a.Z);  (unrolled code)
+        const f = (z - a.z) / (b.z - a.z);
+        this._positions.push((b.x - a.x) * f + a.x, (b.y - a.y) * f + a.y, z);
+    }
+}
+
+//# sourceMappingURL=ContouringService.js.map

package/dist/domains/terrain/geometry/ContouringService.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/domains/terrain/geometry/ContouringService.ts"],"sourcesContent":["import { Vector3 } from 'three';\n\nimport {\n  isAbsEqual,\n  isBetween,\n} from '../../../foundation/utilities/extensions/mathUtils';\nimport { Range1 } from '../../../foundation/utilities/geometry/Range1';\n\nimport { type RegularGrid2 } from './RegularGrid2';\n\nexport class ContouringService {\n  // ==================================================\n  // INSTANCE FIELDS\n  // ==================================================\n\n  private readonly _tempRange = new Range1();\n  private readonly _increment: number;\n  private readonly _tolerance: number;\n  private readonly _positions: number[] = [];\n\n  // ==================================================\n  // CONSTRUCTOR\n  // ==================================================\n\n  public constructor(increment: number) {\n    this._increment = increment;\n    this._tolerance = this._increment / 1000;\n  }\n\n  // ==================================================\n  // INSTANCE METHODS: Create functions\n  // ==================================================\n\n  public createContoursAsPositions(grid: RegularGrid2): number[] {\n    const p0 = new Vector3();\n    const p1 = new Vector3();\n    const p2 = new Vector3();\n    const p3 = new Vector3();\n\n    for (let i = 0; i < grid.nodeSize.i - 1; i++) {\n      for (let j = 0; j < grid.nodeSize.j - 1; j++) {\n        const isDef0 = grid.getRelativeNodePosition(i + 0, j + 0, p0);\n        const isDef1 = grid.getRelativeNodePosition(i + 1, j + 0, p1);\n        const isDef2 = grid.getRelativeNodePosition(i + 1, j + 1, p2);\n        const isDef3 = grid.getRelativeNodePosition(i + 0, j + 1, p3);\n\n        let triangleCount = 0;\n        if (isDef0) triangleCount += 1;\n        if (isDef2) triangleCount += 1;\n        if (isDef2) triangleCount += 1;\n        if (isDef3) triangleCount += 1;\n\n        if (triangleCount < 3) {\n          continue;\n        }\n        // (i,j+1)     (i+1,j+1)\n        //     3------2\n        //     |      |\n        //     0------1\n        // (i,j)       (i+1,j)\n\n        if (!isDef0) {\n          this.addTriangle(p1, p2, p3);\n        }\n        if (triangleCount === 4 || !isDef1) {\n          this.addTriangle(p0, p2, p3);\n        }\n        if (!isDef2) {\n          this.addTriangle(p0, p1, p3);\n        }\n        if (triangleCount === 4 || !isDef3) {\n          this.addTriangle(p0, p1, p2);\n        }\n      }\n    }\n    return this._positions;\n  }\n\n  // ==================================================\n  // INSTANCE METHODS: Helpers\n  // ==================================================\n\n  private addTriangle(a: Vector3, b: Vector3, c: Vector3): void {\n    this._tempRange.set(Math.min(a.z, b.z, c.z), Math.max(a.z, b.z, c.z));\n\n    for (const anyTick of this._tempRange.getFastTicks(\n      this._increment,\n      this._tolerance\n    )) {\n      const z = Number(anyTick);\n      this.addLevelAt(z, a, b, c);\n    }\n  }\n\n  private addLevelAt(z: number, a: Vector3, b: Vector3, c: Vector3): boolean {\n    // Make sure we don't run into numerical problems\n    if (isAbsEqual(a.z, z, this._tolerance)) {\n      a.z = z + this._tolerance;\n    }\n    if (isAbsEqual(b.z, z, this._tolerance)) {\n      b.z = z + this._tolerance;\n    }\n    if (isAbsEqual(c.z, z, this._tolerance)) {\n      c.z = z + this._tolerance;\n    }\n    if (isAbsEqual(a.z, b.z, this._tolerance)) {\n      b.z = a.z + this._tolerance;\n    }\n    // Intersection of two of the edges\n    const ab = isBetween(a.z, z, b.z);\n    const bc = isBetween(b.z, z, c.z);\n    const ca = isBetween(c.z, z, a.z);\n\n    let numPoints = 0;\n    if (ab) numPoints++;\n    if (bc) numPoints++;\n    if (ca) numPoints++;\n    if (numPoints !== 2) {\n      return false; // should never come here, but this is a safety value\n    }\n    if (ab) this.addLinearInterpolation(a, b, z);\n    if (bc) this.addLinearInterpolation(b, c, z);\n    if (ca) this.addLinearInterpolation(c, a, z);\n    return true;\n  }\n\n  private addLinearInterpolation(a: Vector3, b: Vector3, z: number): void {\n    // Z is assumed to be on or between a.Z and b.Z, used by the function below\n    // a.Z and b.Z is assumed to be different (Check by yourself)\n    // Returns  a + (b-a)*(z-a.Z)/(b.Z-a.Z);  (unrolled code)\n    const f = (z - a.z) / (b.z - a.z);\n    this._positions.push((b.x - a.x) * f + a.x, (b.y - a.y) * f + a.y, z);\n  }\n}\n"],"names":["Vector3","isAbsEqual","isBetween","Range1","ContouringService","increment","_tempRange","_positions","_increment","_tolerance","createContoursAsPositions","grid","p0","p1","p2","p3","i","nodeSize","j","isDef0","getRelativeNodePosition","isDef1","isDef2","isDef3","triangleCount","addTriangle","a","b","c","set","Math","min","z","max","anyTick","getFastTicks","Number","addLevelAt","ab","bc","ca","numPoints","addLinearInterpolation","f","push","x","y"],"mappings":"AAAA,SAASA,OAAO,QAAQ,QAAQ;AAEhC,SACEC,UAAU,EACVC,SAAS,QACJ,wDAAqD;AAC5D,SAASC,MAAM,QAAQ,mDAAgD;AAIvE,OAAO,MAAMC;IAUX,qDAAqD;IACrD,cAAc;IACd,qDAAqD;IAErD,YAAmBC,SAAiB,CAAE;QAbtC,qDAAqD;QACrD,kBAAkB;QAClB,qDAAqD;aAEpCC,aAAa,IAAIH;aAGjBI,aAAuB,EAAE;QAOxC,IAAI,CAACC,UAAU,GAAGH;QAClB,IAAI,CAACI,UAAU,GAAG,IAAI,CAACD,UAAU,GAAG;IACtC;IAEA,qDAAqD;IACrD,qCAAqC;IACrC,qDAAqD;IAE9CE,0BAA0BC,IAAkB,EAAY;QAC7D,MAAMC,KAAK,IAAIZ;QACf,MAAMa,KAAK,IAAIb;QACf,MAAMc,KAAK,IAAId;QACf,MAAMe,KAAK,IAAIf;QAEf,IAAK,IAAIgB,IAAI,GAAGA,IAAIL,KAAKM,QAAQ,CAACD,CAAC,GAAG,GAAGA,IAAK;YAC5C,IAAK,IAAIE,IAAI,GAAGA,IAAIP,KAAKM,QAAQ,CAACC,CAAC,GAAG,GAAGA,IAAK;gBAC5C,MAAMC,SAASR,KAAKS,uBAAuB,CAACJ,IAAI,GAAGE,IAAI,GAAGN;gBAC1D,MAAMS,SAASV,KAAKS,uBAAuB,CAACJ,IAAI,GAAGE,IAAI,GAAGL;gBAC1D,MAAMS,SAASX,KAAKS,uBAAuB,CAACJ,IAAI,GAAGE,IAAI,GAAGJ;gBAC1D,MAAMS,SAASZ,KAAKS,uBAAuB,CAACJ,IAAI,GAAGE,IAAI,GAAGH;gBAE1D,IAAIS,gBAAgB;gBACpB,IAAIL,QAAQK,iBAAiB;gBAC7B,IAAIF,QAAQE,iBAAiB;gBAC7B,IAAIF,QAAQE,iBAAiB;gBAC7B,IAAID,QAAQC,iBAAiB;gBAE7B,IAAIA,gBAAgB,GAAG;oBACrB;gBACF;gBACA,wBAAwB;gBACxB,eAAe;gBACf,eAAe;gBACf,eAAe;gBACf,sBAAsB;gBAEtB,IAAI,CAACL,QAAQ;oBACX,IAAI,CAACM,WAAW,CAACZ,IAAIC,IAAIC;gBAC3B;gBACA,IAAIS,kBAAkB,KAAK,CAACH,QAAQ;oBAClC,IAAI,CAACI,WAAW,CAACb,IAAIE,IAAIC;gBAC3B;gBACA,IAAI,CAACO,QAAQ;oBACX,IAAI,CAACG,WAAW,CAACb,IAAIC,IAAIE;gBAC3B;gBACA,IAAIS,kBAAkB,KAAK,CAACD,QAAQ;oBAClC,IAAI,CAACE,WAAW,CAACb,IAAIC,IAAIC;gBAC3B;YACF;QACF;QACA,OAAO,IAAI,CAACP,UAAU;IACxB;IAEA,qDAAqD;IACrD,4BAA4B;IAC5B,qDAAqD;IAE7CkB,YAAYC,CAAU,EAAEC,CAAU,EAAEC,CAAU,EAAQ;QAC5D,IAAI,CAACtB,UAAU,CAACuB,GAAG,CAACC,KAAKC,GAAG,CAACL,EAAEM,CAAC,EAAEL,EAAEK,CAAC,EAAEJ,EAAEI,CAAC,GAAGF,KAAKG,GAAG,CAACP,EAAEM,CAAC,EAAEL,EAAEK,CAAC,EAAEJ,EAAEI,CAAC;QAEnE,KAAK,MAAME,WAAW,IAAI,CAAC5B,UAAU,CAAC6B,YAAY,CAChD,IAAI,CAAC3B,UAAU,EACf,IAAI,CAACC,UAAU,EACd;YACD,MAAMuB,IAAII,OAAOF;YACjB,IAAI,CAACG,UAAU,CAACL,GAAGN,GAAGC,GAAGC;QAC3B;IACF;IAEQS,WAAWL,CAAS,EAAEN,CAAU,EAAEC,CAAU,EAAEC,CAAU,EAAW;QACzE,iDAAiD;QACjD,IAAI3B,WAAWyB,EAAEM,CAAC,EAAEA,GAAG,IAAI,CAACvB,UAAU,GAAG;YACvCiB,EAAEM,CAAC,GAAGA,IAAI,IAAI,CAACvB,UAAU;QAC3B;QACA,IAAIR,WAAW0B,EAAEK,CAAC,EAAEA,GAAG,IAAI,CAACvB,UAAU,GAAG;YACvCkB,EAAEK,CAAC,GAAGA,IAAI,IAAI,CAACvB,UAAU;QAC3B;QACA,IAAIR,WAAW2B,EAAEI,CAAC,EAAEA,GAAG,IAAI,CAACvB,UAAU,GAAG;YACvCmB,EAAEI,CAAC,GAAGA,IAAI,IAAI,CAACvB,UAAU;QAC3B;QACA,IAAIR,WAAWyB,EAAEM,CAAC,EAAEL,EAAEK,CAAC,EAAE,IAAI,CAACvB,UAAU,GAAG;YACzCkB,EAAEK,CAAC,GAAGN,EAAEM,CAAC,GAAG,IAAI,CAACvB,UAAU;QAC7B;QACA,mCAAmC;QACnC,MAAM6B,KAAKpC,UAAUwB,EAAEM,CAAC,EAAEA,GAAGL,EAAEK,CAAC;QAChC,MAAMO,KAAKrC,UAAUyB,EAAEK,CAAC,EAAEA,GAAGJ,EAAEI,CAAC;QAChC,MAAMQ,KAAKtC,UAAU0B,EAAEI,CAAC,EAAEA,GAAGN,EAAEM,CAAC;QAEhC,IAAIS,YAAY;QAChB,IAAIH,IAAIG;QACR,IAAIF,IAAIE;QACR,IAAID,IAAIC;QACR,IAAIA,cAAc,GAAG;YACnB,OAAO,OAAO,qDAAqD;QACrE;QACA,IAAIH,IAAI,IAAI,CAACI,sBAAsB,CAAChB,GAAGC,GAAGK;QAC1C,IAAIO,IAAI,IAAI,CAACG,sBAAsB,CAACf,GAAGC,GAAGI;QAC1C,IAAIQ,IAAI,IAAI,CAACE,sBAAsB,CAACd,GAAGF,GAAGM;QAC1C,OAAO;IACT;IAEQU,uBAAuBhB,CAAU,EAAEC,CAAU,EAAEK,CAAS,EAAQ;QACtE,2EAA2E;QAC3E,6DAA6D;QAC7D,yDAAyD;QACzD,MAAMW,IAAI,AAACX,CAAAA,IAAIN,EAAEM,CAAC,AAADA,IAAML,CAAAA,EAAEK,CAAC,GAAGN,EAAEM,CAAC,AAADA;QAC/B,IAAI,CAACzB,UAAU,CAACqC,IAAI,CAAC,AAACjB,CAAAA,EAAEkB,CAAC,GAAGnB,EAAEmB,CAAC,AAADA,IAAKF,IAAIjB,EAAEmB,CAAC,EAAE,AAAClB,CAAAA,EAAEmB,CAAC,GAAGpB,EAAEoB,CAAC,AAADA,IAAKH,IAAIjB,EAAEoB,CAAC,EAAEd;IACrE;AACF"}

package/dist/domains/terrain/geometry/Grid2.d.ts

@@ -1,14 +1,14 @@
-import { Index2 } from '../../../foundation/utilities/geometry/Index2';
-import { Range3 } from '../../../foundation/utilities/geometry/Range3';
-import { Shape } from '../../../foundation/utilities/geometry/Shape';
+import { type Index2 } from "../../../foundation/utilities/geometry/Index2";
+import { type Range3 } from "../../../foundation/utilities/geometry/Range3";
+import { Shape } from "../../../foundation/utilities/geometry/Shape";
 export declare class Grid2 extends Shape {
-    readonly nodeSize: Index2;
-    readonly cellSize: Index2;
-    constructor(nodeSize: Index2);
-    clone(): Shape;
-    expandBoundingBox(_: Range3): void;
-    getNodeIndex(i: number, j: number): number;
-    getCellIndex(i: number, j: number): number;
-    isNodeInside(i: number, j: number): boolean;
-    isCellInside(i: number, j: number): boolean;
+	readonly nodeSize: Index2;
+	readonly cellSize: Index2;
+	constructor(nodeSize: Index2);
+	override clone(): Shape;
+	override expandBoundingBox(_: Range3): void;
+	getNodeIndex(i: number, j: number): number;
+	getCellIndex(i: number, j: number): number;
+	isNodeInside(i: number, j: number): boolean;
+	isCellInside(i: number, j: number): boolean;
 }

package/dist/domains/terrain/geometry/Grid2.js

@@ -0,0 +1,40 @@
+import { Shape } from "../../../foundation/utilities/geometry/Shape.js";
+export class Grid2 extends Shape {
+    // ==================================================
+    // CONSTRUCTOR
+    // ==================================================
+    constructor(nodeSize){
+        super();
+        this.nodeSize = nodeSize.clone();
+        this.cellSize = nodeSize.clone();
+        this.cellSize.i -= 1;
+        this.cellSize.j -= 1;
+    }
+    // ==================================================
+    // OVERRIDES of Shape:
+    // ==================================================
+    clone() {
+        return new Grid2(this.nodeSize);
+    }
+    expandBoundingBox(_) {}
+    // ==================================================
+    // INSTANCE METHODS: Getters
+    // ==================================================
+    getNodeIndex(i, j) {
+        return i + this.nodeSize.i * j;
+    }
+    getCellIndex(i, j) {
+        return i + this.cellSize.i * j;
+    }
+    // ==================================================
+    // INSTANCE METHODS: Requests
+    // ==================================================
+    isNodeInside(i, j) {
+        return i >= 0 && j >= 0 && i < this.nodeSize.i && j < this.nodeSize.j;
+    }
+    isCellInside(i, j) {
+        return i >= 0 && j >= 0 && i < this.cellSize.i && j < this.cellSize.j;
+    }
+}
+
+//# sourceMappingURL=Grid2.js.map

package/dist/domains/terrain/geometry/Grid2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/domains/terrain/geometry/Grid2.ts"],"sourcesContent":["import { type Index2 } from '../../../foundation/utilities/geometry/Index2';\nimport { type Range3 } from '../../../foundation/utilities/geometry/Range3';\nimport { Shape } from '../../../foundation/utilities/geometry/Shape';\n\nexport class Grid2 extends Shape {\n  // ==================================================\n  // INSTANCE FIELDS\n  // ==================================================\n\n  public readonly nodeSize: Index2;\n  public readonly cellSize: Index2;\n\n  // ==================================================\n  // CONSTRUCTOR\n  // ==================================================\n\n  public constructor(nodeSize: Index2) {\n    super();\n    this.nodeSize = nodeSize.clone();\n    this.cellSize = nodeSize.clone();\n    this.cellSize.i -= 1;\n    this.cellSize.j -= 1;\n  }\n\n  // ==================================================\n  // OVERRIDES of Shape:\n  // ==================================================\n\n  public override clone(): Shape {\n    return new Grid2(this.nodeSize);\n  }\n\n  public override expandBoundingBox(_: Range3): void {}\n\n  // ==================================================\n  // INSTANCE METHODS: Getters\n  // ==================================================\n\n  public getNodeIndex(i: number, j: number): number {\n    return i + this.nodeSize.i * j;\n  }\n\n  public getCellIndex(i: number, j: number): number {\n    return i + this.cellSize.i * j;\n  }\n\n  // ==================================================\n  // INSTANCE METHODS: Requests\n  // ==================================================\n\n  public isNodeInside(i: number, j: number): boolean {\n    return i >= 0 && j >= 0 && i < this.nodeSize.i && j < this.nodeSize.j;\n  }\n\n  public isCellInside(i: number, j: number): boolean {\n    return i >= 0 && j >= 0 && i < this.cellSize.i && j < this.cellSize.j;\n  }\n}\n"],"names":["Shape","Grid2","nodeSize","clone","cellSize","i","j","expandBoundingBox","_","getNodeIndex","getCellIndex","isNodeInside","isCellInside"],"mappings":"AAEA,SAASA,KAAK,QAAQ,kDAA+C;AAErE,OAAO,MAAMC,cAAcD;IAQzB,qDAAqD;IACrD,cAAc;IACd,qDAAqD;IAErD,YAAmBE,QAAgB,CAAE;QACnC,KAAK;QACL,IAAI,CAACA,QAAQ,GAAGA,SAASC,KAAK;QAC9B,IAAI,CAACC,QAAQ,GAAGF,SAASC,KAAK;QAC9B,IAAI,CAACC,QAAQ,CAACC,CAAC,IAAI;QACnB,IAAI,CAACD,QAAQ,CAACE,CAAC,IAAI;IACrB;IAEA,qDAAqD;IACrD,sBAAsB;IACtB,qDAAqD;IAErCH,QAAe;QAC7B,OAAO,IAAIF,MAAM,IAAI,CAACC,QAAQ;IAChC;IAEgBK,kBAAkBC,CAAS,EAAQ,CAAC;IAEpD,qDAAqD;IACrD,4BAA4B;IAC5B,qDAAqD;IAE9CC,aAAaJ,CAAS,EAAEC,CAAS,EAAU;QAChD,OAAOD,IAAI,IAAI,CAACH,QAAQ,CAACG,CAAC,GAAGC;IAC/B;IAEOI,aAAaL,CAAS,EAAEC,CAAS,EAAU;QAChD,OAAOD,IAAI,IAAI,CAACD,QAAQ,CAACC,CAAC,GAAGC;IAC/B;IAEA,qDAAqD;IACrD,6BAA6B;IAC7B,qDAAqD;IAE9CK,aAAaN,CAAS,EAAEC,CAAS,EAAW;QACjD,OAAOD,KAAK,KAAKC,KAAK,KAAKD,IAAI,IAAI,CAACH,QAAQ,CAACG,CAAC,IAAIC,IAAI,IAAI,CAACJ,QAAQ,CAACI,CAAC;IACvE;IAEOM,aAAaP,CAAS,EAAEC,CAAS,EAAW;QACjD,OAAOD,KAAK,KAAKC,KAAK,KAAKD,IAAI,IAAI,CAACD,QAAQ,CAACC,CAAC,IAAIC,IAAI,IAAI,CAACF,QAAQ,CAACE,CAAC;IACvE;AACF"}

package/dist/domains/terrain/geometry/RegularGrid2.d.ts

@@ -1,36 +1,36 @@
-import { Vector2, Vector3 } from 'three';
-import { Index2 } from '../../../foundation/utilities/geometry/Index2';
-import { Range1 } from '../../../foundation/utilities/geometry/Range1';
-import { Range3 } from '../../../foundation/utilities/geometry/Range3';
-import { Shape } from '../../../foundation/utilities/geometry/Shape';
-import { Grid2 } from './Grid2';
+import { type Vector2, Vector3 } from "three";
+import { Index2 } from "../../../foundation/utilities/geometry/Index2";
+import { type Range1 } from "../../../foundation/utilities/geometry/Range1";
+import { Range3 } from "../../../foundation/utilities/geometry/Range3";
+import { type Shape } from "../../../foundation/utilities/geometry/Shape";
+import { Grid2 } from "./Grid2";
 export declare class RegularGrid2 extends Grid2 {
-    readonly origin: Vector2;
-    readonly increment: Vector2;
-    private _buffer;
-    private _hasRotationAngle;
-    private _rotationAngle;
-    private _sinRotationAngle;
-    private _cosRotationAngle;
-    static _tempVectorA: Vector3;
-    static _tempVectorB: Vector3;
-    get rotationAngle(): number;
-    set rotationAngle(value: number);
-    constructor(nodeSize: Index2, origin: Vector2, increment: Vector2, rotationAngle?: number | undefined);
-    toString(): string;
-    clone(): Shape;
-    expandBoundingBox(boundingBox: Range3): void;
-    isNodeDef(i: number, j: number): boolean;
-    isNodeInsideDef(i: number, j: number): boolean;
-    getZ(i: number, j: number): number;
-    getNodePosition(i: number, j: number, resultPosition?: Vector3): boolean;
-    getNodePosition2(i: number, j: number, resultPosition: Vector3): void;
-    getRelativeNodePosition(i: number, j: number, resultPosition: Vector3): boolean;
-    getCellFromPosition(position: Vector3, resultCell?: Index2): Index2;
-    getNormal(i: number, j: number, z: number | undefined, normalize: boolean, resultNormal?: Vector3): Vector3;
-    getCornerRange(): Range3;
-    setNodeUndef(i: number, j: number): void;
-    setZ(i: number, j: number, value: number): void;
-    normalizeZ(wantedRange?: Range1): void;
-    smoothSimple(numberOfPasses?: number): void;
+	readonly origin: Vector2;
+	readonly increment: Vector2;
+	private _buffer;
+	private _hasRotationAngle;
+	private _rotationAngle;
+	private _sinRotationAngle;
+	private _cosRotationAngle;
+	static _tempVectorA: Vector3;
+	static _tempVectorB: Vector3;
+	get rotationAngle(): number;
+	set rotationAngle(value: number);
+	constructor(nodeSize: Index2, origin: Vector2, increment: Vector2, rotationAngle?: number | undefined);
+	override toString(): string;
+	override clone(): Shape;
+	override expandBoundingBox(boundingBox: Range3): void;
+	isNodeDef(i: number, j: number): boolean;
+	isNodeInsideDef(i: number, j: number): boolean;
+	getZ(i: number, j: number): number;
+	getNodePosition(i: number, j: number, resultPosition?: Vector3): boolean;
+	getNodePosition2(i: number, j: number, resultPosition: Vector3): void;
+	getRelativeNodePosition(i: number, j: number, resultPosition: Vector3): boolean;
+	getCellFromPosition(position: Vector3, resultCell?: Index2): Index2;
+	getNormal(i: number, j: number, z: number | undefined, normalize: boolean, resultNormal?: Vector3): Vector3;
+	getCornerRange(): Range3;
+	setNodeUndef(i: number, j: number): void;
+	setZ(i: number, j: number, value: number): void;
+	normalizeZ(wantedRange?: Range1): void;
+	smoothSimple(numberOfPasses?: number): void;
 }

package/dist/domains/terrain/geometry/RegularGrid2.js

@@ -0,0 +1,302 @@
+import cloneDeep from "lodash-es/cloneDeep";
+import { Vector3 } from "three";
+import { Index2 } from "../../../foundation/utilities/geometry/Index2.js";
+import { Range3 } from "../../../foundation/utilities/geometry/Range3.js";
+import { Grid2 } from "./Grid2.js";
+export class RegularGrid2 extends Grid2 {
+    static{
+        this._tempVectorA = new Vector3();
+    }
+    static{
+        this._tempVectorB = new Vector3();
+    }
+    // ==================================================
+    // INSTANCE PROPERTIES
+    // ==================================================
+    get rotationAngle() {
+        return this._rotationAngle;
+    }
+    set rotationAngle(value) {
+        this._hasRotationAngle = value !== 0;
+        if (this._hasRotationAngle) {
+            this._rotationAngle = value;
+            this._sinRotationAngle = Math.sin(this._rotationAngle);
+            this._cosRotationAngle = Math.cos(this._rotationAngle);
+        } else {
+            this._rotationAngle = 0;
+            this._sinRotationAngle = 0;
+            this._cosRotationAngle = 1;
+        }
+    }
+    // ==================================================
+    // CONSTRUCTOR
+    // ==================================================
+    constructor(nodeSize, origin, increment, rotationAngle = undefined){
+        super(nodeSize), this._hasRotationAngle = false, this._rotationAngle = 0, this._sinRotationAngle = 0 // Due to speed
+        , this._cosRotationAngle = 1 // Due to speed
+        ;
+        this.origin = origin;
+        this.increment = increment;
+        if (rotationAngle !== undefined) {
+            this.rotationAngle = rotationAngle;
+        }
+        this._buffer = new Float32Array(nodeSize.size);
+    }
+    // ==================================================
+    // OVERRIDES of object
+    // ==================================================
+    toString() {
+        return `nodeSize: (${this.nodeSize.toString()}) origin: (${this.origin.x}, ${this.origin.y}) inc: (${this.increment.x}, ${this.increment.y})`;
+    }
+    // ==================================================
+    // OVERRIDES of Shape
+    // ==================================================
+    clone() {
+        return cloneDeep(this);
+    }
+    expandBoundingBox(boundingBox) {
+        const position = new Vector3();
+        for(let j = this.nodeSize.j - 1; j >= 0; j--){
+            for(let i = this.nodeSize.i - 1; i >= 0; i--){
+                if (this.getNodePosition(i, j, position)) {
+                    boundingBox.add(position);
+                }
+            }
+        }
+    }
+    // ==================================================
+    // INSTANCE METHODS: Requests
+    // ==================================================
+    isNodeDef(i, j) {
+        return !Number.isNaN(this.getZ(i, j));
+    }
+    isNodeInsideDef(i, j) {
+        return this.isNodeInside(i, j) && this.isNodeDef(i, j);
+    }
+    // ==================================================
+    // INSTANCE METHODS: Getters
+    // ==================================================
+    getZ(i, j) {
+        const index = this.getNodeIndex(i, j);
+        return this._buffer[index];
+    }
+    // ==================================================
+    // INSTANCE METHODS: Getters: Node position
+    // ==================================================
+    getNodePosition(i, j, resultPosition) {
+        if (resultPosition === undefined) {
+            resultPosition = new Vector3();
+        }
+        const z = this.getZ(i, j);
+        if (Number.isNaN(z)) {
+            return false;
+        }
+        if (this._hasRotationAngle) {
+            const dx = this.increment.x * i;
+            const dy = this.increment.y * j;
+            resultPosition.x = dx * this._cosRotationAngle - dy * this._sinRotationAngle;
+            resultPosition.y = dx * this._sinRotationAngle + dy * this._cosRotationAngle;
+        } else {
+            resultPosition.x = this.increment.x * i;
+            resultPosition.y = this.increment.y * j;
+        }
+        resultPosition.x += this.origin.x;
+        resultPosition.y += this.origin.y;
+        resultPosition.z = z;
+        return true;
+    }
+    getNodePosition2(i, j, resultPosition) {
+        if (this._hasRotationAngle) {
+            const dx = this.increment.x * i;
+            const dy = this.increment.y * j;
+            resultPosition.x = dx * this._cosRotationAngle - dy * this._sinRotationAngle;
+            resultPosition.y = dx * this._sinRotationAngle + dy * this._cosRotationAngle;
+        } else {
+            resultPosition.x = this.increment.x * i;
+            resultPosition.y = this.increment.y * j;
+        }
+        resultPosition.x += this.origin.x;
+        resultPosition.y += this.origin.y;
+    }
+    getRelativeNodePosition(i, j, resultPosition) {
+        const z = this.getZ(i, j);
+        if (Number.isNaN(z)) return false;
+        resultPosition.x = this.increment.x * i;
+        resultPosition.y = this.increment.y * j;
+        resultPosition.z = z;
+        return true;
+    }
+    // ==================================================
+    // INSTANCE METHODS: Getters: Cell position
+    // ==================================================
+    getCellFromPosition(position, resultCell) {
+        if (resultCell === undefined) {
+            resultCell = new Index2();
+        }
+        const dx = position.x - this.origin.x;
+        const dy = position.y - this.origin.y;
+        let i;
+        let j;
+        if (this._hasRotationAngle) {
+            const x = dx * this._cosRotationAngle + dy * this._sinRotationAngle;
+            const y = -dx * this._sinRotationAngle + dy * this._cosRotationAngle;
+            i = x / this.increment.x;
+            j = y / this.increment.y;
+        } else {
+            i = dx / this.increment.x;
+            j = dy / this.increment.y;
+        }
+        resultCell.i = Math.floor(i);
+        resultCell.j = Math.floor(j);
+        return resultCell;
+    }
+    // ==================================================
+    // INSTANCE METHODS: Getters: Others
+    // ==================================================
+    getNormal(i, j, z, normalize, resultNormal) {
+        if (resultNormal === undefined) {
+            resultNormal = new Vector3();
+        }
+        if (z === undefined) {
+            z = this.getZ(i, j);
+        }
+        resultNormal.set(0, 0, 0);
+        let def0 = this.isNodeInside(i + 1, j + 0);
+        let def1 = this.isNodeInside(i + 0, j + 1);
+        let def2 = this.isNodeInside(i - 1, j + 0);
+        let def3 = this.isNodeInside(i + 0, j - 1);
+        const i0 = def0 ? this.getNodeIndex(i + 1, j + 0) : -1;
+        const i1 = def1 ? this.getNodeIndex(i + 0, j + 1) : -1;
+        const i2 = def2 ? this.getNodeIndex(i - 1, j + 0) : -1;
+        const i3 = def3 ? this.getNodeIndex(i + 0, j - 1) : -1;
+        let z0 = def0 ? this._buffer[i0] : 0;
+        let z1 = def1 ? this._buffer[i1] : 0;
+        let z2 = def2 ? this._buffer[i2] : 0;
+        let z3 = def3 ? this._buffer[i3] : 0;
+        if (def0) {
+            if (Number.isNaN(z0)) def0 = false;
+            else z0 -= z;
+        }
+        if (def1) {
+            if (Number.isNaN(z1)) def1 = false;
+            else z1 -= z;
+        }
+        if (def2) {
+            if (Number.isNaN(z2)) def2 = false;
+            else z2 -= z;
+        }
+        if (def3) {
+            if (Number.isNaN(z3)) def3 = false;
+            else z3 -= z;
+        }
+        const a = RegularGrid2._tempVectorA;
+        const b = RegularGrid2._tempVectorB;
+        if (def0 && def1) {
+            a.set(+this.increment.x, 0, z0);
+            b.set(0, +this.increment.y, z1);
+            a.cross(b);
+            resultNormal.add(a);
+        }
+        if (def1 && def2) {
+            a.set(0, +this.increment.y, z1);
+            b.set(-this.increment.x, 0, z2);
+            a.cross(b);
+            resultNormal.add(a);
+        }
+        if (def2 && def3) {
+            a.set(-this.increment.x, 0, z2);
+            b.set(0, -this.increment.y, z3);
+            a.cross(b);
+            resultNormal.add(a);
+        }
+        if (def3 && def0) {
+            a.set(0, -this.increment.y, z3);
+            b.set(+this.increment.x, 0, z0);
+            a.cross(b);
+            resultNormal.add(a);
+        }
+        if (normalize) {
+            resultNormal.normalize();
+            if (resultNormal.lengthSq() < 0.5) {
+                resultNormal.set(0, 0, 1); // If the normal is too small, we assume it is a flat surface
+            }
+        }
+        return resultNormal;
+    }
+    getCornerRange() {
+        const corner = new Vector3();
+        const range = new Range3();
+        range.addHorizontal(this.origin);
+        this.getNodePosition2(0, this.nodeSize.j - 1, corner);
+        range.add(corner);
+        this.getNodePosition2(this.nodeSize.i - 1, 0, corner);
+        range.add(corner);
+        this.getNodePosition2(this.nodeSize.i - 1, this.nodeSize.j - 1, corner);
+        range.add(corner);
+        return range;
+    }
+    // ==================================================
+    // INSTANCE METHODS: Setters
+    // ==================================================
+    setNodeUndef(i, j) {
+        this.setZ(i, j, Number.NaN);
+    }
+    setZ(i, j, value) {
+        const index = this.getNodeIndex(i, j);
+        this._buffer[index] = value;
+    }
+    // ==================================================
+    // INSTANCE METHODS: Operation
+    // ==================================================
+    normalizeZ(wantedRange) {
+        const currentRange = this.zRange;
+        for(let i = this._buffer.length - 1; i >= 0; i--){
+            let z = this._buffer[i];
+            z = currentRange.getFraction(z);
+            if (wantedRange !== undefined) z = wantedRange.getValue(z);
+            this._buffer[i] = z;
+        }
+        this.touch();
+    }
+    smoothSimple(numberOfPasses = 1) {
+        if (numberOfPasses <= 0) {
+            return;
+        }
+        let buffer = new Float32Array(this.nodeSize.size);
+        for(let pass = 0; pass < numberOfPasses; pass++){
+            for(let i = this.nodeSize.i - 1; i >= 0; i--)for(let j = this.nodeSize.j - 1; j >= 0; j--){
+                if (!this.isNodeDef(i, j)) continue;
+                const iMin = Math.max(i - 1, 0);
+                const iMax = Math.min(i + 1, this.cellSize.i);
+                const jMin = Math.max(j - 1, 0);
+                const jMax = Math.min(j + 1, this.cellSize.j);
+                let count = 0;
+                let sum = 0;
+                // New value = (Sum the surrounding values + 2 * Current value) / N
+                for(let ii = iMin; ii <= iMax; ii++){
+                    for(let jj = jMin; jj <= jMax; jj++){
+                        if (ii === i && jj === j) {
+                            continue;
+                        }
+                        if (!this.isNodeDef(ii, jj)) {
+                            continue;
+                        }
+                        sum += this.getZ(ii, jj);
+                        count += 1;
+                    }
+                }
+                sum += this.getZ(i, j) * count;
+                count += count;
+                const index = this.getNodeIndex(i, j);
+                buffer[index] = sum / count;
+            }
+            [this._buffer, buffer] = [
+                buffer,
+                this._buffer
+            ]; // Swap buffers
+        }
+        this.touch();
+    }
+}
+
+//# sourceMappingURL=RegularGrid2.js.map