@tscircuit/schematic-trace-solver 0.0.51 → 0.0.53

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -100,7 +100,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     const indices: number[] = []
 
     for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
-      if (this.shouldProcessLabel(this.outputNetLabelPlacements[i]!, i)) {
+      if (this.shouldProcessLabel(this.outputNetLabelPlacements[i]!)) {
         indices.push(i)
       }
     }
@@ -108,14 +108,9 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return indices
   }
 
-  private shouldProcessLabel(label: NetLabelPlacement, labelIndex: number) {
+  private shouldProcessLabel(label: NetLabelPlacement) {
     const orientations = this.getAvailableOrientations(label)
-    if (orientations.length === 0) return false
-
-    return !(
-      orientations.includes(label.orientation) &&
-      this.isLabelPlacementValid(label, labelIndex)
-    )
+    return orientations.length > 0 && !orientations.includes(label.orientation)
   }
 
   private processLabel(labelIndex: number) {
@@ -441,27 +436,6 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     )?.netLabelWidth
   }
 
-  private isLabelPlacementValid(label: NetLabelPlacement, labelIndex: number) {
-    return this.isCandidateValidWithOffset(
-      {
-        orientation: label.orientation,
-        anchorPoint: label.anchorPoint,
-        center: label.center,
-        width: label.width,
-        height: label.height,
-      },
-      labelIndex,
-    )
-  }
-
-  private isCandidateValidWithOffset(
-    candidate: CandidateLabel,
-    labelIndex: number,
-  ) {
-    const bounds = this.getOffsetCollisionBounds(candidate)
-    return this.getBoundsStatus(bounds, labelIndex) === "valid"
-  }
-
   private getCandidateStatus(
     candidate: CandidateLabel,
     label: NetLabelPlacement,
@@ -505,16 +479,6 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return "valid"
   }
 
-  private getOffsetCollisionBounds(candidate: CandidateLabel) {
-    const direction = dir(candidate.orientation)
-    const collisionTestOffset = 1e-4
-    const testCenter = {
-      x: candidate.center.x + direction.x * collisionTestOffset,
-      y: candidate.center.y + direction.y * collisionTestOffset,
-    }
-    return getRectBounds(testCenter, candidate.width, candidate.height)
-  }
-
   private intersectsAnyOtherNetLabel(bounds: Bounds, labelIndex: number) {
     for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
       if (i === labelIndex) continue

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -13,6 +13,7 @@ import {
 } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { TraceOverlapShiftSolver } from "../TraceOverlapShiftSolver/TraceOverlapShiftSolver"
 import { NetLabelPlacementSolver } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { colorAvailableNetOrientationLabels } from "./colorAvailableNetOrientationLabels"
 import { visualizeInputProblem } from "./visualizeInputProblem"
 import { TraceLabelOverlapAvoidanceSolver } from "../TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver"
 import { correctPinsInsideChips } from "./correctPinsInsideChip"
@@ -23,6 +24,7 @@ import { TraceCleanupSolver } from "../TraceCleanupSolver/TraceCleanupSolver"
 import { Example28Solver } from "../Example28Solver/Example28Solver"
 import { AvailableNetOrientationSolver } from "../AvailableNetOrientationSolver/AvailableNetOrientationSolver"
 import { VccNetLabelCornerPlacementSolver } from "../VccNetLabelCornerPlacementSolver/VccNetLabelCornerPlacementSolver"
+import { TraceAnchoredNetLabelOverlapSolver } from "../TraceAnchoredNetLabelOverlapSolver/TraceAnchoredNetLabelOverlapSolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -75,6 +77,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   example28Solver?: Example28Solver
   availableNetOrientationSolver?: AvailableNetOrientationSolver
   vccNetLabelCornerPlacementSolver?: VccNetLabelCornerPlacementSolver
+  traceAnchoredNetLabelOverlapSolver?: TraceAnchoredNetLabelOverlapSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -270,6 +273,18 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         ]
       },
     ),
+    definePipelineStep(
+      "traceAnchoredNetLabelOverlapSolver",
+      TraceAnchoredNetLabelOverlapSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          traces: instance.availableNetOrientationSolver!.traces,
+          netLabelPlacements:
+            instance.vccNetLabelCornerPlacementSolver!.outputNetLabelPlacements,
+        },
+      ],
+    ),
   ]
 
   constructor(inputProblem: InputProblem) {
@@ -389,6 +404,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       circles: visualizations.flatMap((v) => v.circles || []),
       texts: visualizations.flatMap((v) => v.texts || []),
     }
