KiCad PCB EDA Suite
plot_board_layers.cpp
Go to the documentation of this file.
1 
8 /*
9  * This program source code file is part of KiCad, a free EDA CAD application.
10  *
11  * Copyright (C) 1992-2017 KiCad Developers, see AUTHORS.txt for contributors.
12  *
13  * This program is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU General Public License
15  * as published by the Free Software Foundation; either version 2
16  * of the License, or (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, you may find one here:
25  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
26  * or you may search the http://www.gnu.org website for the version 2 license,
27  * or you may write to the Free Software Foundation, Inc.,
28  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
29  */
30 
31 
32 #include <fctsys.h>
33 #include <common.h>
34 #include <plotter.h>
35 #include <base_struct.h>
36 #include <draw_graphic_text.h>
38 #include <trigo.h>
39 #include <pcb_base_frame.h>
40 #include <macros.h>
41 
42 #include <class_board.h>
43 #include <class_module.h>
44 #include <class_track.h>
45 #include <class_edge_mod.h>
46 #include <class_pcb_text.h>
47 #include <class_zone.h>
48 #include <class_drawsegment.h>
49 #include <class_pcb_target.h>
50 #include <class_dimension.h>
51 
52 #include <pcbnew.h>
53 #include <pcbplot.h>
54 #include <plot_auxiliary_data.h>
55 
56 // Local
57 /* Plot a solder mask layer.
58  * Solder mask layers have a minimum thickness value and cannot be drawn like standard layers,
59  * unless the minimum thickness is 0.
60  */
61 static void PlotSolderMaskLayer( BOARD *aBoard, PLOTTER* aPlotter,
62  LSET aLayerMask, const PCB_PLOT_PARAMS& aPlotOpt,
63  int aMinThickness );
64 
65 /* Creates the plot for silkscreen layers
66  * Silkscreen layers have specific requirement for pads (not filled) and texts
67  * (with option to remove them from some copper areas (pads...)
68  */
69 void PlotSilkScreen( BOARD *aBoard, PLOTTER* aPlotter, LSET aLayerMask,
70  const PCB_PLOT_PARAMS& aPlotOpt )
71 {
72  BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
73  itemplotter.SetLayerSet( aLayerMask );
74 
75  // Plot edge layer and graphic items
76  itemplotter.PlotBoardGraphicItems();
77 
78  // Plot footprint outlines :
79  itemplotter.Plot_Edges_Modules();
80 
81  // Plot pads (creates pads outlines, for pads on silkscreen layers)
82  LSET layersmask_plotpads = aLayerMask;
83 
84  // Calculate the mask layers of allowed layers for pads
85 
86  if( !aPlotOpt.GetPlotPadsOnSilkLayer() ) // Do not plot pads on silk screen layers
87  layersmask_plotpads.set( B_SilkS, false ).set( F_SilkS, false );
88 
89  if( layersmask_plotpads.any() )
90  {
91  for( MODULE* Module = aBoard->m_Modules; Module; Module = Module->Next() )
92  {
93  aPlotter->StartBlock( NULL );
94 
95  for( D_PAD* pad = Module->PadsList(); pad; pad = pad->Next() )
96  {
97  // See if the pad is on this layer
98  LSET masklayer = pad->GetLayerSet();
99  if( !( masklayer & layersmask_plotpads ).any() )
100  continue;
101 
103 
104  if( layersmask_plotpads[B_SilkS] )
105  color = aBoard->Colors().GetLayerColor( B_SilkS );
106 
107  if( layersmask_plotpads[F_SilkS] )
108  color = ( color == COLOR4D::BLACK) ? aBoard->Colors().GetLayerColor( F_SilkS ) : color;
109 
110  itemplotter.PlotPad( pad, color, SKETCH );
111  }
112 
113  aPlotter->EndBlock( NULL );
114  }
115  }
116 
117  // Plot footprints fields (ref, value ...)
118  for( MODULE* module = aBoard->m_Modules; module; module = module->Next() )
119  {
120  if( ! itemplotter.PlotAllTextsModule( module ) )
121  {
122  wxLogMessage( _( "Your BOARD has a bad layer number for footprint %s" ),
123  GetChars( module->GetReference() ) );
124  }
125  }
126 
127  // Plot filled areas
128  aPlotter->StartBlock( NULL );
129 
130  for( int ii = 0; ii < aBoard->GetAreaCount(); ii++ )
131  {
132  ZONE_CONTAINER* edge_zone = aBoard->GetArea( ii );
133 
134  if( !aLayerMask[ edge_zone->GetLayer() ] )
135  continue;
136 
137  itemplotter.PlotFilledAreas( edge_zone );
138  }
139 
140  aPlotter->EndBlock( NULL );
141 
142  // Plot segments used to fill zone areas (outdated, but here for old boards
143  // compatibility):
144  for( SEGZONE* seg = aBoard->m_Zone; seg; seg = seg->Next() )
145  {
146  if( !aLayerMask[ seg->GetLayer() ] )
147  continue;
148 
149  aPlotter->ThickSegment( seg->GetStart(), seg->GetEnd(), seg->GetWidth(),
150  itemplotter.GetPlotMode(), NULL );
151  }
152 }
153 
154 void PlotOneBoardLayer( BOARD *aBoard, PLOTTER* aPlotter, PCB_LAYER_ID aLayer,
155  const PCB_PLOT_PARAMS& aPlotOpt )
156 {
157  PCB_PLOT_PARAMS plotOpt = aPlotOpt;
158  int soldermask_min_thickness = aBoard->GetDesignSettings().m_SolderMaskMinWidth;
159 
160  // Set a default color and the text mode for this layer
161  aPlotter->SetColor( aPlotOpt.GetColor() );
162  aPlotter->SetTextMode( aPlotOpt.GetTextMode() );
163 
164  // Specify that the contents of the "Edges Pcb" layer are to be plotted
165  // in addition to the contents of the currently specified layer.
166  LSET layer_mask( aLayer );
167 
168  if( !aPlotOpt.GetExcludeEdgeLayer() )
169  layer_mask.set( Edge_Cuts );
170 
171  if( IsCopperLayer( aLayer ) )
172  {
173  // Skip NPTH pads on copper layers ( only if hole size == pad size ):
174  // Drill mark will be plotted,
175  // if drill mark is SMALL_DRILL_SHAPE or FULL_DRILL_SHAPE
176  if( plotOpt.GetFormat() == PLOT_FORMAT_DXF )
177  {
178  plotOpt.SetSkipPlotNPTH_Pads( false );
179  PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
180  }
181  else
182  {
183  plotOpt.SetSkipPlotNPTH_Pads( true );
184  PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
185  }
186  }
187  else
188  {
189  switch( aLayer )
190  {
191  case B_Mask:
192  case F_Mask:
193  plotOpt.SetSkipPlotNPTH_Pads( false );
194  // Disable plot pad holes
196 
197  // Plot solder mask:
198  if( soldermask_min_thickness == 0 )
199  {
200  if( plotOpt.GetFormat() == PLOT_FORMAT_DXF )
201  PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
202  else
203  PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
204  }
205  else
206  PlotSolderMaskLayer( aBoard, aPlotter, layer_mask, plotOpt,
207  soldermask_min_thickness );
208 
209  break;
210 
211  case B_Adhes:
212  case F_Adhes:
213  case B_Paste:
214  case F_Paste:
215  plotOpt.SetSkipPlotNPTH_Pads( false );
216  // Disable plot pad holes
218 
219  if( plotOpt.GetFormat() == PLOT_FORMAT_DXF )
220  PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
221  else
222  PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
223  break;
224 
225  case F_SilkS:
226  case B_SilkS:
227  if( plotOpt.GetFormat() == PLOT_FORMAT_DXF && plotOpt.GetDXFPlotPolygonMode() )
228  // PlotLayerOutlines() is designed only for DXF plotters.
229  // and must not be used for other plot formats
230  PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
231  else
232  PlotSilkScreen( aBoard, aPlotter, layer_mask, plotOpt );
233 
234  // Gerber: Subtract soldermask from silkscreen if enabled
235  if( aPlotter->GetPlotterType() == PLOT_FORMAT_GERBER
236  && plotOpt.GetSubtractMaskFromSilk() )
237  {
238  if( aLayer == F_SilkS )
239  layer_mask = LSET( F_Mask );
240  else
241  layer_mask = LSET( B_Mask );
242 
243  // Create the mask to subtract by creating a negative layer polarity
244  aPlotter->SetLayerPolarity( false );
245 
246  // Disable plot pad holes
248 
249  // Plot the mask
250  PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
251  }
252  break;
253 
254  // These layers are plotted like silk screen layers.
255  // Mainly, pads on these layers are not filled.
256  // This is not necessary the best choice.
257  case Dwgs_User:
258  case Cmts_User:
259  case Eco1_User:
260  case Eco2_User:
261  case Edge_Cuts:
262  case Margin:
263  case F_CrtYd:
264  case B_CrtYd:
265  case F_Fab:
266  case B_Fab:
267  plotOpt.SetSkipPlotNPTH_Pads( false );
269 
270  if( plotOpt.GetFormat() == PLOT_FORMAT_DXF && plotOpt.GetDXFPlotPolygonMode() )
271  // PlotLayerOutlines() is designed only for DXF plotters.
272  // and must not be used for other plot formats
273  PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
274  else
275  PlotSilkScreen( aBoard, aPlotter, layer_mask, plotOpt );
276  break;
277 
278  default:
279  plotOpt.SetSkipPlotNPTH_Pads( false );
281 
282  if( plotOpt.GetFormat() == PLOT_FORMAT_DXF && plotOpt.GetDXFPlotPolygonMode() )
283  // PlotLayerOutlines() is designed only for DXF plotters.
284  // and must not be used for other plot formats
285  PlotLayerOutlines( aBoard, aPlotter, layer_mask, plotOpt );
286  else
287  PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
288  break;
289  }
290  }
291 }
292 
293 
294 /* Plot a copper layer or mask.
295  * Silk screen layers are not plotted here.
296  */
297 void PlotStandardLayer( BOARD *aBoard, PLOTTER* aPlotter,
298  LSET aLayerMask, const PCB_PLOT_PARAMS& aPlotOpt )
299 {
300  BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
301 
302  itemplotter.SetLayerSet( aLayerMask );
303 
304  EDA_DRAW_MODE_T plotMode = aPlotOpt.GetPlotMode();
305 
306  // Plot edge layer and graphic items
307  itemplotter.PlotBoardGraphicItems();
308 
309  // Draw footprint shapes without pads (pads will plotted later)
310  // We plot here module texts, but they are usually on silkscreen layer,
311  // so they are not plot here but plot by PlotSilkScreen()
312  // Plot footprints fields (ref, value ...)
313  for( MODULE* module = aBoard->m_Modules; module; module = module->Next() )
314  {
315  if( ! itemplotter.PlotAllTextsModule( module ) )
316  {
317  wxLogMessage( _( "Your BOARD has a bad layer number for footprint %s" ),
318  GetChars( module->GetReference() ) );
319  }
320  }
321 
322  for( MODULE* module = aBoard->m_Modules; module; module = module->Next() )
323  {
324  for( BOARD_ITEM* item = module->GraphicalItemsList(); item; item = item->Next() )
325  {
326  if( !aLayerMask[ item->GetLayer() ] )
327  continue;
328 
329  switch( item->Type() )
330  {
331  case PCB_MODULE_EDGE_T:
332  itemplotter.Plot_1_EdgeModule( (EDGE_MODULE*) item );
333  break;
334 
335  default:
336  break;
337  }
338  }
339  }
340 
341  // Plot footprint pads
342  for( MODULE* module = aBoard->m_Modules; module; module = module->Next() )
343  {
344  aPlotter->StartBlock( NULL );
345 
346  for( D_PAD* pad = module->PadsList(); pad; pad = pad->Next() )
347  {
348  if( (pad->GetLayerSet() & aLayerMask) == 0 )
349  continue;
350 
351  wxSize margin;
352  double width_adj = 0;
353 
354  if( ( aLayerMask & LSET::AllCuMask() ).any() )
355  width_adj = itemplotter.getFineWidthAdj();
356 
357  static const LSET speed( 4, B_Mask, F_Mask, B_Paste, F_Paste );
358 
359  LSET anded = ( speed & aLayerMask );
360 
361  if( anded == LSET( F_Mask ) || anded == LSET( B_Mask ) )
362  {
363  margin.x = margin.y = pad->GetSolderMaskMargin();
364  }
365  else if( anded == LSET( F_Paste ) || anded == LSET( B_Paste ) )
366  {
367  margin = pad->GetSolderPasteMargin();
368  }
369 
370  // Now offset the pad size by margin + width_adj
371  // this is easy for most shapes, but not for a trapezoid
372  wxSize padPlotsSize;
373  wxSize extraSize = margin * 2;
374  extraSize.x += width_adj;
375  extraSize.y += width_adj;
376  wxSize deltaSize = pad->GetDelta(); // has meaning only for trapezoidal pads
377 
378  if( pad->GetShape() == PAD_SHAPE_TRAPEZOID )
379  { // The easy way is to use BuildPadPolygon to calculate
380  // size and delta of the trapezoidal pad after offseting:
381  wxPoint coord[4];
382  pad->BuildPadPolygon( coord, extraSize/2, 0.0 );
383  // Calculate the size and delta from polygon corners coordinates:
384  // coord[0] is the lower left
385  // coord[1] is the upper left
386  // coord[2] is the upper right
387  // coord[3] is the lower right
388 
389  // the size is the distance between middle of segments
390  // (left/right or top/bottom)
391  // size X is the dist between left and right middle points:
392  padPlotsSize.x = ( ( -coord[0].x + coord[3].x ) // the lower segment X length
393  + ( -coord[1].x + coord[2].x ) ) // the upper segment X length
394  / 2; // the Y size is the half sum
395  // size Y is the dist between top and bottom middle points:
396  padPlotsSize.y = ( ( coord[0].y - coord[1].y ) // the left segment Y lenght
397  + ( coord[3].y - coord[2].y ) ) // the right segment Y lenght
398  / 2; // the Y size is the half sum
399 
400  // calculate the delta ( difference of lenght between 2 opposite edges )
401  // The delta.x is the delta along the X axis, therefore the delta of Y lenghts
402  wxSize delta;
403 
404  if( coord[0].y != coord[3].y )
405  delta.x = coord[0].y - coord[3].y;
406  else
407  delta.y = coord[1].x - coord[0].x;
408 
409  pad->SetDelta( delta );
410  }
411  else
412  padPlotsSize = pad->GetSize() + extraSize;
413 
414  // Don't draw a null size item :
415  if( padPlotsSize.x <= 0 || padPlotsSize.y <= 0 )
416  continue;
417 
419 
420  if( pad->GetLayerSet()[B_Cu] )
421  color = aBoard->Colors().GetItemColor( LAYER_PAD_BK );
422 
423  if( pad->GetLayerSet()[F_Cu] )
424  color = color.LegacyMix( aBoard->Colors().GetItemColor( LAYER_PAD_FR ) );
425 
426  // Temporary set the pad size to the required plot size:
427  wxSize tmppadsize = pad->GetSize();
428  pad->SetSize( padPlotsSize );
429 
430  switch( pad->GetShape() )
431  {
432  case PAD_SHAPE_CIRCLE:
433  case PAD_SHAPE_OVAL:
434  if( aPlotOpt.GetSkipPlotNPTH_Pads() &&
435  ( pad->GetSize() == pad->GetDrillSize() ) &&
436  ( pad->GetAttribute() == PAD_ATTRIB_HOLE_NOT_PLATED ) )
437  break;
438  // Fall through:
439  case PAD_SHAPE_TRAPEZOID:
440  case PAD_SHAPE_RECT:
441  case PAD_SHAPE_ROUNDRECT:
442  default:
443  itemplotter.PlotPad( pad, color, plotMode );
444  break;
445  }
446 
447  pad->SetSize( tmppadsize ); // Restore the pad size
448  pad->SetDelta( deltaSize );
449  }
450 
451  aPlotter->EndBlock( NULL );
452  }
453 
454  // Plot vias on copper layers, and if aPlotOpt.GetPlotViaOnMaskLayer() is true,
455  // plot them on solder mask
456 
457  GBR_METADATA gbr_metadata;
458 
459  bool isOnCopperLayer = ( aLayerMask & LSET::AllCuMask() ).any();
460 
461  if( isOnCopperLayer )
462  {
465  }
466 
467  aPlotter->StartBlock( NULL );
468 
469  for( TRACK* track = aBoard->m_Track; track; track = track->Next() )
470  {
471  const VIA* Via = dyn_cast<const VIA*>( track );
472 
473  if( !Via )
474  continue;
475 
476  // vias are not plotted if not on selected layer, but if layer
477  // is SOLDERMASK_LAYER_BACK or SOLDERMASK_LAYER_FRONT,vias are drawn,
478  // only if they are on the corresponding external copper layer
479  LSET via_mask_layer = Via->GetLayerSet();
480 
481  if( aPlotOpt.GetPlotViaOnMaskLayer() )
482  {
483  if( via_mask_layer[B_Cu] )
484  via_mask_layer.set( B_Mask );
485 
486  if( via_mask_layer[F_Cu] )
487  via_mask_layer.set( F_Mask );
488  }
489 
490  if( !( via_mask_layer & aLayerMask ).any() )
491  continue;
492 
493  int via_margin = 0;
494  double width_adj = 0;
495 
496  // If the current layer is a solder mask, use the global mask
497  // clearance for vias
498  if( aLayerMask[B_Mask] || aLayerMask[F_Mask] )
499  via_margin = aBoard->GetDesignSettings().m_SolderMaskMargin;
500 
501  if( ( aLayerMask & LSET::AllCuMask() ).any() )
502  width_adj = itemplotter.getFineWidthAdj();
503 
504  int diameter = Via->GetWidth() + 2 * via_margin + width_adj;
505 
506  // Don't draw a null size item :
507  if( diameter <= 0 )
508  continue;
509 
510  // Some vias can be not connected (no net).
511  // Set the m_NotInNet for these vias to force a empty net name in gerber file
512  gbr_metadata.m_NetlistMetadata.m_NotInNet = Via->GetNetname().IsEmpty();
513 
514  gbr_metadata.SetNetName( Via->GetNetname() );
515 
516  COLOR4D color = aBoard->Colors().GetItemColor( LAYER_VIAS + Via->GetViaType() );
517  // Set plot color (change WHITE to LIGHTGRAY because
518  // the white items are not seen on a white paper or screen
519  aPlotter->SetColor( color != WHITE ? color : LIGHTGRAY);
520  aPlotter->FlashPadCircle( Via->GetStart(), diameter, plotMode, &gbr_metadata );
521  }
522 
523  aPlotter->EndBlock( NULL );
524  aPlotter->StartBlock( NULL );
526 
527  // Plot tracks (not vias) :
528  for( TRACK* track = aBoard->m_Track; track; track = track->Next() )
529  {
530  if( track->Type() == PCB_VIA_T )
531  continue;
532 
533  if( !aLayerMask[track->GetLayer()] )
534  continue;
535 
536  // Some track segments can be not connected (no net).
537  // Set the m_NotInNet for these segments to force a empty net name in gerber file
538  gbr_metadata.m_NetlistMetadata.m_NotInNet = track->GetNetname().IsEmpty();
539 
540  gbr_metadata.SetNetName( track->GetNetname() );
541  int width = track->GetWidth() + itemplotter.getFineWidthAdj();
542  aPlotter->SetColor( itemplotter.getColor( track->GetLayer() ) );
543  aPlotter->ThickSegment( track->GetStart(), track->GetEnd(), width, plotMode, &gbr_metadata );
544  }
545 
546  aPlotter->EndBlock( NULL );
547 
548  // Plot zones (outdated, for old boards compatibility):
549  for( TRACK* track = aBoard->m_Zone; track; track = track->Next() )
550  {
551  if( !aLayerMask[track->GetLayer()] )
552  continue;
553 
554  int width = track->GetWidth() + itemplotter.getFineWidthAdj();
555  aPlotter->SetColor( itemplotter.getColor( track->GetLayer() ) );
556  aPlotter->ThickSegment( track->GetStart(), track->GetEnd(), width, plotMode, NULL );
557  }
558 
559  // Plot filled ares
560  aPlotter->StartBlock( NULL );
561  for( int ii = 0; ii < aBoard->GetAreaCount(); ii++ )
562  {
563  ZONE_CONTAINER* zone = aBoard->GetArea( ii );
564 
565  if( !aLayerMask[zone->GetLayer()] )
566  continue;
567 
568  itemplotter.PlotFilledAreas( zone );
569  }
570  aPlotter->EndBlock( NULL );
571 
572  // Adding drill marks, if required and if the plotter is able to plot them:
574  itemplotter.PlotDrillMarks();
575 }
576 
577 
578 // Seems like we want to plot from back to front?
579 static const PCB_LAYER_ID plot_seq[] = {
580 
581  B_Adhes, // 32
582  F_Adhes,
583  B_Paste,
584  F_Paste,
585  B_SilkS,
586  B_Mask,
587  F_Mask,
588  Dwgs_User,
589  Cmts_User,
590  Eco1_User,
591  Eco2_User,
592  Edge_Cuts,
593  Margin,
594 
595  F_CrtYd, // CrtYd & Body are footprint only
596  B_CrtYd,
597  F_Fab,
598  B_Fab,
599 
600  B_Cu,
601  In30_Cu,
602  In29_Cu,
603  In28_Cu,
604  In27_Cu,
605  In26_Cu,
606  In25_Cu,
607  In24_Cu,
608  In23_Cu,
609  In22_Cu,
610  In21_Cu,
611  In20_Cu,
612  In19_Cu,
613  In18_Cu,
614  In17_Cu,
615  In16_Cu,
616  In15_Cu,
617  In14_Cu,
618  In13_Cu,
619  In12_Cu,
620  In11_Cu,
621  In10_Cu,
622  In9_Cu,
623  In8_Cu,
624  In7_Cu,
625  In6_Cu,
626  In5_Cu,
627  In4_Cu,
628  In3_Cu,
629  In2_Cu,
630  In1_Cu,
631  F_Cu,
632 
633  F_SilkS,
634 };
635 
636 
637 /* Plot outlines of copper, for copper layer
638  */
639 void PlotLayerOutlines( BOARD* aBoard, PLOTTER* aPlotter,
640  LSET aLayerMask, const PCB_PLOT_PARAMS& aPlotOpt )
641 {
642 
643  BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
644  itemplotter.SetLayerSet( aLayerMask );
645 
646  SHAPE_POLY_SET outlines;
647 
648  for( LSEQ seq = aLayerMask.Seq( plot_seq, DIM( plot_seq ) ); seq; ++seq )
649  {
650  PCB_LAYER_ID layer = *seq;
651 
652  outlines.RemoveAllContours();
653  aBoard->ConvertBrdLayerToPolygonalContours( layer, outlines );
654 
655  outlines.Simplify( SHAPE_POLY_SET::PM_FAST );
656 
657  // Plot outlines
658  std::vector< wxPoint > cornerList;
659 
660  // Now we have one or more basic polygons: plot each polygon
661  for( int ii = 0; ii < outlines.OutlineCount(); ii++ )
662  {
663  for(int kk = 0; kk <= outlines.HoleCount (ii); kk++ )
664  {
665  cornerList.clear();
666  const SHAPE_LINE_CHAIN& path = (kk == 0) ? outlines.COutline( ii ) : outlines.CHole( ii, kk - 1 );
667 
668  for( int jj = 0; jj < path.PointCount(); jj++ )
669  cornerList.push_back( wxPoint( path.CPoint( jj ).x , path.CPoint( jj ).y ) );
670 
671 
672  // Ensure the polygon is closed
673  if( cornerList[0] != cornerList[cornerList.size() - 1] )
674  cornerList.push_back( cornerList[0] );
675 
676  aPlotter->PlotPoly( cornerList, NO_FILL );
677  }
678  }
679 
680  // Plot pad holes
682  {
683  int smallDrill = (aPlotOpt.GetDrillMarksType() == PCB_PLOT_PARAMS::SMALL_DRILL_SHAPE)
684  ? SMALL_DRILL : INT_MAX;
685 
686  for( MODULE* module = aBoard->m_Modules; module; module = module->Next() )
687  {
688  for( D_PAD* pad = module->PadsList(); pad; pad = pad->Next() )
689  {
690  wxSize hole = pad->GetDrillSize();
691 
692  if( hole.x == 0 || hole.y == 0 )
693  continue;
694 
695  if( hole.x == hole.y )
696  {
697  hole.x = std::min( smallDrill, hole.x );
698  aPlotter->Circle( pad->GetPosition(), hole.x, NO_FILL );
699  }
700  else
701  {
702  // Note: small drill marks have no significance when applied to slots
703  wxPoint drl_start, drl_end;
704  int width;
705  pad->GetOblongDrillGeometry( drl_start, drl_end, width );
706  aPlotter->ThickSegment( pad->GetPosition() + drl_start,
707  pad->GetPosition() + drl_end, width, SKETCH, NULL );
708  }
709  }
710  }
711  }
712 
713  // Plot vias holes
714  for( TRACK* track = aBoard->m_Track; track; track = track->Next() )
715  {
716  const VIA* via = dyn_cast<const VIA*>( track );
717 
718  if( via && via->IsOnLayer( layer ) ) // via holes can be not through holes
719  {
720  aPlotter->Circle( via->GetPosition(), via->GetDrillValue(), NO_FILL );
721  }
722  }
723  }
724 }
725 
726 
727 /* Plot a solder mask layer.
728  * Solder mask layers have a minimum thickness value and cannot be drawn like standard layers,
729  * unless the minimum thickness is 0.
730  * Currently the algo is:
731  * 1 - build all pad shapes as polygons with a size inflated by
732  * mask clearance + (min width solder mask /2)
733  * 2 - Merge shapes
734  * 3 - deflate result by (min width solder mask /2)
735  * 4 - ORing result by all pad shapes as polygons with a size inflated by
736  * mask clearance only (because deflate sometimes creates shape artifacts)
737  * 5 - draw result as polygons
738  *
739  * TODO:
740  * make this calculation only for shapes with clearance near than (min width solder mask)
741  * (using DRC algo)
742  * plot all other shapes by flashing the basing shape
743  * (shapes will be better, and calculations faster)
744  */
745 void PlotSolderMaskLayer( BOARD *aBoard, PLOTTER* aPlotter,
746  LSET aLayerMask, const PCB_PLOT_PARAMS& aPlotOpt,
747  int aMinThickness )
748 {
749  PCB_LAYER_ID layer = aLayerMask[B_Mask] ? B_Mask : F_Mask;
750  int inflate = aMinThickness/2;
751 
752  BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
753  itemplotter.SetLayerSet( aLayerMask );
754 
755  // Plot edge layer and graphic items
756  // They do not have a solder Mask margin, because they are only graphic items
757  // on this layer (like logos), not actually areas around pads.
758  itemplotter.PlotBoardGraphicItems();
759 
760  for( MODULE* module = aBoard->m_Modules; module; module = module->Next() )
761  {
762  for( BOARD_ITEM* item = module->GraphicalItemsList(); item; item = item->Next() )
763  {
764  if( layer != item->GetLayer() )
765  continue;
766 
767  switch( item->Type() )
768  {
769  case PCB_MODULE_EDGE_T:
770  itemplotter.Plot_1_EdgeModule( (EDGE_MODULE*) item );
771  break;
772 
773  default:
774  break;
775  }
776  }
777  }
778 
779  // Build polygons for each pad shape.
780  // the size of the shape on solder mask should be:
781  // size of pad + clearance around the pad.
782  // clearance = solder mask clearance + extra margin
783  // extra margin is half the min width for solder mask
784  // This extra margin is used to merge too close shapes
785  // (distance < aMinThickness), and will be removed when creating
786  // the actual shapes
787  SHAPE_POLY_SET areas; // Contains shapes to plot
788  SHAPE_POLY_SET initialPolys; // Contains exact shapes to plot
789 
790  /* calculates the coeff to compensate radius reduction of holes clearance
791  * due to the segment approx ( 1 /cos( PI/circleToSegmentsCount )
792  */
793  int circleToSegmentsCount = 32;
794  double correction = GetCircletoPolyCorrectionFactor( circleToSegmentsCount );
795 
796  // Plot pads
797  for( MODULE* module = aBoard->m_Modules; module; module = module->Next() )
798  {
799  // add shapes with exact size
800  module->TransformPadsShapesWithClearanceToPolygon( layer,
801  initialPolys, 0,
802  circleToSegmentsCount, correction );
803  // add shapes inflated by aMinThickness/2
804  module->TransformPadsShapesWithClearanceToPolygon( layer,
805  areas, inflate,
806  circleToSegmentsCount, correction );
807  }
808 
809  // Plot vias on solder masks, if aPlotOpt.GetPlotViaOnMaskLayer() is true,
810  if( aPlotOpt.GetPlotViaOnMaskLayer() )
811  {
812  // The current layer is a solder mask,
813  // use the global mask clearance for vias
814  int via_clearance = aBoard->GetDesignSettings().m_SolderMaskMargin;
815  int via_margin = via_clearance + inflate;
816 
817  for( TRACK* track = aBoard->m_Track; track; track = track->Next() )
818  {
819  const VIA* via = dyn_cast<const VIA*>( track );
820 
821  if( !via )
822  continue;
823 
824  // vias are plotted only if they are on the corresponding
825  // external copper layer
826  LSET via_set = via->GetLayerSet();
827 
828  if( via_set[B_Cu] )
829  via_set.set( B_Mask );
830 
831  if( via_set[F_Cu] )
832  via_set.set( F_Mask );
833 
834  if( !( via_set & aLayerMask ).any() )
835  continue;
836 
837  via->TransformShapeWithClearanceToPolygon( areas, via_margin,
838  circleToSegmentsCount,
839  correction );
840  via->TransformShapeWithClearanceToPolygon( initialPolys, via_clearance,
841  circleToSegmentsCount,
842  correction );
843  }
844  }
845 
846  // Add filled zone areas.
847 #if 0 // Set to 1 if a solder mask margin must be applied to zones on solder mask
848  int zone_margin = aBoard->GetDesignSettings().m_SolderMaskMargin;
849 #else
850  int zone_margin = 0;
851 #endif
852 
853  for( int ii = 0; ii < aBoard->GetAreaCount(); ii++ )
854  {
855  ZONE_CONTAINER* zone = aBoard->GetArea( ii );
856 
857  if( zone->GetLayer() != layer )
858  continue;
859 
861  inflate+zone_margin, false );
863  zone_margin, false );
864  }
865 
866  // To avoid a lot of code, use a ZONE_CONTAINER
867  // to handle and plot polygons, because our polygons look exactly like
868  // filled areas in zones
869  // Note, also this code is not optimized: it creates a lot of copy/duplicate data
870  // However it is not complex, and fast enough for plot purposes (copy/convert data
871  // is only a very small calculation time for these calculations)
872  ZONE_CONTAINER zone( aBoard );
873  zone.SetArcSegmentCount( 32 );
874  zone.SetMinThickness( 0 ); // trace polygons only
875  zone.SetLayer ( layer );
876 
877  areas.BooleanAdd( initialPolys, SHAPE_POLY_SET::PM_FAST );
878  areas.Inflate( -inflate, circleToSegmentsCount );
879 
880  // Combine the current areas to initial areas. This is mandatory because
881  // inflate/deflate transform is not perfect, and we want the initial areas perfectly kept
882  areas.BooleanAdd( initialPolys, SHAPE_POLY_SET::PM_FAST );
884 
885  zone.SetFilledPolysList( areas );
886 
887  itemplotter.PlotFilledAreas( &zone );
888 }
889 
890 
891 
897 static void initializePlotter( PLOTTER *aPlotter, BOARD * aBoard,
898  PCB_PLOT_PARAMS *aPlotOpts )
899 {
900  PAGE_INFO pageA4( wxT( "A4" ) );
901  const PAGE_INFO& pageInfo = aBoard->GetPageSettings();
902  const PAGE_INFO* sheet_info;
903  double paperscale; // Page-to-paper ratio
904  wxSize paperSizeIU;
905  wxSize pageSizeIU( pageInfo.GetSizeIU() );
906  bool autocenter = false;
907 
908  /* Special options: to fit the sheet to an A4 sheet replace
909  the paper size. However there is a difference between
910  the autoscale and the a4paper option:
911  - Autoscale fits the board to the paper size
912  - A4paper fits the original paper size to an A4 sheet
913  - Both of them fit the board to an A4 sheet
914  */
915  if( aPlotOpts->GetA4Output() ) // Fit paper to A4
916  {
917  sheet_info = &pageA4;
918  paperSizeIU = pageA4.GetSizeIU();
919  paperscale = (double) paperSizeIU.x / pageSizeIU.x;
920  autocenter = true;
921  }
922  else
923  {
924  sheet_info = &pageInfo;
925  paperSizeIU = pageSizeIU;
926  paperscale = 1;
927 
928  // Need autocentering only if scale is not 1:1
929  autocenter = (aPlotOpts->GetScale() != 1.0);
930  }
931 
932  EDA_RECT bbox = aBoard->ComputeBoundingBox();
933  wxPoint boardCenter = bbox.Centre();
934  wxSize boardSize = bbox.GetSize();
935 
936  double compound_scale;
937 
938  /* Fit to 80% of the page if asked; it could be that the board is empty,
939  * in this case regress to 1:1 scale */
940  if( aPlotOpts->GetAutoScale() && boardSize.x > 0 && boardSize.y > 0 )
941  {
942  double xscale = (paperSizeIU.x * 0.8) / boardSize.x;
943  double yscale = (paperSizeIU.y * 0.8) / boardSize.y;
944 
945  compound_scale = std::min( xscale, yscale ) * paperscale;
946  }
947  else
948  compound_scale = aPlotOpts->GetScale() * paperscale;
949 
950 
951  /* For the plot offset we have to keep in mind the auxiliary origin
952  too: if autoscaling is off we check that plot option (i.e. autoscaling
953  overrides auxiliary origin) */
954  wxPoint offset( 0, 0);
955 
956  if( autocenter )
957  {
958  offset.x = KiROUND( boardCenter.x - ( paperSizeIU.x / 2.0 ) / compound_scale );
959  offset.y = KiROUND( boardCenter.y - ( paperSizeIU.y / 2.0 ) / compound_scale );
960  }
961  else
962  {
963  if( aPlotOpts->GetUseAuxOrigin() )
964  offset = aBoard->GetAuxOrigin();
965  }
966 
967  /* Configure the plotter object with all the stuff computed and
968  most of that taken from the options */
969  aPlotter->SetPageSettings( *sheet_info );
970 
971  aPlotter->SetViewport( offset, IU_PER_MILS/10, compound_scale,
972  aPlotOpts->GetMirror() );
973  // has meaning only for gerber plotter. Must be called only after SetViewport
974  aPlotter->SetGerberCoordinatesFormat( aPlotOpts->GetGerberPrecision() );
975 
976  aPlotter->SetDefaultLineWidth( aPlotOpts->GetLineWidth() );
977  aPlotter->SetCreator( wxT( "PCBNEW" ) );
978  aPlotter->SetColorMode( false ); // default is plot in Black and White.
979  aPlotter->SetTextMode( aPlotOpts->GetTextMode() );
980 }
981 
984 static void FillNegativeKnockout( PLOTTER *aPlotter, const EDA_RECT &aBbbox )
985 {
986  const int margin = 5 * IU_PER_MM; // Add a 5 mm margin around the board
987  aPlotter->SetNegative( true );
988  aPlotter->SetColor( WHITE ); // Which will be plotted as black
989  EDA_RECT area = aBbbox;
990  area.Inflate( margin );
991  aPlotter->Rect( area.GetOrigin(), area.GetEnd(), FILLED_SHAPE );
992  aPlotter->SetColor( BLACK );
993 }
994 
997 static void ConfigureHPGLPenSizes( HPGL_PLOTTER *aPlotter,
998  PCB_PLOT_PARAMS *aPlotOpts )
999 {
1000  /* Compute pen_dim (the value is given in mils) in pcb units,
1001  with plot scale (if Scale is 2, pen diameter value is always m_HPGLPenDiam
1002  so apparent pen diam is actually pen diam / Scale */
1003  int pen_diam = KiROUND( aPlotOpts->GetHPGLPenDiameter() * IU_PER_MILS /
1004  aPlotOpts->GetScale() );
1005 
1006  // Set HPGL-specific options and start
1007  aPlotter->SetPenSpeed( aPlotOpts->GetHPGLPenSpeed() );
1008  aPlotter->SetPenNumber( aPlotOpts->GetHPGLPenNum() );
1009  aPlotter->SetPenDiameter( pen_diam );
1010 }
1011 
1018  int aLayer,
1019  const wxString& aFullFileName,
1020  const wxString& aSheetDesc )
1021 {
1022  // Create the plotter driver and set the few plotter specific
1023  // options
1024  PLOTTER* plotter = NULL;
1025 
1026  switch( aPlotOpts->GetFormat() )
1027  {
1028  case PLOT_FORMAT_DXF:
1029  plotter = new DXF_PLOTTER();
1030  break;
1031 
1032  case PLOT_FORMAT_POST:
1033  PS_PLOTTER* PS_plotter;
1034  PS_plotter = new PS_PLOTTER();
1035  PS_plotter->SetScaleAdjust( aPlotOpts->GetFineScaleAdjustX(),
1036  aPlotOpts->GetFineScaleAdjustY() );
1037  plotter = PS_plotter;
1038  break;
1039 
1040  case PLOT_FORMAT_PDF:
1041  plotter = new PDF_PLOTTER();
1042  break;
1043 
1044  case PLOT_FORMAT_HPGL:
1045  HPGL_PLOTTER* HPGL_plotter;
1046  HPGL_plotter = new HPGL_PLOTTER();
1047 
1048  /* HPGL options are a little more convoluted to compute, so
1049  they're split in another function */
1050  ConfigureHPGLPenSizes( HPGL_plotter, aPlotOpts );
1051  plotter = HPGL_plotter;
1052  break;
1053 
1054  case PLOT_FORMAT_GERBER:
1055  plotter = new GERBER_PLOTTER();
1056  break;
1057 
1058  case PLOT_FORMAT_SVG:
1059  plotter = new SVG_PLOTTER();
1060  break;
1061 
1062  default:
1063  wxASSERT( false );
1064  return NULL;
1065  }
1066 
1067  // Compute the viewport and set the other options
1068 
1069  // page layout is not mirrored, so temporary change mirror option
1070  // just to plot the page layout
1071  PCB_PLOT_PARAMS plotOpts = *aPlotOpts;
1072 
1073  if( plotOpts.GetPlotFrameRef() && plotOpts.GetMirror() )
1074  plotOpts.SetMirror( false );
1075 
1076  initializePlotter( plotter, aBoard, &plotOpts );
1077 
1078  if( plotter->OpenFile( aFullFileName ) )
1079  {
1080  plotter->ClearHeaderLinesList();
1081 
1082  // For the Gerber "file function" attribute, set the layer number
1083  if( plotter->GetPlotterType() == PLOT_FORMAT_GERBER )
1084  {
1085  bool useX2mode = plotOpts.GetUseGerberAttributes();
1086 
1087  if( useX2mode )
1088  {
1089  AddGerberX2Attribute( plotter, aBoard, aLayer, false );
1090  GERBER_PLOTTER* gbrplotter = static_cast <GERBER_PLOTTER*> ( plotter );
1091  gbrplotter->UseX2Attributes( true );
1092  gbrplotter->UseX2NetAttributes( plotOpts.GetIncludeGerberNetlistInfo() );
1093  }
1094  else
1095  {
1096  AddGerberX2Attribute( plotter, aBoard, aLayer, true );
1097  }
1098  }
1099 
1100  plotter->StartPlot();
1101 
1102  // Plot the frame reference if requested
1103  if( aPlotOpts->GetPlotFrameRef() )
1104  {
1105  PlotWorkSheet( plotter, aBoard->GetTitleBlock(),
1106  aBoard->GetPageSettings(),
1107  1, 1, // Only one page
1108  aSheetDesc, aBoard->GetFileName() );
1109 
1110  if( aPlotOpts->GetMirror() )
1111  initializePlotter( plotter, aBoard, aPlotOpts );
1112  }
1113 
1114  /* When plotting a negative board: draw a black rectangle
1115  * (background for plot board in white) and switch the current
1116  * color to WHITE; note the color inversion is actually done
1117  * in the driver (if supported) */
1118  if( aPlotOpts->GetNegative() )
1119  {
1120  EDA_RECT bbox = aBoard->ComputeBoundingBox();
1121  FillNegativeKnockout( plotter, bbox );
1122  }
1123 
1124  return plotter;
1125  }
1126 
1127  delete plotter;
1128  return NULL;
1129 }
void SetFilledPolysList(SHAPE_POLY_SET &aPolysList)
Function SetFilledPolysList sets the list of filled polygons.
Definition: class_zone.h:545
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
#define DIM(x)
of elements in an array
Definition: macros.h:98
int m_SolderMaskMargin
Solder mask margin.
#define SMALL_DRILL
Definition: pcbplot.h:72
bool GetMirror() const
Class ZONE_CONTAINER handles a list of polygons defining a copper zone.
Definition: class_zone.h:60
bool GetSubtractMaskFromSilk() const
bool GetAutoScale() const
int GetHPGLPenDiameter() const
virtual void SetCreator(const wxString &aCreator)
Definition: plotter.h:160
double GetScale() const
const wxPoint GetOrigin() const
Definition: eda_rect.h:112
void UseX2NetAttributes(bool aEnable)
Definition: plotter.h:1137
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
TEXTE_PCB class definition.
virtual LSET GetLayerSet() const override
Function GetLayerSet returns a "layer mask", which is a bitmap of all layers on which the TRACK segme...
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
like PAD_STANDARD, but not plated mechanical use only, no connection allowed
Definition: pad_shapes.h:65
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...
void BooleanAdd(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Performs boolean polyset union For aFastMode meaning, see function booleanOp
virtual bool StartPlot()=0
Class BOARD_ITEM is a base class for any item which can be embedded within the BOARD container class...
const wxSize GetSize() const
Definition: eda_rect.h:101
virtual void SetColor(COLOR4D color)=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
int PointCount() const
Function PointCount()
EDA_RECT ComputeBoundingBox(bool aBoardEdgesOnly=false) const
Function ComputeBoundingBox calculates the bounding box containing all board items (or board edge seg...
void PlotPad(D_PAD *aPad, COLOR4D aColor, EDA_DRAW_MODE_T aPlotMode)
Plot a pad.
a class to handle special data during plot.
virtual bool OpenFile(const wxString &aFullFilename)
Open or create the plot file aFullFilename.
Definition: plotter.cpp:82
void SetNetAttribType(int aNetAttribType)
Class BOARD to handle a board.
void SetScaleAdjust(double scaleX, double scaleY)
Set the &#39;fine&#39; scaling for the postscript engine.
Definition: plotter.h:683
virtual void SetLayerPolarity(bool aPositive)
Function SetLayerPolarity sets current Gerber layer polarity to positive or negative by writing %LPD*...
Definition: plotter.h:418
static const PCB_LAYER_ID plot_seq[]
void PlotStandardLayer(BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt)
Function PlotStandardLayer plot copper or technical layers.
int color
Definition: DXF_plotter.cpp:62
MODULE * Next() const
Definition: class_module.h:121
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...
int HoleCount(int aOutline) const
Returns the number of holes in a given outline
virtual PCB_LAYER_ID GetLayer() const override
Function GetLayer returns the primary layer this item is on.
Definition: class_zone.cpp:175
void PlotDrillMarks()
Function PlotDrillMarks Draw a drill mark for pads and vias.
void SetMirror(bool aFlag)
virtual void SetPenDiameter(double diameter)
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
bool PlotAllTextsModule(MODULE *aModule)
Classes to handle copper zones.
DLIST< SEGZONE > m_Zone
Definition: class_board.h:247
void SetArcSegmentCount(int aArcSegCount)
Definition: class_zone.h:186
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
const SHAPE_LINE_CHAIN & CHole(int aOutline, int aHole) const
bool GetUseAuxOrigin() const
int OutlineCount() const
Returns the number of outlines in the set
void SetDrillMarksType(DrillMarksType aVal)
virtual void PlotPoly(const std::vector< wxPoint > &aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void *aData=NULL)=0
Function PlotPoly.
virtual void SetPageSettings(const PAGE_INFO &aPageSettings)
Definition: plotter.cpp:538
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
double GetFineScaleAdjustX() const
virtual void SetGerberCoordinatesFormat(int aResolution, bool aUseInches=false)
Definition: plotter.h:432
void PlotWorkSheet(PLOTTER *plotter, const TITLE_BLOCK &aTitleBlock, const PAGE_INFO &aPageInfo, int aSheetNumber, int aNumberOfSheets, const wxString &aSheetDesc, const wxString &aFilename)
Functions relatives to tracks, vias and segments used to fill zones.
This file contains miscellaneous commonly used macros and functions.
bool GetA4Output() const
void PlotFilledAreas(ZONE_CONTAINER *aZone)
SEGZONE * Next() const
Definition: class_track.h:364
Classes used in Pcbnew, CvPcb and GerbView.
bool GetExcludeEdgeLayer() const
Board plot function definition file.
static void PlotSolderMaskLayer(BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt, int aMinThickness)
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
BOARD_ITEM * Next() const
COLOR4D GetItemColor(int aItemIdx) const
Function GetItemColor.
DIMENSION class definition.
virtual void FlashPadCircle(const wxPoint &aPadPos, int aDiameter, EDA_DRAW_MODE_T aTraceMode, void *aData)=0
virtual function FlashPadCircle
void PlotLayerOutlines(BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt)
Function PlotLayerOutlines plot copper outline of a copper layer.
DrillMarksType GetDrillMarksType() const
PCB_LAYER_ID
A quick note on layer IDs:
bool GetIncludeGerberNetlistInfo() const
Class LSET is a set of PCB_LAYER_IDs.
void SetLayerSet(LSET aLayerMask)
Definition: pcbplot.h:104
void Inflate(int aFactor, int aCircleSegmentsCount)
Performs outline inflation/deflation, using round corners.
int GetLineWidth() const
VIATYPE_T GetViaType() const
Definition: class_track.h:458
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.
int GetHPGLPenNum() const
const wxString & GetFileName() const
Definition: class_board.h:234
Class SHAPE_POLY_SET.
EDA_DRAW_MODE_T
Definition: eda_text.h:62
const COLORS_DESIGN_SETTINGS & Colors() const
Function GetColorSettings.
Definition: class_board.h:563
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
void PlotBoardGraphicItems()
plot items like text and graphics, but not tracks and modules
virtual void SetTextMode(PlotTextMode mode)
Change the current text mode.
Definition: plotter.h:427
const wxPoint & GetStart() const
Definition: class_track.h:122
virtual void SetPenSpeed(int speed)
Definition: plotter.h:605
void Plot_1_EdgeModule(EDGE_MODULE *aEdge)
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...
D_PAD * Next() const
Definition: class_pad.h:160
void SetSkipPlotNPTH_Pads(bool aSkip)
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
void ConvertBrdLayerToPolygonalContours(PCB_LAYER_ID aLayer, SHAPE_POLY_SET &aOutlines)
Function ConvertBrdLayerToPolygonalContours Build a set of polygons which are the outlines of copper ...
bool GetPlotViaOnMaskLayer() const
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
a few functions useful in geometry calculations.
void Simplify(POLYGON_MODE aFastMode)
Simplifies the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) For aFast...
int GetAreaCount() const
Function GetAreaCount.
Definition: class_board.h:1011
static void ConfigureHPGLPenSizes(HPGL_PLOTTER *aPlotter, PCB_PLOT_PARAMS *aPlotOpts)
Calculate the effective size of HPGL pens and set them in the plotter object.
wxPoint Centre() const
Definition: eda_rect.h:60
PlotFormat GetFormat() const
Class PCB_PLOT_PARAMS handles plot parameters and options when plotting/printing a board...
const wxPoint GetPosition() const override
Definition: class_track.h:430
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 prepar...
void Fracture(POLYGON_MODE aFastMode)
Converts a set of polygons with holes to a singe outline with "slits"/"fractures" connecting the oute...
Class LSEQ is a sequence (and therefore also a set) of PCB_LAYER_IDs.
const PAGE_INFO & GetPageSettings() const
Definition: class_board.h:547
COLOR4D GetColor() const
virtual void SetViewport(const wxPoint &aOffset, double aIusPerDecimil, double aScale, bool aMirror)=0
Set the plot offset and scaling for the current plot.
aperture used for connected items like tracks (not vias)
const wxPoint GetEnd() const
Definition: eda_rect.h:114
bool GetDXFPlotPolygonMode() const
virtual void SetDefaultLineWidth(int width)=0
Set the default line width.
const wxPoint & GetAuxOrigin() const
Definition: class_board.h:343
void TransformOutlinesShapeWithClearanceToPolygon(SHAPE_POLY_SET &aCornerBuffer, int aMinClearanceValue, bool aUseNetClearance) const
Function TransformOutlinesShapeWithClearanceToPolygon Convert the outlines shape to a polygon with no...
void SetNetName(const wxString &aNetname)
Base plotter engine class.
Definition: plotter.h:96
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
TITLE_BLOCK & GetTitleBlock()
Definition: class_board.h:553
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
Class to handle a graphic segment.
int GetDrillValue() const
Function GetDrillValue "calculates" the drill value for vias (m-Drill if > 0, or default drill value ...
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:169
DLIST< MODULE > m_Modules
Definition: class_board.h:245
Class SHAPE_LINE_CHAIN.
bool GetNegative() const
int GetWidth() const
Definition: class_track.h:116
virtual PlotFormat GetPlotterType() const =0
Returns the effective plot engine in use.
virtual void ThickSegment(const wxPoint &start, const wxPoint &end, int width, EDA_DRAW_MODE_T tracemode, void *aData)
Definition: plotter.cpp:457
bool GetPlotFrameRef() const
virtual void SetPenNumber(int number)
Definition: plotter.h:610
void RemoveAllContours()
Removes all outlines & holes (clears) the polygon set.
int GetHPGLPenSpeed() const
EDA_DRAW_MODE_T GetPlotMode() const
Class EDA_RECT handles the component boundary box.
Definition: eda_rect.h:44
bool GetPlotPadsOnSilkLayer() const
The common library.
virtual void Rect(const wxPoint &p1, const wxPoint &p2, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)=0
COLOR4D GetLayerColor(LAYER_NUM aLayer) const
Function GetLayerColor.
void ClearHeaderLinesList()
Function ClearHeaderLinesList remove all lines from the list of free lines to print at the beginning ...
Definition: plotter.h:184
Definition: colors.h:49
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
PCB_TARGET class definition.
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
int getFineWidthAdj()
Definition: pcbplot.h:95
DLIST< TRACK > m_Track
Definition: class_board.h:246
GBR_NETLIST_METADATA m_NetlistMetadata
a item to handle object attribute:
bool IsOnLayer(PCB_LAYER_ID aLayer) const override
Function IsOnLayer tests to see if this object is on the given layer.
Module description (excepted pads)
Definition: colors.h:45
Basic classes for most KiCad items.
EDGE_MODULE class definition.
void SetMinThickness(int aMinThickness)
Definition: class_zone.h:199
const VECTOR2I & CPoint(int aIndex) const
Function CPoint()
print info associated to a net (TO.N attribute)
void UseX2Attributes(bool aEnable)
Definition: plotter.h:1136
COLOR4D getColor(LAYER_NUM aLayer)
Function getColor.
virtual void SetNegative(bool _negative)
Definition: plotter.h:120
virtual void Circle(const wxPoint &pos, int diametre, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)=0
virtual void SetColorMode(bool _color_mode)
Definition: plotter.h:125
double GetFineScaleAdjustY() const
EDA_RECT & Inflate(wxCoord dx, wxCoord dy)
Function Inflate inflates the rectangle horizontally by dx and vertically by dy.
int m_SolderMaskMinWidth
Solder mask min width.
#define min(a, b)
Definition: auxiliary.h:85
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
int GetGerberPrecision() const
double GetCircletoPolyCorrectionFactor(int aSegCountforCircle)