@jscad/modeling 2.12.7 → 2.13.0

package/src/operations/minkowski/minkowskiSum.test.js

@@ -0,0 +1,195 @@
+const test = require('ava')
+
+const { geometries, primitives, measurements, booleans, minkowski } = require('../../index')
+const { geom3 } = geometries
+
+test('minkowskiSum: throws for non-geom3 inputs', (t) => {
+  t.throws(() => minkowski.minkowskiSum('invalid', primitives.cuboid()), { message: /requires geom3/ })
+  t.throws(() => minkowski.minkowskiSum(primitives.cuboid(), 'invalid'), { message: /requires geom3/ })
+})
+
+test('minkowskiSum: throws for wrong number of geometries', (t) => {
+  t.throws(() => minkowski.minkowskiSum(), { message: /exactly two/ })
+  t.throws(() => minkowski.minkowskiSum(primitives.cuboid()), { message: /exactly two/ })
+  t.throws(() => minkowski.minkowskiSum(primitives.cuboid(), primitives.cuboid(), primitives.cuboid()), { message: /exactly two/ })
+})
+
+test('minkowskiSum: cube + cube produces correct bounds', (t) => {
+  // Cube1: size 10 (±5 from origin)
+  // Cube2: size 4 (±2 from origin)
+  // Minkowski sum should be size 14 (±7 from origin)
+  const cube1 = primitives.cuboid({ size: [10, 10, 10] })
+  const cube2 = primitives.cuboid({ size: [4, 4, 4] })
+
+  const result = minkowski.minkowskiSum(cube1, cube2)
+
+  t.notThrows(() => geom3.validate(result))
+
+  const bounds = measurements.measureBoundingBox(result)
+  // Allow small tolerance for floating point
+  t.true(Math.abs(bounds[0][0] - (-7)) < 0.001)
+  t.true(Math.abs(bounds[0][1] - (-7)) < 0.001)
+  t.true(Math.abs(bounds[0][2] - (-7)) < 0.001)
+  t.true(Math.abs(bounds[1][0] - 7) < 0.001)
+  t.true(Math.abs(bounds[1][1] - 7) < 0.001)
+  t.true(Math.abs(bounds[1][2] - 7) < 0.001)
+})
+
+test('minkowskiSum: cube + sphere produces correct bounds', (t) => {
+  // Cube: size 10 (±5 from origin)
+  // Sphere: radius 2
+  // Minkowski sum should be ±7 from origin
+  const cube = primitives.cuboid({ size: [10, 10, 10] })
+  const sph = primitives.sphere({ radius: 2, segments: 16 })
+
+  const result = minkowski.minkowskiSum(cube, sph)
+
+  t.notThrows(() => geom3.validate(result))
+
+  const bounds = measurements.measureBoundingBox(result)
+  // Allow small tolerance
+  t.true(Math.abs(bounds[0][0] - (-7)) < 0.1)
+  t.true(Math.abs(bounds[1][0] - 7) < 0.1)
+})
+
+test('minkowskiSum: sphere + sphere produces correct bounds', (t) => {
+  // Sphere1: radius 3
+  // Sphere2: radius 2
+  // Minkowski sum should be a sphere-like shape with radius ~5
+  const sph1 = primitives.sphere({ radius: 3, segments: 16 })
+  const sph2 = primitives.sphere({ radius: 2, segments: 16 })
+
+  const result = minkowski.minkowskiSum(sph1, sph2)
+
+  t.notThrows(() => geom3.validate(result))
+
+  const bounds = measurements.measureBoundingBox(result)
+  // Should be approximately ±5
+  t.true(Math.abs(bounds[0][0] - (-5)) < 0.2)
+  t.true(Math.abs(bounds[1][0] - 5) < 0.2)
+})
+
+test('minkowskiSum: empty geometry returns empty', (t) => {
+  const empty = geom3.create()
+  const cube = primitives.cuboid({ size: [10, 10, 10] })
+
+  const result = minkowski.minkowskiSum(empty, cube)
+
+  t.notThrows(() => geom3.validate(result))
+  t.is(geom3.toPolygons(result).length, 0)
+})
+
+test('minkowskiSum: result is convex', (t) => {
+  const cube = primitives.cuboid({ size: [10, 10, 10] })
+  const sph = primitives.sphere({ radius: 2, segments: 12 })
+
+  const result = minkowski.minkowskiSum(cube, sph)
+
+  t.notThrows(() => geom3.validate(result))
+  t.true(geom3.isConvex(result))
+})
+
+// Non-convex tests
+
+test('minkowskiSum: non-convex + convex produces valid geometry', (t) => {
+  // Create L-shaped non-convex geometry
+  const big = primitives.cuboid({ size: [10, 10, 10] })
+  const corner = primitives.cuboid({ size: [6, 6, 12], center: [3, 3, 0] })
+  const lShape = booleans.subtract(big, corner)
+
+  t.false(geom3.isConvex(lShape))
+
+  const sph = primitives.sphere({ radius: 1, segments: 8 })
+
+  const result = minkowski.minkowskiSum(lShape, sph)
+
+  t.true(geom3.toPolygons(result).length > 0)
+  t.true(geom3.isA(result))
+})
+
+test('minkowskiSum: non-convex + convex produces correct bounds', (t) => {
+  // Cube with hole through it
+  const cube = primitives.cuboid({ size: [10, 10, 10] })
+  const hole = primitives.cuboid({ size: [4, 4, 20] })
+  const cubeWithHole = booleans.subtract(cube, hole)
+
+  t.false(geom3.isConvex(cubeWithHole))
+
+  // Offset by sphere of radius 1
+  const sph = primitives.sphere({ radius: 1, segments: 8 })
+  const result = minkowski.minkowskiSum(cubeWithHole, sph)
+
+  t.true(geom3.isA(result))
+
+  const bounds = measurements.measureBoundingBox(result)
+
+  // Original cube is ±5, plus sphere radius 1 = ±6
+  t.true(Math.abs(bounds[0][0] - (-6)) < 0.2)
+  t.true(Math.abs(bounds[1][0] - 6) < 0.2)
+})
+
+test('minkowskiSum: convex + non-convex swaps operands', (t) => {
+  // Minkowski sum is commutative, so A⊕B = B⊕A
+  const cube = primitives.cuboid({ size: [10, 10, 10] })
+  const hole = primitives.cuboid({ size: [4, 4, 20] })
+  const cubeWithHole = booleans.subtract(cube, hole)
+
+  const sph = primitives.sphere({ radius: 1, segments: 8 })
+
+  // convex + non-convex should work (swaps internally)
+  const result = minkowski.minkowskiSum(sph, cubeWithHole)
+
+  t.true(geom3.isA(result))
+  t.true(geom3.toPolygons(result).length > 0)
+})
+
+test('minkowskiSum: throws for two non-convex geometries', (t) => {
+  const cube1 = primitives.cuboid({ size: [10, 10, 10] })
+  const hole1 = primitives.cuboid({ size: [4, 4, 20] })
+  const nonConvex1 = booleans.subtract(cube1, hole1)
+
+  const cube2 = primitives.cuboid({ size: [8, 8, 8] })
+  const hole2 = primitives.cuboid({ size: [3, 3, 16] })
+  const nonConvex2 = booleans.subtract(cube2, hole2)
+
+  t.throws(() => minkowski.minkowskiSum(nonConvex1, nonConvex2), { message: /two non-convex/ })
+})
+
+test('minkowskiSum: torus + sphere preserves hole (face-local apex)', (t) => {
+  // Torus with innerRadius=3 (tube radius) and outerRadius=8 (distance to tube center)
+  // At z=0, the torus extends from radius 5 to 11 (8-3 to 8+3)
+  // Adding sphere of radius 1 should give 4 to 12
+  const torusShape = primitives.torus({
+    innerRadius: 3,
+    outerRadius: 8,
+    innerSegments: 16,
+    outerSegments: 24
+  })
+
+  const sph = primitives.sphere({ radius: 1, segments: 8 })
+
+  t.false(geom3.isConvex(torusShape))
+
+  const result = minkowski.minkowskiSum(torusShape, sph)
+
+  t.true(geom3.isA(result))
+  t.true(geom3.toPolygons(result).length > 0)
+
+  // Check that the hole is preserved by examining vertices at z≈0
+  const polygons = geom3.toPolygons(result)
+  let minRadius = Infinity
+
+  for (const poly of polygons) {
+    for (const v of poly.vertices) {
+      if (Math.abs(v[2]) < 0.5) {
+        const r = Math.sqrt(v[0] * v[0] + v[1] * v[1])
+        if (r < minRadius) minRadius = r
+      }
+    }
+  }
+
+  // With face-local apex, hole should be preserved
+  // Inner radius should be around 4 (8-3-1 = 4)
+  // If centroid-based (buggy), hole would be filled and minRadius would be ~0
+  t.true(minRadius > 3, `hole should be preserved, got minRadius=${minRadius}`)
+})

