@tscircuit/rectdiff 0.0.26 → 0.0.28

package/lib/RectDiffPipeline.ts

@@ -7,6 +7,7 @@ import type { SimpleRouteJson } from "./types/srj-types"
 import type { GridFill3DOptions, XYRect } from "./rectdiff-types"
 import type { CapacityMeshNode } from "./types/capacity-mesh-types"
 import type { GraphicsObject } from "graphics-debug"
+import { AdjacentLayerContainmentMergeSolver } from "./solvers/AdjacentLayerContainmentMergeSolver/AdjacentLayerContainmentMergeSolver"
 import { GapFillSolverPipeline } from "./solvers/GapFillSolver/GapFillSolverPipeline"
 import { OuterLayerContainmentMergeSolver } from "./solvers/OuterLayerContainmentMergeSolver/OuterLayerContainmentMergeSolver"
 import { RectDiffGridSolverPipeline } from "./solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline"
@@ -27,6 +28,7 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
   rectDiffGridSolverPipeline?: RectDiffGridSolverPipeline
   gapFillSolver?: GapFillSolverPipeline
   outerLayerContainmentMergeSolver?: OuterLayerContainmentMergeSolver
+  adjacentLayerContainmentMergeSolver?: AdjacentLayerContainmentMergeSolver
   boardVoidRects: XYRect[] | undefined
   zIndexByName?: Map<string, number>
   layerNames?: string[]
@@ -87,6 +89,22 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
         },
       ],
     ),
