poly-extrude 0.18.1 → 0.20.0

package/src/polyline.ts

@@ -7,13 +7,23 @@ function checkOptions(options) {
     options.sideDepth = Math.max(0, options.sideDepth);
 }
 
-type PolylinesOptions = {
-    depth?: number;
+type ExpandLineOptions = {
     lineWidth?: number;
+    cutCorner?: boolean;
+}
+
+type PolylinesOptions = ExpandLineOptions & {
+    depth?: number;
     bottomStickGround?: boolean;
     pathUV?: boolean;
 }
 
+type SlopesOptions = PolylinesOptions & {
+    side?: 'left' | 'right',
+    sideDepth?: number
+}
+
+
 type PolylinesResult = ResultType & {
     lines: Array<PolylineType>;
 }
@@ -37,11 +47,6 @@ export function extrudePolylines(lines: Array<PolylineType>, opts?: PolylinesOpt
     return result;
 }
 
-type SlopesOptions = PolylinesOptions & {
-    side?: 'left' | 'right',
-    sideDepth?: number
-}
-
 export function extrudeSlopes(lines: Array<PolylineType>, opts?: SlopesOptions): PolylinesResult {
     const options = Object.assign({}, { depth: 2, lineWidth: 1, side: 'left', sideDepth: 0, bottomStickGround: false, pathUV: false, isSlope: true }, opts);
     checkOptions(options);
@@ -90,10 +95,15 @@ function generateTopAndBottom(result, options) {
     const { leftPoints, rightPoints } = result;
     const line = result.line;
     const pathUV = options.pathUV;
+    let uvCalPath = line;
+    // let needCalUV = false;
+    if (leftPoints.length > uvCalPath.length) {
+        uvCalPath = leftPoints;
+    }
     if (pathUV) {
-        calLineDistance(line);
-        for (let i = 0, len = line.length; i < len; i++) {
-            leftPoints[i].distance = rightPoints[i].distance = line[i].distance;
+        calLineDistance(uvCalPath);
+        for (let i = 0, len = uvCalPath.length; i < len; i++) {
+            leftPoints[i].distance = rightPoints[i].distance = uvCalPath[i].distance;
         }
     }
     let i = 0, len = leftPoints.length;
@@ -106,6 +116,8 @@ function generateTopAndBottom(result, options) {
         points[idx0 + 1] = y1;
         points[idx0 + 2] = lz + z1;
 
+        // const p1 = leftPoints[i];
+
         // top right
         const [x2, y2, z2] = rightPoints[i];
         const idx1 = len * 3 + idx0;
@@ -113,6 +125,8 @@ function generateTopAndBottom(result, options) {
         points[idx1 + 1] = y2;
         points[idx1 + 2] = rz + z2;
 
+        // const p2 = rightPoints[i];
+
         // bottom left
         const idx2 = (len * 2) * 3 + idx0;
         points[idx2] = x1;
@@ -133,8 +147,8 @@ function generateTopAndBottom(result, options) {
 
         // generate path uv
         if (pathUV) {
-            const p = line[i];
-            const uvx = p.distance;
+            const p = uvCalPath[i];
+            let uvx = p.distance;
 
             const uIndex0 = i * 2;
             uv[uIndex0] = uvx;
@@ -307,56 +321,118 @@ function generateSides(result, options) {
 
 const TEMPV1 = { x: 0, y: 0 }, TEMPV2 = { x: 0, y: 0 };
 
-export function expandLine(line, options) {
-    // let preAngle = 0;
+export function expandLine(line, options?: ExpandLineOptions) {
+    options = Object.assign({}, { lineWidth: 1, cutCorner: false }, options);
     let radius = options.lineWidth / 2;
-    if (options.isSlope) {
+    if ((options as any).isSlope) {
         radius *= 2;
     }
+    const { cutCorner } = options;
     const points: Array<number[]> = [], leftPoints: Array<number[]> = [], rightPoints: Array<number[]> = [];
     const len = line.length;
+
+    const repeatVertex = () => {
+        const len1 = leftPoints.length;
+        if (len1) {
+            leftPoints.push(leftPoints[len1 - 1]);
+            rightPoints.push(rightPoints[len1 - 1]);
+            const len2 = points.length;
+            points.push(points[len2 - 2], points[len2 - 1]);
+        }
+    };
+
+    const equal = (p1, p2) => {
+        return p1[0] === p2[0] && p1[1] === p2[1];
+    };
+
     let i = 0;
+    let preleftline, prerightline;
     while (i < len) {
+        let p0;
         let p1 = line[i],
             p2 = line[i + 1];
-        const currentp = line[i];
+        const currentp = p1;
         // last vertex
         if (i === len - 1) {
             p1 = line[len - 2];
             p2 = line[len - 1];
+            if (equal(p1, p2)) {
+                for (let j = line.indexOf(p1); j >= 0; j--) {
+                    const p = line[j];
+                    if (!equal(p, currentp)) {
+                        p1 = p;
+                        break;
+                    }
+                }
+            }
+        } else {
+            if (equal(p1, p2)) {
+                for (let j = line.indexOf(p2); j < len; j++) {
+                    const p = line[j];
+                    if (!equal(p, currentp)) {
+                        p2 = p;
+                        break;
+                    }
+                }
+            }
+        }
+        if (equal(p1, p2)) {
+            repeatVertex();
+            i++;
+            continue;
         }
-        const dy = p2[1] - p1[1],
+
+        let dy = p2[1] - p1[1],
             dx = p2[0] - p1[0];
+
         let rAngle = 0;
-        const rad = Math.atan(dy / dx);
+        const rad = Math.atan2(dy, dx);
         const angle = radToDeg(rad);
-        // preAngle = angle;
         if (i === 0 || i === len - 1) {
             rAngle = angle;
             rAngle -= 90;
         } else {
             // 至少3个顶点才会触发
-            const p0 = line[i - 1];
+            p0 = line[i - 1];
+            if (equal(p0, p2) || equal(p0, p1)) {
+                for (let j = line.indexOf(p2); j >= 0; j--) {
+                    const p = line[j];
+                    if (!equal(p, p2) && (!equal(p, p1))) {
+                        p0 = p;
+                        break;
+                    }
+                }
+            }
+            if (equal(p0, p2) || equal(p0, p1) || equal(p1, p2)) {
+                repeatVertex();
+                i++;
+                continue;
+            }
             TEMPV1.x = p0[0] - p1[0];
             TEMPV1.y = p0[1] - p1[1];
             TEMPV2.x = p2[0] - p1[0];
             TEMPV2.y = p2[1] - p1[1];
+            if ((TEMPV1.x === 0 && TEMPV1.y === 0) || (TEMPV2.x === 0 && TEMPV2.y === 0)) {
+                console.error('has repeat vertex,the index:', i);
+            }
             const vAngle = getAngle(TEMPV1, TEMPV2);
             rAngle = angle - vAngle / 2;
         }
+
         const rRad = degToRad(rAngle);
         const p3 = currentp;
         const x = Math.cos(rRad) + p3[0], y = Math.sin(rRad) + p3[1];
         const p4 = [x, y];
-        const [line1, line2] = translateLine(p1, p2, radius);
-        let op1 = lineIntersection(line1[0], line1[1], p3, p4);
-        let op2 = lineIntersection(line2[0], line2[1], p3, p4);
+        const [leftline, rightline] = translateLine(p1, p2, radius);
+        let op1 = lineIntersection(leftline[0], leftline[1], p3, p4);
+        let op2 = lineIntersection(rightline[0], rightline[1], p3, p4);
         // 平行，回头路
         if (!op1 || !op2) {
             const len1 = points.length;
             const point1 = points[len1 - 2];
             const point2 = points[len1 - 1];
             if (!point1 || !point2) {
+                i++;
                 continue;
             }
             op1 = [point1[0], point1[1]];
@@ -366,13 +442,64 @@ export function expandLine(line, options) {
         op2[2] = currentp[2] || 0;
         // const [op1, op2] = calOffsetPoint(rRad, radius, p1);
         points.push(op1, op2);
-        if (leftOnLine(op1, p1, p2)) {
-            leftPoints.push(op1);
-            rightPoints.push(op2);
+        let needCut = false;
+        if (cutCorner) {
+            const bufferRadius = radius * 2;
+            if (distance(currentp, op1) > bufferRadius || distance(currentp, op2) > bufferRadius) {
+                needCut = true;
+            }
+        }
+        if (needCut && p0 && preleftline && prerightline) {
+            let cutPoint = op1;
+            if (distance(op1, p0) < distance(op2, p0)) {
+                cutPoint = op2;
+            }
+            const dy = cutPoint[1] - currentp[1], dx = cutPoint[0] - currentp[0];
+            const cutAngle = Math.atan2(dy, dx) / Math.PI * 180;
+            const cutRad = degToRad(cutAngle);
+            const x1 = Math.cos(cutRad) * radius + currentp[0];
+            const y1 = Math.sin(cutRad) * radius + currentp[1];
+            const v1 = [x1, y1];
+
+            const hcutangle = cutAngle + 90;
+            // console.log(i, cutAngle, hcutangle);
+            const hcutRad = degToRad(hcutangle);
+            const x2 = Math.cos(hcutRad) + x1;
+            const y2 = Math.sin(hcutRad) + y1;
+            const v2 = [x2, y2];
+
+            let preline = preleftline;
+            let currentLine = leftline;
+            let appendArray = leftPoints;
+            let repeatArray = rightPoints;
+            if (!leftOnLine(cutPoint, p1, p2)) {
+                preline = prerightline;
+                currentLine = rightline;
+                appendArray = rightPoints;
+                repeatArray = leftPoints;
+            }
+
+            let cross1 = lineIntersection(preline[0], preline[1], v1, v2);
+            let cross2 = lineIntersection(currentLine[0], currentLine[1], v1, v2);
+
+            cross1[2] = currentp[2] || 0;
+            cross2[2] = currentp[2] || 0;
+            const repeatPoint = cutPoint === op1 ? op2 : op1;
+            appendArray.push(cross1, cross2);
+            repeatArray.push(repeatPoint, [...repeatPoint]);
         } else {
-            leftPoints.push(op2);
-            rightPoints.push(op1);
+            if (leftOnLine(op1, p1, p2)) {
+                leftPoints.push(op1);
+                rightPoints.push(op2);
+            } else {
+                leftPoints.push(op2);
+                rightPoints.push(op1);
+            }
         }
+
+        preleftline = leftline;
+        prerightline = rightline;
+
         i++;
     }
 
@@ -395,9 +522,15 @@ const getAngle = ({ x: x1, y: y1 }, { x: x2, y: y2 }) => {
     const dot = x1 * x2 + y1 * y2;
     const det = x1 * y2 - y1 * x2;
     const angle = Math.atan2(det, dot) / Math.PI * 180;
-    return (angle + 360) % 360;
+    return (angle);
+    // return (angle + 360) % 360;
 };
 
+function distance(p1, p2) {
+    const dx = p2[0] - p1[0], dy = p2[1] - p1[1];
+    return Math.sqrt(dx * dx + dy * dy);
+}
+
 export function leftOnLine(p, p1, p2) {
     const [x1, y1] = p1;
     const [x2, y2] = p2;
@@ -412,8 +545,11 @@ export function leftOnLine(p, p1, p2) {
  * @param {*} distance
  * @returns
  */
-function translateLine(p1, p2, distance) {
+export function translateLine(p1, p2, distance) {
     const dy = p2[1] - p1[1], dx = p2[0] - p1[0];
+    if (dy === 0 && dx === 0) {
+        return null;
+    }
     const rad = Math.atan2(dy, dx);
     const rad1 = rad + Math.PI / 2;
     let offsetX = Math.cos(rad1) * distance, offsetY = Math.sin(rad1) * distance;
@@ -438,13 +574,14 @@ function translateLine(p1, p2, distance) {
 function lineIntersection(p1, p2, p3, p4): Array<number> | null {
     const dx1 = p2[0] - p1[0], dy1 = p2[1] - p1[1];
     const dx2 = p4[0] - p3[0], dy2 = p4[1] - p3[1];
+    //vertical 
     if (dx1 === 0 && dx2 === 0) {
         return null;
     }
+    //horizontal
     if (dy1 === 0 && dy2 === 0) {
         return null;
     }
-
     const k1 = dy1 / dx1;
     const k2 = dy2 / dx2;