@tscircuit/schematic-trace-solver 0.0.7 → 0.0.9

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver_visualize.ts

@@ -0,0 +1,89 @@
+import type { GraphicsObject } from "graphics-debug"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import { getColorFromString } from "lib/utils/getColorFromString"
+import { chooseHostTraceForGroup } from "./host"
+import type { SingleNetLabelPlacementSolver } from "./SingleNetLabelPlacementSolver"
+
+export function visualizeSingleNetLabelPlacementSolver(
+  solver: SingleNetLabelPlacementSolver,
+): GraphicsObject {
+  const graphics = visualizeInputProblem(solver.inputProblem)
+
+  // Visualize the entire trace group for this net id
+  const groupId = solver.overlappingSameNetTraceGroup.globalConnNetId
+  const host = chooseHostTraceForGroup({
+    inputProblem: solver.inputProblem,
+    inputTraceMap: solver.inputTraceMap,
+    globalConnNetId: groupId,
+    fallbackTrace: solver.overlappingSameNetTraceGroup.overlappingTraces,
+  })
+  const groupStroke = getColorFromString(groupId, 0.9)
+  const groupFill = getColorFromString(groupId, 0.5)
+
+  for (const trace of Object.values(solver.inputTraceMap)) {
+    if (trace.globalConnNetId !== groupId) continue
+    const isHost = host ? trace.mspPairId === host.mspPairId : false
+    graphics.lines!.push({
+      points: trace.tracePath,
+      strokeColor: isHost ? groupStroke : groupFill,
+      strokeWidth: isHost ? 0.006 : 0.003,
+      strokeDash: isHost ? undefined : "4 2",
+    } as any)
+  }
+
+  // Visualize all tested candidate rectangles with reason coloring
+  for (const c of solver.testedCandidates) {
+    const fill =
+      c.status === "ok"
+        ? "rgba(0, 180, 0, 0.25)"
+        : c.status === "chip-collision"
+          ? "rgba(220, 0, 0, 0.25)"
+          : c.status === "trace-collision"
+            ? "rgba(220, 140, 0, 0.25)"
+            : "rgba(120, 120, 120, 0.15)"
+    const stroke =
+      c.status === "ok"
+        ? "green"
+        : c.status === "chip-collision"
+          ? "red"
+          : c.status === "trace-collision"
+            ? "orange"
+            : "gray"
+
+    graphics.rects!.push({
+      center: {
+        x: (c.bounds.minX + c.bounds.maxX) / 2,
+        y: (c.bounds.minY + c.bounds.maxY) / 2,
+      },
+      width: c.width,
+      height: c.height,
+      fill,
+      strokeColor: stroke,
+    } as any)
+
+    graphics.points!.push({
+      x: c.anchor.x,
+      y: c.anchor.y,
+      color: stroke,
+    } as any)
+  }
+
+  // Visualize the final accepted label (if any)
+  if (solver.netLabelPlacement) {
+    const p = solver.netLabelPlacement
+    graphics.rects!.push({
+      center: p.center,
+      width: p.width,
+      height: p.height,
+      fill: "rgba(0, 128, 255, 0.35)",
+      strokeColor: "blue",
+    } as any)
+    graphics.points!.push({
+      x: p.anchorPoint.x,
+      y: p.anchorPoint.y,
+      color: "blue",
+    } as any)
+  }
+
+  return graphics
+}

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/anchors.ts

@@ -0,0 +1,11 @@
+export function anchorsForSegment(
+  a: { x: number; y: number },
+  b: { x: number; y: number },
+) {
+  // Start, midpoint, end
+  return [
+    { x: a.x, y: a.y },
+    { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 },
+    { x: b.x, y: b.y },
+  ]
+}

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts

@@ -0,0 +1,45 @@
+import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+export function segmentIntersectsRect(
+  p1: { x: number; y: number },
+  p2: { x: number; y: number },
+  rect: { minX: number; minY: number; maxX: number; maxY: number },
+  EPS = 1e-9,
+): boolean {
+  const isVert = Math.abs(p1.x - p2.x) < EPS
+  const isHorz = Math.abs(p1.y - p2.y) < EPS
+  if (!isVert && !isHorz) return false
+
+  if (isVert) {
+    const x = p1.x
+    if (x < rect.minX - EPS || x > rect.maxX + EPS) return false
+    const segMinY = Math.min(p1.y, p2.y)
+    const segMaxY = Math.max(p1.y, p2.y)
+    const overlap = Math.min(segMaxY, rect.maxY) - Math.max(segMinY, rect.minY)
+    return overlap > EPS
+  } else {
+    const y = p1.y
+    if (y < rect.minY - EPS || y > rect.maxY + EPS) return false
+    const segMinX = Math.min(p1.x, p2.x)
+    const segMaxX = Math.max(p1.x, p2.x)
+    const overlap = Math.min(segMaxX, rect.maxX) - Math.max(segMinX, rect.minX)
+    return overlap > EPS
+  }
+}
+
+export function rectIntersectsAnyTrace(
+  bounds: { minX: number; minY: number; maxX: number; maxY: number },
+  inputTraceMap: Record<MspConnectionPairId, SolvedTracePath>,
+  hostPathId?: MspConnectionPairId,
+  hostSegIndex?: number,
+): boolean {
+  for (const [pairId, solved] of Object.entries(inputTraceMap)) {
+    const pts = solved.tracePath
+    for (let i = 0; i < pts.length - 1; i++) {
+      if (pairId === hostPathId && i === hostSegIndex) continue
+      if (segmentIntersectsRect(pts[i]!, pts[i + 1]!, bounds)) return true
+    }
+  }
+  return false
+}

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry.ts

@@ -0,0 +1,48 @@
+import type { FacingDirection } from "lib/utils/dir"
+
+export const NET_LABEL_HORIZONTAL_WIDTH = 0.4
+export const NET_LABEL_HORIZONTAL_HEIGHT = 0.2
+
+export function getDimsForOrientation(orientation: FacingDirection) {
+  if (orientation === "y+" || orientation === "y-") {
+    return {
+      width: NET_LABEL_HORIZONTAL_HEIGHT,
+      height: NET_LABEL_HORIZONTAL_WIDTH,
+    }
+  }
+  return {
+    width: NET_LABEL_HORIZONTAL_WIDTH,
+    height: NET_LABEL_HORIZONTAL_HEIGHT,
+  }
+}
+
+export function getCenterFromAnchor(
+  anchor: { x: number; y: number },
+  orientation: FacingDirection,
+  width: number,
+  height: number,
+) {
+  switch (orientation) {
+    case "x+":
+      return { x: anchor.x + width / 2, y: anchor.y }
+    case "x-":
+      return { x: anchor.x - width / 2, y: anchor.y }
+    case "y+":
+      return { x: anchor.x, y: anchor.y + height / 2 }
+    case "y-":
+      return { x: anchor.x, y: anchor.y - height / 2 }
+  }
+}
+
+export function getRectBounds(
+  center: { x: number; y: number },
+  w: number,
+  h: number,
+) {
+  return {
+    minX: center.x - w / 2,
+    minY: center.y - h / 2,
+    maxX: center.x + w / 2,
+    maxY: center.y + h / 2,
+  }
+}

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/host.ts

@@ -0,0 +1,64 @@
+import type { InputChip, InputProblem } from "lib/types/InputProblem"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+
+export function lengthOfTrace(path: SolvedTracePath): number {
+  let sum = 0
+  const pts = path.tracePath
+  for (let i = 0; i < pts.length - 1; i++) {
+    sum +=
+      Math.abs(pts[i + 1]!.x - pts[i]!.x) + Math.abs(pts[i + 1]!.y - pts[i]!.y)
+  }
+  return sum
+}
+
+export function chooseHostTraceForGroup(params: {
+  inputProblem: InputProblem
+  inputTraceMap: Record<MspConnectionPairId, SolvedTracePath>
+  globalConnNetId: string
+  fallbackTrace?: SolvedTracePath
+}): SolvedTracePath | undefined {
+  const { inputProblem, inputTraceMap, globalConnNetId, fallbackTrace } = params
+
+  const chipsById: Record<string, InputChip> = Object.fromEntries(
+    inputProblem.chips.map((c) => [c.chipId, c]),
+  )
+
+  const groupTraces = Object.values(inputTraceMap).filter(
+    (t) => t.globalConnNetId === globalConnNetId,
+  )
+
+  const chipIdsInGroup = new Set<string>()
+  for (const t of groupTraces) {
+    chipIdsInGroup.add(t.pins[0].chipId)
+    chipIdsInGroup.add(t.pins[1].chipId)
+  }
+
+  let largestChipId: string | null = null
+  let largestPinCount = -1
+  for (const id of chipIdsInGroup) {
+    const chip = chipsById[id]
+    const count = chip?.pins?.length ?? 0
+    if (count > largestPinCount) {
+      largestPinCount = count
+      largestChipId = id
+    }
+  }
+
+  const hostCandidates =
+    largestChipId == null
+      ? []
+      : groupTraces.filter(
+          (t) =>
+            t.pins[0].chipId === largestChipId ||
+            t.pins[1].chipId === largestChipId,
+        )
+
+  if (hostCandidates.length > 0) {
+    return hostCandidates.reduce((a, b) =>
+      lengthOfTrace(a) >= lengthOfTrace(b) ? a : b,
+    )
+  }
+
+  return fallbackTrace
+}

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/solvePortOnlyPin.ts

