KiCad PCB EDA Suite
plot_board_layers.cpp File Reference

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

#include <fctsys.h>
#include <common.h>
#include <plotter.h>
#include <base_struct.h>
#include <draw_graphic_text.h>
#include <trigo.h>
#include <pcb_base_frame.h>
#include <macros.h>
#include <class_board.h>
#include <class_module.h>
#include <class_track.h>
#include <class_edge_mod.h>
#include <class_pcb_text.h>
#include <class_zone.h>
#include <class_drawsegment.h>
#include <class_pcb_target.h>
#include <class_dimension.h>
#include <pcbnew.h>
#include <pcbplot.h>
#include <plot_auxiliary_data.h>

Go to the source code of this file.

Functions

static void PlotSolderMaskLayer (BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt, int aMinThickness)
 
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 PlotOneBoardLayer (BOARD *aBoard, PLOTTER *aPlotter, PCB_LAYER_ID aLayer, const PCB_PLOT_PARAMS &aPlotOpt)
 Function PlotOneBoardLayer main function to plot one copper or technical layer. More...
 
void PlotStandardLayer (BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt)
 Function PlotStandardLayer plot copper or technical layers. More...
 
void PlotLayerOutlines (BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt)
 Function PlotLayerOutlines plot copper outline of a copper layer. More...
 
static void initializePlotter (PLOTTER *aPlotter, BOARD *aBoard, PCB_PLOT_PARAMS *aPlotOpts)
 Set up most plot options for plotting a board (especially the viewport) Important thing: page size is the 'drawing' page size, paper size is the physical page size. More...
 
static void FillNegativeKnockout (PLOTTER *aPlotter, const EDA_RECT &aBbbox)
 Prefill in black an area a little bigger than the board to prepare for the negative plot. More...
 
static void ConfigureHPGLPenSizes (HPGL_PLOTTER *aPlotter, PCB_PLOT_PARAMS *aPlotOpts)
 Calculate the effective size of HPGL pens and set them in the plotter object. More...
 
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...
 

Variables

static const PCB_LAYER_ID plot_seq []
 

Detailed Description

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

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

Definition in file plot_board_layers.cpp.

Function Documentation

static void ConfigureHPGLPenSizes ( HPGL_PLOTTER aPlotter,
PCB_PLOT_PARAMS aPlotOpts 
)
static

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

Definition at line 996 of file plot_board_layers.cpp.

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

Referenced by StartPlotBoard().

998 {
999  /* Compute pen_dim (the value is given in mils) in pcb units,
1000  with plot scale (if Scale is 2, pen diameter value is always m_HPGLPenDiam
1001  so apparent pen diam is actually pen diam / Scale */
1002  int pen_diam = KiROUND( aPlotOpts->GetHPGLPenDiameter() * IU_PER_MILS /
1003  aPlotOpts->GetScale() );
1004 
1005  // Set HPGL-specific options and start
1006  aPlotter->SetPenSpeed( aPlotOpts->GetHPGLPenSpeed() );
1007  aPlotter->SetPenNumber( aPlotOpts->GetHPGLPenNum() );
1008  aPlotter->SetPenDiameter( pen_diam );
1009 }
int GetHPGLPenDiameter() const
double GetScale() const
static int KiROUND(double v)
KiROUND rounds a floating point number to an int using "round halfway cases away from zero"...
Definition: common.h:107
virtual void SetPenDiameter(double diameter)
int GetHPGLPenNum() const
virtual void SetPenSpeed(int speed)
Definition: plotter.h:605
virtual void SetPenNumber(int number)
Definition: plotter.h:610
int GetHPGLPenSpeed() const
static void FillNegativeKnockout ( PLOTTER aPlotter,
const EDA_RECT aBbbox 
)
static

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

Definition at line 983 of file plot_board_layers.cpp.

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

Referenced by StartPlotBoard().

984 {
985  const int margin = 5 * IU_PER_MM; // Add a 5 mm margin around the board
986  aPlotter->SetNegative( true );
987  aPlotter->SetColor( WHITE ); // Which will be plotted as black
988  EDA_RECT area = aBbbox;
989  area.Inflate( margin );
990  aPlotter->Rect( area.GetOrigin(), area.GetEnd(), FILLED_SHAPE );
991  aPlotter->SetColor( BLACK );
992 }
const wxPoint GetOrigin() const
Definition: eda_rect.h:112
virtual void SetColor(COLOR4D color)=0
const wxPoint GetEnd() const
Definition: eda_rect.h:114
Class EDA_RECT handles the component boundary box.
Definition: eda_rect.h:44
virtual void Rect(const wxPoint &p1, const wxPoint &p2, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)=0
Definition: colors.h:49
Definition: colors.h:45
virtual void SetNegative(bool _negative)
Definition: plotter.h:120
EDA_RECT & Inflate(wxCoord dx, wxCoord dy)
Function Inflate inflates the rectangle horizontally by dx and vertically by dy.
static void initializePlotter ( PLOTTER aPlotter,
BOARD aBoard,
PCB_PLOT_PARAMS aPlotOpts 
)
static

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

Definition at line 896 of file plot_board_layers.cpp.

References EDA_RECT::Centre(), BOARD::ComputeBoundingBox(), PCB_PLOT_PARAMS::GetA4Output(), PCB_PLOT_PARAMS::GetAutoScale(), BOARD::GetAuxOrigin(), PCB_PLOT_PARAMS::GetGerberPrecision(), PCB_PLOT_PARAMS::GetLineWidth(), PCB_PLOT_PARAMS::GetMirror(), BOARD::GetPageSettings(), PCB_PLOT_PARAMS::GetScale(), EDA_RECT::GetSize(), PCB_PLOT_PARAMS::GetTextMode(), PCB_PLOT_PARAMS::GetUseAuxOrigin(), KiROUND(), min, PLOTTER::SetColorMode(), PLOTTER::SetCreator(), PLOTTER::SetDefaultLineWidth(), PLOTTER::SetGerberCoordinatesFormat(), PLOTTER::SetPageSettings(), PLOTTER::SetTextMode(), PLOTTER::SetViewport(), wxPoint::x, and wxPoint::y.

Referenced by StartPlotBoard().

