dgeoutils 2.2.3 → 2.2.7

package/dist/DLine.d.ts

@@ -4,9 +4,16 @@ export declare class DLine {
     a: number;
     b: number;
     c: number;
-    p1: DPoint;
-    p2: DPoint;
-    constructor(a?: number, b?: number, c?: number, p1?: DPoint, p2?: DPoint);
+    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;
@@ -80,10 +87,10 @@ export declare class DLine {
      * @param l
      * @param delta
      */
-    findFi(l: DLine, delta?: number): number;
+    findFi({ a, b }: DLine, delta?: number): number;
     /**
      * [Cross product](https://en.wikipedia.org/wiki/Cross_product)
-     * @param l
+     * @param l {DLine}
      */
-    vectorProduct(l: DLine): DLine;
+    vectorProduct({ a, b, c }: DLine): DLine;
 }

package/dist/DLine.js

@@ -3,36 +3,44 @@ 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 = 0, b = 0, c = 0, p1 = DPoint_1.DPoint.zero(), p2 = DPoint_1.DPoint.zero()
+    constructor(a, b, c, begin = DPoint_1.DPoint.zero(), end = DPoint_1.DPoint.zero()
     // eslint-disable-next-line no-empty-function
     ) {
         this.a = a;
         this.b = b;
         this.c = c;
-        this.p1 = p1;
-        this.p2 = p2;
+        this.begin = begin;
+        this.end = end;
     }
     clone() {
-        return new DLine(this.a, this.b, this.c, this.p1.clone(), this.p2.clone());
+        return new DLine(this.a, this.b, this.c, this.begin.clone(), this.end.clone());
     }
     findPerpendicular(p) {
         (0, utils_1.checkFunction)('findPerpendicular')
-            .checkArgument('this.p1')
-            .shouldBeMeters(this.p1)
-            .checkArgument('this.p2')
-            .shouldBeMeters(this.p2)
+            .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) {
         (0, utils_1.checkFunction)('perpendicularDistance')
-            .checkArgument('this.p1')
-            .shouldBeMeters(this.p1)
-            .checkArgument('this.p2')
-            .shouldBeMeters(this.p2)
+            .checkArgument('this.begin')
+            .shouldBeMeters(this.begin)
+            .checkArgument('this.end')
+            .shouldBeMeters(this.end)
             .checkArgument('p')
             .shouldBeMeters(p);
         const perpendicularLine = this.findPerpendicular(p);
@@ -61,10 +69,10 @@ class DLine {
         const per = this.findPerpendicular(center);
         const t = this.intersection(per, Infinity);
         let distance = t.distance(center);
-        if (this.p1.equal(center)) {
+        if (this.begin.equal(center)) {
             distance = 0;
         }
-        if (this.p2.equal(center)) {
+        if (this.end.equal(center)) {
             distance = 0;
         }
         if (distance < r) {
@@ -74,25 +82,25 @@ class DLine {
                 const move = Math.sqrt(r * r - ct * ct);
                 // Mean "|" x = const
                 if (this.isParallelY) {
-                    t.x = this.p1.x;
+                    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.p1.y;
+                    t.y = this.begin.y;
                     const r1 = t.clone().move(move, 0);
                     const r2 = t.clone().move(-move, 0);
                     return [r1, r2];
                 }
             }
-            if (this.p1.like(center)) {
-                const p = this.p1.clone();
+            if (this.begin.like(center)) {
+                const p = this.begin.clone();
                 return [this.movePoint(p, r), this.movePoint(p, -r)];
             }
-            if (this.p2.like(center)) {
-                const p = this.p2.clone();
+            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;
@@ -125,16 +133,16 @@ class DLine {
      * @param [d=0]
      */
     insideRange(p, d = 0) {
-        const { p1, p2 } = this;
-        return this.inRange(p, d) && !p1.like(p, 0.00001) && !p2.like(p, 0.00001);
+        const { begin, end } = this;
+        return this.inRange(p, d) && !begin.like(p, 0.00001) && !end.like(p, 0.00001);
     }
     get center() {
-        return this.p1
+        return this.begin
             .clone()
-            .setIfLessThan(this.p2)
-            .move(this.p2
+            .setIfLessThan(this.end)
+            .move(this.end
             .clone()
-            .move(this.p1
+            .move(this.begin
             .clone()
             .minus())
             .abs()
@@ -142,16 +150,16 @@ class DLine {
             .divide(2));
     }
     get minX() {
-        return Math.min(this.p1.x, this.p2.x);
+        return Math.min(this.begin.x, this.end.x);
     }
     get minY() {
-        return Math.min(this.p1.y, this.p2.y);
+        return Math.min(this.begin.y, this.end.y);
     }
     get maxX() {
-        return Math.max(this.p1.x, this.p2.x);
+        return Math.max(this.begin.x, this.end.x);
     }
     get maxY() {
-        return Math.max(this.p1.y, this.p2.y);
+        return Math.max(this.begin.y, this.end.y);
     }
     toString() {
         return `(${this.a}, ${this.b}, ${this.c})`;
@@ -241,47 +249,26 @@ class DLine {
      * Get lines segment start and end points as array
      */
     get points() {
-        return [this.p1, this.p2];
+        return [this.begin, this.end];
     }
     /**
      * Get line segment direction (from start point to end point)
      */
     getFi() {
         (0, utils_1.checkFunction)('getFi')
-            .checkArgument('this.p1')
-            .shouldBeMeters(this.p1)
-            .checkArgument('this.p2')
-            .shouldBeMeters(this.p2);
-        const l = new DLine(0, 1, 0);
-        const result = this.findFi(l);
-        if (this.p1.x === this.p2.x) {
-            if (this.p1.y === this.p2.y) {
-                return 0;
-            }
-            else if (this.p1.y < this.p2.y) {
-                return Math.PI + Math.PI / 2;
-            }
-            return Math.PI / 2;
-        }
-        else if (this.p1.x < this.p2.x) {
-            if (this.p1.y === this.p2.y) {
-                return 0;
-            }
-            else if (this.p1.y < this.p2.y) {
-                return Math.PI - result + Math.PI;
-            }
-            return result;
-        }
-        if (this.p1.y === this.p2.y) {
-            return Math.PI;
+            .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;
         }
-        else if (this.p1.y < this.p2.y) {
-            return Math.PI - result + Math.PI;
-        }
-        return result;
+        return (Math.PI - v) % (Math.PI * 2);
     }
     toWKT() {
-        const { p1: { x: x1, y: y1 }, p2: { x: x2, y: y2 } } = this;
+        const { begin: { x: x1, y: y1 }, end: { x: x2, y: y2 } } = this;
         return `LINESTRING (${x1} ${y1}, ${x2} ${y2})`;
     }
     /**
@@ -291,7 +278,7 @@ class DLine {
      */
     movePoint(p, d) {
         const fi = this.findFi(new DLine(1, 0, 0));
-        const td = this.p1.distance(this.p2) / 2;
+        const td = this.begin.distance(this.end) / 2;
         const dcosT = td * Math.cos(fi);
         const dsinT = td * Math.sin(fi);
         const p1T = new DPoint_1.DPoint(p.x - dsinT, p.y - dcosT);
@@ -310,8 +297,9 @@ class DLine {
      * @param l
      * @param delta
      */
-    findFi(l, delta = 1.0001) {
-        let val = (this.a * l.a + this.b * l.b) / (Math.sqrt(this.a * this.a + this.b * this.b) * Math.sqrt(l.a * l.a + l.b * l.b));
+    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;
         }
@@ -322,13 +310,11 @@ class DLine {
     }
     /**
      * [Cross product](https://en.wikipedia.org/wiki/Cross_product)
-     * @param l
+     * @param l {DLine}
      */
-    vectorProduct(l) {
-        const i = this.b * l.c - this.c * l.b;
-        const j = this.c * l.a - this.a * l.c;
-        const k = this.a * l.b - this.b * l.a;
-        return new DLine(i, j, k);
+    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);
     }
 }
 exports.DLine = DLine;

package/dist/DPoint.d.ts

@@ -24,15 +24,18 @@ export declare class DPoint {
      */
     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
@@ -80,6 +83,16 @@ export declare class DPoint {
      * @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

package/dist/DPoint.js

@@ -152,6 +152,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;

package/dist/DPolygon.d.ts

@@ -11,6 +11,39 @@ 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`
@@ -138,13 +171,19 @@ export declare class DPolygon {
      * @param newCenter
      */
     setCenter(newCenter: DPoint): DPolygon;
-    toWKT(): string;
+    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
      */
     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;
@@ -260,6 +299,17 @@ export declare class DPolygon {
      * ![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;

package/dist/DPolygon.js

@@ -8,6 +8,7 @@ const DCircle_1 = require("./DCircle");
 const DNumbers_1 = require("./DNumbers");
 const jsts_1 = require("jsts");
 const DPolygonLoop_1 = require("./DPolygonLoop");
+const { buffer: { BufferParameters: { CAP_ROUND, CAP_FLAT, CAP_SQUARE } } } = jsts_1.operation;
 exports.MIN_POINTS_IN_VALID_POLYGON = 3;
 const APPROXIMATION_VALUE = 0.1;
 const MAX_CONVEX_ITERATIONS = 100;
@@ -21,6 +22,34 @@ class DPolygon {
         this.holes = [];
         this.searchStore = {};
     }
+    /**
+     * 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, height = 0) {
+        return triangles.map((v) => v
+            .loop()
+            .height(height)
+            .run()
+            .toArrayOfCoords())
+            .flat(2);
+    }
     /**
      * Get size of min area rectangle.
      * @param poly should be `minAreaRectangle`
@@ -410,12 +439,21 @@ class DPolygon {
             .move(newCenter.clone().move(this.center.minus()))
             .run();
     }
-    toWKT() {
-        let h = '';
-        if (this.holes && this.holes.length) {
-            h = `, ${this.holes.map((hole) => hole.toString()).join(', ')}`;
+    /**
+     * @param [type = DPolygon.WKT_POLYGON] Available values `DPolygon.WKT_POLYGON`, `DPolygon.WKT_LINESTRING`
+     */
+    toWKT(type = DPolygon.WKT_POLYGON) {
+        if (type === DPolygon.WKT_POLYGON) {
+            let h = '';
+            if (this.holes && this.holes.length) {
+                h = `, ${this.holes.map((hole) => hole.toString())
+                    .join(', ')}`;
+            }
+            return `POLYGON ((${this.deintersection.pPoints.map((r) => `${r.x} ${r.y}`)
+                .join(', ')})${h})`;
         }
-        return `POLYGON ((${this.deintersection.pPoints.map((r) => `${r.x} ${r.y}`).join(', ')})${h})`;
+        return `LINESTRING (${this.pPoints.map((r) => `${r.x} ${r.y}`)
+            .join(', ')})`;
     }
     /**
      * Filter points
@@ -463,7 +501,7 @@ class DPolygon {
      */
     close() {
         const p0 = this.first;
-        if (p0 && !p0.equal(this.last)) {
+        if (p0 && !this.closed) {
             this.push(p0.clone());
         }
         return this;
@@ -473,7 +511,7 @@ class DPolygon {
      */
     open() {
         const p = this.first;
-        if (this.length > 2 && p && p.equal(this.last)) {
+        if (this.length > 2 && p && this.closed) {
             this.pop();
         }
         return this;
@@ -789,10 +827,9 @@ class DPolygon {
         return this.simpleLogicFunction(p, true, false);
     }
     smartUnion(p) {
-        var _a;
         const res = this.clone().simpleUnion(p);
         if (res) {
-            let allHoles = [...this.holes, ...p.holes, ...((_a = res.holes) !== null && _a !== void 0 ? _a : [])].map((h) => h.clone());
+            let allHoles = [...this.holes, ...p.holes, ...res.holes].map((h) => h.clone());
             for (const a of allHoles) {
                 for (const b of allHoles) {
                     if (a.equal(b)) {
@@ -801,12 +838,7 @@ class DPolygon {
                     const r = a.simpleUnion(b);
                     if (r) {
                         allHoles = allHoles.filter((v) => !v.equal(a) && !v.equal(b));
-                        if (Array.isArray(r)) {
-                            allHoles = [...allHoles, ...r];
-                        }
-                        else {
-                            allHoles.push(r);
-                        }
+                        allHoles.push(r);
                     }
                 }
             }
@@ -872,6 +904,89 @@ class DPolygon {
         res.push(p);
         return res;
     }
+    /**
+     * Divide polygon to triangles and return points indexes
+     */
+    getTrianglesPointIndexes() {
+        const innerAndNotIntersect = (poly, p1, p2) => {
+            const l = p1.findLine(p2);
+            const { center } = l;
+            const intersections = poly.holes.reduce((a, hole) => a && Boolean(hole.clone().close()
+                .intersection(l, true).length), Boolean(poly.clone().close()
+                .intersection(l, true).length));
+            const contain = poly.holes.reduce((a, hole) => a && !hole
+                .contain(center), poly.contain(center));
+            return !intersections && contain;
+        };
+        const getTriangle = (poly) => {
+            for (let i = 0; i < poly.length; i++) {
+                const p0 = poly.at(0);
+                const p1 = poly.at(1);
+                const p2 = poly.at(2);
+                if (innerAndNotIntersect(poly, p0, p2)) {
+                    poly.removePart(0, 1);
+                    return [
+                        p0.properties.index,
+                        p1.properties.index,
+                        p2.properties.index
+                    ];
+                }
+                poly.push(poly.shift());
+            }
+            return undefined;
+        };
+        let p = this.clone();
+        let index = 0;
+        p.points.forEach((f) => {
+            f.properties.index = index++;
+        });
+        p.holes.forEach((h) => {
+            h.pPoints.forEach((f) => {
+                f.properties.index = index++;
+            });
+        });
+        p = p.clockWise.open();
+        while (p.holes.length) {
+            const h = p.holes.shift()
+                .clone()
+                .clockWise
+                .reverse()
+                .close();
+            for (let i = 0; i < p.length; i++) {
+                if (innerAndNotIntersect(p, p.first, h.first)) {
+                    p.insertAfter(0, ...h.points, p.first);
+                    break;
+                }
+                p.push(p.shift());
+            }
+        }
+        const res = [];
+        while (p.length > 3) {
+            const triangle = getTriangle(p);
+            if (triangle) {
+                res.push(...triangle);
+            }
+        }
+        res.push(...p.points.map((f) => f.properties.index));
+        return res;
+    }
+    get closed() {
+        return this.first.equal(this.last);
+    }
+    /**
+     * @param v
+     * @param [quadrantSegments=64]
+     * @param [type=DPolygon.CAP_ROUND] DPolygon.CAP_ROUND || DPolygon.CAP_FLAT || DPolygon.CAP_SQUARE
+     */
+    buffer(v, quadrantSegments = 64, type = DPolygon.CAP_ROUND) {
+        const reader = new jsts_1.io.WKTReader();
+        const { noHoles, closed } = this;
+        const points = reader
+            .read(noHoles.toWKT(closed ? DPolygon.WKT_POLYGON : DPolygon.WKT_LINESTRING))
+            .buffer(v, quadrantSegments, type)
+            .getCoordinates();
+        return new DPolygon(points.map(({ x, y }) => new DPoint_1.DPoint(x, y)));
+    }
     simpleIncludeX(p) {
         const { x } = p;
         return this.minX <= x && this.maxX >= x;
@@ -1033,3 +1148,17 @@ class DPolygon {
     }
 }
 exports.DPolygon = DPolygon;
+/**
+ * Specifies a round line buffer end cap style.
+ */
+DPolygon.CAP_ROUND = CAP_ROUND;
+/**
+ * Specifies a flat line buffer end cap style.
+ */
+DPolygon.CAP_FLAT = CAP_FLAT;
+/**
+ * Specifies a square line buffer end cap style.
+ */
+DPolygon.CAP_SQUARE = CAP_SQUARE;
+DPolygon.WKT_LINESTRING = 'LINESTRING';
+DPolygon.WKT_POLYGON = 'POLYGON';

package/dist/DPolygonLoop.d.ts

@@ -39,6 +39,16 @@ export declare class DPolygonLoop {
      * @param f
      */
     setY(f: SetterFunction): DPolygonLoop;
+    /**
+     * Set `z` value
+     * @param z
+     */
+    setZ(z: number): DPolygonLoop;
+    /**
+     * Transform `z` value by function
+     * @param f
+     */
+    setZ(f: SetterFunction): DPolygonLoop;
     rotate(a: number): DPolygonLoop;
     /**
      * Add `v` to `x` and `y`

package/dist/DPolygonLoop.js

@@ -8,33 +8,35 @@ var LoopFunctions;
     LoopFunctions[LoopFunctions["height"] = 2] = "height";
     LoopFunctions[LoopFunctions["setX"] = 3] = "setX";
     LoopFunctions[LoopFunctions["setY"] = 4] = "setY";
-    LoopFunctions[LoopFunctions["rotate"] = 5] = "rotate";
-    LoopFunctions[LoopFunctions["move"] = 6] = "move";
-    LoopFunctions[LoopFunctions["round"] = 7] = "round";
-    LoopFunctions[LoopFunctions["ceil"] = 8] = "ceil";
-    LoopFunctions[LoopFunctions["floor"] = 9] = "floor";
-    LoopFunctions[LoopFunctions["toFixed"] = 10] = "toFixed";
-    LoopFunctions[LoopFunctions["abs"] = 11] = "abs";
-    LoopFunctions[LoopFunctions["scale"] = 12] = "scale";
-    LoopFunctions[LoopFunctions["divide"] = 13] = "divide";
-    LoopFunctions[LoopFunctions["degreeToRadians"] = 14] = "degreeToRadians";
-    LoopFunctions[LoopFunctions["radiansToDegrees"] = 15] = "radiansToDegrees";
-    LoopFunctions[LoopFunctions["radiansToMeters"] = 16] = "radiansToMeters";
-    LoopFunctions[LoopFunctions["metersToRadians"] = 17] = "metersToRadians";
-    LoopFunctions[LoopFunctions["hipPoint"] = 18] = "hipPoint";
-    LoopFunctions[LoopFunctions["xPoint"] = 19] = "xPoint";
-    LoopFunctions[LoopFunctions["yPoint"] = 20] = "yPoint";
-    LoopFunctions[LoopFunctions["wPoint"] = 21] = "wPoint";
-    LoopFunctions[LoopFunctions["hPoint"] = 22] = "hPoint";
-    LoopFunctions[LoopFunctions["setIfLessThan"] = 23] = "setIfLessThan";
-    LoopFunctions[LoopFunctions["minus"] = 24] = "minus";
-    LoopFunctions[LoopFunctions["degreeToMeters"] = 25] = "degreeToMeters";
-    LoopFunctions[LoopFunctions["metersToDegree"] = 26] = "metersToDegree";
-    LoopFunctions[LoopFunctions["flipVertically"] = 27] = "flipVertically";
+    LoopFunctions[LoopFunctions["setZ"] = 5] = "setZ";
+    LoopFunctions[LoopFunctions["rotate"] = 6] = "rotate";
+    LoopFunctions[LoopFunctions["move"] = 7] = "move";
+    LoopFunctions[LoopFunctions["round"] = 8] = "round";
+    LoopFunctions[LoopFunctions["ceil"] = 9] = "ceil";
+    LoopFunctions[LoopFunctions["floor"] = 10] = "floor";
+    LoopFunctions[LoopFunctions["toFixed"] = 11] = "toFixed";
+    LoopFunctions[LoopFunctions["abs"] = 12] = "abs";
+    LoopFunctions[LoopFunctions["scale"] = 13] = "scale";
+    LoopFunctions[LoopFunctions["divide"] = 14] = "divide";
+    LoopFunctions[LoopFunctions["degreeToRadians"] = 15] = "degreeToRadians";
+    LoopFunctions[LoopFunctions["radiansToDegrees"] = 16] = "radiansToDegrees";
+    LoopFunctions[LoopFunctions["radiansToMeters"] = 17] = "radiansToMeters";
+    LoopFunctions[LoopFunctions["metersToRadians"] = 18] = "metersToRadians";
+    LoopFunctions[LoopFunctions["hipPoint"] = 19] = "hipPoint";
+    LoopFunctions[LoopFunctions["xPoint"] = 20] = "xPoint";
+    LoopFunctions[LoopFunctions["yPoint"] = 21] = "yPoint";
+    LoopFunctions[LoopFunctions["wPoint"] = 22] = "wPoint";
+    LoopFunctions[LoopFunctions["hPoint"] = 23] = "hPoint";
+    LoopFunctions[LoopFunctions["setIfLessThan"] = 24] = "setIfLessThan";
+    LoopFunctions[LoopFunctions["minus"] = 25] = "minus";
+    LoopFunctions[LoopFunctions["degreeToMeters"] = 26] = "degreeToMeters";
+    LoopFunctions[LoopFunctions["metersToDegree"] = 27] = "metersToDegree";
+    LoopFunctions[LoopFunctions["flipVertically"] = 28] = "flipVertically";
 })(LoopFunctions || (LoopFunctions = {}));
 // eslint-disable-next-line complexity
 const decodePoolRecord = (a, { functionName, pointArg, numberPointArg, numberArg, setterArg }) => {
     let res = a;
+    // eslint-disable-next-line default-case
     switch (functionName) {
         case LoopFunctions.getTileFromCoords:
             res = (k) => a(k)
@@ -56,6 +58,10 @@ const decodePoolRecord = (a, { functionName, pointArg, numberPointArg, numberArg
             res = (k) => a(k)
                 .setY(setterArg);
             break;
+        case LoopFunctions.setZ:
+            res = (k) => a(k)
+                .setZ(setterArg);
+            break;
         case LoopFunctions.rotate:
             res = (k) => a(k)
                 .rotate(numberArg);
@@ -148,11 +154,11 @@ const decodePoolRecord = (a, { functionName, pointArg, numberPointArg, numberArg
             res = (k) => a(k)
                 .flipVertically(numberPointArg);
             break;
-        default:
     }
     return res;
 };
 class DPolygonLoop {
+    // eslint-disable-next-line no-empty-function,no-useless-constructor
     constructor(parent) {
         this.parent = parent;
         this.pool = [];
@@ -207,6 +213,13 @@ class DPolygonLoop {
         });
         return this;
     }
+    setZ(z) {
+        this.pool.push({
+            functionName: LoopFunctions.setZ,
+            setterArg: z
+        });
+        return this;
+    }
     rotate(a) {
         this.pool.push({
             functionName: LoopFunctions.rotate,

package/dist/TraceMatrix.d.ts

@@ -6,8 +6,8 @@ export declare enum TraceMatrixValues {
 }
 declare type SimpleMatrix = TraceMatrixValues[][];
 export declare class TraceMatrix {
-    private readonly m;
     private readonly size;
+    private readonly m;
     constructor(size: DPoint, f: (p: DPoint) => TraceMatrixValues);
     fullMatrixTrace(): DPolygon[];
     private reverseMatrix;

package/dist/TraceMatrix.js

@@ -25,6 +25,7 @@ const setByPosition = (m, p, value) => {
 };
 class TraceMatrix {
     constructor(size, f) {
+        this.size = size;
         this.findGroupByIndex = (m, s) => {
             const res = new DPolygon_1.DPolygon();
             if (s && getByPosition(m, s) === TraceMatrixValues.t) {
@@ -146,7 +147,6 @@ class TraceMatrix {
             const t = this.reverseMatrix(tmpMatrix);
             return this.totalCountInMatrix(t) ? t : null;
         };
-        this.size = size;
         this.m = TraceMatrix.createMatrix(this.size, f);
     }
     fullMatrixTrace() {

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export * from './DPoint';
 export * from './DPolygon';
 export * from './FastSearch';
 export * from './TraceMatrix';
+export * from './DPolygonLoop';
 export declare const DGeo: {
     DEBUG: boolean;
 };

package/dist/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./DPoint"), exports);
 __exportStar(require("./DPolygon"), exports);
 __exportStar(require("./FastSearch"), exports);
 __exportStar(require("./TraceMatrix"), exports);
+__exportStar(require("./DPolygonLoop"), exports);
 exports.DGeo = {
     DEBUG: false
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dgeoutils",
-  "version": "2.2.3",
+  "version": "2.2.7",
   "description": "",
   "scripts": {
     "build": "node_modules/.bin/tsc",
@@ -56,4 +56,4 @@
     "type": "git",
     "url": "https://github.com/edejin/DGeoUtils"
   }
-}
+}