feat(modeling): preserve color for offset and extrude

Author: platypii

packages/modeling/src/geometries/geom2/reverse.js

@@ -13,5 +13,6 @@ import { clone } from './clone.js'
 export const reverse = (geometry) => {
   const reversed = clone(geometry)
   reversed.outlines = reversed.outlines.map((outline) => outline.slice().reverse())
+  if (geometry.color) reversed.color = geometry.color
   return reversed
 }

packages/modeling/src/geometries/geom2/reverse.test.js

@@ -29,3 +29,10 @@ test('reverse: does not modify input geometry', (t) => {
   t.true(comparePoints(toPoints(geometry), forward))
   t.true(comparePoints(toPoints(another), backward))
 })
+
+test('reverse: preserves color', (t) => {
+  const points = [[0, 0], [1, 0], [0, 1]]
+  const geometry = colorize([1, 0, 0], create([points]))
+  const reversed = reverse(geometry)
+  t.deepEqual(reversed.color, [1, 0, 0, 1])
+})

packages/modeling/src/operations/extrusions/extrudeLinear.test.js

@@ -4,6 +4,8 @@ import { comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
 import { TAU } from '../../maths/constants.js'
 
+import { colorize } from '../../colors/index.js'
+
 import { geom2, geom3, path2 } from '../../geometries/index.js'
 
 import { measureVolume } from '../../measurements/index.js'
@@ -37,6 +39,17 @@ test('extrudeLinear (defaults)', (t) => {
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
+test('extrudeLinear: preserves color', (t) => {
+  const red = colorize([1, 0, 0], square())
+  const extruded = extrudeLinear({ }, red)
+  t.deepEqual(extruded.color, [1, 0, 0, 1])
+
+  // one red, one blue
+  const out = extrudeLinear({ }, [red, square()])
+  t.deepEqual(out[0].color, [1, 0, 0, 1])
+  t.is(out[1].color, undefined)
+})
+
 test('extrudeLinear (no twist)', (t) => {
   const geometry2 = square({ size: 10 })
 

packages/modeling/src/operations/extrusions/extrudeLinearGeom2.js

@@ -53,5 +53,7 @@ export const extrudeLinearGeom2 = (options, geometry) => {
     repair,
     callback: createTwist
   }
-  return extrudeFromSlices(options, baseSlice)
+  const output = extrudeFromSlices(options, baseSlice)
+  if (geometry.color) output.color = geometry.color
+  return output
 }

packages/modeling/src/operations/extrusions/extrudeLinearPath2.js

@@ -18,5 +18,6 @@ export const extrudeLinearPath2 = (options, geometry) => {
   // Convert path2 to geom2
   const points = path2.toPoints(geometry)
   const geometry2 = geom2.create([points])
+  if (geometry.color) geometry2.color = geometry.color
   return extrudeLinearGeom2(options, geometry2)
 }

packages/modeling/src/operations/extrusions/extrudeRotate.js

@@ -59,6 +59,7 @@ export const extrudeRotate = (options, geometry) => {
   // convert geometry to an array of sides, easier to deal with
   let shapeSides = geom2.toSides(geometry)
   if (shapeSides.length === 0) throw new Error('the given geometry cannot be empty')
+  let sliceGeometry = geometry
 
   // determine if the extrusion can be computed in the first place
   // ie all the points have to be either x > 0 or x < 0
@@ -87,8 +88,8 @@ export const extrudeRotate = (options, geometry) => {
         return [point0, point1]
       })
       // recreate the geometry from the (-) capped points
-      geometry = geom2.reverse(geom2.fromSides(shapeSides))
-      geometry = mirrorX(geometry)
+      sliceGeometry = geom2.reverse(geom2.fromSides(shapeSides))
+      sliceGeometry = mirrorX(sliceGeometry)
     } else if (pointsWithPositiveX.length >= pointsWithNegativeX.length) {
       shapeSides = shapeSides.map((side) => {
         let point0 = side[0]
@@ -98,13 +99,13 @@ export const extrudeRotate = (options, geometry) => {
         return [point0, point1]
       })
       // recreate the geometry from the (+) capped points
-      geometry = geom2.fromSides(shapeSides)
+      sliceGeometry = geom2.fromSides(shapeSides)
     }
   }
 
   const rotationPerSlice = totalRotation / segments
   const isCapped = Math.abs(totalRotation) < TAU
-  let baseSlice = slice.fromGeom2(geometry)
+  let baseSlice = slice.fromGeom2(sliceGeometry)
   baseSlice = slice.reverse(baseSlice)
 
   const matrix = mat4.create()
@@ -126,5 +127,7 @@ export const extrudeRotate = (options, geometry) => {
     close: !isCapped,
     callback: createSlice
   }
-  return extrudeFromSlices(options, baseSlice)
+  const output = extrudeFromSlices(options, baseSlice)
+  if (geometry.color) output.color = geometry.color
+  return output
 }

packages/modeling/src/operations/extrusions/extrudeRotate.test.js

@@ -4,10 +4,14 @@ import { comparePoints, comparePolygonsAsPoints } from '../../../test/helpers/in
 
 import { TAU } from '../../maths/constants.js'
 
+import { colorize } from '../../colors/index.js'
+
 import { geom2, geom3 } from '../../geometries/index.js'
 
 import { measureVolume } from '../../measurements/index.js'
 
+import { square } from '../../primitives/index.js'
+
 import { extrudeRotate } from './index.js'
 
 test('extrudeRotate: (defaults) extruding of a geom2 produces an expected geom3', (t) => {
@@ -20,6 +24,12 @@ test('extrudeRotate: (defaults) extruding of a geom2 produces an expected geom3'
   t.is(pts.length, 96)
 })
 
+test('extrudeRotate: preserves color', (t) => {
+  const red = colorize([1, 0, 0], square())
+  const extruded = extrudeRotate({ }, red)
+  t.deepEqual(extruded.color, [1, 0, 0, 1])
+})
+
 test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (t) => {
   const geometry2 = geom2.create([[[10, 8], [10, -8], [26, -8], [26, 8]]])
 

packages/modeling/src/operations/offsets/offsetGeom2.js

@@ -46,7 +46,10 @@ export const offsetGeom2 = (options, geometry) => {
     }
     return offsetFromPoints(options, outline)
   })
+  // TODO: union outlines that expanded into each other
 
   // create a composite geometry from the new outlines
-  return geom2.create(newOutlines)
+  const output = geom2.create(newOutlines)
+  if (geometry.color) output.color = geometry.color
+  return output
 }

packages/modeling/src/operations/offsets/offsetGeom2.test.js

@@ -1,9 +1,8 @@
 import test from 'ava'
 
+import { colorize } from '../../colors/index.js'
 import { geom2 } from '../../geometries/index.js'
-
 import { measureArea } from '../../measurements/index.js'
-
 import { roundedRectangle, square } from '../../primitives/index.js'
 
 import { offset } from './index.js'
@@ -12,12 +11,10 @@ import { comparePoints } from '../../../test/helpers/index.js'
 
 test('offset: offset an empty geom2', (t) => {
   const empty = geom2.create()
-  const obs = offset({ delta: 1 }, empty)
-  const pts = geom2.toPoints(obs)
-  const exp = []
-  t.notThrows(() => geom2.validate(obs))
-  t.is(measureArea(obs), 0)
-  t.true(comparePoints(pts, exp))
+  const result = offset({ delta: 1 }, empty)
+  t.notThrows(() => geom2.validate(result))
+  t.is(measureArea(result), 0)
+  t.is(geom2.toPoints(result).length, 0)
 })
 
 test('offset: offset option validation', (t) => {
@@ -38,6 +35,12 @@ test('offset: offset option validation', (t) => {
   t.throws(() => offset({ corners: 'fluffy' }, empty), { message: 'corners must be "edge", "chamfer", or "round"' })
 })
 
+test('offset: offset geom2 preserves color', (t) => {
+  const geometry = colorize([1, 0, 0], square({ }))
+  const result = offset({ }, geometry)
+  t.deepEqual(result.color, [1, 0, 0, 1])
+})
+
 test('offset: offset of a geom2 produces expected changes to points', (t) => {
   const geometry = square({ size: 16 })
 

packages/modeling/src/operations/offsets/offsetGeom3.js

@@ -25,10 +25,9 @@ export const offsetGeom3 = (options, geometry) => {
     throw new Error('corners must be "round" for 3D geometries')
   }
 
-  const polygons = geom3.toPolygons(geometry)
-  if (polygons.length === 0) throw new Error('the given geometry cannot be empty')
-
   options = { delta, corners, segments }
   const expanded = offsetShell(options, geometry)
-  return union(geometry, expanded)
+  const output = union(geometry, expanded)
+  if (geometry.color) output.color = geometry.color
+  return output
 }