pcbplot.h File Reference

#include <pad_shapes.h>
#include <pcb_plot_params.h>
#include <settings/color_settings.h>
#include <settings/settings_manager.h>
#include <board_item.h>

Go to the source code of this file.

Classes
class	BRDITEMS_PLOTTER

Macros
#define	PLOT_MIN_SCALE   0.01
#define	PLOT_MAX_SCALE   100.0

Functions
PLOTTER *	StartPlotBoard (BOARD *aBoard, const PCB_PLOT_PARAMS *aPlotOpts, int aLayer, const wxString &aFullFileName, const wxString &aSheetName, const wxString &aSheetPath)
	Open a new plotfile using the options (and especially the format) specified in the options and prepare the page for plotting. More...
void	PlotBoardLayers (BOARD *aBoard, PLOTTER *aPlotter, const LSEQ &aLayerSequence, const PCB_PLOT_PARAMS &aPlotOptions)
	Plot a sequence of board layer IDs. More...
void	PlotInteractiveLayer (BOARD *aBoard, PLOTTER *aPlotter)
	Plot interactive items (hypertext links, properties, etc.). More...
void	PlotOneBoardLayer (BOARD *aBoard, PLOTTER *aPlotter, PCB_LAYER_ID aLayer, const PCB_PLOT_PARAMS &aPlotOpt)
	Plot one copper or technical layer. More...
void	PlotStandardLayer (BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt)
	Plot copper or technical layers. More...
void	PlotLayerOutlines (BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt)
	Plot copper outline of a copper layer. More...
void	BuildPlotFileName (wxFileName *aFilename, const wxString &aOutputDir, const wxString &aSuffix, const wxString &aExtension)
	Complete a plot filename. More...
const wxString	GetGerberProtelExtension (int aLayer)
const wxString	GetGerberFileFunctionAttribute (const BOARD *aBoard, int aLayer)
	Return the "file function" attribute for aLayer, as defined in the Gerber file format specification J1 (chapter 5). More...
void	AddGerberX2Header (PLOTTER *aPlotter, const BOARD *aBoard, bool aUseX1CompatibilityMode=false)
	Calculate some X2 attributes as defined in the Gerber file format specification J4 (chapter 5) and add them the to the gerber file header. More...
void	AddGerberX2Attribute (PLOTTER *aPlotter, const BOARD *aBoard, int aLayer, bool aUseX1CompatibilityMode)
	Calculate some X2 attributes as defined in the Gerber file format specification and add them to the gerber file header. More...

Macro Definition Documentation

PLOT_MAX_SCALE

#define PLOT_MAX_SCALE   100.0

Definition at line 51 of file pcbplot.h.

PLOT_MIN_SCALE

#define PLOT_MIN_SCALE   0.01

Definition at line 50 of file pcbplot.h.

Function Documentation

AddGerberX2Attribute()

void AddGerberX2Attribute	(	PLOTTER *	aPlotter,
		const BOARD *	aBoard,
		int	aLayer,
		bool	aUseX1CompatibilityMode
	)

Calculate some X2 attributes as defined in the Gerber file format specification and add them to the gerber file header.

TF.GenerationSoftware TF.CreationDate TF.ProjectId TF.FileFunction TF.FilePolarity

Parameters

