@tscircuit/schematic-trace-solver 0.0.49 → 0.0.51

package/lib/solvers/VccNetLabelCornerPlacementSolver/VccNetLabelCornerPlacementSolver.ts

@@ -0,0 +1,268 @@
+import type { GraphicsObject } from "graphics-debug"
+import { traceCrossesBoundsInterior } from "lib/solvers/AvailableNetOrientationSolver/geometry"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import {
+  getCenterFromAnchor,
+  getRectBounds,
+} from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import {
+  getDistance,
+  getTraceCorners,
+  isTraceLine,
+  rectsOverlap,
+  tracePathContainsPoint,
+} from "./geometry"
+import type {
+  Bounds,
+  CornerCandidateStatus,
+  EvaluatedCornerCandidate,
+  TraceCornerCandidate,
+  VccNetLabelCornerPlacementSolverParams,
+} from "./types"
+import { visualizeVccNetLabelCornerPlacementSolver } from "./visualize"
+
+export class VccNetLabelCornerPlacementSolver extends BaseSolver {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+
+  outputNetLabelPlacements: NetLabelPlacement[]
+  queuedLabelIndices: number[] = []
+  currentLabelIndex: number | null = null
+  currentLabel: NetLabelPlacement | null = null
+  currentCandidateResults: EvaluatedCornerCandidate[] = []
+
+  private queuedCornerCandidates: TraceCornerCandidate[] = []
+  private shouldAdvanceToNextLabel = false
+  private traceMap: Record<string, SolvedTracePath>
+
+  constructor(params: VccNetLabelCornerPlacementSolverParams) {
+    super()
+    this.inputProblem = params.inputProblem
+    this.traces = params.traces
+    this.netLabelPlacements = params.netLabelPlacements
+    this.outputNetLabelPlacements = [...params.netLabelPlacements]
+    this.traceMap = Object.fromEntries(
+      params.traces.map((trace) => [trace.mspPairId, trace]),
+    )
+    this.queuedLabelIndices = this.getProcessableLabelIndices()
+    this.prepareNextLabel()
+  }
+
+  override getConstructorParams(): ConstructorParameters<
+    typeof VccNetLabelCornerPlacementSolver
+  >[0] {
+    return {
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      netLabelPlacements: this.netLabelPlacements,
+    }
+  }
+
+  override _step() {
+    if (this.shouldAdvanceToNextLabel) {
+      this.advanceToNextLabel()
+      return
+    }
+
+    const label = this.currentLabel
+    const labelIndex = this.currentLabelIndex
+    if (label === null || labelIndex === null) {
+      this.finish()
+      return
+    }
+
+    const candidate = this.queuedCornerCandidates.shift()
+    if (!candidate) {
+      this.shouldAdvanceToNextLabel = true
+      return
+    }
+
+    const result = this.evaluateCornerCandidate(label, labelIndex, candidate)
+    this.currentCandidateResults.push(result)
+
+    if (result.status !== "valid") return
+
+    result.selected = true
+    this.applyCandidate(labelIndex, label, result)
+    this.shouldAdvanceToNextLabel = true
+  }
+
+  getOutput() {
+    return {
+      netLabelPlacements: this.outputNetLabelPlacements,
+    }
+  }
+
+  private getProcessableLabelIndices() {
+    const labelIndices: number[] = []
+
+    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+      const label = this.outputNetLabelPlacements[i]!
+      if (!this.shouldProcessLabel(label)) continue
+
+      labelIndices.push(i)
+    }
+
+    return labelIndices
+  }
+
+  private prepareNextLabel() {
+    const labelIndex = this.queuedLabelIndices.shift()
+    if (labelIndex === undefined) {
+      this.clearCurrentLabel()
+      return false
+    }
+
+    const label = this.outputNetLabelPlacements[labelIndex]!
+    this.currentLabelIndex = labelIndex
+    this.currentLabel = label
+    this.currentCandidateResults = []
+    this.queuedCornerCandidates = this.getCornerCandidatesForLabel(label)
+
+    return true
+  }
+
+  private advanceToNextLabel() {
+    this.shouldAdvanceToNextLabel = false
+    if (!this.prepareNextLabel()) this.finish()
+  }
+
+  private clearCurrentLabel() {
+    this.currentLabelIndex = null
+    this.currentLabel = null
+    this.currentCandidateResults = []
+    this.queuedCornerCandidates = []
+  }
+
+  private finish() {
+    this.clearCurrentLabel()
+    this.solved = true
+  }
+
+  private evaluateCornerCandidate(
+    label: NetLabelPlacement,
+    labelIndex: number,
+    candidate: TraceCornerCandidate,
+  ): EvaluatedCornerCandidate {
+    const center = getCenterFromAnchor(
+      candidate.anchorPoint,
+      label.orientation,
+      label.width,
+      label.height,
+    )
+    const bounds = getRectBounds(center, label.width, label.height)
+
+    return {
+      ...candidate,
+      center,
+      width: label.width,
+      height: label.height,
+      status: this.getCandidateStatus(bounds, labelIndex),
+      selected: false,
+    }
+  }
+
+  private getCandidateStatus(
+    bounds: Bounds,
+    labelIndex: number,
+  ): CornerCandidateStatus {
+    if (this.intersectsAnyChip(bounds)) return "chip-collision"
+    if (traceCrossesBoundsInterior(bounds, this.traceMap)) {
+      return "trace-collision"
+    }
+    if (this.intersectsAnyOtherNetLabel(bounds, labelIndex)) {
+      return "netlabel-collision"
+    }
+
+    return "valid"
+  }
+
+  private applyCandidate(
+    labelIndex: number,
+    label: NetLabelPlacement,
+    candidate: EvaluatedCornerCandidate,
+  ) {
+    this.outputNetLabelPlacements[labelIndex] = {
+      ...label,
+      anchorPoint: candidate.anchorPoint,
+      center: candidate.center,
+    }
+  }
+
+  private shouldProcessLabel(label: NetLabelPlacement) {
+    return (
+      label.netId === "VCC" &&
+      this.getCornerCandidatesForLabel(label).length > 0
+    )
+  }
+
+  private intersectsAnyChip(bounds: Bounds) {
+    return this.inputProblem.chips.some((chip) =>
+      rectsOverlap(bounds, getRectBounds(chip.center, chip.width, chip.height)),
+    )
+  }
+
+  private intersectsAnyOtherNetLabel(bounds: Bounds, labelIndex: number) {
+    return this.outputNetLabelPlacements.some((label, index) => {
+      if (index === labelIndex) return false
+      return rectsOverlap(
+        bounds,
+        getRectBounds(label.center, label.width, label.height),
+      )
+    })
+  }
+
+  private getCornerCandidatesForLabel(label: NetLabelPlacement) {
+    const candidates: TraceCornerCandidate[] = []
+    const seenCornerKeys = new Set<string>()
+
+    for (const trace of this.getTraceLinesForLabel(label)) {
+      for (const anchorPoint of getTraceCorners(trace.tracePath)) {
+        const key = `${anchorPoint.x}:${anchorPoint.y}`
+        if (seenCornerKeys.has(key)) continue
+        seenCornerKeys.add(key)
+        candidates.push({
+          anchorPoint,
+          traceId: trace.mspPairId,
+          distance: getDistance(anchorPoint, label.anchorPoint),
+        })
+      }
+    }
+
+    return candidates.sort((a, b) => a.distance - b.distance)
+  }
+
+  private getTraceLinesForLabel(label: NetLabelPlacement) {
+    return this.traces.filter(
+      (trace) => isTraceLine(trace) && this.isTraceForLabel(trace, label),
+    )
+  }
+
+  private isTraceForLabel(trace: SolvedTracePath, label: NetLabelPlacement) {
+    if (!tracePathContainsPoint(trace.tracePath, label.anchorPoint)) {
+      return false
+    }
+
+    const traceIds = new Set(label.mspConnectionPairIds)
+    if (traceIds.size > 0) {
+      return traceIds.has(trace.mspPairId)
+    }
+
+    return trace.globalConnNetId === label.globalConnNetId
+  }
+
+  override visualize(): GraphicsObject {
+    return visualizeVccNetLabelCornerPlacementSolver({
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      outputNetLabelPlacements: this.outputNetLabelPlacements,
+      currentLabel: this.currentLabel,
+      currentCandidateResults: this.currentCandidateResults,
+      solved: this.solved,
+    })
+  }
+}

