@tscircuit/schematic-trace-solver 0.0.165 → 0.0.166

package/dist/index.js

@@ -13009,6 +13009,214 @@ var alignSameNetJunctions = ({
   };
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/collapseSameNetCycles.ts
+import { getSegmentIntersection as getSegmentIntersection4 } from "@tscircuit/math-utils/line-intersections";
+var TRACE_LENGTH_EPSILON = 1e-6;
+var getTracePathStartingAtPin = (trace, pin) => {
+  const pathStart = trace.tracePath[0];
+  const pathEnd = trace.tracePath.at(-1);
+  if (!pathStart || !pathEnd) return null;
+  if (pointsEqual(pathStart, pin)) return trace.tracePath;
+  if (pointsEqual(pathEnd, pin)) return [...trace.tracePath].reverse();
+  return null;
+};
+var getPerpendicularPathCrossings = (targetPath, donorPath) => {
+  const crossings = [];
+  const sharedEndpoint = targetPath[0];
+  for (let targetSegmentIndex = 0; targetSegmentIndex < targetPath.length - 1; targetSegmentIndex++) {
+    const targetStart = targetPath[targetSegmentIndex];
+    const targetEnd = targetPath[targetSegmentIndex + 1];
+    const targetOrientation = getRailOrientation(targetStart, targetEnd);
+    if (!targetOrientation) continue;
+    for (let donorSegmentIndex = 0; donorSegmentIndex < donorPath.length - 1; donorSegmentIndex++) {
+      const donorStart = donorPath[donorSegmentIndex];
+      const donorEnd = donorPath[donorSegmentIndex + 1];
+      const donorOrientation = getRailOrientation(donorStart, donorEnd);
+      if (!donorOrientation || donorOrientation === targetOrientation) continue;
+      const intersectionPoint = getSegmentIntersection4(
+        targetStart,
+        targetEnd,
+        donorStart,
+        donorEnd
+      );
+      if (!intersectionPoint || pointsEqual(intersectionPoint, sharedEndpoint)) {
+        continue;
+      }
+      crossings.push({
+        intersectionPoint,
+        targetSegmentIndex,
+        donorSegmentIndex
+      });
+    }
+  }
+  return crossings;
+};
+var buildCollapsedCyclePath = ({
+  targetTrace,
+  targetPath,
+  donorPath,
+  crossing
+}) => {
+  const pathFromSharedPin = simplifyPath([
+    ...donorPath.slice(0, crossing.donorSegmentIndex + 1),
+    crossing.intersectionPoint,
+    ...targetPath.slice(crossing.targetSegmentIndex + 1)
+  ]);
+  if (pointsEqual(targetTrace.tracePath[0], targetPath[0])) {
+    return pathFromSharedPin;
+  }
+  return pathFromSharedPin.reverse();
+};
+var getNetLabelPlacementsForCycleCollapse = ({
+  targetTrace,
+  tracePath,
+  netLabelPlacements
+}) => {
+  const candidateNetLabelPlacements = moveAttachedLabelsToReroutedTrace({
+    trace: targetTrace,
+    originalTracePath: targetTrace.tracePath,
+    reroutedTracePath: tracePath,
+    netLabelPlacements
+  });
+  for (let labelIndex = 0; labelIndex < netLabelPlacements.length; labelIndex++) {
+    const label = netLabelPlacements[labelIndex];
+    if (label.globalConnNetId !== targetTrace.globalConnNetId) continue;
+    if (!tracePathContainsPoint(targetTrace.tracePath, label.anchorPoint)) {
+      continue;
+    }
+    const candidateLabel = candidateNetLabelPlacements[labelIndex];
+    if (!tracePathContainsPoint(tracePath, candidateLabel.anchorPoint)) {
+      return null;
+    }
+  }
+  const otherNetLabelPlacements = candidateNetLabelPlacements.filter(
+    (label) => label.globalConnNetId !== targetTrace.globalConnNetId
+  );
+  if (pathIntersectsAnyNetLabel({
+    path: tracePath,
+    netLabelPlacements: otherNetLabelPlacements
+  })) {
+    return null;
+  }
+  const sameNetLabelPlacements = candidateNetLabelPlacements.filter(
+    (label) => label.globalConnNetId === targetTrace.globalConnNetId
+  );
+  if (pathEntersAnyNetLabel({
+    path: tracePath,
+    netLabelPlacements: sameNetLabelPlacements
+  })) {
+    return null;
+  }
+  return candidateNetLabelPlacements;
+};
+var candidateIsBetter = (candidate, bestCandidate) => {
+  if (!bestCandidate) return true;
+  const visibleLengthDelta = candidate.netVisibleLength - bestCandidate.netVisibleLength;
+  if (Math.abs(visibleLengthDelta) > TRACE_LENGTH_EPSILON) {
+    return visibleLengthDelta < 0;
+  }
+  return candidate.netVisibleSegmentCount < bestCandidate.netVisibleSegmentCount;
+};
+var getBestCycleCollapseCandidate = ({
+  targetTrace,
+  traces,
+  netLabelPlacements
+}) => {
+  const sameNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId === targetTrace.globalConnNetId
+  );
+  const baselineNetVisibleLength = getVisibleTraceLength(sameNetTraces);
+  const baselineTargetVisibleLength = getVisibleTraceLength([targetTrace]);
+  let bestCandidate = null;
+  for (const donorTrace of sameNetTraces) {
+    if (donorTrace.mspPairId === targetTrace.mspPairId) continue;
+    const sharedPin = getSharedPin({
+      donorTrace,
+      branchTrace: targetTrace
+    });
+    if (!sharedPin) continue;
+    const targetPath = getTracePathStartingAtPin(targetTrace, sharedPin);
+    const donorPath = getTracePathStartingAtPin(donorTrace, sharedPin);
+    if (!targetPath || !donorPath) continue;
+    const crossings = getPerpendicularPathCrossings(targetPath, donorPath);
+    for (const crossing of crossings) {
+      const tracePath = buildCollapsedCyclePath({
+        targetTrace,
+        targetPath,
+        donorPath,
+        crossing
+      });
+      const candidateTrace = { ...targetTrace, tracePath };
+      const candidateTargetVisibleLength = getVisibleTraceLength([
+        candidateTrace
+      ]);
+      if (candidateTargetVisibleLength > baselineTargetVisibleLength + TRACE_LENGTH_EPSILON) {
+        continue;
+      }
+      const candidateNetLabelPlacements = getNetLabelPlacementsForCycleCollapse(
+        {
+          targetTrace,
+          tracePath,
+          netLabelPlacements
+        }
+      );
+      if (!candidateNetLabelPlacements) continue;
+      const candidateNetTraces = sameNetTraces.map((trace) => {
+        if (trace.mspPairId === targetTrace.mspPairId) return candidateTrace;
+        return trace;
+      });
+      const netVisibleLength = getVisibleTraceLength(candidateNetTraces);
+      if (netVisibleLength >= baselineNetVisibleLength - TRACE_LENGTH_EPSILON) {
+        continue;
+      }
+      const netVisibleSegmentCount = getVisibleTraceSegmentCount(candidateNetTraces);
+      const candidate = {
+        tracePath,
+        netLabelPlacements: candidateNetLabelPlacements,
+        netVisibleLength,
+        netVisibleSegmentCount
+      };
+      if (candidateIsBetter(candidate, bestCandidate)) {
+        bestCandidate = candidate;
+      }
+    }
+  }
+  return bestCandidate;
+};
+var collapseSameNetCycles = ({
+  traces,
+  netLabelPlacements
+}) => {
+  const outputTraces = [...traces];
+  let outputNetLabelPlacements = [...netLabelPlacements];
+  let collapsedCycleCount = 0;
+  let traceIndex = 0;
+  while (traceIndex < outputTraces.length) {
+    const targetTrace = outputTraces[traceIndex];
+    const candidate = getBestCycleCollapseCandidate({
+      targetTrace,
+      traces: outputTraces,
+      netLabelPlacements: outputNetLabelPlacements
+    });
+    if (!candidate) {
+      traceIndex++;
+      continue;
+    }
+    outputTraces[traceIndex] = {
+      ...targetTrace,
+      tracePath: candidate.tracePath
+    };
+    outputNetLabelPlacements = candidate.netLabelPlacements;
+    collapsedCycleCount++;
+    traceIndex = 0;
+  }
+  return {
+    traces: outputTraces,
+    netLabelPlacements: outputNetLabelPlacements,
+    collapsedCycleCount
+  };
+};
+
 // lib/solvers/SameNetJunctionAlignmentSolver/placeGroundRailLabelsAtOuterEnd.ts
 var placeGroundRailLabelsAtOuterEnd = ({
   inputProblem,
@@ -13090,14 +13298,19 @@ var SameNetJunctionAlignmentSolver = class extends BaseSolver {
     this.outputNetLabelPlacements = input.netLabelPlacements;
   }
   _step() {
-    const result = alignSameNetJunctions(this.input);
-    this.outputTraces = result.traces;
+    const alignment = alignSameNetJunctions(this.input);
+    const cycleCollapse = collapseSameNetCycles({
+      traces: alignment.traces,
+      netLabelPlacements: alignment.netLabelPlacements
+    });
+    this.outputTraces = cycleCollapse.traces;
     this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
       inputProblem: this.input.inputProblem,
-      traces: result.traces,
-      netLabelPlacements: result.netLabelPlacements
+      traces: cycleCollapse.traces,
+      netLabelPlacements: cycleCollapse.netLabelPlacements
     });
-    this.stats.alignedJunctionCount = result.alignedJunctionCount;
+    this.stats.alignedJunctionCount = alignment.alignedJunctionCount;
+    this.stats.collapsedCycleCount = cycleCollapse.collapsedCycleCount;
     this.solved = true;
   }
   getOutput() {

package/lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts

@@ -6,6 +6,7 @@ import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/
 import type { InputProblem } from "lib/types/InputProblem"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { alignSameNetJunctions } from "./alignSameNetJunctions"
+import { collapseSameNetCycles } from "./collapseSameNetCycles"
 import { placeGroundRailLabelsAtOuterEnd } from "./placeGroundRailLabelsAtOuterEnd"
 
 interface SameNetJunctionAlignmentSolverInput {
@@ -28,14 +29,19 @@ export class SameNetJunctionAlignmentSolver extends BaseSolver {
   }
 
   override _step() {
-    const result = alignSameNetJunctions(this.input)
-    this.outputTraces = result.traces
+    const alignment = alignSameNetJunctions(this.input)
+    const cycleCollapse = collapseSameNetCycles({
+      traces: alignment.traces,
+      netLabelPlacements: alignment.netLabelPlacements,
+    })
+    this.outputTraces = cycleCollapse.traces
     this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
       inputProblem: this.input.inputProblem,
-      traces: result.traces,
-      netLabelPlacements: result.netLabelPlacements,
+      traces: cycleCollapse.traces,
+      netLabelPlacements: cycleCollapse.netLabelPlacements,
     })
-    this.stats.alignedJunctionCount = result.alignedJunctionCount
+    this.stats.alignedJunctionCount = alignment.alignedJunctionCount
+    this.stats.collapsedCycleCount = cycleCollapse.collapsedCycleCount
     this.solved = true
   }
 

package/lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts

@@ -41,7 +41,7 @@ const MAX_SAME_NET_LABEL_BOUNDARY_RAIL_OFFSET = 0.2
 const MAX_SHARED_PIN_RAIL_OFFSET = 0.05
 const MIN_RETURN_STEM_LENGTH = 0.05
 
-const getSharedPin = ({
+export const getSharedPin = ({
   donorTrace,
   branchTrace,
 }: {

package/lib/solvers/SameNetJunctionAlignmentSolver/collapseSameNetCycles.ts

@@ -0,0 +1,310 @@
+import type { Point } from "@tscircuit/math-utils"
+import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections"
+import { moveAttachedLabelsToReroutedTrace } from "lib/solvers/Example28Solver/labelMovement"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  getRailOrientation,
+  getVisibleTraceLength,
+  getVisibleTraceSegmentCount,
+  pointsEqual,
+} from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import { getSharedPin } from "./alignSameNetJunctions"
+import {
+  pathEntersAnyNetLabel,
+  pathIntersectsAnyNetLabel,
+} from "./pathIntersectsAnyNetLabel"
+
+interface CollapseSameNetCyclesInput {
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+interface PathCrossing {
+  intersectionPoint: Point
+  targetSegmentIndex: number
+  donorSegmentIndex: number
+}
+
+interface CycleCollapseCandidate {
+  tracePath: Point[]
+  netLabelPlacements: NetLabelPlacement[]
+  netVisibleLength: number
+  netVisibleSegmentCount: number
+}
+
+const TRACE_LENGTH_EPSILON = 1e-6
+
+const getTracePathStartingAtPin = (
+  trace: SolvedTracePath,
+  pin: Point,
+): Point[] | null => {
+  const pathStart = trace.tracePath[0]
+  const pathEnd = trace.tracePath.at(-1)
+  if (!pathStart || !pathEnd) return null
+  if (pointsEqual(pathStart, pin)) return trace.tracePath
+  if (pointsEqual(pathEnd, pin)) return [...trace.tracePath].reverse()
+  return null
+}
+
+const getPerpendicularPathCrossings = (
+  targetPath: Point[],
+  donorPath: Point[],
+): PathCrossing[] => {
+  const crossings: PathCrossing[] = []
+  const sharedEndpoint = targetPath[0]!
+
+  for (
+    let targetSegmentIndex = 0;
+    targetSegmentIndex < targetPath.length - 1;
+    targetSegmentIndex++
+  ) {
+    const targetStart = targetPath[targetSegmentIndex]!
+    const targetEnd = targetPath[targetSegmentIndex + 1]!
+    const targetOrientation = getRailOrientation(targetStart, targetEnd)
+    if (!targetOrientation) continue
+
+    for (
+      let donorSegmentIndex = 0;
+      donorSegmentIndex < donorPath.length - 1;
+      donorSegmentIndex++
+    ) {
+      const donorStart = donorPath[donorSegmentIndex]!
+      const donorEnd = donorPath[donorSegmentIndex + 1]!
+      const donorOrientation = getRailOrientation(donorStart, donorEnd)
+      if (!donorOrientation || donorOrientation === targetOrientation) continue
+
+      const intersectionPoint = getSegmentIntersection(
+        targetStart,
+        targetEnd,
+        donorStart,
+        donorEnd,
+      )
+      if (
+        !intersectionPoint ||
+        pointsEqual(intersectionPoint, sharedEndpoint)
+      ) {
+        continue
+      }
+
+      crossings.push({
+        intersectionPoint,
+        targetSegmentIndex,
+        donorSegmentIndex,
+      })
+    }
+  }
+
+  return crossings
+}
+
+const buildCollapsedCyclePath = ({
+  targetTrace,
+  targetPath,
+  donorPath,
+  crossing,
+}: {
+  targetTrace: SolvedTracePath
+  targetPath: Point[]
+  donorPath: Point[]
+  crossing: PathCrossing
+}) => {
+  const pathFromSharedPin = simplifyPath([
+    ...donorPath.slice(0, crossing.donorSegmentIndex + 1),
+    crossing.intersectionPoint,
+    ...targetPath.slice(crossing.targetSegmentIndex + 1),
+  ])
+  if (pointsEqual(targetTrace.tracePath[0]!, targetPath[0]!)) {
+    return pathFromSharedPin
+  }
+  return pathFromSharedPin.reverse()
+}
+
+const getNetLabelPlacementsForCycleCollapse = ({
+  targetTrace,
+  tracePath,
+  netLabelPlacements,
+}: {
+  targetTrace: SolvedTracePath
+  tracePath: Point[]
+  netLabelPlacements: NetLabelPlacement[]
+}): NetLabelPlacement[] | null => {
+  const candidateNetLabelPlacements = moveAttachedLabelsToReroutedTrace({
+    trace: targetTrace,
+    originalTracePath: targetTrace.tracePath,
+    reroutedTracePath: tracePath,
+    netLabelPlacements,
+  })
+
+  for (
+    let labelIndex = 0;
+    labelIndex < netLabelPlacements.length;
+    labelIndex++
+  ) {
+    const label = netLabelPlacements[labelIndex]!
+    if (label.globalConnNetId !== targetTrace.globalConnNetId) continue
+    if (!tracePathContainsPoint(targetTrace.tracePath, label.anchorPoint)) {
+      continue
+    }
+    const candidateLabel = candidateNetLabelPlacements[labelIndex]!
+    if (!tracePathContainsPoint(tracePath, candidateLabel.anchorPoint)) {
+      return null
+    }
+  }
+
+  const otherNetLabelPlacements = candidateNetLabelPlacements.filter(
+    (label) => label.globalConnNetId !== targetTrace.globalConnNetId,
+  )
+  if (
+    pathIntersectsAnyNetLabel({
+      path: tracePath,
+      netLabelPlacements: otherNetLabelPlacements,
+    })
+  ) {
+    return null
+  }
+
+  const sameNetLabelPlacements = candidateNetLabelPlacements.filter(
+    (label) => label.globalConnNetId === targetTrace.globalConnNetId,
+  )
+  if (
+    pathEntersAnyNetLabel({
+      path: tracePath,
+      netLabelPlacements: sameNetLabelPlacements,
+    })
+  ) {
+    return null
+  }
+  return candidateNetLabelPlacements
+}
+
+const candidateIsBetter = (
+  candidate: CycleCollapseCandidate,
+  bestCandidate: CycleCollapseCandidate | null,
+) => {
+  if (!bestCandidate) return true
+  const visibleLengthDelta =
+    candidate.netVisibleLength - bestCandidate.netVisibleLength
+  if (Math.abs(visibleLengthDelta) > TRACE_LENGTH_EPSILON) {
+    return visibleLengthDelta < 0
+  }
+  return candidate.netVisibleSegmentCount < bestCandidate.netVisibleSegmentCount
+}
+
+const getBestCycleCollapseCandidate = ({
+  targetTrace,
+  traces,
+  netLabelPlacements,
+}: {
+  targetTrace: SolvedTracePath
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}): CycleCollapseCandidate | null => {
+  const sameNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId === targetTrace.globalConnNetId,
+  )
+  const baselineNetVisibleLength = getVisibleTraceLength(sameNetTraces)
+  const baselineTargetVisibleLength = getVisibleTraceLength([targetTrace])
+  let bestCandidate: CycleCollapseCandidate | null = null
+
+  for (const donorTrace of sameNetTraces) {
+    if (donorTrace.mspPairId === targetTrace.mspPairId) continue
+    const sharedPin = getSharedPin({
+      donorTrace,
+      branchTrace: targetTrace,
+    })
+    if (!sharedPin) continue
+    const targetPath = getTracePathStartingAtPin(targetTrace, sharedPin)
+    const donorPath = getTracePathStartingAtPin(donorTrace, sharedPin)
+    if (!targetPath || !donorPath) continue
+
+    const crossings = getPerpendicularPathCrossings(targetPath, donorPath)
+    for (const crossing of crossings) {
+      const tracePath = buildCollapsedCyclePath({
+        targetTrace,
+        targetPath,
+        donorPath,
+        crossing,
+      })
+      const candidateTrace = { ...targetTrace, tracePath }
+      const candidateTargetVisibleLength = getVisibleTraceLength([
+        candidateTrace,
+      ])
+      if (
+        candidateTargetVisibleLength >
+        baselineTargetVisibleLength + TRACE_LENGTH_EPSILON
+      ) {
+        continue
+      }
+      const candidateNetLabelPlacements = getNetLabelPlacementsForCycleCollapse(
+        {
+          targetTrace,
+          tracePath,
+          netLabelPlacements,
+        },
+      )
+      if (!candidateNetLabelPlacements) continue
+
+      const candidateNetTraces = sameNetTraces.map((trace) => {
+        if (trace.mspPairId === targetTrace.mspPairId) return candidateTrace
+        return trace
+      })
+      const netVisibleLength = getVisibleTraceLength(candidateNetTraces)
+      if (netVisibleLength >= baselineNetVisibleLength - TRACE_LENGTH_EPSILON) {
+        continue
+      }
+      const netVisibleSegmentCount =
+        getVisibleTraceSegmentCount(candidateNetTraces)
+      const candidate = {
+        tracePath,
+        netLabelPlacements: candidateNetLabelPlacements,
+        netVisibleLength,
+        netVisibleSegmentCount,
+      }
+      if (candidateIsBetter(candidate, bestCandidate)) {
+        bestCandidate = candidate
+      }
+    }
+  }
+
+  return bestCandidate
+}
+
+export const collapseSameNetCycles = ({
+  traces,
+  netLabelPlacements,
+}: CollapseSameNetCyclesInput) => {
+  const outputTraces = [...traces]
+  let outputNetLabelPlacements = [...netLabelPlacements]
+  let collapsedCycleCount = 0
+  let traceIndex = 0
+
+  while (traceIndex < outputTraces.length) {
+    const targetTrace = outputTraces[traceIndex]!
+    const candidate = getBestCycleCollapseCandidate({
+      targetTrace,
+      traces: outputTraces,
+      netLabelPlacements: outputNetLabelPlacements,
+    })
+    if (!candidate) {
+      traceIndex++
+      continue
+    }
+
+    outputTraces[traceIndex] = {
+      ...targetTrace,
+      tracePath: candidate.tracePath,
+    }
+    outputNetLabelPlacements = candidate.netLabelPlacements
+    collapsedCycleCount++
+    traceIndex = 0
+  }
+
+  return {
+    traces: outputTraces,
+    netLabelPlacements: outputNetLabelPlacements,
+    collapsedCycleCount,
+  }
+}

package/package.json

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