@tscircuit/core 0.0.2013 → 0.0.2014

package/dist/index.js

@@ -3196,6 +3196,53 @@ function fillPolygonWithRects(polygon, options = {}) {
   return rects;
 }
 
+// lib/utils/obstacles/generateApproximatingRects.ts
+function generateApproximatingRects(rotatedRect, numRects = 2) {
+  const { center, width, height, rotation: rotation5 } = rotatedRect;
+  const rects = [];
+  const angleRad = rotation5 * Math.PI / 180;
+  const cosAngle = Math.cos(angleRad);
+  const sinAngle = Math.sin(angleRad);
+  const normalizedRotation = (rotation5 % 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/getAxisAlignedRectFromPolygon.ts
 var AXIS_ALIGNED_RECT_TOLERANCE_MM = 1e-3;
 var getAxisAlignedRectFromPolygon = (points) => {
@@ -3233,6 +3280,59 @@ var getAxisAlignedRectFromPolygon = (points) => {
   };
 };
 
+// lib/utils/obstacles/getObstaclesFromPcbKeepoutOutline.ts
+var getObstaclesFromPcbKeepoutOutline = (keepout, componentId) => {
+  const { outline, stroke_width } = keepout;
+  if (!Number.isFinite(stroke_width) || stroke_width <= 0) return [];
+  const obstacles = [];
+  for (let segmentIndex = 0; segmentIndex < outline.length - 1; segmentIndex++) {
+    const start = outline[segmentIndex];
+    const end = outline[segmentIndex + 1];
+    const deltaX = end.x - start.x;
+    const deltaY = end.y - start.y;
+    const segmentLength = Math.hypot(deltaX, deltaY);
+    if (!Number.isFinite(segmentLength) || segmentLength === 0) continue;
+    const approximatingRects = generateApproximatingRects({
+      center: {
+        x: (start.x + end.x) / 2,
+        y: (start.y + end.y) / 2
+      },
+      width: segmentLength,
+      height: stroke_width,
+      rotation: Math.atan2(deltaY, deltaX) * 180 / Math.PI
+    });
+    for (const [approximationIndex, rect] of approximatingRects.entries()) {
+      obstacles.push({
+        obstacleId: `${keepout.pcb_keepout_id}_segment_${segmentIndex}_rect_${approximationIndex}`,
+        componentId,
+        type: "rect",
+        layers: keepout.layers,
+        ...rect,
+        connectedTo: []
+      });
+    }
+  }
+  const isClosed = outline.length > 1 && outline[0].x === outline.at(-1)?.x && outline[0].y === outline.at(-1)?.y;
+  const joinPoints = isClosed ? outline.slice(0, -1) : outline;
+  for (const [joinIndex, point6] of joinPoints.entries()) {
+    const approximatingRects = fillCircleWithRects(
+      { center: point6, radius: stroke_width / 2 },
+      { rectHeight: stroke_width / 4 }
+    );
+    for (const [approximationIndex, rect] of approximatingRects.entries()) {
+      obstacles.push({
+        obstacleId: `${keepout.pcb_keepout_id}_join_${joinIndex}_rect_${approximationIndex}`,
+        componentId,
+        type: "rect",
+        layers: keepout.layers,
+        ...rect,
+        connectedTo: []
+      });
+    }
+  }
+  return obstacles;
+};
+
 // lib/utils/obstacles/getObstaclesFromRoute.ts
 var isCloseTo = (a, b) => Math.abs(a - b) < 1e-4;
 var getObstaclesFromRoute = (route, source_trace_id, { viaDiameter = 0.5 } = {}) => {
@@ -3472,6 +3572,10 @@ var getObstaclesFromCircuitJson = (circuitJson, connMap) => {
           height: element.height,
           connectedTo: []
         });
+      } else if (element.shape === "outline") {
+        obstacles.push(
+          ...getObstaclesFromPcbKeepoutOutline(element, pcbComponentId)
+        );
       }
     } else if (element.type === "pcb_cutout") {
       if (element.shape === "rect") {
@@ -64471,7 +64575,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.2012",
+  version: "0.0.2013",
   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.2013",
+  "version": "0.0.2014",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",