assignable via simpler obstacle consolidation

Author: seveibar

examples/unassigned-obstacles/AssignableViaAutoroutingPipelineSolver/AssignableViaAutoroutingPipelineSolver03.fixture.tsx

@@ -62,6 +62,7 @@ export const simpleRouteJson: SimpleRouteJson = {
       connectedTo: [],
       width: 0.6,
       height: 0.6,
+      netIsAssignable: true,
     },
   ],
   connections: [

lib/solvers/AssignableViaAutoroutingPipeline/AssignableViaNodeMergerSolver.ts

@@ -73,6 +73,7 @@ export class AssignableViaNodeMergerSolver extends BaseSolver {
 
     // Collect all unique z-layers from the nodes to merge
     const zLayersSet = new Set<number>()
+    let containsTarget = false
 
     for (const node of nodesToMerge) {
       const nodeMinX = node.center.x - node.width / 2
@@ -89,6 +90,11 @@ export class AssignableViaNodeMergerSolver extends BaseSolver {
       for (const z of node.availableZ) {
         zLayersSet.add(z)
       }
+
+      // Check if any node contains a target
+      if (node._containsTarget) {
+        containsTarget = true
+      }
     }
 
     const width = maxX - minX
@@ -110,6 +116,7 @@ export class AssignableViaNodeMergerSolver extends BaseSolver {
           ? `z${availableZ[0]}`
           : `z${availableZ.join(",")}`,
       availableZ,
+      _containsTarget: containsTarget,
       _containsObstacle: false,
       _completelyInsideObstacle: false,
     }

lib/solvers/AssignableViaAutoroutingPipeline/CapacityMeshNodeSolver_OnlyTraverseLayersInAssignableObstacles.ts

@@ -10,13 +10,15 @@ interface CapacityMeshNodeSolverOptions {
  * aren't allowed, but there may be assignable vias on the PCB as obstacles.
  *
  * Behavior:
- * - Outside obstacles, multi-layer nodes are *always* Z-split into single-layer nodes.
- * - Inside an "assignable" obstacle (obstacle.netIsAssignable === true), we keep
- *   exactly *one* multi-layer node (capacity ~ 1 via region), i.e. we do not Z-split it.
- *   Further nodes completely inside the same assignable obstacle will be Z-split (one per layer).
+ * - Outside assignable obstacles, multi-layer nodes are *always* Z-split into single-layer nodes.
+ * - During mesh subdivision, nodes overlapping with "assignable" obstacles
+ *   (obstacle.netIsAssignable === true) are NOT filtered, allowing normal subdivision.
+ * - After the main mesh subdivision is complete:
+ *   1. All nodes overlapping with assignable obstacles are removed
+ *   2. Each assignable obstacle is replaced with a single multi-layer node spanning all layers
  * - Single-layer nodes that are larger than MAX_SIZE_FOR_SINGLE_LAYER_NODES are XY-subdivided.
- * - IMPORTANT: the single multi-layer node inside an assignable obstacle is **traversable**,
- *   so we mark `_containsObstacle = false` and `_completelyInsideObstacle = false` on it.
+ * - IMPORTANT: the multi-layer nodes created from assignable obstacles are **traversable**,
+ *   so we mark `_containsObstacle = false` and `_completelyInsideObstacle = false` on them.
  */
 export class CapacityMeshNodeSolver_OnlyTraverseLayersInAssignableObstacles extends CapacityMeshNodeSolver2_NodeUnderObstacle {
   MAX_SIZE_FOR_SINGLE_LAYER_NODES = 2 // 2x2mm
@@ -40,32 +42,6 @@ export class CapacityMeshNodeSolver_OnlyTraverseLayersInAssignableObstacles exte
     )
   }
 
-  private isNodeCompletelyInsideSpecificObstacle(
-    node: CapacityMeshNode,
-    obstacle: Obstacle,
-  ): boolean {
-    const nb = this.getNodeBounds(node)
-    const obsLeft = obstacle.center.x - obstacle.width / 2
-    const obsRight = obstacle.center.x + obstacle.width / 2
-    const obsTop = obstacle.center.y - obstacle.height / 2
-    const obsBottom = obstacle.center.y + obstacle.height / 2
-
-    return (
-      nb.minX >= obsLeft &&
-      nb.maxX <= obsRight &&
-      nb.minY >= obsTop &&
-      nb.maxY <= obsBottom
-    )
-  }
-
-  private getAssignableContainer(node: CapacityMeshNode): Obstacle | null {
-    const assignables = this.getOverlappingAssignableObstacles(node)
-    for (const o of assignables) {
-      return o
-    }
-    return null
-  }
-
   shouldNodeBeXYSubdivided(node: CapacityMeshNode) {
     if (node._depth! >= this.MAX_DEPTH) return false
     if (node._containsTarget) return true
@@ -82,27 +58,135 @@ export class CapacityMeshNodeSolver_OnlyTraverseLayersInAssignableObstacles exte
   }
 
   /**
-   * Multi-layer nodes are filtered unless they are completely inside an
-   * assignable obstacle (the single allowed via region per obstacle).
-   * Single-layer nodes use the standard relaxed single-layer filtering.
+   * Filter nodes for obstacles, but skip filtering for assignable obstacles.
+   * Assignable obstacles will be handled separately at the end.
    */
   shouldFilterNodeForObstacle(node: CapacityMeshNode): boolean {
     if (!node._containsObstacle) return false
 
+    // Check if this node overlaps with any assignable obstacles
+    const assignableObstacles = this.getOverlappingAssignableObstacles(node)
+    if (assignableObstacles.length > 0) {
+      // Don't filter - let the node be created, we'll remove it later
+      return false
+    }
+
     if (node.availableZ.length === 1) {
       return this.shouldFilterSingleLayerNodeForObstacle(node)
     }
 
-    // Multi-layer: allowed only if it is the single node inside an assignable obstacle
-    const container = this.getAssignableContainer(node)
-    if (container) return false
-
+    // Multi-layer nodes (not in assignable obstacles) should be filtered
     return true
   }
 
+  /**
+   * Remove nodes inside assignable obstacles and replace with single multi-layer nodes.
+   * The new node's bounds are extended to cover all removed nodes' XY space.
+   */
+  private insertAssignableObstaclesAsNodes() {
+    const assignableObstacles = this.srj.obstacles.filter((o) =>
+      this.isObstacleAssignable(o),
+    )
+
+    // Map to track which nodes overlap with which obstacle
+    const obstacleToNodesMap = new Map<Obstacle, CapacityMeshNode[]>()
+
+    for (const obstacle of assignableObstacles) {
+      const overlappingNodes: CapacityMeshNode[] = []
+
+      for (const node of this.finishedNodes) {
+        // Check if this node overlaps with this assignable obstacle
+        const nodeOverlaps = this.getXYZOverlappingObstacles(node).some((o) => o === obstacle)
+        if (nodeOverlaps) {
+          overlappingNodes.push(node)
+        }
+      }
+
+      obstacleToNodesMap.set(obstacle, overlappingNodes)
+    }
+
+    // Collect all nodes to remove
+    const nodesToRemove = new Set<CapacityMeshNode>()
+    for (const nodes of obstacleToNodesMap.values()) {
+      for (const node of nodes) {
+        nodesToRemove.add(node)
+      }
+    }
+
+    // Remove the nodes
+    this.finishedNodes = this.finishedNodes.filter((node) => !nodesToRemove.has(node))
+
+    // Add a single multi-layer node for each assignable obstacle
+    for (const obstacle of assignableObstacles) {
+      const overlappingNodes = obstacleToNodesMap.get(obstacle) || []
+      const availableZ = Array.from({ length: this.srj.layerCount }, (_, i) => this.srj.layerCount - i - 1)
+
+      // Calculate bounding box that covers all removed nodes
+      let minX = obstacle.center.x - obstacle.width / 2
+      let maxX = obstacle.center.x + obstacle.width / 2
+      let minY = obstacle.center.y - obstacle.height / 2
+      let maxY = obstacle.center.y + obstacle.height / 2
+
+      for (const node of overlappingNodes) {
+        const nodeMinX = node.center.x - node.width / 2
+        const nodeMaxX = node.center.x + node.width / 2
+        const nodeMinY = node.center.y - node.height / 2
+        const nodeMaxY = node.center.y + node.height / 2
+
+        minX = Math.min(minX, nodeMinX)
+        maxX = Math.max(maxX, nodeMaxX)
+        minY = Math.min(minY, nodeMinY)
+        maxY = Math.max(maxY, nodeMaxY)
+      }
+
+      const width = maxX - minX
+      const height = maxY - minY
+      const centerX = (minX + maxX) / 2
+      const centerY = (minY + maxY) / 2
+
+      // Check if this extended area contains any target points
+      let containsTarget = false
+      for (const conn of this.srj.connections) {
+        for (const point of conn.pointsToConnect) {
+          if (
+            point.x >= minX &&
+            point.x <= maxX &&
+            point.y >= minY &&
+            point.y <= maxY
+          ) {
+            containsTarget = true
+            break
+          }
+        }
+        if (containsTarget) break
+      }
+
+      // Create a multi-layer node with extended bounds
+      const node: CapacityMeshNode = {
+        capacityMeshNodeId: `assignable_via_${obstacle.center.x}_${obstacle.center.y}`,
+        center: { x: centerX, y: centerY },
+        width,
+        height,
+        layer: availableZ.length === 1 ? `z${availableZ[0]}` : `z${availableZ.join(",")}`,
+        availableZ,
+        _depth: 0,
+        _containsTarget: containsTarget,
+        _containsObstacle: false,
+        _completelyInsideObstacle: false,
+      } as any
+
+      // Store the obstacle reference for later use
+      ;(node as any)._assignedViaObstacle = obstacle
+
+      this.finishedNodes.push(node)
+    }
+  }
+
   _step() {
     const nextNode = this.unfinishedNodes.pop()
     if (!nextNode) {
+      // Main subdivision complete, now insert assignable obstacles as nodes
+      this.insertAssignableObstaclesAsNodes()
       this.solved = true
       return
     }
@@ -115,17 +199,9 @@ export class CapacityMeshNodeSolver_OnlyTraverseLayersInAssignableObstacles exte
     for (const childNode of childNodes) {
       const shouldBeXYSubdivided = this.shouldNodeBeXYSubdivided(childNode)
 
-      // Detect an assignable container that fully contains this node and is not yet claimed
-      const assignableContainer =
-        childNode.availableZ.length > 1 && !shouldBeXYSubdivided
-          ? this.getAssignableContainer(childNode)
-          : null
-
-      // Z-subdivide multi-layer nodes except when this is the *one* allowed via region
+      // Z-subdivide all multi-layer nodes (no special handling for assignable obstacles)
       const shouldBeZSubdivided =
-        childNode.availableZ.length > 1 &&
-        !shouldBeXYSubdivided &&
-        !assignableContainer
+        childNode.availableZ.length > 1 && !shouldBeXYSubdivided
 
       if (shouldBeXYSubdivided) {
         unfinishedNewNodes.push(childNode)
@@ -148,21 +224,11 @@ export class CapacityMeshNodeSolver_OnlyTraverseLayersInAssignableObstacles exte
         continue
       }
 
-      // Not XY-subdivided and not Z-subdivided:
-      //  - a single-layer node that passes filtering, or
-      //  - the *single* multi-layer node inside an assignable obstacle
+      // Not XY-subdivided and not Z-subdivided: single-layer node that passes filtering
       if (
         !this.shouldFilterNodeForObstacle(childNode) ||
         childNode._containsTarget
       ) {
-        if (assignableContainer) {
-          // >>> IMPORTANT FIX <<<
-          // The multi-layer node inside an assignable obstacle is traversable.
-          // Mark it as *not* containing an obstacle.
-          childNode._containsObstacle = false
-          childNode._completelyInsideObstacle = false
-          ;(childNode as any)._assignedViaObstacle = assignableContainer
-        }
         finishedNewNodes.push(childNode)
       }
     }

lib/solvers/AssignableViaAutoroutingPipeline/SingleLayerNodeMergerSolver_OnlyMergeTargets.ts

@@ -34,6 +34,13 @@ export class SingleLayerNodeMergerSolver_OnlyMergeTargets extends BaseSolver {
     this.absorbedNodeIds = new Set()
     const unprocessedNodesWithArea: Array<[CapacityMeshNode, number]> = []
     for (const node of nodes) {
+      // Skip assignable via nodes - pass them through unchanged
+      if ((node as any)._assignedViaObstacle) {
+        this.newNodes.push(node)
+        this.absorbedNodeIds.add(node.capacityMeshNodeId)
+        continue
+      }
+
       // Only process nodes that contain targets
       if (!node._containsTarget) {
         this.newNodes.push(node)