dgeoutils 2.2.1 → 2.2.5

package/dist/DPolygon.js

@@ -8,18 +8,47 @@ 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;
 const CLOSE_TO_INTERSECTION_DISTANCE = 0.001;
 class DPolygon {
-    constructor(points = []) {
+    // eslint-disable-next-line no-useless-constructor,no-empty-function
+    constructor(pPoints = []) {
+        this.pPoints = pPoints;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         this.properties = {};
         this.holes = [];
-        this.pPoints = [];
         this.searchStore = {};
-        this.pPoints = points;
+    }
+    /**
+     * 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.
@@ -93,7 +122,7 @@ class DPolygon {
         return res;
     }
     static createSquareBySize(size) {
-        return new DPolygon([DPoint_1.DPoint.Zero(), size.clone().setX(0), size.clone(), size.clone().setY(0)]).close();
+        return new DPolygon([DPoint_1.DPoint.zero(), size.clone().setX(0), size.clone(), size.clone().setY(0)]).close();
     }
     loop() {
         return new DPolygonLoop_1.DPolygonLoop(this);
@@ -209,8 +238,8 @@ class DPolygon {
         const closed = this.deintersection;
         let sum = 0;
         for (let i = 1; i < closed.length; i++) {
-            const cur = closed.p(i);
-            const prev = closed.p(i - 1);
+            const cur = closed.at(i);
+            const prev = closed.at(i - 1);
             sum += prev.x * cur.y - prev.y * cur.x;
         }
         return Math.abs(sum / 2) - this.holes.reduce((a, hole) => a + hole.area, 0);
@@ -222,8 +251,8 @@ class DPolygon {
         const p = this.clone().close();
         for (let i = 0; i < p.length - 1; i++) {
             for (let j = i + 2; j < p.length - 1; j++) {
-                const firstLine = p.p(i).findLine(p.p(i + 1));
-                const secondLine = p.p(j).findLine(p.p(j + 1));
+                const firstLine = p.at(i).findLine(p.at(i + 1));
+                const secondLine = p.at(j).findLine(p.at(j + 1));
                 const intersectionPoint = firstLine.intersection(secondLine);
                 if (intersectionPoint &&
                     ![...firstLine.points, ...secondLine.points].some((t) => t.like(intersectionPoint))) {
@@ -246,19 +275,19 @@ class DPolygon {
      * Get first point
      */
     get first() {
-        return this.p(0);
+        return this.at(0);
     }
     /**
      * Get second point
      */
     get second() {
-        return this.p(1);
+        return this.at(1);
     }
     /**
      * Get last point
      */
     get last() {
-        return this.p(this.length - 1);
+        return this.at(this.length - 1);
     }
     /**
      * Get min area rectangle
@@ -268,21 +297,21 @@ class DPolygon {
         let resultPolygon = new DPolygon();
         let resultArea = Infinity;
         for (let k = 0; k < p.length - 1; k++) {
-            const l = p.p(k).findLine(p.p(k + 1));
+            const l = p.at(k).findLine(p.at(k + 1));
             let maxWidth = 0;
             let maxWidthPoint1 = null;
             let maxWidthPoint2 = null;
             let maxHeight = 0;
             let maxHeightPoint = null;
             for (let i = 0; i < p.length - 1; i++) {
-                const p1 = l.findPoint(l.findPerpendicular(p.p(i)));
-                const h = p1.distance(p.p(i));
+                const p1 = l.findPoint(l.findPerpendicular(p.at(i)));
+                const h = p1.distance(p.at(i));
                 if (h >= maxHeight) {
                     maxHeight = h;
-                    maxHeightPoint = p.p(i);
+                    maxHeightPoint = p.at(i);
                 }
                 for (let j = i; j < p.length - 1; j++) {
-                    const p2 = l.findPoint(l.findPerpendicular(p.p(j)));
+                    const p2 = l.findPoint(l.findPerpendicular(p.at(j)));
                     const w = p1.distance(p2);
                     if (w >= maxWidth) {
                         maxWidth = w;
@@ -338,9 +367,9 @@ class DPolygon {
             p = p.deintersection;
             l = p.length;
             for (let i = 1; i < p.length - 1; i++) {
-                const p1 = p.p(i - 1);
-                const p2 = p.p(i);
-                const p3 = p.p(i + 1);
+                const p1 = p.at(i - 1);
+                const p2 = p.at(i);
+                const p3 = p.at(i + 1);
                 const d = p2.findInnerAngle(p1, p3);
                 if (d > Math.PI || DNumbers_1.DNumbers.likeZero(DNumbers_1.DNumbers.rad2Deg(d)) || DNumbers_1.DNumbers.likePI(d) || DNumbers_1.DNumbers.like2PI(d)) {
                     p.removePart(--i, 1);
@@ -360,8 +389,8 @@ class DPolygon {
         let sum = 0;
         const p = this.clone().close();
         for (let i = 1; i < p.length; i++) {
-            const p1 = p.p(i - 1);
-            const p2 = p.p(i);
+            const p1 = p.at(i - 1);
+            const p2 = p.at(i);
             sum += (p2.x - p1.x) * (p2.y + p1.y);
         }
         return sum < 0;
@@ -406,23 +435,25 @@ class DPolygon {
      * @param newCenter
      */
     setCenter(newCenter) {
-        return this.clone().move(newCenter.clone().move(this.center.minus()));
-    }
-    toWKT() {
-        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 this.loop()
+            .move(newCenter.clone().move(this.center.minus()))
+            .run();
     }
     /**
-     * Rotate polygon with center in point {0, 0}
-     * @param a Radians
+     * @param [type = DPolygon.WKT_POLYGON] Available values `DPolygon.WKT_POLYGON`, `DPolygon.WKT_LINESTRING`
      */
-    rotate(a) {
-        this.pPoints = this.pPoints.map((p) => p.rotate(a));
-        this.holes = this.holes.map((h) => h.rotate(a));
-        return this;
+    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 `LINESTRING (${this.pPoints.map((r) => `${r.x} ${r.y}`)
+            .join(', ')})`;
     }
     /**
      * Filter points
@@ -432,60 +463,14 @@ class DPolygon {
         this.pPoints = this.pPoints.filter(f);
         return this;
     }
-    move(x = 0, y) {
-        this.pPoints = this.pPoints.map((p) => p.move(x, y));
-        this.holes = this.holes.map((h) => h.move(x, y));
-        return this;
-    }
-    scale(x = 0, y) {
-        this.pPoints = this.pPoints.map((p) => p.scale(x, y));
-        this.holes = this.holes.map((h) => h.scale(x, y));
-        return this;
-    }
-    divide(x = 0, y) {
-        this.pPoints = this.pPoints.map((p) => p.divide(x, y));
-        this.holes = this.holes.map((h) => h.divide(x, y));
-        return this;
-    }
-    round() {
-        this.pPoints = this.pPoints.map((p) => p.round());
-        this.holes = this.holes.map((h) => h.round());
-        return this;
-    }
-    floor() {
-        this.pPoints = this.pPoints.map((p) => p.floor());
-        this.holes = this.holes.map((h) => h.floor());
-        return this;
-    }
-    ceil() {
-        this.pPoints = this.pPoints.map((p) => p.ceil());
-        this.holes = this.holes.map((h) => h.ceil());
-        return this;
-    }
-    flipVertically(size) {
-        this.pPoints = this.pPoints.map((p) => p.flipVertically(size));
-        this.holes = this.holes.map((h) => h.flipVertically(size));
-        return this;
-    }
-    toFixed(n = 2) {
-        this.pPoints = this.pPoints.map((p) => p.toFixed(n));
-        this.holes = this.holes.map((h) => h.toFixed(n));
-        return this;
-    }
     map(f) {
         this.pPoints = this.pPoints.map(f);
         this.holes = this.holes.map((h) => h.map(f));
         return this;
     }
-    p(index, divide = false) {
-        if (divide) {
-            let t = index;
-            while (t < 0) {
-                t += this.length;
-            }
-            return this.pPoints[t % this.length];
-        }
-        return this.pPoints[index];
+    at(index) {
+        const { length } = this;
+        return this.points[(index % length + length) % length];
     }
     pop() {
         return this.pPoints.pop();
@@ -508,26 +493,6 @@ class DPolygon {
         return (this.pPoints.map((r) => r.getValue()) + this.holes
             .reduce((a, h) => a + h.getValue(), ''));
     }
-    degreeToMeters() {
-        this.pPoints = this.pPoints.map((r) => r.degreeToMeters());
-        this.holes = this.holes.map((h) => h.degreeToMeters());
-        return this;
-    }
-    metersToDegree() {
-        this.pPoints = this.pPoints.map((r) => r.metersToDegree());
-        this.holes = this.holes.map((h) => h.metersToDegree());
-        return this;
-    }
-    radiansToMeters() {
-        this.pPoints = this.pPoints.map((r) => r.radiansToMeters());
-        this.holes = this.holes.map((h) => h.radiansToMeters());
-        return this;
-    }
-    metersToRadians() {
-        this.pPoints = this.pPoints.map((r) => r.metersToRadians());
-        this.holes = this.holes.map((h) => h.metersToRadians());
-        return this;
-    }
     toString() {
         return `(${this.pPoints.map((r) => r.toString()).join(', ')})`;
     }
@@ -536,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;
@@ -546,20 +511,11 @@ 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;
     }
-    /**
-     * Set `height` (`z`)
-     * @param z
-     */
-    height(z) {
-        this.map((p) => p.height(z));
-        this.holes = this.holes.map((h) => h.height(z));
-        return this;
-    }
     add(poly) {
         const res = new DPolygon([...this.points, ...poly.points]).close();
         res.holes = [...this.holes, ...poly.holes].map((h) => h.clone());
@@ -586,7 +542,7 @@ class DPolygon {
         if (!(p instanceof DPolygon)) {
             return false;
         }
-        if (this.clone().open().length !== p.clone().open().length || this.holes.length !== p.holes.length) {
+        if (this.length !== p.length || this.holes.length !== p.holes.length) {
             return false;
         }
         return (this.same(p) &&
@@ -597,20 +553,18 @@ class DPolygon {
      * @param p
      */
     same(p) {
-        const pClone = p.clone().open();
-        const thisClone = this.clone().open();
-        const thisAsString = thisClone.toString();
-        return thisClone.points.reduce((a) => {
-            const f = pClone.shift();
-            pClone.push(f);
-            return (a ||
-                thisAsString === pClone.toString() ||
-                thisAsString ===
-                    pClone
-                        .clone()
-                        .reverse()
-                        .toString());
-        }, false);
+        const pClone = p.clone().close();
+        const thisAsString = this.clone()
+            .close()
+            .toString();
+        for (let i = 0; i < pClone.length; i++) {
+            if (thisAsString === pClone.toString() || thisAsString === pClone.clone().reverse()
+                .toString()) {
+                return true;
+            }
+            pClone.nextStart();
+        }
+        return false;
     }
     findIndex(p) {
         return this.points.findIndex((t) => t.equal(p));
@@ -618,7 +572,7 @@ class DPolygon {
     /**
      * Get polygon approximation by
      * [Ramer–Douglas–Peucker algorithm](https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm)
-     * @param e
+     * @param [e=Math.sqrt(this.perimeter)*APPROXIMATION_VALUE]
      */
     approximation(e = Math.sqrt(this.perimeter) * APPROXIMATION_VALUE) {
         return new DPolygon(this.clone().douglasPeucker(this.pPoints, e));
@@ -692,10 +646,10 @@ class DPolygon {
     /**
      * Check if contain point
      * @param p
-     * @param isBorderInside
-     * @param move Ignore this parameter
+     * @param [isBorderInside=false]
+     * @param [move=(0,0)] Ignore this parameter
      */
-    contain(p, isBorderInside = false, move = DPoint_1.DPoint.Zero()) {
+    contain(p, isBorderInside = false, move = DPoint_1.DPoint.zero()) {
         const simpleInclude = this.simpleInclude(p);
         if (!simpleInclude) {
             return false;
@@ -708,7 +662,7 @@ class DPolygon {
         const poly = this.deintersection;
         const intersectionPoints = [];
         for (let i = 0; i < poly.length - 1; i++) {
-            const polygonLine = poly.p(i).findLine(poly.p(i + 1));
+            const polygonLine = poly.at(i).findLine(poly.at(i + 1));
             const intersection = line.intersection(polygonLine, CLOSE_TO_INTERSECTION_DISTANCE);
             if (intersection) {
                 intersectionPoints.push(intersection);
@@ -733,8 +687,8 @@ class DPolygon {
                 return true;
             }
             for (let i = 0; i < poly.length - 1; i++) {
-                const p0 = poly.p(i);
-                const p1 = poly.p(i + 1);
+                const p0 = poly.at(i);
+                const p1 = poly.at(i + 1);
                 const polygonLine = p0.findLine(p1);
                 const onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
                 if (onBorder) {
@@ -758,8 +712,8 @@ class DPolygon {
      */
     removeDuplicates() {
         for (let i = 0; i < this.length - 1; i++) {
-            const p1 = this.p(i);
-            const p2 = this.p(i + 1);
+            const p1 = this.at(i);
+            const p2 = this.at(i + 1);
             if (p1.equal(p2)) {
                 this.removePart(i, 1);
                 i--;
@@ -767,11 +721,6 @@ class DPolygon {
         }
         return this;
     }
-    /**
-     * Parse from [OpenLayers](https://openlayers.org/) coordinates or
-     * [GeoJSON](https://en.wikipedia.org/wiki/GeoJSON) coordinates
-     * @param a
-     */
     static parse(a) {
         return new DPolygon(a.map((r) => DPoint_1.DPoint.parse(r)));
     }
@@ -878,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)) {
@@ -890,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);
                     }
                 }
             }
@@ -906,9 +849,36 @@ class DPolygon {
     /**
      * Divide polygon to triangles
      *
-     * ![Example](/media/examples/toTriangles.png)
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/toTriangles.png)
      */
     toTriangles() {
+        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 new DPolygon([
+                        p0.clone(),
+                        p1.clone(),
+                        p2.clone()
+                    ]);
+                }
+                poly.push(poly.shift());
+            }
+            return undefined;
+        };
         const p = this.clone().clockWise.open();
         while (p.holes.length) {
             const h = p.holes.shift()
@@ -917,7 +887,7 @@ class DPolygon {
                 .reverse()
                 .close();
             for (let i = 0; i < p.length; i++) {
-                if (p.innerAndNotIntersect(p.first, h.first)) {
+                if (innerAndNotIntersect(p, p.first, h.first)) {
                     p.insertAfter(0, ...h.points, p.first);
                     break;
                 }
@@ -926,7 +896,7 @@ class DPolygon {
         }
         const res = [];
         while (p.length > 3) {
-            const triangle = p.getTriangle();
+            const triangle = getTriangle(p);
             if (triangle) {
                 res.push(triangle);
             }
@@ -934,35 +904,22 @@ class DPolygon {
         res.push(p);
         return res;
     }
+    get closed() {
+        return this.first.equal(this.last);
+    }
     /**
-     * @internal
+     * @param v
+     * @param [quadrantSegments=64]
+     * @param [type=DPolygon.CAP_ROUND] DPolygon.CAP_ROUND || DPolygon.CAP_FLAT || DPolygon.CAP_SQUARE
      */
-    getTriangle() {
-        for (let i = 0; i < this.length; i++) {
-            const p0 = this.p(0);
-            const p1 = this.p(1);
-            const p2 = this.p(2);
-            if (this.innerAndNotIntersect(p0, p2)) {
-                this.removePart(0, 1);
-                return new DPolygon([
-                    p0.clone(),
-                    p1.clone(),
-                    p2.clone()
-                ]);
-            }
-            this.push(this.shift());
-        }
-        return undefined;
-    }
-    innerAndNotIntersect(p1, p2) {
-        const l = p1.findLine(p2);
-        const { center } = l;
-        const intersections = this.holes.reduce((a, hole) => a && Boolean(hole.clone().close()
-            .intersection(l, true).length), Boolean(this.clone().close()
-            .intersection(l, true).length));
-        const contain = this.holes.reduce((a, hole) => a && !hole
-            .contain(center), this.contain(center));
-        return !intersections && contain;
+    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;
@@ -996,7 +953,7 @@ class DPolygon {
         const start = this.first;
         ctx.moveTo(start.x, start.y);
         for (let i = 1; i <= (steps % this.length); i++) {
-            const { x, y } = this.p(i);
+            const { x, y } = this.at(i);
             ctx.lineTo(x, y);
         }
     }
@@ -1012,8 +969,8 @@ class DPolygon {
         const poly = this.deintersection;
         let totalFi = 0;
         for (let i = 0; i < poly.length - 1; i++) {
-            const p1 = poly.p(i);
-            const p2 = poly.p(i + 1);
+            const p1 = poly.at(i);
+            const p2 = poly.at(i + 1);
             const line1 = new DLine_1.DLine(p1.x - p.x, p1.y - p.y, 0);
             const line2 = new DLine_1.DLine(p2.x - p.x, p2.y - p.y, 0);
             const fiDif = line1.findFi(line2);
@@ -1125,3 +1082,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

@@ -10,20 +10,89 @@ export declare class DPolygonLoop {
      * Run loop
      */
     run(): DPolygon;
+    /**
+     * @param zoom default value would be `z` of point
+     */
     getTileFromCoords(zoom?: number): DPolygonLoop;
+    /**
+     * @param zoom default value would be `z` of point
+     */
     getCoordsFromTile(zoom?: number): DPolygonLoop;
     height(z: number): DPolygonLoop;
-    setX(x: number | SetterFunction): DPolygonLoop;
-    setY(y: number | SetterFunction): DPolygonLoop;
+    /**
+     * Set `x` value
+     * @param x
+     */
+    setX(x: number): DPolygonLoop;
+    /**
+     * Transform `x` value by function
+     * @param f
+     */
+    setX(f: SetterFunction): DPolygonLoop;
+    /**
+     * Set `y` value
+     * @param y
+     */
+    setY(y: number): DPolygonLoop;
+    /**
+     * Transform `y` value by function
+     * @param f
+     */
+    setY(f: SetterFunction): DPolygonLoop;
     rotate(a: number): DPolygonLoop;
-    move(x?: number | DPoint, y?: number): DPolygonLoop;
+    /**
+     * Add `v` to `x` and `y`
+     * @param v
+     */
+    move(v: number): DPolygonLoop;
+    /**
+     * Add `p.x` to `x` field and `p.y` to `y` field.
+     * @param p
+     */
+    move(p: DPoint): DPolygonLoop;
+    /**
+     * Add `x` to `x` field and `y` to `y` field.
+     * @param x
+     * @param y
+     */
+    move(x: number, y: number): DPolygonLoop;
     round(): DPolygonLoop;
     ceil(): DPolygonLoop;
     floor(): DPolygonLoop;
     toFixed(n?: number): DPolygonLoop;
     abs(): DPolygonLoop;
-    scale(x?: number | DPoint, y?: number): DPolygonLoop;
-    divide(x?: number | DPoint, y?: number): DPolygonLoop;
+    /**
+     * Multiply `v` to `x` and `y`
+     * @param v
+     */
+    scale(v: number): DPolygonLoop;
+    /**
+     * Multiply `p.x` to `x` field and `p.y` to `y` field.
+     * @param p
+     */
+    scale(p: DPoint): DPolygonLoop;
+    /**
+     * Multiply `x` to `x` field and `y` to `y` field.
+     * @param x
+     * @param y
+     */
+    scale(x: number, y: number): DPolygonLoop;
+    /**
+     * Divide `x` and `y` to `v`
+     * @param v
+     */
+    divide(v: number): DPolygonLoop;
+    /**
+     * Divide `x` field to `p.x` and `y` field to `p.y`.
+     * @param p
+     */
+    divide(p: DPoint): DPolygonLoop;
+    /**
+     * Divide `x` field to `x` and `y` field to `y`.
+     * @param x
+     * @param y
+     */
+    divide(x: number, y: number): DPolygonLoop;
     degreeToRadians(): DPolygonLoop;
     radiansToDegrees(): DPolygonLoop;
     radiansToMeters(): DPolygonLoop;
@@ -37,5 +106,14 @@ export declare class DPolygonLoop {
     minus(): DPolygonLoop;
     degreeToMeters(): DPolygonLoop;
     metersToDegree(): DPolygonLoop;
-    flipVertically(size: DPoint | number): DPolygonLoop;
+    /**
+     * Flip vertically
+     * @param size canvas size
+     */
+    flipVertically(size: DPoint): DPolygonLoop;
+    /**
+     * Flip vertically
+     * @param height canvas height
+     */
+    flipVertically(height: number): DPolygonLoop;
 }