KiCad PCB EDA Suite
GENDRILL_WRITER_BASE Class Reference

Create drill maps and drill reports and drill files. More...

#include <gendrill_file_writer_base.h>

Inheritance diagram for GENDRILL_WRITER_BASE:
EXCELLON_WRITER GERBER_WRITER

Public Types

enum  ZEROS_FMT { DECIMAL_FORMAT, SUPPRESS_LEADING, SUPPRESS_TRAILING, KEEP_ZEROS }
 
enum  TYPE_FILE { PTH_FILE, NPTH_FILE, MIXED_FILE }
 

Public Member Functions

virtual ~GENDRILL_WRITER_BASE ()
 
void SetMergeOption (bool aMerge)
 Set the option to make separate drill files for PTH and NPTH. More...
 
wxPoint GetOffset ()
 Return the plot offset (usually the position of the drill/place origin). More...
 
void SetPageInfo (const PAGE_INFO *aPageInfo)
 Set the page info used to plot drill maps. More...
 
void SetMapFileFormat (PLOT_FORMAT aMapFmt)
 Initialize the format for the drill map file. More...
 
void CreateMapFilesSet (const wxString &aPlotDirectory, REPORTER *aReporter=nullptr)
 Create the full set of map files for the board, in PS, PDF ... More...
 
bool GenDrillReportFile (const wxString &aFullFileName)
 Create a plain text report file giving a list of drill values and drill count for through holes, oblong holes, and for buried vias, drill values and drill count per layer pair there is only one report for all drill files even when buried or blinds vias exist. More...
 

Protected Member Functions

bool genDrillMapFile (const wxString &aFullFileName, PLOT_FORMAT aFormat)
 Plot a map of drill marks for holes. More...
 
void buildHolesList (DRILL_LAYER_PAIR aLayerPair, bool aGenerateNPTH_list)
 Create the list of holes and tools for a given board. More...
 
int getHolesCount () const
 
bool plotDrillMarks (PLOTTER *aPlotter)
 Write the drill marks in HPGL, POSTSCRIPT or other supported formats/. More...
 
std::vector< DRILL_LAYER_PAIRgetUniqueLayerPairs () const
 Get unique layer pairs by examining the micro and blind_buried vias. More...
 
unsigned printToolSummary (OUTPUTFORMATTER &aOut, bool aSummaryNPTH) const
 Print m_toolListBuffer[] tools to aOut and returns total hole count. More...
 
const std::string layerPairName (DRILL_LAYER_PAIR aPair) const
 
const std::string layerName (PCB_LAYER_ID aLayer) const
 
virtual const wxString getDrillFileName (DRILL_LAYER_PAIR aPair, bool aNPTH, bool aMerge_PTH_NPTH) const
 
const wxString BuildFileFunctionAttributeString (DRILL_LAYER_PAIR aLayerPair, TYPE_FILE aHoleType, bool aCompatNCdrill=false) const
 
 GENDRILL_WRITER_BASE (BOARD *aPcb)
 

Protected Attributes

BOARDm_pcb
 
wxString m_drillFileExtension
 
bool m_unitsMetric
 
ZEROS_FMT m_zeroFormat
 
DRILL_PRECISION m_precision
 
double m_conversionUnits
 
wxPoint m_offset
 
bool m_merge_PTH_NPTH
 
std::vector< HOLE_INFOm_holeListBuffer
 
std::vector< DRILL_TOOLm_toolListBuffer
 
PLOT_FORMAT m_mapFileFmt
 
const PAGE_INFOm_pageInfo
 

Detailed Description

Create drill maps and drill reports and drill files.

Drill files are created by specialized derived classes, depending on the file format.

Definition at line 152 of file gendrill_file_writer_base.h.

Member Enumeration Documentation

◆ TYPE_FILE

Enumerator
PTH_FILE 
NPTH_FILE 
MIXED_FILE 

Definition at line 162 of file gendrill_file_writer_base.h.

162  { // type of holes in file: PTH, NPTH, mixed
163  PTH_FILE, // PTH only, this is the default also for blind/buried holes
164  NPTH_FILE, // NPTH only
165  MIXED_FILE // PHT+NPTH (mixed)
166  };

◆ ZEROS_FMT

Enumerator
DECIMAL_FORMAT 
SUPPRESS_LEADING 
SUPPRESS_TRAILING 
KEEP_ZEROS 

Definition at line 155 of file gendrill_file_writer_base.h.

155  { // Zero format in coordinates
156  DECIMAL_FORMAT, // Floating point coordinates
157  SUPPRESS_LEADING, // Suppress leading zeros
158  SUPPRESS_TRAILING, // Suppress trailing zeros
159  KEEP_ZEROS // keep zeros
160  };

Constructor & Destructor Documentation

◆ ~GENDRILL_WRITER_BASE()

virtual GENDRILL_WRITER_BASE::~GENDRILL_WRITER_BASE ( )
inlinevirtual

Definition at line 168 of file gendrill_file_writer_base.h.

169  {
170  }

◆ GENDRILL_WRITER_BASE()

Member Function Documentation

◆ BuildFileFunctionAttributeString()

const wxString GENDRILL_WRITER_BASE::BuildFileFunctionAttributeString ( DRILL_LAYER_PAIR  aLayerPair,
TYPE_FILE  aHoleType,
bool  aCompatNCdrill = false 
) const
protected
Parameters
aLayerPairis the layer pair (Drill from rom first layer to second layer)
aHoleTypeis type of drill file (PTH, NPTH, mixed)
aCompatNCdrillis true when generating NC (Excellon) compatible drill file
Returns
a wxString containing the .FileFunction attribute. the standard X2 FileFunction for drill files is TF.FileFunction,Plated[NonPlated],layer1num,layer2num,PTH[NPTH][Blind][Buried], Drill[Route][Mixed]*% There is no X1 version, as the Gerber drill files uses only X2 format There is a compatible NC drill version.

Definition at line 363 of file gendrill_file_writer_base.cpp.

366 {
367 // Build a wxString containing the .FileFunction attribute for drill files.
368 // %TF.FileFunction,Plated[NonPlated],layer1num,layer2num,PTH[NPTH][Blind][Buried],Drill[Route][Mixed]*%
369  wxString text;
370 
371  if( aCompatNCdrill )
372  text = "; #@! ";
373  else
374  text = "%";
375 
376  text << "TF.FileFunction,";
377 
378  if( aHoleType == NPTH_FILE )
379  text << "NonPlated,";
380  else if( aHoleType == MIXED_FILE ) // only for Excellon format
381  text << "MixedPlating,";
382  else
383  text << "Plated,";
384 
385  int layer1 = aLayerPair.first;
386  int layer2 = aLayerPair.second;
387  // In Gerber files, layers num are 1 to copper layer count instead of F_Cu to B_Cu
388  // (0 to copper layer count-1)
389  // Note also for a n copper layers board, gerber layers num are 1 ... n
390  layer1 += 1;
391 
392  if( layer2 == B_Cu )
393  layer2 = m_pcb->GetCopperLayerCount();
394  else
395  layer2 += 1;
396 
397  text << layer1 << "," << layer2;
398 
399  // Now add PTH or NPTH or Blind or Buried attribute
400  int toplayer = 1;
401  int bottomlayer = m_pcb->GetCopperLayerCount();
402 
403  if( aHoleType == NPTH_FILE )
404  text << ",NPTH";
405  else if( aHoleType == MIXED_FILE ) // only for Excellon format
406  {
407  // write nothing
408  }
409  else if( layer1 == toplayer && layer2 == bottomlayer )
410  text << ",PTH";
411  else if( layer1 == toplayer || layer2 == bottomlayer )
412  text << ",Blind";
413  else
414  text << ",Buried";
415 
416  // In NC drill file, these previous parameters should be enough:
417  if( aCompatNCdrill )
418  return text;
419 
420 
421  // Now add Drill or Route or Mixed:
422  // file containing only round holes have Drill attribute
423  // file containing only oblong holes have Routed attribute
424  // file containing both holes have Mixed attribute
425  bool hasOblong = false;
426  bool hasDrill = false;
427 
428  for( unsigned ii = 0; ii < m_holeListBuffer.size(); ii++ )
429  {
430  const HOLE_INFO& hole_descr = m_holeListBuffer[ii];
431 
432  if( hole_descr.m_Hole_Shape ) // m_Hole_Shape not 0 is an oblong hole)
433  hasOblong = true;
434  else
435  hasDrill = true;
436  }
437 
438  if( hasOblong && hasDrill )
439  text << ",Mixed";
440  else if( hasDrill )
441  text << ",Drill";
442  else if( hasOblong )
443  text << ",Route";
444 
445  // else: empty file.
446 
447  // End of .FileFunction attribute:
448  text << "*%";
449 
450  return text;
451 }
Handle hole which must be drilled (diameter, position and layers).
int GetCopperLayerCount() const
Definition: board.cpp:455
std::vector< HOLE_INFO > m_holeListBuffer

