pcbplot.h File Reference

Board plot function definition file. More...

#include <layer_ids.h>
#include <pad_shapes.h>
#include <pcb_plot_params.h>
#include <settings/color_settings.h>
#include <settings/settings_manager.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 &aSheetDesc)
	Open a new plotfile using the options (and especially the format) specified in the options and prepare the page for plotting. 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 (LAYER_NUM aLayer)
const wxString	GetGerberFileFunctionAttribute (const BOARD *aBoard, LAYER_NUM 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, LAYER_NUM aLayer, bool aUseX1CompatibilityMode)
	Calculate some X2 attributes as defined in the Gerber file format specification and add them to the gerber file header. More...

Detailed Description

Board plot function definition file.

Definition in file pcbplot.h.

Macro Definition Documentation

PLOT_MAX_SCALE

#define PLOT_MAX_SCALE   100.0

Definition at line 55 of file pcbplot.h.

PLOT_MIN_SCALE

#define PLOT_MIN_SCALE   0.01

Definition at line 54 of file pcbplot.h.

Function Documentation

AddGerberX2Attribute()

void AddGerberX2Attribute	(	PLOTTER *	aPlotter,
		const BOARD *	aBoard,
		LAYER_NUM	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 353 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 282 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, that specify 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 and has no special meaning:
 // this 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.
 // and therefore for a given board, all Gerber files having the same key have the same
 // plot origin and use the same registration
 //
 // Currently the key is "Original" when using absolute Pcbnew coordinates,
 // and the PY and PY position of auxiliary axis, when using it.
 // Please, if absolute Pcbnew coordinates, one day, are set by user, change the way
 // the key is built to ensure file only using the *same* axis have the same key.
 wxString registration_id = wxT( "Original" );
 wxPoint 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(), and text.

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

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 372 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(), PLOT_CONTROLLER::OpenPlotfile(), and DIALOG_PLOT::Plot().

GetGerberFileFunctionAttribute()

const wxString GetGerberFileFunctionAttribute	(	const BOARD *	aBoard,
		LAYER_NUM	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 87 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

(

LAYER_NUM

aLayer

)

Returns

the appropriate Gerber file extension for aLayer

Definition at line 46 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 PLOT_CONTROLLER::OpenPlotfile(), and DIALOG_PLOT::Plot().

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 714 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 );

 aPlotter->PlotPoly( path, FILL_T::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_T::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, 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 SEG::A, arrayDim(), SEG::B, SHAPE_POLY_SET::CHole(), PLOTTER::Circle(), BOARD::ConvertBrdLayerToPolygonalContours(), SHAPE_POLY_SET::COutline(), BOARD::Footprints(), ADVANCED_CFG::GetCfg(), PCB_PLOT_PARAMS::GetDrillMarksType(), SHAPE_SEGMENT::GetSeg(), SHAPE_SEGMENT::GetWidth(), SHAPE_POLY_SET::HoleCount(), ADVANCED_CFG::m_SmallDrillMarkSize, PCB_PLOT_PARAMS::NO_DRILL_SHAPE, NO_FILL, SHAPE_POLY_SET::OutlineCount(), pad, path, plot_seq, PLOTTER::PlotPoly(), SHAPE_POLY_SET::PM_FAST, SHAPE_POLY_SET::RemoveAllContours(), LSET::Seq(), BRDITEMS_PLOTTER::SetLayerSet(), SHAPE_POLY_SET::Simplify(), SKETCH, PCB_PLOT_PARAMS::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 68 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().

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 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 ) control the actual hole: no hole, small hole, actual hole

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 218 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( ( 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 );

 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 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 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() == 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:
 {
 // 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( wxPoint( 0, 0 ) );
 dummy.SetOrientation( 0 );
 SHAPE_POLY_SET outline;
 int maxError = aBoard->GetDesignSettings().m_MaxError;
 int numSegs = GetArcToSegmentCount( mask_clearance, maxError, 360.0 );
 dummy.TransformShapeWithClearanceToPolygon( 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( wxSize( 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, 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( nullptr );
 }

 // 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 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( 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 );
 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( 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 );
 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( nullptr );

 // 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, CHAMFERED_RECT, CIRCLE, 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(), GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CONDUCTOR, GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_VIAPAD, GBR_NETLIST_METADATA::GBR_NETINFO_NET, PCB_ARC::GetAngle(), PCB_ARC::GetArcAngleStart(), GetArcToSegmentCount(), PCB_ARC::GetCenter(), COLOR_SETTINGS::GetColor(), BRDITEMS_PLOTTER::getColor(), BOARD::GetDesignSettings(), PCB_PLOT_PARAMS::GetDrillMarksType(), BRDITEMS_PLOTTER::getFineWidthAdj(), PCB_PLOT_PARAMS::GetPlotMode(), PCB_PLOT_PARAMS::GetPlotViaOnMaskLayer(), PCB_ARC::GetRadius(), PCB_PLOT_PARAMS::GetSketchPadsOnFabLayers(), PCB_PLOT_PARAMS::GetSkipPlotNPTH_Pads(), 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, BOARD_DESIGN_SETTINGS::m_SolderMaskMargin, SHAPE_POLY_SET::NewOutline(), PCB_PLOT_PARAMS::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, GBR_METADATA::SetApertureAttrib(), PLOTTER::SetColor(), BRDITEMS_PLOTTER::SetLayerSet(), GBR_METADATA::SetNetAttribType(), GBR_METADATA::SetNetName(), EDA_ITEM::SetPosition(), SKETCH, PLOTTER::StartBlock(), PLOTTER::ThickArc(), PLOTTER::ThickSegment(), BOARD::Tracks(), TRAPEZOID, UNDEFINED_LAYER, via, WHITE, 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 &	aSheetDesc
	)

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 1137 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:
 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( 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(), wxT( "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 nullptr;
}

References AddGerberX2Attribute(), PLOTTER::ClearHeaderLinesList(), PCB_PLOT_PARAMS::ColorSettings(), BOARD::ComputeBoundingBox(), ConfigureHPGLPenSizes(), GERBER_PLOTTER::DisableApertMacros(), DXF, FillNegativeKnockout(), 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(), PCB_PLOT_PARAMS::GetMirror(), PCB_PLOT_PARAMS::GetNegative(), BOARD::GetPageSettings(), PCB_PLOT_PARAMS::GetPlotFrameRef(), PLOTTER::GetPlotterType(), BOARD::GetProject(), BOARD::GetTitleBlock(), PCB_PLOT_PARAMS::GetUseGerberX2format(), HPGL, initializePlotter(), KIGFX::PCB_RENDER_SETTINGS::LoadColors(), Millimeter2iu(), PLOTTER::OpenFile(), PDF, PlotDrawingSheet(), POST, PLOTTER::RenderSettings(), KIGFX::RENDER_SETTINGS::SetDefaultPenWidth(), PCB_PLOT_PARAMS::SetMirror(), PLOTTER::SetRenderSettings(), PSLIKE_PLOTTER::SetScaleAdjust(), DXF_PLOTTER::SetUnits(), PLOTTER::StartPlot(), SVG, GERBER_PLOTTER::UseX2format(), and GERBER_PLOTTER::UseX2NetAttributes().

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