dgeoutils 2.2.7 → 2.2.8

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/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,61 +37,20 @@ 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
-     */
     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;
     degreeToMeters(): DPoint;
     metersToDegree(): DPoint;
@@ -138,70 +61,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 +94,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;
 }

package/dist/DPoint.js

@@ -19,12 +19,10 @@ exports.DOUBLE_PI_IN_DEGREE = 360;
 exports.PI_TO_DEGREE = Math.PI / exports.PI_IN_DEGREE;
 exports.DEGREE_TO_PI = exports.PI_IN_DEGREE / Math.PI;
 class DPoint {
-    // eslint-disable-next-line no-empty-function,no-useless-constructor
     constructor(x = 0, y = x, z) {
         this.x = x;
         this.y = y;
         this.z = z;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         this.properties = {};
     }
     static zero() {
@@ -48,13 +46,6 @@ class DPoint {
     static random() {
         return new DPoint(Math.random(), Math.random());
     }
-    /**
-     * @remark Point should be Lng/Lat.
-     *
-     * @remark `z` value default for `zoom` argument.
-     *
-     * @param [zoom=this.z]
-     */
     getTileFromCoords(zoom = this.z) {
         (0, utils_1.checkFunction)('getTileFromCoords')
             .checkArgument('this')
@@ -63,13 +54,6 @@ class DPoint {
         const y = Math.floor((1 - Math.log(Math.tan(this.y * exports.PI_TO_DEGREE) + 1 / Math.cos(this.y * exports.PI_TO_DEGREE)) / Math.PI) / 2 * (Math.pow(2, zoom)));
         return new DPoint(x, y, zoom);
     }
-    /**
-     * Result would be Lng/Lat.
-     *
-     * @remark `z` value default for `zoom` argument.
-     *
-     * @param [zoom=this.z]
-     */
     getCoordsFromTile(zoom = this.z) {
         (0, utils_1.checkFunction)('getCoordsFromTile')
             .checkArgument('this')
@@ -85,10 +69,6 @@ class DPoint {
         }
         return [this.x, this.y, this.z];
     }
-    /**
-     * Find line between two points.
-     * @param p
-     */
     findLine(p) {
         (0, utils_1.checkFunction)('findLine')
             .checkArgument('this')
@@ -177,10 +157,6 @@ class DPoint {
     ltOrEqual(p) {
         return this.lt(p) || this.equal(p);
     }
-    /**
-     * Clockwise rotation
-     * @param a radians
-     */
     rotate(a) {
         const x = this.x * Math.cos(a) - this.y * Math.sin(a);
         const y = this.x * Math.sin(a) + this.y * Math.cos(a);
@@ -264,9 +240,6 @@ class DPoint {
         this.y = Math.floor(this.y);
         return this;
     }
-    /**
-     * @param [n=2]
-     */
     toFixed(n = 2) {
         this.x = parseFloat(this.x.toFixed(n));
         this.y = parseFloat(this.y.toFixed(n));
@@ -310,10 +283,6 @@ class DPoint {
     equal(p) {
         return this.x === p.x && this.y === p.y && this.z === p.z;
     }
-    /**
-     * @param p
-     * @param [d=0.001]
-     */
     like(p, d = 0.001) {
         if (this.equal(p)) {
             return true;
@@ -331,27 +300,18 @@ class DPoint {
         this.y = v - this.y;
         return this;
     }
-    /**
-     * Check if point looks like radians
-     */
     get likeRadians() {
         if (radiansPolygon.length === 0) {
             radiansPolygon.push(new DPoint(-Math.PI, -Math.PI / 2), new DPoint(Math.PI, Math.PI / 2));
         }
         return radiansPolygon.simpleInclude(this);
     }
-    /**
-     * Check if point looks like `EPSG:4326` (degrees)
-     */
     get likeWorldGeodeticSystem() {
         if (worldGeodeticPolygon.length === 0) {
             worldGeodeticPolygon.push(new DPoint(-180, -90), new DPoint(180, 90));
         }
         return !this.likeRadians && worldGeodeticPolygon.simpleInclude(this);
     }
-    /**
-     * Check if point looks like `EPSG:3857` (meters)
-     */
     get likePseudoMercator() {
         if (pseudoMercatorPolygon.length === 0) {
             pseudoMercatorPolygon.push(new DPoint(-20026376.39, -20048966.10), new DPoint(20026376.39, 20048966.10));
@@ -420,16 +380,6 @@ class DPoint {
     minus() {
         return this.clone().scale(-1);
     }
-    /**
-     * 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, pointsCount = 360) {
         (0, utils_1.checkFunction)('orthodromicPath')
             .checkArgument('this')