altium-to-circuit-json 0.0.82 → 0.0.84

package/dist/index.js

@@ -465,15 +465,6 @@ function createPcbConversionContext({
   };
 }
 
-// lib/schematic/document/constants.ts
-var SCHEMATIC_SHEET_ID = "schematic_sheet_altium";
-var SCHEMATIC_UNIT_TO_MILLIMETERS = 10.16 / 1.1;
-var SCHEMATIC_SHEET_INSET = 5 / SCHEMATIC_UNIT_TO_MILLIMETERS;
-var SCHEMATIC_SHEET_WIDTH = 297 / SCHEMATIC_UNIT_TO_MILLIMETERS;
-var SCHEMATIC_SHEET_HEIGHT = 210 / SCHEMATIC_UNIT_TO_MILLIMETERS;
-var SCHEMATIC_SHEET_INNER_WIDTH = SCHEMATIC_SHEET_WIDTH - SCHEMATIC_SHEET_INSET * 2;
-var SCHEMATIC_SHEET_INNER_HEIGHT = SCHEMATIC_SHEET_HEIGHT - SCHEMATIC_SHEET_INSET * 2;
-
 // lib/schematic/geometry/getAveragePoint.ts
 function getAveragePoint(points) {
   if (points.length === 0) return { x: 0, y: 0 };
@@ -616,6 +607,15 @@ function unscaleLength(lengthMillimeters, altiumUnitsToMillimetersScale) {
   }).x;
 }
 
+// lib/schematic/document/constants.ts
+var SCHEMATIC_SHEET_ID = "schematic_sheet_altium";
+var SCHEMATIC_UNIT_TO_MILLIMETERS = 10.16 / 1.1;
+var SCHEMATIC_SHEET_INSET = 5 / SCHEMATIC_UNIT_TO_MILLIMETERS;
+var SCHEMATIC_SHEET_WIDTH = 297 / SCHEMATIC_UNIT_TO_MILLIMETERS;
+var SCHEMATIC_SHEET_HEIGHT = 210 / SCHEMATIC_UNIT_TO_MILLIMETERS;
+var SCHEMATIC_SHEET_INNER_WIDTH = SCHEMATIC_SHEET_WIDTH - SCHEMATIC_SHEET_INSET * 2;
+var SCHEMATIC_SHEET_INNER_HEIGHT = SCHEMATIC_SHEET_HEIGHT - SCHEMATIC_SHEET_INSET * 2;
+
 // lib/schematic/document/getPositiveNumber.ts
 function getPositiveNumber(candidate, fallback) {
   const parsed = Number(candidate);
@@ -623,11 +623,43 @@ function getPositiveNumber(candidate, fallback) {
 }
 
 // lib/schematic/document/getAltiumSheetDimensions.ts
+var STANDARD_SHEET_SIZES = [
+  { width: 1150, height: 760 },
+  { width: 1550, height: 1110 },
+  { width: 2230, height: 1570 },
+  { width: 3150, height: 2230 },
+  { width: 4460, height: 3150 },
+  { width: 950, height: 750 },
+  { width: 1500, height: 950 },
+  { width: 2e3, height: 1500 },
+  { width: 3200, height: 2e3 },
+  { width: 4200, height: 3200 },
+  { width: 1100, height: 850 },
+  { width: 1400, height: 850 },
+  { width: 1700, height: 1100 },
+  { width: 990, height: 790 },
+  { width: 1540, height: 990 },
+  { width: 2060, height: 1560 },
+  { width: 3260, height: 2060 },
+  { width: 4280, height: 3280 }
+];
 function getAltiumSheetDimensions(sheetRecord) {
-  return {
+  const customDimensions = {
     width: getPositiveNumber(sheetRecord?.getCaseInsensitive("CUSTOMX"), 1e3),
     height: getPositiveNumber(sheetRecord?.getCaseInsensitive("CUSTOMY"), 800)
   };
+  const sheetStyle = sheetRecord?.getCaseInsensitive("SHEETSTYLE");
+  if (sheetRecord?.getCaseInsensitive("USECUSTOMSHEET") === "T" || sheetStyle === void 0) {
+    return customDimensions;
+  }
+  const standardDimensions = STANDARD_SHEET_SIZES[Number(sheetStyle)];
+  if (!standardDimensions) {
+    throw new RangeError(
+      `Unsupported Altium schematic sheet style: ${sheetStyle}`
+    );
+  }
+  const isPortrait = Number(sheetRecord?.getCaseInsensitive("WORKSPACEORIENTATION") ?? 0) !== 0;
+  return isPortrait ? { width: standardDimensions.height, height: standardDimensions.width } : standardDimensions;
 }
 
 // lib/schematic/document/createSheetBorder.ts
@@ -650,12 +682,26 @@ function createSheetBorder(sheetRecord, scale5) {
 
 // lib/schematic/document/addSchematicSheet.ts
 function addSchematicSheet(context) {
+  const scaledSheetWidth = scaleLength(
+    context.sheetDimensions.width,
+    context.scale
+  );
+  const scaledSheetHeight = scaleLength(
+    context.sheetDimensions.height,
+    context.scale
+  );
+  const usesCustomSheet = context.sheetRecord?.getCaseInsensitive("USECUSTOMSHEET") === "T";
+  const sheetDimensions = usesCustomSheet ? {
+    sheet_width: scaledSheetWidth * SCHEMATIC_UNIT_TO_MILLIMETERS,
+    sheet_height: scaledSheetHeight * SCHEMATIC_UNIT_TO_MILLIMETERS
+  } : {};
   context.elements.push({
     type: "schematic_sheet",
     schematic_sheet_id: SCHEMATIC_SHEET_ID,
     name: context.options.sheetName ?? "Altium schematic",
     outline_color: "#334155",
-    sheet_index: 0
+    sheet_index: 0,
+    ...sheetDimensions
   });
   if (context.options.includeSheetBorder === true) {
     context.elements.push(createSheetBorder(context.sheetRecord, context.scale));
@@ -5181,7 +5227,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 +5265,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 +5281,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 +5331,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 +5364,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 +5469,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 +5919,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);