dgeoutils 2.2.9 → 2.2.13

package/dist/DPlane.d.ts

@@ -0,0 +1,25 @@
+import { DPoint } from './DPoint';
+import { DPolygon } from './DPolygon';
+export declare class DPlane {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    p1: DPoint;
+    p2: DPoint;
+    p3: DPoint;
+    constructor(a: number, b: number, c: number, d: number, p1?: DPoint, p2?: DPoint, p3?: DPoint);
+    static find(p1: DPoint, p2: DPoint, p3: DPoint): DPlane;
+    x(p: DPoint): DPoint;
+    x(p: DPolygon): DPolygon;
+    y(p: DPoint): DPoint;
+    y(p: DPolygon): DPolygon;
+    z(p: DPoint): DPoint;
+    z(p: DPolygon): DPolygon;
+    clone(): DPlane;
+    distance(p: DPoint): number;
+    distance(p: DPlane): number;
+    equal(p: DPlane): boolean;
+    same(p: DPlane): boolean;
+    parallel(p: DPlane): boolean;
+}

package/dist/DPlane.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DPlane = void 0;
+const DPoint_1 = require("./DPoint");
+const utils_1 = require("./utils");
+const DNumbers_1 = require("./DNumbers");
+class DPlane {
+    constructor(a, b, c, d, p1 = DPoint_1.DPoint.zero(), p2 = DPoint_1.DPoint.zero(), p3 = DPoint_1.DPoint.zero()) {
+        this.a = a;
+        this.b = b;
+        this.c = c;
+        this.d = d;
+        this.p1 = p1;
+        this.p2 = p2;
+        this.p3 = p3;
+    }
+    static find(p1, p2, p3) {
+        if (p1.x === p2.x && p2.x === p3.x) {
+            return new DPlane(1, 0, 0, -p1.x, p1, p2, p3);
+        }
+        if (p1.y === p2.y && p2.y === p3.y) {
+            return new DPlane(0, 1, 0, -p1.y, p1, p2, p3);
+        }
+        if (p1.z === p2.z && p2.z === p3.z) {
+            return new DPlane(0, 0, 1, -p1.z, p1, p2, p3);
+        }
+        const d = 1;
+        const [a, b, c] = (0, utils_1.gaussianElimination)([
+            [p1.x, p1.y, p1.z, -d],
+            [p2.x, p2.y, p2.z, -d],
+            [p3.x, p3.y, p3.z, -d]
+        ]);
+        return new DPlane(a, b, c, d, p1, p2, p3);
+    }
+    x(p) {
+        if (p instanceof DPoint_1.DPoint) {
+            const { a, b, c, d } = this;
+            const { y, z } = p;
+            p.x = -(b * y + c * z + d) / a;
+            return p;
+        }
+        return p.map((t) => this.x(t));
+    }
+    y(p) {
+        if (p instanceof DPoint_1.DPoint) {
+            const { a, b, c, d } = this;
+            const { x, z } = p;
+            p.y = -(a * x + c * z + d) / b;
+            return p;
+        }
+        return p.map((t) => this.y(t));
+    }
+    z(p) {
+        if (p instanceof DPoint_1.DPoint) {
+            const { a, b, c, d } = this;
+            const { x, y } = p;
+            p.z = -(a * x + b * y + d) / c;
+            return p;
+        }
+        return p.map((t) => this.z(t));
+    }
+    clone() {
+        const { a, b, c, d, p1, p2, p3 } = this;
+        return new DPlane(a, b, c, d, p1, p2, p3);
+    }
+    distance(p) {
+        if (p instanceof DPoint_1.DPoint) {
+            const { x, y, z } = p;
+            const { a, b, c, d } = this;
+            return Math.abs(a * x + b * y + c * z + d) / Math.sqrt(a * a + b * b + c * c);
+        }
+        const { a, b, c, d } = p;
+        const { d: r } = this;
+        return Math.abs(d - r) / Math.sqrt(a * a + b * b + c * c);
+    }
+    equal(p) {
+        const { a, b, c, d } = p;
+        const { a: q, b: w, c: e, d: r } = this;
+        return DNumbers_1.DNumbers.like(a, q) &&
+            DNumbers_1.DNumbers.like(b, w) &&
+            DNumbers_1.DNumbers.like(c, e) &&
+            DNumbers_1.DNumbers.like(d, r);
+    }
+    same(p) {
+        const { a, b, c, d } = p;
+        const { a: q, b: w, c: e, d: r } = this;
+        const t = a / q;
+        const y = b / w;
+        const u = c / e;
+        const i = d / r;
+        return DNumbers_1.DNumbers.like(t, y) &&
+            DNumbers_1.DNumbers.like(t, u) &&
+            DNumbers_1.DNumbers.like(t, c) &&
+            DNumbers_1.DNumbers.like(t, i);
+    }
+    parallel(p) {
+        const { a, b, c, d } = p;
+        const { a: q, b: w, c: e, d: r } = this;
+        const t = a / q;
+        const y = b / w;
+        const u = c / e;
+        const i = d / r;
+        return DNumbers_1.DNumbers.like(t, y) &&
+            DNumbers_1.DNumbers.like(t, u) &&
+            DNumbers_1.DNumbers.like(t, c) &&
+            !DNumbers_1.DNumbers.like(t, i);
+    }
+}
+exports.DPlane = DPlane;

