dgeoutils 2.2.7 → 2.2.11

package/dist/DCircle.d.ts

@@ -3,10 +3,6 @@ import { DPolygon } from './DPolygon';
 export declare class DCircle {
     center: DPoint;
     r: number;
-    /**
-     * @param [center=(0,0)]
-     * @param [r=0]
-     */
     constructor(center?: DPoint, r?: number);
     toString(): string;
     getValue(): {
@@ -14,33 +10,9 @@ export declare class DCircle {
         r: number;
     };
     clone(): DCircle;
-    /**
-     * Find intersection points with other circle.
-     *
-     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPoints.png)
-     * @param c
-     */
     findPoints(c: DCircle): DPoint[] | number;
     equal({ center, r }: DCircle): boolean;
-    /**
-     * Transform circle to polygon
-     *
-     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPolygonInside.png)
-     * @param [pointCount=64]
-     */
     findPolygonInside(pointCount?: number): DPolygon;
-    /**
-     * Transform circle to polygon on sphere. It would be different for different latitude.
-     *
-     * @remarks
-     * Center should be Lng/Lat.
-     *
-     * @remarks
-     * Radius should be in meters.
-     *
-     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPolygonInsideOnSphere.png)
-     * @param [pointCount=64]
-     */
     findPolygonInsideOnSphere(pointCount?: number): DPolygon;
     private sphereOffset;
 }

package/dist/DCircle.js

@@ -5,13 +5,7 @@ const DPoint_1 = require("./DPoint");
 const DPolygon_1 = require("./DPolygon");
 const DNumbers_1 = require("./DNumbers");
 const utils_1 = require("./utils");
-// eslint-disable-next-line padded-blocks
 class DCircle {
-    /**
-     * @param [center=(0,0)]
-     * @param [r=0]
-     */
-    // eslint-disable-next-line no-useless-constructor,no-empty-function
     constructor(center = DPoint_1.DPoint.zero(), r = 0) {
         this.center = center;
         this.r = r;
@@ -25,12 +19,6 @@ class DCircle {
     clone() {
         return new DCircle(this.center, this.r);
     }
-    /**
-     * Find intersection points with other circle.
-     *
-     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPoints.png)
-     * @param c
-     */
     findPoints(c) {
         if (this.equal(c)) {
             return Infinity;
@@ -63,12 +51,6 @@ class DCircle {
     equal({ center, r }) {
         return this.center.equal(center) && this.r === r;
     }
-    /**
-     * Transform circle to polygon
-     *
-     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPolygonInside.png)
-     * @param [pointCount=64]
-     */
     findPolygonInside(pointCount = 64) {
         const preAngle = 2 * Math.PI / pointCount;
         const points = [];
@@ -80,18 +62,6 @@ class DCircle {
         }
         return new DPolygon_1.DPolygon([...points, points[0]]);
     }
-    /**
-     * Transform circle to polygon on sphere. It would be different for different latitude.
-     *
-     * @remarks
-     * Center should be Lng/Lat.
-     *
-     * @remarks
-     * Radius should be in meters.
-     *
-     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPolygonInsideOnSphere.png)
-     * @param [pointCount=64]
-     */
     findPolygonInsideOnSphere(pointCount = 64) {
         (0, utils_1.checkFunction)('findPolygonInsideOnSphere')
             .checkArgument('center')

package/dist/DLine.d.ts

@@ -6,37 +6,13 @@ export declare class DLine {
     c: number;
     begin: DPoint;
     end: DPoint;
-    /**
-     * @param a
-     * @param b
-     * @param c
-     * @param [begin=DPoint.zero()]
-     * @param [end=DPoint.zero()]
-     */
     constructor(a: number, b: number, c: number, begin?: DPoint, end?: DPoint);
     clone(): DLine;
     findPerpendicular(p: DPoint): DLine;
     perpendicularDistance(p: DPoint): number;
-    /**
-     * Find intersection of two lines segments.
-     * For intersection of two lines use [[findPoint]]
-     * @param l
-     * @param [d=0]
-     * @param [includeOnly=false]
-     */
     intersection(l: DLine, d?: number, includeOnly?: boolean): DPoint | null;
     intersectionWithCircle(circle: DCircle): DPoint | [DPoint, DPoint] | null;
-    /**
-     * Check if point below to line segment
-     * @param p
-     * @param d
-     */
     inRange(p: DPoint, d?: number): boolean;
-    /**
-     * Check if point below to line segment, but not equal star or end point.
-     * @param p
-     * @param [d=0]
-     */
     insideRange(p: DPoint, d?: number): boolean;
     get center(): DPoint;
     get minX(): number;
@@ -45,52 +21,16 @@ export declare class DLine {
     get maxY(): number;
     toString(): string;
     getValue(): number[];
-    /**
-     * Find `x` from `y` value of point
-     * @param p
-     */
     x(p: DPoint): DPoint;
-    /**
-     * Find `y` from `x` value of point
-     * @param p
-     */
     y(p: DPoint): DPoint;
-    /**
-     * Find intersection of two lines.
-     * For intersection of two lines segments use [[intersection]]
-     * @param l
-     */
     findPoint(l: DLine): DPoint | null;
-    /**
-     * Check if line parallel to `x` or `y` axis
-     */
     get isParallel(): boolean;
     get isParallelY(): boolean;
     get isParallelX(): boolean;
-    /**
-     * Get lines segment start and end points as array
-     */
     get points(): [DPoint, DPoint];
-    /**
-     * Get line segment direction (from start point to end point)
-     */
     getFi(): number;
     toWKT(): string;
-    /**
-     * Move lines point to left or right
-     * @param p
-     * @param d
-     */
     movePoint(p: DPoint, d: number): DPoint;
-    /**
-     * Find angle between current line and line in argument
-     * @param l
-     * @param delta
-     */
     findFi({ a, b }: DLine, delta?: number): number;
-    /**
-     * [Cross product](https://en.wikipedia.org/wiki/Cross_product)
-     * @param l {DLine}
-     */
     vectorProduct({ a, b, c }: DLine): DLine;
 }

package/dist/DLine.js

@@ -3,19 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DLine = void 0;
 const DPoint_1 = require("./DPoint");
 const utils_1 = require("./utils");
-// eslint-disable-next-line padded-blocks
 class DLine {
-    /**
-     * @param a
-     * @param b
-     * @param c
-     * @param [begin=DPoint.zero()]
-     * @param [end=DPoint.zero()]
-     */
-    // eslint-disable-next-line no-useless-constructor
-    constructor(a, b, c, begin = DPoint_1.DPoint.zero(), end = DPoint_1.DPoint.zero()
-    // eslint-disable-next-line no-empty-function
-    ) {
+    constructor(a, b, c, begin = DPoint_1.DPoint.zero(), end = DPoint_1.DPoint.zero()) {
         this.a = a;
         this.b = b;
         this.c = c;
@@ -47,13 +36,6 @@ class DLine {
         const targetPoint = perpendicularLine.findPoint(this);
         return targetPoint.distance(p);
     }
-    /**
-     * Find intersection of two lines segments.
-     * For intersection of two lines use [[findPoint]]
-     * @param l
-     * @param [d=0]
-     * @param [includeOnly=false]
-     */
     intersection(l, d = 0, includeOnly = false) {
         const p = this.findPoint(l);
         if (p) {
@@ -80,14 +62,12 @@ class DLine {
             if (this.isParallel) {
                 const ct = center.distance(t);
                 const move = Math.sqrt(r * r - ct * ct);
-                // Mean "|" x = const
                 if (this.isParallelY) {
                     t.x = this.begin.x;
                     const r1 = t.clone().move(0, -move);
                     const r2 = t.clone().move(0, move);
                     return [r1, r2];
                 }
-                // Mean "-" y = const
                 if (this.isParallelX) {
                     t.y = this.begin.y;
                     const r1 = t.clone().move(move, 0);
@@ -115,11 +95,6 @@ class DLine {
         }
         return null;
     }
-    /**
-     * Check if point below to line segment
-     * @param p
-     * @param d
-     */
     inRange(p, d = 0) {
         const { minX, minY, maxX, maxY } = this;
         const { x, y } = p;
@@ -127,11 +102,6 @@ class DLine {
         const isInY = y >= minY - d && y <= maxY + d;
         return isInX && isInY;
     }
-    /**
-     * Check if point below to line segment, but not equal star or end point.
-     * @param p
-     * @param [d=0]
-     */
     insideRange(p, d = 0) {
         const { begin, end } = this;
         return this.inRange(p, d) && !begin.like(p, 0.00001) && !end.like(p, 0.00001);
@@ -167,10 +137,6 @@ class DLine {
     getValue() {
         return [this.a, this.b, this.c];
     }
-    /**
-     * Find `x` from `y` value of point
-     * @param p
-     */
     x(p) {
         if (this.isParallelY) {
             return new DPoint_1.DPoint(-this.c / this.a, p.y);
@@ -180,10 +146,6 @@ class DLine {
         }
         return new DPoint_1.DPoint(-this.b / this.a * p.y - this.c / this.a, p.y);
     }
-    /**
-     * Find `y` from `x` value of point
-     * @param p
-     */
     y(p) {
         if (this.isParallelY) {
             return new DPoint_1.DPoint(-this.c / this.a, p.y);
@@ -193,11 +155,6 @@ class DLine {
         }
         return new DPoint_1.DPoint(p.x, -this.a / this.b * p.x - this.c / this.b);
     }
-    /**
-     * Find intersection of two lines.
-     * For intersection of two lines segments use [[intersection]]
-     * @param l
-     */
     findPoint(l) {
         if (this.isParallelY && l.isParallelY) {
             return null;
@@ -233,9 +190,6 @@ class DLine {
         }
         return res;
     }
-    /**
-     * Check if line parallel to `x` or `y` axis
-     */
     get isParallel() {
         return this.isParallelX || this.isParallelY;
     }
@@ -245,15 +199,9 @@ class DLine {
     get isParallelX() {
         return Math.abs(this.a) < 0.001;
     }
-    /**
-     * Get lines segment start and end points as array
-     */
     get points() {
         return [this.begin, this.end];
     }
-    /**
-     * Get line segment direction (from start point to end point)
-     */
     getFi() {
         (0, utils_1.checkFunction)('getFi')
             .checkArgument('this.begin')
@@ -271,11 +219,6 @@ class DLine {
         const { begin: { x: x1, y: y1 }, end: { x: x2, y: y2 } } = this;
         return `LINESTRING (${x1} ${y1}, ${x2} ${y2})`;
     }
-    /**
-     * Move lines point to left or right
-     * @param p
-     * @param d
-     */
     movePoint(p, d) {
         const fi = this.findFi(new DLine(1, 0, 0));
         const td = this.begin.distance(this.end) / 2;
@@ -292,11 +235,6 @@ class DLine {
         }
         return p3;
     }
-    /**
-     * Find angle between current line and line in argument
-     * @param l
-     * @param delta
-     */
     findFi({ a, b }, delta = 1.0001) {
         const { a: q, b: w } = this;
         let val = (q * a + w * b) / (Math.sqrt(q * q + w * w) * Math.sqrt(a * a + b * b));
@@ -308,10 +246,6 @@ class DLine {
         }
         return Math.acos(val);
     }
-    /**
-     * [Cross product](https://en.wikipedia.org/wiki/Cross_product)
-     * @param l {DLine}
-     */
     vectorProduct({ a, b, c }) {
         const { a: q, b: w, c: e } = this;
         return new DLine(w * c - e * b, e * a - q * c, q * b - w * a);

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

@@ -19,53 +19,17 @@ export declare class DPoint {
     properties: {
         [key: string]: any;
     };
-    /**
-     * Create point with zero coords `(0, 0)`
-     */
     constructor();
-    /**
-     * Create point
-     * @param xy - `x` and `y` value
-     */
     constructor(xy: number);
-    /**
-     * Create point
-     * @param x - lng, meters to East, radians to East or width
-     * @param y - lat, meters to North, radians to North or height
-     */
     constructor(x: number, y: number);
-    /**
-     * Create point
-     * @param x - lng, meters to East, radians to East or width
-     * @param y - lat, meters to North, radians to North or height
-     * @param z - height
-     */
     constructor(x: number, y: number, z?: number);
     static zero(): DPoint;
     static parse(c: LatLng | number[] | DCoord): DPoint;
     static parseFromWKT(wkt: string): DPoint;
     static random(): DPoint;
-    /**
-     * @remark Point should be Lng/Lat.
-     *
-     * @remark `z` value default for `zoom` argument.
-     *
-     * @param [zoom=this.z]
-     */
     getTileFromCoords(zoom?: number): DPoint;
-    /**
-     * Result would be Lng/Lat.
-     *
-     * @remark `z` value default for `zoom` argument.
-     *
-     * @param [zoom=this.z]
-     */
     getCoordsFromTile(zoom?: number): DPoint;
     toCoords(): DCoord;
-    /**
-     * Find line between two points.
-     * @param p
-     */
     findLine(p: DPoint): DLine;
     findInnerAngle(p1: DPoint, p3: DPoint): number;
     toString(): string;
@@ -73,62 +37,25 @@ export declare class DPoint {
     height(z: number): DPoint;
     toWKT(): string;
     distance(p: DPoint): number;
-    /**
-     * Set `x` value
-     * @param x
-     */
     setX(x: number): DPoint;
-    /**
-     * Transform `x` value by function
-     * @param f
-     */
     setX(f: SetterFunction): DPoint;
-    /**
-     * Set `z` value
-     * @param z
-     */
     setZ(z: number): DPoint;
-    /**
-     * Transform `z` value by function
-     * @param f
-     */
     setZ(f: SetterFunction): DPoint;
-    /**
-     * Set `y` value
-     * @param y
-     */
     setY(y: number): DPoint;
-    /**
-     * Transform `y` value by function
-     * @param f
-     */
     setY(f: SetterFunction): DPoint;
     clone(): DPoint;
     gt(p: DPoint): boolean;
     lt(p: DPoint): boolean;
     gtOrEqual(p: DPoint): boolean;
     ltOrEqual(p: DPoint): boolean;
-    /**
-     * Clockwise rotation
-     * @param a radians
-     */
     rotate(a: number): DPoint;
-    /**
-     * Add `v` to `x` and `y`
-     * @param v
-     */
+    rotate3dX(a: number): DPoint;
+    rotate3dY(a: number): DPoint;
+    rotate3dZ(a: number): DPoint;
     move(v: number): DPoint;
-    /**
-     * Add `p.x` to `x` field and `p.y` to `y` field.
-     * @param p
-     */
     move(p: DPoint): DPoint;
-    /**
-     * Add `x` to `x` field and `y` to `y` field.
-     * @param x
-     * @param y
-     */
     move(x: number, y: number): DPoint;
+    move(x: number, y: number, z: number): DPoint;
     degreeToMeters(): DPoint;
     metersToDegree(): DPoint;
     degreeToRadians(): DPoint;
@@ -138,70 +65,20 @@ export declare class DPoint {
     round(): DPoint;
     ceil(): DPoint;
     floor(): DPoint;
-    /**
-     * @param [n=2]
-     */
     toFixed(n?: number): DPoint;
     abs(): DPoint;
-    /**
-     * Multiply `v` to `x` and `y`
-     * @param v
-     */
     scale(v: number): DPoint;
-    /**
-     * Multiply `p.x` to `x` field and `p.y` to `y` field.
-     * @param p
-     */
     scale(p: DPoint): DPoint;
-    /**
-     * Multiply `x` to `x` field and `y` to `y` field.
-     * @param x
-     * @param y
-     */
     scale(x: number, y: number): DPoint;
-    /**
-     * Divide `x` and `y` to `v`
-     * @param v
-     */
     divide(v: number): DPoint;
-    /**
-     * Divide `x` field to `p.x` and `y` field to `p.y`.
-     * @param p
-     */
     divide(p: DPoint): DPoint;
-    /**
-     * Divide `x` field to `x` and `y` field to `y`.
-     * @param x
-     * @param y
-     */
     divide(x: number, y: number): DPoint;
     equal(p: DPoint): boolean;
-    /**
-     * @param p
-     * @param [d=0.001]
-     */
     like(p: DPoint, d?: number): boolean;
-    /**
-     * Flip vertically
-     * @param size canvas size
-     */
     flipVertically(size: DPoint): DPoint;
-    /**
-     * Flip vertically
-     * @param height canvas height
-     */
     flipVertically(height: number): DPoint;
-    /**
-     * Check if point looks like radians
-     */
     get likeRadians(): boolean;
-    /**
-     * Check if point looks like `EPSG:4326` (degrees)
-     */
     get likeWorldGeodeticSystem(): boolean;
-    /**
-     * Check if point looks like `EPSG:3857` (meters)
-     */
     get likePseudoMercator(): boolean;
     get w(): number;
     set w(x: number);
@@ -221,15 +98,5 @@ export declare class DPoint {
     };
     setIfLessThan(p: DPoint): DPoint;
     minus(): DPoint;
-    /**
-     * Find [orthodromic path](https://en.wikipedia.org/wiki/Great-circle_navigation) between to points.
-     *
-     * @remark Points should be Lng/Lat.
-     *
-     * ![example](/media/examples/orthodromicPath.png)
-     *
-     * @param point
-     * @param [pointsCount=360]
-     */
     orthodromicPath(point: DPoint, pointsCount?: number): DPolygon;
 }