@jscad/modeling 3.0.1-alpha.0 → 3.0.2-alpha.0

package/src/operations/booleans/trees/splitPolygonByPlane.js

@@ -7,23 +7,27 @@ import * as poly3 from '../../../geometries/poly3/index.js'
 
 import { splitLineSegmentByPlane } from './splitLineSegmentByPlane.js'
 
-// Returns object:
-// .type:
-//   0: coplanar-front
-//   1: coplanar-back
-//   2: front
-//   3: back
-//   4: spanning
-// In case the polygon is spanning, returns:
-// .front: a Polygon3 of the front part
-// .back: a Polygon3 of the back part
-export const splitPolygonByPlane = (splane, polygon) => {
-  const result = {
-    type: null,
-    front: null,
-    back: null
-  }
-  // cache in local lets (speedup):
+/*
+ * Split the given polygon by the given plane.
+ *
+ * @@param (Object} result - object of which to update with the result
+ * @param {Plane} splane - plane to split across
+ * @param {Poly3} ploygon - polygon of which to split
+ * @returns none
+ *
+ * The result is updated in place to improve performance (no allocation)
+ *   result.type:
+ *     0: coplanar-front
+ *     1: coplanar-back
+ *     2: front
+ *     3: back
+ *     4: spanning
+ *
+ * In case the polygon is spanning (4)
+ *   result.front contains null or a ploygon (front part)
+ *   result.back contains null or a polygon (back part)
+ */
+export const splitPolygonByPlane = (result, splane, polygon) => {
   const vertices = polygon.vertices
   const numVertices = vertices.length
   const pplane = poly3.plane(polygon)
@@ -41,17 +45,20 @@ export const splitPolygonByPlane = (splane, polygon) => {
       if (t > EPS) hasFront = true
       if (t < MINEPS) hasBack = true
     }
+
     if ((!hasFront) && (!hasBack)) {
       // all points coplanar
       const t = vec3.dot(splane, pplane)
       result.type = (t >= 0) ? 0 : 1
     } else if (!hasBack) {
+      // points only front of the plane
       result.type = 2
     } else if (!hasFront) {
+      // points only back of the plane
       result.type = 3
     } else {
-      // spanning
-      result.type = 4
+      // points span the plane
+      // split the line segments by the plane
       const frontVertices = []
       const backVertices = []
       let isback = vertexIsBack[0]
@@ -61,14 +68,10 @@ export const splitPolygonByPlane = (splane, polygon) => {
         if (nextVertexIndex >= numVertices) nextVertexIndex = 0
         const nextIsBack = vertexIsBack[nextVertexIndex]
         if (isback === nextIsBack) {
-          // line segment is on one side of the plane:
-          if (isback) {
-            backVertices.push(vertex)
-          } else {
-            frontVertices.push(vertex)
-          }
+          // line segment is on one side of the plane
+          isback ? backVertices.push(vertex) : frontVertices.push(vertex)
         } else {
-          // line segment intersects plane:
+          // line segment spans the plane
           const nextPoint = vertices[nextVertexIndex]
           const intersectionPoint = splitLineSegmentByPlane(splane, vertex, nextPoint)
           if (isback) {
@@ -82,8 +85,9 @@ export const splitPolygonByPlane = (splane, polygon) => {
           }
         }
         isback = nextIsBack
-      } // for vertexIndex
-      // remove duplicate vertices:
+      }
+
+      // remove duplicate vertices
       const EPS_SQUARED = EPS * EPS
       if (backVertices.length >= 3) {
         let prevVertex = backVertices[backVertices.length - 1]
@@ -107,12 +111,13 @@ export const splitPolygonByPlane = (splane, polygon) => {
           prevVertex = vertex
         }
       }
-      if (frontVertices.length >= 3) {
-        result.front = poly3.fromVerticesAndPlane(frontVertices, pplane)
-      }
-      if (backVertices.length >= 3) {
-        result.back = poly3.fromVerticesAndPlane(backVertices, pplane)
-      }
+
+      // assemble the result
+      result.type = 4
+
+      result.front = frontVertices.length >= 3 ? poly3.fromVerticesAndPlane(frontVertices, pplane) : null
+
+      result.back = backVertices.length >= 3 ? poly3.fromVerticesAndPlane(backVertices, pplane) : null
     }
   }
   return result

package/src/operations/extrusions/extrudeWalls.js

@@ -25,10 +25,11 @@ const repartitionEdges = (newLength, edges) => {
   }
 
   const divisor = vec3.fromValues(multiple, multiple, multiple)
+  const increment = vec3.create()
 
   const newEdges = []
   edges.forEach((edge) => {
-    const increment = vec3.subtract(vec3.create(), edge[1], edge[0])
+    vec3.subtract(increment, edge[1], edge[0])
     vec3.divide(increment, increment, divisor)
 
     // repartition the edge
@@ -48,6 +49,7 @@ const EPSAREA = (EPS * EPS / 2) * Math.sin(Math.PI / 3)
  * Extrude (build) walls between the given slices.
  * Each wall consists of two triangles, which may be invalid if slices are overlapping.
  */
+// FIXME this function should take an eps parameter
 export const extrudeWalls = (slice0, slice1) => {
   let edges0 = slice.toEdges(slice0)
   let edges1 = slice.toEdges(slice1)

package/src/operations/hulls/hullPoints2.js

@@ -17,28 +17,32 @@ export const hullPoints2 = (uniquePoints) => {
     }
   })
 
-  // gather information for sorting by polar coordinates (point, angle, distSq)
-  const points = []
-  uniquePoints.forEach((point) => {
-    // use faster fakeAtan2 instead of Math.atan2
-    const angle = fakeAtan2(point[1] - min[1], point[0] - min[0])
-    const distSq = vec2.squaredDistance(point, min)
-    points.push({ point, angle, distSq })
-  })
+  // calculations relative to min point
+  const squaredDistance = (point) => vec2.squaredDistance(point, min)
+  const polarAngle = (point) => (point[0] === min[0] && point[1] === min[1]) ? -Infinity : -(point[0] - min[0]) / (point[1] - min[1])
 
-  // sort by polar coordinates
-  points.sort((pt1, pt2) => pt1.angle !== pt2.angle
-    ? pt1.angle - pt2.angle
-    : pt1.distSq - pt2.distSq)
+  // points are sorted by polar angle in clockwise order
+  const sorted = uniquePoints
+  sorted.sort((pt1, pt2) => {
+    const pa1 = polarAngle(pt1)
+    const pa2 = polarAngle(pt2)
+    if (pa1 === pa2) {
+      // sort by the relative distances to min point
+      return squaredDistance(pt1) - squaredDistance(pt2)
+    }
+    // sort by polar angles to min point
+    return pa1 - pa2
+  })
 
   const stack = [] // start with empty stack
-  points.forEach((point) => {
+  sorted.forEach((point) => {
     let cnt = stack.length
-    while (cnt > 1 && ccw(stack[cnt - 2], stack[cnt - 1], point.point) <= Number.EPSILON) {
-      stack.pop() // get rid of colinear and interior (clockwise) points
+    while (cnt > 1 && ccw(stack[cnt - 2], stack[cnt - 1], point) <= Number.EPSILON) {
+      // get rid of colinear and interior (clockwise) points
+      stack.pop()
       cnt = stack.length
     }
-    stack.push(point.point)
+    stack.push(point)
   })
 
   return stack
@@ -46,15 +50,3 @@ export const hullPoints2 = (uniquePoints) => {
 
 // returns: < 0 clockwise, 0 colinear, > 0 counter-clockwise
 const ccw = (v1, v2, v3) => (v2[0] - v1[0]) * (v3[1] - v1[1]) - (v2[1] - v1[1]) * (v3[0] - v1[0])
-
-// Returned "angle" is really 1/tan (inverse of slope) made negative to increase with angle.
-// This function is strictly for sorting in this algorithm.
-const fakeAtan2 = (y, x) => {
-  // The "if" is a special case for when the minimum vector found in loop above is present.
-  // We need to ensure that it sorts as the minimum point. Otherwise, this becomes NaN.
-  if (y === 0 && x === 0) {
-    return -Infinity
-  } else {
-    return -x / y
-  }
-}

package/src/operations/modifiers/mergePolygons.js

@@ -67,7 +67,6 @@ const calculateAngle = (prevVertex, midVertex, nextVertex, normal) => {
 
 // create a polygon starting from the given edge (if possible)
 const createPolygonAnd = (edge) => {
-  let polygon
   const vertices = []
   while (edge.next) {
     const next = edge.next
@@ -81,8 +80,8 @@ const createPolygonAnd = (edge) => {
 
     edge = next
   }
-  if (vertices.length > 0) polygon = poly3.create(vertices)
-  return polygon
+  if (vertices.length > 0) return poly3.create(vertices)
+  return null
 }
 
 /*

package/src/operations/modifiers/reTesselateCoplanarPolygons.js

@@ -31,7 +31,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
   // Make a list of all encountered y coordinates
   // And build a map of all polygons that have a vertex at a certain y coordinate:
   const yCoordinateBins = new Map()
-  const yCoordinateBinningFactor = 10 / EPS
+  const yCoordinateBinningFactor = 10 / EPS // FIXME
   for (let polygonIndex = 0; polygonIndex < numPolygons; polygonIndex++) {
     const poly3d = sourcePolygons[polygonIndex]
     let vertices2d = []
@@ -68,7 +68,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
         }
         let polygonIndexes = yCoordinateToPolygonIndexes.get(y)
         if (!polygonIndexes) {
-          polygonIndexes = {} // PERF
+          polygonIndexes = []
           yCoordinateToPolygonIndexes.set(y, polygonIndexes)
         }
         polygonIndexes[polygonIndex] = true
@@ -242,7 +242,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
         const prevOutPolygon = newOutPolygonRow[newOutPolygonRow.length - 1]
         const d1 = vec2.distance(outPolygon.topLeft, prevOutPolygon.topRight)
         const d2 = vec2.distance(outPolygon.bottomLeft, prevOutPolygon.bottomRight)
-        if ((d1 < EPS) && (d2 < EPS)) {
+        if ((d1 < EPS) && (d2 < EPS)) { // FIXME
           // we can join this polygon with the one to the left:
           outPolygon.topLeft = prevOutPolygon.topLeft
           outPolygon.leftLine = prevOutPolygon.leftLine
@@ -263,8 +263,8 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
             // We have a match if the sidelines are equal or if the top coordinates
             // are on the sidelines of the previous polygon
             const prevPolygon = prevOutPolygonRow[ii]
-            if (vec2.distance(prevPolygon.bottomLeft, thisPolygon.topLeft) < EPS) {
-              if (vec2.distance(prevPolygon.bottomRight, thisPolygon.topRight) < EPS) {
+            if (vec2.distance(prevPolygon.bottomLeft, thisPolygon.topLeft) < EPS) { // FIXME
+              if (vec2.distance(prevPolygon.bottomRight, thisPolygon.topRight) < EPS) { // FIXME
                 // Yes, the top of this polygon matches the bottom of the previous:
                 matchedIndexes.add(ii)
                 // Now check if the joined polygon would remain convex:
@@ -300,7 +300,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
           // Finish the polygon with the last point(s):
           const prevPolygon = prevOutPolygonRow[ii]
           prevPolygon.outPolygon.rightPoints.push(prevPolygon.bottomRight)
-          if (vec2.distance(prevPolygon.bottomRight, prevPolygon.bottomLeft) > EPS) {
+          if (vec2.distance(prevPolygon.bottomRight, prevPolygon.bottomLeft) > EPS) { // FIXME
             // polygon ends with a horizontal line:
             prevPolygon.outPolygon.leftPoints.push(prevPolygon.bottomLeft)
           }
@@ -324,7 +324,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
           rightPoints: []
         }
         thisPolygon.outPolygon.leftPoints.push(thisPolygon.topLeft)
-        if (vec2.distance(thisPolygon.topLeft, thisPolygon.topRight) > EPS) {
+        if (vec2.distance(thisPolygon.topLeft, thisPolygon.topRight) > EPS) { // FIXME
           // we have a horizontal line at the top:
           thisPolygon.outPolygon.rightPoints.push(thisPolygon.topRight)
         }