References B_Cu, BOARD::GetCopperLayerCount(), HOLE_INFO::m_Hole_Shape, m_holeListBuffer, m_pcb, MIXED_FILE, NPTH_FILE, and text.

Referenced by GERBER_WRITER::createDrillFile(), and EXCELLON_WRITER::writeEXCELLONHeader().

◆ buildHolesList()

void GENDRILL_WRITER_BASE::buildHolesList ( DRILL_LAYER_PAIR  aLayerPair,
bool  aGenerateNPTH_list 
)
protected

Create the list of holes and tools for a given board.

The list is sorted by increasing drill size. Only holes included within aLayerPair are listed. If aLayerPair identifies with [F_Cu, B_Cu], then pad holes are always included also.

Parameters
aLayerPairis an inclusive range of layers.
aGenerateNPTH_list: true to create NPTH only list (with no plated holes) false to created plated holes list (with no NPTH )

Definition at line 66 of file gendrill_file_writer_base.cpp.

68 {
69  HOLE_INFO new_hole;
70 
71  m_holeListBuffer.clear();
72  m_toolListBuffer.clear();
73 
74  wxASSERT( aLayerPair.first < aLayerPair.second ); // fix the caller
75 
76  // build hole list for vias
77  if( ! aGenerateNPTH_list ) // vias are always plated !
78  {
79  for( auto track : m_pcb->Tracks() )
80  {
81  if( track->Type() != PCB_VIA_T )
82  continue;
83 
84  PCB_VIA* via = static_cast<PCB_VIA*>( track );
85  int hole_sz = via->GetDrillValue();
86 
87  if( hole_sz == 0 ) // Should not occur.
88  continue;
89 
90  new_hole.m_ItemParent = via;
91 
92  if( aLayerPair == DRILL_LAYER_PAIR( F_Cu, B_Cu ) )
94  else
96 
97  new_hole.m_Tool_Reference = -1; // Flag value for Not initialized
98  new_hole.m_Hole_Orient = 0;
99  new_hole.m_Hole_Diameter = hole_sz;
100  new_hole.m_Hole_NotPlated = false;
101  new_hole.m_Hole_Size.x = new_hole.m_Hole_Size.y = new_hole.m_Hole_Diameter;
102 
103  new_hole.m_Hole_Shape = 0; // hole shape: round
104  new_hole.m_Hole_Pos = via->GetStart();
105 
106  via->LayerPair( &new_hole.m_Hole_Top_Layer, &new_hole.m_Hole_Bottom_Layer );
107 
108  // LayerPair() returns params with m_Hole_Bottom_Layer > m_Hole_Top_Layer
109  // Remember: top layer = 0 and bottom layer = 31 for through hole vias
110  // Any captured via should be from aLayerPair.first to aLayerPair.second exactly.
111  if( new_hole.m_Hole_Top_Layer != aLayerPair.first ||
112  new_hole.m_Hole_Bottom_Layer != aLayerPair.second )
113  continue;
114 
115  m_holeListBuffer.push_back( new_hole );
116  }
117  }
118 
119  if( aLayerPair == DRILL_LAYER_PAIR( F_Cu, B_Cu ) )
120  {
121  // add holes for thru hole pads
122  for( FOOTPRINT* footprint : m_pcb->Footprints() )
123  {
124  for( PAD* pad : footprint->Pads() )
125  {
126  if( !m_merge_PTH_NPTH )
127  {
128  if( !aGenerateNPTH_list && pad->GetAttribute() == PAD_ATTRIB::NPTH )
129  continue;
130 
131  if( aGenerateNPTH_list && pad->GetAttribute() != PAD_ATTRIB::NPTH )
132  continue;
133  }
134 
135  if( pad->GetDrillSize().x == 0 )
136  continue;
137 
138  new_hole.m_ItemParent = pad;
139  new_hole.m_Hole_NotPlated = (pad->GetAttribute() == PAD_ATTRIB::NPTH);
140  new_hole.m_HoleAttribute = new_hole.m_Hole_NotPlated
143  new_hole.m_Tool_Reference = -1; // Flag is: Not initialized
144  new_hole.m_Hole_Orient = pad->GetOrientation();
145  new_hole.m_Hole_Shape = 0; // hole shape: round
146  new_hole.m_Hole_Diameter = std::min( pad->GetDrillSize().x, pad->GetDrillSize().y );
147  new_hole.m_Hole_Size.x = new_hole.m_Hole_Size.y = new_hole.m_Hole_Diameter;
148 
149  if( pad->GetDrillShape() != PAD_DRILL_SHAPE_CIRCLE )
150  new_hole.m_Hole_Shape = 1; // oval flag set
151 
152  new_hole.m_Hole_Size = pad->GetDrillSize();
153  new_hole.m_Hole_Pos = pad->GetPosition(); // hole position
154  new_hole.m_Hole_Bottom_Layer = B_Cu;
155  new_hole.m_Hole_Top_Layer = F_Cu; // pad holes are through holes
156  m_holeListBuffer.push_back( new_hole );
157  }
158  }
159  }
160 
161  // Sort holes per increasing diameter value (and for each dimater, by position)
162  sort( m_holeListBuffer.begin(), m_holeListBuffer.end(), cmpHoleSorting );
163 
164  // build the tool list
165  int last_hole = -1; // Set to not initialized (this is a value not used
166  // for m_holeListBuffer[ii].m_Hole_Diameter)
167  bool last_notplated_opt = false;
169 
170  DRILL_TOOL new_tool( 0, false );
171  unsigned jj;
172 
173  for( unsigned ii = 0; ii < m_holeListBuffer.size(); ii++ )
174  {
175  if( m_holeListBuffer[ii].m_Hole_Diameter != last_hole
176  || m_holeListBuffer[ii].m_Hole_NotPlated != last_notplated_opt
178  || m_holeListBuffer[ii].m_HoleAttribute != last_attribute
179 #endif
180  )
181  {
182  new_tool.m_Diameter = m_holeListBuffer[ii].m_Hole_Diameter;
183  new_tool.m_Hole_NotPlated = m_holeListBuffer[ii].m_Hole_NotPlated;
184  new_tool.m_HoleAttribute = m_holeListBuffer[ii].m_HoleAttribute;
185  m_toolListBuffer.push_back( new_tool );
186  last_hole = new_tool.m_Diameter;
187  last_notplated_opt = new_tool.m_Hole_NotPlated;
188  last_attribute = new_tool.m_HoleAttribute;
189  }
190 
191  jj = m_toolListBuffer.size();
192 
193  if( jj == 0 )
194  continue; // Should not occurs
195 
196  m_holeListBuffer[ii].m_Tool_Reference = jj; // Tool value Initialized (value >= 1)
197 
198  m_toolListBuffer.back().m_TotalCount++;
199 
200  if( m_holeListBuffer[ii].m_Hole_Shape )
201  m_toolListBuffer.back().m_OvalCount++;
202  }
203 }
BOARD_ITEM * m_ItemParent
#define USE_ATTRIB_FOR_HOLES
std::vector< DRILL_TOOL > m_toolListBuffer
like PAD_PTH, but not plated
FOOTPRINTS & Footprints()
Definition: board.h:234
Handle hole which must be drilled (diameter, position and layers).
std::pair< PCB_LAYER_ID, PCB_LAYER_ID > DRILL_LAYER_PAIR
PCB_LAYER_ID m_Hole_Bottom_Layer
HOLE_ATTRIBUTE m_HoleAttribute
PCB_LAYER_ID m_Hole_Top_Layer
Definition: layer_ids.h:71
static bool cmpHoleSorting(const HOLE_INFO &a, const HOLE_INFO &b)
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
Definition: pad.h:57
std::vector< HOLE_INFO > m_holeListBuffer
TRACKS & Tracks()
Definition: board.h:231

