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 
629  wxSize size = aSize;
630 
631  if( aTraceMode == FILLED )
632  {
633  // in filled mode, the pen diameter is removed from size
634  // to keep the pad size
635  size.x -= KiROUND( penDiameter ) / 2;
636  size.x = std::max( size.x, 0);
637  size.y -= KiROUND( penDiameter ) / 2;
638  size.y = std::max( size.y, 0);
639 
640  // keep aCornerRadius to a value < min size x,y < 2:
641  aCornerRadius = std::min( aCornerRadius, std::min( size.x, size.y ) /2 );
642  }
643 
644  TransformRoundChamferedRectToPolygon( outline, aPadPos, size, aOrient,
645  aCornerRadius, 0.0, 0, GetPlotterArcHighDef() );
646 
647  // TransformRoundRectToPolygon creates only one convex polygon
648  std::vector< wxPoint > cornerList;
649  SHAPE_LINE_CHAIN& poly = outline.Outline( 0 );
650 
651  for( int ii = 0; ii < poly.PointCount(); ++ii )
652  cornerList.push_back( wxPoint( poly.Point( ii ).x, poly.Point( ii ).y ) );
653 
654  if( cornerList.back() != cornerList.front() )
655  cornerList.push_back( cornerList.front() );
656 
657  PlotPoly( cornerList, aTraceMode == FILLED ? FILLED_SHAPE : NO_FILL );
658 }
659 
660 void HPGL_PLOTTER::FlashPadCustom( const wxPoint& aPadPos, const wxSize& aSize,
661  SHAPE_POLY_SET* aPolygons,
662  EDA_DRAW_MODE_T aTraceMode, void* aData )
663 {
664  std::vector< wxPoint > cornerList;
665 
666  for( int cnt = 0; cnt < aPolygons->OutlineCount(); ++cnt )
667  {
668  SHAPE_LINE_CHAIN& poly = aPolygons->Outline( cnt );
669 
670  cornerList.clear();
671  cornerList.reserve( poly.PointCount() );
672 
673  for( int ii = 1; ii < poly.PointCount(); ++ii )
674  cornerList.push_back( wxPoint( poly.Point( ii ).x, poly.Point( ii ).y ) );
675 
676  if( cornerList.back() != cornerList.front() )
677  cornerList.push_back( cornerList.front() );
678 
679  PlotPoly( cornerList, aTraceMode == FILLED ? FILLED_SHAPE : NO_FILL );
680  }
681 }
682 
683 
684 void HPGL_PLOTTER::FlashPadTrapez( const wxPoint& aPadPos, const wxPoint* aCorners,
685  double aPadOrient, EDA_DRAW_MODE_T aTraceMode, void* aData )
686 {
687  std::vector< wxPoint > cornerList;
688  cornerList.reserve( 5 );
689 
690  for( int ii = 0; ii < 4; ii++ )
691  {
692  wxPoint coord( aCorners[ii] );
693  RotatePoint( &coord, aPadOrient );
694  coord += aPadPos;
695  cornerList.push_back( coord );
696  }
697 
698  // Close polygon
699  cornerList.push_back( cornerList.front() );
700 
701  PlotPoly( cornerList, aTraceMode == FILLED ? FILLED_SHAPE : NO_FILL );
702 }
703 
704 
705 void HPGL_PLOTTER::FlashRegularPolygon( const wxPoint& aShapePos,
706  int aRadius, int aCornerCount,
707  double aOrient, EDA_DRAW_MODE_T aTraceMode, void* aData )
708 {
709  // Do nothing
710  wxASSERT( 0 );
711 }
void FinishTo(const wxPoint &pos)
Definition: plotter.h:264
virtual bool EndPlot() override
HPGL end of plot: pen return and release.
int penSpeed
Definition: plotter.h:678
void PenFinish()
Definition: plotter.h:270
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:
void TransformRoundChamferedRectToPolygon(SHAPE_POLY_SET &aCornerBuffer, const wxPoint &aPosition, const wxSize &aSize, double aRotation, int aCornerRadius, double aChamferRatio, int aChamferCorners, int aApproxErrorMax, int aMinSegPerCircleCount)
convert a rectangle with rounded corners and/or chamfered corners to a polygon Convert rounded corner...
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:206
char penState
Current pen state: 'U', 'D' or 'Z' (see PenTo)
Definition: plotter.h:586
void NORMALIZE_ANGLE_180(T &Angle)
Definition: trigo.h:346
double m_IUsPerDecimil
Definition: plotter.h:563
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:625
wxPoint plotOffset
Plot offset (in IUs)
Definition: plotter.h:569
wxPoint penLastpos
Last pen positions; set to -1,-1 when the pen is at rest.
Definition: plotter.h:588
PAGE_INFO pageInfo
Definition: plotter.h:592
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:259
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:573
virtual void SetCurrentLineWidth(int width, void *aData=NULL) override
HPGL doesn't handle line thickness or color.
Definition: plotter.h:619
T AddAngles(T a1, T2 a2)
Add two angles (keeping the result normalized). T2 is here.
Definition: trigo.h:299
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:59
virtual void SetPenSpeed(int speed)
Definition: plotter.h:630
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:557
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:123
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:679
void MoveTo(const wxPoint &pos)
Definition: plotter.h:254
virtual DPOINT userToDeviceCoordinates(const wxPoint &aCoordinate)
Modifies coordinates according to the orientation, scale factor, and offsets trace.
Definition: plotter.cpp:98
double cosdecideg(double r, double a)
Circle generation utility: computes r * cos(a) Where a is in decidegrees, not in radians.
Definition: trigo.h:365
double sindecideg(double r, double a)
Circle generation utility: computes r * sin(a) Where a is in decidegrees, not in radians.
Definition: trigo.h:356
virtual void FlashRegularPolygon(const wxPoint &aShapePos, int aDiameter, int aCornerCount, double aOrient, EDA_DRAW_MODE_T aTraceMode, void *aData) override
Flash a regular polygon.
#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:680
virtual void SetPenNumber(int number)
Definition: plotter.h:635
FILE * outputFile
true if the Y axis is top to bottom (SVG)
Definition: plotter.h:578
int GetPlotterArcHighDef() const
Definition: plotter.h:220
FILL_T
Enum FILL_T is the set of fill types used in plotting or drawing enclosed areas.
Definition: base_struct.h:42
VECTOR2I & Point(int aIndex)
Function Point()
static const double PLUsPERDECIMIL
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:566
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:436
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:457
wxSize paperSize
Paper size in IU - not in mils.
Definition: plotter.h:594
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:114
#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.