@tscircuit/schematic-trace-solver 0.0.28 → 0.0.30

package/dist/index.js

@@ -469,6 +469,68 @@ var dir = (facingDirection) => {
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/generateElbowVariants.ts
 var EPS = 1e-6;
 var MIN_LEN = 1e-6;
+var checkIfUTurnNeeded = (elbow) => {
+  if (elbow.length !== 4) return false;
+  const [start, p1, p2, end] = elbow;
+  const startOrient = orientationOf(start, p1);
+  const startFacing = startOrient === "horizontal" ? p1.x > start.x ? "x+" : "x-" : p1.y > start.y ? "y+" : "y-";
+  const endOrient = orientationOf(p2, end);
+  const endFacing = endOrient === "horizontal" ? end.x > p2.x ? "x+" : "x-" : end.y > p2.y ? "y+" : "y-";
+  if (startFacing === "x+" && end.x < p1.x - EPS) return true;
+  if (startFacing === "x-" && end.x > p1.x + EPS) return true;
+  if (startFacing === "y+" && end.y < p1.y - EPS) return true;
+  if (startFacing === "y-" && end.y > p1.y + EPS) return true;
+  if (endFacing === "x-" && p2.x > end.x + EPS && startFacing === "x+")
+    return true;
+  if (endFacing === "x+" && p2.x < end.x - EPS && startFacing === "x-")
+    return true;
+  if (endFacing === "y-" && p2.y > end.y + EPS && startFacing === "y+")
+    return true;
+  if (endFacing === "y+" && p2.y < end.y - EPS && startFacing === "y-")
+    return true;
+  return false;
+};
+var expandToUTurn = (elbow) => {
+  if (elbow.length !== 4) return elbow;
+  const [start, p1, p2, end] = elbow;
+  const overshoot = Math.max(
+    Math.abs(start.x - p1.x),
+    Math.abs(start.y - p1.y),
+    0.2
+    // minimum overshoot
+  );
+  const startOrient = orientationOf(start, p1);
+  const expanded = [{ ...start }];
+  if (startOrient === "horizontal") {
+    const startDir = p1.x > start.x ? 1 : -1;
+    expanded.push({ x: start.x + startDir * overshoot, y: start.y });
+    const verticalSpace = Math.max(
+      overshoot * 2,
+      Math.abs(end.y - start.y) + overshoot
+    );
+    const midY = end.y > start.y ? start.y - verticalSpace : start.y + verticalSpace;
+    expanded.push({ x: start.x + startDir * overshoot, y: midY });
+    const endOrient = orientationOf(p2, end);
+    const endApproachX = endOrient === "horizontal" ? end.x > p2.x ? end.x - overshoot : end.x + overshoot : end.x;
+    expanded.push({ x: endApproachX, y: midY });
+    expanded.push({ x: endApproachX, y: end.y });
+  } else {
+    const startDir = p1.y > start.y ? 1 : -1;
+    expanded.push({ x: start.x, y: start.y + startDir * overshoot });
+    const horizontalSpace = Math.max(
+      overshoot * 2,
+      Math.abs(end.x - start.x) + overshoot
+    );
+    const midX = end.x > start.x ? start.x - horizontalSpace : start.x + horizontalSpace;
+    expanded.push({ x: midX, y: start.y + startDir * overshoot });
+    const endOrient = orientationOf(p2, end);
+    const endApproachY = endOrient === "vertical" ? end.y > p2.y ? end.y - overshoot : end.y + overshoot : end.y;
+    expanded.push({ x: midX, y: endApproachY });
+    expanded.push({ x: end.x, y: endApproachY });
+  }
+  expanded.push({ ...end });
+  return expanded;
+};
 var isAxisAligned = (a, b) => Math.abs(a.x - b.x) < EPS || Math.abs(a.y - b.y) < EPS;
 var orientationOf = (a, b) => {
   const dx = Math.abs(a.x - b.x);
@@ -550,15 +612,20 @@ var generateElbowVariants = ({
   const elbow = preprocessElbow(baseElbow);
   assertOrthogonalPolyline(elbow);
   const nPts = elbow.length;
-  const nSegs = nPts - 1;
-  if (nSegs < 5) {
+  if (nPts < 4) {
     return {
       elbowVariants: [elbow.map((p) => ({ ...p }))],
       movableSegments: []
     };
+  } else if (nPts === 4) {
+    const needsUTurn = checkIfUTurnNeeded(elbow);
+    if (needsUTurn) {
+      const expandedElbow = expandToUTurn(elbow);
+      return generateElbowVariants({ baseElbow: expandedElbow, guidelines });
+    }
   }
-  const firstMovableIndex = 2;
-  const lastMovableIndex = nPts - 4;
+  const firstMovableIndex = 1;
+  const lastMovableIndex = nPts - 3;
   const movableSegments = [];
   const movableIdx = [];
   const axes = [];
@@ -1427,10 +1494,11 @@ function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex)
     const pts = solved.tracePath;
     for (let i = 0; i < pts.length - 1; i++) {
       if (pairId === hostPathId && i === hostSegIndex) continue;
-      if (segmentIntersectsRect(pts[i], pts[i + 1], bounds)) return true;
+      if (segmentIntersectsRect(pts[i], pts[i + 1], bounds))
+        return { hasIntersection: true, mspPairId: pairId, segIndex: i };
     }
   }
-  return false;
+  return { hasIntersection: false };
 }
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/host.ts
@@ -1515,14 +1583,16 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
     };
   }
   let pin = null;
