@jscad/modeling 2.12.0 → 3.0.0-alpha.0

package/src/operations/offsets/offsetFromPoints.test.js

@@ -0,0 +1,317 @@
+import test from 'ava'
+
+import { path2 } from '../../geometries/index.js'
+import { measureBoundingBox } from '../../measurements/index.js'
+
+import { offsetFromPoints } from './index.js'
+
+import { comparePoints } from '../../../test/helpers/index.js'
+
+test('offset: offset empty points', (t) => {
+  const offsetPoints = offsetFromPoints({ }, [])
+  t.is(offsetPoints.length, 0)
+})
+
+test('offset: offset single point', (t) => {
+  const offsetPoints = offsetFromPoints({ corners: 'round' }, [[2, 2]])
+  t.is(offsetPoints.length, 1)
+})
+
+test('offset: offsetting a straight line produces expected geometry', (t) => {
+  const points = [[0, 0], [0, 10]]
+
+  // offset it by 2.
+  let offsetPoints = offsetFromPoints({ delta: 2, corners: 'edge', segments: 8 }, points)
+  let offsetLinePath2 = path2.create(offsetPoints)
+  t.notThrows(() => path2.validate(offsetLinePath2))
+  t.is(offsetPoints.length, 2)
+  let boundingBox = measureBoundingBox(offsetLinePath2)
+  t.true(comparePoints(boundingBox, [[2, 0, 0], [2, 10, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
+
+  // offset it by -2.
+  offsetPoints = offsetFromPoints({ delta: -2, corners: 'edge', segments: 8 }, points)
+  offsetLinePath2 = path2.create(offsetPoints)
+  t.notThrows(() => path2.validate(offsetLinePath2))
+  t.is(offsetPoints.length, 2)
+  boundingBox = measureBoundingBox(offsetLinePath2)
+  t.true(comparePoints(boundingBox, [[-2, 0, 0], [-2, 10, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
+
+  // reverse the points, offset it by 2.
+  points.reverse()
+  offsetPoints = offsetFromPoints({ delta: 2, corners: 'edge', segments: 8 }, points)
+  offsetLinePath2 = path2.create(offsetPoints)
+  t.notThrows(() => path2.validate(offsetLinePath2))
+  t.is(offsetPoints.length, 2)
+  boundingBox = measureBoundingBox(offsetLinePath2)
+  t.true(comparePoints(boundingBox, [[-2, 0, 0], [-2, 10, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
+})
+
+test('offset: offsetting a bent line produces expected geometry', (t) => {
+  const points = [[0, 0], [0, 5], [0, 10], [5, 10], [10, 10]]
+
+  // offset it by 2.
+  let offsetPoints = offsetFromPoints({ delta: 2, corners: 'edge', segments: 8 }, points)
+  let offsetLinePath2 = path2.create(offsetPoints)
+  t.notThrows(() => path2.validate(offsetLinePath2))
+  t.is(offsetPoints.length, 5)
+  let boundingBox = measureBoundingBox(offsetLinePath2)
+  t.true(comparePoints(boundingBox, [[2, 0, 0], [10, 8, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
+
+  // offset it by -2.
+  offsetPoints = offsetFromPoints({ delta: -2, corners: 'edge', segments: 8 }, points)
+  offsetLinePath2 = path2.create(offsetPoints)
+  t.notThrows(() => path2.validate(offsetLinePath2))
+  t.is(offsetPoints.length, 5)
+  boundingBox = measureBoundingBox(offsetLinePath2)
+  t.true(comparePoints(boundingBox, [[-2, 0, 0], [10, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
+})
+
+test('offset: offsetting a 2 segment straight line produces expected geometry', (t) => {
+  const points = [[0, 0], [0, 5], [0, 10]]
+  const offsetPoints = offsetFromPoints({ delta: 2, corners: 'edge', segments: 8 }, points)
+  const offsetLinePath2 = path2.create(offsetPoints)
+  t.notThrows(() => path2.validate(offsetLinePath2))
+  t.is(offsetPoints.length, 3)
+  const boundingBox = measureBoundingBox(offsetLinePath2)
+  t.true(comparePoints(boundingBox, [[2, 0, 0], [2, 10, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
+})
+
+test('offset (corners: chamfer): offset of a path2 produces expected offset path2', (t) => {
+  const openline = [[0, 0], [5, 0], [0, 5]]
+  const closeline = [[0, 0], [5, 0], [0, 5], [0, 0]]
+
+  // empty points
+  let pts = offsetFromPoints({ delta: 1 }, [])
+  let obs = path2.create(pts)
+  let exp = []
+  t.notThrows(() => path2.validate(obs))
+  t.true(comparePoints(pts, exp))
+
+  // expand +
+  pts = offsetFromPoints({ delta: 1, corners: 'chamfer' }, openline)
+  obs = path2.create(pts)
+  exp = [
+    [-6.123233995736766e-17, -1],
+    [5, -1],
+    [5.707106781186548, 0.7071067811865475],
+    [0.7071067811865475, 5.707106781186548]
+  ]
+  t.notThrows(() => path2.validate(obs))
+  t.true(comparePoints(pts, exp))
+
+  pts = offsetFromPoints({ delta: 1, corners: 'chamfer' }, closeline)
+  obs = path2.create(pts)
+  exp = [
+    [-6.123233995736766e-17, -1],
+    [5, -1],
+    [5.707106781186548, 0.7071067811865475],
+    [0.7071067811865475, 5.707106781186548],
+    [-1, 5],
+    [-1, 6.123233995736766e-17]
+  ]
+  t.notThrows(() => path2.validate(obs))
+  t.true(comparePoints(pts, exp))
+
+  // contract -
+  pts = offsetFromPoints({ delta: -1, corners: 'chamfer' }, openline)
+  obs = path2.create(pts)
+  exp = [
+    [6.123233995736766e-17, 1],
+    [2.5857864376269046, 1],
+    [-0.7071067811865475, 4.292893218813452]
+  ]
+  t.notThrows(() => path2.validate(obs))
+  t.true(comparePoints(pts, exp))
+
+  pts = offsetFromPoints({ delta: -1, corners: 'chamfer', closed: true }, openline)
+  obs = path2.create(pts)
+  exp = [
+    [1, 1],
+    [2.5857864376269046, 1],
+    [0.9999999999999996, 2.585786437626905]
+  ]
+  t.notThrows(() => path2.validate(obs))
+  t.true(comparePoints(pts, exp))
+})
+
+test('offset (corners: edge): offset of a path2 produces expected offset path2', (t) => {
+  const openline = [[-5, -5], [5, -5], [5, 5], [3, 5], [3, 0], [-3, 0], [-3, 5], [-5, 5]]
+
+  let pts = offsetFromPoints({ delta: 1, corners: 'edge' }, openline)
+  let obs = path2.create(pts)
+  let exp = [
+    [-5, -6],
+    [6, -6],
+    [6, 6],
+    [2, 6],
+    [2, 1],
+    [-2, 1],
+    [-1.9999999999999996, 6],
+    [-5, 6]
+  ]
+  t.notThrows(() => path2.validate(obs))
+  t.true(comparePoints(pts, exp))
+
+  pts = offsetFromPoints({ delta: 1, corners: 'edge', closed: true }, openline)
+  obs = path2.create(pts)
+  exp = [
+    [6, -6],
+    [6, 6],
+    [2, 6],
+    [2, 1],
+    [-2, 1],
+    [-1.9999999999999996, 6],
+    [-6, 6],
+    [-6, -6]
+  ]
+  t.notThrows(() => path2.validate(obs))
+  t.true(comparePoints(pts, exp))
+
+  pts = offsetFromPoints({ delta: -0.5, corners: 'edge' }, openline)
+  obs = path2.create(pts)
+  exp = [
+    [-5, -4.5],
+    [4.5, -4.5],
+    [4.5, 4.5],
+    [3.5, 4.5],
+    [3.4999999999999996, -0.5],
+    [-3.5, -0.4999999999999996],
+    [-3.5, 4.5],
+    [-5, 4.5]
+  ]
+  t.notThrows(() => path2.validate(obs))
+  t.true(comparePoints(pts, exp))
+
+  pts = offsetFromPoints({ delta: -0.5, corners: 'edge', closed: true }, openline)
+  obs = path2.create(pts)
+  exp = [
+    [-4.5, -4.5],
+    [4.5, -4.5],
+    [4.5, 4.5],
+    [3.5, 4.5],
+    [3.4999999999999996, -0.5],
+    [-3.5, -0.4999999999999996],
+    [-3.5, 4.5],
+    [-4.5, 4.5]
+  ]
+  t.notThrows(() => path2.validate(obs))
+  t.true(comparePoints(pts, exp))
+})
+
+test('offset (corners: round): offset of a path2 produces expected offset path2', (t) => {
+  const openline = [[-5, -5], [5, -5], [5, 5], [3, 5], [3, 0], [-3, 0], [-3, 5], [-5, 5]]
+  const closeline = [[-5, -5], [5, -5], [5, 5], [3, 5], [3, 0], [-3, 0], [-3, 5], [-5, 5], [-5, -5]]
+
+  let pts = offsetFromPoints({ delta: 1, corners: 'round', segments: 16 }, openline)
+  let obs = path2.create(pts)
+  let exp = [
+    [-5, -6],
+    [5, -6],
+    [5.38268343236509, -5.923879532511287],
+    [5.707106781186548, -5.707106781186548],
+    [5.923879532511287, -5.38268343236509],
+    [6, -5],
+    [6, 5],
+    [5.923879532511287, 5.38268343236509],
+    [5.707106781186548, 5.707106781186548],
+    [5.38268343236509, 5.923879532511287],
+    [5, 6],
+    [3, 6],
+    [2.6173165676349104, 5.923879532511287],
+    [2.2928932188134525, 5.707106781186548],
+    [2.076120467488713, 5.38268343236509],
+    [2, 5],
+    [2, 1],
+    [-2, 1],
+    [-2, 5],
+    [-2.076120467488713, 5.38268343236509],
+    [-2.2928932188134525, 5.707106781186548],
+    [-2.6173165676349104, 5.923879532511287],
+    [-3, 6],
+    [-5, 6]
+  ]
+  t.notThrows(() => path2.validate(obs))
+  t.true(comparePoints(pts, exp))
+
+  pts = offsetFromPoints({ delta: 1, corners: 'round', segments: 16, closed: true }, openline)
+  obs = path2.create(pts)
+  exp = [
+    [-5.923879532511287, -5.38268343236509],
+    [-5.707106781186548, -5.707106781186548],
+    [-5.3826834323650905, -5.923879532511286],
+    [-5, -6],
+    [5, -6],
+    [5.38268343236509, -5.923879532511287],
+    [5.707106781186548, -5.707106781186548],
+    [5.923879532511287, -5.38268343236509],
+    [6, -5],
+    [6, 5],
+    [5.923879532511287, 5.38268343236509],
+    [5.707106781186548, 5.707106781186548],
+    [5.38268343236509, 5.923879532511287],
+    [5, 6],
+    [3, 6],
+    [2.6173165676349104, 5.923879532511287],
+    [2.2928932188134525, 5.707106781186548],
+    [2.076120467488713, 5.38268343236509],
+    [2, 5],
+    [2, 1],
+    [-2, 1],
+    [-2, 5],
+    [-2.076120467488713, 5.38268343236509],
+    [-2.2928932188134525, 5.707106781186548],
+    [-2.6173165676349104, 5.923879532511287],
+    [-3, 6],
+    [-5, 6],
+    [-5.38268343236509, 5.923879532511287],
+    [-5.707106781186548, 5.707106781186548],
+    [-5.923879532511287, 5.38268343236509],
+    [-6, 5],
+    [-6, -5]
+  ]
+  t.notThrows(() => path2.validate(obs))
+  t.true(comparePoints(pts, exp))
+})
+
+test('offset (corners: round): offset of a CW path2 produces expected offset path2', (t) => {
+  const closeline = [[5, -5], [5, 5], [3, 5], [3, 0], [-3, 0], [-3, 5], [-5, 5], [-5, -5]].reverse()
+
+  const pts = offsetFromPoints({ delta: 1, corners: 'round', segments: 16, closed: true }, closeline)
+  const obs = path2.create(pts)
+  const exp = [
+    [-5.38268343236509, -5.923879532511287],
+    [-5.707106781186548, -5.707106781186548],
+    [-5.923879532511287, -5.38268343236509],
+    [-6, -5],
+    [-6, 5],
+    [-5.923879532511287, 5.38268343236509],
+    [-5.707106781186548, 5.707106781186548],
+    [-5.38268343236509, 5.923879532511287],
+    [-5, 6],
+    [-3, 6],
+    [-2.6173165676349104, 5.923879532511287],
+    [-2.2928932188134525, 5.707106781186548],
+    [-2.076120467488713, 5.38268343236509],
+    [-2, 5],
+    [-2, 1],
+    [2, 1],
+    [2, 5],
+    [2.076120467488713, 5.38268343236509],
+    [2.2928932188134525, 5.707106781186548],
+    [2.6173165676349104, 5.923879532511287],
+    [3, 6],
+    [5, 6],
+    [5.38268343236509, 5.923879532511287],
+    [5.707106781186548, 5.707106781186548],
+    [5.923879532511287, 5.38268343236509],
+    [6, 5],
+    [6, -5],
+    [5.923879532511287, -5.38268343236509],
+    [5.707106781186548, -5.707106781186548],
+    [5.38268343236509, -5.923879532511287],
+    [5, -6],
+    [-5, -6]
+  ]
+  t.notThrows(() => path2.validate(obs))
+  t.true(comparePoints(pts, exp))
+})

package/src/operations/offsets/offsetGeom2.js

@@ -0,0 +1,55 @@
+import * as geom2 from '../../geometries/geom2/index.js'
+import * as poly2 from '../../geometries/poly2/index.js'
+
+import { offsetFromPoints } from './offsetFromPoints.js'
+
+/*
+ * Create an offset geometry from the given geom2 using the given options (if any).
+ * @param {object} options - options for offset
+ * @param {number} [options.delta=1] - delta of offset (+ to exterior, - from interior)
+ * @param {string} [options.corners='edge'] - type corner to create during of expansion; edge, chamfer, round
+ * @param {number} [options.segments=16] - number of segments when creating round corners
+ * @param {Geom2} geometry - geometry from which to create the offset
+ * @returns {Geom2} offset geometry, plus rounded corners
+ */
+export const offsetGeom2 = (options, geometry) => {
+  const defaults = {
+    delta: 1,
+    corners: 'edge',
+    segments: 16,
+    expandHoles: false
+  }
+  const { delta, corners, segments, expandHoles } = Object.assign({ }, defaults, options)
+
+  if (!(corners === 'edge' || corners === 'chamfer' || corners === 'round')) {
+    throw new Error('corners must be "edge", "chamfer", or "round"')
+  }
+  if (!Number.isFinite(delta)) throw new Error('delta must be a finite number')
+  if (corners === 'round' && !Number.isFinite(segments)) throw new Error('segments must be a finite number')
+  if (corners === 'round' && !(segments > 0)) throw new Error('segments must be greater than zero')
+
+  // convert the geometry to outlines, and generate offsets from each
+  const outlines = geom2.toOutlines(geometry)
+  const newOutlines = outlines.map((outline) => {
+    let outside = true
+    // if expanding holes, we need to determine if the outline is inside or outside
+    if (expandHoles) {
+      const level = outlines.reduce((acc, polygon) => acc + poly2.arePointsInside(outline, poly2.create(polygon)), 0)
+      outside = (level % 2) === 0
+    }
+
+    options = {
+      delta: outside ? delta : -delta,
+      corners,
+      closed: true,
+      segments
+    }
+    return offsetFromPoints(options, outline)
+  })
+  // TODO: union outlines that expanded into each other
+
+  // create a composite geometry from the new outlines
+  const output = geom2.create(newOutlines)
+  if (geometry.color) output.color = geometry.color
+  return output
+}

package/src/operations/offsets/offsetGeom2.test.js

@@ -0,0 +1,268 @@
+import test from 'ava'
+
+import { colorize } from '../../colors/index.js'
+import { geom2 } from '../../geometries/index.js'
+import { measureArea } from '../../measurements/index.js'
+import { roundedRectangle, square } from '../../primitives/index.js'
+
+import { offset } from './index.js'
+
+import { comparePoints } from '../../../test/helpers/index.js'
+
+test('offset: offset an empty geom2', (t) => {
+  const empty = geom2.create()
+  const result = offset({ delta: 1 }, empty)
+  t.notThrows(() => geom2.validate(result))
+  t.is(measureArea(result), 0)
+  t.is(geom2.toPoints(result).length, 0)
+})
+
+test('offset: offset option validation', (t) => {
+  const empty = geom2.create()
+  t.throws(() => offset({ delta: null }, empty), { message: 'delta must be a finite number' })
+  t.throws(() => offset({ delta: undefined }, empty), { message: 'delta must be a finite number' })
+  t.throws(() => offset({ delta: Infinity }, empty), { message: 'delta must be a finite number' })
+  t.throws(() => offset({ delta: NaN }, empty), { message: 'delta must be a finite number' })
+  t.throws(() => offset({ corners: 'round', segments: null }, empty), { message: 'segments must be a finite number' })
+  t.throws(() => offset({ corners: 'round', segments: undefined }, empty), { message: 'segments must be a finite number' })
+  t.throws(() => offset({ corners: 'round', segments: Infinity }, empty), { message: 'segments must be a finite number' })
+  t.throws(() => offset({ corners: 'round', segments: NaN }, empty), { message: 'segments must be a finite number' })
+  t.throws(() => offset({ corners: 'round', segments: 0 }, empty), { message: 'segments must be greater than zero' })
+  t.throws(() => offset({ corners: 'round', segments: -1 }, empty), { message: 'segments must be greater than zero' })
+  t.throws(() => offset({ corners: null }, empty), { message: 'corners must be "edge", "chamfer", or "round"' })
+  t.throws(() => offset({ corners: undefined }, empty), { message: 'corners must be "edge", "chamfer", or "round"' })
+  t.throws(() => offset({ corners: 4 }, empty), { message: 'corners must be "edge", "chamfer", or "round"' })
+  t.throws(() => offset({ corners: 'fluffy' }, empty), { message: 'corners must be "edge", "chamfer", or "round"' })
+})
+
+test('offset: offset geom2 preserves color', (t) => {
+  const geometry = colorize([1, 0, 0], square({ }))
+  const result = offset({ }, geometry)
+  t.deepEqual(result.color, [1, 0, 0, 1])
+})
+
+test('offset: offset of a geom2 produces expected changes to points', (t) => {
+  const geometry = square({ size: 16 })
+
+  const obs = offset({ delta: 2, corners: 'round', segments: 8 }, geometry)
+  const pts = geom2.toPoints(obs)
+  const exp = [
+    [-9.414213562373096, -9.414213562373096],
+    [-8, -10],
+    [8, -10],
+    [9.414213562373096, -9.414213562373096],
+    [10, -8],
+    [10, 8],
+    [9.414213562373096, 9.414213562373096],
+    [8, 10],
+    [-8, 10],
+    [-9.414213562373096, 9.414213562373096],
+    [-10, 8],
+    [-10, -8]
+  ]
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 12)
+  t.true(comparePoints(pts, exp))
+})
+
+test('offset (options): offsetting of a simple geom2 produces expected offset geom2', (t) => {
+  const geometry = geom2.create([
+    [[-5, -5], [5, -5], [5, 5], [3, 5], [3, 0], [-3, 0], [-3, 5], [-5, 5]]
+  ])
+
+  // expand +
+  let obs = offset({ delta: 1, corners: 'round', segments: 4 }, geometry)
+  let pts = geom2.toPoints(obs)
+  let exp = [
+    [-5, -6],
+    [5, -6],
+    [6, -5],
+    [6, 5],
+    [5, 6],
+    [3, 6],
+    [2, 5],
+    [2, 1],
+    [-2, 1],
+    [-2, 5],
+    [-3, 6],
+    [-5, 6],
+    [-6, 5],
+    [-6, -5]
+  ]
+  t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 121)
+  t.is(pts.length, 14)
+  t.true(comparePoints(pts, exp))
+
+  // contract -
+  obs = offset({ delta: -0.5, corners: 'round', segments: 4 }, geometry)
+  pts = geom2.toPoints(obs)
+  exp = [
+    [-4.5, -4.5],
+    [4.5, -4.5],
+    [4.5, 4.5],
+    [3.5, 4.5],
+    [3.5, -3.0616171314629196e-17],
+    [3, -0.5],
+    [-3, -0.5],
+    [-3.5, 3.0616171314629196e-17],
+    [-3.5, 4.5],
+    [-4.5, 4.5]
+  ]
+  t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 46.25)
+  t.is(pts.length, 10)
+  t.true(comparePoints(pts, exp))
+
+  // segments 1 - sharp points at corner
+  obs = offset({ delta: 1, corners: 'edge' }, geometry)
+  pts = geom2.toPoints(obs)
+  exp = [
+    [6, -6],
+    [6, 6],
+    [2, 6],
+    [2, 1],
+    [-2, 1],
+    [-1.9999999999999996, 6],
+    [-6, 6],
+    [-6, -6]
+  ]
+  t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 124)
+  t.is(pts.length, 8)
+  t.true(comparePoints(pts, exp))
+
+  // segments 16 - rounded corners
+  obs = offset({ delta: -0.5, corners: 'round', segments: 16 }, geometry)
+  pts = geom2.toPoints(obs)
+  exp = [
+    [-4.5, -4.5],
+    [4.5, -4.5],
+    [4.5, 4.5],
+    [3.5, 4.5],
+    [3.5, -3.061616997868383e-17],
+    [3.4619397662556435, -0.19134171618254492],
+    [3.353553390593274, -0.3535533905932738],
+    [3.191341716182545, -0.46193976625564337],
+    [3, -0.5],
+    [-3, -0.5],
+    [-3.191341716182545, -0.46193976625564337],
+    [-3.353553390593274, -0.3535533905932738],
+    [-3.4619397662556435, -0.19134171618254495],
+    [-3.5, 3.061616997868383e-17],
+    [-3.5, 4.5],
+    [-4.5, 4.5]
+  ]
+  t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 46.1173165676349)
+  t.is(pts.length, 16)
+  t.true(comparePoints(pts, exp))
+})
+
+test('offset (options): offsetting of a complex geom2 produces expected offset geom2', (t) => {
+  const geometry = geom2.create([
+    [
+      [-75, -75],
+      [75, -75],
+      [75, 75],
+      [40, 75],
+      [40, 0],
+      [-40, 0],
+      [-40, 75],
+      [-75, 75]
+    ],
+    [
+      [15, -40],
+      [8, -40],
+      [8, -25],
+      [-8, -25],
+      [-8, -40],
+      [-15, -40],
+      [-15, -10],
+      [15, -10]
+    ],
+    [[-2, -19], [2, -19], [2, -15], [-2, -15]]
+  ])
+
+  // expand +
+  const obs = offset({ delta: 2, corners: 'edge', expandHoles: true }, geometry)
+  const pts = geom2.toPoints(obs)
+  const exp = [
+    [77, -77],
+    [77, 77],
+    [38, 77],
+    [38, 2],
+    [-38, 2],
+    [-37.99999999999999, 77],
+    [-77, 77],
+    [-77, -77],
+    [13, -38],
+    [10, -38],
+    [10, -23],
+    [-10, -23],
+    [-10, -38],
+    [-13, -38],
+    [-13, -12],
+    [13, -12],
+    [3.9999999999999996, -21],
+    [4, -13],
+    [-4, -13],
+    [-4, -21]
+  ]
+  t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 17704)
+  t.is(pts.length, 20)
+  t.true(comparePoints(pts, exp))
+})
+
+test('offset (options): offsetting of round geom2 produces expected offset geom2', (t) => {
+  const geometry = geom2.create([[
+    [10.00000, 0.00000],
+    [9.23880, 3.82683],
+    [7.07107, 7.07107],
+    [3.82683, 9.23880],
+    [0.00000, 10.00000],
+    [-3.82683, 9.23880],
+    [-7.07107, 7.07107],
+    [-9.23880, 3.82683],
+    [-10.00000, 0.00000],
+    [-9.23880, -3.82683],
+    [-7.07107, -7.07107],
+    [-3.82683, -9.23880],
+    [-0.00000, -10.00000],
+    [3.82683, -9.23880],
+    [7.07107, -7.07107],
+    [9.23880, -3.82683]
+  ]])
+
+  const obs = offset({ delta: -0.5, corners: 'round' }, geometry)
+  const pts = geom2.toPoints(obs)
+  const exp = [
+    [9.490204518135641, 0],
+    [8.767810140100096, 3.6317399864658007],
+    [6.710590060510285, 6.7105900605102855],
+    [3.6317399864658024, 8.767810140100096],
+    [-4.440892098500626e-16, 9.490204518135641],
+    [-3.6317399864658007, 8.767810140100096],
+    [-6.7105900605102855, 6.710590060510285],
+    [-8.767810140100096, 3.6317399864658024],
+    [-9.490204518135641, -4.440892098500626e-16],
+    [-8.767810140100096, -3.6317399864658007],
+    [-6.710590060510285, -6.7105900605102855],
+    [-3.6317399864658024, -8.767810140100096],
+    [4.440892098500626e-16, -9.490204518135641],
+    [3.6317399864658007, -8.767810140100096],
+    [6.7105900605102855, -6.710590060510285],
+    [8.767810140100096, -3.6317399864658024]
+  ]
+  t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 275.72806620525375)
+  t.is(pts.length, 16)
+  t.true(comparePoints(pts, exp))
+})
+
+test('offset (options): offsetting issue #1017', (t) => {
+  const geometry = roundedRectangle({ size: [10, 10], segments: 4 })
+  const obs = offset({ delta: -2, corners: 'round' }, geometry)
+  t.notThrows.skip(() => geom2.validate(obs))
+})

package/src/operations/offsets/offsetGeom3.js

@@ -0,0 +1,33 @@
+import * as geom3 from '../../geometries/geom3/index.js'
+
+import { union } from '../booleans/union.js'
+
+import { offsetShell } from './offsetShell.js'
+
+/*
+ * Expand the given geometry (geom3) using the given options (if any).
+ * @param {object} options - options for expand
+ * @param {number} [options.delta=1] - delta (+/-) of expansion
+ * @param {string} [options.corners='round'] - type corner to create during of expansion; round
+ * @param {number} [options.segments=12] - number of segments when creating round corners
+ * @param {Geom3} geometry - the geometry to expand
+ * @returns {Geom3} expanded geometry
+ */
+export const offsetGeom3 = (options, geometry) => {
+  const defaults = {
+    delta: 1,
+    corners: 'round',
+    segments: 12
+  }
+  const { delta, corners, segments } = Object.assign({ }, defaults, options)
+
+  if (!(corners === 'round')) {
+    throw new Error('corners must be "round" for 3D geometries')
+  }
+
+  options = { delta, corners, segments }
+  const expanded = offsetShell(options, geometry)
+  const output = union(geometry, expanded)
+  if (geometry.color) output.color = geometry.color
+  return output
+}