@tscircuit/schematic-trace-solver 0.0.36 → 0.0.38

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/turnMinimization.ts

@@ -0,0 +1,305 @@
+import type { Point } from "graphics-debug"
+import type { InputProblem } from "lib/types/InputProblem"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getObstacleRects } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { hasCollisions } from "./hasCollisions"
+import { countTurns } from "./countTurns"
+import { simplifyPath } from "./simplifyPath"
+
+const minimizeTurns = ({
+  path,
+  obstacles,
+  labelBounds,
+}: {
+  path: Point[]
+  obstacles: any[]
+  labelBounds: any[]
+}): Point[] => {
+  if (path.length <= 2) {
+    return path
+  }
+
+  const hasCollisionsWithLabels = (
+    pathSegments: Point[],
+    labels: any[],
+  ): boolean => {
+    for (let i = 0; i < pathSegments.length - 1; i++) {
+      const p1 = pathSegments[i]
+      const p2 = pathSegments[i + 1]
+
+      for (const label of labels) {
+        if (segmentIntersectsRect(p1, p2, label)) {
+          return true
+        }
+      }
+    }
+    return false
+  }
+
+  const tryConnectPoints = (start: Point, end: Point): Point[][] => {
+    const candidates: Point[][] = []
+
+    if (start.x === end.x || start.y === end.y) {
+      candidates.push([start, end])
+    } else {
+      candidates.push([start, { x: end.x, y: start.y }, end])
+      candidates.push([start, { x: start.x, y: end.y }, end])
+    }
+
+    return candidates
+  }
+
+  const recognizeStairStepPattern = (
+    pathToCheck: Point[],
+    startIdx: number,
+  ): number => {
+    if (startIdx >= pathToCheck.length - 3) return -1
+
+    let endIdx = startIdx
+    let isStairStep = true
+
+    for (
+      let i = startIdx;
+      i < pathToCheck.length - 2 && i < startIdx + 10;
+      i++
+    ) {
+      if (i + 2 >= pathToCheck.length) break
+
+      const p1 = pathToCheck[i]
+      const p2 = pathToCheck[i + 1]
+      const p3 = pathToCheck[i + 2]
+
+      const seg1Vertical = p1.x === p2.x
+      const seg2Vertical = p2.x === p3.x
+
+      if (seg1Vertical === seg2Vertical) {
+        break
+      }
+
+      const seg1Direction = seg1Vertical
+        ? Math.sign(p2.y - p1.y)
+        : Math.sign(p2.x - p1.x)
+
+      if (i > startIdx) {
+        const prevP = pathToCheck[i - 1]
+        const prevSegVertical = prevP.x === p1.x
+        const prevDirection = prevSegVertical
+          ? Math.sign(p1.y - prevP.y)
+          : Math.sign(p1.x - prevP.x)
+
+        if (
+          (seg1Vertical &&
+            prevSegVertical &&
+            seg1Direction !== prevDirection) ||
+          (!seg1Vertical && !prevSegVertical && seg1Direction !== prevDirection)
+        ) {
+          isStairStep = false
+          break
+        }
+      }
+
+      endIdx = i + 2
+    }
+
+    return isStairStep && endIdx - startIdx >= 3 ? endIdx : -1
+  }
+
+  let optimizedPath = [...path]
+  let currentTurns = countTurns(optimizedPath)
+  let improved = true
+
+  while (improved) {
+    improved = false
+
+    // First try to identify and replace stair-step patterns
+    for (let startIdx = 0; startIdx < optimizedPath.length - 3; startIdx++) {
+      const stairEndIdx = recognizeStairStepPattern(optimizedPath, startIdx)
+
+      if (stairEndIdx > 0) {
+        const startPoint = optimizedPath[startIdx]
+        const endPoint = optimizedPath[stairEndIdx]
+
+        const connectionOptions = tryConnectPoints(startPoint, endPoint)
+
+        for (const connection of connectionOptions) {
+          const testPath = [
+            ...optimizedPath.slice(0, startIdx + 1),
+            ...connection.slice(1, -1),
+            ...optimizedPath.slice(stairEndIdx),
+          ]
+
+          const collidesWithObstacles = hasCollisions(connection, obstacles)
+          const collidesWithLabels = hasCollisionsWithLabels(
+            connection,
+            labelBounds,
+          )
+
+          if (!collidesWithObstacles && !collidesWithLabels) {
+            const newTurns = countTurns(testPath)
+            const turnsRemoved = stairEndIdx - startIdx - 1
+
+            optimizedPath = testPath
+            currentTurns = newTurns
+            improved = true
+            break
+          }
+        }
+
+        if (improved) break
+      }
+    }
+
+    // If no stair-step optimization worked, try regular point removal
+    if (!improved) {
+      for (let startIdx = 0; startIdx < optimizedPath.length - 2; startIdx++) {
+        const maxRemove = Math.min(
+          optimizedPath.length - startIdx - 2,
+          optimizedPath.length - 2,
+        )
+
+        for (let removeCount = 1; removeCount <= maxRemove; removeCount++) {
+          const endIdx = startIdx + removeCount + 1
+
+          if (endIdx >= optimizedPath.length) continue
+
+          const startPoint = optimizedPath[startIdx]
+          const endPoint = optimizedPath[endIdx]
+
+          const connectionOptions = tryConnectPoints(startPoint, endPoint)
+
+          for (const connection of connectionOptions) {
+            const testPath = [
+              ...optimizedPath.slice(0, startIdx + 1),
+              ...connection.slice(1, -1),
+              ...optimizedPath.slice(endIdx),
+            ]
+
+            const connectionSegments = connection
+            const collidesWithObstacles = hasCollisions(
+              connectionSegments,
+              obstacles,
+            )
+            const collidesWithLabels = hasCollisionsWithLabels(
+              connectionSegments,
+              labelBounds,
+            )
+
+            if (!collidesWithObstacles && !collidesWithLabels) {
+              const newTurns = countTurns(testPath)
+
+              if (
+                newTurns < currentTurns ||
+                (newTurns === currentTurns &&
+                  testPath.length < optimizedPath.length)
+              ) {
+                optimizedPath = testPath
+                currentTurns = newTurns
+                improved = true
+                break
+              }
+            }
+          }
+
+          if (improved) break
+        }
+        if (improved) break
+      }
+    }
+
+    if (!improved) {
+      for (let i = 0; i < optimizedPath.length - 2; i++) {
+        const p1 = optimizedPath[i]
+        const p2 = optimizedPath[i + 1]
+        const p3 = optimizedPath[i + 2]
+
+        const allVertical = p1.x === p2.x && p2.x === p3.x
+        const allHorizontal = p1.y === p2.y && p2.y === p3.y
+
+        if (allVertical || allHorizontal) {
+          const testPath = [
+            ...optimizedPath.slice(0, i + 1),
+            ...optimizedPath.slice(i + 2),
+          ]
+
+          const collidesWithObstacles = hasCollisions([p1, p3], obstacles)
+          const collidesWithLabels = hasCollisionsWithLabels(
+            [p1, p3],
+            labelBounds,
+          )
+
+          if (!collidesWithObstacles && !collidesWithLabels) {
+            optimizedPath = testPath
+            improved = true
+            break
+          }
+        }
+      }
+    }
+  }
+
+  const finalSimplifiedPath = simplifyPath(optimizedPath)
+  return finalSimplifiedPath
+}
+
+export const minimizeTurnsWithFilteredLabels = ({
+  traces,
+  problem,
+  allLabelPlacements,
+  mergedLabelNetIdMap,
+  paddingBuffer,
+}: {
+  traces: SolvedTracePath[]
+  problem: InputProblem
+  allLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Map<string, Set<string>>
+  paddingBuffer: number
+}): SolvedTracePath[] | null => {
+  let changesMade = false
+  const obstacles = getObstacleRects(problem)
+
+  const newTraces = traces.map((trace) => {
+    const originalPath = trace.tracePath
+    const filteredLabels = allLabelPlacements.filter((label) => {
+      const originalNetIds = mergedLabelNetIdMap.get(label.globalConnNetId)
+      if (originalNetIds) {
+        return !originalNetIds.has(trace.globalConnNetId)
+      }
+      return label.globalConnNetId !== trace.globalConnNetId
+    })
+
+    const labelBounds = filteredLabels.map((nl) => ({
+      minX: nl.center.x - nl.width / 2 - paddingBuffer,
+      maxX: nl.center.x + nl.width / 2 + paddingBuffer,
+      minY: nl.center.y - nl.height / 2 - paddingBuffer,
+      maxY: nl.center.y + nl.height / 2 + paddingBuffer,
+    }))
+
+    const newPath = minimizeTurns({
+      path: originalPath,
+      obstacles,
+      labelBounds,
+    })
+
+    if (
+      newPath.length !== originalPath.length ||
+      newPath.some(
+        (p, i) => p.x !== originalPath[i].x || p.y !== originalPath[i].y,
+      )
+    ) {
+      changesMade = true
+    }
+
+    return {
+      ...trace,
+      tracePath: newPath,
+    }
+  })
+
+  if (changesMade) {
+    return newTraces
+  } else {
+    return null
+  }
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/violation.ts

@@ -0,0 +1,25 @@
+import type { Point } from "@tscircuit/math-utils"
+
+export const findTraceViolationZone = (
+  path: Point[],
+  labelBounds: { minX: number; maxX: number; minY: number; maxY: number },
+) => {
+  const isPointInside = (p: Point) =>
+    p.x > labelBounds.minX &&
+    p.x < labelBounds.maxX &&
+    p.y > labelBounds.minY &&
+    p.y < labelBounds.maxY
+
+  let firstInsideIndex = -1
+  let lastInsideIndex = -1
+
+  for (let i = 0; i < path.length; i++) {
+    if (isPointInside(path[i])) {
+      if (firstInsideIndex === -1) {
+        firstInsideIndex = i
+      }
+      lastInsideIndex = i
+    }
+  }
+  return { firstInsideIndex, lastInsideIndex }
+}

package/package.json

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

package/site/examples/example20.page.tsx

@@ -0,0 +1,103 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import type { InputProblem } from "lib/types/InputProblem"
+
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: {
+        x: 0,
+        y: 0,
+      },
+      width: 2.4000000000000004,
+      height: 1,
+      pins: [
+        {
+          pinId: "U1.1",
+          x: 1.2000000000000002,
+          y: -0.30000000000000004,
+        },
+        {
+          pinId: "U1.2",
+          x: -1.2000000000000002,
+          y: -0.30000000000000004,
+        },
+        {
+          pinId: "U1.3",
+          x: 1.2000000000000002,
+          y: 0.09999999999999998,
+        },
+        {
+          pinId: "U1.4",
+          x: -1.2000000000000002,
+          y: 0.30000000000000004,
+        },
+        {
+          pinId: "U1.5",
+          x: -1.2000000000000002,
+          y: 0.10000000000000003,
+        },
+        {
+          pinId: "U1.6",
+          x: -1.2000000000000002,
+          y: -0.09999999999999998,
+        },
+        {
+          pinId: "U1.7",
+          x: 1.2000000000000002,
+          y: -0.10000000000000003,
+        },
+        {
+          pinId: "U1.8",
+          x: 1.2000000000000002,
+          y: 0.30000000000000004,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_1",
+      center: {
+        x: 2.7,
+        y: 1.9049999999999998,
+      },
+      width: 2.2,
+      height: 0.8,
+      pins: [
+        {
+          pinId: "J1.1",
+          x: 1.6,
+          y: 2.105,
+        },
+        {
+          pinId: "J1.2",
+          x: 1.6,
+          y: 1.9049999999999998,
+        },
+        {
+          pinId: "J1.3",
+          x: 1.6,
+          y: 1.7049999999999998,
+        },
+      ],
+    },
+  ],
+  directConnections: [],
+  netConnections: [
+    {
+      netId: "GND",
+      pinIds: ["U1.1", "J1.3"],
+    },
+    {
+      netId: "VCC",
+      pinIds: ["U1.8", "J1.1"],
+    },
+  ],
+  availableNetLabelOrientations: {
+    VCC: ["y+"],
+    OUT: ["x-", "x+"],
+    GND: ["y-"],
+  },
+  maxMspPairDistance: 2.4,
+}
+
+export default () => <PipelineDebugger inputProblem={inputProblem} />

