dgeoutils 2.2.4 → 2.2.8

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,51 +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 `y` value
-     * @param y
-     */
+    setZ(z: number): DPoint;
+    setZ(f: SetterFunction): DPoint;
     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;
@@ -128,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);
@@ -211,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')
@@ -152,6 +132,10 @@ class DPoint {
         this.x = typeof x === 'number' ? x : x(this);
         return this;
     }
+    setZ(z) {
+        this.z = typeof z === 'number' ? z : z(this);
+        return this;
+    }
     setY(y) {
         this.y = typeof y === 'number' ? y : y(this);
         return this;
@@ -173,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);
@@ -260,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));
@@ -306,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;
@@ -327,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));
@@ -416,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')

package/dist/DPolygon.d.ts

@@ -11,20 +11,12 @@ export declare class DPolygon {
     holes: DPolygon[];
     private searchStore;
     constructor(pPoints?: DPoint[]);
-    /**
-     * Get size of min area rectangle.
-     * @param poly should be `minAreaRectangle`
-     */
+    static CAP_ROUND: number;
+    static CAP_FLAT: number;
+    static CAP_SQUARE: number;
+    static arrayOfTrianglesToVertices(triangles: DPolygon[], height?: number): number[];
     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;
@@ -35,116 +27,37 @@ 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;
-    toWKT(): string;
-    /**
-     * Filter points
-     * @param f
-     */
+    static WKT_LINESTRING: string;
+    static WKT_POLYGON: string;
+    toWKT(type?: string): string;
     filter(f: (p: DPoint) => boolean): DPolygon;
-    map(f: (r: DPoint, index?: number) => DPoint): DPolygon;
+    map(f: (r: DPoint) => DPoint): DPolygon;
+    map(f: (r: DPoint, index: number) => DPoint): DPolygon;
     at(index: number): DPoint;
     pop(): DPoint;
     push(...args: DPoint[]): number;
@@ -153,113 +66,41 @@ 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
-     */
     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[];
+    getTrianglesPointIndexes(): number[];
+    get closed(): boolean;
+    buffer(v: number, quadrantSegments?: number, type?: number): DPolygon;
     private simpleIncludeX;
     private simpleIncludeY;
     private douglasPeucker;