circuit-to-canvas 0.0.46 → 0.0.47

package/dist/index.js

@@ -456,6 +456,90 @@ function drawSoldermaskRingForOval(ctx, center, radius_x, radius_y, margin, rota
   }
   ctx.restore();
 }
+function offsetPolygonPoints(points, offset) {
+  if (points.length < 3 || offset === 0) return points;
+  let centerX = 0;
+  let centerY = 0;
+  for (const point of points) {
+    centerX += point.x;
+    centerY += point.y;
+  }
+  centerX /= points.length;
+  centerY /= points.length;
+  const result = [];
+  for (const point of points) {
+    const vectorX = point.x - centerX;
+    const vectorY = point.y - centerY;
+    const distance = Math.sqrt(vectorX * vectorX + vectorY * vectorY);
+    if (distance > 0) {
+      const normalizedX = vectorX / distance;
+      const normalizedY = vectorY / distance;
+      result.push({
+        x: point.x + normalizedX * offset,
+        y: point.y + normalizedY * offset
+      });
+    } else {
+      result.push({
+        x: point.x + offset,
+        y: point.y
+      });
+    }
+  }
+  return result;
+}
+function drawSoldermaskRingForPolygon(ctx, points, margin, realToCanvasMat, soldermaskColor, padColor) {
+  if (points.length < 3 || margin >= 0) return;
+  const scaledMargin = Math.abs(margin) * Math.abs(realToCanvasMat.a);
+  const prevCompositeOp = ctx.globalCompositeOperation;
+  if (ctx.globalCompositeOperation !== void 0) {
+    ctx.globalCompositeOperation = "source-atop";
+  }
+  ctx.beginPath();
+  const canvasPoints = points.map(
+    (p) => applyToPoint6(realToCanvasMat, [p.x, p.y])
+  );
+  const firstPoint = canvasPoints[0];
+  if (firstPoint) {
+    const [firstX, firstY] = firstPoint;
+    ctx.moveTo(firstX, firstY);
+    for (let i = 1; i < canvasPoints.length; i++) {
+      const point = canvasPoints[i];
+      if (point) {
+        const [x, y] = point;
+        ctx.lineTo(x, y);
+      }
+    }
+    ctx.closePath();
+    ctx.fillStyle = soldermaskColor;
+    ctx.fill();
+  }
+  if (ctx.globalCompositeOperation !== void 0) {
+    ctx.globalCompositeOperation = prevCompositeOp || "source-over";
+  }
+  const innerPoints = offsetPolygonPoints(points, margin);
+  if (innerPoints.length >= 3) {
+    ctx.beginPath();
+    const innerCanvasPoints = innerPoints.map(
+      (p) => applyToPoint6(realToCanvasMat, [p.x, p.y])
+    );
+    const firstInnerPoint = innerCanvasPoints[0];
+    if (firstInnerPoint) {
+      const [firstX, firstY] = firstInnerPoint;
+      ctx.moveTo(firstX, firstY);
+      for (let i = 1; i < innerCanvasPoints.length; i++) {
+        const point = innerCanvasPoints[i];
+        if (point) {
+          const [x, y] = point;
+          ctx.lineTo(x, y);
+        }
+      }
+      ctx.closePath();
+      ctx.fillStyle = padColor;
+      ctx.fill();
+    }
+  }
+  ctx.restore();
+}
 
 // lib/drawer/elements/pcb-plated-hole.ts
 function getSoldermaskColor(layers, colorMap) {
@@ -643,7 +727,7 @@ function drawPcbPlatedHole(params) {
         height: hole.rect_pad_height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: (hole.rect_border_radius ?? 0) + margin
+        borderRadius: hole.rect_border_radius ?? 0
       });
     }
     drawRect({
@@ -702,7 +786,7 @@ function drawPcbPlatedHole(params) {
         height: hole.rect_pad_height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: (hole.rect_border_radius ?? 0) + margin
+        borderRadius: hole.rect_border_radius ?? 0
       });
     }
     drawRect({
@@ -762,7 +846,7 @@ function drawPcbPlatedHole(params) {
         height: hole.rect_pad_height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: (hole.rect_border_radius ?? 0) + margin,
+        borderRadius: hole.rect_border_radius ?? 0,
         rotation: hole.rect_ccw_rotation
       });
     }
