@tscircuit/schematic-trace-solver 0.0.199 → 0.0.201

package/dist/index.js

@@ -13243,6 +13243,52 @@ var getUnconnectedPins = ({
   );
   return connectionPair.pins.filter((pin) => !connectedPinIds.has(pin.pinId));
 };
+var pathsIntersect = (firstPath, secondPath) => {
+  for (let firstIndex = 0; firstIndex < firstPath.length - 1; firstIndex++) {
+    for (let secondIndex = 0; secondIndex < secondPath.length - 1; secondIndex++) {
+      if (doSegmentsIntersect3(
+        firstPath[firstIndex],
+        firstPath[firstIndex + 1],
+        secondPath[secondIndex],
+        secondPath[secondIndex + 1]
+      )) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+var connectionPairPinsAreAlreadyConnected = ({
+  connectionPair,
+  sameNetTraces
+}) => {
+  const [firstPin, secondPin] = connectionPair.pins;
+  const connectedTraceIndexes = new Set(
+    sameNetTraces.flatMap(
+      (trace, index) => trace.pinIds.includes(firstPin.pinId) ? [index] : []
+    )
+  );
+  let previousSize = -1;
+  while (connectedTraceIndexes.size !== previousSize) {
+    previousSize = connectedTraceIndexes.size;
+    for (let traceIndex = 0; traceIndex < sameNetTraces.length; traceIndex++) {
+      if (connectedTraceIndexes.has(traceIndex)) continue;
+      const trace = sameNetTraces[traceIndex];
+      const connectsToComponent = [...connectedTraceIndexes].some(
+        (connectedTraceIndex) => {
+          const connectedTrace = sameNetTraces[connectedTraceIndex];
+          return trace.pinIds.some(
+            (pinId) => connectedTrace.pinIds.includes(pinId)
+          ) || pathsIntersect(trace.tracePath, connectedTrace.tracePath);
+        }
+      );
+      if (connectsToComponent) connectedTraceIndexes.add(traceIndex);
+    }
+  }
+  return [...connectedTraceIndexes].some(
+    (traceIndex) => sameNetTraces[traceIndex].pinIds.includes(secondPin.pinId)
+  );
+};
 var getJunctionCandidates = ({
   connectionPair,
   sameNetTraces,
@@ -13507,6 +13553,12 @@ var UnroutedTraceRecoverySolver = class extends BaseSolver {
     const sameNetTraces = existingTraces.filter(
       (trace) => trace.globalConnNetId === connectionPair.globalConnNetId
     );
+    if (connectionPairPinsAreAlreadyConnected({
+      connectionPair,
+      sameNetTraces
+    })) {
+      return;
+    }
     const junctionCandidates = getJunctionCandidates({
       connectionPair,
       sameNetTraces,
@@ -14519,7 +14571,7 @@ var getAlignedAttachedLabelConnectorPath = ({
   const reverseCandidate = findCandidate([...forwardPath].reverse());
   return reverseCandidate ? reverseCandidate.reverse() : null;
 };
-var pathsIntersect = (firstPath, secondPath) => {
+var pathsIntersect2 = (firstPath, secondPath) => {
   if (firstPath.some((point) => tracePathContainsPoint(secondPath, point)) || secondPath.some((point) => tracePathContainsPoint(firstPath, point))) {
     return true;
   }
@@ -14546,7 +14598,7 @@ var preserveAttachedTraceJunctions = ({
     (trace) => trace.mspPairId === originalTrace.mspPairId ? candidateTrace : trace
   );
   for (const connector of traces) {
-    if (connector.mspPairId === originalTrace.mspPairId || connector.globalConnNetId !== originalTrace.globalConnNetId || !pathsIntersect(originalTrace.tracePath, connector.tracePath) || pathsIntersect(candidateTrace.tracePath, connector.tracePath)) {
+    if (connector.mspPairId === originalTrace.mspPairId || connector.globalConnNetId !== originalTrace.globalConnNetId || !pathsIntersect2(originalTrace.tracePath, connector.tracePath) || pathsIntersect2(candidateTrace.tracePath, connector.tracePath)) {
       continue;
     }
     const endpointIndex = [0, connector.tracePath.length - 1].find(
@@ -14579,7 +14631,7 @@ var preserveAttachedTraceJunctions = ({
         (point, index) => index === endpointIndex ? movedJunction : point
       )
     };
-    if (!pathsIntersect(candidateTrace.tracePath, movedConnector.tracePath)) {
+    if (!pathsIntersect2(candidateTrace.tracePath, movedConnector.tracePath)) {
       return null;
     }
     outputTraces = outputTraces.map(
@@ -15107,6 +15159,38 @@ var placeGroundRailLabelsAtOuterEnd = ({
   return output;
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/shortenSameSideRailToLabelAnchor.ts
+var MAX_LOCAL_RAIL_SHIFT = 0.5;
+var MIN_ESCAPE_LENGTH = 1;
+var shortenSameSideRailToLabelAnchor = ({
+  traces,
+  netLabelPlacements
+}) => traces.map((trace) => {
+  const path = trace.tracePath;
+  const firstPin = path[0];
+  const secondPin = path.at(-1);
+  if (!firstPin || !secondPin || !nearlyEqual(firstPin.x, secondPin.x)) {
+    return trace;
+  }
+  const railIndex = path.findIndex(
+    (point, index) => index > 0 && index < path.length - 2 && isHorizontal2(path[index - 1], point) && isVertical2(point, path[index + 1]) && isHorizontal2(path[index + 1], path[index + 2])
+  );
+  if (railIndex < 0) return trace;
+  const firstRail = path[railIndex];
+  const secondRail = path[railIndex + 1];
+  const escapeLength = Math.abs(firstRail.x - firstPin.x);
+  const label = netLabelPlacements.find(
+    ({ anchorPoint, orientation, mspConnectionPairIds }) => mspConnectionPairIds.includes(trace.mspPairId) && (orientation === "y-" && anchorPoint.y < Math.min(firstPin.y, secondPin.y) || orientation === "y+" && anchorPoint.y > Math.max(firstPin.y, secondPin.y)) && anchorPoint.x >= Math.min(firstPin.x, firstRail.x) && anchorPoint.x <= Math.max(firstPin.x, firstRail.x) && Math.abs(anchorPoint.x - firstPin.x) < escapeLength && Math.abs(anchorPoint.x - firstRail.x) <= MAX_LOCAL_RAIL_SHIFT && escapeLength >= MIN_ESCAPE_LENGTH
+  );
+  if (!label) return trace;
+  return {
+    ...trace,
+    tracePath: path.map(
+      (point, index) => index === railIndex || index === railIndex + 1 ? { ...point, x: label.anchorPoint.x } : point
+    )
+  };
+});
+
 // lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts
 var SameNetJunctionAlignmentSolver = class extends BaseSolver {
   input;
@@ -15120,10 +15204,13 @@ var SameNetJunctionAlignmentSolver = class extends BaseSolver {
   }
   _step() {
     const alignment = alignSameNetJunctions(this.input);
-    this.outputTraces = alignment.traces;
+    this.outputTraces = shortenSameSideRailToLabelAnchor({
+      traces: alignment.traces,
+      netLabelPlacements: alignment.netLabelPlacements
+    });
     this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
       inputProblem: this.input.inputProblem,
-      traces: alignment.traces,
+      traces: this.outputTraces,
       netLabelPlacements: alignment.netLabelPlacements
     });
     this.stats.alignedJunctionCount = alignment.alignedJunctionCount;

package/lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts

@@ -8,6 +8,7 @@ import type { InputProblem } from "lib/types/InputProblem"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { alignSameNetJunctions } from "./alignSameNetJunctions"
 import { placeGroundRailLabelsAtOuterEnd } from "./placeGroundRailLabelsAtOuterEnd"
+import { shortenSameSideRailToLabelAnchor } from "./shortenSameSideRailToLabelAnchor"
 
 interface SameNetJunctionAlignmentSolverInput {
   inputProblem: InputProblem
@@ -31,10 +32,13 @@ export class SameNetJunctionAlignmentSolver extends BaseSolver {
 
   override _step() {
     const alignment = alignSameNetJunctions(this.input)
-    this.outputTraces = alignment.traces
+    this.outputTraces = shortenSameSideRailToLabelAnchor({
+      traces: alignment.traces,
+      netLabelPlacements: alignment.netLabelPlacements,
+    })
     this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
       inputProblem: this.input.inputProblem,
-      traces: alignment.traces,
+      traces: this.outputTraces,
       netLabelPlacements: alignment.netLabelPlacements,
     })
     this.stats.alignedJunctionCount = alignment.alignedJunctionCount

package/lib/solvers/SameNetJunctionAlignmentSolver/shortenSameSideRailToLabelAnchor.ts

@@ -0,0 +1,62 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  isHorizontal,
+  isVertical,
+  nearlyEqual,
+} from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
+
+const MAX_LOCAL_RAIL_SHIFT = 0.5
+const MIN_ESCAPE_LENGTH = 1
+
+export const shortenSameSideRailToLabelAnchor = ({
+  traces,
+  netLabelPlacements,
+}: {
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}) =>
+  traces.map((trace) => {
+    const path = trace.tracePath
+    const firstPin = path[0]
+    const secondPin = path.at(-1)
+    if (!firstPin || !secondPin || !nearlyEqual(firstPin.x, secondPin.x)) {
+      return trace
+    }
+
+    const railIndex = path.findIndex(
+      (point, index) =>
+        index > 0 &&
+        index < path.length - 2 &&
+        isHorizontal(path[index - 1]!, point) &&
+        isVertical(point, path[index + 1]!) &&
+        isHorizontal(path[index + 1]!, path[index + 2]!),
+    )
+    if (railIndex < 0) return trace
+    const firstRail = path[railIndex]!
+    const secondRail = path[railIndex + 1]!
+    const escapeLength = Math.abs(firstRail.x - firstPin.x)
+    const label = netLabelPlacements.find(
+      ({ anchorPoint, orientation, mspConnectionPairIds }) =>
+        mspConnectionPairIds.includes(trace.mspPairId) &&
+        ((orientation === "y-" &&
+          anchorPoint.y < Math.min(firstPin.y, secondPin.y)) ||
+          (orientation === "y+" &&
+            anchorPoint.y > Math.max(firstPin.y, secondPin.y))) &&
+        anchorPoint.x >= Math.min(firstPin.x, firstRail.x) &&
+        anchorPoint.x <= Math.max(firstPin.x, firstRail.x) &&
+        Math.abs(anchorPoint.x - firstPin.x) < escapeLength &&
+        Math.abs(anchorPoint.x - firstRail.x) <= MAX_LOCAL_RAIL_SHIFT &&
+        escapeLength >= MIN_ESCAPE_LENGTH,
+    )
+    if (!label) return trace
+
+    return {
+      ...trace,
+      tracePath: path.map((point, index) =>
+        index === railIndex || index === railIndex + 1
+          ? { ...point, x: label.anchorPoint.x }
+          : point,
+      ),
+    }
+  })

package/lib/solvers/UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver.ts

@@ -204,6 +204,67 @@ const getUnconnectedPins = ({
   return connectionPair.pins.filter((pin) => !connectedPinIds.has(pin.pinId))
 }
 
+const pathsIntersect = (firstPath: Point[], secondPath: Point[]): boolean => {
+  for (let firstIndex = 0; firstIndex < firstPath.length - 1; firstIndex++) {
+    for (
+      let secondIndex = 0;
+      secondIndex < secondPath.length - 1;
+      secondIndex++
+    ) {
+      if (
+        doSegmentsIntersect(
+          firstPath[firstIndex]!,
+          firstPath[firstIndex + 1]!,
+          secondPath[secondIndex]!,
+          secondPath[secondIndex + 1]!,
+        )
+      ) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+const connectionPairPinsAreAlreadyConnected = ({
+  connectionPair,
+  sameNetTraces,
+}: {
+  connectionPair: MspConnectionPair
+  sameNetTraces: SolvedTracePath[]
+}): boolean => {
+  const [firstPin, secondPin] = connectionPair.pins
+  const connectedTraceIndexes = new Set(
+    sameNetTraces.flatMap((trace, index) =>
+      trace.pinIds.includes(firstPin.pinId) ? [index] : [],
+    ),
+  )
+
+  let previousSize = -1
+  while (connectedTraceIndexes.size !== previousSize) {
+    previousSize = connectedTraceIndexes.size
+    for (let traceIndex = 0; traceIndex < sameNetTraces.length; traceIndex++) {
+      if (connectedTraceIndexes.has(traceIndex)) continue
+      const trace = sameNetTraces[traceIndex]!
+      const connectsToComponent = [...connectedTraceIndexes].some(
+        (connectedTraceIndex) => {
+          const connectedTrace = sameNetTraces[connectedTraceIndex]!
+          return (
+            trace.pinIds.some((pinId) =>
+              connectedTrace.pinIds.includes(pinId),
+            ) || pathsIntersect(trace.tracePath, connectedTrace.tracePath)
+          )
+        },
+      )
+      if (connectsToComponent) connectedTraceIndexes.add(traceIndex)
+    }
+  }
+
+  return [...connectedTraceIndexes].some((traceIndex) =>
+    sameNetTraces[traceIndex]!.pinIds.includes(secondPin.pinId),
+  )
+}
+
 const getJunctionCandidates = ({
   connectionPair,
   sameNetTraces,
@@ -552,6 +613,14 @@ export class UnroutedTraceRecoverySolver extends BaseSolver {
     const sameNetTraces = existingTraces.filter(
       (trace) => trace.globalConnNetId === connectionPair.globalConnNetId,
     )
+    if (
+      connectionPairPinsAreAlreadyConnected({
+        connectionPair,
+        sameNetTraces,
+      })
+    ) {
+      return
+    }
     const junctionCandidates = getJunctionCandidates({
       connectionPair,
       sameNetTraces,

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/tscircuit/schematic-trace-solver.git"
   },
   "main": "dist/index.js",
-  "version": "0.0.199",
+  "version": "0.0.201",
   "type": "module",
   "scripts": {
     "start": "cosmos",