plot_brditems_plotter.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <algorithm>                          // for min
#include <cmath>                              // for abs
 
#include <geometry/seg.h>                     // for SEG
#include <geometry/shape_circle.h>
#include <geometry/shape_ellipse.h>
#include <geometry/shape_line_chain.h>        // for SHAPE_LINE_CHAIN
#include <geometry/shape_poly_set.h>          // for SHAPE_POLY_SET, SHAPE_P...
#include <geometry/shape_rect.h>
#include <geometry/shape_segment.h>
#include <string_utils.h>
#include <macros.h>
#include <math/util.h>                        // for KiROUND
#include <math/vector2d.h>                    // for VECTOR2I
#include <plotters/plotter_gerber.h>
#include <trigo.h>
#include <font/stroke_font.h>
#include <gal/gal_display_options.h>
#include <callback_gal.h>
#include <core/typeinfo.h>                    // for dyn_cast, PCB_DIMENSION_T
#include <gbr_metadata.h>
#include <gbr_netlist_metadata.h>             // for GBR_NETLIST_METADATA
#include <layer_ids.h>                        // for LSET, IsCopperLayer
#include <lset.h>
#include <drill/drill_enumerator.h>
#include <drill/drill_chart_model.h>
#include <drill/drill_symbol_assigner.h>
#include <drill/drill_symbol_profile.h>
#include <plotters/drill_markers.h>
#include <pcb_drill_chart.h>
#include <pcb_drill_map.h>
#include <pcbplot.h>
#include <pcb_plot_params.h>                  // for PCB_PLOT_PARAMS, PCB_PL...
#include <advanced_config.h>
 
#include <line_ending.h>
#include <pcb_dimension.h>
#include <pcb_shape.h>
#include <footprint.h>
#include <pcb_track.h>
#include <pad.h>
#include <pcb_target.h>
#include <pcb_text.h>
#include <pcb_textbox.h>
#include <pcb_tablecell.h>
#include <pcb_table.h>
#include <zone.h>
#include <pcb_barcode.h>
 