@@ -824,12 +908,39 @@ function drawPcbPlatedHole(params) {
         x: hole.x + point.x,
         y: hole.y + point.y
       }));
+      if (hasSoldermask && margin > 0) {
+        const expandedPoints = offsetPolygonPoints(padPoints, margin);
+        drawPolygon({
+          ctx,
+          points: expandedPoints,
+          fill: positiveMarginColor,
+          realToCanvasMat
+        });
+      }
       drawPolygon({
         ctx,
         points: padPoints,
         fill: copperColor,
         realToCanvasMat
       });
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForPolygon(
+          ctx,
+          padPoints,
+          margin,
+          realToCanvasMat,
+          soldermaskRingColor,
+          copperColor
+        );
+      }
+      if (isCoveredWithSoldermask) {
+        drawPolygon({
+          ctx,
+          points: padPoints,
+          fill: soldermaskRingColor,
+          realToCanvasMat
+        });
+      }
     }
     if (!isCoveredWithSoldermask) {
       const holeX = hole.x + (hole.hole_offset_x ?? 0);
@@ -1233,7 +1344,7 @@ function drawPcbSmtPad(params) {
         height: pad.height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: getBorderRadius(pad, margin)
+        borderRadius: getBorderRadius(pad)
       });
     }
     drawRect({
@@ -1281,7 +1392,7 @@ function drawPcbSmtPad(params) {
         height: pad.height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: getBorderRadius(pad, margin),
+        borderRadius: getBorderRadius(pad),
         rotation: pad.ccw_rotation ?? 0
       });
     }
@@ -1455,13 +1566,32 @@ function drawPcbSmtPad(params) {
   }
   if (pad.shape === "polygon") {
     if (pad.points && pad.points.length >= 3) {
+      if (hasSoldermask && margin > 0) {
+        const expandedPoints = offsetPolygonPoints(pad.points, margin);
+        drawPolygon({
+          ctx,
+          points: expandedPoints,
+          fill: positiveMarginColor,
+          realToCanvasMat
+        });
+      }
       drawPolygon({
         ctx,
         points: pad.points,
         fill: color,
         realToCanvasMat
       });
-      if (isCoveredWithSoldermask && margin >= 0) {
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForPolygon(
+          ctx,
+          pad.points,
+          margin,
+          realToCanvasMat,
+          soldermaskRingColor,
+          color
+        );
+      }
+      if (isCoveredWithSoldermask && margin === 0) {
         drawPolygon({
           ctx,
           points: pad.points,

package/lib/drawer/elements/pcb-plated-hole.ts

@@ -11,6 +11,8 @@ import {
   drawSoldermaskRingForOval,
   drawSoldermaskRingForPill,
   drawSoldermaskRingForRect,
+  drawSoldermaskRingForPolygon,
+  offsetPolygonPoints,
 } from "./soldermask-margin"
 
 export interface DrawPcbPlatedHoleParams {
@@ -249,7 +251,7 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
         height: hole.rect_pad_height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: (hole.rect_border_radius ?? 0) + margin,
+        borderRadius: hole.rect_border_radius ?? 0,
       })
     }
 
@@ -318,7 +320,7 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
         height: hole.rect_pad_height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: (hole.rect_border_radius ?? 0) + margin,
+        borderRadius: hole.rect_border_radius ?? 0,
       })
     }
 
@@ -388,7 +390,7 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
         height: hole.rect_pad_height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: (hole.rect_border_radius ?? 0) + margin,
+        borderRadius: hole.rect_border_radius ?? 0,
         rotation: hole.rect_ccw_rotation,
       })
     }