898 {
899  PAGE_INFO pageA4( wxT( "A4" ) );
900  const PAGE_INFO& pageInfo = aBoard->GetPageSettings();
901  const PAGE_INFO* sheet_info;
902  double paperscale; // Page-to-paper ratio
903  wxSize paperSizeIU;
904  wxSize pageSizeIU( pageInfo.GetSizeIU() );
905  bool autocenter = false;
906 
907  /* Special options: to fit the sheet to an A4 sheet replace
908  the paper size. However there is a difference between
909  the autoscale and the a4paper option:
910  - Autoscale fits the board to the paper size
911  - A4paper fits the original paper size to an A4 sheet
912  - Both of them fit the board to an A4 sheet
913  */
914  if( aPlotOpts->GetA4Output() ) // Fit paper to A4
915  {
916  sheet_info = &pageA4;
917  paperSizeIU = pageA4.GetSizeIU();
918  paperscale = (double) paperSizeIU.x / pageSizeIU.x;
919  autocenter = true;
920  }
921  else
922  {
923  sheet_info = &pageInfo;
924  paperSizeIU = pageSizeIU;
925  paperscale = 1;
926 
927  // Need autocentering only if scale is not 1:1
928  autocenter = (aPlotOpts->GetScale() != 1.0);
929  }
930 
931  EDA_RECT bbox = aBoard->ComputeBoundingBox();
932  wxPoint boardCenter = bbox.Centre();
933  wxSize boardSize = bbox.GetSize();
934 
935  double compound_scale;
936 
937  /* Fit to 80% of the page if asked; it could be that the board is empty,
938  * in this case regress to 1:1 scale */
939  if( aPlotOpts->GetAutoScale() && boardSize.x > 0 && boardSize.y > 0 )
940  {
941  double xscale = (paperSizeIU.x * 0.8) / boardSize.x;
942  double yscale = (paperSizeIU.y * 0.8) / boardSize.y;
943 
944  compound_scale = std::min( xscale, yscale ) * paperscale;
945  }
946  else
947  compound_scale = aPlotOpts->GetScale() * paperscale;
948 
949 
950  /* For the plot offset we have to keep in mind the auxiliary origin
951  too: if autoscaling is off we check that plot option (i.e. autoscaling
952  overrides auxiliary origin) */
953  wxPoint offset( 0, 0);
954 
955  if( autocenter )
956  {
957  offset.x = KiROUND( boardCenter.x - ( paperSizeIU.x / 2.0 ) / compound_scale );
958  offset.y = KiROUND( boardCenter.y - ( paperSizeIU.y / 2.0 ) / compound_scale );
959  }
960  else
961  {
962  if( aPlotOpts->GetUseAuxOrigin() )
963  offset = aBoard->GetAuxOrigin();
964  }
965 
966  /* Configure the plotter object with all the stuff computed and
967  most of that taken from the options */
968  aPlotter->SetPageSettings( *sheet_info );
969 
970  aPlotter->SetViewport( offset, IU_PER_MILS/10, compound_scale,
971  aPlotOpts->GetMirror() );
972  // has meaning only for gerber plotter. Must be called only after SetViewport
973  aPlotter->SetGerberCoordinatesFormat( aPlotOpts->GetGerberPrecision() );
974 
975  aPlotter->SetDefaultLineWidth( aPlotOpts->GetLineWidth() );
976  aPlotter->SetCreator( wxT( "PCBNEW" ) );
977  aPlotter->SetColorMode( false ); // default is plot in Black and White.
978  aPlotter->SetTextMode( aPlotOpts->GetTextMode() );
979 }
bool GetMirror() const
bool GetAutoScale() const
virtual void SetCreator(const wxString &aCreator)
Definition: plotter.h:160
double GetScale() const
static int KiROUND(double v)
KiROUND rounds a floating point number to an int using "round halfway cases away from zero"...
Definition: common.h:107
const wxSize GetSize() const
Definition: eda_rect.h:101
EDA_RECT ComputeBoundingBox(bool aBoardEdgesOnly=false) const
Function ComputeBoundingBox calculates the bounding box containing all board items (or board edge seg...
bool GetUseAuxOrigin() const
virtual void SetPageSettings(const PAGE_INFO &aPageSettings)
Definition: plotter.cpp:538
virtual void SetGerberCoordinatesFormat(int aResolution, bool aUseInches=false)
Definition: plotter.h:432
bool GetA4Output() const
int GetLineWidth() const
PlotTextMode GetTextMode() const
Class PAGE_INFO describes the page size and margins of a paper page on which to eventually print or p...
Definition: page_info.h:49
virtual void SetTextMode(PlotTextMode mode)
Change the current text mode.
Definition: plotter.h:427
wxPoint Centre() const
Definition: eda_rect.h:60
const PAGE_INFO & GetPageSettings() const
Definition: class_board.h:547
virtual void SetViewport(const wxPoint &aOffset, double aIusPerDecimil, double aScale, bool aMirror)=0
Set the plot offset and scaling for the current plot.
virtual void SetDefaultLineWidth(int width)=0
Set the default line width.
const wxPoint & GetAuxOrigin() const
Definition: class_board.h:343
Class EDA_RECT handles the component boundary box.
Definition: eda_rect.h:44
virtual void SetColorMode(bool _color_mode)
Definition: plotter.h:125
#define min(a, b)
Definition: auxiliary.h:85
int GetGerberPrecision() const
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 638 of file plot_board_layers.cpp.

References SHAPE_POLY_SET::CHole(), PLOTTER::Circle(), BOARD::ConvertBrdLayerToPolygonalContours(), SHAPE_POLY_SET::COutline(), SHAPE_LINE_CHAIN::CPoint(), DIM, dyn_cast(), PCB_PLOT_PARAMS::GetDrillMarksType(), VIA::GetDrillValue(), VIA::GetPosition(), SHAPE_POLY_SET::HoleCount(), VIA::IsOnLayer(), BOARD::m_Modules, BOARD::m_Track, min, TRACK::Next(), MODULE::Next(), D_PAD::Next(), 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(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by PlotOneBoardLayer(), and BRDITEMS_PLOTTER::SetLayerSet().

640 {
641 
642  BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
643  itemplotter.SetLayerSet( aLayerMask );
644 
645  SHAPE_POLY_SET outlines;
646 
647  for( LSEQ seq = aLayerMask.Seq( plot_seq, DIM( plot_seq ) ); seq; ++seq )
648  {
649  PCB_LAYER_ID layer = *seq;
650 
651  outlines.RemoveAllContours();
652  aBoard->ConvertBrdLayerToPolygonalContours( layer, outlines );
653 
654  outlines.Simplify( SHAPE_POLY_SET::PM_FAST );
655 
656  // Plot outlines
657  std::vector< wxPoint > cornerList;
658 
659  // Now we have one or more basic polygons: plot each polygon
660  for( int ii = 0; ii < outlines.OutlineCount(); ii++ )
661  {
662  for(int kk = 0; kk <= outlines.HoleCount (ii); kk++ )
663  {
664  cornerList.clear();
665  const SHAPE_LINE_CHAIN& path = (kk == 0) ? outlines.COutline( ii ) : outlines.CHole( ii, kk - 1 );
666 
667  for( int jj = 0; jj < path.PointCount(); jj++ )
668  cornerList.push_back( wxPoint( path.CPoint( jj ).x , path.CPoint( jj ).y ) );
669 
670 
671  // Ensure the polygon is closed
672  if( cornerList[0] != cornerList[cornerList.size() - 1] )
673  cornerList.push_back( cornerList[0] );
674 
675  aPlotter->PlotPoly( cornerList, NO_FILL );
676  }
677  }
678 
679  // Plot pad holes
681  {
682  int smallDrill = (aPlotOpt.GetDrillMarksType() == PCB_PLOT_PARAMS::SMALL_DRILL_SHAPE)
683  ? SMALL_DRILL : INT_MAX;
684 
685  for( MODULE* module = aBoard->m_Modules; module; module = module->Next() )
686  {
687  for( D_PAD* pad = module->PadsList(); pad; pad = pad->Next() )
688  {
689  wxSize hole = pad->GetDrillSize();
690 
691  if( hole.x == 0 || hole.y == 0 )
692  continue;
693 
694  if( hole.x == hole.y )
695  {
696  hole.x = std::min( smallDrill, hole.x );
697  aPlotter->Circle( pad->GetPosition(), hole.x, NO_FILL );
698  }
699  else
700  {
701  // Note: small drill marks have no significance when applied to slots
702  wxPoint drl_start, drl_end;
703  int width;
704  pad->GetOblongDrillGeometry( drl_start, drl_end, width );
705  aPlotter->ThickSegment( pad->GetPosition() + drl_start,
706  pad->GetPosition() + drl_end, width, SKETCH, NULL );
707  }
708  }
709  }
710  }
711 
712  // Plot vias holes
713  for( TRACK* track = aBoard->m_Track; track; track = track->Next() )
714  {
715  const VIA* via = dyn_cast<const VIA*>( track );
716 
717  if( via && via->IsOnLayer( layer ) ) // via holes can be not through holes
718  {
719  aPlotter->Circle( via->GetPosition(), via->GetDrillValue(), NO_FILL );
720  }
721  }
722  }
723 }
#define DIM(x)
of elements in an array
Definition: macros.h:98
#define SMALL_DRILL
Definition: pcbplot.h:72
int PointCount() const
Function PointCount()
static const PCB_LAYER_ID plot_seq[]
MODULE * Next() const
Definition: class_module.h:121
int HoleCount(int aOutline) const
Returns the number of holes in a given outline
const SHAPE_LINE_CHAIN & CHole(int aOutline, int aHole) const
int OutlineCount() const
Returns the number of outlines in the set
virtual void PlotPoly(const std::vector< wxPoint > &aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void *aData=NULL)=0
Function PlotPoly.
Casted dyn_cast(From aObject)
Function dyn_cast()
Definition: typeinfo.h:61
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:364
DrillMarksType GetDrillMarksType() const
PCB_LAYER_ID
A quick note on layer IDs:
Class SHAPE_POLY_SET.
D_PAD * Next() const
Definition: class_pad.h:160
void ConvertBrdLayerToPolygonalContours(PCB_LAYER_ID aLayer, SHAPE_POLY_SET &aOutlines)
Function ConvertBrdLayerToPolygonalContours Build a set of polygons which are the outlines of copper ...
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
void Simplify(POLYGON_MODE aFastMode)
Simplifies the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) For aFast...
const wxPoint GetPosition() const override
Definition: class_track.h:427
Class LSEQ is a sequence (and therefore also a set) of PCB_LAYER_IDs.
TRACK * Next() const
Definition: class_track.h:99
int GetDrillValue() const
Function GetDrillValue "calculates" the drill value for vias (m-Drill if > 0, or default drill value ...
DLIST< MODULE > m_Modules
Definition: class_board.h:245
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:457
void RemoveAllContours()
Removes all outlines & holes (clears) the polygon set.
DLIST< TRACK > m_Track
Definition: class_board.h:246
bool IsOnLayer(PCB_LAYER_ID aLayer) const override
Function IsOnLayer tests to see if this object is on the given layer.
const VECTOR2I & CPoint(int aIndex) const
Function CPoint()
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
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 153 of file plot_board_layers.cpp.

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_SVG_PRINT::CreateSVGFile(), DIALOG_PLOT::Plot(), PLOT_CONTROLLER::PlotLayer(), and BRDITEMS_PLOTTER::SetLayerSet().

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

References B_SilkS, BLACK, color, BOARD::Colors(), PLOTTER::EndBlock(), F_SilkS, BOARD::GetArea(), BOARD::GetAreaCount(), GetChars(), ZONE_CONTAINER::GetLayer(), COLORS_DESIGN_SETTINGS::GetLayerColor(), PCB_PLOT_PARAMS::GetPlotMode(), PCB_PLOT_PARAMS::GetPlotPadsOnSilkLayer(), BOARD::m_Modules, BOARD::m_Zone, MODULE::Next(), D_PAD::Next(), SEGZONE::Next(), BRDITEMS_PLOTTER::Plot_Edges_Modules(), BRDITEMS_PLOTTER::PlotAllTextsModule(), BRDITEMS_PLOTTER::PlotBoardGraphicItems(), BRDITEMS_PLOTTER::PlotFilledAreas(), BRDITEMS_PLOTTER::PlotPad(), BRDITEMS_PLOTTER::SetLayerSet(), SKETCH, PLOTTER::StartBlock(), and PLOTTER::ThickSegment().

Referenced by PlotOneBoardLayer(), and BRDITEMS_PLOTTER::SetLayerSet().

70 {
71  BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
72  itemplotter.SetLayerSet( aLayerMask );
73 
74  // Plot edge layer and graphic items
75  itemplotter.PlotBoardGraphicItems();
76 
77  // Plot footprint outlines :
78  itemplotter.Plot_Edges_Modules();
79 
80  // Plot pads (creates pads outlines, for pads on silkscreen layers)
81  LSET layersmask_plotpads = aLayerMask;
82 
83  // Calculate the mask layers of allowed layers for pads
84 
85  if( !aPlotOpt.GetPlotPadsOnSilkLayer() ) // Do not plot pads on silk screen layers
86  layersmask_plotpads.set( B_SilkS, false ).set( F_SilkS, false );
87 
88  if( layersmask_plotpads.any() )
89  {
90  for( MODULE* Module = aBoard->m_Modules; Module; Module = Module->Next() )
91  {
92  aPlotter->StartBlock( NULL );
93 
94  for( D_PAD* pad = Module->PadsList(); pad; pad = pad->Next() )
95  {
96  // See if the pad is on this layer
97  LSET masklayer = pad->GetLayerSet();
98  if( !( masklayer & layersmask_plotpads ).any() )
99  continue;
100 
102 
103  if( layersmask_plotpads[B_SilkS] )
104  color = aBoard->Colors().GetLayerColor( B_SilkS );
105 
106  if( layersmask_plotpads[F_SilkS] )
107  color = ( color == COLOR4D::BLACK) ? aBoard->Colors().GetLayerColor( F_SilkS ) : color;
108 
109  itemplotter.PlotPad( pad, color, SKETCH );
110  }
111 
112  aPlotter->EndBlock( NULL );
113  }
114  }
115 
116  // Plot footprints fields (ref, value ...)
117  for( MODULE* module = aBoard->m_Modules; module; module = module->Next() )
118  {
119  if( ! itemplotter.PlotAllTextsModule( module ) )
120  {
121  wxLogMessage( _( "Your BOARD has a bad layer number for footprint %s" ),
122  GetChars( module->GetReference() ) );
123  }
124  }
125 
126  // Plot filled areas
127  aPlotter->StartBlock( NULL );
128 
129  for( int ii = 0; ii < aBoard->GetAreaCount(); ii++ )
130  {
131  ZONE_CONTAINER* edge_zone = aBoard->GetArea( ii );
132 
133  if( !aLayerMask[ edge_zone->GetLayer() ] )
134  continue;
135 
136  itemplotter.PlotFilledAreas( edge_zone );
137  }
138 
139  aPlotter->EndBlock( NULL );
140 
141  // Plot segments used to fill zone areas (outdated, but here for old boards
142  // compatibility):
143  for( SEGZONE* seg = aBoard->m_Zone; seg; seg = seg->Next() )
144  {
145  if( !aLayerMask[ seg->GetLayer() ] )
146  continue;
147 
148  aPlotter->ThickSegment( seg->GetStart(), seg->GetEnd(), seg->GetWidth(),
149  itemplotter.GetPlotMode(), NULL );
150  }
151 }
Class ZONE_CONTAINER handles a list of polygons defining a copper zone.
Definition: class_zone.h:60
virtual void EndBlock(void *aData)
calling this function allows to define the end of a group of drawing items for instance in SVG or Ger...
Definition: plotter.h:453
int color
Definition: DXF_plotter.cpp:62
MODULE * Next() const
Definition: class_module.h:121
virtual PCB_LAYER_ID GetLayer() const override
Function GetLayer returns the primary layer this item is on.
Definition: class_zone.cpp:175
virtual void StartBlock(void *aData)
calling this function allows to define the beginning of a group of drawing items, for instance in SVG...
Definition: plotter.h:444
DLIST< SEGZONE > m_Zone
Definition: class_board.h:247
SEGZONE * Next() const
Definition: class_track.h:361
Class LSET is a set of PCB_LAYER_IDs.
const COLORS_DESIGN_SETTINGS & Colors() const
Function GetColorSettings.
Definition: class_board.h:563
D_PAD * Next() const
Definition: class_pad.h:160
int GetAreaCount() const
Function GetAreaCount.
Definition: class_board.h:1011
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:92
ZONE_CONTAINER * GetArea(int index) const
Function GetArea returns the Area (Zone Container) at a given index.
Definition: class_board.h:982
DLIST< MODULE > m_Modules
Definition: class_board.h:245
virtual void ThickSegment(const wxPoint &start, const wxPoint &end, int width, EDA_DRAW_MODE_T tracemode, void *aData)
Definition: plotter.cpp:457
bool GetPlotPadsOnSilkLayer() const
COLOR4D GetLayerColor(LAYER_NUM aLayer) const
Function GetLayerColor.
Definition: colors.h:45
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
void PlotSolderMaskLayer ( BOARD aBoard,
PLOTTER aPlotter,
LSET  aLayerMask,
const PCB_PLOT_PARAMS aPlotOpt,
int  aMinThickness 
)
static

Definition at line 744 of file plot_board_layers.cpp.

References B_Cu, B_Mask, SHAPE_POLY_SET::BooleanAdd(), dyn_cast(), F_Cu, F_Mask, SHAPE_POLY_SET::Fracture(), BOARD::GetArea(), BOARD::GetAreaCount(), BOARD::GetDesignSettings(), ZONE_CONTAINER::GetLayer(), VIA::GetLayerSet(), PCB_PLOT_PARAMS::GetPlotViaOnMaskLayer(), SHAPE_POLY_SET::Inflate(), BOARD::m_Modules, BOARD_DESIGN_SETTINGS::m_SolderMaskMargin, BOARD::m_Track, TRACK::Next(), BOARD_ITEM::Next(), MODULE::Next(), PCB_MODULE_EDGE_T, BRDITEMS_PLOTTER::Plot_1_EdgeModule(), BRDITEMS_PLOTTER::PlotBoardGraphicItems(), BRDITEMS_PLOTTER::PlotFilledAreas(), SHAPE_POLY_SET::PM_FAST, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE, ZONE_CONTAINER::SetArcSegmentCount(), ZONE_CONTAINER::SetFilledPolysList(), ZONE_CONTAINER::SetLayer(), BRDITEMS_PLOTTER::SetLayerSet(), ZONE_CONTAINER::SetMinThickness(), ZONE_CONTAINER::TransformOutlinesShapeWithClearanceToPolygon(), and TRACK::TransformShapeWithClearanceToPolygon().

Referenced by PlotOneBoardLayer().

747 {
748  PCB_LAYER_ID layer = aLayerMask[B_Mask] ? B_Mask : F_Mask;
749  int inflate = aMinThickness/2;
750 
751  BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
752  itemplotter.SetLayerSet( aLayerMask );
753 
754  // Plot edge layer and graphic items
755  // They do not have a solder Mask margin, because they are only graphic items
756  // on this layer (like logos), not actually areas around pads.
757  itemplotter.PlotBoardGraphicItems();
758 
759  for( MODULE* module = aBoard->m_Modules; module; module = module->Next() )
760  {
761  for( BOARD_ITEM* item = module->GraphicalItemsList(); item; item = item->Next() )
762  {
763  if( layer != item->GetLayer() )
764  continue;
765 
766  switch( item->Type() )
767  {
768  case PCB_MODULE_EDGE_T:
769  itemplotter.Plot_1_EdgeModule( (EDGE_MODULE*) item );
770  break;
771 
772  default:
773  break;
774  }
775  }
776  }
777 
778  // Build polygons for each pad shape.
779  // the size of the shape on solder mask should be:
780  // size of pad + clearance around the pad.
781  // clearance = solder mask clearance + extra margin
782  // extra margin is half the min width for solder mask
783  // This extra margin is used to merge too close shapes
784  // (distance < aMinThickness), and will be removed when creating
785  // the actual shapes
786  SHAPE_POLY_SET areas; // Contains shapes to plot
787  SHAPE_POLY_SET initialPolys; // Contains exact shapes to plot
788 
789  /* calculates the coeff to compensate radius reduction of holes clearance
790  * due to the segment approx ( 1 /cos( PI/circleToSegmentsCount )
791  */
792  int circleToSegmentsCount = 32;
793  double correction = 1.0 / cos( M_PI / circleToSegmentsCount );
794 
795  // Plot pads
796  for( MODULE* module = aBoard->m_Modules; module; module = module->Next() )
797  {
798  // add shapes with exact size
799  module->TransformPadsShapesWithClearanceToPolygon( layer,
800  initialPolys, 0,
801  circleToSegmentsCount, correction );
802  // add shapes inflated by aMinThickness/2
803  module->TransformPadsShapesWithClearanceToPolygon( layer,
804  areas, inflate,
805  circleToSegmentsCount, correction );
806  }
807 
808  // Plot vias on solder masks, if aPlotOpt.GetPlotViaOnMaskLayer() is true,
809  if( aPlotOpt.GetPlotViaOnMaskLayer() )
810  {
811  // The current layer is a solder mask,
812  // use the global mask clearance for vias
813  int via_clearance = aBoard->GetDesignSettings().m_SolderMaskMargin;
814  int via_margin = via_clearance + inflate;
815 
816  for( TRACK* track = aBoard->m_Track; track; track = track->Next() )
817  {
818  const VIA* via = dyn_cast<const VIA*>( track );
819 
820  if( !via )
821  continue;
822 
823  // vias are plotted only if they are on the corresponding
824  // external copper layer
825  LSET via_set = via->GetLayerSet();
826 
827  if( via_set[B_Cu] )
828  via_set.set( B_Mask );
829 
830  if( via_set[F_Cu] )
831  via_set.set( F_Mask );
832 
833  if( !( via_set & aLayerMask ).any() )
834  continue;
835 
836  via->TransformShapeWithClearanceToPolygon( areas, via_margin,
837  circleToSegmentsCount,
838  correction );
839  via->TransformShapeWithClearanceToPolygon( initialPolys, via_clearance,
840  circleToSegmentsCount,
841  correction );
842  }
843  }
844 
845  // Add filled zone areas.
846 #if 0 // Set to 1 if a solder mask margin must be applied to zones on solder mask
847  int zone_margin = aBoard->GetDesignSettings().m_SolderMaskMargin;
848 #else
849  int zone_margin = 0;
850 #endif
851 
852  for( int ii = 0; ii < aBoard->GetAreaCount(); ii++ )
853  {
854  ZONE_CONTAINER* zone = aBoard->GetArea( ii );
855 
856  if( zone->GetLayer() != layer )
857  continue;
858 
860  inflate+zone_margin, false );
862  zone_margin, false );
863  }
864 
865  // To avoid a lot of code, use a ZONE_CONTAINER
866  // to handle and plot polygons, because our polygons look exactly like
867  // filled areas in zones
868  // Note, also this code is not optimized: it creates a lot of copy/duplicate data
869  // However it is not complex, and fast enough for plot purposes (copy/convert data
870  // is only a very small calculation time for these calculations)
871  ZONE_CONTAINER zone( aBoard );
872  zone.SetArcSegmentCount( 32 );
873  zone.SetMinThickness( 0 ); // trace polygons only
874  zone.SetLayer ( layer );
875 
876  areas.BooleanAdd( initialPolys, SHAPE_POLY_SET::PM_FAST );
877  areas.Inflate( -inflate, circleToSegmentsCount );
878 
879  // Combine the current areas to initial areas. This is mandatory because
880  // inflate/deflate transform is not perfect, and we want the initial areas perfectly kept
881  areas.BooleanAdd( initialPolys, SHAPE_POLY_SET::PM_FAST );
883 
884  zone.SetFilledPolysList( areas );
885 
886  itemplotter.PlotFilledAreas( &zone );
887 }
void SetFilledPolysList(SHAPE_POLY_SET &aPolysList)
Function SetFilledPolysList sets the list of filled polygons.
Definition: class_zone.h:545
int m_SolderMaskMargin
Solder mask margin.
Class ZONE_CONTAINER handles a list of polygons defining a copper zone.
Definition: class_zone.h:60
virtual LSET GetLayerSet() const override
Function GetLayerSet returns a "layer mask", which is a bitmap of all layers on which the TRACK segme...
void BooleanAdd(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Performs boolean polyset union For aFastMode meaning, see function booleanOp
Class BOARD_ITEM is a base class for any item which can be embedded within the BOARD container class...
MODULE * Next() const
Definition: class_module.h:121
virtual PCB_LAYER_ID GetLayer() const override
Function GetLayer returns the primary layer this item is on.
Definition: class_zone.cpp:175
void SetArcSegmentCount(int aArcSegCount)
Definition: class_zone.h:186
class EDGE_MODULE, a footprint edge
Definition: typeinfo.h:94
Casted dyn_cast(From aObject)
Function dyn_cast()
Definition: typeinfo.h:61
BOARD_ITEM * Next() const
PCB_LAYER_ID
A quick note on layer IDs:
Class LSET is a set of PCB_LAYER_IDs.
void Inflate(int aFactor, int aCircleSegmentsCount)
Performs outline inflation/deflation, using round corners.
Class SHAPE_POLY_SET.
void TransformShapeWithClearanceToPolygon(SHAPE_POLY_SET &aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor) const override
Function TransformShapeWithClearanceToPolygon Convert the track shape to a closed polygon Used in fil...
virtual void SetLayer(PCB_LAYER_ID aLayer) override
Function SetLayer sets the layer this item is on.
Definition: class_zone.cpp:202
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:532
bool GetPlotViaOnMaskLayer() const
int GetAreaCount() const
Function GetAreaCount.
Definition: class_board.h:1011
void Fracture(POLYGON_MODE aFastMode)
Converts a set of polygons with holes to a singe outline with "slits"/"fractures" connecting the oute...
void TransformOutlinesShapeWithClearanceToPolygon(SHAPE_POLY_SET &aCornerBuffer, int aMinClearanceValue, bool aUseNetClearance) const
Function TransformOutlinesShapeWithClearanceToPolygon Convert the outlines shape to a polygon with no...
TRACK * Next() const
Definition: class_track.h:99
ZONE_CONTAINER * GetArea(int index) const
Function GetArea returns the Area (Zone Container) at a given index.
Definition: class_board.h:982
DLIST< MODULE > m_Modules
Definition: class_board.h:245
DLIST< TRACK > m_Track
Definition: class_board.h:246
void SetMinThickness(int aMinThickness)
Definition: class_zone.h:199
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 296 of file plot_board_layers.cpp.

References LSET::AllCuMask(), B_Cu, B_Mask, B_Paste, BLACK, color, BOARD::Colors(), delta, dyn_cast(), PLOTTER::EndBlock(), F_Cu, F_Mask, F_Paste, PLOTTER::FlashPadCircle(), GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CONDUCTOR, GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_VIAPAD, GBR_NETLIST_METADATA::GBR_NETINFO_NET, BOARD::GetArea(), BOARD::GetAreaCount(), GetChars(), BRDITEMS_PLOTTER::getColor(), BOARD::GetDesignSettings(), PCB_PLOT_PARAMS::GetDrillMarksType(), BRDITEMS_PLOTTER::getFineWidthAdj(), COLORS_DESIGN_SETTINGS::GetItemColor(), ZONE_CONTAINER::GetLayer(), 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(), LAYER_PAD_BK, LAYER_PAD_FR, LAYER_VIAS, LIGHTGRAY, BOARD::m_Modules, GBR_METADATA::m_NetlistMetadata, GBR_NETLIST_METADATA::m_NotInNet, BOARD_DESIGN_SETTINGS::m_SolderMaskMargin, BOARD::m_Track, BOARD::m_Zone, TRACK::Next(), BOARD_ITEM::Next(), MODULE::Next(), D_PAD::Next(), SEGZONE::Next(), PCB_PLOT_PARAMS::NO_DRILL_SHAPE, PAD_ATTRIB_HOLE_NOT_PLATED, PAD_SHAPE_CIRCLE, 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(), GBR_METADATA::SetApertureAttrib(), PLOTTER::SetColor(), BRDITEMS_PLOTTER::SetLayerSet(), GBR_METADATA::SetNetAttribType(), GBR_METADATA::SetNetName(), PLOTTER::StartBlock(), PLOTTER::ThickSegment(), WHITE, wxPoint::x, and wxPoint::y.

Referenced by DIALOG_SVG_PRINT::CreateSVGFile(), PlotOneBoardLayer(), and BRDITEMS_PLOTTER::SetLayerSet().

298 {
299  BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
300 
301  itemplotter.SetLayerSet( aLayerMask );
302 
303  EDA_DRAW_MODE_T plotMode = aPlotOpt.GetPlotMode();
304 
305  // Plot edge layer and graphic items
306  itemplotter.PlotBoardGraphicItems();
307 
308  // Draw footprint shapes without pads (pads will plotted later)
309  // We plot here module texts, but they are usually on silkscreen layer,
310  // so they are not plot here but plot by PlotSilkScreen()
311  // Plot footprints fields (ref, value ...)
312  for( MODULE* module = aBoard->m_Modules; module; module = module->Next() )
313  {
314  if( ! itemplotter.PlotAllTextsModule( module ) )
315  {
316  wxLogMessage( _( "Your BOARD has a bad layer number for footprint %s" ),
317  GetChars( module->GetReference() ) );
318  }
319  }
320 
321  for( MODULE* module = aBoard->m_Modules; module; module = module->Next() )
322  {
323  for( BOARD_ITEM* item = module->GraphicalItemsList(); item; item = item->Next() )
324  {
325  if( !aLayerMask[ item->GetLayer() ] )
326  continue;
327 
328  switch( item->Type() )
329  {
330  case PCB_MODULE_EDGE_T:
331  itemplotter.Plot_1_EdgeModule( (EDGE_MODULE*) item );
332  break;
333 
334  default:
335  break;
336  }
337  }
338  }
339 
340  // Plot footprint pads
341  for( MODULE* module = aBoard->m_Modules; module; module = module->Next() )
342  {
343  aPlotter->StartBlock( NULL );
344 
345  for( D_PAD* pad = module->PadsList(); pad; pad = pad->Next() )
346  {
347  if( (pad->GetLayerSet() & aLayerMask) == 0 )
348  continue;
349 
350  wxSize margin;
351  double width_adj = 0;
352 
353  if( ( aLayerMask & LSET::AllCuMask() ).any() )
354  width_adj = itemplotter.getFineWidthAdj();
355 
356  static const LSET speed( 4, B_Mask, F_Mask, B_Paste, F_Paste );
357 
358  LSET anded = ( speed & aLayerMask );
359 
360  if( anded == LSET( F_Mask ) || anded == LSET( B_Mask ) )
361  {
362  margin.x = margin.y = pad->GetSolderMaskMargin();
363  }
364  else if( anded == LSET( F_Paste ) || anded == LSET( B_Paste ) )
365  {
366  margin = pad->GetSolderPasteMargin();
367  }
368 
369  // Now offset the pad size by margin + width_adj
370  // this is easy for most shapes, but not for a trapezoid
371  wxSize padPlotsSize;
372  wxSize extraSize = margin * 2;
373  extraSize.x += width_adj;
374  extraSize.y += width_adj;
375  wxSize deltaSize = pad->GetDelta(); // has meaning only for trapezoidal pads
376 
377  if( pad->GetShape() == PAD_SHAPE_TRAPEZOID )
378  { // The easy way is to use BuildPadPolygon to calculate
379  // size and delta of the trapezoidal pad after offseting:
380  wxPoint coord[4];
381  pad->BuildPadPolygon( coord, extraSize/2, 0.0 );
382  // Calculate the size and delta from polygon corners coordinates:
383  // coord[0] is the lower left
384  // coord[1] is the upper left
385  // coord[2] is the upper right
386  // coord[3] is the lower right
387 
388  // the size is the distance between middle of segments
389  // (left/right or top/bottom)
390  // size X is the dist between left and right middle points:
391  padPlotsSize.x = ( ( -coord[0].x + coord[3].x ) // the lower segment X length
392  + ( -coord[1].x + coord[2].x ) ) // the upper segment X length
393  / 2; // the Y size is the half sum
394  // size Y is the dist between top and bottom middle points:
395  padPlotsSize.y = ( ( coord[0].y - coord[1].y ) // the left segment Y lenght
396  + ( coord[3].y - coord[2].y ) ) // the right segment Y lenght
397  / 2; // the Y size is the half sum
398 
399  // calculate the delta ( difference of lenght between 2 opposite edges )
400  // The delta.x is the delta along the X axis, therefore the delta of Y lenghts
401  wxSize delta;
402 
403  if( coord[0].y != coord[3].y )
404  delta.x = coord[0].y - coord[3].y;
405  else
406  delta.y = coord[1].x - coord[0].x;
407 
408  pad->SetDelta( delta );
409  }
410  else
411  padPlotsSize = pad->GetSize() + extraSize;
412 
413  // Don't draw a null size item :
414  if( padPlotsSize.x <= 0 || padPlotsSize.y <= 0 )
415  continue;
416 
418 
419  if( pad->GetLayerSet()[B_Cu] )
420  color = aBoard->Colors().GetItemColor( LAYER_PAD_BK );
421 
422  if( pad->GetLayerSet()[F_Cu] )
423  color = color.LegacyMix( aBoard->Colors().GetItemColor( LAYER_PAD_FR ) );
424 
425  // Temporary set the pad size to the required plot size:
426  wxSize tmppadsize = pad->GetSize();
427  pad->SetSize( padPlotsSize );
428 
429  switch( pad->GetShape() )
430  {
431  case PAD_SHAPE_CIRCLE:
432  case PAD_SHAPE_OVAL:
433  if( aPlotOpt.GetSkipPlotNPTH_Pads() &&
434  ( pad->GetSize() == pad->GetDrillSize() ) &&
435  ( pad->GetAttribute() == PAD_ATTRIB_HOLE_NOT_PLATED ) )
436  break;
437  // Fall through:
438  case PAD_SHAPE_TRAPEZOID:
439  case PAD_SHAPE_RECT:
440  case PAD_SHAPE_ROUNDRECT:
441  default:
442  itemplotter.PlotPad( pad, color, plotMode );
443  break;
444  }
445 
446  pad->SetSize( tmppadsize ); // Restore the pad size
447  pad->SetDelta( deltaSize );
448  }
449 
450  aPlotter->EndBlock( NULL );
451  }
452 
453  // Plot vias on copper layers, and if aPlotOpt.GetPlotViaOnMaskLayer() is true,
454  // plot them on solder mask
455 
456  GBR_METADATA gbr_metadata;
457 
458  bool isOnCopperLayer = ( aLayerMask & LSET::AllCuMask() ).any();
459 
460  if( isOnCopperLayer )
461  {
464  }
465 
466  aPlotter->StartBlock( NULL );
467 
468  for( TRACK* track = aBoard->m_Track; track; track = track->Next() )
469  {
470  const VIA* Via = dyn_cast<const VIA*>( track );
471 
472  if( !Via )
473  continue;
474 
475  // vias are not plotted if not on selected layer, but if layer
476  // is SOLDERMASK_LAYER_BACK or SOLDERMASK_LAYER_FRONT,vias are drawn,
477  // only if they are on the corresponding external copper layer
478  LSET via_mask_layer = Via->GetLayerSet();
479 
480  if( aPlotOpt.GetPlotViaOnMaskLayer() )
481  {
482  if( via_mask_layer[B_Cu] )
483  via_mask_layer.set( B_Mask );
484 
485  if( via_mask_layer[F_Cu] )
486  via_mask_layer.set( F_Mask );
487  }
488 
489  if( !( via_mask_layer & aLayerMask ).any() )
490  continue;
491 
492  int via_margin = 0;
493  double width_adj = 0;
494 
495  // If the current layer is a solder mask, use the global mask
496  // clearance for vias
497  if( aLayerMask[B_Mask] || aLayerMask[F_Mask] )
498  via_margin = aBoard->GetDesignSettings().m_SolderMaskMargin;
499 
500  if( ( aLayerMask & LSET::AllCuMask() ).any() )
501  width_adj = itemplotter.getFineWidthAdj();
502 
503  int diameter = Via->GetWidth() + 2 * via_margin + width_adj;
504 
505  // Don't draw a null size item :
506  if( diameter <= 0 )
507  continue;
508 
509  // Some vias can be not connected (no net).
510  // Set the m_NotInNet for these vias to force a empty net name in gerber file
511  gbr_metadata.m_NetlistMetadata.m_NotInNet = Via->GetNetname().IsEmpty();
512 
513  gbr_metadata.SetNetName( Via->GetNetname() );
514 
515  COLOR4D color = aBoard->Colors().GetItemColor( LAYER_VIAS + Via->GetViaType() );
516  // Set plot color (change WHITE to LIGHTGRAY because
517  // the white items are not seen on a white paper or screen
518  aPlotter->SetColor( color != WHITE ? color : LIGHTGRAY);
519  aPlotter->FlashPadCircle( Via->GetStart(), diameter, plotMode, &gbr_metadata );
520  }
521 
522  aPlotter->EndBlock( NULL );
523  aPlotter->StartBlock( NULL );
525 
526  // Plot tracks (not vias) :
527  for( TRACK* track = aBoard->m_Track; track; track = track->Next() )
528  {
529  if( track->Type() == PCB_VIA_T )
530  continue;
531 
532  if( !aLayerMask[track->GetLayer()] )
533  continue;
534 
535  // Some track segments can be not connected (no net).
536  // Set the m_NotInNet for these segments to force a empty net name in gerber file
537  gbr_metadata.m_NetlistMetadata.m_NotInNet = track->GetNetname().IsEmpty();
538 
539  gbr_metadata.SetNetName( track->GetNetname() );
540  int width = track->GetWidth() + itemplotter.getFineWidthAdj();
541  aPlotter->SetColor( itemplotter.getColor( track->GetLayer() ) );
542  aPlotter->ThickSegment( track->GetStart(), track->GetEnd(), width, plotMode, &gbr_metadata );
543  }
544 
545  aPlotter->EndBlock( NULL );
546 
547  // Plot zones (outdated, for old boards compatibility):
548  for( TRACK* track = aBoard->m_Zone; track; track = track->Next() )
549  {
550  if( !aLayerMask[track->GetLayer()] )
551  continue;
552 
553  int width = track->GetWidth() + itemplotter.getFineWidthAdj();
554  aPlotter->SetColor( itemplotter.getColor( track->GetLayer() ) );
555  aPlotter->ThickSegment( track->GetStart(), track->GetEnd(), width, plotMode, NULL );
556  }
557 
558  // Plot filled ares
559  aPlotter->StartBlock( NULL );
560  for( int ii = 0; ii < aBoard->GetAreaCount(); ii++ )
561  {
562  ZONE_CONTAINER* zone = aBoard->GetArea( ii );
563 
564  if( !aLayerMask[zone->GetLayer()] )
565  continue;
566 
567  itemplotter.PlotFilledAreas( zone );
568  }
569  aPlotter->EndBlock( NULL );
570 
571  // Adding drill marks, if required and if the plotter is able to plot them:
573  itemplotter.PlotDrillMarks();
574 }
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:673
int m_SolderMaskMargin
Solder mask margin.
Class ZONE_CONTAINER handles a list of polygons defining a copper zone.
Definition: class_zone.h:60
virtual void EndBlock(void *aData)
calling this function allows to define the end of a group of drawing items for instance in SVG or Ger...
Definition: plotter.h:453
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:65
Class BOARD_ITEM is a base class for any item which can be embedded within the BOARD container class...
virtual void SetColor(COLOR4D color)=0
void SetNetAttribType(int aNetAttribType)
int color
Definition: DXF_plotter.cpp:62
MODULE * Next() const
Definition: class_module.h:121
virtual PCB_LAYER_ID GetLayer() const override
Function GetLayer returns the primary layer this item is on.
Definition: class_zone.cpp:175
virtual void StartBlock(void *aData)
calling this function allows to define the beginning of a group of drawing items, for instance in SVG...
Definition: plotter.h:444
DLIST< SEGZONE > m_Zone
Definition: class_board.h:247
smd pads, back layer
class EDGE_MODULE, a footprint edge
Definition: typeinfo.h:94
static const int delta[8][2]
Definition: solve.cpp:112
Casted dyn_cast(From aObject)
Function dyn_cast()
Definition: typeinfo.h:61
SEGZONE * Next() const
Definition: class_track.h:361
BOARD_ITEM * Next() const
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
DrillMarksType GetDrillMarksType() const
Class LSET is a set of PCB_LAYER_IDs.
VIATYPE_T GetViaType() const
Definition: class_track.h:455
EDA_DRAW_MODE_T
Definition: eda_text.h:62
const COLORS_DESIGN_SETTINGS & Colors() const
Function GetColorSettings.
Definition: class_board.h:563
const wxPoint & GetStart() const
Definition: class_track.h:122
D_PAD * Next() const
Definition: class_pad.h:160
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:532
bool GetPlotViaOnMaskLayer() const
int GetAreaCount() const
Function GetAreaCount.
Definition: class_board.h:1011
aperture used for connected items like tracks (not vias)
void SetNetName(const wxString &aNetname)
bool GetSkipPlotNPTH_Pads() const
TRACK * Next() const
Definition: class_track.h:99
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:92
smd pads, front layer
const wxString & GetNetname() const
Function GetNetname.
ZONE_CONTAINER * GetArea(int index) const
Function GetArea returns the Area (Zone Container) at a given index.
Definition: class_board.h:982
DLIST< MODULE > m_Modules
Definition: class_board.h:245
int GetWidth() const
Definition: class_track.h:116
virtual void ThickSegment(const wxPoint &start, const wxPoint &end, int width, EDA_DRAW_MODE_T tracemode, void *aData)
Definition: plotter.cpp:457
EDA_DRAW_MODE_T GetPlotMode() const
Definition: colors.h:49
void SetApertureAttrib(GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB aApertAttribute)
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
DLIST< TRACK > m_Track
Definition: class_board.h:246
GBR_NETLIST_METADATA m_NetlistMetadata
a item to handle object attribute:
Definition: colors.h:45
print info associated to a net (TO.N attribute)
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
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 1016 of file plot_board_layers.cpp.

References AddGerberX2Attribute(), PLOTTER::ClearHeaderLinesList(), BOARD::ComputeBoundingBox(), ConfigureHPGLPenSizes(), FillNegativeKnockout(), 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::GetUseGerberAttributes(), 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(), PLOTTER::StartPlot(), GERBER_PLOTTER::UseX2Attributes(), and GERBER_PLOTTER::UseX2NetAttributes().

Referenced by DIALOG_SVG_PRINT::CreateSVGFile(), PLOT_CONTROLLER::OpenPlotfile(), DIALOG_PLOT::Plot(), and BRDITEMS_PLOTTER::SetLayerSet().

1020 {
1021  // Create the plotter driver and set the few plotter specific
1022  // options
1023  PLOTTER* plotter = NULL;
1024 
1025  switch( aPlotOpts->GetFormat() )
1026  {
1027  case PLOT_FORMAT_DXF:
1028  plotter = new DXF_PLOTTER();
1029  break;
1030 
1031  case PLOT_FORMAT_POST:
1032  PS_PLOTTER* PS_plotter;
1033  PS_plotter = new PS_PLOTTER();
1034  PS_plotter->SetScaleAdjust( aPlotOpts->GetFineScaleAdjustX(),
1035  aPlotOpts->GetFineScaleAdjustY() );
1036  plotter = PS_plotter;
1037  break;
1038 
1039  case PLOT_FORMAT_PDF:
1040  plotter = new PDF_PLOTTER();
1041  break;
1042 
1043  case PLOT_FORMAT_HPGL:
1044  HPGL_PLOTTER* HPGL_plotter;
1045  HPGL_plotter = new HPGL_PLOTTER();
1046 
1047  /* HPGL options are a little more convoluted to compute, so
1048  they're split in another function */
1049  ConfigureHPGLPenSizes( HPGL_plotter, aPlotOpts );
1050  plotter = HPGL_plotter;
1051  break;
1052 
1053  case PLOT_FORMAT_GERBER:
1054  plotter = new GERBER_PLOTTER();
1055  break;
1056 
1057  case PLOT_FORMAT_SVG:
1058  plotter = new SVG_PLOTTER();
1059  break;
1060 
1061  default:
1062  wxASSERT( false );
1063  return NULL;
1064  }
1065 
1066  // Compute the viewport and set the other options
1067 
1068  // page layout is not mirrored, so temporary change mirror option
1069  // just to plot the page layout
1070  PCB_PLOT_PARAMS plotOpts = *aPlotOpts;
1071 
1072  if( plotOpts.GetPlotFrameRef() && plotOpts.GetMirror() )
1073  plotOpts.SetMirror( false );
1074 
1075  initializePlotter( plotter, aBoard, &plotOpts );
1076 
1077  if( plotter->OpenFile( aFullFileName ) )
1078  {
1079  plotter->ClearHeaderLinesList();
1080 
1081  // For the Gerber "file function" attribute, set the layer number
1082  if( plotter->GetPlotterType() == PLOT_FORMAT_GERBER )
1083  {
1084  bool useX2mode = plotOpts.GetUseGerberAttributes();
1085 
1086  if( useX2mode )
1087  {
1088  AddGerberX2Attribute( plotter, aBoard, aLayer, false );
1089  GERBER_PLOTTER* gbrplotter = static_cast <GERBER_PLOTTER*> ( plotter );
1090  gbrplotter->UseX2Attributes( true );
1091  gbrplotter->UseX2NetAttributes( plotOpts.GetIncludeGerberNetlistInfo() );
1092  }
1093  else
1094  {
1095  AddGerberX2Attribute( plotter, aBoard, aLayer, true );
1096  }
1097  }
1098 
1099  plotter->StartPlot();
1100 
1101  // Plot the frame reference if requested
1102  if( aPlotOpts->GetPlotFrameRef() )
1103  {
1104  PlotWorkSheet( plotter, aBoard->GetTitleBlock(),
1105  aBoard->GetPageSettings(),
1106  1, 1, // Only one page
1107  aSheetDesc, aBoard->GetFileName() );
1108 
1109  if( aPlotOpts->GetMirror() )
1110  initializePlotter( plotter, aBoard, aPlotOpts );
1111  }
1112 
1113  /* When plotting a negative board: draw a black rectangle
1114  * (background for plot board in white) and switch the current
1115  * color to WHITE; note the color inversion is actually done
1116  * in the driver (if supported) */
1117  if( aPlotOpts->GetNegative() )
1118  {
1119  EDA_RECT bbox = aBoard->ComputeBoundingBox();
1120  FillNegativeKnockout( plotter, bbox );
1121  }
1122 
1123  return plotter;
1124  }
1125 
1126  delete plotter;
1127  return NULL;
1128 }
bool GetMirror() const
void UseX2NetAttributes(bool aEnable)
Definition: plotter.h:1137
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...
bool GetUseGerberAttributes() const
EDA_RECT ComputeBoundingBox(bool aBoardEdgesOnly=false) const
Function ComputeBoundingBox calculates the bounding box containing all board items (or board edge seg...
virtual bool OpenFile(const wxString &aFullFilename)
Open or create the plot file aFullFilename.
Definition: plotter.cpp:82
void SetScaleAdjust(double scaleX, double scaleY)
Set the &#39;fine&#39; scaling for the postscript engine.
Definition: plotter.h:683
void SetMirror(bool aFlag)
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:465
double GetFineScaleAdjustX() const
void PlotWorkSheet(PLOTTER *plotter, const TITLE_BLOCK &aTitleBlock, const PAGE_INFO &aPageInfo, int aSheetNumber, int aNumberOfSheets, const wxString &aSheetDesc, const wxString &aFilename)
bool GetIncludeGerberNetlistInfo() const
const wxString & GetFileName() const
Definition: class_board.h:234
static void ConfigureHPGLPenSizes(HPGL_PLOTTER *aPlotter, PCB_PLOT_PARAMS *aPlotOpts)
Calculate the effective size of HPGL pens and set them in the plotter object.
PlotFormat GetFormat() const
Class PCB_PLOT_PARAMS handles plot parameters and options when plotting/printing a board...
const PAGE_INFO & GetPageSettings() const
Definition: class_board.h:547
Base plotter engine class.
Definition: plotter.h:96
TITLE_BLOCK & GetTitleBlock()
Definition: class_board.h:553
bool GetNegative() const
virtual PlotFormat GetPlotterType() const =0
Returns the effective plot engine in use.
bool GetPlotFrameRef() const
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:184
void UseX2Attributes(bool aEnable)
Definition: plotter.h:1136
double GetFineScaleAdjustY() const

Variable Documentation

const PCB_LAYER_ID plot_seq[]
static

Definition at line 578 of file plot_board_layers.cpp.

Referenced by PlotLayerOutlines().