aPlotter	is the current plotter.
aBoard	is the board, needed to extract some info.
aLayer	is the layer number to create the attribute for.
aUseX1CompatibilityMode	set to false to generate X2 attributes, true to use X1 compatibility (X2 attributes added as structured comments, starting by "G04 #@! " followed by the X2 attribute.

Definition at line 342 of file pcbplot.cpp.

{
 AddGerberX2Header( aPlotter, aBoard, aUseX1CompatibilityMode );
 
 wxString text;
 
 // Add the TF.FileFunction
 text = GetGerberFileFunctionAttribute( aBoard, aLayer );
 aPlotter->AddLineToHeader( makeStringCompatX1( text, aUseX1CompatibilityMode ) );
 
 // Add the TF.FilePolarity (for layers which support that)
 text = GetGerberFilePolarityAttribute( aLayer );
 
 if( !text.IsEmpty() )
 aPlotter->AddLineToHeader( makeStringCompatX1( text, aUseX1CompatibilityMode ) );
}

References AddGerberX2Header(), PLOTTER::AddLineToHeader(), GetGerberFileFunctionAttribute(), GetGerberFilePolarityAttribute(), makeStringCompatX1(), and text.

Referenced by StartPlotBoard().

AddGerberX2Header()

void AddGerberX2Header	(	PLOTTER *	aPlotter,
		const BOARD *	aBoard,
		bool	aUseX1CompatibilityMode = false
	)

Calculate some X2 attributes as defined in the Gerber file format specification J4 (chapter 5) and add them the to the gerber file header.

TF.GenerationSoftware TF.CreationDate TF.ProjectId file format attribute is not added

Parameters

aPlotter	is the current plotter.
aBoard	is the board, needed to extract some info.
aUseX1CompatibilityMode	set to false to generate X2 attributes, true to use X1 compatibility (X2 attributes added as structured comments, starting by "G04 #@! " followed by the X2 attribute

Definition at line 276 of file pcbplot.cpp.

{
 wxString text;
 
 // Creates the TF,.GenerationSoftware. Format is:
 // %TF,.GenerationSoftware,<vendor>,<application name>[,<application version>]*%
 text.Printf( wxT( "%%TF.GenerationSoftware,KiCad,Pcbnew,%s*%%" ), GetBuildVersion() );
 aPlotter->AddLineToHeader( makeStringCompatX1( text, aUseX1CompatibilityMode ) );
 
 // creates the TF.CreationDate attribute:
 text = GbrMakeCreationDateAttributeString( aUseX1CompatibilityMode ? GBR_NC_STRING_FORMAT_X1
 : GBR_NC_STRING_FORMAT_X2 );
 aPlotter->AddLineToHeader( text );
 
 // Creates the TF,.ProjectId. Format is (from Gerber file format doc):
 // %TF.ProjectId,<project id>,<project GUID>,<revision id>*%
 // <project id> is the name of the project, restricted to basic ASCII symbols only,
 // Rem: <project id> accepts only ASCII 7 code (only basic ASCII codes are allowed in
 // gerber files) and comma not accepted.
 // All illegal chars will be replaced by underscore.
 //
 // <project GUID> is a string which is an unique id of a project.
 // However Kicad does not handle such a project GUID, so it is built from the board name
 wxFileName fn = aBoard->GetFileName();
 wxString msg = fn.GetFullName();
 
 // Build a <project GUID>, from the board name
 wxString guid = GbrMakeProjectGUIDfromString( msg );
 
 // build the <project id> string: this is the board short filename (without ext)
 // and all non ASCII chars and comma are replaced by '_'
 msg = fn.GetName();
 msg.Replace( wxT( "," ), wxT( "_" ) );
 
 // build the <revision id> string. All non ASCII chars and comma are replaced by '_'
 wxString rev = ExpandTextVars( aBoard->GetTitleBlock().GetRevision(), aBoard->GetProject() );
 rev.Replace( wxT( "," ), wxT( "_" ) );
 
 if( rev.IsEmpty() )
 rev = wxT( "rev?" );
 
 text.Printf( wxT( "%%TF.ProjectId,%s,%s,%s*%%" ), msg.ToAscii(), guid, rev.ToAscii() );
 aPlotter->AddLineToHeader( makeStringCompatX1( text, aUseX1CompatibilityMode ) );
 
 // Add the TF.SameCoordinates to specify that all gerber files uses the same origin and
 // orientation, and the registration between files is OK.
 // The parameter of TF.SameCoordinates is a string that is common to all files using the
 // same registration. The string value has no meaning; it is just a key.
 // Because there is no mirroring/rotation in Kicad, only the plot offset origin can create
 // incorrect registration, so we create a key from plot offset options.
 //
 // Currently the key is "Original" when using absolute Pcbnew coordinates, and the PY and PY
 // position of the auxiliary axis when using it.
 // If we ever add user-settable absolute Pcbnew coordinates, we'll need to change the way
 // the key is built to ensure file only using the *same* axis have the same key.
 wxString registration_id = wxT( "Original" );
 VECTOR2I auxOrigin = aBoard->GetDesignSettings().GetAuxOrigin();
 
 if( aBoard->GetPlotOptions().GetUseAuxOrigin() && auxOrigin.x && auxOrigin.y )
 registration_id.Printf( wxT( "PX%xPY%x" ), auxOrigin.x, auxOrigin.y );
 
 text.Printf( wxT( "%%TF.SameCoordinates,%s*%%" ), registration_id.GetData() );
 aPlotter->AddLineToHeader( makeStringCompatX1( text, aUseX1CompatibilityMode ) );
}

References PLOTTER::AddLineToHeader(), ExpandTextVars(), GBR_NC_STRING_FORMAT_X1, GBR_NC_STRING_FORMAT_X2, GbrMakeCreationDateAttributeString(), GbrMakeProjectGUIDfromString(), BOARD_DESIGN_SETTINGS::GetAuxOrigin(), GetBuildVersion(), BOARD::GetDesignSettings(), BOARD::GetFileName(), BOARD::GetPlotOptions(), BOARD::GetProject(), TITLE_BLOCK::GetRevision(), BOARD::GetTitleBlock(), PCB_PLOT_PARAMS::GetUseAuxOrigin(), makeStringCompatX1(), text, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by AddGerberX2Attribute(), GERBER_WRITER::createDrillFile(), PLACEFILE_GERBER_WRITER::CreatePlaceFile(), and GENDRILL_WRITER_BASE::genDrillMapFile().

BuildPlotFileName()

void BuildPlotFileName	(	wxFileName *	aFilename,
		const wxString &	aOutputDir,
		const wxString &	aSuffix,
		const wxString &	aExtension
	)

Complete a plot filename.

It forces the output directory, adds a suffix to the name, and sets the specified extension. The suffix is usually the layer name and replaces illegal file name character in the suffix with an underscore character.

Parameters

aFilename	is the file name to initialize that contains the base filename.
aOutputDir	is the path.
aSuffix	is the suffix to add to the base filename.
aExtension	is the file extension.

Definition at line 361 of file pcbplot.cpp.

{
 // aFilename contains the base filename only (without path and extension)
 // when calling this function.
 // It is expected to be a valid filename (this is usually the board filename)
 aFilename->SetPath( aOutputDir );
 
 // Set the file extension
 aFilename->SetExt( aExtension );
 
 // remove leading and trailing spaces if any from the suffix, if
 // something survives add it to the name;
 // also the suffix can contain some not allowed chars in filename (/ \ . : and some others),
 // so change them to underscore
 // Remember it can be called from a python script, so the illegal chars
 // have to be filtered here.
 wxString suffix = aSuffix;
 suffix.Trim( true );
 suffix.Trim( false );
 
 wxString badchars = wxFileName::GetForbiddenChars(wxPATH_DOS);
 badchars.Append( "%." );
 
 for( unsigned ii = 0; ii < badchars.Len(); ii++ )
 suffix.Replace( badchars[ii], wxT("_") );
 
 if( !suffix.IsEmpty() )
 aFilename->SetName( aFilename->GetName() + wxT( "-" ) + suffix );
}

Referenced by DIALOG_EXPORT_SVG::ExportSVGFile(), PCBNEW_JOBS_HANDLER::JobExportGerbers(), PLOT_CONTROLLER::OpenPlotfile(), and DIALOG_PLOT::Plot().

GetGerberFileFunctionAttribute()

const wxString GetGerberFileFunctionAttribute	(	const BOARD *	aBoard,
		int	aLayer
	)

Return the "file function" attribute for aLayer, as defined in the Gerber file format specification J1 (chapter 5).

The returned string includes the "%TF.FileFunction" attribute prefix and the "*%" suffix.

Parameters

aBoard	is the board, needed to get the total count of copper layers.
aLayer	is the layer number to create the attribute for.

Returns

The attribute, as a text string

Definition at line 81 of file pcbplot.cpp.

{
 wxString attrib;
 
 switch( aLayer )
 {
 case F_Adhes:
 attrib = wxT( "Glue,Top" );
 break;
 
 case B_Adhes:
 attrib = wxT( "Glue,Bot" );
 break;
 
 case F_SilkS:
 attrib = wxT( "Legend,Top" );
 break;
 
 case B_SilkS:
 attrib = wxT( "Legend,Bot" );
 break;
 
 case F_Mask:
 attrib = wxT( "Soldermask,Top" );
 break;
 
 case B_Mask:
 attrib = wxT( "Soldermask,Bot" );
 break;
 
 case F_Paste:
 attrib = wxT( "Paste,Top" );
 break;
 
 case B_Paste:
 attrib = wxT( "Paste,Bot" );
 break;
 
 case Edge_Cuts:
 // Board outline.
 // Can be "Profile,NP" (Not Plated: usual) or "Profile,P"
 // This last is the exception (Plated)
 attrib = wxT( "Profile,NP" );
 break;
 
 case Dwgs_User:
 attrib = wxT( "OtherDrawing,Comment" );
 break;
 
 case Cmts_User:
 attrib = wxT( "Other,Comment" );
 break;
 
 case Eco1_User:
 attrib = wxT( "Other,ECO1" );
 break;
 
 case Eco2_User:
 attrib = wxT( "Other,ECO2" );
 break;
 
 case B_Fab:
 // This is actually a assembly layer
 attrib = wxT( "AssemblyDrawing,Bot" );
 break;
 
 case F_Fab:
 // This is actually a assembly layer
 attrib = wxT( "AssemblyDrawing,Top" );
 break;
 
 case B_Cu:
 attrib.Printf( wxT( "Copper,L%d,Bot" ), aBoard->GetCopperLayerCount() );
 break;
 
 case F_Cu:
 attrib = wxT( "Copper,L1,Top" );
 break;
 
 default:
 if( IsCopperLayer( aLayer ) )
 attrib.Printf( wxT( "Copper,L%d,Inr" ), aLayer+1 );
 else
 attrib.Printf( wxT( "Other,User" ), aLayer+1 );
 break;
 }
 
 // This code adds a optional parameter: the type of copper layers.
 // Because it is not used by Pcbnew (it can be used only by external autorouters)
 // user do not really set this parameter.
 // Therefore do not add it.
 // However, this code is left here, for perhaps a future usage.
#if 0
 // Add the signal type of the layer, if relevant
 if( IsCopperLayer( aLayer ) )
 {
 LAYER_T type = aBoard->GetLayerType( ToLAYER_ID( aLayer ) );
 
 switch( type )
 {
 case LT_SIGNAL:
 attrib += wxT( ",Signal" );
 break;
 case LT_POWER:
 attrib += wxT( ",Plane" );
 break;
 case LT_MIXED:
 attrib += wxT( ",Mixed" );
 break;
 default:
 break; // do nothing (but avoid a warning for unhandled LAYER_T values from GCC)
 }
 }
#endif
 
 wxString fileFct;
 fileFct.Printf( wxT( "%%TF.FileFunction,%s*%%" ), attrib );
 
 return fileFct;
}

References B_Adhes, B_Cu, B_Fab, B_Mask, B_Paste, B_SilkS, Cmts_User, Dwgs_User, Eco1_User, Eco2_User, Edge_Cuts, F_Adhes, F_Cu, F_Fab, F_Mask, F_Paste, F_SilkS, BOARD::GetCopperLayerCount(), BOARD::GetLayerType(), IsCopperLayer(), LT_MIXED, LT_POWER, LT_SIGNAL, and ToLAYER_ID().

Referenced by AddGerberX2Attribute().

GetGerberProtelExtension()

const wxString GetGerberProtelExtension

(

int

aLayer

)

Returns

the appropriate Gerber file extension for aLayer

Definition at line 42 of file pcbplot.cpp.

{
 if( IsCopperLayer( aLayer ) )
 {
 if( aLayer == F_Cu )
 return wxT( "gtl" );
 else if( aLayer == B_Cu )
 return wxT( "gbl" );
 else
 return wxString::Format( wxT( "g%d" ), aLayer+1 );
 }
 else
 {
 switch( aLayer )
 {
 case B_Adhes: return wxT( "gba" );
 case F_Adhes: return wxT( "gta" );
 
 case B_Paste: return wxT( "gbp" );
 case F_Paste: return wxT( "gtp" );
 
 case B_SilkS: return wxT( "gbo" );
 case F_SilkS: return wxT( "gto" );
 
 case B_Mask: return wxT( "gbs" );
 case F_Mask: return wxT( "gts" );
 
 case Edge_Cuts: return wxT( "gm1" );
 
 case Dwgs_User:
 case Cmts_User:
 case Eco1_User:
 case Eco2_User:
 default: return wxT( "gbr" );
 }
 }
}

References B_Adhes, B_Cu, B_Mask, B_Paste, B_SilkS, Cmts_User, Dwgs_User, Eco1_User, Eco2_User, Edge_Cuts, F_Adhes, F_Cu, F_Mask, F_Paste, F_SilkS, Format(), and IsCopperLayer().

Referenced by PCBNEW_JOBS_HANDLER::JobExportGerbers(), PLOT_CONTROLLER::OpenPlotfile(), and DIALOG_PLOT::Plot().

PlotBoardLayers()

void PlotBoardLayers	(	BOARD *	aBoard,
		PLOTTER *	aPlotter,
		const LSEQ &	aLayerSequence,
		const PCB_PLOT_PARAMS &	aPlotOptions
	)

Plot a sequence of board layer IDs.

Parameters

aBoard	is the board to plot.
aPlotter	is the plotter to use.
aLayerSequence	is the sequence of layer IDs to plot.
aPlotOptions	are the plot options (files, sketch). Has meaning for some formats only.

Definition at line 69 of file plot_board_layers.cpp.

{
 wxCHECK( aBoard && aPlotter && aLayers.size(), /* void */ );
 
 for( LSEQ seq = aLayers; seq; ++seq )
 PlotOneBoardLayer( aBoard, aPlotter, *seq, aPlotOptions );
}

References PlotOneBoardLayer().

Referenced by PCBNEW_JOBS_HANDLER::JobExportDxf(), PCBNEW_JOBS_HANDLER::JobExportGerber(), PCBNEW_JOBS_HANDLER::JobExportGerbers(), PCBNEW_JOBS_HANDLER::JobExportPdf(), PCB_PLOT_SVG::Plot(), DIALOG_PLOT::Plot(), and PLOT_CONTROLLER::PlotLayers().

PlotInteractiveLayer()

void PlotInteractiveLayer	(	BOARD *	aBoard,
		PLOTTER *	aPlotter
	)

Plot interactive items (hypertext links, properties, etc.).

Definition at line 79 of file plot_board_layers.cpp.

{
 for( const FOOTPRINT* fp : aBoard->Footprints() )
 {
 std::vector<wxString> properties;
 
 properties.emplace_back( wxString::Format( wxT( "!%s = %s" ),
 _( "Reference designator" ),
 fp->Reference().GetShownText() ) );
 
 properties.emplace_back( wxString::Format( wxT( "!%s = %s" ),
 _( "Value" ),
 fp->Value().GetShownText() ) );
 
 for( const auto& [ name, value ] : fp->GetProperties() )
 properties.emplace_back( wxString::Format( wxT( "!%s = %s" ), name, value ) );
 
 properties.emplace_back( wxString::Format( wxT( "!%s = %s" ),
 _( "Footprint" ),
 fp->GetFPIDAsString() ) );
 
 properties.emplace_back( wxString::Format( wxT( "!%s = %s" ),
 _( "Description" ),
 fp->GetDescription() ) );
 
 properties.emplace_back( wxString::Format( wxT( "!%s = %s" ),
 _( "Keywords" ),
 fp->GetKeywords() ) );
 
 aPlotter->HyperlinkMenu( fp->GetBoundingBox(), properties );
 }
}

References _, BOARD::Footprints(), Format(), PLOTTER::HyperlinkMenu(), and name.

Referenced by PCBNEW_JOBS_HANDLER::JobExportPdf(), DIALOG_PLOT::Plot(), PLOT_CONTROLLER::PlotLayer(), and PLOT_CONTROLLER::PlotLayers().

PlotLayerOutlines()

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

Plot copper outline of a copper layer.

Parameters

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

Plot copper outline of a copper layer.

Definition at line 704 of file plot_board_layers.cpp.

{
 BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
 itemplotter.SetLayerSet( aLayerMask );
 
 SHAPE_POLY_SET outlines;
 
 for( LSEQ seq = aLayerMask.Seq( aLayerMask.SeqStackupBottom2Top() ); seq; ++seq )
 {
 PCB_LAYER_ID layer = *seq;
 
 outlines.RemoveAllContours();
 aBoard->ConvertBrdLayerToPolygonalContours( layer, outlines );
 
 outlines.Simplify( SHAPE_POLY_SET::PM_FAST );
 
 // Plot outlines
 std::vector<VECTOR2I> 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 );
 
 aPlotter->PlotPoly( path, FILL_T::NO_FILL );
 }
 }
 
 // Plot pad holes
 if( aPlotOpt.GetDrillMarksType() != DRILL_MARKS::NO_DRILL_SHAPE )
 {
 int smallDrill = ( aPlotOpt.GetDrillMarksType() == DRILL_MARKS::SMALL_DRILL_SHAPE )
 ? pcbIUScale.mmToIU( ADVANCED_CFG::GetCfg().m_SmallDrillMarkSize ) :
 INT_MAX;
 
 for( FOOTPRINT* footprint : aBoard->Footprints() )
 {
 for( PAD* pad : footprint->Pads() )
 {
 if( pad->HasHole() )
 {
 std::shared_ptr<SHAPE_SEGMENT> slot = pad->GetEffectiveHoleShape();
 
 if( slot->GetSeg().A == slot->GetSeg().B ) // circular hole
 {
 int drill = std::min( smallDrill, slot->GetWidth() );
 aPlotter->Circle( pad->GetPosition(), drill, FILL_T::NO_FILL );
 }
 else
 {
 // Note: small drill marks have no significance when applied to slots
 aPlotter->ThickSegment( slot->GetSeg().A,
 slot->GetSeg().B,
 slot->GetWidth(), SKETCH, nullptr );
 }
 }
 }
 }
 }
 
 // Plot vias holes
 for( PCB_TRACK* track : aBoard->Tracks() )
 {
 const PCB_VIA* via = dyn_cast<const PCB_VIA*>( track );
 
 if( via && via->IsOnLayer( layer ) ) // via holes can be not through holes
 aPlotter->Circle( via->GetPosition(), via->GetDrillValue(), FILL_T::NO_FILL );
 }
 }
}