References B_Cu, cmpHoleSorting(), F_Cu, BOARD::Footprints(), HOLE_MECHANICAL, HOLE_PAD, HOLE_UNKNOWN, HOLE_VIA_BURIED, HOLE_VIA_THROUGH, DRILL_TOOL::m_Diameter, HOLE_INFO::m_Hole_Bottom_Layer, HOLE_INFO::m_Hole_Diameter, DRILL_TOOL::m_Hole_NotPlated, HOLE_INFO::m_Hole_NotPlated, HOLE_INFO::m_Hole_Orient, HOLE_INFO::m_Hole_Pos, HOLE_INFO::m_Hole_Shape, HOLE_INFO::m_Hole_Size, HOLE_INFO::m_Hole_Top_Layer, DRILL_TOOL::m_HoleAttribute, HOLE_INFO::m_HoleAttribute, m_holeListBuffer, HOLE_INFO::m_ItemParent, m_merge_PTH_NPTH, m_pcb, HOLE_INFO::m_Tool_Reference, m_toolListBuffer, NPTH, pad, PAD_DRILL_SHAPE_CIRCLE, PCB_VIA_T, BOARD::Tracks(), USE_ATTRIB_FOR_HOLES, and via.

Referenced by GERBER_WRITER::CreateDrillandMapFilesSet(), EXCELLON_WRITER::CreateDrillandMapFilesSet(), CreateMapFilesSet(), and GenDrillReportFile().

◆ CreateMapFilesSet()

void GENDRILL_WRITER_BASE::CreateMapFilesSet ( const wxString &  aPlotDirectory,
REPORTER aReporter = nullptr 
)

Create the full set of map files for the board, in PS, PDF ...

format (use SetMapFileFormat() to select the format).

File names are computed from the board name and layer ID.

Parameters
aPlotDirectoryis the output folder.
aReporteris a REPORTER to return activity or any message (can be NULL)

Definition at line 304 of file gendrill_file_writer_base.cpp.

306 {
307  wxFileName fn;
308  wxString msg;
309 
310  std::vector<DRILL_LAYER_PAIR> hole_sets = getUniqueLayerPairs();
311 
312  // append a pair representing the NPTH set of holes, for separate drill files.
313  if( !m_merge_PTH_NPTH )
314  hole_sets.emplace_back( F_Cu, B_Cu );
315 
316  for( std::vector<DRILL_LAYER_PAIR>::const_iterator it = hole_sets.begin();
317  it != hole_sets.end(); ++it )
318  {
319  DRILL_LAYER_PAIR pair = *it;
320  // For separate drill files, the last layer pair is the NPTH drill file.
321  bool doing_npth = m_merge_PTH_NPTH ? false : ( it == hole_sets.end() - 1 );
322 
323  buildHolesList( pair, doing_npth );
324 
325  // The file is created if it has holes, or if it is the non plated drill file
326  // to be sure the NPTH file is up to date in separate files mode.
327  // Also a PTH drill file is always created, to be sure at least one plated hole drill file
328  // is created (do not create any PTH drill file can be seen as not working drill generator).
329  if( getHolesCount() > 0 || doing_npth || pair == DRILL_LAYER_PAIR( F_Cu, B_Cu ) )
330  {
331  fn = getDrillFileName( pair, doing_npth, m_merge_PTH_NPTH );
332  fn.SetPath( aPlotDirectory );
333 
334  fn.SetExt( wxEmptyString ); // Will be added by GenDrillMap
335  wxString fullfilename = fn.GetFullPath() + wxT( "-drl_map" );
336  fullfilename << wxT(".") << GetDefaultPlotExtension( m_mapFileFmt );
337 
338  bool success = genDrillMapFile( fullfilename, m_mapFileFmt );
339 
340  if( ! success )
341  {
342  if( aReporter )
343  {
344  msg.Printf( _( "Failed to create file '%s'." ), fullfilename );
345  aReporter->Report( msg, RPT_SEVERITY_ERROR );
346  }
347 
348  return;
349  }
350  else
351  {
352  if( aReporter )
353  {
354  msg.Printf( _( "Created file '%s'." ), fullfilename );
355  aReporter->Report( msg, RPT_SEVERITY_ACTION );
356  }
357  }
358  }
359  }
360 }
virtual const wxString getDrillFileName(DRILL_LAYER_PAIR aPair, bool aNPTH, bool aMerge_PTH_NPTH) const
wxString GetDefaultPlotExtension(PLOT_FORMAT aFormat)
Returns the default plot extension for a format.
std::vector< DRILL_LAYER_PAIR > getUniqueLayerPairs() const
Get unique layer pairs by examining the micro and blind_buried vias.
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED)=0
Report a string with a given severity.
#define _(s)
std::pair< PCB_LAYER_ID, PCB_LAYER_ID > DRILL_LAYER_PAIR
void buildHolesList(DRILL_LAYER_PAIR aLayerPair, bool aGenerateNPTH_list)
Create the list of holes and tools for a given board.
Definition: layer_ids.h:71
bool genDrillMapFile(const wxString &aFullFileName, PLOT_FORMAT aFormat)
Plot a map of drill marks for holes.

References _, B_Cu, buildHolesList(), F_Cu, genDrillMapFile(), GetDefaultPlotExtension(), getDrillFileName(), getHolesCount(), getUniqueLayerPairs(), m_mapFileFmt, m_merge_PTH_NPTH, REPORTER::Report(), RPT_SEVERITY_ACTION, and RPT_SEVERITY_ERROR.

Referenced by GERBER_WRITER::CreateDrillandMapFilesSet(), and EXCELLON_WRITER::CreateDrillandMapFilesSet().

◆ genDrillMapFile()

bool GENDRILL_WRITER_BASE::genDrillMapFile ( const wxString &  aFullFileName,
PLOT_FORMAT  aFormat 
)
protected

Plot a map of drill marks for holes.

Hole list must be created before calling this function, by buildHolesList() for the right holes set (PTH, NPTH, buried/blind vias ...) the paper sheet to use to plot the map is set in m_pageInfo ( calls SetPageInfo() to set it ). If NULL, A4 format will be used.

Parameters
aFullFileNameis the full filename of the map file to create.
aFormatis one of the supported plot formats (see enum PlotFormat ).

Definition at line 69 of file gen_drill_report_files.cpp.