package/lib/solvers/VccNetLabelCornerPlacementSolver/geometry.ts

@@ -0,0 +1,59 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { Bounds } from "./types"
+
+export const EPS = 1e-6
+
+export const isTraceLine = (trace: SolvedTracePath) =>
+  getUniquePinCount(trace.pinIds) >= 2
+
+export const rectsOverlap = (a: Bounds, b: Bounds) =>
+  Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS &&
+  Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS
+
+export const getTraceCorners = (path: Point[]) => {
+  const corners: Point[] = []
+  for (let i = 1; i < path.length - 1; i++) {
+    const previousPoint = path[i - 1]!
+    const cornerPoint = path[i]!
+    const nextPoint = path[i + 1]!
+    if (isTraceCorner(previousPoint, cornerPoint, nextPoint)) {
+      corners.push(cornerPoint)
+    }
+  }
+  return corners
+}
+
+export const tracePathContainsPoint = (path: Point[], point: Point) => {
+  for (let i = 0; i < path.length - 1; i++) {
+    if (isPointOnSegment(point, path[i]!, path[i + 1]!)) return true
+  }
+  return false
+}
+
+export const getDistance = (a: Point, b: Point) =>
+  Math.abs(a.x - b.x) + Math.abs(a.y - b.y)
+
+const getUniquePinCount = (pinIds: string[]) => new Set(pinIds).size
+
+const isTraceCorner = (a: Point, b: Point, c: Point) =>
+  getSegmentOrientation(a, b) !== getSegmentOrientation(b, c)
+
+const isPointOnSegment = (point: Point, start: Point, end: Point) => {
+  if (getSegmentOrientation(start, end) === "horizontal") {
+    return (
+      Math.abs(point.y - start.y) <= EPS &&
+      point.x >= Math.min(start.x, end.x) - EPS &&
+      point.x <= Math.max(start.x, end.x) + EPS
+    )
+  }
+
+  return (
+    Math.abs(point.x - start.x) <= EPS &&
+    point.y >= Math.min(start.y, end.y) - EPS &&
+    point.y <= Math.max(start.y, end.y) + EPS
+  )
+}
+
+const getSegmentOrientation = (a: Point, b: Point) =>
+  Math.abs(a.y - b.y) <= EPS ? "horizontal" : "vertical"

