@tscircuit/core 0.0.1429 → 0.0.1430

package/dist/index.js

@@ -2546,51 +2546,29 @@ var isRouteOutsideBoard = ({
   );
 };
 
-// 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],
+// lib/utils/obstacles/fillCircleWithRects.ts
+function fillCircleWithRects(circle, options = {}) {
+  const { center, radius } = circle;
+  const { rectHeight = 0.1 } = options;
+  const rects = [];
+  const numSlices = Math.ceil(radius * 2 / rectHeight);
+  for (let i = 0; i < numSlices; i++) {
+    const y = center.y - radius + (i + 0.5) * rectHeight;
+    const dy = y - center.y;
+    const halfWidth = Math.sqrt(radius * radius - dy * dy);
+    if (halfWidth > 0) {
+      rects.push({
         center: {
-          x: start.x,
-          y: start.y
+          x: center.x,
+          y
         },
-        connectedTo: [source_trace_id],
-        width: viaDiameter,
-        height: viaDiameter
-      };
-      obstacles.push(via);
+        width: halfWidth * 2,
+        height: rectHeight
+      });
     }
   }
-  return obstacles;
-};
+  return rects;
+}
 
 // lib/utils/obstacles/fillPolygonWithRects.ts
 function fillPolygonWithRects(polygon, options = {}) {
@@ -2633,29 +2611,88 @@ function fillPolygonWithRects(polygon, options = {}) {
   return rects;
 }
 
-// lib/utils/obstacles/fillCircleWithRects.ts
-function fillCircleWithRects(circle, options = {}) {
-  const { center, radius } = circle;
-  const { rectHeight = 0.1 } = options;
-  const rects = [];
-  const numSlices = Math.ceil(radius * 2 / rectHeight);
-  for (let i = 0; i < numSlices; i++) {
-    const y = center.y - radius + (i + 0.5) * rectHeight;
-    const dy = y - center.y;
-    const halfWidth = Math.sqrt(radius * radius - dy * dy);
-    if (halfWidth > 0) {
-      rects.push({
+// lib/utils/obstacles/getAxisAlignedRectFromPolygon.ts
+var AXIS_ALIGNED_RECT_TOLERANCE_MM = 1e-3;
+var getAxisAlignedRectFromPolygon = (points) => {
+  const isCloseTo2 = (a, b) => Math.abs(a - b) <= AXIS_ALIGNED_RECT_TOLERANCE_MM;
+  const normalizedPoints = points.filter(
+    (point6, index) => index === 0 || !isCloseTo2(point6.x, points[index - 1].x) || !isCloseTo2(point6.y, points[index - 1].y)
+  );
+  if (normalizedPoints.length > 1 && isCloseTo2(normalizedPoints[0].x, normalizedPoints.at(-1).x) && isCloseTo2(normalizedPoints[0].y, normalizedPoints.at(-1).y)) {
+    normalizedPoints.pop();
+  }
+  if (normalizedPoints.length < 4) return null;
+  const minX = Math.min(...normalizedPoints.map((point6) => point6.x));
+  const maxX = Math.max(...normalizedPoints.map((point6) => point6.x));
+  const minY = Math.min(...normalizedPoints.map((point6) => point6.y));
+  const maxY = Math.max(...normalizedPoints.map((point6) => point6.y));
+  const expectedCorners = [
+    { x: minX, y: minY },
+    { x: minX, y: maxY },
+    { x: maxX, y: minY },
+    { x: maxX, y: maxY }
+  ];
+  if (!normalizedPoints.every(
+    (point6) => isCloseTo2(point6.x, minX) || isCloseTo2(point6.x, maxX) || isCloseTo2(point6.y, minY) || isCloseTo2(point6.y, maxY)
+  ) || !expectedCorners.every(
+    (corner) => normalizedPoints.some(
+      (point6) => isCloseTo2(point6.x, corner.x) && isCloseTo2(point6.y, corner.y)
+    )
+  )) {
+    return null;
+  }
+  return {
+    center: { x: (minX + maxX) / 2, y: (minY + maxY) / 2 },
+    width: maxX - minX,
+    height: maxY - minY
+  };
+};
+
+// 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: center.x,
-          y
+          x: start.x,
+          y: start.y
         },
-        width: halfWidth * 2,
-        height: rectHeight
-      });
+        connectedTo: [source_trace_id],
+        width: viaDiameter,
+        height: viaDiameter
+      };
+      obstacles.push(via);
     }
   }
-  return rects;
-}
+  return obstacles;
+};
 
 // lib/utils/obstacles/getObstaclesFromCircuitJson.ts
 var EVERY_LAYER = ["top", "inner1", "inner2", "bottom"];
@@ -2729,7 +2766,7 @@ var getObstaclesFromCircuitJson = (circuitJson, connMap) => {
           center: rect.center,
           width: rect.width,
           height: rect.height,
-          ccwRotationDegrees: element.ccw_rotation,
+          ccwRotationDegrees: axisAlignedRect ? void 0 : element.ccw_rotation,
           connectedTo: withNetId([element.pcb_smtpad_id])
         });
       } else if (element.shape === "pill" || element.shape === "rotated_pill") {
@@ -2747,24 +2784,31 @@ var getObstaclesFromCircuitJson = (circuitJson, connMap) => {
           connectedTo: withNetId([element.pcb_smtpad_id])
         });
       } else if (element.shape === "polygon") {
-        const xs = element.points.map((point6) => point6.x);
-        const ys = element.points.map((point6) => point6.y);
-        const minX = Math.min(...xs);
-        const maxX = Math.max(...xs);
-        const minY = Math.min(...ys);
-        const maxY = Math.max(...ys);
-        obstacles.push({
-          componentId: pcbComponentId,
-          type: "rect",
-          layers: [element.layer],
-          center: {
-            x: (minX + maxX) / 2,
-            y: (minY + maxY) / 2
-          },
-          width: maxX - minX,
-          height: maxY - minY,
-          connectedTo: withNetId([element.pcb_smtpad_id])
+        const axisAlignedRect = getAxisAlignedRectFromPolygon(element.points);
+        if (axisAlignedRect) {
+          obstacles.push({
+            componentId: pcbComponentId,
+            type: "rect",
+            layers: [element.layer],
+            ...axisAlignedRect,
+            connectedTo: withNetId([element.pcb_smtpad_id])
+          });
+          continue;
+        }
+        const approximatingRects = fillPolygonWithRects(element.points, {
+          rectHeight: 0.1
         });
+        for (const rect of approximatingRects) {
+          obstacles.push({
+            componentId: pcbComponentId,
+            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") {
@@ -22352,7 +22396,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1428",
+  version: "0.0.1429",
   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.1429",
+  "version": "0.0.1430",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",