Render KiCad DSN through-hole pads as plated holes (#489)

* Fix KiCad DSN through-hole pad import

* update

Author: rushabhcodes

lib/dsn-pcb/dsn-json-to-circuit-json/dsn-component-converters/convert-padstacks-to-smtpads.ts

@@ -1,14 +1,31 @@
-import type { AnyCircuitElement, PcbSmtPad } from "circuit-json"
+import type { AnyCircuitElement, PcbPlatedHole, PcbSmtPad } from "circuit-json"
 import Debug from "debug"
-import type { DsnPcb } from "lib/dsn-pcb/types"
+import type { DsnPcb, Padstack } from "lib/dsn-pcb/types"
+import { parsePadstackName } from "lib/utils/get-padstack-name"
 import { applyToPoint } from "transformation-matrix"
 
 const debug = Debug("dsn-converter:convertPadstacksToSmtpads")
 
+// Layer name sets for front and back copper — covers KiCad (F.Cu/B.Cu) and
+// Freerouting/other tools (Top/Bottom)
+const FRONT_COPPER = new Set(["F.Cu", "Top", "F_Cu"])
+const BACK_COPPER = new Set(["B.Cu", "Bottom", "B_Cu"])
+
+function isThruHolePadstack(padstack: Padstack): boolean {
+  const layers = padstack.shapes.map((s) => s.layer)
+  return (
+    layers.some((l) => FRONT_COPPER.has(l)) &&
+    layers.some((l) => BACK_COPPER.has(l))
+  )
+}
+
 function getLayerFromPadstack(
   padstack: DsnPcb["library"]["padstacks"][number],
 ) {
-  return padstack.shapes[0].layer.includes("B.") ? "bottom" : "top"
+  return padstack.shapes[0].layer.includes("B.") ||
+    padstack.shapes[0].layer === "Bottom"
+    ? "bottom"
+    : "top"
 }
 
 function getPolygonPoints(
@@ -66,6 +83,10 @@ function getRectangleDimensionsFromPolygon(coordinates: number[]) {
   }
 }
 
+function isApproximatelyEqual(a: number, b: number) {
+  return Math.abs(a - b) < 1e-6
+}
+
 export function convertPadstacksToSmtPads(
   pcb: DsnPcb,
   dsnToCircuitJsonTransform: any,
@@ -85,13 +106,11 @@ export function convertPadstacksToSmtPads(
       return
     }
 
-    // Handle each placement for this component
     placementComponent.places.forEach((place) => {
       debug("processing place...", { place })
       const { x: compX, y: compY, side } = place
 
       image.pins.forEach((pin) => {
-        // Find the corresponding padstack
         const padstack = padstacks.find((p) => p.name === pin.padstack_name)
         debug("found padstack", { padstack })
 
@@ -100,22 +119,118 @@ export function convertPadstacksToSmtPads(
           return
         }
 
-        // Find shape in padstack - try rectangle first, then polygon
-        const rectShape = padstack.shapes.find(
-          (shape) => shape.shapeType === "rect",
+        const { x: circuitX, y: circuitY } = applyToPoint(
+          dsnToCircuitJsonTransform,
+          {
+            x: (compX || 0) + pin.x,
+            y: (compY || 0) + pin.y,
+          },
         )
 
+        const commonIds = {
+          pcb_component_id: `${componentId}_${place.refdes}`,
+          pcb_port_id: `pcb_port_${componentId}-Pad${pin.pin_number}_${place.refdes}`,
+          port_hints: [pin.pin_number.toString()],
+        }
+        const pcbPlatedHoleId = `pcb_plated_hole_${componentId}_${place.refdes}_${pin.pin_number}`
+        const parsedPadstackName = parsePadstackName(padstack.name)
+
+        // ── Through-hole detection ──────────────────────────────────────────
+        if (isThruHolePadstack(padstack)) {
+          const circleShape = padstack.shapes.find(
+            (s) => s.shapeType === "circle",
+          )
+          const pathShape = padstack.shapes.find((s) => s.shapeType === "path")
+
+          if (circleShape && circleShape.shapeType === "circle") {
+            const outerDiameter = circleShape.diameter / 1000
+
+            // Prefer explicit hole from parser, then name convention, then 60% estimate
+            const holeDiameter =
+              padstack.hole?.diameter !== undefined
+                ? padstack.hole.diameter / 1000
+                : parsedPadstackName?.shape === "circle"
+                  ? parsedPadstackName.holeDiameter
+                  : outerDiameter * 0.6
+
+            const platedHole: PcbPlatedHole = {
+              type: "pcb_plated_hole",
+              pcb_plated_hole_id: pcbPlatedHoleId,
+              ...commonIds,
+              shape: "circle",
+              x: circuitX,
+              y: circuitY,
+              outer_diameter: outerDiameter,
+              hole_diameter: holeDiameter,
+              layers: ["top", "bottom"],
+            }
+            elements.push(platedHole)
+            return
+          }
+
+          if (pathShape && pathShape.shapeType === "path") {
+            const [x1, y1, x2, y2] = pathShape.coordinates
+            const strokeWidth = pathShape.width / 1000
+            const endpointDist =
+              Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2) / 1000
+            const isHorizontal = Math.abs(x2 - x1) >= Math.abs(y2 - y1)
+
+            const major = endpointDist + strokeWidth
+            const minor = strokeWidth
+            const outerWidth = isHorizontal ? major : minor
+            const outerHeight = isHorizontal ? minor : major
+
+            let holeWidth: number
+            let holeHeight: number
+            if (padstack.hole?.width !== undefined) {
+              holeWidth = padstack.hole.width / 1000
+              holeHeight = (padstack.hole.height ?? padstack.hole.width) / 1000
+            } else {
+              const parsedNameMatchesOuterDimensions =
+                parsedPadstackName?.shape === "oval" &&
+                isApproximatelyEqual(parsedPadstackName.width, outerWidth) &&
+                isApproximatelyEqual(parsedPadstackName.height, outerHeight)
+
+              if (
+                parsedPadstackName?.shape === "oval" &&
+                !parsedNameMatchesOuterDimensions
+              ) {
+                holeWidth = parsedPadstackName.width
+                holeHeight = parsedPadstackName.height
+              } else {
+                holeWidth = outerWidth * 0.6
+                holeHeight = outerHeight * 0.6
+              }
+            }
+
+            const platedHole: PcbPlatedHole = {
+              type: "pcb_plated_hole",
+              pcb_plated_hole_id: pcbPlatedHoleId,
+              ...commonIds,
+              shape: "oval",
+              x: circuitX,
+              y: circuitY,
+              outer_width: outerWidth,
+              outer_height: outerHeight,
+              hole_width: holeWidth,
+              hole_height: holeHeight,
+              ccw_rotation: 0,
+              layers: ["top", "bottom"],
+            }
+            elements.push(platedHole)
+            return
+          }
+        }
+
+        // ── SMT pad (single-layer or unrecognised padstack) ─────────────────
+        const rectShape = padstack.shapes.find((s) => s.shapeType === "rect")
         const polygonShape = padstack.shapes.find(
-          (shape) => shape.shapeType === "polygon",
+          (s) => s.shapeType === "polygon",
         )
-
         const circleShape = padstack.shapes.find(
-          (shape) => shape.shapeType === "circle",
-        )
-
-        const pathShape = padstack.shapes.find(
-          (shape) => shape.shapeType === "path",
+          (s) => s.shapeType === "circle",
         )
+        const pathShape = padstack.shapes.find((s) => s.shapeType === "path")
 
         debug("found shapes", {
           rectShape,
@@ -128,39 +243,30 @@ export function convertPadstacksToSmtPads(
         let height: number
 
         if (rectShape) {
-          // Handle rectangle shape
           const [x1, y1, x2, y2] = rectShape.coordinates
-          width = Math.abs(x2 - x1) / 1000 // Convert μm to mm
-          height = Math.abs(y2 - y1) / 1000 // Convert μm to mm
+          width = Math.abs(x2 - x1) / 1000
+          height = Math.abs(y2 - y1) / 1000
         } else if (polygonShape) {
-          // Handle polygon shape
           const coordinates = polygonShape.coordinates
           let minX = Infinity
           let maxX = -Infinity
           let minY = Infinity
           let maxY = -Infinity
-
-          // Coordinates are in pairs (x,y), so iterate by 2
           for (let i = 0; i < coordinates.length; i += 2) {
             const x = coordinates[i]
             const y = coordinates[i + 1]
-
             minX = Math.min(minX, x)
             maxX = Math.max(maxX, x)
             minY = Math.min(minY, y)
             maxY = Math.max(maxY, y)
           }
-
           width = Math.abs(maxX - minX) / 1000
           height = Math.abs(maxY - minY) / 1000
         } else if (pathShape) {
-          // For path shapes (oval/pill pads), width is the path width
-          // and height is the distance between path endpoints
           const [x1, y1, x2, y2] = pathShape.coordinates
-          width = pathShape.width / 1000 // Convert μm to mm
+          width = pathShape.width / 1000
           height = Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2) / 1000
         } else if (circleShape) {
-          // Handle circle shape
           const radius = circleShape.diameter / 2 / 1000
           width = radius
           height = radius
@@ -169,16 +275,6 @@ export function convertPadstacksToSmtPads(
           return
         }
 
-        // Calculate position in circuit space using the transformation matrix
-        // Convert component position and pin offset to circuit coordinates
-        const { x: circuitX, y: circuitY } = applyToPoint(
-          dsnToCircuitJsonTransform,
-          {
-            x: (compX || 0) + pin.x,
-            y: (compY || 0) + pin.y,
-          },
-        )
-
         let pcbPad: PcbSmtPad
         const rectangleDimensionsFromPolygon = polygonShape
           ? getRectangleDimensionsFromPolygon(polygonShape.coordinates)
@@ -188,54 +284,40 @@ export function convertPadstacksToSmtPads(
 
         if (polygonShape && !shouldImportPolygonAsRect) {
           const layer = getLayerFromPadstack(padstack)
-          debug("determining layer with padstack shapes", {
-            shapes: padstack.shapes,
-            layer,
-          })
           pcbPad = {
             type: "pcb_smtpad",
             pcb_smtpad_id: `pcb_smtpad_${componentId}_${place.refdes}_${Number(pin.pin_number) - 1}`,
-            pcb_component_id: `${componentId}_${place.refdes}`,
-            pcb_port_id: `pcb_port_${componentId}-Pad${pin.pin_number}_${place.refdes}`,
+            ...commonIds,
             shape: "polygon",
             points: getPolygonPoints(polygonShape.coordinates, {
               x: circuitX,
               y: circuitY,
             }),
             layer,
-            port_hints: [pin.pin_number.toString()],
           }
         } else if (rectShape || pathShape || shouldImportPolygonAsRect) {
           const layer = getLayerFromPadstack(padstack)
-          debug("determining layer with padstack shapes", {
-            shapes: padstack.shapes,
-            layer,
-          })
           pcbPad = {
             type: "pcb_smtpad",
             pcb_smtpad_id: `pcb_smtpad_${componentId}_${place.refdes}_${Number(pin.pin_number) - 1}`,
-            pcb_component_id: `${componentId}_${place.refdes}`,
-            pcb_port_id: `pcb_port_${componentId}-Pad${pin.pin_number}_${place.refdes}`,
+            ...commonIds,
             shape: "rect",
             x: circuitX,
             y: circuitY,
             width: rectangleDimensionsFromPolygon?.width ?? width,
             height: rectangleDimensionsFromPolygon?.height ?? height,
             layer,
-            port_hints: [pin.pin_number.toString()],
           }
         } else {
           pcbPad = {
             type: "pcb_smtpad",
             pcb_smtpad_id: `pcb_smtpad_${componentId}_${place.refdes}_${Number(pin.pin_number) - 1}`,
-            pcb_component_id: `${componentId}_${place.refdes}`,
-            pcb_port_id: `pcb_port_${componentId}-Pad${pin.pin_number}_${place.refdes}`,
+            ...commonIds,
             shape: "circle",
             x: circuitX,
             y: circuitY,
             radius: circleShape!.diameter / 2 / 1000,
             layer: side === "front" ? "top" : "bottom",
-            port_hints: [pin.pin_number.toString()],
           }
         }
 

lib/dsn-pcb/dsn-json-to-circuit-json/parse-dsn-to-dsn-json.ts

@@ -659,6 +659,22 @@ function processPadstack(nodes: ASTNode[]): Padstack {
           if (rest[0].type === "Atom" && typeof rest[0].value === "string") {
             padstack.attach = rest[0].value
           }
+        } else if (key === "hole") {
+          if (rest[0]?.type === "Atom") {
+            if (typeof rest[0].value === "number") {
+              padstack.hole = { shape: "circle", diameter: rest[0].value }
+            } else if (
+              rest[0].value === "oval" &&
+              rest[1]?.type === "Atom" &&
+              rest[2]?.type === "Atom"
+            ) {
+              padstack.hole = {
+                shape: "oval",
+                width: rest[1].value as number,
+                height: rest[2].value as number,
+              }
+            }
+          }
         }
       }
     }