package/lib/solvers/VccNetLabelCornerPlacementSolver/types.ts

@@ -0,0 +1,37 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+
+export interface VccNetLabelCornerPlacementSolverParams {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+export type Bounds = {
+  minX: number
+  minY: number
+  maxX: number
+  maxY: number
+}
+
+export type TraceCornerCandidate = {
+  anchorPoint: Point
+  traceId: string
+  distance: number
+}
+
+export type CornerCandidateStatus =
+  | "valid"
+  | "chip-collision"
+  | "trace-collision"
+  | "netlabel-collision"
+
+export type EvaluatedCornerCandidate = TraceCornerCandidate & {
+  center: Point
+  width: number
+  height: number
+  status: CornerCandidateStatus
+  selected: boolean
+}

package/lib/solvers/VccNetLabelCornerPlacementSolver/visualize.ts

@@ -0,0 +1,114 @@
+import type { GraphicsObject } from "graphics-debug"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { InputProblem } from "lib/types/InputProblem"
+import { getColorFromString } from "lib/utils/getColorFromString"
+import type { EvaluatedCornerCandidate } from "./types"
+
+const CANDIDATE_SELECTED_COLOR = "blue"
+const CANDIDATE_REJECTED_COLOR = "red"
+
+export const visualizeVccNetLabelCornerPlacementSolver = (state: {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+  currentLabel: NetLabelPlacement | null
+  currentCandidateResults: EvaluatedCornerCandidate[]
+  solved: boolean
+}): GraphicsObject => {
+  const graphics = visualizeInputProblem(state.inputProblem)
+  ensureGraphicsArrays(graphics)
+
+  drawTraces(graphics, state.traces)
+  drawNetLabels(graphics, state.outputNetLabelPlacements)
+
+  if (!state.solved) {
+    drawCurrentLabel(graphics, state.currentLabel)
+    drawCurrentCandidates(graphics, state.currentCandidateResults)
+  }
+
+  return graphics
+}
+
+const drawTraces = (graphics: GraphicsObject, traces: SolvedTracePath[]) => {
+  for (const trace of traces) {
+    graphics.lines!.push({
+      points: trace.tracePath,
+      strokeColor: "purple",
+    } as any)
+  }
+}
+
+const drawNetLabels = (
+  graphics: GraphicsObject,
+  labels: NetLabelPlacement[],
+) => {
+  for (const label of labels) {
+    graphics.rects!.push({
+      center: label.center,
+      width: label.width,
+      height: label.height,
+      fill: getColorFromString(label.globalConnNetId, 0.35),
+      strokeColor: getColorFromString(label.globalConnNetId, 0.9),
+      label: `netId: ${label.netId}\nglobalConnNetId: ${label.globalConnNetId}`,
+    } as any)
+    graphics.points!.push({
+      x: label.anchorPoint.x,
+      y: label.anchorPoint.y,
+      color: getColorFromString(label.globalConnNetId, 0.9),
+      label: `anchorPoint\norientation: ${label.orientation}`,
+    } as any)
+  }
+}
+
+const drawCurrentLabel = (
+  graphics: GraphicsObject,
+  currentLabel: NetLabelPlacement | null,
+) => {
+  if (!currentLabel) return
+
+  graphics.rects!.push({
+    center: currentLabel.center,
+    width: currentLabel.width,
+    height: currentLabel.height,
+    fill: "rgba(255, 0, 0, 0.2)",
+    strokeColor: CANDIDATE_REJECTED_COLOR,
+    label: `trace-line VCC target\n${currentLabel.netId ?? currentLabel.globalConnNetId}`,
+  } as any)
+}
+
+const drawCurrentCandidates = (
+  graphics: GraphicsObject,
+  candidates: EvaluatedCornerCandidate[],
+) => {
+  for (const candidate of candidates) {
+    const color = candidate.selected
+      ? CANDIDATE_SELECTED_COLOR
+      : CANDIDATE_REJECTED_COLOR
+    graphics.rects!.push({
+      center: candidate.center,
+      width: candidate.width,
+      height: candidate.height,
+      fill: candidate.selected
+        ? "rgba(0, 0, 255, 0.2)"
+        : "rgba(255, 0, 0, 0.15)",
+      strokeColor: color,
+      strokeDash: candidate.selected ? undefined : "4 2",
+      label: `${candidate.selected ? "selected" : candidate.status} trace corner\ntrace: ${candidate.traceId}\ndistance: ${candidate.distance.toFixed(3)}`,
+    } as any)
+    graphics.points!.push({
+      ...candidate.anchorPoint,
+      color,
+      label: `candidate anchor\n${candidate.status}`,
+    } as any)
+  }
+}
+
+const ensureGraphicsArrays = (graphics: GraphicsObject) => {
+  if (!graphics.lines) graphics.lines = []
+  if (!graphics.points) graphics.points = []
+  if (!graphics.rects) graphics.rects = []
+  if (!graphics.circles) graphics.circles = []
+  if (!graphics.texts) graphics.texts = []
+}

package/package.json

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

package/tests/assets/example22.json

@@ -94,7 +94,7 @@
     }
   ],
   "availableNetLabelOrientations": {
-    "VCC": ["y-"],
+    "VCC": ["y+"],
     "OUT": ["x-", "x+"],
     "GND": ["y-"],
     "MMM": ["x+", "x-"]

package/tests/examples/__snapshots__/example12.snap.svg

@@ -2,96 +2,99 @@
   <rect width="100%" height="100%" fill="white" />
   <g>
     <circle data-type="point" data-label="J1.1
-x+" data-x="1.1" data-y="0.2" cx="288.33702882483374" cy="207.43247369481963" r="3" fill="hsl(218, 100%, 50%, 0.8)" />
+x+" data-x="1.1" data-y="0.2" cx="301.5156017830609" cy="201.4588202080238" r="3" fill="hsl(218, 100%, 50%, 0.8)" />
   </g>
   <g>
     <circle data-type="point" data-label="J1.2
-x+" data-x="1.1" data-y="0" cx="288.33702882483374" cy="230.00856722434997" r="3" fill="hsl(219, 100%, 50%, 0.8)" />
+x+" data-x="1.1" data-y="0" cx="301.5156017830609" cy="225.2329658246657" r="3" fill="hsl(219, 100%, 50%, 0.8)" />
   </g>
   <g>
     <circle data-type="point" data-label="J1.3
-x+" data-x="1.1" data-y="-0.2" cx="288.33702882483374" cy="252.5846607538803" r="3" fill="hsl(220, 100%, 50%, 0.8)" />
+x+" data-x="1.1" data-y="-0.2" cx="301.5156017830609" cy="249.00711144130761" r="3" fill="hsl(220, 100%, 50%, 0.8)" />
   </g>
   <g>
     <circle data-type="point" data-label="R1.1
-x-" data-x="0.5499999999999996" data-y="-1.7944553499999996" cx="226.25277161862525" cy="432.5675263051804" r="3" fill="hsl(226, 100%, 50%, 0.8)" />
+x-" data-x="0.5499999999999996" data-y="-1.7944553499999996" cx="236.13670133729568" cy="438.5411797919762" r="3" fill="hsl(226, 100%, 50%, 0.8)" />
   </g>
   <g>
     <circle data-type="point" data-label="R1.2
-x+" data-x="1.6499999999999997" data-y="-1.7944553499999996" cx="350.4212860310421" cy="432.5675263051804" r="3" fill="hsl(227, 100%, 50%, 0.8)" />
+x+" data-x="1.6499999999999997" data-y="-1.7944553499999996" cx="366.8945022288261" cy="438.5411797919762" r="3" fill="hsl(227, 100%, 50%, 0.8)" />
   </g>
   <g>
     <circle data-type="point" data-label="C1.1
-x-" data-x="2.3099999999999996" data-y="0.01999999999999985" cx="424.9223946784922" cy="227.75095787139696" r="3" fill="hsl(121, 100%, 50%, 0.8)" />
+x-" data-x="2.3099999999999996" data-y="0.01999999999999985" cx="445.34918276374435" cy="222.85555126300153" r="3" fill="hsl(121, 100%, 50%, 0.8)" />
   </g>
   <g>
     <circle data-type="point" data-label="C1.2
-x+" data-x="3.41" data-y="0.01999999999999985" cx="549.090909090909" cy="227.75095787139696" r="3" fill="hsl(122, 100%, 50%, 0.8)" />
+x+" data-x="3.41" data-y="0.01999999999999985" cx="576.1069836552749" cy="222.85555126300153" r="3" fill="hsl(122, 100%, 50%, 0.8)" />
   </g>
   <g>
     <circle data-type="point" data-label="anchorPoint
-orientation: y+" data-x="1.4024999999999999" data-y="0.2" cx="322.48337028824835" cy="207.43247369481963" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+orientation: y+" data-x="1.7049999999999998" data-y="0.2" cx="373.4323922734027" cy="201.4588202080238" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
     <circle data-type="point" data-label="anchorPoint
-orientation: x+" data-x="1.3" data-y="-0.4486138374999999" cx="310.9131223543641" cy="280.6483069945576" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+orientation: x+" data-x="1.3" data-y="-0.4486138374999999" cx="325.28974739970283" cy="278.5600193164933" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
     <circle data-type="point" data-label="anchorPoint
-orientation: y-" data-x="1.8499999999999996" data-y="-1.7944553499999996" cx="372.9973795605724" cy="432.5675263051804" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+orientation: y-" data-x="1.8499999999999996" data-y="-1.7944553499999996" cx="390.668647845468" cy="438.5411797919762" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
     <circle data-type="point" data-label="anchorPoint
-orientation: x+" data-x="3.41" data-y="0.01999999999999985" cx="549.090909090909" cy="227.75095787139696" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+orientation: y-" data-x="3.511" data-y="-0.4310000000000001" cx="588.1129271916791" cy="276.466249628529" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
-    <polyline data-points="1.1,0.2 2.3099999999999996,0.01999999999999985" data-type="line" data-label="" points="288.33702882483374,207.43247369481963 424.9223946784922,227.75095787139696" fill="none" stroke="hsl(190, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
+    <polyline data-points="1.1,0.2 2.3099999999999996,0.01999999999999985" data-type="line" data-label="" points="301.5156017830609,201.4588202080238 445.34918276374435,222.85555126300153" fill="none" stroke="hsl(190, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
   </g>
   <g>
-    <polyline data-points="1.1,0 0.5499999999999996,-1.7944553499999996" data-type="line" data-label="" points="288.33702882483374,230.00856722434997 226.25277161862525,432.5675263051804" fill="none" stroke="hsl(158, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
+    <polyline data-points="1.1,0 0.5499999999999996,-1.7944553499999996" data-type="line" data-label="" points="301.5156017830609,225.2329658246657 236.13670133729568,438.5411797919762" fill="none" stroke="hsl(158, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
   </g>
   <g>
-    <polyline data-points="1.1,-0.2 1.6499999999999997,-1.7944553499999996" data-type="line" data-label="" points="288.33702882483374,252.5846607538803 350.4212860310421,432.5675263051804" fill="none" stroke="hsl(157, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
+    <polyline data-points="1.1,-0.2 1.6499999999999997,-1.7944553499999996" data-type="line" data-label="" points="301.5156017830609,249.00711144130761 366.8945022288261,438.5411797919762" fill="none" stroke="hsl(157, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
   </g>
   <g>
-    <polyline data-points="1.1,-0.2 3.41,0.01999999999999985" data-type="line" data-label="" points="288.33702882483374,252.5846607538803 549.090909090909,227.75095787139696" fill="none" stroke="hsl(157, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
+    <polyline data-points="1.1,-0.2 3.41,0.01999999999999985" data-type="line" data-label="" points="301.5156017830609,249.00711144130761 576.1069836552749,222.85555126300153" fill="none" stroke="hsl(157, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
   </g>
   <g>
-    <polyline data-points="1.6499999999999997,-1.7944553499999996 3.41,0.01999999999999985" data-type="line" data-label="" points="350.4212860310421,432.5675263051804 549.090909090909,227.75095787139696" fill="none" stroke="hsl(157, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
+    <polyline data-points="1.6499999999999997,-1.7944553499999996 3.41,0.01999999999999985" data-type="line" data-label="" points="366.8945022288261,438.5411797919762 576.1069836552749,222.85555126300153" fill="none" stroke="hsl(157, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
   </g>
   <g>
-    <polyline data-points="1.1,0.2 1.7049999999999998,0.2 1.7049999999999998,0.01999999999999985 2.3099999999999996,0.01999999999999985" data-type="line" data-label="" points="288.33702882483374,207.43247369481963 356.62971175166297,207.43247369481963 356.62971175166297,227.75095787139696 424.9223946784922,227.75095787139696" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="1.1,0.2 1.7049999999999998,0.2 1.7049999999999998,0.01999999999999985 2.3099999999999996,0.01999999999999985" data-type="line" data-label="" points="301.5156017830609,201.4588202080238 373.4323922734027,201.4588202080238 373.4323922734027,222.85555126300153 445.34918276374435,222.85555126300153" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <polyline data-points="1.1,0 1.3,0 1.3,-0.8972276749999998 0.34999999999999964,-0.8972276749999998 0.34999999999999964,-1.7944553499999996 0.5499999999999996,-1.7944553499999996" data-type="line" data-label="" points="288.33702882483374,230.00856722434997 310.9131223543641,230.00856722434997 310.9131223543641,331.28804676476517 203.6766780890949,331.28804676476517 203.6766780890949,432.5675263051804 226.25277161862525,432.5675263051804" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="1.1,0 1.3,0 1.3,-0.8972276749999998 0.34999999999999964,-0.8972276749999998 0.34999999999999964,-1.7944553499999996 0.5499999999999996,-1.7944553499999996" data-type="line" data-label="" points="301.5156017830609,225.2329658246657 325.28974739970283,225.2329658246657 325.28974739970283,331.88707280832097 212.36255572065375,331.88707280832097 212.36255572065375,438.5411797919762 236.13670133729568,438.5411797919762" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <polyline data-points="1.6499999999999997,-1.7944553499999996 1.8499999999999996,-1.7944553499999996 1.8499999999999996,-0.2 1.1,-0.2" data-type="line" data-label="" points="350.4212860310421,432.5675263051804 372.9973795605724,432.5675263051804 372.9973795605724,252.5846607538803 288.33702882483374,252.5846607538803" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="1.6499999999999997,-1.7944553499999996 1.8499999999999996,-1.7944553499999996 1.8499999999999996,-0.2 1.1,-0.2" data-type="line" data-label="" points="366.8945022288261,438.5411797919762 390.668647845468,438.5411797919762 390.668647845468,249.00711144130761 301.5156017830609,249.00711144130761" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <rect data-type="rect" data-label="schematic_component_0" data-x="0" data-y="0" x="40.000000000000014" y="184.8563801652893" width="248.33702882483374" height="90.30437411812136" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.008858928571428573" />
+    <polyline data-points="3.41,0.01999999999999985 3.511,0.01999999999999985 3.511,-0.4310000000000001" data-type="line" data-label="" points="576.1069836552749,222.85555126300153 588.1129271916791,222.85555126300153 588.1129271916791,276.466249628529" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <rect data-type="rect" data-label="schematic_component_1" data-x="1.0999999999999996" data-y="-1.7944553499999996" x="226.25277161862525" y="410.61731546059264" width="124.16851441241684" height="43.90042168917546" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.008858928571428573" />
+    <rect data-type="rect" data-label="schematic_component_0" data-x="0" data-y="0" x="40.00000000000003" y="177.6846745913819" width="261.5156017830609" height="95.09658246656761" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.008412500000000002" />
   </g>
   <g>
-    <rect data-type="rect" data-label="schematic_component_2" data-x="2.86" data-y="0.01999999999999985" x="424.9223946784922" y="180.34116145938327" width="124.16851441241681" height="94.81959282402738" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.008858928571428573" />
+    <rect data-type="rect" data-label="schematic_component_1" data-x="1.0999999999999996" data-y="-1.7944553499999996" x="236.13670133729568" y="415.42613075780093" width="130.75780089153045" height="46.230098068350514" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.008412500000000002" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="schematic_component_2" data-x="2.86" data-y="0.01999999999999985" x="445.34918276374435" y="172.92984546805354" width="130.75780089153056" height="99.85141158989597" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.008412500000000002" />
   </g>
   <g>
     <rect data-type="rect" data-label="netId: VCC
-globalConnNetId: connectivity_net0" data-x="1.4024999999999999" data-y="0.42500000000000004" x="311.1953235234831" y="156.6362632533764" width="22.57609352953034" height="50.796210441443236" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008858928571428573" />
+globalConnNetId: connectivity_net0" data-x="1.7049999999999998" data-y="0.42500000000000004" x="361.54531946508166" y="147.96699257057952" width="23.77414561664193" height="53.49182763744429" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008412500000000002" />
   </g>
   <g>
     <rect data-type="rect" data-label="netId: OUT
-globalConnNetId: connectivity_net1" data-x="1.5250000000000001" data-y="-0.4486138374999999" x="310.9131223543641" y="269.3602602297924" width="50.796210441443236" height="22.57609352953034" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008858928571428573" />
+globalConnNetId: connectivity_net1" data-x="1.5250000000000001" data-y="-0.4486138374999999" x="325.28974739970283" y="266.6729465081724" width="53.49182763744432" height="23.774145616641874" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008412500000000002" />
   </g>
   <g>
     <rect data-type="rect" data-label="netId: GND
-globalConnNetId: connectivity_net2" data-x="1.8499999999999996" data-y="-2.0194553499999994" x="361.7093327958072" y="432.56752630518037" width="22.576093529530397" height="50.79621044144329" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008858928571428573" />
+globalConnNetId: connectivity_net2" data-x="1.8499999999999996" data-y="-2.0194553499999994" x="378.78157503714704" y="438.54117979197616" width="23.77414561664193" height="53.49182763744432" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008412500000000002" />
   </g>
   <g>
     <rect data-type="rect" data-label="netId: GND
-globalConnNetId: connectivity_net2" data-x="3.636" data-y="0.01999999999999985" x="549.2037895585568" y="216.4629111066318" width="50.796210441443236" height="22.57609352953034" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008858928571428573" />
+globalConnNetId: connectivity_net2" data-x="3.511" data-y="-0.6560000000000001" x="576.2258543833581" y="276.466249628529" width="23.77414561664193" height="53.49182763744432" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008412500000000002" />
   </g>
   <g id="crosshair" style="display: none">
     <line id="crosshair-h" y1="0" y2="640" stroke="#666" stroke-width="0.5" />
@@ -121,12 +124,12 @@ globalConnNetId: connectivity_net2" data-x="3.636" data-y="0.01999999999999985"
 
       // Calculate real coordinates using inverse transformation
       const matrix = {
-        "a": 112.88046764765167,
+        "a": 118.8707280832095,
         "c": 0,
-        "e": 164.16851441241687,
+        "e": 170.75780089153048,
         "b": 0,
-        "d": -112.88046764765167,
-        "f": 230.00856722434997
+        "d": -118.8707280832095,
+        "f": 225.2329658246657
       };
       // Manually invert and apply the affine transform
       // Since we only use translate and scale, we can directly compute: