@tscircuit/rectdiff 0.0.38 → 0.0.39

package/lib/solvers/SparseMultilayerPromotionSolver/findBestCoalesceCandidate.ts

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,104 @@
+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: [],
+    }
+  }
+}

package/lib/solvers/SparseMultilayerPromotionSolver/solvers/PromoteSparseMultilayerCoverageSolver.ts

@@ -0,0 +1,148 @@
+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 { createResidualNodes } from "../createResidualNodes"
+import { findBestPromotionCandidate } from "../findBestPromotionCandidate"
+import { getUsableMultilayerVolumeShare } from "../getUsableMultilayerVolumeShare"
+
+type PromoteSparseMultilayerCoverageSolverInput = {
+  meshNodes: CapacityMeshNode[]
+  minRectSize: number
+  promotionTargetShare: number
+}
+
+/**
+ * Turn overlapping single-layer space into shared space.
+ * It runs until the configured shared-space threshold is reached.
+ */
+export class PromoteSparseMultilayerCoverageSolver extends BaseSolver {
+  private nextMergedId = 0
+  private nextResidualId = 0
+  private outputNodes: CapacityMeshNode[] = []
+  private promotedNodeIds = new Set<CapacityMeshNodeId>()
+  private residualNodeIds = new Set<CapacityMeshNodeId>()
+  private workingNodes: CapacityMeshNode[] = []
+
+  constructor(private input: PromoteSparseMultilayerCoverageSolverInput) {
+    super()
+  }
+
+  override _setup() {
+    this.nextMergedId = 0
+    this.nextResidualId = 0
+    this.promotedNodeIds.clear()
+    this.residualNodeIds.clear()
+    this.workingNodes = this.input.meshNodes.map((node) => cloneNode({ node }))
+    this.outputNodes = [...this.workingNodes]
+  }
+
+  override _step() {
+    if (
+      getUsableMultilayerVolumeShare({ nodes: this.workingNodes }) >=
+      this.input.promotionTargetShare
+    ) {
+      this.outputNodes = [...this.workingNodes]
+      this.solved = true
+      return
+    }
+
+    const candidate = findBestPromotionCandidate({
+      minRectSize: this.input.minRectSize,
+      nodes: this.workingNodes,
+    })
+    if (!candidate) {
+      this.outputNodes = [...this.workingNodes]
+      this.solved = true
+      return
+    }
+
+    const { sourceNode, targetNode } = candidate
+    if (!sourceNode || !targetNode) {
+      this.outputNodes = [...this.workingNodes]
+      this.solved = true
+      return
+    }
+
+    const mergedNode = cloneNodeWithRect({
+      templateNode: sourceNode,
+      rect: candidate.rect,
+      capacityMeshNodeId: `sparse-multilayer-merge-${this.nextMergedId++}`,
+      availableZ: candidate.unionZ,
+    })
+    this.promotedNodeIds.add(mergedNode.capacityMeshNodeId)
+
+    this.workingNodes = [
+      ...this.workingNodes.filter(
+        (node) =>
+          node.capacityMeshNodeId !== sourceNode.capacityMeshNodeId &&
+          node.capacityMeshNodeId !== targetNode.capacityMeshNodeId,
+      ),
+      mergedNode,
+      ...createResidualNodes({
+        cutRect: candidate.rect,
+        getNextResidualId: () => this.nextResidualId++,
+        idPrefix: `${sourceNode.capacityMeshNodeId}-sparse-residual`,
+        node: sourceNode,
+        onResidualNodeIdCreated: (nodeId) => this.residualNodeIds.add(nodeId),
+      }),
+      ...createResidualNodes({
+        cutRect: candidate.rect,
+        getNextResidualId: () => this.nextResidualId++,
+        idPrefix: `${targetNode.capacityMeshNodeId}-sparse-residual`,
+        node: targetNode,
+        onResidualNodeIdCreated: (nodeId) => this.residualNodeIds.add(nodeId),
+      }),
+    ]
+
+    this.outputNodes = [...this.workingNodes]
+  }
+
+  override getOutput() {
+    return {
+      outputNodes: this.outputNodes,
+      promotedNodeIds: this.promotedNodeIds,
+      residualNodeIds: this.residualNodeIds,
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    return {
+      title: "PromoteSparseMultilayerCoverageSolver",
+      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(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/solvers/TrimContainedSingleLayerCoverageSolver.ts

@@ -0,0 +1,137 @@
+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 { EPS } from "../../../utils/rectdiff-geometry"
+import { cloneNode } from "../cloneNode"
+import { cloneNodeWithRect } from "../cloneNodeWithRect"
+import { getUsableMultilayerVolumeShare } from "../getUsableMultilayerVolumeShare"
+import { isFreeNode } from "../isFreeNode"
+import { nodeToRect } from "../nodeToRect"
+import { getColorForZLayer } from "../../../utils/getColorForZLayer"
+import { subtractRects } from "../../../math/rects/subtractRects"
+
+type TrimContainedSingleLayerCoverageSolverInput = {
+  meshNodes: CapacityMeshNode[]
+  minRectSize: number
+  promotionTargetShare: number
+}
+
+/**
+ * Remove single-layer pieces that are already covered by shared space.
+ * This keeps the result smaller and simpler.
+ */
+export class TrimContainedSingleLayerCoverageSolver extends BaseSolver {
+  private nextResidualId = 0
+  private outputNodes: CapacityMeshNode[] = []
+  private residualNodeIds = new Set<CapacityMeshNodeId>()
+
+  constructor(private input: TrimContainedSingleLayerCoverageSolverInput) {
+    super()
+  }
+
+  override _setup() {
+    this.nextResidualId = 0
+    this.residualNodeIds.clear()
+    this.outputNodes = this.input.meshNodes.map((node) => cloneNode({ node }))
+  }
+
+  override _step() {
+    if (
+      getUsableMultilayerVolumeShare({ nodes: this.outputNodes }) >=
+      this.input.promotionTargetShare
+    ) {
+      this.solved = true
+      return
+    }
+
+    const freeMultilayerNodes = this.outputNodes.filter(
+      (node) => isFreeNode({ node }) && node.availableZ.length > 1,
+    )
+    const nextNodes: CapacityMeshNode[] = []
+
+    for (const node of this.outputNodes) {
+      if (!isFreeNode({ node }) || node.availableZ.length !== 1) {
+        nextNodes.push(node)
+        continue
+      }
+
+      const z = node.availableZ[0]!
+      const coveringRects = freeMultilayerNodes
+        .filter((candidate) => candidate.availableZ.includes(z))
+        .map((candidate) => nodeToRect({ node: candidate }))
+
+      if (coveringRects.length === 0) {
+        nextNodes.push(node)
+        continue
+      }
+
+      const nodeRect = nodeToRect({ node })
+      const residuals = subtractRects({
+        target: nodeRect,
+        cutters: coveringRects,
+      }).filter(
+        (rect) =>
+          rect.width + EPS >= this.input.minRectSize &&
+          rect.height + EPS >= this.input.minRectSize,
+      )
+
+      if (
+        residuals.length === 1 &&
+        Math.abs(residuals[0]!.x - nodeRect.x) <= EPS &&
+        Math.abs(residuals[0]!.y - nodeRect.y) <= EPS &&
+        Math.abs(residuals[0]!.width - nodeRect.width) <= EPS &&
+        Math.abs(residuals[0]!.height - nodeRect.height) <= EPS
+      ) {
+        nextNodes.push(node)
+        continue
+      }
+
+      for (const rect of residuals) {
+        const residualNode = cloneNodeWithRect({
+          templateNode: node,
+          rect,
+          capacityMeshNodeId: `${node.capacityMeshNodeId}-contained-residual-${this.nextResidualId++}`,
+        })
+        this.residualNodeIds.add(residualNode.capacityMeshNodeId)
+        nextNodes.push(residualNode)
+      }
+    }
+
+    this.outputNodes = nextNodes
+    this.solved = true
+  }
+
+  override getOutput() {
+    return {
+      outputNodes: this.outputNodes,
+      residualNodeIds: this.residualNodeIds,
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    return {
+      title: "TrimContainedSingleLayerCoverageSolver",
+      coordinateSystem: "cartesian",
+      rects: this.outputNodes.map((node) => {
+        const colors = getColorForZLayer(node.availableZ)
+        const isResidual = this.residualNodeIds.has(node.capacityMeshNodeId)
+
+        return {
+          center: node.center,
+          width: node.width,
+          height: node.height,
+          stroke: isResidual ? "rgba(14, 116, 144, 0.95)" : colors.stroke,
+          fill: isResidual ? "rgba(34, 211, 238, 0.18)" : colors.fill,
+          layer: getZLayerName({ availableZ: node.availableZ }),
+        }
+      }),
+      points: [],
+      lines: [],
+      texts: [],
+    }
+  }
+}

package/lib/solvers/SparseMultilayerPromotionSolver/types.ts

@@ -0,0 +1,23 @@
+import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
+import type { XYRect } from "../../rectdiff-types"
+import type { SimpleRouteJson } from "../../types/srj-types"
+
+export type SparseMultilayerPromotionInput = {
+  meshNodes: CapacityMeshNode[]
+  promotionTargetShare: number
+  simpleRouteJson: SimpleRouteJson
+}
+
+export type PromotionCandidate = {
+  rect: XYRect
+  sourceNode: CapacityMeshNode
+  targetNode: CapacityMeshNode
+  unionZ: number[]
+  area: number
+}
+
+export type CoalesceCandidate = {
+  rect: XYRect
+  absorbedNodes: CapacityMeshNode[]
+  score: number
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/rectdiff",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "type": "module",
   "main": "lib/index.ts",
   "types": "lib/index.ts",