@@ -453,8 +455,6 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
   }
 
   if (hole.shape === "hole_with_polygon_pad") {
-    // Note: Polygon pads don't support soldermask margins (similar to SMT polygon pads)
-    // Draw polygon pad
     const padOutline = hole.pad_outline
     if (padOutline && padOutline.length >= 3) {
       // Transform pad_outline points to be relative to hole.x, hole.y
@@ -462,12 +462,47 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
         x: hole.x + point.x,
         y: hole.y + point.y,
       }))
+
+      // For positive margins, draw extended mask area first
+      if (hasSoldermask && margin > 0) {
+        const expandedPoints = offsetPolygonPoints(padPoints, margin)
+        drawPolygon({
+          ctx,
+          points: expandedPoints,
+          fill: positiveMarginColor,
+          realToCanvasMat,
+        })
+      }
+
+      // Draw polygon pad
       drawPolygon({
         ctx,
         points: padPoints,
         fill: copperColor,
         realToCanvasMat,
       })
+
+      // For negative margins, draw soldermask ring on top of the pad
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForPolygon(
+          ctx,
+          padPoints,
+          margin,
+          realToCanvasMat,
+          soldermaskRingColor,
+          copperColor,
+        )
+      }
+
+      // If fully covered, draw soldermask overlay
+      if (isCoveredWithSoldermask) {
+        drawPolygon({
+          ctx,
+          points: padPoints,
+          fill: soldermaskRingColor,
+          realToCanvasMat,
+        })
+      }
     }
 
     // Draw drill hole (with offset, only if not fully covered with soldermask)

package/lib/drawer/elements/pcb-smtpad.ts

@@ -9,6 +9,8 @@ import {
   drawSoldermaskRingForRect,
   drawSoldermaskRingForCircle,
   drawSoldermaskRingForPill,
+  drawSoldermaskRingForPolygon,
+  offsetPolygonPoints,
 } from "./soldermask-margin"
 
 export interface DrawPcbSmtPadParams {
@@ -67,7 +69,7 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
         height: pad.height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: getBorderRadius(pad, margin),
+        borderRadius: getBorderRadius(pad),
       })
     }
 
@@ -123,7 +125,7 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
         height: pad.height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: getBorderRadius(pad, margin),
+        borderRadius: getBorderRadius(pad),
         rotation: pad.ccw_rotation ?? 0,
       })
     }
