@tscircuit/rectdiff 0.0.39 → 0.0.40

package/lib/solvers/SparseMultilayerPromotionSolver/SparseMultilayerPromotionSolver.ts

@@ -1,134 +0,0 @@
-import {
-  BasePipelineSolver,
-  definePipelineStep,
-  type PipelineStep,
-} from "@tscircuit/solver-utils"
-import type { GraphicsObject } from "graphics-debug"
-import type {
-  CapacityMeshNode,
-  CapacityMeshNodeId,
-} from "../../types/capacity-mesh-types"
-import { getZLayerName } from "../../math/layers/getZLayerName"
-import { getColorForZLayer } from "../../utils/getColorForZLayer"
-import { CoalesceMultilayerTilesSolver } from "./solvers/CoalesceMultilayerTilesSolver"
-import { PromoteSparseMultilayerCoverageSolver } from "./solvers/PromoteSparseMultilayerCoverageSolver"
-import { TrimContainedSingleLayerCoverageSolver } from "./solvers/TrimContainedSingleLayerCoverageSolver"
-import type { SparseMultilayerPromotionInput } from "./types"
-
-/**
- * This pipeline makes shared multilayer regions easier to use.
- * It grows shared space, removes redundant leftovers, and combines small tiles.
- */
-export class SparseMultilayerPromotionSolver extends BasePipelineSolver<SparseMultilayerPromotionInput> {
-  coalesceMultilayerTilesSolver?: CoalesceMultilayerTilesSolver
-  promoteSparseMultilayerCoverageSolver?: PromoteSparseMultilayerCoverageSolver
-  trimContainedSingleLayerCoverageSolver?: TrimContainedSingleLayerCoverageSolver
-
-  override pipelineDef: PipelineStep<any>[] = [
-    definePipelineStep(
-      "promoteSparseMultilayerCoverageSolver",
-      PromoteSparseMultilayerCoverageSolver,
-      (solver: SparseMultilayerPromotionSolver) => [
-        {
-          meshNodes: solver.inputProblem.meshNodes,
-          minRectSize: Math.max(
-            solver.inputProblem.simpleRouteJson.minViaDiameter ?? 0,
-            solver.inputProblem.simpleRouteJson.minTraceWidth ?? 0,
-          ),
-          promotionTargetShare: solver.inputProblem.promotionTargetShare,
-        },
-      ],
-    ),
-    definePipelineStep(
-      "trimContainedSingleLayerCoverageSolver",
-      TrimContainedSingleLayerCoverageSolver,
-      (solver: SparseMultilayerPromotionSolver) => [
-        {
-          meshNodes:
-            solver.promoteSparseMultilayerCoverageSolver?.getOutput()
-              .outputNodes ?? solver.inputProblem.meshNodes,
-          minRectSize: Math.max(
-            solver.inputProblem.simpleRouteJson.minViaDiameter ?? 0,
-            solver.inputProblem.simpleRouteJson.minTraceWidth ?? 0,
-          ),
-          promotionTargetShare: solver.inputProblem.promotionTargetShare,
-        },
-      ],
-    ),
-    definePipelineStep(
-      "coalesceMultilayerTilesSolver",
-      CoalesceMultilayerTilesSolver,
-      (solver: SparseMultilayerPromotionSolver) => [
-        {
-          meshNodes:
-            solver.trimContainedSingleLayerCoverageSolver?.getOutput()
-              .outputNodes ??
-            solver.promoteSparseMultilayerCoverageSolver?.getOutput()
-              .outputNodes ??
-            solver.inputProblem.meshNodes,
-        },
-      ],
-    ),
-  ]
-
-  override getConstructorParams() {
-    return [this.inputProblem]
-  }
-
-  override getOutput(): { outputNodes: CapacityMeshNode[] } {
-    return {
-      outputNodes:
-        this.coalesceMultilayerTilesSolver?.getOutput().outputNodes ??
-        this.trimContainedSingleLayerCoverageSolver?.getOutput().outputNodes ??
-        this.promoteSparseMultilayerCoverageSolver?.getOutput().outputNodes ??
-        this.inputProblem.meshNodes,
-    }
-  }
-
-  override finalVisualize(): GraphicsObject {
-    const promotedIds = new Set<CapacityMeshNodeId>([
-      ...(this.promoteSparseMultilayerCoverageSolver?.getOutput()
-        .promotedNodeIds ?? []),
-      ...(this.coalesceMultilayerTilesSolver?.getOutput().promotedNodeIds ??
-        []),
-    ])
-    const residualIds = new Set<CapacityMeshNodeId>([
-      ...(this.promoteSparseMultilayerCoverageSolver?.getOutput()
-        .residualNodeIds ?? []),
-      ...(this.trimContainedSingleLayerCoverageSolver?.getOutput()
-        .residualNodeIds ?? []),
-    ])
-
-    return {
-      title: "SparseMultilayerPromotionSolver",
-      coordinateSystem: "cartesian",
-      rects: this.getOutput().outputNodes.map((node) => {
-        const colors = getColorForZLayer(node.availableZ)
-        const isPromoted = promotedIds.has(node.capacityMeshNodeId)
-        const isResidual = residualIds.has(node.capacityMeshNodeId)
-
-        return {
-          center: node.center,
-          width: node.width,
-          height: node.height,
-          stroke: isPromoted
-            ? "rgba(168, 85, 247, 0.95)"
-            : isResidual
-              ? "rgba(14, 116, 144, 0.95)"
-              : colors.stroke,
-          fill: node._containsObstacle
-            ? "rgba(239, 68, 68, 0.35)"
-            : isPromoted
-              ? "rgba(192, 132, 252, 0.28)"
-              : isResidual
-                ? "rgba(34, 211, 238, 0.18)"
-                : colors.fill,
-          layer: getZLayerName({ availableZ: node.availableZ }),
-        }
-      }),
-      points: [],
-      lines: [],
-      texts: [],
-    }
-  }
-}

