@tscircuit/rectdiff 0.0.31 → 0.0.33

package/tests/solver/arduino-uno-inner2-ground-inner1-power/arduino-uno-inner2-ground-inner1-power.test.ts

@@ -0,0 +1,94 @@
+import { expect, test } from "bun:test"
+import simpleRouteJson from "../../../test-assets/arduino-uno-inner2-ground-inner1-power.json"
+import {
+  getBounds,
+  getSvgFromGraphicsObject,
+  mergeGraphics,
+  stackGraphicsVertically,
+  type GraphicsObject,
+  type Rect,
+} from "graphics-debug"
+import { RectDiffPipeline } from "lib/RectDiffPipeline"
+import { makeCapacityMeshNodeWithLayerInfo } from "tests/fixtures/makeCapacityMeshNodeWithLayerInfo"
+import { makeSimpleRouteOutlineGraphics } from "tests/fixtures/makeSimpleRouteOutlineGraphics"
+
+test("arduino-uno-inner2-ground-inner1-power", async () => {
+  const solver = new RectDiffPipeline({
+    simpleRouteJson,
+  })
+
+  const outline = makeSimpleRouteOutlineGraphics(simpleRouteJson)
+
+  solver.solve()
+
+  const { meshNodes } = solver.getOutput()
+  const rectsByCombo = makeCapacityMeshNodeWithLayerInfo(meshNodes)
+  const allGraphicsObjects: GraphicsObject[] = []
+
+  for (const z of Array.from(
+    { length: simpleRouteJson.layerCount },
+    (_, index) => index,
+  )) {
+    const layerRects: Rect[] = []
+
+    for (const [key, rects] of rectsByCombo) {
+      const layers = key
+        .split(",")
+        .map((value) => Number.parseInt(value, 10))
+        .filter((value) => !Number.isNaN(value))
+
+      if (layers.includes(z)) {
+        layerRects.push(...rects)
+      }
+    }
+
+    let labelY = 0
+
+    if (layerRects.length > 0) {
+      let maxY = -Infinity
+
+      for (const rect of layerRects) {
+        const top = rect.center.y + rect.height * (2 / 3)
+
+        if (top > maxY) maxY = top
+      }
+
+      labelY = maxY
+    }
+
+    const graphics: GraphicsObject = {
+      title: `RectDiffPipeline - z${z}`,
+      texts: [
+        {
+          anchorSide: "top_right",
+          text: `Layer z=${z}`,
+          x: 0,
+          y: labelY,
+          fontSize: 0.5,
+        },
+      ],
+      coordinateSystem: "cartesian",
+      rects: layerRects,
+      points: [],
+      lines: [],
+    }
+
+    allGraphicsObjects.push(mergeGraphics(graphics, outline))
+  }
+
+  const stackedGraphics = stackGraphicsVertically(allGraphicsObjects)
+  const bounds = getBounds(stackedGraphics)
+  const boundsWidth = Math.max(1, bounds.maxX - bounds.minX)
+  const boundsHeight = Math.max(1, bounds.maxY - bounds.minY)
+  const svgWidth = 640
+  const svgHeight = Math.max(
+    svgWidth,
+    Math.ceil((boundsHeight / boundsWidth) * svgWidth),
+  )
+
+  const svg = getSvgFromGraphicsObject(stackedGraphics, {
+    svgWidth,
+    svgHeight,
+  })
+  await expect(svg).toMatchSvgSnapshot(import.meta.path)
+})

package/tests/srj-layer-summary.test.ts

@@ -0,0 +1,94 @@
+import { expect, test } from "bun:test"
+import { stat } from "node:fs/promises"
+import path from "node:path"
+import type { SimpleRouteJson } from "lib/types/srj-types"
+import { RectDiffPipeline } from "lib/RectDiffPipeline"
+
+const srjGlobs = ["tests/**/*.json", "test-assets/*.json"]
+
+const readSimpleRouteJson = async (
+  filePath: string,
+): Promise<SimpleRouteJson | null> => {
+  const json = await Bun.file(filePath).json()
+
+  if (Array.isArray(json)) {
+    const first = json[0]
+    return first?.simpleRouteJson ?? first?.simple_route_json ?? null
+  }
+
+  return json.simple_route_json ?? json.simpleRouteJson ?? json
+}
+
+test("solve srj files and print multi-layer node summary", async () => {
+  const srjFiles: Array<{
+    filePath: string
+    size: number
+    srj: SimpleRouteJson
+  }> = []
+
+  for (const pattern of srjGlobs) {
+    for await (const filePath of new Bun.Glob(pattern).scan(".")) {
+      const srj = await readSimpleRouteJson(filePath)
+
+      if (!srj?.bounds || !srj?.connections || !srj?.obstacles) continue
+
+      const { size } = await stat(filePath)
+      srjFiles.push({ filePath, size, srj })
+    }
+  }
+
+  const largestFiles = srjFiles.sort((a, b) => b.size - a.size)
+  expect(largestFiles.length).toBeGreaterThan(0)
+
+  const rows: Array<Record<string, string | number>> = []
+
+  for (const { filePath, srj } of largestFiles) {
+    const solver = new RectDiffPipeline({ simpleRouteJson: srj })
+    solver.solve()
+
+    const allMeshNodes = solver.getOutput().meshNodes
+    const meshNodes = allMeshNodes.filter((node) => !node._containsObstacle)
+    expect(meshNodes.length).toBeGreaterThan(0)
+
+    let totalVolume = 0
+    let obstacleVolume = 0
+    let multiLayerVolume = 0
+
+    for (const node of allMeshNodes) {
+      const layerSpan = node.availableZ.length
+      const volume = node.width * node.height * layerSpan
+
+      totalVolume += volume
+
+      if (node._containsObstacle) {
+        obstacleVolume += volume
+      }
+    }
+
+    for (const node of meshNodes) {
+      const layerSpan = node.availableZ.length
+      const volume = node.width * node.height * layerSpan
+
+      if (layerSpan >= 2) {
+        multiLayerVolume += volume
+      }
+    }
+
+    const usableVolume = totalVolume - obstacleVolume
+
+    rows.push({
+      file: path.basename(filePath),
+      multi_volume_pct:
+        usableVolume > 0
+          ? `${((multiLayerVolume / usableVolume) * 100).toFixed(1)}%`
+          : "0.0%",
+    })
+  }
+
+  console.table(
+    rows.map((row) => ({
+      file: row.file,
+      multi_volume_pct: row.multi_volume_pct,
+    })),
+  )
+})