#include <wx/debug.h>                         // for wxASSERT_MSG
 
 
COLOR4D BRDITEMS_PLOTTER::getColor( int aLayer ) const
{
    COLOR4D color = ColorSettings()->GetColor( aLayer );
 
    // A hack to avoid plotting a white item in white color on white paper
    if( color == COLOR4D::WHITE )
        color = COLOR4D( LIGHTGRAY );
 
    return color;
}
 
 
void BRDITEMS_PLOTTER::PlotPadNumber( const PAD* aPad, const COLOR4D& aColor ) const
{
    wxString padNumber = UnescapeString( aPad->GetNumber() );
 
    if( padNumber.IsEmpty() )
        return;
 
    BOX2I    padBBox = aPad->GetBoundingBox();
    VECTOR2I position = padBBox.Centre();
    VECTOR2I padsize = padBBox.GetSize();
 
    // TODO(JE) padstacks
    if( aPad->GetShape( PADSTACK::TEMP_ALL_LAYERS ) == PAD_SHAPE::CUSTOM )
    {
        // See if we have a number box
        for( const std::shared_ptr<PCB_SHAPE>& primitive : aPad->GetPrimitives( PADSTACK::TEMP_ALL_LAYERS ) )
        {
            if( primitive->IsProxyItem() && primitive->GetShape() == SHAPE_T::RECTANGLE )
            {
                position = primitive->GetCenter();
                RotatePoint( position, aPad->GetOrientation() );
                position += aPad->ShapePos( PADSTACK::TEMP_ALL_LAYERS );
 
                padsize.x = std::abs( primitive->GetBotRight().x - primitive->GetTopLeft().x );
                padsize.y = std::abs( primitive->GetBotRight().y - primitive->GetTopLeft().y );
 
                break;
            }
        }
    }
 
    if( aPad->GetShape( PADSTACK::TEMP_ALL_LAYERS ) != PAD_SHAPE::CUSTOM )
    {
        // Don't allow a 45° rotation to bloat a pad's bounding box unnecessarily
        int limit = KiROUND( std::min( aPad->GetSize( PADSTACK::TEMP_ALL_LAYERS ).x,
                                       aPad->GetSize( PADSTACK::TEMP_ALL_LAYERS ).y ) * 1.1 );
 
        if( padsize.x > limit && padsize.y > limit )
        {
            padsize.x = limit;
            padsize.y = limit;
        }
    }
 
    TEXT_ATTRIBUTES textAttrs;
 
    textAttrs.m_Mirrored = m_plotter->GetPlotMirrored();
 
    if( padsize.x < ( padsize.y * 0.95 ) )
    {
        textAttrs.m_Angle = ANGLE_90;
        std::swap( padsize.x, padsize.y );
    }
 
    // approximate the size of the pad number text:
    // We use a size for at least 3 chars, to give a good look even for short numbers
    int tsize = KiROUND( padsize.x / std::max( PrintableCharCount( padNumber ), 3 ) );
    tsize = std::min( tsize, padsize.y );
 
    // enforce a max size
    tsize = std::min( tsize, pcbIUScale.mmToIU( 5.0 ) );
 
    textAttrs.m_Size = VECTOR2I( tsize, tsize );
 
    // use a somewhat spindly font to go with the outlined pads
    textAttrs.m_StrokeWidth = KiROUND( tsize / 12.0 );
 
    m_plotter->PlotText( position, aColor, padNumber, textAttrs );
}
 
 
void BRDITEMS_PLOTTER::PlotPad( const PAD* aPad, PCB_LAYER_ID aLayer, const COLOR4D& aColor, bool aSketchMode ) const
{
    VECTOR2I     shape_pos = aPad->ShapePos( aLayer );
    GBR_METADATA metadata;
 
    m_plotter->MarkFootprintPlotted( aPad->GetParentFootprint() );
 
    bool plotOnCopperLayer = ( m_layerMask & LSET::AllCuMask() ).any();
    bool plotOnExternalCopperLayer = ( m_layerMask & LSET::ExternalCuMask() ).any();
 
    // Pad not on the solder mask layer cannot be soldered.
    // therefore it can have a specific aperture attribute.
    // Not yet in use.
    // bool isPadOnBoardTechLayers = ( aPad->GetLayerSet() & LSET::AllBoardTechMask() ).any();
 
    metadata.SetCmpReference( aPad->GetParentFootprint()->GetReference() );
 
    if( plotOnCopperLayer )
    {
        metadata.SetNetAttribType( GBR_NETINFO_ALL );
        metadata.SetCopper( true );
 
        // Gives a default attribute, for instance for pads used as tracks in net ties:
        // Connector pads and SMD pads are on external layers
        // if on internal layers, they are certainly used as net tie
        // and are similar to tracks: just conductor items
        metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CONDUCTOR );
 
        const bool useUTF8 = false;
        const bool useQuoting = false;
        metadata.SetPadName( aPad->GetNumber(), useUTF8, useQuoting );
 
        if( !aPad->GetNumber().IsEmpty() )
            metadata.SetPadPinFunction( aPad->GetPinFunction(), useUTF8, useQuoting );
 
        metadata.SetNetName( aPad->GetNetname() );
 
        // Some pads are mechanical pads ( through hole or smd )
        // when this is the case, they have no pad name and/or are not plated.
        // In this case gerber files have slightly different attributes.
        if( aPad->GetAttribute() == PAD_ATTRIB::NPTH || aPad->GetNumber().IsEmpty() )
            metadata.m_NetlistMetadata.m_NotInNet = true;
 
        if( !plotOnExternalCopperLayer )
        {
            // the .P object attribute (GBR_NETLIST_METADATA::GBR_NETINFO_PAD)
            // is used on outer layers, unless the component is embedded
            // or a "etched" component (fp only drawn, not a physical component)
            // Currently, Pcbnew does not handle embedded component, so we disable the .P
            // attribute on internal layers
            // Note the Gerber doc is not really clear about through holes pads about the .P
            metadata.SetNetAttribType( GBR_NETLIST_METADATA::GBR_NETINFO_NET
                                            | GBR_NETLIST_METADATA::GBR_NETINFO_CMP );
 
        }
 
        // Some attributes are reserved to the external copper layers:
        // GBR_APERTURE_ATTRIB_CONNECTORPAD and GBR_APERTURE_ATTRIB_SMDPAD_CUDEF
        // for instance.
        // Pad with type PAD_ATTRIB::CONN or PAD_ATTRIB::SMD that is not on outer layer
        // has its aperture attribute set to GBR_APERTURE_ATTRIB_CONDUCTOR
        switch( aPad->GetAttribute() )
        {
        case PAD_ATTRIB::NPTH:       // Mechanical pad through hole
            metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_WASHERPAD );
            break;
 
        case PAD_ATTRIB::PTH :       // Pad through hole, a hole is also expected
            metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_COMPONENTPAD );
            break;
 
        case PAD_ATTRIB::CONN:       // Connector pads, no solder paste but with solder mask.
            if( plotOnExternalCopperLayer )
                metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CONNECTORPAD );
            break;
 
        case PAD_ATTRIB::SMD:        // SMD pads (on external copper layer only)
                                     // with solder paste and mask
            if( plotOnExternalCopperLayer )
                metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_SMDPAD_CUDEF );
            break;
        }
 
        // Fabrication properties can have specific GBR_APERTURE_METADATA options
        // that replace previous aperture attribute:
        switch( aPad->GetProperty() )
        {
        case PAD_PROP::BGA:          // Only applicable to outer layers
            if( plotOnExternalCopperLayer )
                metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_BGAPAD_CUDEF );
            break;
 
        case PAD_PROP::FIDUCIAL_GLBL:
            metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_FIDUCIAL_GLBL );
            break;
 
        case PAD_PROP::FIDUCIAL_LOCAL:
            metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_FIDUCIAL_LOCAL );
            break;
 
        case PAD_PROP::TESTPOINT:    // Only applicable to outer layers
            if( plotOnExternalCopperLayer )
                metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_TESTPOINT );
            break;
 
        case PAD_PROP::HEATSINK:
            metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_HEATSINKPAD );
            break;
 
        case PAD_PROP::CASTELLATED:
            metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CASTELLATEDPAD );
            break;
 
        case PAD_PROP::PRESSFIT:    // used only in drill files
        case PAD_PROP::NONE:
        case PAD_PROP::MECHANICAL:
            break;
        }
 
        // Ensure NPTH pads have *always* the GBR_APERTURE_ATTRIB_WASHERPAD attribute
        if( aPad->GetAttribute() == PAD_ATTRIB::NPTH )
            metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_WASHERPAD );
    }
    else
    {
        metadata.SetNetAttribType( GBR_NETLIST_METADATA::GBR_NETINFO_CMP );
    }
 
    // Set plot color (change WHITE to LIGHTGRAY because
    // the white items are not seen on a white paper or screen
    m_plotter->SetColor( aColor != WHITE ? aColor : LIGHTGRAY );
 
    if( aSketchMode )
    {
        switch( aPad->GetShape( aLayer ) )
        {
        case PAD_SHAPE::CIRCLE:
            m_plotter->ThickCircle( shape_pos, aPad->GetSize( aLayer ).x, GetSketchPadLineWidth(),
                                    nullptr );
            break;
 
        case PAD_SHAPE::OVAL:
        {
            m_plotter->ThickOval( shape_pos, aPad->GetSize( aLayer ), aPad->GetOrientation(),
                                  GetSketchPadLineWidth(), nullptr );
            break;
        }
 
        case PAD_SHAPE::RECTANGLE:
        case PAD_SHAPE::ROUNDRECT:
        case PAD_SHAPE::TRAPEZOID:
        case PAD_SHAPE::CHAMFERED_RECT:
        case PAD_SHAPE::CUSTOM:
        {
            SHAPE_POLY_SET outline;
            aPad->TransformShapeToPolygon( outline, aLayer, 0, m_plotter->GetPlotterArcHighDef(),
                                           ERROR_INSIDE, false );
 
            m_plotter->ThickPoly( outline, GetSketchPadLineWidth(), nullptr );
            break;
        }
 
        default:
            UNIMPLEMENTED_FOR( aPad->ShowPadShape( PADSTACK::TEMP_ALL_LAYERS ) );
        }
 
        return;
    }
 
    switch( aPad->GetShape( aLayer ) )
    {
    case PAD_SHAPE::CIRCLE:
        m_plotter->FlashPadCircle( shape_pos, aPad->GetSize( aLayer ).x, &metadata );
        break;
 
    case PAD_SHAPE::OVAL:
        m_plotter->FlashPadOval( shape_pos, aPad->GetSize( aLayer ), aPad->GetOrientation(), &metadata );
        break;
 
    case PAD_SHAPE::RECTANGLE:
        m_plotter->FlashPadRect( shape_pos, aPad->GetSize( aLayer ), aPad->GetOrientation(), &metadata );
        break;
 
    case PAD_SHAPE::ROUNDRECT:
        m_plotter->FlashPadRoundRect( shape_pos, aPad->GetSize( aLayer ),
                                      aPad->GetRoundRectCornerRadius( aLayer ),
                                      aPad->GetOrientation(), &metadata );
        break;
 
    case PAD_SHAPE::TRAPEZOID:
    {
        // Build the pad polygon in coordinates relative to the pad
        // (i.e. for a pad at pos 0,0, rot 0.0). Needed to use aperture macros,
        // to be able to create a pattern common to all trapezoid pads having the same shape
        VECTOR2I coord[4];
 
        // Order is lower left, lower right, upper right, upper left.
        VECTOR2I half_size = aPad->GetSize( aLayer ) / 2;
        VECTOR2I trap_delta = aPad->GetDelta( aLayer ) / 2;
 
        coord[0] = VECTOR2I( -half_size.x - trap_delta.y, half_size.y + trap_delta.x );
        coord[1] = VECTOR2I( half_size.x + trap_delta.y, half_size.y - trap_delta.x );
        coord[2] = VECTOR2I( half_size.x - trap_delta.y, -half_size.y + trap_delta.x );
        coord[3] = VECTOR2I( -half_size.x + trap_delta.y, -half_size.y - trap_delta.x );
 
        m_plotter->FlashPadTrapez( shape_pos, coord, aPad->GetOrientation(), &metadata );
        break;
    }
 
    case PAD_SHAPE::CHAMFERED_RECT:
        if( m_plotter->GetPlotterType() == PLOT_FORMAT::GERBER )
        {
            GERBER_PLOTTER* gerberPlotter = static_cast<GERBER_PLOTTER*>( m_plotter );
 
            gerberPlotter->FlashPadChamferRoundRect( shape_pos, aPad->GetSize( aLayer ),
                                                     aPad->GetRoundRectCornerRadius( aLayer ),
                                                     aPad->GetChamferRectRatio( aLayer ),
                                                     aPad->GetChamferPositions( aLayer ),
                                                     aPad->GetOrientation(), &metadata );
            break;
        }
 
        KI_FALLTHROUGH;
 
    default:
    case PAD_SHAPE::CUSTOM:
    {
        const std::shared_ptr<SHAPE_POLY_SET>& polygons = aPad->GetEffectivePolygon( aLayer, ERROR_INSIDE );
 
        if( polygons->OutlineCount() )
        {
            m_plotter->FlashPadCustom( shape_pos, aPad->GetSize( aLayer ), aPad->GetOrientation(),
                                       polygons.get(), &metadata );
        }
    }
        break;
    }
}
 
 
void BRDITEMS_PLOTTER::PlotFootprintTextItems( const FOOTPRINT* aFootprint ) const
{
    if( !GetPlotFPText() )
        return;
 
    const wxString variantName = m_board ? m_board->GetCurrentVariant() : wxString();
    const bool     dnp = aFootprint->GetDNPForVariant( variantName );
 
    const PCB_TEXT* reference = &aFootprint->Reference();
    PCB_LAYER_ID    refLayer = reference->GetLayer();
 
    // Reference and value have special controls for forcing their plotting
    if( GetPlotReference()
            && m_layerMask[refLayer]
            && reference->IsVisible()
            && !( dnp && hideDNPItems( refLayer ) ) )
    {
        m_plotter->MarkFootprintPlotted( aFootprint );
        PlotText( reference, refLayer, reference->IsKnockout(), reference->GetFontMetrics(),
                  dnp && crossoutDNPItems( refLayer ) );
    }
 
    const PCB_TEXT* value  = &aFootprint->Value();
    PCB_LAYER_ID    valueLayer = value->GetLayer();
 
    if( GetPlotValue()
            && m_layerMask[valueLayer]
            && value->IsVisible()
            && !( dnp && hideDNPItems( valueLayer ) ) )
    {
        m_plotter->MarkFootprintPlotted( aFootprint );
        PlotText( value, valueLayer, value->IsKnockout(), value->GetFontMetrics(), false );
    }
 
    std::vector<PCB_TEXT*> texts;
 
    // Skip the reference and value texts that are handled specially
    for( PCB_FIELD* field : aFootprint->GetFields() )
    {
        wxCHECK2( field, continue );
 
        if( field->IsReference() || field->IsValue() )
            continue;
 
        if( field->IsVisible() )
            texts.push_back( field );
    }
 
    for( BOARD_ITEM* item : aFootprint->GraphicalItems() )
    {
        if( PCB_TEXT* textItem = dynamic_cast<PCB_TEXT*>( item ) )
            texts.push_back( textItem );
    }
 
    for( const PCB_TEXT* text : texts )
    {
        PCB_LAYER_ID textLayer = text->GetLayer();
        bool         strikeout = false;
 
        if( textLayer == Edge_Cuts || textLayer >= PCB_LAYER_ID_COUNT )
            continue;
 
        if( dnp && hideDNPItems( textLayer ) )
            continue;
 
        if( !m_layerMask[textLayer] || aFootprint->GetPrivateLayers().test( textLayer ) )
            continue;
 
        if( text->GetText() == wxT( "${REFERENCE}" ) )
        {
            if( !GetPlotReference() )
                continue;
 
            strikeout = dnp && crossoutDNPItems( textLayer );
        }
 
        if( text->GetText() == wxT( "${VALUE}" ) )
        {
            if( !GetPlotValue() )
                continue;
        }
 
        m_plotter->MarkFootprintPlotted( aFootprint );
        PlotText( text, textLayer, text->IsKnockout(), text->GetFontMetrics(), strikeout );
    }
}
 
 
void BRDITEMS_PLOTTER::PlotBoardGraphicItem( const BOARD_ITEM* item ) const
{
    switch( item->Type() )
    {
    case PCB_SHAPE_T:
        PlotShape( static_cast<const PCB_SHAPE*>( item ) );
        break;
 
    case PCB_TEXT_T:
    {
        const PCB_TEXT* text = static_cast<const PCB_TEXT*>( item );
        PlotText( text, text->GetLayer(), text->IsKnockout(), text->GetFontMetrics() );
        break;
    }
 
    case PCB_TEXTBOX_T:
    {
        m_plotter->SetTextMode( PLOT_TEXT_MODE::STROKE );
 
        const PCB_TEXTBOX* textbox = static_cast<const PCB_TEXTBOX*>( item );
        PlotText( textbox, textbox->GetLayer(), textbox->IsKnockout(), textbox->GetFontMetrics() );
 
        if( textbox->IsBorderEnabled() )
        {
            // PlotShape works only for textbox rotated by 0 or 180 degrees.
            // This is not always the case so use the polygonal shape of the box of the text box.
            PCB_SHAPE dummy = textbox->GetPolygonalBoxShape();
            PlotShape( &dummy );
        }
 
        m_plotter->SetTextMode( GetTextMode() );
        break;
    }
 
    case PCB_BARCODE_T:
        PlotBarCode( static_cast<const PCB_BARCODE*>( item ) );
        break;
 
    case PCB_TABLE_T:
    case PCB_DRILL_CHART_T:
    {
        const PCB_TABLE* table = static_cast<const PCB_TABLE*>( item );
 
        m_plotter->SetTextMode( PLOT_TEXT_MODE::STROKE );
 
        for( const PCB_TABLECELL* cell : table->GetCells() )
            PlotText( cell, cell->GetLayer(), cell->IsKnockout(), cell->GetFontMetrics() );
 
        PlotTableBorders( table );
 
        if( item->Type() == PCB_DRILL_CHART_T )
            PlotChartSymbols( static_cast<const PCB_DRILL_CHART*>( item ) );
 
        m_plotter->SetTextMode( GetTextMode() );
        break;
    }
 
    case PCB_DIM_ALIGNED_T:
    case PCB_DIM_CENTER_T:
    case PCB_DIM_RADIAL_T:
    case PCB_DIM_ORTHOGONAL_T:
    case PCB_DIM_LEADER_T:
        m_plotter->SetTextMode( PLOT_TEXT_MODE::STROKE );
 
        PlotDimension( static_cast<const PCB_DIMENSION_BASE*>( item ) );
 
        m_plotter->SetTextMode( GetTextMode() );
        break;
 
    case PCB_TARGET_T:
        PlotPcbTarget( static_cast<const PCB_TARGET*>( item ) );
        break;
 
    default:
        break;
    }
}
 
 
void BRDITEMS_PLOTTER::PlotDimension( const PCB_DIMENSION_BASE* aDim ) const
{
    if( !m_layerMask[aDim->GetLayer()] )
        return;
 
    COLOR4D color = ColorSettings()->GetColor( aDim->GetLayer() );
 
    // Set plot color (change WHITE to LIGHTGRAY because
    // the white items are not seen on a white paper or screen
    m_plotter->SetColor( color != WHITE ? color : LIGHTGRAY);
 
    PlotText( aDim, aDim->GetLayer(), false, aDim->GetFontMetrics() );
 
    PCB_SHAPE temp_item;
 
    temp_item.SetStroke( STROKE_PARAMS( aDim->GetLineThickness(), LINE_STYLE::SOLID ) );
    temp_item.SetLayer( aDim->GetLayer() );
 
    for( const std::shared_ptr<SHAPE>& shape : aDim->GetShapes() )
    {
        switch( shape->Type() )
        {
        case SH_SEGMENT:
        {
            const SEG& seg = static_cast<const SHAPE_SEGMENT*>( shape.get() )->GetSeg();
 
            temp_item.SetShape( SHAPE_T::SEGMENT );
            temp_item.SetStart( seg.A );
            temp_item.SetEnd( seg.B );
 
            PlotShape( &temp_item );
            break;
        }
 
        case SH_CIRCLE:
        {
            VECTOR2I start( shape->Centre() );
            int radius = static_cast<const SHAPE_CIRCLE*>( shape.get() )->GetRadius();
 
            temp_item.SetShape( SHAPE_T::CIRCLE );
            temp_item.SetFilled( false );
            temp_item.SetStart( start );
            temp_item.SetEnd( VECTOR2I( start.x + radius, start.y ) );
 
            PlotShape( &temp_item );
            break;
        }
 
        default:
            break;
        }
    }
}
 
 
void BRDITEMS_PLOTTER::PlotPcbTarget( const PCB_TARGET* aMire ) const
{
    int dx1, dx2, dy1, dy2, radius;
 
    if( !m_layerMask[aMire->GetLayer()] )
        return;
 
    m_plotter->SetColor( getColor( aMire->GetLayer() ) );
 
    PCB_SHAPE temp_item;
 
    temp_item.SetShape( SHAPE_T::CIRCLE );
    temp_item.SetFilled( false );
    temp_item.SetStroke( STROKE_PARAMS( aMire->GetWidth(), LINE_STYLE::SOLID ) );
    temp_item.SetLayer( aMire->GetLayer() );
    temp_item.SetStart( aMire->GetPosition() );
    radius = aMire->GetSize() / 3;
 
    if( aMire->GetShape() )   // temp_item X
        radius = aMire->GetSize() / 2;
 
    // Draw the circle
    temp_item.SetEnd( VECTOR2I( temp_item.GetStart().x + radius, temp_item.GetStart().y ) );
 
    PlotShape( &temp_item );
 
    temp_item.SetShape( SHAPE_T::SEGMENT );
 
    radius = aMire->GetSize() / 2;
    dx1    = radius;
    dy1    = 0;
    dx2    = 0;
    dy2    = radius;
 
    if( aMire->GetShape() )    // Shape X
    {
        dx1 = dy1 = radius;
        dx2 = dx1;
        dy2 = -dy1;
    }
 
    VECTOR2I mirePos( aMire->GetPosition() );
 
    // Draw the X or + temp_item:
    temp_item.SetStart( VECTOR2I( mirePos.x - dx1, mirePos.y - dy1 ) );
    temp_item.SetEnd( VECTOR2I( mirePos.x + dx1, mirePos.y + dy1 ) );
    PlotShape( &temp_item );
 
    temp_item.SetStart( VECTOR2I( mirePos.x - dx2, mirePos.y - dy2 ) );
    temp_item.SetEnd( VECTOR2I( mirePos.x + dx2, mirePos.y + dy2 ) );
    PlotShape( &temp_item );
}
 
 
void BRDITEMS_PLOTTER::PlotFootprintGraphicItems( const FOOTPRINT* aFootprint ) const
{
    const wxString variantName = m_board ? m_board->GetCurrentVariant() : wxString();
    const bool     dnp = aFootprint->GetDNPForVariant( variantName );
 
    for( const BOARD_ITEM* item : aFootprint->GraphicalItems() )
    {
        PCB_LAYER_ID itemLayer = item->GetLayer();
 
        if( aFootprint->GetPrivateLayers().test( itemLayer ) )
            continue;
 
        if( dnp && hideDNPItems( itemLayer ) )
            continue;
 
        if( !( m_layerMask & item->GetLayerSet() ).any() )
            continue;
 
        m_plotter->MarkFootprintPlotted( aFootprint );
 
        switch( item->Type() )
        {
        case PCB_SHAPE_T:
            PlotShape( static_cast<const PCB_SHAPE*>( item ) );
            break;
 
        case PCB_TEXTBOX_T:
        {
            const PCB_TEXTBOX* textbox = static_cast<const PCB_TEXTBOX*>( item );
 
            m_plotter->SetTextMode( PLOT_TEXT_MODE::STROKE );
 
            PlotText( textbox, textbox->GetLayer(), textbox->IsKnockout(),
                      textbox->GetFontMetrics() );
 
            if( textbox->IsBorderEnabled() )
            {
                // PlotShape works only for textbox rotated by 0 or 180 degrees.
                // This is not always the case so use the polygonal shape
                PCB_SHAPE dummy = textbox->GetPolygonalBoxShape();
                PlotShape( &dummy );
            }
 
            m_plotter->SetTextMode( GetTextMode() );
            break;
        }
 
        case PCB_BARCODE_T:
            PlotBarCode( static_cast<const PCB_BARCODE*>( item ) );
            break;
 
        case PCB_TABLE_T:
        case PCB_DRILL_CHART_T:
        {
            const PCB_TABLE* table = static_cast<const PCB_TABLE*>( item );
 
            m_plotter->SetTextMode( PLOT_TEXT_MODE::STROKE );
 
            for( const PCB_TABLECELL* cell : table->GetCells() )
                PlotText( cell, cell->GetLayer(), cell->IsKnockout(), cell->GetFontMetrics() );
 
            PlotTableBorders( table );
 
            m_plotter->SetTextMode( GetTextMode() );
            break;
        }
 
        case PCB_DIM_ALIGNED_T:
        case PCB_DIM_CENTER_T:
        case PCB_DIM_RADIAL_T:
        case PCB_DIM_ORTHOGONAL_T:
        case PCB_DIM_LEADER_T:
            PlotDimension( static_cast<const PCB_DIMENSION_BASE*>( item ) );
            break;
 
        case PCB_TEXT_T:
            // Plotted in PlotFootprintTextItems()
            break;
 
        case PCB_REFERENCE_IMAGE_T:
            // Not plotted at all
            break;
 
        default:
            UNIMPLEMENTED_FOR( item->GetClass() );
        }
    }
}
 
 
static void* plotMetadata( PLOTTER* aPlotter, GBR_METADATA& aMetadata, const PLOT_PARAMS* aPlotOptions )
{
    // Gerber writes its metadata through the plotters' opaque data parameter, so that parameter
    // stays void*.  DXF instead reads the sketch/filled mode back out of the plot options and
    // never writes to them, which is what lets a const plot hand them over at all.
    switch( aPlotter->GetPlotterType() )
    {
    case PLOT_FORMAT::GERBER:   return &aMetadata;
    case PLOT_FORMAT::DXF:      return const_cast<PLOT_PARAMS*>( aPlotOptions );
    default:                    return nullptr;
    }
}
 
 
#define getMetadata() plotMetadata( m_plotter, gbr_metadata, this )
 
 
void BRDITEMS_PLOTTER::PlotText( const EDA_TEXT* aText, PCB_LAYER_ID aLayer, bool aIsKnockout,
                                 const KIFONT::METRICS& aFontMetrics, bool aStrikeout ) const
{
    int           maxError = m_board->GetDesignSettings().m_MaxError;
    KIFONT::FONT* font = aText->GetDrawFont( m_plotter->RenderSettings() );
    wxString      shownText( aText->GetShownText( FOR_CANVAS ) );
 
    const PCB_TEXTBOX* knockoutBox = aIsKnockout ? dynamic_cast<const PCB_TEXTBOX*>( aText ) : nullptr;
 
    if( shownText.IsEmpty() && !knockoutBox )
        return;
 
    if( !m_layerMask[aLayer] )
        return;
 
    GBR_METADATA gbr_metadata;
 
    if( IsCopperLayer( aLayer ) )
        gbr_metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_NONCONDUCTOR );
 
    COLOR4D color = getColor( aLayer );
    m_plotter->SetColor( color );
 
    const VECTOR2I& pos = aText->GetTextPos();
 
    TEXT_ATTRIBUTES attrs = aText->GetAttributes();
    attrs.m_Size = aText->GetTextSize();
    attrs.m_StrokeWidth = aText->GetEffectiveTextPenWidth();
    attrs.m_Angle = aText->GetDrawRotation();
    attrs.m_Multiline = false;
 
    m_plotter->SetCurrentLineWidth( attrs.m_StrokeWidth );
 
    const auto strikeoutText =
            [&]( const PCB_TEXT* text )
            {
                SHAPE_POLY_SET  textPoly;
 
                text->TransformTextToPolySet( textPoly, 0, ARC_LOW_DEF, ERROR_INSIDE );
                textPoly.Rotate( -text->GetDrawRotation(), text->GetDrawPos() );
 
                BOX2I    rect = textPoly.BBox();
                VECTOR2I start( rect.GetLeft() - attrs.m_StrokeWidth,
                                ( rect.GetTop() + rect.GetBottom() ) / 2 );
                VECTOR2I end( rect.GetRight() + attrs.m_StrokeWidth,
                              ( rect.GetTop() + rect.GetBottom() ) / 2 );
 
                RotatePoint( start, text->GetDrawPos(), text->GetDrawRotation() );
                RotatePoint( end, text->GetDrawPos(), text->GetDrawRotation() );
 
                m_plotter->ThickSegment( start, end, attrs.m_StrokeWidth, getMetadata() );
            };
 
    if( aIsKnockout )
    {
        SHAPE_POLY_SET  finalPoly;
 
        if( knockoutBox )
            knockoutBox->TransformTextToPolySet( finalPoly, 0, maxError, ERROR_INSIDE );
        else if( const PCB_TEXT* text = dynamic_cast<const PCB_TEXT*>( aText ) )
            text->TransformTextToPolySet( finalPoly, 0, maxError, ERROR_INSIDE );
 
        finalPoly.Fracture();
 
        for( int ii = 0; ii < finalPoly.OutlineCount(); ++ii )
            m_plotter->PlotPoly( finalPoly.Outline( ii ), FILL_T::FILLED_SHAPE, 0, getMetadata() );
    }
    else
    {
        if( font->IsOutline() && !m_board->GetEmbeddedFiles()->GetAreFontsEmbedded() )
        {
            KIGFX::GAL_DISPLAY_OPTIONS empty_opts;
 
            CALLBACK_GAL callback_gal( empty_opts,
                    // Stroke callback
                    [&]( const VECTOR2I& aPt1, const VECTOR2I& aPt2 )
                    {
                        m_plotter->ThickSegment( aPt1, aPt2, attrs.m_StrokeWidth, getMetadata() );
                    },
                    // Polygon callback
                    [&]( const SHAPE_LINE_CHAIN& aPoly )
                    {
                        m_plotter->PlotPoly( aPoly, FILL_T::FILLED_SHAPE, 0, getMetadata() );
                    } );
 
            callback_gal.DrawGlyphs( *aText->GetRenderCache( font, shownText ) );
        }
        else if( aText->IsMultilineAllowed() )
        {
            std::vector<VECTOR2I> positions;
            wxArrayString strings_list;
            wxStringSplit( shownText, strings_list, '\n' );
            positions.reserve(  strings_list.Count() );
 
            aText->GetLinePositions( m_plotter->RenderSettings(), positions, (int) strings_list.Count() );
 
            for( unsigned ii = 0; ii < strings_list.Count(); ii++ )
            {
                wxString& txt =  strings_list.Item( ii );
                m_plotter->PlotText( positions[ii], color, txt, attrs, font, aFontMetrics, getMetadata() );
            }
 
            if( aStrikeout && strings_list.Count() == 1 )
                strikeoutText( static_cast<const PCB_TEXT*>( aText ) );
        }
        else
        {
            m_plotter->PlotText( pos, color, shownText, attrs, font, aFontMetrics, getMetadata() );
 
            if( aStrikeout )
                strikeoutText( static_cast<const PCB_TEXT*>( aText ) );
        }
    }
}
 
 
void BRDITEMS_PLOTTER::PlotZone( const ZONE* aZone, PCB_LAYER_ID aLayer, const SHAPE_POLY_SET& aPolysList ) const
{
    if( aPolysList.IsEmpty() )
        return;
 
    GBR_METADATA gbr_metadata;
 
    if( aZone->IsOnCopperLayer() )
    {
        gbr_metadata.SetNetName( aZone->GetNetname() );
        gbr_metadata.SetCopper( true );
 
        // Zones with no net name can exist.
        // they are not used to connect items, so the aperture attribute cannot
        // be set as conductor
        if( aZone->GetNetname().IsEmpty() )
        {
            gbr_metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_NONCONDUCTOR );
        }
        else
        {
            gbr_metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CONDUCTOR );
            gbr_metadata.SetNetAttribType( GBR_NETLIST_METADATA::GBR_NETINFO_NET );
        }
    }
 
    m_plotter->SetColor( getColor( aLayer ) );
 
    m_plotter->StartBlock( nullptr );    // Clean current object attributes
 
    /*
     * In non filled mode the outline is plotted, but not the filling items
     */
 
    for( int idx = 0; idx < aPolysList.OutlineCount(); ++idx )
    {
        const SHAPE_LINE_CHAIN& outline = aPolysList.Outline( idx );
 
        // Plot the current filled area (as region for Gerber plotter to manage attributes)
        if( m_plotter->GetPlotterType() == PLOT_FORMAT::GERBER )
        {
            static_cast<GERBER_PLOTTER*>( m_plotter )->PlotGerberRegion( outline, &gbr_metadata );
        }
        else if( m_plotter->GetPlotterType() == PLOT_FORMAT::DXF )
        {
            if( GetDXFPlotMode() == FILLED )
                m_plotter->PlotPoly( outline, FILL_T::FILLED_SHAPE, 0, getMetadata() );
        }
        else
        {
            m_plotter->PlotPoly( outline, FILL_T::FILLED_SHAPE, 0, getMetadata() );
        }
    }
 
    m_plotter->EndBlock( nullptr );    // Clear object attributes
}
 
 
void BRDITEMS_PLOTTER::PlotShape( const PCB_SHAPE* aShape ) const
{
    if( !( m_layerMask & aShape->GetLayerSet() ).any() )
        return;
 
    int          thickness = aShape->GetWidth();
    int          margin = thickness; // unclamped thickness (can be negative)
    LINE_STYLE   lineStyle = aShape->GetStroke().GetLineStyle();
    bool         onCopperLayer = ( LSET::AllCuMask() & m_layerMask ).any();
    bool         onSolderMaskLayer = ( LSET( { F_Mask, B_Mask } ) & m_layerMask ).any();
    bool         isSolidFill = aShape->IsSolidFill();
    bool         isHatchedFill = aShape->IsHatchedFill();
 
    if( onSolderMaskLayer
        && aShape->HasSolderMask()
        && IsExternalCopperLayer( aShape->GetLayer() ) )
    {
        margin += 2 * aShape->GetSolderMaskExpansion();
        thickness = std::max( margin, 0 );
 
        if( isHatchedFill )
        {
            isSolidFill = true;
            isHatchedFill = false;
        }
    }
 
    m_plotter->SetColor( getColor( aShape->GetLayer() ) );
 
    const FOOTPRINT* parentFP = aShape->GetParentFootprint();
    GBR_METADATA     gbr_metadata;
    const wxString   variantName = m_board ? m_board->GetCurrentVariant() : wxString();
    const bool       parentDnp = parentFP ? parentFP->GetDNPForVariant( variantName ) : false;
 
    if( parentFP )
    {
        gbr_metadata.SetCmpReference( parentFP->GetReference() );
        gbr_metadata.SetNetAttribType( GBR_NETLIST_METADATA::GBR_NETINFO_CMP );
    }
 
    if( parentFP && parentDnp && GetSketchDNPFPsOnFabLayers() )
    {
        if( aShape->GetLayer() == F_Fab || aShape->GetLayer() == B_Fab )
        {
            thickness = GetSketchPadLineWidth();
            isSolidFill = false;
            isHatchedFill = false;
        }
    }
 
    if( aShape->GetLayer() == Edge_Cuts )
    {
        gbr_metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_EDGECUT );
    }
    else if( onCopperLayer )
    {
        if( parentFP )
        {
            gbr_metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_ETCHEDCMP );
            gbr_metadata.SetCopper( true );
        }
        else if( aShape->GetNetCode() > 0 )
        {
            gbr_metadata.SetCopper( true );
            gbr_metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CONDUCTOR );
            gbr_metadata.SetNetAttribType( GBR_NETLIST_METADATA::GBR_NETINFO_NET );
            gbr_metadata.SetNetName( aShape->GetNetname() );
        }
        else
        {
            // Graphic items (PCB_SHAPE, TEXT) having no net have the NonConductor attribute
            // Graphic items having a net have the Conductor attribute, but are not (yet?)
            // supported in Pcbnew
            gbr_metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_NONCONDUCTOR );
        }
    }
 
    if( lineStyle <= LINE_STYLE::FIRST_TYPE )
    {
        switch( aShape->GetShape() )
        {
        case SHAPE_T::SEGMENT:
        {
            VECTOR2I segStart = aShape->GetStart();
            VECTOR2I segEnd = aShape->GetEnd();
 
            if( EDA_SHAPE::ShortenSegmentForEndings( segStart, segEnd, aShape->GetStartEnding(), aShape->GetEndEnding(),
                                                     thickness ) )
            {
                m_plotter->ThickSegment( segStart, segEnd, thickness, getMetadata() );
            }
 
            break;
        }
 
        case SHAPE_T::CIRCLE:
            if( isSolidFill )
            {
                int diameter = aShape->GetRadius() * 2 + thickness;
 
                if( margin < 0 )
                {
                    diameter += margin;
                    diameter = std::max( diameter, 0 );
                }
 
                m_plotter->FilledCircle( aShape->GetStart(), diameter, getMetadata() );
            }
            else
            {
                m_plotter->ThickCircle( aShape->GetStart(), aShape->GetRadius() * 2, thickness, getMetadata() );
            }
 
            break;
 
        case SHAPE_T::ARC:
        {
            // when startAngle == endAngle ThickArc() doesn't know whether it's 0 deg and 360 deg
            // but it is a circle
            if( std::abs( aShape->GetArcAngle().AsDegrees() ) == 360.0 )
            {
                m_plotter->ThickCircle( aShape->GetCenter(), aShape->GetRadius() * 2, thickness, getMetadata() );
            }
            else
            {
                EDA_ANGLE startAngle;
                EDA_ANGLE endAngle;
                aShape->CalcArcAngles( startAngle, endAngle );
 
                EDA_ANGLE arcAngle = endAngle - startAngle;
 
                if( aShape->ShortenArcForEndings( startAngle, arcAngle, aShape->GetRadius(), thickness ) )
                {
                    m_plotter->ThickArc( VECTOR2D( aShape->GetCenter() ), startAngle, arcAngle, aShape->GetRadius(),
                                         thickness, getMetadata() );
                }
            }
 
            break;
        }
 
        case SHAPE_T::BEZIER:
            if( std::optional<BEZIER<double>> curve = aShape->ShortenedBezierCurve( thickness ) )
            {
                if( m_plotter->GetPlotterType() == PLOT_FORMAT::SVG )
                {
                    m_plotter->BezierCurve( VECTOR2I( curve->Start ), VECTOR2I( curve->C1 ), VECTOR2I( curve->C2 ),
                                            VECTOR2I( curve->End ), aShape->GetMaxError(), thickness );
                }
                else
                {
                    std::vector<VECTOR2D> pts = aShape->ShortenedBezierPolyline( thickness );
 
                    for( size_t i = 0; i + 1 < pts.size(); i++ )
                        m_plotter->ThickSegment( VECTOR2I( pts[i] ), VECTOR2I( pts[i + 1] ), thickness, getMetadata() );
                }
            }
 
            break;
 
        case SHAPE_T::POLY:
            if( aShape->IsPolyShapeValid() )
            {
                auto plotStrokeOutline =
                        [&]( const SHAPE_LINE_CHAIN& aOutline, int aOutlineIdx )
                        {
                            if( aOutline.PointCount() < 2 )
                                return;
 
                            if( aShape->GetStartEnding().GetShortenDepth( thickness ) > 0
                                || aShape->GetEndEnding().GetShortenDepth( thickness ) > 0 )
                            {
                                std::vector<VECTOR2I> pts;
 
                                if( !aShape->GetShortenedBodyPolyPoints( aOutline, aOutlineIdx, pts, thickness ) )
                                    return;
 
                                SHAPE_LINE_CHAIN shortened;
 
                                for( const VECTOR2I& pt : pts )
                                    shortened.Append( pt );
 
                                shortened.SetClosed( aOutline.IsClosed() );
                                m_plotter->PlotPoly( shortened, FILL_T::NO_FILL, thickness, getMetadata() );
                            }
                            else
                            {
                                m_plotter->PlotPoly( aOutline, FILL_T::NO_FILL, thickness, getMetadata() );
                            }
                        };
 
                if( m_plotter->GetPlotterType() == PLOT_FORMAT::DXF && GetDXFPlotMode() == SKETCH )
                {
                    m_plotter->ThickPoly( aShape->GetPolyShape(), thickness, getMetadata() );
                }
                else
                {
                    m_plotter->SetCurrentLineWidth( thickness, &gbr_metadata );
 
                    const SHAPE_POLY_SET& origPoly = aShape->GetPolyShape();
 
                    // Stroke the unfractured outline so degenerate near-zero-width spikes (which Fracture()
                    // collapses but the editor still draws as thick lines) are preserved in the plot output
                    // (issue #24143).
                    if( thickness > 0 )
                    {
                        if( m_plotter->GetPlotterType() == PLOT_FORMAT::DXF && isSolidFill )
                        {
                            // We can't split outline and fill into separate instructions for DXF as it
                            // doesn't do fills, so we need the outline to be drawn only once (and include
                            // any thick edge).
                        }
                        else
                        {
                            for( int jj = 0; jj < origPoly.OutlineCount(); ++jj )
                                plotStrokeOutline( origPoly.COutline( jj ), jj );
 
                            thickness = 0;
                        }
                    }
 
                    if( !isSolidFill )
                        break;
 
                    // Fracture before plotting the fill to avoid invalid gerber regions generated from
                    // self-intersecting or overlapping outlines.
                    SHAPE_POLY_SET tmpPoly = origPoly.CloneDropTriangulation();
                    tmpPoly.Fracture();
 
                    if( margin < 0 )
                        tmpPoly.Inflate( margin / 2, CORNER_STRATEGY::ROUND_ALL_CORNERS, aShape->GetMaxError() );
 
                    for( int jj = 0; jj < tmpPoly.OutlineCount(); ++jj )
                    {
                        SHAPE_LINE_CHAIN& poly = tmpPoly.Outline( jj );
                        poly.SetClosed( true );
 
                        // Width 0; the stroke was already plotted from the unfractured outline.
                        if( m_plotter->GetPlotterType() == PLOT_FORMAT::GERBER )
                        {
                            GERBER_PLOTTER* gbr_plotter = static_cast<GERBER_PLOTTER*>( m_plotter );
                            gbr_plotter->PlotPolyAsRegion( poly, FILL_T::FILLED_SHAPE, thickness, &gbr_metadata );
                        }
                        else
                        {
                            m_plotter->PlotPoly( poly, FILL_T::FILLED_SHAPE, thickness, getMetadata() );
                        }
                    }
                }
            }
 
            break;
 
        case SHAPE_T::RECTANGLE:
        {
            int radius = aShape->GetCornerRadius();
 
            if( radius == 0 && m_plotter->GetPlotterType() == PLOT_FORMAT::DXF && GetDXFPlotMode() == SKETCH )
            {
                std::vector<VECTOR2I> pts = aShape->GetRectCorners();
                m_plotter->ThickRect( pts[0], pts[2], thickness, getMetadata() );
            }
            else
            {
                BOX2I box( aShape->GetStart(), VECTOR2I( aShape->GetEnd().x - aShape->GetStart().x,
                                                         aShape->GetEnd().y - aShape->GetStart().y ) );
                box.Normalize();
 
                if( margin < 0 )
                {
                    box.Inflate( margin );
                    radius += margin;
                }
 
                SHAPE_RECT rect( box );
                rect.SetRadius( radius );
 
                SHAPE_LINE_CHAIN outline = rect.Outline();
                SHAPE_POLY_SET  poly( outline );
 
                FILL_T fill_mode = isSolidFill ? FILL_T::FILLED_SHAPE : FILL_T::NO_FILL;
 
                if( poly.OutlineCount() > 0 )
                {
                    if( m_plotter->GetPlotterType() == PLOT_FORMAT::GERBER )
                    {
                        GERBER_PLOTTER* gbr_plotter = static_cast<GERBER_PLOTTER*>( m_plotter );
                        gbr_plotter->PlotPolyAsRegion( poly.COutline( 0 ), fill_mode, thickness, &gbr_metadata );
                    }
                    else
                    {
                        // TODO: PlotPoly needs to handle arcs...
                        m_plotter->PlotPoly( poly.COutline( 0 ), fill_mode, thickness, getMetadata() );
                    }
                }
            }
 
            break;
        }
 
        case SHAPE_T::ELLIPSE:
        case SHAPE_T::ELLIPSE_ARC:
        {
            const bool isClosed = ( aShape->GetShape() == SHAPE_T::ELLIPSE );
 
            SHAPE_ELLIPSE e = isClosed ? SHAPE_ELLIPSE( aShape->GetEllipseCenter(), aShape->GetEllipseMajorRadius(),
                                                        aShape->GetEllipseMinorRadius(), aShape->GetEllipseRotation() )
                                       : SHAPE_ELLIPSE( aShape->GetEllipseCenter(), aShape->GetEllipseMajorRadius(),
                                                        aShape->GetEllipseMinorRadius(), aShape->GetEllipseRotation(),
                                                        aShape->GetEllipseStartAngle(), aShape->GetEllipseEndAngle() );
 
            SHAPE_LINE_CHAIN chain = e.ConvertToPolyline( aShape->GetMaxError() );
 
            if( isClosed )
                chain.SetClosed( true );
 
            FILL_T fill = ( isClosed && isSolidFill ) ? FILL_T::FILLED_SHAPE : FILL_T::NO_FILL;
 
            if( m_plotter->GetPlotterType() == PLOT_FORMAT::GERBER && isClosed )
            {
                GERBER_PLOTTER* gbr_plotter = static_cast<GERBER_PLOTTER*>( m_plotter );
                gbr_plotter->PlotPolyAsRegion( chain, fill, thickness, &gbr_metadata );
            }
            else
            {
                m_plotter->PlotPoly( chain, fill, thickness, getMetadata() );
            }
 
            break;
        }
 
        default:
            UNIMPLEMENTED_FOR( aShape->SHAPE_T_asString() );
        }
    }
    else
    {
        std::vector<SHAPE*> shapes = aShape->MakeEffectiveShapesForStroking( thickness );
 
        for( SHAPE* shape : shapes )
        {
            STROKE_PARAMS::Stroke( shape, lineStyle, aShape->GetWidth(),
                                   m_plotter->RenderSettings(),
                                   [&]( const VECTOR2I& a, const VECTOR2I& b )
                                   {
                                       m_plotter->ThickSegment( a, b, thickness, getMetadata() );
                                   } );
        }
 
        for( SHAPE* shape : shapes )
            delete shape;
    }
 
    // Plot line endings for open shapes.
    if( aShape->GetStartEnding().GetStyle() != LINE_ENDING_STYLE::NONE
        || aShape->GetEndEnding().GetStyle() != LINE_ENDING_STYLE::NONE )
    {
        EDA_ANGLE startTangent, endTangent;
        aShape->GetEndingTangents( startTangent, endTangent, thickness );
 
        VECTOR2I startPt, endPt;
 
        if( aShape->GetLineEndingEndpoints( startPt, endPt ) )
        {
            aShape->GetStartEnding().Plot( m_plotter, startPt, startTangent, thickness, getMetadata() );
            aShape->GetEndEnding().Plot( m_plotter, endPt, endTangent, thickness, getMetadata() );
        }
    }
 
    if( isHatchedFill )
    {
        for( int ii = 0; ii < aShape->GetHatching().OutlineCount(); ++ii )
        {
            if( m_plotter->GetPlotterType() == PLOT_FORMAT::GERBER )
            {
                GERBER_PLOTTER* gbr_plotter = static_cast<GERBER_PLOTTER*>( m_plotter );
                gbr_plotter->PlotPolyAsRegion( aShape->GetHatching().Outline( ii ), FILL_T::FILLED_SHAPE, 0,
                                               &gbr_metadata );
            }
            else
            {
                m_plotter->PlotPoly( aShape->GetHatching().Outline( ii ), FILL_T::FILLED_SHAPE, 0, getMetadata() );
            }
        }
    }
}
 
 
void BRDITEMS_PLOTTER::PlotBarCode( const PCB_BARCODE* aBarCode ) const
{
    if( !m_layerMask[aBarCode->GetLayer()] )
        return;
 
    // To avoid duplicate code, build a PCB_SHAPE to plot the polygon shape
    PCB_SHAPE dummy( aBarCode->GetParent(), SHAPE_T::POLY );
    dummy.SetLayer( aBarCode->GetLayer() );
    dummy.SetFillMode( FILL_T::FILLED_SHAPE );
    dummy.SetWidth( 0 );
 
    SHAPE_POLY_SET shape;
    aBarCode->TransformShapeToPolySet( shape, aBarCode->GetLayer(), 0, 0, ERROR_INSIDE );
    dummy.SetPolyShape( shape );
 
    PlotShape( &dummy );
}
 
 
void BRDITEMS_PLOTTER::PlotTableBorders( const PCB_TABLE* aTable ) const
{
    if( !m_layerMask[aTable->GetLayer()] )
        return;
 
    GBR_METADATA gbr_metadata;
 
    if( const FOOTPRINT* parentFP = aTable->GetParentFootprint() )
    {
        gbr_metadata.SetCmpReference( parentFP->GetReference() );
        gbr_metadata.SetNetAttribType( GBR_NETLIST_METADATA::GBR_NETINFO_CMP );
    }
 
    aTable->DrawBorders(
            [&]( const VECTOR2I& ptA, const VECTOR2I& ptB, const STROKE_PARAMS& stroke )
            {
                int        lineWidth = stroke.GetWidth();
                LINE_STYLE lineStyle = stroke.GetLineStyle();
 
                if( lineStyle <= LINE_STYLE::FIRST_TYPE )
                {
                    m_plotter->ThickSegment( ptA, ptB, lineWidth, getMetadata() );
                }
                else
                {
                    SHAPE_SEGMENT seg( ptA, ptB );
 
                    STROKE_PARAMS::Stroke( &seg, lineStyle, lineWidth, m_plotter->RenderSettings(),
                            [&]( const VECTOR2I& a, const VECTOR2I& b )
                            {
                                m_plotter->ThickSegment( a, b, lineWidth, getMetadata() );
                            } );
                }
            } );
}
 
 
void BRDITEMS_PLOTTER::plotOneDrillMark( PAD_DRILL_SHAPE aDrillShape, const VECTOR2I& aDrillPos,
                                         const VECTOR2I& aDrillSize, const VECTOR2I& aPadSize,
                                         const EDA_ANGLE& aOrientation, int aSmallDrill ) const
{
    VECTOR2I drillSize = aDrillSize;
 
    // Small drill marks have no significance when applied to slots
    if( aSmallDrill && aDrillShape == PAD_DRILL_SHAPE::CIRCLE )
        drillSize.x = std::min( aSmallDrill, drillSize.x );
 
    // Round holes only have x diameter, slots have both
    drillSize.x -= getFineWidthAdj();
    drillSize.x = std::clamp( drillSize.x, 1, aPadSize.x - 1 );
 
    if( aDrillShape == PAD_DRILL_SHAPE::OBLONG )
    {
        drillSize.y -= getFineWidthAdj();
        drillSize.y = std::clamp( drillSize.y, 1, aPadSize.y - 1 );
 
        m_plotter->FlashPadOval( aDrillPos, drillSize, aOrientation, nullptr );
    }
    else
    {
        m_plotter->FlashPadCircle( aDrillPos, drillSize.x, nullptr );
    }
}
 
 
void BRDITEMS_PLOTTER::PlotDrillMarks() const
{
    int smallDrill = 0;
 
    if( GetDrillMarksType() == DRILL_MARKS::SMALL_DRILL_SHAPE )
        smallDrill = pcbIUScale.mmToIU( ADVANCED_CFG::GetCfg().m_SmallDrillMarkSize );
 
    /* Drill marks are drawn white-on-black to knock-out the underlying pad.  This works only
     * for drivers supporting color change, obviously... it means that:
       - PS, SVG and PDF output is correct (i.e. you have a 'donut' pad)
       - In gerbers you can't see them. This is arguably the right thing to do since having
         drill marks and high speed drill stations is a sure recipe for broken tools and angry
         manufacturers. If you *really* want them you could start a layer with negative
         polarity to knock-out the film.
       - In DXF they go into the 'WHITE' layer. This could be useful.
     */
    if( m_plotter->GetPlotterType() != PLOT_FORMAT::DXF || GetDXFPlotMode() == FILLED )
         m_plotter->SetColor( WHITE );
 
    for( PCB_TRACK* track : m_board->Tracks() )
    {
        if( track->Type() == PCB_VIA_T )
        {
            const PCB_VIA* via = static_cast<const PCB_VIA*>( track );
 
            // Via are not always on all layers
            if( ( via->GetLayerSet() & m_layerMask ).none() )
                continue;
 
            plotOneDrillMark( PAD_DRILL_SHAPE::CIRCLE, via->GetStart(),
                              VECTOR2I( via->GetDrillValue(), 0 ),
                              VECTOR2I( via->GetWidth( PADSTACK::TEMP_ALL_LAYERS ), 0 ),
                              ANGLE_0, smallDrill );
        }
    }
 
    for( FOOTPRINT* footprint : m_board->Footprints() )
    {
        for( PAD* pad : footprint->Pads() )
        {
            if( pad->GetDrillSize().x == 0 )
                continue;
 
            // Skip marks on layers the pad isn't on for Gerber only (24416). Other
            // formats keep them as a drill map, e.g. Edge.Cuts (24867).
            if( m_plotter->GetPlotterType() == PLOT_FORMAT::GERBER && ( pad->GetLayerSet() & m_layerMask ).none() )
                continue;
 
            if( m_plotter->GetPlotterType() != PLOT_FORMAT::DXF || GetDXFPlotMode() == FILLED )
            {
                // Drill mark is in black unless we can find something to knock it out of
                m_plotter->SetColor( BLACK );
 
                for( PCB_LAYER_ID layer : m_layerMask )
                {
                    if( !pad->IsOnLayer( layer ) )
                        continue;
 
                    VECTOR2I padSize = pad->GetSize( layer );
 
                    if( padSize.x > pad->GetDrillSize().x || padSize.y > pad->GetDrillSize().y )
                    {
                        m_plotter->SetColor( WHITE );
                        break;
                    }
                }
            }
 
            plotOneDrillMark( pad->GetDrillShape(), pad->GetPosition(), pad->GetDrillSize(),
                              pad->GetSize( PADSTACK::TEMP_ALL_LAYERS ), pad->GetOrientation(), smallDrill );
        }
    }
 
    if( m_plotter->GetPlotterType() != PLOT_FORMAT::DXF || GetDXFPlotMode() == FILLED )
        m_plotter->SetColor( BLACK );
}
 
 
void BRDITEMS_PLOTTER::PlotDrillSymbols( PCB_LAYER_ID aLayer ) const
{
    const std::vector<const PCB_DRILL_MAP*> maps = m_board->DrillMapsOnLayer( aLayer );
 
    if( maps.empty() )
        return;
 
    const DRILL_SYMBOL_PROFILE& profile = m_board->GetDesignSettings().GetDrillSymbolProfile();
 
    // Resolved rather than read straight from the profile, so a map drawn without any chart
    // ever having been placed still shows marks
    const std::shared_ptr<const DRILL_SYMBOL_CACHE> cache = m_board->DrillSymbolCache();
 
    // DXF reads its sketch/filled mode back out of this. Without it every stroked mark is
    // emitted filled no matter what the user asked for
    GBR_METADATA gbr_metadata;
 
    m_plotter->SetColor( getColor( aLayer ) );
    m_plotter->SetCurrentLineWidth( profile.GetSymbolWidth() );
 
    DRILL_QUERY query;
    query.m_MergePTHNPTH = true;
 
    // Several maps can share a layer. The UI prevents it but a parsed, pasted or
    // API-created board need not
    for( const PCB_DRILL_MAP* map : maps )
    {
 
        const std::shared_ptr<const SHAPE_POLY_SET> outlines = map->GetBoardOutlines();
 
        for( int ii = 0; ii < outlines->OutlineCount(); ++ii )
        {
            m_plotter->PlotPoly( outlines->COutline( ii ), FILL_T::NO_FILL, profile.GetSymbolWidth(),
                                 getMetadata() );
 
            for( int jj = 0; jj < outlines->HoleCount( ii ); ++jj )
            {
                m_plotter->PlotPoly( outlines->CHole( ii, jj ), FILL_T::NO_FILL, profile.GetSymbolWidth(),
                                     getMetadata() );
            }
        }
 
        for( const DRILL_SPAN& span : EnumerateDrillSpans( *m_board ) )
        {
            // The map's own span filter, so a backdrill map does not print every other hole too
            if( !map->GetAllSpans() && !( span == map->GetSpan() ) )
                continue;
 
            query.m_Span = span;
 
            for( const DRILL_OPERATION& op : EnumerateDrillOperations( *m_board, query ) )
            {
                // The map is a set of marks on the holes, displaced as a whole. The holes
                // themselves never move
                const VECTOR2I pos = op.m_Position + map->GetOffset();
 
                const auto it = cache->m_ByGroup.find( profile.GroupKeyString( op ) );
 
                if( it == cache->m_ByGroup.end() )
                    continue;
 
                const DRILL_SYMBOL_ASSIGNMENT& assignment = it->second;
 
                if( assignment.m_MarkMode == DRILL_MARK_MODE::SHAPE )
                {
                    m_plotter->Marker( pos, map->GetSymbolSize(),
                                       DRILL_MARKERS::CuratedShape( assignment.m_ShapeIndex ) );
                }
                else
                {
                    const wxString text =
                            assignment.m_MarkMode == DRILL_MARK_MODE::LETTER
                                    ? assignment.m_Letter
                                    : wxString::Format( wxT( "%.2f" ),
                                                        pcbIUScale.IUTomm( op.m_Diameter ) );
 
                    TEXT_ATTRIBUTES attrs;
                    attrs.m_Size = VECTOR2I( map->GetSymbolSize(), map->GetSymbolSize() );
                    attrs.m_StrokeWidth = profile.GetSymbolWidth();
                    attrs.m_Halign = GR_TEXT_H_ALIGN_CENTER;
                    attrs.m_Valign = GR_TEXT_V_ALIGN_CENTER;
 
                    m_plotter->PlotText( pos, getColor( aLayer ), text, attrs, nullptr,
                                         KIFONT::METRICS::Default() );
                }
 
                if( map->GetGuideCross() )
                {
                    const int reach = map->GetSymbolSize();
 
                    m_plotter->ThickSegment( pos - VECTOR2I( reach, 0 ),
                                             pos + VECTOR2I( reach, 0 ),
                                             profile.GetSymbolWidth(), getMetadata() );
                    m_plotter->ThickSegment( pos - VECTOR2I( 0, reach ),
                                             pos + VECTOR2I( 0, reach ),
                                             profile.GetSymbolWidth(), getMetadata() );
                }
 
                // A slot's true extent is the cost driver, so it is drawn as well as marked
                if( map->GetOutlineSlots() && op.m_IsSlot )
                {
                    m_plotter->ThickOval( pos, op.m_SizeXY, op.m_Orientation,
                                          profile.GetSymbolWidth(), getMetadata() );
                }
            }
        }
    }
 
    m_plotter->SetCurrentLineWidth( PLOTTER::USE_DEFAULT_LINE_WIDTH );
}
 
 
void BRDITEMS_PLOTTER::PlotChartSymbols( const PCB_DRILL_CHART* aChart ) const
{
 
    if( aChart->GetSymbolColumn() < 0 || aChart->RowShapes().empty() )
        return;
 
    const DRILL_SYMBOL_PROFILE& profile = m_board->GetDesignSettings().GetDrillSymbolProfile();
 
    m_plotter->SetColor( getColor( aChart->GetLayer() ) );
    m_plotter->SetCurrentLineWidth( profile.GetSymbolWidth() );
 
    for( const auto& [row, shapeIndex] : aChart->RowShapes() )
    {
        const PCB_TABLECELL* cell = aChart->GetCell( row, aChart->GetSymbolColumn() );
 
        if( !cell )
            continue;
 
        const BOX2I box = cell->GetBoundingBox();
 
        // Same fit as the painter, so the plotted chart matches what was on screen
        const int size = std::min<int>( profile.GetSymbolSize(),
                                        std::min( box.GetWidth(), box.GetHeight() ) * 2 / 3 );
 
        if( size > 0 )
            m_plotter->Marker( box.GetCenter(), size, DRILL_MARKERS::CuratedShape( shapeIndex ) );
    }
 
    m_plotter->SetCurrentLineWidth( PLOTTER::USE_DEFAULT_LINE_WIDTH );
}