KiCad PCB EDA Suite
HPGL_plotter.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) 2017 Jean-Pierre Charras, jp.charras at wanadoo.fr
5  * Copyright (C) 2017 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 
33 /* Some HPGL commands:
34  * Note: the HPGL unit is 25 micrometers
35  * All commands MUST be terminated by a semi-colon or a linefeed.
36  * Spaces can NOT be substituted for required commas in the syntax of a command.
37  *
38  *
39  * AA (Arc Absolute): Angle is a floating point # (requires non integer value)
40  * Draws an arc with the center at (X,Y).
41  * A positive angle creates a counter-clockwise arc.
42  * If the chord angle is specified,
43  * this will be the number of degrees used for stepping around the arc.
44  * If no value is given then a default value of five degrees is used.
45  * AA x, y, a {,b};
46  *
47  * AR (Arc Relative):
48  * AR Dx, Dy, a {, b};
49  *
50  * CA (Alternate Character Set):
51  * CA {n};
52  *
53  * CI (Circle):
54  * CI r {,b};
55  *
56  * CP (Character Plot):
57  * CP {h, v};
58  * h [-127.9999 .. 127.9999] Anzahl der Zeichen horizontal
59  * v [-127.9999 .. 127.9999] Anzahl der Zeichen vertikal
60  *
61  * CS (Standard Character Set):
62  * CS {n};
63  *
64  * DR (Relative Direction for Label Text):
65  * DR s, a;
66  *
67  * DI (Absolute Direction for Label Text):
68  * DI {s, a};
69  *
70  * DT (Define Terminator - this character becomes unavailable except to terminate a label string.
71  * Default is ^C control-C):
72  * DT t;
73  *
74  * EA (rEctangle Absolute - Unfilled, from current position to diagonal x,y):
75  * EA x, y;
76  *
77  * ER (rEctangle Relative - Unfilled, from current position to diagonal x,y):
78  * ER x,y;
79  *
80  * FT (Fill Type):
81  * FT {s {,l {a}}};
82  *
83  * IM (Input Mask):
84  * IM {f};
85  *
86  * IN (Initialize): This command instructs the controller to begin processing the HPGL plot file.
87  * Without this, the commands in the file are received but never executed.
88  * If multiple IN s are found during execution of the file,
89  * the controller performs a Pause/Cancel operation.
90  * All motion from the previous job, yet to be executed, is lost,
91  * and the new information is executed.
92  * IN;
93  *
94  * IP Input P1 and P2:
95  * IP {P1x, P1y {, P2x, P2y}};
96  *
97  * IW (Input Window):
98  * IW {XUL, YUL, XOR, YOR};
99  *
100  * LB (Label):
101  * LB c1 .. cn t;
102  *
103  * PA (Plot Absolute): Moves to an absolute HPGL position and sets absolute mode for
104  * future PU and PD commands. If no arguments follow the command,
105  * only absolute mode is set.
106  * PA {x1, y1 {{PU|PD|,} ..., ..., xn, yn}};
107  * P1x, P1y, P2x, P2y [Integer in ASCII]
108  *
109  * PD (Pen Down): Executes <current pen> pen then moves to the requested position
110  * if one is specified. This position is dependent on whether absolute
111  * or relative mode is set. This command performs no motion in 3-D mode,
112  * but the outputs and feedrates are affected.
113  * PD {x, y};
114  *
115  * PM Polygon mode
116  * associated commands:
117  * PM2 End polygon mode
118  * FP Fill polygon
119  * EP Draw polygon outline
120  *
121  * PR (Plot Relative): Moves to the relative position specified and sets relative mode
122  * for future PU and PD commands.
123  * If no arguments follow the command, only relative mode is set.
124  * PR {Dx1, Dy1 {{PU|PD|,} ..., ..., Dxn, Dyn}};
125  *
126  * PS (Paper Size):
127  * PS {n};
128  *
129  * PT (Pen Thickness): in mm
130  * PT {l};
131  *
132  * PU (Pen Up): Executes <current pen> pen then moves to the requested position
133  * if one is specified. This position is dependent on whether absolute
134  * or relative mode is set.
135  * This command performs no motion in 3-D mode, but the outputs
136  * and feedrates are affected.
137  * PU {x, y};
138  *
139  * RA (Rectangle Absolute - Filled, from current position to diagonal x,y):
140  * RA x, y;
141  *
142  * RO (Rotate Coordinate System):
143  * RO;
144  *
145  * RR (Rectangle Relative - Filled, from current position to diagonal x,y):
146  * RR x, y;
147  *
148  * SA (Select Alternate Set):
149  * SA;
150  *
151  * SC (Scale):
152  * SC {Xmin, Xmax, Ymin, Ymax};
153  *
154  * SI (Absolute Character Size):
155  * SI b, h;
156  * b [-127.9999 .. 127.9999, keine 0]
157  * h [-127.9999 .. 127.9999, keine 0]
158  *
159  * SL (Character Slant):
160  * SL {a};
161  * a [-3.5 .. -0.5, 0.5 .. 3.5]
162 *
163  * SP (Select Pen): Selects a new pen or tool for use.
164  * If no pen number or a value of zero is given,
165  * the controller performs an EOF (end of file command).
166  * Once an EOF is performed, no motion is executed,
167  * until a new IN command is received.
168  * SP n;
169  *
170  * SR (Relative Character Size):
171  * SR {b, h};
172  * b [-127.9999 .. 127.9999, keine 0]
173  * h [-127.9999 .. 127.9999, keine 0]
174  *
175  * SS (Select Standard Set):
176  * SS;
177  *
178  * TL (Tick Length):
179  * TL {tp {, tm}};
180  *
181  * UC (User Defined Character):
182  * UC {i,} x1, y1, {i,} x2, y2, ... {i,} xn, yn;
183  *
184  * VS (Velocity Select):
185  * VS {v {, n}};
186  * v [1 .. 40] in cm/s
187  * n [1 .. 8]
188  *
189  * XT (X Tick):
190  * XT;
191  *
192  * YT (Y Tick):
193  * YT;
194  */
195 
196 
197 #include <fctsys.h>
198 #include <gr_basic.h>
199 #include <trigo.h>
200 #include <eda_base_frame.h>
201 #include <base_struct.h>
202 #include <plotter.h>
203 #include <macros.h>
204 #include <kicad_string.h>
206 
207 // The hpgl command to close a polygon def, fill it and plot outline:
208 // PM 2; ends the polygon definition and closes it if not closed
209 // FP; fills the polygon
210 // EP; draws the polygon outline. It usually gives a better look to the filled polygon
211 static const char hpgl_end_polygon_cmd[] = "PM 2; FP; EP;\n";
212 
213 // HPGL scale factor (1 Plotter Logical Unit = 1/40mm = 25 micrometers)
214 // PLUsPERDECIMIL = (25.4 / 10000) / 0.025
215 static const double PLUsPERDECIMIL = 0.1016;
216 
218 {
219  SetPenSpeed( 40 ); // Default pen speed = 40 cm/s; Pen speed is *always* in cm
220  SetPenNumber( 1 ); // Default pen num = 1
221  SetPenDiameter( 0.0 );
222 }
223 
224 void HPGL_PLOTTER::SetViewport( const wxPoint& aOffset, double aIusPerDecimil,
225  double aScale, bool aMirror )
226 {
227  plotOffset = aOffset;
228  plotScale = aScale;
229  m_IUsPerDecimil = aIusPerDecimil;
230  iuPerDeviceUnit = PLUsPERDECIMIL / aIusPerDecimil;
231  /* Compute the paper size in IUs */
233  paperSize.x *= 10.0 * aIusPerDecimil;
234  paperSize.y *= 10.0 * aIusPerDecimil;
235  SetDefaultLineWidth( 0 ); // HPGL has pen sizes instead
236  m_plotMirror = aMirror;
237 }
238 
239 
244 {
245  wxASSERT( outputFile );
246  fprintf( outputFile, "IN;VS%d;PU;PA;SP%d;\n", penSpeed, penNumber );
247 
248  // Set HPGL Pen Thickness (in mm) (usefull in polygon fill command)
249  double penThicknessMM = userToDeviceSize( penDiameter )/40;
250  fprintf( outputFile, "PT %.1f;\n", penThicknessMM );
251 
252  return true;
253 }
254 
255 
260 {
261  wxASSERT( outputFile );
262  fputs( "PU;PA;SP0;\n", outputFile );
263  fclose( outputFile );
264  outputFile = NULL;
265  return true;
266 }
267 
268 
269 void HPGL_PLOTTER::SetPenDiameter( double diameter )
270 {
271  penDiameter = diameter;
272 }
273 
277 void HPGL_PLOTTER::Rect( const wxPoint& p1, const wxPoint& p2, FILL_T fill, int width )
278 {
279  wxASSERT( outputFile );
280  DPOINT p2dev = userToDeviceCoordinates( p2 );
281  MoveTo( p1 );
282  fprintf( outputFile, "EA %.0f,%.0f;\n", p2dev.x, p2dev.y );
283  PenFinish();
284 }
285 
286 
287 // HPGL circle
288 void HPGL_PLOTTER::Circle( const wxPoint& centre, int diameter, FILL_T fill,
289  int width )
290 {
291  wxASSERT( outputFile );
292  double radius = userToDeviceSize( diameter / 2 );
293  SetCurrentLineWidth( width );
294 
295  if( fill == FILLED_SHAPE )
296  {
297  // Draw the filled area
298  MoveTo( centre );
299  fprintf( outputFile, "PM 0; CI %g;\n", radius );
300  fprintf( outputFile, hpgl_end_polygon_cmd ); // Close, fill polygon and draw outlines
301  PenFinish();
302  }
303 
304  if( radius > 0 )
305  {
306  MoveTo( centre );
307  fprintf( outputFile, "CI %g;\n", radius );
308  PenFinish();
309  }
310 }
311 
312 
317 void HPGL_PLOTTER::PlotPoly( const std::vector<wxPoint>& aCornerList,
318  FILL_T aFill, int aWidth, void * aData )
319 {
320  if( aCornerList.size() <= 1 )
321  return;
322 
323  SetCurrentLineWidth( aWidth );
324  MoveTo( aCornerList[0] );
325 
326  if( aFill == FILLED_SHAPE )
327  {
328  // Draw the filled area
330  fprintf( outputFile, "PM 0;\n" ); // Start polygon
331 
332  for( unsigned ii = 1; ii < aCornerList.size(); ++ii )
333  LineTo( aCornerList[ii] );
334 
335  int ii = aCornerList.size() - 1;
336 
337  if( aCornerList[ii] != aCornerList[0] )
338  LineTo( aCornerList[0] );
339 
340  fprintf( outputFile, hpgl_end_polygon_cmd ); // Close, fill polygon and draw outlines
341  }
342  else
343  {
344  // Plot only the polygon outline.
345  for( unsigned ii = 1; ii < aCornerList.size(); ii++ )
346  LineTo( aCornerList[ii] );
347 
348  // Always close polygon if filled.
349  if( aFill )
350  {
351  int ii = aCornerList.size() - 1;
352 
353  if( aCornerList[ii] != aCornerList[0] )
354  LineTo( aCornerList[0] );
355  }
356  }
357 
358  PenFinish();
359 }
360 
361 
365 void HPGL_PLOTTER::penControl( char plume )
366 {
367  wxASSERT( outputFile );
368 
369  switch( plume )
370  {
371  case 'U':
372 
373  if( penState != 'U' )
374  {
375  fputs( "PU;", outputFile );
376  penState = 'U';
377  }
378 
379  break;
380 
381  case 'D':
382 
383  if( penState != 'D' )
384  {
385  fputs( "PD;", outputFile );
386  penState = 'D';
387  }
388 
389  break;
390 
391  case 'Z':
392  fputs( "PU;", outputFile );
393  penState = 'U';
394  penLastpos.x = -1;
395  penLastpos.y = -1;
396  break;
397  }
398 }
399 
400 
401 void HPGL_PLOTTER::PenTo( const wxPoint& pos, char plume )
402 {
403  wxASSERT( outputFile );
404 
405  if( plume == 'Z' )
406  {
407  penControl( 'Z' );
408  return;
409  }
410 
411  penControl( plume );
412  DPOINT pos_dev = userToDeviceCoordinates( pos );
413 
414  if( penLastpos != pos )
415  fprintf( outputFile, "PA %.0f,%.0f;\n", pos_dev.x, pos_dev.y );
416 
417  penLastpos = pos;
418 }
419 
420 
424 void HPGL_PLOTTER::SetDash( int dashed )
425 {
426  wxASSERT( outputFile );
427 
428  switch( dashed )
429  {
430  case PLOTDASHTYPE_DASH:
431  fprintf( outputFile, "LT -2 4 1;\n" );
432  break;
433  case PLOTDASHTYPE_DOT:
434  fprintf( outputFile, "LT -1 2 1;\n" );
435  break;
437  fprintf( outputFile, "LT -4 6 1;\n" );
438  break;
439  default:
440  fputs( "LT;\n", outputFile );
441  }
442 }
443 
444 
445 void HPGL_PLOTTER::ThickSegment( const wxPoint& start, const wxPoint& end,
446  int width, EDA_DRAW_MODE_T tracemode, void* aData )
447 {
448  wxASSERT( outputFile );
449  wxPoint center;
450  wxSize size;
451 
452  // Suppress overlap if pen is too big
453  if( penDiameter >= width )
454  {
455  MoveTo( start );
456  FinishTo( end );
457  }
458  else
459  segmentAsOval( start, end, width, tracemode );
460 }
461 
462 
463 /* Plot an arc:
464  * Center = center coord
465  * Stangl, endAngle = angle of beginning and end
466  * Radius = radius of the arc
467  * Command
468  * PU PY x, y; PD start_arc_X AA, start_arc_Y, angle, NbSegm; PU;
469  * Or PU PY x, y; PD start_arc_X AA, start_arc_Y, angle, PU;
470  */
471 void HPGL_PLOTTER::Arc( const wxPoint& centre, double StAngle, double EndAngle, int radius,
472  FILL_T fill, int width )
473 {
474  wxASSERT( outputFile );
475  double angle;
476 
477  if( radius <= 0 )
478  return;
479 
480  DPOINT centre_dev = userToDeviceCoordinates( centre );
481 
482  if( m_plotMirror )
483  angle = StAngle - EndAngle;
484  else
485  angle = EndAngle - StAngle;
486 
488  angle /= 10;
489 
490  // Calculate arc start point:
491  wxPoint cmap;
492  cmap.x = centre.x + KiROUND( cosdecideg( radius, StAngle ) );
493  cmap.y = centre.y - KiROUND( sindecideg( radius, StAngle ) );
494  DPOINT cmap_dev = userToDeviceCoordinates( cmap );
495 
496  fprintf( outputFile,
497  "PU;PA %.0f,%.0f;PD;AA %.0f,%.0f,",
498  cmap_dev.x, cmap_dev.y,
499  centre_dev.x, centre_dev.y );
500  fprintf( outputFile, "%.0f", angle );
501  fprintf( outputFile, ";PU;\n" );
502  PenFinish();
503 }
504 
505 
506 /* Plot oval pad.
507  */
508 void HPGL_PLOTTER::FlashPadOval( const wxPoint& pos, const wxSize& aSize, double orient,
509  EDA_DRAW_MODE_T trace_mode, void* aData )
510 {
511  wxASSERT( outputFile );
512  int deltaxy, cx, cy;
513  wxSize size( aSize );
514 
515  /* The pad will be drawn as an oblong shape with size.y > size.x
516  * (Oval vertical orientation 0)
517  */
518  if( size.x > size.y )
519  {
520  std::swap( size.x, size.y );
521  orient = AddAngles( orient, 900 );
522  }
523 
524  deltaxy = size.y - size.x; // distance between centers of the oval
525 
526  if( trace_mode == FILLED )
527  {
528  FlashPadRect( pos, wxSize( size.x, deltaxy + KiROUND( penDiameter ) ),
529  orient, trace_mode, aData );
530  cx = 0; cy = deltaxy / 2;
531  RotatePoint( &cx, &cy, orient );
532  FlashPadCircle( wxPoint( cx + pos.x, cy + pos.y ), size.x, trace_mode, aData );
533  cx = 0; cy = -deltaxy / 2;
534  RotatePoint( &cx, &cy, orient );
535  FlashPadCircle( wxPoint( cx + pos.x, cy + pos.y ), size.x, trace_mode, aData );
536  }
537  else // Plot in outline mode.
538  {
539  sketchOval( pos, size, orient, KiROUND( penDiameter ) );
540  }
541 }
542 
543 
544 /* Plot round pad or via.
545  */
546 void HPGL_PLOTTER::FlashPadCircle( const wxPoint& pos, int diametre,
547  EDA_DRAW_MODE_T trace_mode, void* aData )
548 {
549  wxASSERT( outputFile );
550  DPOINT pos_dev = userToDeviceCoordinates( pos );
551 
552  int radius = diametre / 2;
553 
554  if( trace_mode == FILLED )
555  {
556  // if filled mode, the pen diameter is removed from diameter
557  // to keep the pad size
558  radius -= KiROUND( penDiameter ) / 2;
559  }
560 
561  if( radius < 0 )
562  radius = 0;
563 
564  double rsize = userToDeviceSize( radius );
565 
566  if( trace_mode == FILLED ) // Plot in filled mode.
567  {
568  // A filled polygon uses always the current point to start the polygon.
569  // Gives a correct current starting point for the circle
570  MoveTo( wxPoint( pos.x+radius, pos.y ) );
571  // Plot filled area and its outline
572  fprintf( outputFile, "PM 0; PA %.0f,%.0f;CI %.0f;%s",
573  pos_dev.x, pos_dev.y, rsize, hpgl_end_polygon_cmd );
574  }
575  else
576  {
577  // Draw outline only:
578  fprintf( outputFile, "PA %.0f,%.0f;CI %.0f;\n",
579  pos_dev.x, pos_dev.y, rsize );
580  }
581 
582  PenFinish();
583 }
584 
585 
586 void HPGL_PLOTTER::FlashPadRect( const wxPoint& pos, const wxSize& padsize,
587  double orient, EDA_DRAW_MODE_T trace_mode, void* aData )
588 {
589  // Build rect polygon:
590  std::vector<wxPoint> corners;
591 
592  int dx = padsize.x / 2;
593  int dy = padsize.y / 2;
594 
595  if( trace_mode == FILLED )
596  {
597  // in filled mode, the pen diameter is removed from size
598  // to compensate the extra size due to this pen size
599  dx -= KiROUND( penDiameter ) / 2;
600  dx = std::max( dx, 0);
601  dy -= KiROUND( penDiameter ) / 2;
602  dy = std::max( dy, 0);
603  }
604 
605 
606  corners.push_back( wxPoint( - dx, - dy ) );
607  corners.push_back( wxPoint( - dx, + dy ) );
608  corners.push_back( wxPoint( + dx, + dy ) );
609  corners.push_back( wxPoint( + dx, - dy ) );
610  // Close polygon
611  corners.push_back( wxPoint( - dx, - dy ) );
612 
613  for( unsigned ii = 0; ii < corners.size(); ii++ )
614  {
615  RotatePoint( &corners[ii], orient );
616  corners[ii] += pos;
617  }
618 
619  PlotPoly( corners, trace_mode == FILLED ? FILLED_SHAPE : NO_FILL );
620 }
621 
622 
623 void HPGL_PLOTTER::FlashPadRoundRect( const wxPoint& aPadPos, const wxSize& aSize,
624  int aCornerRadius, double aOrient,
625  EDA_DRAW_MODE_T aTraceMode, void* aData )
626 {
627  SHAPE_POLY_SET outline;
628  const int segmentToCircleCount = 32;
629 
630  wxSize size = aSize;
631 
632  if( aTraceMode == FILLED )
633  {
634  // in filled mode, the pen diameter is removed from size
635  // to keep the pad size
636  size.x -= KiROUND( penDiameter ) / 2;
637  size.x = std::max( size.x, 0);
638  size.y -= KiROUND( penDiameter ) / 2;
639  size.y = std::max( size.y, 0);
640 
641  // keep aCornerRadius to a value < min size x,y < 2:
642  aCornerRadius = std::min( aCornerRadius, std::min( size.x, size.y ) /2 );
643  }
644 
645  TransformRoundChamferedRectToPolygon( outline, aPadPos, size, aOrient,
646  aCornerRadius, 0.0, 0, segmentToCircleCount );
647 
648  // TransformRoundRectToPolygon creates only one convex polygon
649  std::vector< wxPoint > cornerList;
650  cornerList.reserve( segmentToCircleCount + 5 );
651  SHAPE_LINE_CHAIN& poly = outline.Outline( 0 );
652 
653  for( int ii = 0; ii < poly.PointCount(); ++ii )
654  cornerList.push_back( wxPoint( poly.Point( ii ).x, poly.Point( ii ).y ) );
655 
656  if( cornerList.back() != cornerList.front() )
657  cornerList.push_back( cornerList.front() );
658 
659  PlotPoly( cornerList, aTraceMode == FILLED ? FILLED_SHAPE : NO_FILL );
660 }
661 
662 void HPGL_PLOTTER::FlashPadCustom( const wxPoint& aPadPos, const wxSize& aSize,
663  SHAPE_POLY_SET* aPolygons,
664  EDA_DRAW_MODE_T aTraceMode, void* aData )
665 {
666  std::vector< wxPoint > cornerList;
667 
668  for( int cnt = 0; cnt < aPolygons->OutlineCount(); ++cnt )
669  {
670  SHAPE_LINE_CHAIN& poly = aPolygons->Outline( cnt );
671 
672  cornerList.clear();
673  cornerList.reserve( poly.PointCount() );
674 
675  for( int ii = 1; ii < poly.PointCount(); ++ii )
676  cornerList.push_back( wxPoint( poly.Point( ii ).x, poly.Point( ii ).y ) );
677 
678  if( cornerList.back() != cornerList.front() )
679  cornerList.push_back( cornerList.front() );
680 
681  PlotPoly( cornerList, aTraceMode == FILLED ? FILLED_SHAPE : NO_FILL );
682  }
683 }
684 
685 
686 void HPGL_PLOTTER::FlashPadTrapez( const wxPoint& aPadPos, const wxPoint* aCorners,
687  double aPadOrient, EDA_DRAW_MODE_T aTraceMode, void* aData )
688 {
689  std::vector< wxPoint > cornerList;
690  cornerList.reserve( 5 );
691 
692  for( int ii = 0; ii < 4; ii++ )
693  {
694  wxPoint coord( aCorners[ii] );
695  RotatePoint( &coord, aPadOrient );
696  coord += aPadPos;
697  cornerList.push_back( coord );
698  }
699 
700  // Close polygon
701  cornerList.push_back( cornerList.front() );
702 
703  PlotPoly( cornerList, aTraceMode == FILLED ? FILLED_SHAPE : NO_FILL );
704 }
void FinishTo(const wxPoint &pos)
Definition: plotter.h:251
virtual bool EndPlot() override
HPGL end of plot: pen return and release.
int penSpeed
Definition: plotter.h:652
void PenFinish()
Definition: plotter.h:257
int OutlineCount() const
Returns the number of outlines in the set
virtual void FlashPadCircle(const wxPoint &aPadPos, int aDiameter, EDA_DRAW_MODE_T aTraceMode, void *aData) override
virtual function FlashPadCircle
virtual void PlotPoly(const std::vector< wxPoint > &aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void *aData=NULL) override
HPGL polygon:
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:118
virtual void SetPenDiameter(double diameter)
void TransformRoundChamferedRectToPolygon(SHAPE_POLY_SET &aCornerBuffer, const wxPoint &aPosition, const wxSize &aSize, double aRotation, int aCornerRadius, double aChamferRatio, int aChamferCorners, int aCircleToSegmentsCount)
convert a rectangle with rounded corners and/or chamfered corners to a polygon Convert rounded corner...
virtual void ThickSegment(const wxPoint &start, const wxPoint &end, int width, EDA_DRAW_MODE_T tracemode, void *aData) override
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:216
char penState
Current pen state: 'U', 'D' or 'Z' (see PenTo)
Definition: plotter.h:562
void NORMALIZE_ANGLE_180(T &Angle)
Definition: trigo.h:344
double m_IUsPerDecimil
Definition: plotter.h:539
int PointCount() const
Function PointCount()
virtual bool StartPlot() override
At the start of the HPGL plot pen speed and number are requested.
virtual void SetDefaultLineWidth(int width) override
Set the default line width.
Definition: plotter.h:601
wxPoint plotOffset
Plot offset (in IUs)
Definition: plotter.h:545
wxPoint penLastpos
Last pen positions; set to -1,-1 when the pen is at rest.
Definition: plotter.h:564
PAGE_INFO pageInfo
Definition: plotter.h:568
This file contains miscellaneous commonly used macros and functions.
virtual void SetViewport(const wxPoint &aOffset, double aIusPerDecimil, double aScale, bool aMirror) override
Set the plot offset and scaling for the current plot.
virtual void Rect(const wxPoint &p1, const wxPoint &p2, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH) override
HPGL rectangle: fill not supported.
virtual void FlashPadRoundRect(const wxPoint &aPadPos, const wxSize &aSize, int aCornerRadius, double aOrient, EDA_DRAW_MODE_T aTraceMode, void *aData) override
virtual function FlashPadRoundRect
void LineTo(const wxPoint &pos)
Definition: plotter.h:246
static const int USE_DEFAULT_LINE_WIDTH
Definition: plotter.h:102
bool m_plotMirror
X axis orientation (SVG) and plot mirrored (only for PS, PDF HPGL and SVG)
Definition: plotter.h:549
virtual void SetCurrentLineWidth(int width, void *aData=NULL) override
HPGL doesn't handle line thickness or color.
Definition: plotter.h:595
T AddAngles(T a1, T2 a2)
Add two angles (keeping the result normalized). T2 is here.
Definition: trigo.h:297
Class SHAPE_POLY_SET.
SHAPE_LINE_CHAIN & Outline(int aIndex)
Returns the reference to aIndex-th outline in the set
EDA_DRAW_MODE_T
Definition: eda_text.h:78
virtual void SetPenSpeed(int speed)
Definition: plotter.h:606
static const char hpgl_end_polygon_cmd[]
Base window classes and related definitions.
double plotScale
Plot scale - chosen by the user (even implicitly with 'fit in a4')
Definition: plotter.h:533
virtual void SetDash(int dashed) override
HPGL supports dashed lines.
virtual void FlashPadOval(const wxPoint &aPadPos, const wxSize &aSize, double aPadOrient, EDA_DRAW_MODE_T aTraceMode, void *aData) override
virtual function FlashPadOval
const wxSize & GetSizeMils() const
Definition: page_info.h:142
virtual void PenTo(const wxPoint &pos, char plume) override
moveto/lineto primitive, moves the 'pen' to the specified direction
virtual DPOINT userToDeviceSize(const wxSize &size)
Modifies size according to the plotter scale factors (wxSize version, returns a DPOINT)
Definition: plotter.cpp:121
virtual void FlashPadRect(const wxPoint &aPadPos, const wxSize &aSize, double aOrient, EDA_DRAW_MODE_T aTraceMode, void *aData) override
virtual function FlashPadRect
int penNumber
Definition: plotter.h:653
void MoveTo(const wxPoint &pos)
Definition: plotter.h:241
virtual DPOINT userToDeviceCoordinates(const wxPoint &aCoordinate)
Modifies coordinates according to the orientation, scale factor, and offsets trace.
Definition: plotter.cpp:96
double cosdecideg(double r, double a)
Circle generation utility: computes r * cos(a) Where a is in decidegrees, not in radians.
Definition: trigo.h:363
double sindecideg(double r, double a)
Circle generation utility: computes r * sin(a) Where a is in decidegrees, not in radians.
Definition: trigo.h:354
#define max(a, b)
Definition: auxiliary.h:86
Class SHAPE_LINE_CHAIN.
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
double penDiameter
Definition: plotter.h:654
virtual void SetPenNumber(int number)
Definition: plotter.h:611
FILE * outputFile
true if the Y axis is top to bottom (SVG)
Definition: plotter.h:554
FILL_T
Enum FILL_T is the set of fill types used in plotting or drawing enclosed areas.
Definition: base_struct.h:54
VECTOR2I & Point(int aIndex)
Function Point()
static const double PLUsPERDECIMIL
Basic classes for most KiCad items.
void penControl(char plume)
Pen control logic (remove redundant pen activations)
virtual void FlashPadCustom(const wxPoint &aPadPos, const wxSize &aSize, SHAPE_POLY_SET *aPolygons, EDA_DRAW_MODE_T aTraceMode, void *aData) override
virtual function FlashPadCustom
double iuPerDeviceUnit
Device scale (from IUs to plotter device units - usually decimils)
Definition: plotter.h:542
void segmentAsOval(const wxPoint &start, const wxPoint &end, int width, EDA_DRAW_MODE_T tracemode)
Cdonvert a thick segment and plot it as an oval.
Definition: plotter.cpp:387
virtual void FlashPadTrapez(const wxPoint &aPadPos, const wxPoint *aCorners, double aPadOrient, EDA_DRAW_MODE_T aTraceMode, void *aData) override
virtual function FlashPadTrapez flash a trapezoidal pad
virtual void Circle(const wxPoint &pos, int diametre, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH) override
void sketchOval(const wxPoint &pos, const wxSize &size, double orient, int width)
Definition: plotter.cpp:408
wxSize paperSize
Paper size in IU - not in mils.
Definition: plotter.h:570
#define min(a, b)
Definition: auxiliary.h:85
virtual void Arc(const wxPoint &centre, double StAngle, double EndAngle, int rayon, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH) override
Generic fallback: arc rendered as a polyline.