@jbroll/jscad-modeling 2.12.7

package/src/geometries/path2/appendArc.d.ts

@@ -0,0 +1,15 @@
+import Path2 from './type'
+import Vec2 from '../../maths/vec2/type'
+
+export default appendArc
+
+export interface AppendArcOptions {
+  endpoint: Vec2
+  radius?: Vec2
+  xaxisrotation?: number
+  clockwise?: boolean
+  large?: boolean
+  segments?: number
+}
+
+declare function appendArc(options: AppendArcOptions, geometry: Path2): Path2

package/src/geometries/path2/appendArc.js

@@ -0,0 +1,142 @@
+const { TAU } = require('../../maths/constants')
+const vec2 = require('../../maths/vec2')
+
+const fromPoints = require('./fromPoints')
+const toPoints = require('./toPoints')
+
+/**
+ * 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)
+ * @param {Number} [options.xaxisrotation=0] - rotation (RADIANS) of the X axis of the arc with respect to the X axis of the coordinate system
+ * @param {Boolean} [options.clockwise=false] - draw an arc clockwise with respect to the center point
+ * @param {Boolean} [options.large=false] - draw an arc longer than TAU / 2 radians
+ * @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
+ *
+ * @example
+ * let p1 = path2.fromPoints({}, [[27.5,-22.96875]]);
+ * p1 = path2.appendPoints([[27.5,-3.28125]], p1);
+ * p1 = path2.appendArc({endpoint: [12.5, -22.96875], radius: [15, -19.6875]}, p1);
+ */
+const appendArc = (options, geometry) => {
+  const defaults = {
+    radius: [0, 0], // X and Y radius
+    xaxisrotation: 0,
+    clockwise: false,
+    large: false,
+    segments: 16
+  }
+  let { endpoint, radius, xaxisrotation, clockwise, large, segments } = Object.assign({}, defaults, options)
+
+  // validate the given options
+  if (!Array.isArray(endpoint)) throw new Error('endpoint must be an array of X and Y values')
+  if (endpoint.length < 2) throw new Error('endpoint must contain X and Y values')
+  endpoint = vec2.clone(endpoint)
+
+  if (!Array.isArray(radius)) throw new Error('radius must be an array of X and Y values')
+  if (radius.length < 2) throw new Error('radius must contain X and Y values')
+
+  if (segments < 4) throw new Error('segments must be four or more')
+
+  const decimals = 100000
+
+  // validate the given geometry
+  if (geometry.isClosed) {
+    throw new Error('the given path cannot be closed')
+  }
+
+  const points = toPoints(geometry)
+  if (points.length < 1) {
+    throw new Error('the given path must contain one or more points (as the starting point for the arc)')
+  }
+
+  let xradius = radius[0]
+  let yradius = radius[1]
+  const startpoint = points[points.length - 1]
+
+  // round to precision in order to have determinate calculations
+  xradius = Math.round(xradius * decimals) / decimals
+  yradius = Math.round(yradius * decimals) / decimals
+  endpoint = vec2.fromValues(Math.round(endpoint[0] * decimals) / decimals, Math.round(endpoint[1] * decimals) / decimals)
+
+  const sweepFlag = !clockwise
+  let newpoints = []
+  if ((xradius === 0) || (yradius === 0)) {
+    // http://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes:
+    // If rx = 0 or ry = 0, then treat this as a straight line from (x1, y1) to (x2, y2) and stop
+    newpoints.push(endpoint)
+  } else {
+    xradius = Math.abs(xradius)
+    yradius = Math.abs(yradius)
+
+    // see http://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes :
+    const phi = xaxisrotation
+    const cosphi = Math.cos(phi)
+    const sinphi = Math.sin(phi)
+    const minushalfdistance = vec2.subtract(vec2.create(), startpoint, endpoint)
+    vec2.scale(minushalfdistance, minushalfdistance, 0.5)
+    // F.6.5.1:
+    // round to precision in order to have determinate calculations
+    const x = Math.round((cosphi * minushalfdistance[0] + sinphi * minushalfdistance[1]) * decimals) / decimals
+    const y = Math.round((-sinphi * minushalfdistance[0] + cosphi * minushalfdistance[1]) * decimals) / decimals
+    const startTranslated = vec2.fromValues(x, y)
+    // F.6.6.2:
+    const biglambda = (startTranslated[0] * startTranslated[0]) / (xradius * xradius) + (startTranslated[1] * startTranslated[1]) / (yradius * yradius)
+    if (biglambda > 1.0) {
+      // F.6.6.3:
+      const sqrtbiglambda = Math.sqrt(biglambda)
+      xradius *= sqrtbiglambda
+      yradius *= sqrtbiglambda
+      // round to precision in order to have determinate calculations
+      xradius = Math.round(xradius * decimals) / decimals
+      yradius = Math.round(yradius * decimals) / decimals
+    }
+    // F.6.5.2:
+    let multiplier1 = Math.sqrt((xradius * xradius * yradius * yradius - xradius * xradius * startTranslated[1] * startTranslated[1] - yradius * yradius * startTranslated[0] * startTranslated[0]) / (xradius * xradius * startTranslated[1] * startTranslated[1] + yradius * yradius * startTranslated[0] * startTranslated[0]))
+    if (sweepFlag === large) multiplier1 = -multiplier1
+    const centerTranslated = vec2.fromValues(xradius * startTranslated[1] / yradius, -yradius * startTranslated[0] / xradius)
+    vec2.scale(centerTranslated, centerTranslated, multiplier1)
+    // F.6.5.3:
+    let center = vec2.fromValues(cosphi * centerTranslated[0] - sinphi * centerTranslated[1], sinphi * centerTranslated[0] + cosphi * centerTranslated[1])
+    center = vec2.add(center, center, vec2.scale(vec2.create(), vec2.add(vec2.create(), startpoint, endpoint), 0.5))
+
+    // F.6.5.5:
+    const vector1 = vec2.fromValues((startTranslated[0] - centerTranslated[0]) / xradius, (startTranslated[1] - centerTranslated[1]) / yradius)
+    const vector2 = vec2.fromValues((-startTranslated[0] - centerTranslated[0]) / xradius, (-startTranslated[1] - centerTranslated[1]) / yradius)
+    const theta1 = vec2.angleRadians(vector1)
+    const theta2 = vec2.angleRadians(vector2)
+    let deltatheta = theta2 - theta1
+    deltatheta = deltatheta % TAU
+    if ((!sweepFlag) && (deltatheta > 0)) {
+      deltatheta -= TAU
+    } else if ((sweepFlag) && (deltatheta < 0)) {
+      deltatheta += TAU
+    }
+
+    // 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
+    if (numsteps < 1) numsteps = 1
+    for (let step = 1; step < numsteps; step++) {
+      const theta = theta1 + step / numsteps * deltatheta
+      const costheta = Math.cos(theta)
+      const sintheta = Math.sin(theta)
+      // F.6.3.1:
+      const point = vec2.fromValues(cosphi * xradius * costheta - sinphi * yradius * sintheta, sinphi * xradius * costheta + cosphi * yradius * sintheta)
+      vec2.add(point, point, center)
+      newpoints.push(point)
+    }
+    // ensure end point is precisely what user gave as parameter
+    if (numsteps) newpoints.push(options.endpoint)
+  }
+  newpoints = points.concat(newpoints)
+  const result = fromPoints({}, newpoints)
+  return result
+}
+
+module.exports = appendArc

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

