Enhancement: IPC2581 Support

This may be out of scope for this project, but I think pygerber has enough infrastructure to add support for IPC2581. That standard is supported by an increasing number of board houses and CAD packages, and parsing the files is fairly straightforward.

A CAD packages produces a .cvg file, which is an XML file following the IPC2581 standard. Unfortunately, the standard is not freely available (unless you become a member, which is free). Even still, being a plain text XML file it's easy to understand the structure:

IPC-2581 (root)
- Content - Layer names, color dictionary, standard shapes with units
- LogisticHeader - Owner and enterprise information, if applicable
- Bom - Collection of BomItems, each having attributes relating to a component in the BOM
- Ecad - Layer stackup and materials, layer geometry

Most interesting is the Ecad node. It is divided into CadHeader and CadData. The CadHeader has layers in Spec nodes which have optional MATERIAL properties, e.g. Solder Resist. The CadData node contains layer information (each layer has a name, function, side, and polarity), stackup information under a Stackup node, and actual geometry (both traces and component geometry) under a Step node.

Here's a sort of tree view of the nodes:

# IPC2581
# . Content
# . . FunctionMode
# . . StepRef
# . . LayerRef
# . . BomRef
# . . DictionaryStandard
# . . . EntryStandard
# . . . . RectCenter
# . . . . Circle
# . . DictionaryColor
# . . . EntryColor
# . . . . Color
# . LogisticHeader
# . . Role
# . . Enterprise
# . . Person
# . Bom
# . . BomHeader
# . . . StepRef
# . . BomItem
# . . . RefDes
# . . . Characteristics
# . Ecad
# . . CadHeader
# . . . Spec
# . . . . General
# . . . . . Property
# . . CadData
# . . . Layer
# . . . Stackup
# . . . . StackupGroup
# . . . . . StackupLayer
# . . . . . . SpecRef
# . . . Step
# . . . . Datum
# . . . . Profile
# . . . . . Polygon
# . . . . . . PolyBegin
# . . . . . . PolyStepCurve
# . . . . . . PolyStepSegment
# . . . . . Cutout
# . . . . . . PolyBegin
# . . . . . . PolyStepCurve
# . . . . . . PolyStepSegment
# . . . . PadStack
# . . . . . LayerPad
# . . . . . . Xform
# . . . . . . Location
# . . . . . . StandardPrimitiveRef
# . . . . . . PinRef
# . . . . . LayerHole
# . . . . . . Span
# . . . . Package
# . . . . . Outline
# . . . . . . Polygon
# . . . . . . . PolyBegin
# . . . . . . . PolyStepCurve
# . . . . . . . PolyStepSegment
# . . . . . . LineDesc
# . . . . . Pin
# . . . . . . Location
# . . . . . . StandardPrimitiveRef
# . . . . Component
# . . . . . Xform
# . . . . . Location
# . . . . LayerFeature
# . . . . . Set
# . . . . . . ColorRef
# . . . . . . Hole
# . . . . . . Features
# . . . . . . . Contour
# . . . . . . . . Polygon
# . . . . . . . . . PolyBegin
# . . . . . . . . . PolyStepSegment
# . . . . . . . UserSpecial
# . . . . . . . . Arc
# . . . . . . . . . LineDesc
# . . . . . . . . Line
# . . . . . . . . . LineDesc

This is not comprehensive, it's built up based on a random example file I had.

Examples

Parsing Layers and Nets

def get_layer_list(root: ET.Element):
    """
    Return a list of layers in dictionary format for this document

    Parameters
    ----------
    root : ET.Element

    Returns
    -------
    List of layer dictionaries with elements:
        name            Layer name
        layerFunction   Layer function as a string, one of {'DRILL', 'DOCUMENT', 'PASTEMASK', 'LEGEND', 'SOLDERMASK', 'SIGNAL', 'DIELCORE'}
        side            PCB side, one of {'TOP', 'BOTTOM', 'INTERNAL'}
        polarity        Layer drawing polarity, one of {'POSITIVE','NEGATIVE'}
        thickness       Layer thickness as float
        sequence        Layer sequence position as int
        z               Layer z position as float (bottom is z=0)

    """
    rpf = '{http://webstds.ipc.org/2581}'  # Root prefix
    # Get layer names and functions
    layers = root.findall(f'{rpf}Ecad/{rpf}CadData/{rpf}Layer')
    layers = [l.attrib for l in layers]

    # Get layer thicknesses
    for layer in layers:
        name = layer['name']
        stackuplayer = root.find(
            f'{rpf}Ecad/{rpf}CadData/{rpf}Stackup/{rpf}StackupGroup/{rpf}StackupLayer[@layerOrGroupRef="{name}"]')
        layer['thickness'] = float(stackuplayer.attrib['thickness'])
        layer['sequence'] = int(stackuplayer.attrib['sequence'])

    thicknesses = [layer['thickness'] for layer in layers]
    zpos = np.cumsum(-np.array(thicknesses)) + np.sum(thicknesses)
    for i, layer in enumerate(layers):
        layer['z'] = np.around(zpos[i], decimals=6)

    return layers

