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

package/src/geometries/geom3/fromVerticesConvex.js

@@ -0,0 +1,25 @@
+import { runner } from '../../operations/hulls/quickhull/index.js'
+import { create } from './create.js'
+import * as poly3 from '../poly3/index.js'
+
+/**
+ * Construct a new convex 3D geometry from a list of unique vertices.
+ *
+ * @param {Array} uniqueVertices - list of vertices to construct convex 3D geometry
+ * @returns {geom3} a new geometry
+ * @alias module:modeling/geom3.fromVerticesConvex
+ */
+export const fromVerticesConvex = (uniqueVertices) => {
+  if (!Array.isArray(uniqueVertices)) {
+    throw new Error('the given vertices must be an array')
+  }
+
+  const faces = runner(uniqueVertices, { skipTriangulation: true })
+
+  const polygons = faces.map((face) => {
+    const vertices = face.map((index) => uniqueVertices[index])
+    return poly3.create(vertices)
+  })
+
+  return create(polygons)
+}

package/src/geometries/geom3/{fromPointsConvex.test.js → fromVerticesConvex.test.js}

@@ -1,8 +1,8 @@
 import test from 'ava'
 
-import { fromPointsConvex, validate } from './index.js'
+import { fromVerticesConvex, validate } from './index.js'
 
