circuit-to-canvas 0.0.45 → 0.0.47

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

@@ -11,6 +11,8 @@ import {
   drawSoldermaskRingForOval,
   drawSoldermaskRingForPill,
   drawSoldermaskRingForRect,
+  drawSoldermaskRingForPolygon,
+  offsetPolygonPoints,
 } from "./soldermask-margin"
 
 export interface DrawPcbPlatedHoleParams {
@@ -35,11 +37,12 @@ function getSoldermaskColor(
 export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
   const { ctx, hole, realToCanvasMat, colorMap } = params
 
+  const isCoveredWithSoldermask = hole.is_covered_with_solder_mask === true
+  const margin = isCoveredWithSoldermask ? 0 : (hole.soldermask_margin ?? 0)
   const hasSoldermask =
-    hole.is_covered_with_solder_mask === true &&
+    !isCoveredWithSoldermask &&
     hole.soldermask_margin !== undefined &&
     hole.soldermask_margin !== 0
-  const margin = hasSoldermask ? hole.soldermask_margin! : 0
   const soldermaskRingColor = getSoldermaskColor(hole.layers, colorMap)
   const positiveMarginColor = colorMap.substrate
   const copperColor = colorMap.copper.top
@@ -78,14 +81,27 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
       )
     }
 
-    // Draw inner drill hole
-    drawCircle({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      radius: hole.hole_diameter / 2,
-      fill: colorMap.drill,
-      realToCanvasMat,
-    })
+    // If fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawCircle({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius: hole.outer_diameter / 2,
+        fill: soldermaskRingColor,
+        realToCanvasMat,
+      })
+    }
+
+    // Draw inner drill hole (only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      drawCircle({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius: hole.hole_diameter / 2,
+        fill: colorMap.drill,
+        realToCanvasMat,
+      })
+    }
     return
   }
 
@@ -129,16 +145,31 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
       )
     }
 
-    // Draw inner drill hole
-    drawOval({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      radius_x: hole.hole_width / 2,
-      radius_y: hole.hole_height / 2,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation: hole.ccw_rotation,
-    })
+    // If fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawOval({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius_x: hole.outer_width / 2,
+        radius_y: hole.outer_height / 2,
+        fill: soldermaskRingColor,
+        realToCanvasMat,
+        rotation: hole.ccw_rotation,
+      })
+    }
+
+    // Draw inner drill hole (only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      drawOval({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius_x: hole.hole_width / 2,
+        radius_y: hole.hole_height / 2,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation: hole.ccw_rotation,
+      })
+    }
     return
   }
 
@@ -182,16 +213,31 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
       )
     }
 
-    // Draw inner drill hole
-    drawPill({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      width: hole.hole_width,
-      height: hole.hole_height,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation: hole.ccw_rotation,
-    })
+    // If fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.outer_width,
+        height: hole.outer_height,
+        fill: soldermaskRingColor,
+        realToCanvasMat,
+        rotation: hole.ccw_rotation,
+      })
+    }
+
+    // Draw inner drill hole (only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation: hole.ccw_rotation,
+      })
+    }
     return
   }
 
@@ -205,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,
       })
     }
 
@@ -236,16 +282,31 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
       )
     }
 
-    // Draw circular drill hole (with offset)
-    const holeX = hole.x + (hole.hole_offset_x ?? 0)
-    const holeY = hole.y + (hole.hole_offset_y ?? 0)
-    drawCircle({
-      ctx,
-      center: { x: holeX, y: holeY },
-      radius: hole.hole_diameter / 2,
-      fill: colorMap.drill,
-      realToCanvasMat,
-    })
+    // If fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.rect_pad_width,
+        height: hole.rect_pad_height,
+        fill: soldermaskRingColor,
+        realToCanvasMat,
+        borderRadius: hole.rect_border_radius ?? 0,
+      })
+    }
+
+    // Draw circular drill hole (with offset, only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      const holeX = hole.x + (hole.hole_offset_x ?? 0)
+      const holeY = hole.y + (hole.hole_offset_y ?? 0)
+      drawCircle({
+        ctx,
+        center: { x: holeX, y: holeY },
+        radius: hole.hole_diameter / 2,
+        fill: colorMap.drill,
+        realToCanvasMat,
+      })
+    }
     return
   }
 
@@ -259,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,
       })
     }
 
@@ -290,17 +351,32 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
       )
     }
 
