dgeoutils 2.2.17 → 2.2.23

package/dist/DLine.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DLine = void 0;
 const DPoint_1 = require("./DPoint");
 const utils_1 = require("./utils");
+const DNumbers_1 = require("./DNumbers");
 class DLine {
     constructor(a, b, c, begin = DPoint_1.DPoint.zero(), end = DPoint_1.DPoint.zero()) {
         this.a = a;
@@ -49,7 +50,7 @@ class DLine {
     intersectionWithCircle(circle) {
         const { center, r } = circle;
         const per = this.findPerpendicular(center);
-        const t = this.intersection(per, Infinity);
+        const t = this.findPoint(per);
         let distance = t.distance(center);
         if (this.begin.equal(center)) {
             distance = 0;
@@ -221,19 +222,15 @@ class DLine {
     }
     movePoint(p, d) {
         const fi = this.findFi(new DLine(1, 0, 0));
-        const td = this.begin.distance(this.end) / 2;
-        const dcosT = td * Math.cos(fi);
-        const dsinT = td * Math.sin(fi);
-        const p1T = new DPoint_1.DPoint(p.x - dsinT, p.y - dcosT);
-        const p2T = new DPoint_1.DPoint(p.x + dsinT, p.y + dcosT);
-        const dcos = d * Math.cos(fi);
-        const dsin = d * Math.sin(fi);
-        const p2 = new DPoint_1.DPoint(p.x + dsin, p.y + dcos);
-        const p3 = new DPoint_1.DPoint(p.x - dsin, p.y + dcos);
-        if (this.inRange(p1T) || this.inRange(p2T)) {
-            return p2;
-        }
-        return p3;
+        const td = this.x(new DPoint_1.DPoint(1, 1)).distance(this.x(new DPoint_1.DPoint(2, 2))) / 2;
+        const sinCos = new DPoint_1.DPoint(Math.sin(fi), Math.cos(fi));
+        const dt = sinCos.clone().scale(td);
+        const p1T = p.clone().move(dt.clone().minus());
+        const p2T = p.clone().move(dt);
+        if (DNumbers_1.DNumbers.like(this.y(p1T).y, p1T.y) || DNumbers_1.DNumbers.like(this.y(p2T).y, p2T.y)) {
+            return p.clone().move(sinCos.scale(d));
+        }
+        return p.clone().move(sinCos.scale(d).setX(({ x }) => -x));
     }
     findFi({ a, b }, delta = 1.0001) {
         const { a: q, b: w } = this;

package/dist/DPoint.d.ts

@@ -102,5 +102,5 @@ export declare class DPoint {
     setIfLessThan(p: DPoint): DPoint;
     minus(): DPoint;
     orthodromicPath(point: DPoint, pointsCount?: number): DPolygon;
-    findCloserPoint(p: DPolygon): DPoint;
+    sortByDistance(p: DPolygon): DPolygon;
 }

package/dist/DPoint.js

@@ -462,17 +462,15 @@ class DPoint {
             return new DPoint(x, y).radiansToDegrees();
         }));
     }
-    findCloserPoint(p) {
-        let d = Infinity;
-        let res = DPoint.zero();
-        for (const t of p.points) {
-            const td = this.distance(t);
-            if (td < d) {
-                d = td;
-                res = t.clone();
-            }
-        }
-        return res;
+    sortByDistance(p) {
+        return p
+            .clone()
+            .map((d, index) => {
+            d.properties.distance = d.distance(this);
+            d.properties.index = index;
+            return d;
+        })
+            .sort((a, b) => a.properties.distance - b.properties.distance);
     }
 }
 exports.DPoint = DPoint;

package/dist/DPolygon.d.ts

@@ -2,6 +2,7 @@
 import { DCoord, DPoint, LatLng } from './DPoint';
 import { DLine } from './DLine';
 import { DPolygonLoop } from './DPolygonLoop';
+import { True } from './utils';
 export declare const MIN_POINTS_IN_VALID_POLYGON = 3;
 export declare class DPolygon {
     private pPoints;
@@ -58,6 +59,7 @@ export declare class DPolygon {
     filter(f: (p: DPoint) => boolean): DPolygon;
     map(f: (r: DPoint) => DPoint): DPolygon;
     map(f: (r: DPoint, index: number) => DPoint): DPolygon;
+    sort(f: (a: DPoint, b: DPoint) => number): DPolygon;
     at(index: number): DPoint;
     pop(): DPoint;
     push(...args: DPoint[]): number;
@@ -101,8 +103,11 @@ export declare class DPolygon {
     getTrianglesPointIndexes(): number[];
     get closed(): boolean;
     buffer(v: number, quadrantSegments?: number, type?: number): DPolygon;
+    sideBuffers(v: number, quadrantSegments?: number): [DPolygon, DPolygon];
     bezier(step?: number): DPolygon;
     setGrowingHeight(from: number, to: number): DPolygon;
+    loopPointsGenerator(): () => Generator<[DPoint, DPoint, undefined, number]>;
+    loopPointsGenerator(withLine: True): () => Generator<[DPoint, DPoint, DLine, number]>;
     private getBezierPoint;
     private simpleIncludeX;
     private simpleIncludeY;

package/dist/DPolygon.js

@@ -13,6 +13,43 @@ exports.MIN_POINTS_IN_VALID_POLYGON = 3;
 const APPROXIMATION_VALUE = 0.1;
 const MAX_CONVEX_ITERATIONS = 100;
 const CLOSE_TO_INTERSECTION_DISTANCE = 0.001;
+const containCalculator = (poly, p) => {
+    const hasSamePoint = poly.points.some((point) => point.equal(p));
+    if (hasSamePoint) {
+        return true;
+    }
+    for (const [, , polygonLine] of poly.loopPointsGenerator(true)()) {
+        const onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
+        if (onBorder) {
+            return true;
+        }
+    }
+    let totalFi = 0;
+    for (const [{ x, y }, { x: a, y: b }] of poly.loopPointsGenerator()()) {
+        const line1 = new DLine_1.DLine(x - p.x, y - p.y, 0);
+        const line2 = new DLine_1.DLine(a - p.x, b - p.y, 0);
+        const fiDif = line1.findFi(line2);
+        if (line1.vectorProduct(line2).c > 0) {
+            totalFi += fiDif;
+        }
+        else {
+            totalFi -= fiDif;
+        }
+    }
+    const eps = Math.PI / 10000;
+    let result = false;
+    const absTotalFi = Math.abs(totalFi);
+    if (absTotalFi < eps) {
+        result = false;
+    }
+    else if (Math.abs(2 * Math.PI - absTotalFi) < eps) {
+        result = true;
+    }
+    else {
+        throw new Error('contains2 faild');
+    }
+    return result;
+};
 class DPolygon {
     constructor(pPoints = []) {
         this.pPoints = pPoints;
@@ -156,24 +193,25 @@ class DPolygon {
     }
     get perimeter() {
         let p = 0;
-        for (let i = 1; i < this.pPoints.length; i++) {
-            p += this.pPoints[i - 1].distance(this.pPoints[i]);
+        for (const [p1, p2] of this.loopPointsGenerator()()) {
+            p += p1.distance(p2);
         }
         return p;
     }
     get area() {
-        const closed = this.deintersection;
         let sum = 0;
-        for (let i = 1; i < closed.length; i++) {
-            const cur = closed.at(i);
-            const prev = closed.at(i - 1);
-            sum += prev.x * cur.y - prev.y * cur.x;
+        for (const [{ x, y }, { x: a, y: b }] of this.deintersection.loopPointsGenerator()()) {
+            sum += x * b - y * a;
         }
         return Math.abs(sum / 2) - this.holes.reduce((a, hole) => a + hole.area, 0);
     }
     get deintersection() {
-        const p = this.clone().close();
+        let p = this.clone().close();
+        const store = {};
         for (let i = 0; i < p.length - 1; i++) {
+            const k = p.at(i).toString();
+            store[k] = store[k] || [];
+            store[k].push(i);
             for (let j = i + 2; j < p.length - 1; j++) {
                 const firstLine = p.at(i).findLine(p.at(i + 1));
                 const secondLine = p.at(j).findLine(p.at(j + 1));
@@ -187,6 +225,24 @@ class DPolygon {
                 }
             }
         }
+        for (const key of Object.keys(store)) {
+            const record = store[key];
+            if (record.length > 1) {
+                for (let j = record.length - 1; j > 0; j--) {
+                    const origin = p.clone();
+                    const d = record[j] - record[j - 1];
+                    if (d > 1) {
+                        const part = new DPolygon(origin.removePart(record[j - 1], d));
+                        const allInside = part.points
+                            .reduce((a, e) => a && containCalculator(origin, e), true);
+                        if (allInside && origin.isClockwise === part.isClockwise) {
+                            origin.insertAfter(record[j - 1] - 1, ...part.reverse().points);
+                            p = origin;
+                        }
+                    }
+                }
+            }
+        }
         return p;
     }
     get valid() {
@@ -205,19 +261,18 @@ class DPolygon {
         const p = this.convex;
         let resultPolygon = new DPolygon();
         let resultArea = Infinity;
-        for (let k = 0; k < p.length - 1; k++) {
-            const l = p.at(k).findLine(p.at(k + 1));
+        for (const [, , l] of p.loopPointsGenerator(true)()) {
             let maxWidth = 0;
             let maxWidthPoint1 = null;
             let maxWidthPoint2 = null;
             let maxHeight = 0;
             let maxHeightPoint = null;
-            for (let i = 0; i < p.length - 1; i++) {
-                const p1 = l.findPoint(l.findPerpendicular(p.at(i)));
-                const h = p1.distance(p.at(i));
+            for (const [z, , , i] of p.loopPointsGenerator()()) {
+                const p1 = l.findPoint(l.findPerpendicular(z));
+                const h = p1.distance(z);
                 if (h >= maxHeight) {
                     maxHeight = h;
-                    maxHeightPoint = p.at(i);
+                    maxHeightPoint = z;
                 }
                 for (let j = i; j < p.length - 1; j++) {
                     const p2 = l.findPoint(l.findPerpendicular(p.at(j)));
@@ -290,11 +345,9 @@ class DPolygon {
     }
     get isClockwise() {
         let sum = 0;
-        const p = this.clone().close();
-        for (let i = 1; i < p.length; i++) {
-            const p1 = p.at(i - 1);
-            const p2 = p.at(i);
-            sum += (p2.x - p1.x) * (p2.y + p1.y);
+        for (const [{ x, y }, { x: a, y: b }] of this.clone().close()
+            .loopPointsGenerator()()) {
+            sum += (a - x) * (b + y);
         }
         return sum < 0;
     }
@@ -311,10 +364,7 @@ class DPolygon {
     }
     intersection(l, includeOnly = false) {
         const res = [];
-        for (let i = 0; i < this.pPoints.length - 1; i++) {
-            const p1 = this.pPoints[i];
-            const p2 = this.pPoints[i + 1];
-            const line = p1.findLine(p2);
+        for (const [, , line] of this.loopPointsGenerator(true)()) {
             const intersect = line.intersection(l, 0, includeOnly);
             if (intersect) {
                 res.push(intersect);
@@ -349,6 +399,10 @@ class DPolygon {
         this.holes = this.holes.map((h) => h.map(f));
         return this;
     }
+    sort(f) {
+        this.points.sort(f);
+        return this;
+    }
     at(index) {
         const { length } = this;
         return this.points[(index % length + length) % length];
@@ -504,11 +558,9 @@ class DPolygon {
         }
         const poly = this.deintersection;
         let totalFi = 0;
-        for (let i = 0; i < poly.length - 1; i++) {
-            const p1 = poly.at(i);
-            const p2 = poly.at(i + 1);
-            const line1 = new DLine_1.DLine(p1.x - p.x, p1.y - p.y, 0);
-            const line2 = new DLine_1.DLine(p2.x - p.x, p2.y - p.y, 0);
+        for (const [{ x, y }, { x: a, y: b }] of poly.loopPointsGenerator()()) {
+            const line1 = new DLine_1.DLine(x - p.x, y - p.y, 0);
+            const line2 = new DLine_1.DLine(a - p.x, b - p.y, 0);
             const fiDif = line1.findFi(line2);
             if (line1.vectorProduct(line2).c > 0) {
                 totalFi += fiDif;
@@ -518,18 +570,14 @@ class DPolygon {
             }
         }
         const eps = Math.PI / 10000;
-        let result = false;
         const absTotalFi = Math.abs(totalFi);
         if (absTotalFi < eps) {
-            result = false;
+            return false;
         }
         else if (Math.abs(2 * Math.PI - absTotalFi) < eps) {
-            result = true;
-        }
-        else {
-            throw new Error('contains2 faild');
+            return true;
         }
-        return result;
+        throw new Error('contains2 faild');
     }
     onBorder(p) {
         const simpleInclude = this.simpleInclude(p);
@@ -539,10 +587,7 @@ class DPolygon {
             if (hasSamePoint) {
                 return true;
             }
-            for (let i = 0; i < poly.length - 1; i++) {
-                const p0 = poly.at(i);
-                const p1 = poly.at(i + 1);
-                const polygonLine = p0.findLine(p1);
+            for (const [, , polygonLine] of poly.loopPointsGenerator(true)()) {
                 const onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
                 if (onBorder) {
                     return true;
@@ -578,15 +623,13 @@ class DPolygon {
         const { fullLength } = this;
         const pieceLength = fullLength / piecesCount;
         let currentPieceLength = pieceLength;
-        for (let i = 0; i < this.pPoints.length - 1; i++) {
-            const p1 = this.pPoints[i];
-            const p2 = this.pPoints[i + 1];
-            if (p1.distance(p2) === currentPieceLength) {
+        for (const [p1, p2, , i] of this.loopPointsGenerator()()) {
+            const d = p1.distance(p2);
+            if (d === currentPieceLength) {
                 p2.properties.pieceBorder = true;
                 currentPieceLength = pieceLength;
-                continue;
             }
-            if (p1.distance(p2) - currentPieceLength > 0) {
+            else if (d - currentPieceLength > 0) {
                 const circle = new DCircle_1.DCircle(p1, currentPieceLength);
                 const line = p1.findLine(p2);
                 const intersectionPoint = line.intersectionWithCircle(circle)
@@ -594,10 +637,9 @@ class DPolygon {
                 intersectionPoint.properties.pieceBorder = true;
                 this.insertAfter(i, intersectionPoint);
                 currentPieceLength = pieceLength;
-                continue;
             }
-            if (p1.distance(p2) - currentPieceLength < 0) {
-                currentPieceLength -= p1.distance(p2);
+            else {
+                currentPieceLength -= d;
             }
         }
         return this;
@@ -808,6 +850,17 @@ class DPolygon {
             .getCoordinates();
         return new DPolygon(points.map(({ x, y }) => new DPoint_1.DPoint(x, y)));
     }
+    sideBuffers(v, quadrantSegments = 64) {
+        const { first, last } = this;
+        const buffer = this.buffer(v, quadrantSegments, DPolygon.CAP_FLAT).open();
+        const [start0, start1] = first.sortByDistance(buffer).points.map((r) => r.properties.index);
+        const [end0, end1] = last.sortByDistance(buffer).points.map((r) => r.properties.index);
+        const fromPoint = Math.min(Math.max(start0, start1), Math.max(end0, end1));
+        const toPoint = Math.max(Math.min(start0, start1), Math.min(end0, end1));
+        const linePart = new DPolygon(buffer.removePart(fromPoint - 1, toPoint - fromPoint + 1));
+        buffer.unshift(buffer.pop());
+        return [linePart, buffer];
+    }
     bezier(step = 0.1) {
         const res = new DPolygon();
         for (let i = 0; i < 1; i += step) {
@@ -829,13 +882,21 @@ class DPolygon {
             .run();
         return this;
     }
+    loopPointsGenerator(withLine = false) {
+        const that = this;
+        return function* () {
+            for (let i = 0; i < that.length - 1; i++) {
+                const p1 = that.at(i);
+                const p2 = that.at(i + 1);
+                yield [p1, p2, withLine ? p1.findLine(p2) : undefined, i];
+            }
+        };
+    }
     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);
+        for (const [p1, p2] of this.loopPointsGenerator()()) {
             p1.move(p2.clone().move(p1.clone().minus())
                 .scale(v));
         }

package/dist/utils.d.ts

@@ -22,7 +22,7 @@ export declare const gaussianElimination: {
     (matrix: number[][]): number[];
     MIN: number;
 };
-declare type True = true;
+export declare type True = true;
 export declare const createCanvas: {
     (size: number): [HTMLCanvasElement, CanvasRenderingContext2D];
     (size: number, offscreen: True): [OffscreenCanvas, OffscreenCanvasRenderingContext2D];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dgeoutils",
-  "version": "2.2.17",
+  "version": "2.2.23",
   "description": "",
   "scripts": {
     "build": "node_modules/.bin/tsc",
@@ -45,7 +45,7 @@
     "jest-html-reporter": "^3.4.2",
     "jsdom": "^17.0.0",
     "ts-jest": "^27.0.4",
-    "typedoc": "^0.21.9",
+    "typedoc": "^0.22.11",
     "typescript": "^4.4.3"
   },
   "jest": {