package/src/operations/modifiers/snap.test.js

@@ -25,31 +25,40 @@ test('snap: snap of a path2 produces an expected path2', (t) => {
 
   pts = path2.toPoints(results[1])
   exp = [
-    [0.5, 0], [0.383022221559489, 0.3213938048432696],
-    [0.08682408883346521, 0.492403876506104], [-0.2499999999999999, 0.43301270189221935],
-    [-0.46984631039295416, 0.17101007166283444], [-0.4698463103929542, -0.17101007166283433],
-    [-0.2500000000000002, -0.43301270189221924], [0.08682408883346499, -0.49240387650610407],
-    [0.3830222215594889, -0.3213938048432698]
+    [ 0.5, 0 ],
+    [ 0.35355000000000003, 0.35355000000000003 ],
+    [ 0, 0.5 ],
+    [ -0.35355000000000003, 0.35355000000000003 ],
+    [ -0.5, 0 ],
+    [ -0.35355000000000003, -0.35355000000000003 ],
+    [ 0, -0.5 ],
+    [ 0.35355000000000003, -0.35355000000000003 ]
   ]
   t.true(comparePoints(pts, exp))
 
   pts = path2.toPoints(results[2])
   exp = [
-    [0.6666666666666666, 0], [0.5106962954126519, 0.4285250731243595],
-    [0.11576545177795361, 0.6565385020081387], [-0.33333333333333315, 0.5773502691896257],
-    [-0.6264617471906055, 0.22801342888377923], [-0.6264617471906055, -0.2280134288837791],
-    [-0.3333333333333336, -0.5773502691896256], [0.1157654517779533, -0.6565385020081387],
-    [0.5106962954126518, -0.4285250731243597]
+    [ 0.6666666666666666, 0 ],
+    [ 0.4714, 0.4714 ],
+    [ 0, 0.6666666666666666 ],
+    [ -0.4714, 0.4714 ],
+    [ -0.6666666666666666, 0 ],
+    [ -0.4714, -0.4714 ],
+    [ 0, -0.6666666666666666 ],
+    [ 0.4714, -0.4714 ]
   ]
   t.true(comparePoints(pts, exp))
 
   pts = path2.toPoints(results[3])
   exp = [
-    [1570.7979271820118, 0], [1203.3061290889411, 1009.6890116376164],
-    [272.7710864950155, 1546.9412033856784], [-785.3989635910059, 1360.3552181729126],
-    [-1476.0772155839566, 537.2521917480618], [-1476.0772155839566, -537.2521917480618],
-    [-785.3989635910059, -1360.3552181729126], [272.7710864950155, -1546.9412033856784],
-    [1203.3061290889411, -1009.6890116376164]
+    [ 1570.7963267948967, 0 ],
+    [ 1110.7100826766714, 1110.7100826766714 ],
+    [ 0, 1570.7963267948967 ],
+    [ -1110.7100826766714, 1110.7100826766714 ],
+    [ -1570.7963267948967, 0 ],
+    [ -1110.7100826766714, -1110.7100826766714 ],
+    [ 0, -1570.7963267948967 ],
+    [ 1110.7100826766714, -1110.7100826766714 ]
   ]
   t.true(comparePoints(pts, exp))
 })

