dgeoutils 2.4.47 → 2.4.52

package/dist/cjs/DPlane.js

@@ -0,0 +1,132 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DPlane = void 0;
+var DPoint_1 = require("./DPoint");
+var utils_1 = require("./utils");
+var DNumbers_1 = require("./DNumbers");
+var DPlane = (function () {
+    function DPlane(a, b, c, d, p1, p2, p3) {
+        if (p1 === void 0) { p1 = DPoint_1.DPoint.zero(); }
+        if (p2 === void 0) { p2 = DPoint_1.DPoint.zero(); }
+        if (p3 === void 0) { 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;
+    }
+    DPlane.find = function (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);
+        }
+        var d = 1;
+        var _a = __read((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]
+        ]), 3), a = _a[0], b = _a[1], c = _a[2];
+        return new DPlane(a, b, c, d, p1, p2, p3);
+    };
+    DPlane.prototype.x = function (p) {
+        var _this = this;
+        if (p instanceof DPoint_1.DPoint) {
+            var _a = this, a = _a.a, b = _a.b, c = _a.c, d = _a.d;
+            var y = p.y, z = p.z;
+            p.x = -(b * y + c * z + d) / a;
+            return p;
+        }
+        return p.map(function (t) { return _this.x(t); });
+    };
+    DPlane.prototype.y = function (p) {
+        var _this = this;
+        if (p instanceof DPoint_1.DPoint) {
+            var _a = this, a = _a.a, b = _a.b, c = _a.c, d = _a.d;
+            var x = p.x, z = p.z;
+            p.y = -(a * x + c * z + d) / b;
+            return p;
+        }
+        return p.map(function (t) { return _this.y(t); });
+    };
+    DPlane.prototype.z = function (p) {
+        var _this = this;
+        if (p instanceof DPoint_1.DPoint) {
+            var _a = this, a = _a.a, b = _a.b, c = _a.c, d = _a.d;
+            var x = p.x, y = p.y;
+            p.z = -(a * x + b * y + d) / c;
+            return p;
+        }
+        return p.map(function (t) { return _this.z(t); });
+    };
+    DPlane.prototype.clone = function () {
+        var _a = this, a = _a.a, b = _a.b, c = _a.c, d = _a.d, p1 = _a.p1, p2 = _a.p2, p3 = _a.p3;
+        return new DPlane(a, b, c, d, p1, p2, p3);
+    };
+    DPlane.prototype.distance = function (p) {
+        if (p instanceof DPoint_1.DPoint) {
+            var x = p.x, y = p.y, z = p.z;
+            var _a = this, a_1 = _a.a, b_1 = _a.b, c_1 = _a.c, d_1 = _a.d;
+            return Math.abs(a_1 * x + b_1 * y + c_1 * z + d_1) / Math.sqrt(a_1 * a_1 + b_1 * b_1 + c_1 * c_1);
+        }
+        var _b = p, a = _b.a, b = _b.b, c = _b.c, d = _b.d;
+        var r = this.d;
+        return Math.abs(d - r) / Math.sqrt(a * a + b * b + c * c);
+    };
+    DPlane.prototype.equal = function (p) {
+        var a = p.a, b = p.b, c = p.c, d = p.d;
+        var _a = this, q = _a.a, w = _a.b, e = _a.c, r = _a.d;
+        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);
+    };
+    DPlane.prototype.same = function (p) {
+        var a = p.a, b = p.b, c = p.c, d = p.d;
+        var _a = this, q = _a.a, w = _a.b, e = _a.c, r = _a.d;
+        var t = a / q;
+        var y = b / w;
+        var u = c / e;
+        var 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);
+    };
+    DPlane.prototype.parallel = function (p) {
+        var a = p.a, b = p.b, c = p.c, d = p.d;
+        var _a = this, q = _a.a, w = _a.b, e = _a.c, r = _a.d;
+        var t = a / q;
+        var y = b / w;
+        var u = c / e;
+        var 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);
+    };
+    return DPlane;
+}());
+exports.DPlane = DPlane;

package/dist/cjs/DPoint.d.ts