@@ -0,0 +1,88 @@
+const test = require('ava')
+
+const { TAU } = require('../../maths/constants')
+
+const { appendArc, fromPoints, toPoints } = require('./index')
+
+const { comparePoints } = require('../../../test/helpers/')
+
+test('appendArc: appending to an empty path produces an error', (t) => {
+  const p1 = fromPoints({}, [])
+  t.throws(() => appendArc({ endpoint: [12, 12] }, p1),
+    { message: 'the given path must contain one or more points (as the starting point for the arc)' })
+})
+
+test('appendArc: appending to a path produces a new path', (t) => {
+  const p1 = fromPoints({}, [[1, 1], [2, 2]])
+  let obs = appendArc({ endpoint: [-2, 2] }, p1)
+  let pts = toPoints(obs)
+  t.is(pts.length, 3)
+
+  // test radius
+  const p2 = fromPoints({}, [[27, -22], [27, -3]])
+  obs = appendArc({ endpoint: [12, -22], radius: [15, -20] }, p2)
+  pts = toPoints(obs)
+  t.is(pts.length, 7)
+
+  // test segments
+  obs = appendArc({ endpoint: [12, -22], radius: [15, -20], segments: 64 }, p2)
+  pts = toPoints(obs)
+  t.is(pts.length, 19)
+
+  // test clockwise
+  obs = appendArc({ endpoint: [12, -22], radius: [15, -20], clockwise: true }, p2)
+  pts = toPoints(obs)
+  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]
+  ]
+  t.is(pts.length, 7)
+  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)
+
+  // test xaxisrotation
+  obs = appendArc({ endpoint: [12, -22], radius: [15, -20], xaxisrotation: TAU / 4 }, p2)
+  pts = toPoints(obs)
+  exp = [
+    [27, -22],
+    [27, -3],
+    [21.830323320631795, -4.401628923214028],
+    [17.364704977487236, -6.805886946199115],
+    [13.940501387124588, -10.031143708098092],
+    [11.816394990371812, -13.833746263211978],
+    [11.15285201325494, -17.926425912558045],
+    [12, -22.000000000000004]
+  ]
+  t.is(pts.length, 8)
+  t.true(comparePoints(pts, exp))
+
+  // test small arc between far points
+  obs = appendArc({ endpoint: [120, -220], radius: [5, -5] }, p2)
+  pts = toPoints(obs)
+  t.is(pts.length, 2)
+})
+
+test('appendArc: appending to a path produces exact endpoint', (t) => {
+  let p1 = fromPoints({}, [[18, 1.8], [1, 3]])
+  const endpoint = [1, -3]
+
+  p1 = appendArc({
+    endpoint,
+    radius: [4, 4],
+    segments: 36,
+    large: true
+  }, p1)
+
+  const pts = toPoints(p1)
+
+  t.deepEqual(pts[pts.length - 1], endpoint)
+})

package/src/geometries/path2/appendBezier.d.ts

@@ -0,0 +1,11 @@
+import Path2 from './type'
+import Vec2 from '../../maths/vec2/type'
+
+export default appendBezier
+
+export interface AppendBezierOptions {
+  controlPoints: Array<Vec2 | null>
+  segments?: number
+}
+
+declare function appendBezier(options: AppendBezierOptions, geometry: Path2): Path2

package/src/geometries/path2/appendBezier.js

@@ -0,0 +1,156 @@
+const { TAU } = require('../../maths/constants')
+const vec2 = require('../../maths/vec2')
+const vec3 = require('../../maths/vec2')
+
+const appendPoints = require('./appendPoints')
+const toPoints = require('./toPoints')
+
+/**
+ * Append a series of points to the given geometry that represent a Bezier curve.
+ * The Bézier curve starts at the last point in the given geometry, and ends at the last control point.
+ * The other control points are intermediate control points to transition the curve from start to end points.
+ * The first control point may be null to ensure a smooth transition occurs. In this case,
+ * the second to last point of the given geometry is mirrored into the control points of the Bezier curve.
+ * In other words, the trailing gradient of the geometry matches the new gradient of the curve.
+ * @param {Object} options - options for construction
+ * @param {Array} options.controlPoints - list of control points (2D) for the bezier curve
+ * @param {Number} [options.segment=16] - number of segments per 360 rotation
+ * @param {path2} geometry - the path of which to appended points
+ * @returns {path2} a new path with the appended points
+ * @alias module:modeling/geometries/path2.appendBezier
+ *
+ * @example
+ * let p5 = path2.create({}, [[10,-20]])
+ * p5 = path2.appendBezier({controlPoints: [[10,-10],[25,-10],[25,-20]]}, p5);
+ * p5 = path2.appendBezier({controlPoints: [null, [25,-30],[40,-30],[40,-20]]}, p5)
+ */
+const appendBezier = (options, geometry) => {
+  const defaults = {
+    segments: 16
+  }
+  let { controlPoints, segments } = Object.assign({}, defaults, options)
+
+  // validate the given options
+  if (!Array.isArray(controlPoints)) throw new Error('controlPoints must be an array of one or more points')
+  if (controlPoints.length < 1) throw new Error('controlPoints must be an array of one or more points')
+
+  if (segments < 4) throw new Error('segments must be four or more')
+
+  // validate the given geometry
+  if (geometry.isClosed) {
+    throw new Error('the given geometry cannot be closed')
+  }
+
+  const points = toPoints(geometry)
+  if (points.length < 1) {
+    throw new Error('the given path must contain one or more points (as the starting point for the bezier curve)')
+  }
+
+  // make a copy of the control points
+  controlPoints = controlPoints.slice()
+
+  // special handling of null control point (only first is allowed)
+  const firstControlPoint = controlPoints[0]
+  if (firstControlPoint === null) {
+    if (controlPoints.length < 2) {
+      throw new Error('a null control point must be passed with one more control points')
+    }
+    // special handling of a previous bezier curve
+    let lastBezierControlPoint = points[points.length - 2]
+    if ('lastBezierControlPoint' in geometry) {
+      lastBezierControlPoint = geometry.lastBezierControlPoint
+    }
+    if (!Array.isArray(lastBezierControlPoint)) {
+      throw new Error('the given path must contain TWO or more points if given a null control point')
+    }
+    // replace the first control point with the mirror of the last bezier control point
+    const controlpoint = vec2.scale(vec2.create(), points[points.length - 1], 2)
+    vec2.subtract(controlpoint, controlpoint, lastBezierControlPoint)
+
+    controlPoints[0] = controlpoint
+  }
+
+  // add a control point for the previous end point
+  controlPoints.unshift(points[points.length - 1])
+
+  const bezierOrder = controlPoints.length - 1
+  const factorials = []
+  let fact = 1
+  for (let i = 0; i <= bezierOrder; ++i) {
+    if (i > 0) fact *= i
+    factorials.push(fact)
+  }
+
+  const binomials = []
+  for (let i = 0; i <= bezierOrder; ++i) {
+    const binomial = factorials[bezierOrder] / (factorials[i] * factorials[bezierOrder - i])
+    binomials.push(binomial)
+  }
+
+  const v0 = vec2.create()
+  const v1 = vec2.create()
+  const v3 = vec3.create()
+  const getPointForT = (t) => {
+    let tk = 1 // = pow(t,k)
+    let oneMinusTNMinusK = Math.pow(1 - t, bezierOrder) // = pow( 1-t, bezierOrder - k)
+    const invOneMinusT = (t !== 1) ? (1 / (1 - t)) : 1
+    const point = vec2.create() // 0, 0, 0
+    for (let k = 0; k <= bezierOrder; ++k) {
+      if (k === bezierOrder) oneMinusTNMinusK = 1
+      const bernsteinCoefficient = binomials[k] * tk * oneMinusTNMinusK
+      const derivativePoint = vec2.scale(v0, controlPoints[k], bernsteinCoefficient)
+      vec2.add(point, point, derivativePoint)
+      tk *= t
+      oneMinusTNMinusK *= invOneMinusT
+    }
+    return point
+  }
+
+  const newpoints = []
+  const newpointsT = []
+  const numsteps = bezierOrder + 1
+  for (let i = 0; i < numsteps; ++i) {
+    const t = i / (numsteps - 1)
+    const point = getPointForT(t)
+    newpoints.push(point)
+    newpointsT.push(t)
+  }
+
+  // subdivide each segment until the angle at each vertex becomes small enough:
+  let subdivideBase = 1
+  const maxangle = TAU / segments
+  const maxsinangle = Math.sin(maxangle)
+  while (subdivideBase < newpoints.length - 1) {
+    const dir1 = vec2.subtract(v0, newpoints[subdivideBase], newpoints[subdivideBase - 1])
+    vec2.normalize(dir1, dir1)
+    const dir2 = vec2.subtract(v1, newpoints[subdivideBase + 1], newpoints[subdivideBase])
+    vec2.normalize(dir2, dir2)
+    const sinangle = vec2.cross(v3, dir1, dir2) // the sine of the angle
+    if (Math.abs(sinangle[2]) > maxsinangle) {
+      // angle is too big, we need to subdivide
+      const t0 = newpointsT[subdivideBase - 1]
+      const t1 = newpointsT[subdivideBase + 1]
+      const newt0 = t0 + (t1 - t0) * 1 / 3
+      const newt1 = t0 + (t1 - t0) * 2 / 3
+      const point0 = getPointForT(newt0)
+      const point1 = getPointForT(newt1)
+      // remove the point at subdivideBase and replace with 2 new points:
+      newpoints.splice(subdivideBase, 1, point0, point1)
+      newpointsT.splice(subdivideBase, 1, newt0, newt1)
+      // re - evaluate the angles, starting at the previous junction since it has changed:
+      subdivideBase--
+      if (subdivideBase < 1) subdivideBase = 1
+    } else {
+      ++subdivideBase
+    }
+  }
+
+  // append to the new points to the given path
+  // but skip the first new point because it is identical to the last point in the given path
+  newpoints.shift()
+  const result = appendPoints(newpoints, geometry)
+  result.lastBezierControlPoint = controlPoints[controlPoints.length - 2]
+  return result
+}
+
+module.exports = appendBezier

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

