dgeoutils 2.4.1 → 2.4.2

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "dgeoutils",
-  "version": "2.4.1",
+  "version": "2.4.2",
   "description": "Geometries utils for my projects",
   "scripts": {
-    "build": "npm run build:es2015 && npm run build:esm && npm run build:cjs && npm run build:umd && npm run build:umd:min",
-    "build:es2015": "tsc --module es2015 --target es2015 --outDir dist/es2015",
+    "build": "npm run build:esm && npm run build:cjs && npm run build:umd && npm run build:umd:min",
     "build:esm": "tsc --module es2015 --target es5 --downlevelIteration --outDir dist/esm",
-    "build:cjs": "tsc --module commonjs --target es2015 --declaration --downlevelIteration --outDir dist/cjs",
+    "build:cjs": "tsc",
     "build:umd": "rollup dist/esm/index.js --format umd -e \"jsts\" -g \"jsts:jsts\" --name \"DGeoUtils\" -m inline --file dist/umd/dgeoutils.js",
     "build:umd:min": "cd dist/umd && uglifyjs --compress --mangle --source-map --comments -o dgeoutils.min.js -- dgeoutils.js",
     "prepublishOnly": "npm run lint:report && npm run test && npm run test:badges && npm run doc && npm run build",
@@ -21,8 +20,8 @@
   },
   "author": "Efim Dejin <efim@dej.in.ua>",
   "license": "MIT",
-  "main": "dist/cjs/index.js",
-  "types": "dist/cjs/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
     "/dist"
   ],

package/dist/es2015/DCircle.js

@@ -1,87 +0,0 @@
-import { DPoint, EARTH_RADIUS_IN_METERS } from './DPoint';
-import { DPolygon } from './DPolygon';
-import { checkFunction } from './utils';
-export class DCircle {
-    constructor(center = DPoint.zero(), r = 0) {
-        this.center = center;
-        this.r = r;
-    }
-    toString() {
-        return `(${this.center.toString()}, ${this.r})`;
-    }
-    getValue() {
-        return { center: this.center, r: this.r };
-    }
-    clone() {
-        return new DCircle(this.center, this.r);
-    }
-    findPoints(c) {
-        if (this.equal(c)) {
-            return Infinity;
-        }
-        const { center: { x: x0, y: y0 }, r: r0 } = this;
-        const { center: { x: x1, y: y1 }, r: r1 } = c;
-        const r02 = r0 * r0;
-        const d = this.center.distance(c.center);
-        const a = (r02 - r1 * r1 + d * d) / (2 * d);
-        const h = Math.sqrt(r02 - a * a);
-        const ad = a / d;
-        const dy = y1 - y0;
-        const dx = x1 - x0;
-        const hd = h / d;
-        const x2 = x0 + ad * (x1 - x0);
-        const y2 = y0 + ad * (y1 - y0);
-        const x31 = x2 + hd * dy;
-        const y31 = y2 - hd * dx;
-        const x32 = x2 - hd * dy;
-        const y32 = y2 + hd * dx;
-        const res = [];
-        if (!isNaN(x31) && !isNaN(y31)) {
-            res.push(new DPoint(x31, y31));
-        }
-        if (!isNaN(x32) && !isNaN(y32) && !(x31 === x32 && y31 === y32)) {
-            res.push(new DPoint(x32, y32));
-        }
-        return res;
-    }
-    equal({ center, r }) {
-        return this.center.equal(center) && this.r === r;
-    }
-    findPolygonInside(pointCount = 64, startAngle = 0, stopAngle = 2 * Math.PI) {
-        const step = 2 * Math.PI / pointCount;
-        const points = [];
-        let angle = startAngle;
-        while (angle < stopAngle - step) {
-            points.push(new DPoint(this.r).scale(Math.cos(angle), Math.sin(angle))
-                .move(this.center));
-            angle += step;
-        }
-        const x = this.r * Math.cos(stopAngle) + this.center.x;
-        const y = this.r * Math.sin(stopAngle) + this.center.y;
-        points.push(new DPoint(x, y));
-        return new DPolygon(points);
-    }
-    findPolygonInsideOnSphere(pointCount = 64, startAngle = 0, stopAngle = 2 * Math.PI) {
-        checkFunction('findPolygonInsideOnSphere')
-            .checkArgument('center')
-            .shouldBeDegree(this.center);
-        const step = 2 * Math.PI / pointCount;
-        const points = [];
-        let angle = startAngle;
-        while (angle < stopAngle - step) {
-            points.push(this.sphereOffset(angle));
-            angle += step;
-        }
-        points.push(this.sphereOffset(stopAngle));
-        return new DPolygon(points);
-    }
-    sphereOffset(bearing, earthRadius = EARTH_RADIUS_IN_METERS) {
-        const { x: lon1, y: lat1 } = this.center.clone().degreeToRadians();
-        const dByR = this.r / earthRadius;
-        const lat = Math.asin(Math.sin(lat1) * Math.cos(dByR) +
-            Math.cos(lat1) * Math.sin(dByR) * Math.cos(bearing));
-        const lon = lon1 +
-            Math.atan2(Math.sin(bearing) * Math.sin(dByR) * Math.cos(lat1), Math.cos(dByR) - Math.sin(lat1) * Math.sin(lat));
-        return new DPoint(lon, lat).radiansToDegrees();
-    }
-}

