@tscircuit/schematic-trace-solver 0.0.46 → 0.0.47

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/tryFourPointDetour.ts

@@ -1,12 +1,14 @@
 import type { Point } from "graphics-debug"
 import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
-import { getRectBounds } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import {
-  segmentIntersectsRect,
-  isVertical,
-} from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 
+/**
+ * Generates candidate four-point detour paths for a trace colliding with a label obstacle.
+ * It uses a two-strategy approach: a simpler one for individual labels and a more robust one
+ * for merged labels, finding precise entry and exit points. Detours are U-shaped, respecting
+ * the trace's direction to prevent loops.
+ */
 export const generateFourPointDetourCandidates = ({
   initialTrace,
   label,
@@ -16,89 +18,137 @@ export const generateFourPointDetourCandidates = ({
 }: {
   initialTrace: SolvedTracePath
   label: NetLabelPlacement
-  labelBounds: any
+  labelBounds: { minX: number; maxX: number; minY: number; maxY: number }
   paddingBuffer: number
   detourCount: number
 }): Point[][] => {
-  let collidingSegIndex = -1
-  for (let i = 0; i < initialTrace.tracePath.length - 1; i++) {
-    if (
-      segmentIntersectsRect(
-        initialTrace.tracePath[i],
-        initialTrace.tracePath[i + 1],
-        labelBounds,
-      )
-    ) {
-      collidingSegIndex = i
-      break
-    }
+  const isMergedLabel = label.globalConnNetId.startsWith("merged-group-")
+  const effectivePadding = paddingBuffer + detourCount * paddingBuffer
+  const paddedLabelBounds = {
+    minX: labelBounds.minX - effectivePadding,
+    maxX: labelBounds.maxX + effectivePadding,
+    minY: labelBounds.minY - effectivePadding,
+    maxY: labelBounds.maxY + effectivePadding,
   }
 
-  if (collidingSegIndex === -1) return []
+  let entryPoint: Point, exitPoint: Point
+  let entryIndex: number, exitIndex: number
 
-  const pA = initialTrace.tracePath[collidingSegIndex]
-  const pB = initialTrace.tracePath[collidingSegIndex + 1]
+  const isPointInRect = (p: Point) =>
+    p.x >= paddedLabelBounds.minX &&
+    p.x <= paddedLabelBounds.maxX &&
+    p.y >= paddedLabelBounds.minY &&
+    p.y <= paddedLabelBounds.maxY
 
-  if (!pA || !pB) return []
+  if (isMergedLabel) {
+    // STRATEGY 2: Merged Label - find first point before and after the entire crossing
+    let firstInsideIndex = -1
+    for (let i = 0; i < initialTrace.tracePath.length; i++) {
+      if (isPointInRect(initialTrace.tracePath[i])) {
+        firstInsideIndex = i
+        break
+      }
+    }
 
-  const candidateDetours: Point[][] = []
-  const paddedLabelBounds = getRectBounds(
-    label.center,
-    label.width,
-    label.height,
-  )
+    if (firstInsideIndex === -1) return [] // No points inside, shouldn't be called
 
-  const effectivePadding = paddingBuffer + detourCount * paddingBuffer
+    entryIndex = Math.max(0, firstInsideIndex - 1)
+    entryPoint = initialTrace.tracePath[entryIndex]
 
-  if (isVertical(pA, pB)) {
-    const xCandidates = [
-      paddedLabelBounds.maxX + effectivePadding,
-      paddedLabelBounds.minX - effectivePadding,
-    ]
-    for (const newX of xCandidates) {
+    let firstOutsideIndex = -1
+    for (let i = firstInsideIndex; i < initialTrace.tracePath.length; i++) {
+      if (!isPointInRect(initialTrace.tracePath[i])) {
+        firstOutsideIndex = i
+        break
+      }
+    }
+
+    if (firstOutsideIndex === -1) {
+      // Trace ends inside the box, use the last point as exit
+      exitIndex = initialTrace.tracePath.length - 1
+    } else {
+      exitIndex = firstOutsideIndex
+    }
+    exitPoint = initialTrace.tracePath[exitIndex]
+  } else {
+    // STRATEGY 1: Single Label - find the first intersecting segment
+    let collidingSegIndex = -1
+    for (let i = 0; i < initialTrace.tracePath.length - 1; i++) {
+      if (
+        segmentIntersectsRect(
+          initialTrace.tracePath[i],
+          initialTrace.tracePath[i + 1],
+          { ...paddedLabelBounds, chipId: "temp-obstacle" },
+        )
+      ) {
+        collidingSegIndex = i
+        break
+      }
+    }
+
+    if (collidingSegIndex === -1) return []
+
+    entryIndex = collidingSegIndex
+    exitIndex = collidingSegIndex + 1
+    entryPoint = initialTrace.tracePath[entryIndex]
+    exitPoint = initialTrace.tracePath[exitIndex]
+  }
+
+  if (!entryPoint || !exitPoint || entryIndex >= exitIndex) return []
+
+  const candidateDetours: Point[][] = []
+  const dx = exitPoint.x - entryPoint.x
+  const dy = exitPoint.y - entryPoint.y
+
+  if (Math.abs(dx) > Math.abs(dy)) {
+    // More horizontal
+    const yCandidates = [paddedLabelBounds.maxY, paddedLabelBounds.minY]
+    for (const newY of yCandidates) {
       candidateDetours.push(
-        pB.y > pA.y
+        dx > 0 // Left-to-right
           ? [
-              { x: pA.x, y: paddedLabelBounds.minY - effectivePadding },
-              { x: newX, y: paddedLabelBounds.minY - effectivePadding },
-              { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
-              { x: pB.x, y: paddedLabelBounds.maxY + effectivePadding },
+              { x: paddedLabelBounds.minX, y: entryPoint.y },
+              { x: paddedLabelBounds.minX, y: newY },
+              { x: paddedLabelBounds.maxX, y: newY },
+              { x: paddedLabelBounds.maxX, y: exitPoint.y },
             ]
           : [
-              { x: pA.x, y: paddedLabelBounds.maxY + effectivePadding },
-              { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
-              { x: newX, y: paddedLabelBounds.minY - effectivePadding },
-              { x: pB.x, y: paddedLabelBounds.minY - effectivePadding },
+              // Right-to-left
+              { x: paddedLabelBounds.maxX, y: entryPoint.y },
+              { x: paddedLabelBounds.maxX, y: newY },
+              { x: paddedLabelBounds.minX, y: newY },
+              { x: paddedLabelBounds.minX, y: exitPoint.y },
             ],
       )
     }
   } else {
-    const yCandidates = [
-      paddedLabelBounds.maxY + effectivePadding,
-      paddedLabelBounds.minY - effectivePadding,
-    ]
-    for (const newY of yCandidates) {
+    // More vertical
+    const xCandidates = [paddedLabelBounds.maxX, paddedLabelBounds.minX]
+    for (const newX of xCandidates) {
       candidateDetours.push(
-        pB.x > pA.x
+        dy > 0 // Top-to-bottom
           ? [
-              { x: paddedLabelBounds.minX - effectivePadding, y: pA.y },
-              { x: paddedLabelBounds.minX - effectivePadding, y: newY },
-              { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
-              { x: paddedLabelBounds.maxX + effectivePadding, y: pB.y },
+              { x: entryPoint.x, y: paddedLabelBounds.minY },
+              { x: newX, y: paddedLabelBounds.minY },
+              { x: newX, y: paddedLabelBounds.maxY },
+              { x: exitPoint.x, y: paddedLabelBounds.maxY },
             ]
           : [
-              { x: paddedLabelBounds.maxX + effectivePadding, y: pA.y },
-              { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
-              { x: paddedLabelBounds.minX - effectivePadding, y: newY },
-              { x: paddedLabelBounds.minX - effectivePadding, y: pB.y },
+              // Bottom-to-top
+              { x: entryPoint.x, y: paddedLabelBounds.maxY },
+              { x: newX, y: paddedLabelBounds.maxY },
+              { x: newX, y: paddedLabelBounds.minY },
+              { x: exitPoint.x, y: paddedLabelBounds.minY },
             ],
       )
     }
   }
 
   return candidateDetours.map((detourPoints) => [
-    ...initialTrace.tracePath.slice(0, collidingSegIndex + 1),
+    ...initialTrace.tracePath.slice(0, entryIndex),
+    entryPoint,
     ...detourPoints,
-    ...initialTrace.tracePath.slice(collidingSegIndex + 1),
+    exitPoint,
+    ...initialTrace.tracePath.slice(exitIndex + 1),
   ])
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.46",
+  "version": "0.0.47",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/site/examples/example27.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example27.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/tests/assets/example27.json

@@ -0,0 +1,168 @@
+{
+  "chips": [
+    {
+      "chipId": "schematic_component_0",
+      "center": {
+        "x": 0,
+        "y": 0
+      },
+      "width": 0.4,
+      "height": 2.5999999999999996,
+      "pins": [
+        {
+          "pinId": "P.1",
+          "x": -0.6000000000000001,
+          "y": 1.0999999999999999
+        },
+        {
+          "pinId": "P.2",
+          "x": -0.6000000000000001,
+          "y": 0.8999999999999999
+        },
+        {
+          "pinId": "P.3",
+          "x": -0.6000000000000001,
+          "y": 0.6999999999999998
+        },
+        {
+          "pinId": "P.4",
+          "x": -0.6000000000000001,
+          "y": 0.4999999999999998
+        },
+        {
+          "pinId": "P.5",
+          "x": -0.6000000000000001,
+          "y": 0.2999999999999998
+        },
+        {
+          "pinId": "P.6",
+          "x": -0.6000000000000001,
+          "y": 0.09999999999999987
+        },
+        {
+          "pinId": "P.7",
+          "x": -0.6000000000000001,
+          "y": -0.10000000000000009
+        },
+        {
+          "pinId": "P.8",
+          "x": -0.6000000000000001,
+          "y": -0.30000000000000004
+        },
+        {
+          "pinId": "P.9",
+          "x": -0.6000000000000001,
+          "y": -0.5
+        },
+        {
+          "pinId": "P.10",
+          "x": -0.6000000000000001,
+          "y": -0.7
+        },
+        {
+          "pinId": "P.11",
+          "x": -0.6000000000000001,
+          "y": -0.8999999999999999
+        },
+        {
+          "pinId": "P.12",
+          "x": -0.6000000000000001,
+          "y": -1.0999999999999999
+        },
+        {
+          "pinId": "P.13",
+          "x": 0.6000000000000001,
+          "y": -1.0999999999999999
+        },
+        {
+          "pinId": "P.14",
+          "x": 0.6000000000000001,
+          "y": -0.8999999999999999
+        },
+        {
+          "pinId": "P.15",
+          "x": 0.6000000000000001,
+          "y": -0.6999999999999998
+        },
+        {
+          "pinId": "P.16",
+          "x": 0.6000000000000001,
+          "y": -0.4999999999999998
+        },
+        {
+          "pinId": "P.17",
+          "x": 0.6000000000000001,
+          "y": -0.2999999999999998
+        },
+        {
+          "pinId": "P.18",
+          "x": 0.6000000000000001,
+          "y": -0.09999999999999987
+        },
+        {
+          "pinId": "P.19",
+          "x": 0.6000000000000001,
+          "y": 0.10000000000000009
+        },
+        {
+          "pinId": "P.20",
+          "x": 0.6000000000000001,
+          "y": 0.30000000000000004
+        },
+        {
+          "pinId": "P.21",
+          "x": 0.6000000000000001,
+          "y": 0.5
+        },
+        {
+          "pinId": "P.22",
+          "x": 0.6000000000000001,
+          "y": 0.7
+        },
+        {
+          "pinId": "P.23",
+          "x": 0.6000000000000001,
+          "y": 0.8999999999999999
+        },
+        {
+          "pinId": "P.24",
+          "x": 0.6000000000000001,
+          "y": 1.0999999999999999
+        }
+      ]
+    }
+  ],
+  "directConnections": [
+    {
+      "pinIds": ["P.1", "P.18"],
+      "netId": "P.pin1 to P.pin18"
+    },
+    {
+      "pinIds": ["P.2", "P.17"],
+      "netId": "P.pin2 to P.pin17"
+    },
+    {
+      "pinIds": ["P.3", "P.16"],
+      "netId": "P.pin3 to P.pin16"
+    },
+    {
+      "pinIds": ["P.4", "P.15"],
+      "netId": "P.pin4 to P.pin15"
+    },
+    {
+      "pinIds": ["P.5", "P.14"],
+      "netId": "P.pin5 to P.pin14"
+    },
+    {
+      "pinIds": ["P.6", "P.13"],
+      "netId": "P.pin6 to P.pin13"
+    },
+    {
+      "pinIds": ["P.7", "P.19"],
+      "netId": "P.pin7 to P.pin19"
+    }
+  ],
+  "netConnections": [],
+  "availableNetLabelOrientations": {},
+  "maxMspPairDistance": 2.4
+}