package/site/examples/example21.page.tsx

@@ -0,0 +1,177 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import type { InputProblem } from "lib/types/InputProblem"
+
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: {
+        x: 0,
+        y: 0,
+      },
+      width: 2,
+      height: 2,
+      pins: [
+        {
+          pinId: "CORNERS.1",
+          x: -1.4,
+          y: -0.6,
+        },
+        {
+          pinId: "CORNERS.2",
+          x: -1.4,
+          y: 0.6,
+        },
+        {
+          pinId: "CORNERS.3",
+          x: 1.4,
+          y: 0.6,
+        },
+        {
+          pinId: "CORNERS.4",
+          x: 1.4,
+          y: -0.6,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_1",
+      center: {
+        x: 4.785,
+        y: -0.3999999999999999,
+      },
+      width: 1.2000000000000002,
+      height: 1,
+      pins: [
+        {
+          pinId: "U100.1",
+          x: 3.785,
+          y: -0.29999999999999993,
+        },
+        {
+          pinId: "U100.2",
+          x: 4.785,
+          y: -1.2999999999999998,
+        },
+        {
+          pinId: "U100.3",
+          x: 3.785,
+          y: -0.4999999999999999,
+        },
+        {
+          pinId: "U100.5",
+          x: 5.785,
+          y: -0.3999999999999999,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_2",
+      center: {
+        x: 6.7,
+        y: -0.9499999999999993,
+      },
+      width: 0.53,
+      height: 1.06,
+      pins: [
+        {
+          pinId: "C101.1",
+          x: 6.7,
+          y: -0.39999999999999925,
+        },
+        {
+          pinId: "C101.2",
+          x: 6.7,
+          y: -1.4999999999999993,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_3",
+      center: {
+        x: 2.8699999999999997,
+        y: -1.75,
+      },
+      width: 0.53,
+      height: 1.06,
+      pins: [
+        {
+          pinId: "C100.1",
+          x: 2.8699999999999997,
+          y: -1.2,
+        },
+        {
+          pinId: "C100.2",
+          x: 2.8699999999999997,
+          y: -2.3,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_4",
+      center: {
+        x: 2.9752723250000006,
+        y: 0.050000000000000266,
+      },
+      width: 0.3194553499999995,
+      height: 1.06,
+      pins: [
+        {
+          pinId: "R100.1",
+          x: 2.9752723250000006,
+          y: 0.6000000000000001,
+        },
+        {
+          pinId: "R100.2",
+          x: 2.9752723250000006,
+          y: -0.4999999999999998,
+        },
+      ],
+    },
+  ],
+  directConnections: [
+    {
+      pinIds: ["C101.1", "U100.5"],
+      netId: "group > capacitor.C101 > port.pin1 to U100.VOUT",
+    },
+    {
+      pinIds: ["C100.1", "U100.1"],
+      netId: "group > capacitor.C100 > port.pin1 to U100.VIN",
+    },
+    {
+      pinIds: ["R100.2", "U100.3"],
+      netId: "group > resistor.R100 > port.pin2 to U100.EN",
+    },
+  ],
+  netConnections: [
+    {
+      netId: "GND",
+      pinIds: ["CORNERS.1", "CORNERS.4", "U100.2", "C101.2", "C100.2"],
+      netLabelWidth: 0.3,
+    },
+    {
+      netId: "VIN",
+      pinIds: ["CORNERS.2", "U100.1", "C100.1", "R100.1"],
+      netLabelWidth: 0.3,
+    },
+    {
+      netId: "VOUT",
+      pinIds: ["CORNERS.3", "U100.5", "C101.1"],
+      netLabelWidth: 0.4,
+    },
+    {
+      netId: "LDO_EN",
+      pinIds: ["U100.3", "R100.2"],
+      netLabelWidth: 0.6,
+    },
+  ],
+  availableNetLabelOrientations: {
+    GND: ["y-"],
+    VIN: ["y+"],
+    VOUT: ["y+"],
+    LDO_EN: ["x-", "x+"],
+  },
+  maxMspPairDistance: 2.4,
+} as InputProblem
+
+export default () => <PipelineDebugger inputProblem={inputProblem} />