@@ -0,0 +1,177 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { FacingDirection } from "lib/utils/dir"
+import { ChipObstacleSpatialIndex } from "lib/data-structures/ChipObstacleSpatialIndex"
+import type {
+  NetLabelPlacement,
+  OverlappingSameNetTraceGroup,
+} from "../NetLabelPlacementSolver"
+import {
+  getDimsForOrientation,
+  getCenterFromAnchor,
+  getRectBounds,
+} from "./geometry"
+import { rectIntersectsAnyTrace } from "./collisions"
+
+export function solveNetLabelPlacementForPortOnlyPin(params: {
+  inputProblem: InputProblem
+  inputTraceMap: Record<MspConnectionPairId, SolvedTracePath>
+  chipObstacleSpatialIndex: ChipObstacleSpatialIndex
+  overlappingSameNetTraceGroup: OverlappingSameNetTraceGroup
+  availableOrientations: FacingDirection[]
+}): {
+  placement: NetLabelPlacement | null
+  testedCandidates: Array<{
+    center: { x: number; y: number }
+    width: number
+    height: number
+    bounds: { minX: number; minY: number; maxX: number; maxY: number }
+    anchor: { x: number; y: number }
+    orientation: FacingDirection
+    status: "ok" | "chip-collision" | "trace-collision" | "parallel-to-segment"
+    hostSegIndex: number
+  }>
+  error?: string
+} {
+  const {
+    inputProblem,
+    inputTraceMap,
+    chipObstacleSpatialIndex,
+    overlappingSameNetTraceGroup,
+    availableOrientations,
+  } = params
+
+  const pinId = overlappingSameNetTraceGroup.portOnlyPinId
+  if (!pinId) {
+    return {
+      placement: null,
+      testedCandidates: [],
+      error: "No portOnlyPinId provided",
+    }
+  }
+
+  // Find pin coordinates
+  let pin: { x: number; y: number } | null = null
+  for (const chip of inputProblem.chips) {
+    const p = chip.pins.find((pp) => pp.pinId === pinId)
+    if (p) {
+      pin = { x: p.x, y: p.y }
+      break
+    }
+  }
+  if (!pin) {
+    return {
+      placement: null,
+      testedCandidates: [],
+      error: `Port-only pin not found: ${pinId}`,
+    }
+  }
+
+  const orientations =
+    availableOrientations.length > 0
+      ? availableOrientations
+      : (["x+", "x-", "y+", "y-"] as FacingDirection[])
+
+  const anchor = { x: pin.x, y: pin.y }
+  const outwardOf = (o: FacingDirection) =>
+    o === "x+"
+      ? { x: 1, y: 0 }
+      : o === "x-"
+        ? { x: -1, y: 0 }
+        : o === "y+"
+          ? { x: 0, y: 1 }
+          : { x: 0, y: -1 }
+
+  const testedCandidates: Array<{
+    center: { x: number; y: number }
+    width: number
+    height: number
+    bounds: { minX: number; minY: number; maxX: number; maxY: number }
+    anchor: { x: number; y: number }
+    orientation: FacingDirection
+    status: "ok" | "chip-collision" | "trace-collision" | "parallel-to-segment"
+    hostSegIndex: number
+  }> = []
+
+  for (const orientation of orientations) {
+    const { width, height } = getDimsForOrientation(orientation)
+    // Place label fully outside the chip: shift center slightly outward
+    const baseCenter = getCenterFromAnchor(anchor, orientation, width, height)
+    const outward = outwardOf(orientation)
+    const offset = 1e-3
+    const center = {
+      x: baseCenter.x + outward.x * offset,
+      y: baseCenter.y + outward.y * offset,
+    }
+    const bounds = getRectBounds(center, width, height)
+
+    // Chip collision check
+    const chips = chipObstacleSpatialIndex.getChipsInBounds(bounds)
+    if (chips.length > 0) {
+      testedCandidates.push({
+        center,
+        width,
+        height,
+        bounds,
+        anchor,
+        orientation,
+        status: "chip-collision",
+        hostSegIndex: -1,
+      })
+      continue
+    }
+
+    // Trace collision check
+    if (
+      rectIntersectsAnyTrace(
+        bounds,
+        inputTraceMap,
+        "" as MspConnectionPairId,
+        -1,
+      )
+    ) {
+      testedCandidates.push({
+        center,
+        width,
+        height,
+        bounds,
+        anchor,
+        orientation,
+        status: "trace-collision",
+        hostSegIndex: -1,
+      })
+      continue
+    }
+
+    // Found a valid placement
+    testedCandidates.push({
+      center,
+      width,
+      height,
+      bounds,
+      anchor,
+      orientation,
+      status: "ok",
+      hostSegIndex: -1,
+    })
+
+    const placement: NetLabelPlacement = {
+      globalConnNetId: overlappingSameNetTraceGroup.globalConnNetId,
+      dcConnNetId: undefined,
+      orientation,
+      anchorPoint: anchor,
+      width,
+      height,
+      center,
+    }
+
+    return { placement, testedCandidates }
+  }
+
+  return {
+    placement: null,
+    testedCandidates,
+    error: "Could not place net label at port without collisions",
+  }
+}

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver.ts