@@ -328,6 +330,17 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
 
   if (pad.shape === "polygon") {
     if (pad.points && pad.points.length >= 3) {
+      // For positive margins, draw extended mask area first
+      if (hasSoldermask && margin > 0) {
+        const expandedPoints = offsetPolygonPoints(pad.points, margin)
+        drawPolygon({
+          ctx,
+          points: expandedPoints,
+          fill: positiveMarginColor,
+          realToCanvasMat,
+        })
+      }
+
       // Draw the copper pad
       drawPolygon({
         ctx,
@@ -336,8 +349,20 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
         realToCanvasMat,
       })
 
-      // If covered with soldermask and margin >= 0, draw soldermaskOverCopper overlay
-      if (isCoveredWithSoldermask && margin >= 0) {
+      // For negative margins, draw soldermask ring on top of the pad
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForPolygon(
+          ctx,
+          pad.points,
+          margin,
+          realToCanvasMat,
+          soldermaskRingColor,
+          color,
+        )
+      }
+
+      // If covered with soldermask and margin == 0 (treat as 0 positive margin), draw soldermaskOverCopper overlay
+      if (isCoveredWithSoldermask && margin === 0) {
         drawPolygon({
           ctx,
           points: pad.points,

package/lib/drawer/elements/soldermask-margin.ts

@@ -324,3 +324,133 @@ export function drawSoldermaskRingForOval(
 
   ctx.restore()
 }
+
+/**
+ * Offsets polygon points by a given distance (positive = outward, negative = inward)
+ */
+export function offsetPolygonPoints(
+  points: Array<{ x: number; y: number }>,
+  offset: number,
+): Array<{ x: number; y: number }> {
+  if (points.length < 3 || offset === 0) return points
+
+  // Calculate polygon centroid
+  let centerX = 0
+  let centerY = 0
+  for (const point of points) {
+    centerX += point.x
+    centerY += point.y
+  }
+  centerX /= points.length
+  centerY /= points.length
+
+  const result: Array<{ x: number; y: number }> = []
+
+  for (const point of points) {
+    // Calculate vector from center to point
+    const vectorX = point.x - centerX
+    const vectorY = point.y - centerY
+
+    // Calculate distance from center
+    const distance = Math.sqrt(vectorX * vectorX + vectorY * vectorY)
+
+    if (distance > 0) {
+      // Normalize vector and offset
+      const normalizedX = vectorX / distance
+      const normalizedY = vectorY / distance
+
+      result.push({
+        x: point.x + normalizedX * offset,
+        y: point.y + normalizedY * offset,
+      })
+    } else {
+      // Point is at center, offset in arbitrary direction
+      result.push({
+        x: point.x + offset,
+        y: point.y,
+      })
+    }
+  }
+
+  return result
+}
+
+/**
+ * Draws a soldermask ring for polygon shapes with negative margin
+ * (soldermask appears inside the pad boundary)
+ */
+export function drawSoldermaskRingForPolygon(
+  ctx: CanvasContext,
+  points: Array<{ x: number; y: number }>,
+  margin: number,
+  realToCanvasMat: Matrix,
+  soldermaskColor: string,
+  padColor: string,
+): void {
+  if (points.length < 3 || margin >= 0) return
+
+  const scaledMargin = Math.abs(margin) * Math.abs(realToCanvasMat.a)
+
+  // For negative margins, outer is pad boundary, inner is contracted by margin
+  // Use source-atop so the ring only appears on the pad
+  const prevCompositeOp = ctx.globalCompositeOperation
+  if (ctx.globalCompositeOperation !== undefined) {
+    ctx.globalCompositeOperation = "source-atop"
+  }
+
+  // Draw outer polygon filled (at pad boundary)
+  ctx.beginPath()
+  const canvasPoints = points.map((p) =>
+    applyToPoint(realToCanvasMat, [p.x, p.y]),
+  )
+
+  const firstPoint = canvasPoints[0]
+  if (firstPoint) {
+    const [firstX, firstY] = firstPoint
+    ctx.moveTo(firstX, firstY)
+
+    for (let i = 1; i < canvasPoints.length; i++) {
+      const point = canvasPoints[i]
+      if (point) {
+        const [x, y] = point
+        ctx.lineTo(x, y)
+      }
+    }
+    ctx.closePath()
+    ctx.fillStyle = soldermaskColor
+    ctx.fill()
+  }
+
+  // Reset composite operation and restore pad color in inner area
+  if (ctx.globalCompositeOperation !== undefined) {
+    ctx.globalCompositeOperation = prevCompositeOp || "source-over"
+  }
+
+  // Restore pad color in inner polygon (contracted by margin)
+  const innerPoints = offsetPolygonPoints(points, margin)
+  if (innerPoints.length >= 3) {
+    ctx.beginPath()
+    const innerCanvasPoints = innerPoints.map((p) =>
+      applyToPoint(realToCanvasMat, [p.x, p.y]),
+    )
+
+    const firstInnerPoint = innerCanvasPoints[0]
+    if (firstInnerPoint) {
+      const [firstX, firstY] = firstInnerPoint
+      ctx.moveTo(firstX, firstY)
+
+      for (let i = 1; i < innerCanvasPoints.length; i++) {
+        const point = innerCanvasPoints[i]
+        if (point) {
+          const [x, y] = point
+          ctx.lineTo(x, y)
+        }
+      }
+      ctx.closePath()
+      ctx.fillStyle = padColor
+      ctx.fill()
+    }
+  }
+
+  ctx.restore()
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "circuit-to-canvas",
   "main": "dist/index.js",
-  "version": "0.0.46",
+  "version": "0.0.47",
   "type": "module",
   "scripts": {
     "build": "tsup-node ./lib/index.ts --format esm --dts",