@tscircuit/schematic-trace-solver 0.0.81 → 0.0.83

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -146,6 +146,8 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     candidate: EvaluatedCandidate,
     labelIndex: number,
   ) {
+    if (candidate.phase === "trace-anchor") return
+
     const tracePath = this.getCandidateConnectorTrace(label, candidate)
     if (tracePath.length < 2) return
 
@@ -187,6 +189,13 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     )
     if (rotatedCandidate) return rotatedCandidate
 
+    const traceAnchorCandidate = this.findValidTraceAnchorCandidate(
+      label,
+      orientations[0]!,
+      labelIndex,
+    )
+    if (traceAnchorCandidate) return traceAnchorCandidate
+
     const shiftedCandidate = this.findValidShiftedCandidate(
       label,
       orientations[0]!,
@@ -228,6 +237,57 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return null
   }
 
+  private findValidTraceAnchorCandidate(
+    label: NetLabelPlacement,
+    orientation: FacingDirection,
+    labelIndex: number,
+  ) {
+    const direction = dir(orientation)
+    const candidatePoints = this.getTraceAnchorCandidatePoints(label).sort(
+      (a, b) => {
+        const aAlongDirection = a.x * direction.x + a.y * direction.y
+        const bAlongDirection = b.x * direction.x + b.y * direction.y
+        return bAlongDirection - aAlongDirection
+      },
+    )
+
+    for (const anchorPoint of candidatePoints) {
+      const candidate = this.createCandidate(label, anchorPoint, orientation)
+      const result = this.evaluateCandidate(
+        candidate,
+        label,
+        labelIndex,
+        "trace-anchor",
+      )
+      this.currentCandidateResults.push(result)
+
+      if (result.status === "valid") {
+        result.selected = true
+        return result
+      }
+    }
+
+    return null
+  }
+
+  private getTraceAnchorCandidatePoints(label: NetLabelPlacement) {
+    const seen = new Set<string>()
+    const points: Point[] = []
+
+    for (const traceId of label.mspConnectionPairIds ?? []) {
+      const trace = this.traceMap[traceId]
+      if (!trace) continue
+      for (const point of trace.tracePath) {
+        const key = `${point.x.toFixed(9)},${point.y.toFixed(9)}`
+        if (seen.has(key)) continue
+        seen.add(key)
+        points.push(point)
+      }
+    }
+
+    return points
+  }
+
   private getAvailableOrientations(label: NetLabelPlacement) {
     const effectiveNetId = label.netId ?? label.globalConnNetId
     return this.inputProblem.availableNetLabelOrientations[effectiveNetId] ?? []
@@ -608,16 +668,33 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     phase: CandidatePhase
   }) {
     const { candidate, label, labelIndex, phase } = params
+    const bounds = getRectBounds(
+      candidate.center,
+      candidate.width,
+      candidate.height,
+    )
     const boundsStatus = this.getBoundsStatus({
-      bounds: getRectBounds(
-        candidate.center,
-        candidate.width,
-        candidate.height,
-      ),
+      bounds,
       labelIndex,
       label,
     })
-    if (boundsStatus !== "valid") return boundsStatus
+    if (boundsStatus !== "valid") {
+      if (
+        phase !== "trace-anchor" ||
+        boundsStatus !== "chip-collision" ||
+        !this.isAcceptableTraceAnchorChipCollision(candidate, label, bounds)
+      ) {
+        return boundsStatus
+      }
+
+      const nonChipBoundsStatus = this.getBoundsStatus({
+        bounds,
+        labelIndex,
+        label,
+        ignoreChipCollisions: true,
+      })
+      if (nonChipBoundsStatus !== "valid") return nonChipBoundsStatus
+    }
 
     const connectorTrace = this.getCandidateConnectorTrace(label, {
       anchorPoint: candidate.anchorPoint,
@@ -647,22 +724,59 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return "valid"
   }
 
+  private isAcceptableTraceAnchorChipCollision(
+    candidate: CandidateLabel,
+    label: NetLabelPlacement,
+    bounds: Bounds,
+  ) {
+    const collidingChips =
+      this.chipObstacleSpatialIndex.getChipsInBounds(bounds)
+    if (collidingChips.length === 0) return false
+
+    const labelChipIds = new Set(
+      label.pinIds
+        .map((pinId) => this.pinMap[pinId]?.chipId)
+        .filter((chipId): chipId is string => Boolean(chipId)),
+    )
+
+    return collidingChips.every((chip) => {
+      if (!labelChipIds.has(chip.chipId)) return false
+
+      const { anchorPoint, orientation } = candidate
+      const chipBounds = chip.bounds
+      if (isYOrientation(orientation)) {
+        return (
+          anchorPoint.x < chipBounds.minX - EPS ||
+          anchorPoint.x > chipBounds.maxX + EPS
+        )
+      }
+      return (
+        anchorPoint.y < chipBounds.minY - EPS ||
+        anchorPoint.y > chipBounds.maxY + EPS
+      )
+    })
+  }
+
   private getBoundsStatus(candidateBoundsCheck: {
     bounds: Bounds
     labelIndex: number
     label: NetLabelPlacement
+    ignoreChipCollisions?: boolean
   }): CandidateStatus {
-    const { bounds, labelIndex, label } = candidateBoundsCheck
+    const { bounds, labelIndex, label, ignoreChipCollisions } =
+      candidateBoundsCheck
 
-    if (this.chipObstacleSpatialIndex.getChipsInBounds(bounds).length > 0) {
-      return "chip-collision"
+    if (!ignoreChipCollisions) {
+      if (this.chipObstacleSpatialIndex.getChipsInBounds(bounds).length > 0) {
+        return "chip-collision"
+      }
+      if (this.sharesChipBoundary(bounds)) {
+        return "chip-collision"
+      }
     }
     if (rectIntersectsAnyTextBox(bounds, this.inputProblem)) {
       return "text-collision"
     }
-    if (this.sharesChipBoundary(bounds)) {
-      return "chip-collision"
-    }
     if (traceCrossesBoundsInterior(bounds, this.traceMap)) {
       return "trace-collision"
     }

package/lib/solvers/AvailableNetOrientationSolver/types.ts

@@ -35,7 +35,11 @@ export type CandidateStatus =
   | "trace-clearance-violation"
   | "netlabel-collision"
 
-export type CandidatePhase = "rotate" | "shift" | "lateral-shift"
+export type CandidatePhase =
+  | "rotate"
+  | "trace-anchor"
+  | "shift"
+  | "lateral-shift"
 
 export type EvaluatedCandidate = CandidateLabel & {
   status: CandidateStatus

package/lib/solvers/Example28Solver/Example28Solver.ts

@@ -1,18 +1,27 @@
 import type { GraphicsObject } from "graphics-debug"
+import {
+  getPinMap,
+  getTracePins,
+} from "lib/solvers/AvailableNetOrientationSolver/traces"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
-import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import {
   detectTraceLabelOverlap,
   type TraceLabelOverlap,
 } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
-import type { InputProblem } from "lib/types/InputProblem"
+import type { InputPin, InputProblem } from "lib/types/InputProblem"
+import { dir } from "lib/utils/dir"
 import { moveAttachedLabelsToReroutedTrace } from "./labelMovement"
 import { findBestReroutePath } from "./reroute"
 import type { Example28SolverParams, RerouteCandidateResult } from "./types"
 import { visualizeExample28Solver } from "./visualize"
 
+const LABEL_OUTWARD_STEP = 0.1
+const LABEL_MAX_OUTWARD_STEPS = 10
+const LABEL_TRACE_CLEARANCE = 0.1
+
 export class Example28Solver extends BaseSolver {
   inputProblem: InputProblem
   traces: SolvedTracePath[]
@@ -25,6 +34,7 @@ export class Example28Solver extends BaseSolver {
   currentCandidateResults: RerouteCandidateResult[] = []
 
   private chipObstacles: ReturnType<typeof getObstacleRects>
+  private pinMap: Record<string, InputPin & { chipId: string }>
 
   constructor(params: Example28SolverParams) {
     super()
@@ -34,6 +44,7 @@ export class Example28Solver extends BaseSolver {
     this.outputTraces = [...params.traces]
     this.outputNetLabelPlacements = [...params.netLabelPlacements]
     this.chipObstacles = getObstacleRects(params.inputProblem)
+    this.pinMap = getPinMap(params.inputProblem)
     this.initializeQueuedOverlaps()
     this.currentOverlap = this.queuedOverlaps[0] ?? null
   }
@@ -144,6 +155,8 @@ export class Example28Solver extends BaseSolver {
     if (traceIndex === -1) return
 
     const currentTrace = this.outputTraces[traceIndex]!
+    if (this.tryMoveLabelOutward(overlap.label)) return
+
     const rerouteResult = findBestReroutePath({
       trace: currentTrace,
       obstacleLabel: overlap.label,
@@ -169,6 +182,79 @@ export class Example28Solver extends BaseSolver {
     })
   }
 
+  private tryMoveLabelOutward(labelToMove: NetLabelPlacement) {
+    const labelIndex = this.outputNetLabelPlacements.findIndex(
+      (label) =>
+        label.globalConnNetId === labelToMove.globalConnNetId &&
+        label.anchorPoint.x === labelToMove.anchorPoint.x &&
+        label.anchorPoint.y === labelToMove.anchorPoint.y &&
+        label.pinIds.join(",") === labelToMove.pinIds.join(","),
+    )
+    if (labelIndex === -1) return false
+
+    const label = this.outputNetLabelPlacements[labelIndex]!
+    if (label.mspConnectionPairIds.length > 0) return false
+    if (label.pinIds.length !== 1) return false
+    if (
+      this.outputNetLabelPlacements.filter(
+        (otherLabel) => otherLabel.globalConnNetId === label.globalConnNetId,
+      ).length !== 1
+    ) {
+      return false
+    }
+
+    const outward = dir(label.orientation)
+    if (outward.x === 0 && outward.y === 0) return false
+
+    for (let step = 1; step <= LABEL_MAX_OUTWARD_STEPS; step++) {
+      const distance = step * LABEL_OUTWARD_STEP
+      const candidate = {
+        ...label,
+        anchorPoint: {
+          x: label.anchorPoint.x + outward.x * distance,
+          y: label.anchorPoint.y + outward.y * distance,
+        },
+        center: {
+          x: label.center.x + outward.x * distance,
+          y: label.center.y + outward.y * distance,
+        },
+      }
+      const candidateWithClearance = {
+        ...candidate,
+        width: candidate.width + LABEL_TRACE_CLEARANCE * 2,
+        height: candidate.height + LABEL_TRACE_CLEARANCE * 2,
+      }
+      if (
+        detectTraceLabelOverlap({
+          traces: this.outputTraces,
+          netLabels: [candidateWithClearance],
+        }).length > 0
+      ) {
+        continue
+      }
+
+      const connectorTrace = createPortOnlyLabelConnectorTrace({
+        label,
+        movedLabel: candidate,
+        pinMap: this.pinMap,
+      })
+      if (
+        detectTraceLabelOverlap({
+          traces: [connectorTrace],
+          netLabels: this.outputNetLabelPlacements,
+        }).length > 0
+      ) {
+        continue
+      }
+
+      this.outputNetLabelPlacements[labelIndex] = candidate
+      this.outputTraces.push(connectorTrace)
+      return true
+    }
+
+    return false
+  }
+
   override visualize(): GraphicsObject {
     return visualizeExample28Solver({
       inputProblem: this.inputProblem,
@@ -180,3 +266,29 @@ export class Example28Solver extends BaseSolver {
     })
   }
 }
+
+const getPortOnlyLabelConnectorMspPairId = (label: NetLabelPlacement) =>
+  `port-only-label-connector-${label.globalConnNetId}-${label.pinIds[0]}`
+
+const createPortOnlyLabelConnectorTrace = ({
+  label,
+  movedLabel,
+  pinMap,
+}: {
+  label: NetLabelPlacement
+  movedLabel: NetLabelPlacement
+  pinMap: Record<string, InputPin & { chipId: string }>
+}): SolvedTracePath => {
+  const mspPairId = getPortOnlyLabelConnectorMspPairId(label)
+
+  return {
+    mspPairId,
+    dcConnNetId: label.dcConnNetId ?? label.globalConnNetId,
+    globalConnNetId: label.globalConnNetId,
+    userNetId: label.netId,
+    pins: getTracePins(label, pinMap),
+    tracePath: [label.anchorPoint, movedLabel.anchorPoint],
+    mspConnectionPairIds: [mspPairId],
+    pinIds: label.pinIds,
+  }
+}

package/lib/solvers/Example28Solver/reroute.ts

@@ -20,8 +20,7 @@ import type {
   TracePathScore,
 } from "./types"
 
-const LABEL_SIDE_CLEARANCE = 0.1
-const LABEL_HUG_CLEARANCE = 0.001
+const LABEL_CLEARANCE = 0.1
 
 export const findBestReroutePath = ({
   trace,
@@ -102,7 +101,7 @@ export const generateRerouteCandidateResults = ({
       trace,
       label,
       problem: inputProblem,
-      paddingBuffer: LABEL_SIDE_CLEARANCE,
+      paddingBuffer: LABEL_CLEARANCE,
       detourCount: 0,
     }),
     ...generateEndpointDetourCandidates(trace, label),
@@ -188,9 +187,11 @@ const generateEndpointDetourCandidates = (
   const start = trace.tracePath[0]
   const end = trace.tracePath[trace.tracePath.length - 1]
   if (!start || !end) return []
+  const startExit = trace.tracePath[1] ?? start
+  const endEntry = trace.tracePath[trace.tracePath.length - 2] ?? end
 
   const bounds = getRectBounds(label.center, label.width, label.height)
-  const padding = LABEL_SIDE_CLEARANCE
+  const padding = LABEL_CLEARANCE
   const labelDirection = dir(label.orientation)
   const labelSideX =
     labelDirection.x < 0 ? bounds.minX - padding : bounds.maxX + padding
@@ -204,18 +205,22 @@ const generateEndpointDetourCandidates = (
     candidates.push(
       [
         start,
-        { x: start.x, y: topY },
+        startExit,
+        { x: startExit.x, y: topY },
         { x: sideX, y: topY },
         { x: sideX, y: bottomY },
-        { x: end.x, y: bottomY },
+        { x: endEntry.x, y: bottomY },
+        endEntry,
         end,
       ],
       [
         start,
-        { x: start.x, y: bottomY },
+        startExit,
+        { x: startExit.x, y: bottomY },
         { x: sideX, y: bottomY },
         { x: sideX, y: topY },
-        { x: end.x, y: topY },
+        { x: endEntry.x, y: topY },
+        endEntry,
         end,
       ],
     )
@@ -231,6 +236,8 @@ const generateLabelHugCandidates = (
   const start = trace.tracePath[0]
   const end = trace.tracePath[trace.tracePath.length - 1]
   if (!start || !end) return []
+  const startExit = trace.tracePath[1] ?? start
+  const endEntry = trace.tracePath[trace.tracePath.length - 2] ?? end
 
   const labelDirection = dir(label.orientation)
   if (labelDirection.x === 0) return []
@@ -238,29 +245,33 @@ const generateLabelHugCandidates = (
   const bounds = getRectBounds(label.center, label.width, label.height)
   const sideX =
     labelDirection.x < 0
-      ? bounds.minX - LABEL_SIDE_CLEARANCE
-      : bounds.maxX + LABEL_SIDE_CLEARANCE
-  const topY = bounds.maxY + LABEL_HUG_CLEARANCE
-  const bottomY = bounds.minY - LABEL_HUG_CLEARANCE
-  const startsAboveEnd = start.y >= end.y
+      ? bounds.minX - LABEL_CLEARANCE
+      : bounds.maxX + LABEL_CLEARANCE
+  const topY = bounds.maxY + LABEL_CLEARANCE
+  const bottomY = bounds.minY - LABEL_CLEARANCE
+  const startsAboveEnd = startExit.y >= endEntry.y
   const firstY = startsAboveEnd ? topY : bottomY
   const secondY = startsAboveEnd ? bottomY : topY
 
   return [
     [
       start,
-      { x: start.x, y: firstY },
+      startExit,
+      { x: startExit.x, y: firstY },
       { x: sideX, y: firstY },
       { x: sideX, y: secondY },
-      { x: end.x, y: secondY },
+      { x: endEntry.x, y: secondY },
+      endEntry,
       end,
     ],
     [
       start,
-      { x: start.x, y: secondY },
+      startExit,
+      { x: startExit.x, y: secondY },
       { x: sideX, y: secondY },
       { x: sideX, y: firstY },
-      { x: end.x, y: firstY },
+      { x: endEntry.x, y: firstY },
+      endEntry,
       end,
     ],
   ]
@@ -341,9 +352,9 @@ const generateHorizontalSegmentPushCandidate = (
     return null
   }
 
-  let segmentPushX = bounds.minX - LABEL_SIDE_CLEARANCE
+  let segmentPushX = bounds.minX - LABEL_CLEARANCE
   if (labelDirection.x > 0) {
-    segmentPushX = bounds.maxX + LABEL_SIDE_CLEARANCE
+    segmentPushX = bounds.maxX + LABEL_CLEARANCE
   }
   const segmentPushStartY = getClearedHorizontalY({
     start: previousAnchor,
@@ -393,10 +404,10 @@ const getClearedHorizontalY = ({
 
   const labelCenterY = (labelBounds.minY + labelBounds.maxY) / 2
   if (start.y >= labelCenterY) {
-    return labelBounds.maxY + LABEL_HUG_CLEARANCE
+    return labelBounds.maxY + LABEL_CLEARANCE
   }
 
-  return labelBounds.minY - LABEL_HUG_CLEARANCE
+  return labelBounds.minY - LABEL_CLEARANCE
 }
 
 const markSelectedCandidate = (

package/package.json

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