@tscircuit/schematic-trace-solver 0.0.188 → 0.0.190

package/lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts

@@ -7,7 +7,6 @@ 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 {
@@ -32,18 +31,14 @@ export class SameNetJunctionAlignmentSolver extends BaseSolver {
 
   override _step() {
     const alignment = alignSameNetJunctions(this.input)
-    const cycleCollapse = collapseSameNetCycles({
-      traces: alignment.traces,
-      netLabelPlacements: alignment.netLabelPlacements,
-    })
-    this.outputTraces = cycleCollapse.traces
+    this.outputTraces = alignment.traces
     this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
       inputProblem: this.input.inputProblem,
-      traces: cycleCollapse.traces,
-      netLabelPlacements: cycleCollapse.netLabelPlacements,
+      traces: alignment.traces,
+      netLabelPlacements: alignment.netLabelPlacements,
     })
     this.stats.alignedJunctionCount = alignment.alignedJunctionCount
-    this.stats.collapsedCycleCount = cycleCollapse.collapsedCycleCount
+    this.stats.collapsedCycleCount = alignment.collapsedCycleCount
     this.solved = true
   }
 

package/lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts

@@ -8,6 +8,7 @@ import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/Sche
 import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import { getMovedAnchorPointForReroute } from "lib/solvers/Example28Solver/getMovedAnchorPointForReroute"
