poly-extrude 0.3.0 → 0.4.0

package/dist/poly-extrude.js

@@ -1,5 +1,5 @@
 /*!
- * poly-extrude v0.3.0
+ * poly-extrude v0.4.0
   */
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
@@ -1233,7 +1233,7 @@
       y: 0
     };
     function expandLine(line, options) {
-      var preAngle = 0;
+      // let preAngle = 0;
       var radius = options.lineWidth / 2;
       var points = [],
           leftPoints = [],
@@ -1241,66 +1241,76 @@
       var len = line.length;
       var i = 0;
 
-      while (i < len - 1) {
-        var _p = line[i],
-            _p2 = line[i + 1];
-        var dy = _p2[1] - _p[1],
-            dx = _p2[0] - _p[0];
-        var _rAngle = 0;
+      while (i < len) {
+        var p1 = line[i],
+            p2 = line[i + 1];
+        var currentp = line[i]; // last vertex
+
+        if (i === len - 1) {
+          p1 = line[len - 2];
+          p2 = line[len - 1];
+        }
+
+        var dy = p2[1] - p1[1],
+            dx = p2[0] - p1[0];
+        var rAngle = 0;
         var rad = Math.atan(dy / dx);
-        var angle = radToDeg(rad);
-        preAngle = angle;
+        var angle = radToDeg(rad); // preAngle = angle;
 
-        if (i === 0) {
-          _rAngle = angle;
-          _rAngle -= 90;
+        if (i === 0 || i === len - 1) {
+          rAngle = angle;
+          rAngle -= 90;
         } else {
+          // 至少3个顶点才会触发
           var p0 = line[i - 1];
-          TEMPV1.x = p0[0] - _p[0];
-          TEMPV1.y = p0[1] - _p[1];
-          TEMPV2.x = _p2[0] - _p[0];
-          TEMPV2.y = _p2[1] - _p[1];
+          TEMPV1.x = p0[0] - p1[0];
+          TEMPV1.y = p0[1] - p1[1];
+          TEMPV2.x = p2[0] - p1[0];
+          TEMPV2.y = p2[1] - p1[1];
           var vAngle = getAngle(TEMPV1, TEMPV2);
-          _rAngle = angle - vAngle / 2;
+          rAngle = angle - vAngle / 2;
         }
 
-        var _rRad = degToRad(_rAngle);
+        var rRad = degToRad(rAngle);
+        var p3 = currentp;
+        var x = Math.cos(rRad) + p3[0],
+            y = Math.sin(rRad) + p3[1];
+        var p4 = [x, y];
 
-        var _calOffsetPoint = calOffsetPoint(_rRad, radius, _p),
-            _op = _calOffsetPoint[0],
-            _op2 = _calOffsetPoint[1];
+        var _translateLine = translateLine(p1, p2, radius),
+            line1 = _translateLine[0],
+            line2 = _translateLine[1];
 
-        points.push(_op, _op2);
+        var op1 = lineIntersection(line1[0], line1[1], p3, p4);
+        var op2 = lineIntersection(line2[0], line2[1], p3, p4); // 平行，回头路
 
-        if (leftOnLine(_op, _p, _p2)) {
-          leftPoints.push(_op);
-          rightPoints.push(_op2);
-        } else {
-          leftPoints.push(_op2);
-          rightPoints.push(_op);
-        }
+        if (!op1 || !op2) {
+          var len1 = points.length;
+          var point1 = points[len1 - 2];
+          var point2 = points[len1 - 1];
 
-        i++;
-      }
+          if (!point1 || !point2) {
+            continue;
+          }
+
+          op1 = [point1[0], point1[1]];
+          op2 = [point2[0], point2[1]];
+        }
 
-      var rAngle = preAngle;
-      rAngle -= 90;
-      var rRad = degToRad(rAngle);
-      var p1 = line[len - 2];
-      var p2 = line[len - 1];
+        op1[2] = currentp[2] || 0;
+        op2[2] = currentp[2] || 0; // const [op1, op2] = calOffsetPoint(rRad, radius, p1);
 
-      var _calOffsetPoint2 = calOffsetPoint(rRad, radius, p2),
-          op1 = _calOffsetPoint2[0],
-          op2 = _calOffsetPoint2[1];
+        points.push(op1, op2);
 
-      points.push(op1, op2);
+        if (leftOnLine(op1, p1, p2)) {
+          leftPoints.push(op1);
+          rightPoints.push(op2);
+        } 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);
+        i++;
       }
 
       return {
@@ -1308,21 +1318,7 @@
         leftPoints: leftPoints,
         rightPoints: rightPoints
       };
-    }
-
-    function calOffsetPoint(rad, radius, p) {
-      var x = p[0],
-          y = p[1];
-      var z = p[2] || 0;
-      var x1 = Math.cos(rad) * radius,
-          y1 = Math.sin(rad) * radius;
-      var p1 = [x + x1, y + y1, z];
-      var rad1 = rad += Math.PI;
-      var x2 = Math.cos(rad1) * radius,
-          y2 = Math.sin(rad1) * radius;
-      var p2 = [x + x2, y + y2, z];
-      return [p1, p2];
-    }
+    } // eslint-disable-next-line no-unused-vars
 
     var getAngle = function getAngle(_ref, _ref2) {
       var x1 = _ref.x,
@@ -1344,6 +1340,80 @@
           y = p[1];
       return (y1 - y2) * x + (x2 - x1) * y + x1 * y2 - x2 * y1 > 0;
     }