+    definePipelineStep(
+      "adjacentLayerContainmentMergeSolver",
+      AdjacentLayerContainmentMergeSolver,
+      (rectDiffPipeline: RectDiffPipeline) => [
+        {
+          meshNodes:
+            rectDiffPipeline.outerLayerContainmentMergeSolver?.getOutput()
+              .outputNodes ??
+            rectDiffPipeline.gapFillSolver?.getOutput().outputNodes ??
+            rectDiffPipeline.rectDiffGridSolverPipeline?.getOutput()
+              .meshNodes ??
+            [],
+          simpleRouteJson: rectDiffPipeline.inputProblem.simpleRouteJson,
+        },
+      ],
+    ),
   ]
 
   override _setup(): void {
@@ -118,6 +136,11 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
   }
 
   override getOutput(): { meshNodes: CapacityMeshNode[] } {
+    const adjacentLayerMergeOutput =
+      this.adjacentLayerContainmentMergeSolver?.getOutput()
+    if (adjacentLayerMergeOutput) {
+      return { meshNodes: adjacentLayerMergeOutput.outputNodes }
+    }
     const outerLayerMergeOutput =
       this.outerLayerContainmentMergeSolver?.getOutput()
     if (outerLayerMergeOutput) {

package/lib/solvers/AdjacentLayerContainmentMergeSolver/AdjacentLayerContainmentMergeSolver.ts

@@ -0,0 +1,456 @@
+import { BaseSolver } from "@tscircuit/solver-utils"
+import type { GraphicsObject } from "graphics-debug"
+import type { XYRect } from "lib/rectdiff-types"
+import type { CapacityMeshNode } from "lib/types/capacity-mesh-types"
+import type { SimpleRouteJson } from "lib/types/srj-types"
+import { getColorForZLayer } from "lib/utils/getColorForZLayer"
+import { EPS, overlaps, subtractRect2D } from "lib/utils/rectdiff-geometry"
+
+type AdjacentLayerContainmentMergeSolverInput = {
+  meshNodes: CapacityMeshNode[]
+  simpleRouteJson: SimpleRouteJson
+  minFragmentArea?: number
+}
+
+const DEFAULT_MIN_FRAGMENT_AREA = 0.2 ** 2
+
+const nodeToRect = (node: CapacityMeshNode): XYRect => ({
+  x: node.center.x - node.width / 2,
+  y: node.center.y - node.height / 2,
+  width: node.width,
+  height: node.height,
+})
+
+const rectArea = (rect: XYRect) => rect.width * rect.height
+
+const cloneNode = (node: CapacityMeshNode): CapacityMeshNode => ({
+  ...node,
+  center: { ...node.center },
+  availableZ: [...node.availableZ],
+})
+
+const cloneNodeWithRect = (
+  node: CapacityMeshNode,
+  rect: XYRect,
+  capacityMeshNodeId: string,
+): CapacityMeshNode => ({
+  ...node,
+  capacityMeshNodeId,
+  center: {
+    x: rect.x + rect.width / 2,
+    y: rect.y + rect.height / 2,
+  },
+  width: rect.width,
+  height: rect.height,
+  availableZ: [...node.availableZ],
+  layer: `z${node.availableZ.join(",")}`,
+})
+
+const clonePromotedNodeWithRect = (
+  node: CapacityMeshNode,
+  rect: XYRect,
+  capacityMeshNodeId: string,
+  availableZ: number[],
+): CapacityMeshNode => ({
+  ...node,
+  capacityMeshNodeId,
+  center: {
+    x: rect.x + rect.width / 2,
+    y: rect.y + rect.height / 2,
+  },
+  width: rect.width,
+  height: rect.height,
+  availableZ: [...availableZ],
+  layer: `z${availableZ.join(",")}`,
+})
+
+const isFreeNode = (node: CapacityMeshNode) =>
+  !node._containsObstacle && !node._containsTarget
+
+const isSingletonNodeOnLayer = (node: CapacityMeshNode, z: number) =>
+  node.availableZ.length === 1 && node.availableZ[0] === z
+
+const sameRect = (a: XYRect, b: XYRect) =>
+  Math.abs(a.x - b.x) <= EPS &&
+  Math.abs(a.y - b.y) <= EPS &&
+  Math.abs(a.width - b.width) <= EPS &&
+  Math.abs(a.height - b.height) <= EPS
+
+const subtractRects = (target: XYRect, cutters: XYRect[]) => {
+  let remaining: XYRect[] = [target]
+
+  for (const cutter of cutters) {
+    if (remaining.length === 0) return remaining
+
+    const nextRemaining: XYRect[] = []
+    for (const piece of remaining) {
+      nextRemaining.push(...subtractRect2D(piece, cutter))
+    }
+    remaining = nextRemaining
+  }
+
+  return remaining
+}
+
+const isFullyCoveredByRects = (target: XYRect, coveringRects: XYRect[]) => {
+  return subtractRects(target, coveringRects).length === 0
+}
+
+const sortAndDedupeCuts = (values: number[]) => {
+  const sorted = [...values].sort((a, b) => a - b)
+  const out: number[] = []
+
+  for (const value of sorted) {
+    const last = out[out.length - 1]
+    if (last == null || Math.abs(last - value) > EPS) {
+      out.push(value)
+    }
+  }
+
+  return out
+}
+
+const partitionRectByRects = (target: XYRect, supportRects: XYRect[]) => {
+  const xCuts = [target.x, target.x + target.width]
+  const yCuts = [target.y, target.y + target.height]
+  const targetMaxX = target.x + target.width
+  const targetMaxY = target.y + target.height
+
+  for (const rect of supportRects) {
+    const x0 = Math.max(target.x, rect.x)
+    const x1 = Math.min(targetMaxX, rect.x + rect.width)
+    const y0 = Math.max(target.y, rect.y)
+    const y1 = Math.min(targetMaxY, rect.y + rect.height)
+
+    if (x1 <= x0 + EPS || y1 <= y0 + EPS) continue
+
+    xCuts.push(x0, x1)
+    yCuts.push(y0, y1)
+  }
+
+  const xs = sortAndDedupeCuts(xCuts)
+  const ys = sortAndDedupeCuts(yCuts)
+  const cells: XYRect[] = []
+
+  for (let xi = 0; xi < xs.length - 1; xi++) {
+    const x0 = xs[xi]!
+    const x1 = xs[xi + 1]!
+
+    if (x1 <= x0 + EPS) continue
+
+    for (let yi = 0; yi < ys.length - 1; yi++) {
+      const y0 = ys[yi]!
+      const y1 = ys[yi + 1]!
+
+      if (y1 <= y0 + EPS) continue
+
+      cells.push({
+        x: x0,
+        y: y0,
+        width: x1 - x0,
+        height: y1 - y0,
+      })
+    }
+  }
+
+  return cells
+}
+
+const canMergeHorizontally = (a: XYRect, b: XYRect) =>
+  Math.abs(a.y - b.y) <= EPS &&
+  Math.abs(a.height - b.height) <= EPS &&
+  Math.abs(a.x + a.width - b.x) <= EPS
+
+const canMergeVertically = (a: XYRect, b: XYRect) =>
+  Math.abs(a.x - b.x) <= EPS &&
+  Math.abs(a.width - b.width) <= EPS &&
+  Math.abs(a.y + a.height - b.y) <= EPS
+
+const mergeTouchingRects = (rects: XYRect[]) => {
+  const out = rects.map((rect) => ({ ...rect }))
+  let changed = true
+
+  while (changed) {
+    changed = false
+
+    outer: for (let i = 0; i < out.length; i++) {
+      for (let j = i + 1; j < out.length; j++) {
+        const a = out[i]!
+        const b = out[j]!
+
+        if (canMergeHorizontally(a, b) || canMergeHorizontally(b, a)) {
+          const merged: XYRect = {
+            x: Math.min(a.x, b.x),
+            y: a.y,
+            width: a.width + b.width,
+            height: a.height,
+          }
+          out.splice(j, 1)
+          out.splice(i, 1, merged)
+          changed = true
+          break outer
+        }
+
+        if (canMergeVertically(a, b) || canMergeVertically(b, a)) {
+          const merged: XYRect = {
+            x: a.x,
+            y: Math.min(a.y, b.y),
+            width: a.width,
+            height: a.height + b.height,
+          }
+          out.splice(j, 1)
+          out.splice(i, 1, merged)
+          changed = true
+          break outer
+        }
+      }
+    }
+  }
+
+  return out
+}
+
+const isPromotableRect = (params: {
+  rect: XYRect
+  viaMinSize: number
+  minFragmentArea: number
+}) => {
+  const { rect, viaMinSize, minFragmentArea } = params
+
+  return (
+    rect.width > EPS &&
+    rect.height > EPS &&
+    rectArea(rect) + EPS >= minFragmentArea &&
+    rect.width + EPS >= viaMinSize &&
+    rect.height + EPS >= viaMinSize
+  )
+}
+
+const isResidualRect = (rect: XYRect, minFragmentArea: number) =>
+  rect.width > EPS &&
+  rect.height > EPS &&
+  rectArea(rect) + EPS >= minFragmentArea
+
+const computePromotablePieces = (params: {
+  target: XYRect
+  supportRects: XYRect[]
+  viaMinSize: number
+  minFragmentArea: number
+}) => {
+  const { target, supportRects, viaMinSize, minFragmentArea } = params
+  const overlappingSupports = supportRects.filter((rect) =>
+    overlaps(rect, target),
+  )
+
+  if (overlappingSupports.length === 0) return []
+
+  if (
+    isFullyCoveredByRects(target, overlappingSupports) &&
+    isPromotableRect({ rect: target, viaMinSize, minFragmentArea })
+  ) {
+    return [target]
+  }
+
+  const partitioned = partitionRectByRects(target, overlappingSupports)
+  const coveredPieces = partitioned.filter((piece) =>
+    isFullyCoveredByRects(piece, overlappingSupports),
+  )
+
+  if (coveredPieces.length === 0) return []
+
+  const mergedCoveredPieces = mergeTouchingRects(coveredPieces)
+
+  return mergedCoveredPieces.filter(
+    (piece) =>
+      isFullyCoveredByRects(piece, overlappingSupports) &&
+      isPromotableRect({ rect: piece, viaMinSize, minFragmentArea }),
+  )
+}
+
+export class AdjacentLayerContainmentMergeSolver extends BaseSolver {
+  private outputNodes: CapacityMeshNode[] = []
+  private promotedNodeIds = new Set<string>()
+  private residualNodeIds = new Set<string>()
+
+  constructor(private input: AdjacentLayerContainmentMergeSolverInput) {
+    super()
+  }
+
+  override _setup() {
+    this.outputNodes = this.input.meshNodes.map(cloneNode)
+    this.promotedNodeIds.clear()
+    this.residualNodeIds.clear()
+  }
+
+  override _step() {
+    this.outputNodes = this.processAdjacentLayerContainmentMerges()
+    this.solved = true
+  }
+
+  private processAdjacentLayerContainmentMerges(): CapacityMeshNode[] {
+    const srj = this.input.simpleRouteJson
+    const layerCount = Math.max(1, srj.layerCount || 1)
+
+    if (layerCount < 2) {
+      return this.input.meshNodes.map(cloneNode)
+    }
+
+    const viaMinSize = Math.max(srj.minViaDiameter ?? 0, srj.minTraceWidth || 0)
+    const minFragmentArea = Math.max(
+      EPS,
+      this.input.minFragmentArea ?? DEFAULT_MIN_FRAGMENT_AREA,
+    )
+
+    let workingNodes = this.input.meshNodes.map(cloneNode)
+    let nextResidualId = 0
+    let nextPromotedId = 0
+
+    for (let lowerZ = 0; lowerZ < layerCount - 1; lowerZ++) {
+      const upperZ = lowerZ + 1
+      const mutableNodes = workingNodes.filter(
+        (node) =>
+          isFreeNode(node) &&
+          (isSingletonNodeOnLayer(node, lowerZ) ||
+            isSingletonNodeOnLayer(node, upperZ)),
+      )
+
+      if (mutableNodes.length === 0) continue
+
+      const immutableNodes = workingNodes.filter(
+        (node) => !mutableNodes.includes(node),
+      )
+      const supportRectsByLayer = new Map<number, XYRect[]>()
+
+      supportRectsByLayer.set(
+        lowerZ,
+        mutableNodes
+          .filter((node) => isSingletonNodeOnLayer(node, lowerZ))
+          .map(nodeToRect),
+      )
+      supportRectsByLayer.set(
+        upperZ,
+        mutableNodes
+          .filter((node) => isSingletonNodeOnLayer(node, upperZ))
+          .map(nodeToRect),
+      )
+
+      const promotedRects: XYRect[] = []
+      const promotedNodes: CapacityMeshNode[] = []
+      const candidateNodes = mutableNodes
+        .filter((node) =>
+          isPromotableRect({
+            rect: nodeToRect(node),
+            viaMinSize,
+            minFragmentArea,
+          }),
+        )
+        .sort((a, b) => rectArea(nodeToRect(b)) - rectArea(nodeToRect(a)))
+
+      for (const candidate of candidateNodes) {
+        const candidateRect = nodeToRect(candidate)
+        const candidatePieces = subtractRects(
+          candidateRect,
+          promotedRects,
+        ).filter((piece) => isResidualRect(piece, minFragmentArea))
+        const candidateZ = candidate.availableZ[0]!
+        const oppositeZ = candidateZ === lowerZ ? upperZ : lowerZ
+        const supportRects = supportRectsByLayer.get(oppositeZ) ?? []
+
+        for (const piece of candidatePieces) {
+          const promotablePieces = computePromotablePieces({
+            target: piece,
+            supportRects,
+            viaMinSize,
+            minFragmentArea,
+          })
+
+          for (const promotablePiece of promotablePieces) {
+            promotedRects.push(promotablePiece)
+
+            const promotedNode = clonePromotedNodeWithRect(
+              candidate,
+              promotablePiece,
+              `${candidate.capacityMeshNodeId}-adjacent-merge-${nextPromotedId++}`,
+              [lowerZ, upperZ],
+            )
+            promotedNodes.push(promotedNode)
+            this.promotedNodeIds.add(promotedNode.capacityMeshNodeId)
+          }
+        }
+      }
+
+      const residualNodes: CapacityMeshNode[] = []
+
+      for (const node of mutableNodes) {
+        const nodeRect = nodeToRect(node)
+        const remainingPieces = subtractRects(nodeRect, promotedRects).filter(
+          (piece) => isResidualRect(piece, minFragmentArea),
+        )
+
+        if (
+          remainingPieces.length === 1 &&
+          sameRect(remainingPieces[0]!, nodeRect)
+        ) {
+          residualNodes.push(node)
+          continue
+        }
+
+        for (const piece of remainingPieces) {
+          const residualNode = cloneNodeWithRect(
+            node,
+            piece,
+            `${node.capacityMeshNodeId}-adjacent-residual-${nextResidualId++}`,
+          )
+          residualNodes.push(residualNode)
+          this.residualNodeIds.add(residualNode.capacityMeshNodeId)
+        }
+      }
+
+      workingNodes = [...immutableNodes, ...promotedNodes, ...residualNodes]
+    }
+
+    return workingNodes
+  }
+
+  override getOutput(): { outputNodes: CapacityMeshNode[] } {
+    return { outputNodes: this.outputNodes }
+  }
+
+  override visualize(): GraphicsObject {
+    return {
+      title: "AdjacentLayerContainmentMergeSolver",
+      coordinateSystem: "cartesian",
+      rects: this.outputNodes.map((node) => {
+        const colors = getColorForZLayer(node.availableZ)
+        const isPromoted = this.promotedNodeIds.has(node.capacityMeshNodeId)
+        const isResidual = this.residualNodeIds.has(node.capacityMeshNodeId)
+
+        return {
+          center: node.center,
+          width: node.width,
+          height: node.height,
+          stroke: isPromoted
+            ? "rgba(245, 158, 11, 0.95)"
+            : isResidual
+              ? "rgba(37, 99, 235, 0.95)"
+              : colors.stroke,
+          fill: node._containsObstacle
+            ? "rgba(239, 68, 68, 0.35)"
+            : isPromoted
+              ? "rgba(251, 191, 36, 0.28)"
+              : isResidual
+                ? "rgba(59, 130, 246, 0.18)"
+                : colors.fill,
+          layer: `z${node.availableZ.join(",")}`,
+          label: [
+            `node ${node.capacityMeshNodeId}`,
+            `z:${node.availableZ.join(",")}`,
+          ].join("\n"),
+        }
+      }),
+      points: [],
+      lines: [],
+      texts: [],
+    }
+  }
+}

package/lib/solvers/OuterLayerContainmentMergeSolver/OuterLayerContainmentMergeSolver.ts

@@ -28,6 +28,7 @@ const nodeToRect = (node: CapacityMeshNode): XYRect => ({
 })
 
 const rectArea = (rect: XYRect) => rect.width * rect.height
+const MIN_OUTER_LAYER_MERGE_AREA_MM2 = 1
 
 const cloneNode = (node: CapacityMeshNode): CapacityMeshNode => ({
   ...node,
@@ -144,7 +145,9 @@ export class OuterLayerContainmentMergeSolver extends BaseSolver {
     const candidateNodes = mutableOuterNodes
       .filter(
         (node) =>
-          node.width + EPS >= viaMinSize && node.height + EPS >= viaMinSize,
+          node.width + EPS >= viaMinSize &&
+          node.height + EPS >= viaMinSize &&
+          rectArea(nodeToRect(node)) > MIN_OUTER_LAYER_MERGE_AREA_MM2 + EPS,
       )
       .sort((a, b) => rectArea(nodeToRect(b)) - rectArea(nodeToRect(a)))
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/rectdiff",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/pages/bugreports/bugreport50-multi-support-layer-merge.page.tsx

@@ -0,0 +1,19 @@
+import { useMemo } from "react"
+import { SolverDebugger3d } from "../../components/SolverDebugger3d"
+import { RectDiffPipeline } from "../../lib/RectDiffPipeline"
+import srjJson from "../../tests/solver/bugreport50-multi-support-layer-merge/bugreport50-multi-support-layer-merge.json"
+
+const simpleRouteJson =
+  srjJson.simpleRouteJson ?? srjJson.simple_route_json ?? srjJson
+
+export default () => {
+  const solver = useMemo(
+    () =>
+      new RectDiffPipeline({
+        simpleRouteJson,
+      }),
+    [],
+  )
+
+  return <SolverDebugger3d solver={solver} simpleRouteJson={simpleRouteJson} />
+}

package/tests/__snapshots__/board-outline.snap.svg

@@ -1,4 +1,4 @@
-<svg width="640" height="640" viewBox="0 0 640 640" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" fill="white"/><g><rect data-type="rect" data-label="node" data-x="-5" data-y="1.1600000000000008" x="40" y="110" width="210" height="338.80000000000007" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="5" data-y="1.1600000000000008" x="390" y="110" width="210" height="338.80000000000007" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="0" data-y="4" x="250" y="110.00000000000006" width="140" height="140" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-5.48" data-y="-5.16" x="40" y="471.20000000000005" width="176.39999999999998" height="58.799999999999955" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="5.48" data-y="-5.16" x="423.6" y="471.20000000000005" width="176.39999999999998" height="58.799999999999955" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-2.4800000000000004" data-y="-4.84" x="216.39999999999998" y="448.80000000000007" width="33.60000000000002" height="81.19999999999993" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="2.4800000000000004" data-y="-4.84" x="390" y="448.80000000000007" width="33.60000000000002" height="81.19999999999993" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-5.48" data-y="-4" x="40" y="448.80000000000007" width="176.39999999999998" height="22.399999999999977" fill="#fef3c7" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="5.48" data-y="-4" x="423.6" y="448.80000000000007" width="176.39999999999998" height="22.399999999999977" fill="#fef3c7" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="6.890000000000001" data-y="-4" x="522.3000000000001" y="448.80000000000007" width="77.69999999999993" height="22.399999999999977" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-6.89" data-y="-4" x="40" y="448.80000000000007" width="77.70000000000002" height="22.399999999999977" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-5" data-y="-4" x="136.6" y="448.80000000000007" width="16.80000000000001" height="22.399999999999977" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-3.5900000000000003" data-y="-4" x="172.3" y="448.80000000000007" width="44.099999999999966" height="22.399999999999977" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="3.5900000000000007" data-y="-4" x="423.6" y="448.80000000000007" width="44.10000000000002" height="22.399999999999977" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="5" data-y="-4" x="486.6" y="448.80000000000007" width="16.799999999999955" height="22.399999999999977" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-5.51" data-y="-4" x="117.70000000000002" y="448.80000000000007" width="18.899999999999977" height="22.399999999999977" fill="red" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-4.49" data-y="-4" x="153.4" y="448.80000000000007" width="18.899999999999977" height="22.399999999999977" fill="red" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="4.49" data-y="-4" x="467.70000000000005" y="448.80000000000007" width="18.899999999999977" height="22.399999999999977" fill="red" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="5.51" data-y="-4" x="503.4" y="448.80000000000007" width="18.899999999999977" height="22.399999999999977" fill="red" stroke="black" stroke-width="0.02857142857142857"/></g><g id="crosshair" style="display: none"><line id="crosshair-h" y1="0" y2="640" stroke="#666" stroke-width="0.5"/><line id="crosshair-v" x1="0" x2="640" stroke="#666" stroke-width="0.5"/><text id="coordinates" font-family="monospace" font-size="12" fill="#666"></text></g><script><![CDATA[
+<svg width="640" height="640" viewBox="0 0 640 640" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" fill="white"/><g><rect data-type="rect" data-label="node" data-x="-5" data-y="1.1600000000000001" x="40" y="110" width="210" height="338.79999999999995" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="5" data-y="1.1600000000000001" x="390" y="110" width="210" height="338.79999999999995" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="0" data-y="4" x="250" y="110" width="140" height="140" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-5.48" data-y="-5.16" x="40" y="471.20000000000005" width="176.39999999999998" height="58.799999999999955" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="5.48" data-y="-5.16" x="423.6" y="471.20000000000005" width="176.39999999999998" height="58.799999999999955" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-2.48" data-y="-4.84" x="216.4" y="448.79999999999995" width="33.599999999999994" height="81.20000000000005" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="2.48" data-y="-4.84" x="390" y="448.79999999999995" width="33.60000000000002" height="81.20000000000005" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-6.890000000000001" data-y="-3.999999999999999" x="40" y="448.79999999999995" width="77.69999999999996" height="22.400000000000034" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-5" data-y="-3.999999999999999" x="136.6" y="448.79999999999995" width="16.80000000000001" height="22.400000000000034" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-3.59" data-y="-3.999999999999999" x="172.3" y="448.79999999999995" width="44.099999999999994" height="22.400000000000034" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="3.59" data-y="-3.999999999999999" x="423.6" y="448.79999999999995" width="44.099999999999966" height="22.400000000000034" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="5" data-y="-3.999999999999999" x="486.6" y="448.79999999999995" width="16.799999999999955" height="22.400000000000034" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="6.889999999999999" data-y="-3.999999999999999" x="522.3" y="448.79999999999995" width="77.70000000000005" height="22.400000000000034" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-5.51" data-y="-4" x="117.70000000000002" y="448.79999999999995" width="18.899999999999977" height="22.40000000000009" fill="red" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-4.49" data-y="-4" x="153.4" y="448.79999999999995" width="18.899999999999977" height="22.40000000000009" fill="red" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="4.49" data-y="-4" x="467.70000000000005" y="448.79999999999995" width="18.899999999999977" height="22.40000000000009" fill="red" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="5.51" data-y="-4" x="503.4" y="448.79999999999995" width="18.899999999999977" height="22.40000000000009" fill="red" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-5.51" data-y="-3.999999999999999" x="117.70000000000002" y="448.79999999999995" width="18.899999999999977" height="22.400000000000034" fill="#fef3c7" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-4.49" data-y="-3.999999999999999" x="153.39999999999998" y="448.79999999999995" width="18.900000000000034" height="22.400000000000034" fill="#fef3c7" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="4.49" data-y="-3.999999999999999" x="467.70000000000005" y="448.79999999999995" width="18.899999999999977" height="22.400000000000034" fill="#fef3c7" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="5.51" data-y="-3.999999999999999" x="503.4" y="448.79999999999995" width="18.899999999999977" height="22.400000000000034" fill="#fef3c7" stroke="black" stroke-width="0.02857142857142857"/></g><g id="crosshair" style="display: none"><line id="crosshair-h" y1="0" y2="640" stroke="#666" stroke-width="0.5"/><line id="crosshair-v" x1="0" x2="640" stroke="#666" stroke-width="0.5"/><text id="coordinates" font-family="monospace" font-size="12" fill="#666"></text></g><script><![CDATA[
               document.currentScript.parentElement.addEventListener('mousemove', (e) => {
                 const svg = e.currentTarget;
                 const rect = svg.getBoundingClientRect();
@@ -20,7 +20,7 @@
                 v.setAttribute('y2', '640');
 
                 // Calculate real coordinates using inverse transformation
-                const matrix = {"a":35,"c":0,"e":320,"b":0,"d":-35,"f":320.00000000000006};
+                const matrix = {"a":35,"c":0,"e":320,"b":0,"d":-35,"f":320};
                 // Manually invert and apply the affine transform
                 // Since we only use translate and scale, we can directly compute:
                 // x' = (x - tx) / sx

package/tests/outer-layer-containment-merge-solver.test.ts

@@ -0,0 +1,73 @@
+import { expect, test } from "bun:test"
+import { OuterLayerContainmentMergeSolver } from "lib/solvers/OuterLayerContainmentMergeSolver/OuterLayerContainmentMergeSolver"
+import type { CapacityMeshNode } from "lib/types/capacity-mesh-types"
+import type { SimpleRouteJson } from "lib/types/srj-types"
+
+const makeNode = (
+  capacityMeshNodeId: string,
+  centerX: number,
+  width: number,
+  height: number,
+  availableZ: number[],
+): CapacityMeshNode => ({
+  capacityMeshNodeId,
+  center: { x: centerX, y: 0 },
+  width,
+  height,
+  layer: `z${availableZ.join(",")}`,
+  availableZ,
+})
+
+test("OuterLayerContainmentMergeSolver only promotes nodes larger than 1 mm^2", () => {
+  const simpleRouteJson: SimpleRouteJson = {
+    bounds: {
+      minX: -1,
+      maxX: 6,
+      minY: -1,
+      maxY: 1,
+    },
+    obstacles: [
+      {
+        type: "rect",
+        layers: ["inner1"],
+        zLayers: [1],
+        center: { x: 2.5, y: 0 },
+        width: 7,
+        height: 2,
+        connectedTo: [],
+        isCopperPour: true,
+      },
+    ],
+    connections: [],
+    layerCount: 3,
+    minTraceWidth: 0.1,
+  }
+
+  const solver = new OuterLayerContainmentMergeSolver({
+    meshNodes: [
+      makeNode("below-threshold", 0.4, 0.8, 1, [0]),
+      makeNode("at-threshold", 2, 1, 1, [0]),
+      makeNode("above-threshold", 4.6, 1.2, 1, [0]),
+      makeNode("below-support", 0.4, 0.8, 1, [1, 2]),
+      makeNode("at-support", 2, 1, 1, [1, 2]),
+      makeNode("above-support", 4.6, 1.2, 1, [1, 2]),
+    ],
+    simpleRouteJson,
+    zIndexByName: new Map([
+      ["top", 0],
+      ["inner1", 1],
+      ["bottom", 2],
+    ]),
+  })
+
+  solver.solve()
+
+  const outputNodes = solver.getOutput().outputNodes
+  const nodeById = new Map(
+    outputNodes.map((node) => [node.capacityMeshNodeId, node] as const),
+  )
+
+  expect(nodeById.get("below-threshold")?.availableZ).toEqual([0])
+  expect(nodeById.get("at-threshold")?.availableZ).toEqual([0])
+  expect(nodeById.get("above-threshold")?.availableZ).toEqual([0, 2])
+})