altium-to-circuit-json 0.0.82 → 0.0.83

package/dist/index.js

@@ -5181,7 +5181,10 @@ function contourToPoints(contour) {
 import {
   AltiumFillRecord,
   AltiumPolygonRecord,
-  AltiumRegionRecord as AltiumRegionRecord3
+  AltiumRegionRecord as AltiumRegionRecord3,
+  getPcbContour as getPcbContour2,
+  getPcbRecordPolygonIndex,
+  getPcbRegionGeometry as getPcbRegionGeometry5
 } from "altiumts";
 
 // lib/pcb/copperAreas/convertCopperFill.ts
@@ -5216,8 +5219,13 @@ function convertCopperFill({
 }
 
 // lib/pcb/copperAreas/convertCopperPolygon.ts
-import { getPcbContour } from "altiumts";
+import {
+  getPcbContour,
+  getPcbRegionGeometry as getPcbRegionGeometry3
+} from "altiumts";
+import polygonClipping from "polygon-clipping";
 function convertCopperPolygon({
+  cutouts,
   polygonIndex,
   layerMap,
   record,
@@ -5227,21 +5235,45 @@ function convertCopperPolygon({
   if (!layer) return [];
   const points = contourToPoints(getPcbContour(record));
   if (points.length < 3) return [];
-  return [
-    {
-      type: "pcb_copper_pour",
-      pcb_copper_pour_id: `pcb_copper_pour_altium_polygon_${polygonIndex}`,
-      ...sourceNetId ? { source_net_id: sourceNetId } : {},
-      covered_with_solder_mask: true,
-      layer,
-      shape: "polygon",
-      points
+  const cutoutPolygons = cutouts.map((cutout) => {
+    const geometry = getPcbRegionGeometry3(cutout);
+    return [geometry.outline, ...geometry.holes].map(
+      (contour) => contourToPoints(contour).map((point) => [point.x, point.y])
+    );
+  });
+  const copperPolygons = cutouts.length === 0 ? [[points]] : polygonClipping.difference(
+    [points.map((point) => [point.x, point.y])],
+    cutoutPolygons
+  ).map(
+    (polygon) => polygon.map(
+      (ring) => ring.slice(0, -1).map(([x, y]) => ({ x, y }))
+    )
+  );
+  return copperPolygons.flatMap(
+    ([outerRing, ...holes], partIndex) => {
+      if (!outerRing || outerRing.length < 3) return [];
+      return [
+        {
+          type: "pcb_copper_pour",
+          pcb_copper_pour_id: `pcb_copper_pour_altium_polygon_${polygonIndex}${partIndex === 0 ? "" : `_island_${partIndex}`}`,
+          ...sourceNetId ? { source_net_id: sourceNetId } : {},
+          covered_with_solder_mask: true,
+          layer,
+          ...holes.length === 0 ? { shape: "polygon", points: outerRing } : {
+            shape: "brep",
+            brep_shape: {
+              outer_ring: { vertices: outerRing },
+              inner_rings: holes.map((vertices) => ({ vertices }))
+            }
+          }
+        }
+      ];
     }
-  ];
+  );
 }
 
 // lib/pcb/copperAreas/convertCopperRegion.ts
-import { getPcbRegionGeometry as getPcbRegionGeometry3 } from "altiumts";
+import { getPcbRegionGeometry as getPcbRegionGeometry4 } from "altiumts";
 function convertCopperRegion({
   layerMap,
   record,
@@ -5253,7 +5285,7 @@ function convertCopperRegion({
   }
   const layer = layerMap.getLayer(record.layer);
   if (!layer) return [];
-  const geometry = getPcbRegionGeometry3(record);
+  const geometry = getPcbRegionGeometry4(record);
   const outerVertices = contourToPoints(geometry.outline);
   if (outerVertices.length < 3) return [];
   const innerRings = geometry.holes.map((hole) => ({ vertices: contourToPoints(hole) })).filter((ring) => ring.vertices.length >= 3);
@@ -5286,20 +5318,97 @@ function convertCopperRegion({
   ];
 }
 
+// lib/pcb/copperAreas/isContourInsideContour.ts
+import { doesLineIntersectLine } from "@tscircuit/math-utils";
+function isContourInsideContour({
+  innerContour,
+  outerContour
+}) {
+  const innerBounds = innerContour.bounds;
+  const outerBounds = outerContour.bounds;
+  if (!innerBounds || !outerBounds || innerBounds.minX <= outerBounds.minX || innerBounds.maxX >= outerBounds.maxX || innerBounds.minY <= outerBounds.minY || innerBounds.maxY >= outerBounds.maxY) {
+    return false;
+  }
+  const innerPoints = innerContour.isExplicitlyClosed ? innerContour.points.slice(0, -1) : innerContour.points;
+  const outerPoints = outerContour.isExplicitlyClosed ? outerContour.points.slice(0, -1) : outerContour.points;
+  if (innerPoints.length < 3 || outerPoints.length < 3) return false;
+  const toleranceMils = 8 * Number.EPSILON * Math.max(
+    1,
+    Math.abs(outerBounds.minX),
+    Math.abs(outerBounds.maxX),
+    Math.abs(outerBounds.minY),
+    Math.abs(outerBounds.maxY)
+  );
+  for (const point of innerPoints) {
+    let isInside = false;
+    for (let index = 0; index < outerPoints.length; index++) {
+      const start = outerPoints[index];
+      const end = outerPoints[(index + 1) % outerPoints.length];
+      if (!start || !end) continue;
+      if (start.y > point.y !== end.y > point.y && point.x < start.x + (point.y - start.y) * (end.x - start.x) / (end.y - start.y)) {
+        isInside = !isInside;
+      }
+    }
+    if (!isInside) return false;
+  }
+  for (let innerIndex = 0; innerIndex < innerPoints.length; innerIndex++) {
+    const innerStart = innerPoints[innerIndex];
+    const innerEnd = innerPoints[(innerIndex + 1) % innerPoints.length];
+    if (!innerStart || !innerEnd) continue;
+    for (let outerIndex = 0; outerIndex < outerPoints.length; outerIndex++) {
+      const outerStart = outerPoints[outerIndex];
+      const outerEnd = outerPoints[(outerIndex + 1) % outerPoints.length];
+      if (!outerStart || !outerEnd) continue;
+      if (doesLineIntersectLine([innerStart, innerEnd], [outerStart, outerEnd], {
+        lineThickness: toleranceMils
+      })) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
 // lib/pcb/copperAreas/convertAltiumCopperAreas.ts
 function convertAltiumCopperAreas(document, {
   layerMap = new PcbCopperLayerMap(document),
   getSourceNetId = () => void 0
 } = {}) {
-  const polygonsWithRegions = new Set(
-    document.records.flatMap((record) => {
-      if (!(record instanceof AltiumRegionRecord3) || record.recordKind !== "Region") {
-        return [];
+  const polygonsWithCopperRegions = /* @__PURE__ */ new Set();
+  const cutoutsByPolygon = /* @__PURE__ */ new Map();
+  const polygonContours = /* @__PURE__ */ new Map();
+  for (const record of document.records) {
+    if (!(record instanceof AltiumRegionRecord3) || record.recordKind !== "Region") {
+      continue;
+    }
+    const polygonIndex = getPcbRecordPolygonIndex(document, record);
+    const linkedPolygon = document.getPolygonForRecord(record);
+    if (record.regionKind === "COPPER") {
+      if (linkedPolygon) polygonsWithCopperRegions.add(linkedPolygon);
+    } else if (record.regionKind === "POLYGON_CUTOUT") {
+      const cutoutGeometry = getPcbRegionGeometry5(record);
+      const candidatePolygons = polygonIndex === void 0 ? document.polygons : linkedPolygon ? [linkedPolygon] : [];
+      const polygons = candidatePolygons.filter((polygon) => {
+        if (record.layer !== polygon.layer && record.layer !== "MULTILAYER") {
+          return false;
+        }
+        let polygonContour = polygonContours.get(polygon);
+        if (!polygonContour) {
+          polygonContour = getPcbContour2(polygon);
+          polygonContours.set(polygon, polygonContour);
+        }
+        return isContourInsideContour({
+          innerContour: cutoutGeometry.outline,
+          outerContour: polygonContour
+        });
+      });
+      for (const polygon of polygons) {
+        const cutouts = cutoutsByPolygon.get(polygon) ?? [];
+        cutouts.push(record);
+        cutoutsByPolygon.set(polygon, cutouts);
       }
-      const polygon = document.getPolygonForRecord(record);
-      return polygon ? [polygon] : [];
-    })
-  );
+    }
+  }
   const polygonIndexes = new Map(
     document.polygons.map((polygon, index) => [polygon, index])
   );
@@ -5314,10 +5423,11 @@ function convertAltiumCopperAreas(document, {
     }
     if (record instanceof AltiumPolygonRecord) {
       const polygonIndex = polygonIndexes.get(record);
-      if (record.shelved === true || polygonIndex === void 0 || polygonsWithRegions.has(record)) {
+      if (record.shelved === true || polygonIndex === void 0 || polygonsWithCopperRegions.has(record)) {
         return [];
       }
       return convertCopperPolygon({
+        cutouts: cutoutsByPolygon.get(record) ?? [],
         layerMap,
         polygonIndex,
         record,
@@ -5763,12 +5873,12 @@ function convertPcbSilkscreenLine({
 }
 
 // lib/pcb/silkscreen/convertPcbSilkscreenRegion.ts
-import { getPcbRegionGeometry as getPcbRegionGeometry4 } from "altiumts";
+import { getPcbRegionGeometry as getPcbRegionGeometry6 } from "altiumts";
 function convertPcbSilkscreenRegion({
   record,
   recordIndex
 }) {
-  const geometry = getPcbRegionGeometry4(record);
+  const geometry = getPcbRegionGeometry6(record);
   const outerVertices = geometry.outline.points.map(toMillimeterPoint);
   if (outerVertices.length < 3) return void 0;
   const innerRings = geometry.holes.map((hole) => ({ vertices: hole.points.map(toMillimeterPoint) })).filter((ring) => ring.vertices.length >= 3);