altium-to-circuit-json 0.0.78 → 0.0.80

package/dist/index.js

@@ -5288,32 +5288,68 @@ function getMeasurement(record, key) {
   return parseAltiumMeasurementToMils2(record.getCaseInsensitive(key));
 }
 
-// lib/pcb/annotations/convertPcbDimension.ts
-function convertPcbDimension({
-  record,
-  recordIndex
-}) {
+// lib/pcb/annotations/getDimensionAxis.ts
+import { applyToPoint as applyToPoint9, rotateDEG as rotateDEG4 } from "transformation-matrix";
+function getDimensionAxis(record) {
+  const angleDegrees = record.getNumber("ANGLE");
+  if (angleDegrees !== void 0 && Number.isFinite(angleDegrees)) {
+    return applyToPoint9(rotateDEG4(angleDegrees), { x: 1, y: 0 });
+  }
   const start = record.start;
   const end = record.end;
-  if (!start || !end) return void 0;
+  if (!start || !end) return { x: 1, y: 0 };
   const deltaX = end.x - start.x;
   const deltaY = end.y - start.y;
-  const lengthMils = Math.hypot(deltaX, deltaY);
+  const distance = Math.hypot(deltaX, deltaY);
+  if (distance === 0) return { x: 1, y: 0 };
+  return { x: deltaX / distance, y: deltaY / distance };
+}
+
+// lib/pcb/annotations/getPcbDimensionProjection.ts
+function getPcbDimensionProjection(record) {
+  const referenceStart = record.start;
+  const referenceEnd = record.end;
+  if (!referenceStart || !referenceEnd) return void 0;
+  const axis = getDimensionAxis(record);
+  const deltaX = referenceEnd.x - referenceStart.x;
+  const deltaY = referenceEnd.y - referenceStart.y;
+  const signedLengthMils = deltaX * axis.x + deltaY * axis.y;
+  const lengthMils = Math.abs(signedLengthMils);
   if (lengthMils === 0) return void 0;
+  return {
+    axis,
+    lengthMils,
+    projectedEnd: {
+      x: referenceStart.x + axis.x * signedLengthMils,
+      y: referenceStart.y + axis.y * signedLengthMils
+    },
+    referenceEnd,
+    referenceStart
+  };
+}
+
+// lib/pcb/annotations/convertPcbDimension.ts
+function convertPcbDimension({
+  record,
+  recordIndex
+}) {
+  const projection = getPcbDimensionProjection(record);
+  if (!projection) return void 0;
+  const { axis, lengthMils, projectedEnd, referenceStart } = projection;
   const perpendicular = {
-    x: -deltaY / lengthMils,
-    y: deltaX / lengthMils
+    x: -axis.y,
+    y: axis.x
   };
-  const lineAnchor = record.dimensionLineAnchor ?? start;
-  const signedOffsetMils = (lineAnchor.x - start.x) * perpendicular.x + (lineAnchor.y - start.y) * perpendicular.y;
+  const lineAnchor = record.dimensionLineAnchor ?? referenceStart;
+  const signedOffsetMils = (lineAnchor.x - referenceStart.x) * perpendicular.x + (lineAnchor.y - referenceStart.y) * perpendicular.y;
   const offsetSign = signedOffsetMils < 0 ? -1 : 1;
   return {
     type: "pcb_fabrication_note_dimension",
     pcb_fabrication_note_dimension_id: `pcb_fabrication_note_dimension_altium_${recordIndex}`,
     pcb_component_id: BOARD_GRAPHICS_COMPONENT_ID,
     layer: mapMechanicalLayer(getRecordLayer(record)),
-    from: toMillimeterPoint(start),
-    to: toMillimeterPoint(end),
+    from: toMillimeterPoint(referenceStart),
+    to: toMillimeterPoint(projectedEnd),
     text: getDimensionText(record, lengthMils),
     offset_distance: milsToMillimeters(Math.abs(signedOffsetMils)),
     offset_direction: {
@@ -5327,6 +5363,45 @@ function convertPcbDimension({
   };
 }
 
+// lib/pcb/annotations/convertPcbDimensionExtensionPath.ts
+var REFERENCE_ALIGNMENT_TOLERANCE_MILS = 1e-6;
+function convertPcbDimensionExtensionPath({
+  record,
+  recordIndex
+}) {
+  const projection = getPcbDimensionProjection(record);
+  if (!projection) return void 0;
+  const { projectedEnd, referenceEnd } = projection;
+  const referenceGapMils = Math.hypot(
+    referenceEnd.x - projectedEnd.x,
+    referenceEnd.y - projectedEnd.y
+  );
+  if (referenceGapMils <= REFERENCE_ALIGNMENT_TOLERANCE_MILS) return void 0;
+  return {
+    type: "pcb_fabrication_note_path",
+    pcb_fabrication_note_path_id: `pcb_fabrication_note_path_altium_dimension_${recordIndex}_reference_extension`,
+    pcb_component_id: BOARD_GRAPHICS_COMPONENT_ID,
+    layer: mapMechanicalLayer(getRecordLayer(record)),
+    route: [referenceEnd, projectedEnd].map(toMillimeterPoint),
+    stroke_width: milsToMillimeters(record.lineWidthMils ?? 8),
+    color: FABRICATION_NOTE_COLOR
+  };
+}
+
+// lib/pcb/annotations/convertPcbDimensionElements.ts
+function convertPcbDimensionElements({
+  record,
+  recordIndex
+}) {
+  const dimension = convertPcbDimension({ record, recordIndex });
+  if (!dimension) return [];
+  const extensionPath = convertPcbDimensionExtensionPath({
+    record,
+    recordIndex
+  });
+  return extensionPath ? [dimension, extensionPath] : [dimension];
+}
+
 // lib/pcb/annotations/convertPcbFabricationNotePath.ts
 import {
   AltiumTrackRecord as AltiumTrackRecord6,
@@ -5724,10 +5799,10 @@ import {
 import { normalizeAltiumAngle } from "altiumts";
 
 // lib/pcb/pads/getRotatedHoleOffset.ts
-import { applyToPoint as applyToPoint9, rotateDEG as rotateDEG4 } from "transformation-matrix";
+import { applyToPoint as applyToPoint10, rotateDEG as rotateDEG5 } from "transformation-matrix";
 function getRotatedHoleOffset(geometry) {
-  const padToPcbTransform = rotateDEG4(geometry.ccwRotationDegrees);
-  return applyToPoint9(padToPcbTransform, {
+  const padToPcbTransform = rotateDEG5(geometry.ccwRotationDegrees);
+  return applyToPoint10(padToPcbTransform, {
     x: geometry.holeOffsetXMils,
     y: geometry.holeOffsetYMils
   });
@@ -6076,8 +6151,7 @@ function convertPcbRecords(context) {
     }
     if (record instanceof AltiumDimensionRecord) {
       if (options.includeDimensions === false) continue;
-      const dimension = convertPcbDimension({ record, recordIndex });
-      if (dimension) elements.push(dimension);
+      elements.push(...convertPcbDimensionElements({ record, recordIndex }));
       continue;
     }
     if (options.includeDimensions !== false && isExplodedPcbDimensionGraphic(document, record)) {