Preserve pad geometry and repair constrained via clearances

lib/drc/AutoroutingDrcEngine.ts

@@ -1,11 +1,21 @@
 import {
+  getBoundsFromPoints,
   getSegmentIntersection,
   pointToSegmentClosestPoint,
   segmentToBoundsMinDistance,
   segmentToCircleMinDistance,
   segmentToSegmentMinDistance,
 } from "@tscircuit/math-utils"
 import type { ConnectivityMap } from "circuit-json-to-connectivity-map"
+import {
+  applyToPoint,
+  applyToPoints,
+  compose,
+  inverse,
+  type Matrix,
+  rotateDEG,
+  translate,
+} from "transformation-matrix"
 import type {
   SimpleRouteJson,
   SimplifiedPcbTrace,
@@ -61,6 +71,8 @@ type StaticObstacle = {
   width: number
   height: number
   radius?: number
+  padToBoardTransform: Matrix
+  boardToPadTransform: Matrix
   layers: string[]
   pcbPortId?: string
 }
@@ -162,11 +174,21 @@ const getViaBounds = (via: Via): Bounds => {
   }
 }
 
-const getObstacleBounds = (obstacle: StaticObstacle): Bounds => ({
-  minX: obstacle.x - obstacle.width / 2,
-  minY: obstacle.y - obstacle.height / 2,
-  maxX: obstacle.x + obstacle.width / 2,
-  maxY: obstacle.y + obstacle.height / 2,
+const getObstacleBounds = (obstacle: StaticObstacle): Bounds =>
+  getBoundsFromPoints(
+    applyToPoints(obstacle.padToBoardTransform, [
+      { x: -obstacle.width / 2, y: -obstacle.height / 2 },
+      { x: obstacle.width / 2, y: -obstacle.height / 2 },
+      { x: obstacle.width / 2, y: obstacle.height / 2 },
+      { x: -obstacle.width / 2, y: obstacle.height / 2 },
+    ]),
+  )!
+
+const getObstacleLocalBounds = (obstacle: StaticObstacle): Bounds => ({
+  minX: -obstacle.width / 2,
+  minY: -obstacle.height / 2,
+  maxX: obstacle.width / 2,
+  maxY: obstacle.height / 2,
 })
 
 const getCellKey = (cellX: number, cellY: number) => `${cellX}:${cellY}`
@@ -523,8 +545,19 @@ export class AutoroutingDrcEngine {
       if (addedIds.has(obstacleId)) continue
       addedIds.add(obstacleId)
 
+      const hasRotation =
+        typeof obstacle.ccwRotationDegrees === "number" &&
+        Number.isFinite(obstacle.ccwRotationDegrees)
+      const padToBoardTransform = compose(
+        translate(obstacle.center.x, obstacle.center.y),
+        rotateDEG(hasRotation ? obstacle.ccwRotationDegrees! : 0),
+      )
+      // Explicit rotation describes a rectangular pad, including square pads.
+      // Only legacy, unrotated multilayer obstacles use the circular inference.
       const isCircular =
-        isMultiLayer && Math.abs(obstacle.width - obstacle.height) < 0.001
+        !hasRotation &&
+        isMultiLayer &&
+        Math.abs(obstacle.width - obstacle.height) < 0.001
       obstacles.push({
         kind: "obstacle",
         obstacleType,
@@ -534,6 +567,8 @@ export class AutoroutingDrcEngine {
         y: obstacle.center.y,
         width: obstacle.width,
         height: obstacle.height,
+        padToBoardTransform,
+        boardToPadTransform: inverse(padToBoardTransform),
         ...(isCircular
           ? { radius: Math.max(obstacle.width, obstacle.height) / 2 }
           : {}),
@@ -752,10 +787,19 @@ export class AutoroutingDrcEngine {
     if (this.obstacleSharesNet(segment.netId, obstacle)) return undefined
     this.lastRunStats.exactCheckCount += 1
 
-    const obstacleBounds = getObstacleBounds(obstacle)
+    const obstacleBounds = getObstacleLocalBounds(obstacle)
+    const localSegment = {
+      ...segment,
+      start: applyToPoint(obstacle.boardToPadTransform, segment.start),
+      end: applyToPoint(obstacle.boardToPadTransform, segment.end),
+    }
     const shapeDistance =
       obstacle.radius === undefined
-        ? segmentToBoundsMinDistance(segment.start, segment.end, obstacleBounds)
+        ? segmentToBoundsMinDistance(
+            localSegment.start,
+            localSegment.end,
+            obstacleBounds,
+          )
         : segmentToCircleMinDistance(segment.start, segment.end, {
             x: obstacle.x,
             y: obstacle.y,
@@ -788,7 +832,13 @@ export class AutoroutingDrcEngine {
       ],
       center:
         obstacle.radius === undefined
-          ? getClosestPointBetweenSegmentAndBounds(segment, obstacleBounds)
+          ? applyToPoint(
+              obstacle.padToBoardTransform,
+              getClosestPointBetweenSegmentAndBounds(
+                localSegment,
+                obstacleBounds,
+              ),
+            )
           : getClosestPointBetweenSegmentAndPoint(segment, obstacle),
     }
   }
@@ -800,19 +850,20 @@ export class AutoroutingDrcEngine {
     if (this.obstacleSharesNet(via.netId, obstacle)) return undefined
     this.lastRunStats.exactCheckCount += 1
 
-    const obstacleBounds = getObstacleBounds(obstacle)
+    const obstacleBounds = getObstacleLocalBounds(obstacle)
+    const localVia = applyToPoint(obstacle.boardToPadTransform, via)
     const pointToObstacleDistance =
       obstacle.radius === undefined
         ? Math.hypot(
             Math.max(
-              obstacleBounds.minX - via.x,
+              obstacleBounds.minX - localVia.x,
               0,
-              via.x - obstacleBounds.maxX,
+              localVia.x - obstacleBounds.maxX,
             ),
             Math.max(
-              obstacleBounds.minY - via.y,
+              obstacleBounds.minY - localVia.y,
               0,
-              via.y - obstacleBounds.maxY,
+              localVia.y - obstacleBounds.maxY,
             ),
           )
         : Math.hypot(via.x - obstacle.x, via.y - obstacle.y) - obstacle.radius

lib/solvers/GlobalDrcForceImproveSolver/GlobalDrcForceImproveSolver.ts

@@ -110,11 +110,13 @@ const TRACE_LAYER_CORRIDOR_VARIANTS = ([1, -1] as const).flatMap(
 
 const TRACE_LAYER_CORRIDOR_MAX_DRC_COUNT = 8
 
+const TRACE_PAIR_DISPLACEMENT_VARIANTS = ([0, 1] as const).map((routeSide) => ({
+  kind: "displacementChain" as const,
+  routeSide,
+}))
+
 const LOW_COUNT_TRACE_TOPOLOGY_VARIANTS = [
-  ...([0, 1] as const).map((routeSide) => ({
-    kind: "displacementChain" as const,
-    routeSide,
-  })),
+  ...TRACE_PAIR_DISPLACEMENT_VARIANTS,
   ...([-1, 1] as const).flatMap((directionSign) =>
     ([0, 1] as const).map((routeSide) => ({
       kind: "segment" as const,
@@ -391,7 +393,7 @@ export class GlobalDrcForceImproveSolver extends BaseSolver {
   }
 
   private getViaIssueCount(snapshot: DrcSnapshot) {
-    return getViaDrcIssueCount(snapshot, false)
+    return getViaDrcIssueCount(snapshot)
   }
 
   private getRepairIssueCount(snapshot: DrcSnapshot) {
@@ -676,6 +678,42 @@ export class GlobalDrcForceImproveSolver extends BaseSolver {
         error,
         bestSnapshot.traceRouteIndexById,
       )
+      if (
+        this.enableTraceViaOwnerTargeting &&
+        traceRouteIndex !== undefined &&
+        Array.isArray(error.pcb_via_ids) &&
+        error.pcb_via_ids.length === 1 &&
+        candidateAttemptsThisStep < maxCandidateAttemptsThisStep
+      ) {
+        const candidateRoutes = cloneRoutes(bestRoutes)
+        if (
+          applyViaOnlyDisplacementForTraceError(
+            this.srj,
+            candidateRoutes,
+            error,
+            bestSnapshot.traceRouteIndexById,
+            traceRouteIndex,
+            this.connMap,
+          )
+        ) {
+          const routes = materializeRoutes(candidateRoutes)
+          const snapshot = this.getSnapshot(routes)
+          const viaIssueCount = this.getViaIssueCount(snapshot)
+          candidateAttemptsThisStep += 1
+          this.candidateAttempts += 1
+          if (
+            viaIssueCount <= bestViaIssueCount &&
+            isDrcSnapshotCountBetter(snapshot, bestSnapshot)
+          ) {
+            bestTopologyCandidate = {
+              routes,
+              snapshot,
+              viaIssueCount,
+              usesViaInPad: false,
+            }
+          }
+        }
+      }
       if (this.enableSafeTraceLayerMoves && traceRouteIndex !== undefined) {
         const safeRouteIndexes = traceRoutePair ?? [traceRouteIndex]
         const localSpanVariantCount =
@@ -727,48 +765,62 @@ export class GlobalDrcForceImproveSolver extends BaseSolver {
             ? Math.floor(layerVariant / this.srj.layerCount)
             : 0
           const changedRouteIndex = safeRouteIndexes[routeSide]!
-          const candidateRoutes = cloneRoutesForIndexes(bestRoutes, [
-            changedRouteIndex,
-          ])
-          const changed = applySafeTraceLayerMoveForError(
-            this.srj,
-            candidateRoutes,
-            error,
-            changedRouteIndex,
-            targetZ,
-            spanExpansion,
-            this.connMap,
-            directionVariant,
-          )
-          if (!changed) continue
+          // Compare both placements before accepting a direction. The helper
+          // skips the adjusted candidate when its via positions are unchanged.
+          let evaluatedDirection = false
+          for (const adjustViaClearance of [false, true]) {
+            const candidateRoutes = cloneRoutesForIndexes(bestRoutes, [
+              changedRouteIndex,
+            ])
+            const changed = applySafeTraceLayerMoveForError(
+              this.srj,
+              candidateRoutes,
+              error,
+              changedRouteIndex,
+              targetZ,
+              spanExpansion,
+              this.connMap,
+              directionVariant,
+              adjustViaClearance,
+            )
+            if (!changed) continue
 
-          const materializedCandidateRoutes = materializeRoutesForIndexes(
-            candidateRoutes,
-            [changedRouteIndex],
-          )
-          safeTraceLayerCandidateAttemptsThisStep += 1
-          this.candidateAttempts += 1
-          const candidateSnapshot = this.getSnapshot(
-            materializedCandidateRoutes,
-          )
-          const candidateViaIssueCount =
-            this.getViaIssueCount(candidateSnapshot)
-          const comparisonSnapshot =
-            bestTopologyCandidate?.snapshot ?? bestSnapshot
-          const comparisonViaIssueCount =
-            bestTopologyCandidate?.viaIssueCount ?? bestViaIssueCount
+            const materializedCandidateRoutes = materializeRoutesForIndexes(
+              candidateRoutes,
+              [changedRouteIndex],
+            )
+            evaluatedDirection = true
+            this.candidateAttempts += 1
+            const candidateSnapshot = this.getSnapshot(
+              materializedCandidateRoutes,
+            )
+            const candidateViaIssueCount =
+              this.getViaIssueCount(candidateSnapshot)
+            const comparisonSnapshot =
+              bestTopologyCandidate?.snapshot ?? bestSnapshot
+            const comparisonViaIssueCount =
+              bestTopologyCandidate?.viaIssueCount ?? bestViaIssueCount
 
-          if (
-            candidateViaIssueCount <= comparisonViaIssueCount &&
-            isDrcSnapshotCountBetter(candidateSnapshot, comparisonSnapshot)
-          ) {
-            bestTopologyCandidate = {
-              routes: materializedCandidateRoutes,
-              snapshot: candidateSnapshot,
-              viaIssueCount: candidateViaIssueCount,
-              usesViaInPad: false,
+            if (
+              candidateViaIssueCount <= comparisonViaIssueCount &&
+              (isDrcSnapshotCountBetter(
+                candidateSnapshot,
+                comparisonSnapshot,
+              ) ||
+                (bestTopologyCandidate !== undefined &&
+                  getRepairDrcIssueCount(candidateSnapshot) ===
+                    getRepairDrcIssueCount(comparisonSnapshot) &&
+                  candidateSnapshot.count < comparisonSnapshot.count))
+            ) {
+              bestTopologyCandidate = {
+                routes: materializedCandidateRoutes,
+                snapshot: candidateSnapshot,
+                viaIssueCount: candidateViaIssueCount,
+                usesViaInPad: false,
+              }
             }
           }
+          if (evaluatedDirection) safeTraceLayerCandidateAttemptsThisStep += 1
         }
         if (traceErrorKey) {
           this.safeTraceLayerCursorByErrorId.set(
@@ -849,7 +901,6 @@ export class GlobalDrcForceImproveSolver extends BaseSolver {
       }
       if (
         this.enableSafeTraceLayerMoves &&
-        shouldTryTracePairTopology &&
         traceErrorKey &&
         ((this.initialLowCountErrorsHaveMovableTraces &&
           (traceRoutePair || traceRouteIndex !== undefined)) ||
@@ -858,7 +909,12 @@ export class GlobalDrcForceImproveSolver extends BaseSolver {
         const traceTopologyVariants = this
           .initialLowCountErrorsHaveMovableTraces
           ? LOW_COUNT_TRACE_TOPOLOGY_VARIANTS
-          : TRACE_PAIR_DETOUR_VARIANTS
+          : shouldTryTracePairTopology
+            ? [
+                ...TRACE_PAIR_DISPLACEMENT_VARIANTS,
+                ...TRACE_PAIR_DETOUR_VARIANTS,
+              ]
+            : TRACE_PAIR_DISPLACEMENT_VARIANTS
         const detourRouteIndexes = traceRoutePair ?? [traceRouteIndex!]
         let detourCursor =
           this.tracePairDetourCursorByErrorId.get(traceErrorKey) ?? 0
@@ -906,7 +962,6 @@ export class GlobalDrcForceImproveSolver extends BaseSolver {
 
             if (
               chainIssueCount > 0 &&
-              chainIssueCount <= 3 &&
               candidateAttemptsThisStep < maxCandidateAttemptsThisStep
             ) {
               const propagatedRoutes = cloneRoutes(materializedChainRoutes)
@@ -959,6 +1014,7 @@ export class GlobalDrcForceImproveSolver extends BaseSolver {
             const comparisonViaIssueCount =
               bestTopologyCandidate?.viaIssueCount ?? bestViaIssueCount
             if (
+              chainViaIssueCount <= comparisonViaIssueCount &&
               isBetterDrcSnapshot(
                 chainSnapshot,
                 chainViaIssueCount,