+    colorAvailableNetOrientationLabels(finalGraphics, this.inputProblem)
     return finalGraphics
   }
 

package/lib/solvers/SchematicTracePipelineSolver/colorAvailableNetOrientationLabels.ts

@@ -0,0 +1,54 @@
+import type { GraphicsObject } from "graphics-debug"
+import type { InputProblem } from "lib/types/InputProblem"
+
+const AVAILABLE_Y_PLUS_COLOR = "#93c5fd"
+const AVAILABLE_Y_MINUS_COLOR = "#fca5a5"
+const AVAILABLE_ORIENTATION_FILL_ALPHA = "66"
+
+export const colorAvailableNetOrientationLabels = (
+  graphicsObject: GraphicsObject,
+  inputProblem: InputProblem,
+) => {
+  const availableOrientations = inputProblem.availableNetLabelOrientations
+  if (!availableOrientations) return
+
+  for (const rect of graphicsObject.rects ?? []) {
+    const orientations = getAvailableOrientationsForRect(
+      rect.label,
+      availableOrientations,
+    )
+    if (!orientations) continue
+
+    const hasYPlus = orientations.includes("y+")
+    const hasYMinus = orientations.includes("y-")
+    if (hasYPlus === hasYMinus) continue
+
+    const color = hasYPlus ? AVAILABLE_Y_PLUS_COLOR : AVAILABLE_Y_MINUS_COLOR
+
+    rect.fill = `${color}${AVAILABLE_ORIENTATION_FILL_ALPHA}`
+    rect.stroke = color
+    rect.color = color
+  }
+}
+
+const getAvailableOrientationsForRect = (
+  label: string | undefined,
+  availableOrientations: InputProblem["availableNetLabelOrientations"],
+) => {
+  for (const netId of getNetIdsFromRectLabel(label)) {
+    if (Object.hasOwn(availableOrientations, netId)) {
+      return availableOrientations[netId]
+    }
+  }
+
+  return undefined
+}
+
+const getNetIdsFromRectLabel = (label: string | undefined) => {
+  if (!label) return []
+
+  return [
+    label.match(/^netId: (.+)$/m)?.[1],
+    label.match(/^globalConnNetId: (.+)$/m)?.[1],
+  ].filter((netId): netId is string => Boolean(netId && netId !== "undefined"))
+}

package/lib/solvers/TraceAnchoredNetLabelOverlapSolver/TraceAnchoredNetLabelOverlapSolver.ts

