KiCad PCB EDA Suite
pcbplot.h File Reference

Board plot function definition file. More...

#include <wx/filename.h>
#include <pad_shapes.h>
#include <pcb_plot_params.h>
#include <layers_id_colors_and_visibility.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
 
#define SMALL_DRILL   KiROUND( 0.35 * IU_PER_MM )
 
#define OPTKEY_LAYERBASE   wxT( "PlotLayer_%d" )
 
#define OPTKEY_PRINT_LINE_WIDTH   wxT( "PrintLineWidth" )
 
#define OPTKEY_PRINT_SCALE   wxT( "PrintScale" )
 
#define OPTKEY_PRINT_PAGE_FRAME   wxT( "PrintPageFrame" )
 
#define OPTKEY_PRINT_MONOCHROME_MODE   wxT( "PrintMonochrome" )
 
#define OPTKEY_PRINT_PAGE_PER_LAYER   wxT( "PrintSinglePage" )
 
#define OPTKEY_PRINT_PADS_DRILL   wxT( "PrintPadsDrillOpt" )
 
#define OPTKEY_PLOT_X_FINESCALE_ADJ   wxT( "PlotXFineScaleAdj" )
 
#define OPTKEY_PLOT_Y_FINESCALE_ADJ   wxT( "PlotYFineScaleAdj" )
 
#define CONFIG_PS_FINEWIDTH_ADJ   wxT( "PSPlotFineWidthAdj" )
 
#define OPTKEY_PLOT_CHECK_ZONES   wxT( "CheckZonesBeforePlotting" )
 

Functions

PLOTTERStartPlotBoard (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...
 
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...
 
void PlotSilkScreen (BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt)
 Function PlotSilkScreen plot silkscreen layers which have specific requirements, mainly for pads. More...
 
void BuildPlotFileName (wxFileName *aFilename, const wxString &aOutputDir, const wxString &aSuffix, const wxString &aExtension)
 Function BuildPlotFileName (helper function) Complete a plot filename: forces the output directory, add a suffix to the name and sets the specified extension the suffix is usually the layer name replaces not allowed chars in suffix by '_'. More...
 
const wxString GetGerberProtelExtension (LAYER_NUM aLayer)
 Function GetGerberProtelExtension. More...
 
const wxString GetGerberFileFunctionAttribute (const BOARD *aBoard, LAYER_NUM aLayer)
 Function GetGerberFileFunctionAttribute Returns 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)
 Calculates 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. More...
 
void AddGerberX2Attribute (PLOTTER *aPlotter, const BOARD *aBoard, LAYER_NUM aLayer, bool aUseX1CompatibilityMode)
 Calculates 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. 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 69 of file pcbplot.h.

◆ PLOT_MIN_SCALE

#define PLOT_MIN_SCALE   0.01

Definition at line 68 of file pcbplot.h.

◆ SMALL_DRILL

#define SMALL_DRILL   KiROUND( 0.35 * IU_PER_MM )

Definition at line 72 of file pcbplot.h.

Function Documentation

◆ AddGerberX2Attribute()

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

Calculates 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= the current plotter.
aBoard= the board, needed to extract some info
aLayer= the layer number to create the attribute for
aUseX1CompatibilityMode= 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 352 of file pcbplot.cpp.

354 {
355  AddGerberX2Header( aPlotter, aBoard, aUseX1CompatibilityMode );
356 
357  wxString text;
358 
359  // Add the TF.FileFunction
360  text = GetGerberFileFunctionAttribute( aBoard, aLayer );
361  aPlotter->AddLineToHeader( makeStringCompatX1( text, aUseX1CompatibilityMode ) );
362 
363  // Add the TF.FilePolarity (for layers which support that)
364  text = GetGerberFilePolarityAttribute( aLayer );
365 
366  if( !text.IsEmpty() )
367  aPlotter->AddLineToHeader( makeStringCompatX1( text, aUseX1CompatibilityMode ) );
368 }
void AddGerberX2Header(PLOTTER *aPlotter, const BOARD *aBoard, bool aUseX1CompatibilityMode)
Calculates some X2 attributes, as defined in the Gerber file format specification J4 (chapter 5) and ...
Definition: pcbplot.cpp:280
void AddLineToHeader(const wxString &aExtraString)
Function AddLineToHeader Add a line to the list of free lines to print at the beginning of the file.
Definition: plotter.h:176
static const wxString GetGerberFilePolarityAttribute(LAYER_NUM aLayer)
Definition: pcbplot.cpp:209
static wxString & makeStringCompatX1(wxString &aText, bool aUseX1CompatibilityMode)
Definition: pcbplot.cpp:268
const wxString GetGerberFileFunctionAttribute(const BOARD *aBoard, LAYER_NUM aLayer)
Function GetGerberFileFunctionAttribute Returns the "file function" attribute for aLayer,...
Definition: pcbplot.cpp:89

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

Referenced by StartPlotBoard().

◆ AddGerberX2Header()

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

Calculates 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= the current plotter.
aBoard= the board, needed to extract some info
aUseX1CompatibilityMode= 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 280 of file pcbplot.cpp.