70 {
71  // Remark:
72  // Hole list must be created before calling this function, by buildHolesList(),
73  // for the right holes set (PTH, NPTH, buried/blind vias ...)
74 
75  double scale = 1.0;
76  wxPoint offset = GetOffset();
77  PLOTTER* plotter = nullptr;
78  PAGE_INFO dummy( PAGE_INFO::A4, false );
79  int bottom_limit = 0; // Y coord limit of page. 0 mean do not use
80 
81  PCB_PLOT_PARAMS plot_opts; // starts plotting with default options
82 
83  LOCALE_IO toggle; // use standard C notation for float numbers
84 
85  const PAGE_INFO& page_info = m_pageInfo ? *m_pageInfo : dummy;
86 
87  // Calculate dimensions and center of PCB. The Edge_Cuts layer must be visible
88  // to calculate the board edges bounding box
89  LSET visibleLayers = m_pcb->GetVisibleLayers();
90  m_pcb->SetVisibleLayers( visibleLayers | LSET( Edge_Cuts ) );
92  m_pcb->SetVisibleLayers( visibleLayers );
93 
94  // Calculate the scale for the format type, scale 1 in HPGL, drawing on
95  // an A4 sheet in PS, + text description of symbols
96  switch( aFormat )
97  {
99  plotter = new GERBER_PLOTTER();
100  plotter->SetViewport( offset, IU_PER_MILS / 10, scale, false );
101  plotter->SetGerberCoordinatesFormat( 5 ); // format x.5 unit = mm
102  break;
103 
104  case PLOT_FORMAT::HPGL: // Scale for HPGL format.
105  {
106  HPGL_PLOTTER* hpgl_plotter = new HPGL_PLOTTER;
107  plotter = hpgl_plotter;
108  hpgl_plotter->SetPenNumber( plot_opts.GetHPGLPenNum() );
109  hpgl_plotter->SetPenSpeed( plot_opts.GetHPGLPenSpeed() );
110  plotter->SetPageSettings( page_info );
111  plotter->SetViewport( offset, IU_PER_MILS / 10, scale, false );
112  }
113  break;
114 
115  default:
116  wxASSERT( false );
118 
119  case PLOT_FORMAT::PDF:
120  case PLOT_FORMAT::POST:
121  case PLOT_FORMAT::SVG:
122  {
123  PAGE_INFO pageA4( wxT( "A4" ) );
124  wxSize pageSizeIU = pageA4.GetSizeIU();
125 
126  // Reserve a 10 mm margin around the page.
127  int margin = Millimeter2iu( 10 );
128 
129  // Calculate a scaling factor to print the board on the sheet
130  double Xscale = double( pageSizeIU.x - ( 2 * margin ) ) / bbbox.GetWidth();
131 
132  // We should print the list of drill sizes, so reserve room for it
133  // 60% height for board 40% height for list
134  int ypagesize_for_board = KiROUND( pageSizeIU.y * 0.6 );
135  double Yscale = double( ypagesize_for_board - margin ) / bbbox.GetHeight();
136 
137  scale = std::min( Xscale, Yscale );
138 
139  // Experience shows the scale should not to large, because texts
140  // create problem (can be to big or too small).
141  // So the scale is clipped at 3.0;
142  scale = std::min( scale, 3.0 );
143 
144  offset.x = KiROUND( double( bbbox.Centre().x ) - ( pageSizeIU.x / 2.0 ) / scale );
145  offset.y = KiROUND( double( bbbox.Centre().y ) - ( ypagesize_for_board / 2.0 ) / scale );
146 
147  // bottom_limit is used to plot the legend (drill diameters)
148  // texts are scaled differently for scale > 1.0 and <= 1.0
149  // so the limit is scaled differently.
150  bottom_limit = ( pageSizeIU.y - margin ) / std::min( scale, 1.0 );
151 
152  if( aFormat == PLOT_FORMAT::SVG )
153  plotter = new SVG_PLOTTER;
154  else if( aFormat == PLOT_FORMAT::PDF )
155  plotter = new PDF_PLOTTER;
156  else
157  plotter = new PS_PLOTTER;
158 
159  plotter->SetPageSettings( pageA4 );
160  plotter->SetViewport( offset, IU_PER_MILS / 10, scale, false );
161  break;
162  }
163 
164  case PLOT_FORMAT::DXF:
165  {
166  DXF_PLOTTER* dxf_plotter = new DXF_PLOTTER;
167 
168  if( m_unitsMetric )
169  dxf_plotter->SetUnits( DXF_UNITS::MILLIMETERS );
170  else
171  dxf_plotter->SetUnits( DXF_UNITS::INCHES );
172 
173  plotter = dxf_plotter;
174  plotter->SetPageSettings( page_info );
175  plotter->SetViewport( offset, IU_PER_MILS / 10, scale, false );
176  break;
177  }
178  }
179 
180  plotter->SetCreator( wxT( "PCBNEW" ) );
181  plotter->SetColorMode( false );
182 
183  KIGFX::PCB_RENDER_SETTINGS renderSettings;
184  renderSettings.SetDefaultPenWidth( Millimeter2iu( 0.2 ) );
185 
186  plotter->SetRenderSettings( &renderSettings );
187 
188  if( !plotter->OpenFile( aFullFileName ) )
189  {
190  delete plotter;
191  return false;
192  }
193 
194  plotter->StartPlot();
195 
196  // Draw items on edge layer (not all, only items useful for drill map
197  BRDITEMS_PLOTTER itemplotter( plotter, m_pcb, plot_opts );
198  itemplotter.SetLayerSet( Edge_Cuts );
199 
200  for( auto PtStruct : m_pcb->Drawings() )
201  {
202  switch( PtStruct->Type() )
203  {
204  case PCB_SHAPE_T:
205  itemplotter.PlotPcbShape( (PCB_SHAPE*) PtStruct );
206  break;
207 
208  case PCB_TEXT_T:
209  itemplotter.PlotPcbText( (PCB_TEXT*) PtStruct );
210  break;
211 
212  case PCB_DIM_ALIGNED_T:
213  case PCB_DIM_CENTER_T:
215  case PCB_DIM_LEADER_T:
216  case PCB_TARGET_T:
217  case PCB_MARKER_T: // do not draw
218  default:
219  break;
220  }
221  }
222 
223  int plotX, plotY, TextWidth;
224  int intervalle = 0;
225  char line[1024];
226  wxString msg;
227  int textmarginaftersymbol = Millimeter2iu( 2 );
228 
229  // Set Drill Symbols width
230  plotter->SetCurrentLineWidth( -1 );
231 
232  // Plot board outlines and drill map
233  plotDrillMarks( plotter );
234 
235  // Print a list of symbols used.
236  int charSize = Millimeter2iu( 2 ); // text size in IUs
237 
238  // real char scale will be 1/scale, because the global plot scale is scale
239  // for scale < 1.0 ( plot bigger actual size)
240  // Therefore charScale = 1.0 / scale keep the initial charSize
241  // (for scale < 1 we use the global scaling factor: the board must be plotted
242  // smaller than the actual size)
243  double charScale = std::min( 1.0, 1.0 / scale );
244 
245  TextWidth = KiROUND( ( charSize * charScale ) / 10.0 ); // Set text width (thickness)
246  intervalle = KiROUND( charSize * charScale ) + TextWidth;
247 
248  // Trace information.
249  plotX = KiROUND( bbbox.GetX() + textmarginaftersymbol * charScale );
250  plotY = bbbox.GetBottom() + intervalle;
251 
252  // Plot title "Info"
253  wxString Text = wxT( "Drill Map:" );
254  plotter->Text( wxPoint( plotX, plotY ), COLOR4D::UNSPECIFIED, Text, 0,
255  wxSize( KiROUND( charSize * charScale ), KiROUND( charSize * charScale ) ),
256  GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, TextWidth, false, false );
257 
258  // For some formats (PS, PDF SVG) we plot the drill size list on more than one column
259  // because the list must be contained inside the printed page
260  // (others formats do not have a defined page size)
261  int max_line_len = 0; // The max line len in iu of the currently plotted column
262 
263  for( unsigned ii = 0; ii < m_toolListBuffer.size(); ii++ )
264  {
265  DRILL_TOOL& tool = m_toolListBuffer[ii];
266 
267  if( tool.m_TotalCount == 0 )
268  continue;
269 
270  plotY += intervalle;
271 
272  // Ensure there are room to plot the line
273  if( bottom_limit && ( plotY+intervalle > bottom_limit ) )
274  {
275  plotY = bbbox.GetBottom() + intervalle;
276  plotX += max_line_len + Millimeter2iu( 10 );//column_width;
277  max_line_len = 0;
278  }
279 
280  int plot_diam = KiROUND( tool.m_Diameter );
281 
282  // For markers plotted with the comment, keep marker size <= text height
283  plot_diam = std::min( plot_diam, KiROUND( charSize * charScale ) );
284  int x = KiROUND( plotX - textmarginaftersymbol * charScale - plot_diam / 2.0 );
285  int y = KiROUND( plotY + charSize * charScale );
286 
287  plotter->SetCurrentLineWidth( getMarkerBestPenSize( plot_diam ) );
288  plotter->Marker( wxPoint( x, y ), plot_diam, ii );
289  plotter->SetCurrentLineWidth( -1 );
290 
291  // List the diameter of each drill in mm and inches.
292  sprintf( line, "%3.3fmm / %2.4f\" ", diameter_in_mm( tool.m_Diameter ),
293  diameter_in_inches( tool.m_Diameter ) );
294 
295  msg = FROM_UTF8( line );
296 
297  // Now list how many holes and ovals are associated with each drill.
298  if( ( tool.m_TotalCount == 1 ) && ( tool.m_OvalCount == 0 ) )
299  sprintf( line, "(1 hole)" );
300  else if( tool.m_TotalCount == 1 ) // && ( toolm_OvalCount == 1 )
301  sprintf( line, "(1 slot)" );
302  else if( tool.m_OvalCount == 0 )
303  sprintf( line, "(%d holes)", tool.m_TotalCount );
304  else if( tool.m_OvalCount == 1 )
305  sprintf( line, "(%d holes + 1 slot)", tool.m_TotalCount - 1 );
306  else // if ( toolm_OvalCount > 1 )
307  sprintf( line, "(%d holes + %d slots)", tool.m_TotalCount - tool.m_OvalCount,
308  tool.m_OvalCount );
309 
310  msg += FROM_UTF8( line );
311 
312  if( tool.m_Hole_NotPlated )
313  msg += wxT( " (not plated)" );
314 
315  plotter->Text( wxPoint( plotX, y ), COLOR4D::UNSPECIFIED, msg, 0,
316  wxSize( KiROUND( charSize * charScale ), KiROUND( charSize * charScale ) ),
317  GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, TextWidth, false, false );
318 
319  intervalle = KiROUND( ( ( charSize * charScale ) + TextWidth ) * 1.2 );
320 
321  if( intervalle < ( plot_diam + ( 1 * IU_PER_MM / scale ) + TextWidth ) )
322  intervalle = plot_diam + ( 1 * IU_PER_MM / scale ) + TextWidth;
323 
324  // Evaluate the text horizontal size, to know the maximal column size
325  // This is a rough value, but ok to create a new column to plot next texts
326  int text_len = msg.Len() * ( ( charSize * charScale ) + TextWidth );
327  max_line_len = std::max( max_line_len, text_len + plot_diam );
328  }
329 
330  plotter->EndPlot();
331  delete plotter;
332 
333  return true;
334 }
double diameter_in_inches(double ius)
double diameter_in_mm(double ius)
class PCB_DIM_ALIGNED, a linear dimension (graphic item)
Definition: typeinfo.h:100
virtual void SetCreator(const wxString &aCreator)
Definition: plotter.h:174
class PCB_DIM_LEADER, a leader dimension (graphic item)
Definition: typeinfo.h:101
static wxString FROM_UTF8(const char *cstring)
Convert a UTF8 encoded C string to a wxString for all wxWidgets build modes.
Definition: macros.h:110
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: locale_io.h:40
virtual bool StartPlot()=0
int GetX() const
Definition: eda_rect.h:98
static constexpr double IU_PER_MM
Mock up a conversion function.
const EDA_RECT GetBoardEdgesBoundingBox() const
Return the board bounding box calculated using exclusively the board edges (graphics on Edge....
Definition: board.h:738
virtual bool OpenFile(const wxString &aFullFilename)
Open or create the plot file aFullFilename.
Definition: plotter.cpp:76
class PCB_DIM_CENTER, a center point marking (graphic item)
Definition: typeinfo.h:102
virtual void SetColorMode(bool aColorMode)
Plot in B/W or color.
Definition: plotter.h:152
int getMarkerBestPenSize(int aMarkerDiameter)
void SetRenderSettings(RENDER_SETTINGS *aSettings)
Definition: plotter.h:155
int GetWidth() const
Definition: eda_rect.h:109
class PCB_TEXT, text on a layer
Definition: typeinfo.h:91
LSET GetVisibleLayers() const
A proxy function that calls the correspondent function in m_BoardSettings.
Definition: board.cpp:481
int GetHPGLPenSpeed() const
#define KI_FALLTHROUGH
The KI_FALLTHROUGH macro is to be used when switch statement cases should purposely fallthrough from ...
Definition: macros.h:83
void SetUnits(DXF_UNITS aUnit)
Set the units to use for plotting the DXF file.
virtual void SetGerberCoordinatesFormat(int aResolution, bool aUseInches=false)
Definition: plotter.h:470
int GetBottom() const
Definition: eda_rect.h:114
static LIB_SYMBOL * dummy()
Used to draw a dummy shape when a LIB_SYMBOL is not found in library.
Definition: sch_symbol.cpp:72
PCB specific render settings.
Definition: pcb_painter.h:64
std::vector< DRILL_TOOL > m_toolListBuffer
virtual bool EndPlot()=0
LSET is a set of PCB_LAYER_IDs.
Definition: layer_ids.h:504
void SetVisibleLayers(LSET aLayerMask)
A proxy function that calls the correspondent function in m_BoardSettings changes the bit-mask of vis...
Definition: board.cpp:499
Describe the page size and margins of a paper page on which to eventually print or plot.
Definition: page_info.h:53
virtual void SetPenSpeed(int speed)
Definition: plotter_hpgl.h:85
static const wxChar A4[]
Definition: page_info.h:63
wxPoint GetOffset()
Return the plot offset (usually the position of the drill/place origin).
Parameters and options when plotting/printing a board.
int GetHeight() const
Definition: eda_rect.h:110
virtual void SetViewport(const wxPoint &aOffset, double aIusPerDecimil, double aScale, bool aMirror)=0
Set the plot offset and scaling for the current plot.
class PCB_TARGET, a target (graphic item)
Definition: typeinfo.h:104
void Marker(const wxPoint &position, int diametre, unsigned aShapeId)
Draw a pattern shape number aShapeId, to coord position.
Definition: plotter.cpp:338
int GetHPGLPenNum() const
Base plotter engine class.
Definition: plotter.h:121
class PCB_MARKER, a marker used to show something
Definition: typeinfo.h:98
const int scale
virtual void SetPenNumber(int number)
Definition: plotter_hpgl.h:90
Handle the component boundary box.
Definition: eda_rect.h:42
#define IU_PER_MILS
Definition: plotter.cpp:136
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: util.h:73
wxPoint Centre() const
Definition: eda_rect.h:55
bool plotDrillMarks(PLOTTER *aPlotter)
Write the drill marks in HPGL, POSTSCRIPT or other supported formats/.
virtual void Text(const wxPoint &aPos, const COLOR4D &aColor, const wxString &aText, double aOrient, const wxSize &aSize, enum EDA_TEXT_HJUSTIFY_T aH_justify, enum EDA_TEXT_VJUSTIFY_T aV_justify, int aWidth, bool aItalic, bool aBold, bool aMultilineAllowed=false, void *aData=nullptr)
Draw text with the plotter.
Definition: gr_text.cpp:219
class PCB_DIM_ORTHOGONAL, a linear dimension constrained to x/y
Definition: typeinfo.h:103
void SetDefaultPenWidth(int aWidth)
class PCB_SHAPE, a segment not on copper layers
Definition: typeinfo.h:90
static constexpr int Millimeter2iu(double mm)
virtual void SetCurrentLineWidth(int width, void *aData=nullptr)=0
Set the line width for the next drawing.
DRAWINGS & Drawings()
Definition: board.h:237
virtual void SetPageSettings(const PAGE_INFO &aPageSettings)
Definition: plotter.h:158

References PAGE_INFO::A4, EDA_RECT::Centre(), diameter_in_inches(), diameter_in_mm(), BOARD::Drawings(), dummy(), DXF, Edge_Cuts, PLOTTER::EndPlot(), FROM_UTF8(), GERBER, BOARD::GetBoardEdgesBoundingBox(), EDA_RECT::GetBottom(), EDA_RECT::GetHeight(), PCB_PLOT_PARAMS::GetHPGLPenNum(), PCB_PLOT_PARAMS::GetHPGLPenSpeed(), getMarkerBestPenSize(), GetOffset(), BOARD::GetVisibleLayers(), EDA_RECT::GetWidth(), EDA_RECT::GetX(), GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, HPGL, INCHES, IU_PER_MILS, IU_PER_MM, KI_FALLTHROUGH, KiROUND(), DRILL_TOOL::m_Diameter, DRILL_TOOL::m_Hole_NotPlated, DRILL_TOOL::m_OvalCount, m_pageInfo, m_pcb, m_toolListBuffer, DRILL_TOOL::m_TotalCount, m_unitsMetric, PLOTTER::Marker(), Millimeter2iu(), MILLIMETERS, PLOTTER::OpenFile(), PCB_DIM_ALIGNED_T, PCB_DIM_CENTER_T, PCB_DIM_LEADER_T, PCB_DIM_ORTHOGONAL_T, PCB_MARKER_T, PCB_SHAPE_T, PCB_TARGET_T, PCB_TEXT_T, PDF, plotDrillMarks(), BRDITEMS_PLOTTER::PlotPcbShape(), BRDITEMS_PLOTTER::PlotPcbText(), POST, scale, PLOTTER::SetColorMode(), PLOTTER::SetCreator(), PLOTTER::SetCurrentLineWidth(), KIGFX::RENDER_SETTINGS::SetDefaultPenWidth(), PLOTTER::SetGerberCoordinatesFormat(), BRDITEMS_PLOTTER::SetLayerSet(), PLOTTER::SetPageSettings(), HPGL_PLOTTER::SetPenNumber(), HPGL_PLOTTER::SetPenSpeed(), PLOTTER::SetRenderSettings(), DXF_PLOTTER::SetUnits(), PLOTTER::SetViewport(), BOARD::SetVisibleLayers(), PLOTTER::StartPlot(), SVG, and PLOTTER::Text().

Referenced by CreateMapFilesSet().

◆ GenDrillReportFile()

bool GENDRILL_WRITER_BASE::GenDrillReportFile ( const wxString &  aFullFileName)

Create a plain text report file giving a list of drill values and drill count for through holes, oblong holes, and for buried vias, drill values and drill count per layer pair there is only one report for all drill files even when buried or blinds vias exist.

Here is a sample created by this function: Drill report for F:/tmp/interf_u/interf_u.brd Created on 04/10/2012 20:48:38 Selected Drill Unit: Imperial (inches)

Drill report for plated through holes : T1 0,025" 0,64mm (88 holes) T2 0,031" 0,79mm (120 holes) T3 0,032" 0,81mm (151 holes) (with 1 slot) T4 0,040" 1,02mm (43 holes) T5 0,079" 2,00mm (1 hole) (with 1 slot) T6 0,120" 3,05mm (1 hole) (with 1 slot)

Total plated holes count 404

Drill report for buried and blind vias :

Drill report for holes from layer Soudure to layer Interne1 :

Total plated holes count 0

Drill report for holes from layer Interne1 to layer Interne2 : T1 0,025" 0,64mm (3 holes)

Total plated holes count 3

Drill report for holes from layer Interne2 to layer Composant : T1 0,025" 0,64mm (1 hole)

Total plated holes count 1

Drill report for unplated through holes : T1 0,120" 3,05mm (1 hole) (with 1 slot)

Total unplated holes count 1

Parameters
aFullFileNameis the name of the file to create.
Returns
true if the file is created.

Definition at line 337 of file gen_drill_report_files.cpp.

338 {
339  FILE_OUTPUTFORMATTER out( aFullFileName );
340 
341  static const char separator[] =
342  " =============================================================\n";
343 
344  wxASSERT( m_pcb );
345 
346  unsigned totalHoleCount;
347  wxFileName brdFilename( m_pcb->GetFileName() );
348 
349  std::vector<DRILL_LAYER_PAIR> hole_sets = getUniqueLayerPairs();
350 
351  out.Print( 0, "Drill report for %s\n", TO_UTF8( brdFilename.GetFullName() ) );
352  out.Print( 0, "Created on %s\n\n", TO_UTF8( DateAndTime() ) );
353 
354  // Output the cu layer stackup, so layer name references make sense.
355  out.Print( 0, "Copper Layer Stackup:\n" );
356  out.Print( 0, separator );
357 
359 
360  int conventional_layer_num = 1;
361 
362  for( LSEQ seq = cu.Seq(); seq; ++seq, ++conventional_layer_num )
363  {
364  out.Print( 0, " L%-2d: %-25s %s\n",
365  conventional_layer_num,
366  TO_UTF8( m_pcb->GetLayerName( *seq ) ),
367  layerName( *seq ).c_str() ); // generic layer name
368  }
369 
370  out.Print( 0, "\n\n" );
371 
372  /* output hole lists:
373  * 1 - through holes
374  * 2 - for partial holes only: by layer starting and ending pair
375  * 3 - Non Plated through holes
376  */
377 
378  bool buildNPTHlist = false; // First pass: build PTH list only
379 
380  // in this loop are plated only:
381  for( unsigned pair_ndx = 0; pair_ndx < hole_sets.size(); ++pair_ndx )
382  {
383  DRILL_LAYER_PAIR pair = hole_sets[pair_ndx];
384 
385  buildHolesList( pair, buildNPTHlist );
386 
387  if( pair == DRILL_LAYER_PAIR( F_Cu, B_Cu ) )
388  {
389  out.Print( 0, "Drill file '%s' contains\n",
390  TO_UTF8( getDrillFileName( pair, false, m_merge_PTH_NPTH ) ) );
391 
392  out.Print( 0, " plated through holes:\n" );
393  out.Print( 0, separator );
394  totalHoleCount = printToolSummary( out, false );
395  out.Print( 0, " Total plated holes count %u\n", totalHoleCount );
396  }
397  else // blind/buried
398  {
399  out.Print( 0, "Drill file '%s' contains\n",
400  TO_UTF8( getDrillFileName( pair, false, m_merge_PTH_NPTH ) ) );
401 
402  out.Print( 0, " holes connecting layer pair: '%s and %s' (%s vias):\n",
403  TO_UTF8( m_pcb->GetLayerName( ToLAYER_ID( pair.first ) ) ),
404  TO_UTF8( m_pcb->GetLayerName( ToLAYER_ID( pair.second ) ) ),
405  pair.first == F_Cu || pair.second == B_Cu ? "blind" : "buried" );
406 
407  out.Print( 0, separator );
408  totalHoleCount = printToolSummary( out, false );
409  out.Print( 0, " Total plated holes count %u\n", totalHoleCount );
410  }
411 
412  out.Print( 0, "\n\n" );
413  }
414 
415  // NPTHoles. Generate the full list (pads+vias) if PTH and NPTH are merged,
416  // or only the NPTH list (which never has vias)
417  if( !m_merge_PTH_NPTH )
418  buildNPTHlist = true;
419 
420  buildHolesList( DRILL_LAYER_PAIR( F_Cu, B_Cu ), buildNPTHlist );
421 
422  // nothing wrong with an empty NPTH file in report.
423  if( m_merge_PTH_NPTH )
424  out.Print( 0, "Not plated through holes are merged with plated holes\n" );
425  else
426  out.Print( 0, "Drill file '%s' contains\n",
428  true, m_merge_PTH_NPTH ) ) );
429 
430  out.Print( 0, " unplated through holes:\n" );
431  out.Print( 0, separator );
432  totalHoleCount = printToolSummary( out, true );
433  out.Print( 0, " Total unplated holes count %u\n", totalHoleCount );
434 
435  return true;
436 }
static LSET AllCuMask(int aCuLayerCount=MAX_CU_LAYERS)
Return a mask holding the requested number of Cu PCB_LAYER_IDs.
Definition: lset.cpp:750
unsigned printToolSummary(OUTPUTFORMATTER &aOut, bool aSummaryNPTH) const
Print m_toolListBuffer[] tools to aOut and returns total hole count.
virtual const wxString getDrillFileName(DRILL_LAYER_PAIR aPair, bool aNPTH, bool aMerge_PTH_NPTH) const
const wxString GetLayerName(PCB_LAYER_ID aLayer) const
Return the name of a aLayer.
Definition: board.cpp:362
LSET GetEnabledLayers() const
A proxy function that calls the corresponding function in m_BoardSettings.
Definition: board.cpp:467
std::vector< DRILL_LAYER_PAIR > getUniqueLayerPairs() const
Get unique layer pairs by examining the micro and blind_buried vias.
LSEQ Seq(const PCB_LAYER_ID *aWishListSequence, unsigned aCount) const
Return an LSEQ from the union of this LSET and a desired sequence.
Definition: lset.cpp:411
const wxString & GetFileName() const
Definition: board.h:229
#define TO_UTF8(wxstring)
Convert a wxString to a UTF8 encoded C string for all wxWidgets build modes.
Definition: macros.h:96
LSET is a set of PCB_LAYER_IDs.
Definition: layer_ids.h:504
std::pair< PCB_LAYER_ID, PCB_LAYER_ID > DRILL_LAYER_PAIR
LSEQ is a sequence (and therefore also a set) of PCB_LAYER_IDs.
Definition: layer_ids.h:465
void buildHolesList(DRILL_LAYER_PAIR aLayerPair, bool aGenerateNPTH_list)
Create the list of holes and tools for a given board.
const std::string layerName(PCB_LAYER_ID aLayer) const
Definition: layer_ids.h:71
Used for text file output.
Definition: richio.h:456
wxString DateAndTime()
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition: lset.cpp:905

