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 
487  NORMALIZE_ANGLE_180( angle );
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  TransformRoundRectToPolygon( outline, aPadPos, size, aOrient,
646  aCornerRadius, 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
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:120
int PointCount() const
Function PointCount()
void TransformRoundRectToPolygon(SHAPE_POLY_SET &aCornerBuffer, const wxPoint &aPosition, const wxSize &aSize, double aRotation, int aCornerRadius, int aCircleToSegmentsCount)
Function TransformRoundRectToPolygon convert a rectangle with rounded corners to a polygon Convert ar...
virtual void SetPenDiameter(double diameter)
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: &#39;U&#39;, &#39;D&#39; or &#39;Z&#39; (see PenTo)
Definition: plotter.h:562
void NORMALIZE_ANGLE_180(T &Angle)
Definition: trigo.h:335
int OutlineCount() const
Returns the number of outlines in the set
double m_IUsPerDecimil
Definition: plotter.h:539
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.
const wxSize & GetSizeMils() const
Definition: page_info.h:142
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&#39;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:288
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:77
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 &#39;fit in a4&#39;)
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
virtual void PenTo(const wxPoint &pos, char plume) override
moveto/lineto primitive, moves the &#39;pen&#39; 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:354
double sindecideg(double r, double a)
Circle generation utility: computes r * sin(a) Where a is in decidegrees, not in radians.
Definition: trigo.h:345
#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.