package/dist/es2015/DLine.js

@@ -1,257 +0,0 @@
-import { DPoint } from './DPoint';
-import { checkFunction } from './utils';
-import { DNumbers } from './DNumbers';
-export class DLine {
-    constructor(a, b, c, begin = DPoint.zero(), end = DPoint.zero()) {
-        this.a = a;
-        this.b = b;
-        this.c = c;
-        this.begin = begin;
-        this.end = end;
-    }
-    clone() {
-        return new DLine(this.a, this.b, this.c, this.begin.clone(), this.end.clone());
-    }
-    findPerpendicular(p) {
-        checkFunction('findPerpendicular')
-            .checkArgument('this.begin')
-            .shouldBeMeters(this.begin)
-            .checkArgument('this.end')
-            .shouldBeMeters(this.end)
-            .checkArgument('p')
-            .shouldBeMeters(p);
-        return new DLine(-this.b, this.a, this.b * p.x - this.a * p.y);
-    }
-    perpendicularDistance(p) {
-        checkFunction('perpendicularDistance')
-            .checkArgument('this.begin')
-            .shouldBeMeters(this.begin)
-            .checkArgument('this.end')
-            .shouldBeMeters(this.end)
-            .checkArgument('p')
-            .shouldBeMeters(p);
-        const perpendicularLine = this.findPerpendicular(p);
-        const targetPoint = perpendicularLine.findPoint(this);
-        return targetPoint.distance(p);
-    }
-    intersection(l, d = 0, includeOnly = false) {
-        const p = this.findPoint(l);
-        if (p) {
-            if (includeOnly) {
-                return this.insideRange(p, d) && l.insideRange(p, d) ? p : null;
-            }
-            return this.inRange(p, d) && l.inRange(p, d) ? p : null;
-        }
-        return null;
-    }
-    intersectionWithCircle(circle) {
-        const { center, r } = circle;
-        const per = this.findPerpendicular(center);
-        const t = this.findPoint(per);
-        let distance = t.distance(center);
-        if (this.begin.equal(center)) {
-            distance = 0;
-        }
-        if (this.end.equal(center)) {
-            distance = 0;
-        }
-        if (distance < r) {
-            const { a, b, c } = this;
-            if (this.isParallel) {
-                const ct = center.distance(t);
-                const move = Math.sqrt(r * r - ct * ct);
-                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];
-                }
-                if (this.isParallelX) {
-                    t.y = this.begin.y;
-                    const r1 = t.clone().move(move, 0);
-                    const r2 = t.clone().move(-move, 0);
-                    return [r1, r2];
-                }
-            }
-            if (this.begin.like(center)) {
-                const p = this.begin.clone();
-                return [this.movePoint(p, r), this.movePoint(p, -r)];
-            }
-            if (this.end.like(center)) {
-                const p = this.end.clone();
-                return [this.movePoint(p, r), this.movePoint(p, -r)];
-            }
-            const s = a * a + b * b;
-            const d = r * r - c * c / s;
-            const mult = Math.sqrt(d / s);
-            const r1 = t.clone().move(b * mult, -a * mult);
-            const r2 = t.clone().move(-b * mult, a * mult);
-            return [r1, r2];
-        }
-        if (distance === r) {
-            return t;
-        }
-        return null;
-    }
-    inRange(p, d = 0) {
-        const { minX, minY, maxX, maxY } = this;
-        const { x, y } = p;
-        const isInX = x >= minX - d && x <= maxX + d;
-        const isInY = y >= minY - d && y <= maxY + d;
-        return isInX && isInY;
-    }
-    insideRange(p, d = 0) {
-        const { begin, end } = this;
-        return this.inRange(p, d) && !begin.like(p, 0.00001) && !end.like(p, 0.00001);
-    }
-    get center() {
-        return this.begin
-            .clone()
-            .setIfLessThan(this.end)
-            .move(this.end
-            .clone()
-            .move(this.begin
-            .clone()
-            .minus())
-            .abs()
-            .minus()
-            .divide(2));
-    }
-    get minX() {
-        return Math.min(this.begin.x, this.end.x);
-    }
-    get minY() {
-        return Math.min(this.begin.y, this.end.y);
-    }
-    get maxX() {
-        return Math.max(this.begin.x, this.end.x);
-    }
-    get maxY() {
-        return Math.max(this.begin.y, this.end.y);
-    }
-    toString() {
-        return `(${this.a}, ${this.b}, ${this.c})`;
-    }
-    getValue() {
-        return [this.a, this.b, this.c];
-    }
-    x(p) {
-        if (this.isParallelY) {
-            return new DPoint(-this.c / this.a, p.y);
-        }
-        if (this.isParallelX) {
-            return new DPoint(p.x, -this.c / this.b);
-        }
-        return new DPoint(-this.b / this.a * p.y - this.c / this.a, p.y);
-    }
-    y(p) {
-        if (this.isParallelY) {
-            return new DPoint(-this.c / this.a, p.y);
-        }
-        if (this.isParallelX) {
-            return new DPoint(p.x, -this.c / this.b);
-        }
-        return new DPoint(p.x, -this.a / this.b * p.x - this.c / this.b);
-    }
-    findPoint(l) {
-        if (this.isParallelY && l.isParallelY) {
-            return null;
-        }
-        if (this.isParallelX && l.isParallelX) {
-            return null;
-        }
-        if (this.isParallelX && l.isParallelY) {
-            return new DPoint(-l.c / l.a, -this.c / this.b);
-        }
-        if (this.isParallelY && l.isParallelX) {
-            return new DPoint(-this.c / this.a, -l.c / l.b);
-        }
-        if (this.isParallelY) {
-            const x = -this.c / this.a;
-            return l.y(new DPoint(x));
-        }
-        if (this.isParallelX) {
-            const y = -this.c / this.b;
-            return l.x(new DPoint(0, y));
-        }
-        if (l.isParallelY) {
-            const x = -l.c / l.a;
-            return this.y(new DPoint(x));
-        }
-        if (l.isParallelX) {
-            const y = -l.c / l.b;
-            return this.x(new DPoint(0, y));
-        }
-        const res = this.y(new DPoint((l.c / l.b - this.c / this.b) / (this.a / this.b - l.a / l.b)));
-        if (!isFinite(res.x) && !isFinite(res.y)) {
-            return null;
-        }
-        return res;
-    }
-    get isParallel() {
-        return this.isParallelX || this.isParallelY;
-    }
-    get isParallelY() {
-        return Math.abs(this.b) < 0.001;
-    }
-    get isParallelX() {
-        return Math.abs(this.a) < 0.001;
-    }
-    get points() {
-        return [this.begin, this.end];
-    }
-    getFi() {
-        checkFunction('getFi')
-            .checkArgument('this.begin')
-            .shouldBeMeters(this.begin)
-            .checkArgument('this.end')
-            .shouldBeMeters(this.end);
-        const { x, y } = this.end.clone().move(this.begin.clone().minus());
-        let v = Math.atan2(y, x) - Math.PI;
-        if (v > 0) {
-            v = Math.PI - v;
-        }
-        return (Math.PI - v) % (Math.PI * 2);
-    }
-    toWKT() {
-        const { begin: { x: x1, y: y1 }, end: { x: x2, y: y2 } } = this;
-        return `LINESTRING (${x1} ${y1}, ${x2} ${y2})`;
-    }
-    movePoint(i, k) {
-        const isArray = Array.isArray(i);
-        const p = isArray ? i : [i];
-        const d = (isArray ? k : [k]);
-        const fi = this.findFi(new DLine(1, 0, 0));
-        const td = this.x(new DPoint(1, 1)).distance(this.x(new DPoint(2, 2))) / 2;
-        const sinCos = new DPoint(Math.sin(fi), Math.cos(fi));
-        const dt = sinCos.clone().scale(td);
-        const p1T = p[0].clone().move(dt.clone().minus());
-        const p2T = p[0].clone().move(dt);
-        let res = [];
-        if (DNumbers.like(this.y(p1T).y, p1T.y) || DNumbers.like(this.y(p2T).y, p2T.y)) {
-            res = p.map((t, index) => t.clone()
-                .move(sinCos.clone().scale(d[index])));
-        }
-        else {
-            res = p.map((t, index) => t.clone()
-                .move(sinCos.clone().scale(d[index])
-                .setX(({ x }) => -x)));
-        }
-        return isArray ? res : res[0];
-    }
-    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));
-        if (val > 1 && val < delta) {
-            val = 1;
-        }
-        else if (val < -1 && val > -delta) {
-            val = -1;
-        }
-        return Math.acos(val);
-    }
-    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/es2015/DNumbers.js

