fix(modeling): added path3 to operations

Author: z3dev

packages/modeling/src/colors/colorize.js

@@ -1,6 +1,8 @@
 import * as geom2 from '../geometries/geom2/index.js'
 import * as geom3 from '../geometries/geom3/index.js'
 import * as path2 from '../geometries/path2/index.js'
+import * as path3 from '../geometries/path3/index.js'
+import * as slice from '../geometries/slice/index.js'
 import * as poly3 from '../geometries/poly3/index.js'
 
 const colorGeom2 = (color, object) => {
@@ -21,6 +23,18 @@ const colorPath2 = (color, object) => {
   return newPath2
 }
 
+const colorPath3 = (color, object) => {
+  const newPath3 = path3.clone(object)
+  newPath3.color = color
+  return newPath3
+}
+
+const colorSlice = (color, object) => {
+  const newSlice = slice.clone(object)
+  newSlice.color = color
+  return newSlice
+}
+
 const colorPoly3 = (color, object) => {
   const newPoly = poly3.clone(object)
   newPoly.color = color
@@ -46,9 +60,11 @@ export const colorize = (color, ...objects) => {
   if (color.length === 3) color = [color[0], color[1], color[2], 1.0] // add alpha
 
   const results = objects.map((object) => {
-    if (geom2.isA(object)) return colorGeom2(color, object)
     if (geom3.isA(object)) return colorGeom3(color, object)
+    if (geom2.isA(object)) return colorGeom2(color, object)
     if (path2.isA(object)) return colorPath2(color, object)
+    if (path3.isA(object)) return colorPath3(color, object)
+    if (slice.isA(object)) return colorSlice(color, object)
     if (poly3.isA(object)) return colorPoly3(color, object)
     if (Array.isArray(object)) return colorize(color, ...object)
 

packages/modeling/src/operations/booleans/union.js

@@ -37,7 +37,7 @@ export const union = (...geometries) => {
   }
 
   const geometry = geometries[0]
-  // if (path.isA(geometry)) return unionPath(matrix, geometries)
+  // TODO if (path2.isA(geometry)) return unionPath(geometries)
   if (geom2.isA(geometry)) return unionGeom2(geometries)
   if (geom3.isA(geometry)) return unionGeom3(geometries)
   throw new Error('union unsupported geometry type')

packages/modeling/src/operations/hulls/hull.js

@@ -42,9 +42,10 @@ export const hull = (...geometries) => {
   }
 
   const geometry = geometries[0]
-  if (path2.isA(geometry)) return hullPath2(geometries)
-  if (geom2.isA(geometry)) return hullGeom2(geometries)
   if (geom3.isA(geometry)) return hullGeom3(geometries)
+  if (geom2.isA(geometry)) return hullGeom2(geometries)
+  if (path2.isA(geometry)) return hullPath2(geometries)
+  // FIXME return geom3? if (path3.isA(geometry)) return hullPath3(geometries)
 
   // FIXME should this throw an error for unknown geometries?
   return geometry

packages/modeling/src/operations/hulls/toUniquePoints.js

@@ -1,6 +1,7 @@
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
 import * as path2 from '../../geometries/path2/index.js'
+import * as path3 from '../../geometries/path3/index.js'
 
 /*
  * Return the unique vertices of a geometry
@@ -25,6 +26,8 @@ export const toUniquePoints = (geometries) => {
       geom3.toVertices(geometry).forEach((vertices) => vertices.forEach(addPoint))
     } else if (path2.isA(geometry)) {
       path2.toPoints(geometry).forEach(addPoint)
+    } else if (path3.isA(geometry)) {
+      path3.toVertices(geometry).forEach(addPoint)
     }
   })
 

packages/modeling/src/operations/modifiers/generalize.js

@@ -3,6 +3,8 @@ import { measureEpsilon } from '../../measurements/measureEpsilon.js'
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
 import * as path2 from '../../geometries/path2/index.js'
+import * as path3 from '../../geometries/path3/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
 import { snapPolygons } from './snapPolygons.js'
 import { mergePolygons } from './mergePolygons.js'
@@ -13,6 +15,10 @@ import { triangulatePolygons } from './triangulatePolygons.js'
  */
 const generalizePath2 = (options, geometry) => geometry
 
+/*
+ */
+const generalizePath3 = (options, geometry) => geometry
+
 /*
  */
 const generalizeGeom2 = (options, geometry) => geometry
@@ -66,9 +72,10 @@ const generalizeGeom3 = (options, geometry) => {
  */
 export const generalize = (options, ...geometries) => {
   const results = geometries.map((geometry) => {
-    if (path2.isA(geometry)) return generalizePath2(options, geometry)
-    if (geom2.isA(geometry)) return generalizeGeom2(options, geometry)
     if (geom3.isA(geometry)) return generalizeGeom3(options, geometry)
+    if (geom2.isA(geometry)) return generalizeGeom2(options, geometry)
+    if (path2.isA(geometry)) return generalizePath2(options, geometry)
+    if (path3.isA(geometry)) return generalizePath3(options, geometry)
     if (Array.isArray(geometry)) return generalize(options, ...geometry)
     return geometry
   })

packages/modeling/src/operations/modifiers/snap.js

@@ -1,22 +1,38 @@
 import * as vec2 from '../../maths/vec2/index.js'
+import * as vec3 from '../../maths/vec2/index.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
 import * as path2 from '../../geometries/path2/index.js'
+import * as path3 from '../../geometries/path3/index.js'
 import * as poly2 from '../../geometries/poly2/index.js'
 
 import { measureEpsilon } from '../../measurements/measureEpsilon.js'
 
 import { snapPolygons } from './snapPolygons.js'
 
+/*
+ */
 const snapPath2 = (geometry) => {
   const epsilon = measureEpsilon(geometry)
   const points = path2.toPoints(geometry)
   const newPoints = points.map((point) => vec2.snap(vec2.create(), point, epsilon))
   // snap can produce duplicate points, remove those
-  return path2.create(newPoints)
+  return path2.fromPoints({}, newPoints)
+}
+
+/*
+ */
+const snapPath3 = (geometry) => {
+  const epsilon = measureEpsilon(geometry)
+  const vertices = path3.toVertices(geometry)
+  const newVertices = vertices.map((vertice) => vec3.snap(vec3.create(), vertice, epsilon))
+  // snap can produce duplicate points, remove those
+  return path3.fromVertices({}, newVertices)
 }
 
+/*
+ */
 const snapGeom2 = (geometry) => {
   const epsilon = measureEpsilon(geometry)
   const outlines = geom2.toOutlines(geometry)
@@ -38,6 +54,8 @@ const snapGeom2 = (geometry) => {
   return geom2.create(newOutlines)
 }
 
+/*
+ */
 const snapGeom3 = (geometry) => {
   const epsilon = measureEpsilon(geometry)
   const polygons = geom3.toPolygons(geometry)
@@ -54,9 +72,10 @@ const snapGeom3 = (geometry) => {
  */
 export const snap = (...geometries) => {
   const results = geometries.map((geometry) => {
-    if (path2.isA(geometry)) return snapPath2(geometry)
-    if (geom2.isA(geometry)) return snapGeom2(geometry)
     if (geom3.isA(geometry)) return snapGeom3(geometry)
+    if (geom2.isA(geometry)) return snapGeom2(geometry)
+    if (path2.isA(geometry)) return snapPath2(geometry)
+    if (path3.isA(geometry)) return snapPath3(geometry)
     if (Array.isArray(geometry)) return snap(...geometry)
     return geometry
   })

packages/modeling/src/utils/areAllShapesTheSameType.js

@@ -2,6 +2,8 @@
 import * as geom2 from '../geometries/geom2/index.js'
 import * as geom3 from '../geometries/geom3/index.js'
 import * as path2 from '../geometries/path2/index.js'
+import * as path3 from '../geometries/path3/index.js'
+import * as slice from '../geometries/slice/index.js'
 
 /**
  * @param {Array} shapes - list of shapes to compare
@@ -15,6 +17,8 @@ export const areAllShapesTheSameType = (shapes) => {
     if (geom2.isA(shape)) currentType = 1
     if (geom3.isA(shape)) currentType = 2
     if (path2.isA(shape)) currentType = 3
+    if (path3.isA(shape)) currentType = 4
+    if (slice.isA(shape)) currentType = 5
 
     if (previousType && currentType !== previousType) return false
     previousType = currentType