+  let pinFacingDirection = null;
   for (const chip of inputProblem.chips) {
     const p = chip.pins.find((pp) => pp.pinId === pinId);
     if (p) {
       pin = { x: p.x, y: p.y };
+      pinFacingDirection = p._facingDirection || getPinDirection(p, chip);
       break;
     }
   }
-  if (!pin) {
+  if (!pin || !pinFacingDirection) {
     return {
       placement: null,
       testedCandidates: [],
@@ -1534,21 +1604,21 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
   const outwardOf = (o) => o === "x+" ? { x: 1, y: 0 } : o === "x-" ? { x: -1, y: 0 } : o === "y+" ? { x: 0, y: 1 } : { x: 0, y: -1 };
   const testedCandidates = [];
   for (const orientation of orientations) {
-    const { width, height } = getDimsForOrientation(orientation);
-    const baseCenter = getCenterFromAnchor(anchor, orientation, width, height);
-    const outward = outwardOf(orientation);
-    const offset = 1e-3;
+    const { width: width2, height: height2 } = getDimsForOrientation(orientation);
+    const baseCenter2 = getCenterFromAnchor(anchor, orientation, width2, height2);
+    const outward2 = outwardOf(orientation);
+    const offset2 = 1e-3;
     const center = {
-      x: baseCenter.x + outward.x * offset,
-      y: baseCenter.y + outward.y * offset
+      x: baseCenter2.x + outward2.x * offset2,
+      y: baseCenter2.y + outward2.y * offset2
     };
-    const bounds = getRectBounds(center, width, height);
+    const bounds = getRectBounds(center, width2, height2);
     const chips = chipObstacleSpatialIndex.getChipsInBounds(bounds);
     if (chips.length > 0) {
       testedCandidates.push({
         center,
-        width,
-        height,
+        width: width2,
+        height: height2,
         bounds,
         anchor,
         orientation,
@@ -1557,16 +1627,17 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
       });
       continue;
     }
-    if (rectIntersectsAnyTrace(
+    const traceIntersectionResult = rectIntersectsAnyTrace(
       bounds,
       inputTraceMap,
       "",
       -1
-    )) {
+    );
+    if (traceIntersectionResult.hasIntersection) {
       testedCandidates.push({
         center,
-        width,
-        height,
+        width: width2,
+        height: height2,
         bounds,
         anchor,
         orientation,
@@ -1577,8 +1648,8 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
     }
     testedCandidates.push({
       center,
-      width,
-      height,
+      width: width2,
+      height: height2,
       bounds,
       anchor,
       orientation,
@@ -1593,17 +1664,39 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
       pinIds: [pinId],
       orientation,
       anchorPoint: anchor,
-      width,
-      height,
+      width: width2,
+      height: height2,
       center
     };
     return { placement, testedCandidates };
   }
-  return {
-    placement: null,
-    testedCandidates,
-    error: "Could not place net label at port without collisions"
+  const fallbackOrientation = pinFacingDirection;
+  const { width, height } = getDimsForOrientation(fallbackOrientation);
+  const baseCenter = getCenterFromAnchor(
+    anchor,
+    fallbackOrientation,
+    width,
+    height
+  );
+  const outward = outwardOf(fallbackOrientation);
+  const offset = 1e-3;
+  const fallbackCenter = {
+    x: baseCenter.x + outward.x * offset,
+    y: baseCenter.y + outward.y * offset
+  };
+  const fallbackPlacement = {
+    globalConnNetId: overlappingSameNetTraceGroup.globalConnNetId,
+    dcConnNetId: void 0,
+    netId: overlappingSameNetTraceGroup.netId,
+    mspConnectionPairIds: [],
+    pinIds: [pinId],
+    orientation: fallbackOrientation,
+    anchorPoint: anchor,
+    width,
+    height,
+    center: fallbackCenter
   };
+  return { placement: fallbackPlacement, testedCandidates };
 }
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver_visualize.ts
@@ -1619,12 +1712,11 @@ function visualizeSingleNetLabelPlacementSolver(solver) {
   const groupStroke = getColorFromString(groupId, 0.9);
   const groupFill = getColorFromString(groupId, 0.5);
   for (const trace of Object.values(solver.inputTraceMap)) {
-    if (trace.globalConnNetId !== groupId) continue;
     const isHost = host ? trace.mspPairId === host.mspPairId : false;
     graphics.lines.push({
-      points: trace.tracePath,
-      strokeColor: isHost ? groupStroke : groupFill,
-      strokeDash: isHost ? void 0 : "4 2"
+      points: trace.tracePath
+      // strokeColor: isHost ? groupStroke : groupFill,
+      // strokeDash: isHost ? undefined : "4 2",
     });
   }
   for (const c of solver.testedCandidates) {
@@ -1796,12 +1888,13 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
               });
               continue;
             }
-            if (rectIntersectsAnyTrace(
+            const traceIntersectionResult = rectIntersectsAnyTrace(
               bounds,
               this.inputTraceMap,
               curr.mspPairId,
               si
-            )) {
+            );
+            if (traceIntersectionResult.hasIntersection) {
               this.testedCandidates.push({
                 center: testCenter,
                 width,

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

@@ -261,14 +261,13 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
             }
 
             // Trace collision check (ignore the host segment)
-            if (
-              rectIntersectsAnyTrace(
-                bounds,
-                this.inputTraceMap,
-                curr.mspPairId,
-                si,
-              )
-            ) {
+            const traceIntersectionResult = rectIntersectsAnyTrace(
+              bounds,
+              this.inputTraceMap,
+              curr.mspPairId,
+              si,
+            )
+            if (traceIntersectionResult.hasIntersection) {
               this.testedCandidates.push({
                 center: testCenter,
                 width,

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

@@ -21,12 +21,11 @@ export function visualizeSingleNetLabelPlacementSolver(
   const groupFill = getColorFromString(groupId, 0.5)
 
   for (const trace of Object.values(solver.inputTraceMap)) {
-    if (trace.globalConnNetId !== groupId) continue
     const isHost = host ? trace.mspPairId === host.mspPairId : false
     graphics.lines!.push({
       points: trace.tracePath,
-      strokeColor: isHost ? groupStroke : groupFill,
-      strokeDash: isHost ? undefined : "4 2",
+      // strokeColor: isHost ? groupStroke : groupFill,
+      // strokeDash: isHost ? undefined : "4 2",
     } as any)
   }
 

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

@@ -33,13 +33,20 @@ export function rectIntersectsAnyTrace(
   inputTraceMap: Record<MspConnectionPairId, SolvedTracePath>,
   hostPathId?: MspConnectionPairId,
   hostSegIndex?: number,
-): boolean {
+):
+  | {
+      hasIntersection: true
+      mspPairId: MspConnectionPairId
+      segIndex: number
+    }
+  | { hasIntersection: false } {
   for (const [pairId, solved] of Object.entries(inputTraceMap)) {
     const pts = solved.tracePath
     for (let i = 0; i < pts.length - 1; i++) {
       if (pairId === hostPathId && i === hostSegIndex) continue
-      if (segmentIntersectsRect(pts[i]!, pts[i + 1]!, bounds)) return true
+      if (segmentIntersectsRect(pts[i]!, pts[i + 1]!, bounds))
+        return { hasIntersection: true, mspPairId: pairId, segIndex: i }
     }
   }
-  return false
+  return { hasIntersection: false }
 }

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

@@ -3,6 +3,7 @@ import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/Ms
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { FacingDirection } from "lib/utils/dir"
 import { ChipObstacleSpatialIndex } from "lib/data-structures/ChipObstacleSpatialIndex"
+import { getPinDirection } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
 import type {
   NetLabelPlacement,
   OverlappingSameNetTraceGroup,
@@ -51,16 +52,18 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
     }
   }
 
-  // Find pin coordinates
+  // Find pin coordinates and facing direction
   let pin: { x: number; y: number } | null = null
+  let pinFacingDirection: FacingDirection | null = null
   for (const chip of inputProblem.chips) {
     const p = chip.pins.find((pp) => pp.pinId === pinId)
     if (p) {
       pin = { x: p.x, y: p.y }
+      pinFacingDirection = p._facingDirection || getPinDirection(p, chip)
       break
     }
   }
-  if (!pin) {
+  if (!pin || !pinFacingDirection) {
     return {
       placement: null,
       testedCandidates: [],
@@ -123,14 +126,13 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
     }
 
     // Trace collision check
-    if (
-      rectIntersectsAnyTrace(
-        bounds,
-        inputTraceMap,
-        "" as MspConnectionPairId,
-        -1,
-      )
-    ) {
+    const traceIntersectionResult = rectIntersectsAnyTrace(
+      bounds,
+      inputTraceMap,
+      "" as MspConnectionPairId,
+      -1,
+    )
+    if (traceIntersectionResult.hasIntersection) {
       testedCandidates.push({
         center,
         width,
@@ -172,9 +174,34 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
     return { placement, testedCandidates }
   }
 
-  return {
-    placement: null,
-    testedCandidates,
-    error: "Could not place net label at port without collisions",
+  // If no valid placements found, return placement using pin's facing direction
+  const fallbackOrientation = pinFacingDirection
+  const { width, height } = getDimsForOrientation(fallbackOrientation)
+  const baseCenter = getCenterFromAnchor(
+    anchor,
+    fallbackOrientation,
+    width,
+    height,
+  )
+  const outward = outwardOf(fallbackOrientation)
+  const offset = 1e-3
+  const fallbackCenter = {
+    x: baseCenter.x + outward.x * offset,
+    y: baseCenter.y + outward.y * offset,
   }
+
+  const fallbackPlacement: NetLabelPlacement = {
+    globalConnNetId: overlappingSameNetTraceGroup.globalConnNetId,
+    dcConnNetId: undefined,
+    netId: overlappingSameNetTraceGroup.netId,
+    mspConnectionPairIds: [],
+    pinIds: [pinId],
+    orientation: fallbackOrientation,
+    anchorPoint: anchor,
+    width,
+    height,
+    center: fallbackCenter,
+  }
+
+  return { placement: fallbackPlacement, testedCandidates }
 }

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

@@ -14,6 +14,123 @@ export interface MovableSegment {
 const EPS = 1e-6 // numeric tolerance for equality
 const MIN_LEN = 1e-6 // forbid near-zero length segments (adjacent collapses)
 
+const checkIfUTurnNeeded = (elbow: Point[]): boolean => {
+  if (elbow.length !== 4) return false
+
+  const [start, p1, p2, end] = elbow
+
+  // Determine facing directions from the path segments
+  const startOrient = orientationOf(start, p1)
+  const startFacing: FacingDirection =
+    startOrient === "horizontal"
+      ? p1.x > start.x
+        ? "x+"
+        : "x-"
+      : p1.y > start.y
+        ? "y+"
+        : "y-"
+
+  const endOrient = orientationOf(p2, end)
+  const endFacing: FacingDirection =
+    endOrient === "horizontal"
+      ? end.x > p2.x
+        ? "x+"
+        : "x-"
+      : end.y > p2.y
+        ? "y+"
+        : "y-"
+
+  // Check if path overshoots and needs to turn back
+  if (startFacing === "x+" && end.x < p1.x - EPS) return true
+  if (startFacing === "x-" && end.x > p1.x + EPS) return true
+  if (startFacing === "y+" && end.y < p1.y - EPS) return true
+  if (startFacing === "y-" && end.y > p1.y + EPS) return true
+
+  // Check if path segments conflict (p2 is past the end in the facing direction)
+  if (endFacing === "x-" && p2.x > end.x + EPS && startFacing === "x+")
+    return true
+  if (endFacing === "x+" && p2.x < end.x - EPS && startFacing === "x-")
+    return true
+  if (endFacing === "y-" && p2.y > end.y + EPS && startFacing === "y+")
+    return true
+  if (endFacing === "y+" && p2.y < end.y - EPS && startFacing === "y-")
+    return true
+
+  return false
+}
+
+const expandToUTurn = (elbow: Point[]): Point[] => {
+  if (elbow.length !== 4) return elbow
+
+  const [start, p1, p2, end] = elbow
+
+  // Calculate overshoot distance from existing segments
+  const overshoot = Math.max(
+    Math.abs(start.x - p1.x),
+    Math.abs(start.y - p1.y),
+    0.2, // minimum overshoot
+  )
+
+  const startOrient = orientationOf(start, p1)
+  const expanded: Point[] = [{ ...start }]
+
+  if (startOrient === "horizontal") {
+    const startDir = p1.x > start.x ? 1 : -1
+    expanded.push({ x: start.x + startDir * overshoot, y: start.y })
+
+    // Move away vertically to create space for U-turn
+    const verticalSpace = Math.max(
+      overshoot * 2,
+      Math.abs(end.y - start.y) + overshoot,
+    )
+    const midY =
+      end.y > start.y ? start.y - verticalSpace : start.y + verticalSpace
+
+    expanded.push({ x: start.x + startDir * overshoot, y: midY })
+
+    // Approach end from its required direction
+    const endOrient = orientationOf(p2, end)
+    const endApproachX =
+      endOrient === "horizontal"
+        ? end.x > p2.x
+          ? end.x - overshoot
+          : end.x + overshoot
+        : end.x
+
+    expanded.push({ x: endApproachX, y: midY })
+    expanded.push({ x: endApproachX, y: end.y })
+  } else {
+    // Vertical start
+    const startDir = p1.y > start.y ? 1 : -1
+    expanded.push({ x: start.x, y: start.y + startDir * overshoot })
+
+    // Move away horizontally to create space for U-turn
+    const horizontalSpace = Math.max(
+      overshoot * 2,
+      Math.abs(end.x - start.x) + overshoot,
+    )
+    const midX =
+      end.x > start.x ? start.x - horizontalSpace : start.x + horizontalSpace
+
+    expanded.push({ x: midX, y: start.y + startDir * overshoot })
+
+    // Approach end from its required direction
+    const endOrient = orientationOf(p2, end)
+    const endApproachY =
+      endOrient === "vertical"
+        ? end.y > p2.y
+          ? end.y - overshoot
+          : end.y + overshoot
+        : end.y
+
+    expanded.push({ x: midX, y: endApproachY })
+    expanded.push({ x: end.x, y: endApproachY })
+  }
+
+  expanded.push({ ...end })
+  return expanded
+}
+
 /** True if segment [a,b] is axis-aligned (horizontal or vertical). */
 const isAxisAligned = (a: Point, b: Point): boolean =>
   Math.abs(a.x - b.x) < EPS || Math.abs(a.y - b.y) < EPS
@@ -155,21 +272,27 @@ export const generateElbowVariants = ({
   assertOrthogonalPolyline(elbow)
 
   const nPts = elbow.length
-  const nSegs = nPts - 1
 
   // No interior segments to move if path is too short.
-  if (nSegs < 5) {
+  if (nPts < 4) {
     return {
       elbowVariants: [elbow.map((p) => ({ ...p }))],
       movableSegments: [],
     }
+  } else if (nPts === 4) {
+    const needsUTurn = checkIfUTurnNeeded(elbow)
+    if (needsUTurn) {
+      const expandedElbow = expandToUTurn(elbow)
+      // Recursively call with the expanded path
+      return generateElbowVariants({ baseElbow: expandedElbow, guidelines })
+    }
   }
 
   // 2) Choose which segments are allowed to move.
-  //    We avoid segments adjacent to the first and last segment:
-  //    movable indices i in [2 .. (nPts - 4)] inclusive (segment i connects P[i] -> P[i+1]).
-  const firstMovableIndex = 2
-  const lastMovableIndex = nPts - 4
+  //    We avoid moving the very first and last segments of the:
+  //    movable indices i in [1 .. (nPts - 3)] inclusive (segment i connects P[i] -> P[i+1]).
+  const firstMovableIndex = 1
+  const lastMovableIndex = nPts - 3
 
   const movableSegments: MovableSegment[] = []
   const movableIdx: number[] = []

package/package.json

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

package/site/examples/example08.page.tsx

@@ -88,7 +88,7 @@ export const inputProblem: InputProblem = {
   ],
   netConnections: [],
   availableNetLabelOrientations: {},
-  maxMspPairDistance: 2,
+  maxMspPairDistance: 5,
 }
 
 export default () => <PipelineDebugger inputProblem={inputProblem} />