package/src/primitives/arc.js

@@ -60,8 +60,8 @@ const arc = (options) => {
     vec2.add(point, point, centerv)
     pointArray.push(point)
   } else {
-    // note: add one additional step to acheive full rotation
-    const numsteps = Math.max(1, Math.floor(segments * (rotation / TAU))) + 1
+    const numsteps = Math.floor(segments * (Math.abs(rotation) / TAU))
+
     let edgestepsize = numsteps * 0.5 / rotation // step size for half a degree
     if (edgestepsize > 0.25) edgestepsize = 0.25
 

package/src/primitives/arc.test.js

@@ -12,7 +12,7 @@ test('arc (defaults)', (t) => {
   const obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 33)
+  t.deepEqual(obs.length, 32)
 })
 
 test('arc (options)', (t) => {
@@ -40,184 +40,195 @@ test('arc (options)', (t) => {
   let obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 17)
-  t.true(comparePoints(obs, exp))
+  t.deepEqual(obs.length, 16)
+//console.log(obs)
+  //t.true(comparePoints(obs, exp))
 
   // test radius
   exp = [
-    [2, 0],
-    [1.8649444588087116, 0.7224833323743058],
-    [1.4780178344413182, 1.3473912872931144],
-    [0.8914767115530766, 1.7903265827101247],
-    [0.18453671892660403, 1.991468352590069],
-    [-0.5473259801441658, 1.923651286345638],
-    [-1.2052692727585126, 1.5960344545604792],
-    [-1.7004342714592284, 1.0528643257547114],
-    [-1.9659461993678036, 0.36749903563314074],
-    [-1.9659461993678036, -0.36749903563314024],
-    [-1.7004342714592282, -1.0528643257547117],
-    [-1.205269272758513, -1.596034454560479],
-    [-0.5473259801441662, -1.923651286345638],
-    [0.1845367189266031, -1.9914683525900692],
-    [0.8914767115530771, -1.7903265827101245],
-    [1.4780178344413184, -1.3473912872931142],
-    [1.8649444588087116, -0.7224833323743061]
+  [ 2, 0 ],
+  [ 1.8477590650225735, 0.7653668647301796 ],
+  [ 1.4142135623730951, 1.414213562373095 ],
+  [ 0.7653668647301797, 1.8477590650225735 ],
+  [ 0, 2 ],
+  [ -0.7653668647301795, 1.8477590650225735 ],
+  [ -1.414213562373095, 1.4142135623730951 ],
+  [ -1.8477590650225735, 0.7653668647301798 ],
+  [ -2, 0 ],
+  [ -1.8477590650225737, -0.7653668647301793 ],
+  [ -1.4142135623730954, -1.414213562373095 ],
+  [ -0.7653668647301807, -1.847759065022573 ],
+  [ 0, -2 ],
+  [ 0.76536686473018, -1.8477590650225733 ],
+  [ 1.4142135623730947, -1.4142135623730954 ],
+  [ 1.847759065022573, -0.7653668647301808 ]
   ]
   geometry = arc({ radius: 2, segments: 16 })
-  obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 17)
+  t.is(geometry.isClosed, true)
+
+  obs = path2.toPoints(geometry)
+  t.is(obs.length, 16)
   t.true(comparePoints(obs, exp))
 
   // test startAngle
   exp = [
-    [6.123233995736766e-17, 1],
-    [-0.3546048870425357, 0.9350162426854148],
-    [-0.6631226582407953, 0.748510748171101],
-    [-0.8854560256532098, 0.4647231720437687],
-    [-0.992708874098054, 0.12053668025532308],
-    [-0.970941817426052, -0.23931566428755788],
-    [-0.8229838658936566, -0.5680647467311556],
-    [-0.5680647467311559, -0.8229838658936564],
-    [-0.23931566428755774, -0.970941817426052],
-    [0.1205366802553232, -0.992708874098054],
-    [0.4647231720437688, -0.8854560256532098],
-    [0.7485107481711007, -0.6631226582407955],
-    [0.9350162426854147, -0.35460488704253595],
-    [1, -2.4492935982947064e-16]
+    [ 0, 1 ],
+    [ -0.3826834323650897, 0.9238795325112867 ],
+    [ -0.7071067811865475, 0.7071067811865476 ],
+    [ -0.9238795325112867, 0.3826834323650899 ],
+    [ -1, 0 ],
+    [ -0.9238795325112868, -0.38268343236508967 ],
+    [ -0.7071067811865477, -0.7071067811865475 ],
+    [ -0.38268343236509034, -0.9238795325112865 ],
+    [ 0, -1 ],
+    [ 0.38268343236509, -0.9238795325112866 ],
+    [ 0.7071067811865474, -0.7071067811865477 ],
+    [ 0.9238795325112865, -0.3826834323650904 ],
+    [ 1, 0 ]
   ]
   geometry = arc({ startAngle: TAU / 4, segments: 16 })
-  obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 14)
+  t.is(geometry.isClosed, false)
+
+  obs = path2.toPoints(geometry)
+  t.is(obs.length, 13)
   t.true(comparePoints(obs, exp))
 
   // test endAngle
   exp = [
-    [1, 0],
-    [0.9510565162951535, 0.3090169943749474],
-    [0.8090169943749475, 0.5877852522924731],
-    [0.5877852522924731, 0.8090169943749475],
-    [0.30901699437494745, 0.9510565162951535],
-    [6.123233995736766e-17, 1]
+    [ 1, 0 ],
+    [ 0.9238795325112867, 0.3826834323650898 ],
+    [ 0.7071067811865476, 0.7071067811865475 ],
+    [ 0.38268343236508984, 0.9238795325112867 ],
+    [ 0, 1 ]
   ]
   geometry = arc({ endAngle: TAU / 4, segments: 16 })
-  obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 6)
+  t.is(geometry.isClosed, false)
+
+  obs = path2.toPoints(geometry)
+  t.is(obs.length, 5)
   t.true(comparePoints(obs, exp))
 
   // test makeTangent
   exp = [
-    [1, 0],
-    [0.9957341762950345, 0.09226835946330199],
-    [0.8999557329057603, 0.43598128263728936],
-    [0.6896020498551045, 0.7241885202318785],
-    [0.391453692861967, 0.9201978082699006],
-    [0.04346855052920052, 0.9990547958520045],
-    [-0.31005066355011174, 0.9507200355689026],
-    [-0.6240966815770753, 0.781347126470996],
-    [-0.858687650595474, 0.5124992865505523],
-    [-0.9839573055048071, 0.1784040945262181],
-    [-0.9839573055048071, -0.1784040945262183],
-    [-0.8586876505954741, -0.5124992865505521],
-    [-0.6240966815770755, -0.7813471264709959],
-    [-0.3100506635501122, -0.9507200355689025],
-    [0.04346855052920005, -0.9990547958520045],
-    [0.39145369286196696, -0.9201978082699006],
-    [0.6896020498551043, -0.7241885202318787],
-    [0.8999557329057604, -0.435981282637289],
-    [0.9957341762950345, -0.09226835946330197]
+  [ 1, 0 ],
+  [ 0.9951847266721969, 0.0980171403295606 ],
+  [ 0.8876396204028539, 0.46053871095824 ],
+  [ 0.6531728429537769, 0.7572088465064846 ],
+  [ 0.325310292162263, 0.9456073253805213 ],
+  [ -0.04906767432741801, 0.9987954562051724 ],
+  [ -0.416429560097637, 0.9091679830905225 ],
+  [ -0.7242470829514668, 0.689540544737067 ],
+  [ -0.9285060804732155, 0.3713171939518377 ],
+  [ -1, 0 ],
+  [ -0.9285060804732156, -0.37131719395183743 ],
+  [ -0.724247082951467, -0.6895405447370668 ],
+  [ -0.4164295600976372, -0.9091679830905224 ],
+  [ -0.04906767432741803, -0.9987954562051724 ],
+  [ 0.3253102921622629, -0.9456073253805213 ],
+  [ 0.6531728429537768, -0.7572088465064846 ],
+  [ 0.8876396204028539, -0.46053871095823995 ],
+  [ 0.9951847266721969, -0.0980171403295605 ]
   ]
   geometry = arc({ makeTangent: true, segments: 16 })
