@tscircuit/schematic-trace-solver 0.0.158 → 0.0.160

package/lib/solvers/SameNetJunctionAlignmentSolver/placeGroundRailLabelsAtOuterEnd.ts

@@ -0,0 +1,122 @@
+import { traceCrossesBoundsInterior } from "lib/solvers/AvailableNetOrientationSolver/geometry"
+import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import {
+  getCenterFromAnchor,
+  getRectBounds,
+} from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import {
+  rectsOverlap,
+  tracePathContainsPoint,
+} from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import {
+  isHorizontal,
+  isVertical,
+  nearlyEqual,
+} from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import type { InputProblem } from "lib/types/InputProblem"
+
+/** Put a shared decoupling GND at the load end of its rail, away from the IC. */
+export const placeGroundRailLabelsAtOuterEnd = ({
+  inputProblem,
+  traces,
+  netLabelPlacements,
+}: {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}): NetLabelPlacement[] => {
+  const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem)
+  const groundNetId = netConnMap.getNetConnectedToId("GND")
+  if (!groundNetId) return netLabelPlacements
+  const chipMap = new Map(inputProblem.chips.map((chip) => [chip.chipId, chip]))
+  const traceMap = Object.fromEntries(
+    traces.map((trace) => [trace.mspPairId, trace]),
+  )
+  const obstacles = getObstacleRects(inputProblem)
+  const output = [...netLabelPlacements]
+
+  for (const rail of traces) {
+    if (rail.globalConnNetId !== groundNetId) continue
+    const [a, b] = rail.pins
+    if (
+      a.chipId === b.chipId ||
+      !nearlyEqual(a.y, b.y) ||
+      ![a, b].every(
+        (pin) =>
+          pin._facingDirection === "y-" &&
+          chipMap.get(pin.chipId)?.pins.length === 2,
+      )
+    )
+      continue
+    const path = simplifyPath(rail.tracePath)
+    if (
+      path.length !== 4 ||
+      !isVertical(path[0]!, path[1]!) ||
+      !isHorizontal(path[1]!, path[2]!) ||
+      !isVertical(path[2]!, path[3]!) ||
+      path[1]!.y >= a.y
+    )
+      continue
+
+    for (const feed of traces) {
+      if (feed.globalConnNetId !== groundNetId) continue
+      const shared = feed.pins.find((pin) => rail.pinIds.includes(pin.pinId))
+      const icPin = feed.pins.find(
+        (pin) =>
+          !rail.pinIds.includes(pin.pinId) &&
+          (chipMap.get(pin.chipId)?.pins.length ?? 0) > 2,
+      )
+      if (!shared || !icPin || !nearlyEqual(icPin.y, path[1]!.y)) continue
+      const outer = shared.pinId === a.pinId ? b : a
+      if (Math.abs(outer.x - icPin.x) <= Math.abs(shared.x - icPin.x)) continue
+      const anchorPoint = { x: outer.x, y: path[1]!.y }
+      if (!tracePathContainsPoint(rail.tracePath, anchorPoint)) continue
+
+      for (let index = 0; index < output.length; index++) {
+        const label = output[index]!
+        if (
+          label.globalConnNetId !== groundNetId ||
+          label.orientation !== "y-" ||
+          !label.mspConnectionPairIds.some(
+            (id) => id === feed.mspPairId || id === rail.mspPairId,
+          ) ||
+          (!tracePathContainsPoint(feed.tracePath, label.anchorPoint) &&
+            !tracePathContainsPoint(rail.tracePath, label.anchorPoint))
+        )
+          continue
+        const center = getCenterFromAnchor(
+          anchorPoint,
+          label.orientation,
+          label.width,
+          label.height,
+        )
+        const bounds = getRectBounds(center, label.width, label.height)
+        if (
+          obstacles.some((obstacle) => rectsOverlap(bounds, obstacle)) ||
+          traceCrossesBoundsInterior(bounds, traceMap) ||
+          output.some(
+            (other, otherIndex) =>
+              otherIndex !== index &&
+              rectsOverlap(
+                bounds,
+                getRectBounds(other.center, other.width, other.height),
+              ),
+          )
+        )
+          continue
+        output[index] = {
+          ...label,
+          anchorPoint,
+          center,
+          mspConnectionPairIds: [rail.mspPairId],
+          pinIds: [...rail.pinIds],
+        }
+      }
+    }
+  }
+  return output
+}