-    // Draw pill drill hole (with offset)
-    const holeX = hole.x + (hole.hole_offset_x ?? 0)
-    const holeY = hole.y + (hole.hole_offset_y ?? 0)
-    drawPill({
-      ctx,
-      center: { x: holeX, y: holeY },
-      width: hole.hole_width,
-      height: hole.hole_height,
-      fill: colorMap.drill,
-      realToCanvasMat,
-    })
+    // If fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.rect_pad_width,
+        height: hole.rect_pad_height,
+        fill: soldermaskRingColor,
+        realToCanvasMat,
+        borderRadius: hole.rect_border_radius ?? 0,
+      })
+    }
+
+    // Draw pill drill hole (with offset, only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      const holeX = hole.x + (hole.hole_offset_x ?? 0)
+      const holeY = hole.y + (hole.hole_offset_y ?? 0)
+      drawPill({
+        ctx,
+        center: { x: holeX, y: holeY },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: colorMap.drill,
+        realToCanvasMat,
+      })
+    }
     return
   }
 
@@ -314,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,
       })
     }
@@ -347,24 +423,38 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
       )
     }
 
-    // Draw rotated pill drill hole (with offset)
-    const holeX = hole.x + (hole.hole_offset_x ?? 0)
-    const holeY = hole.y + (hole.hole_offset_y ?? 0)
-    drawPill({
-      ctx,
-      center: { x: holeX, y: holeY },
-      width: hole.hole_width,
-      height: hole.hole_height,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation: hole.hole_ccw_rotation,
-    })
+    // If fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.rect_pad_width,
+        height: hole.rect_pad_height,
+        fill: soldermaskRingColor,
+        realToCanvasMat,
+        borderRadius: hole.rect_border_radius ?? 0,
+        rotation: hole.rect_ccw_rotation,
+      })
+    }
+
+    // Draw rotated pill drill hole (with offset, only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      const holeX = hole.x + (hole.hole_offset_x ?? 0)
+      const holeY = hole.y + (hole.hole_offset_y ?? 0)
+      drawPill({
+        ctx,
+        center: { x: holeX, y: holeY },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation: hole.hole_ccw_rotation,
+      })
+    }
     return
   }
 
   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
@@ -372,54 +462,91 @@ 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)
-    const holeX = hole.x + (hole.hole_offset_x ?? 0)
-    const holeY = hole.y + (hole.hole_offset_y ?? 0)
-    const holeShape = hole.hole_shape
+    // Draw drill hole (with offset, only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      const holeX = hole.x + (hole.hole_offset_x ?? 0)
+      const holeY = hole.y + (hole.hole_offset_y ?? 0)
+      const holeShape = hole.hole_shape
 
-    if (holeShape === "circle") {
-      drawCircle({
-        ctx,
-        center: { x: holeX, y: holeY },
-        radius: (hole.hole_diameter ?? 0) / 2,
-        fill: colorMap.drill,
-        realToCanvasMat,
-      })
-    } else if (holeShape === "oval") {
-      drawOval({
-        ctx,
-        center: { x: holeX, y: holeY },
-        radius_x: (hole.hole_width ?? 0) / 2,
-        radius_y: (hole.hole_height ?? 0) / 2,
-        fill: colorMap.drill,
-        realToCanvasMat,
-      })
-    } else if (holeShape === "pill") {
-      drawPill({
-        ctx,
-        center: { x: holeX, y: holeY },
-        width: hole.hole_width ?? 0,
-        height: hole.hole_height ?? 0,
-        fill: colorMap.drill,
-        realToCanvasMat,
-      })
-    } else if (holeShape === "rotated_pill") {
-      drawPill({
-        ctx,
-        center: { x: holeX, y: holeY },
-        width: hole.hole_width ?? 0,
-        height: hole.hole_height ?? 0,
-        fill: colorMap.drill,
-        realToCanvasMat,
-      })
+      if (holeShape === "circle") {
+        drawCircle({
+          ctx,
+          center: { x: holeX, y: holeY },
+          radius: (hole.hole_diameter ?? 0) / 2,
+          fill: colorMap.drill,
+          realToCanvasMat,
+        })
+      } else if (holeShape === "oval") {
+        drawOval({
+          ctx,
+          center: { x: holeX, y: holeY },
+          radius_x: (hole.hole_width ?? 0) / 2,
+          radius_y: (hole.hole_height ?? 0) / 2,
+          fill: colorMap.drill,
+          realToCanvasMat,
+        })
+      } else if (holeShape === "pill") {
+        drawPill({
+          ctx,
+          center: { x: holeX, y: holeY },
+          width: hole.hole_width ?? 0,
+          height: hole.hole_height ?? 0,
+          fill: colorMap.drill,
+          realToCanvasMat,
+        })
+      } else if (holeShape === "rotated_pill") {
+        drawPill({
+          ctx,
+          center: { x: holeX, y: holeY },
+          width: hole.hole_width ?? 0,
+          height: hole.hole_height ?? 0,
+          fill: colorMap.drill,
+          realToCanvasMat,
+        })
+      }
     }
     return
   }

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

