@tscircuit/schematic-trace-solver 0.0.33 → 0.0.35

package/dist/index.js

@@ -842,6 +842,20 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       chipAlpha: 0.1,
       connectionAlpha: 0.1
     });
+    g.lines.push({
+      points: this.baseElbow,
+      strokeColor: "red",
+      strokeDash: "4 4"
+    });
+    const [pin1, pin2] = this.pins;
+    g.lines.push({
+      points: [
+        { x: pin1.x, y: pin1.y },
+        { x: pin2.x, y: pin2.y }
+      ],
+      strokeColor: "blue",
+      strokeDash: "5 5"
+    });
     for (const { path, collisionChipIds: collisionRectIds } of this.queue) {
       g.lines.push({ points: path, strokeColor: "teal", strokeDash: "2 2" });
     }
@@ -1927,6 +1941,12 @@ var NetLabelPlacementSolver = class extends BaseSolver {
     const { netConnMap } = getConnectivityMapsFromInputProblem(
       this.inputProblem
     );
+    const pinIdToPinMap = /* @__PURE__ */ new Map();
+    for (const chip of this.inputProblem.chips) {
+      for (const pin of chip.pins) {
+        pinIdToPinMap.set(pin.pinId, pin);
+      }
+    }
     const userNetIdByPinId = {};
     for (const dc of this.inputProblem.directConnections) {
       if (dc.netId) {
@@ -1941,10 +1961,21 @@ var NetLabelPlacementSolver = class extends BaseSolver {
       }
     }
     const groups = [];
-    for (const globalConnNetId of Object.keys(netConnMap.netMap)) {
-      const pinsInNet = netConnMap.getIdsConnectedToNet(
+    const allPinIds = this.inputProblem.chips.flatMap(
+      (c) => c.pins.map((p) => p.pinId)
+    );
+    const allGlobalConnNetIds = /* @__PURE__ */ new Set();
+    for (const pinId of allPinIds) {
+      const netId = netConnMap.getNetConnectedToId(pinId);
+      if (netId) {
+        allGlobalConnNetIds.add(netId);
+      }
+    }
+    for (const globalConnNetId of allGlobalConnNetIds) {
+      const allIdsInNet = netConnMap.getIdsConnectedToNet(
         globalConnNetId
       );
+      const pinsInNet = allIdsInNet.filter((id) => pinIdToPinMap.has(id));
       const adj = {};
       for (const pid of pinsInNet) adj[pid] = /* @__PURE__ */ new Set();
       for (const t of byGlobal[globalConnNetId] ?? []) {
@@ -2008,12 +2039,13 @@ var NetLabelPlacementSolver = class extends BaseSolver {
               )
             )
           );
-          groups.push({
+          const group = {
             globalConnNetId,
             netId: userNetId,
             overlappingTraces: rep,
             mspConnectionPairIds
-          });
+          };
+          groups.push(group);
         } else {
           for (const p of component) {
             const userNetId = userNetIdByPinId[p];

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -107,6 +107,13 @@ export class NetLabelPlacementSolver extends BaseSolver {
       this.inputProblem,
     )
 
+    const pinIdToPinMap = new Map<string, unknown>()
+    for (const chip of this.inputProblem.chips) {
+      for (const pin of chip.pins) {
+        pinIdToPinMap.set(pin.pinId, pin)
+      }
+    }
+
     // Map pins to user-provided netIds (if any)
     const userNetIdByPinId: Record<string, string | undefined> = {}
     for (const dc of this.inputProblem.directConnections) {
@@ -124,11 +131,24 @@ export class NetLabelPlacementSolver extends BaseSolver {
 
     const groups: Array<OverlappingSameNetTraceGroup> = []
 
+    const allPinIds = this.inputProblem.chips.flatMap((c) =>
+      c.pins.map((p) => p.pinId),
+    )
+
+    const allGlobalConnNetIds = new Set<string>()
+    for (const pinId of allPinIds) {
+      const netId = netConnMap.getNetConnectedToId(pinId)
+      if (netId) {
+        allGlobalConnNetIds.add(netId)
+      }
+    }
+
     // Consider every global connectivity net id
-    for (const globalConnNetId of Object.keys((netConnMap as any).netMap)) {
-      const pinsInNet = netConnMap.getIdsConnectedToNet(
+    for (const globalConnNetId of allGlobalConnNetIds) {
+      const allIdsInNet = netConnMap.getIdsConnectedToNet(
         globalConnNetId,
       ) as string[]
+      const pinsInNet = allIdsInNet.filter((id) => pinIdToPinMap.has(id))
 
       // Build adjacency from solved traces (edges)
       const adj: Record<string, Set<string>> = {}
@@ -205,12 +225,13 @@ export class NetLabelPlacementSolver extends BaseSolver {
             ),
           )
 
-          groups.push({
+          const group = {
             globalConnNetId,
             netId: userNetId,
             overlappingTraces: rep,
             mspConnectionPairIds,
-          })
+          }
+          groups.push(group)
         } else {
           // No traces in this component: place label at each pin that has a user net id
           for (const p of component) {

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts

@@ -222,6 +222,25 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       connectionAlpha: 0.1,
     })
 
+    // Draw the base elbow
+
+    g.lines!.push({
+      points: this.baseElbow,
+      strokeColor: "red",
+      strokeDash: "4 4",
+    })
+
+    // Draw the MSP pair connection with a dashed line
+    const [pin1, pin2] = this.pins
+    g.lines!.push({
+      points: [
+        { x: pin1.x, y: pin1.y },
+        { x: pin2.x, y: pin2.y },
+      ],
+      strokeColor: "blue",
+      strokeDash: "5 5",
+    })
+
     // Draw all the new candidates
     for (const { path, collisionChipIds: collisionRectIds } of this.queue) {
       g.lines!.push({ points: path, strokeColor: "teal", strokeDash: "2 2" })

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "type": "module",
   "scripts": {
     "start": "cosmos",
@@ -15,7 +15,7 @@
     "@tscircuit/math-utils": "^0.0.19",
     "@types/bun": "^1.2.21",
     "bun-match-svg": "^0.0.13",
-    "calculate-elbow": "^0.0.11",
+    "calculate-elbow": "^0.0.12",
     "connectivity-map": "^1.0.0",
     "flatbush": "^4.5.0",
     "graphics-debug": "^0.0.62",

package/site/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2_01-example17.page.tsx

@@ -0,0 +1,324 @@
+import { useMemo } from "react"
+import { GenericSolverDebugger } from "../components/GenericSolverDebugger"
+import { SchematicTraceSingleLineSolver2 } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"
+
+export const inputProblem = {
+  chipMap: {
+    schematic_component_0: {
+      chipId: "schematic_component_0",
+      center: {
+        x: 0,
+        y: 0,
+      },
+      width: 2.3,
+      height: 1,
+      pins: [
+        {
+          pinId: "U1.1",
+          x: -1.15,
+          y: 0.30000000000000004,
+        },
+        {
+          pinId: "U1.2",
+          x: -1.15,
+          y: 0.10000000000000003,
+        },
+        {
+          pinId: "U1.3",
+          x: -1.15,
+          y: -0.09999999999999998,
+        },
+        {
+          pinId: "U1.4",
+          x: -1.15,
+          y: -0.30000000000000004,
+        },
+        {
+          pinId: "U1.5",
+          x: 1.15,
+          y: -0.30000000000000004,
+        },
+        {
+          pinId: "U1.6",
+          x: 1.15,
+          y: -0.10000000000000003,
+        },
+        {
+          pinId: "U1.7",
+          x: 1.15,
+          y: 0.09999999999999998,
+        },
+        {
+          pinId: "U1.8",
+          x: 1.15,
+          y: 0.30000000000000004,
+        },
+      ],
+    },
+    schematic_component_1: {
+      chipId: "schematic_component_1",
+      center: {
+        x: -1.1500000000000004,
+        y: 1.6700000000000002,
+      },
+      width: 1.04,
+      height: 1.0400000000000005,
+      pins: [
+        {
+          pinId: "D1.1",
+          x: -1.1500000000000004,
+          y: 1.15,
+        },
+        {
+          pinId: "D1.2",
+          x: -1.1500000000000004,
+          y: 2.1900000000000004,
+        },
+      ],
+    },
+    schematic_component_2: {
+      chipId: "schematic_component_2",
+      center: {
+        x: -2.37,
+        y: 0.10000000000000009,
+      },
+      width: 1.04,
+      height: 0.54,
+      pins: [
+        {
+          pinId: "D2.1",
+          x: -1.85,
+          y: 0.10000000000000002,
+        },
+        {
+          pinId: "D2.2",
+          x: -2.89,
+          y: 0.10000000000000016,
+        },
+      ],
+    },
+    schematic_component_3: {
+      chipId: "schematic_component_3",
+      center: {
+        x: 2.4,
+        y: -0.3000000000000007,
+      },
+      width: 1.1000000000000005,
+      height: 0.84,
+      pins: [
+        {
+          pinId: "C1.1",
+          x: 1.8499999999999996,
+          y: -0.3000000000000007,
+        },
+        {
+          pinId: "C1.2",
+          x: 2.95,
+          y: -0.3000000000000007,
+        },
+      ],
+    },
+    schematic_component_4: {
+      chipId: "schematic_component_4",
+      center: {
+        x: 4.2,
+        y: -0.3000000000000007,
+      },
+      width: 1.0999999999999996,
+      height: 0.84,
+      pins: [
+        {
+          pinId: "C2.1",
+          x: 3.6500000000000004,
+          y: -0.3000000000000007,
+        },
+        {
+          pinId: "C2.2",
+          x: 4.75,
+          y: -0.3000000000000007,
+        },
+      ],
+    },
+  },
+  pins: [
+    {
+      pinId: "U1.1",
+      x: -1.15,
+      y: 0.30000000000000004,
+      chipId: "schematic_component_0",
+    },
+    {
+      pinId: "D1.1",
+      x: -1.1500000000000004,
+      y: 1.15,
+      chipId: "schematic_component_1",
+    },
+  ],
+  inputProblem: {
+    chips: [
+      {
+        chipId: "schematic_component_0",
+        center: {
+          x: 0,
+          y: 0,
+        },
+        width: 2.3,
+        height: 1,
+        pins: [
+          {
+            pinId: "U1.1",
+            x: -1.15,
+            y: 0.30000000000000004,
+          },
+          {
+            pinId: "U1.2",
+            x: -1.15,
+            y: 0.10000000000000003,
+          },
+          {
+            pinId: "U1.3",
+            x: -1.15,
+            y: -0.09999999999999998,
+          },
+          {
+            pinId: "U1.4",
+            x: -1.15,
+            y: -0.30000000000000004,
+          },
+          {
+            pinId: "U1.5",
+            x: 1.15,
+            y: -0.30000000000000004,
+          },
+          {
+            pinId: "U1.6",
+            x: 1.15,
+            y: -0.10000000000000003,
+          },
+          {
+            pinId: "U1.7",
+            x: 1.15,
+            y: 0.09999999999999998,
+          },
+          {
+            pinId: "U1.8",
+            x: 1.15,
+            y: 0.30000000000000004,
+          },
+        ],
+      },
+      {
+        chipId: "schematic_component_1",
+        center: {
+          x: -1.1500000000000004,
+          y: 1.6700000000000002,
+        },
+        width: 1.04,
+        height: 1.0400000000000005,
+        pins: [
+          {
+            pinId: "D1.1",
+            x: -1.1500000000000004,
+            y: 1.15,
+          },
+          {
+            pinId: "D1.2",
+            x: -1.1500000000000004,
+            y: 2.1900000000000004,
+          },
+        ],
+      },
+      {
+        chipId: "schematic_component_2",
+        center: {
+          x: -2.37,
+          y: 0.10000000000000009,
+        },
+        width: 1.04,
+        height: 0.54,
+        pins: [
+          {
+            pinId: "D2.1",
+            x: -1.85,
+            y: 0.10000000000000002,
+          },
+          {
+            pinId: "D2.2",
+            x: -2.89,
+            y: 0.10000000000000016,
+          },
+        ],
+      },
+      {
+        chipId: "schematic_component_3",
+        center: {
+          x: 2.4,
+          y: -0.3000000000000007,
+        },
+        width: 1.1000000000000005,
+        height: 0.84,
+        pins: [
+          {
+            pinId: "C1.1",
+            x: 1.8499999999999996,
+            y: -0.3000000000000007,
+          },
+          {
+            pinId: "C1.2",
+            x: 2.95,
+            y: -0.3000000000000007,
+          },
+        ],
+      },
+      {
+        chipId: "schematic_component_4",
+        center: {
+          x: 4.2,
+          y: -0.3000000000000007,
+        },
+        width: 1.0999999999999996,
+        height: 0.84,
+        pins: [
+          {
+            pinId: "C2.1",
+            x: 3.6500000000000004,
+            y: -0.3000000000000007,
+          },
+          {
+            pinId: "C2.2",
+            x: 4.75,
+            y: -0.3000000000000007,
+          },
+        ],
+      },
+    ],
+    directConnections: [
+      {
+        pinIds: ["U1.5", "C1.1"],
+        netId: ".U1 .VCC to .C1 .pin1",
+      },
+      {
+        pinIds: ["C1.2", "C2.1"],
+        netId: ".C1 .pin2 to .C2 .pin1",
+      },
+      {
+        pinIds: ["U1.1", "D1.1"],
+        netId: ".U1 .OUT1 to .D1 .pin1",
+      },
+      {
+        pinIds: ["U1.2", "D2.1"],
+        netId: ".U1 .OUT2 to .D2 .pin1",
+      },
+    ],
+    netConnections: [],
+    availableNetLabelOrientations: {},
+    maxMspPairDistance: 2.4,
+  },
+}
+
+export default () => {
+  const solver = useMemo(() => {
+    return new SchematicTraceSingleLineSolver2(inputProblem as any)
+  }, [])
+  return <GenericSolverDebugger solver={solver} />
+}