-test('fromPointsConvex (uniquePoints)', (t) => {
+test('fromVerticesConvex (uniqueVertices)', (t) => {
   const out = []
   for (let x = -9; x <= 9; ++x) {
     for (let y = -9; y <= 9; ++y) {
@@ -14,7 +14,7 @@ test('fromPointsConvex (uniquePoints)', (t) => {
     }
   }
 
-  const obs = fromPointsConvex(out)
+  const obs = fromVerticesConvex(out)
   validate(obs)
   t.is(obs.polygons.length, 170)
   t.true(obs.polygons.every((f) => ([3, 4, 8, 9].indexOf(f.vertices.length) !== -1)))

package/src/geometries/geom3/index.d.ts

@@ -1,14 +1,13 @@
 export { clone } from './clone.js'
 export { create } from './create.js'
-export { fromPoints } from './fromPoints.js'
-export { fromPointsConvex } from './fromPointsConvex.js'
-export { fromCompactBinary } from './fromCompactBinary.js'
+export { fromVertices } from './fromVertices.js'
+export { fromVerticesConvex } from './fromVerticesConvex.js'
 export { invert } from './invert.js'
 export { isA } from './isA.js'
-export { toPoints } from './toPoints.js'
+export { isConvex } from './isConvex.js'
 export { toPolygons } from './toPolygons.js'
 export { toString } from './toString.js'
-export { toCompactBinary } from './toCompactBinary.js'
+export { toVertices } from './toVertices.js'
 export { transform } from './transform.js'
 export { validate } from './validate.js'
 

package/src/geometries/geom3/index.js

@@ -1,11 +1,12 @@
 /**
  * Represents a 3D geometry consisting of a list of polygons.
- * @see {@link geom3} for data structure information.
- * @module modeling/geometries/geom3
+ *
+ * @see {@link Geom3} for data structure information
+ * @module modeling/geom3
  *
  * @example
- * import { geometries } from '@jscad/modeling'
- * const myShape = geometries.geom3.fromPoints([
+ * import { geom3 } from '@jscad/modeling'
+ * const myShape = geom3.fromVertices([
  *   [[-1,-1,-1], [-1,-1,1], [-1,1,1], [-1,1,-1]],
  *   [[1,-1,-1], [1,1,-1], [1,1,1], [1,-1,1]],
  *   [[-1,-1,-1], [1,-1,-1], [1,-1,1], [-1,-1,1]]
@@ -14,16 +15,35 @@
  *   [[-1,-1,1], [1,-1,1], [1,1,1], [-1,1,1]]
  * ])
  */
+
+/**
+ * @typedef Geom3
+ * @type {Object}
+ * @property {Array} polygons - list of polygons, each polygon containing three or more vertices
+ * @property {Mat4} transforms - transforms to apply to the polygons, see transform()
+ *
+ * @example
+ * {
+ *   "polygons": [
+ *     {"vertices": [[-1,-1,-1], [-1,-1,1], [-1,1,1], [-1,1,-1]]},
+ *     {"vertices": [[1,-1,-1], [1,1,-1], [1,1,1], [1,-1,1]]},
+ *     {"vertices": [[-1,-1,-1], [1,-1,-1], [1,-1,1], [-1,-1,1]]},
+ *     {"vertices": [[-1,1,-1], [-1,1,1], [1,1,1], [1,1,-1]]},
+ *     {"vertices": [[-1,-1,-1], [-1,1,-1], [1,1,-1], [1,-1,-1]]},
+ *     {"vertices": [[-1,-1,1], [1,-1,1], [1,1,1], [-1,1,1]]}
+ *   ],
+ *   "transforms": [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],
+ * }
+ */
 export { clone } from './clone.js'
 export { create } from './create.js'
-export { fromPoints } from './fromPoints.js'
-export { fromPointsConvex } from './fromPointsConvex.js'
-export { fromCompactBinary } from './fromCompactBinary.js'
+export { fromVertices } from './fromVertices.js'
+export { fromVerticesConvex } from './fromVerticesConvex.js'
 export { invert } from './invert.js'
 export { isA } from './isA.js'
-export { toPoints } from './toPoints.js'
+export { isConvex } from './isConvex.js'
 export { toPolygons } from './toPolygons.js'
 export { toString } from './toString.js'
-export { toCompactBinary } from './toCompactBinary.js'
+export { toVertices } from './toVertices.js'
 export { transform } from './transform.js'
 export { validate } from './validate.js'

package/src/geometries/geom3/invert.js

@@ -5,9 +5,13 @@ import { toPolygons } from './toPolygons.js'
 
 /**
  * Invert the given geometry, transposing solid and empty space.
+ *
  * @param {Geom3} geometry - the geometry to invert
  * @returns {Geom3} a new geometry
- * @alias module:modeling/geometries/geom3.invert
+ * @alias module:modeling/geom3.invert
+ *
+ * @example
+ * let inverted = geom3.invert(geometry)
  */
 export const invert = (geometry) => {
   const polygons = toPolygons(geometry)

package/src/geometries/geom3/invert.test.js

@@ -1,6 +1,6 @@
 import test from 'ava'
 
-import { invert, create, fromPoints } from './index.js'
+import { invert, create, fromVertices } from './index.js'
 
 import { comparePolygons, compareVectors } from '../../../test/helpers/index.js'
 
@@ -23,7 +23,7 @@ test('invert: Creates a invert of a populated geom3', (t) => {
     ],
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
-  const geometry = fromPoints(vertices)
+  const geometry = fromVertices(vertices)
   const another = invert(geometry)
   t.not(another, geometry)
   t.true(comparePolygons(another.polygons[0], expected.polygons[0]))

package/src/geometries/geom3/isA.js

@@ -1,8 +1,12 @@
 /**
  * Determine if the given object is a 3D geometry.
+ *
  * @param {object} object - the object to interrogate
  * @returns {Boolean} true if the object matches a geom3
- * @alias module:modeling/geometries/geom3.isA
+ * @alias module:modeling/geom3.isA
+ *
+ * @example
+ * if (geom3.isA(geometry)) { ... }
  */
 export const isA = (object) => {
   if (object && typeof object === 'object') {

package/src/geometries/geom3/isA.test.js

@@ -1,10 +1,10 @@
 import test from 'ava'
 
-import { isA, create, fromPoints } from './index.js'
+import { isA, create, fromVertices } from './index.js'
 
 test('isA: identifies created geom3', (t) => {
   const p1 = create()
-  const p2 = fromPoints([[[0, 0, 0], [1, 0, 0], [1, 0, 1]]])
+  const p2 = fromVertices([[[0, 0, 0], [1, 0, 0], [1, 0, 1]]])
   t.true(isA(p1))
   t.true(isA(p2))
 })

package/src/geometries/geom3/isConvex.d.ts

@@ -0,0 +1,3 @@
+import type { Geom3 } from './type.d.ts'
+
+export function isConvex(geometry: Geom3): boolean

package/src/geometries/geom3/isConvex.js

@@ -0,0 +1,65 @@
+import { EPS } from '../../maths/constants.js'
+import { dot } from '../../maths/vec3/dot.js'
+import { plane } from '../poly3/plane.js'
+
+import { isA } from './isA.js'
+import { toPolygons } from './toPolygons.js'
+
+/**
+ * Test if a 3D geometry is convex.
+ *
+ * A polyhedron is convex if every vertex lies on or behind every face plane
+ * (i.e., on the interior side of the plane).
+ *
+ * @param {geom3} geometry - the geometry to test
+ * @returns {boolean} true if the geometry is convex
+ * @alias module:modeling/geom3.isConvex
+ *
+ * @example
+ * const cube = cuboid()
+ * console.log(geom3.isConvex(cube)) // true
+ */
+export const isConvex = (geometry) => {
+  if (!isA(geometry)) {
+    throw new Error('isConvex requires a geom3 geometry')
+  }
+
+  const polygons = toPolygons(geometry)
+
+  if (polygons.length === 0) {
+    return true // Empty geometry is trivially convex
+  }
+
+  // Collect all unique vertices
+  const vertices = []
+  const found = new Set()
+  for (let i = 0; i < polygons.length; i++) {
+    const verts = polygons[i].vertices
+    for (let j = 0; j < verts.length; j++) {
+      const v = verts[j]
+      const key = `${v[0]},${v[1]},${v[2]}`
+      if (!found.has(key)) {
+        found.add(key)
+        vertices.push(v)
+      }
+    }
+  }
+
+  // For each face plane, check that all vertices are on or behind it
+  for (let i = 0; i < polygons.length; i++) {
+    const p = plane(polygons[i])
+
+    for (let j = 0; j < vertices.length; j++) {
+      const v = vertices[j]
+      // Distance from point to plane: dot(normal, point) - w
+      const distance = dot(p, v) - p[3]
+
+      // If any vertex is in front of any face (positive distance), not convex
+      if (distance > EPS) {
+        return false
+      }
+    }
+  }
+
+  return true
+}

package/src/geometries/geom3/isConvex.test.js

@@ -0,0 +1,44 @@
+import test from 'ava'
+
+import { geom3, cylinderElliptic, sphere, cuboid, subtract } from '../../index.js'
+
+test('isConvex: throws for non-geom3 input', (t) => {
+  t.throws(() => geom3.isConvex('invalid'), { message: /requires a geom3/ })
+  t.throws(() => geom3.isConvex(null), { message: /requires a geom3/ })
+})
+
+test('isConvex: empty geometry is convex', (t) => {
+  const empty = geom3.create()
+  t.true(geom3.isConvex(empty))
+})
+
+test('isConvex: cuboid is convex', (t) => {
+  const cube = cuboid({ size: [10, 10, 10] })
+  t.true(geom3.isConvex(cube))
+})
+
+test('isConvex: sphere is convex', (t) => {
+  const sph = sphere({ radius: 5, segments: 16 })
+  t.true(geom3.isConvex(sph))
+})
+
+test('isConvex: cylinder is convex', (t) => {
+  const cyl = cylinderElliptic({ height: 10, startRadius: [3, 3], endRadius: [3, 3], segments: 16 })
+  t.true(geom3.isConvex(cyl))
+})
+
+test('isConvex: cube with hole is not convex', (t) => {
+  const cube = cuboid({ size: [10, 10, 10] })
+  const hole = cuboid({ size: [4, 4, 20] }) // Hole through the cube
+
+  const withHole = subtract(cube, hole)
+  t.false(geom3.isConvex(withHole))
+})
+
+test('isConvex: L-shaped solid is not convex', (t) => {
+  const big = cuboid({ size: [10, 10, 10], center: [0, 0, 0] })
+  const corner = cuboid({ size: [6, 6, 12], center: [3, 3, 0] })
+
+  const lShape = subtract(big, corner)
+  t.false(geom3.isConvex(lShape))
+})

package/src/geometries/geom3/toPolygons.js

@@ -2,12 +2,14 @@ import { applyTransforms } from './applyTransforms.js'
 
 /**
  * Produces an array of polygons from the given geometry, after applying transforms.
+ *
  * The returned array should not be modified as the polygons are shared with the geometry.
+ *
  * @param {Geom3} geometry - the geometry
  * @returns {Array} an array of polygons
- * @alias module:modeling/geometries/geom3.toPolygons
+ * @alias module:modeling/geom3.toPolygons
  *
  * @example
- * let sharedPolygons = toPolygons(geometry)
+ * let sharedPolygons = geom3.toPolygons(geometry)
  */
 export const toPolygons = (geometry) => applyTransforms(geometry).polygons

package/src/geometries/geom3/toString.js

@@ -4,12 +4,13 @@ import { toPolygons } from './toPolygons.js'
 
 /**
  * Create a string representing the contents of the given geometry.
+ *
  * @param {Geom3} geometry - the geometry
  * @returns {string} a representative string
- * @alias module:modeling/geometries/geom3.toString
+ * @alias module:modeling/geom3.toString
  *
  * @example
- * console.out(toString(geometry))
+ * console.out(geom3.toString(geometry))
  */
 export const toString = (geometry) => {
   const polygons = toPolygons(geometry)

package/src/geometries/geom3/toString.test.js

@@ -1,6 +1,6 @@
 import test from 'ava'
 
-import { create, fromPoints, toString } from './index.js'
+import { create, fromVertices, toString } from './index.js'
 
 test('toString: serialize empty geom3 into a string', (t) => {
   const geometry = create()
@@ -10,7 +10,7 @@ test('toString: serialize empty geom3 into a string', (t) => {
 })
 
 test('toString: serialize geom3 into a string', (t) => {
-  const geometry = fromPoints([[[0, 0, 3], [0, 1, 3], [2, 0, 3]]])
+  const geometry = fromVertices([[[0, 0, 3], [0, 1, 3], [2, 0, 3]]])
   const result = toString(geometry)
   const expected = 'geom3 (1 polygons):\n  poly3: [[0.0000000, 0.0000000, 3.0000000], [0.0000000, 1.0000000, 3.0000000], [2.0000000, 0.0000000, 3.0000000]]\n'
   t.is(result, expected)

package/src/geometries/geom3/{toPoints.d.ts → toVertices.d.ts}

@@ -1,4 +1,4 @@
 import type { Geom3 } from './type.d.ts'
 import type { Vec3 } from '../../maths/vec3/type.d.ts'
 
-export function toPoints(geometry: Geom3): Array<Array<Vec3>>
+export function toVertices(geometry: Geom3): Array<Array<Vec3>>

package/src/geometries/geom3/toVertices.js

@@ -0,0 +1,20 @@
+import * as poly3 from '../poly3/index.js'
+
+import { toPolygons } from './toPolygons.js'
+
+/**
+ * Return the given geometry as a list of vertices, after applying transforms.
+ *
+ * The returned array should not be modified as the vertices are shared with the geometry.
+ *
+ * @param {Geom3} geometry - the geometry
+ * @return {Array} list of vertices, where each sub-array represents a polygon
+ * @alias module:modeling/geom3.toVertices
+ *
+ * @example
+ * let sharedVertices = geom3.toVertices(geometry)
+ */
+export const toVertices = (geometry) => {
+  const polygons = toPolygons(geometry)
+  return polygons.map((polygon) => poly3.toVertices(polygon))
+}

package/src/geometries/geom3/{toPoints.test.js → toVertices.test.js}

@@ -1,17 +1,17 @@
 import test from 'ava'
 
-import { toPoints, fromPoints, toString } from './index.js'
+import { toVertices, fromVertices, toString } from './index.js'
 
 import { comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
-test('toPoints: Creates an array of vertices from a populated geom3', (t) => {
+test('toVertices: Creates an array of vertices from a populated geom3', (t) => {
   const vertices = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
-  const geometry = fromPoints(vertices)
+  const geometry = fromVertices(vertices)
 
   toString(geometry)
 
   const expected = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
-  const vertexList = toPoints(geometry)
+  const vertexList = toVertices(geometry)
   t.deepEqual(vertexList, expected)
   t.true(comparePolygonsAsPoints(vertexList, expected))
 

package/src/geometries/geom3/transform.js

@@ -2,15 +2,18 @@ import * as mat4 from '../../maths/mat4/index.js'
 
 /**
  * Transform the given geometry using the given matrix.
+ *
  * This is a lazy transform of the polygons, as this function only adjusts the transforms.
+ *
  * See applyTransforms() for the actual application of the transforms to the polygons.
+ *
  * @param {Mat4} matrix - the matrix to transform with
  * @param {Geom3} geometry - the geometry to transform
  * @returns {Geom3} a new geometry
- * @alias module:modeling/geometries/geom3.transform
+ * @alias module:modeling/geom3.transform
  *
  * @example
- * let newGeometry = transform(fromXRotation(TAU / 4), geometry)
+ * let newGeometry = geom3.transform(fromXRotation(TAU / 4), geometry)
  */
 export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)

package/src/geometries/geom3/transform.test.js

@@ -2,7 +2,7 @@ import test from 'ava'
 
 import { mat4 } from '../../maths/index.js'
 
-import { transform, fromPoints, toPolygons } from './index.js'
+import { transform, fromVertices, toPolygons } from './index.js'
 
 import { comparePolygons, compareVectors } from '../../../test/helpers/index.js'
 
@@ -20,7 +20,7 @@ test('transform: Adjusts the transforms of a populated geom3', (t) => {
     ],
     transforms: [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
-  const geometry = fromPoints(vertices)
+  const geometry = fromVertices(vertices)
   let another = transform(rotate90, geometry)
   t.not(geometry, another)
   t.true(comparePolygons(another.polygons[0], expected.polygons[0]))

package/src/geometries/geom3/validate.js

@@ -4,13 +4,17 @@ import { isA } from './isA.js'
 
 /**
  * Determine if the given object is a valid 3D geometry.
+ *
  * Checks for valid data structure, convex polygon faces, and manifold edges.
  *
- * **If the geometry is not valid, an exception will be thrown with details of the geometry error.**
+ * **NOTE: If the geometry is not valid, an exception will be thrown with details of the geometry error.**
  *
  * @param {object} object - the object to interrogate
  * @throws {Error} error if the geometry is not valid
- * @alias module:modeling/geometries/geom3.validate
+ * @alias module:modeling/geom3.validate
+ *
+ * @example
+ * if (geom3.validate(geometry)) { ... }
  */
 export const validate = (object) => {
   if (!isA(object)) {

package/src/geometries/geom3/validate.test.js

@@ -1,7 +1,7 @@
 import test from 'ava'
 
 import * as vec3 from '../../maths/vec3/index.js'
-import { fromPoints, validate } from './index.js'
+import { fromVertices, validate } from './index.js'
 
 // tetrahedron
 const a = vec3.fromValues(-1, -1, 1)
@@ -11,16 +11,16 @@ const d = vec3.fromValues(1, 1, 1)
 
 test('validate: allow valid geom3', (t) => {
   // simplest valid geometry
-  const geometry = fromPoints([[a, b, c], [d, b, a], [d, a, c], [c, b, d]])
+  const geometry = fromVertices([[a, b, c], [d, b, a], [d, a, c], [c, b, d]])
   t.notThrows(() => validate(geometry))
 })
 
 test('validate: throw exception for nan', (t) => {
-  const geometry = fromPoints([[a, b, c], [d, b, a], [d, a, c], [c, b, [1, 1, NaN]]])
+  const geometry = fromVertices([[a, b, c], [d, b, a], [d, a, c], [c, b, [1, 1, NaN]]])
   t.throws(() => validate(geometry))
 })
 
 test('validate: throw exception for infinity', (t) => {
-  const geometry = fromPoints([[a, b, c], [d, b, a], [d, a, c], [c, b, [1, 1, Infinity]]])
+  const geometry = fromVertices([[a, b, c], [d, b, a], [d, a, c], [c, b, [1, 1, Infinity]]])
   t.throws(() => validate(geometry))
 })

package/src/geometries/index.d.ts

@@ -1,6 +1,7 @@
 export * as geom2 from './geom2/index.js'
 export * as geom3 from './geom3/index.js'
 export * as path2 from './path2/index.js'
+export * as path3 from './path3/index.js'
 export * as poly2 from './poly2/index.js'
 export * as poly3 from './poly3/index.js'
 export * as slice from './slice/index.js'

package/src/geometries/index.js

@@ -1,21 +1,24 @@
 /**
  * Geometries are objects that represent the contents of primitives or the results of operations.
+ *
  * Note: Geometries are considered immutable, so never change the contents directly.
  *
- * @see {@link geom2} - 2D geometry consisting of 2D outlines
- * @see {@link geom3} - 3D geometry consisting of polygons
- * @see {@link path2} - 2D geometry consisting of ordered points
- * @see {@link poly2} - 2D polygon consisting of ordered points
- * @see {@link poly3} - 3D polygon consisting of ordered vertices
- * @see {@link slice} - 3D geometry consisting of 3D contours
+ * @see [Geom2]{@link module:modeling/geom2} - 2D geometry consisting of 2D outlines
+ * @see [Geom3]{@link module:modeling/geom3} - 3D geometry consisting of polygons
+ * @see [Path2]{@link module:modeling/path2} - 2D geometry consisting of ordered 2D points
+ * @see [Path3]{@link module:modeling/path3} - 3D geometry consisting of ordered 3D vertices
+ * @see [Poly2]{@link module:modeling/poly2} - 2D polygon consisting of 2D points
+ * @see [Poly3]{@link module:modeling/poly3} - 3D polygon consisting of 3D vertices
+ * @see [Slice]{@link module:modeling/slice} - 3D geometry consisting of 3D contours
+ * @alias module:modeling.geometry
  *
- * @module modeling/geometries
  * @example
  * import { geom2, geom3, path2, poly2, poly3, slice } from '@jscad/modeling'
  */
 export * as geom2 from './geom2/index.js'
 export * as geom3 from './geom3/index.js'
 export * as path2 from './path2/index.js'
+export * as path3 from './path3/index.js'
 export * as poly2 from './poly2/index.js'
 export * as poly3 from './poly3/index.js'
 export * as slice from './slice/index.js'

package/src/geometries/path2/appendArc.js

@@ -6,8 +6,10 @@ import { toPoints } from './toPoints.js'
 
 /**
  * Append a series of points to the given geometry that represent an arc.
+ *
  * This implementation follows the SVG specifications.
  * @see http://www.w3.org/TR/SVG/paths.html#PathDataEllipticalArcCommands
+ *
  * @param {object} options - options for construction
  * @param {Vec2} options.endpoint - end point of arc (REQUIRED)
  * @param {Vec2} [options.radius=[0,0]] - radius of arc (X and Y)
@@ -17,12 +19,12 @@ import { toPoints } from './toPoints.js'
  * @param {number} [options.segments=16] - number of segments per full rotation
  * @param {Path2} geometry - the path of which to append the arc
  * @returns {Path2} a new path with the appended points
- * @alias module:modeling/geometries/path2.appendArc
+ * @alias module:modeling/path2.appendArc
  *
  * @example
- * let myShape = fromPoints({}, [[27.5,-22.96875]]);
- * myShape = appendPoints([[27.5,-3.28125]], myShape);
- * myShape = appendArc({endpoint: [12.5, -22.96875], radius: [15, -19.6875]}, myShape);
+ * let myShape = path2.fromPoints({}, [[27.5,-22.96875]]);
+ * myShape = path2.appendPoints([[27.5,-3.28125]], myShape);
+ * myShape = path2.appendArc({endpoint: [12.5, -22.96875], radius: [15, -19.6875]}, myShape);
  */
 export const appendArc = (options, geometry) => {
   const defaults = {
@@ -120,7 +122,7 @@ export const appendArc = (options, geometry) => {
     }
 
     // Ok, we have the center point and angle range (from theta1, deltatheta radians) so we can create the ellipse
-    let numSteps = Math.ceil(Math.abs(deltatheta) / TAU * segments) + 1
+    let numSteps = Math.floor(segments * (Math.abs(deltatheta) / TAU))
     if (numSteps < 1) numSteps = 1
     for (let step = 1; step < numSteps; step++) {
       const theta = theta1 + step / numSteps * deltatheta

package/src/geometries/path2/appendArc.test.js

@@ -23,12 +23,12 @@ test('appendArc: appending to a path produces a new path', (t) => {
   const p2 = fromPoints({}, [[27, -22], [27, -3]])
   obs = appendArc({ endpoint: [12, -22], radius: [15, -20] }, p2)
   pts = toPoints(obs)
-  t.is(pts.length, 7)
+  t.is(pts.length, 5)
 
   // test segments
   obs = appendArc({ endpoint: [12, -22], radius: [15, -20], segments: 64 }, p2)
   pts = toPoints(obs)
-  t.is(pts.length, 19)
+  t.is(pts.length, 17)
 
   // test clockwise
   obs = appendArc({ endpoint: [12, -22], radius: [15, -20], clockwise: true }, p2)
@@ -36,19 +36,17 @@ test('appendArc: appending to a path produces a new path', (t) => {
   let exp = [
     [27, -22],
     [27, -3],
-    [26.086451657912605, -8.941047736250177],
-    [23.87938869625451, -14.243872270248309],
-    [20.58174906029909, -18.420882475791835],
-    [16.49674848226545, -21.0880050920699],
-    [11.999999999999998, -22]
+    [24.7485593841743, -12.579008396887021],
+    [19.29019838402471, -19.492932330409836],
+    [12, -22]
   ]
-  t.is(pts.length, 7)
+  t.is(pts.length, 5)
   t.true(comparePoints(pts, exp))
 
   // test large
   obs = appendArc({ endpoint: [12, -22], radius: [15, -20], large: true }, p2)
   pts = toPoints(obs)
-  t.is(pts.length, 16)
+  t.is(pts.length, 14)
 
   // test xaxisRotation
   obs = appendArc({ endpoint: [12, -22], radius: [15, -20], xaxisRotation: TAU / 4 }, p2)
@@ -56,14 +54,12 @@ test('appendArc: appending to a path produces a new path', (t) => {
   exp = [
     [27, -22],
     [27, -3],
-    [21.830323320631795, -4.401628923214028],
-    [17.364704977487236, -6.805886946199115],
+    [19.486852090983938, -5.488140907400943],
     [13.940501387124588, -10.031143708098092],
-    [11.816394990371812, -13.833746263211978],
-    [11.15285201325494, -17.926425912558045],
-    [12, -22.000000000000004]
+    [11.296247566821858, -15.862906638006239],
+    [12, -22]
   ]
-  t.is(pts.length, 8)
+  t.is(pts.length, 6)
   t.true(comparePoints(pts, exp))
 
   // test small arc between far points