@tscircuit/schematic-trace-solver 0.0.7 → 0.0.8

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/package.json

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

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,
 }