@jscad/modeling 2.11.1 → 2.12.1

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

@@ -1,5 +1,4 @@
 const test = require('ava')
-const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
 const { TAU } = require('../../maths/constants')
 const { geom2, geom3 } = require('../../geometries')
 const { circle } = require('../../primitives')
@@ -7,56 +6,55 @@ const { circle } = require('../../primitives')
 const { extrudeHelical } = require('./index')
 
 test('extrudeHelical: (defaults) extruding of a geom2 produces an expected geom3', (t) => {
-    const geometry2 = geom2.fromPoints([[10, 8], [10, -8], [26, -8], [26, 8]])
+  const geometry2 = geom2.fromPoints([[10, 8], [10, -8], [26, -8], [26, 8]])
 
-    const geometry3 = extrudeHelical({}, geometry2)
-    const pts = geom3.toPoints(geometry3)
-    t.notThrows(() => geom3.validate(geometry3))
+  const geometry3 = extrudeHelical({}, geometry2)
+  t.notThrows(() => geom3.validate(geometry3))
 })
 
 test('extrudeHelical: (defaults) extruding of a circle produces an expected geom3', (t) => {
-    const geometry2 = circle({ size: 3, center: [10, 0] })
+  const geometry2 = circle({ size: 3, center: [10, 0] })
 
-    const geometry3 = extrudeHelical({}, geometry2)
-    t.notThrows(() => geom3.validate(geometry3))
+  const geometry3 = extrudeHelical({}, geometry2)
+  t.notThrows(() => geom3.validate(geometry3))
 })
 
 test('extrudeHelical: (angle) extruding of a circle produces an expected geom3', (t) => {
-    const maxRevolutions = 10
-    const geometry2 = circle({ size: 3, center: [10, 0] })
-    for (const index of [...Array(maxRevolutions).keys()]) {
-        // also test negative angles
-        const geometry3 = extrudeHelical({angle: TAU * (index - maxRevolutions / 2)}, geometry2)
-        t.notThrows(() => geom3.validate(geometry3))
-    }
+  const maxRevolutions = 10
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(maxRevolutions).keys()]) {
+    // also test negative angles
+    const geometry3 = extrudeHelical({ angle: TAU * (index - maxRevolutions / 2) }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
 })
 
 test('extrudeHelical: (pitch) extruding of a circle produces an expected geom3', (t) => {
-    const startPitch = -10
-    const geometry2 = circle({ size: 3, center: [10, 0] })
-    for (const index of [...Array(20).keys()]) {
-        // also test negative pitches
-        const geometry3 = extrudeHelical({pitch: startPitch + index}, geometry2)
-        t.notThrows(() => geom3.validate(geometry3))
-    }
+  const startPitch = -10
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(20).keys()]) {
+    // also test negative pitches
+    const geometry3 = extrudeHelical({ pitch: startPitch + index }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
 })
 
 test('extrudeHelical: (endRadiusOffset) extruding of a circle produces an expected geom3', (t) => {
-    const startOffset = -5
-    const geometry2 = circle({ size: 3, center: [10, 0] })
-    for (const index of [...Array(10).keys()]) {
-        // also test negative pitches
-        const geometry3 = extrudeHelical({endRadiusOffset: startOffset + index}, geometry2)
-        t.notThrows(() => geom3.validate(geometry3))
-    }
+  const startOffset = -5
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(10).keys()]) {
+    // also test negative pitches
+    const geometry3 = extrudeHelical({ endRadiusOffset: startOffset + index }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
 })
 
 test('extrudeHelical: (segments) extruding of a circle produces an expected geom3', (t) => {
-    const startSegments = 3
-    const geometry2 = circle({ size: 3, center: [10, 0] })
-    for (const index of [...Array(30).keys()]) {
-        // also test negative pitches
-        const geometry3 = extrudeHelical({segments: startSegments + index}, geometry2)
-        t.notThrows(() => geom3.validate(geometry3))
-    }
-})
+  const startSegments = 3
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(30).keys()]) {
+    // also test negative pitches
+    const geometry3 = extrudeHelical({ segments: startSegments + index }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
+})