@@ -1,22 +0,0 @@
-import { DEGREE_TO_PI, DOUBLE_PI_IN_DEGREE, PI_IN_DEGREE, PI_TO_DEGREE } from './DPoint';
-const delta = 0.001;
-export class DNumbers {
-    static like(v, s, d = delta) {
-        return Math.abs(v - s) < d;
-    }
-    static likeZero(v) {
-        return DNumbers.like(v, 0);
-    }
-    static like2PI(v) {
-        return DNumbers.like(DNumbers.rad2Deg(v), DOUBLE_PI_IN_DEGREE);
-    }
-    static likePI(v) {
-        return DNumbers.like(DNumbers.rad2Deg(v), PI_IN_DEGREE);
-    }
-    static rad2Deg(v) {
-        return v * DEGREE_TO_PI;
-    }
-    static deg2Rad(v) {
-        return v * PI_TO_DEGREE;
-    }
-}

package/dist/es2015/DPlane.js

@@ -1,105 +0,0 @@
-import { DPoint } from './DPoint';
-import { gaussianElimination } from './utils';
-import { DNumbers } from './DNumbers';
-export class DPlane {
-    constructor(a, b, c, d, p1 = DPoint.zero(), p2 = DPoint.zero(), p3 = 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] = 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) {
-            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) {
-            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) {
-            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) {
-            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.like(a, q) &&
-            DNumbers.like(b, w) &&
-            DNumbers.like(c, e) &&
-            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.like(t, y) &&
-            DNumbers.like(t, u) &&
-            DNumbers.like(t, c) &&
-            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.like(t, y) &&
-            DNumbers.like(t, u) &&
-            DNumbers.like(t, c) &&
-            !DNumbers.like(t, i);
-    }
-}