poly-extrude 0.20.6 → 0.22.0

package/package.json

@@ -1,53 +1,54 @@
-{
-  "name": "poly-extrude",
-  "version": "0.20.6",
-  "description": "extrude polyline/polygon etc",
-  "main": "dist/poly-extrude.js",
-  "module": "dist/poly-extrude.mjs",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "tsc": "npx tsc",
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "lint": "eslint src/**/*.js",
-    "build": "npm run lint && npm run tsc  && cross-env NODE_ENV=prd  rollup -c",
-    "dev": "npm run lint && cross-env NODE_ENV=dev  rollup -c -w"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/deyihu/poly-extrude.git"
-  },
-  "author": "",
-  "license": "ISC",
-  "bugs": {
-    "url": "https://github.com/deyihu/poly-extrude/issues"
-  },
-  "homepage": "https://github.com/deyihu/poly-extrude#readme",
-  "devDependencies": {
-    "@babel/core": "^7.17.5",
-    "@babel/preset-env": "^7.16.11",
-    "@rollup/plugin-babel": "^5.3.0",
-    "@rollup/plugin-commonjs": "^21.0.1",
-    "@rollup/plugin-json": "^4.1.0",
-    "@rollup/plugin-node-resolve": "^13.1.3",
-    "@rollup/plugin-typescript": "^8.3.0",
-    "cross-env": "^5.1.4",
-    "eslint": "^6.2.2",
-    "eslint-config-standard": "^14.1.0",
-    "eslint-plugin-import": "^2.18.2",
-    "eslint-plugin-node": "^10.0.0",
-    "eslint-plugin-promise": "^4.2.1",
-    "eslint-plugin-standard": "^4.0.1",
-    "rollup": "^2.64.0",
-    "rollup-plugin-terser": "^7.0.2",
-    "typescript": "^5.7.2",
-    "tslib": "^2.8.1"
-  },
-  "dependencies": {
-    "earcut": "^3.0.1"
-  },
-  "files": [
-    "dist/",
-    "src/",
-    "index.js"
-  ]
+{
+  "name": "poly-extrude",
+  "version": "0.22.0",
+  "description": "extrude polyline/polygon etc",
+  "main": "dist/poly-extrude.js",
+  "module": "dist/poly-extrude.mjs",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "tsc": "npx tsc",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "lint": "eslint src/**/*.js",
+    "build": "npm run lint && npm run tsc  && cross-env NODE_ENV=prd  rollup -c",
+    "dev": "npm run lint && cross-env NODE_ENV=dev  rollup -c -w"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deyihu/poly-extrude.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/deyihu/poly-extrude/issues"
+  },
+  "homepage": "https://github.com/deyihu/poly-extrude#readme",
+  "devDependencies": {
+    "@babel/core": "^7.17.5",
+    "@babel/preset-env": "^7.16.11",
+    "@rollup/plugin-babel": "^5.3.0",
+    "@rollup/plugin-commonjs": "^21.0.1",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^13.1.3",
+    "@rollup/plugin-typescript": "^8.3.0",
+    "cross-env": "^5.1.4",
+    "eslint": "^6.2.2",
+    "eslint-config-standard": "^14.1.0",
+    "eslint-plugin-import": "^2.18.2",
+    "eslint-plugin-node": "^10.0.0",
+    "eslint-plugin-promise": "^4.2.1",
+    "eslint-plugin-standard": "^4.0.1",
+    "rollup": "^2.64.0",
+    "rollup-plugin-terser": "^7.0.2",
+    "tslib": "^2.8.1",
+    "typescript": "^5.7.2"
+  },
+  "dependencies": {
+    "bezier-js": "^6.1.4",
+    "earcut": "^3.0.1"
+  },
+  "files": [
+    "dist/",
+    "src/",
+    "index.js"
+  ]
 }

package/src/index.ts

@@ -5,6 +5,7 @@ import { expandPaths } from './path';
 import { expandTubes } from './tube';
 import { plane } from './plane';
 import { extrudePolygonsOnPath } from './polygonpath';
