@eturnity/eturnity_maths 9.25.0-panel-placement.0 → 9.25.0-panel-placement.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eturnity/eturnity_maths",
-  "version": "9.25.0-panel-placement.0",
+  "version": "9.25.0-panel-placement.1",
   "author": "Eturnity Team",
   "main": "src/index.js",
   "private": false,
@@ -19,6 +19,7 @@
   "dependencies": {
     "cdt2d": "1.0.0",
     "lodash": "4.17.21",
+    "earcut": "2.2.4",
     "planar-face-discovery": "2.0.7",
     "point-in-polygon": "1.1.0",
     "rbush": "3.0.1",

package/src/index.js

@@ -18,3 +18,4 @@ export * from './panelFunctions'
 export * from './stringPatchMatching'
 export * from './plane'
 export * from './gridStAffine'
+export * from './straightSkeleton'

package/src/objects/Roof.js

@@ -1,4 +1,5 @@
 import { Polygon } from './Polygon'
+import { computeStraightSkeleton } from '../straightSkeleton'
 
 export class Roof extends Polygon {
   constructor(outline = [], isClosed = true) {
@@ -6,6 +7,26 @@ export class Roof extends Polygon {
     this.moduleFields = []
   }
 
+  // Straight skeleton (ridges/hips/valleys + roof facets) of the roof outline,
+  // projected on the horizontal xy plane. See computeStraightSkeleton.
+  computeStraightSkeleton(options) {
+    return computeStraightSkeleton(this.outline, options)
+  }
+
+  // Cached straight skeleton, only recomputed when the geometry (version)
+  // changes. Mirrors getAABB.
+  getStraightSkeleton(options) {
+    if (
+      this._straightSkeleton &&
+      this._straightSkeletonVersion === this.version
+    ) {
+      return this._straightSkeleton
+    }
+    this._straightSkeleton = this.computeStraightSkeleton(options)
+    this._straightSkeletonVersion = this.version
+    return this._straightSkeleton
+  }
+
   _serializeExtra() {
     return {
       moduleFields: this.moduleFields.map((m) => ({ id: m.id })),

package/src/segmentVoronoi.scratch.test.js

@@ -0,0 +1,51 @@
+import { computeSegmentVoronoiRegions } from './segmentVoronoi'
+import { calcPolygonArea } from './geometry'
+
+const square = [
+  { x: 0, y: 0 },
+  { x: 10, y: 0 },
+  { x: 10, y: 10 },
+  { x: 0, y: 10 },
+]
+
+function totalArea(region) {
+  return region.outlines.reduce((s, o) => s + calcPolygonArea(o), 0)
+}
+
+test('single segment -> region covers whole outline', () => {
+  const segs = [[{ x: 2, y: 5 }, { x: 8, y: 5 }]]
+  const regions = computeSegmentVoronoiRegions(square, segs)
+  expect(regions).toHaveLength(1)
+  expect(totalArea(regions[0])).toBeCloseTo(100, 0)
+})
+
+test('two horizontal segments -> split roughly in half', () => {
+  const segs = [
+    [{ x: 2, y: 2.5 }, { x: 8, y: 2.5 }],
+    [{ x: 2, y: 7.5 }, { x: 8, y: 7.5 }],
+  ]
+  const regions = computeSegmentVoronoiRegions(square, segs)
+  expect(regions).toHaveLength(2)
+  const a0 = totalArea(regions[0])
+  const a1 = totalArea(regions[1])
+  console.log('areas', a0, a1, 'loops', regions.map((r) => r.outlines.length))
+  expect(a0).toBeCloseTo(50, 0)
+  expect(a1).toBeCloseTo(50, 0)
+})
+
+test('four points (vertical+horizontal cross via 4 short segs) areas sum to total', () => {
+  const segs = [
+    [{ x: 2.5, y: 2.5 }, { x: 2.5, y: 2.5 }],
+    [{ x: 7.5, y: 2.5 }, { x: 7.5, y: 2.5 }],
+    [{ x: 2.5, y: 7.5 }, { x: 2.5, y: 7.5 }],
+    [{ x: 7.5, y: 7.5 }, { x: 7.5, y: 7.5 }],
+  ]
+  const regions = computeSegmentVoronoiRegions(square, segs)
+  const total = regions.reduce((s, r) => s + totalArea(r), 0)
+  console.log(
+    'quad areas',
+    regions.map((r) => totalArea(r).toFixed(2))
+  )
+  expect(total).toBeCloseTo(100, 0)
+  regions.forEach((r) => expect(totalArea(r)).toBeCloseTo(25, 0))
+})

package/src/straightSkeleton.js

@@ -0,0 +1,530 @@
+import TinyQueue from 'tinyqueue'
+import { getOutlineList } from './splitMergePolygons'
+import { calcPolygonArea, get2DBoundOfPolygon } from './geometry'
+
+/**
+ * Computes the straight skeleton of a closed outline (projected on the
+ * horizontal xy plane) and the roof facets it induces.
+ *
+ * The straight skeleton is the uniform-pitch "roof" of a simple polygon: every
+ * outline edge sweeps inward at the same speed and the traced corners form the
+ * ridges, hips and valleys. Because the boundaries are angle bisectors of
+ * straight edges, every skeleton edge is a straight segment (no parabolic arcs,
+ * unlike a segment Voronoi diagram / medial axis). Concave (reflex) outlines
+ * are supported through split events.
+ *
+ * Each output point carries a z coordinate forming a uniform-pitch roof of
+ * slope `options.slopeDegrees`: the eaves (outline) sit at z = 0 and every
+ * ridge/hip node rises by `(horizontal distance from the eaves) * tan(slope)`.
+ *
+ * @param {Array<{x:number,y:number,z?:number}>} outline - Closed simple polygon
+ *   (>= 3 points, no holes, no self-intersection). Only x/y are used.
+ * @param {Object} [options]
+ * @param {number} [options.slopeDegrees=30] - Roof pitch in degrees, used to
+ *   derive the z (height) of the skeleton/facet vertices. 0 gives a flat roof.
+ * @param {number} [options.tolerance] - Geometric tolerance. Defaults to a
+ *   small fraction of the outline bounding-box diagonal.
+ * @returns {{skeleton: Array<[{x,y,z},{x,y,z}]>, faces: Array<Array<{x,y,z}>>}}
+ *   `skeleton` is the list of internal edges (ridges/hips/valleys) as point
+ *   pairs; `faces` is one outline per roof facet. z encodes the roof height.
+ */
+export function computeStraightSkeleton(outline, options = {}) {
+  if (!Array.isArray(outline) || outline.length < 3) {
+    throw new Error('computeStraightSkeleton: outline must have >= 3 points')
+  }
+  const bound = get2DBoundOfPolygon(outline)
+  const diagonal = Math.hypot(bound.xMax - bound.xMin, bound.yMax - bound.yMin)
+  const eps =
+    options.tolerance > 0 ? options.tolerance : Math.max(1e-9, diagonal * 1e-9)
+
+  const ring = normalizeOutline(outline, eps)
+  if (ring.length < 3) {
+    return { skeleton: [], faces: [] }
+  }
+
+  // Symbolic perturbation: rectilinear roof outlines are riddled with parallel
+  // edges, right angles and simultaneous events, all degenerate for the
+  // event-driven skeleton. A sub-millimetre jitter breaks those degeneracies
+  // so the generic edge/split events apply; faces are then rebuilt against the
+  // *original* outline so the perturbation never reaches the output geometry.
+  const jitter = diagonal * 1e-6
+  const perturbed = ring.map((p, i) => ({
+    x: p.x + (hash(i * 2 + 1) * 2 - 1) * jitter,
+    y: p.y + (hash(i * 2 + 2) * 2 - 1) * jitter,
+  }))
+
+  // Roof height: each skeleton node carries its wavefront "time" t, i.e. its
+  // horizontal distance from the eaves, so for a uniform slope the height is
+  // z = t * tan(slope). Eaves (the outline) stay at z = 0.
+  const slopeDegrees = Number.isFinite(options.slopeDegrees)
+    ? options.slopeDegrees
+    : 30
+  const slopeFactor = Math.tan((slopeDegrees * Math.PI) / 180)
+
+  const rawSkeleton = buildSkeleton(perturbed, eps)
+  // Weld skeleton nodes (and snap them onto the original outline vertices) to
+  // erase the perturbation, then rebuild the facets from the clean geometry.
+  const cleaned = cleanSkeleton(rawSkeleton, ring, jitter * 8)
+  const faces = buildFaces(
+    ring,
+    cleaned,
+    Math.max(eps, jitter * 8),
+    slopeFactor
+  )
+  const skeleton = cleaned.map(([a, b]) => [
+    { x: a.x, y: a.y, z: a.t * slopeFactor },
+    { x: b.x, y: b.y, z: b.t * slopeFactor },
+  ])
+  return { skeleton, faces }
+}
+
+// --- outline normalization -------------------------------------------------
+
+/** Drops duplicate / collinear points and forces counter-clockwise order. */
+function normalizeOutline(outline, eps) {
+  let pts = outline.map((p) => ({ x: p.x, y: p.y }))
+  // remove consecutive duplicates
+  pts = pts.filter((p, i) => {
+    const q = pts[(i - 1 + pts.length) % pts.length]
+    return Math.hypot(p.x - q.x, p.y - q.y) > eps
+  })
+  // ensure CCW (positive signed area)
+  if (signedArea(pts) < 0) pts.reverse()
+  return pts
+}
+
+/** Deterministic pseudo-random in [0,1) used for symbolic perturbation. */
+function hash(i) {
+  const s = Math.sin(i * 12.9898) * 43758.5453
+  return s - Math.floor(s)
+}
+
+function signedArea(pts) {
+  let s = 0
+  for (let i = 0; i < pts.length; i++) {
+    const a = pts[i]
+    const b = pts[(i + 1) % pts.length]
+    s += a.x * b.y - b.x * a.y
+  }
+  return s / 2
+}
+
+// --- linear algebra helpers ------------------------------------------------
+
+const sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y })
+const add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y })
+const scale = (a, s) => ({ x: a.x * s, y: a.y * s })
+const dot = (a, b) => a.x * b.x + a.y * b.y
+const cross = (a, b) => a.x * b.y - a.y * b.x
+const len = (a) => Math.hypot(a.x, a.y)
+const norm = (a) => {
+  const l = len(a)
+  return l === 0 ? { x: 0, y: 0 } : { x: a.x / l, y: a.y / l }
+}
+
+/** Inward (left) unit normal of an edge directed a -> b (CCW polygon). */
+function inwardNormal(a, b) {
+  const d = norm(sub(b, a))
+  return { x: -d.y, y: d.x }
+}
+
+/**
+ * Velocity of the vertex sitting between edges with inward normals nL, nR:
+ * the vector v with v·nL = 1 and v·nR = 1 (stays on both inward-moving lines).
+ */
+function bisectorVelocity(nL, nR) {
+  const det = nL.x * nR.y - nL.y * nR.x
+  if (Math.abs(det) < 1e-12) {
+    // (anti)parallel edges -> straight angle, move along the shared normal
+    return { x: nL.x, y: nL.y }
+  }
+  return {
+    x: (nR.y - nL.y) / det,
+    y: (nL.x - nR.x) / det,
+  }
+}
+
+/**
+ * Intersection parameter `s` along ray (p1, d1) with ray (p2, d2):
+ * p1 + s*d1 = p2 + u*d2. Returns {s, u} or null when parallel.
+ */
+function rayRay(p1, d1, p2, d2) {
+  const det = d2.x * d1.y - d1.x * d2.y
+  if (Math.abs(det) < 1e-15) return null
+  const dx = p2.x - p1.x
+  const dy = p2.y - p1.y
+  const s = (-dx * d2.y + d2.x * dy) / det
+  const u = (-dx * d1.y + d1.x * dy) / det
+  return { s, u }
+}
+
+// --- skeleton construction (Felkel & Obdrzalek) ----------------------------
+
+function buildSkeleton(ring, eps) {
+  const n = ring.length
+  // original edges as { p, dir, normal }
+  const edges = ring.map((p, i) => {
+    const q = ring[(i + 1) % n]
+    return { p, dir: norm(sub(q, p)), normal: inwardNormal(p, q) }
+  })
+
+  // initial vertices: vertex i sits between edge i-1 (left) and edge i (right)
+  let uid = 0
+  const vertices = ring.map((p, i) => ({
+    id: uid++,
+    pos: { x: p.x, y: p.y },
+    time: 0,
+    edgeLeft: edges[(i - 1 + n) % n],
+    edgeRight: edges[i],
+    prev: null,
+    next: null,
+    bisector: null,
+    reflex: false,
+    processed: false,
+  }))
+  for (let i = 0; i < n; i++) {
+    vertices[i].prev = vertices[(i - 1 + n) % n]
+    vertices[i].next = vertices[(i + 1) % n]
+  }
+  vertices.forEach((v) => initVertex(v))
+
+  const allEdges = edges
+  const skeleton = []
+  const queue = new TinyQueue([], (a, b) => a.time - b.time)
+
+  vertices.forEach((v) => {
+    const ev = nextEventForVertex(v, allEdges, eps)
+    if (ev) queue.push(ev)
+  })
+
+  let guard = 0
+  const guardMax = 100 * n * n + 1000
+  while (queue.length > 0) {
+    if (guard++ > guardMax) break
+    const ev = queue.pop()
+    if (ev.type === 'edge') {
+      const { va, vb } = ev
+      if (va.processed || vb.processed) continue
+      if (va.next !== vb) continue
+      handleEdgeEvent(ev, skeleton, allEdges, queue, eps, () => uid++)
+    } else {
+      const { v } = ev
+      if (v.processed) continue
+      // re-locate the live edge instance that contains the split point
+      const span = findEdgeSpan(v, ev.edge, ev.point, eps)
+      if (!span) continue
+      handleSplitEvent(ev, span, skeleton, allEdges, queue, eps, () => uid++)
+    }
+  }
+
+  return skeleton.map(([a, b]) => [
+    { x: a.x, y: a.y, t: a.t },
+    { x: b.x, y: b.y, t: b.t },
+  ])
+}
+
+function initVertex(v) {
+  v.bisector = bisectorVelocity(v.edgeLeft.normal, v.edgeRight.normal)
+  // reflex if the turn from incoming to outgoing edge is a right turn (CCW poly)
+  v.reflex = cross(v.edgeLeft.dir, v.edgeRight.dir) < 0
+}
+
+function posAt(v, t) {
+  return add(v.pos, scale(v.bisector, t - v.time))
+}
+
+/** Earliest of: edge event with v.next, and (if reflex) a split event. */
+function nextEventForVertex(v, allEdges, eps) {
+  const candidates = []
+  const e = edgeEvent(v, eps)
+  if (e) candidates.push(e)
+  if (v.reflex) {
+    const s = splitEvent(v, allEdges, eps)
+    if (s) candidates.push(s)
+  }
+  if (candidates.length === 0) return null
+  return candidates.reduce((a, b) => (a.time <= b.time ? a : b))
+}
+
+function edgeEvent(v, eps) {
+  const b = v.next
+  if (!b || b === v) return null
+  const r = rayRay(v.pos, v.bisector, b.pos, b.bisector)
+  if (!r) return null
+  const t = v.time + r.s
+  if (r.s < -eps) return null
+  if (t < v.time - eps || t < b.time - eps) return null
+  return { type: 'edge', time: t, point: posAt(v, t), va: v, vb: b }
+}
+
+function splitEvent(v, allEdges, eps) {
+  let best = null
+  for (const E of allEdges) {
+    if (E === v.edgeLeft || E === v.edgeRight) continue
+    const denom = 1 - dot(v.bisector, E.normal)
+    if (Math.abs(denom) < 1e-12) continue
+    const s = (dot(sub(v.pos, E.p), E.normal) - v.time) / denom
+    if (s < eps) continue
+    const t = v.time + s
+    const P = posAt(v, t)
+    // must be on the interior side of E
+    if (dot(sub(P, E.p), E.normal) < eps) continue
+    // crude pre-filter: P roughly on E's line span will be re-checked at pop
+    if (!best || t < best.time) {
+      best = { type: 'split', time: t, point: P, v, edge: E }
+    }
+  }
+  return best
+}
+
+/**
+ * Finds the currently-active vertex pair (va, va.next) whose shared edge is the
+ * original edge `E` and whose bisector wedge contains `point`. Returns null
+ * when the split point is no longer valid for this edge.
+ */
+function findEdgeSpan(v, E, point, eps) {
+  // walk v's own LAV looking for the edge instance
+  const start = v
+  let cur = start
+  let guard = 0
+  do {
+    if (!cur.processed && cur.edgeRight === E) {
+      const va = cur
+      const vb = cur.next
+      if (vb && !vb.processed && pointInWedge(point, va, vb, E, eps)) {
+        return { va, vb }
+      }
+    }
+    cur = cur.next
+    guard++
+  } while (cur && cur !== start && guard < 100000)
+  return null
+}
+
+/** True when `P` lies in the live trapezoid of edge E bounded by the bisectors
+ *  of its two end vertices. */
+function pointInWedge(P, va, vb, E, eps) {
+  if (dot(sub(P, E.p), E.normal) < -eps) return false
+  // left bound: bisector leaving va; right bound: bisector leaving vb
+  const leftOk = cross(va.bisector, sub(P, va.pos)) <= eps
+  const rightOk = cross(vb.bisector, sub(P, vb.pos)) >= -eps
+  return leftOk && rightOk
+}
+
+function handleEdgeEvent(ev, skeleton, allEdges, queue, eps, nextUid) {
+  const { va, vb, point, time } = ev
+  va.processed = true
+  vb.processed = true
+  pushArc(skeleton, withTime(va.pos, va.time), withTime(point, time), eps)
+  pushArc(skeleton, withTime(vb.pos, vb.time), withTime(point, time), eps)
+
+  const prev = va.prev
+  const next = vb.next
+
+  // triangle / final collapse
+  if (prev === vb || next === va || prev === next) {
+    // remaining wavefront collapses to this point
+    if (prev && prev !== va && prev !== vb) {
+      prev.processed = true
+      pushArc(
+        skeleton,
+        withTime(prev.pos, prev.time),
+        withTime(point, time),
+        eps
+      )
+    }
+    return
+  }
+
+  const nv = {
+    id: nextUid(),
+    pos: { x: point.x, y: point.y },
+    time,
+    edgeLeft: va.edgeLeft,
+    edgeRight: vb.edgeRight,
+    prev,
+    next,
+    bisector: null,
+    reflex: false,
+    processed: false,
+  }
+  prev.next = nv
+  next.prev = nv
+  initVertex(nv)
+
+  const e = nextEventForVertex(nv, allEdges, eps)
+  if (e) queue.push(e)
+}
+
+function handleSplitEvent(ev, span, skeleton, allEdges, queue, eps, nextUid) {
+  const { v, point, time } = ev
+  const { va, vb } = span
+  v.processed = true
+  pushArc(skeleton, withTime(v.pos, v.time), withTime(point, time), eps)
+
+  // chain A: v.prev -> v1 -> vb -> ... (v1 carries v.edgeLeft and edge E)
+  const v1 = {
+    id: nextUid(),
+    pos: { x: point.x, y: point.y },
+    time,
+    edgeLeft: v.edgeLeft,
+    edgeRight: ev.edge,
+    prev: v.prev,
+    next: vb,
+    bisector: null,
+    reflex: false,
+    processed: false,
+  }
+  // chain B: va -> v2 -> v.next -> ... (v2 carries edge E and v.edgeRight)
+  const v2 = {
+    id: nextUid(),
+    pos: { x: point.x, y: point.y },
+    time,
+    edgeLeft: ev.edge,
+    edgeRight: v.edgeRight,
+    prev: va,
+    next: v.next,
+    bisector: null,
+    reflex: false,
+    processed: false,
+  }
+  v.prev.next = v1
+  vb.prev = v1
+  va.next = v2
+  v.next.prev = v2
+  initVertex(v1)
+  initVertex(v2)
+
+  collapseIfDegenerate(v1, skeleton, eps)
+  collapseIfDegenerate(v2, skeleton, eps)
+
+  for (const nv of [v1, v2]) {
+    if (nv.processed) continue
+    const e = nextEventForVertex(nv, allEdges, eps)
+    if (e) queue.push(e)
+  }
+}
+
+/** Handles a fresh vertex that is already part of a 1- or 2-vertex loop. */
+function collapseIfDegenerate(nv, skeleton, eps) {
+  if (nv.processed) return
+  if (nv.next === nv) {
+    nv.processed = true
+    return
+  }
+  if (nv.next && nv.next.next === nv) {
+    // 2-vertex loop: both edges collapse onto the segment between them
+    const other = nv.next
+    nv.processed = true
+    other.processed = true
+    pushArc(
+      skeleton,
+      withTime(nv.pos, nv.time),
+      withTime(other.pos, other.time),
+      eps
+    )
+  }
+}
+
+// Tags a position with the wavefront time it was reached at (= its horizontal
+// distance from the eaves), used downstream to derive the roof height.
+function withTime(p, t) {
+  return { x: p.x, y: p.y, t }
+}
+
+function pushArc(skeleton, a, b, eps) {
+  if (Math.hypot(a.x - b.x, a.y - b.y) <= eps) return
+  skeleton.push([
+    { x: a.x, y: a.y, t: a.t },
+    { x: b.x, y: b.y, t: b.t },
+  ])
+}
+
+/**
+ * Clusters skeleton endpoints (welding the perturbed duplicates), snaps any
+ * cluster that sits on an original outline vertex back onto it, and drops
+ * degenerate segments.
+ */
+function cleanSkeleton(skeleton, ring, tol) {
+  const reps = []
+  const snap = (p) => {
+    for (const r of reps) {
+      if (Math.hypot(r.x - p.x, r.y - p.y) <= tol) return r
+    }
+    const r = { x: p.x, y: p.y, t: p.t || 0 }
+    reps.push(r)
+    return r
+  }
+  // seed clusters with the exact outline vertices (height 0) so endpoints snap
+  // onto them
+  ring.forEach((p) => reps.push({ x: p.x, y: p.y, t: 0 }))
+
+  const out = []
+  const seen = new Set()
+  skeleton.forEach(([a, b]) => {
+    const ra = snap(a)
+    const rb = snap(b)
+    if (Math.hypot(ra.x - rb.x, ra.y - rb.y) <= tol) return
+    const key = `${reps.indexOf(ra)}_${reps.indexOf(rb)}`
+    const rev = `${reps.indexOf(rb)}_${reps.indexOf(ra)}`
+    if (seen.has(key) || seen.has(rev)) return
+    seen.add(key)
+    out.push([
+      { x: ra.x, y: ra.y, t: ra.t },
+      { x: rb.x, y: rb.y, t: rb.t },
+    ])
+  })
+  return out
+}
+
+// --- facet extraction ------------------------------------------------------
+
+/**
+ * Builds roof facets by overlaying the outline and the skeleton segments into a
+ * planar arrangement and reading back its bounded faces.
+ */
+function buildFaces(ring, skeleton, eps, slopeFactor) {
+  const n = ring.length
+  const rawEdges = []
+  for (let i = 0; i < n; i++) {
+    rawEdges.push([ring[i], ring[(i + 1) % n]])
+  }
+  skeleton.forEach(([a, b]) => rawEdges.push([a, b]))
+
+  // weld endpoints into a node list; z is the roof height derived from each
+  // node's wavefront time t (outline vertices have no t -> eave height 0).
+  const nodes = []
+  const weld = (p) => {
+    for (let i = 0; i < nodes.length; i++) {
+      if (Math.hypot(nodes[i].x - p.x, nodes[i].y - p.y) <= eps * 100) return i
+    }
+    nodes.push({ x: p.x, y: p.y, z: (p.t || 0) * slopeFactor })
+    return nodes.length - 1
+  }
+  const edgeList = []
+  const seen = new Set()
+  rawEdges.forEach(([a, b]) => {
+    const ia = weld(a)
+    const ib = weld(b)
+    if (ia === ib) return
+    const key = ia < ib ? `${ia}_${ib}` : `${ib}_${ia}`
+    if (seen.has(key)) return
+    seen.add(key)
+    edgeList.push([ia, ib])
+  })
+
+  let faces
+  try {
+    faces = getOutlineList(nodes, edgeList).map((f) => f.outline)
+  } catch (err) {
+    return []
+  }
+
+  const totalArea = Math.abs(calcPolygonArea(ring))
+  return faces
+    .filter((f) => {
+      const a = calcPolygonArea(f)
+      return a > totalArea * 1e-4 && a < totalArea * (1 - 1e-4)
+    })
+    .map((f) => f.map((p) => ({ x: p.x, y: p.y, z: p.z || 0 })))
+}

package/src/tests/straightSkeleton/roofStraightSkeleton.spec.js

@@ -0,0 +1,45 @@
+import { Roof, calcPolygonArea } from '../../index'
+
+const area = (poly) => Math.abs(calcPolygonArea(poly))
+const sumFaces = (faces) => faces.reduce((s, f) => s + area(f), 0)
+
+const rectangle = [
+  { x: 0, y: 0, z: 0 },
+  { x: 20, y: 0, z: 0 },
+  { x: 20, y: 10, z: 0 },
+  { x: 0, y: 10, z: 0 },
+]
+
+describe('Roof.getStraightSkeleton', () => {
+  test('computes facets that tile the roof outline', () => {
+    const roof = new Roof(rectangle)
+    const { skeleton, faces } = roof.getStraightSkeleton()
+    expect(skeleton.length).toBeGreaterThan(0)
+    expect(sumFaces(faces)).toBeCloseTo(200, 4)
+  })
+
+  test('caches the result for the same version', () => {
+    const roof = new Roof(rectangle)
+    const first = roof.getStraightSkeleton()
+    const second = roof.getStraightSkeleton()
+    expect(second).toBe(first) // same reference, not recomputed
+  })
+
+  test('recomputes when the version changes', () => {
+    const roof = new Roof(rectangle)
+    const first = roof.getStraightSkeleton()
+
+    // simulate a geometry edit
+    roof.outline = [
+      { x: 0, y: 0, z: 0 },
+      { x: 30, y: 0, z: 0 },
+      { x: 30, y: 10, z: 0 },
+      { x: 0, y: 10, z: 0 },
+    ]
+    roof.version += 1
+
+    const second = roof.getStraightSkeleton()
+    expect(second).not.toBe(first)
+    expect(sumFaces(second.faces)).toBeCloseTo(300, 4)
+  })
+})

package/src/tests/straightSkeleton/straightSkeleton.spec.js

@@ -0,0 +1,188 @@
+import {
+  computeStraightSkeleton,
+  calcPolygonArea,
+  isInsidePolygon,
+} from '../../index'
+
+const area = (poly) => Math.abs(calcPolygonArea(poly))
+const sumFaces = (faces) => faces.reduce((s, f) => s + area(f), 0)
+
+// Every skeleton node must lie inside (or on) the outline.
+const skeletonInside = (skeleton, outline) =>
+  skeleton.every(([a, b]) =>
+    [a, b].every(
+      (p) =>
+        isInsidePolygon({ x: p.x, y: p.y, z: 0 }, outline) ||
+        distanceToOutline(p, outline) < 1e-6
+    )
+  )
+
+const distanceToOutline = (p, outline) => {
+  let min = Infinity
+  for (let i = 0; i < outline.length; i++) {
+    const a = outline[i]
+    const b = outline[(i + 1) % outline.length]
+    min = Math.min(min, distToSeg(p, a, b))
+  }
+  return min
+}
+const distToSeg = (p, a, b) => {
+  const dx = b.x - a.x
+  const dy = b.y - a.y
+  const l2 = dx * dx + dy * dy
+  let t = l2 ? ((p.x - a.x) * dx + (p.y - a.y) * dy) / l2 : 0
+  t = Math.max(0, Math.min(1, t))
+  return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy))
+}
+
+describe('computeStraightSkeleton', () => {
+  const cases = [
+    {
+      name: 'rectangle',
+      outline: [
+        { x: 0, y: 0 },
+        { x: 20, y: 0 },
+        { x: 20, y: 10 },
+        { x: 0, y: 10 },
+      ],
+      expectedArea: 200,
+      expectedFaces: 4,
+    },
+    {
+      name: 'square',
+      outline: [
+        { x: 0, y: 0 },
+        { x: 10, y: 0 },
+        { x: 10, y: 10 },
+        { x: 0, y: 10 },
+      ],
+      expectedArea: 100,
+    },
+    {
+      name: 'right triangle',
+      outline: [
+        { x: 0, y: 0 },
+        { x: 12, y: 0 },
+        { x: 0, y: 9 },
+      ],
+      expectedArea: 54,
+      expectedFaces: 3,
+    },
+    {
+      name: 'L-shape (1 reflex / split)',
+      outline: [
+        { x: 0, y: 0 },
+        { x: 10, y: 0 },
+        { x: 10, y: 4 },
+        { x: 4, y: 4 },
+        { x: 4, y: 10 },
+        { x: 0, y: 10 },
+      ],
+      expectedArea: 64,
+      expectedFaces: 6,
+    },
+    {
+      name: 'T-shape (2 reflex)',
+      outline: [
+        { x: 0, y: 6 },
+        { x: 4, y: 6 },
+        { x: 4, y: 0 },
+        { x: 6, y: 0 },
+        { x: 6, y: 6 },
+        { x: 10, y: 6 },
+        { x: 10, y: 9 },
+        { x: 0, y: 9 },
+      ],
+      expectedArea: 2 * 6 + 10 * 3, // stem 2x6=12 + bar 10x3=30
+    },
+    {
+      name: 'plus / cross (4 reflex)',
+      outline: [
+        { x: 1, y: 0 },
+        { x: 2, y: 0 },
+        { x: 2, y: 1 },
+        { x: 3, y: 1 },
+        { x: 3, y: 2 },
+        { x: 2, y: 2 },
+        { x: 2, y: 3 },
+        { x: 1, y: 3 },
+        { x: 1, y: 2 },
+        { x: 0, y: 2 },
+        { x: 0, y: 1 },
+        { x: 1, y: 1 },
+      ],
+      expectedArea: 5,
+    },
+    {
+      name: 'rotated (non axis-aligned) quad',
+      outline: [
+        { x: 0, y: 0 },
+        { x: 8, y: 3 },
+        { x: 5, y: 11 },
+        { x: -3, y: 8 },
+      ],
+      // area via shoelace of the rotated square (side ~8.54) = ~73
+      expectedArea: undefined,
+    },
+  ]
+
+  cases.forEach(({ name, outline, expectedArea, expectedFaces }) => {
+    test(`${name}: facets tile the outline and skeleton stays inside`, () => {
+      const { skeleton, faces } = computeStraightSkeleton(outline)
+      const total = area(outline)
+      expect(faces.length).toBeGreaterThanOrEqual(3)
+      expect(sumFaces(faces)).toBeCloseTo(total, 4)
+      if (expectedArea !== undefined) {
+        expect(total).toBeCloseTo(expectedArea, 4)
+      }
+      if (expectedFaces !== undefined) {
+        expect(faces.length).toBe(expectedFaces)
+      }
+      expect(skeletonInside(skeleton, outline)).toBe(true)
+    })
+  })
+
+  test('throws on degenerate outline', () => {
+    expect(() => computeStraightSkeleton([{ x: 0, y: 0 }])).toThrow()
+  })
+
+  test('z encodes the requested slope (peak height = inradius * tan(slope))', () => {
+    const square = [
+      { x: 0, y: 0 },
+      { x: 10, y: 0 },
+      { x: 10, y: 10 },
+      { x: 0, y: 10 },
+    ]
+    const inradius = 5
+    // default 30°
+    const { skeleton, faces } = computeStraightSkeleton(square)
+    const peakZ = Math.max(...skeleton.flat().map((p) => p.z))
+    expect(peakZ).toBeCloseTo(inradius * Math.tan((30 * Math.PI) / 180), 3)
+    // eaves stay at 0
+    const allFaceZ = faces.flat().map((p) => p.z)
+    expect(Math.min(...allFaceZ)).toBeCloseTo(0, 6)
+    expect(Math.max(...allFaceZ)).toBeCloseTo(peakZ, 3)
+
+    // custom slope is honoured; flat roof gives z = 0
+    const at45 = computeStraightSkeleton(square, { slopeDegrees: 45 })
+    expect(Math.max(...at45.skeleton.flat().map((p) => p.z))).toBeCloseTo(
+      inradius * Math.tan((45 * Math.PI) / 180),
+      3
+    )
+    const flat = computeStraightSkeleton(square, { slopeDegrees: 0 })
+    expect(Math.max(...flat.skeleton.flat().map((p) => p.z))).toBeCloseTo(0, 6)
+  })
+
+  test('rectangle ridge sits at half-span height', () => {
+    const rect = [
+      { x: 0, y: 0 },
+      { x: 20, y: 0 },
+      { x: 20, y: 10 },
+      { x: 0, y: 10 },
+    ]
+    const { skeleton } = computeStraightSkeleton(rect, { slopeDegrees: 30 })
+    const peakZ = Math.max(...skeleton.flat().map((p) => p.z))
+    // ridge runs at y=5, half-span 5 from the long eaves
+    expect(peakZ).toBeCloseTo(5 * Math.tan((30 * Math.PI) / 180), 3)
+  })
+})