@@ -30,6 +30,7 @@ export class SchematicTraceLinesSolver extends BaseSolver {
   currentConnectionPair: MspConnectionPair | null = null
 
   solvedTracePaths: Array<SolvedTracePath> = []
+  failedConnectionPairs: Array<MspConnectionPair & { error?: string }> = []
 
   declare activeSubSolver: SchematicTraceSingleLineSolver | null
 
@@ -75,9 +76,16 @@ export class SchematicTraceLinesSolver extends BaseSolver {
       this.currentConnectionPair = null
     }
     if (this.activeSubSolver?.failed) {
-      this.failed = true
-      this.error = this.activeSubSolver.error
-      return
+      // Record the failure for this connection and continue to the next pair
+      if (this.currentConnectionPair) {
+        this.failedConnectionPairs.push({
+          ...this.currentConnectionPair,
+          error: this.activeSubSolver.error || undefined,
+        })
+      }
+      this.activeSubSolver = null
+      this.currentConnectionPair = null
+      // Do not fail the whole solver; proceed to schedule the next pair
     }
 
     if (this.activeSubSolver) {
@@ -122,6 +130,19 @@ export class SchematicTraceLinesSolver extends BaseSolver {
       })
     }
 
+    // Indicate failed connection pairs with dashed red lines between their pins
+    for (const pair of this.failedConnectionPairs) {
+      graphics.lines!.push({
+        points: [
+          { x: pair.pins[0].x, y: pair.pins[0].y },
+          { x: pair.pins[1].x, y: pair.pins[1].y },
+        ],
+        strokeColor: "red",
+        strokeDash: "4 2",
+        strokeWidth: 0.004,
+      })
+    }
+
     return graphics
   }
 }

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver.ts

@@ -103,12 +103,47 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
 
     const nextCandidatePath = this.queuedCandidatePaths.shift()!
 
