KiCad PCB EDA Suite
board_adapter.cpp
Go to the documentation of this file.
1 /*
2  * This program source code file is part of KiCad, a free EDA CAD application.
3  *
4  * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
5  * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, you may find one here:
19  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
20  * or you may search the http://www.gnu.org website for the version 2 license,
21  * or you may write to the Free Software Foundation, Inc.,
22  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23  */
24 
30 #include "../3d_rendering/ccamera.h"
31 #include "board_adapter.h"
33 #include <board.h>
34 #include <3d_math.h>
35 #include "3d_fastmath.h"
37 #include <math/util.h> // for KiROUND
38 #include <pgm_base.h>
40 
47 const wxChar *BOARD_ADAPTER::m_logTrace = wxT( "KI_TRACE_EDA_CINFO3D_VISU" );
48 
49 
51  m_board( nullptr ),
52  m_3d_model_manager( nullptr ),
53  m_colors( nullptr ),
54  m_layerZcoordTop(),
55  m_layerZcoordBottom()
56 {
57  wxLogTrace( m_logTrace, wxT( "BOARD_ADAPTER::BOARD_ADAPTER" ) );
58 
61  m_drawFlags.resize( FL_LAST, false );
62 
63  if( PgmOrNull() )
64  m_colors = Pgm().GetSettingsManager().GetColorSettings();
65 
68 
69  m_boardPos = wxPoint();
70  m_boardSize = wxSize();
71  m_boardCenter = SFVEC3F( 0.0f );
72 
74 
78 
80  m_epoxyThickness3DU = 0.0f;
81  m_copperThickness3DU = 0.0f;
83  m_biuTo3Dunits = 1.0;
84 
86  m_stats_nr_vias = 0;
88  m_stats_nr_holes = 0;
91 
94 
97  SetFlag( FL_SHOW_BOARD_BODY, true );
102  SetFlag( FL_ZONE, true );
103  SetFlag( FL_SILKSCREEN, true );
104  SetFlag( FL_SOLDERMASK, true );
106 
112 
113  SetFlag( FL_USE_SELECTION, true );
114 
115  m_BgColorBot = SFVEC4F( 0.4, 0.4, 0.5, 1.0 );
116  m_BgColorTop = SFVEC4F( 0.8, 0.8, 0.9, 1.0 );
117  m_BoardBodyColor = SFVEC4F( 0.4, 0.4, 0.5, 0.9 );
118  m_SolderMaskColorTop = SFVEC4F( 0.1, 0.2, 0.1, 0.83 );
119  m_SolderMaskColorBot = SFVEC4F( 0.1, 0.2, 0.1, 0.83 );
120  m_SolderPasteColor = SFVEC4F( 0.4, 0.4, 0.4, 1.0 );
121  m_SilkScreenColorTop = SFVEC4F( 0.9, 0.9, 0.9, 1.0 );
122  m_SilkScreenColorBot = SFVEC4F( 0.9, 0.9, 0.9, 1.0 );
123  m_CopperColor = SFVEC4F( 0.75, 0.61, 0.23, 1.0 );
124 
127 
128  m_F_Cu_PlatedPads_poly = nullptr;
129  m_B_Cu_PlatedPads_poly = nullptr;
130 
131  // Avoid raytracing options not initialized:
135 
139 
142 }
143 
144 
146 {
147  destroyLayers();
148 }
149 
150 
152 {
153  wxASSERT( aLayer < PCB_LAYER_ID_COUNT );
154 
155  DISPLAY3D_FLG flg;
156 
157  // see if layer needs to be shown
158  // check the flags
159  switch( aLayer )
160  {
161  case B_Adhes:
162  case F_Adhes:
163  flg = FL_ADHESIVE;
164  break;
165 
166  case B_Paste:
167  case F_Paste:
168  flg = FL_SOLDERPASTE;
169  break;
170 
171  case B_SilkS:
172  case F_SilkS:
173  flg = FL_SILKSCREEN;
174  break;
175 
176  case B_Mask:
177  case F_Mask:
178  flg = FL_SOLDERMASK;
179  break;
180 
181  case Dwgs_User:
182  case Cmts_User:
184  return false;
185 
186  flg = FL_COMMENTS;
187  break;
188 
189  case Eco1_User:
190  case Eco2_User:
192  return false;
193 
194  flg = FL_ECO;
195  break;
196 
197  case Edge_Cuts:
199  return false;
200 
201  return true;
202  break;
203 
204  case Margin:
206  return false;
207 
208  return true;
209  break;
210 
211  case B_Cu:
212  case F_Cu:
213  return m_board->IsLayerVisible( aLayer ) || GetFlag( FL_USE_REALISTIC_MODE );
214  break;
215 
216  default:
217  // the layer is an internal copper layer, used the visibility
218  return m_board->IsLayerVisible( aLayer );
219  }
220 
221  // The layer has a flag, return the flag
222  return GetFlag( flg );
223 }
224 
225 
227 {
228  wxASSERT( aFlag < FL_LAST );
229 
230  return m_drawFlags[aFlag];
231 }
232 
233 
234 void BOARD_ADAPTER::SetFlag( DISPLAY3D_FLG aFlag, bool aState )
235 {
236  wxASSERT( aFlag < FL_LAST );
237 
238  m_drawFlags[aFlag] = aState;
239 }
240 
242 {
243  if( aFPAttributes & FP_SMD )
245  else if( aFPAttributes & FP_THROUGH_HOLE )
247  else
249 }
250 
251 
252 // !TODO: define the actual copper thickness by user
253 #define COPPER_THICKNESS KiROUND( 0.035 * IU_PER_MM ) // for 35 um
254 #define TECH_LAYER_THICKNESS KiROUND( 0.04 * IU_PER_MM )
255 
257 {
259 }
260 
261 unsigned int BOARD_ADAPTER::GetNrSegmentsCircle( float aDiameter3DU ) const
262 {
263  wxASSERT( aDiameter3DU > 0.0f );
264 
265  return GetNrSegmentsCircle( (int)( aDiameter3DU / m_biuTo3Dunits ) );
266 }
267 
268 
269 unsigned int BOARD_ADAPTER::GetNrSegmentsCircle( int aDiameterBIU ) const
270 {
271  wxASSERT( aDiameterBIU > 0 );
272 
273  return GetArcToSegmentCount( aDiameterBIU / 2, ARC_HIGH_DEF, 360.0 );
274 }
275 
276 
277 void BOARD_ADAPTER::InitSettings( REPORTER* aStatusReporter, REPORTER* aWarningReporter )
278 {
279  wxLogTrace( m_logTrace, wxT( "BOARD_ADAPTER::InitSettings" ) );
280 
281  if( aStatusReporter )
282  aStatusReporter->Report( _( "Build board outline" ) );
283 
284  wxString msg;
285 
286  const bool succeedToGetBoardPolygon = createBoardPolygon( &msg );
287 
288  if( aWarningReporter )
289  {
290  if( !succeedToGetBoardPolygon )
291  aWarningReporter->Report( msg, RPT_SEVERITY_WARNING );
292  else
293  aWarningReporter->Report( wxEmptyString );
294  }
295 
296  // Calculates the board bounding box (board outlines + items)
297  // to ensure any item, even outside the board outlines can be seen
298 
299  bool boardEdgesOnly = true;
300 
302  || !succeedToGetBoardPolygon )
303  boardEdgesOnly = false;
304 
305  EDA_RECT bbbox = m_board->ComputeBoundingBox( boardEdgesOnly );
306 
307  // Gives a non null size to avoid issues in zoom / scale calculations
308  if( ( bbbox.GetWidth() == 0 ) && ( bbbox.GetHeight() == 0 ) )
309  bbbox.Inflate( Millimeter2iu( 10 ) );
310 
311  m_boardSize = bbbox.GetSize();
312  m_boardPos = bbbox.Centre();
313 
314  wxASSERT( (m_boardSize.x > 0) && (m_boardSize.y > 0) );
315 
316  m_boardPos.y = -m_boardPos.y; // The y coord is inverted in 3D viewer
317 
319 
320  // Ensure the board has 2 sides for 3D views, because it is hard to find
321  // a *really* single side board in the true life...
322  if( m_copperLayersCount < 2 )
324 
325  // Calculate the convertion to apply to all positions.
327 
329 
330  // !TODO: use value defined by user (currently use default values by ctor
333 
334  // Init Z position of each layer
335  // calculate z position for each copper layer
336  // Zstart = -m_epoxyThickness / 2.0 is the z position of the back (bottom layer) (layer id = 31)
337  // Zstart = +m_epoxyThickness / 2.0 is the z position of the front (top layer) (layer id = 0)
338  // all unused copper layer z position are set to 0
339 
340  // ____==__________==________==______ <- Bottom = +m_epoxyThickness / 2.0,
341  // | | Top = Bottom + m_copperThickness
342  // |__________________________________|
343  // == == == == <- Bottom = -m_epoxyThickness / 2.0,
344  // Top = Bottom - m_copperThickness
345 
346  unsigned int layer;
347 
348  for( layer = 0; layer < m_copperLayersCount; ++layer )
349  {
350  m_layerZcoordBottom[layer] = m_epoxyThickness3DU / 2.0f -
351  (m_epoxyThickness3DU * layer / (m_copperLayersCount - 1) );
352 
353  if( layer < (m_copperLayersCount / 2) )
355  else
357  }
358 
359  #define layerThicknessMargin 1.1
360  const float zpos_offset = m_nonCopperLayerThickness3DU * layerThicknessMargin;
361 
362  // Fill remaining unused copper layers and back layer zpos
363  // with -m_epoxyThickness / 2.0
364  for( ; layer < MAX_CU_LAYERS; layer++ )
365  {
366  m_layerZcoordBottom[layer] = -(m_epoxyThickness3DU / 2.0f);
368  }
369 
370  // This is the top of the copper layer thickness.
371  const float zpos_copperTop_back = m_layerZcoordTop[B_Cu];
372  const float zpos_copperTop_front = m_layerZcoordTop[F_Cu];
373 
374  // calculate z position for each non copper layer
375  // Solder mask and Solder paste have the same Z position
376  for( int layer_id = MAX_CU_LAYERS; layer_id < PCB_LAYER_ID_COUNT; ++layer_id )
377  {
378  float zposTop;
379  float zposBottom;
380 
381  switch( layer_id )
382  {
383  case B_Adhes:
384  zposBottom = zpos_copperTop_back - 2.0f * zpos_offset;
385  zposTop = zposBottom - m_nonCopperLayerThickness3DU;
386  break;
387 
388  case F_Adhes:
389  zposBottom = zpos_copperTop_front + 2.0f * zpos_offset;
390  zposTop = zposBottom + m_nonCopperLayerThickness3DU;
391  break;
392 
393  case B_Mask:
394  case B_Paste:
395  zposBottom = zpos_copperTop_back;
396  zposTop = zpos_copperTop_back - m_nonCopperLayerThickness3DU;
397  break;
398 
399  case F_Mask:
400  case F_Paste:
401  zposTop = zpos_copperTop_front + m_nonCopperLayerThickness3DU;
402  zposBottom = zpos_copperTop_front;
403  break;
404 
405  case B_SilkS:
406  zposBottom = zpos_copperTop_back - 1.0f * zpos_offset;
407  zposTop = zposBottom - m_nonCopperLayerThickness3DU;
408  break;
409 
410  case F_SilkS:
411  zposBottom = zpos_copperTop_front + 1.0f * zpos_offset;
412  zposTop = zposBottom + m_nonCopperLayerThickness3DU;
413  break;
414 
415  // !TODO: review
416  default:
417  zposTop = zpos_copperTop_front + (layer_id - MAX_CU_LAYERS + 3.0f) * zpos_offset;
418  zposBottom = zposTop - m_nonCopperLayerThickness3DU;
419  break;
420  }
421 
422  m_layerZcoordTop[layer_id] = zposTop;
423  m_layerZcoordBottom[layer_id] = zposBottom;
424  }
425 
428  0.0f );
429 
430  SFVEC3F boardSize = SFVEC3F( m_boardSize.x * m_biuTo3Dunits,
432  0.0f );
433  boardSize /= 2.0f;
434 
435  SFVEC3F boardMin = (m_boardCenter - boardSize);
436  SFVEC3F boardMax = (m_boardCenter + boardSize);
437 
438  boardMin.z = m_layerZcoordTop[B_Adhes];
439  boardMax.z = m_layerZcoordTop[F_Adhes];
440 
441  m_boardBoundingBox = CBBOX( boardMin, boardMax );
442 
443 #ifdef PRINT_STATISTICS_3D_VIEWER
444  unsigned stats_startCreateBoardPolyTime = GetRunningMicroSecs();
445 #endif
446 
447  if( aStatusReporter )
448  aStatusReporter->Report( _( "Create layers" ) );
449 
450  createLayers( aStatusReporter );
451 }
452 
453 
454 extern bool BuildFootprintPolygonOutlines( BOARD* aBoard, SHAPE_POLY_SET& aOutlines,
455  int aTolerance,
456  OUTLINE_ERROR_HANDLER* aErrorHandler = nullptr );
457 
458 
459 bool BOARD_ADAPTER::createBoardPolygon( wxString* aErrorMsg )
460 {
462 
463  bool success;
464 
465  if( m_board->IsFootprintHolder() )
466  {
467  if( !m_board->GetFirstFootprint() )
468  {
469  if( aErrorMsg )
470  *aErrorMsg = _( "No footprint loaded." );
471 
472  return false;
473  }
474 
477 
478  // Make polygon strictly simple to avoid issues (especially in 3D viewer)
480 
481  if( !success && aErrorMsg )
482  {
483  *aErrorMsg = _( "Footprint outline is missing or malformed. Run Footprint Checker for "
484  "a full analysis." );
485  }
486  }
487  else
488  {
490 
491  if( !success && aErrorMsg )
492  *aErrorMsg = _( "Board outline is missing or malformed. Run DRC for a full analysis." );
493  }
494 
495  return success;
496 }
497 
498 
499 float BOARD_ADAPTER::GetModulesZcoord3DIU( bool aIsFlipped ) const
500 {
501  if( aIsFlipped )
502  {
503  if( GetFlag( FL_SOLDERPASTE ) )
505  else
507  }
508  else
509  {
510  if( GetFlag( FL_SOLDERPASTE ) )
511  return m_layerZcoordTop[F_SilkS];
512  else
513  return m_layerZcoordTop[F_Paste];
514  }
515 }
516 
517 
519 {
520  wxASSERT( aLayerId < PCB_LAYER_ID_COUNT );
521 
522  const COLOR4D color = m_colors->GetColor( aLayerId );
523 
524  return SFVEC4F( color.r, color.g, color.b, color.a );
525 }
526 
527 
529 {
530  return GetColor( m_colors->GetColor( aItemId ) );
531 }
532 
533 
535 {
536  return SFVEC4F( aColor.r, aColor.g, aColor.b, aColor.a );
537 }
GRID3D_TYPE m_3D_grid_type
bool GetFlag(DISPLAY3D_FLG aFlag) const
GetFlag - get a configuration status of a flag.
SFVEC4F GetColor(COLOR4D aColor) const
GetColor.
Defines math related functions.
#define TECH_LAYER_THICKNESS
SFVEC4F m_SilkScreenColorBot
in realistic mode: SilkScreen color ( bot )
bool GetBoardPolygonOutlines(SHAPE_POLY_SET &aOutlines, OUTLINE_ERROR_HANDLER *aErrorHandler=nullptr)
Extract the board outlines and build a closed polygon from lines, arcs and circle items on edge cut l...
Definition: board.cpp:1845
int m_raytrace_nrsamples_refractions
CBVHCONTAINER2D * m_platedpads_container2D_B_Cu
float m_nonCopperLayerThickness3DU
Non copper layers thickness.
float m_raytrace_spread_reflections
SHAPE_POLY_SET * m_B_Cu_PlatedPads_poly
glm::vec4 SFVEC4F
Definition: xv3d_types.h:49
int GetHolePlatingThickness() const
Pad & via drills are finish size.
void SetFlag(DISPLAY3D_FLG aFlag, bool aState)
SetFlag - set the status of a flag.
COLOR_SETTINGS * m_colors
SFVEC4F m_SolderMaskColorTop
in realistic mode: solder mask color ( top )
int color
Definition: DXF_plotter.cpp:60
CBVHCONTAINER2D m_through_holes_inner
It contains the list of throughHoles of the board, the radius is the inner hole.
int GetWidth() const
Definition: eda_rect.h:119
void InitSettings(REPORTER *aStatusReporter, REPORTER *aWarningReporter)
InitSettings - Function to be called by the render when it need to reload the settings for the board.
SFVEC4F m_BoardBodyColor
in realistic mode: FR4 board color
SFVEC4F m_SolderPasteColor
in realistic mode: solder paste color
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Definition: board.h:559
double g
Green component.
Definition: color4d.h:375
unsigned int m_stats_nr_holes
number of holes in the board
#define layerThicknessMargin
SFVEC4F m_SolderMaskColorBot
in realistic mode: solder mask color ( bot )
CBVHCONTAINER2D m_through_holes_outer_ring
It contains the list of throughHoles of the board, the radius of the hole is inflated with the annula...
wxPoint m_boardPos
center board actual position in board units
REPORTER is a pure virtual class used to derive REPORTER objects from.
Definition: reporter.h:64
std::array< float, PCB_LAYER_ID_COUNT > m_layerZcoordBottom
Bottom (Start) Z position of each layer (normalized)
float m_epoxyThickness3DU
Epoxy thickness (normalized)
unsigned int m_stats_nr_vias
Nr of vias.
float m_copperThickness3DU
Copper thickness (normalized)
KIWAY Kiway & Pgm(), KFCTL_STANDALONE
The global Program "get" accessor.
Definition: single_top.cpp:102
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED)=0
Function Report is a pure virtual function to override in the derived object.
FOOTPRINT_ATTR_T
Enum FOOTPRINT_ATTR_T is the set of attributes allowed within a FOOTPRINT, using FOOTPRINT::SetAttrib...
Definition: footprint.h:67
double b
Blue component.
Definition: color4d.h:376
RENDER_ENGINE m_render_engine
SHAPE_POLY_SET * m_F_Cu_PlatedPads_poly
PCB_LAYER_ID
A quick note on layer IDs:
double a
Alpha component.
Definition: color4d.h:377
unsigned int GetNrSegmentsCircle(float aDiameter3DU) const
GetNrSegmentsCircle.
float m_raytrace_spread_shadows
SFVEC4F m_BgColorTop
background top color
std::vector< bool > m_drawFlags
std::array< float, PCB_LAYER_ID_COUNT > m_layerZcoordTop
Top (End) Z position of each layer (normalized)
FOOTPRINT * GetFirstFootprint() const
Gets the first footprint on the board or nullptr.
Definition: board.h:348
int GetHolePlatingThicknessBIU() const noexcept
GetCopperThicknessBIU - Get the current copper layer thickness.
int m_raytrace_nrsamples_shadows
CBBOX m_boardBoundingBox
3d bounding box of the pcb board in 3d units
SHAPE_POLY_SET m_board_poly
PCB board outline polygon.
bool BuildFootprintPolygonOutlines(BOARD *aBoard, SHAPE_POLY_SET &aOutlines, int aTolerance, OUTLINE_ERROR_HANDLER *aErrorHandler=nullptr)
This function is used to extract a board outline for a footprint view.
SHAPE_POLY_SET.
Use all material properties from model file.
float m_raytrace_spread_refractions
float m_stats_track_med_width
Track average width.
float m_calc_seg_max_factor3DU
max factor used for cicle segment approximation calculation
double m_biuTo3Dunits
Normalization scale to convert board internal units to 3D units to normalize 3D units between -1....
SFVEC4F m_BgColorBot
background bottom color
bool Is3DLayerEnabled(PCB_LAYER_ID aLayer) const
Is3DLayerEnabled - Check if a layer is enabled.
a few functions useful in geometry calculations.
void Simplify(POLYGON_MODE aFastMode)
Simplifies the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) For aFast...
bool IsFootprintHolder()
Find out if the board is being used to hold a single footprint for editing/viewing.
Definition: board.h:271
int m_raytrace_recursivelevel_reflections
SFVEC4F GetItemColor(int aItemId) const
GetItemColor - get the technical color of a layer.
void createLayers(REPORTER *aStatusReporter)
int GetHeight() const
Definition: eda_rect.h:120
DISPLAY3D_FLG
Flags used in rendering options.
Definition: 3d_enums.h:34
CBVHCONTAINER2D m_through_holes_outer
It contains the list of throughHoles of the board, the radius of the hole is inflated with the copper...
COLOR4D GetColor(int aLayer) const
wxSize m_boardSize
board actual size in board units
bool IsLayerVisible(PCB_LAYER_ID aLayer) const
A proxy function that calls the correspondent function in m_BoardSettings tests whether a given layer...
Definition: board.cpp:443
SFVEC4F GetLayerColor(PCB_LAYER_ID aLayerId) const
GetLayerColor - get the technical color of a layer.
see class PGM_BASE
bool ShouldFPBeDisplayed(FOOTPRINT_ATTR_T aFPAttributes) const
ShouldFPBeDisplayed - Test if footprint should be displayed in relation to attributes and the flags.
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:186
#define _(s)
Definition: 3d_actions.cpp:33
unsigned GetRunningMicroSecs()
Function GetRunningMicroSecs An alternate way to calculate an elapset time (in microsecondes) to clas...
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
unsigned int m_copperLayersCount
Number of copper layers actually used by the board.
bool createBoardPolygon(wxString *aErrorMsg)
Create the board outline polygon.
SFVEC4F m_CopperColor
in realistic mode: copper color
int GetCopperLayerCount() const
Definition: board.cpp:425
void RemoveAllContours()
Removes all outlines & holes (clears) the polygon set.
EDA_RECT handles the component boundary box.
Definition: eda_rect.h:44
float GetModulesZcoord3DIU(bool aIsFlipped) const
GetModulesZcoord3DIU - Get the position of the footprint in 3d integer units considering if it is fli...
const std::function< void(const wxString &msg, BOARD_ITEM *itemA, BOARD_ITEM *itemB, const wxPoint &pt)> OUTLINE_ERROR_HANDLER
wxPoint Centre() const
Definition: eda_rect.h:62
float m_stats_via_med_hole_diameter
Computed medium diameter of the via holes in 3D units.
EDA_RECT ComputeBoundingBox(bool aBoardEdgesOnly=false) const
Calculate the bounding box containing all board items (or board edge segments).
Definition: board.cpp:998
Defines math related functions.
SFVEC4F m_SilkScreenColorTop
in realistic mode: SilkScreen color ( top )
float m_stats_hole_med_diameter
Computed medium diameter of the holes in 3D units.
SFVEC3F m_boardCenter
3d center position of the pcb board in 3d units
#define COPPER_THICKNESS
static const wxChar * m_logTrace
Trace mask used to enable or disable the trace output of this class.
double r
Red component.
Definition: color4d.h:374
MATERIAL_MODE m_material_mode
PGM_BASE * PgmOrNull()
similat to PGM_BASE& Pgm(), but return a reference that can be nullptr when running a shared lib from...
int m_raytrace_recursivelevel_refractions
ANTIALIASING_MODE m_antialiasing_mode
CBVHCONTAINER2D * m_platedpads_container2D_F_Cu
static constexpr int Millimeter2iu(double mm)
float m_calc_seg_min_factor3DU
min factor used for cicle segment approximation calculation
#define RANGE_SCALE_3D
This defines the range that all coord will have to be rendered.
Definition: board_adapter.h:61
CBBOX manages a bounding box defined by two SFVEC3F min max points.
Definition: cbbox.h:39
void Reset()
Function Reset reset the bounding box to zero and de-initialized it.
Definition: cbbox.cpp:99
int GetArcToSegmentCount(int aRadius, int aErrorMax, double aArcAngleDegree)
unsigned int m_stats_nr_tracks
Number of tracks in the board.
void Clear() override
EDA_RECT & Inflate(wxCoord dx, wxCoord dy)
Function Inflate inflates the rectangle horizontally by dx and vertically by dy.
Definition: eda_rect.cpp:363
const wxSize GetSize() const
Definition: eda_rect.h:103
COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:100
int m_raytrace_nrsamples_reflections