feat: handle direct straight-line trace when possible

lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver.ts

@@ -76,8 +76,34 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
         pin._facingDirection = getPinDirection(pin, chip)
       }
     }
-
     const [pin1, pin2] = this.pins
+
+    // Attempt direct straight-line connection if pins are aligned
+    const EPS = 1e-6
+    const isDirectVertical = Math.abs(pin1.x - pin2.x) < EPS
+    const isDirectHorizontal = Math.abs(pin1.y - pin2.y) < EPS
+    if (isDirectVertical || isDirectHorizontal) {
+      const directPath = [
+        { x: pin1.x, y: pin1.y },
+        { x: pin2.x, y: pin2.y },
+      ]
+      const excludeChipIds = Array.from(new Set(this.pins.map((p) => p.chipId)))
+      const intersects =
+        this.chipObstacleSpatialIndex.doesOrthogonalLineIntersectChip(
+          directPath,
+          { excludeChipIds },
+        )
+      if (!intersects) {
+        this.solvedTracePath = directPath
+        this.solved = true
+        this.baseElbow = directPath
+        this.movableSegments = []
+        this.allCandidatePaths = [directPath]
+        this.queuedCandidatePaths = [directPath]
+        return
+      }
+    }
+
     this.baseElbow = calculateElbow(
       {
         x: pin1.x,

lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts

@@ -61,8 +61,27 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     this.obstacles = getObstacleRects(this.inputProblem)
     this.rectById = new Map(this.obstacles.map((r) => [r.chipId, r]))
 
-    // Build initial elbow path
     const [pin1, pin2] = this.pins
+
+    // Attempt direct straight-line connection if pins are aligned
+    const EPS = 1e-6
+    const isDirectVertical = Math.abs(pin1.x - pin2.x) < EPS
+    const isDirectHorizontal = Math.abs(pin1.y - pin2.y) < EPS
+    if (isDirectVertical || isDirectHorizontal) {
+      const directPath: Point[] = [
+        { x: pin1.x, y: pin1.y },
+        { x: pin2.x, y: pin2.y },
+      ]
+      const collision = findFirstCollision(directPath, this.obstacles)
+      if (!collision) {
+        this.solvedTracePath = directPath
+        this.solved = true
+        this.baseElbow = directPath
+        this.aabb = aabbFromPoints(directPath[0]!, directPath[1]!)
+        return
+      }
+    }
+    // Build initial elbow path
     this.baseElbow = calculateElbow(
       {
         x: pin1.x,

tests/solvers/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2_direct_line.test.ts

@@ -0,0 +1,54 @@
+import { SchematicTraceSingleLineSolver2 } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"
+import { test, expect } from "bun:test"
+
+test("SchematicTraceSingleLineSolver2 traces direct horizontal line when possible", () => {
+  const chipA = {
+    chipId: "A",
+    center: { x: 0, y: 0 },
+    width: 1,
+    height: 1,
+    pins: [
+      {
+        pinId: "A.1",
+        x: 0.5,
+        y: 0,
+      },
+    ],
+  }
+  const chipB = {
+    chipId: "B",
+    center: { x: 3, y: 0 },
+    width: 1,
+    height: 1,
+    pins: [
+      {
+        pinId: "B.1",
+        x: 2.5,
+        y: 0,
+      },
+    ],
+  }
+
+  const input = {
+    chipMap: {
+      A: chipA,
+      B: chipB,
+    },
+    pins: [
+      { pinId: "A.1", x: 0.5, y: 0, chipId: "A" },
+      { pinId: "B.1", x: 2.5, y: 0, chipId: "B" },
+    ],
+    inputProblem: {
+      chips: [chipA, chipB],
+    },
+  }
+
+  const solver = new SchematicTraceSingleLineSolver2(input as any)
+  solver.solve()
+
+  expect(solver.solved).toBe(true)
+  expect(solver.solvedTracePath).toEqual([
+    { x: 0.5, y: 0 },
+    { x: 2.5, y: 0 },
+  ])
+})