Functions to plot one board layer (silkscreen layers or other layers). More...

#include <eda_item.h>
#include <geometry/geometry_utils.h>
#include <geometry/shape_segment.h>
#include <pcb_base_frame.h>
#include <math/util.h>
#include <board.h>
#include <core/arraydim.h>
#include <footprint.h>
#include <track.h>
#include <fp_shape.h>
#include <pcb_text.h>
#include <zone.h>
#include <pcb_shape.h>
#include <pcb_target.h>
#include <dimension.h>
#include <pcbplot.h>
#include <plotters_specific.h>
#include <pcb_painter.h>
#include <gbr_metadata.h>
#include <advanced_config.h>

Macros
#define	NEW_ALGO 1

Functions
static void	PlotSolderMaskLayer (BOARD aBoard, PLOTTER aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt, int aMinThickness)

void	PlotOneBoardLayer (BOARD aBoard, PLOTTER aPlotter, PCB_LAYER_ID aLayer, const PCB_PLOT_PARAMS &aPlotOpt)
	Function PlotOneBoardLayer main function to plot one copper or technical layer. More...

void	PlotStandardLayer (BOARD aBoard, PLOTTER aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt)
	Function PlotStandardLayer plot copper or technical layers. More...

void	PlotLayerOutlines (BOARD aBoard, PLOTTER aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt)
	Function PlotLayerOutlines plot copper outline of a copper layer. More...

static void	initializePlotter (PLOTTER aPlotter, BOARD aBoard, PCB_PLOT_PARAMS *aPlotOpts)
	Set up most plot options for plotting a board (especially the viewport) Important thing: page size is the 'drawing' page size, paper size is the physical page size. More...

static void	FillNegativeKnockout (PLOTTER *aPlotter, const EDA_RECT &aBbbox)
	Prefill in black an area a little bigger than the board to prepare for the negative plot. More...

static void	ConfigureHPGLPenSizes (HPGL_PLOTTER aPlotter, PCB_PLOT_PARAMS aPlotOpts)
	Calculate the effective size of HPGL pens and set them in the plotter object. More...

PLOTTER *	StartPlotBoard (BOARD aBoard, PCB_PLOT_PARAMS aPlotOpts, int aLayer, const wxString &aFullFileName, const wxString &aSheetDesc)
	Open a new plotfile using the options (and especially the format) specified in the options and prepare the page for plotting. More...

Variables
static const PCB_LAYER_ID	plot_seq []

Detailed Description

Functions to plot one board layer (silkscreen layers or other layers).

Silkscreen layers have specific requirement for pads (not filled) and texts (with option to remove them from some copper areas (pads...)

Definition in file plot_board_layers.cpp.

Macro Definition Documentation

◆ NEW_ALGO

#define NEW_ALGO 1

Definition at line 745 of file plot_board_layers.cpp.

Function Documentation

◆ ConfigureHPGLPenSizes()

static void ConfigureHPGLPenSizes	(	HPGL_PLOTTER *	aPlotter,
		PCB_PLOT_PARAMS *	aPlotOpts
	)

static

Calculate the effective size of HPGL pens and set them in the plotter object.

Definition at line 1045 of file plot_board_layers.cpp.

 {
     // Compute penDiam (the value is given in mils) in pcb units, with plot scale (if Scale is 2,
     // penDiam value is always m_HPGLPenDiam so apparent penDiam is actually penDiam / Scale
     int penDiam = KiROUND( aPlotOpts->GetHPGLPenDiameter() * IU_PER_MILS / aPlotOpts->GetScale() );
 
     // Set HPGL-specific options and start
     aPlotter->SetPenSpeed( aPlotOpts->GetHPGLPenSpeed() );
     aPlotter->SetPenNumber( aPlotOpts->GetHPGLPenNum() );
     aPlotter->SetPenDiameter( penDiam );
 }

References PCB_PLOT_PARAMS::GetHPGLPenDiameter(), PCB_PLOT_PARAMS::GetHPGLPenNum(), PCB_PLOT_PARAMS::GetHPGLPenSpeed(), PCB_PLOT_PARAMS::GetScale(), IU_PER_MILS, KiROUND(), HPGL_PLOTTER::SetPenDiameter(), HPGL_PLOTTER::SetPenNumber(), and HPGL_PLOTTER::SetPenSpeed().

Referenced by StartPlotBoard().

◆ FillNegativeKnockout()

static void FillNegativeKnockout	(	PLOTTER *	aPlotter,
		const EDA_RECT &	aBbbox
	)

static

Prefill in black an area a little bigger than the board to prepare for the negative plot.

Definition at line 1030 of file plot_board_layers.cpp.

 {
     const int margin = 5 * IU_PER_MM;   // Add a 5 mm margin around the board
     aPlotter->SetNegative( true );
     aPlotter->SetColor( WHITE );        // Which will be plotted as black
     EDA_RECT area = aBbbox;
     area.Inflate( margin );
     aPlotter->Rect( area.GetOrigin(), area.GetEnd(), FILL_TYPE::FILLED_SHAPE );
     aPlotter->SetColor( BLACK );
 }

References BLACK, FILLED_SHAPE, EDA_RECT::GetEnd(), EDA_RECT::GetOrigin(), EDA_RECT::Inflate(), IU_PER_MM, PLOTTER::Rect(), PLOTTER::SetColor(), PLOTTER::SetNegative(), and WHITE.

Referenced by StartPlotBoard().

◆ initializePlotter()

static void initializePlotter	(	PLOTTER *	aPlotter,
		BOARD *	aBoard,
		PCB_PLOT_PARAMS *	aPlotOpts
	)

static

Set up most plot options for plotting a board (especially the viewport) Important thing: page size is the 'drawing' page size, paper size is the physical page size.

Definition at line 946 of file plot_board_layers.cpp.

 {
     PAGE_INFO pageA4( wxT( "A4" ) );
     const PAGE_INFO& pageInfo = aBoard->GetPageSettings();
     const PAGE_INFO* sheet_info;
     double paperscale; // Page-to-paper ratio
     wxSize paperSizeIU;
     wxSize pageSizeIU( pageInfo.GetSizeIU() );
     bool autocenter = false;
 
     // Special options: to fit the sheet to an A4 sheet replace the paper size. However there
     // is a difference between the autoscale and the a4paper option:
     //  - Autoscale fits the board to the paper size
     //  - A4paper fits the original paper size to an A4 sheet
     //  - Both of them fit the board to an A4 sheet
     if( aPlotOpts->GetA4Output() )
     {
         sheet_info  = &pageA4;
         paperSizeIU = pageA4.GetSizeIU();
         paperscale  = (double) paperSizeIU.x / pageSizeIU.x;
         autocenter  = true;
     }
     else
     {
         sheet_info  = &pageInfo;
         paperSizeIU = pageSizeIU;
         paperscale  = 1;
 
         // Need autocentering only if scale is not 1:1
         autocenter  = (aPlotOpts->GetScale() != 1.0);
     }
 
     EDA_RECT bbox = aBoard->ComputeBoundingBox();
     wxPoint boardCenter = bbox.Centre();
     wxSize boardSize = bbox.GetSize();
 
     double compound_scale;
 
     // Fit to 80% of the page if asked; it could be that the board is empty, in this case
     // regress to 1:1 scale
     if( aPlotOpts->GetAutoScale() && boardSize.x > 0 && boardSize.y > 0 )
     {
         double xscale = (paperSizeIU.x * 0.8) / boardSize.x;
         double yscale = (paperSizeIU.y * 0.8) / boardSize.y;
 
         compound_scale = std::min( xscale, yscale ) * paperscale;
     }
     else
         compound_scale = aPlotOpts->GetScale() * paperscale;
 
 
     // For the plot offset we have to keep in mind the auxiliary origin too: if autoscaling is
     // off we check that plot option (i.e. autoscaling overrides auxiliary origin)
     wxPoint offset( 0, 0);
 
     if( autocenter )
     {
         offset.x = KiROUND( boardCenter.x - ( paperSizeIU.x / 2.0 ) / compound_scale );
         offset.y = KiROUND( boardCenter.y - ( paperSizeIU.y / 2.0 ) / compound_scale );
     }
     else
     {
         if( aPlotOpts->GetUseAuxOrigin() )
             offset = aBoard->GetDesignSettings().m_AuxOrigin;
     }
 
     aPlotter->SetPageSettings( *sheet_info );
 
     aPlotter->SetViewport( offset, IU_PER_MILS/10, compound_scale, aPlotOpts->GetMirror() );
     // Has meaning only for gerber plotter. Must be called only after SetViewport
     aPlotter->SetGerberCoordinatesFormat( aPlotOpts->GetGerberPrecision() );
     // Has meaning only for SVG plotter. Must be called only after SetViewport
     aPlotter->SetSvgCoordinatesFormat( aPlotOpts->GetSvgPrecision(), aPlotOpts->GetSvgUseInch() );
 
     aPlotter->SetCreator( wxT( "PCBNEW" ) );
     aPlotter->SetColorMode( false );        // default is plot in Black and White.
     aPlotter->SetTextMode( aPlotOpts->GetTextMode() );
 }

Referenced by StartPlotBoard().

◆ PlotLayerOutlines()

void PlotLayerOutlines	(	BOARD *	aBoard,
		PLOTTER *	aPlotter,
		LSET	aLayerMask,
		const PCB_PLOT_PARAMS &	aPlotOpt
	)

Function PlotLayerOutlines plot copper outline of a copper layer.

Parameters

aBoard	= the board to plot
aPlotter	= the plotter to use
aLayerMask	= the mask to define the layers to plot
aPlotOpt	= the plot options. Has meaning for some formats only

Definition at line 632 of file plot_board_layers.cpp.

 {
     BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
     itemplotter.SetLayerSet( aLayerMask );
 
     SHAPE_POLY_SET outlines;
 
     for( LSEQ seq = aLayerMask.Seq( plot_seq, arrayDim( plot_seq ) );  seq;  ++seq )
     {
         PCB_LAYER_ID layer = *seq;
 
         outlines.RemoveAllContours();
         aBoard->ConvertBrdLayerToPolygonalContours( layer, outlines );
 
         outlines.Simplify( SHAPE_POLY_SET::PM_FAST );
 
         // Plot outlines
         std::vector<wxPoint> cornerList;
 
         // Now we have one or more basic polygons: plot each polygon
         for( int ii = 0; ii < outlines.OutlineCount(); ii++ )
         {
             for(int kk = 0; kk <= outlines.HoleCount (ii); kk++ )
             {
                 cornerList.clear();
                 const SHAPE_LINE_CHAIN& path = (kk == 0) ? outlines.COutline( ii ) : outlines.CHole( ii, kk - 1 );
 
                 for( int jj = 0; jj < path.PointCount(); jj++ )
                     cornerList.emplace_back( (wxPoint) path.CPoint( jj ) );
 
                 // Ensure the polygon is closed
                 if( cornerList[0] != cornerList[cornerList.size() - 1] )
                     cornerList.push_back( cornerList[0] );
 
                 aPlotter->PlotPoly( cornerList, FILL_TYPE::NO_FILL );
             }
         }
 
         // Plot pad holes
         if( aPlotOpt.GetDrillMarksType() != PCB_PLOT_PARAMS::NO_DRILL_SHAPE )
         {
             int smallDrill = (aPlotOpt.GetDrillMarksType() == PCB_PLOT_PARAMS::SMALL_DRILL_SHAPE)
                                   ? ADVANCED_CFG::GetCfg().m_SmallDrillMarkSize : INT_MAX;
 
             for( FOOTPRINT* footprint : aBoard->Footprints() )
             {
                 for( PAD* pad : footprint->Pads() )
                 {
                     wxSize hole = pad->GetDrillSize();
 
                     if( hole.x == 0 || hole.y == 0 )
                         continue;
 
                     if( hole.x == hole.y )
                     {
                         hole.x = std::min( smallDrill, hole.x );
                         aPlotter->Circle( pad->GetPosition(), hole.x, FILL_TYPE::NO_FILL );
                     }
                     else
                     {
                         // Note: small drill marks have no significance when applied to slots
                         const SHAPE_SEGMENT* seg = pad->GetEffectiveHoleShape();
                         aPlotter->ThickSegment( (wxPoint) seg->GetSeg().A,
                                                 (wxPoint) seg->GetSeg().B,
                                                 seg->GetWidth(), SKETCH, NULL );
                     }
                 }
             }
         }
 
         // Plot vias holes
         for( TRACK* track : aBoard->Tracks() )
         {
             const VIA* via = dyn_cast<const VIA*>( track );
 
             if( via && via->IsOnLayer( layer ) )    // via holes can be not through holes
             {
                 aPlotter->Circle( via->GetPosition(), via->GetDrillValue(), FILL_TYPE::NO_FILL );
             }
         }
     }
 }

References SEG::A, arrayDim(), SEG::B, SHAPE_POLY_SET::CHole(), PLOTTER::Circle(), BOARD::ConvertBrdLayerToPolygonalContours(), SHAPE_POLY_SET::COutline(), SHAPE_LINE_CHAIN::CPoint(), BOARD::Footprints(), ADVANCED_CFG::GetCfg(), PCB_PLOT_PARAMS::GetDrillMarksType(), VIA::GetDrillValue(), VIA::GetPosition(), SHAPE_SEGMENT::GetSeg(), SHAPE_SEGMENT::GetWidth(), SHAPE_POLY_SET::HoleCount(), VIA::IsOnLayer(), ADVANCED_CFG::m_SmallDrillMarkSize, PCB_PLOT_PARAMS::NO_DRILL_SHAPE, NO_FILL, NULL, SHAPE_POLY_SET::OutlineCount(), plot_seq, PLOTTER::PlotPoly(), SHAPE_POLY_SET::PM_FAST, SHAPE_LINE_CHAIN::PointCount(), SHAPE_POLY_SET::RemoveAllContours(), LSET::Seq(), BRDITEMS_PLOTTER::SetLayerSet(), SHAPE_POLY_SET::Simplify(), SKETCH, PCB_PLOT_PARAMS::SMALL_DRILL_SHAPE, PLOTTER::ThickSegment(), and BOARD::Tracks().

Referenced by PlotOneBoardLayer().

◆ PlotOneBoardLayer()

void PlotOneBoardLayer	(	BOARD *	aBoard,
		PLOTTER *	aPlotter,
		PCB_LAYER_ID	aLayer,
		const PCB_PLOT_PARAMS &	aPlotOpt
	)

Function PlotOneBoardLayer main function to plot one copper or technical layer.

It prepare options and calls the specialized plot function, according to the layer type

Parameters

aBoard	= the board to plot
aPlotter	= the plotter to use
aLayer	= the layer id to plot
aPlotOpt	= the plot options (files, sketch). Has meaning for some formats only

Definition at line 63 of file plot_board_layers.cpp.

 {
     PCB_PLOT_PARAMS plotOpt = aPlotOpt;
     int soldermask_min_thickness = aBoard->GetDesignSettings().m_SolderMaskMinWidth;
 
     // Set a default color and the text mode for this layer
     aPlotter->SetColor( BLACK );
     aPlotter->SetTextMode( aPlotOpt.GetTextMode() );
 
     // Specify that the contents of the "Edges Pcb" layer are to be plotted in addition to the
     // contents of the currently specified layer.
     LSET    layer_mask( aLayer );
 
     if( !aPlotOpt.GetExcludeEdgeLayer() )
         layer_mask.set( Edge_Cuts );
 
     if( IsCopperLayer( aLayer ) )
     {
         // Skip NPTH pads on copper layers ( only if hole size == pad size ):
         // Drill mark will be plotted if drill mark is SMALL_DRILL_SHAPE  or FULL_DRILL_SHAPE
         if( plotOpt.GetFormat() == PLOT_FORMAT::DXF )
         {
             plotOpt.SetSkipPlotNPTH_Pads( false );
             PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
         }
         else
         {
             plotOpt.SetSkipPlotNPTH_Pads( true );
             PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
         }
     }
     else
     {
         switch( aLayer )
         {
         case B_Mask:
         case F_Mask:
             plotOpt.SetSkipPlotNPTH_Pads( false );
             // Disable plot pad holes
             plotOpt.SetDrillMarksType( PCB_PLOT_PARAMS::NO_DRILL_SHAPE );
 
             // Plot solder mask:
             if( soldermask_min_thickness == 0 )
             {
                 if( plotOpt.GetFormat() == PLOT_FORMAT::DXF )
                     PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
                 else
                     PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
             }
             else
                 PlotSolderMaskLayer( aBoard, aPlotter, layer_mask, plotOpt,
                                      soldermask_min_thickness );
 
             break;
 
         case B_Adhes:
         case F_Adhes:
         case B_Paste:
         case F_Paste:
             plotOpt.SetSkipPlotNPTH_Pads( false );
             // Disable plot pad holes
             plotOpt.SetDrillMarksType( PCB_PLOT_PARAMS::NO_DRILL_SHAPE );
 
             if( plotOpt.GetFormat() == PLOT_FORMAT::DXF )
                 PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
             else
                 PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
             break;
 
         case F_SilkS:
         case B_SilkS:
             if( plotOpt.GetFormat() == PLOT_FORMAT::DXF && plotOpt.GetDXFPlotPolygonMode() )
                 // PlotLayerOutlines() is designed only for DXF plotters.
                 // and must not be used for other plot formats
                 PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
             else
                 PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
 
             // Gerber: Subtract soldermask from silkscreen if enabled
             if( aPlotter->GetPlotterType() == PLOT_FORMAT::GERBER
                     && plotOpt.GetSubtractMaskFromSilk() )
             {
                 if( aLayer == F_SilkS )
                     layer_mask = LSET( F_Mask );
                 else
                     layer_mask = LSET( B_Mask );
 
                 // Create the mask to subtract by creating a negative layer polarity
                 aPlotter->SetLayerPolarity( false );
 
                 // Disable plot pad holes
                 plotOpt.SetDrillMarksType( PCB_PLOT_PARAMS::NO_DRILL_SHAPE );
 
                 // Plot the mask
                 PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
             }
             break;
 
         // These layers are plotted like silk screen layers.
         // Mainly, pads on these layers are not filled.
         // This is not necessary the best choice.
         case Dwgs_User:
         case Cmts_User:
         case Eco1_User:
         case Eco2_User:
         case Edge_Cuts:
         case Margin:
         case F_CrtYd:
         case B_CrtYd:
         case F_Fab:
         case B_Fab:
             plotOpt.SetSkipPlotNPTH_Pads( false );
             plotOpt.SetDrillMarksType( PCB_PLOT_PARAMS::NO_DRILL_SHAPE );
 
             if( plotOpt.GetFormat() == PLOT_FORMAT::DXF && plotOpt.GetDXFPlotPolygonMode() )
                 // PlotLayerOutlines() is designed only for DXF plotters.
                 // and must not be used for other plot formats
                 PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
             else
                 PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
             break;
 
         default:
             plotOpt.SetSkipPlotNPTH_Pads( false );
             plotOpt.SetDrillMarksType( PCB_PLOT_PARAMS::NO_DRILL_SHAPE );
 
             if( plotOpt.GetFormat() == PLOT_FORMAT::DXF && plotOpt.GetDXFPlotPolygonMode() )
                 // PlotLayerOutlines() is designed only for DXF plotters.
                 // and must not be used for other plot formats
                 PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
             else
                 PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
             break;
         }
     }
 }

References B_Adhes, B_CrtYd, B_Fab, B_Mask, B_Paste, B_SilkS, BLACK, Cmts_User, Dwgs_User, DXF, Eco1_User, Eco2_User, Edge_Cuts, F_Adhes, F_CrtYd, F_Fab, F_Mask, F_Paste, F_SilkS, GERBER, BOARD::GetDesignSettings(), PCB_PLOT_PARAMS::GetDXFPlotPolygonMode(), PCB_PLOT_PARAMS::GetExcludeEdgeLayer(), PCB_PLOT_PARAMS::GetFormat(), PLOTTER::GetPlotterType(), PCB_PLOT_PARAMS::GetSubtractMaskFromSilk(), PCB_PLOT_PARAMS::GetTextMode(), IsCopperLayer(), BOARD_DESIGN_SETTINGS::m_SolderMaskMinWidth, Margin, PCB_PLOT_PARAMS::NO_DRILL_SHAPE, PlotLayerOutlines(), PlotSolderMaskLayer(), PlotStandardLayer(), PLOTTER::SetColor(), PCB_PLOT_PARAMS::SetDrillMarksType(), PLOTTER::SetLayerPolarity(), PCB_PLOT_PARAMS::SetSkipPlotNPTH_Pads(), and PLOTTER::SetTextMode().

Referenced by DIALOG_EXPORT_SVG::CreateSVGFile(), DIALOG_PLOT::Plot(), and PLOT_CONTROLLER::PlotLayer().

◆ PlotSolderMaskLayer()

void PlotSolderMaskLayer	(	BOARD *	aBoard,
		PLOTTER *	aPlotter,
		LSET	aLayerMask,
		const PCB_PLOT_PARAMS &	aPlotOpt,
		int	aMinThickness
	)

static

Definition at line 747 of file plot_board_layers.cpp.

 {
     int             maxError = aBoard->GetDesignSettings().m_MaxError;
     PCB_LAYER_ID    layer = aLayerMask[B_Mask] ? B_Mask : F_Mask;
     SHAPE_POLY_SET  buffer;
     SHAPE_POLY_SET* boardOutline = nullptr;
 
     if( aBoard->GetBoardPolygonOutlines( buffer ) )
         boardOutline = &buffer;
 
     // We remove 1nm as we expand both sides of the shapes, so allowing for
     // a strictly greater than or equal comparison in the shape separation (boolean add)
     // means that we will end up with separate shapes that then are shrunk
     int inflate = aMinThickness/2 - 1;
 
     BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
     itemplotter.SetLayerSet( aLayerMask );
 
     // Plot edge layer and graphic items.
     // They do not have a solder Mask margin, because they are graphic items
     // on this layer (like logos), not actually areas around pads.
 
     itemplotter.PlotBoardGraphicItems();
 
     for( FOOTPRINT* footprint : aBoard->Footprints() )
     {
         for( BOARD_ITEM* item : footprint->GraphicalItems() )
         {
             itemplotter.PlotFootprintTextItems( footprint );
 
             if( item->Type() == PCB_FP_SHAPE_T && item->GetLayer() == layer )
                 itemplotter.PlotFootprintGraphicItem( (FP_SHAPE*) item );
         }
     }
 
     // Build polygons for each pad shape.  The size of the shape on solder mask should be size
     // of pad + clearance around the pad, where clearance = solder mask clearance + extra margin.
     // Extra margin is half the min width for solder mask, which is used to merge too-close shapes
     // (distance < aMinThickness), and will be removed when creating the actual shapes.
 
     // Will contain shapes inflated by inflate value that will be merged and deflated by
     // inflate value to build final polygons
     // After calculations the remaining polygons are polygons to plot
     SHAPE_POLY_SET areas;
     // Will contain exact shapes of all items on solder mask
     SHAPE_POLY_SET initialPolys;
 
 #if NEW_ALGO
     // Generate polygons with arcs inside the shape or exact shape
     // to minimize shape changes created by arc to segment size correction.
     DISABLE_ARC_RADIUS_CORRECTION disabler;
 #endif
     {
         // Plot pads
         for( FOOTPRINT* footprint : aBoard->Footprints() )
         {
             // add shapes with their exact mask layer size in initialPolys
             footprint->TransformPadsWithClearanceToPolygon( initialPolys, layer, 0, maxError,
                                                             ERROR_OUTSIDE );
             // add shapes inflated by aMinThickness/2 in areas
             footprint->TransformPadsWithClearanceToPolygon( areas, layer, inflate, maxError,
                                                             ERROR_OUTSIDE );
         }
 
         // Plot vias on solder masks, if aPlotOpt.GetPlotViaOnMaskLayer() is true,
         if( aPlotOpt.GetPlotViaOnMaskLayer() )
         {
             // The current layer is a solder mask, use the global mask clearance for vias
             int via_clearance = aBoard->GetDesignSettings().m_SolderMaskMargin;
             int via_margin = via_clearance + inflate;
 
             for( TRACK* track : aBoard->Tracks() )
             {
                 const VIA* via = dyn_cast<const VIA*>( track );
 
                 if( !via )
                     continue;
 
                 // vias are plotted only if they are on the corresponding external copper layer
                 LSET via_set = via->GetLayerSet();
 
                 if( via_set[B_Cu] )
                     via_set.set( B_Mask );
 
                 if( via_set[F_Cu] )
                     via_set.set( F_Mask );
 
                 if( !( via_set & aLayerMask ).any() )
                     continue;
 
                 // add shapes with their exact mask layer size in initialPolys
                 via->TransformShapeWithClearanceToPolygon( initialPolys, layer, via_clearance,
                                                            maxError, ERROR_OUTSIDE );
                 // add shapes inflated by aMinThickness/2 in areas
                 via->TransformShapeWithClearanceToPolygon( areas, layer, via_margin, maxError,
                                                            ERROR_OUTSIDE );
             }
         }
 
         // Add filled zone areas.
 #if 0   // Set to 1 if a solder mask margin must be applied to zones on solder mask
         int zone_margin = aBoard->GetDesignSettings().m_SolderMaskMargin;
 #else
         int zone_margin = 0;
 #endif
 
         for( ZONE* zone : aBoard->Zones() )
         {
             if( zone->GetLayer() != layer )
                 continue;
 
             // add shapes inflated by aMinThickness/2 in areas
             zone->TransformSmoothedOutlineToPolygon( areas, inflate + zone_margin, boardOutline );
             // add shapes with their exact mask layer size in initialPolys
             zone->TransformSmoothedOutlineToPolygon( initialPolys, zone_margin, boardOutline );
         }
 
         int numSegs = GetArcToSegmentCount( inflate, maxError, 360.0 );
 
         // Merge all polygons: After deflating, not merged (not overlapping) polygons
         // will have the initial shape (with perhaps small changes due to deflating transform)
         areas.Simplify( SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
         areas.Deflate( inflate, numSegs );
     }
 
 #if !NEW_ALGO
     // To avoid a lot of code, use a ZONE to handle and plot polygons, because our polygons look
     // exactly like filled areas in zones.
     // Note, also this code is not optimized: it creates a lot of copy/duplicate data.
     // However it is not complex, and fast enough for plot purposes (copy/convert data is only a
     // very small calculation time for these calculations).
     ZONE zone( aBoard );
     zone.SetMinThickness( 0 );      // trace polygons only
     zone.SetLayer( layer );
     // Combine the current areas to initial areas. This is mandatory because inflate/deflate
     // transform is not perfect, and we want the initial areas perfectly kept
     areas.BooleanAdd( initialPolys, SHAPE_POLY_SET::PM_FAST );
     areas.Fracture( SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
 
     itemplotter.PlotFilledAreas( &zone, areas );
 #else
 
     // Remove initial shapes: each shape will be added later, as flashed item or region
     // with a suitable attribute.
     // Do not merge pads is mandatory in Gerber files: They must be identified as pads
 
     // we deflate areas in polygons, to avoid after subtracting initial shapes
     // having small artifacts due to approximations during polygon transforms
     areas.BooleanSubtract( initialPolys, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
 
     // Slightly inflate polygons to avoid any gap between them and other shapes,
     // These gaps are created by arc to segments approximations
     areas.Inflate( Millimeter2iu( 0.002 ),6 );
 
     // Now, only polygons with a too small thickness are stored in areas.
     areas.Fracture( SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
 
     // Plot each initial shape (pads and polygons on mask layer), with suitable attributes:
     PlotStandardLayer( aBoard, aPlotter, aLayerMask, aPlotOpt );
 
     // Add shapes corresponding to areas having too small thickness.
     std::vector<wxPoint> cornerList;
 
     for( int ii = 0; ii < areas.OutlineCount(); ii++ )
     {
         cornerList.clear();
         const SHAPE_LINE_CHAIN& path = areas.COutline( ii );
 
         // polygon area in mm^2 :
         double curr_area = path.Area() / ( IU_PER_MM * IU_PER_MM );
 
         // Skip very small polygons: they are certainly artifacts created by
         // arc approximations and polygon transforms
         // (inflate/deflate transforms)
         constexpr double poly_min_area_mm2 = 0.01;     // 0.01 mm^2 gives a good filtering
 
         if( curr_area < poly_min_area_mm2 )
             continue;
 
         for( int jj = 0; jj < path.PointCount(); jj++ )
             cornerList.emplace_back( (wxPoint) path.CPoint( jj ) );
 
         // Ensure the polygon is closed
         if( cornerList[0] != cornerList[cornerList.size() - 1] )
             cornerList.push_back( cornerList[0] );
 
         aPlotter->PlotPoly( cornerList, FILL_TYPE::FILLED_SHAPE );
     }
 #endif
 }

References SHAPE_LINE_CHAIN::Area(), B_Cu, B_Mask, SHAPE_POLY_SET::BooleanAdd(), SHAPE_POLY_SET::BooleanSubtract(), SHAPE_POLY_SET::COutline(), SHAPE_LINE_CHAIN::CPoint(), SHAPE_POLY_SET::Deflate(), ERROR_OUTSIDE, F_Cu, F_Mask, FILLED_SHAPE, BOARD::Footprints(), SHAPE_POLY_SET::Fracture(), GetArcToSegmentCount(), BOARD::GetBoardPolygonOutlines(), BOARD::GetDesignSettings(), VIA::GetLayerSet(), PCB_PLOT_PARAMS::GetPlotViaOnMaskLayer(), SHAPE_POLY_SET::Inflate(), IU_PER_MM, BOARD_DESIGN_SETTINGS::m_MaxError, BOARD_DESIGN_SETTINGS::m_SolderMaskMargin, Millimeter2iu(), SHAPE_POLY_SET::OutlineCount(), PCB_FP_SHAPE_T, BRDITEMS_PLOTTER::PlotBoardGraphicItems(), BRDITEMS_PLOTTER::PlotFilledAreas(), BRDITEMS_PLOTTER::PlotFootprintGraphicItem(), BRDITEMS_PLOTTER::PlotFootprintTextItems(), PLOTTER::PlotPoly(), PlotStandardLayer(), SHAPE_POLY_SET::PM_FAST, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE, SHAPE_LINE_CHAIN::PointCount(), ZONE::SetLayer(), BRDITEMS_PLOTTER::SetLayerSet(), ZONE::SetMinThickness(), SHAPE_POLY_SET::Simplify(), BOARD::Tracks(), TRACK::TransformShapeWithClearanceToPolygon(), and BOARD::Zones().

Referenced by PlotOneBoardLayer().

◆ PlotStandardLayer()

void PlotStandardLayer	(	BOARD *	aBoard,
		PLOTTER *	aPlotter,
		LSET	aLayerMask,
		const PCB_PLOT_PARAMS &	aPlotOpt
	)

Function PlotStandardLayer plot copper or technical layers.

not used for silk screen layers, because these layers have specific requirements, mainly for pads

Parameters

aBoard	= the board to plot
aPlotter	= the plotter to use
aLayerMask	= the mask to define the layers to plot
aPlotOpt	= the plot options (files, sketch). Has meaning for some formats only

aPlotOpt has 3 important options to control this plot, which are set, depending on the layer type to plot SetEnablePlotVia( bool aEnable ) aEnable = true to plot vias, false to skip vias (has meaning only for solder mask layers). SetSkipPlotNPTH_Pads( bool aSkip ) aSkip = true to skip NPTH Pads, when the pad size and the pad hole have the same size. Used in GERBER format only. SetDrillMarksType( DrillMarksType aVal ) controle the actual hole: no hole, small hole, actual hole

pads not connected to copper are optionally not drawn

Vias not connected to copper are optionally not drawn

Definition at line 206 of file plot_board_layers.cpp.

 {
     BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
 
     itemplotter.SetLayerSet( aLayerMask );
 
     OUTLINE_MODE plotMode = aPlotOpt.GetPlotMode();
     bool onCopperLayer = ( LSET::AllCuMask() & aLayerMask ).any();
     bool onSolderMaskLayer = ( LSET( 2, F_Mask, B_Mask ) & aLayerMask ).any();
     bool onSolderPasteLayer = ( LSET( 2, F_Paste, B_Paste ) & aLayerMask ).any();
     bool onFrontFab = ( LSET(  F_Fab ) & aLayerMask ).any();
     bool onBackFab  = ( LSET( B_Fab ) & aLayerMask ).any();
     bool sketchPads = ( onFrontFab || onBackFab ) && aPlotOpt.GetSketchPadsOnFabLayers();
 
      // Plot edge layer and graphic items
     itemplotter.PlotBoardGraphicItems();
 
     // Draw footprint texts:
     for( FOOTPRINT* footprint : aBoard->Footprints() )
         itemplotter.PlotFootprintTextItems( footprint );
 
     // Draw footprint other graphic items:
     for( FOOTPRINT* footprint : aBoard->Footprints() )
         itemplotter.PlotFootprintGraphicItems( footprint );
 
     // Plot footprint pads
     for( FOOTPRINT* footprint : aBoard->Footprints() )
     {
         aPlotter->StartBlock( NULL );
 
         for( PAD* pad : footprint->Pads() )
         {
             OUTLINE_MODE padPlotMode = plotMode;
 
             if( !( pad->GetLayerSet() & aLayerMask ).any() )
             {
                 if( sketchPads &&
                         ( ( onFrontFab && pad->GetLayerSet().Contains( F_Cu ) ) ||
                           ( onBackFab && pad->GetLayerSet().Contains( B_Cu ) ) ) )
                     padPlotMode = SKETCH;
                 else
                     continue;
             }
 
             if( onCopperLayer && !pad->FlashLayer( aLayerMask ) )
                 continue;
 
             COLOR4D color = COLOR4D::BLACK;
 
             if( pad->GetLayerSet()[B_Cu] )
                color = aPlotOpt.ColorSettings()->GetColor( LAYER_PAD_BK );
 
             if( pad->GetLayerSet()[F_Cu] )
                 color = color.LegacyMix( aPlotOpt.ColorSettings()->GetColor( LAYER_PAD_FR ) );
 
             if( sketchPads && aLayerMask[F_Fab] )
                 color = aPlotOpt.ColorSettings()->GetColor( F_Fab );
             else if( sketchPads && aLayerMask[B_Fab] )
                 color = aPlotOpt.ColorSettings()->GetColor( B_Fab );
 
             wxSize margin;
             int width_adj = 0;
 
             if( onCopperLayer )
                 width_adj =  itemplotter.getFineWidthAdj();
 
             if( onSolderMaskLayer )
                 margin.x = margin.y = pad->GetSolderMaskMargin();
 
             if( onSolderPasteLayer )
                 margin = pad->GetSolderPasteMargin();
 
             // not all shapes can have a different margin for x and y axis
             // in fact only oval and rect shapes can have different values.
             // Round shape have always the same x,y margin
             // so define a unique value for other shapes that do not support different values
             int mask_clearance = margin.x;
 
             // Now offset the pad size by margin + width_adj
             wxSize padPlotsSize = pad->GetSize() + margin * 2 + wxSize( width_adj, width_adj );
 
             // Store these parameters that can be modified to plot inflated/deflated pads shape
             PAD_SHAPE_T padShape = pad->GetShape();
             wxSize      padSize = pad->GetSize();
             wxSize      padDelta = pad->GetDelta(); // has meaning only for trapezoidal pads
             double      padCornerRadius = pad->GetRoundRectCornerRadius();
 
             // Don't draw a null size item :
             if( padPlotsSize.x <= 0 || padPlotsSize.y <= 0 )
                 continue;
 
             switch( pad->GetShape() )
             {
             case PAD_SHAPE_CIRCLE:
             case PAD_SHAPE_OVAL:
                 pad->SetSize( padPlotsSize );
 
                 if( aPlotOpt.GetSkipPlotNPTH_Pads() &&
                     ( aPlotOpt.GetDrillMarksType() == PCB_PLOT_PARAMS::NO_DRILL_SHAPE ) &&
                     ( pad->GetSize() == pad->GetDrillSize() ) &&
                     ( pad->GetAttribute() == PAD_ATTRIB_NPTH ) )
                     break;
 
                 itemplotter.PlotPad( pad, color, padPlotMode );
                 break;
 
             case PAD_SHAPE_RECT:
                 pad->SetSize( padPlotsSize );
 
                 if( mask_clearance > 0 )
                 {
                     pad->SetShape( PAD_SHAPE_ROUNDRECT );
                     pad->SetRoundRectCornerRadius( mask_clearance );
                 }
 
                 itemplotter.PlotPad( pad, color, padPlotMode );
                 break;
 
             case PAD_SHAPE_TRAPEZOID:
                 // inflate/deflate a trapezoid is a bit complex.
                 // so if the margin is not null, build a similar polygonal pad shape,
                 // and inflate/deflate the polygonal shape
                 // because inflating/deflating using different values for y and y
                 // we are using only margin.x as inflate/deflate value
                 if( mask_clearance == 0 )
                     itemplotter.PlotPad( pad, color, padPlotMode );
                 else
                 {
                     PAD dummy( *pad );
                     dummy.SetAnchorPadShape( PAD_SHAPE_CIRCLE );
                     dummy.SetShape( PAD_SHAPE_CUSTOM );
                     SHAPE_POLY_SET outline;
                     outline.NewOutline();
                     int dx = padSize.x / 2;
                     int dy = padSize.y / 2;
                     int ddx = padDelta.x / 2;
                     int  ddy = padDelta.y / 2;
 
                     outline.Append( -dx - ddy,  dy + ddx );
                     outline.Append(  dx + ddy,  dy - ddx );
                     outline.Append(  dx - ddy, -dy + ddx );
                     outline.Append( -dx + ddy, -dy - ddx );
 
                     // Shape polygon can have holes so use InflateWithLinkedHoles(), not Inflate()
                     // which can create bad shapes if margin.x is < 0
                     int maxError = aBoard->GetDesignSettings().m_MaxError;
                     int numSegs = GetArcToSegmentCount( mask_clearance, maxError, 360.0 );
                     outline.InflateWithLinkedHoles( mask_clearance, numSegs, SHAPE_POLY_SET::PM_FAST );
                     dummy.DeletePrimitivesList();
                     dummy.AddPrimitivePoly( outline, 0, true );
 
                     // Be sure the anchor pad is not bigger than the deflated shape because this
                     // anchor will be added to the pad shape when plotting the pad. So now the
                     // polygonal shape is built, we can clamp the anchor size
                     dummy.SetSize( wxSize( 0,0 ) );
 
                     itemplotter.PlotPad( &dummy, color, padPlotMode );
                 }
 
                 break;
 
             case PAD_SHAPE_ROUNDRECT:
             case PAD_SHAPE_CHAMFERED_RECT:
                 // Chamfer and rounding are stored as a percent and so don't need scaling
                 pad->SetSize( padPlotsSize );
                 itemplotter.PlotPad( pad, color, padPlotMode );
                 break;
 
             case PAD_SHAPE_CUSTOM:
             {
                 // inflate/deflate a custom shape is a bit complex.
                 // so build a similar pad shape, and inflate/deflate the polygonal shape
                 PAD dummy( *pad );
                 SHAPE_POLY_SET shape;
                 pad->MergePrimitivesAsPolygon( &shape, UNDEFINED_LAYER );
                 // Shape polygon can have holes so use InflateWithLinkedHoles(), not Inflate()
                 // which can create bad shapes if margin.x is < 0
                 int maxError = aBoard->GetDesignSettings().m_MaxError;
                 int numSegs = GetArcToSegmentCount( mask_clearance, maxError, 360.0 );
                 shape.InflateWithLinkedHoles( mask_clearance, numSegs, SHAPE_POLY_SET::PM_FAST );
                 dummy.DeletePrimitivesList();
                 dummy.AddPrimitivePoly( shape, 0, true );
 
                 // Be sure the anchor pad is not bigger than the deflated shape because this
                 // anchor will be added to the pad shape when plotting the pad. So now the
                 // polygonal shape is built, we can clamp the anchor size
                 if( mask_clearance < 0 )  // we expect margin.x = margin.y for custom pads
                     dummy.SetSize( padPlotsSize );
 
                 itemplotter.PlotPad( &dummy, color, padPlotMode );
             }
                 break;
             }
 
             // Restore the pad parameters modified by the plot code
             pad->SetSize( padSize );
             pad->SetDelta( padDelta );
             pad->SetShape( padShape );
             pad->SetRoundRectCornerRadius( padCornerRadius );
         }
 
         aPlotter->EndBlock( NULL );
     }
 
     // Plot vias on copper layers, and if aPlotOpt.GetPlotViaOnMaskLayer() is true,
     // plot them on solder mask
 
     GBR_METADATA gbr_metadata;
 
     bool isOnCopperLayer = ( aLayerMask & LSET::AllCuMask() ).any();
 
     if( isOnCopperLayer )
     {
         gbr_metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_VIAPAD );
         gbr_metadata.SetNetAttribType( GBR_NETLIST_METADATA::GBR_NETINFO_NET );
     }
 
     aPlotter->StartBlock( NULL );
 
     for( TRACK* track : aBoard->Tracks() )
     {
         const VIA* via = dyn_cast<const VIA*>( track );
 
         if( !via )
             continue;
 
         // vias are not plotted if not on selected layer, but if layer is SOLDERMASK_LAYER_BACK
         // or SOLDERMASK_LAYER_FRONT, vias are drawn only if they are on the corresponding
         // external copper layer
         LSET via_mask_layer = via->GetLayerSet();
 
         if( aPlotOpt.GetPlotViaOnMaskLayer() )
         {
             if( via_mask_layer[B_Cu] )
                 via_mask_layer.set( B_Mask );
 
             if( via_mask_layer[F_Cu] )
                 via_mask_layer.set( F_Mask );
         }
 
         if( !( via_mask_layer & aLayerMask ).any() )
             continue;
 
         int via_margin = 0;
         double width_adj = 0;
 
         // If the current layer is a solder mask, use the global mask clearance for vias
         if( aLayerMask[B_Mask] || aLayerMask[F_Mask] )
             via_margin = aBoard->GetDesignSettings().m_SolderMaskMargin;
 
         if( ( aLayerMask & LSET::AllCuMask() ).any() )
             width_adj = itemplotter.getFineWidthAdj();
 
         int diameter = via->GetWidth() + 2 * via_margin + width_adj;
 
         if( onCopperLayer && !via->FlashLayer( aLayerMask ) )
             continue;
 
         // Don't draw a null size item :
         if( diameter <= 0 )
             continue;
 
         // Some vias can be not connected (no net).
         // Set the m_NotInNet for these vias to force a empty net name in gerber file
         gbr_metadata.m_NetlistMetadata.m_NotInNet = via->GetNetname().IsEmpty();
 
         gbr_metadata.SetNetName( via->GetNetname() );
 
         COLOR4D color = aPlotOpt.ColorSettings()->GetColor(
                 LAYER_VIAS + static_cast<int>( via->GetViaType() ) );
         // Set plot color (change WHITE to LIGHTGRAY because the white items are not seen on a
         // white paper or screen
         aPlotter->SetColor( color != WHITE ? color : LIGHTGRAY );
         aPlotter->FlashPadCircle( via->GetStart(), diameter, plotMode, &gbr_metadata );
     }
 
     aPlotter->EndBlock( NULL );
     aPlotter->StartBlock( NULL );
     gbr_metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CONDUCTOR );
 
     // Plot tracks (not vias) :
     for( TRACK* track : aBoard->Tracks() )
     {
         if( track->Type() == PCB_VIA_T )
             continue;
 
         if( !aLayerMask[track->GetLayer()] )
             continue;
 
         // Some track segments can be not connected (no net).
         // Set the m_NotInNet for these segments to force a empty net name in gerber file
         gbr_metadata.m_NetlistMetadata.m_NotInNet = track->GetNetname().IsEmpty();
 
         gbr_metadata.SetNetName( track->GetNetname() );
         int width = track->GetWidth() + itemplotter.getFineWidthAdj();
         aPlotter->SetColor( itemplotter.getColor( track->GetLayer() ) );
 
         if( track->Type() == PCB_ARC_T )
         {
             ARC* arc = static_cast<ARC*>( track );
             VECTOR2D center( arc->GetCenter() );
             int radius = arc->GetRadius();
             double start_angle = arc->GetArcAngleStart();
             double end_angle = start_angle + arc->GetAngle();
 
             aPlotter->ThickArc( wxPoint( center.x, center.y ), -end_angle, -start_angle,
                                 radius, width, plotMode, &gbr_metadata );
         }
         else
         {
             aPlotter->ThickSegment( track->GetStart(), track->GetEnd(), width, plotMode,
                                     &gbr_metadata );
         }
 
     }
 
     aPlotter->EndBlock( NULL );
 
     // Plot filled ares
     aPlotter->StartBlock( NULL );
 
     NETINFO_ITEM nonet( aBoard );
 
     for( ZONE* zone : aBoard->Zones() )
     {
         for( PCB_LAYER_ID layer : zone->GetLayerSet().Seq() )
         {
             if( !aLayerMask[layer] )
                 continue;
 
             SHAPE_POLY_SET mainArea = zone->GetFilledPolysList( layer );
             SHAPE_POLY_SET islands;
 
             for( int i = mainArea.OutlineCount() - 1; i >= 0; i-- )
             {
                 if( zone->IsIsland( layer, i ) )
                 {
                     islands.AddOutline( mainArea.CPolygon( i )[0] );
                     mainArea.DeletePolygon( i );
                 }
             }
 
             itemplotter.PlotFilledAreas( zone, mainArea );
 
             if( !islands.IsEmpty() )
             {
                 ZONE dummy( *zone );
                 dummy.SetNet( &nonet );
                 itemplotter.PlotFilledAreas( &dummy, islands );
             }
         }
     }
 
     aPlotter->EndBlock( NULL );
 
     // Adding drill marks, if required and if the plotter is able to plot them:
     if( aPlotOpt.GetDrillMarksType() != PCB_PLOT_PARAMS::NO_DRILL_SHAPE )
         itemplotter.PlotDrillMarks();
 }

References SHAPE_POLY_SET::AddOutline(), LSET::AllCuMask(), SHAPE_POLY_SET::Append(), B_Cu, B_Fab, B_Mask, B_Paste, BLACK, color, PCB_PLOT_PARAMS::ColorSettings(), SHAPE_POLY_SET::CPolygon(), SHAPE_POLY_SET::DeletePolygon(), dummy(), PLOTTER::EndBlock(), F_Cu, F_Fab, F_Mask, F_Paste, VIA::FlashLayer(), PLOTTER::FlashPadCircle(), BOARD::Footprints(), GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CONDUCTOR, GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_VIAPAD, GBR_NETLIST_METADATA::GBR_NETINFO_NET, ARC::GetAngle(), ARC::GetArcAngleStart(), GetArcToSegmentCount(), ARC::GetCenter(), COLOR_SETTINGS::GetColor(), BRDITEMS_PLOTTER::getColor(), BOARD::GetDesignSettings(), PCB_PLOT_PARAMS::GetDrillMarksType(), BRDITEMS_PLOTTER::getFineWidthAdj(), VIA::GetLayerSet(), BOARD_CONNECTED_ITEM::GetNetname(), PCB_PLOT_PARAMS::GetPlotMode(), PCB_PLOT_PARAMS::GetPlotViaOnMaskLayer(), ARC::GetRadius(), PCB_PLOT_PARAMS::GetSketchPadsOnFabLayers(), PCB_PLOT_PARAMS::GetSkipPlotNPTH_Pads(), TRACK::GetStart(), VIA::GetViaType(), TRACK::GetWidth(), SHAPE_POLY_SET::InflateWithLinkedHoles(), SHAPE_POLY_SET::IsEmpty(), LAYER_PAD_BK, LAYER_PAD_FR, LAYER_VIAS, LIGHTGRAY, BOARD_DESIGN_SETTINGS::m_MaxError, GBR_METADATA::m_NetlistMetadata, GBR_NETLIST_METADATA::m_NotInNet, BOARD_DESIGN_SETTINGS::m_SolderMaskMargin, SHAPE_POLY_SET::NewOutline(), PCB_PLOT_PARAMS::NO_DRILL_SHAPE, NULL, SHAPE_POLY_SET::OutlineCount(), PAD_ATTRIB_NPTH, PAD_SHAPE_CHAMFERED_RECT, PAD_SHAPE_CIRCLE, PAD_SHAPE_CUSTOM, PAD_SHAPE_OVAL, PAD_SHAPE_RECT, PAD_SHAPE_ROUNDRECT, PAD_SHAPE_TRAPEZOID, PCB_ARC_T, PCB_VIA_T, BRDITEMS_PLOTTER::PlotBoardGraphicItems(), BRDITEMS_PLOTTER::PlotDrillMarks(), BRDITEMS_PLOTTER::PlotFilledAreas(), BRDITEMS_PLOTTER::PlotFootprintGraphicItems(), BRDITEMS_PLOTTER::PlotFootprintTextItems(), BRDITEMS_PLOTTER::PlotPad(), SHAPE_POLY_SET::PM_FAST, GBR_METADATA::SetApertureAttrib(), PLOTTER::SetColor(), BRDITEMS_PLOTTER::SetLayerSet(), GBR_METADATA::SetNetAttribType(), GBR_METADATA::SetNetName(), SKETCH, PLOTTER::StartBlock(), PLOTTER::ThickArc(), PLOTTER::ThickSegment(), BOARD::Tracks(), UNDEFINED_LAYER, WHITE, and BOARD::Zones().

Referenced by PlotOneBoardLayer(), and PlotSolderMaskLayer().

◆ StartPlotBoard()

PLOTTER* StartPlotBoard	(	BOARD *	aBoard,
		PCB_PLOT_PARAMS *	aPlotOpts,
		int	aLayer,
		const wxString &	aFullFileName,
		const wxString &	aSheetDesc
	)

Open a new plotfile using the options (and especially the format) specified in the options and prepare the page for plotting.

Return the plotter object if OK, NULL if the file is not created (or has a problem)

Definition at line 1063 of file plot_board_layers.cpp.

 {
     // Create the plotter driver and set the few plotter specific options
     PLOTTER*    plotter = NULL;
 
     switch( aPlotOpts->GetFormat() )
     {
     case PLOT_FORMAT::DXF:
         DXF_PLOTTER* DXF_plotter;
         DXF_plotter = new DXF_PLOTTER();
         DXF_plotter->SetUnits( aPlotOpts->GetDXFPlotUnits() );
 
         plotter = DXF_plotter;
         break;
 
     case PLOT_FORMAT::POST:
         PS_PLOTTER* PS_plotter;
         PS_plotter = new PS_PLOTTER();
         PS_plotter->SetScaleAdjust( aPlotOpts->GetFineScaleAdjustX(),
                                     aPlotOpts->GetFineScaleAdjustY() );
         plotter = PS_plotter;
         break;
 
     case PLOT_FORMAT::PDF:
         plotter = new PDF_PLOTTER();
         break;
 
     case PLOT_FORMAT::HPGL:
         HPGL_PLOTTER* HPGL_plotter;
         HPGL_plotter = new HPGL_PLOTTER();
 
         // HPGL options are a little more convoluted to compute, so they get their own function
         ConfigureHPGLPenSizes( HPGL_plotter, aPlotOpts );
         plotter = HPGL_plotter;
         break;
 
     case PLOT_FORMAT::GERBER:
         plotter = new GERBER_PLOTTER();
         break;
 
     case PLOT_FORMAT::SVG:
         plotter = new SVG_PLOTTER();
         break;
 
     default:
         wxASSERT( false );
         return NULL;
     }
 
     KIGFX::PCB_RENDER_SETTINGS* renderSettings = new KIGFX::PCB_RENDER_SETTINGS();
     renderSettings->LoadColors( aPlotOpts->ColorSettings() );
     renderSettings->SetDefaultPenWidth( Millimeter2iu( 0.0212 ) );  // Hairline at 1200dpi
     plotter->SetRenderSettings( renderSettings );
 
     // Compute the viewport and set the other options
 
     // page layout is not mirrored, so temporarily change mirror option for the page layout
     PCB_PLOT_PARAMS plotOpts = *aPlotOpts;
 
     if( plotOpts.GetPlotFrameRef() && plotOpts.GetMirror() )
         plotOpts.SetMirror( false );
 
     initializePlotter( plotter, aBoard, &plotOpts );
 
     if( plotter->OpenFile( aFullFileName ) )
     {
         plotter->ClearHeaderLinesList();
 
         // For the Gerber "file function" attribute, set the layer number
         if( plotter->GetPlotterType() == PLOT_FORMAT::GERBER )
         {
             bool useX2mode = plotOpts.GetUseGerberX2format();
 
             GERBER_PLOTTER* gbrplotter = static_cast <GERBER_PLOTTER*> ( plotter );
             gbrplotter->DisableApertMacros( plotOpts.GetDisableGerberMacros() );
             gbrplotter->UseX2format( useX2mode );
             gbrplotter->UseX2NetAttributes( plotOpts.GetIncludeGerberNetlistInfo() );
 
             // Attributes can be added using X2 format or as comment (X1 format)
             AddGerberX2Attribute( plotter, aBoard, aLayer, not useX2mode );
         }
 
         plotter->StartPlot();
 
         // Plot the frame reference if requested
         if( aPlotOpts->GetPlotFrameRef() )
         {
             PlotDrawingSheet( plotter, aBoard->GetProject(), aBoard->GetTitleBlock(),
                               aBoard->GetPageSettings(), "1", 1, aSheetDesc,
                               aBoard->GetFileName() );
 
             if( aPlotOpts->GetMirror() )
                 initializePlotter( plotter, aBoard, aPlotOpts );
         }
 
         // When plotting a negative board: draw a black rectangle (background for plot board
         // in white) and switch the current color to WHITE; note the color inversion is actually
         // done in the driver (if supported)
         if( aPlotOpts->GetNegative() )
         {
             EDA_RECT bbox = aBoard->ComputeBoundingBox();
             FillNegativeKnockout( plotter, bbox );
         }
 
         return plotter;
     }
 
     delete plotter->RenderSettings();
     delete plotter;
     return NULL;
 }

Referenced by DIALOG_EXPORT_SVG::CreateSVGFile(), PLOT_CONTROLLER::OpenPlotfile(), and DIALOG_PLOT::Plot().

Variable Documentation

◆ plot_seq

const PCB_LAYER_ID plot_seq[]

static

Definition at line 571 of file plot_board_layers.cpp.

Referenced by PlotLayerOutlines().

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ NEW_ALGO

Function Documentation

◆ ConfigureHPGLPenSizes()

◆ FillNegativeKnockout()

◆ initializePlotter()

◆ PlotLayerOutlines()

◆ PlotOneBoardLayer()

◆ PlotSolderMaskLayer()

◆ PlotStandardLayer()

◆ StartPlotBoard()

Variable Documentation

◆ plot_seq