poly-extrude 0.21.0 → 0.22.0

package/src/polyline.ts

@@ -1,5 +1,5 @@
 import { PolylineType, ResultType } from './type';
-import { calLineDistance, degToRad, generateNormal, generateSideWallUV, merge, radToDeg } from './util';
+import { calLineDistance, degToRad, generateNormal, generateSideWallUV, merge, radToDeg, pointEqual, pointDistance } from './util';
 
 function checkOptions(options) {
     options.lineWidth = Math.max(0, options.lineWidth);
@@ -351,7 +351,7 @@ export function expandLine(line: Array<Array<number>>, options?: ExpandLineOptio
         let p1 = line[i],
             p2 = line[i + 1];
         const current = p1;
-        if (pre && equal(pre, current)) {
+        if (pre && pointEqual(pre, current)) {
             repeatVertex();
             i++;
             continue;
@@ -361,30 +361,30 @@ export function expandLine(line: Array<Array<number>>, options?: ExpandLineOptio
         if (i === len - 1) {
             p1 = line[len - 2];
             p2 = line[len - 1];
-            if (equal(p1, p2)) {
+            if (pointEqual(p1, p2)) {
                 for (let j = line.indexOf(p1); j >= 0; j--) {
                     const p = line[j];
-                    if (!equal(p, current)) {
+                    if (!pointEqual(p, current)) {
                         p1 = p;
                         break;
                     }
                 }
             }
         } else {
-            if (equal(p1, p2)) {
+            if (pointEqual(p1, p2)) {
                 for (let j = line.indexOf(p2); j < len; j++) {
                     const p = line[j];
-                    if (!equal(p, current)) {
+                    if (!pointEqual(p, current)) {
                         p2 = p;
                         break;
                     }
                 }
             }
-            if (equal(p1, p2)) {
+            if (pointEqual(p1, p2)) {
                 lastRepeat = true;
                 for (let j = line.indexOf(p1); j >= 0; j--) {
                     const p = line[j];
-                    if (!equal(p, current)) {
+                    if (!pointEqual(p, current)) {
                         p1 = p;
                         break;
                     }
@@ -392,7 +392,7 @@ export function expandLine(line: Array<Array<number>>, options?: ExpandLineOptio
             }
 
         }
-        if (equal(p1, p2)) {
+        if (pointEqual(p1, p2)) {
             console.error('not find next vertex:index:', i, line);
             repeatVertex();
             i++;
@@ -410,16 +410,16 @@ export function expandLine(line: Array<Array<number>>, options?: ExpandLineOptio
         } else {
             // 至少3个顶点才会触发
             p0 = line[i - 1];
-            if (equal(p0, p2) || equal(p0, p1)) {
+            if (pointEqual(p0, p2) || pointEqual(p0, p1)) {
                 for (let j = line.indexOf(p2); j >= 0; j--) {
                     const p = line[j];
-                    if (!equal(p, p2) && (!equal(p, p1))) {
+                    if (!pointEqual(p, p2) && (!pointEqual(p, p1))) {
                         p0 = p;
                         break;
                     }
                 }
             }
-            if (equal(p0, p2) || equal(p0, p1) || equal(p1, p2)) {
+            if (pointEqual(p0, p2) || pointEqual(p0, p1) || pointEqual(p1, p2)) {
                 console.error('not find pre vertex:index:', i, line);
                 repeatVertex();
                 i++;
@@ -480,13 +480,13 @@ export function expandLine(line: Array<Array<number>>, options?: ExpandLineOptio
         let needCut = false;
         if (cutCorner) {
             const bufferRadius = radius * 2;
-            if (distance(current, op1) > bufferRadius || distance(current, op2) > bufferRadius) {
+            if (pointDistance(current, op1) > bufferRadius || pointDistance(current, op2) > bufferRadius) {
                 needCut = true;
             }
         }
         if (needCut && p0 && preleftline && prerightline) {
             let cutPoint = op1;
-            if (distance(op1, p0) < distance(op2, p0)) {
+            if (pointDistance(op1, p0) < pointDistance(op2, p0)) {
                 cutPoint = op2;
             }
             const dy = cutPoint[1] - current[1], dx = cutPoint[0] - current[0];
@@ -542,10 +542,6 @@ export function expandLine(line: Array<Array<number>>, options?: ExpandLineOptio
     return { offsetPoints: points, leftPoints, rightPoints, line };
 }
 
-function equal(p1: Point, p2: Point) {
-    return p1[0] === p2[0] && p1[1] === p2[1];
-}
-
 
 // eslint-disable-next-line no-unused-vars
 function calOffsetPoint(rad: number, radius: number, p: Point) {
@@ -567,10 +563,6 @@ const getAngle = ({ x: x1, y: y1 }, { x: x2, y: y2 }) => {
     // return (angle + 360) % 360;
 };
 
-function distance(p1: Point, p2: Point) {
-    const dx = p2[0] - p1[0], dy = p2[1] - p1[1];
-    return Math.sqrt(dx * dx + dy * dy);
-}
 
 export function leftOnLine(p: Point, p1: Point, p2: Point) {
     const [x1, y1] = p1;

package/src/polylineoffset.ts

@@ -1,5 +1,6 @@
 import { PolylineType } from "./type";
-import { mergeArray } from "./util";
+import { mergeArray, pointDistance, pointEqual } from "./util";
+import { Bezier } from 'bezier-js';
 //https://github.com/bbecquet/Leaflet.PolylineOffset/blob/master/leaflet.polylineoffset.js
 
 /**
@@ -230,4 +231,62 @@ export function polylineOffset(line: PolylineType, options: polylineOffsetOption
         result.push([x, y, z]);
     }
     return result;
+}
+
+type polylineRoundOptions = {
+    roundSize: number,
+    steps?: number;
+}
+
+export function polylineRound(line: PolylineType, options: polylineRoundOptions): PolylineType {
+    options = Object.assign({ roundSize: 0, steps: 10 }, options);
+    if (options.roundSize === 0) {
+        return line;
+    }
+    if (!line || line.length < 3) {
+        return line;
+    }
+    const len = line.length;
+    const { roundSize, steps } = options;
+
+    const pts = [line[0]];
+    let pre = line[0];
+
+    for (let i = 1; i < len; i++) {
+        const p1 = line[i - 1], p2 = line[i], p3 = line[i + 1];
+        if (pointEqual(pre, p2)) {
+            continue;
+        }
+        if (!p3) {
+            continue;
+        }
+        const d1 = pointDistance(p2, p1), d2 = pointDistance(p2, p3);
+        if (d1 < roundSize || d2 < roundSize) {
+            pre = p2;
+            pts.push(p2);
+            continue;
+        }
+        const dx1 = p2[0] - p1[0], dy1 = p2[1] - p1[1];
+        const dx2 = p3[0] - p2[0], dy2 = p3[1] - p2[1];
+
+        const percent1 = (d1 - roundSize) / d1;
+        const percent2 = roundSize / d2;
+        const c1 = {
+            x: p1[0] + percent1 * dx1,
+            y: p1[1] + percent1 * dy1
+        };
+        const c2 = {
+            x: p2[0] + percent2 * dx2,
+            y: p2[1] + percent2 * dy2
+        };
+        const be = new Bezier([c1, { x: p2[0], y: p2[1] }, c2]);
+        const path = be.getLUT(steps);
+        for (let j = 0, len1 = path.length; j < len1; j++) {
+            const p = path[j];
+            pts.push([p.x, p.y]);
+        }
+        pre = p2;
+    }
+    pts.push(line[len- 1]);
+    return pts;
 }

package/src/util.ts

@@ -1,6 +1,8 @@
 import { Vector3 } from './math/Vector3';
 import { PolygonType, PolylineType, ResultType } from './type';
 
+type Point = Array<number>;
+
 export function mergeArray(array1, array2) {
     let index = array1.length - 1;
     for (let i = 0, len = array2.length; i < len; i++) {
@@ -310,3 +312,13 @@ export function calLineDistance(line) {
     }
     return distance;
 }
+
+
+export function pointEqual(p1: Point, p2: Point) {
+    return p1[0] === p2[0] && p1[1] === p2[1];
+}
+
+export function pointDistance(p1: Point, p2: Point) {
+    const dx = p2[0] - p1[0], dy = p2[1] - p1[1];
+    return Math.sqrt(dx * dx + dy * dy);
+}