@@ -9,6 +9,8 @@ import {
   drawSoldermaskRingForRect,
   drawSoldermaskRingForCircle,
   drawSoldermaskRingForPill,
+  drawSoldermaskRingForPolygon,
+  offsetPolygonPoints,
 } from "./soldermask-margin"
 
 export interface DrawPcbSmtPadParams {
@@ -33,7 +35,7 @@ function getSoldermaskColor(layer: string, colorMap: PcbColorMap): string {
   )
 }
 
-function getBorderRadius(pad: PcbSmtPad, margin: number = 0): number {
+function getBorderRadius(pad: PcbSmtPad, margin = 0): number {
   return (
     ((pad as { corner_radius?: number }).corner_radius ??
       (pad as { rect_border_radius?: number }).rect_border_radius ??
@@ -46,13 +48,10 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
 
   const color = layerToColor(pad.layer, colorMap)
   const isCoveredWithSoldermask = pad.is_covered_with_solder_mask === true
-  // When covered with soldermask, treat margin 0 or undefined as 0 positive margin
-  const margin =
-    isCoveredWithSoldermask && pad.soldermask_margin !== undefined
-      ? pad.soldermask_margin
-      : 0
+  // If covered with soldermask, fully covered with no margin; otherwise use soldermask_margin if set
+  const margin = isCoveredWithSoldermask ? 0 : (pad.soldermask_margin ?? 0)
   const hasSoldermask =
-    isCoveredWithSoldermask &&
+    !isCoveredWithSoldermask &&
     pad.soldermask_margin !== undefined &&
     pad.soldermask_margin !== 0
   const soldermaskRingColor = getSoldermaskColor(pad.layer, colorMap)
@@ -61,8 +60,8 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
 
   // Draw the copper pad
   if (pad.shape === "rect") {
-    // For positive margins (including 0), draw extended mask area first
-    if (isCoveredWithSoldermask && margin >= 0) {
+    // For positive margins, draw extended mask area first
+    if (hasSoldermask && margin > 0) {
       drawRect({
         ctx,
         center: { x: pad.x, y: pad.y },
@@ -70,7 +69,7 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
         height: pad.height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: getBorderRadius(pad, margin),
+        borderRadius: getBorderRadius(pad),
       })
     }
 
@@ -117,8 +116,8 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
   }
 
   if (pad.shape === "rotated_rect") {
-    // For positive margins (including 0), draw extended mask area first
-    if (isCoveredWithSoldermask && margin >= 0) {
+    // For positive margins, draw extended mask area first
+    if (hasSoldermask && margin > 0) {
       drawRect({
         ctx,
         center: { x: pad.x, y: pad.y },
@@ -126,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,
       })
     }
@@ -176,8 +175,8 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
   }
 
   if (pad.shape === "circle") {
-    // For positive margins (including 0), draw extended mask area first
-    if (isCoveredWithSoldermask && margin >= 0) {
+    // For positive margins, draw extended mask area first
+    if (hasSoldermask && margin > 0) {
       drawCircle({
         ctx,
         center: { x: pad.x, y: pad.y },
@@ -223,8 +222,8 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
   }
 
   if (pad.shape === "pill") {
-    // For positive margins (including 0), draw extended mask area first
-    if (isCoveredWithSoldermask && margin >= 0) {
+    // For positive margins, draw extended mask area first
+    if (hasSoldermask && margin > 0) {
       drawPill({
         ctx,
         center: { x: pad.x, y: pad.y },
@@ -275,8 +274,8 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
   }
 
   if (pad.shape === "rotated_pill") {
-    // For positive margins (including 0), draw extended mask area first
-    if (isCoveredWithSoldermask && margin >= 0) {
+    // For positive margins, draw extended mask area first
+    if (hasSoldermask && margin > 0) {
       drawPill({
         ctx,
         center: { x: pad.x, y: pad.y },
@@ -331,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,
@@ -339,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,