@@ -0,0 +1,331 @@
+import type { GraphicsObject } from "graphics-debug"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import { generateCandidatesAlongTrace } from "./candidates"
+import {
+  getLabelBounds,
+  getTraceLocationsForPoint,
+  rectsOverlap,
+  rectsTouchOrOverlap,
+  traceCrossesBoundsInterior,
+} from "./geometry"
+import type {
+  Bounds,
+  CandidateStatus,
+  LabelCandidate,
+  LabelOverlap,
+  TraceAnchoredNetLabelOverlapSolverParams,
+} from "./types"
+import { visualizeTraceAnchoredNetLabelOverlapSolver } from "./visualize"
+
+type ActiveOverlapSearch = {
+  overlap: LabelOverlap
+  queuedLabelIndices: number[]
+  labelIndex: number | null
+  candidates: LabelCandidate[]
+  candidateIndex: number
+  candidateResults: LabelCandidate[]
+  completed: boolean
+}
+
+export class TraceAnchoredNetLabelOverlapSolver extends BaseSolver {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+
+  outputNetLabelPlacements: NetLabelPlacement[]
+  currentOverlap: LabelOverlap | null = null
+  currentCandidateResults: LabelCandidate[] = []
+
+  private activeSearch: ActiveOverlapSearch | null = null
+  private skippedOverlapKeys = new Set<string>()
+
+  constructor(params: TraceAnchoredNetLabelOverlapSolverParams) {
+    super()
+    this.inputProblem = params.inputProblem
+    this.traces = params.traces
+    this.netLabelPlacements = params.netLabelPlacements
+    this.outputNetLabelPlacements = [...params.netLabelPlacements]
+  }
+
+  override getConstructorParams(): ConstructorParameters<
+    typeof TraceAnchoredNetLabelOverlapSolver
+  >[0] {
+    return {
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      netLabelPlacements: this.netLabelPlacements,
+    }
+  }
+
+  override _step() {
+    if (this.activeSearch?.completed) this.clearActiveSearch()
+
+    const search = this.getNextSearchWithCandidates()
+    if (!search) {
+      this.finish()
+      return
+    }
+
+    this.evaluateNextCandidate(search)
+  }
+
+  getOutput() {
+    return {
+      netLabelPlacements: this.outputNetLabelPlacements,
+    }
+  }
+
+  private findNextOverlap() {
+    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+      for (let j = i + 1; j < this.outputNetLabelPlacements.length; j++) {
+        if (!this.isLabelEligible(i) && !this.isLabelEligible(j)) continue
+
+        const overlap = {
+          firstLabelIndex: i,
+          secondLabelIndex: j,
+        }
+        if (this.skippedOverlapKeys.has(this.getOverlapKey(overlap))) continue
+        if (this.labelsOverlap(overlap)) return overlap
+      }
+    }
+
+    return null
+  }
+
+  private isLabelEligible(labelIndex: number) {
+    return this.getTraceLocationsForLabel(labelIndex).length > 0
+  }
+
+  private labelsOverlap(overlap: LabelOverlap) {
+    const first = this.outputNetLabelPlacements[overlap.firstLabelIndex]
+    const second = this.outputNetLabelPlacements[overlap.secondLabelIndex]
+    if (!first || !second) return false
+
+    return rectsOverlap(getLabelBounds(first), getLabelBounds(second))
+  }
+
+  private startNextOverlapSearch() {
+    const overlap = this.findNextOverlap()
+    if (!overlap) return null
+
+    const search: ActiveOverlapSearch = {
+      overlap,
+      queuedLabelIndices: this.getMoveLabelIndices(overlap),
+      labelIndex: null,
+      candidates: [],
+      candidateIndex: 0,
+      candidateResults: [],
+      completed: false,
+    }
+
+    this.setActiveSearch(search)
+    return search
+  }
+
+  private getMoveLabelIndices(overlap: LabelOverlap) {
+    const labelIndices: number[] = []
+
+    if (this.isLabelEligible(overlap.secondLabelIndex)) {
+      labelIndices.push(overlap.secondLabelIndex)
+    }
+    if (this.isLabelEligible(overlap.firstLabelIndex)) {
+      labelIndices.push(overlap.firstLabelIndex)
+    }
+
+    return labelIndices
+  }
+
+  private getNextSearchWithCandidates() {
+    while (true) {
+      const search = this.activeSearch ?? this.startNextOverlapSearch()
+      if (!search) return null
+      if (this.activateNextLabelSearch(search)) return search
+
+      this.skipSearch(search)
+    }
+  }
+
+  private activateNextLabelSearch(search: ActiveOverlapSearch) {
+    if (
+      search.labelIndex !== null &&
+      search.candidateIndex < search.candidates.length
+    ) {
+      return true
+    }
+
+    while (search.queuedLabelIndices.length > 0) {
+      const labelIndex = search.queuedLabelIndices.shift()!
+      const label = this.outputNetLabelPlacements[labelIndex]
+      if (!label) continue
+
+      search.labelIndex = labelIndex
+      search.candidates = this.getCandidatesForLabel(label)
+      search.candidateIndex = 0
+      if (search.candidates.length > 0) return true
+    }
+
+    search.labelIndex = null
+    search.candidates = []
+    search.candidateIndex = 0
+    return false
+  }
+
+  private skipSearch(search: ActiveOverlapSearch) {
+    this.skippedOverlapKeys.add(this.getOverlapKey(search.overlap))
+    this.clearActiveSearch()
+  }
+
+  private evaluateNextCandidate(search: ActiveOverlapSearch) {
+    const labelIndex = search.labelIndex
+    if (labelIndex === null) return
+
+    const label = this.outputNetLabelPlacements[labelIndex]
+    const candidate = search.candidates[search.candidateIndex]
+    if (!label || !candidate) return
+
+    search.candidateIndex += 1
+
+    const evaluatedCandidate = {
+      ...candidate,
+      status: this.getCandidateStatus(candidate, labelIndex),
+    }
+    search.candidateResults.push(evaluatedCandidate)
+
+    if (evaluatedCandidate.status !== "valid") return
+
+    evaluatedCandidate.selected = true
+    this.applyCandidate(labelIndex, label, evaluatedCandidate)
+    search.completed = true
+  }
+
+  private getCandidatesForLabel(label: NetLabelPlacement) {
+    const candidates: LabelCandidate[] = []
+
+    for (const traceLocation of getTraceLocationsForPoint(
+      label.anchorPoint,
+      this.traces,
+    ).filter(({ trace }) => this.isTraceAssociatedWithLabel(trace, label))) {
+      candidates.push(
+        ...generateCandidatesAlongTrace({
+          inputProblem: this.inputProblem,
+          label,
+          traceLocation,
+        }),
+      )
+    }
+
+    return candidates
+  }
+
+  private getCandidateStatus(
+    candidate: LabelCandidate,
+    labelIndex: number,
+  ): CandidateStatus {
+    const bounds = getLabelBounds(candidate)
+    if (this.intersectsAnyChip(bounds)) return "chip-collision"
+    if (traceCrossesBoundsInterior(bounds, this.traces))
+      return "trace-collision"
+    if (this.intersectsAnyOtherLabel(bounds, labelIndex)) {
+      return "netlabel-collision"
+    }
+
+    return "valid"
+  }
+
+  private applyCandidate(
+    labelIndex: number,
+    label: NetLabelPlacement,
+    candidate: LabelCandidate,
+  ) {
+    this.outputNetLabelPlacements[labelIndex] = {
+      ...label,
+      anchorPoint: candidate.anchorPoint,
+      center: candidate.center,
+      width: candidate.width,
+      height: candidate.height,
+      orientation: candidate.orientation,
+    }
+  }
+
+  private intersectsAnyChip(bounds: Bounds) {
+    return this.inputProblem.chips.some((chip) =>
+      rectsTouchOrOverlap(
+        bounds,
+        getRectBounds(chip.center, chip.width, chip.height),
+      ),
+    )
+  }
+
+  private intersectsAnyOtherLabel(bounds: Bounds, labelIndex: number) {
+    return this.outputNetLabelPlacements.some((label, index) => {
+      if (index === labelIndex) return false
+      return rectsOverlap(bounds, getLabelBounds(label))
+    })
+  }
+
+  private getTraceLocationsForLabel(labelIndex: number) {
+    const label = this.outputNetLabelPlacements[labelIndex]
+    if (!label) return []
+
+    return getTraceLocationsForPoint(label.anchorPoint, this.traces).filter(
+      ({ trace }) => this.isTraceAssociatedWithLabel(trace, label),
+    )
+  }
+
+  private isTraceAssociatedWithLabel(
+    trace: SolvedTracePath,
+    label: NetLabelPlacement,
+  ) {
+    if (label.mspConnectionPairIds.includes(trace.mspPairId)) return true
+    if (label.netId !== undefined && label.netId === trace.userNetId) {
+      return true
+    }
+
+    return label.globalConnNetId === trace.globalConnNetId
+  }
+
+  private getOverlapKey(overlap: LabelOverlap) {
+    const first = this.outputNetLabelPlacements[overlap.firstLabelIndex]
+    const second = this.outputNetLabelPlacements[overlap.secondLabelIndex]
+    return [
+      overlap.firstLabelIndex,
+      overlap.secondLabelIndex,
+      first?.anchorPoint.x,
+      first?.anchorPoint.y,
+      second?.anchorPoint.x,
+      second?.anchorPoint.y,
+    ].join(":")
+  }
+
+  private finish() {
+    this.clearActiveSearch()
+    this.solved = true
+  }
+
+  private setActiveSearch(search: ActiveOverlapSearch) {
+    this.activeSearch = search
+    this.currentOverlap = search.overlap
+    this.currentCandidateResults = search.candidateResults
+  }
+
+  private clearActiveSearch() {
+    this.activeSearch = null
+    this.currentOverlap = null
+    this.currentCandidateResults = []
+  }
+
+  override visualize(): GraphicsObject {
+    return visualizeTraceAnchoredNetLabelOverlapSolver({
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      outputNetLabelPlacements: this.outputNetLabelPlacements,
+      currentOverlap: this.currentOverlap,
+      currentCandidateResults: this.currentCandidateResults,
+      solved: this.solved,
+    })
+  }
+}