@tscircuit/schematic-trace-solver 0.0.11 → 0.0.13

package/dist/index.js

@@ -5264,11 +5264,13 @@ var ConnectivityMap = class {
 var getConnectivityMapsFromInputProblem = (inputProblem) => {
   const directConnMap = new ConnectivityMap({});
   for (const directConn of inputProblem.directConnections) {
-    directConnMap.addConnections([directConn.pinIds]);
+    directConnMap.addConnections([
+      directConn.netId ? [directConn.netId, ...directConn.pinIds] : directConn.pinIds
+    ]);
   }
   const netConnMap = new ConnectivityMap(directConnMap.netMap);
   for (const netConn of inputProblem.netConnections) {
-    netConnMap.addConnections([netConn.pinIds]);
+    netConnMap.addConnections([[netConn.netId, ...netConn.pinIds]]);
   }
   return { directConnMap, netConnMap };
 };
@@ -5481,7 +5483,7 @@ var MspConnectionPairSolver = class extends BaseSolver {
         this.userNetIdByPinId[pid] = nc.netId;
       }
     }
-    this.queuedDcNetIds = Object.keys(directConnMap.netMap);
+    this.queuedDcNetIds = Object.keys(netConnMap.netMap);
   }
   getConstructorParams() {
     return {
@@ -5494,8 +5496,9 @@ var MspConnectionPairSolver = class extends BaseSolver {
       return;
     }
     const dcNetId = this.queuedDcNetIds.shift();
-    const directlyConnectedPins = this.dcConnMap.getIdsConnectedToNet(dcNetId);
-    if (directlyConnectedPins.length === 1) {
+    const allIds = this.globalConnMap.getIdsConnectedToNet(dcNetId);
+    const directlyConnectedPins = allIds.filter((id) => !!this.pinMap[id]);
+    if (directlyConnectedPins.length <= 1) {
       return;
     }
     if (directlyConnectedPins.length === 2) {
@@ -5512,7 +5515,7 @@ var MspConnectionPairSolver = class extends BaseSolver {
       return;
     }
     const msp = getOrthogonalMinimumSpanningTree(
-      directlyConnectedPins.map((p) => this.pinMap[p]),
+      directlyConnectedPins.map((p) => this.pinMap[p]).filter(Boolean),
       { maxDistance: this.maxMspPairDistance }
     );
     for (const [pin1, pin2] of msp) {
@@ -7933,7 +7936,26 @@ function getVerticalGuidelineX(chip1Bounds, chip2Bounds) {
   return (overlapMinX + overlapMaxX) / 2;
 }
 
+// lib/solvers/GuidelinesSolver/getInputProblemBounds.ts
+var getInputProblemBounds = (inputProblem) => {
+  const bounds = {
+    minX: Infinity,
+    maxX: -Infinity,
+    minY: Infinity,
+    maxY: -Infinity
+  };
+  for (const chip of inputProblem.chips) {
+    const chipBounds = getInputChipBounds(chip);
+    bounds.minX = Math.min(bounds.minX, chipBounds.minX);
+    bounds.maxX = Math.max(bounds.maxX, chipBounds.maxX);
+    bounds.minY = Math.min(bounds.minY, chipBounds.minY);
+    bounds.maxY = Math.max(bounds.maxY, chipBounds.maxY);
+  }
+  return bounds;
+};
+
 // lib/solvers/GuidelinesSolver/GuidelinesSolver.ts
+var GUIDELINE_PADDING_FROM_PROBLEM_BOUNDS = 0.1;
 var GuidelinesSolver = class extends BaseSolver {
   inputProblem;
   guidelines;
@@ -7943,7 +7965,29 @@ var GuidelinesSolver = class extends BaseSolver {
   constructor(params) {
     super();
     this.inputProblem = params.inputProblem;
-    this.guidelines = [];
+    const inputProblemBounds = getInputProblemBounds(this.inputProblem);
+    this.guidelines = [
+      {
+        orientation: "horizontal",
+        y: inputProblemBounds.minY - GUIDELINE_PADDING_FROM_PROBLEM_BOUNDS,
+        x: void 0
+      },
+      {
+        orientation: "horizontal",
+        y: inputProblemBounds.maxY + GUIDELINE_PADDING_FROM_PROBLEM_BOUNDS,
+        x: void 0
+      },
+      {
+        orientation: "vertical",
+        y: void 0,
+        x: inputProblemBounds.minX - GUIDELINE_PADDING_FROM_PROBLEM_BOUNDS
+      },
+      {
+        orientation: "vertical",
+        y: void 0,
+        x: inputProblemBounds.maxX + GUIDELINE_PADDING_FROM_PROBLEM_BOUNDS
+      }
+    ];
     this.chipPairsGenerator = getGeneratorForAllChipPairs(
       this.inputProblem.chips
     );

package/lib/solvers/GuidelinesSolver/GuidelinesSolver.ts

@@ -6,6 +6,7 @@ import { getGeneratorForAllChipPairs } from "./getGeneratorForAllChipPairs"
 import { getInputChipBounds } from "./getInputChipBounds"
 import { getHorizontalGuidelineY } from "./getHorizontalGuidelineY"
 import { getVerticalGuidelineX } from "./getVerticalGuidelineX"
+import { getInputProblemBounds } from "./getInputProblemBounds"
 
 export type Guideline =
   | {
@@ -19,6 +20,8 @@ export type Guideline =
       x: number
     }
 
+const GUIDELINE_PADDING_FROM_PROBLEM_BOUNDS = 0.1
+
 export class GuidelinesSolver extends BaseSolver {
   inputProblem: InputProblem
   guidelines: Guideline[]
@@ -33,7 +36,29 @@ export class GuidelinesSolver extends BaseSolver {
   }) {
     super()
     this.inputProblem = params.inputProblem
-    this.guidelines = []
+    const inputProblemBounds = getInputProblemBounds(this.inputProblem)
+    this.guidelines = [
+      {
+        orientation: "horizontal",
+        y: inputProblemBounds.minY - GUIDELINE_PADDING_FROM_PROBLEM_BOUNDS,
+        x: undefined,
+      },
+      {
+        orientation: "horizontal",
+        y: inputProblemBounds.maxY + GUIDELINE_PADDING_FROM_PROBLEM_BOUNDS,
+        x: undefined,
+      },
+      {
+        orientation: "vertical",
+        y: undefined,
+        x: inputProblemBounds.minX - GUIDELINE_PADDING_FROM_PROBLEM_BOUNDS,
+      },
+      {
+        orientation: "vertical",
+        y: undefined,
+        x: inputProblemBounds.maxX + GUIDELINE_PADDING_FROM_PROBLEM_BOUNDS,
+      },
+    ]
     this.chipPairsGenerator = getGeneratorForAllChipPairs(
       this.inputProblem.chips,
     )

package/lib/solvers/GuidelinesSolver/getInputProblemBounds.ts

@@ -0,0 +1,19 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import { getInputChipBounds } from "./getInputChipBounds"
+
+export const getInputProblemBounds = (inputProblem: InputProblem) => {
+  const bounds = {
+    minX: Infinity,
+    maxX: -Infinity,
+    minY: Infinity,
+    maxY: -Infinity,
+  }
+  for (const chip of inputProblem.chips) {
+    const chipBounds = getInputChipBounds(chip)
+    bounds.minX = Math.min(bounds.minX, chipBounds.minX)
+    bounds.maxX = Math.max(bounds.maxX, chipBounds.maxX)
+    bounds.minY = Math.min(bounds.minY, chipBounds.minY)
+    bounds.maxY = Math.max(bounds.maxY, chipBounds.maxY)
+  }
+  return bounds
+}

package/lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -68,7 +68,7 @@ export class MspConnectionPairSolver extends BaseSolver {
       }
     }
 
-    this.queuedDcNetIds = Object.keys(directConnMap.netMap)
+    this.queuedDcNetIds = Object.keys(netConnMap.netMap)
   }
 
   override getConstructorParams(): ConstructorParameters<
@@ -87,9 +87,10 @@ export class MspConnectionPairSolver extends BaseSolver {
 
     const dcNetId = this.queuedDcNetIds.shift()!
 
-    const directlyConnectedPins = this.dcConnMap.getIdsConnectedToNet(dcNetId)
+    const allIds = this.globalConnMap.getIdsConnectedToNet(dcNetId) as string[]
+    const directlyConnectedPins = allIds.filter((id) => !!this.pinMap[id])
 
-    if (directlyConnectedPins.length === 1) {
+    if (directlyConnectedPins.length <= 1) {
       return
     }
 
@@ -113,7 +114,7 @@ export class MspConnectionPairSolver extends BaseSolver {
     // There are more than 3 pins, so we need to run MSP to find the best pairs
 
     const msp = getOrthogonalMinimumSpanningTree(
-      directlyConnectedPins.map((p) => this.pinMap[p]!),
+      directlyConnectedPins.map((p) => this.pinMap[p]!).filter(Boolean),
       { maxDistance: this.maxMspPairDistance },
     )
 

package/lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem.ts

@@ -7,13 +7,17 @@ export const getConnectivityMapsFromInputProblem = (
   const directConnMap = new ConnectivityMap({})
 
   for (const directConn of inputProblem.directConnections) {
-    directConnMap.addConnections([directConn.pinIds])
+    directConnMap.addConnections([
+      directConn.netId
+        ? [directConn.netId, ...directConn.pinIds]
+        : directConn.pinIds,
+    ])
   }
 
   const netConnMap = new ConnectivityMap(directConnMap.netMap)
 
   for (const netConn of inputProblem.netConnections) {
-    netConnMap.addConnections([netConn.pinIds])
+    netConnMap.addConnections([[netConn.netId, ...netConn.pinIds]])
   }
 
   return { directConnMap, netConnMap }

package/package.json

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

package/site/MspConnectionPairSolver/MspConnectionPairSolver01.page.tsx

@@ -0,0 +1,16 @@
+import { MspConnectionPairSolver } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import inputParams from "./MspConnectionPairSolver01_params.json"
+import { GenericSolverDebugger } from "site/components/GenericSolverDebugger"
+import { useMemo } from "react"
+import type { InputProblem } from "lib/types/InputProblem"
+
+export default () => {
+  const solver = useMemo(
+    () =>
+      new MspConnectionPairSolver({
+        inputProblem: inputParams.inputProblem as unknown as InputProblem,
+      }),
+    [],
+  )
+  return <GenericSolverDebugger solver={solver} />
+}

package/site/MspConnectionPairSolver/MspConnectionPairSolver01_params.json

@@ -0,0 +1,111 @@
+{
+  "inputProblem": {
+    "chips": [
+      {
+        "chipId": "U1",
+        "center": {
+          "x": 0,
+          "y": 0
+        },
+        "width": 1.6,
+        "height": 0.6,
+        "pins": [
+          {
+            "pinId": "U1.1",
+            "x": -0.8,
+            "y": 0.2
+          },
+          {
+            "pinId": "U1.2",
+            "x": -0.8,
+            "y": 0
+          },
+          {
+            "pinId": "U1.3",
+            "x": -0.8,
+            "y": -0.2
+          },
+          {
+            "pinId": "U1.4",
+            "x": 0.8,
+            "y": -0.2
+          },
+          {
+            "pinId": "U1.5",
+            "x": 0.8,
+            "y": 0
+          },
+          {
+            "pinId": "U1.6",
+            "x": 0.8,
+            "y": 0.2
+          }
+        ]
+      },
+      {
+        "chipId": "C1",
+        "center": {
+          "x": -2,
+          "y": 0
+        },
+        "width": 0.5,
+        "height": 1,
+        "pins": [
+          {
+            "pinId": "C1.1",
+            "x": -2,
+            "y": 0.5
+          },
+          {
+            "pinId": "C1.2",
+            "x": -2,
+            "y": -0.5
+          }
+        ]
+      },
+      {
+        "chipId": "C2",
+        "center": {
+          "x": -4,
+          "y": 0
+        },
+        "width": 0.5,
+        "height": 1,
+        "pins": [
+          {
+            "pinId": "C2.1",
+            "x": -4,
+            "y": 0.5
+          },
+          {
+            "pinId": "C2.2",
+            "x": -4,
+            "y": -0.5
+          }
+        ]
+      }
+    ],
+    "directConnections": [
+      {
+        "pinIds": ["U1.1", "C1.1"],
+        "netId": "VCC"
+      },
+      {
+        "pinIds": ["U1.2", "C2.1"],
+        "netId": "EN"
+      }
+    ],
+    "netConnections": [
+      {
+        "pinIds": ["U1.3", "C2.2", "C1.2"],
+        "netId": "GND"
+      }
+    ],
+    "availableNetLabelOrientations": {
+      "VCC": ["y+"],
+      "EN": ["x+", "x-"],
+      "GND": ["y-"]
+    },
+    "maxMspPairDistance": 2
+  }
+}

package/tests/solvers/MspConnectionPairSolver/MspConnectionPairSolver_repro1.test.ts

@@ -0,0 +1,14 @@
+import inputParams from "site/MspConnectionPairSolver/MspConnectionPairSolver01_params.json"
+import { test, expect } from "bun:test"
+import { MspConnectionPairSolver } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+
+test("MspConnectionPairSolver_repro1", () => {
+  const solver = new MspConnectionPairSolver({
+    inputProblem: inputParams.inputProblem as unknown as InputProblem,
+  })
+
+  solver.solve()
+
+  expect(solver.mspConnectionPairs.length).toBe(4)
+})

package/tests/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver_repro01.test.ts

@@ -0,0 +1,111 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import { test, expect } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/index"
+
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "U1",
+      center: { x: 0, y: 0 },
+      width: 1.6,
+      height: 0.6,
+      pins: [
+        {
+          pinId: "U1.1",
+          x: -0.8,
+          y: 0.2,
+        },
+        {
+          pinId: "U1.2",
+          x: -0.8,
+          y: 0,
+        },
+        {
+          pinId: "U1.3",
+          x: -0.8,
+          y: -0.2,
+        },
+        {
+          pinId: "U1.4",
+          x: 0.8,
+          y: -0.2,
+        },
+        {
+          pinId: "U1.5",
+          x: 0.8,
+          y: 0,
+        },
+        {
+          pinId: "U1.6",
+          x: 0.8,
+          y: 0.2,
+        },
+      ],
+    },
+    {
+      chipId: "C1",
+      center: { x: -2, y: 0 },
+      width: 0.5,
+      height: 1,
+      pins: [
+        {
+          pinId: "C1.1",
+          x: -2,
+          y: 0.5,
+        },
+        {
+          pinId: "C1.2",
+          x: -2,
+          y: -0.5,
+        },
+      ],
+    },
+    {
+      chipId: "C2",
+      center: { x: -4, y: 0 },
+      width: 0.5,
+      height: 1,
+      pins: [
+        {
+          pinId: "C2.1",
+          x: -4,
+          y: 0.5,
+        },
+        {
+          pinId: "C2.2",
+          x: -4,
+          y: -0.5,
+        },
+      ],
+    },
+  ],
+  directConnections: [
+    {
+      pinIds: ["U1.1", "C1.1"],
+      netId: "VCC",
+    },
+    {
+      pinIds: ["U1.2", "C2.1"],
+      netId: "EN",
+    },
+  ],
+  netConnections: [
+    {
+      pinIds: ["U1.3", "C2.2", "C1.2"],
+      netId: "GND",
+    },
+  ],
+  availableNetLabelOrientations: {
+    VCC: ["y+"],
+    EN: ["x+", "x-"],
+    GND: ["y-"],
+  },
+  maxMspPairDistance: 2,
+}
+
+test("SchematicTracePipelineSolver_repro01", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+  solver.solve()
+
+  // console.log(solver.schematicTraceLinesSolver!.solvedTracePaths)
+})