@tscircuit/schematic-trace-solver 0.0.78 → 0.0.79

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

@@ -7815,6 +7815,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 +7945,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 +8005,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/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.79",
   "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
+}

package/tests/assets/example47.json

@@ -0,0 +1,206 @@
+{
+  "chips": [
+    {
+      "chipId": "schematic_component_0",
+      "center": {
+        "x": -0.5899999999999996,
+        "y": 0.315272325
+      },
+      "width": 1.6,
+      "height": 1,
+      "pins": [
+        {
+          "pinId": "U1.1",
+          "x": 0.6100000000000005,
+          "y": 0.015272324999999976
+        },
+        {
+          "pinId": "U1.2",
+          "x": -1.7899999999999998,
+          "y": 0.015272324999999976
+        },
+        {
+          "pinId": "U1.3",
+          "x": 0.6100000000000005,
+          "y": 0.415272325
+        },
+        {
+          "pinId": "U1.4",
+          "x": -1.7899999999999998,
+          "y": 0.6152723250000001
+        },
+        {
+          "pinId": "U1.5",
+          "x": -1.7899999999999998,
+          "y": 0.41527232500000005
+        },
+        {
+          "pinId": "U1.6",
+          "x": -1.7899999999999998,
+          "y": 0.21527232500000004
+        },
+        {
+          "pinId": "U1.7",
+          "x": 0.6100000000000005,
+          "y": 0.215272325
+        },
+        {
+          "pinId": "U1.8",
+          "x": 0.6100000000000005,
+          "y": 0.6152723250000001
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_1",
+      "center": {
+        "x": 1.88195535,
+        "y": 1.8047276749999999
+      },
+      "width": 0.8539106999999988,
+      "height": 1.1,
+      "pins": [
+        {
+          "pinId": "R1.1",
+          "x": 1.64945535,
+          "y": 2.354727675
+        },
+        {
+          "pinId": "R1.2",
+          "x": 1.64945535,
+          "y": 1.2547276749999998
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_2",
+      "center": {
+        "x": 1.8600000000000005,
+        "y": 0.21527232500000035
+      },
+      "width": 1.1,
+      "height": 0.7789106999999988,
+      "pins": [
+        {
+          "pinId": "R2.1",
+          "x": 1.3100000000000005,
+          "y": 0.21527232500000038
+        },
+        {
+          "pinId": "R2.2",
+          "x": 2.4100000000000006,
+          "y": 0.21527232500000038
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_3",
+      "center": {
+        "x": -1.8774999999999997,
+        "y": 4.109727674999999
+      },
+      "width": 1.1149999999999998,
+      "height": 1.0999999999999996,
+      "pins": [
+        {
+          "pinId": "C1.1",
+          "x": -2.0149999999999997,
+          "y": 4.659727674999999
+        },
+        {
+          "pinId": "C1.2",
+          "x": -2.0149999999999997,
+          "y": 3.5597276749999995
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_4",
+      "center": {
+        "x": -1.6525000000000003,
+        "y": -1.804727675
+      },
+      "width": 1.1150000000000002,
+      "height": 1.1000000000000003,
+      "pins": [
+        {
+          "pinId": "C2.1",
+          "x": -1.7900000000000003,
+          "y": -1.254727675
+        },
+        {
+          "pinId": "C2.2",
+          "x": -1.7900000000000003,
+          "y": -2.3547276750000004
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_5",
+      "center": {
+        "x": 0.9100000000000001,
+        "y": 4.3547276749999995
+      },
+      "width": 1.4000000000000004,
+      "height": 0.8000000000000003,
+      "pins": [
+        {
+          "pinId": "J1.1",
+          "x": -0.18999999999999995,
+          "y": 4.554727675
+        },
+        {
+          "pinId": "J1.2",
+          "x": -0.18999999999999995,
+          "y": 4.3547276749999995
+        },
+        {
+          "pinId": "J1.3",
+          "x": -0.18999999999999995,
+          "y": 4.154727674999999
+        }
+      ]
+    }
+  ],
+  "directConnections": [
+    {
+      "pinIds": ["U1.5", "C2.1"],
+      "netId": "U1.CTRL to C2.pin1"
+    },
+    {
+      "pinIds": ["R1.2", "U1.7"],
+      "netId": "R1.pin2 to U1.DISCH"
+    },
+    {
+      "pinIds": ["U1.7", "R2.1"],
+      "netId": "U1.DISCH to R2.pin1"
+    }
+  ],
+  "netConnections": [
+    {
+      "netId": "GND",
+      "pinIds": ["U1.1", "C1.2", "C2.2", "J1.3"],
+      "netLabelWidth": 0.48
+    },
+    {
+      "netId": "NODE",
+      "pinIds": ["U1.2", "U1.6", "R2.2", "C1.1"],
+      "netLabelWidth": 0.6
+    },
+    {
+      "netId": "OUT",
+      "pinIds": ["U1.3", "J1.2"],
+      "netLabelWidth": 0.48
+    },
+    {
+      "netId": "VCC",
+      "pinIds": ["U1.4", "U1.8", "R1.1", "J1.1"],
+      "netLabelWidth": 0.48
+    }
+  ],
+  "availableNetLabelOrientations": {
+    "VCC": ["y+"],
+    "GND": ["y-"]
+  },
+  "maxMspPairDistance": 2.4
+}