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 #include <math/util.h> // for KiROUND
207 
208 
209 // The hpgl command to close a polygon def, fill it and plot outline:
210 // PM 2; ends the polygon definition and closes it if not closed
211 // FP; fills the polygon
212 // EP; draws the polygon outline. It usually gives a better look to the filled polygon
213 static const char hpgl_end_polygon_cmd[] = "PM 2; FP; EP;\n";
214 
215 // HPGL scale factor (1 Plotter Logical Unit = 1/40mm = 25 micrometers)
216 // PLUsPERDECIMIL = (25.4 / 10000) / 0.025
217 static const double PLUsPERDECIMIL = 0.1016;
218 
220 {
221  SetPenSpeed( 40 ); // Default pen speed = 40 cm/s; Pen speed is *always* in cm
222  SetPenNumber( 1 ); // Default pen num = 1
223  SetPenDiameter( 0.0 );
224 }
225 
226 void HPGL_PLOTTER::SetViewport( const wxPoint& aOffset, double aIusPerDecimil,
227  double aScale, bool aMirror )
228 {
229  plotOffset = aOffset;
230  plotScale = aScale;
231  m_IUsPerDecimil = aIusPerDecimil;
232  iuPerDeviceUnit = PLUsPERDECIMIL / aIusPerDecimil;
233  /* Compute the paper size in IUs */
235  paperSize.x *= 10.0 * aIusPerDecimil;
236  paperSize.y *= 10.0 * aIusPerDecimil;
237  SetDefaultLineWidth( 0 ); // HPGL has pen sizes instead
238  m_plotMirror = aMirror;
239 }
240 
241 
246 {
247  wxASSERT( outputFile );
248  fprintf( outputFile, "IN;VS%d;PU;PA;SP%d;\n", penSpeed, penNumber );
249 
250  // Set HPGL Pen Thickness (in mm) (usefull in polygon fill command)
251  double penThicknessMM = userToDeviceSize( penDiameter )/40;
252  fprintf( outputFile, "PT %.1f;\n", penThicknessMM );
253 
254  return true;
255 }
256 
257 
262 {
263  wxASSERT( outputFile );
264  fputs( "PU;PA;SP0;\n", outputFile );
265  fclose( outputFile );
266  outputFile = NULL;
267  return true;
268 }
269 
270 
271 void HPGL_PLOTTER::SetPenDiameter( double diameter )
272 {
273  penDiameter = diameter;
274 }
275 
279 void HPGL_PLOTTER::Rect( const wxPoint& p1, const wxPoint& p2, FILL_T fill, int width )
280 {
281  wxASSERT( outputFile );
282  DPOINT p2dev = userToDeviceCoordinates( p2 );
283  MoveTo( p1 );
284  fprintf( outputFile, "EA %.0f,%.0f;\n", p2dev.x, p2dev.y );
285  PenFinish();
286 }
287 
288 
289 // HPGL circle
290 void HPGL_PLOTTER::Circle( const wxPoint& centre, int diameter, FILL_T fill,
291  int width )
292 {
293  wxASSERT( outputFile );
294  double radius = userToDeviceSize( diameter / 2 );
295  SetCurrentLineWidth( width );
296 
297  if( fill == FILLED_SHAPE )
298  {
299  // Draw the filled area
300  MoveTo( centre );
301  fprintf( outputFile, "PM 0; CI %g;\n", radius );
302  fprintf( outputFile, hpgl_end_polygon_cmd ); // Close, fill polygon and draw outlines
303  PenFinish();
304  }
305 
306  if( radius > 0 )
307  {
308  MoveTo( centre );
309  fprintf( outputFile, "CI %g;\n", radius );
310  PenFinish();
311  }
312 }
313 
314 
319 void HPGL_PLOTTER::PlotPoly( const std::vector<wxPoint>& aCornerList,
320  FILL_T aFill, int aWidth, void * aData )
321 {
322  if( aCornerList.size() <= 1 )
323  return;
324 
325  SetCurrentLineWidth( aWidth );
326  MoveTo( aCornerList[0] );
327 
328  if( aFill == FILLED_SHAPE )
329  {
330  // Draw the filled area
332  fprintf( outputFile, "PM 0;\n" ); // Start polygon
333 
334  for( unsigned ii = 1; ii < aCornerList.size(); ++ii )
335  LineTo( aCornerList[ii] );
336 
337  int ii = aCornerList.size() - 1;
338 
339  if( aCornerList[ii] != aCornerList[0] )
340  LineTo( aCornerList[0] );
341 
342  fprintf( outputFile, hpgl_end_polygon_cmd ); // Close, fill polygon and draw outlines
343  }
344  else
345  {
346  // Plot only the polygon outline.
347  for( unsigned ii = 1; ii < aCornerList.size(); ii++ )
348  LineTo( aCornerList[ii] );
349 
350  // Always close polygon if filled.
351  if( aFill )
352  {
353  int ii = aCornerList.size() - 1;
354 
355  if( aCornerList[ii] != aCornerList[0] )
356  LineTo( aCornerList[0] );
357  }
358  }
359 
360  PenFinish();
361 }
362 
363 
367 void HPGL_PLOTTER::penControl( char plume )
368 {
369  wxASSERT( outputFile );
370 
371  switch( plume )
372  {
373  case 'U':
374 
375  if( penState != 'U' )
376  {
377  fputs( "PU;", outputFile );
378  penState = 'U';
379  }
380 
381  break;
382 
383  case 'D':
384 
385  if( penState != 'D' )
386  {
387  fputs( "PD;", outputFile );
388  penState = 'D';
389  }
390 
391  break;
392 
393  case 'Z':
394  fputs( "PU;", outputFile );
395  penState = 'U';
396  penLastpos.x = -1;
397  penLastpos.y = -1;
398  break;
399  }
400 }
401 
402 
403 void HPGL_PLOTTER::PenTo( const wxPoint& pos, char plume )
404 {
405  wxASSERT( outputFile );
406 
407  if( plume == 'Z' )
408  {
409  penControl( 'Z' );
410  return;
411  }
412 
413  penControl( plume );
414  DPOINT pos_dev = userToDeviceCoordinates( pos );
415 
416  if( penLastpos != pos )
417  fprintf( outputFile, "PA %.0f,%.0f;\n", pos_dev.x, pos_dev.y );
418 
419  penLastpos = pos;
420 }
421 
422 
427 {
428  wxASSERT( outputFile );
429 
430  switch( dashed )
431  {
433  fprintf( outputFile, "LT -2 4 1;\n" );
434  break;
435  case PLOT_DASH_TYPE::DOT:
436  fprintf( outputFile, "LT -1 2 1;\n" );
437  break;
439  fprintf( outputFile, "LT -4 6 1;\n" );
440  break;
441  default:
442  fputs( "LT;\n", outputFile );
443  }
444 }
445 
446 
447 void HPGL_PLOTTER::ThickSegment( const wxPoint& start, const wxPoint& end,
448  int width, EDA_DRAW_MODE_T tracemode, void* aData )
449 {
450  wxASSERT( outputFile );
451  wxPoint center;
452  wxSize size;
453 
454  // Suppress overlap if pen is too big
455  if( penDiameter >= width )
456  {
457  MoveTo( start );
458  FinishTo( end );
459  }
460  else
461  segmentAsOval( start, end, width, tracemode );
462 }
463 
464 
465 /* Plot an arc:
466  * Center = center coord
467  * Stangl, endAngle = angle of beginning and end
468  * Radius = radius of the arc
469  * Command
470  * PU PY x, y; PD start_arc_X AA, start_arc_Y, angle, NbSegm; PU;
471  * Or PU PY x, y; PD start_arc_X AA, start_arc_Y, angle, PU;
472  */
473 void HPGL_PLOTTER::Arc( const wxPoint& centre, double StAngle, double EndAngle, int radius,
474  FILL_T fill, int width )
475 {
476  wxASSERT( outputFile );
477  double angle;
478 
479  if( radius <= 0 )
480  return;
481 
482  DPOINT centre_dev = userToDeviceCoordinates( centre );
483 
484  if( m_plotMirror )
485  angle = StAngle - EndAngle;
486  else
487  angle = EndAngle - StAngle;
488 
490  angle /= 10;
491 
492  // Calculate arc start point:
493  wxPoint cmap;
494  cmap.x = centre.x + KiROUND( cosdecideg( radius, StAngle ) );
495  cmap.y = centre.y - KiROUND( sindecideg( radius, StAngle ) );
496  DPOINT cmap_dev = userToDeviceCoordinates( cmap );
497 
498  fprintf( outputFile,
499  "PU;PA %.0f,%.0f;PD;AA %.0f,%.0f,",
500  cmap_dev.x, cmap_dev.y,
501  centre_dev.x, centre_dev.y );
502  fprintf( outputFile, "%.0f", angle );
503  fprintf( outputFile, ";PU;\n" );
504  PenFinish();
505 }
506 
507 
508 /* Plot oval pad.
509  */
510 void HPGL_PLOTTER::FlashPadOval( const wxPoint& pos, const wxSize& aSize, double orient,
511  EDA_DRAW_MODE_T trace_mode, void* aData )
512 {
513  wxASSERT( outputFile );
514  int deltaxy, cx, cy;
515  wxSize size( aSize );
516 
517  /* The pad will be drawn as an oblong shape with size.y > size.x
518  * (Oval vertical orientation 0)
519  */
520  if( size.x > size.y )
521  {
522  std::swap( size.x, size.y );
523  orient = AddAngles( orient, 900 );
524  }
525 
526  deltaxy = size.y - size.x; // distance between centers of the oval
527 
528  if( trace_mode == FILLED )
529  {
530  FlashPadRect( pos, wxSize( size.x, deltaxy + KiROUND( penDiameter ) ),
531  orient, trace_mode, aData );
532  cx = 0; cy = deltaxy / 2;
533  RotatePoint( &cx, &cy, orient );
534  FlashPadCircle( wxPoint( cx + pos.x, cy + pos.y ), size.x, trace_mode, aData );
535  cx = 0; cy = -deltaxy / 2;
536  RotatePoint( &cx, &cy, orient );
537  FlashPadCircle( wxPoint( cx + pos.x, cy + pos.y ), size.x, trace_mode, aData );
538  }
539  else // Plot in outline mode.
540  {
541  sketchOval( pos, size, orient, KiROUND( penDiameter ) );
542  }
543 }
544 
545 
546 /* Plot round pad or via.
547  */
548 void HPGL_PLOTTER::FlashPadCircle( const wxPoint& pos, int diametre,
549  EDA_DRAW_MODE_T trace_mode, void* aData )
550 {
551  wxASSERT( outputFile );
552  DPOINT pos_dev = userToDeviceCoordinates( pos );
553 
554  int radius = diametre / 2;
555 
556  if( trace_mode == FILLED )
557  {
558  // if filled mode, the pen diameter is removed from diameter
559  // to keep the pad size
560  radius -= KiROUND( penDiameter ) / 2;
561  }
562 
563  if( radius < 0 )
564  radius = 0;
565 
566  double rsize = userToDeviceSize( radius );
567 
568  if( trace_mode == FILLED ) // Plot in filled mode.
569  {
570  // A filled polygon uses always the current point to start the polygon.
571  // Gives a correct current starting point for the circle
572  MoveTo( wxPoint( pos.x+radius, pos.y ) );
573  // Plot filled area and its outline
574  fprintf( outputFile, "PM 0; PA %.0f,%.0f;CI %.0f;%s",
575  pos_dev.x, pos_dev.y, rsize, hpgl_end_polygon_cmd );
576  }
577  else
578  {
579  // Draw outline only:
580  fprintf( outputFile, "PA %.0f,%.0f;CI %.0f;\n",
581  pos_dev.x, pos_dev.y, rsize );
582  }
583 
584  PenFinish();
585 }
586 
587 
588 void HPGL_PLOTTER::FlashPadRect( const wxPoint& pos, const wxSize& padsize,
589  double orient, EDA_DRAW_MODE_T trace_mode, void* aData )
590 {
591  // Build rect polygon:
592  std::vector<wxPoint> corners;
593 
594  int dx = padsize.x / 2;
595  int dy = padsize.y / 2;
596 
597  if( trace_mode == FILLED )
598  {
599  // in filled mode, the pen diameter is removed from size
600  // to compensate the extra size due to this pen size
601  dx -= KiROUND( penDiameter ) / 2;
602  dx = std::max( dx, 0);
603  dy -= KiROUND( penDiameter ) / 2;
604  dy = std::max( dy, 0);
605  }
606 
607 
608  corners.emplace_back( - dx, - dy );
609  corners.emplace_back( - dx, + dy );
610  corners.emplace_back( + dx, + dy );
611  corners.emplace_back( + dx, - dy );
612  // Close polygon
613  corners.emplace_back( - dx, - dy );
614 
615  for( unsigned ii = 0; ii < corners.size(); ii++ )
616  {
617  RotatePoint( &corners[ii], orient );
618  corners[ii] += pos;
619  }
620 
621  PlotPoly( corners, trace_mode == FILLED ? FILLED_SHAPE : NO_FILL );
622 }
623 
624 
625 void HPGL_PLOTTER::FlashPadRoundRect( const wxPoint& aPadPos, const wxSize& aSize,
626  int aCornerRadius, double aOrient,
627  EDA_DRAW_MODE_T aTraceMode, void* aData )
628 {
629  SHAPE_POLY_SET outline;
630 
631  wxSize size = aSize;
632 
633  if( aTraceMode == FILLED )
634  {
635  // in filled mode, the pen diameter is removed from size
636  // to keep the pad size
637  size.x -= KiROUND( penDiameter ) / 2;
638  size.x = std::max( size.x, 0);
639  size.y -= KiROUND( penDiameter ) / 2;
640  size.y = std::max( size.y, 0);
641 
642  // keep aCornerRadius to a value < min size x,y < 2:
643  aCornerRadius = std::min( aCornerRadius, std::min( size.x, size.y ) /2 );
644  }
645 
646  TransformRoundChamferedRectToPolygon( outline, aPadPos, size, aOrient,
647  aCornerRadius, 0.0, 0, GetPlotterArcHighDef() );
648 
649  // TransformRoundRectToPolygon creates only one convex polygon
650  std::vector<wxPoint> cornerList;
651  SHAPE_LINE_CHAIN& poly = outline.Outline( 0 );
652  cornerList.reserve( poly.PointCount() );
653 
654  for( int ii = 0; ii < poly.PointCount(); ++ii )
655  cornerList.emplace_back( poly.CPoint( ii ).x, poly.CPoint( ii ).y );
656 
657  if( cornerList.back() != cornerList.front() )
658  cornerList.push_back( cornerList.front() );
659 
660  PlotPoly( cornerList, aTraceMode == FILLED ? FILLED_SHAPE : NO_FILL );
661 }
662 
663 void HPGL_PLOTTER::FlashPadCustom( const wxPoint& aPadPos, const wxSize& aSize,
664  SHAPE_POLY_SET* aPolygons,
665  EDA_DRAW_MODE_T aTraceMode, void* aData )
666 {
667  std::vector< wxPoint > cornerList;
668 
669  for( int cnt = 0; cnt < aPolygons->OutlineCount(); ++cnt )
670  {
671  SHAPE_LINE_CHAIN& poly = aPolygons->Outline( cnt );
672 
673  cornerList.clear();
674  cornerList.reserve( poly.PointCount() );
675 
676  for( int ii = 1; ii < poly.PointCount(); ++ii )
677  cornerList.emplace_back( poly.CPoint( ii ).x, poly.CPoint( ii ).y );
678 
679  if( cornerList.back() != cornerList.front() )
680  cornerList.push_back( cornerList.front() );
681 
682  PlotPoly( cornerList, aTraceMode == FILLED ? FILLED_SHAPE : NO_FILL );
683  }
684 }
685 
686 
687 void HPGL_PLOTTER::FlashPadTrapez( const wxPoint& aPadPos, const wxPoint* aCorners,
688  double aPadOrient, EDA_DRAW_MODE_T aTraceMode, void* aData )
689 {
690  std::vector< wxPoint > cornerList;
691  cornerList.reserve( 5 );
692 
693  for( int ii = 0; ii < 4; ii++ )
694  {
695  wxPoint coord( aCorners[ii] );
696  RotatePoint( &coord, aPadOrient );
697  coord += aPadPos;
698  cornerList.push_back( coord );
699  }
700 
701  // Close polygon
702  cornerList.push_back( cornerList.front() );
703 
704  PlotPoly( cornerList, aTraceMode == FILLED ? FILLED_SHAPE : NO_FILL );
705 }
706 
707 
709  int aRadius, int aCornerCount,
710  double aOrient, EDA_DRAW_MODE_T aTraceMode, void* aData )
711 {
712  // Do nothing
713  wxASSERT( 0 );
714 }
void FinishTo(const wxPoint &pos)
Definition: plotter.h:270
virtual bool EndPlot() override
HPGL end of plot: pen return and release.
int penSpeed
Definition: plotter.h:684
void PenFinish()
Definition: plotter.h:276
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:
virtual void SetPenDiameter(double diameter)
virtual void ThickSegment(const wxPoint &start, const wxPoint &end, int width, EDA_DRAW_MODE_T tracemode, void *aData) override
char penState
Current pen state: 'U', 'D' or 'Z' (see PenTo)
Definition: plotter.h:592
void NORMALIZE_ANGLE_180(T &Angle)
Definition: trigo.h:346
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:208
double m_IUsPerDecimil
Definition: plotter.h:569
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:631
wxPoint plotOffset
Plot offset (in IUs)
Definition: plotter.h:575
wxPoint penLastpos
Last pen positions; set to -1,-1 when the pen is at rest.
Definition: plotter.h:594
PAGE_INFO pageInfo
Definition: plotter.h:598
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
const VECTOR2I & CPoint(int aIndex) const
Function Point()
void LineTo(const wxPoint &pos)
Definition: plotter.h:265
static const int USE_DEFAULT_LINE_WIDTH
Definition: plotter.h:108
bool m_plotMirror
X axis orientation (SVG) and plot mirrored (only for PS, PDF HPGL and SVG)
Definition: plotter.h:579
#define NULL
virtual void SetCurrentLineWidth(int width, void *aData=NULL) override
HPGL doesn't handle line thickness or color.
Definition: plotter.h:625
T AddAngles(T a1, T2 a2)
Add two angles (keeping the result normalized). T2 is here.
Definition: trigo.h:299
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:636
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:563
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:124
virtual void FlashPadRect(const wxPoint &aPadPos, const wxSize &aSize, double aOrient, EDA_DRAW_MODE_T aTraceMode, void *aData) override
virtual function FlashPadRect
PLOT_DASH_TYPE
Enum for choosing dashed line type.
Definition: plotter.h:86
void TransformRoundChamferedRectToPolygon(SHAPE_POLY_SET &aCornerBuffer, const wxPoint &aPosition, const wxSize &aSize, double aRotation, int aCornerRadius, double aChamferRatio, int aChamferCorners, int aApproxErrorMax, int aMinSegPerCircleCount=16)
convert a rectangle with rounded corners and/or chamfered corners to a polygon Convert rounded corner...
int penNumber
Definition: plotter.h:685
void MoveTo(const wxPoint &pos)
Definition: plotter.h:260
virtual DPOINT userToDeviceCoordinates(const wxPoint &aCoordinate)
Modifies coordinates according to the orientation, scale factor, and offsets trace.
Definition: plotter.cpp:99
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.
SHAPE_LINE_CHAIN.
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
double penDiameter
Definition: plotter.h:686
virtual void SetPenNumber(int number)
Definition: plotter.h:641
FILE * outputFile
true if the Y axis is top to bottom (SVG)
Definition: plotter.h:584
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: util.h:61
int GetPlotterArcHighDef() const
Definition: plotter.h:226
FILL_T
Enum FILL_T is the set of fill types used in plotting or drawing enclosed areas.
Definition: base_struct.h:42
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:572
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:437
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 SetDash(PLOT_DASH_TYPE dashed) override
HPGL supports dashed lines.
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:458
wxSize paperSize
Paper size in IU - not in mils.
Definition: plotter.h:600
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.