package/lib/solvers/SparseMultilayerPromotionSolver/cloneNode.ts

@@ -1,15 +0,0 @@
-import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
-
-/**
- * Make a safe copy of a node.
- * Later steps can change the copy without touching the original.
- */
-export const cloneNode = ({
-  node,
-}: {
-  node: CapacityMeshNode
-}): CapacityMeshNode => ({
-  ...node,
-  center: { ...node.center },
-  availableZ: [...node.availableZ],
-})

package/lib/solvers/SparseMultilayerPromotionSolver/cloneNodeWithRect.ts

@@ -1,34 +0,0 @@
-import type { XYRect } from "../../rectdiff-types"
-import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
-import { getZLayerName } from "../../math/layers/getZLayerName"
-
-/**
- * Copy a node and replace its shape.
- * The layer span can also be replaced when needed.
- */
-export const cloneNodeWithRect = ({
-  rect,
-  templateNode,
-  availableZ,
-  capacityMeshNodeId,
-}: {
-  availableZ?: number[]
-  capacityMeshNodeId: string
-  rect: XYRect
-  templateNode: CapacityMeshNode
-}): CapacityMeshNode => {
-  const nextAvailableZ = availableZ ?? templateNode.availableZ
-
-  return {
-    ...templateNode,
-    capacityMeshNodeId,
-    center: {
-      x: rect.x + rect.width / 2,
-      y: rect.y + rect.height / 2,
-    },
-    width: rect.width,
-    height: rect.height,
-    availableZ: [...nextAvailableZ],
-    layer: getZLayerName({ availableZ: nextAvailableZ }),
-  }
-}

package/lib/solvers/SparseMultilayerPromotionSolver/createResidualNodes.ts

@@ -1,42 +0,0 @@
-import { subtractRect2D } from "../../utils/rectdiff-geometry"
-import type {
-  CapacityMeshNode,
-  CapacityMeshNodeId,
-} from "../../types/capacity-mesh-types"
-import type { XYRect } from "../../rectdiff-types"
-import { cloneNodeWithRect } from "./cloneNodeWithRect"
-
-/**
- * Cut one rectangle out of a node and return the remaining pieces.
- * Each remaining piece is turned back into a node.
- */
-export const createResidualNodes = ({
-  cutRect,
-  getNextResidualId,
-  idPrefix,
-  node,
-  onResidualNodeIdCreated,
-}: {
-  cutRect: XYRect
-  getNextResidualId: () => number
-  idPrefix: string
-  node: CapacityMeshNode
-  onResidualNodeIdCreated: (nodeId: CapacityMeshNodeId) => void
-}) =>
-  subtractRect2D(
-    {
-      x: node.center.x - node.width / 2,
-      y: node.center.y - node.height / 2,
-      width: node.width,
-      height: node.height,
-    },
-    cutRect,
-  ).map((rect) => {
-    const residualNode = cloneNodeWithRect({
-      templateNode: node,
-      rect,
-      capacityMeshNodeId: `${idPrefix}-${getNextResidualId()}`,
-    })
-    onResidualNodeIdCreated(residualNode.capacityMeshNodeId)
-    return residualNode
-  })