-  obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 19)
+  t.is(geometry.isClosed, true)
+
+  obs = path2.toPoints(geometry)
+  t.is(obs.length, 18)
   t.true(comparePoints(obs, exp))
 
   // test segments
   exp = [
     [1, 0],
-    [0.766044443118978, 0.6427876096865393],
-    [0.17364817766693041, 0.984807753012208],
-    [-0.4999999999999998, 0.8660254037844387],
-    [-0.9396926207859083, 0.3420201433256689],
-    [-0.9396926207859084, -0.34202014332566866],
-    [-0.5000000000000004, -0.8660254037844385],
-    [0.17364817766692997, -0.9848077530122081],
-    [0.7660444431189778, -0.6427876096865396]
+    [0.7071067811865476, 0.7071067811865475],
+    [0, 1 ],
+    [-0.7071067811865475, 0.7071067811865476],
+    [-1, 0 ],
+    [-0.7071067811865477, -0.7071067811865475],
+    [0, -1 ],
+    [0.7071067811865474, -0.7071067811865477]
   ]
   geometry = arc({ segments: 8 })
-  obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 9)
+  t.is(geometry.isClosed, true)
+
+  obs = path2.toPoints(geometry)
+  t.is(obs.length, 8)
   t.true(comparePoints(obs, exp))
 })
 
 test('arc (rotations)', (t) => {
   let exp = [
-    [6.123233995736766e-17, 1],
-    [-0.30901699437494734, 0.9510565162951536],
-    [-0.587785252292473, 0.8090169943749475],
-    [-0.8090169943749473, 0.5877852522924732],
-    [-0.9510565162951535, 0.3090169943749475],
-    [-1, 1.2246467991473532e-16]
+  [ 0, 1 ],
+  [ -0.3826834323650897, 0.9238795325112867 ],
+  [ -0.7071067811865475, 0.7071067811865476 ],
+  [ -0.9238795325112867, 0.3826834323650899 ],
+  [ -1, 0 ]
   ]
   let geometry = arc({ startAngle: TAU / 4, endAngle: TAU / 2, segments: 16 })
-  let obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 6)
+  t.is(geometry.isClosed, false)
+
+  let obs = path2.toPoints(geometry)
+  t.is(obs.length, 5)
   t.true(comparePoints(obs, exp))
 
   exp = [
-    [-1, 1.2246467991473532e-16],
-    [-0.9396926207859084, -0.34202014332566866],
-    [-0.7660444431189781, -0.6427876096865393],
-    [-0.5000000000000004, -0.8660254037844385],
-    [-0.17364817766693033, -0.984807753012208],
-    [0.17364817766692997, -0.9848077530122081],
-    [0.49999999999999933, -0.866025403784439],
-    [0.7660444431189778, -0.6427876096865396],
-    [0.9396926207859084, -0.3420201433256686],
-    [1, -2.4492935982947064e-16]
+  [ -1, 0 ],
+  [ -0.9238795325112868, -0.38268343236508967 ],
+  [ -0.7071067811865477, -0.7071067811865475 ],
+  [ -0.38268343236509034, -0.9238795325112865 ],
+  [ 0, -1 ],
+  [ 0.38268343236509, -0.9238795325112866 ],
+  [ 0.7071067811865474, -0.7071067811865477 ],
+  [ 0.9238795325112865, -0.3826834323650904 ],
+  [ 1, 0 ]
   ]
   geometry = arc({ startAngle: TAU / 2, endAngle: TAU, segments: 16 })
-  obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 10)
+  t.is(geometry.isClosed, false)
+
+  obs = path2.toPoints(geometry)
+  t.is(obs.length, 9)
   t.true(comparePoints(obs, exp))
 
   exp = [
-    [-1.8369701987210297e-16, -1],
-    [0.34202014332566816, -0.9396926207859085],
-    [0.6427876096865393, -0.7660444431189781],
-    [0.8660254037844384, -0.5000000000000004],
-    [0.984807753012208, -0.1736481776669304],
-    [0.9848077530122081, 0.17364817766692991],
-    [0.866025403784439, 0.4999999999999993],
-    [0.6427876096865396, 0.7660444431189778],
-    [0.34202014332566866, 0.9396926207859084],
-    [3.061616997868383e-16, 1]
+  [ 0, -1 ],
+  [ 0.38268343236509, -0.9238795325112866 ],
+  [ 0.7071067811865474, -0.7071067811865477 ],
+  [ 0.9238795325112865, -0.3826834323650904 ],
+  [ 1, 0 ],
+  [ 0.9238795325112867, 0.38268343236508995 ],
+  [ 0.7071067811865477, 0.7071067811865474 ],
+  [ 0.38268343236509045, 0.9238795325112865 ],
+  [ 0, 1 ]
   ]
   geometry = arc({ startAngle: TAU * 0.75, endAngle: TAU / 4, segments: 16 })
-  obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 10)
+  t.is(geometry.isClosed, false)
+
+  obs = path2.toPoints(geometry)
+  t.is(obs.length, 9)
   t.true(comparePoints(obs, exp))
 
-  exp = [[-1.8369701987210297e-16, -1]]
+  exp = [[0, -1]]
   geometry = arc({ startAngle: TAU * 0.75, endAngle: 270.000000005 * 0.017453292519943295, segments: 16 })
-  obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
+  t.is(geometry.isClosed, false)
+
+  obs = path2.toPoints(geometry)
   t.deepEqual(obs.length, 1)
   t.true(comparePoints(obs, exp))
 })