@tscircuit/schematic-trace-solver 0.0.26 → 0.0.28

package/dist/index.d.ts

@@ -154,6 +154,9 @@ interface MovableSegment {
     };
 }
 
+type ChipPin = InputPin & {
+    chipId: ChipId;
+};
 declare class SchematicTraceSingleLineSolver extends BaseSolver {
     pins: MspConnectionPair["pins"];
     inputProblem: InputProblem;
@@ -168,6 +171,7 @@ declare class SchematicTraceSingleLineSolver extends BaseSolver {
         x: number;
         y: number;
     }[] | null;
+    pinIdMap: Map<PinId, ChipPin>;
     constructor(params: {
         pins: MspConnectionPair["pins"];
         guidelines: Guideline[];
@@ -331,6 +335,7 @@ declare class SingleNetLabelPlacementSolver extends BaseSolver {
         overlappingSameNetTraceGroup: OverlappingSameNetTraceGroup;
         availableOrientations: FacingDirection[];
     });
+    getConstructorParams(): ConstructorParameters<typeof SingleNetLabelPlacementSolver>[0];
     _step(): void;
     visualize(): GraphicsObject;
 }

package/dist/index.js

@@ -668,6 +668,86 @@ var visualizeGuidelines = ({
   return graphics;
 };
 
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getRestrictedCenterLines.ts
+var getRestrictedCenterLines = (params) => {
+  const { pins, inputProblem, pinIdMap, chipMap } = params;
+  const findAllDirectlyConnectedPins = (startPinId) => {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [startPinId];
+    visited.add(startPinId);
+    const directConns = inputProblem.directConnections || [];
+    while (queue.length) {
+      const cur = queue.shift();
+      for (const dc of directConns) {
+        if (dc.pinIds.includes(cur)) {
+          for (const p of dc.pinIds) {
+            if (!visited.has(p)) {
+              visited.add(p);
+              queue.push(p);
+            }
+          }
+        }
+      }
+    }
+    return visited;
+  };
+  const p0 = pins[0].pinId;
+  const p1 = pins[1].pinId;
+  const relatedPinIds = /* @__PURE__ */ new Set([
+    ...findAllDirectlyConnectedPins(p0),
+    ...findAllDirectlyConnectedPins(p1)
+  ]);
+  const restrictedCenterLines = /* @__PURE__ */ new Map();
+  const chipFacingMap = /* @__PURE__ */ new Map();
+  const chipsOfFacingPins = new Set(pins.map((p) => p.chipId));
+  for (const pinId of relatedPinIds) {
+    const pin = pinIdMap.get(pinId);
+    if (!pin) continue;
+    const chip = chipMap[pin.chipId];
+    if (!chip) continue;
+    const facing = pin._facingDirection ?? getPinDirection(pin, chip);
+    let entry = chipFacingMap.get(chip.chipId);
+    if (!entry) {
+      entry = { center: chip.center };
+      const counts = { xPos: 0, xNeg: 0, yPos: 0, yNeg: 0 };
+      for (const cp of chip.pins) {
+        const cpFacing = cp._facingDirection ?? getPinDirection(cp, chip);
+        if (cpFacing === "x+") counts.xPos++;
+        if (cpFacing === "x-") counts.xNeg++;
+        if (cpFacing === "y+") counts.yPos++;
+        if (cpFacing === "y-") counts.yNeg++;
+      }
+      entry.counts = counts;
+      chipFacingMap.set(chip.chipId, entry);
+    }
+    if (facing === "x+") entry.hasXPos = true;
+    if (facing === "x-") entry.hasXNeg = true;
+    if (facing === "y+") entry.hasYPos = true;
+    if (facing === "y-") entry.hasYNeg = true;
+  }
+  for (const [chipId, faces] of chipFacingMap) {
+    const axes = /* @__PURE__ */ new Set();
+    const rcl = { axes };
+    const counts = faces.counts;
+    const anySideHasMultiplePins = !!(counts && (counts.xPos > 1 || counts.xNeg > 1 || counts.yPos > 1 || counts.yNeg > 1));
+    const skipCenterRestriction = !anySideHasMultiplePins && chipsOfFacingPins.has(chipId);
+    if (!skipCenterRestriction) {
+      if (faces.hasXPos && faces.hasXNeg) {
+        rcl.x = faces.center.x;
+        axes.add("x");
+      }
+      if (faces.hasYPos && faces.hasYNeg) {
+        rcl.y = faces.center.y;
+        axes.add("y");
+      }
+    }
+    if (axes.size > 0) {
+      restrictedCenterLines.set(chipId, rcl);
+    }
+  }
+  return restrictedCenterLines;
+};
+
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver.ts
 var SchematicTraceSingleLineSolver = class extends BaseSolver {
   pins;
@@ -680,6 +760,8 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
   queuedCandidatePaths;
   chipObstacleSpatialIndex;
   solvedTracePath = null;
+  // map of pinId -> pin (with chipId attached)
+  pinIdMap = /* @__PURE__ */ new Map();
   constructor(params) {
     super();
     this.pins = params.pins;
@@ -690,6 +772,11 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
     if (!this.inputProblem._chipObstacleSpatialIndex) {
       this.inputProblem._chipObstacleSpatialIndex = this.chipObstacleSpatialIndex;
     }
+    for (const chip of this.inputProblem.chips) {
+      for (const pin of chip.pins) {
+        this.pinIdMap.set(pin.pinId, { ...pin, chipId: chip.chipId });
+      }
+    }
     for (const pin of this.pins) {
       if (!pin._facingDirection) {
         const chip = this.chipMap[pin.chipId];
@@ -746,10 +833,25 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
       return;
     }
     const nextCandidatePath = this.queuedCandidatePaths.shift();
+    const restrictedCenterLines = getRestrictedCenterLines({
+      pins: this.pins,
+      inputProblem: this.inputProblem,
+      pinIdMap: this.pinIdMap,
+      chipMap: this.chipMap
+    });
     for (let i = 0; i < nextCandidatePath.length - 1; i++) {
       const start = nextCandidatePath[i];
       const end = nextCandidatePath[i + 1];
       let excludeChipIds = [];
+      const EPS2 = 1e-9;
+      for (const [, rcl] of restrictedCenterLines) {
+        if (rcl.axes.has("x") && typeof rcl.x === "number") {
+          if ((start.x - rcl.x) * (end.x - rcl.x) < -EPS2) return;
+        }
+        if (rcl.axes.has("y") && typeof rcl.y === "number") {
+          if ((start.y - rcl.y) * (end.y - rcl.y) < -EPS2) return;
+        }
+      }
       const isStartPin = this.pins.some(
         (pin) => Math.abs(pin.x - start.x) < 1e-10 && Math.abs(pin.y - start.y) < 1e-10
       );
@@ -764,12 +866,12 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
           const bounds = getInputChipBounds(this.chipMap[startPin.chipId]);
           const dx = end.x - start.x;
           const dy = end.y - start.y;
-          const EPS2 = 1e-9;
+          const EPS3 = 1e-9;
           const onLeft = Math.abs(start.x - bounds.minX) < 1e-9;
           const onRight = Math.abs(start.x - bounds.maxX) < 1e-9;
           const onBottom = Math.abs(start.y - bounds.minY) < 1e-9;
           const onTop = Math.abs(start.y - bounds.maxY) < 1e-9;
-          const entersInterior = onLeft && dx > EPS2 || onRight && dx < -EPS2 || onBottom && dy > EPS2 || onTop && dy < -EPS2;
+          const entersInterior = onLeft && dx > EPS3 || onRight && dx < -EPS3 || onBottom && dy > EPS3 || onTop && dy < -EPS3;
           if (entersInterior) return;
           if (!excludeChipIds.includes(startPin.chipId)) {
             excludeChipIds.push(startPin.chipId);
@@ -784,12 +886,12 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
           const bounds = getInputChipBounds(this.chipMap[endPin.chipId]);
           const dx = start.x - end.x;
           const dy = start.y - end.y;
-          const EPS2 = 1e-9;
+          const EPS3 = 1e-9;
           const onLeft = Math.abs(end.x - bounds.minX) < 1e-9;
           const onRight = Math.abs(end.x - bounds.maxX) < 1e-9;
           const onBottom = Math.abs(end.y - bounds.minY) < 1e-9;
           const onTop = Math.abs(end.y - bounds.maxY) < 1e-9;
-          const entersInterior = onLeft && dx > EPS2 || onRight && dx < -EPS2 || onBottom && dy > EPS2 || onTop && dy < -EPS2;
+          const entersInterior = onLeft && dx > EPS3 || onRight && dx < -EPS3 || onBottom && dy > EPS3 || onTop && dy < -EPS3;
           if (entersInterior) return;
           if (!excludeChipIds.includes(endPin.chipId)) {
             excludeChipIds.push(endPin.chipId);
@@ -1579,6 +1681,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     this.availableOrientations = params.availableOrientations;
     this.chipObstacleSpatialIndex = params.inputProblem._chipObstacleSpatialIndex ?? new ChipObstacleSpatialIndex(params.inputProblem.chips);
   }
+  getConstructorParams() {
+    return {
+      inputProblem: this.inputProblem,
+      inputTraceMap: this.inputTraceMap,
+      overlappingSameNetTraceGroup: this.overlappingSameNetTraceGroup,
+      availableOrientations: this.availableOrientations
+    };
+  }
   _step() {
     if (this.netLabelPlacement) {
       this.solved = true;

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver.ts

@@ -87,6 +87,17 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
       new ChipObstacleSpatialIndex(params.inputProblem.chips)
   }
 
+  override getConstructorParams(): ConstructorParameters<
+    typeof SingleNetLabelPlacementSolver
+  >[0] {
+    return {
+      inputProblem: this.inputProblem,
+      inputTraceMap: this.inputTraceMap,
+      overlappingSameNetTraceGroup: this.overlappingSameNetTraceGroup,
+      availableOrientations: this.availableOrientations,
+    }
+  }
+
   override _step() {
     if (this.netLabelPlacement) {
       this.solved = true

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver.ts

@@ -4,7 +4,13 @@ import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { Guideline } from "lib/solvers/GuidelinesSolver/GuidelinesSolver"
 import type { MspConnectionPair } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
-import type { InputChip, InputProblem } from "lib/types/InputProblem"
+import type {
+  ChipId,
+  InputChip,
+  InputPin,
+  InputProblem,
+  PinId,
+} from "lib/types/InputProblem"
 import { calculateElbow } from "calculate-elbow"
 import { getPinDirection } from "./getPinDirection"
 import {
@@ -15,6 +21,9 @@ import type { Point } from "@tscircuit/math-utils"
 import { visualizeGuidelines } from "lib/solvers/GuidelinesSolver/visualizeGuidelines"
 import { getInputChipBounds } from "lib/solvers/GuidelinesSolver/getInputChipBounds"
 import { getColorFromString } from "lib/utils/getColorFromString"
+import { getRestrictedCenterLines } from "./getRestrictedCenterLines"
+
+type ChipPin = InputPin & { chipId: ChipId }
 
 export class SchematicTraceSingleLineSolver extends BaseSolver {
   pins: MspConnectionPair["pins"]
@@ -31,6 +40,9 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
 
   solvedTracePath: { x: number; y: number }[] | null = null
 
+  // map of pinId -> pin (with chipId attached)
+  pinIdMap: Map<PinId, ChipPin> = new Map()
+
   constructor(params: {
     pins: MspConnectionPair["pins"]
     guidelines: Guideline[]
@@ -51,6 +63,13 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
         this.chipObstacleSpatialIndex
     }
 
+    // Build a lookup of all pins by id and attach chipId to each pin entry
+    for (const chip of this.inputProblem.chips) {
+      for (const pin of chip.pins) {
+        this.pinIdMap.set(pin.pinId, { ...pin, chipId: chip.chipId })
+      }
+    }
+
     for (const pin of this.pins) {
       if (!pin._facingDirection) {
         const chip = this.chipMap[pin.chipId]
@@ -118,6 +137,13 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
 
     const nextCandidatePath = this.queuedCandidatePaths.shift()!
 
+    const restrictedCenterLines = getRestrictedCenterLines({
+      pins: this.pins,
+      inputProblem: this.inputProblem,
+      pinIdMap: this.pinIdMap,
+      chipMap: this.chipMap,
+    })
+
     for (let i = 0; i < nextCandidatePath.length - 1; i++) {
       const start = nextCandidatePath[i]
       const end = nextCandidatePath[i + 1]
@@ -125,6 +151,19 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
       // Determine which chips to exclude for this specific segment
       let excludeChipIds: string[] = []
 
+      // If this segment would cross any restricted center line, reject the candidate path.
+      const EPS = 1e-9
+      for (const [, rcl] of restrictedCenterLines) {
+        if (rcl.axes.has("x") && typeof rcl.x === "number") {
+          // segment strictly crosses vertical center line
+          if ((start.x - rcl.x) * (end.x - rcl.x) < -EPS) return
+        }
+        if (rcl.axes.has("y") && typeof rcl.y === "number") {
+          // segment strictly crosses horizontal center line
+          if ((start.y - rcl.y) * (end.y - rcl.y) < -EPS) return
+        }
+      }
+
       // Always exclude chips that contain the start or end points of this segment
       // if those points are actually pin locations
       const isStartPin = this.pins.some(

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getRestrictedCenterLines.ts

@@ -0,0 +1,139 @@
+import type {
+  ChipId,
+  InputChip,
+  InputPin,
+  InputProblem,
+  PinId,
+} from "lib/types/InputProblem"
+import { getPinDirection } from "./getPinDirection"
+
+type ChipPin = InputPin & { chipId: ChipId }
+
+/**
+ * A line that should not be crossed by a trace segment.
+ * This is used to prevent traces from crossing through the center of a chip when
+ * connecting pins on that same chip. Right now this is only enabled when a chip
+ * has multiple pins on at least one side.
+ */
+export type RestrictedCenterLine = {
+  x?: number
+  y?: number
+  axes: Set<"x" | "y">
+}
+
+export const getRestrictedCenterLines = (params: {
+  pins: Array<InputPin & { chipId: string }>
+  inputProblem: InputProblem
+  pinIdMap: Map<PinId, ChipPin>
+  chipMap: Record<string, InputChip>
+}): Map<ChipId, RestrictedCenterLine> => {
+  const { pins, inputProblem, pinIdMap, chipMap } = params
+
+  // Determine set of related pin IDs (closure over directConnections) for both endpoints
+  const findAllDirectlyConnectedPins = (startPinId: string) => {
+    const visited = new Set<string>()
+    const queue: string[] = [startPinId]
+    visited.add(startPinId)
+    const directConns = inputProblem.directConnections || []
+    while (queue.length) {
+      const cur = queue.shift()!
+      for (const dc of directConns) {
+        if (dc.pinIds.includes(cur)) {
+          for (const p of dc.pinIds) {
+            if (!visited.has(p)) {
+              visited.add(p)
+              queue.push(p)
+            }
+          }
+        }
+      }
+    }
+    return visited
+  }
+
+  const p0 = pins[0].pinId
+  const p1 = pins[1].pinId
+  const relatedPinIds = new Set<string>([
+    ...findAllDirectlyConnectedPins(p0),
+    ...findAllDirectlyConnectedPins(p1),
+  ])
+
+  const restrictedCenterLines = new Map<ChipId, RestrictedCenterLine>()
+
+  // Collect facing-signs per chip
+  const chipFacingMap = new Map<
+    string,
+    {
+      hasXPos?: boolean
+      hasXNeg?: boolean
+      hasYPos?: boolean
+      hasYNeg?: boolean
+      center: { x: number; y: number }
+      counts?: { xPos: number; xNeg: number; yPos: number; yNeg: number }
+    }
+  >()
+
+  const chipsOfFacingPins = new Set<string>(pins.map((p) => p.chipId))
+
+  for (const pinId of relatedPinIds) {
+    const pin = pinIdMap.get(pinId)
+    if (!pin) continue
+    const chip = chipMap[pin.chipId]
+    if (!chip) continue
+    const facing = pin._facingDirection ?? getPinDirection(pin, chip)
+    let entry = chipFacingMap.get(chip.chipId)
+    if (!entry) {
+      entry = { center: chip.center }
+
+      const counts = { xPos: 0, xNeg: 0, yPos: 0, yNeg: 0 }
+      for (const cp of chip.pins) {
+        const cpFacing = cp._facingDirection ?? getPinDirection(cp, chip)
+        if (cpFacing === "x+") counts.xPos++
+        if (cpFacing === "x-") counts.xNeg++
+        if (cpFacing === "y+") counts.yPos++
+        if (cpFacing === "y-") counts.yNeg++
+      }
+      entry.counts = counts
+
+      chipFacingMap.set(chip.chipId, entry)
+    }
+    if (facing === "x+") entry.hasXPos = true
+    if (facing === "x-") entry.hasXNeg = true
+    if (facing === "y+") entry.hasYPos = true
+    if (facing === "y-") entry.hasYNeg = true
+  }
+
+  // Only mark a center as restricted on an axis if both signs for that axis
+  // are present among related pins on the chip.
+  for (const [chipId, faces] of chipFacingMap) {
+    const axes = new Set<"x" | "y">()
+    const rcl: RestrictedCenterLine = { axes }
+
+    // determine whether any side on this chip has more than one pin
+    const counts = faces.counts
+    const anySideHasMultiplePins = !!(
+      counts &&
+      (counts.xPos > 1 || counts.xNeg > 1 || counts.yPos > 1 || counts.yNeg > 1)
+    )
+
+    const skipCenterRestriction =
+      !anySideHasMultiplePins && chipsOfFacingPins.has(chipId)
+
+    if (!skipCenterRestriction) {
+      if (faces.hasXPos && faces.hasXNeg) {
+        rcl.x = faces.center.x
+        axes.add("x")
+      }
+      if (faces.hasYPos && faces.hasYNeg) {
+        rcl.y = faces.center.y
+        axes.add("y")
+      }
+    }
+
+    if (axes.size > 0) {
+      restrictedCenterLines.set(chipId, rcl)
+    }
+  }
+
+  return restrictedCenterLines
+}

package/package.json

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

package/site/SchematicTracePipelineSolver/SchematicTracePipelineSolver01.page.tsx

@@ -0,0 +1,143 @@
+import { GenericSolverDebugger } from "site/components/GenericSolverDebugger"
+import { useMemo } from "react"
+import type { InputProblem } from "lib/types/InputProblem"
+import { SchematicTracePipelineSolver } from "lib/index"
+
+const inputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: {
+        x: 0,
+        y: 0,
+      },
+      width: 2,
+      height: 1.4,
+      pins: [
+        {
+          pinId: "U3.8",
+          x: -1.4,
+          y: 0.42500000000000004,
+        },
+        {
+          pinId: "U3.4",
+          x: -1.4,
+          y: -0.42500000000000004,
+        },
+        {
+          pinId: "U3.1",
+          x: 1.4,
+          y: 0.5,
+        },
+        {
+          pinId: "U3.6",
+          x: 1.4,
+          y: 0.30000000000000004,
+        },
+        {
+          pinId: "U3.5",
+          x: 1.4,
+          y: 0.10000000000000009,
+        },
+        {
+          pinId: "U3.2",
+          x: 1.4,
+          y: -0.09999999999999998,
+        },
+        {
+          pinId: "U3.3",
+          x: 1.4,
+          y: -0.3,
+        },
+        {
+          pinId: "U3.7",
+          x: 1.4,
+          y: -0.5,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_1",
+      center: {
+        x: -2.3145833,
+        y: 0,
+      },
+      width: 0.5291665999999999,
+      height: 1.0583333000000001,
+      pins: [
+        {
+          pinId: "C20.1",
+          x: -2.3148566499999994,
+          y: 0.5512093000000002,
+        },
+        {
+          pinId: "C20.2",
+          x: -2.31430995,
+          y: -0.5512093000000002,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_2",
+      center: {
+        x: 1.7577928249999983,
+        y: 1.7512907000000002,
+      },
+      width: 0.3155856499999966,
+      height: 1.0583332999999997,
+      pins: [
+        {
+          pinId: "R11.1",
+          x: 1.7580660749999977,
+          y: 2.3025814000000002,
+        },
+        {
+          pinId: "R11.2",
+          x: 1.757519574999999,
+          y: 1.2,
+        },
+      ],
+    },
+  ],
+  directConnections: [
+    {
+      pinIds: ["C20.1", "U3.8"],
+      netId: "capacitor.C20 > port.pin1 to .U3 > .VDD",
+    },
+    {
+      pinIds: ["C20.2", "U3.4"],
+      netId: "capacitor.C20 > port.pin2 to .U3 > .GND",
+    },
+    {
+      pinIds: ["R11.2", "U3.1"],
+      netId: "resistor.R11 > port.pin2 to .U3 > .N_CS",
+    },
+  ],
+  netConnections: [
+    {
+      netId: "V3_3",
+      pinIds: ["U3.8", "U3.3", "U3.7", "C20.1", "R11.1"],
+    },
+    {
+      netId: "GND",
+      pinIds: ["U3.4", "C20.2"],
+    },
+    {
+      netId: "FLASH_N_CS",
+      pinIds: ["U3.1", "R11.2"],
+    },
+  ],
+  availableNetLabelOrientations: {
+    V3_3: ["y+"],
+    GND: ["y-"],
+  },
+  maxMspPairDistance: 5,
+} as InputProblem
+
+export default () => {
+  const solver = useMemo(
+    () => new SchematicTracePipelineSolver(inputProblem),
+    [],
+  )
+  return <GenericSolverDebugger solver={solver} />
+}