+import { isLabelAttachedToTrace } from "lib/solvers/Example28Solver/isLabelAttachedToTrace"
 import { moveAttachedLabelsToReroutedTrace } from "lib/solvers/Example28Solver/labelMovement"
 import {
   rectsOverlap,
@@ -33,6 +34,7 @@ import {
   isCoordinateOnPinFacingSide,
 } from "./findNearestSharedPinExitRail"
 import { collapseRedundantSharedEndpointStubs } from "./collapseRedundantSharedEndpointStubs"
+import { collapseSameNetCycles } from "./collapseSameNetCycles"
 import { getSharedPin } from "./getSharedPin"
 
 interface AlignSameNetJunctionsInput {
@@ -182,14 +184,13 @@ const getAttachedLabelIndexes = (
   netLabelPlacements: NetLabelPlacement[],
 ) =>
   netLabelPlacements.flatMap((label, index) => {
-    const labelOwnsTrace =
-      label.mspConnectionPairIds.includes(trace.mspPairId) ||
-      (label.mspConnectionPairIds.length === 0 &&
-        label.globalConnNetId === trace.globalConnNetId)
-    return labelOwnsTrace &&
+    if (
+      isLabelAttachedToTrace(label, trace) &&
       tracePathContainsPoint(trace.tracePath, label.anchorPoint)
-      ? [index]
-      : []
+    ) {
+      return [index]
+    }
+    return []
   })
 
 const moveAttachedLabels = ({
@@ -1314,17 +1315,24 @@ export const alignSameNetJunctions = ({
     }
   }
 
-  const collapsedSharedEndpointStubs = collapseRedundantSharedEndpointStubs({
+  // Shared-stub collapse can remove the common pin from one trace path, so
+  // collapse cycles while both paths still expose their shared endpoint.
+  const cycleCollapse = collapseSameNetCycles({
     traces: outputTraces,
     netLabelPlacements: outputNetLabelPlacements,
+  })
+  outputTraces = collapseRedundantSharedEndpointStubs({
+    traces: cycleCollapse.traces,
+    netLabelPlacements: cycleCollapse.netLabelPlacements,
     netLabelConnectorTraceIds,
     multiPinNetPinIds: getMultiPinNetPinIds(inputProblem),
   })
-  outputTraces = collapsedSharedEndpointStubs
+  outputNetLabelPlacements = cycleCollapse.netLabelPlacements
 
   return {
     traces: outputTraces,
     netLabelPlacements: outputNetLabelPlacements,
     alignedJunctionCount,
+    collapsedCycleCount: cycleCollapse.collapsedCycleCount,
   }
 }

package/lib/solvers/SameNetJunctionAlignmentSolver/collapseSameNetCycles.ts

@@ -11,6 +11,7 @@ import {
   pointsEqual,
 } from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
 import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import { findPerpendicularPathCrossings } from "lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles"
 import { getSharedPin } from "./getSharedPin"
 import {
   pathEntersAnyNetLabel,
@@ -100,6 +101,25 @@ const getPerpendicularPathCrossings = (
   return crossings
 }
 
+const buildCollapsedSelfCyclePath = (
+  path: Point[],
+  firstSegmentIndex: number,
+  secondSegmentIndex: number,
+) => {
+  const intersectionPoint = getSegmentIntersection(
+    path[firstSegmentIndex]!,
+    path[firstSegmentIndex + 1]!,
+    path[secondSegmentIndex]!,
+    path[secondSegmentIndex + 1]!,
+  )
+  if (!intersectionPoint) return path
+  return simplifyPath([
+    ...path.slice(0, firstSegmentIndex + 1),
+    intersectionPoint,
+    ...path.slice(secondSegmentIndex + 1),
+  ])
+}
+
 const buildCollapsedCyclePath = ({
   targetTrace,
   targetPath,
@@ -209,6 +229,60 @@ const getBestCycleCollapseCandidate = ({
   const baselineTargetVisibleLength = getVisibleTraceLength([targetTrace])
   let bestCandidate: CycleCollapseCandidate | null = null
 
+  const considerTracePath = (tracePath: Point[]) => {
+    const candidateTrace = { ...targetTrace, tracePath }
+    const candidateTargetVisibleLength = getVisibleTraceLength([candidateTrace])
+    if (
+      candidateTargetVisibleLength >
+      baselineTargetVisibleLength + TRACE_LENGTH_EPSILON
+    ) {
+      return
+    }
+    const candidateNetLabelPlacements = getNetLabelPlacementsForCycleCollapse({
+      targetTrace,
+      tracePath,
+      netLabelPlacements,
+    })
+    if (!candidateNetLabelPlacements) return
+
+    const candidateNetTraces = sameNetTraces.map((trace) => {
+      if (trace.mspPairId === targetTrace.mspPairId) return candidateTrace
+      return trace
+    })
+    const netVisibleLength = getVisibleTraceLength(candidateNetTraces)
+    if (netVisibleLength >= baselineNetVisibleLength - TRACE_LENGTH_EPSILON) {
+      return
+    }
+    const candidate: CycleCollapseCandidate = {
+      tracePath,
+      netLabelPlacements: candidateNetLabelPlacements,
+      netVisibleLength,
+      netVisibleSegmentCount: getVisibleTraceSegmentCount(candidateNetTraces),
+    }
+    if (candidateIsBetter(candidate, bestCandidate)) {
+      bestCandidate = candidate
+    }
+  }
+
+  // Comparing a path with itself reports each crossing in both directions.
+  const selfCrossings = findPerpendicularPathCrossings(
+    targetTrace.tracePath,
+    targetTrace.tracePath,
+    { includeTerminalSegments: true },
+  ).filter(
+    ({ pathSegmentIndex, otherPathSegmentIndex }) =>
+      pathSegmentIndex < otherPathSegmentIndex,
+  )
+  for (const crossing of selfCrossings) {
+    considerTracePath(
+      buildCollapsedSelfCyclePath(
+        targetTrace.tracePath,
+        crossing.pathSegmentIndex,
+        crossing.otherPathSegmentIndex,
+      ),
+    )
+  }
+
   for (const donorTrace of sameNetTraces) {
     if (donorTrace.mspPairId === targetTrace.mspPairId) continue
     const sharedPin = getSharedPin({
@@ -228,44 +302,7 @@ const getBestCycleCollapseCandidate = ({
         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
-      }
+      considerTracePath(tracePath)
     }
   }
 

package/lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts

@@ -232,13 +232,17 @@ export const generatePerpendicularTraceDetours = ({
       ]),
     ].filter((coordinate): coordinate is number => coordinate !== undefined)
 
+    const remainingPath = path.slice(index + 2)
+    // A terminal segment has no following leg to reconnect the detour.
+    if (remainingPath.length === 0) remainingPath.push(end)
+
     return [...new Set(detourCoordinates)].map((detour) =>
       simplifyPath([
         ...path.slice(0, index + 1),
         { ...start, [movingAxis]: gate },
         { ...start, [movingAxis]: gate, [detourAxis]: detour },
         { ...end, [detourAxis]: detour },
-        ...path.slice(index + 2),
+        ...remainingPath,
       ]),
     )
   }

package/package.json

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

package/site/SchematicTracePipelineSolver/repro-robot-controller-imu-tof.page.tsx

@@ -0,0 +1,7 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import type { InputProblem } from "lib/types/InputProblem"
+import inputProblem from "../../tests/repros/assets/repro-robot-controller-imu-tof.input.json"
+
+export default () => (
+  <PipelineDebugger inputProblem={inputProblem as InputProblem} />
+)