fix: merge same-net collinear traces (#34)

lib/solvers/SameNetTraceMergeSolver.ts

@@ -0,0 +1,71 @@
+import { mergeCollinearTraces } from "../utils/mergeCollinearTraces"
+
+interface Point {
+  x: number
+  y: number
+}
+interface TracePath {
+  points: Point[]
+  globalConnNetId?: string
+  [key: string]: any
+}
+
+export class SameNetTraceMergeSolver {
+  inputTraces: TracePath[]
+  outputTraces: TracePath[] = []
+  solved = false
+
+  constructor({ traces }: { traces: TracePath[] }) {
+    this.inputTraces = traces
+  }
+
+  solve() {
+    const byNet = new Map<string, TracePath[]>()
+    const noNet: TracePath[] = []
+
+    for (const trace of this.inputTraces) {
+      const netId = trace.globalConnNetId
+      if (!netId) {
+        noNet.push(trace)
+        continue
+      }
+      if (!byNet.has(netId)) byNet.set(netId, [])
+      byNet.get(netId)!.push(trace)
+    }
+
+    const merged: TracePath[] = []
+
+    for (const [netId, netTraces] of byNet.entries()) {
+      const segments = netTraces.flatMap((trace) => {
+        const pts = trace.points ?? []
+        const lines = []
+        for (let i = 0; i < pts.length - 1; i++) {
+          lines.push({
+            x1: pts[i].x,
+            y1: pts[i].y,
+            x2: pts[i + 1].x,
+            y2: pts[i + 1].y,
+            netId,
+          })
+        }
+        return lines
+      })
+
+      const mergedSegs = mergeCollinearTraces(segments)
+      const proto = netTraces[0]
+      for (const seg of mergedSegs) {
+        merged.push({
+          ...proto,
+          globalConnNetId: netId,
+          points: [
+            { x: seg.x1, y: seg.y1 },
+            { x: seg.x2, y: seg.y2 },
+          ],
+        })
+      }
+    }
+
+    this.outputTraces = [...merged, ...noNet]
+    this.solved = true
+  }
+}

lib/utils/mergeCollinearTraces.ts

@@ -0,0 +1,92 @@
+const MERGE_THRESHOLD = 0.001
+
+interface Segment {
+  x1: number
+  y1: number
+  x2: number
+  y2: number
+  netId?: string
+}
+
+function mergeSegments(
+  segments: Segment[],
+  axis: "horizontal" | "vertical",
+): Segment[] {
+  if (segments.length === 0) return []
+
+  const coordKey = axis === "horizontal" ? "y1" : "x1"
+  const minKey = axis === "horizontal" ? "x1" : "y1"
+  const maxKey = axis === "horizontal" ? "x2" : "y2"
+
+  const grouped = new Map<number, Segment[]>()
+  for (const seg of segments) {
+    const coord = seg[coordKey]
+    let found = false
+    for (const [key, group] of grouped.entries()) {
+      if (Math.abs(key - coord) <= MERGE_THRESHOLD) {
+        group.push(seg)
+        found = true
+        break
+      }
+    }
+    if (!found) grouped.set(coord, [seg])
+  }
+
+  const result: Segment[] = []
+  for (const [coord, group] of grouped.entries()) {
+    const sorted = [...group].sort((a, b) => a[minKey] - b[minKey])
+    let curMin = sorted[0][minKey]
+    let curMax = sorted[0][maxKey]
+    const netId = sorted[0].netId
+
+    for (let i = 1; i < sorted.length; i++) {
+      const seg = sorted[i]
+      if (seg[minKey] <= curMax + MERGE_THRESHOLD) {
+        curMax = Math.max(curMax, seg[maxKey])
+      } else {
+        result.push(
+          axis === "horizontal"
+            ? { x1: curMin, y1: coord, x2: curMax, y2: coord, netId }
+            : { x1: coord, y1: curMin, x2: coord, y2: curMax, netId },
+        )
+        curMin = seg[minKey]
+        curMax = seg[maxKey]
+      }
+    }
+    result.push(
+      axis === "horizontal"
+        ? { x1: curMin, y1: coord, x2: curMax, y2: coord, netId }
+        : { x1: coord, y1: curMin, x2: coord, y2: curMax, netId },
+    )
+  }
+  return result
+}
+
+export function mergeCollinearTraces(traces: Segment[]): Segment[] {
+  const horizontal: Segment[] = []
+  const vertical: Segment[] = []
+  const diagonal: Segment[] = []
+
+  for (const t of traces) {
+    const norm: Segment = {
+      x1: Math.min(t.x1, t.x2),
+      y1: Math.min(t.y1, t.y2),
+      x2: Math.max(t.x1, t.x2),
+      y2: Math.max(t.y1, t.y2),
+      netId: t.netId,
+    }
+    if (Math.abs(norm.y1 - norm.y2) <= MERGE_THRESHOLD) {
+      horizontal.push({ ...norm, y2: norm.y1 })
+    } else if (Math.abs(norm.x1 - norm.x2) <= MERGE_THRESHOLD) {
+      vertical.push({ ...norm, x2: norm.x1 })
+    } else {
+      diagonal.push(t)
+    }
+  }
+
+  return [
+    ...mergeSegments(horizontal, "horizontal"),
+    ...mergeSegments(vertical, "vertical"),
+    ...diagonal,
+  ]
+}

tests/merge-collinear-traces.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, test } from "bun:test"
+import { mergeCollinearTraces } from "../lib/utils/mergeCollinearTraces"
+
+describe("mergeCollinearTraces", () => {
+  test("merges two overlapping horizontal segments", () => {
+    const r = mergeCollinearTraces([
+      { x1: 0, y1: 5, x2: 4, y2: 5 },
+      { x1: 3, y1: 5, x2: 8, y2: 5 },
+    ])
+    expect(r).toHaveLength(1)
+    expect(r[0]).toMatchObject({ x1: 0, y1: 5, x2: 8, y2: 5 })
+  })
+
+  test("merges two touching horizontal segments", () => {
+    const r = mergeCollinearTraces([
+      { x1: 0, y1: 5, x2: 4, y2: 5 },
+      { x1: 4, y1: 5, x2: 8, y2: 5 },
+    ])
+    expect(r).toHaveLength(1)
+    expect(r[0]).toMatchObject({ x1: 0, y1: 5, x2: 8, y2: 5 })
+  })
+
+  test("does not merge segments on different Y", () => {
+    const r = mergeCollinearTraces([
+      { x1: 0, y1: 5, x2: 4, y2: 5 },
+      { x1: 0, y1: 6, x2: 4, y2: 6 },
+    ])
+    expect(r).toHaveLength(2)
+  })
+
+  test("merges two overlapping vertical segments", () => {
+    const r = mergeCollinearTraces([
+      { x1: 3, y1: 0, x2: 3, y2: 4 },
+      { x1: 3, y1: 3, x2: 3, y2: 8 },
+    ])
+    expect(r).toHaveLength(1)
+    expect(r[0]).toMatchObject({ x1: 3, y1: 0, x2: 3, y2: 8 })
+  })
+
+  test("does not merge diagonal segments", () => {
+    const r = mergeCollinearTraces([
+      { x1: 0, y1: 0, x2: 4, y2: 4 },
+      { x1: 2, y1: 2, x2: 6, y2: 6 },
+    ])
+    expect(r).toHaveLength(2)
+  })
+
+  test("does not merge segments with a gap", () => {
+    const r = mergeCollinearTraces([
+      { x1: 0, y1: 5, x2: 3, y2: 5 },
+      { x1: 5, y1: 5, x2: 8, y2: 5 },
+    ])
+    expect(r).toHaveLength(2)
+  })
+
+  test("merges 3 collinear segments into one", () => {
+    const r = mergeCollinearTraces([
+      { x1: 0, y1: 0, x2: 2, y2: 0 },
+      { x1: 2, y1: 0, x2: 5, y2: 0 },
+      { x1: 4, y1: 0, x2: 8, y2: 0 },
+    ])
+    expect(r).toHaveLength(1)
+    expect(r[0]).toMatchObject({ x1: 0, y1: 0, x2: 8, y2: 0 })
+  })
+
+  test("handles reversed segment direction", () => {
+    const r = mergeCollinearTraces([
+      { x1: 4, y1: 5, x2: 0, y2: 5 },
+      { x1: 8, y1: 5, x2: 3, y2: 5 },
+    ])
+    expect(r).toHaveLength(1)
+    expect(r[0]).toMatchObject({ x1: 0, y1: 5, x2: 8, y2: 5 })
+  })
+})