package/dist/DPoint.d.ts

@@ -49,9 +49,13 @@ export declare class DPoint {
     gtOrEqual(p: DPoint): boolean;
     ltOrEqual(p: DPoint): boolean;
     rotate(a: number): DPoint;
+    rotate3dX(a: number): DPoint;
+    rotate3dY(a: number): DPoint;
+    rotate3dZ(a: number): DPoint;
     move(v: number): DPoint;
     move(p: DPoint): DPoint;
     move(x: number, y: number): DPoint;
+    move(x: number, y: number, z: number): DPoint;
     degreeToMeters(): DPoint;
     metersToDegree(): DPoint;
     degreeToRadians(): DPoint;
@@ -66,9 +70,11 @@ export declare class DPoint {
     scale(v: number): DPoint;
     scale(p: DPoint): DPoint;
     scale(x: number, y: number): DPoint;
+    scale(x: number, y: number, z: number): DPoint;
     divide(v: number): DPoint;
     divide(p: DPoint): DPoint;
     divide(x: number, y: number): DPoint;
+    divide(x: number, y: number, z: number): DPoint;
     equal(p: DPoint): boolean;
     like(p: DPoint, d?: number): boolean;
     flipVertically(size: DPoint): DPoint;

package/dist/DPoint.js

@@ -164,19 +164,47 @@ class DPoint {
         this.y = y;
         return this;
     }
-    move(x, y = x) {
+    rotate3dX(a) {
+        const { y, z } = this;
+        this.y = y * Math.cos(a) + z * Math.sin(a);
+        this.z = -y * Math.sin(a) + z * Math.cos(a);
+        return this;
+    }
+    rotate3dY(a) {
+        const { x, z } = this;
+        this.x = x * Math.cos(a) + z * Math.sin(a);
+        this.z = -x * Math.sin(a) + z * Math.cos(a);
+        return this;
+    }
+    rotate3dZ(a) {
+        const { x, y } = this;
+        this.x = x * Math.cos(a) - y * Math.sin(a);
+        this.y = -x * Math.sin(a) + y * Math.cos(a);
+        return this;
+    }
+    move(x, y = x, z) {
         let xV = 0;
         let yV = 0;
+        let zV = undefined;
         if (x instanceof DPoint) {
             xV = this.x + x.x;
             yV = this.y + x.y;
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(x.z)) {
+                zV = this.z + x.z;
+            }
         }
         else {
             xV = this.x + x;
             yV = this.y + y;
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(z)) {
+                zV = this.z + z;
+            }
         }
         this.x = xV;
         this.y = yV;
+        if ((0, utils_1.isDefAndNotNull)(zV)) {
+            this.z = zV;
+        }
         return this;
     }
     degreeToMeters() {
@@ -250,46 +278,67 @@ class DPoint {
         this.y = Math.abs(this.y);
         return this;
     }
-    scale(x, y = x) {
+    scale(x, y = x, z) {
         let xV = 0;
         let yV = 0;
+        let zV = undefined;
         if (x instanceof DPoint) {
             xV = this.x * x.x;
             yV = this.y * x.y;
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(x.z)) {
+                zV = this.z * x.z;
+            }
         }
         else {
             xV = this.x * x;
             yV = this.y * y;
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(z)) {
+                zV = this.z * z;
+            }
         }
         this.x = xV;
         this.y = yV;
+        if ((0, utils_1.isDefAndNotNull)(zV)) {
+            this.z = zV;
+        }
         return this;
     }
-    divide(x, y = x) {
+    divide(x, y = x, z) {
         let xV = 0;
         let yV = 0;
+        let zV = undefined;
         if (x instanceof DPoint) {
             xV = this.x / x.x;
             yV = this.y / x.y;
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(x.z)) {
+                zV = this.z / x.z;
+            }
         }
         else {
             xV = this.x / x;
             yV = this.y / y;
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(z)) {
+                zV = this.z / z;
+            }
         }
         this.x = xV;
         this.y = yV;
+        if ((0, utils_1.isDefAndNotNull)(zV)) {
+            this.z = zV;
+        }
         return this;
     }
     equal(p) {
         return this.x === p.x && this.y === p.y && this.z === p.z;
     }
     like(p, d = 0.001) {
+        var _a, _b, _c, _d;
         if (this.equal(p)) {
             return true;
         }
         const likeX = Math.abs(this.x - p.x) < d;
         const likeY = Math.abs(this.y - p.y) < d;
-        const likeZ = Math.abs((this.z || 0) - (p.z || 0)) < d;
+        const likeZ = Math.abs(((_b = (_a = this.z) !== null && _a !== void 0 ? _a : p.z) !== null && _b !== void 0 ? _b : 0) - ((_d = (_c = p.z) !== null && _c !== void 0 ? _c : this.z) !== null && _d !== void 0 ? _d : 0)) < d;
         return likeX && likeY && likeZ;
     }
     flipVertically(size) {
@@ -378,7 +427,7 @@ class DPoint {
         return this;
     }
     minus() {
-        return this.clone().scale(-1);
+        return this.scale(-1);
     }
     orthodromicPath(point, pointsCount = 360) {
         (0, utils_1.checkFunction)('orthodromicPath')

package/dist/DPolygon.d.ts

@@ -54,7 +54,7 @@ export declare class DPolygon {
     setCenter(newCenter: DPoint): DPolygon;
     static WKT_LINESTRING: string;
     static WKT_POLYGON: string;
-    toWKT(type?: string): string;
+    toWKT(type?: string, withZ?: boolean): string;
     filter(f: (p: DPoint) => boolean): DPolygon;
     map(f: (r: DPoint) => DPoint): DPolygon;
     map(f: (r: DPoint, index: number) => DPoint): DPolygon;
@@ -101,6 +101,8 @@ export declare class DPolygon {
     getTrianglesPointIndexes(): number[];
     get closed(): boolean;
     buffer(v: number, quadrantSegments?: number, type?: number): DPolygon;
+    bezier(step?: number): DPolygon;
+    private getBezierPoint;
     private simpleIncludeX;
     private simpleIncludeY;
     private douglasPeucker;

package/dist/DPolygon.js

@@ -326,17 +326,17 @@ class DPolygon {
             .move(newCenter.clone().move(this.center.minus()))
             .run();
     }
-    toWKT(type = DPolygon.WKT_POLYGON) {
+    toWKT(type = DPolygon.WKT_POLYGON, withZ = false) {
         if (type === DPolygon.WKT_POLYGON) {
             let h = '';
             if (this.holes && this.holes.length) {
                 h = `, ${this.holes.map((hole) => hole.toString())
                     .join(', ')}`;
             }
-            return `POLYGON ((${this.deintersection.pPoints.map((r) => `${r.x} ${r.y}`)
+            return `POLYGON ((${this.deintersection.pPoints.map((r) => `${r.x} ${r.y}${withZ ? ` ${r.z}` : ''}`)
                 .join(', ')})${h})`;
         }
-        return `LINESTRING (${this.pPoints.map((r) => `${r.x} ${r.y}`)
+        return `LINESTRING (${this.pPoints.map((r) => `${r.x} ${r.y}${withZ ? ` ${r.z}` : ''}`)
             .join(', ')})`;
     }
     filter(f) {
@@ -807,6 +807,26 @@ class DPolygon {
             .getCoordinates();
         return new DPolygon(points.map(({ x, y }) => new DPoint_1.DPoint(x, y)));
     }
+    bezier(step = 0.1) {
+        const res = new DPolygon();
+        for (let i = 0; i < 1; i += step) {
+            res.push(this.clone().getBezierPoint(i));
+        }
+        return res;
+    }
+    getBezierPoint(v) {
+        if (this.length === 1) {
+            return this.first;
+        }
+        for (let i = 0; i < this.length - 1; i++) {
+            const p1 = this.at(i);
+            const p2 = this.at(i + 1);
+            p1.move(p2.clone().move(p1.clone().minus())
+                .scale(v));
+        }
+        this.pop();
+        return this.getBezierPoint(v);
+    }
     simpleIncludeX(p) {
         const { x } = p;
         return this.minX <= x && this.maxX >= x;

package/dist/DPolygonLoop.d.ts

@@ -17,6 +17,9 @@ export declare class DPolygonLoop {
     setZ(z: number): DPolygonLoop;
     setZ(f: SetterFunction): DPolygonLoop;
     rotate(a: number): DPolygonLoop;
+    rotate3dX(a: number): DPolygonLoop;
+    rotate3dY(a: number): DPolygonLoop;
+    rotate3dZ(a: number): DPolygonLoop;
     move(v: number): DPolygonLoop;
     move(p: DPoint): DPolygonLoop;
     move(x: number, y: number): DPolygonLoop;

package/dist/DPolygonLoop.js

@@ -10,28 +10,31 @@ var LoopFunctions;
     LoopFunctions[LoopFunctions["setY"] = 4] = "setY";
     LoopFunctions[LoopFunctions["setZ"] = 5] = "setZ";
     LoopFunctions[LoopFunctions["rotate"] = 6] = "rotate";
-    LoopFunctions[LoopFunctions["move"] = 7] = "move";
-    LoopFunctions[LoopFunctions["round"] = 8] = "round";
-    LoopFunctions[LoopFunctions["ceil"] = 9] = "ceil";
-    LoopFunctions[LoopFunctions["floor"] = 10] = "floor";
-    LoopFunctions[LoopFunctions["toFixed"] = 11] = "toFixed";
-    LoopFunctions[LoopFunctions["abs"] = 12] = "abs";
-    LoopFunctions[LoopFunctions["scale"] = 13] = "scale";
-    LoopFunctions[LoopFunctions["divide"] = 14] = "divide";
-    LoopFunctions[LoopFunctions["degreeToRadians"] = 15] = "degreeToRadians";
-    LoopFunctions[LoopFunctions["radiansToDegrees"] = 16] = "radiansToDegrees";
-    LoopFunctions[LoopFunctions["radiansToMeters"] = 17] = "radiansToMeters";
-    LoopFunctions[LoopFunctions["metersToRadians"] = 18] = "metersToRadians";
-    LoopFunctions[LoopFunctions["hipPoint"] = 19] = "hipPoint";
-    LoopFunctions[LoopFunctions["xPoint"] = 20] = "xPoint";
-    LoopFunctions[LoopFunctions["yPoint"] = 21] = "yPoint";
-    LoopFunctions[LoopFunctions["wPoint"] = 22] = "wPoint";
-    LoopFunctions[LoopFunctions["hPoint"] = 23] = "hPoint";
-    LoopFunctions[LoopFunctions["setIfLessThan"] = 24] = "setIfLessThan";
-    LoopFunctions[LoopFunctions["minus"] = 25] = "minus";
-    LoopFunctions[LoopFunctions["degreeToMeters"] = 26] = "degreeToMeters";
-    LoopFunctions[LoopFunctions["metersToDegree"] = 27] = "metersToDegree";
-    LoopFunctions[LoopFunctions["flipVertically"] = 28] = "flipVertically";
+    LoopFunctions[LoopFunctions["rotate3dX"] = 7] = "rotate3dX";
+    LoopFunctions[LoopFunctions["rotate3dY"] = 8] = "rotate3dY";
+    LoopFunctions[LoopFunctions["rotate3dZ"] = 9] = "rotate3dZ";
+    LoopFunctions[LoopFunctions["move"] = 10] = "move";
+    LoopFunctions[LoopFunctions["round"] = 11] = "round";
+    LoopFunctions[LoopFunctions["ceil"] = 12] = "ceil";
+    LoopFunctions[LoopFunctions["floor"] = 13] = "floor";
+    LoopFunctions[LoopFunctions["toFixed"] = 14] = "toFixed";
+    LoopFunctions[LoopFunctions["abs"] = 15] = "abs";
+    LoopFunctions[LoopFunctions["scale"] = 16] = "scale";
+    LoopFunctions[LoopFunctions["divide"] = 17] = "divide";
+    LoopFunctions[LoopFunctions["degreeToRadians"] = 18] = "degreeToRadians";
+    LoopFunctions[LoopFunctions["radiansToDegrees"] = 19] = "radiansToDegrees";
+    LoopFunctions[LoopFunctions["radiansToMeters"] = 20] = "radiansToMeters";
+    LoopFunctions[LoopFunctions["metersToRadians"] = 21] = "metersToRadians";
+    LoopFunctions[LoopFunctions["hipPoint"] = 22] = "hipPoint";
+    LoopFunctions[LoopFunctions["xPoint"] = 23] = "xPoint";
+    LoopFunctions[LoopFunctions["yPoint"] = 24] = "yPoint";
+    LoopFunctions[LoopFunctions["wPoint"] = 25] = "wPoint";
+    LoopFunctions[LoopFunctions["hPoint"] = 26] = "hPoint";
+    LoopFunctions[LoopFunctions["setIfLessThan"] = 27] = "setIfLessThan";
+    LoopFunctions[LoopFunctions["minus"] = 28] = "minus";
+    LoopFunctions[LoopFunctions["degreeToMeters"] = 29] = "degreeToMeters";
+    LoopFunctions[LoopFunctions["metersToDegree"] = 30] = "metersToDegree";
+    LoopFunctions[LoopFunctions["flipVertically"] = 31] = "flipVertically";
 })(LoopFunctions || (LoopFunctions = {}));
 const decodePoolRecord = (a, { functionName, pointArg, numberPointArg, numberArg, setterArg }) => {
     let res = a;
@@ -64,6 +67,18 @@ const decodePoolRecord = (a, { functionName, pointArg, numberPointArg, numberArg
             res = (k) => a(k)
                 .rotate(numberArg);
             break;
+        case LoopFunctions.rotate3dX:
+            res = (k) => a(k)
+                .rotate3dX(numberArg);
+            break;
+        case LoopFunctions.rotate3dY:
+            res = (k) => a(k)
+                .rotate3dY(numberArg);
+            break;
+        case LoopFunctions.rotate3dZ:
+            res = (k) => a(k)
+                .rotate3dZ(numberArg);
+            break;
         case LoopFunctions.move:
             res = (k) => a(k)
                 .move(numberPointArg, numberArg);
@@ -215,6 +230,27 @@ class DPolygonLoop {
         });
         return this;
     }
+    rotate3dX(a) {
+        this.pool.push({
+            functionName: LoopFunctions.rotate3dX,
+            numberArg: a
+        });
+        return this;
+    }
+    rotate3dY(a) {
+        this.pool.push({
+            functionName: LoopFunctions.rotate3dY,
+            numberArg: a
+        });
+        return this;
+    }
+    rotate3dZ(a) {
+        this.pool.push({
+            functionName: LoopFunctions.rotate3dZ,
+            numberArg: a
+        });
+        return this;
+    }
     move(x, y = x) {
         this.pool.push({
             functionName: LoopFunctions.move,

package/dist/index.d.ts

@@ -6,6 +6,8 @@ export * from './DPolygon';
 export * from './FastSearch';
 export * from './TraceMatrix';
 export * from './DPolygonLoop';
+export * from './DPlane';
+export { gaussianElimination, createCanvas, createArray, createMatrix, isDefAndNotNull } from './utils';
 export declare const DGeo: {
     DEBUG: boolean;
 };

package/dist/index.js

@@ -10,7 +10,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DGeo = void 0;
+exports.DGeo = exports.isDefAndNotNull = exports.createMatrix = exports.createArray = exports.createCanvas = exports.gaussianElimination = void 0;
 __exportStar(require("./DCircle"), exports);
 __exportStar(require("./DLine"), exports);
 __exportStar(require("./DNumbers"), exports);
@@ -19,6 +19,13 @@ __exportStar(require("./DPolygon"), exports);
 __exportStar(require("./FastSearch"), exports);
 __exportStar(require("./TraceMatrix"), exports);
 __exportStar(require("./DPolygonLoop"), exports);
+__exportStar(require("./DPlane"), exports);
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "gaussianElimination", { enumerable: true, get: function () { return utils_1.gaussianElimination; } });
+Object.defineProperty(exports, "createCanvas", { enumerable: true, get: function () { return utils_1.createCanvas; } });
+Object.defineProperty(exports, "createArray", { enumerable: true, get: function () { return utils_1.createArray; } });
+Object.defineProperty(exports, "createMatrix", { enumerable: true, get: function () { return utils_1.createMatrix; } });
+Object.defineProperty(exports, "isDefAndNotNull", { enumerable: true, get: function () { return utils_1.isDefAndNotNull; } });
 exports.DGeo = {
     DEBUG: false
 };

package/dist/utils.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="offscreencanvas" />
 import { DPoint } from './DPoint';
 export declare const warn: (...args: any[]) => void;
 declare type CheckFunc = (p: DPoint) => CheckFunction;
@@ -12,5 +13,14 @@ interface CheckFunction {
     checkArgument: (argName: string) => CheckArgument;
 }
 export declare const checkFunction: (funcName: string) => CheckFunction;
-export declare const createArray: (v: number) => number[];
-export {};
+export declare const createArray: (v: number, fillSymbol?: any) => number[];
+export declare const createMatrix: ({ h, w }: DPoint, fillSymbol?: any) => number[][];
+export declare const gaussianElimination: (matrix: number[][]) => number[];
+export declare const isDefAndNotNull: (a: any) => boolean;
+declare function createCanvas(size: number): [HTMLCanvasElement, CanvasRenderingContext2D];
+declare function createCanvas(size: number, offscreen: boolean): [OffscreenCanvas, OffscreenCanvasRenderingContext2D];
+declare function createCanvas(w: number, h: number): [HTMLCanvasElement, CanvasRenderingContext2D];
+declare function createCanvas(w: number, h: number, offscreen: boolean): [OffscreenCanvas, OffscreenCanvasRenderingContext2D];
+declare function createCanvas(size: DPoint): [HTMLCanvasElement, CanvasRenderingContext2D];
+declare function createCanvas(size: DPoint, offscreen: boolean): [OffscreenCanvas, OffscreenCanvasRenderingContext2D];
+export { createCanvas };

package/dist/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createArray = exports.checkFunction = exports.warn = void 0;
+exports.createCanvas = exports.isDefAndNotNull = exports.gaussianElimination = exports.createMatrix = exports.createArray = exports.checkFunction = exports.warn = void 0;
 const index_1 = require("./index");
 const DPoint_1 = require("./DPoint");
 const warn = (...args) => {
@@ -63,5 +63,86 @@ const checkFunction = (funcName) => ({
     }
 });
 exports.checkFunction = checkFunction;
-const createArray = (v) => new Array(v).fill(0);
+const createArray = (v, fillSymbol = 0) => new Array(v).fill(fillSymbol);
 exports.createArray = createArray;
+const createMatrix = ({ h, w }, fillSymbol = 0) => (0, exports.createArray)(h)
+    .map(() => (0, exports.createArray)(w, fillSymbol));
+exports.createMatrix = createMatrix;
+const GAUSSIAN_ELIMINATION_MIN = 1e-10;
+const gaussianElimination = (matrix) => {
+    const n = matrix.length;
+    const matrixClone = (0, exports.createMatrix)(new DPoint_1.DPoint(n + 1, n));
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n + 1; j++) {
+            matrix[i][j] = matrix[i][j] === 0 ? GAUSSIAN_ELIMINATION_MIN : matrix[i][j];
+            matrixClone[i][j] = matrix[i][j];
+        }
+    }
+    for (let k = 0; k < n; k++) {
+        for (let i = 0; i < n + 1; i++) {
+            matrixClone[k][i] /= matrix[k][k];
+        }
+        for (let i = k + 1; i < n; i++) {
+            const K = matrixClone[i][k] / matrixClone[k][k];
+            for (let j = 0; j < n + 1; j++) {
+                matrixClone[i][j] -= matrixClone[k][j] * K;
+            }
+        }
+        for (let i = 0; i < n; i++) {
+            for (let j = 0; j < n + 1; j++) {
+                matrix[i][j] = matrixClone[i][j];
+            }
+        }
+    }
+    for (let k = n - 1; k > -1; k--) {
+        for (let i = n; i > -1; i--) {
+            matrixClone[k][i] /= matrix[k][k];
+        }
+        for (let i = k - 1; i > -1; i--) {
+            const K = matrixClone[i][k] / matrixClone[k][k];
+            for (let j = n; j > -1; j--) {
+                matrixClone[i][j] -= matrixClone[k][j] * K;
+            }
+        }
+    }
+    const answer = (0, exports.createArray)(n);
+    for (let i = 0; i < n; i++) {
+        answer[i] = matrixClone[i][n];
+    }
+    return answer;
+};
+exports.gaussianElimination = gaussianElimination;
+const isDefAndNotNull = (a) => a != undefined;
+exports.isDefAndNotNull = isDefAndNotNull;
+function createCanvas(a, b, c) {
+    var _a;
+    let w = 0;
+    let h = 0;
+    let offscreen = false;
+    if (a instanceof DPoint_1.DPoint) {
+        const { x, y } = a;
+        w = x;
+        h = y;
+    }
+    else {
+        w = a;
+        h = a;
+    }
+    if (typeof b === 'boolean') {
+        offscreen = b;
+    }
+    else if (typeof b === 'number') {
+        h = b;
+    }
+    if (typeof c === 'boolean') {
+        offscreen = c;
+    }
+    const canvas = offscreen ? new OffscreenCanvas(w, h) : ((_a = createCanvas.document) !== null && _a !== void 0 ? _a : document).createElement('canvas');
+    if (!offscreen) {
+        canvas.width = w;
+        canvas.height = h;
+    }
+    const ctx = canvas.getContext('2d');
+    return [canvas, ctx];
+}
+exports.createCanvas = createCanvas;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dgeoutils",
-  "version": "2.2.9",
+  "version": "2.2.13",
   "description": "",
   "scripts": {
     "build": "node_modules/.bin/tsc",