+    /**
+     * 平移线
+     * @param {*} p1
+     * @param {*} p2
+     * @param {*} distance
+     * @returns
+     */
+
+
+    function translateLine(p1, p2, distance) {
+      var dy = p2[1] - p1[1],
+          dx = p2[0] - p1[0];
+      var rad = Math.atan2(dy, dx);
+      var rad1 = rad + Math.PI / 2;
+      var offsetX = Math.cos(rad1) * distance,
+          offsetY = Math.sin(rad1) * distance;
+      var tp1 = [p1[0] + offsetX, p1[1] + offsetY];
+      var tp2 = [p2[0] + offsetX, p2[1] + offsetY];
+      var rad2 = rad - Math.PI / 2;
+      offsetX = Math.cos(rad2) * distance;
+      offsetY = Math.sin(rad2) * distance;
+      var tp3 = [p1[0] + offsetX, p1[1] + offsetY];
+      var tp4 = [p2[0] + offsetX, p2[1] + offsetY];
+      return [[tp1, tp2], [tp3, tp4]];
+    }
+    /**
+     * 直线交点
+     * @param {*} p1
+     * @param {*} p2
+     * @param {*} p3
+     * @param {*} p4
+     * @returns
+     */
+
+
+    function lineIntersection(p1, p2, p3, p4) {
+      var dx1 = p2[0] - p1[0],
+          dy1 = p2[1] - p1[1];
+      var dx2 = p4[0] - p3[0],
+          dy2 = p4[1] - p3[1];
+
+      if (dx1 === 0 && dx2 === 0) {
+        return null;
+      }
+
+      if (dy1 === 0 && dy2 === 0) {
+        return null;
+      }
+
+      var k1 = dy1 / dx1;
+      var k2 = dy2 / dx2;
+      var b1 = p1[1] - k1 * p1[0];
+      var b2 = p3[1] - k2 * p3[0];
+      var x, y;
+
+      if (dx1 === 0) {
+        x = p1[0];
+        y = k2 * x + b2;
+      } else if (dx2 === 0) {
+        x = p3[0];
+        y = k1 * x + b1;
+      } else if (dy1 === 0) {
+        y = p1[1];
+        x = (y - b2) / k2;
+      } else if (dy2 === 0) {
+        y = p3[1];
+        x = (y - b1) / k1;
+      } else {
+        x = (b2 - b1) / (k1 - k2);
+        y = k1 * x + b1;
+      }
+
+      return [x, y];
+    }
 
     function cylinder(point, options) {
       if (options === void 0) {