KiCad PCB EDA Suite
Loading...
Searching...
No Matches
plot_board_layers.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) 1992-2024 KiCad Developers, see AUTHORS.txt for contributors.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, you may find one here:
18 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
19 * or you may search the http://www.gnu.org website for the version 2 license,
20 * or you may write to the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24#include <wx/log.h>
25#include <eda_item.h>
26#include <layer_ids.h>
27#include <lset.h>
30#include <pcb_base_frame.h>
31#include <math/util.h> // for KiROUND
32#include <board.h>
33#include <footprint.h>
34#include <pcb_track.h>
35#include <pad.h>
36#include <zone.h>
37#include <pcb_shape.h>
38#include <pcb_target.h>
39#include <pcb_dimension.h>
40#include <pcbplot.h>
45#include <pcb_painter.h>
46#include <gbr_metadata.h>
47#include <advanced_config.h>
48
49/*
50 * Plot a solder mask layer. Solder mask layers have a minimum thickness value and cannot be
51 * drawn like standard layers, unless the minimum thickness is 0.
52 */
53static void PlotSolderMaskLayer( BOARD *aBoard, PLOTTER* aPlotter, LSET aLayerMask,
54 const PCB_PLOT_PARAMS& aPlotOpt, int aMinThickness );
55
56
57void PlotBoardLayers( BOARD* aBoard, PLOTTER* aPlotter, const LSEQ& aLayers,
58 const PCB_PLOT_PARAMS& aPlotOptions )
59{
60 if( !aBoard || !aPlotter || aLayers.empty() )
61 return;
62
63 // if a drill mark must be plotted, the copper layer needs to be plotted
64 // after other layers because the drill mark must be plotted as a filled
65 // white shape *after* all other shapes are plotted
66 bool plot_mark = aPlotOptions.GetDrillMarksType() != DRILL_MARKS::NO_DRILL_SHAPE;
67
68 for( PCB_LAYER_ID layer : aLayers )
69 {
70 // copper layers with drill marks will be plotted after all other layers
71 if( layer <= B_Cu && plot_mark )
72 continue;
73
74 PlotOneBoardLayer( aBoard, aPlotter, layer, aPlotOptions );
75 }
76
77 if( !plot_mark )
78 return;
79
80 for( PCB_LAYER_ID layer : aLayers )
81 {
82 if( layer > B_Cu ) // already plotted
83 continue;
84
85 PlotOneBoardLayer( aBoard, aPlotter, layer, aPlotOptions );
86 }
87}
88
89
90void PlotInteractiveLayer( BOARD* aBoard, PLOTTER* aPlotter, const PCB_PLOT_PARAMS& aPlotOpt )
91{
92 for( const FOOTPRINT* fp : aBoard->Footprints() )
93 {
94 if( fp->GetLayer() == F_Cu && !aPlotOpt.m_PDFFrontFPPropertyPopups )
95 continue;
96
97 if( fp->GetLayer() == B_Cu && !aPlotOpt.m_PDFBackFPPropertyPopups )
98 continue;
99
100 std::vector<wxString> properties;
101
102 properties.emplace_back( wxString::Format( wxT( "!%s = %s" ),
103 _( "Reference designator" ),
104 fp->Reference().GetShownText( false ) ) );
105
106 properties.emplace_back( wxString::Format( wxT( "!%s = %s" ),
107 _( "Value" ),
108 fp->Value().GetShownText( false ) ) );
109
110 properties.emplace_back( wxString::Format( wxT( "!%s = %s" ),
111 _( "Footprint" ),
112 fp->GetFPID().GetUniStringLibItemName() ) );
113
114 for( int i = 0; i < fp->GetFieldCount(); i++ )
115 {
116 PCB_FIELD* field = fp->GetFields().at( i );
117
118 if( field->IsReference() || field->IsValue() || field->IsFootprint() )
119 continue;
120
121 if( field->GetText().IsEmpty() )
122 continue;
123
124 properties.emplace_back( wxString::Format( wxT( "!%s = %s" ),
125 field->GetName(),
126 field->GetText() ) );
127 }
128
129 // These 2 properties are not very useful in a plot file (like a PDF)
130#if 0
131 properties.emplace_back( wxString::Format( wxT( "!%s = %s" ), _( "Library Description" ),
132 fp->GetLibDescription() ) );
133
134 properties.emplace_back( wxString::Format( wxT( "!%s = %s" ),
135 _( "Keywords" ),
136 fp->GetKeywords() ) );
137#endif
138 // Draw items are plotted with a position offset. So we need to move
139 // our boxes (which are not plotted) by the same offset.
140 VECTOR2I offset = -aPlotter->GetPlotOffsetUserUnits();
141
142 // Use a footprint bbox without texts to create the hyperlink area
143 BOX2I bbox = fp->GetBoundingBox( false, false );
144 bbox.Move( offset );
145 aPlotter->HyperlinkMenu( bbox, properties );
146
147 // Use a footprint bbox with visible texts only to create the bookmark area
148 // which is the area to zoom on ft selection
149 // However the bbox need to be inflated for a better look.
150 bbox = fp->GetBoundingBox( true, false );
151 bbox.Move( offset );
152 bbox.Inflate( bbox.GetWidth() /2, bbox.GetHeight() /2 );
153 aPlotter->Bookmark( bbox, fp->GetReference(), _( "Footprints" ) );
154 }
155}
156
157
158void PlotOneBoardLayer( BOARD *aBoard, PLOTTER* aPlotter, PCB_LAYER_ID aLayer,
159 const PCB_PLOT_PARAMS& aPlotOpt )
160{
161 auto plotLayer =
162 [&]( LSET layerMask, PCB_PLOT_PARAMS& plotOpts )
163 {
164 // PlotLayerOutlines() is designed only for DXF plotters.
165 if( plotOpts.GetFormat() == PLOT_FORMAT::DXF && plotOpts.GetDXFPlotPolygonMode() )
166 PlotLayerOutlines( aBoard, aPlotter, layerMask, plotOpts );
167 else
168 PlotStandardLayer( aBoard, aPlotter, layerMask, plotOpts );
169 };
170
171 PCB_PLOT_PARAMS plotOpt = aPlotOpt;
172 int soldermask_min_thickness = aBoard->GetDesignSettings().m_SolderMaskMinWidth;
173
174 // Set a default color and the text mode for this layer
175 aPlotter->SetColor( BLACK );
176 aPlotter->SetTextMode( aPlotOpt.GetTextMode() );
177
178 // Specify that the contents of the "Edges Pcb" layer are to be plotted in addition to the
179 // contents of the currently specified layer.
180 LSET layer_mask( aLayer );
181
182 if( IsCopperLayer( aLayer ) )
183 {
184 // Skip NPTH pads on copper layers ( only if hole size == pad size ):
185 // Drill mark will be plotted if drill mark is SMALL_DRILL_SHAPE or FULL_DRILL_SHAPE
186 if( plotOpt.GetFormat() == PLOT_FORMAT::DXF )
187 plotOpt.SetDXFPlotPolygonMode( true );
188 else
189 plotOpt.SetSkipPlotNPTH_Pads( true );
190
191 plotLayer( layer_mask, plotOpt );
192 }
193 else
194 {
195 switch( aLayer )
196 {
197 case B_Mask:
198 case F_Mask:
199 // Disable plot pad holes
201
202 // Use outline mode for DXF
203 plotOpt.SetDXFPlotPolygonMode( true );
204
205 // Plot solder mask:
206 if( soldermask_min_thickness == 0 )
207 {
208 plotLayer( layer_mask, plotOpt );
209 }
210 else
211 {
212 PlotSolderMaskLayer( aBoard, aPlotter, layer_mask, plotOpt,
213 soldermask_min_thickness );
214 }
215
216 break;
217
218 case B_Adhes:
219 case F_Adhes:
220 case B_Paste:
221 case F_Paste:
222 // Disable plot pad holes
224
225 // Use outline mode for DXF
226 plotOpt.SetDXFPlotPolygonMode( true );
227
228 plotLayer( layer_mask, plotOpt );
229
230 break;
231
232 case F_SilkS:
233 case B_SilkS:
234 plotLayer( layer_mask, plotOpt );
235
236 // Gerber: Subtract soldermask from silkscreen if enabled
237 if( aPlotter->GetPlotterType() == PLOT_FORMAT::GERBER
238 && plotOpt.GetSubtractMaskFromSilk() )
239 {
240 if( aLayer == F_SilkS )
241 layer_mask = LSET( F_Mask );
242 else
243 layer_mask = LSET( B_Mask );
244
245 // Create the mask to subtract by creating a negative layer polarity
246 aPlotter->SetLayerPolarity( false );
247
248 // Disable plot pad holes
250
251 // Plot the mask
252 PlotStandardLayer( aBoard, aPlotter, layer_mask, plotOpt );
253
254 // Disable the negative polarity
255 aPlotter->SetLayerPolarity( true );
256 }
257
258 break;
259
260 case Dwgs_User:
261 case Cmts_User:
262 case Eco1_User:
263 case Eco2_User:
264 case Edge_Cuts:
265 case Margin:
266 case F_CrtYd:
267 case B_CrtYd:
268 case F_Fab:
269 case B_Fab:
270 default:
271 plotLayer( layer_mask, plotOpt );
272 break;
273 }
274 }
275}
276
277
281void PlotStandardLayer( BOARD* aBoard, PLOTTER* aPlotter, LSET aLayerMask,
282 const PCB_PLOT_PARAMS& aPlotOpt )
283{
284 BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
285 int maxError = aBoard->GetDesignSettings().m_MaxError;
286
287 itemplotter.SetLayerSet( aLayerMask );
288
289 OUTLINE_MODE plotMode = aPlotOpt.GetPlotMode();
290 bool onCopperLayer = ( LSET::AllCuMask() & aLayerMask ).any();
291 bool onSolderMaskLayer = ( LSET( { F_Mask, B_Mask } ) & aLayerMask ).any();
292 bool onSolderPasteLayer = ( LSET( { F_Paste, B_Paste } ) & aLayerMask ).any();
293 bool onFrontFab = ( LSET( F_Fab ) & aLayerMask ).any();
294 bool onBackFab = ( LSET( B_Fab ) & aLayerMask ).any();
295 bool sketchPads = ( onFrontFab || onBackFab ) && aPlotOpt.GetSketchPadsOnFabLayers();
296
297 // Plot edge layer and graphic items
298 for( const BOARD_ITEM* item : aBoard->Drawings() )
299 itemplotter.PlotBoardGraphicItem( item );
300
301 // Draw footprint texts:
302 for( const FOOTPRINT* footprint : aBoard->Footprints() )
303 itemplotter.PlotFootprintTextItems( footprint );
304
305 // Draw footprint other graphic items:
306 for( const FOOTPRINT* footprint : aBoard->Footprints() )
307 itemplotter.PlotFootprintGraphicItems( footprint );
308
309 // Plot footprint pads
310 for( FOOTPRINT* footprint : aBoard->Footprints() )
311 {
312 aPlotter->StartBlock( nullptr );
313
314 for( PAD* pad : footprint->Pads() )
315 {
316 OUTLINE_MODE padPlotMode = plotMode;
317
318 if( !( pad->GetLayerSet() & aLayerMask ).any() )
319 {
320 if( sketchPads &&
321 ( ( onFrontFab && pad->GetLayerSet().Contains( F_Cu ) ) ||
322 ( onBackFab && pad->GetLayerSet().Contains( B_Cu ) ) ) )
323 {
324 padPlotMode = SKETCH;
325 }
326 else
327 {
328 continue;
329 }
330 }
331
332 if( onCopperLayer && !pad->IsOnCopperLayer() )
333 continue;
334
336 if( onCopperLayer && !pad->FlashLayer( aLayerMask ) )
337 continue;
338
340
341 // If we're plotting a single layer, the color for that layer can be used directly.
342 if( aLayerMask.count() == 1 )
343 {
344 color = aPlotOpt.ColorSettings()->GetColor( aLayerMask.Seq()[0] );
345 }
346 else
347 {
348 if( ( pad->GetLayerSet() & aLayerMask )[B_Cu] )
349 color = aPlotOpt.ColorSettings()->GetColor( B_Cu );
350
351 if( ( pad->GetLayerSet() & aLayerMask )[F_Cu] )
352 color = color.LegacyMix( aPlotOpt.ColorSettings()->GetColor( F_Cu ) );
353
354 if( sketchPads && aLayerMask[F_Fab] )
355 color = aPlotOpt.ColorSettings()->GetColor( F_Fab );
356 else if( sketchPads && aLayerMask[B_Fab] )
357 color = aPlotOpt.ColorSettings()->GetColor( B_Fab );
358 }
359
360 if( sketchPads &&
361 ( ( onFrontFab && pad->GetLayerSet().Contains( F_Cu ) ) ||
362 ( onBackFab && pad->GetLayerSet().Contains( B_Cu ) ) ) )
363 {
364 if( aPlotOpt.GetPlotPadNumbers() )
365 itemplotter.PlotPadNumber( pad, color );
366 }
367
368 VECTOR2I margin;
369 int width_adj = 0;
370
371 if( onCopperLayer )
372 width_adj = itemplotter.getFineWidthAdj();
373
374 if( onSolderMaskLayer )
375 margin.x = margin.y = pad->GetSolderMaskExpansion();
376
377 if( onSolderPasteLayer )
378 margin = pad->GetSolderPasteMargin();
379
380 // not all shapes can have a different margin for x and y axis
381 // in fact only oval and rect shapes can have different values.
382 // Round shape have always the same x,y margin
383 // so define a unique value for other shapes that do not support different values
384 int mask_clearance = margin.x;
385
386 // Now offset the pad size by margin + width_adj
387 VECTOR2I padPlotsSize = pad->GetSize() + margin * 2 + VECTOR2I( width_adj, width_adj );
388
389 // Store these parameters that can be modified to plot inflated/deflated pads shape
390 PAD_SHAPE padShape = pad->GetShape();
391 VECTOR2I padSize = pad->GetSize();
392 VECTOR2I padDelta = pad->GetDelta(); // has meaning only for trapezoidal pads
393 // CornerRadius and CornerRadiusRatio can be modified
394 // the radius is built from the ratio, so saving/restoring the ratio is enough
395 double padCornerRadiusRatio = pad->GetRoundRectRadiusRatio();
396
397 // Don't draw a 0 sized pad.
398 // Note: a custom pad can have its pad anchor with size = 0
399 if( pad->GetShape() != PAD_SHAPE::CUSTOM
400 && ( padPlotsSize.x <= 0 || padPlotsSize.y <= 0 ) )
401 {
402 continue;
403 }
404
405 switch( pad->GetShape() )
406 {
408 case PAD_SHAPE::OVAL:
409 pad->SetSize( padPlotsSize );
410
411 if( aPlotOpt.GetSkipPlotNPTH_Pads() &&
413 ( pad->GetSize() == pad->GetDrillSize() ) &&
414 ( pad->GetAttribute() == PAD_ATTRIB::NPTH ) )
415 {
416 break;
417 }
418
419 itemplotter.PlotPad( pad, color, padPlotMode );
420 break;
421
423 pad->SetSize( padPlotsSize );
424
425 if( mask_clearance > 0 )
426 {
427 pad->SetShape( PAD_SHAPE::ROUNDRECT );
428 pad->SetRoundRectCornerRadius( mask_clearance );
429 }
430
431 itemplotter.PlotPad( pad, color, padPlotMode );
432 break;
433
435 // inflate/deflate a trapezoid is a bit complex.
436 // so if the margin is not null, build a similar polygonal pad shape,
437 // and inflate/deflate the polygonal shape
438 // because inflating/deflating using different values for y and y
439 // we are using only margin.x as inflate/deflate value
440 if( mask_clearance == 0 )
441 {
442 itemplotter.PlotPad( pad, color, padPlotMode );
443 }
444 else
445 {
446 PAD dummy( *pad );
447 dummy.SetAnchorPadShape( PAD_SHAPE::CIRCLE );
448 dummy.SetShape( PAD_SHAPE::CUSTOM );
449 SHAPE_POLY_SET outline;
450 outline.NewOutline();
451 int dx = padSize.x / 2;
452 int dy = padSize.y / 2;
453 int ddx = padDelta.x / 2;
454 int ddy = padDelta.y / 2;
455
456 outline.Append( -dx - ddy, dy + ddx );
457 outline.Append( dx + ddy, dy - ddx );
458 outline.Append( dx - ddy, -dy + ddx );
459 outline.Append( -dx + ddy, -dy - ddx );
460
461 // Shape polygon can have holes so use InflateWithLinkedHoles(), not Inflate()
462 // which can create bad shapes if margin.x is < 0
463 outline.InflateWithLinkedHoles( mask_clearance,
466 dummy.DeletePrimitivesList();
467 dummy.AddPrimitivePoly( outline, 0, true );
468
469 // Be sure the anchor pad is not bigger than the deflated shape because this
470 // anchor will be added to the pad shape when plotting the pad. So now the
471 // polygonal shape is built, we can clamp the anchor size
472 dummy.SetSize( VECTOR2I( 0, 0 ) );
473
474 itemplotter.PlotPad( &dummy, color, padPlotMode );
475 }
476
477 break;
478
480 {
481 // rounding is stored as a percent, but we have to update this ratio
482 // to force recalculation of other values after size changing (we do not
483 // really change the rounding percent value)
484 double radius_ratio = pad->GetRoundRectRadiusRatio();
485 pad->SetSize( padPlotsSize );
486 pad->SetRoundRectRadiusRatio( radius_ratio );
487
488 itemplotter.PlotPad( pad, color, padPlotMode );
489 break;
490 }
491
493 if( mask_clearance == 0 )
494 {
495 // the size can be slightly inflated by width_adj (PS/PDF only)
496 pad->SetSize( padPlotsSize );
497 itemplotter.PlotPad( pad, color, padPlotMode );
498 }
499 else
500 {
501 // Due to the polygonal shape of a CHAMFERED_RECT pad, the best way is to
502 // convert the pad shape to a full polygon, inflate/deflate the polygon
503 // and use a dummy CUSTOM pad to plot the final shape.
504 PAD dummy( *pad );
505 // Build the dummy pad outline with coordinates relative to the pad position
506 // pad offset and orientation 0. The actual pos, offset and rotation will be
507 // taken in account later by the plot function
508 dummy.SetPosition( VECTOR2I( 0, 0 ) );
509 dummy.SetOffset( VECTOR2I( 0, 0 ) );
510 dummy.SetOrientation( ANGLE_0 );
511 SHAPE_POLY_SET outline;
512 dummy.TransformShapeToPolygon( outline, UNDEFINED_LAYER, 0, maxError,
513 ERROR_INSIDE );
514 outline.InflateWithLinkedHoles( mask_clearance,
517
518 // Initialize the dummy pad shape:
519 dummy.SetAnchorPadShape( PAD_SHAPE::CIRCLE );
520 dummy.SetShape( PAD_SHAPE::CUSTOM );
521 dummy.DeletePrimitivesList();
522 dummy.AddPrimitivePoly( outline, 0, true );
523
524 // Be sure the anchor pad is not bigger than the deflated shape because this
525 // anchor will be added to the pad shape when plotting the pad.
526 // So we set the anchor size to 0
527 dummy.SetSize( VECTOR2I( 0, 0 ) );
528 // Restore pad position and offset
529 dummy.SetPosition( pad->GetPosition() );
530 dummy.SetOffset( pad->GetOffset() );
531 dummy.SetOrientation( pad->GetOrientation() );
532
533 itemplotter.PlotPad( &dummy, color, padPlotMode );
534 }
535
536 break;
537
539 {
540 // inflate/deflate a custom shape is a bit complex.
541 // so build a similar pad shape, and inflate/deflate the polygonal shape
542 PAD dummy( *pad );
543 dummy.SetParentGroup( nullptr );
544
545 SHAPE_POLY_SET shape;
546 pad->MergePrimitivesAsPolygon( &shape );
547
548 // Shape polygon can have holes so use InflateWithLinkedHoles(), not Inflate()
549 // which can create bad shapes if margin.x is < 0
550 shape.InflateWithLinkedHoles( mask_clearance,
553 dummy.DeletePrimitivesList();
554 dummy.AddPrimitivePoly( shape, 0, true );
555
556 // Be sure the anchor pad is not bigger than the deflated shape because this
557 // anchor will be added to the pad shape when plotting the pad. So now the
558 // polygonal shape is built, we can clamp the anchor size
559 if( mask_clearance < 0 ) // we expect margin.x = margin.y for custom pads
560 dummy.SetSize( padPlotsSize );
561
562 itemplotter.PlotPad( &dummy, color, padPlotMode );
563 break;
564 }
565 }
566
567 // Restore the pad parameters modified by the plot code
568 pad->SetSize( padSize );
569 pad->SetDelta( padDelta );
570 pad->SetShape( padShape );
571 pad->SetRoundRectRadiusRatio( padCornerRadiusRatio );
572 }
573
574 aPlotter->EndBlock( nullptr );
575 }
576
577 // Plot vias on copper layers, and if aPlotOpt.GetPlotViaOnMaskLayer() is true,
578 // plot them on solder mask
579
580 GBR_METADATA gbr_metadata;
581
582 bool isOnCopperLayer = ( aLayerMask & LSET::AllCuMask() ).any();
583
584 if( isOnCopperLayer )
585 {
588 }
589
590 aPlotter->StartBlock( nullptr );
591
592 for( const PCB_TRACK* track : aBoard->Tracks() )
593 {
594 if( track->Type() != PCB_VIA_T )
595 continue;
596
597 const PCB_VIA* via = static_cast<const PCB_VIA*>( track );
598
599 // vias are not plotted if not on selected layer
600 LSET via_mask_layer = via->GetLayerSet();
601
602 if( !( via_mask_layer & aLayerMask ).any() )
603 continue;
604
605 int via_margin = 0;
606 double width_adj = 0;
607
608 if( aLayerMask[B_Mask] || aLayerMask[F_Mask] )
609 via_margin = via->GetSolderMaskExpansion();
610
611 if( ( aLayerMask & LSET::AllCuMask() ).any() )
612 width_adj = itemplotter.getFineWidthAdj();
613
614 int diameter = via->GetWidth() + 2 * via_margin + width_adj;
615
617 if( onCopperLayer && !via->FlashLayer( aLayerMask ) )
618 continue;
619
620 // Don't draw a null size item :
621 if( diameter <= 0 )
622 continue;
623
624 // Some vias can be not connected (no net).
625 // Set the m_NotInNet for these vias to force a empty net name in gerber file
626 gbr_metadata.m_NetlistMetadata.m_NotInNet = via->GetNetname().IsEmpty();
627
628 gbr_metadata.SetNetName( via->GetNetname() );
629
630 COLOR4D color = aPlotOpt.ColorSettings()->GetColor(
631 LAYER_VIAS + static_cast<int>( via->GetViaType() ) );
632
633 // Set plot color (change WHITE to LIGHTGRAY because the white items are not seen on a
634 // white paper or screen
635 aPlotter->SetColor( color != WHITE ? color : LIGHTGRAY );
636 aPlotter->FlashPadCircle( via->GetStart(), diameter, plotMode, &gbr_metadata );
637 }
638
639 aPlotter->EndBlock( nullptr );
640 aPlotter->StartBlock( nullptr );
642
643 // Plot tracks (not vias) :
644 for( const PCB_TRACK* track : aBoard->Tracks() )
645 {
646 if( track->Type() == PCB_VIA_T )
647 continue;
648
649 if( !aLayerMask[track->GetLayer()] )
650 continue;
651
652 // Some track segments can be not connected (no net).
653 // Set the m_NotInNet for these segments to force a empty net name in gerber file
654 gbr_metadata.m_NetlistMetadata.m_NotInNet = track->GetNetname().IsEmpty();
655
656 gbr_metadata.SetNetName( track->GetNetname() );
657 int width = track->GetWidth() + itemplotter.getFineWidthAdj();
658 aPlotter->SetColor( itemplotter.getColor( track->GetLayer() ) );
659
660 if( track->Type() == PCB_ARC_T )
661 {
662 const PCB_ARC* arc = static_cast<const PCB_ARC*>( track );
663
664 // Too small arcs cannot be really handled: arc center (and arc radius)
665 // cannot be safely computed
666 if( !arc->IsDegenerated( 10 /* in IU */ ) )
667 {
668 aPlotter->ThickArc( arc->GetCenter(), arc->GetArcAngleStart(), arc->GetAngle(),
669 arc->GetRadius(), width, plotMode, &gbr_metadata );
670 }
671 else
672 {
673 // Approximate this very small arc by a segment.
674 aPlotter->ThickSegment( track->GetStart(), track->GetEnd(), width, plotMode,
675 &gbr_metadata );
676 }
677 }
678 else
679 {
680 aPlotter->ThickSegment( track->GetStart(), track->GetEnd(), width, plotMode,
681 &gbr_metadata );
682 }
683 }
684
685 aPlotter->EndBlock( nullptr );
686
687 // Plot filled ares
688 aPlotter->StartBlock( nullptr );
689
690 NETINFO_ITEM nonet( aBoard );
691
692 for( const ZONE* zone : aBoard->Zones() )
693 {
694 if( zone->GetIsRuleArea() )
695 continue;
696
697 for( PCB_LAYER_ID layer : zone->GetLayerSet().Seq() )
698 {
699 if( !aLayerMask[layer] )
700 continue;
701
702 SHAPE_POLY_SET mainArea = zone->GetFilledPolysList( layer )->CloneDropTriangulation();
703 SHAPE_POLY_SET islands;
704
705 for( int i = mainArea.OutlineCount() - 1; i >= 0; i-- )
706 {
707 if( zone->IsIsland( layer, i ) )
708 {
709 islands.AddOutline( mainArea.CPolygon( i )[0] );
710 mainArea.DeletePolygon( i );
711 }
712 }
713
714 itemplotter.PlotZone( zone, layer, mainArea );
715
716 if( !islands.IsEmpty() )
717 {
718 ZONE dummy( *zone );
719 dummy.SetNet( &nonet );
720 itemplotter.PlotZone( &dummy, layer, islands );
721 }
722 }
723 }
724
725 aPlotter->EndBlock( nullptr );
726
727 // Adding drill marks, if required and if the plotter is able to plot them:
729 itemplotter.PlotDrillMarks();
730}
731
732
736void PlotLayerOutlines( BOARD* aBoard, PLOTTER* aPlotter, LSET aLayerMask,
737 const PCB_PLOT_PARAMS& aPlotOpt )
738{
739 BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
740 itemplotter.SetLayerSet( aLayerMask );
741
742 SHAPE_POLY_SET outlines;
743
744 for( PCB_LAYER_ID layer : aLayerMask.Seq( aLayerMask.SeqStackupForPlotting() ) )
745 {
746 outlines.RemoveAllContours();
747 aBoard->ConvertBrdLayerToPolygonalContours( layer, outlines );
748
750
751 // Plot outlines
752 std::vector<VECTOR2I> cornerList;
753
754 // Now we have one or more basic polygons: plot each polygon
755 for( int ii = 0; ii < outlines.OutlineCount(); ii++ )
756 {
757 for( int kk = 0; kk <= outlines.HoleCount(ii); kk++ )
758 {
759 cornerList.clear();
760 const SHAPE_LINE_CHAIN& path = ( kk == 0 ) ? outlines.COutline( ii )
761 : outlines.CHole( ii, kk - 1 );
762
763 aPlotter->PlotPoly( path, FILL_T::NO_FILL );
764 }
765 }
766
767 // Plot pad holes
769 {
770 int smallDrill = ( aPlotOpt.GetDrillMarksType() == DRILL_MARKS::SMALL_DRILL_SHAPE )
772 : INT_MAX;
773
774 for( FOOTPRINT* footprint : aBoard->Footprints() )
775 {
776 for( PAD* pad : footprint->Pads() )
777 {
778 if( pad->HasHole() )
779 {
780 std::shared_ptr<SHAPE_SEGMENT> slot = pad->GetEffectiveHoleShape();
781
782 if( slot->GetSeg().A == slot->GetSeg().B ) // circular hole
783 {
784 int drill = std::min( smallDrill, slot->GetWidth() );
785 aPlotter->Circle( pad->GetPosition(), drill, FILL_T::NO_FILL );
786 }
787 else
788 {
789 // Note: small drill marks have no significance when applied to slots
790 aPlotter->ThickSegment( slot->GetSeg().A, slot->GetSeg().B,
791 slot->GetWidth(), SKETCH, nullptr );
792 }
793 }
794 }
795 }
796 }
797
798 // Plot vias holes
799 for( PCB_TRACK* track : aBoard->Tracks() )
800 {
801 if( track->Type() != PCB_VIA_T )
802 continue;
803
804 const PCB_VIA* via = static_cast<const PCB_VIA*>( track );
805
806 if( via->GetLayerSet().Contains( layer ) ) // via holes can be not through holes
807 aPlotter->Circle( via->GetPosition(), via->GetDrillValue(), FILL_T::NO_FILL );
808 }
809 }
810}
811
812
830void PlotSolderMaskLayer( BOARD *aBoard, PLOTTER* aPlotter, LSET aLayerMask,
831 const PCB_PLOT_PARAMS& aPlotOpt, int aMinThickness )
832{
833 int maxError = aBoard->GetDesignSettings().m_MaxError;
834 PCB_LAYER_ID layer = aLayerMask[B_Mask] ? B_Mask : F_Mask;
835 SHAPE_POLY_SET buffer;
836 SHAPE_POLY_SET* boardOutline = nullptr;
837
838 if( aBoard->GetBoardPolygonOutlines( buffer ) )
839 boardOutline = &buffer;
840
841 // We remove 1nm as we expand both sides of the shapes, so allowing for a strictly greater
842 // than or equal comparison in the shape separation (boolean add)
843 int inflate = aMinThickness / 2 - 1;
844
845 BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
846 itemplotter.SetLayerSet( aLayerMask );
847
848 // Build polygons for each pad shape. The size of the shape on solder mask should be size
849 // of pad + clearance around the pad, where clearance = solder mask clearance + extra margin.
850 // Extra margin is half the min width for solder mask, which is used to merge too-close shapes
851 // (distance < aMinThickness), and will be removed when creating the actual shapes.
852
853 // Will contain shapes inflated by inflate value that will be merged and deflated by inflate
854 // value to build final polygons
855 SHAPE_POLY_SET areas;
856
857 // Will contain exact shapes of all items on solder mask
858 SHAPE_POLY_SET initialPolys;
859
860 auto plotFPTextItem =
861 [&]( const PCB_TEXT& aText )
862 {
863 if( !itemplotter.GetPlotFPText() )
864 return;
865
866 if( !aText.IsVisible() && !itemplotter.GetPlotInvisibleText() )
867 return;
868
869 if( aText.GetText() == wxT( "${REFERENCE}" ) && !itemplotter.GetPlotReference() )
870 return;
871
872 if( aText.GetText() == wxT( "${VALUE}" ) && !itemplotter.GetPlotValue() )
873 return;
874
875 // add shapes with their exact mask layer size in initialPolys
876 aText.TransformTextToPolySet( initialPolys, 0, maxError, ERROR_OUTSIDE );
877
878 // add shapes inflated by aMinThickness/2 in areas
879 aText.TransformTextToPolySet( areas, inflate, maxError, ERROR_OUTSIDE );
880 };
881
882 // Generate polygons with arcs inside the shape or exact shape to minimize shape changes
883 // created by arc to segment size correction.
885 {
886 // Plot footprint pads and graphics
887 for( const FOOTPRINT* footprint : aBoard->Footprints() )
888 {
889 // add shapes with their exact mask layer size in initialPolys
890 footprint->TransformPadsToPolySet( initialPolys, layer, 0, maxError, ERROR_OUTSIDE );
891 // add shapes inflated by aMinThickness/2 in areas
892 footprint->TransformPadsToPolySet( areas, layer, inflate, maxError, ERROR_OUTSIDE );
893
894 for( const PCB_FIELD* field : footprint->Fields() )
895 {
896 if( field->IsReference() && !itemplotter.GetPlotReference() )
897 continue;
898
899 if( field->IsValue() && !itemplotter.GetPlotValue() )
900 continue;
901
902 if( field->IsOnLayer( layer ) )
903 plotFPTextItem( static_cast<const PCB_TEXT&>( *field ) );
904 }
905
906 for( const BOARD_ITEM* item : footprint->GraphicalItems() )
907 {
908 if( item->IsOnLayer( layer ) )
909 {
910 if( item->Type() == PCB_TEXT_T )
911 {
912 plotFPTextItem( static_cast<const PCB_TEXT&>( *item ) );
913 }
914 else
915 {
916 // add shapes with their exact mask layer size in initialPolys
917 item->TransformShapeToPolygon( initialPolys, layer, 0, maxError,
919
920 // add shapes inflated by aMinThickness/2 in areas
921 item->TransformShapeToPolygon( areas, layer, inflate, maxError,
923 }
924 }
925 }
926 }
927
928 // Plot (untented) vias
929 for( const PCB_TRACK* track : aBoard->Tracks() )
930 {
931 if( track->Type() != PCB_VIA_T )
932 continue;
933
934 const PCB_VIA* via = static_cast<const PCB_VIA*>( track );
935
936 // Note: IsOnLayer() checks relevant mask layers of untented vias
937 if( !via->IsOnLayer( layer ) )
938 continue;
939
940 int clearance = via->GetSolderMaskExpansion();
941
942 // add shapes with their exact mask layer size in initialPolys
943 via->TransformShapeToPolygon( initialPolys, layer, clearance, maxError, ERROR_OUTSIDE );
944
945 // add shapes inflated by aMinThickness/2 in areas
946 clearance += inflate;
947 via->TransformShapeToPolygon( areas, layer, clearance, maxError, ERROR_OUTSIDE );
948 }
949
950 // Add filled zone areas.
951#if 0 // Set to 1 if a solder mask expansion must be applied to zones on solder mask
952 int zone_margin = aBoard->GetDesignSettings().m_SolderMaskExpansion;
953#else
954 int zone_margin = 0;
955#endif
956
957 for( const BOARD_ITEM* item : aBoard->Drawings() )
958 {
959 if( item->IsOnLayer( layer ) )
960 {
961 if( item->Type() == PCB_TEXT_T )
962 {
963 const PCB_TEXT* text = static_cast<const PCB_TEXT*>( item );
964
965 // add shapes with their exact mask layer size in initialPolys
966 text->TransformTextToPolySet( initialPolys, 0, maxError, ERROR_OUTSIDE );
967
968 // add shapes inflated by aMinThickness/2 in areas
969 text->TransformTextToPolySet( areas, inflate, maxError, ERROR_OUTSIDE );
970 }
971 else
972 {
973 // add shapes with their exact mask layer size in initialPolys
974 item->TransformShapeToPolygon( initialPolys, layer, 0, maxError,
976
977 // add shapes inflated by aMinThickness/2 in areas
978 item->TransformShapeToPolygon( areas, layer, inflate, maxError,
980 }
981 }
982 }
983
984 for( ZONE* zone : aBoard->Zones() )
985 {
986 if( zone->GetIsRuleArea() )
987 continue;
988
989 if( !zone->IsOnLayer( layer ) )
990 continue;
991
992 // add shapes inflated by aMinThickness/2 in areas
993 zone->TransformSmoothedOutlineToPolygon( areas, inflate + zone_margin, maxError,
994 ERROR_OUTSIDE, boardOutline );
995
996 // add shapes with their exact mask layer size in initialPolys
997 zone->TransformSmoothedOutlineToPolygon( initialPolys, zone_margin, maxError,
998 ERROR_OUTSIDE, boardOutline );
999 }
1000 }
1001
1002 // Merge all polygons: After deflating, not merged (not overlapping) polygons will have the
1003 // initial shape (with perhaps small changes due to deflating transform)
1005 areas.Deflate( inflate, CORNER_STRATEGY::CHAMFER_ALL_CORNERS, maxError );
1006
1007 // To avoid a lot of code, use a ZONE to handle and plot polygons, because our polygons look
1008 // exactly like filled areas in zones.
1009 // Note, also this code is not optimized: it creates a lot of copy/duplicate data.
1010 // However it is not complex, and fast enough for plot purposes (copy/convert data is only a
1011 // very small calculation time for these calculations).
1012 ZONE zone( aBoard );
1013 zone.SetMinThickness( 0 ); // trace polygons only
1014 zone.SetLayer( layer );
1015
1016 // Combine the current areas to initial areas. This is mandatory because inflate/deflate
1017 // transform is not perfect, and we want the initial areas perfectly kept
1018 areas.BooleanAdd( initialPolys, SHAPE_POLY_SET::PM_FAST );
1020
1021 itemplotter.PlotZone( &zone, layer, areas );
1022}
1023
1024
1031static void initializePlotter( PLOTTER* aPlotter, const BOARD* aBoard,
1032 const PCB_PLOT_PARAMS* aPlotOpts )
1033{
1034 PAGE_INFO pageA4( wxT( "A4" ) );
1035 const PAGE_INFO& pageInfo = aBoard->GetPageSettings();
1036 const PAGE_INFO* sheet_info;
1037 double paperscale; // Page-to-paper ratio
1038 VECTOR2I paperSizeIU;
1039 VECTOR2I pageSizeIU( pageInfo.GetSizeIU( pcbIUScale.IU_PER_MILS ) );
1040 bool autocenter = false;
1041
1042 // Special options: to fit the sheet to an A4 sheet replace the paper size. However there
1043 // is a difference between the autoscale and the a4paper option:
1044 // - Autoscale fits the board to the paper size
1045 // - A4paper fits the original paper size to an A4 sheet
1046 // - Both of them fit the board to an A4 sheet
1047 if( aPlotOpts->GetA4Output() )
1048 {
1049 sheet_info = &pageA4;
1050 paperSizeIU = pageA4.GetSizeIU( pcbIUScale.IU_PER_MILS );
1051 paperscale = (double) paperSizeIU.x / pageSizeIU.x;
1052 autocenter = true;
1053 }
1054 else
1055 {
1056 sheet_info = &pageInfo;
1057 paperSizeIU = pageSizeIU;
1058 paperscale = 1;
1059
1060 // Need autocentering only if scale is not 1:1
1061 autocenter = (aPlotOpts->GetScale() != 1.0);
1062 }
1063
1064 BOX2I bbox = aBoard->ComputeBoundingBox( false, false );
1065 VECTOR2I boardCenter = bbox.Centre();
1066 VECTOR2I boardSize = bbox.GetSize();
1067
1068 double compound_scale;
1069
1070 // Fit to 80% of the page if asked; it could be that the board is empty, in this case
1071 // regress to 1:1 scale
1072 if( aPlotOpts->GetAutoScale() && boardSize.x > 0 && boardSize.y > 0 )
1073 {
1074 double xscale = (paperSizeIU.x * 0.8) / boardSize.x;
1075 double yscale = (paperSizeIU.y * 0.8) / boardSize.y;
1076
1077 compound_scale = std::min( xscale, yscale ) * paperscale;
1078 }
1079 else
1080 {
1081 compound_scale = aPlotOpts->GetScale() * paperscale;
1082 }
1083
1084 // For the plot offset we have to keep in mind the auxiliary origin too: if autoscaling is
1085 // off we check that plot option (i.e. autoscaling overrides auxiliary origin)
1086 VECTOR2I offset( 0, 0);
1087
1088 if( autocenter )
1089 {
1090 offset.x = KiROUND( boardCenter.x - ( paperSizeIU.x / 2.0 ) / compound_scale );
1091 offset.y = KiROUND( boardCenter.y - ( paperSizeIU.y / 2.0 ) / compound_scale );
1092 }
1093 else
1094 {
1095 if( aPlotOpts->GetUseAuxOrigin() )
1096 offset = aBoard->GetDesignSettings().GetAuxOrigin();
1097 }
1098
1099 aPlotter->SetPageSettings( *sheet_info );
1100
1101 aPlotter->SetViewport( offset, pcbIUScale.IU_PER_MILS/10, compound_scale, aPlotOpts->GetMirror() );
1102
1103 // Has meaning only for gerber plotter. Must be called only after SetViewport
1104 aPlotter->SetGerberCoordinatesFormat( aPlotOpts->GetGerberPrecision() );
1105
1106 // Has meaning only for SVG plotter. Must be called only after SetViewport
1107 aPlotter->SetSvgCoordinatesFormat( aPlotOpts->GetSvgPrecision() );
1108
1109 aPlotter->SetCreator( wxT( "PCBNEW" ) );
1110 aPlotter->SetColorMode( !aPlotOpts->GetBlackAndWhite() ); // default is plot in Black and White.
1111 aPlotter->SetTextMode( aPlotOpts->GetTextMode() );
1112}
1113
1114
1118static void FillNegativeKnockout( PLOTTER *aPlotter, const BOX2I &aBbbox )
1119{
1120 const int margin = 5 * pcbIUScale.IU_PER_MM; // Add a 5 mm margin around the board
1121 aPlotter->SetNegative( true );
1122 aPlotter->SetColor( WHITE ); // Which will be plotted as black
1123
1124 BOX2I area = aBbbox;
1125 area.Inflate( margin );
1126 aPlotter->Rect( area.GetOrigin(), area.GetEnd(), FILL_T::FILLED_SHAPE );
1127 aPlotter->SetColor( BLACK );
1128}
1129
1130
1134static void ConfigureHPGLPenSizes( HPGL_PLOTTER *aPlotter, const PCB_PLOT_PARAMS *aPlotOpts )
1135{
1136 // Compute penDiam (the value is given in mils) in pcb units, with plot scale (if Scale is 2,
1137 // penDiam value is always m_HPGLPenDiam so apparent penDiam is actually penDiam / Scale
1138 int penDiam = KiROUND( aPlotOpts->GetHPGLPenDiameter() * pcbIUScale.IU_PER_MILS / aPlotOpts->GetScale() );
1139
1140 // Set HPGL-specific options and start
1141 aPlotter->SetPenSpeed( aPlotOpts->GetHPGLPenSpeed() );
1142 aPlotter->SetPenNumber( aPlotOpts->GetHPGLPenNum() );
1143 aPlotter->SetPenDiameter( penDiam );
1144}
1145
1146
1153PLOTTER* StartPlotBoard( BOARD *aBoard, const PCB_PLOT_PARAMS *aPlotOpts, int aLayer,
1154 const wxString& aLayerName, const wxString& aFullFileName,
1155 const wxString& aSheetName, const wxString& aSheetPath )
1156{
1157 // Create the plotter driver and set the few plotter specific options
1158 PLOTTER* plotter = nullptr;
1159
1160 switch( aPlotOpts->GetFormat() )
1161 {
1162 case PLOT_FORMAT::DXF:
1163 DXF_PLOTTER* DXF_plotter;
1164 DXF_plotter = new DXF_PLOTTER();
1165 DXF_plotter->SetUnits( aPlotOpts->GetDXFPlotUnits() );
1166
1167 plotter = DXF_plotter;
1168 break;
1169
1170 case PLOT_FORMAT::POST:
1171 PS_PLOTTER* PS_plotter;
1172 PS_plotter = new PS_PLOTTER();
1173 PS_plotter->SetScaleAdjust( aPlotOpts->GetFineScaleAdjustX(),
1174 aPlotOpts->GetFineScaleAdjustY() );
1175 plotter = PS_plotter;
1176 break;
1177
1178 case PLOT_FORMAT::PDF:
1179 plotter = new PDF_PLOTTER();
1180 break;
1181
1182 case PLOT_FORMAT::HPGL:
1183 HPGL_PLOTTER* HPGL_plotter;
1184 HPGL_plotter = new HPGL_PLOTTER();
1185
1186 // HPGL options are a little more convoluted to compute, so they get their own function
1187 ConfigureHPGLPenSizes( HPGL_plotter, aPlotOpts );
1188 plotter = HPGL_plotter;
1189 break;
1190
1192 // For Gerber plotter, a valid board layer must be set, in order to create a valid
1193 // Gerber header, especially the TF.FileFunction and .FilePolarity data
1194 if( aLayer < PCBNEW_LAYER_ID_START || aLayer >= PCB_LAYER_ID_COUNT )
1195 {
1196 wxLogError( wxString::Format(
1197 "Invalid board layer %d, cannot build a valid Gerber file header",
1198 aLayer ) );
1199 }
1200
1201 plotter = new GERBER_PLOTTER();
1202 break;
1203
1204 case PLOT_FORMAT::SVG:
1205 plotter = new SVG_PLOTTER();
1206 break;
1207
1208 default:
1209 wxASSERT( false );
1210 return nullptr;
1211 }
1212
1214 renderSettings->LoadColors( aPlotOpts->ColorSettings() );
1215 renderSettings->SetDefaultPenWidth( pcbIUScale.mmToIU( 0.0212 ) ); // Hairline at 1200dpi
1216 renderSettings->SetLayerName( aLayerName );
1217
1218 plotter->SetRenderSettings( renderSettings );
1219
1220 // Compute the viewport and set the other options
1221
1222 // page layout is not mirrored, so temporarily change mirror option for the page layout
1223 PCB_PLOT_PARAMS plotOpts = *aPlotOpts;
1224
1225 if( plotOpts.GetPlotFrameRef() && plotOpts.GetMirror() )
1226 plotOpts.SetMirror( false );
1227
1228 initializePlotter( plotter, aBoard, &plotOpts );
1229
1230 if( plotter->OpenFile( aFullFileName ) )
1231 {
1232 plotter->ClearHeaderLinesList();
1233
1234 // For the Gerber "file function" attribute, set the layer number
1235 if( plotter->GetPlotterType() == PLOT_FORMAT::GERBER )
1236 {
1237 bool useX2mode = plotOpts.GetUseGerberX2format();
1238
1239 GERBER_PLOTTER* gbrplotter = static_cast <GERBER_PLOTTER*> ( plotter );
1240 gbrplotter->DisableApertMacros( plotOpts.GetDisableGerberMacros() );
1241 gbrplotter->UseX2format( useX2mode );
1242 gbrplotter->UseX2NetAttributes( plotOpts.GetIncludeGerberNetlistInfo() );
1243
1244 // Attributes can be added using X2 format or as comment (X1 format)
1245 AddGerberX2Attribute( plotter, aBoard, aLayer, not useX2mode );
1246 }
1247
1248 if( plotter->StartPlot( wxT( "1" ) ) )
1249 {
1250 // Plot the frame reference if requested
1251 if( aPlotOpts->GetPlotFrameRef() )
1252 {
1253 PlotDrawingSheet( plotter, aBoard->GetProject(), aBoard->GetTitleBlock(),
1254 aBoard->GetPageSettings(), &aBoard->GetProperties(), wxT( "1" ),
1255 1, aSheetName, aSheetPath, aBoard->GetFileName(),
1256 renderSettings->GetLayerColor( LAYER_DRAWINGSHEET ) );
1257
1258 if( aPlotOpts->GetMirror() )
1259 initializePlotter( plotter, aBoard, aPlotOpts );
1260 }
1261
1262 // When plotting a negative board: draw a black rectangle (background for plot board
1263 // in white) and switch the current color to WHITE; note the color inversion is actually
1264 // done in the driver (if supported)
1265 if( aPlotOpts->GetNegative() )
1266 {
1267 BOX2I bbox = aBoard->ComputeBoundingBox( false, false );
1268 FillNegativeKnockout( plotter, bbox );
1269 }
1270
1271 return plotter;
1272 }
1273 }
1274
1275 delete plotter->RenderSettings();
1276 delete plotter;
1277 return nullptr;
1278}
int color
Definition: DXF_plotter.cpp:58
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:108
static const ADVANCED_CFG & GetCfg()
Get the singleton instance's config, which is shared by all consumers.
size_t count() const
Definition: base_set.h:107
const VECTOR2I & GetAuxOrigin()
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:79
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:289
bool GetBoardPolygonOutlines(SHAPE_POLY_SET &aOutlines, OUTLINE_ERROR_HANDLER *aErrorHandler=nullptr, bool aAllowUseArcsInPolygons=false, bool aIncludeNPTHAsOutlines=false)
Extract the board outlines and build a closed polygon from lines, arcs and circle items on edge cut l...
Definition: board.cpp:2474
const PAGE_INFO & GetPageSettings() const
Definition: board.h:682
const ZONES & Zones() const
Definition: board.h:334
BOX2I ComputeBoundingBox(bool aBoardEdgesOnly=false, bool aIncludeHiddenText=false) const
Calculate the bounding box containing all board items (or board edge segments).
Definition: board.cpp:1653
void ConvertBrdLayerToPolygonalContours(PCB_LAYER_ID aLayer, SHAPE_POLY_SET &aOutlines) const
Build a set of polygons which are the outlines of copper items (pads, tracks, vias,...
Definition: board.cpp:2897
TITLE_BLOCK & GetTitleBlock()
Definition: board.h:688
const std::map< wxString, wxString > & GetProperties() const
Definition: board.h:361
const FOOTPRINTS & Footprints() const
Definition: board.h:330
const TRACKS & Tracks() const
Definition: board.h:328
const wxString & GetFileName() const
Definition: board.h:326
PROJECT * GetProject() const
Definition: board.h:490
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Definition: board.cpp:875
const DRAWINGS & Drawings() const
Definition: board.h:332
const Vec & GetOrigin() const
Definition: box2.h:200
const SizeVec & GetSize() const
Definition: box2.h:196
size_type GetHeight() const
Definition: box2.h:205
size_type GetWidth() const
Definition: box2.h:204
const Vec GetEnd() const
Definition: box2.h:202
void Move(const Vec &aMoveVector)
Move the rectangle by the aMoveVector.
Definition: box2.h:128
BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Inflates the rectangle horizontally by dx and vertically by dy.
Definition: box2.h:541
Vec Centre() const
Definition: box2.h:87
void PlotDrillMarks()
Draw a drill mark for pads and vias.
void PlotZone(const ZONE *aZone, PCB_LAYER_ID aLayer, const SHAPE_POLY_SET &aPolysList)
void PlotPadNumber(const PAD *aPad, const COLOR4D &aColor)
void PlotBoardGraphicItem(const BOARD_ITEM *item)
Plot items like text and graphics but not tracks and footprints.
void SetLayerSet(LSET aLayerMask)
Definition: pcbplot.h:86
void PlotPad(const PAD *aPad, const COLOR4D &aColor, OUTLINE_MODE aPlotMode)
Plot a pad.
COLOR4D getColor(int aLayer) const
White color is special because it cannot be seen on a white paper in B&W mode.
void PlotFootprintTextItems(const FOOTPRINT *aFootprint)
int getFineWidthAdj() const
Definition: pcbplot.h:77
void PlotFootprintGraphicItems(const FOOTPRINT *aFootprint)
COLOR4D GetColor(int aLayer) const
When creating polygons to create a clearance polygonal area, the polygon must be same or bigger than ...
void SetUnits(DXF_UNITS aUnit)
Set the units to use for plotting the DXF file.
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:94
@ GBR_APERTURE_ATTRIB_VIAPAD
aperture used for vias.
Definition: gbr_metadata.h:102
Metadata which can be added in a gerber file as attribute in X2 format.
Definition: gbr_metadata.h:205
void SetNetName(const wxString &aNetname)
Definition: gbr_metadata.h:229
void SetApertureAttrib(GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB aApertAttribute)
Definition: gbr_metadata.h:209
GBR_NETLIST_METADATA m_NetlistMetadata
An item to handle object attribute.
Definition: gbr_metadata.h:262
void SetNetAttribType(int aNetAttribType)
Definition: gbr_metadata.h:219
@ GBR_NETINFO_NET
print info associated to a net (TO.N attribute)
bool m_NotInNet
true if a pad of a footprint cannot be connected (for instance a mechanical NPTH, ot a not named pad)...
void UseX2format(bool aEnable)
void UseX2NetAttributes(bool aEnable)
void DisableApertMacros(bool aDisable)
Disable Aperture Macro (AM) command, only for broken Gerber Readers.
virtual void SetPenSpeed(int speed)
Definition: plotter_hpgl.h:88
virtual void SetPenNumber(int number)
Definition: plotter_hpgl.h:93
virtual void SetPenDiameter(double diameter)
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
static const COLOR4D BLACK
Definition: color4d.h:402
PCB specific render settings.
Definition: pcb_painter.h:78
void LoadColors(const COLOR_SETTINGS *aSettings) override
void SetDefaultPenWidth(int aWidth)
const COLOR4D & GetLayerColor(int aLayer) const
Return the color used to draw a layer.
void SetLayerName(const wxString &aLayerName)
LSEQ is a sequence (and therefore also a set) of PCB_LAYER_IDs.
Definition: lseq.h:47
LSET is a set of PCB_LAYER_IDs.
Definition: lset.h:35
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:392
LSEQ SeqStackupForPlotting() const
Return the sequence that is typical for a bottom-to-top stack-up.
Definition: lset.cpp:537
static LSET AllCuMask(int aCuLayerCount=MAX_CU_LAYERS)
Return a mask holding the requested number of Cu PCB_LAYER_IDs.
Definition: lset.cpp:732
Handle the data for a net.
Definition: netinfo.h:56
Definition: pad.h:54
Describe the page size and margins of a paper page on which to eventually print or plot.
Definition: page_info.h:59
const VECTOR2D GetSizeIU(double aIUScale) const
Gets the page size in internal units.
Definition: page_info.h:171
bool IsDegenerated(int aThreshold=5) const
Definition: pcb_track.cpp:1627
EDA_ANGLE GetArcAngleStart() const
Definition: pcb_track.cpp:1609
double GetRadius() const
Definition: pcb_track.cpp:1592
EDA_ANGLE GetAngle() const
Definition: pcb_track.cpp:1599
virtual VECTOR2I GetCenter() const override
This defaults to the center of the bounding box if not overridden.
Definition: pcb_track.h:288
bool IsReference() const
Definition: pcb_field.h:70
wxString GetName(bool aUseDefaultName=true) const
Return the field name (not translated).
Definition: pcb_field.cpp:92
bool IsValue() const
Definition: pcb_field.h:71
bool IsFootprint() const
Definition: pcb_field.h:72
Parameters and options when plotting/printing a board.
bool GetNegative() const
PLOT_FORMAT GetFormat() const
bool GetSkipPlotNPTH_Pads() const
void SetDrillMarksType(DRILL_MARKS aVal)
bool GetUseAuxOrigin() const
void SetSkipPlotNPTH_Pads(bool aSkip)
bool GetMirror() const
DXF_UNITS GetDXFPlotUnits() const
bool GetAutoScale() const
bool GetPlotInvisibleText() const
PLOT_TEXT_MODE GetTextMode() const
void SetDXFPlotPolygonMode(bool aFlag)
double GetHPGLPenDiameter() const
unsigned GetSvgPrecision() const
unsigned GetBlackAndWhite() const
double GetScale() const
bool GetPlotReference() const
bool m_PDFFrontFPPropertyPopups
Generate PDF property popup menus for footprints.
void SetMirror(bool aFlag)
bool GetSketchPadsOnFabLayers() const
bool GetSubtractMaskFromSilk() const
int GetGerberPrecision() const
int GetHPGLPenSpeed() const
double GetFineScaleAdjustY() const
bool GetPlotPadNumbers() const
bool GetA4Output() const
int GetHPGLPenNum() const
DRILL_MARKS GetDrillMarksType() const
bool GetUseGerberX2format() const
bool GetPlotValue() const
bool GetIncludeGerberNetlistInfo() const
double GetFineScaleAdjustX() const
bool m_PDFBackFPPropertyPopups
on front and/or back of board
bool GetPlotFPText() const
bool GetPlotFrameRef() const
bool GetDisableGerberMacros() const
OUTLINE_MODE GetPlotMode() const
COLOR_SETTINGS * ColorSettings() const
Base plotter engine class.
Definition: plotter.h:105
virtual void ThickSegment(const VECTOR2I &start, const VECTOR2I &end, int width, OUTLINE_MODE tracemode, void *aData)
Definition: plotter.cpp:553
virtual void Circle(const VECTOR2I &pos, int diametre, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)=0
virtual bool OpenFile(const wxString &aFullFilename)
Open or create the plot file aFullFilename.
Definition: plotter.cpp:74
virtual void SetNegative(bool aNegative)
Definition: plotter.h:125
virtual void SetSvgCoordinatesFormat(unsigned aPrecision)
Set the number of digits for mantissa in coordinates in mm for SVG plotter.
Definition: plotter.h:525
virtual void SetPageSettings(const PAGE_INFO &aPageSettings)
Definition: plotter.h:138
void SetRenderSettings(RENDER_SETTINGS *aSettings)
Definition: plotter.h:135
virtual bool StartPlot(const wxString &aPageNumber)=0
RENDER_SETTINGS * RenderSettings()
Definition: plotter.h:136
virtual void SetGerberCoordinatesFormat(int aResolution, bool aUseInches=false)
Definition: plotter.h:519
virtual void Bookmark(const BOX2I &aBox, const wxString &aName, const wxString &aGroupName=wxEmptyString)
Create a bookmark to a symbol.
Definition: plotter.h:476
virtual PLOT_FORMAT GetPlotterType() const =0
Returns the effective plot engine in use.
virtual void SetTextMode(PLOT_TEXT_MODE mode)
Change the current text mode.
Definition: plotter.h:514
virtual void SetCreator(const wxString &aCreator)
Definition: plotter.h:154
VECTOR2I GetPlotOffsetUserUnits()
Definition: plotter.h:552
void ClearHeaderLinesList()
Remove all lines from the list of free lines to print at the beginning of the file.
Definition: plotter.h:172
virtual void FlashPadCircle(const VECTOR2I &aPadPos, int aDiameter, OUTLINE_MODE aTraceMode, void *aData)=0
virtual void ThickArc(const EDA_SHAPE &aArcShape, OUTLINE_MODE aTraceMode, void *aData)
Definition: plotter.cpp:596
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:132
virtual void StartBlock(void *aData)
calling this function allows one to define the beginning of a group of drawing items,...
Definition: plotter.h:537
virtual void PlotPoly(const std::vector< VECTOR2I > &aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void *aData=nullptr)=0
Draw a polygon ( filled or not ).
virtual void HyperlinkMenu(const BOX2I &aBox, const std::vector< wxString > &aDestURLs)
Create a clickable hyperlink menu with a rectangular click area.
Definition: plotter.h:465
virtual void SetLayerPolarity(bool aPositive)
Set the current Gerber layer polarity to positive or negative by writing %LPD*% or %LPC*% to the Gerb...
Definition: plotter.h:505
virtual void Rect(const VECTOR2I &p1, const VECTOR2I &p2, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)=0
virtual void SetColor(const COLOR4D &color)=0
virtual void EndBlock(void *aData)
calling this function allows one to define the end of a group of drawing items for instance in SVG or...
Definition: plotter.h:546
void SetScaleAdjust(double scaleX, double scaleY)
Set the 'fine' scaling for the postscript engine.
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
Represent a set of closed polygons.
void RemoveAllContours()
Remove all outlines & holes (clears) the polygon set.
void InflateWithLinkedHoles(int aFactor, CORNER_STRATEGY aCornerStrategy, int aMaxError, POLYGON_MODE aFastMode)
Perform outline inflation/deflation, using round corners.
void Fracture(POLYGON_MODE aFastMode)
Convert a set of polygons with holes to a single outline with "slits"/"fractures" connecting the oute...
int AddOutline(const SHAPE_LINE_CHAIN &aOutline)
Adds a new outline to the set and returns its index.
void DeletePolygon(int aIdx)
Delete aIdx-th polygon from the set.
bool IsEmpty() const
Return true if the set is empty (no polygons at all)
void BooleanAdd(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Perform boolean polyset union For aFastMode meaning, see function booleanOp.
int HoleCount(int aOutline) const
Returns the number of holes in a given outline.
int Append(int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
Appends a vertex at the end of the given outline/hole (default: the last outline)
void Simplify(POLYGON_MODE aFastMode)
Simplify the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) For aFastMo...
int NewOutline()
Creates a new empty polygon in the set and returns its index.
void Deflate(int aAmount, CORNER_STRATEGY aCornerStrategy, int aMaxError)
const SHAPE_LINE_CHAIN & CHole(int aOutline, int aHole) const
int OutlineCount() const
Return the number of outlines in the set.
SHAPE_POLY_SET CloneDropTriangulation() const
const POLYGON & CPolygon(int aIndex) const
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
Handle a list of polygons defining a copper zone.
Definition: zone.h:73
void SetMinThickness(int aMinThickness)
Definition: zone.h:271
virtual void SetLayer(PCB_LAYER_ID aLayer) override
Set the layer this item is on.
Definition: zone.cpp:263
@ WHITE
Definition: color4d.h:48
@ LIGHTGRAY
Definition: color4d.h:47
@ BLACK
Definition: color4d.h:44
void PlotDrawingSheet(PLOTTER *plotter, const PROJECT *aProject, const TITLE_BLOCK &aTitleBlock, const PAGE_INFO &aPageInfo, const std::map< wxString, wxString > *aProperties, const wxString &aSheetNumber, int aSheetCount, const wxString &aSheetName, const wxString &aSheetPath, const wxString &aFilename, COLOR4D aColor, bool aIsFirstPage)
@ CHAMFER_ALL_CORNERS
All angles are chamfered.
@ ROUND_ALL_CORNERS
All angles are rounded.
#define _(s)
static constexpr EDA_ANGLE ANGLE_0
Definition: eda_angle.h:401
@ FILLED_SHAPE
Handle special data (items attributes) during plot.
a few functions useful in geometry calculations.
@ ERROR_OUTSIDE
@ ERROR_INSIDE
double m_SmallDrillMarkSize
The diameter of the drill marks on print and plot outputs (in mm) when the "Drill marks" option is se...
bool IsCopperLayer(int aLayerId)
Tests whether a layer is a copper layer.
Definition: layer_ids.h:531
@ LAYER_DRAWINGSHEET
drawingsheet frame and titleblock
Definition: layer_ids.h:221
@ LAYER_VIAS
Meta control for all vias opacity/visibility.
Definition: layer_ids.h:197
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:60
@ F_CrtYd
Definition: layer_ids.h:117
@ B_Adhes
Definition: layer_ids.h:97
@ Edge_Cuts
Definition: layer_ids.h:113
@ Dwgs_User
Definition: layer_ids.h:109
@ F_Paste
Definition: layer_ids.h:101
@ Cmts_User
Definition: layer_ids.h:110
@ F_Adhes
Definition: layer_ids.h:98
@ B_Mask
Definition: layer_ids.h:106
@ B_Cu
Definition: layer_ids.h:95
@ Eco1_User
Definition: layer_ids.h:111
@ F_Mask
Definition: layer_ids.h:107
@ B_Paste
Definition: layer_ids.h:100
@ F_Fab
Definition: layer_ids.h:120
@ Margin
Definition: layer_ids.h:114
@ F_SilkS
Definition: layer_ids.h:104
@ B_CrtYd
Definition: layer_ids.h:116
@ UNDEFINED_LAYER
Definition: layer_ids.h:61
@ Eco2_User
Definition: layer_ids.h:112
@ B_SilkS
Definition: layer_ids.h:103
@ PCB_LAYER_ID_COUNT
Definition: layer_ids.h:137
@ F_Cu
Definition: layer_ids.h:64
@ B_Fab
Definition: layer_ids.h:119
OUTLINE_MODE
Definition: outline_mode.h:25
@ SKETCH
Definition: outline_mode.h:26
@ NPTH
like PAD_PTH, but not plated mechanical use only, no connection allowed
PAD_SHAPE
The set of pad shapes, used with PAD::{Set,Get}Shape()
Definition: padstack.h:46
void AddGerberX2Attribute(PLOTTER *aPlotter, const BOARD *aBoard, int aLayer, bool aUseX1CompatibilityMode)
Calculate some X2 attributes as defined in the Gerber file format specification and add them to the g...
Definition: pcbplot.cpp:354
static void FillNegativeKnockout(PLOTTER *aPlotter, const BOX2I &aBbbox)
Prefill in black an area a little bigger than the board to prepare for the negative plot.
void PlotBoardLayers(BOARD *aBoard, PLOTTER *aPlotter, const LSEQ &aLayers, const PCB_PLOT_PARAMS &aPlotOptions)
Plot a sequence of board layer IDs.
void PlotStandardLayer(BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt)
Plot any layer EXCEPT a solder-mask with an enforced minimum width.
static void PlotSolderMaskLayer(BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt, int aMinThickness)
Plot a solder mask layer.
void PlotOneBoardLayer(BOARD *aBoard, PLOTTER *aPlotter, PCB_LAYER_ID aLayer, const PCB_PLOT_PARAMS &aPlotOpt)
Plot one copper or technical layer.
void PlotLayerOutlines(BOARD *aBoard, PLOTTER *aPlotter, LSET aLayerMask, const PCB_PLOT_PARAMS &aPlotOpt)
Plot outlines.
static void ConfigureHPGLPenSizes(HPGL_PLOTTER *aPlotter, const PCB_PLOT_PARAMS *aPlotOpts)
Calculate the effective size of HPGL pens and set them in the plotter object.
static void initializePlotter(PLOTTER *aPlotter, const BOARD *aBoard, const PCB_PLOT_PARAMS *aPlotOpts)
Set up most plot options for plotting a board (especially the viewport) Important thing: page size is...
void PlotInteractiveLayer(BOARD *aBoard, PLOTTER *aPlotter, const PCB_PLOT_PARAMS &aPlotOpt)
Plot interactive items (hypertext links, properties, etc.).
PLOTTER * StartPlotBoard(BOARD *aBoard, const PCB_PLOT_PARAMS *aPlotOpts, int aLayer, const wxString &aLayerName, const wxString &aFullFileName, const wxString &aSheetName, const wxString &aSheetPath)
Open a new plotfile using the options (and especially the format) specified in the options and prepar...
Plotting engine (HPGL)
Plotting engines similar to ps (PostScript, Gerber, svg)
std::vector< FAB_LAYER_COLOR > dummy
const double IU_PER_MM
Definition: base_units.h:76
const double IU_PER_MILS
Definition: base_units.h:77
constexpr int mmToIU(double mm) const
Definition: base_units.h:88
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:97
@ PCB_TEXT_T
class PCB_TEXT, text on a layer
Definition: typeinfo.h:92
@ PCB_ARC_T
class PCB_ARC, an arc track segment on a copper layer
Definition: typeinfo.h:98
constexpr ret_type KiROUND(fp_type v, bool aQuiet=false)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: util.h:100
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:676