@tscircuit/core 0.0.480 → 0.0.482

package/dist/index.js

@@ -3565,10 +3565,7 @@ var getNumericSchPinStyle = (pinStyles, pinLabels) => {
 };
 
 // lib/components/primitive-components/Trace/Trace.ts
-import {
-  MultilayerIjump,
-  getObstaclesFromSoup
-} from "@tscircuit/infgrid-ijump-astar";
+import { MultilayerIjump } from "@tscircuit/infgrid-ijump-astar";
 import { traceProps } from "@tscircuit/props";
 import "circuit-json";
 import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
@@ -4304,6 +4301,289 @@ var isRouteOutsideBoard = (mergedRoute, { db }) => {
   return outsideBoard;
 };
 
+// lib/utils/obstacles/getObstaclesFromRoute.ts
+var isCloseTo = (a, b) => Math.abs(a - b) < 1e-4;
+var getObstaclesFromRoute = (route, source_trace_id, { viaDiameter = 0.5 } = {}) => {
+  const obstacles = [];
+  for (let i = 0; i < route.length - 1; i++) {
+    const [start, end] = [route[i], route[i + 1]];
+    const prev = i - 1 >= 0 ? route[i - 1] : null;
+    const isHorz = isCloseTo(start.y, end.y);
+    const isVert = isCloseTo(start.x, end.x);
+    if (!isHorz && !isVert) {
+      throw new Error(
+        `getObstaclesFromTrace currently only supports horizontal and vertical traces (not diagonals) Conflicting trace: ${source_trace_id}, start: (${start.x}, ${start.y}), end: (${end.x}, ${end.y})`
+      );
+    }
+    const obstacle = {
+      type: "rect",
+      layers: [start.layer],
+      center: {
+        x: (start.x + end.x) / 2,
+        y: (start.y + end.y) / 2
+      },
+      width: isHorz ? Math.abs(start.x - end.x) : 0.1,
+      // TODO use route width
+      height: isVert ? Math.abs(start.y - end.y) : 0.1,
+      // TODO use route width
+      connectedTo: [source_trace_id]
+    };
+    obstacles.push(obstacle);
+    if (prev && prev.layer === start.layer && start.layer !== end.layer) {
+      const via = {
+        type: "rect",
+        layers: [start.layer, end.layer],
+        center: {
+          x: start.x,
+          y: start.y
+        },
+        connectedTo: [source_trace_id],
+        width: viaDiameter,
+        height: viaDiameter
+      };
+      obstacles.push(via);
+    }
+  }
+  return obstacles;
+};
+
+// lib/utils/obstacles/generateApproximatingRects.ts
+function generateApproximatingRects(rotatedRect, numRects = 4) {
+  const { center, width, height, rotation: rotation2 } = rotatedRect;
+  const rects = [];
+  const angleRad = rotation2 * Math.PI / 180;
+  const cosAngle = Math.cos(angleRad);
+  const sinAngle = Math.sin(angleRad);
+  const normalizedRotation = (rotation2 % 360 + 360) % 360;
+  const sliceAlongWidth = height <= width ? normalizedRotation >= 45 && normalizedRotation < 135 || normalizedRotation >= 225 && normalizedRotation < 315 : normalizedRotation >= 135 && normalizedRotation < 225 || normalizedRotation >= 315 || normalizedRotation < 45;
+  if (sliceAlongWidth) {
+    const sliceWidth = width / numRects;
+    for (let i = 0; i < numRects; i++) {
+      const x = (i - numRects / 2 + 0.5) * sliceWidth;
+      const rotatedX = -x * cosAngle;
+      const rotatedY = -x * sinAngle;
+      const coverageWidth = sliceWidth * 1.1;
+      const coverageHeight = Math.abs(height * cosAngle) + Math.abs(sliceWidth * sinAngle);
+      rects.push({
+        center: {
+          x: center.x + rotatedX,
+          y: center.y + rotatedY
+        },
+        width: coverageWidth,
+        height: coverageHeight
+      });
+    }
+  } else {
+    const sliceHeight = height / numRects;
+    for (let i = 0; i < numRects; i++) {
+      const y = (i - numRects / 2 + 0.5) * sliceHeight;
+      const rotatedX = -y * sinAngle;
+      const rotatedY = y * cosAngle;
+      const coverageWidth = Math.abs(width * cosAngle) + Math.abs(sliceHeight * sinAngle);
+      const coverageHeight = sliceHeight * 1.1;
+      rects.push({
+        center: {
+          x: center.x + rotatedX,
+          y: center.y + rotatedY
+        },
+        width: coverageWidth,
+        height: coverageHeight
+      });
+    }
+  }
+  return rects;
+}
+
+// lib/utils/obstacles/getObstaclesFromCircuitJson.ts
+var EVERY_LAYER = ["top", "inner1", "inner2", "bottom"];
+var getObstaclesFromCircuitJson = (soup, connMap) => {
+  const withNetId = (idList) => connMap ? idList.concat(
+    idList.map((id) => connMap?.getNetConnectedToId(id)).filter(Boolean)
+  ) : idList;
+  const obstacles = [];
+  for (const element of soup) {
+    if (element.type === "pcb_smtpad") {
+      if (element.shape === "circle") {
+        obstacles.push({
+          // @ts-ignore
+          type: "oval",
+          layers: [element.layer],
+          center: {
+            x: element.x,
+            y: element.y
+          },
+          width: element.radius * 2,
+          height: element.radius * 2,
+          connectedTo: withNetId([element.pcb_smtpad_id])
+        });
+      } else if (element.shape === "rect") {
+        obstacles.push({
+          type: "rect",
+          layers: [element.layer],
+          center: {
+            x: element.x,
+            y: element.y
+          },
+          width: element.width,
+          height: element.height,
+          connectedTo: withNetId([element.pcb_smtpad_id])
+        });
+      } else if (element.shape === "rotated_rect") {
+        const rotatedRect = {
+          center: { x: element.x, y: element.y },
+          width: element.width,
+          height: element.height,
+          rotation: element.ccw_rotation
+        };
+        const approximatingRects = generateApproximatingRects(rotatedRect);
+        for (const rect of approximatingRects) {
+          obstacles.push({
+            type: "rect",
+            layers: [element.layer],
+            center: rect.center,
+            width: rect.width,
+            height: rect.height,
+            connectedTo: withNetId([element.pcb_smtpad_id])
+          });
+        }
+      }
+    } else if (element.type === "pcb_keepout") {
+      if (element.shape === "circle") {
+        obstacles.push({
+          // @ts-ignore
+          type: "oval",
+          layers: element.layers,
+          center: {
+            x: element.center.x,
+            y: element.center.y
+          },
+          width: element.radius * 2,
+          height: element.radius * 2,
+          connectedTo: []
+        });
+      } else if (element.shape === "rect") {
+        obstacles.push({
+          type: "rect",
+          layers: element.layers,
+          center: {
+            x: element.center.x,
+            y: element.center.y
+          },
+          width: element.width,
+          height: element.height,
+          connectedTo: []
+        });
+      }
+    } else if (element.type === "pcb_hole") {
+      if (element.hole_shape === "oval") {
+        obstacles.push({
+          // @ts-ignore
+          type: "oval",
+          center: {
+            x: element.x,
+            y: element.y
+          },
+          width: element.hole_width,
+          height: element.hole_height,
+          connectedTo: []
+        });
+      } else if (element.hole_shape === "square") {
+        obstacles.push({
+          type: "rect",
+          layers: EVERY_LAYER,
+          center: {
+            x: element.x,
+            y: element.y
+          },
+          width: element.hole_diameter,
+          height: element.hole_diameter,
+          connectedTo: []
+        });
+      } else if (
+        // @ts-ignore
+        element.hole_shape === "round" || element.hole_shape === "circle"
+      ) {
+        obstacles.push({
+          type: "rect",
+          layers: EVERY_LAYER,
+          center: {
+            x: element.x,
+            y: element.y
+          },
+          width: element.hole_diameter,
+          height: element.hole_diameter,
+          connectedTo: []
+        });
+      }
+    } else if (element.type === "pcb_plated_hole") {
+      if (element.shape === "circle") {
+        obstacles.push({
+          // @ts-ignore
+          type: "oval",
+          layers: EVERY_LAYER,
+          center: {
+            x: element.x,
+            y: element.y
+          },
+          width: element.outer_diameter,
+          height: element.outer_diameter,
+          connectedTo: withNetId([element.pcb_plated_hole_id])
+        });
+      } else if (element.shape === "circular_hole_with_rect_pad") {
+        obstacles.push({
+          // @ts-ignore
+          type: "rect",
+          layers: EVERY_LAYER,
+          center: {
+            x: element.x,
+            y: element.y
+          },
+          width: element.rect_pad_width,
+          height: element.rect_pad_height,
+          connectedTo: withNetId([element.pcb_plated_hole_id])
+        });
+      } else if (element.shape === "oval" || element.shape === "pill") {
+        obstacles.push({
+          // @ts-ignore
+          type: "oval",
+          layers: EVERY_LAYER,
+          center: {
+            x: element.x,
+            y: element.y
+          },
+          width: element.outer_width,
+          height: element.outer_height,
+          connectedTo: withNetId([element.pcb_plated_hole_id])
+        });
+      }
+    } else if (element.type === "pcb_trace") {
+      const traceObstacles = getObstaclesFromRoute(
+        element.route.map((rp) => ({
+          x: rp.x,
+          y: rp.y,
+          layer: "layer" in rp ? rp.layer : rp.from_layer
+        })),
+        element.source_trace_id
+      );
+      obstacles.push(...traceObstacles);
+    } else if (element.type === "pcb_via") {
+      obstacles.push({
+        type: "rect",
+        layers: element.layers,
+        center: {
+          x: element.x,
+          y: element.y
+        },
+        connectedTo: [],
+        // TODO we can associate source_ports with this via
+        width: element.outer_diameter,
+        height: element.outer_diameter
+      });
+    }
+  }
+  return obstacles;
+};
+
 // lib/components/primitive-components/Trace/Trace.ts
 var portToObjective = (port) => {
   const portPosition = port._getGlobalPcbPositionAfterLayout();
@@ -4613,7 +4893,7 @@ searched component ${targetComponent.getString()}, which has ports: ${targetComp
       this.root.db.toArray()
     );
     const [obstacles, errGettingObstacles] = tryNow(
-      () => getObstaclesFromSoup(this.root.db.toArray())
+      () => getObstaclesFromCircuitJson(this.root.db.toArray())
       // Remove as any when autorouting-dataset gets updated
     );
     if (errGettingObstacles) {
@@ -6310,7 +6590,6 @@ var applyEditEvents = ({
 };
 
 // lib/utils/autorouting/getSimpleRouteJsonFromCircuitJson.ts
-import { getObstaclesFromSoup as getObstaclesFromSoup2 } from "@tscircuit/infgrid-ijump-astar";
 import { su as su4 } from "@tscircuit/circuit-json-util";
 import {
   getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson2
@@ -6365,7 +6644,7 @@ var getSimpleRouteJsonFromCircuitJson = ({
   const board = db.pcb_board.list()[0];
   db = su4(subcircuitElements);
   const connMap = getFullConnectivityMapFromCircuitJson2(subcircuitElements);
-  const obstacles = getObstaclesFromSoup2(
+  const obstacles = getObstaclesFromCircuitJson(
     [
       ...db.pcb_component.list(),
       ...db.pcb_smtpad.list(),
@@ -9898,7 +10177,7 @@ import { identity as identity4 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.479",
+  version: "0.0.481",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.480",
+  "version": "0.0.482",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",