282 {
283  wxString text;
284 
285  // Creates the TF,.GenerationSoftware. Format is:
286  // %TF,.GenerationSoftware,<vendor>,<application name>[,<application version>]*%
287  text.Printf( wxT( "%%TF.GenerationSoftware,KiCad,Pcbnew,%s*%%" ), GetBuildVersion() );
288  aPlotter->AddLineToHeader( makeStringCompatX1( text, aUseX1CompatibilityMode ) );
289 
290  // creates the TF.CreationDate attribute:
291  text = GbrMakeCreationDateAttributeString( aUseX1CompatibilityMode ?
294  aPlotter->AddLineToHeader( text );
295 
296  // Creates the TF,.ProjectId. Format is (from Gerber file format doc):
297  // %TF.ProjectId,<project id>,<project GUID>,<revision id>*%
298  // <project id> is the name of the project, restricted to basic ASCII symbols only,
299  // Rem: <project id> accepts only ASCII 7 code (only basic ASCII codes are allowed in gerber files).
300  // and comma not accepted
301  // All illegal chars will be replaced by underscore
302  //
303  // <project GUID> is a string which is an unique id of a project.
304  // However Kicad does not handle such a project GUID, so it is built from the board name
305  wxFileName fn = aBoard->GetFileName();
306  wxString msg = fn.GetFullName();
307 
308  // Build a <project GUID>, from the board name
309  wxString guid = GbrMakeProjectGUIDfromString( msg );
310 
311  // build the <project id> string: this is the board short filename (without ext)
312  // and all non ASCII chars and comma are replaced by '_'
313  msg = fn.GetName();
314  msg.Replace( wxT( "," ), wxT( "_" ) );
315 
316  // build the <rec> string. All non ASCII chars and comma are replaced by '_'
317  wxString rev = ((BOARD*)aBoard)->GetTitleBlock().GetRevision();
318  rev.Replace( wxT( "," ), wxT( "_" ) );
319 
320  if( rev.IsEmpty() )
321  rev = wxT( "rev?" );
322 
323  text.Printf( wxT( "%%TF.ProjectId,%s,%s,%s*%%" ), msg.ToAscii(), GetChars( guid ), rev.ToAscii() );
324  aPlotter->AddLineToHeader( makeStringCompatX1( text, aUseX1CompatibilityMode ) );
325 
326  // Add the TF.SameCoordinates, that specify all gerber files uses the same
327  // origin and orientation, and the registration between files is OK.
328  // The parameter of TF.SameCoordinates is a string that is common
329  // to all files using the same registration and has no special meaning:
330  // this is just a key
331  // Because there is no mirroring/rotation in Kicad, only the plot offset origin
332  // can create incorrect registration.
333  // So we create a key from plot offset options.
334  // and therefore for a given board, all Gerber files having the same key have the same
335  // plot origin and use the same registration
336  //
337  // Currently the key is "Original" when using absolute Pcbnew coordinates,
338  // and te PY ans PY position od auxiliary axis, when using it.
339  // Please, if absolute Pcbnew coordinates, one day, are set by user, change the way
340  // the key is built to ensure file only using the *same* axis have the same key.
341  wxString registration_id = "Original";
342  wxPoint auxOrigin = aBoard->GetAuxOrigin();
343 
344  if( aBoard->GetPlotOptions().GetUseAuxOrigin() && auxOrigin.x && auxOrigin.y )
345  registration_id.Printf( "PX%xPY%x", auxOrigin.x, auxOrigin.y );
346 
347  text.Printf( "%%TF.SameCoordinates,%s*%%", registration_id.GetData() );
348  aPlotter->AddLineToHeader( makeStringCompatX1( text, aUseX1CompatibilityMode ) );
349 }
const PCB_PLOT_PARAMS & GetPlotOptions() const
Definition: class_board.h:558
wxString GbrMakeCreationDateAttributeString(GBR_NC_STRING_FORMAT aFormat)
void AddLineToHeader(const wxString &aExtraString)
Function AddLineToHeader Add a line to the list of free lines to print at the beginning of the file.
Definition: plotter.h:176
const wxString & GetFileName() const
Definition: class_board.h:225
wxString GetBuildVersion()
Function GetBuildVersion Return the build version string.
wxString GbrMakeProjectGUIDfromString(wxString &aText)
A helper function to build a project GUID using format RFC4122 Version 1 or 4 from the project name,...
const wxPoint & GetAuxOrigin() const
Definition: class_board.h:363
static const wxChar * GetChars(const wxString &s)
Function GetChars returns a wxChar* to the actual wxChar* data within a wxString, and is helpful for ...
Definition: macros.h:101
static wxString & makeStringCompatX1(wxString &aText, bool aUseX1CompatibilityMode)
Definition: pcbplot.cpp:268
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:161
bool GetUseAuxOrigin() const

References PLOTTER::AddLineToHeader(), GBR_NC_STRING_FORMAT_X1, GBR_NC_STRING_FORMAT_X2, GbrMakeCreationDateAttributeString(), GbrMakeProjectGUIDfromString(), BOARD::GetAuxOrigin(), GetBuildVersion(), GetChars(), BOARD::GetFileName(), BOARD::GetPlotOptions(), PCB_PLOT_PARAMS::GetUseAuxOrigin(), and makeStringCompatX1().

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

◆ BuildPlotFileName()

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

Function BuildPlotFileName (helper function) Complete a plot filename: forces the output directory, add a suffix to the name and sets the specified extension the suffix is usually the layer name replaces not allowed chars in suffix by '_'.

Parameters
aFilename= the wxFileName to initialize Contains the base filename
aOutputDir= the path
aSuffix= the suffix to add to the base filename
aExtension= the file extension

Definition at line 371 of file pcbplot.cpp.

373 {
374  // aFilename contains the base filename only (without path and extension)
375  // when calling this function.
376  // It is expected to be a valid filename (this is usually the board filename)
377  aFilename->SetPath( aOutputDir );
378 
379  // Set the file extension
380  aFilename->SetExt( aExtension );
381 
382  // remove leading and trailing spaces if any from the suffix, if
383  // something survives add it to the name;
384  // also the suffix can contain some not allowed chars in filename (/ \ . : and some others),
385  // so change them to underscore
386  // Remember it can be called from a python script, so the illegal chars
387  // have to be filtered here.
388  wxString suffix = aSuffix;
389  suffix.Trim( true );
390  suffix.Trim( false );
391 
392  wxString badchars = wxFileName::GetForbiddenChars(wxPATH_DOS);
393  badchars.Append( "%." );
394 
395  for( unsigned ii = 0; ii < badchars.Len(); ii++ )
396  suffix.Replace( badchars[ii], wxT("_") );
397 
398  if( !suffix.IsEmpty() )
399  aFilename->SetName( aFilename->GetName() + wxT( "-" ) + suffix );
400 }

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

◆ GetGerberFileFunctionAttribute()

const wxString GetGerberFileFunctionAttribute ( const BOARD aBoard,
LAYER_NUM  aLayer 
)

Function GetGerberFileFunctionAttribute Returns 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= the board, needed to get the total count of copper layers
aLayer= the layer number to create the attribute for
Returns
The attribute, as a text string

Definition at line 89 of file pcbplot.cpp.

90 {
91  wxString attrib;
92 
93  switch( aLayer )
94  {
95  case F_Adhes:
96  attrib = "Glue,Top";
97  break;
98 
99  case B_Adhes:
100  attrib = "Glue,Bot";
101  break;
102 
103  case F_SilkS:
104  attrib = "Legend,Top";
105  break;
106 
107  case B_SilkS:
108  attrib = "Legend,Bot";
109  break;
110 
111  case F_Mask:
112  attrib = "Soldermask,Top";
113  break;
114 
115  case B_Mask:
116  attrib = "Soldermask,Bot";
117  break;
118 
119  case F_Paste:
120  attrib = "Paste,Top";
121  break;
122 
123  case B_Paste:
124  attrib = "Paste,Bot";
125  break;
126 
127  case Edge_Cuts:
128  // Board outline.
129  // Can be "Profile,NP" (Not Plated: usual) or "Profile,P"
130  // This last is the exception (Plated)
131  attrib = "Profile,NP";
132  break;
133 
134  case Dwgs_User:
135  attrib = "Drawing";
136  break;
137 
138  case Cmts_User:
139  attrib = "Other,Comment";
140  break;
141 
142  case Eco1_User:
143  attrib = "Other,ECO1";
144  break;
145 
146  case Eco2_User:
147  attrib = "Other,ECO2";
148  break;
149 
150  case B_Fab:
151  attrib = "Other,Fab,Bot";
152  break;
153 
154  case F_Fab:
155  attrib = "Other,Fab,Top";
156  break;
157 
158  case B_Cu:
159  attrib.Printf( wxT( "Copper,L%d,Bot" ), aBoard->GetCopperLayerCount() );
160  break;
161 
162  case F_Cu:
163  attrib = "Copper,L1,Top";
164  break;
165 
166  default:
167  if( IsCopperLayer( aLayer ) )
168  attrib.Printf( wxT( "Copper,L%d,Inr" ), aLayer+1 );
169  else
170  attrib.Printf( wxT( "Other,User" ), aLayer+1 );
171  break;
172  }
173 
174  // This code adds a optional parameter: the type of copper layers.
175  // Because it is not used by Pcbnew (it can be used only by external autorouters)
176  // user do not really set this parameter.
177  // Therefore do not add it.
178  // However, this code is left here, for perhaps a future usage.
179 #if 0
180  // Add the signal type of the layer, if relevant
181  if( IsCopperLayer( aLayer ) )
182  {
183  LAYER_T type = aBoard->GetLayerType( ToLAYER_ID( aLayer ) );
184 
185  switch( type )
186  {
187  case LT_SIGNAL:
188  attrib += ",Signal";
189  break;
190  case LT_POWER:
191  attrib += ",Plane";
192  break;
193  case LT_MIXED:
194  attrib += ",Mixed";
195  break;
196  default:
197  break; // do nothing (but avoid a warning for unhandled LAYER_T values from GCC)
198  }
199  }
200 #endif
201 
202  wxString fileFct;
203  fileFct.Printf( "%%TF.FileFunction,%s*%%", GetChars( attrib ) );
204 
205  return fileFct;
206 }
LAYER_T
Enum LAYER_T gives the allowed types of layers, same as Specctra DSN spec.
Definition: class_board.h:66
LAYER_T GetLayerType(PCB_LAYER_ID aLayer) const
Function GetLayerType returns the type of the copper layer given by aLayer.
static const wxChar * GetChars(const wxString &s)
Function GetChars returns a wxChar* to the actual wxChar* data within a wxString, and is helpful for ...
Definition: macros.h:101
int GetCopperLayerCount() const
Function GetCopperLayerCount.
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition: lset.cpp:813

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, GetChars(), BOARD::GetCopperLayerCount(), BOARD::GetLayerType(), IsCopperLayer(), LT_MIXED, LT_POWER, LT_SIGNAL, and ToLAYER_ID().

Referenced by AddGerberX2Attribute().

◆ GetGerberProtelExtension()

const wxString GetGerberProtelExtension ( LAYER_NUM  aLayer)

Function GetGerberProtelExtension.

Returns
the appropriate Gerber file extension for aLayer used by Protel, and still sometimes in use (although the official Gerber Ext is now .gbr)

Definition at line 48 of file pcbplot.cpp.

49 {
50  if( IsCopperLayer( aLayer ) )
51  {
52  if( aLayer == F_Cu )
53  return wxT( "gtl" );
54  else if( aLayer == B_Cu )
55  return wxT( "gbl" );
56  else
57  {
58  return wxString::Format( wxT( "g%d" ), aLayer+1 );
59  }
60  }
61  else
62  {
63  switch( aLayer )
64  {
65  case B_Adhes: return wxT( "gba" );
66  case F_Adhes: return wxT( "gta" );
67 
68  case B_Paste: return wxT( "gbp" );
69  case F_Paste: return wxT( "gtp" );
70 
71  case B_SilkS: return wxT( "gbo" );
72  case F_SilkS: return wxT( "gto" );
73 
74  case B_Mask: return wxT( "gbs" );
75  case F_Mask: return wxT( "gts" );
76 
77  case Edge_Cuts: return wxT( "gm1" );
78 
79  case Dwgs_User:
80  case Cmts_User:
81  case Eco1_User:
82  case Eco2_User:
83  default: return wxT( "gbr" );
84  }
85  }
86 }
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.

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 
)

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 684 of file plot_board_layers.cpp.

