poly-extrude 0.17.0 → 0.18.0

package/readme.md

@@ -2,7 +2,7 @@
 
 Extrude polygons/polylines. Born in [maptalks.three](https://github.com/maptalks/maptalks.three) project<br>
 
-## Examples
+<!-- ## Examples
 
 [![](./gallery/building.png)](https://deyihu.github.io/poly-extrude/test/building.html)
 
@@ -21,7 +21,7 @@ Extrude polygons/polylines. Born in [maptalks.three](https://github.com/maptalks
 [![](./gallery/tube.png)](https://deyihu.github.io/poly-extrude/test/tube.html)<br>
 [![](./gallery/terrain.png)](https://deyihu.github.io/poly-extrude/test/terrain.html)<br>
 
-[shape demo ](https://deyihu.github.io/poly-extrude/test/shape.html)<br>
+[shape demo ](https://deyihu.github.io/poly-extrude/test/shape.html)<br> -->
 
 ## Install
 
@@ -41,7 +41,9 @@ npm i poly-extrude
 
 ```js
   import {
+      polygons,
       extrudePolygons,
+      extrudePolygonsOnPath,
       extrudePolylines,
       cylinder,
       expandPaths,
@@ -107,6 +109,7 @@ npm i poly-extrude
 
 ## API
 
+
 ![](./img/extrudePolygons.png)
 
 ### `extrudePolygons(polygons, options)`
@@ -127,6 +130,49 @@ npm i poly-extrude
   } = result;
   //do something
 ```
+[building](https://deyihu.github.io/poly-extrude/test/building.html)  
+[buildings](https://deyihu.github.io/poly-extrude/test/buildings.html)  
+[china](https://deyihu.github.io/poly-extrude/test/china.html)  
+[muti polygon](https://deyihu.github.io/poly-extrude/test/multi-polygon.html)  
+[ny buildings](https://deyihu.github.io/poly-extrude/test/ny-building.html)  
+[custom shape](https://deyihu.github.io/poly-extrude/test/shape.html)  
+
+___
+
+![](./img/extrudepolygonsonpath.png)
+
+### `extrudePolygonsOnPath(polygons, options)`
+
+* `polygons`
+* `options.extrudePath` is line
+* `options.openEnd`
+* `options.openEndUV`
+
+```js
+  const result = extrudePolygonsOnPath(polygons, {
+      extrudePath: [
+          [0, 0],
+          [100, 0]
+      ]
+  });
+  const {
+      positon,
+      normal,
+      uv,
+      indices
+  } = result;
+  //do something
+```
+
+[base demo](https://deyihu.github.io/poly-extrude/test/polygon-on-path.html)  
+[with holes demo](https://deyihu.github.io/poly-extrude/test/polygon-on-path-hole.html)  
+[with holes by custom shape](https://deyihu.github.io/poly-extrude/test/polygon-on-path-hole1.html)  
+[extrude along spring](https://deyihu.github.io/poly-extrude/test/polygon-on-path-spring.html)  
+[extrude taihu lake](https://deyihu.github.io/poly-extrude/test/polygon-on-path-taihu.html)  
+
+
+___
+
 
 ![](./img/extrudePolylines.png)
 
@@ -138,8 +184,6 @@ npm i poly-extrude
 * `options.bottomStickGround`  Is the bottom attached to the ground 
 * `options.pathUV`  generate Path UV
 
-[extrudePolylines pathUV demo](https://deyihu.github.io/poly-extrude/test/line-pathuv.html)
-
 ```js
    const result = extrudePolylines(polylines, {
        depth: 2,
@@ -153,6 +197,21 @@ npm i poly-extrude
    } = result;
    //do something
 ```
+[line](https://deyihu.github.io/poly-extrude/test/line.html)  
+[line uv](https://deyihu.github.io/poly-extrude/test/line-uv.html)  
+[line pathUV](https://deyihu.github.io/poly-extrude/test/line-pathuv.html)  
+[brige](https://deyihu.github.io/poly-extrude/test/brige.html)  
+[brige bottomStickGround](https://deyihu.github.io/poly-extrude/test/brige-bottomStickGround.html)  
+[extrude brige](https://deyihu.github.io/poly-extrude/test/extrudepolyline-brige.html)  
+[spring](https://deyihu.github.io/poly-extrude/test/spring.html)  
+[wall](https://deyihu.github.io/poly-extrude/test/wall.html)  
+[street](https://deyihu.github.io/poly-extrude/test/street.html)  
+
+
+
+
+___
+
 
 ![](./img/cylinder.png)
 
@@ -181,6 +240,10 @@ const {
 } = result;
 //do something
 ```
+[cylinder](https://deyihu.github.io/poly-extrude/test/cylinder.html)  
+___
+
+
 
 ![](./img/expandPaths.png)
 
@@ -207,6 +270,12 @@ const {
 //do something
 ```
 
+[paths](https://deyihu.github.io/poly-extrude/test/expand-path.html)  
+[street paths](https://deyihu.github.io/poly-extrude/test/expand-path-street.html)  
+[brige paths](https://deyihu.github.io/poly-extrude/test/expand-paths-brige.html)  
+___
+
+
 ![](./img/extrudeSlopes.png)
 
 ### `extrudeSlopes(lines, options)`
@@ -219,7 +288,6 @@ const {
 * `options.bottomStickGround` Is the bottom attached to the ground
 * `options.pathUV`  generate Path UV
 
-[extrudeSlopes pathUV demo](https://deyihu.github.io/poly-extrude/test/slope-pathuv.html)
 
 ```js
 const result = extrudeSlopes(polylines, {
@@ -241,6 +309,10 @@ const {
 //do something
 ```
 
+[slope](https://deyihu.github.io/poly-extrude/test/slope.html)  
+[extrudeSlopes pathUV demo](https://deyihu.github.io/poly-extrude/test/slope-pathuv.html)   
+___
+
 ![](./img/expandTubes.png)
 
 ### `expandTubes(lines, options)`
@@ -267,6 +339,9 @@ const {
 //do something
 ```
 
+[tube](https://deyihu.github.io/poly-extrude/test/tube.html)  
+___
+
 ![](./img/plane.png)
 
 ### `plane(width, height,devideW,devideH)`
@@ -276,8 +351,6 @@ const {
 * `devideW`
 * `devideH`
 
-[plane demo](https://deyihu.github.io/poly-extrude/test/plane.html)  
-[custom terrain demo](https://deyihu.github.io/poly-extrude/test/terrain.html)
 
 ```js
 const result = plane(100, 100, 10, 10);
@@ -291,3 +364,29 @@ const {
 } = result;
 //do something
 ```
+
+[plane demo](https://deyihu.github.io/poly-extrude/test/plane.html)  
+[custom terrain demo](https://deyihu.github.io/poly-extrude/test/terrain.html)  
+
+___
+
+![](./img/polygons.png)
+
+### `polygons(polygons, options)`
+
+* `polygons`
+
+```js
+  const result = polygons(polygons, {
+
+  });
+  const {
+      positon,
+      normal,
+      uv,
+      indices
+  } = result;
+  //do something
+```
+
+[polygons demo](https://deyihu.github.io/poly-extrude/test/simplepolygon.html)

package/src/cylinder.ts

@@ -11,8 +11,8 @@ type CylinderResult = ResultType & {
     points: Float32Array
 }
 
-export function cylinder(point: [number, number], options?: CylinderOptions): CylinderResult {
-    options = Object.assign({}, { radius: 1, height: 2, radialSegments: 6 }, options);
+export function cylinder(point: [number, number], opts?: CylinderOptions): CylinderResult {
+    const options = Object.assign({}, { radius: 1, height: 2, radialSegments: 6 }, opts);
     const radialSegments = Math.round(Math.max(4, options.radialSegments as number));
     let { radius, height } = options;
     radius = (radius as number);

package/src/path.ts

@@ -24,8 +24,8 @@ type PathsResult = ResultType & {
     lines: Array<PolylineType>;
 }
 
-export function expandPaths(lines: Array<PolylineType>, options?: PathsOptions): PathsResult {
-    options = Object.assign({}, { lineWidth: 1, cornerRadius: 0, cornerSplit: 10 }, options);
+export function expandPaths(lines: Array<PolylineType>, opts?: PathsOptions): PathsResult {
+    const options = Object.assign({}, { lineWidth: 1, cornerRadius: 0, cornerSplit: 10 }, opts);
     const results = lines.map(line => {
         const points = line2Vectors(line);
         const pathPointList = new PathPointList();
@@ -43,7 +43,7 @@ export function expandPaths(lines: Array<PolylineType>, options?: PathsOptions):
         }
         return result;
     });
-    const result = merge(results) as PathsResult;
+    const result = merge<PathsResult>(results)
     result.lines = lines;
     return result;
 }

package/src/polygon.ts

@@ -13,10 +13,10 @@ type PolygonsResult = ResultType & {
 }
 
 
-export function extrudePolygons(polygons: Array<PolygonType>, options?: PolygonsOptions): PolygonsResult {
-    options = Object.assign({}, { depth: 2, top: true }, options);
+export function extrudePolygons(polygons: Array<PolygonType>, opts?: PolygonsOptions): PolygonsResult {
+    const options = Object.assign({}, { depth: 2, top: true }, opts);
     const results = polygons.map(polygon => {
-        validatePolygon(polygon);
+        validatePolygon(polygon, true);
         const result = flatVertices(polygon, options) as Record<string, any>;
         result.polygon = polygon;
         const triangles = earcut(result.flatVertices, result.holes, 2);
@@ -28,7 +28,7 @@ export function extrudePolygons(polygons: Array<PolygonType>, options?: Polygons
         result.normal = generateNormal(result.indices, result.position);
         return result;
     });
-    const result = merge(results as Array<ResultType>) as PolygonsResult;
+    const result = merge<PolygonsResult>(results as Array<ResultType>);
     result.polygons = polygons;
     return result;
 
@@ -193,9 +193,10 @@ function simplePolygon(polygon, options = {}) {
     }
 }
 
-export function polygons(polygons, options = {}): PolygonsResult {
+export function polygons(polygons, opts = {}): PolygonsResult {
+    const options = Object.assign({}, opts);
     const results = polygons.map(polygon => {
-        validatePolygon(polygon);
+        validatePolygon(polygon, true);
 
         const result = simplePolygon(polygon, options) as Record<string, any>;
         result.polygon = polygon;
@@ -205,7 +206,7 @@ export function polygons(polygons, options = {}): PolygonsResult {
         result.normal = new Float32Array(result.normal);
         return result;
     });
-    const result = merge(results as Array<ResultType>) as PolygonsResult;
+    const result = merge<PolygonsResult>(results as Array<ResultType>);
     result.polygons = polygons;
     return result;
 

package/src/polygonpath.ts

@@ -1,8 +1,8 @@
 import { Vector3 } from './math/Vector3';
-import { PathPoint } from './path/PathPoint';
+// import { PathPoint } from './path/PathPoint';
 import { PathPointList } from './path/PathPointList';
 import { PolygonType, PolylineType, ResultType } from './type';
-import { generateNormal, isClockwise, line2Vectors, merge, validateRing, isClosedRing, calPolygonPointsCount, getPolygonsBBOX, mergeArray } from './util';
+import { generateNormal, line2Vectors, merge, isClosedRing, calPolygonPointsCount, getPolygonsBBOX, mergeArray, validatePolygon } from './util';
 import earcut from 'earcut';
 const UP = new Vector3(0, 0, 1);
 const normalDir = new Vector3();
@@ -11,18 +11,23 @@ type PolygonsOnPathOptions = {
     extrudePath: PolylineType;
     openEnd?: boolean;
     openEndUV?: boolean;
+    polygonRotation?: number;
 
 }
 
+type PrivatePolygonsOnPathOptions = PolygonsOnPathOptions & {
+    center: Point;
+    bbox: [number, number, number, number]
+}
+
 type PolygonsOnPathResult = ResultType & {
     polygons: Array<PolygonType>;
 }
 
-
 type Point = [number, number];
 
-export function extrudePolygonsOnPath(polygons: Array<PolygonType>, options?: PolygonsOnPathOptions) {
-    options = Object.assign({}, { openEnd: false, openEndUV: true }, options);
+export function extrudePolygonsOnPath(polygons: Array<PolygonType>, opts?: PolygonsOnPathOptions) {
+    const options = (Object.assign({}, { openEnd: false, openEndUV: true, polygonRotation: 0 }, opts)) as PrivatePolygonsOnPathOptions;
     const { extrudePath, openEnd } = options;
     if (!extrudePath || !Array.isArray(extrudePath) || extrudePath.length < 2) {
         console.error('extrudePath is error:', extrudePath);
@@ -31,6 +36,8 @@ export function extrudePolygonsOnPath(polygons: Array<PolygonType>, options?: Po
     const bbox = getPolygonsBBOX(polygons);
     const [minx, miny, maxx, maxy] = bbox;
     const center = [(minx + maxx) / 2, (miny + maxy) / 2] as Point;
+    options.center = center;
+    options.bbox = bbox;
 
     const points = line2Vectors(extrudePath);
     const pathPointList = new PathPointList();
@@ -38,19 +45,8 @@ export function extrudePolygonsOnPath(polygons: Array<PolygonType>, options?: Po
     pathPointList.set(points, 0, options.cornerSplit, UP);
 
     const results = polygons.map(polygon => {
-        for (let i = 0, len = polygon.length; i < len; i++) {
-            const ring = polygon[i];
-            validateRing(ring);
-            if (i === 0) {
-                if (isClockwise(ring)) {
-                    polygon[i] = ring.reverse();
-                }
-            } else if (!isClockwise(ring)) {
-                polygon[i] = ring.reverse();
-            }
-        }
-
-        const result = generatePolygonOnPathVertexData(pathPointList, polygon, center) as Record<string, any>;
+        validatePolygon(polygon, false);
+        const result = generatePolygonOnPathVertexData(pathPointList, polygon, options as PrivatePolygonsOnPathOptions) as Record<string, any>;
         if (!openEnd) {
             generateStartAndEnd(result, polygon, options);
         }
@@ -61,7 +57,7 @@ export function extrudePolygonsOnPath(polygons: Array<PolygonType>, options?: Po
         result.normal = new Float32Array(result.normal);
         return result;
     });
-    const result = merge(results as Array<ResultType>) as PolygonsOnPathResult;
+    const result = merge<PolygonsOnPathResult>(results as Array<ResultType>);
     result.polygons = polygons;
     return result;
 }
@@ -76,7 +72,8 @@ function getAngle(c1: Point, c2: Point) {
 }
 
 
-function transformPolygon(polygon: PolygonType, center: Point) {
+function transformPolygon(polygon: PolygonType, options: PrivatePolygonsOnPathOptions) {
+    const { center, polygonRotation } = options;
     const [cx, cy] = center;
     const list = [];
     polygon.forEach((ring, rIndex) => {
@@ -100,7 +97,7 @@ function transformPolygon(polygon: PolygonType, center: Point) {
                 // dz: 0,
                 distance,
                 radius: Math.sqrt(offsetx * offsetx + offsety * offsety),
-                angle: getAngle(center, p as Point)
+                angle: -getAngle(center, p as Point) + polygonRotation
             }
             tempPoint = p;
         }
@@ -115,8 +112,8 @@ function transformPolygon(polygon: PolygonType, center: Point) {
 const TEMP_VECTOR3 = new Vector3(0, 0, 0);
 // Vertex Data Generate Functions
 // code copy from https://github.com/shawn0326/three.path/blob/master/src/PathGeometry.js
-function generatePolygonOnPathVertexData(pathPointList, polygon: PolygonType, center: Point) {
-    const tpolygon = transformPolygon(polygon, center);
+function generatePolygonOnPathVertexData(pathPointList, polygon: PolygonType, options: PrivatePolygonsOnPathOptions) {
+    const tpolygon = transformPolygon(polygon, options);
     // let count = 0;
     // modify data
     const points: number[] = [];
@@ -154,9 +151,13 @@ function generatePolygonOnPathVertexData(pathPointList, polygon: PolygonType, ce
             v.y *= radius;
             v.z *= radius;
 
-            points[++pIndex] = pathPoint.pos.x + v.x;
-            points[++pIndex] = pathPoint.pos.y + v.y;
-            points[++pIndex] = pathPoint.pos.z + v.z;
+            const x = pathPoint.pos.x + v.x;
+            const y = pathPoint.pos.y + v.y;
+            const z = pathPoint.pos.z + v.z;
+
+            points[++pIndex] = x;
+            points[++pIndex] = y;
+            points[++pIndex] = z;
 
             // if (i === 0 || i === radialSegments - 1) {
             //     console.log(i, radialSegments, v.x, v.y, v.z);
@@ -174,15 +175,15 @@ function generatePolygonOnPathVertexData(pathPointList, polygon: PolygonType, ce
 
             if (first && !isLast) {
                 let index = startPoints.length - 1;
-                startPoints[++index] = pathPoint.pos.x + v.x;
-                startPoints[++index] = pathPoint.pos.y + v.y;
-                startPoints[++index] = pathPoint.pos.z + v.z;
+                startPoints[++index] = x;
+                startPoints[++index] = y;
+                startPoints[++index] = z;
             }
             if (end && !isLast) {
                 let index = endPoints.length - 1;
-                endPoints[++index] = pathPoint.pos.x + v.x;
-                endPoints[++index] = pathPoint.pos.y + v.y;
-                endPoints[++index] = pathPoint.pos.z + v.z;
+                endPoints[++index] = x;
+                endPoints[++index] = y;
+                endPoints[++index] = z;
             }
         }
 

package/src/polyline.ts

@@ -18,8 +18,8 @@ type PolylinesResult = ResultType & {
     lines: Array<PolylineType>;
 }
 
-export function extrudePolylines(lines: Array<PolylineType>, options?: PolylinesOptions): PolylinesResult {
-    options = Object.assign({}, { depth: 2, lineWidth: 1, bottomStickGround: false, pathUV: false }, options);
+export function extrudePolylines(lines: Array<PolylineType>, opts?: PolylinesOptions): PolylinesResult {
+    const options = Object.assign({}, { depth: 2, lineWidth: 1, bottomStickGround: false, pathUV: false }, opts);
     checkOptions(options);
     const results = lines.map(line => {
         const result = expandLine(line, options) as Record<string, any>;
@@ -32,7 +32,7 @@ export function extrudePolylines(lines: Array<PolylineType>, options?: Polylines
         result.normal = generateNormal(result.indices, result.position);
         return result;
     });
-    const result = merge(results as Array<ResultType>) as PolylinesResult;
+    const result = merge<PolylinesResult>(results as Array<ResultType>);
     result.lines = lines;
     return result;
 }
@@ -42,8 +42,8 @@ type SlopesOptions = PolylinesOptions & {
     sideDepth?: number
 }
 
-export function extrudeSlopes(lines: Array<PolylineType>, options?: SlopesOptions): PolylinesResult {
-    options = Object.assign({}, { depth: 2, lineWidth: 1, side: 'left', sideDepth: 0, bottomStickGround: false, pathUV: false, isSlope: true }, options);
+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);
     const { depth, side, sideDepth } = options;
     const results = lines.map(line => {
@@ -73,7 +73,7 @@ export function extrudeSlopes(lines: Array<PolylineType>, options?: SlopesOption
         result.normal = generateNormal(result.indices, result.position);
         return result;
     });
-    const result = merge(results as Array<ResultType>) as PolylinesResult;
+    const result = merge<PolylinesResult>(results as Array<ResultType>);
     result.lines = lines;
     return result;
 }

package/src/tube.ts

@@ -17,8 +17,8 @@ type TubesResult = ResultType & {
     lines: Array<PolylineType>;
 }
 
-export function expandTubes(lines: Array<PolylineType>, options?: TubesOptions) {
-    options = Object.assign({}, { radius: 1, cornerSplit: 0, radialSegments: 8, startRad: -Math.PI / 4 }, options);
+export function expandTubes(lines: Array<PolylineType>, opts?: TubesOptions) {
+    const options = Object.assign({}, { radius: 1, cornerSplit: 0, radialSegments: 8, startRad: -Math.PI / 4 }, opts);
     const results = lines.map(line => {
         const points = line2Vectors(line);
         const pathPointList = new PathPointList();
@@ -32,7 +32,7 @@ export function expandTubes(lines: Array<PolylineType>, options?: TubesOptions)
         result.normal = new Float32Array(result.normal);
         return result;
     });
-    const result = merge(results as Array<ResultType>) as TubesResult;
+    const result = merge<TubesResult>(results as Array<ResultType>);
     result.lines = lines;
     return result;
 }

package/src/util.ts

@@ -72,7 +72,7 @@ export function getPolygonsBBOX(polygons, bbox?) {
     return bbox;
 }
 
-export function validatePolygon(polygon: PolygonType) {
+export function validatePolygon(polygon: PolygonType, ignoreEndPoint: boolean) {
     for (let i = 0, len = polygon.length; i < len; i++) {
         const ring = polygon[i];
         validateRing(ring);
@@ -83,8 +83,10 @@ export function validatePolygon(polygon: PolygonType) {
         } else if (isClockwise(ring)) {
             polygon[i] = ring.reverse();
         }
-        if (isClosedRing(ring)) {
-            ring.splice(ring.length - 1, 1);
+        if (ignoreEndPoint) {
+            if (isClosedRing(ring)) {
+                ring.splice(ring.length - 1, 1);
+            }
         }
     }
 }
@@ -176,7 +178,7 @@ export function generateNormal(indices, position) {
     return normals;
 }
 
-export function merge(results: Array<ResultType>) {
+export function merge<T extends ResultType>(results: Array<ResultType>): T {
     if (results.length === 1) {
         const result = {
             position: results[0].position,
@@ -185,7 +187,7 @@ export function merge(results: Array<ResultType>) {
             indices: results[0].indices,
             results
         };
-        return result;
+        return result as T;
     }
     let plen = 0, ilen = 0;
     for (let i = 0, len = results.length; i < len; i++) {
@@ -218,14 +220,14 @@ export function merge(results: Array<ResultType>) {
         pOffset += position.length;
         pCount += position.length / 3;
     }
-    return result;
+    return result as T;
 }
 
-export function radToDeg(rad) {
+export function radToDeg(rad: number) {
     return rad * 180 / Math.PI;
 }
 
-export function degToRad(angle) {
+export function degToRad(angle: number) {
     return angle / 180 * Math.PI;
 }
 
@@ -279,7 +281,7 @@ export function generateSideWallUV(uvs, vertices, indexA, indexB, indexC, indexD
 
 }
 
-export function line2Vectors(line) {
+export function line2Vectors(line: PolylineType) {
     const points: Vector3[] = [];
     for (let i = 0, len = line.length; i < len; i++) {
         const p = line[i];