KiCad PCB EDA Suite
GERBER_WRITER Class Reference

Used to create Gerber drill files. More...

#include <gendrill_gerber_writer.h>

Inheritance diagram for GERBER_WRITER:
GENDRILL_WRITER_BASE

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

 GERBER_WRITER (BOARD *aPcb)
 
virtual ~GERBER_WRITER ()
 
void SetFormat (int aRightDigits=6)
 Initialize internal parameters to match the given format. More...
 
void SetOptions (const VECTOR2I &aOffset)
 Initialize internal parameters to match drill options. More...
 
void CreateDrillandMapFilesSet (const wxString &aPlotDirectory, bool aGenDrill, bool aGenMap, REPORTER *aReporter=nullptr)
 Create the full set of Excellon drill file for the board filenames are computed from the board name, and layers id. More...
 
void SetMergeOption (bool aMerge)
 Set the option to make separate drill files for PTH and NPTH. More...
 
VECTOR2I 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 ... format (use SetMapFileFormat() to select the format). 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...
 
wxString GetDrillFileExt () const
 Returns the file extension of the drill writer format. 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
 
const wxString BuildFileFunctionAttributeString (DRILL_LAYER_PAIR aLayerPair, TYPE_FILE aHoleType, bool aCompatNCdrill=false) const
 

Protected Attributes

BOARDm_pcb
 
wxString m_drillFileExtension
 
bool m_unitsMetric
 
ZEROS_FMT m_zeroFormat
 
DRILL_PRECISION m_precision
 
double m_conversionUnits
 
VECTOR2I 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
 

Private Member Functions

int createDrillFile (wxString &aFullFilename, bool aIsNpth, DRILL_LAYER_PAIR aLayerPair)
 Create an Excellon drill file. More...
 
virtual const wxString getDrillFileName (DRILL_LAYER_PAIR aPair, bool aNPTH, bool aMerge_PTH_NPTH) const override
 

Detailed Description

Used to create Gerber drill files.

Definition at line 40 of file gendrill_gerber_writer.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

◆ GERBER_WRITER()

◆ ~GERBER_WRITER()

virtual GERBER_WRITER::~GERBER_WRITER ( )
inlinevirtual

Definition at line 45 of file gendrill_gerber_writer.h.

46 {
47 }

Member Function Documentation

◆ BuildFileFunctionAttributeString()

const wxString GENDRILL_WRITER_BASE::BuildFileFunctionAttributeString ( DRILL_LAYER_PAIR  aLayerPair,
TYPE_FILE  aHoleType,
bool  aCompatNCdrill = false 
) const
protectedinherited
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 359 of file gendrill_file_writer_base.cpp.

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

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

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

◆ buildHolesList()

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

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 = ANGLE_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 // Convert oblong holes that are actually circular into drill hits
150 if( pad->GetDrillShape() != PAD_DRILL_SHAPE_CIRCLE &&
151 pad->GetDrillSizeX() != pad->GetDrillSizeY() )
152 {
153 new_hole.m_Hole_Shape = 1; // oval flag set
154 }
155
156 new_hole.m_Hole_Size = pad->GetDrillSize();
157 new_hole.m_Hole_Pos = pad->GetPosition(); // hole position
158 new_hole.m_Hole_Bottom_Layer = B_Cu;
159 new_hole.m_Hole_Top_Layer = F_Cu; // pad holes are through holes
160 m_holeListBuffer.push_back( new_hole );
161 }
162 }
163 }
164
165 // Sort holes per increasing diameter value (and for each dimater, by position)
166 sort( m_holeListBuffer.begin(), m_holeListBuffer.end(), cmpHoleSorting );
167
168 // build the tool list
169 int last_hole = -1; // Set to not initialized (this is a value not used
170 // for m_holeListBuffer[ii].m_Hole_Diameter)
171 bool last_notplated_opt = false;
173
174 DRILL_TOOL new_tool( 0, false );
175 unsigned jj;
176
177 for( unsigned ii = 0; ii < m_holeListBuffer.size(); ii++ )
178 {
179 if( m_holeListBuffer[ii].m_Hole_Diameter != last_hole
180 || m_holeListBuffer[ii].m_Hole_NotPlated != last_notplated_opt
182 || m_holeListBuffer[ii].m_HoleAttribute != last_attribute
183#endif
184 )
185 {
186 new_tool.m_Diameter = m_holeListBuffer[ii].m_Hole_Diameter;
187 new_tool.m_Hole_NotPlated = m_holeListBuffer[ii].m_Hole_NotPlated;
188 new_tool.m_HoleAttribute = m_holeListBuffer[ii].m_HoleAttribute;
189 m_toolListBuffer.push_back( new_tool );
190 last_hole = new_tool.m_Diameter;
191 last_notplated_opt = new_tool.m_Hole_NotPlated;
192 last_attribute = new_tool.m_HoleAttribute;
193 }
194
195 jj = m_toolListBuffer.size();
196
197 if( jj == 0 )
198 continue; // Should not occurs
199
200 m_holeListBuffer[ii].m_Tool_Reference = jj; // Tool value Initialized (value >= 1)
201
202 m_toolListBuffer.back().m_TotalCount++;
203
204 if( m_holeListBuffer[ii].m_Hole_Shape )
205 m_toolListBuffer.back().m_OvalCount++;
206 }
207}
FOOTPRINTS & Footprints()
Definition: board.h:311
TRACKS & Tracks()
Definition: board.h:308
std::vector< DRILL_TOOL > m_toolListBuffer
PCB_LAYER_ID m_Hole_Bottom_Layer
PCB_LAYER_ID m_Hole_Top_Layer
HOLE_ATTRIBUTE m_HoleAttribute
BOARD_ITEM * m_ItemParent
Definition: pad.h:60
static constexpr EDA_ANGLE & ANGLE_0
Definition: eda_angle.h:429
static bool cmpHoleSorting(const HOLE_INFO &a, const HOLE_INFO &b)
#define USE_ATTRIB_FOR_HOLES
std::pair< PCB_LAYER_ID, PCB_LAYER_ID > DRILL_LAYER_PAIR
@ F_Cu
Definition: layer_ids.h:64
@ NPTH
like PAD_PTH, but not plated
@ PAD_DRILL_SHAPE_CIRCLE
Definition: pad_shapes.h:70
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:102

References ANGLE_0, 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, GENDRILL_WRITER_BASE::m_holeListBuffer, HOLE_INFO::m_ItemParent, GENDRILL_WRITER_BASE::m_merge_PTH_NPTH, GENDRILL_WRITER_BASE::m_pcb, HOLE_INFO::m_Tool_Reference, GENDRILL_WRITER_BASE::m_toolListBuffer, NPTH, pad, PAD_DRILL_SHAPE_CIRCLE, PCB_VIA_T, BOARD::Tracks(), USE_ATTRIB_FOR_HOLES, via, VECTOR2< T >::x, and VECTOR2< T >::y.

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

◆ CreateDrillandMapFilesSet()

void GERBER_WRITER::CreateDrillandMapFilesSet ( const wxString &  aPlotDirectory,
bool  aGenDrill,
bool  aGenMap,
REPORTER aReporter = nullptr 
)

Create the full set of Excellon drill file for the board filenames are computed from the board name, and layers id.

