@tscircuit/schematic-trace-solver 0.0.31 → 0.0.33

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/mid.ts

@@ -0,0 +1,97 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { ChipWithBounds } from "./rect"
+
+const EPS = 1e-9
+
+export type Axis = "x" | "y"
+
+export const aabbFromPoints = (a: Point, b: Point) => ({
+  minX: Math.min(a.x, b.x),
+  maxX: Math.max(a.x, b.x),
+  minY: Math.min(a.y, b.y),
+  maxY: Math.max(a.y, b.y),
+})
+
+export const midBetweenPointAndRect = (
+  axis: Axis,
+  p: Point,
+  r: ChipWithBounds,
+  eps = EPS,
+): number[] => {
+  if (axis === "x") {
+    if (p.x < r.minX - eps) {
+      return [(p.x + r.minX) / 2]
+    }
+    if (p.x > r.maxX + eps) {
+      return [(p.x + r.maxX) / 2]
+    }
+    // Point is within rect bounds on this axis - generate candidates on both sides
+    return [r.minX - 0.2, r.maxX + 0.2]
+  } else {
+    if (p.y < r.minY - eps) {
+      return [(p.y + r.minY) / 2]
+    }
+    if (p.y > r.maxY + eps) {
+      return [(p.y + r.maxY) / 2]
+    }
+    // Point is within rect bounds on this axis - generate candidates on both sides
+    return [r.minY - 0.2, r.maxY + 0.2]
+  }
+}
+
+export const candidateMidsFromSet = (
+  axis: Axis,
+  colliding: ChipWithBounds,
+  rectsById: Map<string, ChipWithBounds>,
+  collisionRectIds: Set<string>,
+  aabb: { minX: number; maxX: number; minY: number; maxY: number },
+  eps = EPS,
+): number[] => {
+  const setRects = [...collisionRectIds]
+    .map((id) => rectsById.get(id))
+    .filter((r): r is ChipWithBounds => !!r)
+
+  if (axis === "x") {
+    const leftBoundaries = [aabb.minX, ...setRects.map((r) => r.maxX)].filter(
+      (v) => v < colliding.minX - eps,
+    )
+    const rightBoundaries = [aabb.maxX, ...setRects.map((r) => r.minX)].filter(
+      (v) => v > colliding.maxX + eps,
+    )
+
+    const leftNeighbor =
+      leftBoundaries.length > 0 ? Math.max(...leftBoundaries) : undefined
+    const rightNeighbor =
+      rightBoundaries.length > 0 ? Math.min(...rightBoundaries) : undefined
+
+    const out: number[] = []
+    if (leftNeighbor !== undefined) {
+      out.push((leftNeighbor + colliding.minX) / 2)
+    }
+    if (rightNeighbor !== undefined) {
+      out.push((colliding.maxX + rightNeighbor) / 2)
+    }
+    return out
+  } else {
+    const bottomBoundaries = [aabb.minY, ...setRects.map((r) => r.maxY)].filter(
+      (v) => v < colliding.minY - eps,
+    )
+    const topBoundaries = [aabb.maxY, ...setRects.map((r) => r.minY)].filter(
+      (v) => v > colliding.maxY + eps,
+    )
+
+    const bottomNeighbor =
+      bottomBoundaries.length > 0 ? Math.max(...bottomBoundaries) : undefined
+    const topNeighbor =
+      topBoundaries.length > 0 ? Math.min(...topBoundaries) : undefined
+
+    const out: number[] = []
+    if (bottomNeighbor !== undefined) {
+      out.push((bottomNeighbor + colliding.minY) / 2)
+    }
+    if (topNeighbor !== undefined) {
+      out.push((colliding.maxY + topNeighbor) / 2)
+    }
+    return out
+  }
+}

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/pathOps.ts

