@tscircuit/schematic-trace-solver 0.0.17 → 0.0.19

package/dist/index.js

@@ -6682,7 +6682,18 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
       guidelines: this.guidelines
     });
     this.movableSegments = movableSegments;
-    this.queuedCandidatePaths = [this.baseElbow, ...elbowVariants];
+    const getPathLength = (pts) => {
+      let len = 0;
+      for (let i = 0; i < pts.length - 1; i++) {
+        const dx = pts[i + 1].x - pts[i].x;
+        const dy = pts[i + 1].y - pts[i].y;
+        len += Math.sqrt(dx * dx + dy * dy);
+      }
+      return len;
+    };
+    this.queuedCandidatePaths = [this.baseElbow, ...elbowVariants].sort(
+      (a, b) => getPathLength(a) - getPathLength(b)
+    );
   }
   getConstructorParams() {
     return {

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver.ts

@@ -81,7 +81,19 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
 
     this.movableSegments = movableSegments
 
-    this.queuedCandidatePaths = [this.baseElbow, ...elbowVariants]
+    const getPathLength = (pts: Point[]) => {
+      let len = 0
+      for (let i = 0; i < pts.length - 1; i++) {
+        const dx = pts[i + 1].x - pts[i].x
+        const dy = pts[i + 1].y - pts[i].y
+        len += Math.sqrt(dx * dx + dy * dy)
+      }
+      return len
+    }
+
+    this.queuedCandidatePaths = [this.baseElbow, ...elbowVariants].sort(
+      (a, b) => getPathLength(a) - getPathLength(b),
+    )
   }
 
   override getConstructorParams(): ConstructorParameters<

package/package.json

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

package/site/components/DownloadDropdown.tsx

@@ -6,6 +6,24 @@ interface DownloadDropdownProps {
   className?: string
 }
 
+const deepRemoveUnderscoreProperties = (obj: any): any => {
+  if (obj === null || typeof obj !== "object") {
+    return obj
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map(deepRemoveUnderscoreProperties)
+  }
+
+  const result: any = {}
+  for (const [key, value] of Object.entries(obj)) {
+    if (!key.startsWith("_")) {
+      result[key] = deepRemoveUnderscoreProperties(value)
+    }
+  }
+  return result
+}
+
 export const DownloadDropdown = ({
   solver,
   className = "",
@@ -36,7 +54,9 @@ export const DownloadDropdown = ({
         return
       }
 
-      const params = solver.getConstructorParams()
+      const params = deepRemoveUnderscoreProperties(
+        solver.getConstructorParams(),
+      )
       const blob = new Blob([JSON.stringify(params, null, 2)], {
         type: "application/json",
       })
@@ -56,7 +76,9 @@ export const DownloadDropdown = ({
 
   const downloadPageTsx = () => {
     try {
-      const params = solver.getConstructorParams()
+      const params = deepRemoveUnderscoreProperties(
+        solver.getConstructorParams(),
+      )
       const solverName = solver.constructor.name
       const isSchematicTracePipelineSolver =
         solverName === "SchematicTracePipelineSolver"
@@ -104,19 +126,21 @@ export default () => {
 
   const downloadTestTs = () => {
     try {
-      const params = solver.getConstructorParams()
+      const params = deepRemoveUnderscoreProperties(
+        solver.getConstructorParams(),
+      )
       const solverName = solver.constructor.name
 
-      const content = `import { ${solverName} } from "lib/solvers/${solverName}/${solverName}"
+      const content = `import { ${solverName} } from "lib/solvers/${solverName}/${solverName}\nimport { test, expect } from "bun:test"
 
 test("${solverName} should solve problem correctly", () => {
   const input = ${JSON.stringify(params, null, 2)}
   
   const solver = new ${solverName}(input as any)
-  const result = solver.solve()
+  solver.solve()
   
-  expect(result).toBeDefined()
   // Add more specific assertions based on expected output
+  // expect(solver.netLabelPlacementSolver!.netLabelPlacements).toMatchInlineSnapshot()
 })
 `
 

package/site/examples/example07.page.tsx

@@ -0,0 +1,135 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import type { InputProblem } from "lib/types/InputProblem"
+
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: {
+        x: 0,
+        y: 0,
+      },
+      width: 2.8,
+      height: 1.4,
+      pins: [
+        {
+          pinId: "U3.8",
+          x: -1.4,
+          y: 0.42500000000000004,
+        },
+        {
+          pinId: "U3.4",
+          x: -1.4,
+          y: -0.42500000000000004,
+        },
+        {
+          pinId: "U3.1",
+          x: 1.4,
+          y: 0.5,
+        },
+        {
+          pinId: "U3.6",
+          x: 1.4,
+          y: 0.30000000000000004,
+        },
+        {
+          pinId: "U3.5",
+          x: 1.4,
+          y: 0.10000000000000009,
+        },
+        {
+          pinId: "U3.2",
+          x: 1.4,
+          y: -0.09999999999999998,
+        },
+        {
+          pinId: "U3.3",
+          x: 1.4,
+          y: -0.3,
+        },
+        {
+          pinId: "U3.7",
+          x: 1.4,
+          y: -0.5,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_1",
+      center: {
+        x: -2.3145833,
+        y: 0,
+      },
+      width: 0.5291665999999999,
+      height: 1.1024186000000005,
+      pins: [
+        {
+          pinId: "C20.1",
+          x: -2.3148566499999994,
+          y: 0.5512093000000002,
+        },
+        {
+          pinId: "C20.2",
+          x: -2.31430995,
+          y: -0.5512093000000002,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_2",
+      center: {
+        x: 1.7577928249999983,
+        y: 1.7512907000000002,
+      },
+      width: 0.3155856499999966,
+      height: 1.1025814000000005,
+      pins: [
+        {
+          pinId: "R11.1",
+          x: 1.7580660749999977,
+          y: 2.3025814000000002,
+        },
+        {
+          pinId: "R11.2",
+          x: 1.757519574999999,
+          y: 1.2,
+        },
+      ],
+    },
+  ],
+  directConnections: [
+    {
+      pinIds: ["C20.1", "U3.8"],
+      netId: "capacitor.C20 > port.pin1 to .U3 > .VDD",
+    },
+    {
+      pinIds: ["C20.2", "U3.4"],
+      netId: "capacitor.C20 > port.pin2 to .U3 > .GND",
+    },
+    {
+      pinIds: ["R11.2", "U3.1"],
+      netId: "resistor.R11 > port.pin2 to .U3 > .N_CS",
+    },
+  ],
+  netConnections: [
+    {
+      netId: "V3_3",
+      pinIds: ["U3.8", "U3.3", "U3.7", "C20.1", "R11.1"],
+    },
+    {
+      netId: "GND",
+      pinIds: ["U3.4", "C20.2"],
+    },
+    {
+      netId: "FLASH_N_CS",
+      pinIds: ["U3.1", "R11.2"],
+    },
+  ],
+  availableNetLabelOrientations: {
+    V3_3: ["y+"],
+    GND: ["y-"],
+  },
+  maxMspPairDistance: 2,
+}
+
+export default () => <PipelineDebugger inputProblem={inputProblem} />

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

@@ -0,0 +1,140 @@
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { test, expect } from "bun:test"
+
+test("SchematicTracePipelineSolver should solve problem correctly", () => {
+  const input = {
+    chips: [
+      {
+        chipId: "schematic_component_0",
+        center: {
+          x: 0,
+          y: 0,
+        },
+        width: 2.8,
+        height: 1.4,
+        pins: [
+          {
+            pinId: "U3.8",
+            x: -1.4,
+            y: 0.42500000000000004,
+          },
+          {
+            pinId: "U3.4",
+            x: -1.4,
+            y: -0.42500000000000004,
+          },
+          {
+            pinId: "U3.1",
+            x: 1.4,
+            y: 0.5,
+          },
+          {
+            pinId: "U3.6",
+            x: 1.4,
+            y: 0.30000000000000004,
+          },
+          {
+            pinId: "U3.5",
+            x: 1.4,
+            y: 0.10000000000000009,
+          },
+          {
+            pinId: "U3.2",
+            x: 1.4,
+            y: -0.09999999999999998,
+          },
+          {
+            pinId: "U3.3",
+            x: 1.4,
+            y: -0.3,
+          },
+          {
+            pinId: "U3.7",
+            x: 1.4,
+            y: -0.5,
+          },
+        ],
+      },
+      {
+        chipId: "schematic_component_1",
+        center: {
+          x: -2.3145833,
+          y: 0,
+        },
+        width: 0.5291665999999999,
+        height: 1.1024186000000005,
+        pins: [
+          {
+            pinId: "C20.1",
+            x: -2.3148566499999994,
+            y: 0.5512093000000002,
+          },
+          {
+            pinId: "C20.2",
+            x: -2.31430995,
+            y: -0.5512093000000002,
+          },
+        ],
+      },
+      {
+        chipId: "schematic_component_2",
+        center: {
+          x: 1.7577928249999983,
+          y: 1.7512907000000002,
+        },
+        width: 0.3155856499999966,
+        height: 1.1025814000000005,
+        pins: [
+          {
+            pinId: "R11.1",
+            x: 1.7580660749999977,
+            y: 2.3025814000000002,
+          },
+          {
+            pinId: "R11.2",
+            x: 1.757519574999999,
+            y: 1.2,
+          },
+        ],
+      },
+    ],
+    directConnections: [
+      {
+        pinIds: ["C20.1", "U3.8"],
+        netId: "capacitor.C20 > port.pin1 to .U3 > .VDD",
+      },
+      {
+        pinIds: ["C20.2", "U3.4"],
+        netId: "capacitor.C20 > port.pin2 to .U3 > .GND",
+      },
+      {
+        pinIds: ["R11.2", "U3.1"],
+        netId: "resistor.R11 > port.pin2 to .U3 > .N_CS",
+      },
+    ],
+    netConnections: [
+      {
+        netId: "V3_3",
+        pinIds: ["U3.8", "U3.3", "U3.7", "C20.1", "R11.1"],
+      },
+      {
+        netId: "GND",
+        pinIds: ["U3.4", "C20.2"],
+      },
+      {
+        netId: "FLASH_N_CS",
+        pinIds: ["U3.1", "R11.2"],
+      },
+    ],
+    availableNetLabelOrientations: {
+      V3_3: ["y+"],
+      GND: ["y-"],
+    },
+    maxMspPairDistance: 2,
+  }
+
+  const solver = new SchematicTracePipelineSolver(input as any)
+  solver.solve()
+
+  // console.log(solver.netLabelPlacementSolver!.netLabelPlacements)
+})

package/tests/solvers/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver_shortest.test.ts

@@ -0,0 +1,71 @@
+import { test, expect } from "bun:test"
+import { SchematicTraceSingleLineSolver } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver"
+import { calculateElbow } from "calculate-elbow"
+import { generateElbowVariants } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/generateElbowVariants"
+import type { InputChip, InputProblem } from "lib/types/InputProblem"
+import type { Guideline } from "lib/solvers/GuidelinesSolver/GuidelinesSolver"
+
+const pathLength = (pts: { x: number; y: number }[]) => {
+  let len = 0
+  for (let i = 0; i < pts.length - 1; i++) {
+    const dx = pts[i + 1].x - pts[i].x
+    const dy = pts[i + 1].y - pts[i].y
+    len += Math.sqrt(dx * dx + dy * dy)
+  }
+  return len
+}
+
+test("SchematicTraceSingleLineSolver chooses shortest candidate path", () => {
+  const chipA: InputChip = {
+    chipId: "A",
+    center: { x: 0, y: 0 },
+    width: 0.2,
+    height: 0.2,
+    pins: [{ pinId: "A1", x: 0, y: 0 }],
+  }
+  const chipB: InputChip = {
+    chipId: "B",
+    center: { x: 4, y: 2 },
+    width: 0.2,
+    height: 0.2,
+    pins: [{ pinId: "B1", x: 4, y: 2 }],
+  }
+
+  const pins = [
+    { pinId: "A1", x: 0, y: 0, _facingDirection: "x+" as const, chipId: "A" },
+    { pinId: "B1", x: 4, y: 2, _facingDirection: "x+" as const, chipId: "B" },
+  ]
+
+  const guidelines: Guideline[] = [
+    { orientation: "vertical", x: 4, y: undefined },
+    { orientation: "vertical", x: 6, y: undefined },
+  ]
+
+  const inputProblem: InputProblem = {
+    chips: [chipA, chipB],
+    directConnections: [],
+    netConnections: [],
+    availableNetLabelOrientations: {},
+  }
+
+  const solver = new SchematicTraceSingleLineSolver({
+    pins: pins as any,
+    guidelines,
+    inputProblem,
+    chipMap: { A: chipA, B: chipB },
+  })
+
+  solver.solve()
+  expect(solver.solved).toBe(true)
+
+  const baseElbow = calculateElbow(
+    { x: pins[0].x, y: pins[0].y, facingDirection: pins[0]._facingDirection },
+    { x: pins[1].x, y: pins[1].y, facingDirection: pins[1]._facingDirection },
+    { overshoot: 0.2 },
+  )
+  const { elbowVariants } = generateElbowVariants({ baseElbow, guidelines })
+  const candidates = [baseElbow, ...elbowVariants]
+  const shortestLength = Math.min(...candidates.map(pathLength))
+
+  expect(pathLength(solver.solvedTracePath!)).toBe(shortestLength)
+})