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

package/src/operations/transforms/mirror.test.js

@@ -77,11 +77,11 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
     [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
     [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
   ]
-  const geometry = geom3.fromPoints(points)
+  const geometry = geom3.fromVertices(points)
 
   // mirror about X
   let mirrored = mirror({ normal: [1, 0, 0] }, geometry)
-  let obs = geom3.toPoints(mirrored)
+  let obs = geom3.toVertices(mirrored)
   let exp = [
     [[2, 13, -12], [2, 13, 18], [2, -7, 18], [2, -7, -12]],
     [[-8, -7, 18], [-8, 13, 18], [-8, 13, -12], [-8, -7, -12]],
@@ -96,14 +96,14 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
   t.deepEqual(obs, exp)
 
   mirrored = mirrorX(geometry)
-  obs = geom3.toPoints(mirrored)
+  obs = geom3.toVertices(mirrored)
   t.notThrows(() => geom3.validate(mirrored))
   t.is(measureVolume(mirrored), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // mirror about Y
   mirrored = mirror({ normal: [0, 1, 0] }, geometry)
-  obs = geom3.toPoints(mirrored)
+  obs = geom3.toVertices(mirrored)
   exp = [
     [[-2, -13, -12], [-2, -13, 18], [-2, 7, 18], [-2, 7, -12]],
     [[8, 7, 18], [8, -13, 18], [8, -13, -12], [8, 7, -12]],
@@ -117,14 +117,14 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
   t.true(comparePolygonsAsPoints(obs, exp))
 
   mirrored = mirrorY(geometry)
-  obs = geom3.toPoints(mirrored)
+  obs = geom3.toVertices(mirrored)
   t.notThrows(() => geom3.validate(mirrored))
   t.is(measureVolume(mirrored), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // mirror about Z
   mirrored = mirror({ normal: [0, 0, 1] }, geometry)
-  obs = geom3.toPoints(mirrored)
+  obs = geom3.toVertices(mirrored)
   exp = [
     [[-2, 13, 12], [-2, 13, -18], [-2, -7, -18], [-2, -7, 12]],
     [[8, -7, -18], [8, 13, -18], [8, 13, 12], [8, -7, 12]],
@@ -138,7 +138,7 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
   t.true(comparePolygonsAsPoints(obs, exp))
 
   mirrored = mirrorZ(geometry)
-  obs = geom3.toPoints(mirrored)
+  obs = geom3.toVertices(mirrored)
   t.notThrows(() => geom3.validate(mirrored))
   t.is(measureVolume(mirrored), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))

package/src/operations/transforms/rotate.test.js

@@ -60,11 +60,11 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
     [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
     [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
   ]
-  const geometry = geom3.fromPoints(points)
+  const geometry = geom3.fromVertices(points)
 
   // rotate about X
   let rotated = rotate([TAU / 4], geometry)
-  let obs = geom3.toPoints(rotated)
+  let obs = geom3.toVertices(rotated)
   let exp = [
     [[-2, 12, -7.000000000000001], [-2, -18, -6.999999999999999],
       [-2, -18, 13.000000000000002], [-2, 12, 13]],
@@ -84,14 +84,14 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
   t.true(comparePolygonsAsPoints(obs, exp))
 
   rotated = rotateX(TAU / 4, geometry)
-  obs = geom3.toPoints(rotated)
+  obs = geom3.toVertices(rotated)
   t.notThrows(() => geom3.validate(rotated))
   t.is(measureVolume(rotated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // rotate about Y
   rotated = rotate([0, -TAU / 4], geometry)
-  obs = geom3.toPoints(rotated)
+  obs = geom3.toVertices(rotated)
   exp = [
     [[12, -7, -2.000000000000001], [-18, -7, -1.999999999999999],
       [-18, 13, -1.999999999999999], [12, 13, -2.000000000000001]],
@@ -111,14 +111,14 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
   t.true(comparePolygonsAsPoints(obs, exp))
 
   rotated = rotateY(-TAU / 4, geometry)
-  obs = geom3.toPoints(rotated)
+  obs = geom3.toVertices(rotated)
   t.notThrows(() => geom3.validate(rotated))
   t.is(measureVolume(rotated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // rotate about Z
   rotated = rotate([0, 0, TAU / 2], geometry)
-  obs = geom3.toPoints(rotated)
+  obs = geom3.toVertices(rotated)
   exp = [
     [[2.000000000000001, 7, -12], [2.000000000000001, 7, 18],
       [1.9999999999999984, -13, 18], [1.9999999999999984, -13, -12]],
@@ -138,7 +138,7 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
   t.true(comparePolygonsAsPoints(obs, exp))
 
   rotated = rotateZ(TAU / 2, geometry)
-  obs = geom3.toPoints(rotated)
+  obs = geom3.toVertices(rotated)
   t.notThrows(() => geom3.validate(rotated))
   t.is(measureVolume(rotated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))

package/src/operations/transforms/scale.test.js

@@ -77,11 +77,11 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
     [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
     [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
   ]
-  const geometry = geom3.fromPoints(points)
+  const geometry = geom3.fromVertices(points)
 
   // scale X
   let scaled = scale([3], geometry)
-  let obs = geom3.toPoints(scaled)
+  let obs = geom3.toVertices(scaled)
   let exp = [
     [[-6, -7, -12], [-6, -7, 18], [-6, 13, 18], [-6, 13, -12]],
     [[24, -7, -12], [24, 13, -12], [24, 13, 18], [24, -7, 18]],
@@ -95,14 +95,14 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
   t.true(comparePolygonsAsPoints(obs, exp))
 
   scaled = scaleX(3, geometry)
-  obs = geom3.toPoints(scaled)
+  obs = geom3.toVertices(scaled)
   t.notThrows(() => geom3.validate(scaled))
   t.is(measureVolume(scaled), 3 * measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // scale Y
   scaled = scale([1, 0.5], geometry)
-  obs = geom3.toPoints(scaled)
+  obs = geom3.toVertices(scaled)
   exp = [
     [[-2, -3.5, -12], [-2, -3.5, 18], [-2, 6.5, 18], [-2, 6.5, -12]],
     [[8, -3.5, -12], [8, 6.5, -12], [8, 6.5, 18], [8, -3.5, 18]],
@@ -116,14 +116,14 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
   t.true(comparePolygonsAsPoints(obs, exp))
 
   scaled = scaleY(0.5, geometry)
-  obs = geom3.toPoints(scaled)
+  obs = geom3.toVertices(scaled)
   t.notThrows(() => geom3.validate(scaled))
   t.is(measureVolume(scaled), 0.5 * measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // scale Z
   scaled = scale([1, 1, 5], geometry)
-  obs = geom3.toPoints(scaled)
+  obs = geom3.toVertices(scaled)
   exp = [
     [[-2, -7, -60], [-2, -7, 90], [-2, 13, 90], [-2, 13, -60]],
     [[8, -7, -60], [8, 13, -60], [8, 13, 90], [8, -7, 90]],
@@ -137,7 +137,7 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
   t.true(comparePolygonsAsPoints(obs, exp))
 
   scaled = scaleZ(5, geometry)
-  obs = geom3.toPoints(scaled)
+  obs = geom3.toVertices(scaled)
   t.notThrows(() => geom3.validate(scaled))
   t.is(measureVolume(scaled), 5 * measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))

package/src/operations/transforms/transform.test.js

@@ -40,9 +40,9 @@ test('transform: transforming of a geom3 produces expected changes to polygons',
     [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
     [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
   ]
-  let geometry = geom3.fromPoints(points)
+  let geometry = geom3.fromVertices(points)
   geometry = transform(matrix, geometry)
-  const obs = geom3.toPoints(geometry)
+  const obs = geom3.toVertices(geometry)
   const exp = [
     [[-5, -10, -15], [-5, -10, 15], [-5, 10, 15], [-5, 10, -15]],
     [[5, -10, -15], [5, 10, -15], [5, 10, 15], [5, -10, 15]],

package/src/operations/transforms/translate.test.js

@@ -77,11 +77,11 @@ test('translate: translating of a geom3 produces expected changes to polygons',
     [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
     [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
   ]
-  const geometry = geom3.fromPoints(points)
+  const geometry = geom3.fromVertices(points)
 
   // translate X
   let translated = translate([3], geometry)
-  let obs = geom3.toPoints(translated)
+  let obs = geom3.toVertices(translated)
   let exp = [
     [[1, -7, -12], [1, -7, 18], [1, 13, 18], [1, 13, -12]],
     [[11, -7, -12], [11, 13, -12], [11, 13, 18], [11, -7, 18]],
@@ -95,14 +95,14 @@ test('translate: translating of a geom3 produces expected changes to polygons',
   t.true(comparePolygonsAsPoints(obs, exp))
 
   translated = translateX(3, geometry)
-  obs = geom3.toPoints(translated)
+  obs = geom3.toVertices(translated)
   t.notThrows(() => geom3.validate(translated))
   t.is(measureVolume(translated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // translated Y
   translated = translate([0, 3], geometry)
-  obs = geom3.toPoints(translated)
+  obs = geom3.toVertices(translated)
   exp = [
     [[-2, -4, -12], [-2, -4, 18], [-2, 16, 18], [-2, 16, -12]],
     [[8, -4, -12], [8, 16, -12], [8, 16, 18], [8, -4, 18]],
@@ -116,14 +116,14 @@ test('translate: translating of a geom3 produces expected changes to polygons',
   t.true(comparePolygonsAsPoints(obs, exp))
 
   translated = translateY(3, geometry)
-  obs = geom3.toPoints(translated)
+  obs = geom3.toVertices(translated)
   t.notThrows(() => geom3.validate(translated))
   t.is(measureVolume(translated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // translate Z
   translated = translate([0, 0, 3], geometry)
-  obs = geom3.toPoints(translated)
+  obs = geom3.toVertices(translated)
   exp = [
     [[-2, -7, -9], [-2, -7, 21], [-2, 13, 21], [-2, 13, -9]],
     [[8, -7, -9], [8, 13, -9], [8, 13, 21], [8, -7, 21]],
@@ -137,7 +137,7 @@ test('translate: translating of a geom3 produces expected changes to polygons',
   t.true(comparePolygonsAsPoints(obs, exp))
 
   translated = translateZ(3, geometry)
-  obs = geom3.toPoints(translated)
+  obs = geom3.toVertices(translated)
   t.notThrows(() => geom3.validate(translated))
   t.is(measureVolume(translated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))

package/src/primitives/arc.js

@@ -60,8 +60,8 @@ export const arc = (options) => {
     vec2.add(point, point, centerV)
     pointArray.push(point)
   } else {
-    // note: add one additional step to achieve 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

@@ -13,205 +13,196 @@ test('arc (defaults)', (t) => {
   const obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.is(obs.length, 33)
+  t.is(obs.length, 32)
 })
 
 test('arc (options)', (t) => {
   // test center
   let exp = [
     [3, 2],
-    [2.9324722294043557, 2.361241666187153],
-    [2.739008917220659, 2.6736956436465573],
-    [2.4457383557765384, 2.8951632913550625],
-    [2.092268359463302, 2.9957341762950342],
-    [1.7263370099279172, 2.961825643172819],
-    [1.3973653636207437, 2.7980172272802397],
-    [1.1497828642703858, 2.526432162877356],
-    [1.017026900316098, 2.1837495178165702],
-    [1.017026900316098, 1.8162504821834298],
-    [1.149782864270386, 1.4735678371226442],
-    [1.3973653636207435, 1.2019827727197605],
-    [1.726337009927917, 1.0381743568271808],
-    [2.0922683594633016, 1.0042658237049653],
-    [2.4457383557765384, 1.1048367086449378],
-    [2.739008917220659, 1.326304356353443],
-    [2.9324722294043557, 1.6387583338128469]
+    [2.923879532511287, 2.3826834323650896],
+    [2.7071067811865475, 2.7071067811865475],
+    [2.3826834323650896, 2.923879532511287],
+    [2, 3],
+    [1.6173165676349104, 2.923879532511287],
+    [1.2928932188134525, 2.7071067811865475],
+    [1.0761204674887133, 2.38268343236509],
+    [1, 2],
+    [1.076120467488713, 1.6173165676349104],
+    [1.2928932188134523, 1.2928932188134525],
+    [1.6173165676349097, 1.0761204674887135],
+    [2, 1],
+    [2.38268343236509, 1.0761204674887135],
+    [2.7071067811865475, 1.2928932188134523],
+    [2.9238795325112865, 1.6173165676349095]
   ]
   let geometry = arc({ center: [2, 2], segments: 16 })
   let obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.is(obs.length, 17)
+  t.is(obs.length, 16)
   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]
+    [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.is(obs.length, 17)
+  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.is(obs.length, 14)
+  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]
+    [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.is(obs.length, 6)
+  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]
+    [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.is(obs.length, 19)
+  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.is(obs.length, 9)
+  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.is(obs.length, 6)
+  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.is(obs.length, 10)
+  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.is(obs.length, 10)
+  t.is(obs.length, 9)
   t.true(comparePoints(obs, exp))
 
   exp = [[-1.8369701987210297e-16, -1]]

package/src/primitives/cube.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('cube (defaults)', (t) => {
   const obs = cube()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 24)
   t.is(measureVolume(obs), 7.999999999999999)
@@ -20,7 +20,7 @@ test('cube (defaults)', (t) => {
 test('cube (options)', (t) => {
   // test center
   let obs = cube({ size: 7, center: [6.5, 6.5, 6.5] })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
     [[3, 3, 3], [3, 3, 10], [3, 10, 10], [3, 10, 3]],
     [[10, 3, 3], [10, 10, 3], [10, 10, 10], [10, 3, 10]],
@@ -38,7 +38,7 @@ test('cube (options)', (t) => {
 
   // test size
   obs = cube({ size: 7 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[-3.5, -3.5, -3.5], [-3.5, -3.5, 3.5], [-3.5, 3.5, 3.5], [-3.5, 3.5, -3.5]],
     [[3.5, -3.5, -3.5], [3.5, 3.5, -3.5], [3.5, 3.5, 3.5], [3.5, -3.5, 3.5]],
@@ -57,7 +57,7 @@ test('cube (options)', (t) => {
 
 test('cube (zero size)', (t) => {
   const obs = cube({ size: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)

package/src/primitives/cuboid.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('cuboid (defaults)', (t) => {
   const obs = cuboid()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   const exp = [
     [[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]],
     [[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, -1, 1]],
@@ -29,7 +29,7 @@ test('cuboid (defaults)', (t) => {
 test('cuboid (options)', (t) => {
   // test center
   let obs = cuboid({ size: [6, 6, 6], center: [3, 5, 7] })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
     [[0, 2, 4], [0, 2, 10], [0, 8, 10], [0, 8, 4]],
     [[6, 2, 4], [6, 8, 4], [6, 8, 10], [6, 2, 10]],
@@ -47,7 +47,7 @@ test('cuboid (options)', (t) => {
 
   // test size
   obs = cuboid({ size: [4.5, 1.5, 7] })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[-2.25, -0.75, -3.5], [-2.25, -0.75, 3.5], [-2.25, 0.75, 3.5], [-2.25, 0.75, -3.5]],
     [[2.25, -0.75, -3.5], [2.25, 0.75, -3.5], [2.25, 0.75, 3.5], [2.25, -0.75, 3.5]],
@@ -66,7 +66,7 @@ test('cuboid (options)', (t) => {
 
 test('cuboid (zero size)', (t) => {
   const obs = cuboid({ size: [1, 1, 0] })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)