@tscircuit/schematic-trace-solver 0.0.78 → 0.0.80

package/dist/index.d.ts

@@ -901,6 +901,11 @@ declare class NetLabelTraceCollisionSolver extends BaseSolver {
     constructor(params: NetLabelTraceCollisionSolverParams);
     getConstructorParams(): ConstructorParameters<typeof NetLabelTraceCollisionSolver>[0];
     _step(): void;
+    /**
+     * When a trace is rerouted, net labels that were anchored on the old path
+     * can be left floating in space. Snap their anchor back onto the new path.
+     */
+    private reanchorLabelsOnMovedTrace;
     getOutput(): {
         traces: SolvedTracePath[];
         netLabelPlacements: NetLabelPlacement[];

package/dist/index.js

@@ -5314,6 +5314,33 @@ var segmentRunsAlongRectBoundary = (start, end, rect) => {
   return false;
 };
 
+// lib/solvers/Example28Solver/getMovedAnchorPointForReroute.ts
+var getMovedAnchorPointForReroute = (anchorPoint, originalTracePath, reroutedTracePath) => {
+  const originalSegment = findSegmentContainingPoint(
+    originalTracePath,
+    anchorPoint
+  );
+  if (!originalSegment) return null;
+  const preferredSegment = findPreferredReroutedSegment(
+    reroutedTracePath,
+    originalSegment.index,
+    originalTracePath.length - 1,
+    originalSegment.orientation,
+    anchorPoint
+  );
+  if (!preferredSegment) {
+    return projectPointToPath(anchorPoint, reroutedTracePath);
+  }
+  return projectPointToSegment(
+    anchorPoint,
+    preferredSegment.start,
+    preferredSegment.end
+  );
+};
+
+// lib/solvers/Example28Solver/isLabelAttachedToTrace.ts
+var isLabelAttachedToTrace = (label, trace) => label.globalConnNetId === trace.globalConnNetId || label.mspConnectionPairIds.includes(trace.mspPairId);
+
 // lib/solvers/Example28Solver/labelMovement.ts
 var moveAttachedLabelsToReroutedTrace = ({
   trace,
@@ -5341,29 +5368,6 @@ var moveAttachedLabelsToReroutedTrace = ({
     }
   };
 });
-var isLabelAttachedToTrace = (label, trace) => label.globalConnNetId === trace.globalConnNetId || label.mspConnectionPairIds.includes(trace.mspPairId);
-var getMovedAnchorPointForReroute = (anchorPoint, originalTracePath, reroutedTracePath) => {
-  const originalSegment = findSegmentContainingPoint(
-    originalTracePath,
-    anchorPoint
-  );
-  if (!originalSegment) return null;
-  const preferredSegment = findPreferredReroutedSegment(
-    reroutedTracePath,
-    originalSegment.index,
-    originalTracePath.length - 1,
-    originalSegment.orientation,
-    anchorPoint
-  );
-  if (!preferredSegment) {
-    return projectPointToPath(anchorPoint, reroutedTracePath);
-  }
-  return projectPointToSegment(
-    anchorPoint,
-    preferredSegment.start,
-    preferredSegment.end
-  );
-};
 
 // lib/utils/dir.ts
 var dir = (facingDirection) => {
@@ -7815,6 +7819,43 @@ var TraceAnchoredNetLabelOverlapSolver = class extends BaseSolver {
 };
 
 // lib/solvers/NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver.ts
+var ON_PATH_EPS = 1e-6;
+function getClosestPointOnSegment(params) {
+  const { point, segmentStart, segmentEnd } = params;
+  const dx = segmentEnd.x - segmentStart.x;
+  const dy = segmentEnd.y - segmentStart.y;
+  const segmentLengthSq = dx * dx + dy * dy;
+  if (segmentLengthSq === 0) return { x: segmentStart.x, y: segmentStart.y };
+  const projection = ((point.x - segmentStart.x) * dx + (point.y - segmentStart.y) * dy) / segmentLengthSq;
+  const clampedProjection = Math.max(0, Math.min(1, projection));
+  return {
+    x: segmentStart.x + clampedProjection * dx,
+    y: segmentStart.y + clampedProjection * dy
+  };
+}
+function getClosestPointOnPath(point, path) {
+  let closestPoint = path[0];
+  let closestDistSq = Infinity;
+  for (let i = 0; i < path.length - 1; i++) {
+    const candidatePoint = getClosestPointOnSegment({
+      point,
+      segmentStart: path[i],
+      segmentEnd: path[i + 1]
+    });
+    const dx = candidatePoint.x - point.x;
+    const dy = candidatePoint.y - point.y;
+    const candidateDistSq = dx * dx + dy * dy;
+    if (candidateDistSq < closestDistSq) {
+      closestDistSq = candidateDistSq;
+      closestPoint = candidatePoint;
+    }
+  }
+  return closestPoint;
+}
+function isPointOnPath(point, path) {
+  const closestPoint = getClosestPointOnPath(point, path);
+  return Math.hypot(closestPoint.x - point.x, closestPoint.y - point.y) < ON_PATH_EPS;
+}
 function buildMergedObstacleLabel(seedLabel, allLabels) {
   const TOUCH_MARGIN = 0.01;
   const getBounds3 = (l) => getRectBounds(l.center, l.width, l.height);
@@ -7908,10 +7949,12 @@ var NetLabelTraceCollisionSolver = class extends BaseSolver {
             (t) => t.mspPairId === this.activeSubSolver.initialTrace.mspPairId
           );
           if (idx !== -1) {
+            const oldPath = this.outputTraces[idx].tracePath;
             this.outputTraces[idx] = {
               ...this.outputTraces[idx],
               tracePath: solvedPath
             };
+            this.reanchorLabelsOnMovedTrace(this.outputTraces[idx], oldPath);
           }
         }
         this.activeSubSolver = null;
@@ -7966,6 +8009,32 @@ var NetLabelTraceCollisionSolver = class extends BaseSolver {
       detourCount
     });
   }
+  /**
+   * When a trace is rerouted, net labels that were anchored on the old path
+   * can be left floating in space. Snap their anchor back onto the new path.
+   */
+  reanchorLabelsOnMovedTrace(movedTrace, oldPath) {
+    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+      const label = this.outputNetLabelPlacements[i];
+      if (label.globalConnNetId !== movedTrace.globalConnNetId) continue;
+      if (isPointOnPath(label.anchorPoint, movedTrace.tracePath)) continue;
+      if (!isPointOnPath(label.anchorPoint, oldPath)) continue;
+      const newAnchor = getClosestPointOnPath(
+        label.anchorPoint,
+        movedTrace.tracePath
+      );
+      this.outputNetLabelPlacements[i] = {
+        ...label,
+        anchorPoint: newAnchor,
+        center: getCenterFromAnchor(
+          newAnchor,
+          label.orientation,
+          label.width,
+          label.height
+        )
+      };
+    }
+  }
   getOutput() {
     return {
       traces: this.outputTraces,

package/lib/solvers/Example28Solver/getMovedAnchorPointForReroute.ts

@@ -0,0 +1,37 @@
+import type { Point } from "@tscircuit/math-utils"
+import {
+  findPreferredReroutedSegment,
+  findSegmentContainingPoint,
+  projectPointToPath,
+  projectPointToSegment,
+} from "./geometry"
+
+export const getMovedAnchorPointForReroute = (
+  anchorPoint: Point,
+  originalTracePath: Point[],
+  reroutedTracePath: Point[],
+) => {
+  const originalSegment = findSegmentContainingPoint(
+    originalTracePath,
+    anchorPoint,
+  )
+  if (!originalSegment) return null
+
+  const preferredSegment = findPreferredReroutedSegment(
+    reroutedTracePath,
+    originalSegment.index,
+    originalTracePath.length - 1,
+    originalSegment.orientation,
+    anchorPoint,
+  )
+
+  if (!preferredSegment) {
+    return projectPointToPath(anchorPoint, reroutedTracePath)
+  }
+
+  return projectPointToSegment(
+    anchorPoint,
+    preferredSegment.start,
+    preferredSegment.end,
+  )
+}

package/lib/solvers/Example28Solver/isLabelAttachedToTrace.ts

@@ -0,0 +1,9 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+export const isLabelAttachedToTrace = (
+  label: NetLabelPlacement,
+  trace: SolvedTracePath,
+) =>
+  label.globalConnNetId === trace.globalConnNetId ||
+  label.mspConnectionPairIds.includes(trace.mspPairId)

package/lib/solvers/Example28Solver/labelMovement.ts

@@ -1,12 +1,8 @@
 import type { Point } from "@tscircuit/math-utils"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import {
-  findPreferredReroutedSegment,
-  findSegmentContainingPoint,
-  projectPointToPath,
-  projectPointToSegment,
-} from "./geometry"
+import { getMovedAnchorPointForReroute } from "./getMovedAnchorPointForReroute"
+import { isLabelAttachedToTrace } from "./isLabelAttachedToTrace"
 
 export const moveAttachedLabelsToReroutedTrace = ({
   trace,
@@ -43,40 +39,3 @@ export const moveAttachedLabelsToReroutedTrace = ({
       },
     }
   })
-
-const isLabelAttachedToTrace = (
-  label: NetLabelPlacement,
-  trace: SolvedTracePath,
-) =>
-  label.globalConnNetId === trace.globalConnNetId ||
-  label.mspConnectionPairIds.includes(trace.mspPairId)
-
-const getMovedAnchorPointForReroute = (
-  anchorPoint: Point,
-  originalTracePath: Point[],
-  reroutedTracePath: Point[],
-) => {
-  const originalSegment = findSegmentContainingPoint(
-    originalTracePath,
-    anchorPoint,
-  )
-  if (!originalSegment) return null
-
-  const preferredSegment = findPreferredReroutedSegment(
-    reroutedTracePath,
-    originalSegment.index,
-    originalTracePath.length - 1,
-    originalSegment.orientation,
-    anchorPoint,
-  )
-
-  if (!preferredSegment) {
-    return projectPointToPath(anchorPoint, reroutedTracePath)
-  }
-
-  return projectPointToSegment(
-    anchorPoint,
-    preferredSegment.start,
-    preferredSegment.end,
-  )
-}

package/lib/solvers/NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver.ts

@@ -1,14 +1,67 @@
+import type { Point } from "@tscircuit/math-utils"
 import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import { SingleOverlapSolver } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver"
-import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import {
+  getCenterFromAnchor,
+  getRectBounds,
+} from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import { segmentIntersectsRect } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import type { InputProblem } from "lib/types/InputProblem"
 
+const ON_PATH_EPS = 1e-6
+
+function getClosestPointOnSegment(params: {
+  point: Point
+  segmentStart: Point
+  segmentEnd: Point
+}): Point {
+  const { point, segmentStart, segmentEnd } = params
+  const dx = segmentEnd.x - segmentStart.x
+  const dy = segmentEnd.y - segmentStart.y
+  const segmentLengthSq = dx * dx + dy * dy
+  if (segmentLengthSq === 0) return { x: segmentStart.x, y: segmentStart.y }
+  const projection =
+    ((point.x - segmentStart.x) * dx + (point.y - segmentStart.y) * dy) /
+    segmentLengthSq
+  const clampedProjection = Math.max(0, Math.min(1, projection))
+  return {
+    x: segmentStart.x + clampedProjection * dx,
+    y: segmentStart.y + clampedProjection * dy,
+  }
+}
+
+function getClosestPointOnPath(point: Point, path: Point[]): Point {
+  let closestPoint: Point = path[0]!
+  let closestDistSq = Infinity
+  for (let i = 0; i < path.length - 1; i++) {
+    const candidatePoint = getClosestPointOnSegment({
+      point,
+      segmentStart: path[i]!,
+      segmentEnd: path[i + 1]!,
+    })
+    const dx = candidatePoint.x - point.x
+    const dy = candidatePoint.y - point.y
+    const candidateDistSq = dx * dx + dy * dy
+    if (candidateDistSq < closestDistSq) {
+      closestDistSq = candidateDistSq
+      closestPoint = candidatePoint
+    }
+  }
+  return closestPoint
+}
+
+function isPointOnPath(point: Point, path: Point[]): boolean {
+  const closestPoint = getClosestPointOnPath(point, path)
+  return (
+    Math.hypot(closestPoint.x - point.x, closestPoint.y - point.y) < ON_PATH_EPS
+  )
+}
+
 /**
  * Merges all labels that touch/overlap with each other (transitively) around
  * a seed label into a single bounding-box label. This prevents the situation
@@ -159,10 +212,12 @@ export class NetLabelTraceCollisionSolver extends BaseSolver {
             (t) => t.mspPairId === this.activeSubSolver!.initialTrace.mspPairId,
           )
           if (idx !== -1) {
+            const oldPath = this.outputTraces[idx]!.tracePath
             this.outputTraces[idx] = {
               ...this.outputTraces[idx],
               tracePath: solvedPath,
             }
+            this.reanchorLabelsOnMovedTrace(this.outputTraces[idx]!, oldPath)
           }
         }
         this.activeSubSolver = null
@@ -229,6 +284,37 @@ export class NetLabelTraceCollisionSolver extends BaseSolver {
     })
   }
 
+  /**
+   * When a trace is rerouted, net labels that were anchored on the old path
+   * can be left floating in space. Snap their anchor back onto the new path.
+   */
+  private reanchorLabelsOnMovedTrace(
+    movedTrace: SolvedTracePath,
+    oldPath: Point[],
+  ) {
+    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+      const label = this.outputNetLabelPlacements[i]!
+      if (label.globalConnNetId !== movedTrace.globalConnNetId) continue
+      if (isPointOnPath(label.anchorPoint, movedTrace.tracePath)) continue
+      if (!isPointOnPath(label.anchorPoint, oldPath)) continue
+
+      const newAnchor = getClosestPointOnPath(
+        label.anchorPoint,
+        movedTrace.tracePath,
+      )
+      this.outputNetLabelPlacements[i] = {
+        ...label,
+        anchorPoint: newAnchor,
+        center: getCenterFromAnchor(
+          newAnchor,
+          label.orientation,
+          label.width,
+          label.height,
+        ),
+      }
+    }
+  }
+
   getOutput() {
     return {
       traces: this.outputTraces,

package/package.json

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

package/site/examples/example46.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example46.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/site/examples/example47.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example47.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/site/examples/example48.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example48.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/site/examples/example49.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example49.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/tests/assets/example46.json

@@ -0,0 +1,236 @@
+{
+  "chips": [
+    {
+      "chipId": "schematic_component_0",
+      "center": {
+        "x": -2.71,
+        "y": 0.7199999999999998
+      },
+      "width": 0.8599999999999999,
+      "height": 1.04,
+      "pins": [
+        {
+          "pinId": "DPROT.1",
+          "x": -2.87,
+          "y": 1.2399999999999998
+        },
+        {
+          "pinId": "DPROT.2",
+          "x": -2.87,
+          "y": 0.19999999999999973
+        }
+      ],
+      "sectionId": "pwr"
+    },
+    {
+      "chipId": "schematic_component_1",
+      "center": {
+        "x": -3.25,
+        "y": 3.05
+      },
+      "width": 1.8800000000000003,
+      "height": 1.13,
+      "pins": [
+        {
+          "pinId": "F1.1",
+          "x": -2.87,
+          "y": 3.58
+        },
+        {
+          "pinId": "F1.2",
+          "x": -2.87,
+          "y": 2.5199999999999996
+        }
+      ],
+      "sectionId": "pwr"
+    },
+    {
+      "chipId": "schematic_component_2",
+      "center": {
+        "x": 0,
+        "y": 0
+      },
+      "width": 1.77,
+      "height": 0.6,
+      "pins": [
+        {
+          "pinId": "U2.1",
+          "x": -1.2850000000000001,
+          "y": 0.2
+        },
+        {
+          "pinId": "U2.2",
+          "x": -1.2850000000000001,
+          "y": 0
+        },
+        {
+          "pinId": "U2.3",
+          "x": -1.2850000000000001,
+          "y": -0.2
+        },
+        {
+          "pinId": "U2.4",
+          "x": 1.2850000000000001,
+          "y": -0.1
+        },
+        {
+          "pinId": "U2.5",
+          "x": 1.2850000000000001,
+          "y": 0.1
+        }
+      ],
+      "sectionId": "pwr"
+    },
+    {
+      "chipId": "schematic_component_3",
+      "center": {
+        "x": -2.755,
+        "y": -1.56
+      },
+      "width": 0.9600000000000004,
+      "height": 1.1000000000000003,
+      "pins": [
+        {
+          "pinId": "C1.1",
+          "x": -2.97,
+          "y": -1.01
+        },
+        {
+          "pinId": "C1.2",
+          "x": -2.97,
+          "y": -2.1100000000000003
+        }
+      ],
+      "sectionId": "pwr"
+    },
+    {
+      "chipId": "schematic_component_4",
+      "center": {
+        "x": -0.5950000000000002,
+        "y": -2.4550000000000005
+      },
+      "width": 0.9599999999999999,
+      "height": 1.1000000000000003,
+      "pins": [
+        {
+          "pinId": "C4.1",
+          "x": -0.8100000000000003,
+          "y": -1.9050000000000005
+        },
+        {
+          "pinId": "C4.2",
+          "x": -0.8100000000000003,
+          "y": -3.005000000000001
+        }
+      ],
+      "sectionId": "pwr"
+    },
+    {
+      "chipId": "schematic_component_5",
+      "center": {
+        "x": 2.9724999999999997,
+        "y": -1.8699999999999997
+      },
+      "width": 1.245,
+      "height": 1.13,
+      "pins": [
+        {
+          "pinId": "DPWR.1",
+          "x": 2.675,
+          "y": -1.3299999999999996
+        },
+        {
+          "pinId": "DPWR.2",
+          "x": 2.675,
+          "y": -2.4099999999999997
+        }
+      ],
+      "sectionId": "pwr"
+    },
+    {
+      "chipId": "schematic_component_6",
+      "center": {
+        "x": 1.5519553499999992,
+        "y": -4.1899999999999995
+      },
+      "width": 0.9739106999999991,
+      "height": 1.0999999999999996,
+      "pins": [
+        {
+          "pinId": "R1.1",
+          "x": 1.2594553499999992,
+          "y": -3.6399999999999997
+        },
+        {
+          "pinId": "R1.2",
+          "x": 1.2594553499999992,
+          "y": -4.739999999999999
+        }
+      ],
+      "sectionId": "pwr"
+    },
+    {
+      "chipId": "schematic_component_7",
+      "center": {
+        "x": -0.5950000000000001,
+        "y": -4.765000000000001
+      },
+      "width": 0.8400000000000001,
+      "height": 1.0999999999999996,
+      "pins": [
+        {
+          "pinId": "C18.1",
+          "x": -0.75,
+          "y": -4.215000000000001
+        },
+        {
+          "pinId": "C18.2",
+          "x": -0.75,
+          "y": -5.315
+        }
+      ],
+      "sectionId": "pwr"
+    }
+  ],
+  "directConnections": [
+    {
+      "pinIds": ["F1.2", "DPROT.1"],
+      "netId": ".F1 > .pin2 to .DPROT > .anode"
+    }
+  ],
+  "netConnections": [
+    {
+      "netId": "VBUS",
+      "pinIds": ["DPROT.1", "F1.1", "F1.2"],
+      "netLabelWidth": 0.6
+    },
+    {
+      "netId": "RAW",
+      "pinIds": ["DPROT.2", "U2.1", "U2.3", "C1.1"],
+      "netLabelWidth": 0.48
+    },
+    {
+      "netId": "GND",
+      "pinIds": ["U2.2", "C1.2", "C4.2", "R1.2", "C18.2"],
+      "netLabelWidth": 0.48
+    },
+    {
+      "netId": "V3V3",
+      "pinIds": ["U2.5", "C4.1", "DPWR.1", "C18.1"],
+      "netLabelWidth": 0.6
+    },
+    {
+      "netId": "PWR_LED_K",
+      "pinIds": ["DPWR.2", "R1.1"],
+      "netLabelWidth": 1.2
+    }
+  ],
+  "availableNetLabelOrientations": {
+    "VBUS": ["y+"],
+    "RAW": ["x-", "x+", "y+", "y-"],
+    "V3V3": ["y+"],
+    "GND": ["y-"],
+    "PWR_LED_K": ["x-", "x+", "y+", "y-"]
+  },
+  "maxMspPairDistance": 2.4
+}