package/lib/solvers/SparseMultilayerPromotionSolver/findBestCoalesceCandidate.ts

@@ -1,98 +0,0 @@
-import { getZSpanMask } from "../../math/layers/getZSpanMask"
-import { mergeRects } from "../../math/rects/mergeRects"
-import { rectArea } from "../../math/rects/rectArea"
-import { rectContainsRect } from "../../math/rects/rectContainsRect"
-import { rectsTouchOrOverlap } from "../../math/rects/rectsTouchOrOverlap"
-import { subtractRects } from "../../math/rects/subtractRects"
-import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
-import { isFreeNode } from "./isFreeNode"
-import { nodeToRect } from "./nodeToRect"
-import type { CoalesceCandidate } from "./types"
-
-const areRectsAlignedForMerge = ({
-  a,
-  b,
-}: {
-  a: ReturnType<typeof nodeToRect>
-  b: ReturnType<typeof nodeToRect>
-}) => {
-  const sameVerticalBand =
-    Math.abs(a.x - b.x) <= Number.EPSILON &&
-    Math.abs(a.width - b.width) <= Number.EPSILON &&
-    a.y <= b.y + b.height + Number.EPSILON &&
-    b.y <= a.y + a.height + Number.EPSILON
-
-  const sameHorizontalBand =
-    Math.abs(a.y - b.y) <= Number.EPSILON &&
-    Math.abs(a.height - b.height) <= Number.EPSILON &&
-    a.x <= b.x + b.width + Number.EPSILON &&
-    b.x <= a.x + a.width + Number.EPSILON
-
-  return sameVerticalBand || sameHorizontalBand
-}
-
-/**
- * Find a good merge for nearby shared tiles.
- * Larger, more useful merges are preferred.
- */
-export const findBestCoalesceCandidate = ({
-  nodes,
-}: {
-  nodes: CapacityMeshNode[]
-}): CoalesceCandidate | null => {
-  let best: CoalesceCandidate | null = null
-  const nodesBySpan = new Map<
-    number,
-    Array<{ node: CapacityMeshNode; rect: ReturnType<typeof nodeToRect> }>
-  >()
-
-  for (const node of nodes) {
-    if (!isFreeNode({ node }) || node.availableZ.length <= 1) continue
-    const spanKey = getZSpanMask({ availableZ: node.availableZ })
-    const entries = nodesBySpan.get(spanKey) ?? []
-    entries.push({ node, rect: nodeToRect({ node }) })
-    nodesBySpan.set(spanKey, entries)
-  }
-
-  for (const entries of nodesBySpan.values()) {
-    for (let i = 0; i < entries.length; i++) {
-      const a = entries[i]!
-
-      for (let j = i + 1; j < entries.length; j++) {
-        const b = entries[j]!
-        if (
-          !areRectsAlignedForMerge({ a: a.rect, b: b.rect }) &&
-          !rectsTouchOrOverlap({ a: a.rect, b: b.rect })
-        ) {
-          continue
-        }
-
-        const mergedRect = mergeRects({ a: a.rect, b: b.rect })
-        const absorbedEntries = entries.filter((entry) =>
-          rectContainsRect({ inner: entry.rect, outer: mergedRect }),
-        )
-        if (absorbedEntries.length < 2) continue
-
-        if (
-          subtractRects({
-            target: mergedRect,
-            cutters: absorbedEntries.map((entry) => entry.rect),
-          }).length > 0
-        ) {
-          continue
-        }
-
-        const score = rectArea({ rect: mergedRect }) * absorbedEntries.length
-        if (!best || score > best.score) {
-          best = {
-            rect: mergedRect,
-            absorbedNodes: absorbedEntries.map((entry) => entry.node),
-            score,
-          }
-        }
-      }
-    }
-  }
-
-  return best
-}

