dgeoutils 2.2.7 → 2.2.11

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);
@@ -188,19 +164,47 @@ class DPoint {
         this.y = y;
         return this;
     }
-    move(x, y = x) {
+    rotate3dX(a) {
+        const { y, z } = this;
+        this.y = y * Math.cos(a) + z * Math.sin(a);
+        this.z = -y * Math.sin(a) + z * Math.cos(a);
+        return this;
+    }
+    rotate3dY(a) {
+        const { x, z } = this;
+        this.x = x * Math.cos(a) + z * Math.sin(a);
+        this.z = -x * Math.sin(a) + z * Math.cos(a);
+        return this;
+    }
+    rotate3dZ(a) {
+        const { x, y } = this;
+        this.x = x * Math.cos(a) - y * Math.sin(a);
+        this.y = -x * Math.sin(a) + y * Math.cos(a);
+        return this;
+    }
+    move(x, y = x, z = x) {
         let xV = 0;
         let yV = 0;
+        let zV = undefined;
         if (x instanceof DPoint) {
             xV = this.x + x.x;
             yV = this.y + x.y;
+            if (this.z && x.z) {
+                zV = this.z + x.z;
+            }
         }
         else {
             xV = this.x + x;
             yV = this.y + y;
+            if (this.z && z) {
+                zV = this.z + z;
+            }
         }
         this.x = xV;
         this.y = yV;
+        if (zV) {
+            this.z = zV;
+        }
         return this;
     }
     degreeToMeters() {
@@ -264,9 +268,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,17 +311,14 @@ 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) {
+        var _a, _b, _c, _d;
         if (this.equal(p)) {
             return true;
         }
         const likeX = Math.abs(this.x - p.x) < d;
         const likeY = Math.abs(this.y - p.y) < d;
-        const likeZ = Math.abs((this.z || 0) - (p.z || 0)) < d;
+        const likeZ = Math.abs(((_b = (_a = this.z) !== null && _a !== void 0 ? _a : p.z) !== null && _b !== void 0 ? _b : 0) - ((_d = (_c = p.z) !== null && _c !== void 0 ? _c : this.z) !== null && _d !== void 0 ? _d : 0)) < d;
         return likeX && likeY && likeZ;
     }
     flipVertically(size) {
@@ -331,27 +329,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 +409,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')

package/dist/DPolygon.d.ts

@@ -11,53 +11,12 @@ export declare class DPolygon {
     holes: DPolygon[];
     private searchStore;
     constructor(pPoints?: DPoint[]);
-    /**
-     * Specifies a round line buffer end cap style.
-     */
     static CAP_ROUND: number;
-    /**
-     * Specifies a flat line buffer end cap style.
-     */
     static CAP_FLAT: number;
-    /**
-     * Specifies a square line buffer end cap style.
-     */
     static CAP_SQUARE: number;
-    /**
-     * Transform array of triangles to Three.JS vertices
-     *
-     * ```
-     * const geometry = new THREE.BufferGeometry();
-     * // create a simple square shape. We duplicate the top left and bottom right
-     * // vertices because each vertex needs to appear once per triangle.
-     * const vertices = new Float32Array( DPolygon.arrayOfTrianglesToVertices(triangles, 10) );
-     *
-     * // itemSize = 3 because there are 3 values (components) per vertex
-     * geometry.setAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
-     * const material = new THREE.MeshBasicMaterial( { color: 0xff0000 } );
-     * mesh = new THREE.Mesh( geometry, material );
-     *
-     * scene.add( mesh );
-     * ```
-     *
-     * @param triangles
-     * @param [height=0]
-     */
     static arrayOfTrianglesToVertices(triangles: DPolygon[], height?: number): number[];
-    /**
-     * Get size of min area rectangle.
-     * @param poly should be `minAreaRectangle`
-     */
     static minAreaRectangleSize(poly: DPolygon): DPoint;
-    /**
-     * Slice line string to dashes.
-     * @param poly should be `divideToPieces` at first
-     */
     static toDash(poly: DPolygon): DPolygon[];
-    /**
-     * Get min area rectangle direction
-     * @param poly should be `minAreaRectangle`
-     */
     static minAreaRectangleDirection(poly: DPolygon): number;
     static parseFromWKT(wkt: string): DPolygon;
     static createSquareBySize(size: DPoint): DPolygon;
@@ -68,119 +27,34 @@ export declare class DPolygon {
     get minX(): number;
     get maxY(): number;
     get minY(): number;
-    /**
-     * Get center coordinates
-     */
     get center(): DPoint;
-    /**
-     * Difference between `maxY` and `minY`. Equal `ΔY` (`dY`)
-     */
     get h(): number;
-    /**
-     * Difference between `maxX` and `minX`. Equal `ΔX` (`dX`)
-     */
     get w(): number;
-    /**
-     * Difference between `maxY` and `minY`. Equal `height` (`h`)
-     */
     get dY(): number;
-    /**
-     * Difference between `maxX` and `minX`. Equal `width` (`w`)
-     */
     get dX(): number;
-    /**
-     * Get closed extend polygon
-     */
     get extend(): DPolygon;
-    /**
-     * Point with `width` value as `x` and `height` value as `y`
-     */
     get size(): DPoint;
-    /**
-     * Point with minimal `x` and `y`
-     */
     get leftTop(): DPoint;
-    /**
-     * Point with maximal `x` and `y`
-     */
     get rightBottom(): DPoint;
-    /**
-     * Next point index
-     */
     get length(): number;
-    /**
-     * Get length of line string.
-     */
     get fullLength(): number;
-    /**
-     * Get perimeter.
-     */
     get perimeter(): number;
-    /**
-     * Get polygon area
-     */
     get area(): number;
-    /**
-     * Get deintesected polygon.
-     */
     get deintersection(): DPolygon;
-    /**
-     * Check if polygon contain more than three points
-     */
     get valid(): boolean;
-    /**
-     * Get first point
-     */
     get first(): DPoint;
-    /**
-     * Get second point
-     */
     get second(): DPoint;
-    /**
-     * Get last point
-     */
     get last(): DPoint;
-    /**
-     * Get min area rectangle
-     */
     get minAreaRectangle(): DPolygon;
-    /**
-     * Get convex polygon
-     */
     get convex(): DPolygon;
-    /**
-     * Check polygon direction
-     */
     get isClockwise(): boolean;
-    /**
-     * Get clockwise polygon
-     */
     get clockWise(): DPolygon;
-    /**
-     * Get polygon clone without holes
-     */
     get noHoles(): DPolygon;
-    /**
-     * Check polygon intersection with line
-     * @param l
-     * @param [includeOnly=false]
-     */
     intersection(l: DLine, includeOnly?: boolean): DPoint[];
-    /**
-     * Set polygon center
-     * @param newCenter
-     */
     setCenter(newCenter: DPoint): DPolygon;
     static WKT_LINESTRING: string;
     static WKT_POLYGON: string;
-    /**
-     * @param [type = DPolygon.WKT_POLYGON] Available values `DPolygon.WKT_POLYGON`, `DPolygon.WKT_LINESTRING`
-     */
-    toWKT(type?: string): string;
-    /**
-     * Filter points
-     * @param f
-     */
+    toWKT(type?: string, withZ?: boolean): string;
     filter(f: (p: DPoint) => boolean): DPolygon;
     map(f: (r: DPoint) => DPoint): DPolygon;
     map(f: (r: DPoint, index: number) => DPoint): DPolygon;
@@ -192,129 +66,45 @@ export declare class DPolygon {
     reverse(): DPolygon;
     getValue(): string;
     toString(): string;
-    /**
-     * Add to the end of polygon point equal to first point if it not exist
-     */
     close(): DPolygon;
-    /**
-     * Remove from the end of polygon point equal to first point if it exist
-     */
     open(): DPolygon;
     add(poly: DPolygon): DPolygon;
-    /**
-     * Check if has point in list of points
-     * @param p
-     */
     has(p: DPoint): boolean;
     clone(): DPolygon;
-    /**
-     * Check is it fully equal.
-     * @param p
-     */
     equal(p: DPolygon | null): boolean;
-    /**
-     * Check is polygons are same. They can be with different directions and different start points.
-     * @param p
-     */
     same(p: DPolygon): boolean;
     findIndex(p: DPoint): number;
-    /**
-     * Get polygon approximation by
-     * [Ramer–Douglas–Peucker algorithm](https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm)
-     * @param [e=Math.sqrt(this.perimeter)*APPROXIMATION_VALUE]
-     */
     approximation(e?: number): DPolygon;
     insertAfter(index: number, ...points: DPoint[]): void;
     removePart(index: number, count: number): DPoint[];
-    /**
-     * Check intersection with other polygon
-     * @param p
-     */
     hasSimpleIntersection(p: DPolygon): boolean;
-    /**
-     * Check if it possible to include point
-     * @param p
-     */
     simpleInclude(p: DPoint): boolean;
     drawPolygonOnCanvas(canvas: HTMLCanvasElement | OffscreenCanvas, fillColor?: string, strokeColor?: string, shadowColor?: string, lineWidth?: number, steps?: number): void;
     clearPolygonOnCanvas(canvas: HTMLCanvasElement | OffscreenCanvas): void;
-    /**
-     * Check if contain point
-     * @param p
-     * @param [isBorderInside=false]
-     * @param [move=(0,0)] Ignore this parameter
-     */
-    contain(p: DPoint, isBorderInside?: boolean, move?: DPoint): boolean;
-    /**
-     * Check if point on border
-     * @param p
-     */
+    contain(p: DPoint, isBorderInside?: boolean): boolean;
     onBorder(p: DPoint): boolean;
-    /**
-     * Change start point to second point
-     */
     nextStart(): DPolygon;
-    /**
-     * Remove duplicates points
-     */
     removeDuplicates(): DPolygon;
-    /**
-     * Parse from [OpenLayers](https://openlayers.org/) coordinates
-     * @param a
-     */
     static parse(a: LatLng[]): DPolygon;
-    /**
-     * Parse from [GeoJSON](https://en.wikipedia.org/wiki/GeoJSON) coordinates
-     * @param a
-     */
     static parse(a: number[][]): DPolygon;
-    /**
-     * Parse from [OpenLayers](https://openlayers.org/) coordinates
-     * @param a
-     */
     static parse(a: DCoord[]): DPolygon;
-    /**
-     * Transform to array of coordinates for [OpenLayers](https://openlayers.org/) or
-     * [GeoJSON](https://en.wikipedia.org/wiki/GeoJSON)
-     */
     toArrayOfCoords(): DCoord[];
-    /**
-     * Divide line string to pieces by length
-     * @param piecesCount
-     */
     divideToPieces(piecesCount: number): DPolygon;
     prepareToFastSearch(): void;
     fastHas({ x, y, z }: DPoint): boolean;
-    /**
-     * Get line string as line string with growing length. For animation.
-     */
     get growingPiecesGenerator(): () => Generator<DPolygon, DPolygon>;
     simpleUnion(p: DPolygon): DPolygon | null;
     simpleIntersection(p: DPolygon): DPolygon | null | DPolygon[];
     simpleDifference(p: DPolygon): DPolygon | null | DPolygon[];
     smartUnion(p: DPolygon): DPolygon | null;
-    /**
-     * Divide polygon to triangles
-     *
-     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/toTriangles.png)
-     */
     toTriangles(): DPolygon[];
-    /**
-     * Divide polygon to triangles and return points indexes
-     */
     getTrianglesPointIndexes(): number[];
     get closed(): boolean;
-    /**
-     * @param v
-     * @param [quadrantSegments=64]
-     * @param [type=DPolygon.CAP_ROUND] DPolygon.CAP_ROUND || DPolygon.CAP_FLAT || DPolygon.CAP_SQUARE
-     */
     buffer(v: number, quadrantSegments?: number, type?: number): DPolygon;
     private simpleIncludeX;
     private simpleIncludeY;
     private douglasPeucker;
     private goByPath;
-    private contain2;
     private getJSTSGeometry;
     private simpleLogicFunction;
 }