def get_layer_net_list(root: ET.Element, layername: str):
    """
    Return list of layer nets (as strings) given root and layer name

    Parameters
    ----------
    root : ET.Element
    layername : str

    Returns
    -------
    None.

    """
    rpf = '{http://webstds.ipc.org/2581}'  # Root prefix
    LayerFeatureRoot = root.find(f'{rpf}Ecad/{rpf}CadData/{rpf}Step/{rpf}LayerFeature[@layerRef="{layername}"]')
    LayerSets = LayerFeatureRoot.findall(f'{rpf}Set')
    netnames = []
    for lset in LayerSets:
        if 'net' in lset.attrib.keys():
            #if lset.attrib['net'] != 'No Net':
            netnames.append(lset.attrib['net'])
    return netnames

Parsing Line and Arc Elements

def parse_Line_element(line_elem: ET.Element, z: float = 0.):
    """
    Given the XML element for a Line, parse into an OCCT Geom_TrimmedCurve

    :param line_elem:
    :param z: z-coordinate for layer
    """
    prec = 10  # number of decimal places to keep, in case of precision issues
    startX = np.around(float(line_elem.attrib['startX']), prec)
    startY = np.around(float(line_elem.attrib['startY']), prec)
    endX = np.around(float(line_elem.attrib['endX']), prec)
    endY = np.around(float(line_elem.attrib['endY']), prec)
    start_pt = (startX, startY, z)
    end_pt = (endX, endY, z)

    LineDesc_elem = line_elem.find(f'{rpf}LineDesc')
    tracewidth = np.around(float(LineDesc_elem.attrib['lineWidth']), 3)
    endstyle = LineDesc_elem.attrib['lineEnd']

def parse_Arc_element(arc_elem: ET.Element, z: float = 0.):
    """
    Given the XML element for an Arc, parse into an OCCT Geom_TrimmedCurve

    :param arc_elem:
    :param z:
    """
    prec = 10
    startX = np.around(float(arc_elem.attrib['startX']), prec)
    startY = np.around(float(arc_elem.attrib['startY']), prec)
    endX = np.around(float(arc_elem.attrib['endX']), prec)
    endY = np.around(float(arc_elem.attrib['endY']), prec)
    centerX = np.around(float(arc_elem.attrib['centerX']), prec)
    centerY = np.around(float(arc_elem.attrib['centerY']), prec)
    is_cw = bool(arc_elem.attrib['clockwise'] == 'true')

    start_pt = (startX, startY, z)
    end_pt = (endX, endY, z)
    center_pt = (centerX, centerY, z)
    radius = distance(center_pt,start_pt)

    LineDesc_elem = arc_elem.find(f'{rpf}LineDesc')
    tracewidth = np.around(float(LineDesc_elem.attrib['lineWidth']), 3)
    endstyle = LineDesc_elem.attrib['lineEnd']

IPC2581 has information on geometry, stackup, BOM, components, vias, and pads. This means generating 3D geometry is possible without any additional information, and everything is in a single file which is convenient. I wrote myself a simple proof-of-concept program that uses Open CASCADE Technology (OCCT) as the geometry kernel, so you can generate .IGES and .STEP files. The only tools available for generating CAD data from Gerbers or IPC2581 .cvg files seem to be paid tools (e.g. Zofsz, NETEX-G) so including basic export functionality for STEP or IGES could be a good addition. But that's just one reason why IPC2581 support would be beneficial.

Argmaster / pygerber