686 {
687 
688  BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
689  itemplotter.SetLayerSet( aLayerMask );
690 
691  SHAPE_POLY_SET outlines;
692 
693  for( LSEQ seq = aLayerMask.Seq( plot_seq, arrayDim( plot_seq ) ); seq; ++seq )
694  {
695  PCB_LAYER_ID layer = *seq;
696 
697  outlines.RemoveAllContours();
698  aBoard->ConvertBrdLayerToPolygonalContours( layer, outlines );
699 
700  outlines.Simplify( SHAPE_POLY_SET::PM_FAST );
701 
702  // Plot outlines
703  std::vector< wxPoint > cornerList;
704 
705  // Now we have one or more basic polygons: plot each polygon
706  for( int ii = 0; ii < outlines.OutlineCount(); ii++ )
707  {
708  for(int kk = 0; kk <= outlines.HoleCount (ii); kk++ )
709  {
710  cornerList.clear();
711  const SHAPE_LINE_CHAIN& path = (kk == 0) ? outlines.COutline( ii ) : outlines.CHole( ii, kk - 1 );
712 
713  for( int jj = 0; jj < path.PointCount(); jj++ )
714  cornerList.emplace_back( (wxPoint) path.CPoint( jj ) );
715 
716  // Ensure the polygon is closed
717  if( cornerList[0] != cornerList[cornerList.size() - 1] )
718  cornerList.push_back( cornerList[0] );
719 
720  aPlotter->PlotPoly( cornerList, NO_FILL );
721  }
722  }
723 
724  // Plot pad holes
726  {
727  int smallDrill = (aPlotOpt.GetDrillMarksType() == PCB_PLOT_PARAMS::SMALL_DRILL_SHAPE)
728  ? SMALL_DRILL : INT_MAX;
729 
730  for( auto module : aBoard->Modules() )
731  {
732  for( auto pad : module->Pads() )
733  {
734  wxSize hole = pad->GetDrillSize();
735 
736  if( hole.x == 0 || hole.y == 0 )
737  continue;
738 
739  if( hole.x == hole.y )
740  {
741  hole.x = std::min( smallDrill, hole.x );
742  aPlotter->Circle( pad->GetPosition(), hole.x, NO_FILL );
743  }
744  else
745  {
746  // Note: small drill marks have no significance when applied to slots
747  wxPoint drl_start, drl_end;
748  int width;
749  pad->GetOblongDrillGeometry( drl_start, drl_end, width );
750  aPlotter->ThickSegment( pad->GetPosition() + drl_start,
751  pad->GetPosition() + drl_end, width, SKETCH, NULL );
752  }
753  }
754  }
755  }
756 
757  // Plot vias holes
758  for( auto track : aBoard->Tracks() )
759  {
760  const VIA* via = dyn_cast<const VIA*>( track );
761 
762  if( via && via->IsOnLayer( layer ) ) // via holes can be not through holes
763  {
764  aPlotter->Circle( via->GetPosition(), via->GetDrillValue(), NO_FILL );
765  }
766  }
767  }
768 }
#define SMALL_DRILL
Definition: pcbplot.h:72
int OutlineCount() const
Returns the number of outlines in the set
static const PCB_LAYER_ID plot_seq[]
const SHAPE_LINE_CHAIN & CHole(int aOutline, int aHole) const
virtual void PlotPoly(const std::vector< wxPoint > &aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void *aData=NULL)=0
Function PlotPoly.
int PointCount() const
Function PointCount()
LSEQ Seq(const PCB_LAYER_ID *aWishListSequence, unsigned aCount) const
Function Seq returns an LSEQ from the union of this LSET and a desired sequence.
Definition: lset.cpp:367
const VECTOR2I & CPoint(int aIndex) const
Function CPoint()
PCB_LAYER_ID
A quick note on layer IDs:
int GetDrillValue() const
Function GetDrillValue "calculates" the drill value for vias (m-Drill if > 0, or default drill value ...
MODULES & Modules()
Definition: class_board.h:236
Class SHAPE_POLY_SET.
void ConvertBrdLayerToPolygonalContours(PCB_LAYER_ID aLayer, SHAPE_POLY_SET &aOutlines)
Function ConvertBrdLayerToPolygonalContours Build a set of polygons which are the outlines of copper ...
void Simplify(POLYGON_MODE aFastMode)
Simplifies the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) For aFast...
int HoleCount(int aOutline) const
Returns the number of holes in a given outline
const wxPoint GetPosition() const override
Definition: class_track.h:319
Class LSEQ is a sequence (and therefore also a set) of PCB_LAYER_IDs.
constexpr std::size_t arrayDim(T const (&)[N]) noexcept
Definition: macros.h:108
Class SHAPE_LINE_CHAIN.
virtual void ThickSegment(const wxPoint &start, const wxPoint &end, int width, EDA_DRAW_MODE_T tracemode, void *aData)
Definition: plotter.cpp:476
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
void RemoveAllContours()
Removes all outlines & holes (clears) the polygon set.
bool IsOnLayer(PCB_LAYER_ID aLayer) const override
Function IsOnLayer tests to see if this object is on the given layer.
DrillMarksType GetDrillMarksType() const
TRACKS & Tracks()
Definition: class_board.h:227
virtual void Circle(const wxPoint &pos, int diametre, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)=0
#define min(a, b)
Definition: auxiliary.h:85

References arrayDim(), SHAPE_POLY_SET::CHole(), PLOTTER::Circle(), BOARD::ConvertBrdLayerToPolygonalContours(), SHAPE_POLY_SET::COutline(), SHAPE_LINE_CHAIN::CPoint(), PCB_PLOT_PARAMS::GetDrillMarksType(), VIA::GetDrillValue(), VIA::GetPosition(), SHAPE_POLY_SET::HoleCount(), VIA::IsOnLayer(), min, BOARD::Modules(), PCB_PLOT_PARAMS::NO_DRILL_SHAPE, NO_FILL, 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, SMALL_DRILL, 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 149 of file plot_board_layers.cpp.