@@ -0,0 +1,138 @@
+import { DLine } from './DLine';
+import { DPolygon } from './DPolygon';
+import { Point, Feature } from 'geojson';
+export declare const EARTH_RADIUS_IN_METERS = 6378137;
+export declare type DCoord = [number, number] | [number, number, number];
+export interface LatLng {
+    lat: number;
+    lng?: number;
+    lon?: number;
+    alt?: number;
+}
+export interface XYZ extends Record<string, any> {
+    x: number;
+    y: number;
+    z?: number;
+}
+export declare const HALF_PI_IN_DEGREE = 90;
+export declare const PI_IN_DEGREE = 180;
+export declare const DOUBLE_PI_IN_DEGREE = 360;
+export declare const PI_TO_DEGREE: number;
+export declare const DEGREE_TO_PI: number;
+declare type SetterFunction<T> = (t: DPoint) => T;
+export declare class DPoint {
+    x: number;
+    y: number;
+    z?: number | undefined;
+    properties: Record<string, any>;
+    constructor();
+    constructor(xy: number);
+    constructor(x: number, y: number);
+    constructor(x: number, y: number, z?: number);
+    static zero(): DPoint;
+    static parse(c: LatLng | number[] | DCoord | Point | Feature<Point> | XYZ, format?: string): DPoint;
+    static parseFromWKT(wkt: string): DPoint;
+    static random(): DPoint;
+    static getTileFromQuadKey(quadKey: string): DPoint;
+    toDegreesMinutesSeconds(): {
+        x: string;
+        y: string;
+    };
+    getTileFromCoords(zoom?: number): DPoint;
+    getQuadKeyFromTile(zoom?: number): string;
+    getCoordsFromTile(zoom?: number): DPoint;
+    toCoords(format?: string): DCoord;
+    toGeoJSON(format?: string): Point;
+    toGeoJSONFeature(format?: string): Feature<Point>;
+    findLine(p: DPoint): DLine;
+    findInnerAngle(p1: DPoint, p3: DPoint): number;
+    toString(): string;
+    getValue(): [number, number];
+    height(z: number): DPoint;
+    toWKT(): string;
+    distance(p: DPoint): number;
+    distance3d(p: DPoint): number;
+    setX(x: number): DPoint;
+    setX(f: SetterFunction<number>): DPoint;
+    setZ(z: number): DPoint;
+    setZ(f: SetterFunction<number>): DPoint;
+    setY(y: number): DPoint;
+    setY(f: SetterFunction<number>): DPoint;
+    setProperties(v: SetterFunction<Record<string, any>> | Record<string, any>): DPoint;
+    clone(): DPoint;
+    gt(p: DPoint): boolean;
+    lt(p: DPoint): boolean;
+    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;
+    radiansToDegrees(): DPoint;
+    radiansToMeters(): DPoint;
+    metersToRadians(): DPoint;
+    round(): DPoint;
+    ceil(): DPoint;
+    floor(): DPoint;
+    toFixed(n?: number): DPoint;
+    abs(): 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;
+    mod(v: number): DPoint;
+    mod(p: DPoint): DPoint;
+    mod(x: number, y: number): DPoint;
+    mod(x: number, y: number, z: number): DPoint;
+    div(v: number): DPoint;
+    div(p: DPoint): DPoint;
+    div(x: number, y: number): DPoint;
+    div(x: number, y: number, z: number): DPoint;
+    equal(p: DPoint): boolean;
+    like(p: DPoint, d?: number): boolean;
+    flipVertically(size: DPoint): DPoint;
+    flipVertically(height: number): DPoint;
+    get likeRadians(): boolean;
+    get likeWorldGeodeticSystem(): boolean;
+    get likePseudoMercator(): boolean;
+    get w(): number;
+    set w(x: number);
+    get h(): number;
+    set h(y: number);
+    get area(): number;
+    get hip(): number;
+    get min(): number;
+    get max(): number;
+    get hipPoint(): DPoint;
+    get xPoint(): DPoint;
+    get yPoint(): DPoint;
+    get wPoint(): DPoint;
+    get hPoint(): DPoint;
+    get lat(): number;
+    set lat(v: number);
+    get lng(): number;
+    set lng(v: number);
+    get lon(): number;
+    set lon(v: number);
+    get alt(): number | undefined;
+    set alt(v: number | undefined);
+    simple<T extends Record<string, number>>(xKey?: string, yKey?: string, zKey?: string): T;
+    setIfLessThan(p: DPoint): DPoint;
+    setIfMoreThan(p: DPoint): DPoint;
+    minus(): DPoint;
+    orthodromicPath(point: DPoint, pointsCount?: number): DPolygon;
+    sortByDistance(p: DPolygon): DPolygon;
+    calculateAltitudeByDistanceBetweenPoints(p1: DPoint, p2: DPoint): DPoint;
+}
+export {};