@tscircuit/schematic-trace-solver 0.0.49 → 0.0.50

package/lib/solvers/AvailableNetOrientationSolver/geometry.ts

@@ -0,0 +1,192 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import type { FacingDirection } from "lib/utils/dir"
+import { EPS, TRACE_BOUNDARY_TOLERANCE } from "./constants"
+import type { Bounds, ChipSide } from "./types"
+
+export const isYOrientation = (
+  orientation: FacingDirection,
+): orientation is "y+" | "y-" => orientation === "y+" || orientation === "y-"
+
+export const isXOrientation = (
+  orientation: FacingDirection,
+): orientation is "x+" | "x-" => orientation === "x+" || orientation === "x-"
+
+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 rangesOverlap = (
+  minA: number,
+  maxA: number,
+  minB: number,
+  maxB: number,
+) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS
+
+export const traceCrossesBoundsInterior = (
+  bounds: Bounds,
+  traceMap: Record<string, SolvedTracePath>,
+) => {
+  for (const trace of Object.values(traceMap)) {
+    const points = trace.tracePath
+    for (let i = 0; i < points.length - 1; i++) {
+      if (segmentCrossesBoundsInterior(points[i]!, points[i + 1]!, bounds)) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
+const segmentCrossesBoundsInterior = (p1: Point, p2: Point, bounds: Bounds) => {
+  const interiorBounds = {
+    minX: bounds.minX + TRACE_BOUNDARY_TOLERANCE,
+    minY: bounds.minY + TRACE_BOUNDARY_TOLERANCE,
+    maxX: bounds.maxX - TRACE_BOUNDARY_TOLERANCE,
+    maxY: bounds.maxY - TRACE_BOUNDARY_TOLERANCE,
+  }
+
+  if (
+    interiorBounds.minX >= interiorBounds.maxX ||
+    interiorBounds.minY >= interiorBounds.maxY
+  ) {
+    return false
+  }
+
+  if (sameX(p1, p2)) {
+    if (
+      p1.x <= interiorBounds.minX + EPS ||
+      p1.x >= interiorBounds.maxX - EPS
+    ) {
+      return false
+    }
+    return rangesOverlap(
+      Math.min(p1.y, p2.y),
+      Math.max(p1.y, p2.y),
+      interiorBounds.minY,
+      interiorBounds.maxY,
+    )
+  }
+
+  if (sameY(p1, p2)) {
+    if (
+      p1.y <= interiorBounds.minY + EPS ||
+      p1.y >= interiorBounds.maxY - EPS
+    ) {
+      return false
+    }
+    return rangesOverlap(
+      Math.min(p1.x, p2.x),
+      Math.max(p1.x, p2.x),
+      interiorBounds.minX,
+      interiorBounds.maxX,
+    )
+  }
+
+  return false
+}
+
+export const tracePathCrossesAnyTrace = (
+  tracePath: Point[],
+  traceMap: Record<string, SolvedTracePath>,
+) => {
+  for (const trace of Object.values(traceMap)) {
+    const points = trace.tracePath
+    for (let i = 0; i < tracePath.length - 1; i++) {
+      for (let j = 0; j < points.length - 1; j++) {
+        if (
+          segmentsStrictlyCross(
+            tracePath[i]!,
+            tracePath[i + 1]!,
+            points[j]!,
+            points[j + 1]!,
+          )
+        ) {
+          return true
+        }
+      }
+    }
+  }
+
+  return false
+}
+
+const segmentsStrictlyCross = (a1: Point, a2: Point, b1: Point, b2: Point) => {
+  if (sameX(a1, a2) && sameY(b1, b2)) {
+    return (
+      a1.x > Math.min(b1.x, b2.x) + EPS &&
+      a1.x < Math.max(b1.x, b2.x) - EPS &&
+      b1.y > Math.min(a1.y, a2.y) + EPS &&
+      b1.y < Math.max(a1.y, a2.y) - EPS
+    )
+  }
+
+  if (sameY(a1, a2) && sameX(b1, b2)) {
+    return (
+      b1.x > Math.min(a1.x, a2.x) + EPS &&
+      b1.x < Math.max(a1.x, a2.x) - EPS &&
+      a1.y > Math.min(b1.y, b2.y) + EPS &&
+      a1.y < Math.max(b1.y, b2.y) - EPS
+    )
+  }
+
+  return false
+}
+
+export const getSideDistances = (point: Point, bounds: Bounds) =>
+  [
+    ["left", Math.abs(point.x - bounds.minX)] as const,
+    ["right", Math.abs(point.x - bounds.maxX)] as const,
+    ["bottom", Math.abs(point.y - bounds.minY)] as const,
+    ["top", Math.abs(point.y - bounds.maxY)] as const,
+  ] satisfies Array<readonly [ChipSide, number]>
+
+export const getConnectorTracePath = (
+  source: Point,
+  target: Point,
+  orientation: FacingDirection,
+) =>
+  simplifyOrthogonalPath(
+    isYOrientation(orientation)
+      ? [source, { x: target.x, y: source.y }, target]
+      : [source, { x: source.x, y: target.y }, target],
+  )
+
+const simplifyOrthogonalPath = (path: Point[]) => {
+  const deduped = path.filter(
+    (point, index) => index === 0 || !pointsEqual(point, path[index - 1]!),
+  )
+  if (deduped.length < 3) return deduped
+
+  const simplified: Point[] = [deduped[0]!]
+  for (let i = 1; i < deduped.length - 1; i++) {
+    const prev = simplified[simplified.length - 1]!
+    const point = deduped[i]!
+    const next = deduped[i + 1]!
+    if (
+      (sameX(prev, point) && sameX(point, next)) ||
+      (sameY(prev, point) && sameY(point, next))
+    ) {
+      continue
+    }
+    simplified.push(point)
+  }
+  simplified.push(deduped[deduped.length - 1]!)
+  return simplified
+}
+
+const pointsEqual = (a: Point, b: Point) => sameX(a, b) && sameY(a, b)
+
+const sameX = (a: Point, b: Point) => Math.abs(a.x - b.x) <= EPS
+
+const sameY = (a: Point, b: Point) => Math.abs(a.y - b.y) <= EPS
+
+export const getMaxSearchDistance = (inputProblem: InputProblem) => {
+  const maxChipWidth = Math.max(
+    ...inputProblem.chips.map((chip) => chip.width),
+    1,
+  )
+  return maxChipWidth * 3
+}

package/lib/solvers/AvailableNetOrientationSolver/traces.ts

@@ -0,0 +1,43 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputPin, InputProblem } from "lib/types/InputProblem"
+import type { CandidateLabel } from "./types"
+
+export const getPinMap = (inputProblem: InputProblem) => {
+  const pinMap: Record<string, InputPin & { chipId: string }> = {}
+  for (const chip of inputProblem.chips) {
+    for (const pin of chip.pins) {
+      pinMap[pin.pinId] = { ...pin, chipId: chip.chipId }
+    }
+  }
+  return pinMap
+}
+
+export const getTracePins = (
+  label: NetLabelPlacement,
+  pinMap: Record<string, InputPin & { chipId: string }>,
+): SolvedTracePath["pins"] => {
+  const pins = label.pinIds.flatMap((pinId) => {
+    const pin = pinMap[pinId]
+    return pin ? [pin] : []
+  })
+
+  if (pins.length >= 2) return [pins[0]!, pins[1]!]
+  if (pins.length === 1) return [pins[0]!, pins[0]!]
+
+  const syntheticPin = {
+    pinId: `${label.globalConnNetId}-netlabel-anchor`,
+    x: label.anchorPoint.x,
+    y: label.anchorPoint.y,
+    chipId: "available-net-orientation",
+  }
+  return [syntheticPin, syntheticPin]
+}
+
+export const toNetLabelPlacementPatch = (candidate: CandidateLabel) => ({
+  orientation: candidate.orientation,
+  anchorPoint: candidate.anchorPoint,
+  center: candidate.center,
+  width: candidate.width,
+  height: candidate.height,
+})

package/lib/solvers/AvailableNetOrientationSolver/types.ts

@@ -0,0 +1,44 @@
+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"
+import type { FacingDirection } from "lib/utils/dir"
+
+export interface AvailableNetOrientationSolverParams {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+export type Bounds = {
+  minX: number
+  minY: number
+  maxX: number
+  maxY: number
+}
+
+export type ChipSide = "left" | "right" | "top" | "bottom"
+
+export type CandidateLabel = {
+  orientation: FacingDirection
+  anchorPoint: Point
+  center: Point
+  width: number
+  height: number
+}
+
+export type CandidateStatus =
+  | "valid"
+  | "chip-collision"
+  | "trace-collision"
+  | "netlabel-collision"
+
+export type CandidatePhase = "rotate" | "shift"
+
+export type EvaluatedCandidate = CandidateLabel & {
+  status: CandidateStatus
+  selected: boolean
+  phase: CandidatePhase
+  distance?: number
+  outwardDistance?: number
+}

package/lib/solvers/AvailableNetOrientationSolver/visualize.ts

@@ -0,0 +1,123 @@
+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 { CANDIDATE_REJECTED_COLOR, CANDIDATE_SELECTED_COLOR } from "./constants"
+import type { EvaluatedCandidate } from "./types"
+
+export const visualizeAvailableNetOrientationSolver = (params: {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+  currentLabel: NetLabelPlacement | null
+  currentCandidateResults: EvaluatedCandidate[]
+  solved: boolean
+}): GraphicsObject => {
+  const graphics = visualizeInputProblem(params.inputProblem)
+  ensureGraphicsArrays(graphics)
+
+  drawTraces(graphics, params.traces)
+  drawNetLabels(graphics, params.outputNetLabelPlacements)
+  drawCurrentLabel(graphics, params.currentLabel, params.solved)
+  drawCurrentCandidates(graphics, params.currentCandidateResults, params.solved)
+
+  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,
+  solved: boolean,
+) => {
+  if (!currentLabel || solved) 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: `available orientation target\n${currentLabel.netId ?? currentLabel.globalConnNetId}`,
+  } as any)
+}
+
+const drawCurrentCandidates = (
+  graphics: GraphicsObject,
+  candidates: EvaluatedCandidate[],
+  solved: boolean,
+) => {
+  if (solved) return
+
+  for (const candidate of candidates) {
+    const color = candidate.selected
+      ? CANDIDATE_SELECTED_COLOR
+      : CANDIDATE_REJECTED_COLOR
+    const distanceLabel =
+      candidate.distance === undefined
+        ? ""
+        : `\ndistance: ${candidate.distance.toFixed(3)}`
+    const outwardDistanceLabel =
+      candidate.outwardDistance === undefined || candidate.outwardDistance === 0
+        ? ""
+        : `\noutward distance: ${candidate.outwardDistance.toFixed(3)}`
+
+    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} available orientation\nphase: ${candidate.phase}\norientation: ${candidate.orientation}${distanceLabel}${outwardDistanceLabel}`,
+    } as any)
+    graphics.points!.push({
+      x: candidate.anchorPoint.x,
+      y: candidate.anchorPoint.y,
+      color,
+      label: `candidate anchor\n${candidate.phase}\n${candidate.orientation}`,
+    } 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/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -21,6 +21,7 @@ import { LongDistancePairSolver } from "../LongDistancePairSolver/LongDistancePa
 import { MergedNetLabelObstacleSolver } from "../TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/LabelMergingSolver"
 import { TraceCleanupSolver } from "../TraceCleanupSolver/TraceCleanupSolver"
 import { Example28Solver } from "../Example28Solver/Example28Solver"
+import { AvailableNetOrientationSolver } from "../AvailableNetOrientationSolver/AvailableNetOrientationSolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -71,6 +72,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   traceLabelOverlapAvoidanceSolver?: TraceLabelOverlapAvoidanceSolver
   traceCleanupSolver?: TraceCleanupSolver
   example28Solver?: Example28Solver
+  availableNetOrientationSolver?: AvailableNetOrientationSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -240,6 +242,18 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         },
       ]
     }),
+    definePipelineStep(
+      "availableNetOrientationSolver",
+      AvailableNetOrientationSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          traces: instance.example28Solver!.outputTraces,
+          netLabelPlacements:
+            instance.example28Solver!.outputNetLabelPlacements,
+        },
+      ],
+    ),
   ]
 
   constructor(inputProblem: InputProblem) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.49",
+  "version": "0.0.50",
   "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.4024999999999999" data-y="0.2" cx="337.4739970282318" 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.4024999999999999" data-y="0.42500000000000004" x="325.5869242199108" 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: