@tscircuit/rectdiff 0.0.39 → 0.0.40

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

@@ -1,148 +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 { 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

@@ -1,137 +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 { 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

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