-    const obstacleOps = {
-      excludeChipIds: [this.pins[0].chipId, this.pins[1].chipId],
-    }
     for (let i = 0; i < nextCandidatePath.length - 1; i++) {
       const start = nextCandidatePath[i]
       const end = nextCandidatePath[i + 1]
+
+      // Determine which chips to exclude for this specific segment
+      let excludeChipIds: string[] = []
+
+      // Always exclude chips that contain the start or end points of this segment
+      // if those points are actually pin locations
+      const isStartPin = this.pins.some(
+        (pin) =>
+          Math.abs(pin.x - start.x) < 1e-10 &&
+          Math.abs(pin.y - start.y) < 1e-10,
+      )
+      const isEndPin = this.pins.some(
+        (pin) =>
+          Math.abs(pin.x - end.x) < 1e-10 && Math.abs(pin.y - end.y) < 1e-10,
+      )
+
+      if (isStartPin) {
+        const startPin = this.pins.find(
+          (pin) =>
+            Math.abs(pin.x - start.x) < 1e-10 &&
+            Math.abs(pin.y - start.y) < 1e-10,
+        )
+        if (startPin && !excludeChipIds.includes(startPin.chipId)) {
+          excludeChipIds.push(startPin.chipId)
+        }
+      }
+
+      if (isEndPin) {
+        const endPin = this.pins.find(
+          (pin) =>
+            Math.abs(pin.x - end.x) < 1e-10 && Math.abs(pin.y - end.y) < 1e-10,
+        )
+        if (endPin && !excludeChipIds.includes(endPin.chipId)) {
+          excludeChipIds.push(endPin.chipId)
+        }
+      }
+
+      const obstacleOps = { excludeChipIds }
       const intersects =
         this.chipObstacleSpatialIndex.doesOrthogonalLineIntersectChip(
           [start, end],

package/package.json

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

package/site/SchematicTraceLinesSolver/SchematicTraceLinesSolver01.page.tsx

@@ -0,0 +1,122 @@
+import { useMemo } from "react"
+import { GenericSolverDebugger } from "../components/GenericSolverDebugger"
+import { SchematicTraceLinesSolver } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+const input = {
+  mspConnectionPairs: [
+    {
+      mspPairId: "Q1.1-Q1.2",
+      dcConnNetId: "connectivity_net0",
+      globalConnNetId: "connectivity_net0",
+      userNetId: "V3_3",
+      pins: [
+        {
+          pinId: "Q1.1",
+          x: 0.30397715550000004,
+          y: 0.5800832909999993,
+          _facingDirection: "y+",
+          chipId: "schematic_component_0",
+        },
+        {
+          pinId: "Q1.2",
+          x: 0.31067575550000137,
+          y: -0.5800832909999993,
+          _facingDirection: "y-",
+          chipId: "schematic_component_0",
+        },
+      ],
+    },
+  ],
+  dcConnMap: {
+    netMap: {
+      connectivity_net0: ["Q1.1", "Q1.2"],
+    },
+    idToNetMap: {},
+  },
+  globalConnMap: {
+    netMap: {
+      connectivity_net0: ["Q1.1", "Q1.2"],
+    },
+    idToNetMap: {
+      "Q1.1": "connectivity_net0",
+      "Q1.2": "connectivity_net0",
+    },
+  },
+  inputProblem: {
+    chips: [
+      {
+        chipId: "schematic_component_0",
+        center: {
+          x: 0,
+          y: 0,
+        },
+        width: 0.8935117710000002,
+        height: 1.1601665819999987,
+        pins: [
+          {
+            pinId: "Q1.1",
+            x: 0.30397715550000004,
+            y: 0.5800832909999993,
+          },
+          {
+            pinId: "Q1.2",
+            x: 0.31067575550000137,
+            y: -0.5800832909999993,
+          },
+          {
+            pinId: "Q1.3",
+            x: -0.4467558855000001,
+            y: -0.10250625000000019,
+          },
+        ],
+      },
+    ],
+    directConnections: [],
+    netConnections: [
+      {
+        netId: "V3_3",
+        pinIds: ["Q1.1", "Q1.2"],
+      },
+    ],
+    availableNetLabelOrientations: {
+      V3_3: ["y+"],
+    },
+    maxMspPairDistance: 2,
+  },
+  guidelines: [],
+  chipMap: {
+    schematic_component_0: {
+      chipId: "schematic_component_0",
+      center: {
+        x: 0,
+        y: 0,
+      },
+      width: 0.8935117710000002,
+      height: 1.1601665819999987,
+      pins: [
+        {
+          pinId: "Q1.1",
+          x: 0.30397715550000004,
+          y: 0.5800832909999993,
+        },
+        {
+          pinId: "Q1.2",
+          x: 0.31067575550000137,
+          y: -0.5800832909999993,
+        },
+        {
+          pinId: "Q1.3",
+          x: -0.4467558855000001,
+          y: -0.10250625000000019,
+        },
+      ],
+    },
+  },
+}
+
+export default () => {
+  const solver = useMemo(() => {
+    return new SchematicTraceLinesSolver(input as any)
+  }, [])
+  return <GenericSolverDebugger solver={solver} />
+}

package/site/components/GenericSolverDebugger.tsx

@@ -0,0 +1,16 @@
+import type { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import { useMemo, useReducer } from "react"
+import { InteractiveGraphics } from "graphics-debug/react"
+import { SolverToolbar } from "./SolverToolbar"
+
+export const GenericSolverDebugger = ({ solver }: { solver: BaseSolver }) => {
+  const [, incRenderCount] = useReducer((x) => x + 1, 0)
+
+  return (
+    <div>
+      <SolverToolbar triggerRender={() => incRenderCount()} solver={solver} />
+      <InteractiveGraphics graphics={solver.visualize()} />
+    </div>
+  )
+}

package/site/examples/example01-basic.page.tsx

@@ -95,9 +95,9 @@ const inputProblem: InputProblem = {
     },
   ],
   availableNetLabelOrientations: {
-    VCC: ["y+", "y-"],
+    VCC: ["y+"],
     EN: ["x+", "x-"],
-    GND: ["y+", "y-"],
+    GND: ["y-"],
   },
   maxMspPairDistance: 2,
 }