@tscircuit/schematic-trace-solver 0.0.6 → 0.0.8

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

@@ -3,17 +3,27 @@ import type {
   NetLabelPlacement,
   OverlappingSameNetTraceGroup,
 } from "../NetLabelPlacementSolver"
-import type { InputChip, InputProblem } from "lib/types/InputProblem"
+import type { InputProblem } from "lib/types/InputProblem"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
 import type { FacingDirection } from "lib/utils/dir"
 import type { GraphicsObject } from "graphics-debug"
 import { ChipObstacleSpatialIndex } from "lib/data-structures/ChipObstacleSpatialIndex"
-import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
-import { getColorFromString } from "lib/utils/getColorFromString"
-
-export const NET_LABEL_HORIZONTAL_WIDTH = 0.4
-export const NET_LABEL_HORIZONTAL_HEIGHT = 0.2
+import {
+  getDimsForOrientation,
+  getCenterFromAnchor,
+  getRectBounds,
+} from "./geometry"
+import { rectIntersectsAnyTrace } from "./collisions"
+import { chooseHostTraceForGroup } from "./host"
+import { anchorsForSegment } from "./anchors"
+import { solveNetLabelPlacementForPortOnlyPin } from "./solvePortOnlyPin"
+import { visualizeSingleNetLabelPlacementSolver } from "./SingleNetLabelPlacementSolver_visualize"
+
+export {
+  NET_LABEL_HORIZONTAL_WIDTH,
+  NET_LABEL_HORIZONTAL_HEIGHT,
+} from "./geometry"
 // NOTE: net labels, when in the y+/y- orientation, are rotated and therefore
 // the width/height are swapped
 
@@ -77,95 +87,6 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
       new ChipObstacleSpatialIndex(params.inputProblem.chips)
   }
 
