@jbroll/jscad-modeling 2.12.7

package/src/operations/extrusions/project.js

@@ -0,0 +1,88 @@
+const flatten = require('../../utils/flatten')
+
+const aboutEqualNormals = require('../../maths/utils/aboutEqualNormals')
+const plane = require('../../maths/plane')
+const mat4 = require('../../maths/mat4')
+
+const geom2 = require('../../geometries/geom2')
+const geom3 = require('../../geometries/geom3')
+const poly3 = require('../../geometries/poly3')
+
+const measureEpsilon = require('../../measurements/measureEpsilon')
+
+const unionGeom2 = require('../booleans/unionGeom2')
+
+const projectGeom3 = (options, geometry) => {
+  // create a plane from the options, and verify
+  const projplane = plane.fromNormalAndPoint(plane.create(), options.axis, options.origin)
+  if (Number.isNaN(projplane[0]) || Number.isNaN(projplane[1]) || Number.isNaN(projplane[2]) || Number.isNaN(projplane[3])) {
+    throw new Error('project: invalid axis or origin')
+  }
+
+  const epsilon = measureEpsilon(geometry)
+  const epsilonArea = (epsilon * epsilon * Math.sqrt(3) / 4)
+
+  if (epsilon === 0) return geom2.create()
+
+  // project the polygons to the plane
+  const polygons = geom3.toPolygons(geometry)
+  let projpolys = []
+  for (let i = 0; i < polygons.length; i++) {
+    const newpoints = polygons[i].vertices.map((v) => plane.projectionOfPoint(projplane, v))
+    const newpoly = poly3.create(newpoints)
+    // only keep projections that face the same direction as the plane
+    const newplane = poly3.plane(newpoly)
+    if (!aboutEqualNormals(projplane, newplane)) continue
+    // only keep projections that have a measurable area
+    if (poly3.measureArea(newpoly) < epsilonArea) continue
+    projpolys.push(newpoly)
+  }
+
+  // rotate the polygons to lay on X/Y axes if necessary
+  if (!aboutEqualNormals(projplane, [0, 0, 1])) {
+    const rotation = mat4.fromVectorRotation(mat4.create(), projplane, [0, 0, 1])
+    projpolys = projpolys.map((p) => poly3.transform(rotation, p))
+  }
+
+  // sort the polygons to allow the union to ignore small pieces efficiently
+  projpolys = projpolys.sort((a, b) => poly3.measureArea(b) - poly3.measureArea(a))
+
+  // convert polygons to geometry, and union all pieces into a single geometry
+  const projgeoms = projpolys.map((p) => geom2.fromPoints(p.vertices))
+  return unionGeom2(projgeoms)
+}
+
+/**
+ * Project the given 3D geometry on to the given plane.
+ * @param {Object} options - options for project
+ * @param {Array} [options.axis=[0,0,1]] the axis of the plane (default is Z axis)
+ * @param {Array} [options.origin=[0,0,0]] the origin of the plane
+ * @param {...Object} objects - the list of 3D geometry to project
+ * @return {geom2|Array} the projected 2D geometry, or a list of 2D projected geometry
+ * @alias module:modeling/extrusions.project
+ *
+ * @example
+ * let myshape = project({}, sphere({radius: 20, segments: 5}))
+ */
+const project = (options, ...objects) => {
+  const defaults = {
+    axis: [0, 0, 1], // Z axis
+    origin: [0, 0, 0]
+  }
+  const { axis, origin } = Object.assign({ }, defaults, options)
+
+  objects = flatten(objects)
+  if (objects.length === 0) throw new Error('wrong number of arguments')
+
+  options = { axis, origin }
+
+  const results = objects.map((object) => {
+    // if (path.isA(object)) return project(options, object)
+    // if (geom2.isA(object)) return project(options, object)
+    if (geom3.isA(object)) return projectGeom3(options, object)
+    return object
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = project

package/src/operations/extrusions/project.test.js

@@ -0,0 +1,123 @@
+const test = require('ava')
+
+const comparePoints = require('../../../test/helpers/comparePoints')
+
+const { geom2, geom3 } = require('../../geometries')
+const { cube, torus } = require('../../primitives')
+
+const { project } = require('./index')
+
+test('project (defaults)', (t) => {
+  const geometry0 = geom3.create()
+  const geometry1 = cube({ size: 10 })
+  const geometry2 = 'hi'
+  const geometry3 = undefined
+  const geometry4 = null
+
+  const results = project({ }, geometry0, geometry1, geometry2, geometry3, geometry4)
+  t.is(results.length, 5)
+  t.notThrows(() => geom2.validate(results[0]))
+  t.notThrows(() => geom2.validate(results[1]))
+  t.is(results[2], geometry2)
+  t.is(results[3], geometry3)
+  t.is(results[4], geometry4)
+
+  const result = project({ }, torus({ outerSegments: 4 }))
+  t.notThrows(() => geom2.validate(result))
+  const pts = geom2.toPoints(result)
+  const exp = [
+    [0, -5.000013333333333],
+    [5.000013333333333, 0],
+    [-5.000013333333333, 0],
+    [0, 2.9999933333333333],
+    [-2.9999933333333333, 0],
+    [0, -2.9999933333333333],
+    [2.9999933333333333, 0],
+    [0, 5.000013333333333]
+  ]
+  t.true(comparePoints(pts, exp))
+})
+
+test('project (X and Y axis)', (t) => {
+  let result = project({ axis: [1, 0, 0], origin: [1, 0, 0] }, torus({ outerSegments: 4 }))
+  t.notThrows(() => geom2.validate(result))
+  let pts = geom2.toPoints(result)
+  let exp = [
+    [-0.19511333333333336, -4.98078],
+    [0, -5.000006666666668],
+    [0, 5.000006666666668],
+    [0.3826666666666667, 4.923893333333334],
+    [-0.3826666666666667, -4.923893333333334],
+    [0.19511333333333336, -4.98078],
+    [-0.19511333333333336, 4.98078],
+    [-0.5555666666666668, -4.831446666666667],
+    [0.5555666666666668, 4.831446666666667],
+    [-0.3826666666666667, 4.923893333333334],
+    [0.3826666666666667, -4.923893333333334],
+    [0.7070933333333335, 4.707126666666667],
+    [-0.7070933333333335, -4.707126666666667],
+    [0.5555666666666668, -4.831446666666667],
+    [-0.5555666666666668, 4.831446666666667],
+    [0.8314600000000001, 4.555553333333334],
+    [-0.8314600000000001, -4.555553333333334],
+    [0.7070933333333335, -4.707126666666667],
+    [-0.7070933333333335, 4.707126666666667],
+    [-0.9238600000000001, -4.382700000000001],
+    [0.9238600000000001, 4.382700000000001],
+    [-0.8314600000000001, 4.555553333333334],
+    [0.8314600000000001, -4.555553333333334],
+    [0.9807933333333334, 4.1951],
+    [-0.9807933333333334, -4.1951],
+    [0.9238600000000001, -4.382700000000001],
+    [-0.9238600000000001, 4.382700000000001],
+    [1.0000200000000001, 3.999986666666667],
+    [-1.0000200000000001, -3.999986666666667],
+    [1.0000200000000001, -3.999986666666667],
+    [-1.0000200000000001, 3.999986666666667],
+    [-0.9807933333333334, 4.1951],
+    [0.9807933333333334, -4.1951],
+    [0.19511333333333336, 4.98078]
+  ]
+  t.true(comparePoints(pts, exp))
+
+  result = project({ axis: [0, 1, 0], origin: [0, -1, 0] }, torus({ outerSegments: 4 }))
+  t.notThrows(() => geom2.validate(result))
+  pts = geom2.toPoints(result)
+  exp = [
+    [4.98078, -0.19511333333333336],
+    [5.000006666666668, 0],
+    [-5.000006666666668, 0],
+    [-4.923893333333334, 0.3826666666666667],
+    [4.923893333333334, -0.3826666666666667],
+    [4.98078, 0.19511333333333336],
+    [-4.98078, -0.19511333333333336],
+    [4.831446666666667, -0.5555666666666668],
+    [-4.831446666666667, 0.5555666666666668],
+    [-4.923893333333334, -0.3826666666666667],
+    [4.923893333333334, 0.3826666666666667],
+    [-4.707126666666667, 0.7070933333333335],
+    [4.707126666666667, -0.7070933333333335],
+    [4.831446666666667, 0.5555666666666668],
+    [-4.831446666666667, -0.5555666666666668],
+    [4.555553333333334, -0.8314600000000001],
+    [-4.555553333333334, 0.8314600000000001],
+    [4.707126666666667, 0.7070933333333335],
+    [-4.707126666666667, -0.7070933333333335],
+    [4.382700000000001, -0.9238600000000001],
+    [-4.382700000000001, 0.9238600000000001],
+    [-4.555553333333334, -0.8314600000000001],
+    [4.555553333333334, 0.8314600000000001],
+    [-4.1951, 0.9807933333333334],
+    [4.1951, -0.9807933333333334],
+    [4.382700000000001, 0.9238600000000001],
+    [-4.382700000000001, -0.9238600000000001],
+    [3.999986666666667, -1.0000200000000001],
+    [-3.999986666666667, 1.0000200000000001],
+    [3.999986666666667, 1.0000200000000001],
+    [-3.999986666666667, -1.0000200000000001],
+    [4.1951, 0.9807933333333334],
+    [-4.1951, -0.9807933333333334],
+    [-4.98078, 0.19511333333333336]
+  ]
+  t.true(comparePoints(pts, exp))
+})

package/src/operations/extrusions/slice/calculatePlane.d.ts

@@ -0,0 +1,7 @@
+import Plane from '../../../maths/plane/type'
+
+import Slice from './type'
+
+export default calculatePlane
+
+declare function calculatePlane(slice: Slice): Plane

package/src/operations/extrusions/slice/calculatePlane.js

@@ -0,0 +1,41 @@
+const plane = require('../../../maths/plane')
+const vec3 = require('../../../maths/vec3')
+
+/**
+ * Calculate the plane of the given slice.
+ * NOTE: The slice (and all points) are assumed to be planar from the beginning.
+ * @param {slice} slice - the slice
+ * @returns {plane} the plane of the slice
+ * @alias module:modeling/extrusions/slice.calculatePlane
+ *
+ * @example
+ * let myplane = calculatePlane(slice)
+ */
+const calculatePlane = (slice) => {
+  const edges = slice.edges
+  if (edges.length < 3) throw new Error('slices must have 3 or more edges to calculate a plane')
+
+  // find the midpoint of the slice, which will lie on the plane by definition
+  const midpoint = edges.reduce((point, edge) => vec3.add(vec3.create(), point, edge[0]), vec3.create())
+  vec3.scale(midpoint, midpoint, 1 / edges.length)
+
+  // find the farthest edge from the midpoint, which will be on an outside edge
+  let farthestEdge
+  let distance = 0
+  edges.forEach((edge) => {
+    // Make sure that the farthest edge is not a self-edge
+    if (!vec3.equals(edge[0], edge[1])) {
+      const d = vec3.squaredDistance(midpoint, edge[0])
+      if (d > distance) {
+        farthestEdge = edge
+        distance = d
+      }
+    }
+  })
+  // find the before edge
+  const beforeEdge = edges.find((edge) => vec3.equals(edge[1], farthestEdge[0]))
+
+  return plane.fromPoints(plane.create(), beforeEdge[0], farthestEdge[0], farthestEdge[1])
+}
+
+module.exports = calculatePlane

package/src/operations/extrusions/slice/calculatePlane.test.js

@@ -0,0 +1,35 @@
+const test = require('ava')
+
+const { TAU } = require('../../../maths/constants')
+const { mat4 } = require('../../../maths')
+
+const { calculatePlane, fromPoints, transform } = require('./index')
+
+const { compareVectors } = require('../../../../test/helpers/index')
+
+test('slice: calculatePlane() returns correct plans for various slices', (t) => {
+  // do not do this... it's an error
+  // const slice1 = create()
+  // const plane1 = calculatePlane(slice1)
+
+  const slice2 = fromPoints([[0, 0], [1, 0], [1, 1]])
+  const plane2 = calculatePlane(slice2)
+  t.true(compareVectors(plane2, [0, 0, 1, 0]))
+
+  const slice3 = transform(mat4.fromXRotation(mat4.create(), TAU / 4), slice2)
+  const plane3 = calculatePlane(slice3)
+  t.true(compareVectors(plane3, [0, -1, 0, 0]))
+
+  const slice4 = transform(mat4.fromZRotation(mat4.create(), TAU / 4), slice3)
+  const plane4 = calculatePlane(slice4)
+  t.true(compareVectors(plane4, [1, 0, 0, 0]))
+
+  // Issue #749
+  const slice5 = fromPoints([[-4, 0, 2], [4, 0, 2], [4, 5, 2], [6, 5, 2], [4, 7, 2], [-4, 7, 2], [-6, 5, 2], [-4, 5, 2]])
+  const plane5 = calculatePlane(slice5)
+  t.true(compareVectors(plane5, [0, 0, 1, 2]))
+
+  const slice6 = fromPoints([[4, 0, 0], [-4, 0, 0], [-4, 5, 0], [-6, 5, 0], [-4, 7, 0], [4, 7, 0], [6, 5, 0], [4, 5, 0]])
+  const plane6 = calculatePlane(slice6)
+  t.true(compareVectors(plane6, [0, 0, -1, 0]))
+})

package/src/operations/extrusions/slice/clone.d.ts

@@ -0,0 +1,6 @@
+import Slice from './type'
+
+export default clone
+
+declare function clone(slice: Slice): Slice
+declare function clone(out: Slice, slice: Slice): Slice

package/src/operations/extrusions/slice/clone.js

@@ -0,0 +1,28 @@
+const create = require('./create')
+
+const vec3 = require('../../../maths/vec3')
+
+/**
+ * Create a deep clone of the given slice.
+ *
+ * @param {slice} [out] - receiving slice
+ * @param {slice} slice - slice to clone
+ * @returns {slice} a new slice
+ * @alias module:modeling/extrusions/slice.clone
+ */
+const clone = (...params) => {
+  let out
+  let slice
+  if (params.length === 1) {
+    out = create()
+    slice = params[0]
+  } else {
+    out = params[0]
+    slice = params[1]
+  }
+  // deep clone of edges
+  out.edges = slice.edges.map((edge) => [vec3.clone(edge[0]), vec3.clone(edge[1])])
+  return out
+}
+
+module.exports = clone

package/src/operations/extrusions/slice/clone.test.js

@@ -0,0 +1,34 @@
+const test = require('ava')
+
+const { create, clone, fromPoints, toEdges } = require('./index')
+
+test('slice: clone() should return a new slice with same values', (t) => {
+  const org1 = create()
+  const ret1 = clone(org1)
+  t.not(ret1, org1)
+
+  const org2 = fromPoints([[1, 1], [-1, 1], [-1, -1], [1, -1]])
+  const ret2 = clone(org2)
+  t.not(ret2, org2)
+  t.deepEqual(toEdges(ret2), toEdges(org2))
+})
+
+test('slice: clone() with two params should update a slice with same values', (t) => {
+  const org1 = create()
+  const out1 = create()
+  const ret1 = clone(out1, org1)
+  t.not(out1, org1)
+  t.not(ret1, org1)
+  t.is(ret1, out1)
+
+  t.deepEqual(toEdges(ret1), toEdges(org1))
+
+  const org2 = fromPoints([[1, 1], [-1, 1], [-1, -1], [1, -1]])
+  const out2 = create()
+  const ret2 = clone(out2, org2)
+  t.not(out2, org2)
+  t.not(ret2, org2)
+  t.is(ret2, out2)
+
+  t.deepEqual(toEdges(ret2), toEdges(org2))
+})

package/src/operations/extrusions/slice/create.d.ts

@@ -0,0 +1,5 @@
+import Slice from './type'
+
+export default create
+
+declare function create(edges?: Slice['edges']): Slice

package/src/operations/extrusions/slice/create.js

@@ -0,0 +1,20 @@
+/**
+ * Represents a 3D geometry consisting of a list of edges.
+ * @typedef {Object} slice
+ * @property {Array} edges - list of edges, each edge containing two points (3D)
+ */
+
+/**
+ * Creates a new empty slice.
+ *
+ * @returns {slice} a new slice
+ * @alias module:modeling/extrusions/slice.create
+ */
+const create = (edges) => {
+  if (!edges) {
+    edges = []
+  }
+  return { edges }
+}
+
+module.exports = create

package/src/operations/extrusions/slice/create.test.js

@@ -0,0 +1,9 @@
+const test = require('ava')
+
+const { create } = require('./index')
+
+test('slice: create() should return a slice with initial values', (t) => {
+  const obs = create()
+  const exp = { edges: [] }
+  t.deepEqual(obs, exp)
+})

package/src/operations/extrusions/slice/equals.d.ts

@@ -0,0 +1,5 @@
+import Slice from './type'
+
+export default equals
+
+declare function equals(a: Slice, b: Slice): boolean

package/src/operations/extrusions/slice/equals.js

@@ -0,0 +1,27 @@
+const vec3 = require('../../../maths/vec3')
+
+/**
+ * Determine if the given slices have the same edges.
+ * @param {slice} a - the first slice to compare
+ * @param {slice} b - the second slice to compare
+ * @returns {Boolean} true if the slices are equal
+ * @alias module:modeling/extrusions/slice.equals
+ */
+const equals = (a, b) => {
+  const aedges = a.edges
+  const bedges = b.edges
+
+  if (aedges.length !== bedges.length) {
+    return false
+  }
+
+  const isEqual = aedges.reduce((acc, aedge, i) => {
+    const bedge = bedges[i]
+    const d = vec3.squaredDistance(aedge[0], bedge[0])
+    return acc && (d < Number.EPSILON)
+  }, true)
+
+  return isEqual
+}
+
+module.exports = equals

package/src/operations/extrusions/slice/equals.test.js

@@ -0,0 +1,17 @@
+const test = require('ava')
+
+const { equals, fromPoints } = require('./index')
+
+test('slice: equals() should return proper value', (t) => {
+  const sliceA = fromPoints([[0, 0], [1, 0], [1, 1]])
+  const sliceB = fromPoints([[0, 1], [1, 0], [1, 1]])
+  const sliceC = fromPoints([[0, 0], [1, 0], [1, 1], [0, 0]])
+
+  t.true(equals(sliceA, sliceA))
+
+  t.false(equals(sliceA, sliceB))
+  t.false(equals(sliceB, sliceA))
+
+  t.false(equals(sliceA, sliceC))
+  t.false(equals(sliceC, sliceA))
+})

package/src/operations/extrusions/slice/fromPoints.d.ts

@@ -0,0 +1,9 @@
+import { Vec2, Vec3 } from '../../../maths/types'
+
+import Slice from './type'
+
+type Point = Vec2 | Vec3
+
+export default fromPoints
+
+declare function fromPoints(points: Array<Point>): Slice

package/src/operations/extrusions/slice/fromPoints.js

@@ -0,0 +1,35 @@
+const vec3 = require('../../../maths/vec3')
+
+const create = require('./create')
+
+/**
+ * Create a slice from the given points.
+ *
+ * @param {Array} points - list of points, where each point is either 2D or 3D
+ * @returns {slice} a new slice
+ * @alias module:modeling/extrusions/slice.fromPoints
+ *
+ * @example
+ * const points = [
+ *   [0,  0],
+ *   [0, 10],
+ *   [0, 10]
+ * ]
+ * const slice = fromPoints(points)
+ */
+const fromPoints = (points) => {
+  if (!Array.isArray(points)) throw new Error('the given points must be an array')
+  if (points.length < 3) throw new Error('the given points must contain THREE or more points')
+
+  // create a list of edges from the points
+  const edges = []
+  let prevpoint = points[points.length - 1]
+  points.forEach((point) => {
+    if (point.length === 2) edges.push([vec3.fromVec2(vec3.create(), prevpoint), vec3.fromVec2(vec3.create(), point)])
+    if (point.length === 3) edges.push([prevpoint, point])
+    prevpoint = point
+  })
+  return create(edges)
+}
+
+module.exports = fromPoints

package/src/operations/extrusions/slice/fromPoints.test.js

@@ -0,0 +1,15 @@
+const test = require('ava')
+
+const { fromPoints } = require('./index')
+
+test('slice: fromPoints() should return a new slice with correct values', (t) => {
+  const exp1 = {
+    edges: [
+      [[1, 1, 0], [0, 0, 0]],
+      [[0, 0, 0], [1, 0, 0]],
+      [[1, 0, 0], [1, 1, 0]]
+    ]
+  }
+  const obs1 = fromPoints([[0, 0], [1, 0], [1, 1]])
+  t.deepEqual(obs1, exp1)
+})

package/src/operations/extrusions/slice/fromSides.d.ts

@@ -0,0 +1,7 @@
+import Geom2 from '../../../geometries/geom2/type'
+
+import Slice from './type'
+
+export default fromSides
+
+declare function fromSides(sides: Geom2['sides']): Slice

package/src/operations/extrusions/slice/fromSides.js

@@ -0,0 +1,27 @@
+const vec3 = require('../../../maths/vec3')
+
+const create = require('./create')
+
+/**
+ * Create a slice from the given sides (see geom2).
+ *
+ * @param {Array} sides - list of sides from geom2
+ * @returns {slice} a new slice
+ * @alias module:modeling/extrusions/slice.fromSides
+ *
+ * @example
+ * const myshape = circle({radius: 10})
+ * const slice = fromSides(geom2.toSides(myshape))
+ */
+const fromSides = (sides) => {
+  if (!Array.isArray(sides)) throw new Error('the given sides must be an array')
+
+  // create a list of edges from the sides
+  const edges = []
+  sides.forEach((side) => {
+    edges.push([vec3.fromVec2(vec3.create(), side[0]), vec3.fromVec2(vec3.create(), side[1])])
+  })
+  return create(edges)
+}
+
+module.exports = fromSides

package/src/operations/extrusions/slice/fromSides.test.js

@@ -0,0 +1,15 @@
+const test = require('ava')
+
+const { fromSides } = require('./index')
+
+test('slice: fromSides() should return a new slice with correct values', (t) => {
+  const exp1 = {
+    edges: [
+      [[0, 0, 0], [1, 0, 0]],
+      [[1, 0, 0], [1, 1, 0]],
+      [[1, 1, 0], [0, 0, 0]]
+    ]
+  }
+  const obs1 = fromSides([[[0, 0], [1, 0]], [[1, 0], [1, 1]], [[1, 1], [0, 0]]])
+  t.deepEqual(obs1, exp1)
+})

package/src/operations/extrusions/slice/index.d.ts

@@ -0,0 +1,16 @@
+export { default as calculatePlane } from './calculatePlane'
+export { default as clone } from './clone'
+export { default as create } from './create'
+export { default as equals } from './equals'
+export { default as fromPoints } from './fromPoints'
+export { default as fromSides } from './fromSides'
+export { default as isA } from './isA'
+export { default as reverse } from './reverse'
+export { default as toEdges } from './toEdges'
+export { default as toPolygons } from './toPolygons'
+export { default as toString } from './toString'
+export { default as transform } from './transform'
+
+export { default as Slice } from './type'
+
+export as namespace slice

package/src/operations/extrusions/slice/index.js

@@ -0,0 +1,19 @@
+/**
+ * Represents a 3D geometry consisting of a list of edges.
+ * @see {@link slice} for data structure information.
+ * @module modeling/extrusions/slice
+ */
+module.exports = {
+  calculatePlane: require('./calculatePlane'),
+  clone: require('./clone'),
+  create: require('./create'),
+  equals: require('./equals'),
+  fromPoints: require('./fromPoints'),
+  fromSides: require('./fromSides'),
+  isA: require('./isA'),
+  reverse: require('./reverse'),
+  toEdges: require('./toEdges'),
+  toPolygons: require('./toPolygons'),
+  toString: require('./toString'),
+  transform: require('./transform')
+}

package/src/operations/extrusions/slice/isA.d.ts

@@ -0,0 +1,5 @@
+import Slice from './type'
+
+export default isA
+
+declare function isA(object: any): object is Slice

package/src/operations/extrusions/slice/isA.js

@@ -0,0 +1,18 @@
+/**
+ * Determine if the given object is a slice.
+ * @param {slice} object - the object to interrogate
+ * @returns {Boolean} true if the object matches a slice
+ * @alias module:modeling/extrusions/slice.isA
+ */
+const isA = (object) => {
+  if (object && typeof object === 'object') {
+    if ('edges' in object) {
+      if (Array.isArray(object.edges)) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+module.exports = isA

package/src/operations/extrusions/slice/isA.test.js

@@ -0,0 +1,19 @@
+const test = require('ava')
+
+const { isA, create, fromPoints } = require('./index')
+
+test('isA: identifies created slice', (t) => {
+  const p1 = create()
+  const p2 = fromPoints([[0, 0], [1, 0], [1, 1]])
+  t.true(isA(p1))
+  t.true(isA(p2))
+})
+
+test('isA: identifies non slice', (t) => {
+  const p1 = null
+  const p2 = { }
+  const p3 = { edges: 1 }
+  t.false(isA(p1))
+  t.false(isA(p2))
+  t.false(isA(p3))
+})