References LSET::AllCuMask(), B_Cu, buildHolesList(), DateAndTime(), F_Cu, getDrillFileName(), BOARD::GetEnabledLayers(), BOARD::GetFileName(), BOARD::GetLayerName(), getUniqueLayerPairs(), layerName(), m_merge_PTH_NPTH, m_pcb, OUTPUTFORMATTER::Print(), printToolSummary(), LSET::Seq(), TO_UTF8, and ToLAYER_ID().

Referenced by DIALOG_GENDRILL::OnGenReportFile().

◆ getDrillFileName()

const wxString GENDRILL_WRITER_BASE::getDrillFileName ( DRILL_LAYER_PAIR  aPair,
bool  aNPTH,
bool  aMerge_PTH_NPTH 
) const
protectedvirtual
Parameters
aPairis the layer pair.
aNPTHuse true to generate the filename of NPTH holes.
aMerge_PTH_NPTHuse true to generate the filename of a file which containd both NPH and NPTH holes.
Returns
a filename which identify the drill file function. it is the board name with the layer pair names added, and for separate (PTH and NPTH) files, "-NPH" or "-NPTH" added

Reimplemented in GERBER_WRITER.

Definition at line 273 of file gendrill_file_writer_base.cpp.

275 {
276  wxASSERT( m_pcb );
277 
278  wxString extend;
279 
280  if( aNPTH )
281  extend = "-NPTH";
282  else if( aPair == DRILL_LAYER_PAIR( F_Cu, B_Cu ) )
283  {
284  if( !aMerge_PTH_NPTH )
285  extend = "-PTH";
286  // if merged, extend with nothing
287  }
288  else
289  {
290  extend += '-';
291  extend += layerPairName( aPair );
292  }
293 
294  wxFileName fn = m_pcb->GetFileName();
295 
296  fn.SetName( fn.GetName() + extend );
297  fn.SetExt( m_drillFileExtension );
298 
299  wxString ret = fn.GetFullName();
300 
301  return ret;
302 }
const wxString & GetFileName() const
Definition: board.h:229
const std::string layerPairName(DRILL_LAYER_PAIR aPair) const
std::pair< PCB_LAYER_ID, PCB_LAYER_ID > DRILL_LAYER_PAIR
Definition: layer_ids.h:71