+import { polylineOffset, polylineRound } from './polylineoffset';
 import { isClockwise, merge } from './util';
 export {
     isClockwise, merge,
@@ -12,5 +13,7 @@ export {
     extrudeSlopes, expandLine, leftOnLine,
     cylinder, expandPaths, expandTubes, plane,
     extrudePolygonsOnPath,
-    polygons
+    polygons,
+    polylineOffset,
+    polylineRound
 };

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

@@ -0,0 +1,292 @@
+import { PolylineType } from "./type";
+import { mergeArray, pointDistance, pointEqual } from "./util";
+import { Bezier } from 'bezier-js';
+//https://github.com/bbecquet/Leaflet.PolylineOffset/blob/master/leaflet.polylineoffset.js
+
+/**
+Find the coefficients (a,b) of a line of equation y = a.x + b,
+or the constant x for vertical lines
+Return null if there's no equation possible
+*/
+type Point = {
+    x: number;
+    y: number;
+    z: number;
+}
+
+function lineEquation(pt1: Point, pt2: Point) {
+    if (pt1.x === pt2.x) {
+        return pt1.y === pt2.y ? null : { x: pt1.x };
+    }
+
+    var a = (pt2.y - pt1.y) / (pt2.x - pt1.x);
+    return {
+        a: a,
+        b: pt1.y - a * pt1.x,
+    };
+}
+
+function calZ(p1: Point, p2: Point, p: Point) {
+    const dx = p2.x - p1.x, dy = p2.y - p1.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    const dx1 = p.x - p1.x, dy1 = p.y - p1.y;
+    const dis = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+    const percent = dis / distance;
+    const dz = p2.z - p1.z;
+    return p1.z + dz * percent;
+}
+
+/**
+Return the intersection point of two lines defined by two points each
+Return null when there's no unique intersection
+*/
+function intersection(l1a: Point, l1b: Point, l2a: Point, l2b: Point) {
+    var line1 = lineEquation(l1a, l1b);
+    var line2 = lineEquation(l2a, l2b);
+
+    if (line1 === null || line2 === null) {
+        return null;
+    }
+
+    if (line1.hasOwnProperty('x')) {
+        if (line2.hasOwnProperty('x')) {
+            return null;
+        }
+        const p = {
+            x: line1.x,
+            y: line2.a * line1.x + line2.b,
+            z: 0
+        };
+        p.z = calZ(l1a, l1b, p);
+        return p;
+    }
+    if (line2.hasOwnProperty('x')) {
+        const p = {
+            x: line2.x,
+            y: line1.a * line2.x + line1.b,
+            z: 0
+        };
+        p.z = calZ(l1a, l1b, p);
+        return p;
+
+    }
+
+    if (line1.a === line2.a) {
+        return null;
+    }
+
+    var x = (line2.b - line1.b) / (line1.a - line2.a);
+    const p = {
+        x: x,
+        y: line1.a * x + line1.b,
+        z: 0
+    };
+    p.z = calZ(l1a, l1b, p);
+    return p;
+}
+
+function translatePoint(pt: Point, dist: number, heading: number) {
+    return {
+        x: pt.x + dist * Math.cos(heading),
+        y: pt.y + dist * Math.sin(heading),
+        z: pt.z || 0
+    };
+}
+
+function offsetPointLine(points, distance: number) {
+    var offsetSegments = [];
+    for (let i = 1, len = points.length; i < len; i++) {
+        let a = points[i - 1], b = points[i];
+        const [x1, y1, z1] = a;
+        const [x2, y2, z2] = b;
+        if (x1 === x2 && y1 === y2) {
+            continue;
+        }
+        a = {
+            x: x1,
+            y: y1,
+            z: z1 || 0
+        };
+        b = {
+            x: x2,
+            y: y2,
+            z: z2 || 0
+        }
+        var segmentAngle = Math.atan2(a.y - b.y, a.x - b.x);
+        var offsetAngle = segmentAngle - Math.PI / 2;
+
+        offsetSegments.push({
+            offsetAngle: offsetAngle,
+            original: [a, b],
+            offset: [
+                translatePoint(a, distance, offsetAngle),
+                translatePoint(b, distance, offsetAngle)
+            ]
+        });
+    }
+    return offsetSegments;
+
+
+}
+
+/**
+Join 2 line segments defined by 2 points each with a circular arc
+*/
+function joinSegments(s1, s2, offset) {
+    // TODO: different join styles
+    return circularArc(s1, s2, offset)
+        .filter(function (x) { return x; })
+}
+
+function joinLineSegments(segments, offset) {
+    var joinedPoints = [];
+    var first = segments[0];
+    var last = segments[segments.length - 1];
+
+    if (first && last) {
+        joinedPoints.push(first.offset[0]);
+        for (let i = 1, len = segments.length; i < len; i++) {
+            let s1 = segments[i - 1], s2 = segments[i];
+            const pts = joinSegments(s1, s2, offset);
+            mergeArray(joinedPoints, pts);
+        }
+        joinedPoints.push(last.offset[1]);
+    }
+
+    return joinedPoints;
+}
+
+function segmentAsVector(s) {
+    return {
+        x: s[1].x - s[0].x,
+        y: s[1].y - s[0].y,
+    };
+}
+
+function getSignedAngle(s1, s2) {
+    const a = segmentAsVector(s1);
+    const b = segmentAsVector(s2);
+    return Math.atan2(a.x * b.y - a.y * b.x, a.x * b.x + a.y * b.y);
+}
+
+/**
+Interpolates points between two offset segments in a circular form
+*/
+function circularArc(s1, s2, distance) {
+    // if the segments are the same angle,
+    // there should be a single join point
+    if (s1.offsetAngle === s2.offsetAngle) {
+        return [s1.offset[1]];
+    }
+
+    const signedAngle = getSignedAngle(s1.offset, s2.offset);
+    // for inner angles, just find the offset segments intersection
+    if ((signedAngle * distance > 0) &&
+        (signedAngle * getSignedAngle(s1.offset, [s1.offset[0], s2.offset[1]]) > 0)) {
+        return [intersection(s1.offset[0], s1.offset[1], s2.offset[0], s2.offset[1])];
+    }
+
+    // draws a circular arc with R = offset distance, C = original meeting point
+    var points = [];
+    var center = s1.original[1];
+    // ensure angles go in the anti-clockwise direction
+    var rightOffset = distance > 0;
+    var startAngle = rightOffset ? s2.offsetAngle : s1.offsetAngle;
+    var endAngle = rightOffset ? s1.offsetAngle : s2.offsetAngle;
+    // and that the end angle is bigger than the start angle
+    if (endAngle < startAngle) {
+        endAngle += Math.PI * 2;
+    }
+    var step = Math.PI / 8;
+    for (var alpha = startAngle; alpha < endAngle; alpha += step) {
+        points.push(translatePoint(center, distance, alpha));
+    }
+    points.push(translatePoint(center, distance, endAngle));
+
+    return rightOffset ? points.reverse() : points;
+}
+
+
+function offsetPoints(pts: PolylineType, options: polylineOffsetOptions) {
+    var offsetSegments = offsetPointLine(pts, options.offset);
+    return joinLineSegments(offsetSegments, options.offset);
+}
+
+type polylineOffsetOptions = {
+    offset: number
+}
+export function polylineOffset(line: PolylineType, options: polylineOffsetOptions): PolylineType {
+    options = Object.assign({ offset: 0 }, options);
+    if (options.offset === 0) {
+        return line;
+    }
+    const pts = offsetPoints(line, options);
+    const result = [];
+    for (let i = 0, len = pts.length; i < len; i++) {
+        const pt = pts[i];
+        if (!pt) {
+            continue;
+        }
+        const { x, y, z } = pt;
+        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);
+}