package/lib/solvers/SchematicTraceLinesSolver/getTraceConnectedPinComponents.ts

@@ -0,0 +1,60 @@
+import type { SolvedTracePath } from "./SchematicTraceLinesSolver"
+import type { PinId } from "lib/types/InputProblem"
+
+export interface TraceConnectedPinComponent {
+  pinIds: PinId[]
+  traces: SolvedTracePath[]
+}
+
+/**
+ * Partitions pins into connected components using solved traces as graph edges.
+ * Pins without a solved trace are returned as singleton components.
+ */
+export const getTraceConnectedPinComponents = ({
+  pinIds,
+  traces,
+}: {
+  pinIds: PinId[]
+  traces: SolvedTracePath[]
+}): TraceConnectedPinComponent[] => {
+  const adjacency = new Map<PinId, Set<PinId>>()
+  for (const pinId of pinIds) adjacency.set(pinId, new Set())
+
+  const relevantTraces = traces.filter((trace) => {
+    if (trace.pins.length !== 2) return false
+    const [firstPin, secondPin] = trace.pins
+    return adjacency.has(firstPin.pinId) && adjacency.has(secondPin.pinId)
+  })
+  for (const trace of relevantTraces) {
+    const [firstPin, secondPin] = trace.pins
+    adjacency.get(firstPin.pinId)!.add(secondPin.pinId)
+    adjacency.get(secondPin.pinId)!.add(firstPin.pinId)
+  }
+
+  const components: TraceConnectedPinComponent[] = []
+  const visited = new Set<PinId>()
+  for (const pinId of pinIds) {
+    if (visited.has(pinId)) continue
+    const componentPinIds: PinId[] = []
+    const pending = [pinId]
+    visited.add(pinId)
+    while (pending.length > 0) {
+      const currentPinId = pending.pop()!
+      componentPinIds.push(currentPinId)
+      for (const adjacentPinId of adjacency.get(currentPinId) ?? []) {
+        if (visited.has(adjacentPinId)) continue
+        visited.add(adjacentPinId)
+        pending.push(adjacentPinId)
+      }
+    }
+
+    const componentPinIdSet = new Set(componentPinIds)
+    components.push({
+      pinIds: componentPinIds,
+      traces: relevantTraces.filter((trace) =>
+        trace.pins.every((pin) => componentPinIdSet.has(pin.pinId)),
+      ),
+    })
+  }
+  return components
+}

package/lib/types/InputProblem.ts

@@ -110,10 +110,11 @@ export interface InputNetConnection {
   netLabelHeight?: number
 
   /**
-   * When true, a named one- or two-pin net may use inline labels. A single-pin
-   * net gets an outward stub. A routed two-pin net gets one label along its
-   * trace; when that route is intentionally skipped, both endpoints get
-   * outward stubs. Nets with more than two pins retain anchored labels.
+   * When true, a named net may use inline labels. Each routed connected
+   * component gets a label along its representative trace, while each
+   * disconnected endpoint gets an outward inline-label stub. Conversion is
+   * atomic for the whole net so inline and anchored representations are not
+   * mixed when any label cannot be placed.
    */
   allowInlineNetLabel?: boolean
 

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/tscircuit/schematic-trace-solver.git"
   },
   "main": "dist/index.js",
-  "version": "0.0.158",
+  "version": "0.0.160",
   "type": "module",
   "scripts": {
     "start": "cosmos",