References SHAPE_POLY_SET::CHole(), PLOTTER::Circle(), BOARD::ConvertBrdLayerToPolygonalContours(), SHAPE_POLY_SET::COutline(), BOARD::Footprints(), ADVANCED_CFG::GetCfg(), PCB_PLOT_PARAMS::GetDrillMarksType(), SHAPE_POLY_SET::HoleCount(), ADVANCED_CFG::m_SmallDrillMarkSize, EDA_IU_SCALE::mmToIU(), NO_DRILL_SHAPE, NO_FILL, SHAPE_POLY_SET::OutlineCount(), pad, path, pcbIUScale, PLOTTER::PlotPoly(), SHAPE_POLY_SET::PM_FAST, SHAPE_POLY_SET::RemoveAllContours(), LSET::Seq(), LSET::SeqStackupBottom2Top(), BRDITEMS_PLOTTER::SetLayerSet(), SHAPE_POLY_SET::Simplify(), SKETCH, SMALL_DRILL_SHAPE, PLOTTER::ThickSegment(), BOARD::Tracks(), and via.

Referenced by PlotOneBoardLayer().

PlotOneBoardLayer()

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

Plot one copper or technical layer.

It prepares options and calls the specialized plot function according to the layer type.

Parameters

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

Definition at line 113 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( 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( DRILL_MARKS::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( DRILL_MARKS::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( DRILL_MARKS::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( DRILL_MARKS::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( DRILL_MARKS::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::GetFormat(), PLOTTER::GetPlotterType(), PCB_PLOT_PARAMS::GetSubtractMaskFromSilk(), PCB_PLOT_PARAMS::GetTextMode(), IsCopperLayer(), BOARD_DESIGN_SETTINGS::m_SolderMaskMinWidth, Margin, NO_DRILL_SHAPE, PlotLayerOutlines(), PlotSolderMaskLayer(), PlotStandardLayer(), PLOTTER::SetColor(), PCB_PLOT_PARAMS::SetDrillMarksType(), PLOTTER::SetLayerPolarity(), PCB_PLOT_PARAMS::SetSkipPlotNPTH_Pads(), and PLOTTER::SetTextMode().

Referenced by PlotBoardLayers(), and PLOT_CONTROLLER::PlotLayer().

PlotStandardLayer()

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

Plot copper or technical layers.

This is not used for silk screen layers because these layers have specific requirements. This is mainly for pads.

Parameters

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

aPlotOpt has 3 important options 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 ) aVal = no hole, small hole, actual hole size

Plot copper or technical layers.

Silk screen layers are not plotted here.

pads not connected to copper are optionally not drawn

Vias not connected to copper are optionally not drawn

Definition at line 262 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( const FOOTPRINT* footprint : aBoard->Footprints() )
 itemplotter.PlotFootprintTextItems( footprint );
 
 // Draw footprint other graphic items:
 for( const FOOTPRINT* footprint : aBoard->Footprints() )
 itemplotter.PlotFootprintGraphicItems( footprint );
 
 // Plot footprint pads
 for( FOOTPRINT* footprint : aBoard->Footprints() )
 {
 aPlotter->StartBlock( nullptr );
 
 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 we're plotting a single layer, the color for that layer can be used directly.
 if( aLayerMask.count() == 1 )
 {
 color = aPlotOpt.ColorSettings()->GetColor( aLayerMask.Seq()[0] );
 }
 else
 {
 if( ( pad->GetLayerSet() & aLayerMask )[B_Cu] )
 color = aPlotOpt.ColorSettings()->GetColor( B_Cu );
 
 if( ( pad->GetLayerSet() & aLayerMask )[F_Cu] )
 color = color.LegacyMix( aPlotOpt.ColorSettings()->GetColor( F_Cu ) );
 
 if( sketchPads && aLayerMask[F_Fab] )
 color = aPlotOpt.ColorSettings()->GetColor( F_Fab );
 else if( sketchPads && aLayerMask[B_Fab] )
 color = aPlotOpt.ColorSettings()->GetColor( B_Fab );
 }
 
 VECTOR2I margin;
 int width_adj = 0;
 
 if( onCopperLayer )
 width_adj = itemplotter.getFineWidthAdj();
 
 if( onSolderMaskLayer )
 margin.x = margin.y = pad->GetSolderMaskExpansion();
 
 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
 VECTOR2I padPlotsSize = pad->GetSize() + margin * 2 + VECTOR2I( width_adj, width_adj );
 
 // Store these parameters that can be modified to plot inflated/deflated pads shape
 PAD_SHAPE padShape = pad->GetShape();
 VECTOR2I padSize = pad->GetSize();
 VECTOR2I padDelta = pad->GetDelta(); // has meaning only for trapezoidal pads
 double padCornerRadius = pad->GetRoundRectCornerRadius();
 
 // Don't draw a 0 sized pad.
 // Note: a custom pad can have its pad anchor with size = 0
 if( pad->GetShape() != PAD_SHAPE::CUSTOM
 && ( 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() == DRILL_MARKS::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, FULL_CIRCLE );
 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( VECTOR2I( 0, 0 ) );
 
 itemplotter.PlotPad( &dummy, color, padPlotMode );
 }
 
 break;
 
 case PAD_SHAPE::ROUNDRECT:
 {
 // rounding is stored as a percent, but we have to change the new radius
 // to initial_radius + clearance to have a inflated/deflated similar shape
 int initial_radius = pad->GetRoundRectCornerRadius();
 pad->SetSize( padPlotsSize );
 pad->SetRoundRectCornerRadius( std::max( initial_radius + mask_clearance, 0 ) );
 
 itemplotter.PlotPad( pad, color, padPlotMode );
 break;
 }
 
 case PAD_SHAPE::CHAMFERED_RECT:
 if( mask_clearance == 0 )
 {
 // the size can be slightly inflated by width_adj (PS/PDF only)
 pad->SetSize( padPlotsSize );
 itemplotter.PlotPad( pad, color, padPlotMode );
 }
 else
 {
 // Due to the polygonal shape of a CHAMFERED_RECT pad, the best way is to
 // convert the pad shape to a full polygon, inflate/deflate the polygon
 // and use a dummy CUSTOM pad to plot the final shape.
 PAD dummy( *pad );
 // Build the dummy pad outline with coordinates relative to the pad position
 // and orientation 0. The actual pos and rotation will be taken in account
 // later by the plot function
 dummy.SetPosition( VECTOR2I( 0, 0 ) );
 dummy.SetOrientation( ANGLE_0 );
 SHAPE_POLY_SET outline;
 int maxError = aBoard->GetDesignSettings().m_MaxError;
 int numSegs = GetArcToSegmentCount( mask_clearance, maxError, FULL_CIRCLE );
 dummy.TransformShapeToPolygon( outline, UNDEFINED_LAYER, 0, maxError,
 ERROR_INSIDE );
 outline.InflateWithLinkedHoles( mask_clearance, numSegs,
 SHAPE_POLY_SET::PM_FAST );
 
 // Initialize the dummy pad shape:
 dummy.SetAnchorPadShape( PAD_SHAPE::CIRCLE );
 dummy.SetShape( PAD_SHAPE::CUSTOM );
 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 we set the anchor size to 0
 dummy.SetSize( VECTOR2I( 0, 0 ) );
 dummy.SetPosition( pad->GetPosition() );
 dummy.SetOrientation( pad->GetOrientation() );
 
 itemplotter.PlotPad( &dummy, 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 );
 
 // 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, FULL_CIRCLE );
 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( nullptr );
 aPlotter->Bookmark( footprint->GetBoundingBox(), footprint->GetReference(), _( "Footprints" ) );
 }
 
 // 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( nullptr );
 
 for( const PCB_TRACK* track : aBoard->Tracks() )
 {
 const PCB_VIA* via = dyn_cast<const PCB_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( aLayerMask[B_Mask] || aLayerMask[F_Mask] )
 via_margin = via->GetSolderMaskExpansion();
 
 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( nullptr );
 aPlotter->StartBlock( nullptr );
 gbr_metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CONDUCTOR );
 
 // Plot tracks (not vias) :
 for( const PCB_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 )
 {
 const PCB_ARC* arc = static_cast<const PCB_ARC*>( track );
 
 // ThickArc expects only positive angle arcs, so flip start/end if
 // we are negative
 if( arc->GetAngle() < ANGLE_0 )
 {
 aPlotter->ThickArc( arc->GetCenter(), arc->GetEnd(), arc->GetStart(),
 width, plotMode, &gbr_metadata );
 }
 else
 {
 aPlotter->ThickArc( arc->GetCenter(), arc->GetStart(), arc->GetEnd(),
 width, plotMode, &gbr_metadata );
 }
 }
 else
 {
 aPlotter->ThickSegment( track->GetStart(), track->GetEnd(), width, plotMode,
 &gbr_metadata );
 }
 }
 
 aPlotter->EndBlock( nullptr );
 
 // Plot filled ares
 aPlotter->StartBlock( nullptr );
 
 NETINFO_ITEM nonet( aBoard );
 
 for( const ZONE* zone : aBoard->Zones() )
 {
 for( PCB_LAYER_ID layer : zone->GetLayerSet().Seq() )
 {
 if( !aLayerMask[layer] )
 continue;
 
 SHAPE_POLY_SET mainArea = zone->GetFilledPolysList( layer )->CloneDropTriangulation();
 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, layer, mainArea );
 
 if( !islands.IsEmpty() )
 {
 ZONE dummy( *zone );
 dummy.SetNet( &nonet );
 itemplotter.PlotFilledAreas( &dummy, layer, islands );
 }
 }
 }
 
 aPlotter->EndBlock( nullptr );
 
 // Adding drill marks, if required and if the plotter is able to plot them:
 if( aPlotOpt.GetDrillMarksType() != DRILL_MARKS::NO_DRILL_SHAPE )
 itemplotter.PlotDrillMarks();
}

References _, SHAPE_POLY_SET::AddOutline(), LSET::AllCuMask(), ANGLE_0, SHAPE_POLY_SET::Append(), B_Cu, B_Fab, B_Mask, B_Paste, BLACK, PLOTTER::Bookmark(), CHAMFERED_RECT, CIRCLE, SHAPE_POLY_SET::CloneDropTriangulation(), color, PCB_PLOT_PARAMS::ColorSettings(), SHAPE_POLY_SET::CPolygon(), CUSTOM, SHAPE_POLY_SET::DeletePolygon(), dummy, PLOTTER::EndBlock(), ERROR_INSIDE, F_Cu, F_Fab, F_Mask, F_Paste, PLOTTER::FlashPadCircle(), BOARD::Footprints(), FULL_CIRCLE, GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CONDUCTOR, GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_VIAPAD, GBR_NETLIST_METADATA::GBR_NETINFO_NET, PCB_ARC::GetAngle(), GetArcToSegmentCount(), PCB_ARC::GetCenter(), COLOR_SETTINGS::GetColor(), BRDITEMS_PLOTTER::getColor(), BOARD::GetDesignSettings(), PCB_PLOT_PARAMS::GetDrillMarksType(), PCB_TRACK::GetEnd(), BRDITEMS_PLOTTER::getFineWidthAdj(), PCB_PLOT_PARAMS::GetPlotMode(), PCB_PLOT_PARAMS::GetPlotViaOnMaskLayer(), PCB_PLOT_PARAMS::GetSketchPadsOnFabLayers(), PCB_PLOT_PARAMS::GetSkipPlotNPTH_Pads(), PCB_TRACK::GetStart(), SHAPE_POLY_SET::InflateWithLinkedHoles(), SHAPE_POLY_SET::IsEmpty(), LAYER_VIAS, LIGHTGRAY, BOARD_DESIGN_SETTINGS::m_MaxError, GBR_METADATA::m_NetlistMetadata, GBR_NETLIST_METADATA::m_NotInNet, SHAPE_POLY_SET::NewOutline(), NO_DRILL_SHAPE, NPTH, SHAPE_POLY_SET::OutlineCount(), OVAL, pad, 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, RECT, ROUNDRECT, LSET::Seq(), GBR_METADATA::SetApertureAttrib(), PLOTTER::SetColor(), BRDITEMS_PLOTTER::SetLayerSet(), GBR_METADATA::SetNetAttribType(), GBR_METADATA::SetNetName(), SKETCH, PLOTTER::StartBlock(), PLOTTER::ThickArc(), PLOTTER::ThickSegment(), BOARD::Tracks(), TRAPEZOID, UNDEFINED_LAYER, via, WHITE, VECTOR2< T >::x, VECTOR2< T >::y, and BOARD::Zones().

Referenced by PlotOneBoardLayer(), and PlotSolderMaskLayer().

StartPlotBoard()

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

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

Returns

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

Definition at line 1126 of file plot_board_layers.cpp.

{
 // Create the plotter driver and set the few plotter specific options
 PLOTTER* plotter = nullptr;
 
 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:
 // For Gerber plotter, a valid board layer must be set, in order to create a valid
 // Gerber header, especially the TF.FileFunction and .FilePolarity data
 if( aLayer < PCBNEW_LAYER_ID_START || aLayer >= PCB_LAYER_ID_COUNT )
 {
 wxLogError( wxString::Format(
 "Invalid board layer %d, cannot build a valid Gerber file header",
 aLayer ) );
 }
 
 plotter = new GERBER_PLOTTER();
 break;
 
 case PLOT_FORMAT::SVG:
 plotter = new SVG_PLOTTER();
 break;
 
 default:
 wxASSERT( false );
 return nullptr;
 }
 
 KIGFX::PCB_RENDER_SETTINGS* renderSettings = new KIGFX::PCB_RENDER_SETTINGS();
 renderSettings->LoadColors( aPlotOpts->ColorSettings() );
 renderSettings->SetDefaultPenWidth( pcbIUScale.mmToIU( 0.0212 ) ); // Hairline at 1200dpi
 
 if( aLayer >= 0 && aLayer < GAL_LAYER_ID_END )
 renderSettings->SetLayerName( aBoard->GetLayerName( ToLAYER_ID( aLayer ) ) );
 
 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( wxT( "1" ) );
 
 // Plot the frame reference if requested
 if( aPlotOpts->GetPlotFrameRef() )
 {
 PlotDrawingSheet( plotter, aBoard->GetProject(), aBoard->GetTitleBlock(),
 aBoard->GetPageSettings(), &aBoard->GetProperties(), wxT( "1" ), 1,
 aSheetName, aSheetPath, 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() )
 {
 BOX2I bbox = aBoard->ComputeBoundingBox();
 FillNegativeKnockout( plotter, bbox );
 }
 
 return plotter;
 }
 
 delete plotter->RenderSettings();
 delete plotter;
 return nullptr;
}

References AddGerberX2Attribute(), PLOTTER::ClearHeaderLinesList(), PCB_PLOT_PARAMS::ColorSettings(), BOARD::ComputeBoundingBox(), ConfigureHPGLPenSizes(), GERBER_PLOTTER::DisableApertMacros(), DXF, FillNegativeKnockout(), Format(), GAL_LAYER_ID_END, GERBER, PCB_PLOT_PARAMS::GetDisableGerberMacros(), PCB_PLOT_PARAMS::GetDXFPlotUnits(), BOARD::GetFileName(), PCB_PLOT_PARAMS::GetFineScaleAdjustX(), PCB_PLOT_PARAMS::GetFineScaleAdjustY(), PCB_PLOT_PARAMS::GetFormat(), PCB_PLOT_PARAMS::GetIncludeGerberNetlistInfo(), BOARD::GetLayerName(), PCB_PLOT_PARAMS::GetMirror(), PCB_PLOT_PARAMS::GetNegative(), BOARD::GetPageSettings(), PCB_PLOT_PARAMS::GetPlotFrameRef(), PLOTTER::GetPlotterType(), BOARD::GetProject(), BOARD::GetProperties(), BOARD::GetTitleBlock(), PCB_PLOT_PARAMS::GetUseGerberX2format(), HPGL, initializePlotter(), KIGFX::PCB_RENDER_SETTINGS::LoadColors(), EDA_IU_SCALE::mmToIU(), PLOTTER::OpenFile(), PCB_LAYER_ID_COUNT, pcbIUScale, PDF, PlotDrawingSheet(), POST, PLOTTER::RenderSettings(), KIGFX::RENDER_SETTINGS::SetDefaultPenWidth(), KIGFX::RENDER_SETTINGS::SetLayerName(), PCB_PLOT_PARAMS::SetMirror(), PLOTTER::SetRenderSettings(), PSLIKE_PLOTTER::SetScaleAdjust(), DXF_PLOTTER::SetUnits(), PLOTTER::StartPlot(), SVG, ToLAYER_ID(), GERBER_PLOTTER::UseX2format(), and GERBER_PLOTTER::UseX2NetAttributes().

Referenced by PCBNEW_JOBS_HANDLER::JobExportDxf(), PCBNEW_JOBS_HANDLER::JobExportGerber(), PCBNEW_JOBS_HANDLER::JobExportGerbers(), PCBNEW_JOBS_HANDLER::JobExportPdf(), PLOT_CONTROLLER::OpenPlotfile(), PCB_PLOT_SVG::Plot(), and DIALOG_PLOT::Plot().