package/lib/solvers/SparseMultilayerPromotionSolver/findBestPromotionCandidate.ts

@@ -1,72 +0,0 @@
-import { hasContiguousZSpan } from "../../math/layers/hasContiguousZSpan"
-import { getUnionZ } from "../../math/layers/getUnionZ"
-import { intersectRects } from "../../math/rects/intersectRects"
-import { rectArea } from "../../math/rects/rectArea"
-import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
-import { EPS } from "../../utils/rectdiff-geometry"
-import { isFreeNode } from "./isFreeNode"
-import { nodeToRect } from "./nodeToRect"
-import type { PromotionCandidate } from "./types"
-
-/**
- * Find a good overlap to turn into shared space.
- * Larger overlaps are preferred.
- */
-export const findBestPromotionCandidate = ({
-  minRectSize,
-  nodes,
-}: {
-  minRectSize: number
-  nodes: CapacityMeshNode[]
-}): PromotionCandidate | null => {
-  let best: PromotionCandidate | null = null
-
-  for (let i = 0; i < nodes.length; i++) {
-    const sourceNode = nodes[i]!
-    if (
-      !isFreeNode({ node: sourceNode }) ||
-      sourceNode.availableZ.length !== 1
-    ) {
-      continue
-    }
-
-    for (let j = 0; j < nodes.length; j++) {
-      if (i === j) continue
-
-      const targetNode = nodes[j]!
-      if (!isFreeNode({ node: targetNode })) continue
-
-      const unionZ = getUnionZ({
-        a: sourceNode.availableZ,
-        b: targetNode.availableZ,
-      })
-      if (unionZ.length <= targetNode.availableZ.length) continue
-      if (!hasContiguousZSpan({ zValues: unionZ })) continue
-
-      const overlapRect = intersectRects({
-        a: nodeToRect({ node: sourceNode }),
-        b: nodeToRect({ node: targetNode }),
-      })
-      if (!overlapRect) continue
-      if (
-        overlapRect.width + EPS < minRectSize ||
-        overlapRect.height + EPS < minRectSize
-      ) {
-        continue
-      }
-
-      const area = rectArea({ rect: overlapRect })
-      if (!best || area > best.area) {
-        best = {
-          rect: overlapRect,
-          sourceNode,
-          targetNode,
-          unionZ,
-          area,
-        }
-      }
-    }
-  }
-
-  return best
-}

package/lib/solvers/SparseMultilayerPromotionSolver/getUsableMultilayerVolumeShare.ts

@@ -1,34 +0,0 @@
-import { EPS } from "../../utils/rectdiff-geometry"
-import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
-
-/**
- * Measure how much usable space is shared across multiple layers.
- * Obstacle-only space is not counted.
- */
-export const getUsableMultilayerVolumeShare = ({
-  nodes,
-}: {
-  nodes: CapacityMeshNode[]
-}) => {
-  let totalVolume = 0
-  let obstacleVolume = 0
-  let multilayerVolume = 0
-
-  for (const node of nodes) {
-    const volume = node.width * node.height * node.availableZ.length
-    totalVolume += volume
-
-    if (node._containsObstacle) {
-      obstacleVolume += volume
-      continue
-    }
-
-    if (node.availableZ.length > 1) {
-      multilayerVolume += volume
-    }
-  }
-
-  const usableVolume = totalVolume - obstacleVolume
-  if (usableVolume <= EPS) return 0
-  return multilayerVolume / usableVolume
-}

package/lib/solvers/SparseMultilayerPromotionSolver/isFreeNode.ts

@@ -1,8 +0,0 @@
-import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
-
-/**
- * Check whether a node is plain free space.
- * Obstacles and targets are excluded.
- */
-export const isFreeNode = ({ node }: { node: CapacityMeshNode }) =>
-  !node._containsObstacle && !node._containsTarget

package/lib/solvers/SparseMultilayerPromotionSolver/nodeToRect.ts