151 {
152  PCB_PLOT_PARAMS plotOpt = aPlotOpt;
153  int soldermask_min_thickness = aBoard->GetDesignSettings().m_SolderMaskMinWidth;
154 
155  // Set a default color and the text mode for this layer
156  aPlotter->SetColor( aPlotOpt.GetColor() );
157  aPlotter->SetTextMode( aPlotOpt.GetTextMode() );
158 
159  // Specify that the contents of the "Edges Pcb" layer are to be plotted in addition to the
160  // contents of the currently specified layer.
161  LSET layer_mask( aLayer );
162 
163  if( !aPlotOpt.GetExcludeEdgeLayer() )
164  layer_mask.set( Edge_Cuts );
165 
166  if( IsCopperLayer( aLayer ) )
167  {
168  // Skip NPTH pads on copper layers ( only if hole size == pad size ):
169  // Drill mark will be plotted if drill mark is SMALL_DRILL_SHAPE or FULL_DRILL_SHAPE
170  if( plotOpt.GetFormat() == PLOT_FORMAT_DXF )
171  {
172  plotOpt.SetSkipPlotNPTH_Pads( false );
173  PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
174  }
175  else
176  {
177  plotOpt.SetSkipPlotNPTH_Pads( true );
178  PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
179  }
180  }
181  else
182  {
183  switch( aLayer )
184  {
185  case B_Mask:
186  case F_Mask:
187  plotOpt.SetSkipPlotNPTH_Pads( false );
188  // Disable plot pad holes
190 
191  // Plot solder mask:
192  if( soldermask_min_thickness == 0 )
193  {
194  if( plotOpt.GetFormat() == PLOT_FORMAT_DXF )
195  PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
196  else
197  PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
198  }
199  else
200  PlotSolderMaskLayer( aBoard, aPlotter, layer_mask, plotOpt,
201  soldermask_min_thickness );
202 
203  break;
204 
205  case B_Adhes:
206  case F_Adhes:
207  case B_Paste:
208  case F_Paste:
209  plotOpt.SetSkipPlotNPTH_Pads( false );
210  // Disable plot pad holes
212 
213  if( plotOpt.GetFormat() == PLOT_FORMAT_DXF )
214  PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
215  else
216  PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
217  break;
218 
219  case F_SilkS:
220  case B_SilkS:
221  if( plotOpt.GetFormat() == PLOT_FORMAT_DXF && plotOpt.GetDXFPlotPolygonMode() )
222  // PlotLayerOutlines() is designed only for DXF plotters.
223  // and must not be used for other plot formats
224  PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
225  else
226  PlotSilkScreen( aBoard, aPlotter, layer_mask, plotOpt );
227 
228  // Gerber: Subtract soldermask from silkscreen if enabled
229  if( aPlotter->GetPlotterType() == PLOT_FORMAT_GERBER
230  && plotOpt.GetSubtractMaskFromSilk() )
231  {
232  if( aLayer == F_SilkS )
233  layer_mask = LSET( F_Mask );
234  else
235  layer_mask = LSET( B_Mask );
236 
237  // Create the mask to subtract by creating a negative layer polarity
238  aPlotter->SetLayerPolarity( false );
239 
240  // Disable plot pad holes
242 
243  // Plot the mask
244  PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
245  }
246  break;
247 
248  // These layers are plotted like silk screen layers.
249  // Mainly, pads on these layers are not filled.
250  // This is not necessary the best choice.
251  case Dwgs_User:
252  case Cmts_User:
253  case Eco1_User:
254  case Eco2_User:
255  case Edge_Cuts:
256  case Margin:
257  case F_CrtYd:
258  case B_CrtYd:
259  case F_Fab:
260  case B_Fab:
261  plotOpt.SetSkipPlotNPTH_Pads( false );
263 
264  if( plotOpt.GetFormat() == PLOT_FORMAT_DXF && plotOpt.GetDXFPlotPolygonMode() )
265  // PlotLayerOutlines() is designed only for DXF plotters.
266  // and must not be used for other plot formats
267  PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
268  else
269  PlotSilkScreen( aBoard, aPlotter, layer_mask, plotOpt );
270  break;
271 
272  default:
273  plotOpt.SetSkipPlotNPTH_Pads( false );
275 
276  if( plotOpt.GetFormat() == PLOT_FORMAT_DXF && plotOpt.GetDXFPlotPolygonMode() )
277  // PlotLayerOutlines() is designed only for DXF plotters.
278  // and must not be used for other plot formats
279  PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
280  else
281  PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
282  break;
283  }
284  }
285 }
bool GetDXFPlotPolygonMode() const
virtual void SetColor(COLOR4D color)=0
virtual void SetLayerPolarity(bool aPositive)
Function SetLayerPolarity sets current Gerber layer polarity to positive or negative by writing %LPD*...
Definition: plotter.h:433
void PlotStandardLayer(BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt)
Function PlotStandardLayer plot copper or technical layers.
PlotFormat GetFormat() const
void PlotSilkScreen(BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt)
Function PlotSilkScreen plot silkscreen layers which have specific requirements, mainly for pads.
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:540
void SetDrillMarksType(DrillMarksType aVal)
static void PlotSolderMaskLayer(BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt, int aMinThickness)
void PlotLayerOutlines(BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt)
Function PlotLayerOutlines plot copper outline of a copper layer.
Class LSET is a set of PCB_LAYER_IDs.
virtual void SetTextMode(PlotTextMode mode)
Change the current text mode.
Definition: plotter.h:442
COLOR4D GetColor() const
void SetSkipPlotNPTH_Pads(bool aSkip)
Class PCB_PLOT_PARAMS handles plot parameters and options when plotting/printing a board.
bool GetSubtractMaskFromSilk() const
virtual PlotFormat GetPlotterType() const =0
Returns the effective plot engine in use.
PlotTextMode GetTextMode() const
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
bool GetExcludeEdgeLayer() const
int m_SolderMaskMinWidth
Solder mask min width.

References B_Adhes, B_CrtYd, B_Fab, B_Mask, B_Paste, B_SilkS, Cmts_User, Dwgs_User, Eco1_User, Eco2_User, Edge_Cuts, F_Adhes, F_CrtYd, F_Fab, F_Mask, F_Paste, F_SilkS, PCB_PLOT_PARAMS::GetColor(), 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, PLOT_FORMAT_DXF, PLOT_FORMAT_GERBER, PlotLayerOutlines(), PlotSilkScreen(), 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().

◆ PlotSilkScreen()

void PlotSilkScreen ( BOARD aBoard,
PLOTTER aPlotter,
LSET  aLayerMask,
const PCB_PLOT_PARAMS aPlotOpt 
)

Function PlotSilkScreen plot silkscreen layers which have specific requirements, mainly for pads.

Should not be used for other layers

Parameters
aBoard= the board to plot
aPlotter= the plotter to use
aLayerMask= the mask to define the layers to plot (silkscreen Front and/or Back)
aPlotOpt= the plot options (files, sketch). Has meaning for some formats only

Definition at line 67 of file plot_board_layers.cpp.