package/src/operations/extrusions/extrudeRotate.js

@@ -93,7 +93,7 @@ const extrudeRotate = (options, geometry) => {
         return [point0, point1]
       })
       // recreate the geometry from the (-) capped points
-      geometry = geom2.reverse(geom2.create(shapeSides))
+      geometry = geom2.create(shapeSides)
       geometry = mirrorX(geometry)
     } else if (pointsWithPositiveX.length >= pointsWithNegativeX.length) {
       shapeSides = shapeSides.map((side) => {

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

@@ -2,6 +2,7 @@ export { default as extrudeFromSlices, ExtrudeFromSlicesOptions } from './extrud
 export { default as extrudeLinear, ExtrudeLinearOptions } from './extrudeLinear'
 export { default as extrudeRectangular, ExtrudeRectangularOptions } from './extrudeRectangular'
 export { default as extrudeRotate, ExtrudeRotateOptions } from './extrudeRotate'
+export { default as extrudeHelical, ExtrudeHelicalOptions } from './extrudeHelical'
 export { default as project, ProjectOptions } from './project'
 export * as slice from './slice'
 

package/src/operations/hulls/hullPoints2.js

@@ -25,8 +25,9 @@ const hullPoints2 = (uniquePoints) => {
   })
 
   // sort by polar coordinates
-  points.sort((pt1, pt2) => pt1.angle < pt2.angle ? -1 : pt1.angle > pt2.angle ? 1 :
-    pt1.distSq < pt2.distSq ? -1 : pt1.distSq > pt2.distSq ? 1 : 0)
+  points.sort((pt1, pt2) => pt1.angle !== pt2.angle
+    ? pt1.angle - pt2.angle
+    : pt1.distSq - pt2.distSq)
 
   const stack = [] // start with empty stack
   points.forEach((point) => {

package/src/operations/modifiers/index.js

@@ -8,5 +8,5 @@
 module.exports = {
   generalize: require('./generalize'),
   snap: require('./snap'),
-  retessellate: require('./retessellate'),
+  retessellate: require('./retessellate')
 }

package/src/operations/modifiers/retessellate.js

@@ -1,18 +1,8 @@
 const geom3 = require('../../geometries/geom3')
 const poly3 = require('../../geometries/poly3')
-
-const aboutEqualNormals = require('../../maths/utils/aboutEqualNormals')
-
+const { NEPS } = require('../../maths/constants')
 const reTesselateCoplanarPolygons = require('./reTesselateCoplanarPolygons')
 
-const coplanar = (plane1, plane2) => {
-  // expect the same distance from the origin, within tolerance
-  if (Math.abs(plane1[3] - plane2[3]) < 0.00000015) {
-    return aboutEqualNormals(plane1, plane2)
-  }
-  return false
-}
-
 /*
   After boolean operations all coplanar polygon fragments are joined by a retesselating
   operation. geom3.reTesselate(geom).
@@ -26,29 +16,78 @@ const retessellate = (geometry) => {
     return geometry
   }
 
-  const polygons = geom3.toPolygons(geometry)
-  const polygonsPerPlane = [] // elements: [plane, [poly3...]]
-  polygons.forEach((polygon) => {
-    const mapping = polygonsPerPlane.find((element) => coplanar(element[0], poly3.plane(polygon)))
-    if (mapping) {
-      const polygons = mapping[1]
-      polygons.push(polygon)
+  const polygons = geom3.toPolygons(geometry).map((polygon, index) => ({ vertices: polygon.vertices, plane: poly3.plane(polygon), index: index }))
+  const classified = classifyPolygons(polygons)
+
+  const destPolygons = []
+  classified.forEach((group) => {
+    if (Array.isArray(group)) {
+      const reTessellateCoplanarPolygons = reTesselateCoplanarPolygons(group)
+      destPolygons.push(...reTessellateCoplanarPolygons)
     } else {
-      polygonsPerPlane.push([poly3.plane(polygon), [polygon]])
+      destPolygons.push(group)
     }
   })
 
-  let destpolygons = []
-  polygonsPerPlane.forEach((mapping) => {
-    const sourcepolygons = mapping[1]
-    const retesselayedpolygons = reTesselateCoplanarPolygons(sourcepolygons)
-    destpolygons = destpolygons.concat(retesselayedpolygons)
-  })
-
-  const result = geom3.create(destpolygons)
+  const result = geom3.create(destPolygons)
   result.isRetesselated = true
 
   return result
 }
 
+const classifyPolygons = (polygons) => {
+  let clusters = [polygons] // a cluster is an array of potentially coplanar polygons
+  const nonCoplanar = [] // polygons that are known to be non-coplanar
+  // go through each component of the plane starting with the last one (the distance from origin)
+  for (let component = 3; component >= 0; component--) {
+    const maybeCoplanar = []
+    const tolerance = component === 3 ? 0.000000015 : NEPS
+    clusters.forEach((cluster) => {
+      // sort the cluster by the current component
+      cluster.sort(byPlaneComponent(component, tolerance))
+      // iterate through the cluster and check if there are polygons which are not coplanar with the others
+      // or if there are sub-clusters of coplanar polygons
+      let startIndex = 0
+      for (let i = 1; i < cluster.length; i++) {
+        // if there's a difference larger than the tolerance, split the cluster
+        if (cluster[i].plane[component] - cluster[startIndex].plane[component] > tolerance) {
+          // if there's a single polygon it's definitely not coplanar with any others
+          if (i - startIndex === 1) {
+            nonCoplanar.push(cluster[startIndex])
+          } else { // we have a new sub cluster of potentially coplanar polygons
+            maybeCoplanar.push(cluster.slice(startIndex, i))
+          }
+          startIndex = i
+        }
+      }
+      // handle the last elements of the cluster
+      if (cluster.length - startIndex === 1) {
+        nonCoplanar.push(cluster[startIndex])
+      } else {
+        maybeCoplanar.push(cluster.slice(startIndex))
+      }
+    })
+    // replace previous clusters with the new ones
+    clusters = maybeCoplanar
+  }
+  // restore the original order of the polygons
+  const result = []
+  // polygons inside the cluster should already be sorted by index
+  clusters.forEach((cluster) => {
+    if (cluster[0]) result[cluster[0].index] = cluster
+  })
+  nonCoplanar.forEach((polygon) => { result[polygon.index] = polygon })
+
+  return result
+}
+
+const byPlaneComponent = (component, tolerance) => (a, b) => {
+  if (a.plane[component] - b.plane[component] > tolerance) {
+    return 1
+  } else if (b.plane[component] - a.plane[component] > tolerance) {
+    return -1
+  }
+  return 0
+}
+
 module.exports = retessellate

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

@@ -2,6 +2,8 @@ const test = require('ava')
 
 const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
 
+const { measureArea } = require('../../measurements')
+
 const { geom2, geom3, path2 } = require('../../geometries')
 
 const { mirror, mirrorX, mirrorY, mirrorZ } = require('./index')
@@ -40,25 +42,29 @@ test('mirror: mirroring of geom2 about X/Y produces expected changes to points',
   // mirror about X
   let mirrored = mirror({ normal: [1, 0, 0] }, geometry)
   let obs = geom2.toPoints(mirrored)
-  let exp = [[5, -5], [0, 5], [-10, -5]]
+  let exp = [[0, 5], [5, -5], [-10, -5]]
   t.notThrows(() => geom2.validate(mirrored))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorX(geometry)
   obs = geom2.toPoints(mirrored)
   t.notThrows(() => geom2.validate(mirrored))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   // mirror about Y
   mirrored = mirror({ normal: [0, 1, 0] }, geometry)
   obs = geom2.toPoints(mirrored)
-  exp = [[-5, 5], [0, -5], [10, 5]]
+  exp = [[0, -5], [-5, 5], [10, 5]]
   t.notThrows(() => geom2.validate(mirrored))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorY(geometry)
   obs = geom2.toPoints(mirrored)
   t.notThrows(() => geom2.validate(mirrored))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 })
 
@@ -146,7 +152,7 @@ test('mirror: mirroring of multiple objects produces an array of mirrored object
   t.true(comparePoints(obs, exp))
 
   obs = geom2.toPoints(mirrored[2])
-  exp = [[-5, 5], [0, -5], [10, 5]]
+  exp = [[0, -5], [-5, 5], [10, 5]]
   t.notThrows(() => geom2.validate(mirrored[2]))
   t.true(comparePoints(obs, exp))
 })

package/src/primitives/circle.js

@@ -2,7 +2,7 @@ const { TAU } = require('../maths/constants')
 
 const ellipse = require('./ellipse')
 
-const { isGT } = require('./commonChecks')
+const { isGTE } = require('./commonChecks')
 
 /**
  * Construct a circle in two dimensional space where all points are at the same distance from the center.
@@ -28,7 +28,7 @@ const circle = (options) => {
   }
   let { center, radius, startAngle, endAngle, segments } = Object.assign({}, defaults, options)
 
-  if (!isGT(radius, 0)) throw new Error('radius must be greater than zero')
+  if (!isGTE(radius, 0)) throw new Error('radius must be positive')
 
   radius = [radius, radius]
 

package/src/primitives/circle.test.js

@@ -146,3 +146,10 @@ test('circle (options)', (t) => {
   t.deepEqual(pts.length, 5)
   t.true(comparePoints(pts, exp))
 })
+
+test('circle (radius zero)', (t) => {
+  const geometry = circle({ radius: 0 })
+  const pts = geom2.toPoints(geometry)
+  t.notThrows(() => geom2.validate(geometry))
+  t.is(pts.length, 0)
+})

package/src/primitives/cube.js

@@ -1,6 +1,6 @@
 const cuboid = require('./cuboid')
 
-const { isGT } = require('./commonChecks')
+const { isGTE } = require('./commonChecks')
 
 /**
  * Construct an axis-aligned solid cube in three dimensional space with six square faces.
@@ -20,7 +20,7 @@ const cube = (options) => {
   }
   let { center, size } = Object.assign({}, defaults, options)
 
-  if (!isGT(size, 0)) throw new Error('size must be greater than zero')
+  if (!isGTE(size, 0)) throw new Error('size must be positive')
 
   size = [size, size, size]
 

package/src/primitives/cube.test.js

@@ -46,3 +46,10 @@ test('cube (options)', (t) => {
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
+
+test('cube (zero size)', (t) => {
+  const obs = cube({ size: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})

package/src/primitives/cuboid.js

@@ -23,7 +23,10 @@ const cuboid = (options) => {
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isNumberArray(size, 3)) throw new Error('size must be an array of width, depth and height values')
-  if (!size.every((n) => n > 0)) throw new Error('size values must be greater than zero')
+  if (!size.every((n) => n >= 0)) throw new Error('size values must be positive')
+
+  // if any size is zero return empty geometry
+  if (size[0] === 0 || size[1] === 0 || size[2] === 0) return geom3.create()
 
   const result = geom3.create(
     // adjust a basic shape to size

package/src/primitives/cuboid.test.js

@@ -55,3 +55,10 @@ test('cuboid (options)', (t) => {
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
+
+test('cuboid (zero size)', (t) => {
+  const obs = cuboid({ size: [1, 1, 0] })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})

package/src/primitives/cylinder.js

@@ -1,6 +1,8 @@
+const geom3 = require('../geometries/geom3')
+
 const cylinderElliptic = require('./cylinderElliptic')
 
-const { isGT } = require('./commonChecks')
+const { isGTE } = require('./commonChecks')
 
 /**
  * Construct a Z axis-aligned cylinder in three dimensional space.
@@ -25,7 +27,10 @@ const cylinder = (options) => {
   }
   const { center, height, radius, segments } = Object.assign({}, defaults, options)
 
-  if (!isGT(radius, 0)) throw new Error('radius must be greater than zero')
+  if (!isGTE(radius, 0)) throw new Error('radius must be positive')
+
+  // if size is zero return empty geometry
+  if (height === 0 || radius === 0) return geom3.create()
 
   const newoptions = {
     center,

package/src/primitives/cylinder.test.js

@@ -14,6 +14,20 @@ test('cylinder (defaults)', (t) => {
   t.is(pts.length, 96)
 })
 
+test('cylinder (zero height)', (t) => {
+  const obs = cylinder({ height: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})
+
+test('cylinder (zero radius)', (t) => {
+  const obs = cylinder({ radius: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})
+
 test('cylinder (options)', (t) => {
   let obs = cylinder({ height: 10, radius: 4, segments: 5 })
   let pts = geom3.toPoints(obs)

package/src/primitives/ellipse.js

@@ -34,11 +34,14 @@ const ellipse = (options) => {
 
   if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
   if (!isNumberArray(radius, 2)) throw new Error('radius must be an array of X and Y values')
-  if (!radius.every((n) => n > 0)) throw new Error('radius values must be greater than zero')
+  if (!radius.every((n) => n >= 0)) throw new Error('radius values must be positive')
   if (!isGTE(startAngle, 0)) throw new Error('startAngle must be positive')
   if (!isGTE(endAngle, 0)) throw new Error('endAngle must be positive')
   if (!isGTE(segments, 3)) throw new Error('segments must be three or more')
 
+  // if any radius is zero return empty geometry
+  if (radius[0] === 0 || radius[1] === 0) return geom2.create()
+
   startAngle = startAngle % TAU
   endAngle = endAngle % TAU
 

package/src/primitives/ellipse.test.js

@@ -137,3 +137,10 @@ test('ellipse (options)', (t) => {
   t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(obs.length, 72)
 })
+
+test('ellipse (zero radius)', (t) => {
+  const geometry = ellipse({ radius: [1, 0] })
+  const obs = geom2.toPoints(geometry)
+  t.notThrows(() => geom2.validate(geometry))
+  t.is(obs.length, 0)
+})

package/src/primitives/ellipsoid.js

@@ -32,9 +32,12 @@ const ellipsoid = (options) => {
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isNumberArray(radius, 3)) throw new Error('radius must be an array of X, Y and Z values')
-  if (!radius.every((n) => n > 0)) throw new Error('radius values must be greater than zero')
+  if (!radius.every((n) => n >= 0)) throw new Error('radius values must be positive')
   if (!isGTE(segments, 4)) throw new Error('segments must be four or more')
 
+  // if any radius is zero return empty geometry
+  if (radius[0] === 0 || radius[1] === 0 || radius[2] === 0) return geom3.create()
+
   const xvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[0]), radius[0])
   const yvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[1]), radius[1])
   const zvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[2]), radius[2])

package/src/primitives/ellipsoid.test.js

@@ -207,3 +207,10 @@ test('ellipsoid (options)', (t) => {
   t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
+
+test('ellipsoid (zero radius)', (t) => {
+  const obs = ellipsoid({ radius: [1, 1, 0] })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})

package/src/primitives/geodesicSphere.js

@@ -5,7 +5,7 @@ const geom3 = require('../geometries/geom3')
 
 const polyhedron = require('./polyhedron')
 
-const { isGT, isGTE } = require('./commonChecks')
+const { isGTE } = require('./commonChecks')
 
 /**
  * Construct a geodesic sphere based on icosahedron symmetry.
@@ -25,9 +25,12 @@ const geodesicSphere = (options) => {
   }
   let { radius, frequency } = Object.assign({}, defaults, options)
 
-  if (!isGT(radius, 0)) throw new Error('radius must be greater than zero')
+  if (!isGTE(radius, 0)) throw new Error('radius must be positive')
   if (!isGTE(frequency, 6)) throw new Error('frequency must be six or more')
 
+  // if radius is zero return empty geometry
+  if (radius === 0) return geom3.create()
+
   // adjust the frequency to base 6
   frequency = Math.floor(frequency / 6)
 

package/src/primitives/geodesicSphere.test.js

@@ -51,3 +51,10 @@ test('geodesicSphere (options)', (t) => {
   t.notThrows.skip(() => geom3.validate(obs))
   t.is(pts.length, 180)
 })
+
+test('geodesicSphere (zero radius)', (t) => {
+  const obs = geodesicSphere({ radius: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})

package/src/primitives/polygon.d.ts

@@ -6,6 +6,7 @@ export default polygon
 export interface PolygonOptions {
   points: Array<Vec2> | Array<Array<Vec2>>
   paths?: Array<number> | Array<Array<number>>
+  orientation?: 'counterclockwise' | 'clockwise'
 }
 
 declare function polygon(options: PolygonOptions): Geom2

package/src/primitives/polygon.js

@@ -2,10 +2,13 @@ const geom2 = require('../geometries/geom2')
 
 /**
  * Construct a polygon in two dimensional space from a list of points, or a list of points and paths.
- * NOTE: The ordering of points is VERY IMPORTANT.
+ *
+ * NOTE: The ordering of points is important, and must define a counter clockwise rotation of points.
+ *
  * @param {Object} options - options for construction
  * @param {Array} options.points - points of the polygon : either flat or nested array of 2D points
  * @param {Array} [options.paths] - paths of the polygon : either flat or nested array of point indexes
+ * @param {String} [options.orientation='counterclockwise'] - orientation of points
  * @returns {geom2} new 2D geometry
  * @alias module:modeling/primitives.polygon
  *
@@ -24,9 +27,10 @@ const geom2 = require('../geometries/geom2')
 const polygon = (options) => {
   const defaults = {
     points: [],
-    paths: []
+    paths: [],
+    orientation: 'counterclockwise'
   }
-  const { points, paths } = Object.assign({}, defaults, options)
+  const { points, paths, orientation } = Object.assign({}, defaults, options)
 
   if (!(Array.isArray(points) && Array.isArray(paths))) throw new Error('points and paths must be arrays')
 
@@ -58,13 +62,20 @@ const polygon = (options) => {
   const allpoints = []
   listofpolys.forEach((list) => list.forEach((point) => allpoints.push(point)))
 
+  // convert the list of paths into a list of sides, and accumulate
   let sides = []
   listofpaths.forEach((path) => {
     const setofpoints = path.map((index) => allpoints[index])
     const geometry = geom2.fromPoints(setofpoints)
     sides = sides.concat(geom2.toSides(geometry))
   })
-  return geom2.create(sides)
+
+  // convert the list of sides into a geometry
+  let geometry =  geom2.create(sides)
+  if (orientation == "clockwise") {
+    geometry = geom2.reverse(geometry)
+  }
+  return geometry
 }
 
 module.exports = polygon

package/src/primitives/polygon.test.js

@@ -1,6 +1,7 @@
 const test = require('ava')
 
 const geom2 = require('../geometries/geom2')
+const measureArea = require('../measurements/measureArea')
 
 const { polygon } = require('./index')
 
@@ -51,3 +52,12 @@ test('polygon: providing object.points (array) and object.path (array) creates e
   t.notThrows(() => geom2.validate(geometry))
   t.true(comparePoints(obs, exp))
 })
+
+test('polygon: clockwise points', (t) => {
+  const poly = polygon({
+    points: [[-10, -0], [-10, -10], [-15, -5]],
+    orientation: "clockwise",
+  })
+  t.is(poly.sides.length, 3)
+  t.is(measureArea(poly), 25)
+})

package/src/primitives/rectangle.js

@@ -24,7 +24,10 @@ const rectangle = (options) => {
 
   if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
   if (!isNumberArray(size, 2)) throw new Error('size must be an array of X and Y values')
-  if (!size.every((n) => n > 0)) throw new Error('size values must be greater than zero')
+  if (!size.every((n) => n >= 0)) throw new Error('size values must be positive')
+
+  // if any size is zero return empty geometry
+  if (size[0] === 0 || size[1] === 0) return geom2.create()
 
   const point = [size[0] / 2, size[1] / 2]
   const pswap = [point[0], -point[1]]

package/src/primitives/rectangle.test.js

@@ -50,3 +50,10 @@ test('rectangle (options)', (t) => {
   t.deepEqual(obs.length, 4)
   t.true(comparePoints(obs, exp))
 })
+
+test('rectangle (zero size)', (t) => {
+  const geometry = rectangle({ size: [1, 0] })
+  const obs = geom2.toPoints(geometry)
+  t.notThrows(() => geom2.validate(geometry))
+  t.is(obs.length, 0)
+})