@tscircuit/schematic-trace-solver 0.0.56 → 0.0.60

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -21,6 +21,7 @@ import {
   rangesOverlap,
   rectsOverlap,
   traceCrossesBoundsInterior,
+  tracePathCrossesAnyBounds,
   tracePathCrossesAnyTrace,
 } from "./geometry"
 import { getPinMap, getTracePins, toNetLabelPlacementPatch } from "./traces"
@@ -430,9 +431,25 @@ export class AvailableNetOrientationSolver extends BaseSolver {
   }
 
   private getNetLabelWidth(label: NetLabelPlacement) {
-    if (!label.netId) return undefined
-    return this.inputProblem.netConnections.find(
-      (connection) => connection.netId === label.netId,
+    if (label.netId) {
+      const ncWidth = this.inputProblem.netConnections.find(
+        (connection) => connection.netId === label.netId,
+      )?.netLabelWidth
+      if (ncWidth !== undefined) return ncWidth
+
+      const dcWidthByNetId = this.inputProblem.directConnections.find(
+        (dc) => dc.netId === label.netId,
+      )?.netLabelWidth
+      if (dcWidthByNetId !== undefined) return dcWidthByNetId
+    }
+
+    const dcWidthByPinId = this.inputProblem.directConnections.find((dc) =>
+      dc.pinIds.some((pid) => label.pinIds.includes(pid)),
+    )?.netLabelWidth
+    if (dcWidthByPinId !== undefined) return dcWidthByPinId
+
+    return this.inputProblem.netConnections.find((nc) =>
+      nc.pinIds.some((pid) => label.pinIds.includes(pid)),
     )?.netLabelWidth
   }
 
@@ -447,19 +464,29 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     )
     if (boundsStatus !== "valid") return boundsStatus
 
-    if (
-      tracePathCrossesAnyTrace(
-        getConnectorTracePath(
-          label.anchorPoint,
-          candidate.anchorPoint,
-          candidate.orientation,
-        ),
-        this.traceMap,
-      )
-    ) {
+    const connectorTrace = getConnectorTracePath(
+      label.anchorPoint,
+      candidate.anchorPoint,
+      candidate.orientation,
+    )
+
+    if (tracePathCrossesAnyTrace(connectorTrace, this.traceMap)) {
       return "trace-collision"
     }
 
+    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+      if (i === labelIndex) continue
+      const otherLabel = this.outputNetLabelPlacements[i]!
+      if (
+        tracePathCrossesAnyBounds(
+          connectorTrace,
+          getRectBounds(otherLabel.center, otherLabel.width, otherLabel.height),
+        )
+      ) {
+        return "netlabel-collision"
+      }
+    }
+
     return "valid"
   }
 

package/lib/solvers/AvailableNetOrientationSolver/geometry.ts

@@ -88,6 +88,20 @@ const segmentCrossesBoundsInterior = (p1: Point, p2: Point, bounds: Bounds) => {
   return false
 }
 