-  private 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,
-    }
-  }
-
-  private 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 }
-    }
-  }
-
-  private 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,
-    }
-  }
-
-  private 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
-    }
-  }
-
-  private rectIntersectsAnyTrace(
-    bounds: { minX: number; minY: number; maxX: number; maxY: number },
-    hostPathId: MspConnectionPairId,
-    hostSegIndex: number,
-  ): boolean {
-    for (const [pairId, solved] of Object.entries(this.inputTraceMap)) {
-      const pts = solved.tracePath
-      for (let i = 0; i < pts.length - 1; i++) {
-        if (pairId === hostPathId && i === hostSegIndex) continue
-        if (this.segmentIntersectsRect(pts[i]!, pts[i + 1]!, bounds))
-          return true
-      }
-    }
-    return false
-  }
-
   override _step() {
     if (this.netLabelPlacement) {
       this.solved = true
@@ -174,162 +95,33 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
 
     // Handle port-only island (no traces) by placing a label at the port
     if (this.overlappingSameNetTraceGroup.portOnlyPinId) {
-      const pinId = this.overlappingSameNetTraceGroup.portOnlyPinId
-      // Find pin coordinates
-      let pin: { x: number; y: number } | null = null
-      for (const chip of this.inputProblem.chips) {
-        const p = chip.pins.find((pp) => pp.pinId === pinId)
-        if (p) {
-          pin = { x: p.x, y: p.y }
-          break
-        }
-      }
-      if (!pin) {
-        this.failed = true
-        this.error = `Port-only pin not found: ${pinId}`
-        return
-      }
-
-      const orientations =
-        this.availableOrientations.length > 0
-          ? this.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 }
-
-      for (const orientation of orientations) {
-        const { width, height } = this.getDimsForOrientation(orientation)
-        // Place label fully outside the chip: shift center slightly outward
-        const baseCenter = this.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 = this.getRectBounds(center, width, height)
-
-        // Chip collision check
-        const chips = this.chipObstacleSpatialIndex.getChipsInBounds(bounds)
-        if (chips.length > 0) {
-          this.testedCandidates.push({
-            center,
-            width,
-            height,
-            bounds,
-            anchor,
-            orientation,
-            status: "chip-collision",
-            hostSegIndex: -1,
-          })
-          continue
-        }
-
-        // Trace collision check
-        if (
-          this.rectIntersectsAnyTrace(bounds, "" as MspConnectionPairId, -1)
-        ) {
-          this.testedCandidates.push({
-            center,
-            width,
-            height,
-            bounds,
-            anchor,
-            orientation,
-            status: "trace-collision",
-            hostSegIndex: -1,
-          })
-          continue
-        }
-
-        // Found a valid placement
-        this.testedCandidates.push({
-          center,
-          width,
-          height,
-          bounds,
-          anchor,
-          orientation,
-          status: "ok",
-          hostSegIndex: -1,
-        })
-
-        this.netLabelPlacement = {
-          globalConnNetId: this.overlappingSameNetTraceGroup.globalConnNetId,
-          dcConnNetId: undefined,
-          orientation,
-          anchorPoint: anchor,
-          width,
-          height,
-          center,
-        }
+      const res = solveNetLabelPlacementForPortOnlyPin({
+        inputProblem: this.inputProblem,
+        inputTraceMap: this.inputTraceMap,
+        chipObstacleSpatialIndex: this.chipObstacleSpatialIndex,
+        overlappingSameNetTraceGroup: this.overlappingSameNetTraceGroup,
+        availableOrientations: this.availableOrientations,
+      })
+      this.testedCandidates.push(...res.testedCandidates)
+      if (res.placement) {
+        this.netLabelPlacement = res.placement
         this.solved = true
         return
       }
-
       this.failed = true
-      this.error = "Could not place net label at port without collisions"
+      this.error =
+        res.error ?? "Could not place net label at port without collisions"
       return
     }
 
     // Prefer starting from the trace connected to the "largest" chip (most pins)
     const groupId = this.overlappingSameNetTraceGroup.globalConnNetId
-    const chipsById: Record<string, InputChip> = Object.fromEntries(
-      this.inputProblem.chips.map((c) => [c.chipId, c]),
-    )
-    const groupTraces = Object.values(this.inputTraceMap).filter(
-      (t) => t.globalConnNetId === groupId,
-    )
-    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 lengthOf = (path: SolvedTracePath) => {
-      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
-    }
-    const hostCandidates =
-      largestChipId == null
-        ? []
-        : groupTraces.filter(
-            (t) =>
-              t.pins[0].chipId === largestChipId ||
-              t.pins[1].chipId === largestChipId,
-          )
-    let host =
-      hostCandidates.length > 0
-        ? hostCandidates.reduce((a, b) => (lengthOf(a) >= lengthOf(b) ? a : b))
-        : this.overlappingSameNetTraceGroup.overlappingTraces
+    let host = chooseHostTraceForGroup({
+      inputProblem: this.inputProblem,
+      inputTraceMap: this.inputTraceMap,
+      globalConnNetId: groupId,
+      fallbackTrace: this.overlappingSameNetTraceGroup.overlappingTraces,
+    })
 
     if (!host) {
       this.failed = true
@@ -338,100 +130,138 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
     }
 
     // Ensure we traverse the host path starting at the segment attached to the largest chip's pin
-    let pts = host.tracePath.slice()
-    if (largestChipId && host) {
-      const largePin =
-        host.pins[0].chipId === largestChipId ? host.pins[0] : host.pins[1]
-      const d0 =
-        Math.abs(pts[0].x - largePin.x) + Math.abs(pts[0].y - largePin.y)
-      const dL =
-        Math.abs(pts[pts.length - 1].x - largePin.x) +
-        Math.abs(pts[pts.length - 1].y - largePin.y)
-      if (d0 > dL) {
-        pts = pts.slice().reverse()
-      }
-    }
+    const tracesToScanBase = Object.values(this.inputTraceMap).filter(
+      (t) => t.globalConnNetId === groupId,
+    )
+    const tracesToScan =
+      this.availableOrientations.length === 1
+        ? [
+            host,
+            ...tracesToScanBase.filter((t) => t.mspPairId !== host!.mspPairId),
+          ]
+        : [host]
 
     const orientations =
       this.availableOrientations.length > 0
         ? this.availableOrientations
         : (["x+", "x-", "y+", "y-"] as FacingDirection[])
 
-    const EPS = 1e-6
-    const anchorsForSegment = (
-      a: { x: number; y: number },
-      b: { x: number; y: number },
+    const singleOrientationMode = this.availableOrientations.length === 1
+
+    // For axis-aligned comparisons (furthest-point selection)
+    const scoreFor = (
+      orientation: FacingDirection,
+      anchor: { 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 },
-      ]
+      switch (orientation) {
+        case "y+":
+          return anchor.y
+        case "y-":
+          return -anchor.y
+        case "x+":
+          return anchor.x
+        case "x-":
+          return -anchor.x
+      }
     }
+    let bestCandidate: {
+      anchor: { x: number; y: number }
+      orientation: FacingDirection
+      width: number
+      height: number
+      center: { x: number; y: number }
+      hostSegIndex: number
+      dcConnNetId: string
+    } | null = null
+    let bestScore = -Infinity
 
-    for (let si = 0; si < pts.length - 1; si++) {
-      const a = pts[si]!
-      const b = pts[si + 1]!
-      const isH = Math.abs(a.y - b.y) < EPS
-      const isV = Math.abs(a.x - b.x) < EPS
-      if (!isH && !isV) continue
-
-      // Only consider orientations perpendicular to the segment to avoid
-      // self-overlap with the host segment.
-      const segmentAllowed: FacingDirection[] = isH
-        ? (["y+", "y-"] as FacingDirection[])
-        : (["x+", "x-"] as FacingDirection[])
-      const candidateOrients = orientations.filter((o) =>
-        segmentAllowed.includes(o),
-      )
-      if (candidateOrients.length === 0) continue
-
-      const anchors = anchorsForSegment(a, b)
-      for (const anchor of anchors) {
-        for (const orientation of candidateOrients) {
-          const { width, height } = this.getDimsForOrientation(orientation)
-          const center = this.getCenterFromAnchor(
-            anchor,
-            orientation,
-            width,
-            height,
-          )
+    const EPS = 1e-6
 
-          // Small outward offset to avoid counting the touching trace as a collision
-          const outward =
-            orientation === "x+"
-              ? { x: 1, y: 0 }
-              : orientation === "x-"
-                ? { x: -1, y: 0 }
-                : orientation === "y+"
-                  ? { x: 0, y: 1 }
-                  : { x: 0, y: -1 }
-          const offset = 1e-4
-          const testCenter = {
-            x: center.x + outward.x * offset,
-            y: center.y + outward.y * offset,
-          }
-          const bounds = this.getRectBounds(testCenter, width, height)
+    for (const curr of tracesToScan) {
+      const pts = curr.tracePath.slice()
+      for (let si = 0; si < pts.length - 1; si++) {
+        const a = pts[si]!
+        const b = pts[si + 1]!
+        const isH = Math.abs(a.y - b.y) < EPS
+        const isV = Math.abs(a.x - b.x) < EPS
+        if (!isH && !isV) continue
+
+        // Only consider orientations perpendicular to the segment to avoid
+        // self-overlap with the host segment.
+        const segmentAllowed: FacingDirection[] = isH
+          ? (["y+", "y-"] as FacingDirection[])
+          : (["x+", "x-"] as FacingDirection[])
+        const candidateOrients = orientations.filter((o) =>
+          segmentAllowed.includes(o),
+        )
+        if (candidateOrients.length === 0) continue
 
-          // Chip collision check
-          const chips = this.chipObstacleSpatialIndex.getChipsInBounds(bounds)
-          if (chips.length > 0) {
-            this.testedCandidates.push({
-              center: testCenter,
-              width,
-              height,
-              bounds,
+        const anchors = anchorsForSegment(a, b)
+        for (const anchor of anchors) {
+          for (const orientation of candidateOrients) {
+            const { width, height } = getDimsForOrientation(orientation)
+            const center = getCenterFromAnchor(
               anchor,
               orientation,
-              status: "chip-collision",
-              hostSegIndex: si,
-            })
-            continue
-          }
-
-          // Trace collision check (ignore the host segment)
-          if (this.rectIntersectsAnyTrace(bounds, host!.mspPairId, si)) {
+              width,
+              height,
+            )
+
+            // Small outward offset to avoid counting the touching trace as a collision
+            const outward =
+              orientation === "x+"
+                ? { x: 1, y: 0 }
+                : orientation === "x-"
+                  ? { x: -1, y: 0 }
+                  : orientation === "y+"
+                    ? { x: 0, y: 1 }
+                    : { x: 0, y: -1 }
+            const offset = 1e-4
+            const testCenter = {
+              x: center.x + outward.x * offset,
+              y: center.y + outward.y * offset,
+            }
+            const bounds = getRectBounds(testCenter, width, height)
+
+            // Chip collision check
+            const chips = this.chipObstacleSpatialIndex.getChipsInBounds(bounds)
+            if (chips.length > 0) {
+              this.testedCandidates.push({
+                center: testCenter,
+                width,
+                height,
+                bounds,
+                anchor,
+                orientation,
+                status: "chip-collision",
+                hostSegIndex: si,
+              })
+              continue
+            }
+
+            // Trace collision check (ignore the host segment)
+            if (
+              rectIntersectsAnyTrace(
+                bounds,
+                this.inputTraceMap,
+                curr.mspPairId,
+                si,
+              )
+            ) {
+              this.testedCandidates.push({
+                center: testCenter,
+                width,
+                height,
+                bounds,
+                anchor,
+                orientation,
+                status: "trace-collision",
+                hostSegIndex: si,
+              })
+              continue
+            }
+
+            // Found a valid placement
             this.testedCandidates.push({
               center: testCenter,
               width,
@@ -439,160 +269,64 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
               bounds,
               anchor,
               orientation,
-              status: "trace-collision",
+              status: "ok",
               hostSegIndex: si,
             })
-            continue
-          }
-
-          // Found a valid placement
-          this.testedCandidates.push({
-            center: testCenter,
-            width,
-            height,
-            bounds,
-            anchor,
-            orientation,
-            status: "ok",
-            hostSegIndex: si,
-          })
 
-          this.netLabelPlacement = {
-            globalConnNetId: this.overlappingSameNetTraceGroup.globalConnNetId,
-            dcConnNetId: host!.dcConnNetId,
-            orientation,
-            anchorPoint: anchor,
-            width,
-            height,
-            center,
+            if (singleOrientationMode) {
+              const s = scoreFor(orientation, anchor)
+              if (s > bestScore + 1e-9) {
+                bestScore = s
+                bestCandidate = {
+                  anchor,
+                  orientation,
+                  width,
+                  height,
+                  center,
+                  hostSegIndex: si,
+                  dcConnNetId: curr.dcConnNetId,
+                }
+              }
+              // Continue traversing to prioritize the furthest valid point
+              continue
+            }
+
+            this.netLabelPlacement = {
+              globalConnNetId:
+                this.overlappingSameNetTraceGroup.globalConnNetId,
+              dcConnNetId: curr.dcConnNetId,
+              orientation,
+              anchorPoint: anchor,
+              width,
+              height,
+              center,
+            }
+            this.solved = true
+            return
           }
-          this.solved = true
-          return
         }
       }
     }
 
+    if (singleOrientationMode && bestCandidate) {
+      this.netLabelPlacement = {
+        globalConnNetId: this.overlappingSameNetTraceGroup.globalConnNetId,
+        dcConnNetId: bestCandidate.dcConnNetId,
+        orientation: bestCandidate.orientation,
+        anchorPoint: bestCandidate.anchor,
+        width: bestCandidate.width,
+        height: bestCandidate.height,
+        center: bestCandidate.center,
+      }
+      this.solved = true
+      return
+    }
+
     this.failed = true
     this.error = "Could not place net label without collisions"
   }
 
   override visualize(): GraphicsObject {
-    const graphics = visualizeInputProblem(this.inputProblem)
-
-    // Visualize the entire trace group for this net id
-    const groupId = this.overlappingSameNetTraceGroup.globalConnNetId
-    // Choose host as in _step: the trace that touches the largest chip in the group
-    const chipsById: Record<string, InputChip> = Object.fromEntries(
-      this.inputProblem.chips.map((c) => [c.chipId, c]),
-    )
-    const groupTraces = Object.values(this.inputTraceMap).filter(
-      (t) => t.globalConnNetId === groupId,
-    )
-    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 lengthOf = (path: SolvedTracePath) => {
-      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
-    }
-    const hostCandidates =
-      largestChipId == null
-        ? []
-        : groupTraces.filter(
-            (t) =>
-              t.pins[0].chipId === largestChipId ||
-              t.pins[1].chipId === largestChipId,
-          )
-    const host =
-      hostCandidates.length > 0
-        ? hostCandidates.reduce((a, b) => (lengthOf(a) >= lengthOf(b) ? a : b))
-        : this.overlappingSameNetTraceGroup.overlappingTraces
-    const groupStroke = getColorFromString(groupId, 0.9)
-    const groupFill = getColorFromString(groupId, 0.5)
-
-    for (const trace of Object.values(this.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 this.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 (this.netLabelPlacement) {
-      const p = this.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
+    return visualizeSingleNetLabelPlacementSolver(this)
   }
 }