KiCad PCB EDA Suite
Loading...
Searching...
No Matches
SVG_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) 2020 Jean-Pierre Charras, jp.charras at wanadoo.fr
5 * Copyright The 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
25/* Some info on basic items SVG format, used here:
26 * The root element of all SVG files is the <svg> element.
27 *
28 * The <g> element is used to group SVG shapes together.
29 * Once grouped you can transform the whole group of shapes as if it was a single shape.
30 * This is an advantage compared to a nested <svg> element
31 * which cannot be the target of transformation by itself.
32 *
33 * The <rect> element represents a rectangle.
34 * Using this element you can draw rectangles of various width, height,
35 * with different stroke (outline) and fill colors, with sharp or rounded corners etc.
36 *
37 * <svg xmlns="http://www.w3.org/2000/svg"
38 * xmlns:xlink="http://www.w3.org/1999/xlink">
39 *
40 * <rect x="10" y="10" height="100" width="100"
41 * style="stroke:#006600; fill: #00cc00"/>
42 *
43 * </svg>
44 *
45 * The <circle> element is used to draw circles.
46 * <circle cx="40" cy="40" r="24" style="stroke:#006600; fill:#00cc00"/>
47 *
48 * The <ellipse> element is used to draw ellipses.
49 * An ellipse is a circle that does not have equal height and width.
50 * Its radius in the x and y directions are different, in other words.
51 * <ellipse cx="40" cy="40" rx="30" ry="15"
52 * style="stroke:#006600; fill:#00cc00"/>
53 *
54 * The <line> element is used to draw lines.
55 *
56 * <line x1="0" y1="10" x2="0" y2="100" style="stroke:#006600;"/>
57 * <line x1="10" y1="10" x2="100" y2="100" style="stroke:#006600;"/>
58 *
59 * The <polyline> element is used to draw multiple connected lines
60 * Here is a simple example:
61 *
62 * <polyline points="0,0 30,0 15,30" style="stroke:#006600;"/>
63 *
64 * The <polygon> element is used to draw with multiple (3 or more) sides / edges.
65 * Here is a simple example:
66 *
67 * <polygon points="0,0 50,0 25,50" style="stroke:#660000; fill:#cc3333;"/>
68 *
69 * The <path> element is used to draw advanced shapes combined from lines and arcs,
70 * with or without fill.
71 * It is probably the most advanced and versatile SVG shape of them all.
72 * It is probably also the hardest element to master.
73 * <path d="M50,50
74 * A30,30 0 0,1 35,20
75 * L100,100
76 * M110,110
77 * L100,0"
78 * style="stroke:#660000; fill:none;"/>
79 *
80 * Draw an elliptic arc: it is one of basic path command:
81 * <path d="M(startx,starty) A(radiusx,radiusy)
82 * rotation-axe-x
83 * flag_arc_large,flag_sweep endx,endy">
84 * flag_arc_large: 0 = small arc > 180 deg, 1 = large arc > 180 deg
85 * flag_sweep : 0 = CCW, 1 = CW
86 * The center of ellipse is automatically calculated.
87 */
88
89#include <core/base64.h>
90#include <eda_shape.h>
91#include <string_utils.h>
92#include <font/font.h>
93#include <macros.h>
94#include <trigo.h>
95#include <fmt/format.h>
96
97#include <cstdint>
98#include <wx/mstream.h>
99
101
102// Note:
103// During tests, we (JPC) found issues when the coordinates used 6 digits in mantissa
104// especially for stroke-width using very small (but not null) values < 0.00001 mm
105// So to avoid this king of issue, we are using 4 digits in mantissa
106// The resolution (m_precision ) is 0.1 micron, that looks enough for a SVG file
107
113static wxString XmlEsc( const wxString& aStr, bool isAttribute = false )
114{
115 wxString escaped;
116
117 escaped.reserve( aStr.length() );
118
119 for( wxString::const_iterator it = aStr.begin(); it != aStr.end(); ++it )
120 {
121 const wxChar c = *it;
122
123 switch( c )
124 {
125 case wxS( '<' ):
126 escaped.append( wxS( "&lt;" ) );
127 break;
128 case wxS( '>' ):
129 escaped.append( wxS( "&gt;" ) );
130 break;
131 case wxS( '&' ):
132 escaped.append( wxS( "&amp;" ) );
133 break;
134 case wxS( '\r' ):
135 escaped.append( wxS( "&#xD;" ) );
136 break;
137 default:
138 if( isAttribute )
139 {
140 switch( c )
141 {
142 case wxS( '"' ):
143 escaped.append( wxS( "&quot;" ) );
144 break;
145 case wxS( '\t' ):
146 escaped.append( wxS( "&#x9;" ) );
147 break;
148 case wxS( '\n' ):
149 escaped.append( wxS( "&#xA;" ));
150 break;
151 default:
152 escaped.append(c);
153 }
154 }
155 else
156 {
157 escaped.append(c);
158 }
159 }
160 }
161
162 return escaped;
163}
164
165
167 PSLIKE_PLOTTER( aProject )
168{
169 m_graphics_changed = true;
171 m_fillMode = FILL_T::NO_FILL; // or FILLED_SHAPE or FILLED_WITH_BG_BODYCOLOR
172 m_pen_rgb_color = 0; // current color value (black)
173 m_brush_rgb_color = 0; // current color value with alpha(black)
174 m_brush_alpha = 1.0;
176 m_precision = 4; // default: 4 digits in mantissa.
177}
178
179
180void SVG_PLOTTER::SetViewport( const VECTOR2I& aOffset, double aIusPerDecimil,
181 double aScale, bool aMirror )
182{
183 m_plotMirror = aMirror;
184 m_yaxisReversed = true; // unlike other plotters, SVG has Y axis reversed
185 m_plotOffset = aOffset;
186 m_plotScale = aScale;
187 m_IUsPerDecimil = aIusPerDecimil;
188
189 // Compute the paper size in IUs. for historical reasons the page size is in mils
190 m_paperSize = m_pageInfo.GetSizeMils();
191 m_paperSize.x *= 10.0 * aIusPerDecimil;
192 m_paperSize.y *= 10.0 * aIusPerDecimil;
193
194 // gives now a default value to iuPerDeviceUnit (because the units of the caller is now known)
195 double iusPerMM = m_IUsPerDecimil / 2.54 * 1000;
196 m_iuPerDeviceUnit = 1 / iusPerMM;
197
199}
200
201
202void SVG_PLOTTER::SetSvgCoordinatesFormat( unsigned aPrecision )
203{
204 // Only number of digits in mantissa are adjustable.
205 // SVG units are always mm
206 m_precision = aPrecision;
207}
208
209
211{
212 if( m_fillMode != fill )
213 {
214 m_graphics_changed = true;
215 m_fillMode = fill;
216 }
217}
218
219
220void SVG_PLOTTER::setSVGPlotStyle( int aLineWidth, bool aIsGroup, const std::string& aExtraStyle )
221{
222 if( aIsGroup )
223 fmt::print( m_outputFile, "</g>\n<g " );
224
225 fmt::print( m_outputFile, "style=\"" );
226
228 {
229 fmt::print( m_outputFile, "fill:none; " );
230 }
231 else
232 {
233 // output the background fill color
234 fmt::print( m_outputFile, "fill:#{:06X}; ", m_brush_rgb_color );
235
236 switch( m_fillMode )
237 {
241 fmt::print( m_outputFile, "fill-opacity:{:.{}f}; ", m_brush_alpha, m_precision );
242 break;
243 default: break;
244 }
245 }
246
247 double pen_w = userToDeviceSize( aLineWidth );
248
249 if( pen_w <= 0 )
250 {
251 fmt::print( m_outputFile, "stroke:none;" );
252 }
253 else
254 {
255 // Fix a strange issue found in Inkscape: aWidth < 100 nm create issues on degrouping
256 // objects.
257 // So we use only 4 digits in mantissa for stroke-width.
258 // TODO: perhaps used only 3 or 4 digits in mantissa for all values in mm, because some
259 // issues were previously reported reported when using nm as integer units
260 fmt::print( m_outputFile, "\nstroke:#{:06X}; stroke-width:{:.{}f}; stroke-opacity:1; \n",
262 fmt::print( m_outputFile, "stroke-linecap:round; stroke-linejoin:round;" );
263
264 //set any extra attributes for non-solid lines
265 switch( m_dashed )
266 {
267 case LINE_STYLE::DASH:
268 fmt::print( m_outputFile, "stroke-dasharray:{:.{}f},{:.{}f};",
269 GetDashMarkLenIU( aLineWidth ), m_precision,
270 GetDashGapLenIU( aLineWidth ), m_precision );
271 break;
272
273 case LINE_STYLE::DOT:
274 fmt::print( m_outputFile, "stroke-dasharray:{:f},{:f};", GetDotMarkLenIU( aLineWidth ),
275 GetDashGapLenIU( aLineWidth ) );
276 break;
277
279 fmt::print( m_outputFile, "stroke-dasharray:{:f},{:f},{:f},{:f};",
280 GetDashMarkLenIU( aLineWidth ),
281 GetDashGapLenIU( aLineWidth ), GetDotMarkLenIU( aLineWidth ),
282 GetDashGapLenIU( aLineWidth ) );
283 break;
284
286 fmt::print( m_outputFile, "stroke-dasharray:{:f},{:f},{:f},{:f},{:f},{:f};",
287 GetDashMarkLenIU( aLineWidth ), GetDashGapLenIU( aLineWidth ),
288 GetDotMarkLenIU( aLineWidth ), GetDashGapLenIU( aLineWidth ),
289 GetDotMarkLenIU( aLineWidth ), GetDashGapLenIU( aLineWidth ) );
290 break;
291
294 default:
295 //do nothing
296 break;
297 }
298 }
299
300 if( aExtraStyle.length() )
301 fmt::print( m_outputFile, "{}", aExtraStyle );
302
303 fmt::print( m_outputFile, "\"" );
304
305 if( aIsGroup )
306 {
307 fmt::print( m_outputFile, ">" );
308 m_graphics_changed = false;
309 }
310
311 fmt::print( m_outputFile, "\n" );
312}
313
314
315void SVG_PLOTTER::SetCurrentLineWidth( int aWidth, void* aData )
316{
317 if( aWidth == DO_NOT_SET_LINE_WIDTH )
318 return;
319 else if( aWidth == USE_DEFAULT_LINE_WIDTH )
320 aWidth = m_renderSettings->GetDefaultPenWidth();
321
322 // Note: aWidth == 0 is fine: used for filled shapes with no outline thickness
323 wxASSERT_MSG( aWidth >= 0, "Plotter called to set negative pen width" );
324
325 if( aWidth != m_currentPenWidth )
326 {
327 m_graphics_changed = true;
328 m_currentPenWidth = aWidth;
329 }
330}
331
332
333void SVG_PLOTTER::StartBlock( void* aData )
334{
335 // We can't use <g></g> for blocks because we're already using it for graphics context, and
336 // our graphics context handling is lazy (ie: it leaves the last group open until the context
337 // changes).
338}
339
340
341void SVG_PLOTTER::EndBlock( void* aData )
342{
343}
344
345
346void SVG_PLOTTER::emitSetRGBColor( double r, double g, double b, double a )
347{
348 uint32_t red = (uint32_t) ( 255.0 * r );
349 uint32_t green = (uint32_t) ( 255.0 * g );
350 uint32_t blue = (uint32_t) ( 255.0 * b );
351 uint32_t rgb_color = ( red << 16 ) | ( green << 8 ) | blue;
352
353 if( m_pen_rgb_color != rgb_color || m_brush_alpha != a )
354 {
355 m_graphics_changed = true;
356 m_pen_rgb_color = rgb_color;
357
358 // Currently, use the same color for brush and pen (i.e. to draw and fill a contour).
359 m_brush_rgb_color = rgb_color;
360 m_brush_alpha = a;
361 }
362}
363
364
365void SVG_PLOTTER::SetDash( int aLineWidth, LINE_STYLE aLineStyle )
366{
367 if( m_dashed != aLineStyle )
368 {
369 m_graphics_changed = true;
370 m_dashed = aLineStyle;
371 }
372}
373
374
375void SVG_PLOTTER::Rect( const VECTOR2I& p1, const VECTOR2I& p2, FILL_T fill, int width,
376 int aCornerRadius )
377{
378 BOX2I rect( p1, VECTOR2I( p2.x - p1.x, p2.y - p1.y ) );
379 rect.Normalize();
380
381 VECTOR2D org_dev = userToDeviceCoordinates( rect.GetOrigin() );
382 VECTOR2D end_dev = userToDeviceCoordinates( rect.GetEnd() );
383 VECTOR2D size_dev = end_dev - org_dev;
384
385 // Ensure size of rect in device coordinates is > 0
386 // I don't know if this is a SVG issue or a Inkscape issue, but
387 // Inkscape has problems with negative or null values for width and/or height, so avoid them
388 BOX2D rect_dev( org_dev, size_dev );
389 rect_dev.Normalize();
390
391 setFillMode( fill );
392 SetCurrentLineWidth( width );
393
396
397 // Rectangles having a 0 size value for height or width are just not drawn on Inkscape,
398 // so use a line when happens.
399 if( rect_dev.GetSize().x == 0.0 || rect_dev.GetSize().y == 0.0 ) // Draw a line
400 {
401 fmt::print( m_outputFile,
402 "<line x1=\"{:.{}f}\" y1=\"{:.{}f}\" x2=\"{:.{}f}\" y2=\"{:.{}f}\" />\n",
403 rect_dev.GetPosition().x, m_precision,
404 rect_dev.GetPosition().y, m_precision,
405 rect_dev.GetEnd().x, m_precision,
406 rect_dev.GetEnd().y, m_precision );
407 }
408 else
409 {
410 fmt::print( m_outputFile,
411 "<rect x=\"{:f}\" y=\"{:f}\" width=\"{:f}\" height=\"{:f}\" rx=\"{:f}\" />\n",
412 rect_dev.GetPosition().x,
413 rect_dev.GetPosition().y,
414 rect_dev.GetSize().x,
415 rect_dev.GetSize().y,
416 userToDeviceSize( aCornerRadius ) );
417 }
418}
419
420
421void SVG_PLOTTER::Circle( const VECTOR2I& pos, int diametre, FILL_T fill, int width )
422{
423 VECTOR2D pos_dev = userToDeviceCoordinates( pos );
424 double radius = userToDeviceSize( diametre / 2.0 );
425
426 setFillMode( fill );
427 SetCurrentLineWidth( width );
428
431
432 // If diameter is less than width, switch to filled mode
433 if( fill == FILL_T::NO_FILL && diametre < GetCurrentLineWidth() )
434 {
436 width = GetCurrentLineWidth();
438
439 radius = userToDeviceSize( ( diametre / 2.0 ) + ( width / 2.0 ) );
440 }
441
442 fmt::print( m_outputFile,
443 "<circle cx=\"{:.{}f}\" cy=\"{:.{}f}\" r=\"{:.{}f}\" /> \n",
444 pos_dev.x, m_precision,
445 pos_dev.y, m_precision,
447}
448
449
450void SVG_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
451 const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill, int aWidth )
452{
453 /* Draws an arc of a circle, centered on (xc,yc), with starting point (x1, y1) and ending
454 * at (x2, y2). The current pen is used for the outline and the current brush for filling
455 * the shape.
456 *
457 * The arc is drawn in an anticlockwise direction from the start point to the end point.
458 */
459 if( aRadius <= 0 )
460 {
461 Circle( aCenter, aWidth, FILL_T::FILLED_SHAPE, 0 );
462 return;
463 }
464
465 EDA_ANGLE startAngle = -aStartAngle;
466 EDA_ANGLE endAngle = startAngle - aAngle;
467
468 if( endAngle < startAngle )
469 std::swap( startAngle, endAngle );
470
471 // Calculate start point.
472 VECTOR2D centre_device = userToDeviceCoordinates( aCenter );
473 double radius_device = userToDeviceSize( aRadius );
474
475 if( m_plotMirror )
476 {
478 {
479 std::swap( startAngle, endAngle );
480 startAngle = ANGLE_180 - startAngle;
481 endAngle = ANGLE_180 - endAngle;
482 }
483 else
484 {
485 startAngle = -startAngle;
486 endAngle = -endAngle;
487 }
488 }
489
490 VECTOR2D start;
491 start.x = radius_device;
492 RotatePoint( start, startAngle );
494 end.x = radius_device;
495 RotatePoint( end, endAngle );
496 start += centre_device;
497 end += centre_device;
498
499 double theta1 = startAngle.AsRadians();
500
501 if( theta1 < 0 )
502 theta1 = theta1 + M_PI * 2;
503
504 double theta2 = endAngle.AsRadians();
505
506 if( theta2 < 0 )
507 theta2 = theta2 + M_PI * 2;
508
509 if( theta2 < theta1 )
510 theta2 = theta2 + M_PI * 2;
511
512 int flg_arc = 0; // flag for large or small arc. 0 means less than 180 degrees
513
514 if( fabs( theta2 - theta1 ) > M_PI )
515 flg_arc = 1;
516
517 int flg_sweep = 0; // flag for sweep always 0
518
519 // Draw a single arc: an arc is one of 3 curve commands (2 other are 2 bezier curves)
520 // params are start point, radius1, radius2, X axe rotation,
521 // flag arc size (0 = small arc > 180 deg, 1 = large arc > 180 deg),
522 // sweep arc ( 0 = CCW, 1 = CW),
523 // end point
524 if( aFill != FILL_T::NO_FILL )
525 {
526 // Filled arcs (in Eeschema) consist of the pie wedge and a stroke only on the arc
527 // This needs to be drawn in two steps.
528 setFillMode( aFill );
530
533
534 fmt::print( m_outputFile,
535 "<path d=\"M{:.{}f} {:.{}f} A{:.{}f} {:.{}f} 0.0 {:d} {:d} {:.{}f} {:.{}f} L {:.{}f} {:.{}f} Z\" />\n",
536 start.x, m_precision,
537 start.y, m_precision,
538 radius_device, m_precision,
539 radius_device, m_precision,
540 flg_arc,
541 flg_sweep,
542 end.x, m_precision,
543 end.y, m_precision,
544 centre_device.x, m_precision,
545 centre_device.y, m_precision );
546 }
547
549 SetCurrentLineWidth( aWidth );
550
553
554 fmt::print( m_outputFile,
555 "<path d=\"M{:.{}f} {:.{}f} A{:.{}f} {:.{}f} 0.0 {:d} {:d} {:.{}f} {:.{}f}\" />\n",
556 start.x, m_precision,
557 start.y, m_precision,
558 radius_device, m_precision,
559 radius_device, m_precision,
560 flg_arc,
561 flg_sweep,
562 end.x, m_precision,
563 end.y, m_precision );
564}
565
566
567void SVG_PLOTTER::BezierCurve( const VECTOR2I& aStart, const VECTOR2I& aControl1,
568 const VECTOR2I& aControl2, const VECTOR2I& aEnd,
569 int aTolerance, int aLineThickness )
570{
571#if 1
573 SetCurrentLineWidth( aLineThickness );
574
577
578 VECTOR2D start = userToDeviceCoordinates( aStart );
579 VECTOR2D ctrl1 = userToDeviceCoordinates( aControl1 );
580 VECTOR2D ctrl2 = userToDeviceCoordinates( aControl2 );
582
583 // Generate a cubic curve: start point and 3 other control points.
584 fmt::print( m_outputFile,
585 "<path d=\"M{:.{}f},{:.{}f} C{:.{}f},{:.{}f} {:.{}f},{:.{}f} {:.{}f},{:.{}f}\" />\n",
586 start.x, m_precision,
587 start.y, m_precision,
588 ctrl1.x,m_precision,
589 ctrl1.y, m_precision,
590 ctrl2.x, m_precision,
591 ctrl2.y, m_precision,
592 end.x, m_precision,
593 end.y, m_precision );
594#else
595 PLOTTER::BezierCurve( aStart, aControl1, aControl2, aEnd, aTolerance, aLineThickness );
596#endif
597}
598
599
600void SVG_PLOTTER::PlotPoly( const std::vector<VECTOR2I>& aCornerList, FILL_T aFill,
601 int aWidth, void* aData )
602{
603 if( aCornerList.size() <= 1 )
604 return;
605
606 setFillMode( aFill );
607 SetCurrentLineWidth( aWidth );
608 fmt::print( m_outputFile, "<path " );
609
610 switch( aFill )
611 {
612 case FILL_T::NO_FILL:
613 case FILL_T::HATCH:
616 setSVGPlotStyle( aWidth, false, "fill:none" );
617 break;
618
622 setSVGPlotStyle( aWidth, false, "fill-rule:evenodd;" );
623 break;
624 }
625
626 VECTOR2D pos = userToDeviceCoordinates( aCornerList[0] );
627 fmt::print( m_outputFile, "d=\"M {:.{}f},{:.{}f}\n", pos.x, m_precision, pos.y, m_precision );
628
629 for( unsigned ii = 1; ii < aCornerList.size() - 1; ii++ )
630 {
631 pos = userToDeviceCoordinates( aCornerList[ii] );
632 fmt::print( m_outputFile, "{:.{}f},{:.{}f}\n", pos.x, m_precision, pos.y, m_precision );
633 }
634
635 // If the corner list ends where it begins, then close the poly
636 if( aCornerList.front() == aCornerList.back() )
637 {
638 fmt::print( m_outputFile, "Z\" /> \n" );
639 }
640 else
641 {
642 pos = userToDeviceCoordinates( aCornerList.back() );
643 fmt::print( m_outputFile,
644 "{:.{}f},{:.{}f}\n\" /> \n",
645 pos.x, m_precision,
646 pos.y, m_precision );
647 }
648}
649
650
651void SVG_PLOTTER::PlotImage( const wxImage& aImage, const VECTOR2I& aPos, double aScaleFactor )
652{
653 VECTOR2I pix_size( aImage.GetWidth(), aImage.GetHeight() );
654
655 // Requested size (in IUs)
656 VECTOR2D drawsize( aScaleFactor * pix_size.x, aScaleFactor * pix_size.y );
657
658 // calculate the bitmap start position
659 VECTOR2I start( aPos.x - drawsize.x / 2, aPos.y - drawsize.y / 2 );
660
661 // Rectangles having a 0 size value for height or width are just not drawn on Inkscape,
662 // so use a line when happens.
663 if( drawsize.x == 0.0 || drawsize.y == 0.0 ) // Draw a line
664 {
665 PLOTTER::PlotImage( aImage, aPos, aScaleFactor );
666 }
667 else
668 {
669 wxMemoryOutputStream img_stream;
670
671 if( m_colorMode )
672 {
673 aImage.SaveFile( img_stream, wxBITMAP_TYPE_PNG );
674 }
675 else // Plot in B&W
676 {
677 wxImage image = aImage.ConvertToGreyscale();
678 image.SaveFile( img_stream, wxBITMAP_TYPE_PNG );
679 }
680
681 size_t input_len = img_stream.GetOutputStreamBuffer()->GetBufferSize();
682 std::vector<uint8_t> buffer( input_len );
683 std::vector<uint8_t> encoded;
684
685 img_stream.CopyTo( buffer.data(), buffer.size() );
686 base64::encode( buffer, encoded );
687
688 fmt::print( m_outputFile,
689 "<image x=\"{:f}\" y=\"{:f}\" xlink:href=\"data:image/png;base64,",
690 userToDeviceSize( start.x ),
691 userToDeviceSize( start.y ) );
692
693 for( size_t i = 0; i < encoded.size(); i++ )
694 {
695 fmt::print( m_outputFile, "{}", static_cast<char>( encoded[i] ) );
696
697 if( ( i % 64 ) == 63 )
698 fmt::print( m_outputFile, "\n" );
699 }
700
701 fmt::print( m_outputFile,
702 "\"\npreserveAspectRatio=\"none\" width=\"{:.{}f}\" height=\"{:.{}f}\" />",
703 userToDeviceSize( drawsize.x ), m_precision,
704 userToDeviceSize( drawsize.y ), m_precision );
705 }
706}
707
708
709void SVG_PLOTTER::PenTo( const VECTOR2I& pos, char plume )
710{
711 if( plume == 'Z' )
712 {
713 if( m_penState != 'Z' )
714 {
715 fmt::print( m_outputFile, "\" />\n" );
716 m_penState = 'Z';
717 m_penLastpos.x = -1;
718 m_penLastpos.y = -1;
719 }
720
721 return;
722 }
723
724 if( m_penState == 'Z' ) // here plume = 'D' or 'U'
725 {
726 VECTOR2D pos_dev = userToDeviceCoordinates( pos );
727
728 // Ensure we do not use a fill mode when moving the pen,
729 // in SVG mode (i;e. we are plotting only basic lines, not a filled area
732
735
736 fmt::print( m_outputFile, "<path d=\"M{:.{}f} {:.{}f}\n",
737 pos_dev.x, m_precision,
738 pos_dev.y, m_precision );
739 }
740 else if( m_penState != plume || pos != m_penLastpos )
741 {
744
745 VECTOR2D pos_dev = userToDeviceCoordinates( pos );
746
747 fmt::print( m_outputFile, "L{:.{}f} {:.{}f}\n",
748 pos_dev.x, m_precision,
749 pos_dev.y, m_precision );
750 }
751
752 m_penState = plume;
753 m_penLastpos = pos;
754}
755
756
757bool SVG_PLOTTER::StartPlot( const wxString& aPageNumber )
758{
759 wxASSERT( m_outputFile );
760
761 std::string header = "<?xml version=\"1.0\" standalone=\"no\"?>\n"
762 " <!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \n"
763 " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\"> \n"
764 "<svg\n"
765 " xmlns:svg=\"http://www.w3.org/2000/svg\"\n"
766 " xmlns=\"http://www.w3.org/2000/svg\"\n"
767 " xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n"
768 " version=\"1.1\"\n";
769
770 // Write header.
771 fmt::print( m_outputFile, "{}", header );
772
773 // Write viewport pos and size
774 VECTOR2D origin; // TODO set to actual value
775 fmt::print( m_outputFile,
776 " width=\"{:.{}f}mm\" height=\"{:.{}f}mm\" viewBox=\"{:.{}f} {:.{}f} {:.{}f} {:.{}f}\">\n",
777 (double) m_paperSize.x / m_IUsPerDecimil * 2.54 / 1000, m_precision,
778 (double) m_paperSize.y / m_IUsPerDecimil * 2.54 / 1000, m_precision,
779 origin.x, m_precision, origin.y, m_precision,
782
783 // Write title
784 wxString date = GetISO8601CurrentDateTime();
785
786 fmt::print( m_outputFile,
787 "<title>SVG Image created as {} date {} </title>\n",
788 TO_UTF8( XmlEsc( wxFileName( m_filename ).GetFullName() ) ),
789 TO_UTF8( date ) );
790
791 // End of header
792 fmt::print( m_outputFile, " <desc>Image generated by {} </desc>\n",
793 TO_UTF8( XmlEsc( m_creator ) ) );
794
795 // output the pen and brush color (RVB values in hex) and opacity
796 double opacity = 1.0; // 0.0 (transparent to 1.0 (solid)
797 fmt::print( m_outputFile,
798 "<g style=\"fill:#{:06X}; fill-opacity:{:.{}f};stroke:#{:06X}; stroke-opacity:{:.{}f};\n",
803 opacity,
804 m_precision );
805
806 // output the pen cap and line joint
807 fmt::print( m_outputFile, "stroke-linecap:round; stroke-linejoin:round;\"\n" );
808 fmt::print( m_outputFile, " transform=\"translate(0 0) scale(1 1)\">\n" );
809 return true;
810}
811
812
814{
815 fmt::print( m_outputFile, "</g> \n</svg>\n" );
816 fclose( m_outputFile );
817 m_outputFile = nullptr;
818
819 return true;
820}
821
822
823void SVG_PLOTTER::Text( const VECTOR2I& aPos,
824 const COLOR4D& aColor,
825 const wxString& aText,
826 const EDA_ANGLE& aOrient,
827 const VECTOR2I& aSize,
828 enum GR_TEXT_H_ALIGN_T aH_justify,
829 enum GR_TEXT_V_ALIGN_T aV_justify,
830 int aWidth,
831 bool aItalic,
832 bool aBold,
833 bool aMultilineAllowed,
834 KIFONT::FONT* aFont,
835 const KIFONT::METRICS& aFontMetrics,
836 void* aData )
837{
839 SetColor( aColor );
840 SetCurrentLineWidth( aWidth );
841
844
845 VECTOR2I text_pos = aPos;
846 const char* hjust = "start";
847
848 switch( aH_justify )
849 {
850 case GR_TEXT_H_ALIGN_CENTER: hjust = "middle"; break;
851 case GR_TEXT_H_ALIGN_RIGHT: hjust = "end"; break;
852 case GR_TEXT_H_ALIGN_LEFT: hjust = "start"; break;
854 wxFAIL_MSG( wxT( "Indeterminate state legal only in dialogs." ) );
855 break;
856 }
857
858 switch( aV_justify )
859 {
860 case GR_TEXT_V_ALIGN_CENTER: text_pos.y += aSize.y / 2; break;
861 case GR_TEXT_V_ALIGN_TOP: text_pos.y += aSize.y; break;
862 case GR_TEXT_V_ALIGN_BOTTOM: break;
864 wxFAIL_MSG( wxT( "Indeterminate state legal only in dialogs." ) );
865 break;
866 }
867
868 VECTOR2I text_size;
869
870 // aSize.x or aSize.y is < 0 for mirrored texts.
871 // The actual text size value is the absolute value
872 text_size.x = std::abs( GRTextWidth( aText, aFont, aSize, GetCurrentLineWidth(), aBold, aItalic,
873 aFontMetrics ) );
874 text_size.y = std::abs( aSize.x * 4/3 ); // Hershey font height to em size conversion
875 VECTOR2D anchor_pos_dev = userToDeviceCoordinates( aPos );
876 VECTOR2D text_pos_dev = userToDeviceCoordinates( text_pos );
877 VECTOR2D sz_dev = userToDeviceSize( text_size );
878
879 // Output the text as a hidden string (opacity = 0). This allows WYSIWYG search to highlight
880 // a selection in approximately the right area. It also makes it easier for those that need
881 // to edit the text (as text) in subsequent processes.
882 {
883 if( !aOrient.IsZero() )
884 {
885 fmt::print( m_outputFile,
886 "<g transform=\"rotate({:f} {:.{}f} {:.{}f})\">\n",
887 m_plotMirror ? aOrient.AsDegrees() : -aOrient.AsDegrees(),
888 anchor_pos_dev.x,
890 anchor_pos_dev.y,
891 m_precision );
892 }
893
894 fmt::print( m_outputFile,
895 "<text x=\"{:.{}f}\" y=\"{:.{}f}\"\n",
896 text_pos_dev.x, m_precision,
897 text_pos_dev.y, m_precision );
898
900 if( m_plotMirror != ( aSize.x < 0 ) )
901 {
902 fmt::print( m_outputFile, "transform=\"scale(-1 1) translate({:f} 0)\"\n",
903 -2 * text_pos_dev.x );
904 }
905
906 fmt::print( m_outputFile,
907 "textLength=\"{:.{}f}\" font-size=\"{:.{}f}\" lengthAdjust=\"spacingAndGlyphs\"\n"
908 "text-anchor=\"{}\" opacity=\"0\" stroke-opacity=\"0\">{}</text>\n",
909 sz_dev.x,
911 sz_dev.y,
913 hjust,
914 TO_UTF8( XmlEsc( aText ) ) );
915
916 if( !aOrient.IsZero() )
917 fmt::print( m_outputFile, "</g>\n" );
918 }
919
920 // Output the text again as graphics with a <desc> tag (for non-WYSIWYG search and for
921 // screen readers)
922 {
923 fmt::print( m_outputFile,
924 "<g class=\"stroked-text\"><desc>{}</desc>\n",
925 TO_UTF8( XmlEsc( aText ) ) );
926
927 PLOTTER::Text( aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, GetCurrentLineWidth(),
928 aItalic, aBold, aMultilineAllowed, aFont, aFontMetrics );
929
930 fmt::print( m_outputFile, "</g>" );
931 }
932}
933
934
936 const COLOR4D& aColor,
937 const wxString& aText,
938 const TEXT_ATTRIBUTES& aAttributes,
939 KIFONT::FONT* aFont,
940 const KIFONT::METRICS& aFontMetrics,
941 void* aData )
942{
943 VECTOR2I size = aAttributes.m_Size;
944
945 if( aAttributes.m_Mirrored )
946 size.x = -size.x;
947
948 SVG_PLOTTER::Text( aPos, aColor, aText, aAttributes.m_Angle, size, aAttributes.m_Halign,
949 aAttributes.m_Valign, aAttributes.m_StrokeWidth, aAttributes.m_Italic,
950 aAttributes.m_Bold, aAttributes.m_Multiline, aFont, aFontMetrics, aData );
951}
static wxString XmlEsc(const wxString &aStr, bool isAttribute=false)
Translates '<' to "<", '>' to ">" and so on, according to the spec: http://www.w3....
BOX2< VECTOR2I > BOX2I
Definition box2.h:922
BOX2< VECTOR2D > BOX2D
Definition box2.h:923
constexpr const Vec & GetPosition() const
Definition box2.h:211
constexpr const Vec GetEnd() const
Definition box2.h:212
constexpr BOX2< Vec > & Normalize()
Ensure that the height and width are positive.
Definition box2.h:146
constexpr const Vec & GetOrigin() const
Definition box2.h:210
constexpr const SizeVec & GetSize() const
Definition box2.h:206
double AsDegrees() const
Definition eda_angle.h:116
bool IsZero() const
Definition eda_angle.h:136
double AsRadians() const
Definition eda_angle.h:120
FONT is an abstract base class for both outline and stroke fonts.
Definition font.h:131
A color representation with 4 components: red, green, blue, alpha.
Definition color4d.h:104
double GetDotMarkLenIU(int aLineWidth) const
Definition plotter.cpp:133
virtual void PlotImage(const wxImage &aImage, const VECTOR2I &aPos, double aScaleFactor)
Only PostScript plotters can plot bitmaps.
Definition plotter.cpp:259
double GetDashGapLenIU(int aLineWidth) const
Definition plotter.cpp:145
bool m_mirrorIsHorizontal
Definition plotter.h:657
PAGE_INFO m_pageInfo
Definition plotter.h:675
bool m_plotMirror
Definition plotter.h:655
static const int USE_DEFAULT_LINE_WIDTH
Definition plotter.h:125
bool m_yaxisReversed
Definition plotter.h:658
double m_iuPerDeviceUnit
Definition plotter.h:652
VECTOR2I m_plotOffset
Definition plotter.h:654
VECTOR2I m_penLastpos
Definition plotter.h:668
virtual VECTOR2D userToDeviceCoordinates(const VECTOR2I &aCoordinate)
Modify coordinates according to the orientation, scale factor, and offsets trace.
Definition plotter.cpp:92
VECTOR2I m_paperSize
Definition plotter.h:676
virtual VECTOR2D userToDeviceSize(const VECTOR2I &size)
Modify size according to the plotter scale factors (VECTOR2I version, returns a VECTOR2D).
Definition plotter.cpp:117
char m_penState
Definition plotter.h:667
virtual void BezierCurve(const VECTOR2I &aStart, const VECTOR2I &aControl1, const VECTOR2I &aControl2, const VECTOR2I &aEnd, int aTolerance, int aLineThickness)
Generic fallback: Cubic Bezier curve rendered as a polyline.
Definition plotter.cpp:231
wxString m_creator
Definition plotter.h:670
int m_currentPenWidth
Definition plotter.h:666
double m_plotScale
Plot scale - chosen by the user (even implicitly with 'fit in a4')
Definition plotter.h:644
FILE * m_outputFile
Output file.
Definition plotter.h:661
static const int DO_NOT_SET_LINE_WIDTH
Definition plotter.h:124
RENDER_SETTINGS * m_renderSettings
Definition plotter.h:680
virtual void Text(const VECTOR2I &aPos, const COLOR4D &aColor, const wxString &aText, const EDA_ANGLE &aOrient, const VECTOR2I &aSize, enum GR_TEXT_H_ALIGN_T aH_justify, enum GR_TEXT_V_ALIGN_T aV_justify, int aPenWidth, bool aItalic, bool aBold, bool aMultilineAllowed, KIFONT::FONT *aFont, const KIFONT::METRICS &aFontMetrics, void *aData=nullptr)
Draw text with the plotter.
Definition plotter.cpp:625
double m_IUsPerDecimil
Definition plotter.h:650
virtual int GetCurrentLineWidth() const
Definition plotter.h:167
bool m_colorMode
Definition plotter.h:664
double GetDashMarkLenIU(int aLineWidth) const
Definition plotter.cpp:139
wxString m_filename
Definition plotter.h:671
Container for project specific data.
Definition project.h:65
virtual void SetColor(const COLOR4D &color) override
The SetColor implementation is split with the subclasses: the PSLIKE computes the rgb values,...
PSLIKE_PLOTTER(const PROJECT *aProject=nullptr)
virtual void SetTextMode(PLOT_TEXT_MODE mode) override
PS and PDF fully implement native text (for the Latin-1 subset)
virtual void emitSetRGBColor(double r, double g, double b, double a) override
Initialize m_pen_rgb_color from reduced values r, g ,b ( reduced values are 0.0 to 1....
virtual void PlotImage(const wxImage &aImage, const VECTOR2I &aPos, double aScaleFactor) override
PostScript-likes at the moment are the only plot engines supporting bitmaps.
unsigned m_precision
virtual bool StartPlot(const wxString &aPageNumber) override
Create SVG file header.
virtual void EndBlock(void *aData) override
Calling this function allows one to define the end of a group of drawing items the group is started b...
virtual void SetViewport(const VECTOR2I &aOffset, double aIusPerDecimil, double aScale, bool aMirror) override
Set the plot offset and scaling for the current plot.
LINE_STYLE m_dashed
SVG_PLOTTER(const PROJECT *aProject=nullptr)
virtual void Text(const VECTOR2I &aPos, const COLOR4D &aColor, const wxString &aText, const EDA_ANGLE &aOrient, const VECTOR2I &aSize, enum GR_TEXT_H_ALIGN_T aH_justify, enum GR_TEXT_V_ALIGN_T aV_justify, int aWidth, bool aItalic, bool aBold, bool aMultilineAllowed, KIFONT::FONT *aFont, const KIFONT::METRICS &aFontMetrics, void *aData=nullptr) override
Draw text with the plotter.
uint32_t m_brush_rgb_color
virtual void Rect(const VECTOR2I &p1, const VECTOR2I &p2, FILL_T fill, int width, int aCornerRadius=0) override
virtual void SetSvgCoordinatesFormat(unsigned aPrecision) override
Select SVG coordinate precision (number of digits needed for 1 mm ) (SVG plotter uses always metric u...
virtual bool EndPlot() override
void setSVGPlotStyle(int aLineWidth, bool aIsGroup=true, const std::string &aExtraStyle={})
Output the string which define pen and brush color, shape, transparency.
virtual void Circle(const VECTOR2I &pos, int diametre, FILL_T fill, int width) override
virtual void PlotPoly(const std::vector< VECTOR2I > &aCornerList, FILL_T aFill, int aWidth, void *aData) override
Draw a polygon ( filled or not ).
virtual void PlotText(const VECTOR2I &aPos, const COLOR4D &aColor, const wxString &aText, const TEXT_ATTRIBUTES &aAttributes, KIFONT::FONT *aFont, const KIFONT::METRICS &aFontMetrics, void *aData=nullptr) override
virtual void BezierCurve(const VECTOR2I &aStart, const VECTOR2I &aControl1, const VECTOR2I &aControl2, const VECTOR2I &aEnd, int aTolerance, int aLineThickness) override
Generic fallback: Cubic Bezier curve rendered as a polyline.
virtual void Arc(const VECTOR2D &aCenter, const EDA_ANGLE &aStartAngle, const EDA_ANGLE &aAngle, double aRadius, FILL_T aFill, int aWidth) override
virtual void PenTo(const VECTOR2I &pos, char plume) override
Moveto/lineto primitive, moves the 'pen' to the specified direction.
uint32_t m_pen_rgb_color
virtual void SetDash(int aLineWidth, LINE_STYLE aLineStyle) override
SVG supports dashed lines.
virtual void StartBlock(void *aData) override
Calling this function allows one to define the beginning of a group of drawing items (used in SVG for...
void setFillMode(FILL_T fill)
Prepare parameters for setSVGPlotStyle()
virtual void SetCurrentLineWidth(int width, void *aData=nullptr) override
Set the current line width (in IUs) for the next plot.
GR_TEXT_H_ALIGN_T m_Halign
GR_TEXT_V_ALIGN_T m_Valign
static constexpr EDA_ANGLE ANGLE_180
Definition eda_angle.h:415
FILL_T
Definition eda_shape.h:56
@ FILLED_WITH_COLOR
Definition eda_shape.h:60
@ NO_FILL
Definition eda_shape.h:57
@ REVERSE_HATCH
Definition eda_shape.h:62
@ HATCH
Definition eda_shape.h:61
@ FILLED_WITH_BG_BODYCOLOR
Definition eda_shape.h:59
@ FILLED_SHAPE
Fill with object color.
Definition eda_shape.h:58
@ CROSS_HATCH
Definition eda_shape.h:63
int GRTextWidth(const wxString &aText, KIFONT::FONT *aFont, const VECTOR2I &aSize, int aThickness, bool aBold, bool aItalic, const KIFONT::METRICS &aFontMetrics)
Definition gr_text.cpp:99
This file contains miscellaneous commonly used macros and functions.
void encode(const std::vector< uint8_t > &aInput, std::vector< uint8_t > &aOutput)
Definition base64.cpp:76
EDA_ANGLE abs(const EDA_ANGLE &aAngle)
Definition eda_angle.h:400
Plotting engines similar to ps (PostScript, Gerber, svg)
wxString GetISO8601CurrentDateTime()
#define TO_UTF8(wxstring)
Convert a wxString to a UTF8 encoded C string for all wxWidgets build modes.
LINE_STYLE
Dashed line types.
int radius
VECTOR2I end
GR_TEXT_H_ALIGN_T
This is API surface mapped to common.types.HorizontalAlignment.
@ GR_TEXT_H_ALIGN_CENTER
@ GR_TEXT_H_ALIGN_RIGHT
@ GR_TEXT_H_ALIGN_LEFT
@ GR_TEXT_H_ALIGN_INDETERMINATE
GR_TEXT_V_ALIGN_T
This is API surface mapped to common.types.VertialAlignment.
@ GR_TEXT_V_ALIGN_BOTTOM
@ GR_TEXT_V_ALIGN_INDETERMINATE
@ GR_TEXT_V_ALIGN_CENTER
@ GR_TEXT_V_ALIGN_TOP
#define M_PI
void RotatePoint(int *pX, int *pY, const EDA_ANGLE &aAngle)
Calculate the new point of coord coord pX, pY, for a rotation center 0, 0.
Definition trigo.cpp:229
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:695
VECTOR2< double > VECTOR2D
Definition vector2d.h:694