@@ -0,0 +1,65 @@
+import type { Point } from "@tscircuit/math-utils"
+import { isHorizontal, isVertical } from "./collisions"
+
+const EPS = 1e-9
+
+export type Axis = "x" | "y"
+
+export const shiftSegmentOrth = (
+  pts: Point[],
+  segIndex: number,
+  axis: Axis,
+  newCoord: number,
+  eps = EPS,
+): Point[] | null => {
+  if (segIndex < 0 || segIndex >= pts.length - 1) return null
+  const a = pts[segIndex]!
+  const b = pts[segIndex + 1]!
+  const vert = isVertical(a, b, eps)
+  const horz = isHorizontal(a, b, eps)
+  if (!vert && !horz) return null
+
+  // Ensure axis matches orthogonal shift
+  if (vert && axis !== "x") return null
+  if (horz && axis !== "y") return null
+
+  const out = pts.map((p) => ({ ...p }))
+
+  if (axis === "x") {
+    if (Math.abs(a.x - newCoord) < eps && Math.abs(b.x - newCoord) < eps)
+      return null
+    out[segIndex] = { ...out[segIndex], x: newCoord }
+    out[segIndex + 1] = { ...out[segIndex + 1], x: newCoord }
+  } else {
+    if (Math.abs(a.y - newCoord) < eps && Math.abs(b.y - newCoord) < eps)
+      return null
+    out[segIndex] = { ...out[segIndex], y: newCoord }
+    out[segIndex + 1] = { ...out[segIndex + 1], y: newCoord }
+  }
+
+  // Prevent collapsing adjacent segments
+  if (segIndex - 1 >= 0) {
+    const p = out[segIndex - 1]!
+    const q = out[segIndex]!
+    const manhattan = Math.abs(p.x - q.x) + Math.abs(p.y - q.y)
+    if (manhattan < eps) return null
+  }
+  if (segIndex + 2 <= out.length - 1) {
+    const p = out[segIndex + 1]!
+    const q = out[segIndex + 2]!
+    const manhattan = Math.abs(p.x - q.x) + Math.abs(p.y - q.y)
+    if (manhattan < eps) return null
+  }
+
+  // Sanity: still orthogonal
+  for (let i = 0; i < out.length - 1; i++) {
+    const u = out[i]!
+    const v = out[i + 1]!
+    if (!isHorizontal(u, v, eps) && !isVertical(u, v, eps)) return null
+  }
+
+  return out
+}
+
+export const pathKey = (pts: Point[], decimals = 6) =>
+  pts.map((p) => `${p.x.toFixed(decimals)},${p.y.toFixed(decimals)}`).join("|")

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect.ts

@@ -0,0 +1,19 @@
+import type { InputChip, InputProblem } from "lib/types/InputProblem"
+import { getInputChipBounds } from "lib/solvers/GuidelinesSolver/getInputChipBounds"
+
+export type ChipWithBounds = {
+  chipId: string
+  minX: number
+  minY: number
+  maxX: number
+  maxY: number
+}
+
+export const chipToRect = (chip: InputChip): ChipWithBounds => {
+  const b = getInputChipBounds(chip)
+  return { chipId: chip.chipId, ...b }
+}
+
+export const getObstacleRects = (problem: InputProblem): ChipWithBounds[] => {
+  return problem.chips.map(chipToRect)
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -48,7 +48,7 @@ function definePipelineStep<
 
 export class SchematicTracePipelineSolver extends BaseSolver {
   mspConnectionPairSolver?: MspConnectionPairSolver
-  guidelinesSolver?: GuidelinesSolver
+  // guidelinesSolver?: GuidelinesSolver
   schematicTraceLinesSolver?: SchematicTraceLinesSolver
   traceOverlapShiftSolver?: TraceOverlapShiftSolver
   netLabelPlacementSolver?: NetLabelPlacementSolver
@@ -69,18 +69,18 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         onSolved: (mspSolver) => {},
       },
     ),
-    definePipelineStep(
-      "guidelinesSolver",
-      GuidelinesSolver,
-      () => [
-        {
-          inputProblem: this.inputProblem,
-        },
-      ],
-      {
-        onSolved: (guidelinesSolver) => {},
-      },
-    ),
+    // definePipelineStep(
+    //   "guidelinesSolver",
+    //   GuidelinesSolver,
+    //   () => [
+    //     {
+    //       inputProblem: this.inputProblem,
+    //     },
+    //   ],
+    //   {
+    //     onSolved: (guidelinesSolver) => {},
+    //   },
+    // ),
     definePipelineStep(
       "schematicTraceLinesSolver",
       SchematicTraceLinesSolver,
@@ -90,7 +90,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
           dcConnMap: this.mspConnectionPairSolver!.dcConnMap,
           globalConnMap: this.mspConnectionPairSolver!.globalConnMap,
           inputProblem: this.inputProblem,
-          guidelines: this.guidelinesSolver!.guidelines,
+          // guidelines: this.guidelinesSolver!.guidelines,
           chipMap: this.mspConnectionPairSolver!.chipMap,
         },
       ],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "type": "module",
   "scripts": {
     "start": "cosmos",