69 {
70  BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
71  itemplotter.SetLayerSet( aLayerMask );
72 
73  // Plot edge layer and graphic items
74  itemplotter.PlotBoardGraphicItems();
75 
76  // Plot footprint outlines :
77  itemplotter.Plot_Edges_Modules();
78 
79  // Plot pads (creates pads outlines, for pads on silkscreen layers)
80  LSET layersmask_plotpads = aLayerMask;
81 
82  // Calculate the mask layers of allowed layers for pads
83 
84  if( !aPlotOpt.GetPlotPadsOnSilkLayer() ) // Do not plot pads on silk screen layers
85  layersmask_plotpads.set( B_SilkS, false ).set( F_SilkS, false );
86 
87  if( layersmask_plotpads.any() )
88  {
89  for( auto Module : aBoard->Modules() )
90  {
91  aPlotter->StartBlock( NULL );
92 
93  for( auto pad : Module->Pads() )
94  {
95  // See if the pad is on this layer
96  LSET masklayer = pad->GetLayerSet();
97  if( !( masklayer & layersmask_plotpads ).any() )
98  continue;
99 
101 
102  if( layersmask_plotpads[B_SilkS] )
103  color = aBoard->Colors().GetLayerColor( B_SilkS );
104 
105  if( layersmask_plotpads[F_SilkS] )
106  color = ( color == COLOR4D::BLACK) ? aBoard->Colors().GetLayerColor( F_SilkS ) : color;
107 
108  itemplotter.PlotPad( pad, color, SKETCH );
109  }
110 
111  aPlotter->EndBlock( NULL );
112  }
113  }
114 
115  // Plot footprints fields (ref, value ...)
116  for( auto module : aBoard->Modules() )
117  {
118  if( ! itemplotter.PlotAllTextsModule( module ) )
119  {
120  wxLogMessage( _( "Your BOARD has a bad layer number for footprint %s" ),
121  module->GetReference() );
122  }
123  }
124 
125  // Plot filled areas
126  aPlotter->StartBlock( NULL );
127 
128  // Plot all zones together so we don't end up with divots where zones touch each other.
129  ZONE_CONTAINER* zone = nullptr;
130  SHAPE_POLY_SET aggregateArea;
131 
132  for( ZONE_CONTAINER* candidate : aBoard->Zones() )
133  {
134  if( !aLayerMask[ candidate->GetLayer() ] )
135  continue;
136 
137  if( !zone )
138  zone = candidate;
139 
140  aggregateArea.BooleanAdd( candidate->GetFilledPolysList(), SHAPE_POLY_SET::PM_FAST );
141  }
142 
144  itemplotter.PlotFilledAreas( zone, aggregateArea );
145 
146  aPlotter->EndBlock( NULL );
147 }
Class ZONE_CONTAINER handles a list of polygons defining a copper zone.
Definition: class_zone.h:57
virtual void EndBlock(void *aData)
calling this function allows one to define the end of a group of drawing items for instance in SVG or...
Definition: plotter.h:468
void BooleanAdd(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Performs boolean polyset union For aFastMode meaning, see function booleanOp
int color
Definition: DXF_plotter.cpp:62
virtual void StartBlock(void *aData)
calling this function allows one to define the beginning of a group of drawing items,...
Definition: plotter.h:459
COLOR4D GetLayerColor(LAYER_NUM aLayer) const
Function GetLayerColor.
Class LSET is a set of PCB_LAYER_IDs.
MODULES & Modules()
Definition: class_board.h:236
Class SHAPE_POLY_SET.
#define _(s)
void Fracture(POLYGON_MODE aFastMode)
Converts a set of polygons with holes to a singe outline with "slits"/"fractures" connecting the oute...
const COLORS_DESIGN_SETTINGS & Colors() const
Function GetColorSettings.
Definition: class_board.h:573
ZONE_CONTAINERS & Zones()
Definition: class_board.h:250
bool GetPlotPadsOnSilkLayer() const
Definition: colors.h:45
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39

References _, B_SilkS, BLACK, SHAPE_POLY_SET::BooleanAdd(), color, BOARD::Colors(), PLOTTER::EndBlock(), F_SilkS, SHAPE_POLY_SET::Fracture(), COLORS_DESIGN_SETTINGS::GetLayerColor(), PCB_PLOT_PARAMS::GetPlotPadsOnSilkLayer(), BOARD::Modules(), BRDITEMS_PLOTTER::Plot_Edges_Modules(), BRDITEMS_PLOTTER::PlotAllTextsModule(), BRDITEMS_PLOTTER::PlotBoardGraphicItems(), BRDITEMS_PLOTTER::PlotFilledAreas(), BRDITEMS_PLOTTER::PlotPad(), SHAPE_POLY_SET::PM_FAST, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE, BRDITEMS_PLOTTER::SetLayerSet(), SKETCH, PLOTTER::StartBlock(), 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

Definition at line 291 of file plot_board_layers.cpp.

293 {
294  BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
295 
296  itemplotter.SetLayerSet( aLayerMask );
297 
298  EDA_DRAW_MODE_T plotMode = aPlotOpt.GetPlotMode();
299 
300  // Plot edge layer and graphic items
301  itemplotter.PlotBoardGraphicItems();
302 
303  // Draw footprint texts:
304  for( auto module : aBoard->Modules() )
305  {
306  if( ! itemplotter.PlotAllTextsModule( module ) )
307  {
308  wxLogMessage( _( "Your BOARD has a bad layer number for footprint %s" ),
309  module->GetReference() );
310  }
311  }
312 
313  // Draw footprint other graphic items:
314  for( auto module : aBoard->Modules() )
315  {
316  for( auto item : module->GraphicalItems() )
317  {
318  if( item->Type() == PCB_MODULE_EDGE_T && aLayerMask[ item->GetLayer() ] )
319  itemplotter.Plot_1_EdgeModule( (EDGE_MODULE*) item );
320  }
321  }
322 
323  // Plot footprint pads
324  for( auto module : aBoard->Modules() )
325  {
326  aPlotter->StartBlock( NULL );
327 
328  for( auto pad : module->Pads() )
329  {
330  if( (pad->GetLayerSet() & aLayerMask) == 0 )
331  continue;
332 
333  wxSize margin;
334  double width_adj = 0;
335 
336  if( ( aLayerMask & LSET::AllCuMask() ).any() )
337  width_adj = itemplotter.getFineWidthAdj();
338 
339  static const LSET speed( 4, B_Mask, F_Mask, B_Paste, F_Paste );
340 
341  LSET anded = ( speed & aLayerMask );
342 
343  if( anded == LSET( F_Mask ) || anded == LSET( B_Mask ) )
344  {
345  margin.x = margin.y = pad->GetSolderMaskMargin();
346  }
347  else if( anded == LSET( F_Paste ) || anded == LSET( B_Paste ) )
348  {
349  margin = pad->GetSolderPasteMargin();
350  }
351 
352  // Now offset the pad size by margin + width_adj
353  // this is easy for most shapes, but not for a trapezoid or a custom shape
354  wxSize padPlotsSize;
355  wxSize extraSize = margin * 2;
356  extraSize.x += width_adj;
357  extraSize.y += width_adj;
358  wxSize deltaSize = pad->GetDelta(); // has meaning only for trapezoidal pads
359 
360  if( pad->GetShape() == PAD_SHAPE_TRAPEZOID )
361  { // The easy way is to use BuildPadPolygon to calculate
362  // size and delta of the trapezoidal pad after offseting:
363  wxPoint coord[4];
364  pad->BuildPadPolygon( coord, extraSize/2, 0.0 );
365  // Calculate the size and delta from polygon corners coordinates:
366  // coord[0] is the lower left
367  // coord[1] is the upper left
368  // coord[2] is the upper right
369  // coord[3] is the lower right
370 
371  // the size is the distance between middle of segments
372  // (left/right or top/bottom)
373  // size X is the dist between left and right middle points:
374  padPlotsSize.x = ( ( -coord[0].x + coord[3].x ) // the lower segment X length
375  + ( -coord[1].x + coord[2].x ) ) // the upper segment X length
376  / 2; // the Y size is the half sum
377  // size Y is the dist between top and bottom middle points:
378  padPlotsSize.y = ( ( coord[0].y - coord[1].y ) // the left segment Y lenght
379  + ( coord[3].y - coord[2].y ) ) // the right segment Y lenght
380  / 2; // the Y size is the half sum
381 
382  // calculate the delta ( difference of lenght between 2 opposite edges )
383  // The delta.x is the delta along the X axis, therefore the delta of Y lenghts
384  wxSize delta;
385 
386  if( coord[0].y != coord[3].y )
387  delta.x = coord[0].y - coord[3].y;
388  else
389  delta.y = coord[1].x - coord[0].x;
390 
391  pad->SetDelta( delta );
392  }
393  else
394  padPlotsSize = pad->GetSize() + extraSize;
395 
396  // Don't draw a null size item :
397  if( padPlotsSize.x <= 0 || padPlotsSize.y <= 0 )
398  continue;
399 
401 
402  if( pad->GetLayerSet()[B_Cu] )
403  color = aBoard->Colors().GetItemColor( LAYER_PAD_BK );
404 
405  if( pad->GetLayerSet()[F_Cu] )
406  color = color.LegacyMix( aBoard->Colors().GetItemColor( LAYER_PAD_FR ) );
407 
408  // Temporary set the pad size to the required plot size:
409  wxSize tmppadsize = pad->GetSize();
410 
411  switch( pad->GetShape() )
412  {
413  case PAD_SHAPE_CIRCLE:
414  case PAD_SHAPE_OVAL:
415  pad->SetSize( padPlotsSize );
416 
417  if( aPlotOpt.GetSkipPlotNPTH_Pads() &&
419  ( pad->GetSize() == pad->GetDrillSize() ) &&
420  ( pad->GetAttribute() == PAD_ATTRIB_HOLE_NOT_PLATED ) )
421  break;
422 
423  itemplotter.PlotPad( pad, color, plotMode );
424  break;
425 
426  case PAD_SHAPE_TRAPEZOID:
427  case PAD_SHAPE_RECT:
428  case PAD_SHAPE_ROUNDRECT:
430  pad->SetSize( padPlotsSize );
431  itemplotter.PlotPad( pad, color, plotMode );
432  break;
433 
434  case PAD_SHAPE_CUSTOM:
435  {
436  // inflate/deflate a custom shape is a bit complex.
437  // so build a similar pad shape, and inflate/deflate the polygonal shape
438  D_PAD dummy( *pad );
439  SHAPE_POLY_SET shape;
440  pad->MergePrimitivesAsPolygon( &shape );
441  // Shape polygon can have holes so use InflateWithLinkedHoles(), not Inflate()
442  // which can create bad shapes if margin.x is < 0
443  int maxError = aBoard->GetDesignSettings().m_MaxError;
444  int numSegs = std::max( GetArcToSegmentCount( margin.x, maxError, 360.0 ), 6 );
445  shape.InflateWithLinkedHoles( margin.x, numSegs, SHAPE_POLY_SET::PM_FAST );
446  dummy.DeletePrimitivesList();
447  dummy.AddPrimitive( shape, 0 );
448  dummy.MergePrimitivesAsPolygon();
449 
450  // Be sure the anchor pad is not bigger than the deflated shape because this
451  // anchor will be added to the pad shape when plotting the pad. So now the
452  // polygonal shape is built, we can clamp the anchor size
453  if( margin.x < 0 ) // we expect margin.x = margin.y for custom pads
454  dummy.SetSize( padPlotsSize );
455 
456  itemplotter.PlotPad( &dummy, color, plotMode );
457  }
458  break;
459  }
460 
461  pad->SetSize( tmppadsize ); // Restore the pad size
462  pad->SetDelta( deltaSize );
463  }
464 
465  aPlotter->EndBlock( NULL );
466  }
467 
468  // Plot vias on copper layers, and if aPlotOpt.GetPlotViaOnMaskLayer() is true,
469  // plot them on solder mask
470 
471  GBR_METADATA gbr_metadata;
472 
473  bool isOnCopperLayer = ( aLayerMask & LSET::AllCuMask() ).any();
474 
475  if( isOnCopperLayer )
476  {
479  }
480 
481  aPlotter->StartBlock( NULL );
482 
483  for( auto track : aBoard->Tracks() )
484  {
485  const VIA* Via = dyn_cast<const VIA*>( track );
486 
487  if( !Via )
488  continue;
489 
490  // vias are not plotted if not on selected layer, but if layer is SOLDERMASK_LAYER_BACK
491  // or SOLDERMASK_LAYER_FRONT, vias are drawn only if they are on the corresponding
492  // external copper layer
493  LSET via_mask_layer = Via->GetLayerSet();
494 
495  if( aPlotOpt.GetPlotViaOnMaskLayer() )
496  {
497  if( via_mask_layer[B_Cu] )
498  via_mask_layer.set( B_Mask );
499 
500  if( via_mask_layer[F_Cu] )
501  via_mask_layer.set( F_Mask );
502  }
503 
504  if( !( via_mask_layer & aLayerMask ).any() )
505  continue;
506 
507  int via_margin = 0;
508  double width_adj = 0;
509 
510  // If the current layer is a solder mask, use the global mask clearance for vias
511  if( aLayerMask[B_Mask] || aLayerMask[F_Mask] )
512  via_margin = aBoard->GetDesignSettings().m_SolderMaskMargin;
513 
514  if( ( aLayerMask & LSET::AllCuMask() ).any() )
515  width_adj = itemplotter.getFineWidthAdj();
516 
517  int diameter = Via->GetWidth() + 2 * via_margin + width_adj;
518 
519  // Don't draw a null size item :
520  if( diameter <= 0 )
521  continue;
522 
523  // Some vias can be not connected (no net).
524  // Set the m_NotInNet for these vias to force a empty net name in gerber file
525  gbr_metadata.m_NetlistMetadata.m_NotInNet = Via->GetNetname().IsEmpty();
526 
527  gbr_metadata.SetNetName( Via->GetNetname() );
528 
529  COLOR4D color = aBoard->Colors().GetItemColor( LAYER_VIAS + Via->GetViaType() );
530  // Set plot color (change WHITE to LIGHTGRAY because the white items are not seen on a
531  // white paper or screen
532  aPlotter->SetColor( color != WHITE ? color : LIGHTGRAY);
533  aPlotter->FlashPadCircle( Via->GetStart(), diameter, plotMode, &gbr_metadata );
534  }
535 
536  aPlotter->EndBlock( NULL );
537  aPlotter->StartBlock( NULL );
539 
540  // Plot tracks (not vias) :
541  for( auto track : aBoard->Tracks() )
542  {
543  if( track->Type() == PCB_VIA_T )
544  continue;
545 
546  if( !aLayerMask[track->GetLayer()] )
547  continue;
548 
549  // Some track segments can be not connected (no net).
550  // Set the m_NotInNet for these segments to force a empty net name in gerber file
551  gbr_metadata.m_NetlistMetadata.m_NotInNet = track->GetNetname().IsEmpty();
552 
553  gbr_metadata.SetNetName( track->GetNetname() );
554  int width = track->GetWidth() + itemplotter.getFineWidthAdj();
555  aPlotter->SetColor( itemplotter.getColor( track->GetLayer() ) );
556  aPlotter->ThickSegment( track->GetStart(), track->GetEnd(), width, plotMode, &gbr_metadata );
557  }
558 
559  aPlotter->EndBlock( NULL );
560 
561  // Plot filled ares
562  aPlotter->StartBlock( NULL );
563 
564  // Plot all zones of the same layer & net together so we don't end up with divots where
565  // zones touch each other.
566  std::set<ZONE_CONTAINER*> plotted;
567 
568  for( ZONE_CONTAINER* zone : aBoard->Zones() )
569  {
570  if( !aLayerMask[ zone->GetLayer() ] || plotted.count( zone ) )
571  continue;
572 
573  plotted.insert( zone );
574 
575  SHAPE_POLY_SET aggregateArea = zone->GetFilledPolysList();
576  bool needFracture = false; // If 2 or more filled areas are combined, resulting
577  // aggregateArea will be simplified and fractured
578  // (Long calculation time)
579 
580  for( ZONE_CONTAINER* candidate : aBoard->Zones() )
581  {
582  if( !aLayerMask[ candidate->GetLayer() ] || plotted.count( candidate ) )
583  continue;
584 
585  if( candidate->GetNetCode() != zone->GetNetCode() )
586  continue;
587 
588  // Merging zones of the same net can be done only for areas
589  // having compatible settings for drawings:
590  // use or not outline thickness, and if using outline thickness,
591  // having the same thickness
592  // because after merging only one outline thickness is used
593  if( candidate->GetFilledPolysUseThickness() != zone->GetFilledPolysUseThickness() )
594  // Should not happens, because usually the same option is used for filling
595  continue;
596 
597  if( zone->GetFilledPolysUseThickness() &&
598  ( candidate->GetMinThickness() != zone->GetMinThickness() ) )
599  continue;
600 
601  plotted.insert( candidate );
602  aggregateArea.Append( candidate->GetFilledPolysList() );
603  needFracture = true;
604  }
605 
606  if( needFracture )
607  {
610  }
611 
612  itemplotter.PlotFilledAreas( zone, aggregateArea );
613  }
614  aPlotter->EndBlock( NULL );
615 
616  // Adding drill marks, if required and if the plotter is able to plot them:
618  itemplotter.PlotDrillMarks();
619 }
static LSET AllCuMask(int aCuLayerCount=MAX_CU_LAYERS)
Function AllCuMask returns a mask holding the requested number of Cu PCB_LAYER_IDs.
Definition: lset.cpp:676
int m_SolderMaskMargin
Solder mask margin.
Class ZONE_CONTAINER handles a list of polygons defining a copper zone.
Definition: class_zone.h:57
virtual void EndBlock(void *aData)
calling this function allows one to define the end of a group of drawing items for instance in SVG or...
Definition: plotter.h:468
int GetArcToSegmentCount(int aRadius, int aErrorMax, double aArcAngleDegree)
virtual LSET GetLayerSet() const override
Function GetLayerSet returns a "layer mask", which is a bitmap of all layers on which the TRACK segme...
like PAD_STANDARD, but not plated mechanical use only, no connection allowed
Definition: pad_shapes.h:66
virtual void SetColor(COLOR4D color)=0
const wxPoint & GetStart() const
Definition: class_track.h:109
void SetNetAttribType(int aNetAttribType)
Definition: gbr_metadata.h:155
int color
Definition: DXF_plotter.cpp:62
virtual void StartBlock(void *aData)
calling this function allows one to define the beginning of a group of drawing items,...
Definition: plotter.h:459
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:540
class EDGE_MODULE, a footprint edge
Definition: typeinfo.h:94
COLOR4D GetItemColor(int aItemIdx) const
Function GetItemColor.
virtual void FlashPadCircle(const wxPoint &aPadPos, int aDiameter, EDA_DRAW_MODE_T aTraceMode, void *aData)=0
virtual function FlashPadCircle
Class LSET is a set of PCB_LAYER_IDs.
MODULES & Modules()
Definition: class_board.h:236
Class SHAPE_POLY_SET.
EDA_DRAW_MODE_T
Definition: eda_text.h:59
VIATYPE_T GetViaType() const
Definition: class_track.h:346
bool GetSkipPlotNPTH_Pads() const
void Simplify(POLYGON_MODE aFastMode)
Simplifies the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) For aFast...
const wxString & GetNetname() const
Function GetNetname.
#define _(s)
void Fracture(POLYGON_MODE aFastMode)
Converts a set of polygons with holes to a singe outline with "slits"/"fractures" connecting the oute...
aperture used for connected items like tracks (not vias)
Definition: gbr_metadata.h:84
void SetNetName(const wxString &aNetname)
Definition: gbr_metadata.h:165
const COLORS_DESIGN_SETTINGS & Colors() const
Function GetColorSettings.
Definition: class_board.h:573
ZONE_CONTAINERS & Zones()
Definition: class_board.h:250
bool GetPlotViaOnMaskLayer() const
smd pads, front layer
int GetWidth() const
Definition: class_track.h:103
static LIB_PART * dummy()
Used to draw a dummy shape when a LIB_PART is not found in library.
#define max(a, b)
Definition: auxiliary.h:86
virtual void ThickSegment(const wxPoint &start, const wxPoint &end, int width, EDA_DRAW_MODE_T tracemode, void *aData)
Definition: plotter.cpp:476
void InflateWithLinkedHoles(int aFactor, int aCircleSegmentsCount, POLYGON_MODE aFastMode)
Performs outline inflation/deflation, using round corners.
Definition: colors.h:49
void SetApertureAttrib(GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB aApertAttribute)
Definition: gbr_metadata.h:145
bool m_NotInNet
true if a pad of a footprint cannot be connected (for instance a mechanical NPTH, ot a not named pad)...
class VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
GBR_NETLIST_METADATA m_NetlistMetadata
a item to handle object attribute:
Definition: gbr_metadata.h:184
Definition: colors.h:45
DrillMarksType GetDrillMarksType() const
print info associated to a net (TO.N attribute)
TRACKS & Tracks()
Definition: class_board.h:227
EDA_DRAW_MODE_T GetPlotMode() const
int Append(int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
Appends a vertex at the end of the given outline/hole (default: the last outline)
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39

References _, LSET::AllCuMask(), SHAPE_POLY_SET::Append(), B_Cu, B_Mask, B_Paste, BLACK, color, BOARD::Colors(), dummy(), PLOTTER::EndBlock(), F_Cu, F_Mask, F_Paste, PLOTTER::FlashPadCircle(), SHAPE_POLY_SET::Fracture(), GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CONDUCTOR, GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_VIAPAD, GBR_NETLIST_METADATA::GBR_NETINFO_NET, GetArcToSegmentCount(), BRDITEMS_PLOTTER::getColor(), BOARD::GetDesignSettings(), PCB_PLOT_PARAMS::GetDrillMarksType(), BRDITEMS_PLOTTER::getFineWidthAdj(), COLORS_DESIGN_SETTINGS::GetItemColor(), VIA::GetLayerSet(), BOARD_CONNECTED_ITEM::GetNetname(), PCB_PLOT_PARAMS::GetPlotMode(), PCB_PLOT_PARAMS::GetPlotViaOnMaskLayer(), PCB_PLOT_PARAMS::GetSkipPlotNPTH_Pads(), TRACK::GetStart(), VIA::GetViaType(), TRACK::GetWidth(), SHAPE_POLY_SET::InflateWithLinkedHoles(), 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, max, BOARD::Modules(), PCB_PLOT_PARAMS::NO_DRILL_SHAPE, PAD_ATTRIB_HOLE_NOT_PLATED, PAD_SHAPE_CHAMFERED_RECT, PAD_SHAPE_CIRCLE, PAD_SHAPE_CUSTOM, PAD_SHAPE_OVAL, PAD_SHAPE_RECT, PAD_SHAPE_ROUNDRECT, PAD_SHAPE_TRAPEZOID, PCB_MODULE_EDGE_T, PCB_VIA_T, BRDITEMS_PLOTTER::Plot_1_EdgeModule(), BRDITEMS_PLOTTER::PlotAllTextsModule(), BRDITEMS_PLOTTER::PlotBoardGraphicItems(), BRDITEMS_PLOTTER::PlotDrillMarks(), BRDITEMS_PLOTTER::PlotFilledAreas(), BRDITEMS_PLOTTER::PlotPad(), SHAPE_POLY_SET::PM_FAST, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE, GBR_METADATA::SetApertureAttrib(), PLOTTER::SetColor(), BRDITEMS_PLOTTER::SetLayerSet(), GBR_METADATA::SetNetAttribType(), GBR_METADATA::SetNetName(), SHAPE_POLY_SET::Simplify(), PLOTTER::StartBlock(), PLOTTER::ThickSegment(), BOARD::Tracks(), WHITE, and BOARD::Zones().

Referenced by PlotOneBoardLayer().

◆ 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 1034 of file plot_board_layers.cpp.

1036 {
1037  // Create the plotter driver and set the few plotter specific options
1038  PLOTTER* plotter = NULL;
1039 
1040  switch( aPlotOpts->GetFormat() )
1041  {
1042  case PLOT_FORMAT_DXF:
1043  DXF_PLOTTER* DXF_plotter;
1044  DXF_plotter = new DXF_PLOTTER();
1045  DXF_plotter->SetUnits(
1046  static_cast<DXF_PLOTTER::DXF_UNITS>( aPlotOpts->GetDXFPlotUnits() ) );
1047 
1048  plotter = DXF_plotter;
1049  break;
1050 
1051  case PLOT_FORMAT_POST:
1052  PS_PLOTTER* PS_plotter;
1053  PS_plotter = new PS_PLOTTER();
1054  PS_plotter->SetScaleAdjust( aPlotOpts->GetFineScaleAdjustX(),
1055  aPlotOpts->GetFineScaleAdjustY() );
1056  plotter = PS_plotter;
1057  break;
1058 
1059  case PLOT_FORMAT_PDF:
1060  plotter = new PDF_PLOTTER();
1061  break;
1062 
1063  case PLOT_FORMAT_HPGL:
1064  HPGL_PLOTTER* HPGL_plotter;
1065  HPGL_plotter = new HPGL_PLOTTER();
1066 
1067  // HPGL options are a little more convoluted to compute, so they get their own function
1068  ConfigureHPGLPenSizes( HPGL_plotter, aPlotOpts );
1069  plotter = HPGL_plotter;
1070  break;
1071 
1072  case PLOT_FORMAT_GERBER:
1073  plotter = new GERBER_PLOTTER();
1074  break;
1075 
1076  case PLOT_FORMAT_SVG:
1077  plotter = new SVG_PLOTTER();
1078  break;
1079 
1080  default:
1081  wxASSERT( false );
1082  return NULL;
1083  }
1084 
1085  // Compute the viewport and set the other options
1086 
1087  // page layout is not mirrored, so temporarily change mirror option for the page layout
1088  PCB_PLOT_PARAMS plotOpts = *aPlotOpts;
1089 
1090  if( plotOpts.GetPlotFrameRef() && plotOpts.GetMirror() )
1091  plotOpts.SetMirror( false );
1092 
1093  initializePlotter( plotter, aBoard, &plotOpts );
1094 
1095  if( plotter->OpenFile( aFullFileName ) )
1096  {
1097  plotter->ClearHeaderLinesList();
1098 
1099  // For the Gerber "file function" attribute, set the layer number
1100  if( plotter->GetPlotterType() == PLOT_FORMAT_GERBER )
1101  {
1102  bool useX2mode = plotOpts.GetUseGerberX2format();
1103 
1104  GERBER_PLOTTER* gbrplotter = static_cast <GERBER_PLOTTER*> ( plotter );
1105  gbrplotter->UseX2format( useX2mode );
1106  gbrplotter->UseX2NetAttributes( plotOpts.GetIncludeGerberNetlistInfo() );
1107 
1108  // Attributes can be added using X2 format or as comment (X1 format)
1109  AddGerberX2Attribute( plotter, aBoard, aLayer, not useX2mode );
1110  }
1111 
1112  plotter->StartPlot();
1113 
1114  // Plot the frame reference if requested
1115  if( aPlotOpts->GetPlotFrameRef() )
1116  {
1117  PlotWorkSheet( plotter, aBoard->GetTitleBlock(), aBoard->GetPageSettings(),
1118  1, 1, aSheetDesc, aBoard->GetFileName() );
1119 
1120  if( aPlotOpts->GetMirror() )
1121  initializePlotter( plotter, aBoard, aPlotOpts );
1122  }
1123 
1124  // When plotting a negative board: draw a black rectangle (background for plot board
1125  // in white) and switch the current color to WHITE; note the color inversion is actually
1126  // done in the driver (if supported)
1127  if( aPlotOpts->GetNegative() )
1128  {
1129  EDA_RECT bbox = aBoard->ComputeBoundingBox();
1130  FillNegativeKnockout( plotter, bbox );
1131  }
1132 
1133  return plotter;
1134  }
1135 
1136  delete plotter;
1137  return NULL;
1138 }
const PAGE_INFO & GetPageSettings() const
Definition: class_board.h:555
void UseX2NetAttributes(bool aEnable)
Definition: plotter.h:1254
bool GetPlotFrameRef() const
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...
virtual bool StartPlot()=0
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.
virtual bool OpenFile(const wxString &aFullFilename)
Open or create the plot file aFullFilename.
Definition: plotter.cpp:80
void SetScaleAdjust(double scaleX, double scaleY)
Set the 'fine' scaling for the postscript engine.
Definition: plotter.h:700
PlotFormat GetFormat() const
void SetMirror(bool aFlag)
void UseX2format(bool aEnable)
Definition: plotter.h:1253
void AddGerberX2Attribute(PLOTTER *aPlotter, const BOARD *aBoard, LAYER_NUM aLayer, bool aUseX1CompatibilityMode)
Calculates some X2 attributes, as defined in the Gerber file format specification and add them to the...
Definition: pcbplot.cpp:352
void SetUnits(DXF_UNITS aUnit)
Set the units to use for plotting the DXF file.
const wxString & GetFileName() const
Definition: class_board.h:225
bool GetUseGerberX2format() const
bool GetMirror() const
void PlotWorkSheet(PLOTTER *plotter, const TITLE_BLOCK &aTitleBlock, const PAGE_INFO &aPageInfo, int aSheetNumber, int aNumberOfSheets, const wxString &aSheetDesc, const wxString &aFilename, const COLOR4D aColor)
bool GetIncludeGerberNetlistInfo() const
static void ConfigureHPGLPenSizes(HPGL_PLOTTER *aPlotter, PCB_PLOT_PARAMS *aPlotOpts)
Calculate the effective size of HPGL pens and set them in the plotter object.
Class PCB_PLOT_PARAMS handles plot parameters and options when plotting/printing a board.
double GetFineScaleAdjustX() const
Base plotter engine class.
Definition: plotter.h:97
TITLE_BLOCK & GetTitleBlock()
Definition: class_board.h:561
virtual PlotFormat GetPlotterType() const =0
Returns the effective plot engine in use.
Class EDA_RECT handles the component boundary box.
Definition: eda_rect.h:44
void ClearHeaderLinesList()
Function ClearHeaderLinesList remove all lines from the list of free lines to print at the beginning ...
Definition: plotter.h:185
EDA_RECT ComputeBoundingBox(bool aBoardEdgesOnly=false) const
Function ComputeBoundingBox calculates the bounding box containing all board items (or board edge seg...
double GetFineScaleAdjustY() const
bool GetNegative() const
DXF_PLOTTER::DXF_UNITS GetDXFPlotUnits() const

References AddGerberX2Attribute(), PLOTTER::ClearHeaderLinesList(), BOARD::ComputeBoundingBox(), ConfigureHPGLPenSizes(), FillNegativeKnockout(), 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::GetTitleBlock(), PCB_PLOT_PARAMS::GetUseGerberX2format(), initializePlotter(), PLOTTER::OpenFile(), PLOT_FORMAT_DXF, PLOT_FORMAT_GERBER, PLOT_FORMAT_HPGL, PLOT_FORMAT_PDF, PLOT_FORMAT_POST, PLOT_FORMAT_SVG, PlotWorkSheet(), PCB_PLOT_PARAMS::SetMirror(), PSLIKE_PLOTTER::SetScaleAdjust(), DXF_PLOTTER::SetUnits(), PLOTTER::StartPlot(), GERBER_PLOTTER::UseX2format(), and GERBER_PLOTTER::UseX2NetAttributes().

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