@jbroll/jscad-modeling 2.12.7

package/src/operations/expansions/offset.test.js

@@ -0,0 +1,503 @@
+const test = require('ava')
+
+const { geom2, path2 } = require('../../geometries')
+const { offset } = require('./index')
+const { comparePoints } = require('../../../test/helpers')
+const measureBoundingBox = require('../../measurements/measureBoundingBox')
+
+test('offset: offsetting a straight line produces expected geometry', (t) => {
+  const points = [[0, 0], [0, 10]]
+  let linePath2 = path2.fromPoints({ closed: false }, points)
+
+  // offset it by 2.
+  let offsetLinePath2 = offset({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
+  let offsetPoints = path2.toPoints(offsetLinePath2)
+  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.
+  offsetLinePath2 = offset({ delta: -2, corners: 'edge', segments: 8 }, linePath2)
+  offsetPoints = path2.toPoints(offsetLinePath2)
+  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.
+  linePath2 = path2.fromPoints({ closed: false }, points.reverse())
+  offsetLinePath2 = offset({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
+  offsetPoints = path2.toPoints(offsetLinePath2)
+  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]]
+  const linePath2 = path2.fromPoints({ closed: false }, points)
+
+  // offset it by 2.
+  let offsetLinePath2 = offset({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
+  let offsetPoints = path2.toPoints(offsetLinePath2)
+  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.
+  offsetLinePath2 = offset({ delta: -2, corners: 'edge', segments: 8 }, linePath2)
+  offsetPoints = path2.toPoints(offsetLinePath2)
+  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 linePath2 = path2.fromPoints({ closed: false }, points)
+  const offsetLinePath2 = offset({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
+  const offsetPoints = path2.toPoints(offsetLinePath2)
+  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 = path2.fromPoints({ }, [[0, 0], [5, 0], [0, 5]])
+  const closeline = path2.fromPoints({ }, [[0, 0], [5, 0], [0, 5], [0, 0]])
+
+  // empty path2
+  const empty = path2.create()
+  let obs = offset({ delta: 1 }, empty)
+  let pts = path2.toPoints(obs)
+  let exp = [
+  ]
+  t.notThrows(() => path2.validate(obs))
+  t.true(comparePoints(pts, exp))
+
+  // expand +
+  obs = offset({ delta: 1, corners: 'chamfer' }, openline)
+  pts = path2.toPoints(obs)
+  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))
+
+  obs = offset({ delta: 1, corners: 'chamfer' }, closeline)
+  pts = path2.toPoints(obs)
+  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 -
+  obs = offset({ delta: -1, corners: 'chamfer' }, openline)
+  pts = path2.toPoints(obs)
+  exp = [
+    [6.123233995736766e-17, 1],
+    [2.5857864376269046, 1],
+    [-0.7071067811865475, 4.292893218813452]
+  ]
+  t.notThrows(() => path2.validate(obs))
+  t.true(comparePoints(pts, exp))
+
+  obs = offset({ delta: -1, corners: 'chamfer' }, closeline)
+  pts = path2.toPoints(obs)
+  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 = path2.fromPoints({ }, [[-5, -5], [5, -5], [5, 5], [3, 5], [3, 0], [-3, 0], [-3, 5], [-5, 5]])
+  const closeline = path2.fromPoints({ }, [[-5, -5], [5, -5], [5, 5], [3, 5], [3, 0], [-3, 0], [-3, 5], [-5, 5], [-5, -5]])
+
+  let obs = offset({ delta: 1, corners: 'edge' }, openline)
+  let pts = path2.toPoints(obs)
+  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))
+
+  obs = offset({ delta: 1, corners: 'edge' }, closeline)
+  pts = path2.toPoints(obs)
+  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))
+
+  obs = offset({ delta: -0.5, corners: 'edge' }, openline)
+  pts = path2.toPoints(obs)
+  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))
+
+  obs = offset({ delta: -0.5, corners: 'edge' }, closeline)
+  pts = path2.toPoints(obs)
+  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 = path2.fromPoints({ }, [[-5, -5], [5, -5], [5, 5], [3, 5], [3, 0], [-3, 0], [-3, 5], [-5, 5]])
+  const closeline = path2.fromPoints({ }, [[-5, -5], [5, -5], [5, 5], [3, 5], [3, 0], [-3, 0], [-3, 5], [-5, 5], [-5, -5]])
+
+  let obs = offset({ delta: 1, corners: 'round', segments: 16 }, openline)
+  let pts = path2.toPoints(obs)
+  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))
+
+  obs = offset({ delta: 1, corners: 'round', segments: 16 }, closeline)
+  pts = path2.toPoints(obs)
+  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 = path2.fromPoints({ }, [[-5, -5], [5, -5], [5, 5], [3, 5], [3, 0], [-3, 0], [-3, 5], [-5, 5], [-5, -5]].reverse())
+
+  const obs = offset({ delta: 1, corners: 'round', segments: 16 }, closeline)
+  const pts = path2.toPoints(obs)
+  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))
+})
+
+test('offset (options): offsetting of a simple geom2 produces expected offset geom2', (t) => {
+  const geometry = geom2.fromPoints([[-5, -5], [5, -5], [5, 5], [3, 5], [3, 0], [-3, 0], [-3, 5], [-5, 5]])
+
+  // empty
+  const empty = geom2.create()
+  let obs = offset({ delta: 1 }, empty)
+  let pts = geom2.toPoints(obs)
+  let exp = [
+  ]
+  t.notThrows(() => geom2.validate(obs))
+  t.true(comparePoints(pts, exp))
+
+  // expand +
+  obs = offset({ delta: 1, corners: 'round' }, geometry)
+  pts = geom2.toPoints(obs)
+  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.true(comparePoints(pts, exp))
+
+  // contract -
+  obs = offset({ delta: -0.5, corners: 'round' }, 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.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.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.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], [75, -75]],
+    [[75, -75], [75, 75]],
+    [[-40, 75], [-75, 75]],
+    [[75, 75], [40, 75]],
+    [[40, 75], [40, 0]],
+    [[40, 0], [-40, 0]],
+    [[-40, 0], [-40, 75]],
+    [[15, -10], [15, -40]],
+    [[-15, -10], [15, -10]],
+    [[-15, -40], [-15, -10]],
+    [[-8, -40], [-15, -40]],
+    [[15, -40], [8, -40]],
+    [[-8, -25], [-8, -40]],
+    [[8, -25], [-8, -25]],
+    [[8, -40], [8, -25]],
+    [[-2, -15], [-2, -19]],
+    [[-2, -19], [2, -19]],
+    [[2, -19], [2, -15]],
+    [[2, -15], [-2, -15]]
+  ])
+
+  // expand +
+  const obs = offset({ delta: 2, corners: 'edge' }, geometry)
+  const pts = geom2.toPoints(obs)
+  const exp = [
+    [77, -77],
+    [77, 77],
+    [38, 77],
+    [38, 2],
+    [-38, 2],
+    [-37.99999999999999, 77],
+    [-77, 77],
+    [13, -12],
+    [13, -38],
+    [10, -38],
+    [10, -23],
+    [-10, -23],
+    [-10, -38],
+    [-13, -38],
+    [-13, -12],
+    [-4, -21],
+    [3.9999999999999996, -21],
+    [4, -13],
+    [-4, -13],
+    [-77, -77]
+  ]
+  t.notThrows(() => geom2.validate(obs))
+  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.fromPoints([
+    [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(pts.length, 16)
+  t.true(comparePoints(pts, exp))
+})

package/src/operations/expansions/offsetFromPoints.js

@@ -0,0 +1,170 @@
+const { EPS, TAU } = require('../../maths/constants')
+
+const intersect = require('../../maths/utils/intersect')
+const line2 = require('../../maths/line2')
+const vec2 = require('../../maths/vec2')
+const area = require('../../maths/utils/area')
+
+/*
+ * Create a set of offset points from the given points using the given options (if any).
+ * @param {Object} options - options for offset
+ * @param {Float} [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 {Integer} [options.segments=16] - number of segments when creating round corners
+ * @param {Integer} [options.closed=false] - is the last point connected back to the first point?
+ * @param {Array} points - array of 2D points
+ * @returns {Array} new set of offset points, plus points for each rounded corner
+ */
+const offsetFromPoints = (options, points) => {
+  const defaults = {
+    delta: 1,
+    corners: 'edge',
+    closed: false,
+    segments: 16
+  }
+  let { delta, corners, closed, segments } = Object.assign({ }, defaults, options)
+
+  if (Math.abs(delta) < EPS) return points
+
+  let rotation = options.closed ? area(points) : 1.0 // + counter clockwise, - clockwise
+  if (rotation === 0) rotation = 1.0
+
+  // use right hand normal?
+  const orientation = ((rotation > 0) && (delta >= 0)) || ((rotation < 0) && (delta < 0))
+  delta = Math.abs(delta) // sign is no longer required
+
+  let previousSegment = null
+  let newPoints = []
+  const newCorners = []
+  const of = vec2.create()
+  const n = points.length
+  for (let i = 0; i < n; i++) {
+    const j = (i + 1) % n
+    const p0 = points[i]
+    const p1 = points[j]
+    // calculate the unit normal
+    orientation ? vec2.subtract(of, p0, p1) : vec2.subtract(of, p1, p0)
+    vec2.normal(of, of)
+    vec2.normalize(of, of)
+    // calculate the offset vector
+    vec2.scale(of, of, delta)
+    // calculate the new points (edge)
+    const n0 = vec2.add(vec2.create(), p0, of)
+    const n1 = vec2.add(vec2.create(), p1, of)
+
+    const currentSegment = [n0, n1]
+    if (previousSegment != null) {
+      if (closed || (!closed && j !== 0)) {
+        // check for intersection of new line segments
+        const ip = intersect(previousSegment[0], previousSegment[1], currentSegment[0], currentSegment[1])
+        if (ip) {
+          // adjust the previous points
+          newPoints.pop()
+          // adjust current points
+          currentSegment[0] = ip
+        } else {
+          newCorners.push({ c: p0, s0: previousSegment, s1: currentSegment })
+        }
+      }
+    }
+    previousSegment = [n0, n1]
+
+    if (j === 0 && !closed) continue
+
+    newPoints.push(currentSegment[0])
+    newPoints.push(currentSegment[1])
+  }
+  // complete the closure if required
+  if (closed && previousSegment != null) {
+    // check for intersection of closing line segments
+    const n0 = newPoints[0]
+    const n1 = newPoints[1]
+    const ip = intersect(previousSegment[0], previousSegment[1], n0, n1)
+    if (ip) {
+      // adjust the previous points
+      newPoints[0] = ip
+      newPoints.pop()
+    } else {
+      const p0 = points[0]
+      const cursegment = [n0, n1]
+      newCorners.push({ c: p0, s0: previousSegment, s1: cursegment })
+    }
+  }
+
+  // generate corners if necessary
+
+  if (corners === 'edge') {
+    // map for fast point index lookup
+    const pointIndex = new Map() // {point: index}
+    newPoints.forEach((point, index) => pointIndex.set(point, index))
+
+    // create edge corners
+    const line0 = line2.create()
+    const line1 = line2.create()
+    newCorners.forEach((corner) => {
+      line2.fromPoints(line0, corner.s0[0], corner.s0[1])
+      line2.fromPoints(line1, corner.s1[0], corner.s1[1])
+      const ip = line2.intersectPointOfLines(line0, line1)
+      if (Number.isFinite(ip[0]) && Number.isFinite(ip[1])) {
+        const p0 = corner.s0[1]
+        const i = pointIndex.get(p0)
+        newPoints[i] = ip
+        newPoints[(i + 1) % newPoints.length] = undefined
+      } else {
+        // paralell segments, drop one
+        const p0 = corner.s1[0]
+        const i = pointIndex.get(p0)
+        newPoints[i] = undefined
+      }
+    })
+    newPoints = newPoints.filter((p) => p !== undefined)
+  }
+
+  if (corners === 'round') {
+    // create rounded corners
+    let cornersegments = Math.floor(segments / 4)
+    const v0 = vec2.create()
+    newCorners.forEach((corner) => {
+      // calculate angle of rotation
+      let rotation = vec2.angle(vec2.subtract(v0, corner.s1[0], corner.c))
+      rotation -= vec2.angle(vec2.subtract(v0, corner.s0[1], corner.c))
+      if (orientation && rotation < 0) {
+        rotation = rotation + Math.PI
+        if (rotation < 0) rotation = rotation + Math.PI
+      }
+      if ((!orientation) && rotation > 0) {
+        rotation = rotation - Math.PI
+        if (rotation > 0) rotation = rotation - Math.PI
+      }
+
+      if (rotation !== 0.0) {
+        // generate the segments
+        cornersegments = Math.floor(segments * (Math.abs(rotation) / TAU))
+        const step = rotation / cornersegments
+        const start = vec2.angle(vec2.subtract(v0, corner.s0[1], corner.c))
+        const cornerpoints = []
+        for (let i = 1; i < cornersegments; i++) {
+          const radians = start + (step * i)
+          const point = vec2.fromAngleRadians(vec2.create(), radians)
+          vec2.scale(point, point, delta)
+          vec2.add(point, point, corner.c)
+          cornerpoints.push(point)
+        }
+        if (cornerpoints.length > 0) {
+          const p0 = corner.s0[1]
+          let i = newPoints.findIndex((point) => vec2.equals(p0, point))
+          i = (i + 1) % newPoints.length
+          newPoints.splice(i, 0, ...cornerpoints)
+        }
+      } else {
+        // paralell segments, drop one
+        const p0 = corner.s1[0]
+        const i = newPoints.findIndex((point) => vec2.equals(p0, point))
+        newPoints.splice(i, 1)
+      }
+    })
+  }
+  return newPoints
+}
+
+module.exports = offsetFromPoints