@@ -1,13 +0,0 @@
-import type { XYRect } from "../../rectdiff-types"
-import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
-
-/**
- * Convert a node into a rectangle.
- * This keeps geometry code simple.
- */
-export const nodeToRect = ({ node }: { node: CapacityMeshNode }): XYRect => ({
-  x: node.center.x - node.width / 2,
-  y: node.center.y - node.height / 2,
-  width: node.width,
-  height: node.height,
-})

package/lib/solvers/SparseMultilayerPromotionSolver/solvers/CoalesceMultilayerTilesSolver.ts

@@ -1,104 +0,0 @@
-import { BaseSolver } from "@tscircuit/solver-utils"
-import type { GraphicsObject } from "graphics-debug"
-import type {
-  CapacityMeshNode,
-  CapacityMeshNodeId,
-} from "../../../types/capacity-mesh-types"
-import { getZLayerName } from "../../../math/layers/getZLayerName"
-import { getColorForZLayer } from "../../../utils/getColorForZLayer"
-import { cloneNode } from "../cloneNode"
-import { cloneNodeWithRect } from "../cloneNodeWithRect"
-import { findBestCoalesceCandidate } from "../findBestCoalesceCandidate"
-
-type CoalesceMultilayerTilesSolverInput = {
-  meshNodes: CapacityMeshNode[]
-}
-
-/**
- * Merge small shared tiles into larger regions.
- * It runs until no useful merge remains.
- */
-export class CoalesceMultilayerTilesSolver extends BaseSolver {
-  private nextMergedId = 0
-  private outputNodes: CapacityMeshNode[] = []
-  private promotedNodeIds = new Set<CapacityMeshNodeId>()
-  private workingNodes: CapacityMeshNode[] = []
-
-  constructor(private input: CoalesceMultilayerTilesSolverInput) {
-    super()
-  }
-
-  override _setup() {
-    this.nextMergedId = 0
-    this.promotedNodeIds.clear()
-    this.workingNodes = this.input.meshNodes.map((node) => cloneNode({ node }))
-    this.outputNodes = [...this.workingNodes]
-  }
-
-  override _step() {
-    const candidate = findBestCoalesceCandidate({ nodes: this.workingNodes })
-    if (!candidate) {
-      this.outputNodes = [...this.workingNodes]
-      this.solved = true
-      return
-    }
-
-    const absorbedNodeIds = new Set<CapacityMeshNodeId>(
-      candidate.absorbedNodes.map((node) => node.capacityMeshNodeId),
-    )
-    const templateNode = this.workingNodes.find((node) =>
-      absorbedNodeIds.has(node.capacityMeshNodeId),
-    )
-    if (!templateNode) {
-      this.outputNodes = [...this.workingNodes]
-      this.solved = true
-      return
-    }
-
-    const mergedNode = cloneNodeWithRect({
-      templateNode,
-      rect: candidate.rect,
-      capacityMeshNodeId: `sparse-coalesced-${this.nextMergedId++}`,
-    })
-    this.promotedNodeIds.add(mergedNode.capacityMeshNodeId)
-
-    this.workingNodes = [
-      ...this.workingNodes.filter(
-        (node) => !absorbedNodeIds.has(node.capacityMeshNodeId),
-      ),
-      mergedNode,
-    ]
-
-    this.outputNodes = [...this.workingNodes]
-  }
-
-  override getOutput() {
-    return {
-      outputNodes: this.outputNodes,
-      promotedNodeIds: this.promotedNodeIds,
-    }
-  }
-
-  override visualize(): GraphicsObject {
-    return {
-      title: "CoalesceMultilayerTilesSolver",
-      coordinateSystem: "cartesian",
-      rects: this.outputNodes.map((node) => {
-        const colors = getColorForZLayer(node.availableZ)
-        const isPromoted = this.promotedNodeIds.has(node.capacityMeshNodeId)
-
-        return {
-          center: node.center,
-          width: node.width,
-          height: node.height,
-          stroke: isPromoted ? "rgba(168, 85, 247, 0.95)" : colors.stroke,
-          fill: isPromoted ? "rgba(192, 132, 252, 0.28)" : colors.fill,
-          layer: getZLayerName({ availableZ: node.availableZ }),
-        }
-      }),
-      points: [],
-      lines: [],
-      texts: [],
-    }
-  }
-}