+export const tracePathCrossesAnyBounds = (
+  tracePath: Point[],
+  bounds: Bounds,
+) => {
+  for (let i = 0; i < tracePath.length - 1; i++) {
+    if (
+      segmentCrossesBoundsInterior(tracePath[i]!, tracePath[i + 1]!, bounds)
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
 export const tracePathCrossesAnyTrace = (
   tracePath: Point[],
   traceMap: Record<string, SolvedTracePath>,

package/lib/solvers/Example28Solver/reroute.ts

@@ -1,5 +1,6 @@
 import type { Point } from "@tscircuit/math-utils"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { segmentIntersectsRect as segmentIntersectsLabelRect } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
 import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
@@ -73,9 +74,39 @@ export const generateRerouteCandidateResults = ({
   outputNetLabelPlacements: NetLabelPlacement[]
   chipObstacles: ChipObstacle[]
 }) => {
-  const rawCandidates = generateCandidatePaths(trace, label, inputProblem)
   const seen = new Set<string>()
   const candidateResults: RerouteCandidateResult[] = []
+  const horizontalSegmentPushCandidate = generateHorizontalSegmentPushCandidate(
+    trace,
+    label,
+  )
+
+  if (horizontalSegmentPushCandidate) {
+    candidateResults.push(
+      createCandidateResult({
+        trace,
+        obstacleLabel: label,
+        path: horizontalSegmentPushCandidate,
+        seen,
+        outputTraces,
+        outputNetLabelPlacements,
+        chipObstacles,
+        usesHorizontalSegmentPush: true,
+      }),
+    )
+  }
+
+  const rawCandidates = [
+    ...generateLabelHugCandidates(trace, label),
+    ...generateRerouteCandidates({
+      trace,
+      label,
+      problem: inputProblem,
+      paddingBuffer: LABEL_SIDE_CLEARANCE,
+      detourCount: 0,
+    }),
+    ...generateEndpointDetourCandidates(trace, label),
+  ]
 
   for (const rawCandidate of rawCandidates) {
     candidateResults.push(
@@ -94,22 +125,6 @@ export const generateRerouteCandidateResults = ({
   return candidateResults
 }
 
-const generateCandidatePaths = (
-  trace: SolvedTracePath,
-  label: NetLabelPlacement,
-  inputProblem: InputProblem,
-) => [
-  ...generateLabelHugCandidates(trace, label),
-  ...generateRerouteCandidates({
-    trace,
-    label,
-    problem: inputProblem,
-    paddingBuffer: LABEL_SIDE_CLEARANCE,
-    detourCount: 0,
-  }),
-  ...generateEndpointDetourCandidates(trace, label),
-]
-
 const createCandidateResult = ({
   trace,
   obstacleLabel,
@@ -118,6 +133,7 @@ const createCandidateResult = ({
   outputTraces,
   outputNetLabelPlacements,
   chipObstacles,
+  usesHorizontalSegmentPush,
 }: {
   trace: SolvedTracePath
   obstacleLabel: NetLabelPlacement
@@ -126,6 +142,7 @@ const createCandidateResult = ({
   outputTraces: SolvedTracePath[]
   outputNetLabelPlacements: NetLabelPlacement[]
   chipObstacles: ChipObstacle[]
+  usesHorizontalSegmentPush?: boolean
 }): RerouteCandidateResult => {
   const key = getPathKey(path)
 
@@ -133,6 +150,7 @@ const createCandidateResult = ({
     return {
       path,
       status: "duplicate",
+      usesHorizontalSegmentPush,
       selected: false,
     }
   }
@@ -143,6 +161,7 @@ const createCandidateResult = ({
     return {
       path,
       status: "chip-collision",
+      usesHorizontalSegmentPush,
       selected: false,
     }
   }
@@ -157,6 +176,7 @@ const createCandidateResult = ({
       outputNetLabelPlacements,
     }),
     status: "valid",
+    usesHorizontalSegmentPush,
     selected: false,
   }
 }
@@ -259,6 +279,13 @@ const selectBestReroutePath = ({
   outputNetLabelPlacements: NetLabelPlacement[]
   candidateResults: RerouteCandidateResult[]
 }) => {
+  for (const candidate of candidateResults) {
+    if (!candidate.usesHorizontalSegmentPush) continue
+    if (candidate.status !== "valid") continue
+    if (!candidate.score) continue
+    return candidate.path
+  }
+
   let bestPath: Point[] | null = null
   let bestScore = scoreTracePath({
     trace,
@@ -279,6 +306,99 @@ const selectBestReroutePath = ({
   return bestPath
 }
 
+const generateHorizontalSegmentPushCandidate = (
+  trace: SolvedTracePath,
+  label: NetLabelPlacement,
+): Point[] | null => {
+  const labelDirection = dir(label.orientation)
+  if (labelDirection.x === 0) return null
+
+  const path = trace.tracePath
+  const bounds = getRectBounds(label.center, label.width, label.height)
+  const collidingVerticalSegmentIndex = path.findIndex((start, index) => {
+    const end = path[index + 1]
+    if (!end) return false
+    if (Math.abs(start.x - end.x) >= 1e-9) return false
+    return segmentIntersectsLabelRect(start, end, bounds)
+  })
+
+  if (
+    collidingVerticalSegmentIndex <= 0 ||
+    collidingVerticalSegmentIndex >= path.length - 2
+  ) {
+    return null
+  }
+
+  const previousAnchor = path[collidingVerticalSegmentIndex - 1]!
+  const verticalStart = path[collidingVerticalSegmentIndex]!
+  const verticalEnd = path[collidingVerticalSegmentIndex + 1]!
+  const nextAnchor = path[collidingVerticalSegmentIndex + 2]!
+
+  if (
+    Math.abs(previousAnchor.y - verticalStart.y) >= 1e-9 ||
+    Math.abs(verticalEnd.y - nextAnchor.y) >= 1e-9
+  ) {
+    return null
+  }
+
+  let segmentPushX = bounds.minX - LABEL_SIDE_CLEARANCE
+  if (labelDirection.x > 0) {
+    segmentPushX = bounds.maxX + LABEL_SIDE_CLEARANCE
+  }
+  const segmentPushStartY = getClearedHorizontalY({
+    start: previousAnchor,
+    end: { x: segmentPushX, y: verticalStart.y },
+    labelBounds: bounds,
+  })
+  const segmentPushEndY = getClearedHorizontalY({
+    start: { x: segmentPushX, y: verticalEnd.y },
+    end: nextAnchor,
+    labelBounds: bounds,
+  })
+
+  const segmentPushPath: Point[] = [
+    ...path.slice(0, collidingVerticalSegmentIndex - 1),
+    previousAnchor,
+  ]
+
+  if (Math.abs(previousAnchor.y - segmentPushStartY) >= 1e-9) {
+    segmentPushPath.push({ x: previousAnchor.x, y: segmentPushStartY })
+  }
+
+  segmentPushPath.push({ x: segmentPushX, y: segmentPushStartY })
+  segmentPushPath.push({ x: segmentPushX, y: segmentPushEndY })
+
+  if (Math.abs(nextAnchor.y - segmentPushEndY) >= 1e-9) {
+    segmentPushPath.push({ x: nextAnchor.x, y: segmentPushEndY })
+  }
+
+  segmentPushPath.push(
+    nextAnchor,
+    ...path.slice(collidingVerticalSegmentIndex + 3),
+  )
+
+  return simplifyPath(segmentPushPath)
+}
+
+const getClearedHorizontalY = ({
+  start,
+  end,
+  labelBounds,
+}: {
+  start: Point
+  end: Point
+  labelBounds: { minX: number; minY: number; maxX: number; maxY: number }
+}) => {
+  if (!segmentIntersectsLabelRect(start, end, labelBounds)) return start.y
+
+  const labelCenterY = (labelBounds.minY + labelBounds.maxY) / 2
+  if (start.y >= labelCenterY) {
+    return labelBounds.maxY + LABEL_HUG_CLEARANCE
+  }
+
+  return labelBounds.minY - LABEL_HUG_CLEARANCE
+}
+
 const markSelectedCandidate = (
   candidateResults: RerouteCandidateResult[],
   bestPath: Point[] | null,

package/lib/solvers/Example28Solver/types.ts

@@ -32,6 +32,7 @@ export type RerouteCandidateResult = {
   path: Point[]
   score?: TracePathScore
   status: "valid" | "duplicate" | "chip-collision"
+  usesHorizontalSegmentPush?: boolean
   selected: boolean
 }
 

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -250,6 +250,36 @@ export class NetLabelPlacementSolver extends BaseSolver {
     return groups
   }
 
+  private getNetLabelWidthForGroup(
+    group: OverlappingSameNetTraceGroup,
+  ): number | undefined {
+    if (group.netId) {
+      const ncWidth = this.inputProblem.netConnections.find(
+        (nc) => nc.netId === group.netId,
+      )?.netLabelWidth
+      if (ncWidth !== undefined) return ncWidth
+
+      const dcWidthByNetId = this.inputProblem.directConnections.find(
+        (dc) => dc.netId === group.netId,
+      )?.netLabelWidth
+      if (dcWidthByNetId !== undefined) return dcWidthByNetId
+    }
+
+    const pinIds = group.overlappingTraces?.pins.map((p) => p.pinId) ?? []
+    if (group.portOnlyPinId) {
+      pinIds.push(group.portOnlyPinId)
+    }
+
+    const dcWidthByPinId = this.inputProblem.directConnections.find((dc) =>
+      dc.pinIds.some((pid) => pinIds.includes(pid)),
+    )?.netLabelWidth
+    if (dcWidthByPinId !== undefined) return dcWidthByPinId
+
+    return this.inputProblem.netConnections.find((nc) =>
+      nc.pinIds.some((pid) => pinIds.includes(pid)),
+    )?.netLabelWidth
+  }
+
   override _step() {
     if (this.activeSubSolver?.solved) {
       this.netLabelPlacements.push(this.activeSubSolver.netLabelPlacement!)
@@ -273,11 +303,7 @@ export class NetLabelPlacementSolver extends BaseSolver {
         this.currentGroup
       ) {
         this.triedAnyOrientationFallbackForCurrentGroup = true
-        const netLabelWidth = this.currentGroup.netId
-          ? this.inputProblem.netConnections.find(
-              (nc) => nc.netId === this.currentGroup!.netId,
-            )?.netLabelWidth
-          : undefined
+        const netLabelWidth = this.getNetLabelWidthForGroup(this.currentGroup)
         this.activeSubSolver = new SingleNetLabelPlacementSolver({
           inputProblem: this.inputProblem,
           inputTraceMap: this.inputTraceMap,
@@ -313,11 +339,7 @@ export class NetLabelPlacementSolver extends BaseSolver {
     this.currentGroup = nextOverlappingSameNetTraceGroup
     this.triedAnyOrientationFallbackForCurrentGroup = false
 
-    const netLabelWidth = this.currentGroup.netId
-      ? this.inputProblem.netConnections.find(
-          (nc) => nc.netId === this.currentGroup!.netId,
-        )?.netLabelWidth
-      : undefined
+    const netLabelWidth = this.getNetLabelWidthForGroup(this.currentGroup)
 
     this.activeSubSolver = new SingleNetLabelPlacementSolver({
       inputProblem: this.inputProblem,

package/lib/solvers/TraceAnchoredNetLabelOverlapSolver/candidates.ts

@@ -338,14 +338,26 @@ const getNetLabelWidth = (
   inputProblem: InputProblem,
   label: NetLabelPlacement,
 ) => {
-  const configuredWidth = inputProblem.netConnections.find(
+  const ncWidthByNetId = inputProblem.netConnections.find(
     (connection) => connection.netId === label.netId,
   )?.netLabelWidth
-  if (configuredWidth !== undefined) return configuredWidth
+  if (ncWidthByNetId !== undefined) return ncWidthByNetId
 
-  return label.orientation === "y+" || label.orientation === "y-"
-    ? label.height
-    : label.width
+  const dcWidth = inputProblem.directConnections.find((dc) =>
+    dc.pinIds.some((pid) => label.pinIds.includes(pid)),
+  )?.netLabelWidth
+  if (dcWidth !== undefined) return dcWidth
+
+  const ncWidthByPinId = inputProblem.netConnections.find((nc) =>
+    nc.pinIds.some((pid) => label.pinIds.includes(pid)),
+  )?.netLabelWidth
+  if (ncWidthByPinId !== undefined) return ncWidthByPinId
+
+  if (label.orientation === "y+" || label.orientation === "y-") {
+    return label.height
+  }
+
+  return label.width
 }
 
 const roundDistance = (distance: number) => Number(distance.toFixed(6))

package/lib/solvers/TraceCleanupSolver/is4PointRectangle.ts

@@ -1,5 +1,10 @@
 import type { Point } from "@tscircuit/math-utils"
 
+const EPS = 1e-6
+
+const sameX = (a: Point, b: Point) => Math.abs(a.x - b.x) <= EPS
+const sameY = (a: Point, b: Point) => Math.abs(a.y - b.y) <= EPS
+
 /**
  * Checks if a given path of four points forms a rectangle with horizontal and vertical segments.
  * It verifies if the path forms either an H-V-H "C" shape or a V-H-V "C" shape.
@@ -9,9 +14,9 @@ export const is4PointRectangle = (path: Point[]): boolean => {
   const [p0, p1, p2, p3] = path
   // H-V-H "C" shape
   const isHVHC =
-    p0.y === p1.y && p1.x === p2.x && p2.y === p3.y && p0.x === p3.x
+    sameY(p0, p1) && sameX(p1, p2) && sameY(p2, p3) && sameX(p0, p3)
   // V-H-V "C" shape
   const isVHVC =
-    p0.x === p1.x && p1.y === p2.y && p2.x === p3.x && p0.y === p3.y
+    sameX(p0, p1) && sameY(p1, p2) && sameX(p2, p3) && sameY(p0, p3)
   return isHVHC || isVHVC
 }

package/lib/types/InputProblem.ts

@@ -24,6 +24,7 @@ export interface InputChip {
 export interface InputDirectConnection {
   pinIds: [PinId, PinId]
   netId?: string
+  netLabelWidth?: number
 }
 
 export interface InputNetConnection {

package/package.json

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

package/site/examples/example34.page.tsx

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

package/site/examples/example35.page.tsx

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

package/site/examples/example36.page.tsx

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

package/tests/assets/example34.json

@@ -0,0 +1,61 @@
+{
+  "chips": [
+    {
+      "chipId": "schematic_component_0",
+      "center": {
+        "x": 0,
+        "y": 0
+      },
+      "width": 1,
+      "height": 1,
+      "pins": [
+        {
+          "pinId": "U1.1",
+          "x": 1.1,
+          "y": 0.30000000000000004
+        },
+        {
+          "pinId": "U1.2",
+          "x": 1.1,
+          "y": 0.09999999999999998
+        },
+        {
+          "pinId": "U1.3",
+          "x": 1.1,
+          "y": -0.10000000000000003
+        },
+        {
+          "pinId": "U1.4",
+          "x": 1.1,
+          "y": -0.30000000000000004
+        }
+      ]
+    }
+  ],
+  "directConnections": [],
+  "netConnections": [
+    {
+      "netId": "SCL",
+      "pinIds": ["U1.1"]
+    },
+    {
+      "netId": "SDA",
+      "pinIds": ["U1.2"]
+    },
+    {
+      "netId": "V3_3",
+      "pinIds": ["U1.3"]
+    },
+    {
+      "netId": "GND",
+      "pinIds": ["U1.4"]
+    }
+  ],
+  "availableNetLabelOrientations": {
+    "SCL": ["x-", "x+"],
+    "SDA": ["x-", "x+"],
+    "V3_3": ["y+"],
+    "GND": ["y-"]
+  },
+  "maxMspPairDistance": 2.4
+}

package/tests/assets/example35.json

@@ -0,0 +1,127 @@
+{
+  "chips": [
+    {
+      "chipId": "schematic_component_0",
+      "center": {
+        "x": 0,
+        "y": 0
+      },
+      "width": 1.3,
+      "height": 1,
+      "pins": [
+        {
+          "pinId": "U1.1",
+          "x": -1.05,
+          "y": 0.30000000000000004
+        },
+        {
+          "pinId": "U1.2",
+          "x": -1.05,
+          "y": 0.10000000000000003
+        },
+        {
+          "pinId": "U1.3",
+          "x": -1.05,
+          "y": -0.09999999999999998
+        },
+        {
+          "pinId": "U1.4",
+          "x": -1.05,
+          "y": -0.30000000000000004
+        },
+        {
+          "pinId": "U1.5",
+          "x": 1.05,
+          "y": -0.30000000000000004
+        },
+        {
+          "pinId": "U1.6",
+          "x": 1.05,
+          "y": -0.10000000000000003
+        },
+        {
+          "pinId": "U1.7",
+          "x": 1.05,
+          "y": 0.09999999999999998
+        },
+        {
+          "pinId": "U1.8",
+          "x": 1.05,
+          "y": 0.30000000000000004
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_1",
+      "center": {
+        "x": 2,
+        "y": 2
+      },
+      "width": 1.3,
+      "height": 1,
+      "pins": [
+        {
+          "pinId": "U2.1",
+          "x": 0.95,
+          "y": 2.3
+        },
+        {
+          "pinId": "U2.2",
+          "x": 0.95,
+          "y": 2.1
+        },
+        {
+          "pinId": "U2.3",
+          "x": 0.95,
+          "y": 1.9
+        },
+        {
+          "pinId": "U2.4",
+          "x": 0.95,
+          "y": 1.7
+        },
+        {
+          "pinId": "U2.5",
+          "x": 3.05,
+          "y": 1.7
+        },
+        {
+          "pinId": "U2.6",
+          "x": 3.05,
+          "y": 1.9
+        },
+        {
+          "pinId": "U2.7",
+          "x": 3.05,
+          "y": 2.1
+        },
+        {
+          "pinId": "U2.8",
+          "x": 3.05,
+          "y": 2.3
+        }
+      ]
+    }
+  ],
+  "directConnections": [
+    {
+      "pinIds": ["U1.7", "U2.7"],
+      "netId": "U1.IO3 to U2.IO3"
+    },
+    {
+      "pinIds": ["U1.6", "U2.8"],
+      "netId": "U1.CLK to U2.VCC"
+    }
+  ],
+  "netConnections": [
+    {
+      "netId": "VCC",
+      "pinIds": ["U1.5", "U1.8"],
+      "netLabelWidth": 0.48
+    }
+  ],
+  "availableNetLabelOrientations": {
+    "VCC": ["y+"]
+  },
+  "maxMspPairDistance": 2.4
+}