@tscircuit/rectdiff 0.0.22 → 0.0.24

package/lib/solvers/RectDiffSeedingSolver/layers.ts

@@ -21,11 +21,15 @@ export function canonicalizeLayerOrder(names: string[]) {
   })
 }
 
-export function buildZIndexMap(srj: SimpleRouteJson) {
+// TODO: should not take a srj
+export function buildZIndexMap(params: {
+  obstacles?: Obstacle[]
+  layerCount?: number
+}) {
   const names = canonicalizeLayerOrder(
-    (srj.obstacles ?? []).flatMap((o) => o.layers ?? []),
+    (params.obstacles ?? []).flatMap((o) => o.layers ?? []),
   )
-  const declaredLayerCount = Math.max(1, srj.layerCount || names.length || 1)
+  const declaredLayerCount = Math.max(1, params.layerCount || names.length || 1)
   const fallback = Array.from({ length: declaredLayerCount }, (_, i) =>
     i === 0 ? "top" : i === declaredLayerCount - 1 ? "bottom" : `inner${i}`,
   )
@@ -78,8 +82,8 @@ export function obstacleZs(ob: Obstacle, zIndexByName: Map<string, number>) {
 }
 
 export function obstacleToXYRect(ob: Obstacle): XYRect | null {
-  const w = ob.width as any
-  const h = ob.height as any
+  const w = ob.width
+  const h = ob.height
   if (typeof w !== "number" || typeof h !== "number") return null
   return { x: ob.center.x - w / 2, y: ob.center.y - h / 2, width: w, height: h }
 }

package/lib/utils/buildOutlineGraphics.ts

@@ -0,0 +1,39 @@
+import type { GraphicsObject, Line } from "graphics-debug"
+import type { SimpleRouteJson } from "../types/srj-types"
+
+export type BuildOutlineParams = { srj: SimpleRouteJson }
+
+export const buildOutlineGraphics = ({
+  srj,
+}: BuildOutlineParams): GraphicsObject => {
+  const hasOutline = srj.outline && srj.outline.length > 1
+  const lines: NonNullable<Line[]> = hasOutline
+    ? [
+        {
+          points: [...srj.outline!, srj.outline![0]!],
+          strokeColor: "#111827",
+          strokeWidth: 0.1,
+          label: "outline",
+        },
+      ]
+    : [
+        {
+          points: [
+            { x: srj.bounds.minX, y: srj.bounds.minY },
+            { x: srj.bounds.maxX, y: srj.bounds.minY },
+            { x: srj.bounds.maxX, y: srj.bounds.maxY },
+            { x: srj.bounds.minX, y: srj.bounds.maxY },
+            { x: srj.bounds.minX, y: srj.bounds.minY },
+          ],
+          strokeColor: "#111827",
+          strokeWidth: 0.1,
+          label: "bounds",
+        },
+      ]
+
+  return {
+    title: "SimpleRoute Outline",
+    coordinateSystem: "cartesian",
+    lines,
+  }
+}

package/lib/utils/expandRectFromSeed.ts

@@ -17,6 +17,16 @@ type ExpandDirectionParams = {
   maxAspect: number | null | undefined
 }
 
+const quantize = (value: number, precision = 1e-6) =>
+  Math.round(value / precision) * precision
+
+const quantizeRect = (rect: XYRect): XYRect => ({
+  x: quantize(rect.x),
+  y: quantize(rect.y),
+  width: quantize(rect.width),
+  height: quantize(rect.height),
+})
+
 function maxExpandRight(params: ExpandDirectionParams) {
   const { r, bounds, blockers, maxAspect } = params
   // Start with board boundary
@@ -333,7 +343,7 @@ export function expandRectFromSeed(params: {
     if (r.width + EPS >= minReq.width && r.height + EPS >= minReq.height) {
       const area = r.width * r.height
       if (area > bestArea) {
-        best = r
+        best = quantizeRect(r)
         bestArea = area
       }
     }

package/lib/utils/finalizeRects.ts

@@ -1,15 +1,16 @@
+import type { Obstacle } from "lib/types/srj-types"
 import type { Placed3D, Rect3d, XYRect } from "../rectdiff-types"
-import type { SimpleRouteJson } from "../types/srj-types"
 import {
-  buildZIndexMap,
   obstacleToXYRect,
   obstacleZs,
 } from "../solvers/RectDiffSeedingSolver/layers"
 
 export function finalizeRects(params: {
   placed: Placed3D[]
-  srj: SimpleRouteJson
+  obstacles: Obstacle[]
   boardVoidRects: XYRect[]
+  zIndexByName: Map<string, number>
+  obstacleClearance?: number
 }): Rect3d[] {
   // Convert all placed (free space) nodes to output format
   const out: Rect3d[] = params.placed.map((p) => ({
@@ -20,23 +21,30 @@ export function finalizeRects(params: {
     zLayers: [...p.zLayers].sort((a, b) => a - b),
   }))
 
-  const { zIndexByName } = buildZIndexMap(params.srj)
   const layersByKey = new Map<string, { rect: XYRect; layers: Set<number> }>()
 
-  for (const obstacle of params.srj.obstacles ?? []) {
-    const rect = obstacleToXYRect(obstacle as any)
-    if (!rect) continue
+  for (const obstacle of params.obstacles ?? []) {
+    const baseRect = obstacleToXYRect(obstacle)
+    if (!baseRect) continue
+    const rect = params.obstacleClearance
+      ? {
+          x: baseRect.x - params.obstacleClearance,
+          y: baseRect.y - params.obstacleClearance,
+          width: baseRect.width + 2 * params.obstacleClearance,
+          height: baseRect.height + 2 * params.obstacleClearance,
+        }
+      : baseRect
     const zLayers =
       obstacle.zLayers?.length && obstacle.zLayers.length > 0
         ? obstacle.zLayers
-        : obstacleZs(obstacle as any, zIndexByName)
+        : obstacleZs(obstacle, params.zIndexByName)
     const key = `${rect.x}:${rect.y}:${rect.width}:${rect.height}`
     let entry = layersByKey.get(key)
     if (!entry) {
       entry = { rect, layers: new Set() }
       layersByKey.set(key, entry)
     }
-    zLayers.forEach((layer) => entry!.layers.add(layer))
+    zLayers.forEach((layer: number) => entry!.layers.add(layer))
   }
 
   for (const { rect, layers } of layersByKey.values()) {

package/lib/utils/padRect.ts

@@ -0,0 +1,11 @@
+import type { XYRect } from "../rectdiff-types"
+
+export const padRect = (rect: XYRect, clearance: number): XYRect => {
+  if (!clearance || clearance <= 0) return rect
+  return {
+    x: rect.x - clearance,
+    y: rect.y - clearance,
+    width: rect.width + 2 * clearance,
+    height: rect.height + 2 * clearance,
+  }
+}

package/lib/utils/renderObstacleClearance.ts

@@ -0,0 +1,50 @@
+import type { SimpleRouteJson } from "lib/types/srj-types"
+import type { GraphicsObject } from "graphics-debug"
+
+/**
+ * Pure helper that returns clearance rect graphics; does not mutate inputs.
+ */
+export const buildObstacleClearanceGraphics = (params: {
+  srj: SimpleRouteJson
+  clearance: number | undefined
+}): GraphicsObject => {
+  const { srj, clearance } = params
+  const c = clearance ?? 0
+  if (c <= 0) {
+    return {
+      title: "Obstacle Clearance",
+      coordinateSystem: "cartesian",
+      rects: [],
+    }
+  }
+
+  const rects: NonNullable<GraphicsObject["rects"]> = []
+
+  for (const obstacle of srj.obstacles ?? []) {
+    if (obstacle.type !== "rect" && obstacle.type !== "oval") continue
+    const expanded = {
+      x: obstacle.center.x - obstacle.width / 2 - c,
+      y: obstacle.center.y - obstacle.height / 2 - c,
+      width: obstacle.width + 2 * c,
+      height: obstacle.height + 2 * c,
+    }
+    rects.push({
+      center: {
+        x: expanded.x + expanded.width / 2,
+        y: expanded.y + expanded.height / 2,
+      },
+      width: expanded.width,
+      height: expanded.height,
+      stroke: "rgba(202, 138, 4, 0.9)",
+      fill: "rgba(234, 179, 8, 0.15)",
+      layer: "obstacle-clearance",
+      label: `clearance\nz:${(obstacle.zLayers ?? []).join(",") || "all"}`,
+    })
+  }
+
+  return {
+    title: "Obstacle Clearance",
+    coordinateSystem: "cartesian",
+    rects,
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/rectdiff",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "type": "module",
   "main": "dist/index.js",
   "scripts": {

package/pages/bugreport11.page.tsx

@@ -8,6 +8,7 @@ export default () => {
     () =>
       new RectDiffPipeline({
         simpleRouteJson: simpleRouteJson.simple_route_json,
+        obstacleClearance: 0.015,
       }),
     [],
   )

package/tests/board-outline.test.ts

@@ -6,7 +6,7 @@ import { makeCapacityMeshNodeWithLayerInfo } from "./fixtures/makeCapacityMeshNo
 
 test("board outline snapshot", async () => {
   const solver = new RectDiffPipeline({
-    simpleRouteJson: boardWithCutout as any,
+    simpleRouteJson: boardWithCutout,
   })
 
   // Run to completion

package/tests/fixtures/makeSimpleRouteOutlineGraphics.ts

@@ -1,11 +1,15 @@
 import type { GraphicsObject, Line } from "graphics-debug"
 import type { SimpleRouteJson } from "lib/types/srj-types"
+export type SimpleRouteOutlineInput = {
+  bounds: SimpleRouteJson["bounds"]
+  outline?: SimpleRouteJson["outline"]
+}
 
 /**
  * Creates a GraphicsObject that draws the SRJ outline (or bounds fallback).
  */
 export const makeSimpleRouteOutlineGraphics = (
-  srj: SimpleRouteJson,
+  srj: SimpleRouteOutlineInput,
 ): GraphicsObject => {
   const lines: NonNullable<Line[]> = []
 

package/tests/should-expand-node.test.ts

@@ -15,7 +15,15 @@ test("RectDiff expansion reproduces the two-node gap fixture", async () => {
   expect(meshNodes.length).toBeGreaterThanOrEqual(2)
 
   const finalGraphics = makeCapacityMeshNodeWithLayerInfo(meshNodes)
-  const outline = makeSimpleRouteOutlineGraphics(input.srj)
+  const outline = makeSimpleRouteOutlineGraphics({
+    bounds: {
+      minX: input.bounds.x,
+      maxX: input.bounds.x + input.bounds.width,
+      minY: input.bounds.y,
+      maxY: input.bounds.y + input.bounds.height,
+    },
+    outline: undefined,
+  })
   const svg = getSvgFromGraphicsObject(
     mergeGraphics({ rects: finalGraphics.values().toArray().flat() }, outline),
     {