dgeoutils 2.2.12 → 2.2.13

package/dist/DPoint.d.ts

@@ -70,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

@@ -182,7 +182,7 @@ class DPoint {
         this.y = -x * Math.sin(a) + y * Math.cos(a);
         return this;
     }
-    move(x, y = x, z = x) {
+    move(x, y = x, z) {
         let xV = 0;
         let yV = 0;
         let zV = undefined;
@@ -278,34 +278,54 @@ 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) {
@@ -407,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

@@ -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

@@ -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/index.d.ts

@@ -7,6 +7,7 @@ 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);
@@ -20,6 +20,12 @@ __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,8 +13,14 @@ interface CheckFunction {
     checkArgument: (argName: string) => CheckArgument;
 }
 export declare const checkFunction: (funcName: string) => CheckFunction;
-export declare const createArray: (v: number) => number[];
-export declare const createMatrix: ({ h, w }: DPoint) => number[][];
+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;
-export {};
+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.isDefAndNotNull = exports.gaussianElimination = exports.createMatrix = 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,9 +63,10 @@ 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 }) => (0, exports.createArray)(h).map(() => (0, exports.createArray)(w));
+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) => {
@@ -113,3 +114,35 @@ const gaussianElimination = (matrix) => {
 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.12",
+  "version": "2.2.13",
   "description": "",
   "scripts": {
     "build": "node_modules/.bin/tsc",