Parameters
aPlotDirectoryis the output folder.
aGenDrillset to true to generate the EXCELLON drill file.
aGenMapset to true to generate a drill map file.
aReporteris a REPORTER to return activity or any message (can be NULL).

Definition at line 57 of file gendrill_gerber_writer.cpp.

59{
60 // Note: In Gerber drill files, NPTH and PTH are always separate files
61 m_merge_PTH_NPTH = false;
62
63 wxFileName fn;
64 wxString msg;
65
66 std::vector<DRILL_LAYER_PAIR> hole_sets = getUniqueLayerPairs();
67
68 // append a pair representing the NPTH set of holes, for separate drill files.
69 // (Gerber drill files are separate files for PTH and NPTH)
70 hole_sets.emplace_back( F_Cu, B_Cu );
71
72 for( std::vector<DRILL_LAYER_PAIR>::const_iterator it = hole_sets.begin();
73 it != hole_sets.end(); ++it )
74 {
75 DRILL_LAYER_PAIR pair = *it;
76 // For separate drill files, the last layer pair is the NPTH drill file.
77 bool doing_npth = ( it == hole_sets.end() - 1 );
78
79 buildHolesList( pair, doing_npth );
80
81 // The file is created if it has holes, or if it is the non plated drill file
82 // to be sure the NPTH file is up to date in separate files mode.
83 // Also a PTH drill/map file is always created, to be sure at least one plated hole drill
84 // file is created (do not create any PTH drill file can be seen as not working drill
85 // generator).
86 if( getHolesCount() > 0 || doing_npth || pair == DRILL_LAYER_PAIR( F_Cu, B_Cu ) )
87 {
88 fn = getDrillFileName( pair, doing_npth, false );
89 fn.SetPath( aPlotDirectory );
90
91 if( aGenDrill )
92 {
93 wxString fullFilename = fn.GetFullPath();
94
95 int result = createDrillFile( fullFilename, doing_npth, pair );
96
97 if( result < 0 )
98 {
99 if( aReporter )
100 {
101 msg.Printf( _( "Failed to create file '%s'." ), fullFilename );
102 aReporter->Report( msg, RPT_SEVERITY_ERROR );
103 }
104
105 break;
106 }
107 else
108 {
109 if( aReporter )
110 {
111 msg.Printf( _( "Created file '%s'." ), fullFilename );
112 aReporter->Report( msg, RPT_SEVERITY_ACTION );
113 }
114 }
115
116 }
117 }
118 }
119
120 if( aGenMap )
121 CreateMapFilesSet( aPlotDirectory, aReporter );
122
123 if( aReporter )
124 aReporter->ReportTail( _( "Done." ), RPT_SEVERITY_INFO );
125}
std::vector< DRILL_LAYER_PAIR > getUniqueLayerPairs() const
Get unique layer pairs by examining the micro and blind_buried vias.
void buildHolesList(DRILL_LAYER_PAIR aLayerPair, bool aGenerateNPTH_list)
Create the list of holes and tools for a given board.
void CreateMapFilesSet(const wxString &aPlotDirectory, REPORTER *aReporter=nullptr)
Create the full set of map files for the board, in PS, PDF ... format (use SetMapFileFormat() to sele...
virtual const wxString getDrillFileName(DRILL_LAYER_PAIR aPair, bool aNPTH, bool aMerge_PTH_NPTH) const override
int createDrillFile(wxString &aFullFilename, bool aIsNpth, DRILL_LAYER_PAIR aLayerPair)
Create an Excellon drill file.
virtual REPORTER & ReportTail(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED)
Places the report at the end of the list, for objects that support report ordering.
Definition: reporter.h:99
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED)=0
Report a string with a given severity.
#define _(s)
@ RPT_SEVERITY_ERROR
@ RPT_SEVERITY_INFO
@ RPT_SEVERITY_ACTION

References _, B_Cu, GENDRILL_WRITER_BASE::buildHolesList(), createDrillFile(), GENDRILL_WRITER_BASE::CreateMapFilesSet(), F_Cu, getDrillFileName(), GENDRILL_WRITER_BASE::getHolesCount(), GENDRILL_WRITER_BASE::getUniqueLayerPairs(), GENDRILL_WRITER_BASE::m_merge_PTH_NPTH, REPORTER::Report(), REPORTER::ReportTail(), RPT_SEVERITY_ACTION, RPT_SEVERITY_ERROR, and RPT_SEVERITY_INFO.

Referenced by DIALOG_GENDRILL::GenDrillAndMapFiles(), and PCBNEW_JOBS_HANDLER::JobExportDrill().

◆ createDrillFile()

int GERBER_WRITER::createDrillFile ( wxString &  aFullFilename,
bool  aIsNpth,
DRILL_LAYER_PAIR  aLayerPair 
)
private

Create an Excellon drill file.

Parameters
aFullFilenameis the full file name.
aIsNpthset to true for a NPTH file or false for a PTH file.
aLayerPairis the first board layer and the last board layer for this drill file for blind buried vias, they are not always top and bottom layers/
Returns
hole count or -1 if the file cannot be created.

Definition at line 134 of file gendrill_gerber_writer.cpp.

136{
137 int holes_count;
138
139 LOCALE_IO dummy; // Use the standard notation for double numbers
140
141 GERBER_PLOTTER plotter;
142
143 // Gerber drill file imply X2 format:
144 plotter.UseX2format( true );
145 plotter.UseX2NetAttributes( true );
146 plotter.DisableApertMacros( false );
147
148 // Add the standard X2 header, without FileFunction
149 AddGerberX2Header( &plotter, m_pcb );
150 plotter.SetViewport( m_offset, pcbIUScale.IU_PER_MILS/10, /* scale */ 1.0, /* mirror */false );
151
152 // has meaning only for gerber plotter. Must be called only after SetViewport
153 plotter.SetGerberCoordinatesFormat( 6 );
154 plotter.SetCreator( wxT( "PCBNEW" ) );
155
156 // Add the standard X2 FileFunction for drill files
157 // %TF.FileFunction,Plated[NonPlated],layer1num,layer2num,PTH[NPTH][Blind][Buried],Drill[Route][Mixed]*%
158 wxString text = BuildFileFunctionAttributeString( aLayerPair,
159 aIsNpth ? TYPE_FILE::NPTH_FILE
160 : TYPE_FILE::PTH_FILE );
161 plotter.AddLineToHeader( text );
162
163 // Add file polarity (positive)
164 text = wxT( "%TF.FilePolarity,Positive*%" );
165 plotter.AddLineToHeader( text );
166
167 if( !plotter.OpenFile( aFullFilename ) )
168 return -1;
169
170 plotter.StartPlot( wxT( "1" ) );
171
172 holes_count = 0;
173
174 VECTOR2I hole_pos;
175 bool last_item_is_via = true; // a flag to clear object attributes when a via hole is created.
176
177 for( unsigned ii = 0; ii < m_holeListBuffer.size(); ii++ )
178 {
179 HOLE_INFO& hole_descr = m_holeListBuffer[ii];
180 hole_pos = hole_descr.m_Hole_Pos;
181
182 // Manage the aperture attributes: in drill files 3 attributes can be used:
183 // "ViaDrill", only for vias, not pads
184 // "ComponentDrill", only for Through Holes pads
185 // "Slot" for oblong holes;
186 GBR_METADATA gbr_metadata;
187
188 if( dyn_cast<const PCB_VIA*>( hole_descr.m_ItemParent ) )
189 {
191
192 if( !last_item_is_via )
193 {
194 // be sure the current object attribute is cleared for vias
195 plotter.EndBlock( nullptr );
196 }
197
198 last_item_is_via = true;
199 }
200 else if( dyn_cast<const PAD*>( hole_descr.m_ItemParent ) )
201 {
202 last_item_is_via = false;
203 const PAD* pad = dyn_cast<const PAD*>( hole_descr.m_ItemParent );
204
205 if( pad->GetProperty() == PAD_PROP::CASTELLATED )
206 {
207 gbr_metadata.SetApertureAttrib(
209 }
210 else
211 {
212 // Good practice of oblong pad holes (slots) is to use a specific aperture for
213 // routing, not used in drill commands.
214 if( hole_descr.m_Hole_Shape )
215 gbr_metadata.SetApertureAttrib(
217 else
218 gbr_metadata.SetApertureAttrib(
220 }
221
222 // Add object attribute: component reference to pads (mainly useful for users)
223 wxString ref = pad->GetParent()->GetReference();
224
225 gbr_metadata.SetCmpReference( ref );
227 }
228
229 if( hole_descr.m_Hole_Shape )
230 {
231#if FLASH_OVAL_HOLE // set to 1 to use flashed oblong holes,
232 // 0 to draw them as a line.
233 plotter.FlashPadOval( hole_pos, hole_descr.m_Hole_Size, hole_descr.m_Hole_Orient,
234 FILLED, &gbr_metadata );
235#else
236 // Use routing for oblong hole (Slots)
237 VECTOR2I start, end;
238 convertOblong2Segment( hole_descr.m_Hole_Size, hole_descr.m_Hole_Orient, start, end );
239 int width = std::min( hole_descr.m_Hole_Size.x, hole_descr.m_Hole_Size.y );
240
241 if ( width == 0 )
242 continue;
243
244 plotter.ThickSegment( start+hole_pos, end+hole_pos, width, FILLED, &gbr_metadata );
245#endif
246 }
247 else
248 {
249 int diam = std::min( hole_descr.m_Hole_Size.x, hole_descr.m_Hole_Size.y );
250 plotter.FlashPadCircle( hole_pos, diam, FILLED, &gbr_metadata );
251 }
252
253 holes_count++;
254 }
255
256 plotter.EndPlot();
257
258 return holes_count;
259}
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:109
@ GBR_APERTURE_ATTRIB_CMP_DRILL
aperture used for pad holes in drill files.
Definition: gbr_metadata.h:140
@ GBR_APERTURE_ATTRIB_CMP_OBLONG_DRILL
aperture used for flashed cmp position in placement files.
Definition: gbr_metadata.h:143
@ GBR_APERTURE_ATTRIB_VIADRILL
aperture used for via holes in drill files.
Definition: gbr_metadata.h:139
Metadata which can be added in a gerber file as attribute in X2 format.
Definition: gbr_metadata.h:205
void SetCmpReference(const wxString &aComponentRef)
Definition: gbr_metadata.h:241
void SetApertureAttrib(GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB aApertAttribute)
Definition: gbr_metadata.h:209
void SetNetAttribType(int aNetAttribType)
Definition: gbr_metadata.h:219
@ GBR_NETINFO_CMP
print info associated to a component (TO.C attribute)
const wxString BuildFileFunctionAttributeString(DRILL_LAYER_PAIR aLayerPair, TYPE_FILE aHoleType, bool aCompatNCdrill=false) const
virtual void SetGerberCoordinatesFormat(int aResolution, bool aUseInches=false) override
Selection of Gerber units and resolution (number of digits in mantissa).
virtual void FlashPadCircle(const VECTOR2I &pos, int diametre, OUTLINE_MODE trace_mode, void *aData) override
Filled circular flashes are stored as apertures.
virtual void SetViewport(const VECTOR2I &aOffset, double aIusPerDecimil, double aScale, bool aMirror) override
Set the plot offset and scaling for the current plot.
virtual bool EndPlot() override
void UseX2format(bool aEnable)
virtual void FlashPadOval(const VECTOR2I &aPadPos, const VECTOR2I &aSize, const EDA_ANGLE &aOrient, OUTLINE_MODE aTraceMode, void *aData) override
void UseX2NetAttributes(bool aEnable)
virtual void EndBlock(void *aData) override
Define the end of a group of drawing items the group is started by StartBlock().
virtual void ThickSegment(const VECTOR2I &start, const VECTOR2I &end, int width, OUTLINE_MODE tracemode, void *aData) override
virtual bool StartPlot(const wxString &pageNumber) override
Write GERBER header to file initialize global variable g_Plot_PlotOutputFile.
void DisableApertMacros(bool aDisable)
Disable Aperture Macro (AM) command, only for broken Gerber Readers.
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: locale_io.h:41
virtual bool OpenFile(const wxString &aFullFilename)
Open or create the plot file aFullFilename.
Definition: plotter.cpp:74
virtual void SetCreator(const wxString &aCreator)
Definition: plotter.h:159
void AddLineToHeader(const wxString &aExtraString)
Add a line to the list of free lines to print at the beginning of the file.
Definition: plotter.h:168
@ FILLED
Definition: outline_mode.h:27
@ CASTELLATED
a pad with a castellated through hole
void AddGerberX2Header(PLOTTER *aPlotter, const BOARD *aBoard, bool aUseX1CompatibilityMode)
Calculate some X2 attributes as defined in the Gerber file format specification J4 (chapter 5) and ad...
Definition: pcbplot.cpp:276
std::vector< FAB_LAYER_COLOR > dummy
const double IU_PER_MILS
Definition: base_units.h:78

References AddGerberX2Header(), PLOTTER::AddLineToHeader(), GENDRILL_WRITER_BASE::BuildFileFunctionAttributeString(), CASTELLATED, GERBER_PLOTTER::DisableApertMacros(), dummy, GERBER_PLOTTER::EndBlock(), GERBER_PLOTTER::EndPlot(), FILLED, GERBER_PLOTTER::FlashPadCircle(), GERBER_PLOTTER::FlashPadOval(), GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CASTELLATEDDRILL, GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CMP_DRILL, GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CMP_OBLONG_DRILL, GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_VIADRILL, GBR_NETLIST_METADATA::GBR_NETINFO_CMP, EDA_IU_SCALE::IU_PER_MILS, HOLE_INFO::m_Hole_Orient, HOLE_INFO::m_Hole_Pos, HOLE_INFO::m_Hole_Shape, HOLE_INFO::m_Hole_Size, GENDRILL_WRITER_BASE::m_holeListBuffer, HOLE_INFO::m_ItemParent, GENDRILL_WRITER_BASE::m_offset, GENDRILL_WRITER_BASE::m_pcb, PLOTTER::OpenFile(), pad, pcbIUScale, GBR_METADATA::SetApertureAttrib(), GBR_METADATA::SetCmpReference(), PLOTTER::SetCreator(), GERBER_PLOTTER::SetGerberCoordinatesFormat(), GBR_METADATA::SetNetAttribType(), GERBER_PLOTTER::SetViewport(), GERBER_PLOTTER::StartPlot(), text, GERBER_PLOTTER::ThickSegment(), GERBER_PLOTTER::UseX2format(), GERBER_PLOTTER::UseX2NetAttributes(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by CreateDrillandMapFilesSet().

◆ CreateMapFilesSet()

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

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 300 of file gendrill_file_writer_base.cpp.

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

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

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

◆ genDrillMapFile()

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

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 64 of file gen_drill_report_files.cpp.

65{
66 // Remark:
67 // Hole list must be created before calling this function, by buildHolesList(),
68 // for the right holes set (PTH, NPTH, buried/blind vias ...)
69
70 double scale = 1.0;
71 VECTOR2I offset = GetOffset();
72 PLOTTER* plotter = nullptr;
74 int bottom_limit = 0; // Y coord limit of page. 0 mean do not use
75
76 PCB_PLOT_PARAMS plot_opts; // starts plotting with default options
77
78 LOCALE_IO toggle; // use standard C notation for float numbers
79
80 const PAGE_INFO& page_info = m_pageInfo ? *m_pageInfo : dummy;
81
82 // Calculate dimensions and center of PCB. The Edge_Cuts layer must be visible
83 // to calculate the board edges bounding box
84 LSET visibleLayers = m_pcb->GetVisibleLayers();
85 m_pcb->SetVisibleLayers( visibleLayers | LSET( Edge_Cuts ) );
87 m_pcb->SetVisibleLayers( visibleLayers );
88
89 // Some formats cannot be used to generate a document like the map files
90 // Currently HPGL (old format not very used)
91
92 if( aFormat == PLOT_FORMAT::HPGL )
93 aFormat = PLOT_FORMAT::PDF;
94
95 // Calculate the scale for the format type, scale 1 in HPGL, drawing on
96 // an A4 sheet in PS, + text description of symbols
97 switch( aFormat )
98 {
100 plotter = new GERBER_PLOTTER();
101 plotter->SetViewport( offset, pcbIUScale.IU_PER_MILS / 10, scale, false );
102 plotter->SetGerberCoordinatesFormat( 5 ); // format x.5 unit = mm
103 break;
104
105 default:
106 wxASSERT( false );
108
109 case PLOT_FORMAT::PDF:
111 case PLOT_FORMAT::SVG:
112 {
113 PAGE_INFO pageA4( wxT( "A4" ) );
114 VECTOR2I pageSizeIU = pageA4.GetSizeIU( pcbIUScale.IU_PER_MILS );
115
116 // Reserve a 10 mm margin around the page.
117 int margin = pcbIUScale.mmToIU( 10 );
118
119 // Calculate a scaling factor to print the board on the sheet
120 double Xscale = double( pageSizeIU.x - ( 2 * margin ) ) / bbbox.GetWidth();
121
122 // We should print the list of drill sizes, so reserve room for it
123 // 60% height for board 40% height for list
124 int ypagesize_for_board = KiROUND( pageSizeIU.y * 0.6 );
125 double Yscale = double( ypagesize_for_board - margin ) / bbbox.GetHeight();
126
127 scale = std::min( Xscale, Yscale );
128
129 // Experience shows the scale should not to large, because texts
130 // create problem (can be to big or too small).
131 // So the scale is clipped at 3.0;
132 scale = std::min( scale, 3.0 );
133
134 offset.x = KiROUND( double( bbbox.Centre().x ) - ( pageSizeIU.x / 2.0 ) / scale );
135 offset.y = KiROUND( double( bbbox.Centre().y ) - ( ypagesize_for_board / 2.0 ) / scale );
136
137 // bottom_limit is used to plot the legend (drill diameters)
138 // texts are scaled differently for scale > 1.0 and <= 1.0
139 // so the limit is scaled differently.
140 bottom_limit = ( pageSizeIU.y - margin ) / std::min( scale, 1.0 );
141
142 if( aFormat == PLOT_FORMAT::SVG )
143 plotter = new SVG_PLOTTER;
144 else if( aFormat == PLOT_FORMAT::PDF )
145 plotter = new PDF_PLOTTER;
146 else
147 plotter = new PS_PLOTTER;
148
149 plotter->SetPageSettings( pageA4 );
150 plotter->SetViewport( offset, pcbIUScale.IU_PER_MILS / 10, scale, false );
151 break;
152 }
153
154 case PLOT_FORMAT::DXF:
155 {
156 DXF_PLOTTER* dxf_plotter = new DXF_PLOTTER;
157
158 if( m_unitsMetric )
159 dxf_plotter->SetUnits( DXF_UNITS::MILLIMETERS );
160 else
161 dxf_plotter->SetUnits( DXF_UNITS::INCHES );
162
163 plotter = dxf_plotter;
164 plotter->SetPageSettings( page_info );
165 plotter->SetViewport( offset, pcbIUScale.IU_PER_MILS / 10, scale, false );
166 break;
167 }
168 }
169
170 plotter->SetCreator( wxT( "PCBNEW" ) );
171 plotter->SetColorMode( false );
172
173 KIGFX::PCB_RENDER_SETTINGS renderSettings;
174 renderSettings.SetDefaultPenWidth( pcbIUScale.mmToIU( 0.2 ) );
175
176 plotter->SetRenderSettings( &renderSettings );
177
178 if( !plotter->OpenFile( aFullFileName ) )
179 {
180 delete plotter;
181 return false;
182 }
183
184 plotter->ClearHeaderLinesList();
185
186 // For the Gerber X2 format we need to set the "FileFunction" to Drillmap
187 // and set a few other options.
188 if( plotter->GetPlotterType() == PLOT_FORMAT::GERBER )
189 {
190 GERBER_PLOTTER* gbrplotter = static_cast <GERBER_PLOTTER*> ( plotter );
191 gbrplotter->DisableApertMacros( false );
192 gbrplotter->UseX2format( true ); // Mandatory
193 gbrplotter->UseX2NetAttributes( false ); // net attributes have no meaning here
194
195 // Attributes are added using X2 format
196 AddGerberX2Header( gbrplotter, m_pcb, false );
197
198 wxString text;
199
200 // Add the TF.FileFunction
201 text = "%TF.FileFunction,Drillmap*%";
202 gbrplotter->AddLineToHeader( text );
203
204 // Add the TF.FilePolarity
205 text = wxT( "%TF.FilePolarity,Positive*%" );
206 gbrplotter->AddLineToHeader( text );
207 }
208
209 plotter->StartPlot( wxT( "1" ) );
210
211 // Draw items on edge layer.
212 // Not all, only items useful for drill map, i.e. board outlines.
213 BRDITEMS_PLOTTER itemplotter( plotter, m_pcb, plot_opts );
214
215 // Use attributes of a drawing layer (we are not really draw the Edge.Cuts layer)
216 itemplotter.SetLayerSet( Dwgs_User );
217
218 for( BOARD_ITEM* item : m_pcb->Drawings() )
219 {
220 if( item->GetLayer() != Edge_Cuts )
221 continue;
222
223 switch( item->Type() )
224 {
225 case PCB_SHAPE_T:
226 {
227 PCB_SHAPE dummy_shape( *static_cast<PCB_SHAPE*>( item ) );
228 dummy_shape.SetLayer( Dwgs_User );
229 itemplotter.PlotPcbShape( &dummy_shape );
230 }
231 break;
232
233 default:
234 break;
235 }
236 }
237
238 int plotX, plotY, TextWidth;
239 int intervalle = 0;
240 char line[1024];
241 wxString msg;
242 int textmarginaftersymbol = pcbIUScale.mmToIU( 2 );
243
244 // Set Drill Symbols width
245 plotter->SetCurrentLineWidth( -1 );
246
247 // Plot board outlines and drill map
248 plotDrillMarks( plotter );
249
250 // Print a list of symbols used.
251 int charSize = pcbIUScale.mmToIU( 2 ); // text size in IUs
252
253 // real char scale will be 1/scale, because the global plot scale is scale
254 // for scale < 1.0 ( plot bigger actual size)
255 // Therefore charScale = 1.0 / scale keep the initial charSize
256 // (for scale < 1 we use the global scaling factor: the board must be plotted
257 // smaller than the actual size)
258 double charScale = std::min( 1.0, 1.0 / scale );
259
260 TextWidth = KiROUND( ( charSize * charScale ) / 10.0 ); // Set text width (thickness)
261 intervalle = KiROUND( charSize * charScale ) + TextWidth;
262
263 // Trace information.
264 plotX = KiROUND( bbbox.GetX() + textmarginaftersymbol * charScale );
265 plotY = bbbox.GetBottom() + intervalle;
266
267 // Plot title "Info"
268 wxString Text = wxT( "Drill Map:" );
269
270 TEXT_ATTRIBUTES attrs;
271 attrs.m_StrokeWidth = TextWidth;
273 attrs.m_Size = VECTOR2I( KiROUND( charSize * charScale ), KiROUND( charSize * charScale ) );
276 attrs.m_Multiline = false;
277
278 plotter->PlotText( VECTOR2I( plotX, plotY ), COLOR4D::UNSPECIFIED, Text, attrs, nullptr /* stroke font */ );
279
280 // For some formats (PS, PDF SVG) we plot the drill size list on more than one column
281 // because the list must be contained inside the printed page
282 // (others formats do not have a defined page size)
283 int max_line_len = 0; // The max line len in iu of the currently plotted column
284
285 for( unsigned ii = 0; ii < m_toolListBuffer.size(); ii++ )
286 {
287 DRILL_TOOL& tool = m_toolListBuffer[ii];
288
289 if( tool.m_TotalCount == 0 )
290 continue;
291
292 plotY += intervalle;
293
294 // Ensure there are room to plot the line
295 if( bottom_limit && ( plotY+intervalle > bottom_limit ) )
296 {
297 plotY = bbbox.GetBottom() + intervalle;
298 plotX += max_line_len + pcbIUScale.mmToIU( 10 );//column_width;
299 max_line_len = 0;
300 }
301
302 int plot_diam = KiROUND( tool.m_Diameter );
303
304 // For markers plotted with the comment, keep marker size <= text height
305 plot_diam = std::min( plot_diam, KiROUND( charSize * charScale ) );
306 int x = KiROUND( plotX - textmarginaftersymbol * charScale - plot_diam / 2.0 );
307 int y = KiROUND( plotY + charSize * charScale );
308
309 plotter->SetCurrentLineWidth( getMarkerBestPenSize( plot_diam ) );
310 plotter->Marker( VECTOR2I( x, y ), plot_diam, ii );
311 plotter->SetCurrentLineWidth( -1 );
312
313 // List the diameter of each drill in mm and inches.
314 snprintf( line, sizeof(line), "%3.3fmm / %2.4f\" ", diameter_in_mm( tool.m_Diameter ),
316
317 msg = FROM_UTF8( line );
318
319 // Now list how many holes and ovals are associated with each drill.
320 if( ( tool.m_TotalCount == 1 ) && ( tool.m_OvalCount == 0 ) )
321 snprintf( line, sizeof(line), "(1 hole)" );
322 else if( tool.m_TotalCount == 1 ) // && ( toolm_OvalCount == 1 )
323 snprintf( line, sizeof(line), "(1 slot)" );
324 else if( tool.m_OvalCount == 0 )
325 snprintf( line, sizeof(line), "(%d holes)", tool.m_TotalCount );
326 else if( tool.m_OvalCount == 1 )
327 snprintf( line, sizeof(line), "(%d holes + 1 slot)", tool.m_TotalCount - 1 );
328 else // if ( toolm_OvalCount > 1 )
329 snprintf( line, sizeof(line), "(%d holes + %d slots)", tool.m_TotalCount - tool.m_OvalCount,
330 tool.m_OvalCount );
331
332 msg += FROM_UTF8( line );
333
334 if( tool.m_Hole_NotPlated )
335 msg += wxT( " (not plated)" );
336
337 plotter->PlotText( VECTOR2I( plotX, y ), COLOR4D::UNSPECIFIED, msg, attrs, nullptr /* stroke font */ );
338
339 intervalle = KiROUND( ( ( charSize * charScale ) + TextWidth ) * 1.2 );
340
341 if( intervalle < ( plot_diam + ( 1 * pcbIUScale.IU_PER_MM / scale ) + TextWidth ) )
342 intervalle = plot_diam + ( 1 * pcbIUScale.IU_PER_MM / scale ) + TextWidth;
343
344 // Evaluate the text horizontal size, to know the maximal column size
345 // This is a rough value, but ok to create a new column to plot next texts
346 int text_len = msg.Len() * ( ( charSize * charScale ) + TextWidth );
347 max_line_len = std::max( max_line_len, text_len + plot_diam );
348 }
349
350 plotter->EndPlot();
351 delete plotter;
352
353 return true;
354}
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:70
LSET GetVisibleLayers() const
A proxy function that calls the correspondent function in m_BoardSettings.
Definition: board.cpp:601
const BOX2I GetBoardEdgesBoundingBox() const
Return the board bounding box calculated using exclusively the board edges (graphics on Edge....
Definition: board.h:842
void SetVisibleLayers(LSET aLayerMask)
A proxy function that calls the correspondent function in m_BoardSettings changes the bit-mask of vis...
Definition: board.cpp:619
DRAWINGS & Drawings()
Definition: board.h:314
coord_type GetHeight() const
Definition: box2.h:188
coord_type GetWidth() const
Definition: box2.h:187
coord_type GetX() const
Definition: box2.h:180
Vec Centre() const
Definition: box2.h:70
coord_type GetBottom() const
Definition: box2.h:190
void SetUnits(DXF_UNITS aUnit)
Set the units to use for plotting the DXF file.
VECTOR2I GetOffset()
Return the plot offset (usually the position of the drill/place origin).
bool plotDrillMarks(PLOTTER *aPlotter)
Write the drill marks in HPGL, POSTSCRIPT or other supported formats/.
PCB specific render settings.
Definition: pcb_painter.h:72
void SetDefaultPenWidth(int aWidth)
LSET is a set of PCB_LAYER_IDs.
Definition: layer_ids.h:532
Describe the page size and margins of a paper page on which to eventually print or plot.
Definition: page_info.h:54
static const wxChar A4[]
Definition: page_info.h:63
Parameters and options when plotting/printing a board.
Base plotter engine class.
Definition: plotter.h:110
virtual void SetPageSettings(const PAGE_INFO &aPageSettings)
Definition: plotter.h:143
void SetRenderSettings(RENDER_SETTINGS *aSettings)
Definition: plotter.h:140
virtual bool EndPlot()=0
virtual bool StartPlot(const wxString &aPageNumber)=0
virtual void SetGerberCoordinatesFormat(int aResolution, bool aUseInches=false)
Definition: plotter.h:520
virtual PLOT_FORMAT GetPlotterType() const =0
Returns the effective plot engine in use.
void Marker(const VECTOR2I &position, int diametre, unsigned aShapeId)
Draw a pattern shape number aShapeId, to coord position.
Definition: plotter.cpp:359
void ClearHeaderLinesList()
Remove all lines from the list of free lines to print at the beginning of the file.
Definition: plotter.h:176
virtual void PlotText(const VECTOR2I &aPos, const COLOR4D &aColor, const wxString &aText, const TEXT_ATTRIBUTES &aAttributes, KIFONT::FONT *aFont, void *aData=nullptr)
Definition: plotter.cpp:758
virtual void SetViewport(const VECTOR2I &aOffset, double aIusPerDecimil, double aScale, bool aMirror)=0
Set the plot offset and scaling for the current plot.
virtual void SetColorMode(bool aColorMode)
Plot in B/W or color.
Definition: plotter.h:137
virtual void SetCurrentLineWidth(int width, void *aData=nullptr)=0
Set the line width for the next drawing.
GR_TEXT_H_ALIGN_T m_Halign
GR_TEXT_V_ALIGN_T m_Valign
static constexpr EDA_ANGLE & ANGLE_HORIZONTAL
Definition: eda_angle.h:425
double diameter_in_mm(double ius)
double diameter_in_inches(double ius)
int getMarkerBestPenSize(int aMarkerDiameter)
@ Edge_Cuts
Definition: layer_ids.h:113
@ Dwgs_User
Definition: layer_ids.h:109
#define KI_FALLTHROUGH
The KI_FALLTHROUGH macro is to be used when switch statement cases should purposely fallthrough from ...
Definition: macros.h:83
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
const int scale
const double IU_PER_MM
Definition: base_units.h:77
constexpr int mmToIU(double mm) const
Definition: base_units.h:89
@ GR_TEXT_H_ALIGN_LEFT
@ GR_TEXT_V_ALIGN_CENTER
@ PCB_SHAPE_T
class PCB_SHAPE, a segment not on copper layers
Definition: typeinfo.h:88
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:85
VECTOR2< int > VECTOR2I
Definition: vector2d.h:590

References PAGE_INFO::A4, AddGerberX2Header(), PLOTTER::AddLineToHeader(), ANGLE_HORIZONTAL, BOX2< Vec >::Centre(), PLOTTER::ClearHeaderLinesList(), diameter_in_inches(), diameter_in_mm(), GERBER_PLOTTER::DisableApertMacros(), BOARD::Drawings(), dummy, Dwgs_User, DXF, Edge_Cuts, PLOTTER::EndPlot(), FROM_UTF8(), GERBER, BOARD::GetBoardEdgesBoundingBox(), BOX2< Vec >::GetBottom(), BOX2< Vec >::GetHeight(), getMarkerBestPenSize(), GENDRILL_WRITER_BASE::GetOffset(), PLOTTER::GetPlotterType(), PAGE_INFO::GetSizeIU(), BOARD::GetVisibleLayers(), BOX2< Vec >::GetWidth(), BOX2< Vec >::GetX(), GR_TEXT_H_ALIGN_LEFT, GR_TEXT_V_ALIGN_CENTER, HPGL, INCHES, EDA_IU_SCALE::IU_PER_MILS, EDA_IU_SCALE::IU_PER_MM, KI_FALLTHROUGH, KiROUND(), TEXT_ATTRIBUTES::m_Angle, DRILL_TOOL::m_Diameter, TEXT_ATTRIBUTES::m_Halign, DRILL_TOOL::m_Hole_NotPlated, TEXT_ATTRIBUTES::m_Multiline, DRILL_TOOL::m_OvalCount, GENDRILL_WRITER_BASE::m_pageInfo, GENDRILL_WRITER_BASE::m_pcb, TEXT_ATTRIBUTES::m_Size, TEXT_ATTRIBUTES::m_StrokeWidth, GENDRILL_WRITER_BASE::m_toolListBuffer, DRILL_TOOL::m_TotalCount, GENDRILL_WRITER_BASE::m_unitsMetric, TEXT_ATTRIBUTES::m_Valign, PLOTTER::Marker(), MILLIMETERS, EDA_IU_SCALE::mmToIU(), PLOTTER::OpenFile(), PCB_SHAPE_T, pcbIUScale, PDF, GENDRILL_WRITER_BASE::plotDrillMarks(), BRDITEMS_PLOTTER::PlotPcbShape(), PLOTTER::PlotText(), POST, scale, PLOTTER::SetColorMode(), PLOTTER::SetCreator(), PLOTTER::SetCurrentLineWidth(), KIGFX::RENDER_SETTINGS::SetDefaultPenWidth(), PLOTTER::SetGerberCoordinatesFormat(), BOARD_ITEM::SetLayer(), BRDITEMS_PLOTTER::SetLayerSet(), PLOTTER::SetPageSettings(), PLOTTER::SetRenderSettings(), DXF_PLOTTER::SetUnits(), PLOTTER::SetViewport(), BOARD::SetVisibleLayers(), PLOTTER::StartPlot(), SVG, text, GERBER_PLOTTER::UseX2format(), GERBER_PLOTTER::UseX2NetAttributes(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by GENDRILL_WRITER_BASE::CreateMapFilesSet().

◆ GenDrillReportFile()

bool GENDRILL_WRITER_BASE::GenDrillReportFile ( const wxString &  aFullFileName)
inherited

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 357 of file gen_drill_report_files.cpp.

358{
359 FILE_OUTPUTFORMATTER out( aFullFileName );
360
361 static const char separator[] =
362 " =============================================================\n";
363
364 wxASSERT( m_pcb );
365
366 unsigned totalHoleCount;
367 wxFileName brdFilename( m_pcb->GetFileName() );
368
369 std::vector<DRILL_LAYER_PAIR> hole_sets = getUniqueLayerPairs();
370
371 out.Print( 0, "Drill report for %s\n", TO_UTF8( brdFilename.GetFullName() ) );
372 out.Print( 0, "Created on %s\n\n", TO_UTF8( DateAndTime() ) );
373
374 // Output the cu layer stackup, so layer name references make sense.
375 out.Print( 0, "Copper Layer Stackup:\n" );
376 out.Print( 0, separator );
377
379
380 int conventional_layer_num = 1;
381
382 for( LSEQ seq = cu.Seq(); seq; ++seq, ++conventional_layer_num )
383 {
384 out.Print( 0, " L%-2d: %-25s %s\n",
385 conventional_layer_num,
386 TO_UTF8( m_pcb->GetLayerName( *seq ) ),
387 layerName( *seq ).c_str() ); // generic layer name
388 }
389
390 out.Print( 0, "\n\n" );
391
392 /* output hole lists:
393 * 1 - through holes
394 * 2 - for partial holes only: by layer starting and ending pair
395 * 3 - Non Plated through holes
396 */
397
398 bool buildNPTHlist = false; // First pass: build PTH list only
399
400 // in this loop are plated only:
401 for( unsigned pair_ndx = 0; pair_ndx < hole_sets.size(); ++pair_ndx )
402 {
403 DRILL_LAYER_PAIR pair = hole_sets[pair_ndx];
404
405 buildHolesList( pair, buildNPTHlist );
406
407 if( pair == DRILL_LAYER_PAIR( F_Cu, B_Cu ) )
408 {
409 out.Print( 0, "Drill file '%s' contains\n",
410 TO_UTF8( getDrillFileName( pair, false, m_merge_PTH_NPTH ) ) );
411
412 out.Print( 0, " plated through holes:\n" );
413 out.Print( 0, separator );
414 totalHoleCount = printToolSummary( out, false );
415 out.Print( 0, " Total plated holes count %u\n", totalHoleCount );
416 }
417 else // blind/buried
418 {
419 out.Print( 0, "Drill file '%s' contains\n",
420 TO_UTF8( getDrillFileName( pair, false, m_merge_PTH_NPTH ) ) );
421
422 out.Print( 0, " holes connecting layer pair: '%s and %s' (%s vias):\n",
423 TO_UTF8( m_pcb->GetLayerName( ToLAYER_ID( pair.first ) ) ),
424 TO_UTF8( m_pcb->GetLayerName( ToLAYER_ID( pair.second ) ) ),
425 pair.first == F_Cu || pair.second == B_Cu ? "blind" : "buried" );
426
427 out.Print( 0, separator );
428 totalHoleCount = printToolSummary( out, false );
429 out.Print( 0, " Total plated holes count %u\n", totalHoleCount );
430 }
431
432 out.Print( 0, "\n\n" );
433 }
434
435 // NPTHoles. Generate the full list (pads+vias) if PTH and NPTH are merged,
436 // or only the NPTH list (which never has vias)
437 if( !m_merge_PTH_NPTH )
438 buildNPTHlist = true;
439
440 buildHolesList( DRILL_LAYER_PAIR( F_Cu, B_Cu ), buildNPTHlist );
441
442 // nothing wrong with an empty NPTH file in report.
443 if( m_merge_PTH_NPTH )
444 out.Print( 0, "Not plated through holes are merged with plated holes\n" );
445 else
446 out.Print( 0, "Drill file '%s' contains\n",
448 true, m_merge_PTH_NPTH ) ) );
449
450 out.Print( 0, " unplated through holes:\n" );
451 out.Print( 0, separator );
452 totalHoleCount = printToolSummary( out, true );
453 out.Print( 0, " Total unplated holes count %u\n", totalHoleCount );
454
455 return true;
456}
LSET GetEnabledLayers() const
A proxy function that calls the corresponding function in m_BoardSettings.
Definition: board.cpp:587
const wxString & GetFileName() const
Definition: board.h:306
const wxString GetLayerName(PCB_LAYER_ID aLayer) const
Return the name of a aLayer.
Definition: board.cpp:474
Used for text file output.
Definition: richio.h:457
unsigned printToolSummary(OUTPUTFORMATTER &aOut, bool aSummaryNPTH) const
Print m_toolListBuffer[] tools to aOut and returns total hole count.
const std::string layerName(PCB_LAYER_ID aLayer) const
LSEQ is a sequence (and therefore also a set) of PCB_LAYER_IDs.
Definition: layer_ids.h:493
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
static LSET AllCuMask(int aCuLayerCount=MAX_CU_LAYERS)
Return a mask holding the requested number of Cu PCB_LAYER_IDs.
Definition: lset.cpp:773
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition: lset.cpp:932
#define TO_UTF8(wxstring)
Convert a wxString to a UTF8 encoded C string for all wxWidgets build modes.
Definition: macros.h:96
wxString DateAndTime()

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

Referenced by DIALOG_GENDRILL::OnGenReportFile().

◆ GetDrillFileExt()

wxString GENDRILL_WRITER_BASE::GetDrillFileExt ( ) const
inlineinherited

Returns the file extension of the drill writer format.

Definition at line 270 of file gendrill_file_writer_base.h.

270{ return m_drillFileExtension; }

References GENDRILL_WRITER_BASE::m_drillFileExtension.

◆ getDrillFileName()

const wxString GERBER_WRITER::getDrillFileName ( DRILL_LAYER_PAIR  aPair,
bool  aNPTH,
bool  aMerge_PTH_NPTH 
) const
overrideprivatevirtual
Parameters
aPairis the layer pair.
aNPTHset to true to generate the filename of NPTH holes.
aMerge_PTH_NPTHset to true to generate the filename of a file which contains 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 from GENDRILL_WRITER_BASE.

Definition at line 299 of file gendrill_gerber_writer.cpp.

301{
302 // Gerber files extension is always .gbr.
303 // Therefore, to mark drill files, add "-drl" to the filename.
304 wxFileName fname( GENDRILL_WRITER_BASE::getDrillFileName( aPair, aNPTH, aMerge_PTH_NPTH ) );
305 fname.SetName( fname.GetName() + wxT( "-drl" ) );
306
307 return fname.GetFullPath();
308}

References GENDRILL_WRITER_BASE::getDrillFileName().

Referenced by CreateDrillandMapFilesSet().

◆ getHolesCount()

int GENDRILL_WRITER_BASE::getHolesCount ( ) const
inlineprotectedinherited

◆ GetOffset()

VECTOR2I GENDRILL_WRITER_BASE::GetOffset ( )
inlineinherited

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 GENDRILL_WRITER_BASE::m_offset.

Referenced by GENDRILL_WRITER_BASE::genDrillMapFile().

◆ getUniqueLayerPairs()

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

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

Definition at line 210 of file gendrill_file_writer_base.cpp.

211{
212 wxASSERT( m_pcb );
213
215
216 vias.Collect( m_pcb, { PCB_VIA_T } );
217
218 std::set<DRILL_LAYER_PAIR> unique;
219 DRILL_LAYER_PAIR layer_pair;
220
221 for( int i = 0; i < vias.GetCount(); ++i )
222 {
223 PCB_VIA* v = static_cast<PCB_VIA*>( vias[i] );
224
225 v->LayerPair( &layer_pair.first, &layer_pair.second );
226
227 // only make note of blind buried.
228 // thru hole is placed unconditionally as first in fetched list.
229 if( layer_pair != DRILL_LAYER_PAIR( F_Cu, B_Cu ) )
230 unique.insert( layer_pair );
231 }
232
233 std::vector<DRILL_LAYER_PAIR> ret;
234
235 ret.emplace_back( F_Cu, B_Cu ); // always first in returned list
236
237 for( const DRILL_LAYER_PAIR& pair : unique )
238 ret.push_back( pair );
239
240 return ret;
241}
int GetCount() const
Return the number of objects in the list.
Definition: collector.h:81
Collect all BOARD_ITEM objects of a given set of KICAD_T type(s).
Definition: collectors.h:522
void Collect(BOARD_ITEM *aBoard, const std::vector< KICAD_T > &aTypes)
Collect BOARD_ITEM objects using this class's Inspector method, which does the collection.
Definition: collectors.cpp:631
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:571

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

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

◆ layerName()

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

Definition at line 244 of file gendrill_file_writer_base.cpp.

245{
246 // Generic names here.
247 switch( aLayer )
248 {
249 case F_Cu:
250 return "front";
251 case B_Cu:
252 return "back";
253 default:
254 return StrPrintf( "in%d", aLayer );
255 }
256}
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:84

References B_Cu, F_Cu, and StrPrintf().

Referenced by GENDRILL_WRITER_BASE::GenDrillReportFile(), and GENDRILL_WRITER_BASE::layerPairName().

◆ layerPairName()

const std::string GENDRILL_WRITER_BASE::layerPairName ( DRILL_LAYER_PAIR  aPair) const
protectedinherited
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 259 of file gendrill_file_writer_base.cpp.

260{
261 std::string ret = layerName( aPair.first );
262 ret += '-';
263 ret += layerName( aPair.second );
264
265 return ret;
266}

References GENDRILL_WRITER_BASE::layerName().

Referenced by GENDRILL_WRITER_BASE::getDrillFileName().

◆ plotDrillMarks()

bool GENDRILL_WRITER_BASE::plotDrillMarks ( PLOTTER aPlotter)
protectedinherited

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 459 of file gen_drill_report_files.cpp.

460{
461 // Plot the drill map:
462 VECTOR2I pos;
463
464 for( unsigned ii = 0; ii < m_holeListBuffer.size(); ii++ )
465 {
466 const HOLE_INFO& hole = m_holeListBuffer[ii];
467 pos = hole.m_Hole_Pos;
468
469 // Gives a good line thickness to have a good marker shape:
471
472 // Always plot the drill symbol (for slots identifies the needed cutter!
473 aPlotter->Marker( pos, hole.m_Hole_Diameter, hole.m_Tool_Reference - 1 );
474
475 if( hole.m_Hole_Shape != 0 )
476 aPlotter->FlashPadOval( pos, hole.m_Hole_Size, hole.m_Hole_Orient, SKETCH, nullptr );
477 }
478
479 aPlotter->SetCurrentLineWidth( -1 );
480
481 return true;
482}
virtual void FlashPadOval(const VECTOR2I &aPadPos, const VECTOR2I &aSize, const EDA_ANGLE &aPadOrient, OUTLINE_MODE aTraceMode, void *aData)=0
@ SKETCH
Definition: outline_mode.h:26

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, GENDRILL_WRITER_BASE::m_holeListBuffer, HOLE_INFO::m_Tool_Reference, PLOTTER::Marker(), PLOTTER::SetCurrentLineWidth(), and SKETCH.

Referenced by GENDRILL_WRITER_BASE::genDrillMapFile().

◆ printToolSummary()

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

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 485 of file gen_drill_report_files.cpp.

486{
487 unsigned totalHoleCount = 0;
488
489 for( unsigned ii = 0; ii < m_toolListBuffer.size(); ii++ )
490 {
491 const DRILL_TOOL& tool = m_toolListBuffer[ii];
492
493 if( aSummaryNPTH && !tool.m_Hole_NotPlated )
494 continue;
495
496 if( !aSummaryNPTH && tool.m_Hole_NotPlated )
497 continue;
498
499 // List the tool number assigned to each drill in mm then in inches.
500 int tool_number = ii+1;
501 out.Print( 0, " T%d %2.3fmm %2.4f\" ", tool_number,
504
505 // Now list how many holes and ovals are associated with each drill.
506 if( ( tool.m_TotalCount == 1 ) && ( tool.m_OvalCount == 0 ) )
507 out.Print( 0, "(1 hole)\n" );
508 else if( tool.m_TotalCount == 1 )
509 out.Print( 0, "(1 hole) (with 1 slot)\n" );
510 else if( tool.m_OvalCount == 0 )
511 out.Print( 0, "(%d holes)\n", tool.m_TotalCount );
512 else if( tool.m_OvalCount == 1 )
513 out.Print( 0, "(%d holes) (with 1 slot)\n", tool.m_TotalCount );
514 else // tool.m_OvalCount > 1
515 out.Print( 0, "(%d holes) (with %d slots)\n", tool.m_TotalCount, tool.m_OvalCount );
516
517 totalHoleCount += tool.m_TotalCount;
518 }
519
520 out.Print( 0, "\n" );
521
522 return totalHoleCount;
523}

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

Referenced by GENDRILL_WRITER_BASE::GenDrillReportFile().

◆ SetFormat()

void GERBER_WRITER::SetFormat ( int  aRightDigits = 6)

Initialize internal parameters to match the given format.

Parameters
aRightDigitsis the number of digits for mantissa part of coordinates (5 or 6).

Definition at line 288 of file gendrill_gerber_writer.cpp.

289{
290 /* Set conversion scale depending on drill file units */
291 m_conversionUnits = 1.0 / pcbIUScale.IU_PER_MM; // Gerber units = mm
292
293 // Set precision (unit is mm).
294 m_precision.m_Lhs = 4;
295 m_precision.m_Rhs = aRightDigits == 6 ? 6 : 5;
296}

References EDA_IU_SCALE::IU_PER_MM, GENDRILL_WRITER_BASE::m_conversionUnits, DRILL_PRECISION::m_Lhs, GENDRILL_WRITER_BASE::m_precision, DRILL_PRECISION::m_Rhs, and pcbIUScale.

Referenced by DIALOG_GENDRILL::GenDrillAndMapFiles(), and PCBNEW_JOBS_HANDLER::JobExportDrill().

◆ SetMapFileFormat()

void GENDRILL_WRITER_BASE::SetMapFileFormat ( PLOT_FORMAT  aMapFmt)
inlineinherited

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 GENDRILL_WRITER_BASE::m_mapFileFmt.

Referenced by DIALOG_GENDRILL::GenDrillAndMapFiles(), and PCBNEW_JOBS_HANDLER::JobExportDrill().

◆ SetMergeOption()

void GENDRILL_WRITER_BASE::SetMergeOption ( bool  aMerge)
inlineinherited

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.

178{ m_merge_PTH_NPTH = aMerge; }

References GENDRILL_WRITER_BASE::m_merge_PTH_NPTH.

Referenced by DIALOG_GENDRILL::OnGenReportFile().

◆ SetOptions()

void GERBER_WRITER::SetOptions ( const VECTOR2I aOffset)
inline

Initialize internal parameters to match drill options.

Note
PTH and NPTH are always separate files in Gerber format.
Parameters
aOffsetis the drill coordinates offset.

Definition at line 63 of file gendrill_gerber_writer.h.

64 {
65 m_offset = aOffset;
66 m_merge_PTH_NPTH = false;
67 }

References GENDRILL_WRITER_BASE::m_merge_PTH_NPTH, and GENDRILL_WRITER_BASE::m_offset.

Referenced by DIALOG_GENDRILL::GenDrillAndMapFiles(), and PCBNEW_JOBS_HANDLER::JobExportDrill().

◆ SetPageInfo()

void GENDRILL_WRITER_BASE::SetPageInfo ( const PAGE_INFO aPageInfo)
inlineinherited

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 GENDRILL_WRITER_BASE::m_pageInfo.

Member Data Documentation

◆ m_conversionUnits

◆ m_drillFileExtension

wxString GENDRILL_WRITER_BASE::m_drillFileExtension
protectedinherited

◆ m_holeListBuffer

◆ m_mapFileFmt

◆ m_merge_PTH_NPTH

◆ m_offset

◆ m_pageInfo

const PAGE_INFO* GENDRILL_WRITER_BASE::m_pageInfo
protectedinherited

◆ m_pcb

◆ m_precision

DRILL_PRECISION GENDRILL_WRITER_BASE::m_precision
protectedinherited

◆ m_toolListBuffer

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

◆ m_unitsMetric

◆ m_zeroFormat


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