@@ -0,0 +1,36 @@
+const test = require('ava')
+
+const { appendBezier, fromPoints, toPoints } = require('./index')
+
+const { comparePoints } = require('../../../test/helpers/')
+
+test('appendBezier: appending to an empty path produces an error', (t) => {
+  const p1 = fromPoints({}, [])
+  t.throws(() => appendBezier({ controlPoints: [[12, 12]] }, p1),
+    { message: 'the given path must contain one or more points (as the starting point for the bezier curve)' })
+})
+
+test('appendBezier: appending to a path produces a new path', (t) => {
+  const p1 = fromPoints({}, [[10, -20]])
+  const obs1 = appendBezier({ controlPoints: [[10, -10], [25, -10], [25, -20]], segments: 16 }, p1)
+  const pts = toPoints(obs1)
+  const exp = [
+    [10, -20],
+    [10.410054926134793, -17.32967535436671],
+    [11.524609505100285, -15.244627343392775],
+    [13.170248437738149, -13.74485596707819],
+    [15.709947106075743, -12.693187014174669],
+    [18.469801915922933, -12.556012802926382],
+    [20.665245172410074, -13.128305870265937],
+    [22.5922740239998, -14.318842543198585],
+    [23.857263873597326, -15.783225858248295],
+    [24.69615704524313, -17.676945010515432],
+    [25, -20]
+  ]
+  t.is(pts.length, 11)
+  t.true(comparePoints(pts, exp))
+
+  const obs2 = appendBezier({ controlPoints: [null, [25, -30], [40, -30], [40, -20]], segments: 16 }, obs1)
+  const pts2 = toPoints(obs2)
+  t.is(pts2.length, 23)
+})

package/src/geometries/path2/appendPoints.d.ts

@@ -0,0 +1,6 @@
+import Path2 from './type'
+import Vec2 from '../../maths/vec2/type'
+
+export default appendPoints
+
+declare function appendPoints(points: Array<Vec2>, geometry: Path2): Path2

package/src/geometries/path2/appendPoints.js

@@ -0,0 +1,15 @@
+const concat = require('./concat')
+const create = require('./create')
+
+/**
+ * Append the given list of points to the end of the given geometry.
+ * @param {Array} points - the points (2D) to append to the given path
+ * @param {path2} geometry - the given path
+ * @returns {path2} a new path with the appended points
+ * @alias module:modeling/geometries/path2.appendPoints
+ * @example
+ * let newpath = appendPoints([[3, 4], [4, 5]], oldpath)
+ */
+const appendPoints = (points, geometry) => concat(geometry, create(points))
+
+module.exports = appendPoints

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

@@ -0,0 +1,35 @@
+const test = require('ava')
+
+const { appendPoints, fromPoints, toPoints } = require('./index')
+
+test('appendPoints: appending to an empty path produces a new path with expected points', (t) => {
+  const p1 = fromPoints({}, [])
+  const obs = appendPoints([[1, 1]], p1)
+  const pts = toPoints(obs)
+  t.not(p1, obs)
+  t.is(pts.length, 1)
+})
+
+test('appendPoints: appending to a path produces a new path with expected points', (t) => {
+  const p1 = fromPoints({}, [[1, 1], [2, 2]])
+  const obs = appendPoints([[3, 3], [4, 4]], p1)
+  const pts = toPoints(obs)
+  t.not(p1, obs)
+  t.is(pts.length, 4)
+})
+
+test('appendPoints: appending empty points to a path produces a new path with expected points', (t) => {
+  const p1 = fromPoints({}, [[1, 1], [2, 2]])
+  const obs = appendPoints([], p1)
+  const pts = toPoints(obs)
+  t.not(p1, obs)
+  t.is(pts.length, 2)
+})
+
+test('appendPoints: appending same points to a path produces a new path with expected points', (t) => {
+  const p1 = fromPoints({}, [[1, 1], [2, 2]])
+  const obs = appendPoints([[2, 2], [3, 3]], p1)
+  const pts = toPoints(obs)
+  t.not(p1, obs)
+  t.is(pts.length, 3)
+})

package/src/geometries/path2/applyTransforms.js

@@ -0,0 +1,20 @@
+const mat4 = require('../../maths/mat4')
+const vec2 = require('../../maths/vec2')
+
+/*
+ * Apply the transforms of the given geometry.
+ * NOTE: This function must be called BEFORE exposing any data. See toPoints.
+ * @param {path} geometry - the geometry to transform
+ * @returns {path} the given geometry
+ * @example
+ * geometry = applyTransforms(geometry)
+ */
+const applyTransforms = (geometry) => {
+  if (mat4.isIdentity(geometry.transforms)) return geometry
+
+  geometry.points = geometry.points.map((point) => vec2.transform(vec2.create(), point, geometry.transforms))
+  geometry.transforms = mat4.create()
+  return geometry
+}
+
+module.exports = applyTransforms

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

@@ -0,0 +1,28 @@
+const test = require('ava')
+
+const { fromPoints } = require('./index')
+
+const applyTransforms = require('./applyTransforms')
+
+const { comparePoints, compareVectors } = require('../../../test/helpers/')
+
+test('applyTransforms: Updates a populated path with transformed points', (t) => {
+  const points = [[0, 0], [1, 0], [0, 1]]
+  const expected = {
+    points: [[0, 0], [1, 0], [0, 1]],
+    isClosed: false,
+    transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
+  }
+  const geometry = fromPoints({}, points)
+  const updated = applyTransforms(geometry)
+  t.is(geometry, updated)
+  t.true(comparePoints(updated.points, expected.points))
+  t.false(updated.isClosed)
+  t.true(compareVectors(updated.transforms, expected.transforms))
+
+  const updated2 = applyTransforms(updated)
+  t.is(updated, updated2)
+  t.true(comparePoints(updated2.points, expected.points))
+  t.false(updated2.isClosed)
+  t.true(compareVectors(updated2.transforms, expected.transforms))
+})

package/src/geometries/path2/clone.d.ts

@@ -0,0 +1,5 @@
+import Path2 from './type'
+
+export default clone
+
+declare function clone(geometry: Path2): Path2

package/src/geometries/path2/clone.js

@@ -0,0 +1,9 @@
+/**
+ * Performs a shallow clone of the give geometry.
+ * @param {path2} geometry - the geometry to clone
+ * @returns {path2} a new path
+ * @alias module:modeling/geometries/path2.clone
+ */
+const clone = (geometry) => Object.assign({}, geometry)
+
+module.exports = clone

package/src/geometries/path2/close.d.ts

@@ -0,0 +1,5 @@
+import Path2 from './type'
+
+export default close
+
+declare function close(geometry: Path2): Path2

package/src/geometries/path2/close.js

@@ -0,0 +1,33 @@
+const { EPS } = require('../../maths/constants')
+
+const vec2 = require('../../maths/vec2')
+
+const clone = require('./clone')
+
+/**
+ * Close the given geometry.
+ * @param {path2} geometry - the path to close
+ * @returns {path2} a new path
+ * @alias module:modeling/geometries/path2.close
+ */
+const close = (geometry) => {
+  if (geometry.isClosed) return geometry
+
+  const cloned = clone(geometry)
+  cloned.isClosed = true
+
+  if (cloned.points.length > 1) {
+    // make sure the paths are formed properly
+    const points = cloned.points
+    const p0 = points[0]
+    let pn = points[points.length - 1]
+    while (vec2.distance(p0, pn) < (EPS * EPS)) {
+      points.pop()
+      if (points.length === 1) break
+      pn = points[points.length - 1]
+    }
+  }
+  return cloned
+}
+
+module.exports = close

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

@@ -0,0 +1,43 @@
+const test = require('ava')
+
+const { close, create, fromPoints } = require('./index')
+
+test('close: closes an empty path', (t) => {
+  const p1 = create()
+  t.false(p1.isClosed)
+
+  const p2 = close(p1)
+  t.true(p2.isClosed)
+  t.not(p1, p2)
+
+  const p3 = close(p2)
+  t.true(p3.isClosed)
+  t.is(p2, p3)
+})
+
+test('close: closes various paths', (t) => {
+  let p1 = create()
+  p1 = close(p1)
+  t.true(p1.isClosed)
+  t.is(0, p1.points.length)
+
+  let p2 = fromPoints({ closed: false }, [])
+  p2 = close(p2)
+  t.true(p2.isClosed)
+  t.is(0, p2.points.length)
+
+  let p3 = fromPoints({ closed: true }, [[0, 0]])
+  p3 = close(p3)
+  t.true(p3.isClosed)
+  t.is(1, p3.points.length)
+
+  let p4 = fromPoints({ closed: true }, [[0, 0], [0, 0]])
+  p4 = close(p4)
+  t.true(p4.isClosed)
+  t.is(1, p4.points.length) // the last point is removed
+
+  let p5 = fromPoints({ closed: true }, [[0, 0], [1, 1], [0, 0]])
+  p5 = close(p5)
+  t.true(p5.isClosed)
+  t.is(2, p5.points.length) // the last point is removed
+})

package/src/geometries/path2/concat.d.ts

@@ -0,0 +1,5 @@
+import Path2 from './type'
+
+export default concat
+
+declare function concat(...paths: Array<Path2>): Path2