References B_Cu, F_Cu, BOARD::GetFileName(), layerPairName(), m_drillFileExtension, and m_pcb.

Referenced by EXCELLON_WRITER::CreateDrillandMapFilesSet(), CreateMapFilesSet(), GenDrillReportFile(), and GERBER_WRITER::getDrillFileName().

◆ getHolesCount()

int GENDRILL_WRITER_BASE::getHolesCount ( ) const
inlineprotected

◆ GetOffset()

wxPoint GENDRILL_WRITER_BASE::GetOffset ( )
inline

Return the plot offset (usually the position of the drill/place origin).

Definition at line 183 of file gendrill_file_writer_base.h.

183 { return m_offset; }

References m_offset.

Referenced by genDrillMapFile().

◆ getUniqueLayerPairs()

std::vector< DRILL_LAYER_PAIR > GENDRILL_WRITER_BASE::getUniqueLayerPairs ( ) const
protected

Get unique layer pairs by examining the micro and blind_buried vias.

Definition at line 206 of file gendrill_file_writer_base.cpp.

207 {
208  wxASSERT( m_pcb );
209 
210  static const KICAD_T interesting_stuff_to_collect[] = {
211  PCB_VIA_T,
212  EOT
213  };
214 
215  PCB_TYPE_COLLECTOR vias;
216 
217  vias.Collect( m_pcb, interesting_stuff_to_collect );
218 
219  std::set< DRILL_LAYER_PAIR > unique;
220 
221  DRILL_LAYER_PAIR layer_pair;
222 
223  for( int i = 0; i < vias.GetCount(); ++i )
224  {
225  PCB_VIA* v = static_cast<PCB_VIA*>( vias[i] );
226 
227  v->LayerPair( &layer_pair.first, &layer_pair.second );
228 
229  // only make note of blind buried.
230  // thru hole is placed unconditionally as first in fetched list.
231  if( layer_pair != DRILL_LAYER_PAIR( F_Cu, B_Cu ) )
232  {
233  unique.insert( layer_pair );
234  }
235  }
236 
237  std::vector<DRILL_LAYER_PAIR> ret;
238 
239  ret.emplace_back( F_Cu, B_Cu ); // always first in returned list
240 
241  for( std::set<DRILL_LAYER_PAIR>::const_iterator it = unique.begin(); it != unique.end(); ++it )
242  ret.push_back( *it );
243 
244  return ret;
245 }
search types array terminator (End Of Types)
Definition: typeinfo.h:81
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition: typeinfo.h:77
int GetCount() const
Return the number of objects in the list.
Definition: collector.h:82
void LayerPair(PCB_LAYER_ID *top_layer, PCB_LAYER_ID *bottom_layer) const
Function LayerPair Return the 2 layers used by the via (the via actually uses all layers between thes...
Definition: pcb_track.cpp:434
std::pair< PCB_LAYER_ID, PCB_LAYER_ID > DRILL_LAYER_PAIR
void Collect(BOARD_ITEM *aBoard, const KICAD_T aScanList[])
Collect BOARD_ITEM objects using this class's Inspector method, which does the collection.
Definition: collectors.cpp:609
Definition: layer_ids.h:71
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
Collect all BOARD_ITEM objects of a given set of KICAD_T type(s).
Definition: collectors.h:614

References B_Cu, PCB_TYPE_COLLECTOR::Collect(), EOT, F_Cu, COLLECTOR::GetCount(), PCB_VIA::LayerPair(), m_pcb, and PCB_VIA_T.

Referenced by GERBER_WRITER::CreateDrillandMapFilesSet(), EXCELLON_WRITER::CreateDrillandMapFilesSet(), CreateMapFilesSet(), and GenDrillReportFile().

◆ layerName()

const std::string GENDRILL_WRITER_BASE::layerName ( PCB_LAYER_ID  aLayer) const
protected
Returns
a string from aLayer to identify the layer. string are "front" "back" or "in<aLayer>"

Definition at line 248 of file gendrill_file_writer_base.cpp.

249 {
250  // Generic names here.
251  switch( aLayer )
252  {
253  case F_Cu:
254  return "front";
255  case B_Cu:
256  return "back";
257  default:
258  return StrPrintf( "in%d", aLayer );
259  }
260 }
int StrPrintf(std::string *result, const char *format,...)
This is like sprintf() but the output is appended to a std::string instead of to a character array.
Definition: richio.cpp:79
Definition: layer_ids.h:71

References B_Cu, F_Cu, and StrPrintf().

Referenced by GenDrillReportFile(), and layerPairName().

◆ layerPairName()

const std::string GENDRILL_WRITER_BASE::layerPairName ( DRILL_LAYER_PAIR  aPair) const
protected
Returns
a string from aPair to identify the layer layer pair. string is "<layer1Name>"-"<layer2Name>" used to generate a filename for drill files and drill maps

Definition at line 263 of file gendrill_file_writer_base.cpp.

264 {
265  std::string ret = layerName( aPair.first );
266  ret += '-';
267  ret += layerName( aPair.second );
268 
269  return ret;
270 }
const std::string layerName(PCB_LAYER_ID aLayer) const

References layerName().

Referenced by getDrillFileName().

◆ plotDrillMarks()

bool GENDRILL_WRITER_BASE::plotDrillMarks ( PLOTTER aPlotter)
protected

Write the drill marks in HPGL, POSTSCRIPT or other supported formats/.

Each hole size has a symbol (circle, cross X, cross + ...) up to PLOTTER::MARKER_COUNT different values. If more than PLOTTER::MARKER_COUNT different values, these other values share the same mark shape.

Parameters
aPlotteris a PLOTTER instance (HPGL, POSTSCRIPT ... plotter).

Definition at line 439 of file gen_drill_report_files.cpp.

440 {
441  // Plot the drill map:
442  wxPoint pos;
443 
444  for( unsigned ii = 0; ii < m_holeListBuffer.size(); ii++ )
445  {
446  const HOLE_INFO& hole = m_holeListBuffer[ii];
447  pos = hole.m_Hole_Pos;
448 
449  // Gives a good line thickness to have a good marker shape:
451 
452  // Always plot the drill symbol (for slots identifies the needed cutter!
453  aPlotter->Marker( pos, hole.m_Hole_Diameter, hole.m_Tool_Reference - 1 );
454 
455  if( hole.m_Hole_Shape != 0 )
456  {
457  wxSize oblong_size = hole.m_Hole_Size;
458  aPlotter->FlashPadOval( pos, oblong_size, hole.m_Hole_Orient, SKETCH, nullptr );
459  }
460  }
461 
462  aPlotter->SetCurrentLineWidth( -1 );
463 
464  return true;
465 }
int getMarkerBestPenSize(int aMarkerDiameter)
virtual void FlashPadOval(const wxPoint &aPadPos, const wxSize &aSize, double aPadOrient, OUTLINE_MODE aTraceMode, void *aData)=0
Handle hole which must be drilled (diameter, position and layers).
void Marker(const wxPoint &position, int diametre, unsigned aShapeId)
Draw a pattern shape number aShapeId, to coord position.
Definition: plotter.cpp:338
std::vector< HOLE_INFO > m_holeListBuffer
virtual void SetCurrentLineWidth(int width, void *aData=nullptr)=0
Set the line width for the next drawing.

References PLOTTER::FlashPadOval(), getMarkerBestPenSize(), HOLE_INFO::m_Hole_Diameter, HOLE_INFO::m_Hole_Orient, HOLE_INFO::m_Hole_Pos, HOLE_INFO::m_Hole_Shape, HOLE_INFO::m_Hole_Size, m_holeListBuffer, HOLE_INFO::m_Tool_Reference, PLOTTER::Marker(), PLOTTER::SetCurrentLineWidth(), and SKETCH.

Referenced by genDrillMapFile().

◆ printToolSummary()

unsigned GENDRILL_WRITER_BASE::printToolSummary ( OUTPUTFORMATTER aOut,
bool  aSummaryNPTH 
) const
protected

Print m_toolListBuffer[] tools to aOut and returns total hole count.

Parameters
aOutis the current OUTPUTFORMATTER to print summary.
aSummaryNPTHis true to print summary for NPTH, false for PTH.

Definition at line 468 of file gen_drill_report_files.cpp.

469 {
470  unsigned totalHoleCount = 0;
471 
472  for( unsigned ii = 0; ii < m_toolListBuffer.size(); ii++ )
473  {
474  const DRILL_TOOL& tool = m_toolListBuffer[ii];
475 
476  if( aSummaryNPTH && !tool.m_Hole_NotPlated )
477  continue;
478 
479  if( !aSummaryNPTH && tool.m_Hole_NotPlated )
480  continue;
481 
482  // List the tool number assigned to each drill in mm then in inches.
483  int tool_number = ii+1;
484  out.Print( 0, " T%d %2.3fmm %2.4f\" ", tool_number,
485  diameter_in_mm( tool.m_Diameter ),
486  diameter_in_inches( tool.m_Diameter ) );
487 
488  // Now list how many holes and ovals are associated with each drill.
489  if( ( tool.m_TotalCount == 1 ) && ( tool.m_OvalCount == 0 ) )
490  out.Print( 0, "(1 hole)\n" );
491  else if( tool.m_TotalCount == 1 )
492  out.Print( 0, "(1 hole) (with 1 slot)\n" );
493  else if( tool.m_OvalCount == 0 )
494  out.Print( 0, "(%d holes)\n", tool.m_TotalCount );
495  else if( tool.m_OvalCount == 1 )
496  out.Print( 0, "(%d holes) (with 1 slot)\n", tool.m_TotalCount );
497  else // tool.m_OvalCount > 1
498  out.Print( 0, "(%d holes) (with %d slots)\n", tool.m_TotalCount, tool.m_OvalCount );
499 
500  totalHoleCount += tool.m_TotalCount;
501  }
502 
503  out.Print( 0, "\n" );
504 
505  return totalHoleCount;
506 }
double diameter_in_inches(double ius)
double diameter_in_mm(double ius)
std::vector< DRILL_TOOL > m_toolListBuffer

References diameter_in_inches(), diameter_in_mm(), DRILL_TOOL::m_Diameter, DRILL_TOOL::m_Hole_NotPlated, DRILL_TOOL::m_OvalCount, m_toolListBuffer, DRILL_TOOL::m_TotalCount, and OUTPUTFORMATTER::Print().

Referenced by GenDrillReportFile().

◆ SetMapFileFormat()

void GENDRILL_WRITER_BASE::SetMapFileFormat ( PLOT_FORMAT  aMapFmt)
inline

Initialize the format for the drill map file.

Parameters
aMapFmta PlotFormat value (one of PLOT_FORMAT_HPGL, PLOT_FORMAT_POST, PLOT_FORMAT_GERBER, PLOT_FORMAT_DXF, PLOT_FORMAT_SVG, PLOT_FORMAT_PDF the most useful are PLOT_FORMAT_PDF and PLOT_FORMAT_POST.

Definition at line 201 of file gendrill_file_writer_base.h.

202  {
203  m_mapFileFmt = aMapFmt;
204  }

References m_mapFileFmt.

Referenced by DIALOG_GENDRILL::GenDrillAndMapFiles().

◆ SetMergeOption()

void GENDRILL_WRITER_BASE::SetMergeOption ( bool  aMerge)
inline

Set the option to make separate drill files for PTH and NPTH.

Parameters
aMergeset to true to make only one file containing PTH and NPTH or false to create 2 separate files.

Definition at line 178 of file gendrill_file_writer_base.h.

References m_merge_PTH_NPTH.

Referenced by DIALOG_GENDRILL::OnGenReportFile().

◆ SetPageInfo()

void GENDRILL_WRITER_BASE::SetPageInfo ( const PAGE_INFO aPageInfo)
inline

Set the page info used to plot drill maps.

If NULL, a A4 page format will be used.

Parameters
aPageInfois a reference to the page info, usually used to plot/display the board.

Definition at line 192 of file gendrill_file_writer_base.h.

192 { m_pageInfo = aPageInfo; }

References m_pageInfo.

Member Data Documentation

◆ m_conversionUnits

◆ m_drillFileExtension

wxString GENDRILL_WRITER_BASE::m_drillFileExtension
protected

◆ m_holeListBuffer

std::vector<HOLE_INFO> GENDRILL_WRITER_BASE::m_holeListBuffer
protected

◆ m_mapFileFmt

PLOT_FORMAT GENDRILL_WRITER_BASE::m_mapFileFmt
protected

◆ m_merge_PTH_NPTH

◆ m_offset

◆ m_pageInfo

const PAGE_INFO* GENDRILL_WRITER_BASE::m_pageInfo
protected

Definition at line 390 of file gendrill_file_writer_base.h.

Referenced by GENDRILL_WRITER_BASE(), genDrillMapFile(), and SetPageInfo().

◆ m_pcb

◆ m_precision

◆ m_toolListBuffer

std::vector<DRILL_TOOL> GENDRILL_WRITER_BASE::m_toolListBuffer
protected

◆ m_unitsMetric

◆ m_zeroFormat


The documentation for this class was generated from the following files: