QGIS API Documentation 3.29.0-Master (006c3c0232)
qgssymbol.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgssymbol.cpp
3 ---------------------
4 begin : November 2009
5 copyright : (C) 2009 by Martin Dobias
6 email : wonder dot sk at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
16#include <QColor>
17#include <QImage>
18#include <QPainter>
19#include <QSize>
20#include <QSvgGenerator>
21
22#include <cmath>
23#include <map>
24#include <random>
25
26#include "qgssymbol.h"
27#include "qgssymbollayer.h"
28
31#include "qgslogger.h"
32#include "qgsrendercontext.h" // for bigSymbolPreview
33#include "qgsproject.h"
35#include "qgsstyle.h"
36#include "qgspainteffect.h"
37#include "qgsvectorlayer.h"
38#include "qgsfeature.h"
39#include "qgsgeometry.h"
40#include "qgsmultipoint.h"
42#include "qgslinestring.h"
43#include "qgspolygon.h"
44#include "qgsclipper.h"
45#include "qgsproperty.h"
47#include "qgsapplication.h"
50#include "qgslegendpatchshape.h"
51#include "qgsgeos.h"
52#include "qgsmarkersymbol.h"
53#include "qgslinesymbol.h"
54#include "qgsfillsymbol.h"
55
56QgsPropertiesDefinition QgsSymbol::sPropertyDefinitions;
57
58Q_NOWARN_DEPRECATED_PUSH // because of deprecated mLayer
60 : mType( type )
61 , mLayers( layers )
62{
63
64 // check they're all correct symbol layers
65 for ( int i = 0; i < mLayers.count(); i++ )
66 {
67 if ( !mLayers.at( i ) )
68 {
69 mLayers.removeAt( i-- );
70 }
71 else if ( !mLayers.at( i )->isCompatibleWithSymbol( this ) )
72 {
73 delete mLayers.at( i );
74 mLayers.removeAt( i-- );
75 }
76 }
77}
79
80QPolygonF QgsSymbol::_getLineString( QgsRenderContext &context, const QgsCurve &curve, bool clipToExtent )
81{
82 if ( curve.is3D() )
83 return _getLineString3d( context, curve, clipToExtent );
84 else
85 return _getLineString2d( context, curve, clipToExtent );
86}
87
88QPolygonF QgsSymbol::_getLineString3d( QgsRenderContext &context, const QgsCurve &curve, bool clipToExtent )
89{
90 const unsigned int nPoints = curve.numPoints();
91
93 const QgsMapToPixel &mtp = context.mapToPixel();
94 QVector< double > pointsX;
95 QVector< double > pointsY;
96 QVector< double > pointsZ;
97
98 // apply clipping for large lines to achieve a better rendering performance
99 if ( clipToExtent && nPoints > 1 && !( context.flags() & Qgis::RenderContextFlag::ApplyClipAfterReprojection ) )
100 {
101 const QgsRectangle e = context.extent();
102 const double cw = e.width() / 10;
103 const double ch = e.height() / 10;
104 const QgsBox3d clipRect( e.xMinimum() - cw, e.yMinimum() - ch, -HUGE_VAL, e.xMaximum() + cw, e.yMaximum() + ch, HUGE_VAL ); // TODO also need to be clipped according to z axis
105
106 const QgsLineString *lineString = nullptr;
107 if ( const QgsLineString *ls = qgsgeometry_cast< const QgsLineString * >( &curve ) )
108 {
109 lineString = ls;
110 }
111 else
112 {
113 std::unique_ptr< QgsLineString > segmentized;
114 segmentized.reset( qgsgeometry_cast< QgsLineString * >( curve.segmentize( ) ) );
115 lineString = segmentized.get();
116 }
117
118 QgsClipper::clipped3dLine( lineString->xVector(), lineString->yVector(), lineString->zVector(), pointsX, pointsY, pointsZ, clipRect );
119 }
120 else
121 {
122 // clone...
123 if ( const QgsLineString *ls = qgsgeometry_cast<const QgsLineString *>( &curve ) )
124 {
125 pointsX = ls->xVector();
126 pointsY = ls->yVector();
127 pointsZ = ls->zVector();
128 }
129 else
130 {
131 std::unique_ptr< QgsLineString > segmentized;
132 segmentized.reset( qgsgeometry_cast< QgsLineString * >( curve.segmentize( ) ) );
133
134 pointsX = segmentized->xVector();
135 pointsY = segmentized->yVector();
136 pointsZ = segmentized->zVector();
137 }
138 }
139
140 // transform the points to screen coordinates
141 const QVector< double > preTransformPointsZ = pointsZ;
142 bool wasTransformed = false;
143 if ( ct.isValid() )
144 {
145 //create x, y arrays
146 const int nVertices = pointsX.size();
147 wasTransformed = true;
148
149 try
150 {
151 ct.transformCoords( nVertices, pointsX.data(), pointsY.data(), pointsZ.data(), Qgis::TransformDirection::Forward );
152 }
153 catch ( QgsCsException & )
154 {
155 // we don't abort the rendering here, instead we remove any invalid points and just plot those which ARE valid
156 }
157 }
158
159 // remove non-finite points, e.g. infinite or NaN points caused by reprojecting errors
160 {
161 const int size = pointsX.size();
162
163 const double *xIn = pointsX.data();
164 const double *yIn = pointsY.data();
165 const double *zIn = pointsZ.data();
166
167 const double *preTransformZIn = wasTransformed ? preTransformPointsZ.constData() : nullptr;
168
169 double *xOut = pointsX.data();
170 double *yOut = pointsY.data();
171 double *zOut = pointsZ.data();
172 int outSize = 0;
173 for ( int i = 0; i < size; ++i )
174 {
175 bool pointOk = std::isfinite( *xIn ) && std::isfinite( *yIn );
176
177 // skip z points which have been made non-finite during transformations only. Ie if:
178 // - we did no transformation, then always render even if non-finite z
179 // - we did transformation and z is finite then render
180 // - we did transformation and z is non-finite BUT input z was also non finite then render
181 // - we did transformation and z is non-finite AND input z WAS finite then skip
182 pointOk &= !wasTransformed || std::isfinite( *zIn ) || !std::isfinite( *preTransformZIn );
183
184 if ( pointOk )
185 {
186 *xOut++ = *xIn++;
187 *yOut++ = *yIn++;
188 *zOut++ = *zIn++;
189 outSize++;
190 }
191 else
192 {
193 xIn++;
194 yIn++;
195 zIn++;
196 }
197
198 if ( preTransformZIn )
199 preTransformZIn++;
200 }
201 pointsX.resize( outSize );
202 pointsY.resize( outSize );
203 pointsZ.resize( outSize );
204 }
205
206 if ( clipToExtent && nPoints > 1 && context.flags() & Qgis::RenderContextFlag::ApplyClipAfterReprojection )
207 {
208 // early clipping was not possible, so we have to apply it here after transformation
209 const QgsRectangle e = context.mapExtent();
210 const double cw = e.width() / 10;
211 const double ch = e.height() / 10;
212 const QgsBox3d clipRect( e.xMinimum() - cw, e.yMinimum() - ch, -HUGE_VAL, e.xMaximum() + cw, e.yMaximum() + ch, HUGE_VAL ); // TODO also need to be clipped according to z axis
213
214 QVector< double > tempX;
215 QVector< double > tempY;
216 QVector< double > tempZ;
217 QgsClipper::clipped3dLine( pointsX, pointsY, pointsZ, tempX, tempY, tempZ, clipRect );
218 pointsX = tempX;
219 pointsY = tempY;
220 pointsZ = tempZ;
221 }
222
223 const int polygonSize = pointsX.size();
224 QPolygonF out( polygonSize );
225 const double *x = pointsX.constData();
226 const double *y = pointsY.constData();
227 QPointF *dest = out.data();
228 for ( int i = 0; i < polygonSize; ++i )
229 {
230 double screenX = *x++;
231 double screenY = *y++;
232 mtp.transformInPlace( screenX, screenY );
233 *dest++ = QPointF( screenX, screenY );
234 }
235
236 return out;
237}
238
239QPolygonF QgsSymbol::_getLineString2d( QgsRenderContext &context, const QgsCurve &curve, bool clipToExtent )
240{
241 const unsigned int nPoints = curve.numPoints();
242
244 const QgsMapToPixel &mtp = context.mapToPixel();
245 QPolygonF pts;
246
247 // apply clipping for large lines to achieve a better rendering performance
248 if ( clipToExtent && nPoints > 1 && !( context.flags() & Qgis::RenderContextFlag::ApplyClipAfterReprojection ) )
249 {
250 const QgsRectangle e = context.extent();
251 const double cw = e.width() / 10;
252 const double ch = e.height() / 10;
253 const QgsRectangle clipRect( e.xMinimum() - cw, e.yMinimum() - ch, e.xMaximum() + cw, e.yMaximum() + ch );
254 pts = QgsClipper::clippedLine( curve, clipRect );
255 }
256 else
257 {
258 pts = curve.asQPolygonF();
259 }
260
261 // transform the QPolygonF to screen coordinates
262 if ( ct.isValid() )
263 {
264 try
265 {
266 ct.transformPolygon( pts );
267 }
268 catch ( QgsCsException & )
269 {
270 // we don't abort the rendering here, instead we remove any invalid points and just plot those which ARE valid
271 }
272 }
273
274 // remove non-finite points, e.g. infinite or NaN points caused by reprojecting errors
275 pts.erase( std::remove_if( pts.begin(), pts.end(),
276 []( const QPointF point )
277 {
278 return !std::isfinite( point.x() ) || !std::isfinite( point.y() );
279 } ), pts.end() );
280
281 if ( clipToExtent && nPoints > 1 && context.flags() & Qgis::RenderContextFlag::ApplyClipAfterReprojection )
282 {
283 // early clipping was not possible, so we have to apply it here after transformation
284 const QgsRectangle e = context.mapExtent();
285 const double cw = e.width() / 10;
286 const double ch = e.height() / 10;
287 const QgsRectangle clipRect( e.xMinimum() - cw, e.yMinimum() - ch, e.xMaximum() + cw, e.yMaximum() + ch );
288 pts = QgsClipper::clippedLine( pts, clipRect );
289 }
290
291 QPointF *ptr = pts.data();
292 for ( int i = 0; i < pts.size(); ++i, ++ptr )
293 {
294 mtp.transformInPlace( ptr->rx(), ptr->ry() );
295 }
296
297 return pts;
298}
299
300
301QPolygonF QgsSymbol::_getPolygonRing( QgsRenderContext &context, const QgsCurve &curve, const bool clipToExtent, const bool isExteriorRing, const bool correctRingOrientation )
302{
303 if ( curve.is3D() )
304 return _getPolygonRing3d( context, curve, clipToExtent, isExteriorRing, correctRingOrientation );
305 else
306 return _getPolygonRing2d( context, curve, clipToExtent, isExteriorRing, correctRingOrientation );
307}
308
309QPolygonF QgsSymbol::_getPolygonRing3d( QgsRenderContext &context, const QgsCurve &curve, const bool clipToExtent, const bool isExteriorRing, const bool correctRingOrientation )
310{
311 const QgsCoordinateTransform ct = context.coordinateTransform();
312 const QgsMapToPixel &mtp = context.mapToPixel();
313
314 QVector< double > pointsX;
315 QVector< double > pointsY;
316 QVector< double > pointsZ;
317
318 if ( curve.numPoints() < 1 )
319 return QPolygonF();
320
321 bool reverseRing = false;
322 if ( correctRingOrientation )
323 {
324 // ensure consistent polygon ring orientation
325 if ( ( isExteriorRing && curve.orientation() != Qgis::AngularDirection::Clockwise ) || ( !isExteriorRing && curve.orientation() != Qgis::AngularDirection::CounterClockwise ) )
326 {
327 reverseRing = true;
328 }
329 }
330
331 //clip close to view extent, if needed
332 if ( clipToExtent && !( context.flags() & Qgis::RenderContextFlag::ApplyClipAfterReprojection ) && !context.extent().contains( curve.boundingBox() ) )
333 {
334 const QgsRectangle e = context.extent();
335 const double cw = e.width() / 10;
336 const double ch = e.height() / 10;
337 const QgsBox3d clipRect( e.xMinimum() - cw, e.yMinimum() - ch, -HUGE_VAL, e.xMaximum() + cw, e.yMaximum() + ch, HUGE_VAL ); // TODO also need to be clipped according to z axis
338
339 const QgsLineString *lineString = nullptr;
340 std::unique_ptr< QgsLineString > segmentized;
341 if ( const QgsLineString *ls = qgsgeometry_cast< const QgsLineString * >( &curve ) )
342 {
343 lineString = ls;
344 }
345 else
346 {
347 segmentized.reset( qgsgeometry_cast< QgsLineString * >( curve.segmentize( ) ) );
348 lineString = segmentized.get();
349 }
350
351 pointsX = lineString->xVector();
352 pointsY = lineString->yVector();
353 pointsZ = lineString->zVector();
354
355 QgsClipper::trimPolygon( pointsX, pointsY, pointsZ, clipRect );
356 }
357 else
358 {
359 // clone...
360 if ( const QgsLineString *ls = qgsgeometry_cast<const QgsLineString *>( &curve ) )
361 {
362 pointsX = ls->xVector();
363 pointsY = ls->yVector();
364 pointsZ = ls->zVector();
365 }
366 else
367 {
368 std::unique_ptr< QgsLineString > segmentized;
369 segmentized.reset( qgsgeometry_cast< QgsLineString * >( curve.segmentize( ) ) );
370
371 pointsX = segmentized->xVector();
372 pointsY = segmentized->yVector();
373 pointsZ = segmentized->zVector();
374 }
375 }
376
377 if ( reverseRing )
378 {
379 std::reverse( pointsX.begin(), pointsX.end() );
380 std::reverse( pointsY.begin(), pointsY.end() );
381 std::reverse( pointsZ.begin(), pointsZ.end() );
382 }
383
384 //transform the QPolygonF to screen coordinates
385 const QVector< double > preTransformPointsZ = pointsZ;
386 bool wasTransformed = false;
387 if ( ct.isValid() )
388 {
389 const int nVertices = pointsX.size();
390 wasTransformed = true;
391 try
392 {
393 ct.transformCoords( nVertices, pointsX.data(), pointsY.data(), pointsZ.data(), Qgis::TransformDirection::Forward );
394 }
395 catch ( QgsCsException & )
396 {
397 // we don't abort the rendering here, instead we remove any invalid points and just plot those which ARE valid
398 }
399 }
400
401 // remove non-finite points, e.g. infinite or NaN points caused by reprojecting errors
402 {
403 const int size = pointsX.size();
404
405 const double *xIn = pointsX.data();
406 const double *yIn = pointsY.data();
407 const double *zIn = pointsZ.data();
408
409 const double *preTransformZIn = wasTransformed ? preTransformPointsZ.constData() : nullptr;
410
411 double *xOut = pointsX.data();
412 double *yOut = pointsY.data();
413 double *zOut = pointsZ.data();
414 int outSize = 0;
415 for ( int i = 0; i < size; ++i )
416 {
417 bool pointOk = std::isfinite( *xIn ) && std::isfinite( *yIn );
418 // skip z points which have been made non-finite during transformations only. Ie if:
419 // - we did no transformation, then always render even if non-finite z
420 // - we did transformation and z is finite then render
421 // - we did transformation and z is non-finite BUT input z was also non finite then render
422 // - we did transformation and z is non-finite AND input z WAS finite then skip
423 pointOk &= !wasTransformed || std::isfinite( *zIn ) || !std::isfinite( *preTransformZIn );
424
425 if ( pointOk )
426 {
427 *xOut++ = *xIn++;
428 *yOut++ = *yIn++;
429 *zOut++ = *zIn++;
430 outSize++;
431 }
432 else
433 {
434 xIn++;
435 yIn++;
436 zIn++;
437 }
438
439 if ( preTransformZIn )
440 preTransformZIn++;
441 }
442 pointsX.resize( outSize );
443 pointsY.resize( outSize );
444 pointsZ.resize( outSize );
445 }
446
447 if ( clipToExtent && context.flags() & Qgis::RenderContextFlag::ApplyClipAfterReprojection && !context.mapExtent().contains( curve.boundingBox() ) )
448 {
449 // early clipping was not possible, so we have to apply it here after transformation
450 const QgsRectangle e = context.mapExtent();
451 const double cw = e.width() / 10;
452 const double ch = e.height() / 10;
453 const QgsBox3d clipRect( e.xMinimum() - cw, e.yMinimum() - ch, -HUGE_VAL, e.xMaximum() + cw, e.yMaximum() + ch, HUGE_VAL ); // TODO also need to be clipped according to z axis
454
455 QgsClipper::trimPolygon( pointsX, pointsY, pointsZ, clipRect );
456 }
457
458 const int polygonSize = pointsX.size();
459 QPolygonF out( polygonSize );
460 const double *x = pointsX.constData();
461 const double *y = pointsY.constData();
462 QPointF *dest = out.data();
463 for ( int i = 0; i < polygonSize; ++i )
464 {
465 double screenX = *x++;
466 double screenY = *y++;
467 mtp.transformInPlace( screenX, screenY );
468 *dest++ = QPointF( screenX, screenY );
469 }
470
471 if ( !out.empty() && !out.isClosed() )
472 out << out.at( 0 );
473
474 return out;
475}
476
477
478QPolygonF QgsSymbol::_getPolygonRing2d( QgsRenderContext &context, const QgsCurve &curve, const bool clipToExtent, const bool isExteriorRing, const bool correctRingOrientation )
479{
480 const QgsCoordinateTransform ct = context.coordinateTransform();
481 const QgsMapToPixel &mtp = context.mapToPixel();
482
483 QPolygonF poly = curve.asQPolygonF();
484
485 if ( curve.numPoints() < 1 )
486 return QPolygonF();
487
488 if ( correctRingOrientation )
489 {
490 // ensure consistent polygon ring orientation
491 if ( isExteriorRing && curve.orientation() != Qgis::AngularDirection::Clockwise )
492 std::reverse( poly.begin(), poly.end() );
493 else if ( !isExteriorRing && curve.orientation() != Qgis::AngularDirection::CounterClockwise )
494 std::reverse( poly.begin(), poly.end() );
495 }
496
497 //clip close to view extent, if needed
498 if ( clipToExtent && !( context.flags() & Qgis::RenderContextFlag::ApplyClipAfterReprojection ) && !context.extent().contains( poly.boundingRect() ) )
499 {
500 const QgsRectangle e = context.extent();
501 const double cw = e.width() / 10;
502 const double ch = e.height() / 10;
503 const QgsRectangle clipRect( e.xMinimum() - cw, e.yMinimum() - ch, e.xMaximum() + cw, e.yMaximum() + ch );
504 QgsClipper::trimPolygon( poly, clipRect );
505 }
506
507 //transform the QPolygonF to screen coordinates
508 if ( ct.isValid() )
509 {
510 try
511 {
512 ct.transformPolygon( poly );
513 }
514 catch ( QgsCsException & )
515 {
516 // we don't abort the rendering here, instead we remove any invalid points and just plot those which ARE valid
517 }
518 }
519
520 // remove non-finite points, e.g. infinite or NaN points caused by reprojecting errors
521 poly.erase( std::remove_if( poly.begin(), poly.end(),
522 []( const QPointF point )
523 {
524 return !std::isfinite( point.x() ) || !std::isfinite( point.y() );
525 } ), poly.end() );
526
527 if ( clipToExtent && context.flags() & Qgis::RenderContextFlag::ApplyClipAfterReprojection && !context.mapExtent().contains( poly.boundingRect() ) )
528 {
529 // early clipping was not possible, so we have to apply it here after transformation
530 const QgsRectangle e = context.mapExtent();
531 const double cw = e.width() / 10;
532 const double ch = e.height() / 10;
533 const QgsRectangle clipRect( e.xMinimum() - cw, e.yMinimum() - ch, e.xMaximum() + cw, e.yMaximum() + ch );
534 QgsClipper::trimPolygon( poly, clipRect );
535 }
536
537 QPointF *ptr = poly.data();
538 for ( int i = 0; i < poly.size(); ++i, ++ptr )
539 {
540 mtp.transformInPlace( ptr->rx(), ptr->ry() );
541 }
542
543 if ( !poly.empty() && !poly.isClosed() )
544 poly << poly.at( 0 );
545
546 return poly;
547}
548
549void QgsSymbol::_getPolygon( QPolygonF &pts, QVector<QPolygonF> &holes, QgsRenderContext &context, const QgsPolygon &polygon, const bool clipToExtent, const bool correctRingOrientation )
550{
551 holes.clear();
552
553 pts = _getPolygonRing( context, *polygon.exteriorRing(), clipToExtent, true, correctRingOrientation );
554 const int ringCount = polygon.numInteriorRings();
555 holes.reserve( ringCount );
556 for ( int idx = 0; idx < ringCount; idx++ )
557 {
558 const QPolygonF hole = _getPolygonRing( context, *( polygon.interiorRing( idx ) ), clipToExtent, false, correctRingOrientation );
559 if ( !hole.isEmpty() )
560 holes.append( hole );
561 }
562}
563
565{
566 switch ( type )
567 {
569 return QObject::tr( "Marker" );
571 return QObject::tr( "Line" );
573 return QObject::tr( "Fill" );
575 return QObject::tr( "Hybrid" );
576 }
577 return QString();
578}
579
581{
582 switch ( type )
583 {
593 }
595}
596
598{
599 QgsSymbol::initPropertyDefinitions();
600 return sPropertyDefinitions;
601}
602
604{
605 // delete all symbol layers (we own them, so it's okay)
606 qDeleteAll( mLayers );
607}
608
610{
611 if ( mLayers.empty() )
612 {
614 }
615
616 QgsSymbolLayerList::const_iterator it = mLayers.constBegin();
617
618 QgsUnitTypes::RenderUnit unit = ( *it )->outputUnit();
619
620 for ( ; it != mLayers.constEnd(); ++it )
621 {
622 if ( ( *it )->outputUnit() != unit )
623 {
625 }
626 }
627 return unit;
628}
629
631{
632 if ( mLayers.empty() )
633 {
634 return false;
635 }
636
637 for ( const QgsSymbolLayer *layer : mLayers )
638 {
639 if ( layer->usesMapUnits() )
640 {
641 return true;
642 }
643 }
644 return false;
645}
646
648{
649 if ( mLayers.empty() )
650 {
651 return QgsMapUnitScale();
652 }
653
654 QgsSymbolLayerList::const_iterator it = mLayers.constBegin();
655 if ( it == mLayers.constEnd() )
656 return QgsMapUnitScale();
657
658 QgsMapUnitScale scale = ( *it )->mapUnitScale();
659 ++it;
660
661 for ( ; it != mLayers.constEnd(); ++it )
662 {
663 if ( ( *it )->mapUnitScale() != scale )
664 {
665 return QgsMapUnitScale();
666 }
667 }
668 return scale;
669}
670
672{
673 const auto constMLayers = mLayers;
674 for ( QgsSymbolLayer *layer : constMLayers )
675 {
676 layer->setOutputUnit( u );
677 }
678}
679
681{
682 const auto constMLayers = mLayers;
683 for ( QgsSymbolLayer *layer : constMLayers )
684 {
685 layer->setMapUnitScale( scale );
686 }
687}
688
690{
691 return mAnimationSettings;
692}
693
695{
696 return mAnimationSettings;
697}
698
700{
701 mAnimationSettings = settings;
702}
703
705{
706 std::unique_ptr< QgsSymbol > s;
707
708 // override global default if project has a default for this type
709 switch ( geomType )
710 {
712 s.reset( QgsProject::instance()->styleSettings()->defaultSymbol( Qgis::SymbolType::Marker ) );
713 break;
715 s.reset( QgsProject::instance()->styleSettings()->defaultSymbol( Qgis::SymbolType::Line ) );
716 break;
718 s.reset( QgsProject::instance()->styleSettings()->defaultSymbol( Qgis::SymbolType::Fill ) );
719 break;
720 default:
721 break;
722 }
723
724 // if no default found for this type, get global default (as previously)
725 if ( !s )
726 {
727 switch ( geomType )
728 {
730 s = std::make_unique< QgsMarkerSymbol >();
731 break;
733 s = std::make_unique< QgsLineSymbol >();
734 break;
736 s = std::make_unique< QgsFillSymbol >();
737 break;
738 default:
739 QgsDebugMsg( QStringLiteral( "unknown layer's geometry type" ) );
740 return nullptr;
741 }
742 }
743
744 // set opacity
745 s->setOpacity( QgsProject::instance()->styleSettings()->defaultSymbolOpacity() );
746
747 // set random color, it project prefs allow
748 if ( QgsProject::instance()->styleSettings()->randomizeDefaultSymbolColor() )
749 {
750 s->setColor( QgsApplication::colorSchemeRegistry()->fetchRandomStyleColor() );
751 }
752
753 return s.release();
754}
755
757{
758 return mLayers.value( layer );
759}
760
761const QgsSymbolLayer *QgsSymbol::symbolLayer( int layer ) const
762{
763 return mLayers.value( layer );
764}
765
767{
768 if ( index < 0 || index > mLayers.count() ) // can be added also after the last index
769 return false;
770
771 if ( !layer || !layer->isCompatibleWithSymbol( this ) )
772 return false;
773
774 mLayers.insert( index, layer );
775 return true;
776}
777
778
780{
781 if ( !layer || !layer->isCompatibleWithSymbol( this ) )
782 return false;
783
784 mLayers.append( layer );
785 return true;
786}
787
788
790{
791 if ( index < 0 || index >= mLayers.count() )
792 return false;
793
794 delete mLayers.at( index );
795 mLayers.removeAt( index );
796 return true;
797}
798
799
801{
802 if ( index < 0 || index >= mLayers.count() )
803 return nullptr;
804
805 return mLayers.takeAt( index );
806}
807
808
810{
811 QgsSymbolLayer *oldLayer = mLayers.value( index );
812
813 if ( oldLayer == layer )
814 return false;
815
816 if ( !layer || !layer->isCompatibleWithSymbol( this ) )
817 return false;
818
819 delete oldLayer; // first delete the original layer
820 mLayers[index] = layer; // set new layer
821 return true;
822}
823
824
825void QgsSymbol::startRender( QgsRenderContext &context, const QgsFields &fields )
826{
827 Q_ASSERT_X( !mStarted, "startRender", "Rendering has already been started for this symbol instance!" );
828 mStarted = true;
829
830 mSymbolRenderContext.reset( new QgsSymbolRenderContext( context, QgsUnitTypes::RenderUnknownUnit, mOpacity, false, mRenderHints, nullptr, fields ) );
831
832 // Why do we need a copy here ? Is it to make sure the symbol layer rendering does not mess with the symbol render context ?
833 // Or is there another profound reason ?
834 QgsSymbolRenderContext symbolContext( context, QgsUnitTypes::RenderUnknownUnit, mOpacity, false, mRenderHints, nullptr, fields );
835
836 std::unique_ptr< QgsExpressionContextScope > scope( QgsExpressionContextUtils::updateSymbolScope( this, new QgsExpressionContextScope() ) );
837
839 {
840 const long long mapFrameNumber = context.currentFrame();
841 double animationTimeSeconds = 0;
842 if ( mapFrameNumber >= 0 && context.frameRate() > 0 )
843 {
844 // render is part of an animation, so we base the calculated frame on that
845 animationTimeSeconds = mapFrameNumber / context.frameRate();
846 }
847 else
848 {
849 // render is outside of animation, so base the calculated frame on the current epoch
850 animationTimeSeconds = QDateTime::currentMSecsSinceEpoch() / 1000.0;
851 }
852
853 const long long symbolFrame = static_cast< long long >( std::floor( animationTimeSeconds * mAnimationSettings.frameRate() ) );
854 scope->setVariable( QStringLiteral( "symbol_frame" ), symbolFrame, true );
855 }
856
857 mSymbolRenderContext->setExpressionContextScope( scope.release() );
858
859 mDataDefinedProperties.prepare( context.expressionContext() );
860
861 const auto constMLayers = mLayers;
862 for ( QgsSymbolLayer *layer : constMLayers )
863 {
864 if ( !layer->enabled() || !context.isSymbolLayerEnabled( layer ) )
865 continue;
866
867 layer->prepareExpressions( symbolContext );
868 layer->prepareMasks( symbolContext );
869 layer->startRender( symbolContext );
870 }
871}
872
874{
875 Q_ASSERT_X( mStarted, "startRender", "startRender was not called for this symbol instance!" );
876 mStarted = false;
877
878 Q_UNUSED( context )
879 if ( mSymbolRenderContext )
880 {
881 const auto constMLayers = mLayers;
882 for ( QgsSymbolLayer *layer : constMLayers )
883 {
884 if ( !layer->enabled() || !context.isSymbolLayerEnabled( layer ) )
885 continue;
886
887 layer->stopRender( *mSymbolRenderContext );
888 }
889 }
890
891 mSymbolRenderContext.reset( nullptr );
892
894 mLayer = nullptr;
896}
897
898void QgsSymbol::setColor( const QColor &color ) const
899{
900 const auto constMLayers = mLayers;
901 for ( QgsSymbolLayer *layer : constMLayers )
902 {
903 if ( !layer->isLocked() )
904 layer->setColor( color );
905 }
906}
907
908QColor QgsSymbol::color() const
909{
910 for ( const QgsSymbolLayer *layer : mLayers )
911 {
912 // return color of the first unlocked layer
913 if ( !layer->isLocked() )
914 {
915 const QColor layerColor = layer->color();
916 if ( layerColor.isValid() )
917 return layerColor;
918 }
919 }
920 return QColor( 0, 0, 0 );
921}
922
923void QgsSymbol::drawPreviewIcon( QPainter *painter, QSize size, QgsRenderContext *customContext, bool selected, const QgsExpressionContext *expressionContext, const QgsLegendPatchShape *patchShape )
924{
925 QgsRenderContext *context = customContext;
926 std::unique_ptr< QgsRenderContext > tempContext;
927 if ( !context )
928 {
929 tempContext.reset( new QgsRenderContext( QgsRenderContext::fromQPainter( painter ) ) );
930 context = tempContext.get();
932 }
933
934 const bool prevForceVector = context->forceVectorOutput();
935 context->setForceVectorOutput( true );
936
937 const double opacity = expressionContext ? dataDefinedProperties().valueAsDouble( QgsSymbol::PropertyOpacity, *expressionContext, mOpacity ) : mOpacity;
938
939 QgsSymbolRenderContext symbolContext( *context, QgsUnitTypes::RenderUnknownUnit, opacity, false, mRenderHints, nullptr );
940 symbolContext.setSelected( selected );
941 switch ( mType )
942 {
945 break;
948 break;
951 break;
954 break;
955 }
956
957 if ( patchShape )
958 symbolContext.setPatchShape( *patchShape );
959
960 if ( !customContext && expressionContext )
961 {
962 context->setExpressionContext( *expressionContext );
963 }
964 else if ( !customContext )
965 {
966 // if no render context was passed, build a minimal expression context
967 QgsExpressionContext expContext;
969 context->setExpressionContext( expContext );
970 }
971
972 for ( QgsSymbolLayer *layer : std::as_const( mLayers ) )
973 {
974 if ( !layer->enabled() || ( customContext && !customContext->isSymbolLayerEnabled( layer ) ) )
975 continue;
976
978 {
979 // line symbol layer would normally draw just a line
980 // so we override this case to force it to draw a polygon stroke
981 QgsLineSymbolLayer *lsl = dynamic_cast<QgsLineSymbolLayer *>( layer );
982 if ( lsl )
983 {
984 // from QgsFillSymbolLayer::drawPreviewIcon() -- would be nicer to add the
985 // symbol type to QgsSymbolLayer::drawPreviewIcon so this logic could be avoided!
986
987 // hmm... why was this using size -1 ??
988 const QSizeF targetSize = QSizeF( size.width() - 1, size.height() - 1 );
989
990 const QList< QList< QPolygonF > > polys = patchShape ? patchShape->toQPolygonF( Qgis::SymbolType::Fill, targetSize )
992
993 lsl->startRender( symbolContext );
994 QgsPaintEffect *effect = lsl->paintEffect();
995
996 std::unique_ptr< QgsEffectPainter > effectPainter;
997 if ( effect && effect->enabled() )
998 effectPainter = std::make_unique< QgsEffectPainter >( symbolContext.renderContext(), effect );
999
1000 for ( const QList< QPolygonF > &poly : polys )
1001 {
1002 QVector< QPolygonF > rings;
1003 rings.reserve( poly.size() );
1004 for ( int i = 1; i < poly.size(); ++i )
1005 rings << poly.at( i );
1006 lsl->renderPolygonStroke( poly.value( 0 ), &rings, symbolContext );
1007 }
1008
1009 effectPainter.reset();
1010 lsl->stopRender( symbolContext );
1011 }
1012 }
1013 else
1014 layer->drawPreviewIcon( symbolContext, size );
1015 }
1016
1017 context->setForceVectorOutput( prevForceVector );
1018}
1019
1020void QgsSymbol::exportImage( const QString &path, const QString &format, QSize size )
1021{
1022 if ( format.compare( QLatin1String( "svg" ), Qt::CaseInsensitive ) == 0 )
1023 {
1024 QSvgGenerator generator;
1025 generator.setFileName( path );
1026 generator.setSize( size );
1027 generator.setViewBox( QRect( 0, 0, size.height(), size.height() ) );
1028
1029 QPainter painter( &generator );
1030 drawPreviewIcon( &painter, size );
1031 painter.end();
1032 }
1033 else
1034 {
1035 QImage image = asImage( size );
1036 image.save( path );
1037 }
1038}
1039
1040QImage QgsSymbol::asImage( QSize size, QgsRenderContext *customContext )
1041{
1042 QImage image( size, QImage::Format_ARGB32_Premultiplied );
1043 image.fill( 0 );
1044
1045 QPainter p( &image );
1046 p.setRenderHint( QPainter::Antialiasing );
1047 p.setRenderHint( QPainter::SmoothPixmapTransform );
1048
1049 drawPreviewIcon( &p, size, customContext );
1050
1051 return image;
1052}
1053
1054
1055QImage QgsSymbol::bigSymbolPreviewImage( QgsExpressionContext *expressionContext, Qgis::SymbolPreviewFlags flags )
1056{
1057 QImage preview( QSize( 100, 100 ), QImage::Format_ARGB32_Premultiplied );
1058 preview.fill( 0 );
1059
1060 QPainter p( &preview );
1061 p.setRenderHint( QPainter::Antialiasing );
1062 p.translate( 0.5, 0.5 ); // shift by half a pixel to avoid blurring due antialiasing
1063
1065 {
1066 p.setPen( QPen( Qt::gray ) );
1067 p.drawLine( 0, 50, 100, 50 );
1068 p.drawLine( 50, 0, 50, 100 );
1069 }
1070
1075 context.setPainterFlagsUsingContext( &p );
1076 if ( expressionContext )
1077 context.setExpressionContext( *expressionContext );
1078
1079 context.setIsGuiPreview( true );
1080 startRender( context );
1081
1083 {
1084 QPolygonF poly;
1085 poly << QPointF( 0, 50 ) << QPointF( 99, 50 );
1086 static_cast<QgsLineSymbol *>( this )->renderPolyline( poly, nullptr, context );
1087 }
1088 else if ( mType == Qgis::SymbolType::Fill )
1089 {
1090 QPolygonF polygon;
1091 polygon << QPointF( 20, 20 ) << QPointF( 80, 20 ) << QPointF( 80, 80 ) << QPointF( 20, 80 ) << QPointF( 20, 20 );
1092 static_cast<QgsFillSymbol *>( this )->renderPolygon( polygon, nullptr, nullptr, context );
1093 }
1094 else // marker
1095 {
1096 static_cast<QgsMarkerSymbol *>( this )->renderPoint( QPointF( 50, 50 ), nullptr, context );
1097 }
1098
1099 stopRender( context );
1100 return preview;
1101}
1102
1103QImage QgsSymbol::bigSymbolPreviewImage( QgsExpressionContext *expressionContext, int flags )
1104{
1105 return bigSymbolPreviewImage( expressionContext, static_cast< Qgis::SymbolPreviewFlags >( flags ) );
1106}
1107
1108QString QgsSymbol::dump() const
1109{
1110 QString t;
1111 switch ( type() )
1112 {
1114 t = QStringLiteral( "MARKER" );
1115 break;
1117 t = QStringLiteral( "LINE" );
1118 break;
1120 t = QStringLiteral( "FILL" );
1121 break;
1122 default:
1123 Q_ASSERT( false && "unknown symbol type" );
1124 }
1125 QString s = QStringLiteral( "%1 SYMBOL (%2 layers) color %3" ).arg( t ).arg( mLayers.count() ).arg( QgsSymbolLayerUtils::encodeColor( color() ) );
1126
1127 for ( QgsSymbolLayerList::const_iterator it = mLayers.begin(); it != mLayers.end(); ++it )
1128 {
1129 // TODO:
1130 }
1131 return s;
1132}
1133
1134void QgsSymbol::toSld( QDomDocument &doc, QDomElement &element, QVariantMap props ) const
1135{
1136 props[ QStringLiteral( "alpha" )] = QString::number( opacity() );
1137 double scaleFactor = 1.0;
1138 props[ QStringLiteral( "uom" )] = QgsSymbolLayerUtils::encodeSldUom( outputUnit(), &scaleFactor );
1139 props[ QStringLiteral( "uomScale" )] = ( !qgsDoubleNear( scaleFactor, 1.0 ) ? qgsDoubleToString( scaleFactor ) : QString() );
1140
1141 for ( QgsSymbolLayerList::const_iterator it = mLayers.begin(); it != mLayers.end(); ++it )
1142 {
1143 ( *it )->toSld( doc, element, props );
1144 }
1145}
1146
1148{
1150 for ( QgsSymbolLayerList::const_iterator it = mLayers.begin(); it != mLayers.end(); ++it )
1151 {
1152 QgsSymbolLayer *layer = ( *it )->clone();
1153 layer->setLocked( ( *it )->isLocked() );
1154 layer->setRenderingPass( ( *it )->renderingPass() );
1155 layer->setEnabled( ( *it )->enabled() );
1156 lst.append( layer );
1157 }
1158 return lst;
1159}
1160
1161void QgsSymbol::renderUsingLayer( QgsSymbolLayer *layer, QgsSymbolRenderContext &context, QgsWkbTypes::GeometryType geometryType, const QPolygonF *points, const QVector<QPolygonF> *rings )
1162{
1163 Q_ASSERT( layer->type() == Qgis::SymbolType::Hybrid );
1164
1165 if ( layer->dataDefinedProperties().hasActiveProperties() && !layer->dataDefinedProperties().valueAsBool( QgsSymbolLayer::PropertyLayerEnabled, context.renderContext().expressionContext(), true ) )
1166 return;
1167
1168 QgsGeometryGeneratorSymbolLayer *generatorLayer = static_cast<QgsGeometryGeneratorSymbolLayer *>( layer );
1169
1170 QgsPaintEffect *effect = generatorLayer->paintEffect();
1171 if ( effect && effect->enabled() )
1172 {
1173 QgsEffectPainter p( context.renderContext(), effect );
1174 generatorLayer->render( context, geometryType, points, rings );
1175 }
1176 else
1177 {
1178 generatorLayer->render( context, geometryType, points, rings );
1179 }
1180}
1181
1182QSet<QString> QgsSymbol::usedAttributes( const QgsRenderContext &context ) const
1183{
1184 // calling referencedFields() with ignoreContext=true because in our expression context
1185 // we do not have valid QgsFields yet - because of that the field names from expressions
1186 // wouldn't get reported
1187 QSet<QString> attributes = mDataDefinedProperties.referencedFields( context.expressionContext(), true );
1188 QgsSymbolLayerList::const_iterator sIt = mLayers.constBegin();
1189 for ( ; sIt != mLayers.constEnd(); ++sIt )
1190 {
1191 if ( *sIt )
1192 {
1193 attributes.unite( ( *sIt )->usedAttributes( context ) );
1194 }
1195 }
1196 return attributes;
1197}
1198
1200{
1201 mDataDefinedProperties.setProperty( key, property );
1202}
1203
1205{
1206 if ( mDataDefinedProperties.hasActiveProperties() )
1207 return true;
1208
1209 for ( QgsSymbolLayer *layer : mLayers )
1210 {
1211 if ( layer->hasDataDefinedProperties() )
1212 return true;
1213 }
1214 return false;
1215}
1216
1218{
1219 for ( QgsSymbolLayer *layer : mLayers )
1220 {
1221 if ( layer->canCauseArtifactsBetweenAdjacentTiles() )
1222 return true;
1223 }
1224 return false;
1225}
1226
1228{
1230 mLayer = layer;
1232}
1233
1235{
1237 return mLayer;
1239}
1240
1242
1246class ExpressionContextScopePopper
1247{
1248 public:
1249
1250 ExpressionContextScopePopper() = default;
1251
1252 ~ExpressionContextScopePopper()
1253 {
1254 if ( context )
1255 context->popScope();
1256 }
1257
1258 QgsExpressionContext *context = nullptr;
1259};
1260
1264class GeometryRestorer
1265{
1266 public:
1267 GeometryRestorer( QgsRenderContext &context )
1268 : mContext( context ),
1269 mGeometry( context.geometry() )
1270 {}
1271
1272 ~GeometryRestorer()
1273 {
1274 mContext.setGeometry( mGeometry );
1275 }
1276
1277 private:
1278 QgsRenderContext &mContext;
1279 const QgsAbstractGeometry *mGeometry;
1280};
1282
1283void QgsSymbol::renderFeature( const QgsFeature &feature, QgsRenderContext &context, int layer, bool selected, bool drawVertexMarker, Qgis::VertexMarkerType currentVertexMarkerType, double currentVertexMarkerSize )
1284{
1285 if ( context.renderingStopped() )
1286 return;
1287
1288 const QgsGeometry geom = feature.geometry();
1289 if ( geom.isNull() )
1290 {
1291 return;
1292 }
1293
1294 GeometryRestorer geomRestorer( context );
1295
1296 bool usingSegmentizedGeometry = false;
1297 context.setGeometry( geom.constGet() );
1298
1299 if ( geom.type() != QgsWkbTypes::PointGeometry && !geom.boundingBox().isNull() )
1300 {
1301 try
1302 {
1303 const QPointF boundsOrigin = _getPoint( context, QgsPoint( geom.boundingBox().xMinimum(), geom.boundingBox().yMinimum() ) );
1304 if ( std::isfinite( boundsOrigin.x() ) && std::isfinite( boundsOrigin.y() ) )
1305 context.setTextureOrigin( boundsOrigin );
1306 }
1307 catch ( QgsCsException & )
1308 {
1309
1310 }
1311 }
1312
1313 bool clippingEnabled = clipFeaturesToExtent();
1314 // do any symbol layers prevent feature clipping?
1315 for ( QgsSymbolLayer *layer : std::as_const( mLayers ) )
1316 {
1318 {
1319 clippingEnabled = false;
1320 break;
1321 }
1322 }
1323 if ( clippingEnabled && context.testFlag( Qgis::RenderContextFlag::RenderMapTile ) )
1324 {
1325 // If the "avoid artifacts between adjacent tiles" flag is set (RenderMapTile), then we'll force disable
1326 // the geometry clipping IF (and only if) this symbol can potentially have rendering artifacts when rendered as map tiles.
1327 // If the symbol won't have any artifacts anyway, then it's pointless and incredibly expensive to skip the clipping!
1329 {
1330 clippingEnabled = false;
1331 }
1332 }
1333 if ( context.extent().isEmpty() )
1334 clippingEnabled = false;
1335
1336 mSymbolRenderContext->setGeometryPartCount( geom.constGet()->partCount() );
1337 mSymbolRenderContext->setGeometryPartNum( 1 );
1338
1339 const bool needsExpressionContext = hasDataDefinedProperties();
1340 ExpressionContextScopePopper scopePopper;
1341 if ( mSymbolRenderContext->expressionContextScope() )
1342 {
1343 if ( needsExpressionContext )
1344 {
1345 // this is somewhat nasty - by appending this scope here it's now owned
1346 // by both mSymbolRenderContext AND context.expressionContext()
1347 // the RAII scopePopper is required to make sure it always has ownership transferred back
1348 // from context.expressionContext(), even if exceptions of other early exits occur in this
1349 // function
1350 context.expressionContext().appendScope( mSymbolRenderContext->expressionContextScope() );
1351 scopePopper.context = &context.expressionContext();
1352
1353 QgsExpressionContextUtils::updateSymbolScope( this, mSymbolRenderContext->expressionContextScope() );
1354 mSymbolRenderContext->expressionContextScope()->addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_GEOMETRY_PART_COUNT, mSymbolRenderContext->geometryPartCount(), true ) );
1355 mSymbolRenderContext->expressionContextScope()->addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_GEOMETRY_PART_NUM, 1, true ) );
1356 }
1357 }
1358
1359 // Collection of markers to paint, only used for no curve types.
1360 QPolygonF markers;
1361
1362 QgsGeometry renderedBoundsGeom;
1363
1364 // Step 1 - collect the set of painter coordinate geometries to render.
1365 // We do this upfront, because we only want to ever do this once, regardless how many symbol layers we need to render.
1366
1367 struct PointInfo
1368 {
1369 QPointF renderPoint;
1370 const QgsPoint *originalGeometry = nullptr;
1371 };
1372 QVector< PointInfo > pointsToRender;
1373
1374 struct LineInfo
1375 {
1376 QPolygonF renderLine;
1377 const QgsCurve *originalGeometry = nullptr;
1378 };
1379 QVector< LineInfo > linesToRender;
1380
1381 struct PolygonInfo
1382 {
1383 QPolygonF renderExterior;
1384 QVector< QPolygonF > renderRings;
1385 const QgsCurvePolygon *originalGeometry = nullptr;
1386 int originalPartIndex = 0;
1387 };
1388 QVector< PolygonInfo > polygonsToRender;
1389
1390 std::function< void ( const QgsAbstractGeometry *, int partIndex )> getPartGeometry;
1391 getPartGeometry = [&pointsToRender, &linesToRender, &polygonsToRender, &getPartGeometry, &context, &clippingEnabled, &markers, &feature, &usingSegmentizedGeometry, this]( const QgsAbstractGeometry * part, int partIndex = 0 )
1392 {
1393 Q_UNUSED( feature )
1394
1395 if ( !part )
1396 return;
1397
1398 // geometry preprocessing
1399 QgsGeometry temporaryGeometryContainer;
1400 const QgsAbstractGeometry *processedGeometry = nullptr;
1401
1402 const bool isMultiPart = qgsgeometry_cast< const QgsGeometryCollection * >( part ) && qgsgeometry_cast< const QgsGeometryCollection * >( part )->numGeometries() > 1;
1403
1404 if ( !isMultiPart )
1405 {
1406 // segmentize curved geometries
1407 const bool needsSegmentizing = QgsWkbTypes::isCurvedType( part->wkbType() ) || part->hasCurvedSegments();
1408 if ( needsSegmentizing )
1409 {
1410 std::unique_ptr< QgsAbstractGeometry > segmentizedPart( part->segmentize( context.segmentationTolerance(), context.segmentationToleranceType() ) );
1411 if ( !segmentizedPart )
1412 {
1413 return;
1414 }
1415 temporaryGeometryContainer.set( segmentizedPart.release() );
1416 processedGeometry = temporaryGeometryContainer.constGet();
1417 usingSegmentizedGeometry = true;
1418 }
1419 else
1420 {
1421 // no segmentation required
1422 processedGeometry = part;
1423 }
1424
1425 // Simplify the geometry, if needed.
1427 {
1428 const int simplifyHints = context.vectorSimplifyMethod().simplifyHints();
1429 const QgsMapToPixelSimplifier simplifier( simplifyHints, context.vectorSimplifyMethod().tolerance(),
1431
1432 std::unique_ptr< QgsAbstractGeometry > simplified( simplifier.simplify( processedGeometry ) );
1433 if ( simplified )
1434 {
1435 temporaryGeometryContainer.set( simplified.release() );
1436 processedGeometry = temporaryGeometryContainer.constGet();
1437 }
1438 }
1439
1440 // clip geometry to render context clipping regions
1441 if ( !context.featureClipGeometry().isEmpty() )
1442 {
1443 // apply feature clipping from context to the rendered geometry only -- just like the render time simplification,
1444 // we should NEVER apply this to the geometry attached to the feature itself. Doing so causes issues with certain
1445 // renderer settings, e.g. if polygons are being rendered using a rule based renderer based on the feature's area,
1446 // then we need to ensure that the original feature area is used instead of the clipped area..
1447 QgsGeos geos( processedGeometry );
1448 std::unique_ptr< QgsAbstractGeometry > clippedGeom( geos.intersection( context.featureClipGeometry().constGet() ) );
1449 if ( clippedGeom )
1450 {
1451 temporaryGeometryContainer.set( clippedGeom.release() );
1452 processedGeometry = temporaryGeometryContainer.constGet();
1453 }
1454 }
1455 }
1456 else
1457 {
1458 // for multipart geometries, the processing is deferred till we're rendering the actual part...
1459 processedGeometry = part;
1460 }
1461
1462 if ( !processedGeometry )
1463 {
1464 // shouldn't happen!
1465 QgsDebugMsg( QStringLiteral( "No processed geometry to render for part!" ) );
1466 return;
1467 }
1468
1469 switch ( QgsWkbTypes::flatType( processedGeometry->wkbType() ) )
1470 {
1471 case QgsWkbTypes::Point:
1472 {
1474 {
1475 QgsDebugMsgLevel( QStringLiteral( "point can be drawn only with marker symbol!" ), 2 );
1476 break;
1477 }
1478
1479 PointInfo info;
1480 info.originalGeometry = qgsgeometry_cast< const QgsPoint * >( part );
1481 info.renderPoint = _getPoint( context, *info.originalGeometry );
1482 pointsToRender << info;
1483 break;
1484 }
1485
1487 {
1489 {
1490 QgsDebugMsgLevel( QStringLiteral( "linestring can be drawn only with line symbol!" ), 2 );
1491 break;
1492 }
1493
1494 LineInfo info;
1495 info.originalGeometry = qgsgeometry_cast<const QgsCurve *>( part );
1496 info.renderLine = _getLineString( context, *qgsgeometry_cast<const QgsCurve *>( processedGeometry ), clippingEnabled );
1497 linesToRender << info;
1498 break;
1499 }
1500
1503 {
1504 QPolygonF pts;
1506 {
1507 QgsDebugMsgLevel( QStringLiteral( "polygon can be drawn only with fill symbol!" ), 2 );
1508 break;
1509 }
1510
1511 PolygonInfo info;
1512 info.originalGeometry = qgsgeometry_cast<const QgsCurvePolygon *>( part );
1513 info.originalPartIndex = partIndex;
1514 if ( !qgsgeometry_cast<const QgsPolygon *>( processedGeometry )->exteriorRing() )
1515 {
1516 QgsDebugMsg( QStringLiteral( "cannot render polygon with no exterior ring" ) );
1517 break;
1518 }
1519
1520 _getPolygon( info.renderExterior, info.renderRings, context, *qgsgeometry_cast<const QgsPolygon *>( processedGeometry ), clippingEnabled, mForceRHR );
1521 polygonsToRender << info;
1522 break;
1523 }
1524
1526 {
1527 const QgsMultiPoint *mp = qgsgeometry_cast< const QgsMultiPoint * >( processedGeometry );
1528 markers.reserve( mp->numGeometries() );
1529 }
1534 {
1535 const QgsGeometryCollection *geomCollection = qgsgeometry_cast<const QgsGeometryCollection *>( processedGeometry );
1536
1537 const unsigned int num = geomCollection->numGeometries();
1538 for ( unsigned int i = 0; i < num; ++i )
1539 {
1540 if ( context.renderingStopped() )
1541 break;
1542
1543 getPartGeometry( geomCollection->geometryN( i ), i );
1544 }
1545 break;
1546 }
1547
1550 {
1552 {
1553 QgsDebugMsgLevel( QStringLiteral( "multi-polygon can be drawn only with fill symbol!" ), 2 );
1554 break;
1555 }
1556
1557 QPolygonF pts;
1558
1559 const QgsGeometryCollection *geomCollection = dynamic_cast<const QgsGeometryCollection *>( processedGeometry );
1560 const unsigned int num = geomCollection->numGeometries();
1561
1562 // Sort components by approximate area (probably a bit faster than using
1563 // area() )
1564 std::map<double, QList<unsigned int> > thisAreaToPartNum;
1565 for ( unsigned int i = 0; i < num; ++i )
1566 {
1567 const QgsRectangle r( geomCollection->geometryN( i )->boundingBox() );
1568 thisAreaToPartNum[ r.width() * r.height()] << i;
1569 }
1570
1571 // Draw starting with larger parts down to smaller parts, so that in
1572 // case of a part being incorrectly inside another part, it is drawn
1573 // on top of it (#15419)
1574 std::map<double, QList<unsigned int> >::const_reverse_iterator iter = thisAreaToPartNum.rbegin();
1575 for ( ; iter != thisAreaToPartNum.rend(); ++iter )
1576 {
1577 const QList<unsigned int> &listPartIndex = iter->second;
1578 for ( int idx = 0; idx < listPartIndex.size(); ++idx )
1579 {
1580 const unsigned i = listPartIndex[idx];
1581 getPartGeometry( geomCollection->geometryN( i ), i );
1582 }
1583 }
1584 break;
1585 }
1586
1587 default:
1588 QgsDebugMsg( QStringLiteral( "feature %1: unsupported wkb type %2/%3 for rendering" )
1589 .arg( feature.id() )
1590 .arg( QgsWkbTypes::displayString( part->wkbType() ) )
1591 .arg( part->wkbType(), 0, 16 ) );
1592 }
1593 };
1594
1595 // Use the simplified type ref when rendering -- this avoids some unnecessary cloning/geometry modification
1596 // (e.g. if the original geometry is a compound curve containing only a linestring curve, we don't have
1597 // to segmentize the geometry before rendering)
1598 getPartGeometry( geom.constGet()->simplifiedTypeRef(), 0 );
1599
1600 // step 2 - determine which layers to render
1601 std::vector< int > layers;
1602 if ( layer == -1 )
1603 {
1604 layers.reserve( mLayers.count() );
1605 for ( int i = 0; i < mLayers.count(); ++i )
1606 layers.emplace_back( i );
1607 }
1608 else
1609 {
1610 layers.emplace_back( layer );
1611 }
1612
1613 // step 3 - render these geometries using the desired symbol layers.
1614
1615 if ( needsExpressionContext )
1616 mSymbolRenderContext->expressionContextScope()->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "symbol_layer_count" ), mLayers.count(), true ) );
1617
1618 for ( const int symbolLayerIndex : layers )
1619 {
1620 QgsSymbolLayer *symbolLayer = mLayers.value( symbolLayerIndex );
1621 if ( !symbolLayer || !symbolLayer->enabled() )
1622 continue;
1623
1624 if ( needsExpressionContext )
1625 mSymbolRenderContext->expressionContextScope()->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "symbol_layer_index" ), symbolLayerIndex + 1, true ) );
1626
1627 symbolLayer->startFeatureRender( feature, context );
1628
1629 switch ( mType )
1630 {
1632 {
1633 int geometryPartNumber = 0;
1634 for ( const PointInfo &point : std::as_const( pointsToRender ) )
1635 {
1636 if ( context.renderingStopped() )
1637 break;
1638
1639 mSymbolRenderContext->setGeometryPartNum( geometryPartNumber + 1 );
1640 if ( needsExpressionContext )
1641 mSymbolRenderContext->expressionContextScope()->addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_GEOMETRY_PART_NUM, geometryPartNumber + 1, true ) );
1642
1643 static_cast<QgsMarkerSymbol *>( this )->renderPoint( point.renderPoint, &feature, context, symbolLayerIndex, selected );
1644 geometryPartNumber++;
1645 }
1646
1647 break;
1648 }
1649
1651 {
1652 if ( linesToRender.empty() )
1653 break;
1654
1655 int geometryPartNumber = 0;
1656 for ( const LineInfo &line : std::as_const( linesToRender ) )
1657 {
1658 if ( context.renderingStopped() )
1659 break;
1660
1661 mSymbolRenderContext->setGeometryPartNum( geometryPartNumber + 1 );
1662 if ( needsExpressionContext )
1663 mSymbolRenderContext->expressionContextScope()->addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_GEOMETRY_PART_NUM, geometryPartNumber + 1, true ) );
1664
1665 context.setGeometry( line.originalGeometry );
1666 static_cast<QgsLineSymbol *>( this )->renderPolyline( line.renderLine, &feature, context, symbolLayerIndex, selected );
1667 geometryPartNumber++;
1668 }
1669 break;
1670 }
1671
1673 {
1674 for ( const PolygonInfo &info : std::as_const( polygonsToRender ) )
1675 {
1676 if ( context.renderingStopped() )
1677 break;
1678
1679 mSymbolRenderContext->setGeometryPartNum( info.originalPartIndex + 1 );
1680 if ( needsExpressionContext )
1681 mSymbolRenderContext->expressionContextScope()->addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_GEOMETRY_PART_NUM, info.originalPartIndex + 1, true ) );
1682
1683 context.setGeometry( info.originalGeometry );
1684 static_cast<QgsFillSymbol *>( this )->renderPolygon( info.renderExterior, ( !info.renderRings.isEmpty() ? &info.renderRings : nullptr ), &feature, context, symbolLayerIndex, selected );
1685 }
1686
1687 break;
1688 }
1689
1691 break;
1692 }
1693
1694 symbolLayer->stopFeatureRender( feature, context );
1695 }
1696
1697 // step 4 - handle post processing steps
1698 switch ( mType )
1699 {
1701 {
1702 markers.reserve( pointsToRender.size() );
1703 for ( const PointInfo &info : std::as_const( pointsToRender ) )
1704 {
1706 {
1707 const QRectF bounds = static_cast<QgsMarkerSymbol *>( this )->bounds( info.renderPoint, context, feature );
1708 if ( context.hasRenderedFeatureHandlers() )
1709 {
1710 renderedBoundsGeom = renderedBoundsGeom.isNull() ? QgsGeometry::fromRect( bounds )
1711 : QgsGeometry::collectGeometry( QVector< QgsGeometry>() << QgsGeometry::fromRect( QgsRectangle( bounds ) ) << renderedBoundsGeom );
1712 }
1714 {
1715 //draw debugging rect
1716 context.painter()->setPen( Qt::red );
1717 context.painter()->setBrush( QColor( 255, 0, 0, 100 ) );
1718 context.painter()->drawRect( bounds );
1719 }
1720 }
1721
1722 if ( drawVertexMarker && !usingSegmentizedGeometry )
1723 {
1724 markers.append( info.renderPoint );
1725 }
1726 }
1727 break;
1728 }
1729
1731 {
1732 for ( const LineInfo &info : std::as_const( linesToRender ) )
1733 {
1734 if ( context.hasRenderedFeatureHandlers() && !info.renderLine.empty() )
1735 {
1736 renderedBoundsGeom = renderedBoundsGeom.isNull() ? QgsGeometry::fromQPolygonF( info.renderLine )
1737 : QgsGeometry::collectGeometry( QVector< QgsGeometry>() << QgsGeometry::fromQPolygonF( info.renderLine ) << renderedBoundsGeom );
1738 }
1739
1740 if ( drawVertexMarker && !usingSegmentizedGeometry )
1741 {
1742 markers << info.renderLine;
1743 }
1744 }
1745 break;
1746 }
1747
1749 {
1750 int i = 0;
1751 for ( const PolygonInfo &info : std::as_const( polygonsToRender ) )
1752 {
1753 if ( context.hasRenderedFeatureHandlers() && !info.renderExterior.empty() )
1754 {
1755 renderedBoundsGeom = renderedBoundsGeom.isNull() ? QgsGeometry::fromQPolygonF( info.renderExterior )
1756 : QgsGeometry::collectGeometry( QVector< QgsGeometry>() << QgsGeometry::fromQPolygonF( info.renderExterior ) << renderedBoundsGeom );
1757 // TODO: consider holes?
1758 }
1759
1760 if ( drawVertexMarker && !usingSegmentizedGeometry )
1761 {
1762 markers << info.renderExterior;
1763
1764 for ( const QPolygonF &hole : info.renderRings )
1765 {
1766 markers << hole;
1767 }
1768 }
1769 i++;
1770 }
1771 break;
1772 }
1773
1775 break;
1776 }
1777
1778 if ( context.hasRenderedFeatureHandlers() && !renderedBoundsGeom.isNull() )
1779 {
1781 const QList< QgsRenderedFeatureHandlerInterface * > handlers = context.renderedFeatureHandlers();
1782 for ( QgsRenderedFeatureHandlerInterface *handler : handlers )
1783 handler->handleRenderedFeature( feature, renderedBoundsGeom, featureContext );
1784 }
1785
1786 if ( drawVertexMarker )
1787 {
1788 if ( !markers.isEmpty() && !context.renderingStopped() )
1789 {
1790 const auto constMarkers = markers;
1791 for ( QPointF marker : constMarkers )
1792 {
1793 renderVertexMarker( marker, context, currentVertexMarkerType, currentVertexMarkerSize );
1794 }
1795 }
1796 else
1797 {
1799 const QgsMapToPixel &mtp = context.mapToPixel();
1800
1801 QgsPoint vertexPoint;
1802 QgsVertexId vertexId;
1803 double x, y, z;
1804 QPointF mapPoint;
1805 while ( geom.constGet()->nextVertex( vertexId, vertexPoint ) )
1806 {
1807 //transform
1808 x = vertexPoint.x();
1809 y = vertexPoint.y();
1810 z = 0.0;
1811 if ( ct.isValid() )
1812 {
1813 ct.transformInPlace( x, y, z );
1814 }
1815 mapPoint.setX( x );
1816 mapPoint.setY( y );
1817 mtp.transformInPlace( mapPoint.rx(), mapPoint.ry() );
1818 renderVertexMarker( mapPoint, context, currentVertexMarkerType, currentVertexMarkerSize );
1819 }
1820 }
1821 }
1822}
1823
1825{
1826 return mSymbolRenderContext.get();
1827}
1828
1829void QgsSymbol::renderVertexMarker( QPointF pt, QgsRenderContext &context, Qgis::VertexMarkerType currentVertexMarkerType, double currentVertexMarkerSize )
1830{
1831 int markerSize = context.convertToPainterUnits( currentVertexMarkerSize, QgsUnitTypes::RenderMillimeters );
1832 QgsSymbolLayerUtils::drawVertexMarker( pt.x(), pt.y(), *context.painter(), currentVertexMarkerType, markerSize );
1833}
1834
1835void QgsSymbol::initPropertyDefinitions()
1836{
1837 if ( !sPropertyDefinitions.isEmpty() )
1838 return;
1839
1840 QString origin = QStringLiteral( "symbol" );
1841
1842 sPropertyDefinitions = QgsPropertiesDefinition
1843 {
1844 { QgsSymbol::PropertyOpacity, QgsPropertyDefinition( "alpha", QObject::tr( "Opacity" ), QgsPropertyDefinition::Opacity, origin )},
1845 };
1846}
1847
1848void QgsSymbol::startFeatureRender( const QgsFeature &feature, QgsRenderContext &context, const int layer )
1849{
1850 if ( layer != -1 )
1851 {
1853 if ( symbolLayer && symbolLayer->enabled() )
1854 {
1855 symbolLayer->startFeatureRender( feature, context );
1856 }
1857 return;
1858 }
1859 else
1860 {
1861 const QList< QgsSymbolLayer * > layers = mLayers;
1862 for ( QgsSymbolLayer *symbolLayer : layers )
1863 {
1864 if ( !symbolLayer->enabled() )
1865 continue;
1866
1867 symbolLayer->startFeatureRender( feature, context );
1868 }
1869 }
1870}
1871
1872void QgsSymbol::stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context, int layer )
1873{
1874 if ( layer != -1 )
1875 {
1877 if ( symbolLayer && symbolLayer->enabled() )
1878 {
1879 symbolLayer->stopFeatureRender( feature, context );
1880 }
1881 return;
1882 }
1883 else
1884 {
1885 const QList< QgsSymbolLayer * > layers = mLayers;
1886 for ( QgsSymbolLayer *symbolLayer : layers )
1887 {
1888 if ( !symbolLayer->enabled() )
1889 continue;
1890
1891 symbolLayer->stopFeatureRender( feature, context );
1892 }
1893 }
1894}
@ CounterClockwise
Counter-clockwise direction.
@ Clockwise
Clockwise direction.
@ DisableFeatureClipping
If present, indicates that features should never be clipped to the map extent during rendering.
@ RenderSymbolPreview
The render is for a symbol preview only and map based properties may not be available,...
@ ApplyClipAfterReprojection
Feature geometry clipping to mapExtent() must be performed after the geometries are transformed using...
@ DrawSymbolBounds
Draw bounds of symbols (for debugging/testing)
@ RenderMapTile
Draw map such that there are no problems between adjacent tiles.
@ Antialiasing
Use antialiasing while drawing.
@ HighQualityImageTransforms
Enable high quality image transformations, which results in better appearance of scaled or rotated ra...
@ FlagIncludeCrosshairsForMarkerSymbols
Include a crosshairs reference image in the background of marker symbol previews.
VertexMarkerType
Editing vertex markers, used for showing vertices during a edit operation.
Definition: qgis.h:901
SymbolType
Symbol types.
Definition: qgis.h:206
@ Marker
Marker symbol.
@ Line
Line symbol.
@ Fill
Fill symbol.
@ Hybrid
Hybrid symbol.
Abstract base class for all geometries.
bool is3D() const SIP_HOLDGIL
Returns true if the geometry is 3D and contains a z-value.
virtual QgsRectangle boundingBox() const =0
Returns the minimal bounding box for the geometry.
virtual const QgsAbstractGeometry * simplifiedTypeRef() const SIP_HOLDGIL
Returns a reference to the simplest lossless representation of this geometry, e.g.
virtual int partCount() const =0
Returns count of parts contained in the geometry.
QgsWkbTypes::Type wkbType() const SIP_HOLDGIL
Returns the WKB type of the geometry.
virtual bool nextVertex(QgsVertexId &id, QgsPoint &vertex) const =0
Returns next vertex id and coordinates.
double valueAsDouble(int key, const QgsExpressionContext &context, double defaultValue=0.0, bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as a double.
static QgsColorSchemeRegistry * colorSchemeRegistry()
Returns the application's color scheme registry, used for managing color schemes.
A 3-dimensional box composed of x, y, z coordinates.
Definition: qgsbox3d.h:39
static void trimPolygon(QPolygonF &pts, const QgsRectangle &clipRect)
Trims the given polygon to a rectangular box, by modifying the given polygon in place.
Definition: qgsclipper.h:285
static QPolygonF clippedLine(const QgsCurve &curve, const QgsRectangle &clipExtent)
Takes a linestring and clips it to clipExtent.
Definition: qgsclipper.cpp:110
static void clipped3dLine(const QVector< double > &xIn, const QVector< double > &yIn, const QVector< double > &zIn, QVector< double > &x, QVector< double > &y, QVector< double > &z, const QgsBox3d &clipExtent)
Takes a line with 3D coordinates and clips it to clipExtent.
Definition: qgsclipper.cpp:40
Class for doing transforms between two map coordinate systems.
void transformPolygon(QPolygonF &polygon, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward) const SIP_THROW(QgsCsException)
Transforms a polygon to the destination coordinate system.
void transformCoords(int numPoint, double *x, double *y, double *z, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward) const SIP_THROW(QgsCsException)
Transform an array of coordinates to the destination CRS.
bool isValid() const
Returns true if the coordinate transform is valid, ie both the source and destination CRS have been s...
void transformInPlace(double &x, double &y, double &z, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward) const SIP_THROW(QgsCsException)
Transforms an array of x, y and z double coordinates in place, from the source CRS to the destination...
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgsexception.h:66
Curve polygon geometry type.
const QgsCurve * interiorRing(int i) const SIP_HOLDGIL
Retrieves an interior ring from the curve polygon.
const QgsCurve * exteriorRing() const SIP_HOLDGIL
Returns the curve polygon's exterior ring.
int numInteriorRings() const SIP_HOLDGIL
Returns the number of interior rings contained with the curve polygon.
Abstract base class for curved geometry type.
Definition: qgscurve.h:36
Qgis::AngularDirection orientation() const
Returns the curve's orientation, e.g.
Definition: qgscurve.cpp:286
QgsRectangle boundingBox() const override
Returns the minimal bounding box for the geometry.
Definition: qgscurve.cpp:238
virtual int numPoints() const =0
Returns the number of points in the curve.
QgsCurve * segmentize(double tolerance=M_PI_2/90, SegmentationToleranceType toleranceType=MaximumAngle) const override
Returns a geometry without curves.
Definition: qgscurve.cpp:175
virtual QPolygonF asQPolygonF() const
Returns a QPolygonF representing the points.
Definition: qgscurve.cpp:266
A class to manager painter saving and restoring required for effect drawing.
Single scope for storing variables and functions for use within a QgsExpressionContext.
static QgsExpressionContextScope * updateSymbolScope(const QgsSymbol *symbol, QgsExpressionContextScope *symbolScope=nullptr)
Updates a symbol scope related to a QgsSymbol to an expression context.
static QList< QgsExpressionContextScope * > globalProjectLayerScopes(const QgsMapLayer *layer)
Creates a list of three scopes: global, layer's project and layer.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
static const QString EXPR_GEOMETRY_PART_COUNT
Inbuilt variable name for geometry part count variable.
static const QString EXPR_GEOMETRY_PART_NUM
Inbuilt variable name for geometry part number variable.
void appendScope(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
void appendScopes(const QList< QgsExpressionContextScope * > &scopes)
Appends a list of scopes to the end of the context.
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition: qgsfeature.h:56
QgsGeometry geometry
Definition: qgsfeature.h:67
Q_GADGET QgsFeatureId id
Definition: qgsfeature.h:64
Container of fields for a vector layer.
Definition: qgsfields.h:45
A fill symbol type, for rendering Polygon and MultiPolygon geometries.
Definition: qgsfillsymbol.h:30
Geometry collection.
int numGeometries() const SIP_HOLDGIL
Returns the number of geometries within the collection.
const QgsAbstractGeometry * geometryN(int n) const
Returns a const reference to a geometry from within the collection.
void render(QgsSymbolRenderContext &context, QgsWkbTypes::GeometryType geometryType=QgsWkbTypes::GeometryType::UnknownGeometry, const QPolygonF *points=nullptr, const QVector< QPolygonF > *rings=nullptr)
Will render this symbol layer using the context.
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:164
const QgsAbstractGeometry * constGet() const SIP_HOLDGIL
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
static QgsGeometry collectGeometry(const QVector< QgsGeometry > &geometries)
Creates a new multipart geometry from a list of QgsGeometry objects.
static QgsGeometry fromQPolygonF(const QPolygonF &polygon)
Construct geometry from a QPolygonF.
Q_GADGET bool isNull
Definition: qgsgeometry.h:166
static QgsGeometry fromRect(const QgsRectangle &rect) SIP_HOLDGIL
Creates a new geometry from a QgsRectangle.
QgsWkbTypes::GeometryType type
Definition: qgsgeometry.h:167
void set(QgsAbstractGeometry *geometry)
Sets the underlying geometry store.
bool isEmpty() const
Returns true if the geometry is empty (eg a linestring with no vertices, or a collection with no geom...
QgsRectangle boundingBox() const
Returns the bounding box of the geometry.
Does vector analysis using the geos library and handles import, export, exception handling*.
Definition: qgsgeos.h:99
Represents a patch shape for use in map legends.
QList< QList< QPolygonF > > toQPolygonF(Qgis::SymbolType type, QSizeF size) const
Converts the patch shape to a set of QPolygonF objects representing how the patch should be drawn for...
Line string geometry type, with support for z-dimension and m-values.
Definition: qgslinestring.h:45
QVector< double > xVector() const
Returns the x vertex values as a vector.
QVector< double > yVector() const
Returns the y vertex values as a vector.
QVector< double > zVector() const
Returns the z vertex values as a vector.
virtual void renderPolygonStroke(const QPolygonF &points, const QVector< QPolygonF > *rings, QgsSymbolRenderContext &context)
Renders the line symbol layer along the outline of polygon, using the given render context.
A line symbol type, for rendering LineString and MultiLineString geometries.
Definition: qgslinesymbol.h:30
QgsMapLayerType type
Definition: qgsmaplayer.h:80
QgsMapLayer::LayerFlags flags() const
Returns the flags for this layer.
Implementation of GeometrySimplifier using the "MapToPixel" algorithm.
SimplifyAlgorithm
Types of simplification algorithms that can be used.
QgsGeometry simplify(const QgsGeometry &geometry) const override
Returns a simplified version the specified geometry.
Perform transforms between map coordinates and device coordinates.
Definition: qgsmaptopixel.h:39
void transformInPlace(double &x, double &y) const
Transforms device coordinates to map coordinates.
Struct for storing maximum and minimum scales for measurements in map units.
A marker symbol type, for rendering Point and MultiPoint geometries.
Multi point geometry collection.
Definition: qgsmultipoint.h:30
Base class for visual effects which can be applied to QPicture drawings.
bool enabled() const
Returns whether the effect is enabled.
Point geometry type, with support for z-dimension and m-values.
Definition: qgspoint.h:49
Q_GADGET double x
Definition: qgspoint.h:52
double y
Definition: qgspoint.h:53
Polygon geometry type.
Definition: qgspolygon.h:34
static QgsProject * instance()
Returns the QgsProject singleton instance.
Definition: qgsproject.cpp:476
void setProperty(int key, const QgsProperty &property)
Adds a property to the collection and takes ownership of it.
QSet< QString > referencedFields(const QgsExpressionContext &context=QgsExpressionContext(), bool ignoreContext=false) const override
Returns the set of any fields referenced by the active properties from the collection.
bool hasActiveProperties() const override
Returns true if the collection has any active properties, or false if all properties within the colle...
bool prepare(const QgsExpressionContext &context=QgsExpressionContext()) const override
Prepares the collection against a specified expression context.
Definition for a property.
Definition: qgsproperty.h:46
@ Opacity
Opacity (0-100)
Definition: qgsproperty.h:61
A store for object properties.
Definition: qgsproperty.h:230
A rectangle specified with double values.
Definition: qgsrectangle.h:42
double yMaximum() const SIP_HOLDGIL
Returns the y maximum value (top side of rectangle).
Definition: qgsrectangle.h:193
double xMaximum() const SIP_HOLDGIL
Returns the x maximum value (right side of rectangle).
Definition: qgsrectangle.h:183
double xMinimum() const SIP_HOLDGIL
Returns the x minimum value (left side of rectangle).
Definition: qgsrectangle.h:188
double yMinimum() const SIP_HOLDGIL
Returns the y minimum value (bottom side of rectangle).
Definition: qgsrectangle.h:198
bool isNull() const
Test if the rectangle is null (all coordinates zero or after call to setMinimal()).
Definition: qgsrectangle.h:479
double height() const SIP_HOLDGIL
Returns the height of the rectangle.
Definition: qgsrectangle.h:230
double width() const SIP_HOLDGIL
Returns the width of the rectangle.
Definition: qgsrectangle.h:223
bool isEmpty() const
Returns true if the rectangle is empty.
Definition: qgsrectangle.h:469
bool contains(const QgsRectangle &rect) const SIP_HOLDGIL
Returns true when rectangle contains other rectangle.
Definition: qgsrectangle.h:363
Contains information about the context of a rendering operation.
void setForceVectorOutput(bool force)
Sets whether rendering operations should use vector operations instead of any faster raster shortcuts...
void setTextureOrigin(const QPointF &origin)
Sets the texture origin, which should be used as a brush transform when rendering using QBrush object...
bool hasRenderedFeatureHandlers() const
Returns true if the context has any rendered feature handlers.
double segmentationTolerance() const
Gets the segmentation tolerance applied when rendering curved geometries.
QPainter * painter()
Returns the destination QPainter for the render operation.
void setPainterFlagsUsingContext(QPainter *painter=nullptr) const
Sets relevant flags on a destination painter, using the flags and settings currently defined for the ...
double convertToPainterUnits(double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property=Qgis::RenderSubcomponentProperty::Generic) const
Converts a size from the specified units to painter units (pixels).
QgsExpressionContext & expressionContext()
Gets the expression context.
void setGeometry(const QgsAbstractGeometry *geometry)
Sets pointer to original (unsegmentized) geometry.
QgsGeometry featureClipGeometry() const
Returns the geometry to use to clip features at render time.
const QgsRectangle & extent() const
When rendering a map layer, calling this method returns the "clipping" extent for the layer (in the l...
bool testFlag(Qgis::RenderContextFlag flag) const
Check whether a particular flag is enabled.
bool forceVectorOutput() const
Returns true if rendering operations should use vector operations instead of any faster raster shortc...
long long currentFrame() const
Returns the current frame number of the map (in frames per second), for maps which are part of an ani...
void setIsGuiPreview(bool preview)
Sets GUI preview mode.
QgsRectangle mapExtent() const
Returns the original extent of the map being rendered.
QList< QgsRenderedFeatureHandlerInterface * > renderedFeatureHandlers() const
Returns the list of rendered feature handlers to use while rendering map layers.
void setFlag(Qgis::RenderContextFlag flag, bool on=true)
Enable or disable a particular flag (other flags are not affected)
double frameRate() const
Returns the frame rate of the map, for maps which are part of an animation.
const QgsVectorSimplifyMethod & vectorSimplifyMethod() const
Returns the simplification settings to use when rendering vector layers.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
bool isSymbolLayerEnabled(const QgsSymbolLayer *layer) const
When rendering a map layer in a second pass (for selective masking), some symbol layers may be disabl...
bool renderingStopped() const
Returns true if the rendering operation has been stopped and any ongoing rendering should be canceled...
static QgsRenderContext fromQPainter(QPainter *painter)
Creates a default render context given a pixel based QPainter destination.
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.
QgsCoordinateTransform coordinateTransform() const
Returns the current coordinate transform for the context.
Qgis::RenderContextFlags flags() const
Returns combination of flags used for rendering.
QgsAbstractGeometry::SegmentationToleranceType segmentationToleranceType() const
Gets segmentation tolerance type (maximum angle or maximum difference between curve and approximation...
An interface for classes which provider custom handlers for features rendered as part of a map render...
static QgsStyle * defaultStyle()
Returns default application-wide style.
Definition: qgsstyle.cpp:145
QList< QList< QPolygonF > > defaultPatchAsQPolygonF(Qgis::SymbolType type, QSizeF size) const
Returns the default patch geometry for the given symbol type and size as a set of QPolygonF objects (...
Definition: qgsstyle.cpp:1199
Contains settings relating to symbol animation.
Definition: qgssymbol.h:40
bool isAnimated() const
Returns true if the symbol is animated.
Definition: qgssymbol.h:63
double frameRate() const
Returns the symbol animation frame rate (in frames per second).
Definition: qgssymbol.h:77
static void drawVertexMarker(double x, double y, QPainter &p, Qgis::VertexMarkerType type, int markerSize)
Draws a vertex symbol at (painter) coordinates x, y.
static QString encodeSldUom(QgsUnitTypes::RenderUnit unit, double *scaleFactor)
Encodes a render unit into an SLD unit of measure string.
static QString encodeColor(const QColor &color)
@ PropertyLayerEnabled
Whether symbol layer is enabled.
virtual void startFeatureRender(const QgsFeature &feature, QgsRenderContext &context)
Called before the layer will be rendered for a particular feature.
QgsPaintEffect * paintEffect() const
Returns the current paint effect for the layer.
virtual void startRender(QgsSymbolRenderContext &context)=0
Called before a set of rendering operations commences on the supplied render context.
bool enabled() const
Returns true if symbol layer is enabled and will be drawn.
virtual void stopRender(QgsSymbolRenderContext &context)=0
Called after a set of rendering operations has finished on the supplied render context.
virtual void stopFeatureRender(const QgsFeature &feature, QgsRenderContext &context)
Called after the layer has been rendered for a particular feature.
void setSelected(bool selected)
Sets whether symbols should be rendered using the selected symbol coloring and style.
void setPatchShape(const QgsLegendPatchShape &shape)
Sets the symbol patch shape, to use if rendering symbol preview icons.
void setOriginalGeometryType(QgsWkbTypes::GeometryType type)
Sets the geometry type for the original feature geometry being rendered.
QgsRenderContext & renderContext()
Returns a reference to the context's render context.
Abstract base class for all rendered symbols.
Definition: qgssymbol.h:93
QgsSymbolLayerList cloneLayers() const
Retrieve a cloned list of all layers that make up this symbol.
Definition: qgssymbol.cpp:1147
QgsSymbolRenderContext * symbolRenderContext()
Returns the symbol render context.
Definition: qgssymbol.cpp:1824
QgsSymbolLayer * symbolLayer(int layer)
Returns the symbol layer at the specified index.
Definition: qgssymbol.cpp:756
Property
Data definable properties.
Definition: qgssymbol.h:130
@ PropertyOpacity
Opacity.
Definition: qgssymbol.h:131
void setDataDefinedProperty(Property key, const QgsProperty &property)
Sets a data defined property for the symbol.
Definition: qgssymbol.cpp:1199
void renderUsingLayer(QgsSymbolLayer *layer, QgsSymbolRenderContext &context, QgsWkbTypes::GeometryType geometryType=QgsWkbTypes::GeometryType::UnknownGeometry, const QPolygonF *points=nullptr, const QVector< QPolygonF > *rings=nullptr)
Renders a context using a particular symbol layer without passing in a geometry.
Definition: qgssymbol.cpp:1161
QgsPropertyCollection & dataDefinedProperties()
Returns a reference to the symbol's property collection, used for data defined overrides.
Definition: qgssymbol.h:622
static QPolygonF _getLineString(QgsRenderContext &context, const QgsCurve &curve, bool clipToExtent=true)
Creates a line string in screen coordinates from a QgsCurve in map coordinates.
Definition: qgssymbol.cpp:80
void setOutputUnit(QgsUnitTypes::RenderUnit unit) const
Sets the units to use for sizes and widths within the symbol.
Definition: qgssymbol.cpp:671
void stopRender(QgsRenderContext &context)
Ends the rendering process.
Definition: qgssymbol.cpp:873
qreal mOpacity
Symbol opacity (in the range 0 - 1)
Definition: qgssymbol.h:789
Q_DECL_DEPRECATED const QgsVectorLayer * mLayer
Definition: qgssymbol.h:805
static QPolygonF _getPolygonRing(QgsRenderContext &context, const QgsCurve &curve, bool clipToExtent, bool isExteriorRing=false, bool correctRingOrientation=false)
Creates a polygon ring in screen coordinates from a QgsCurve in map coordinates.
Definition: qgssymbol.cpp:301
QgsSymbolAnimationSettings & animationSettings()
Returns a reference to the symbol animation settings.
Definition: qgssymbol.cpp:689
static Qgis::SymbolType symbolTypeForGeometryType(QgsWkbTypes::GeometryType type)
Returns the default symbol type required for the specified geometry type.
Definition: qgssymbol.cpp:580
void drawPreviewIcon(QPainter *painter, QSize size, QgsRenderContext *customContext=nullptr, bool selected=false, const QgsExpressionContext *expressionContext=nullptr, const QgsLegendPatchShape *patchShape=nullptr)
Draws an icon of the symbol that occupies an area given by size using the specified painter.
Definition: qgssymbol.cpp:923
void renderVertexMarker(QPointF pt, QgsRenderContext &context, Qgis::VertexMarkerType currentVertexMarkerType, double currentVertexMarkerSize)
Render editing vertex marker at specified point.
Definition: qgssymbol.cpp:1829
static QPointF _getPoint(QgsRenderContext &context, const QgsPoint &point)
Creates a point in screen coordinates from a QgsPoint in map coordinates.
Definition: qgssymbol.h:718
static const QgsPropertiesDefinition & propertyDefinitions()
Returns the symbol property definitions.
Definition: qgssymbol.cpp:597
bool appendSymbolLayer(QgsSymbolLayer *layer)
Appends a symbol layer at the end of the current symbol layer list.
Definition: qgssymbol.cpp:779
static QgsSymbol * defaultSymbol(QgsWkbTypes::GeometryType geomType)
Returns a new default symbol for the specified geometry type.
Definition: qgssymbol.cpp:704
bool usesMapUnits() const
Returns true if the symbol has any components which use map unit based sizes.
Definition: qgssymbol.cpp:630
QgsUnitTypes::RenderUnit outputUnit() const
Returns the units to use for sizes and widths within the symbol.
Definition: qgssymbol.cpp:609
Qgis::SymbolFlags flags() const
Returns flags for the symbol.
Definition: qgssymbol.h:530
void toSld(QDomDocument &doc, QDomElement &element, QVariantMap props) const
Converts the symbol to a SLD representation.
Definition: qgssymbol.cpp:1134
void setColor(const QColor &color) const
Sets the color for the symbol.
Definition: qgssymbol.cpp:898
bool insertSymbolLayer(int index, QgsSymbolLayer *layer)
Inserts a symbol layer to specified index.
Definition: qgssymbol.cpp:766
QgsMapUnitScale mapUnitScale() const
Returns the map unit scale for the symbol.
Definition: qgssymbol.cpp:647
static QString symbolTypeToString(Qgis::SymbolType type)
Returns a translated string version of the specified symbol type.
Definition: qgssymbol.cpp:564
qreal opacity() const
Returns the opacity for the symbol.
Definition: qgssymbol.h:495
bool canCauseArtifactsBetweenAdjacentTiles() const
Returns true if the symbol rendering can cause visible artifacts across a single feature when the fea...
Definition: qgssymbol.cpp:1217
void setMapUnitScale(const QgsMapUnitScale &scale) const
Sets the map unit scale for the symbol.
Definition: qgssymbol.cpp:680
bool clipFeaturesToExtent() const
Returns whether features drawn by the symbol will be clipped to the render context's extent.
Definition: qgssymbol.h:552
QImage asImage(QSize size, QgsRenderContext *customContext=nullptr)
Returns an image of the symbol at the specified size.
Definition: qgssymbol.cpp:1040
static void _getPolygon(QPolygonF &pts, QVector< QPolygonF > &holes, QgsRenderContext &context, const QgsPolygon &polygon, bool clipToExtent=true, bool correctRingOrientation=false)
Creates a polygon in screen coordinates from a QgsPolygonXYin map coordinates.
Definition: qgssymbol.cpp:549
QString dump() const
Returns a string dump of the symbol's properties.
Definition: qgssymbol.cpp:1108
bool hasDataDefinedProperties() const
Returns whether the symbol utilizes any data defined properties.
Definition: qgssymbol.cpp:1204
bool deleteSymbolLayer(int index)
Removes and deletes the symbol layer at the specified index.
Definition: qgssymbol.cpp:789
virtual ~QgsSymbol()
Definition: qgssymbol.cpp:603
QSet< QString > usedAttributes(const QgsRenderContext &context) const
Returns a list of attributes required to render this feature.
Definition: qgssymbol.cpp:1182
QImage bigSymbolPreviewImage(QgsExpressionContext *expressionContext=nullptr, Qgis::SymbolPreviewFlags flags=Qgis::SymbolPreviewFlag::FlagIncludeCrosshairsForMarkerSymbols)
Returns a large (roughly 100x100 pixel) preview image for the symbol.
Definition: qgssymbol.cpp:1055
Qgis::SymbolType mType
Definition: qgssymbol.h:785
bool changeSymbolLayer(int index, QgsSymbolLayer *layer)
Deletes the current layer at the specified index and replaces it with layer.
Definition: qgssymbol.cpp:809
QgsSymbolLayer * takeSymbolLayer(int index)
Removes a symbol layer from the list and returns a pointer to it.
Definition: qgssymbol.cpp:800
Qgis::SymbolRenderHints mRenderHints
Definition: qgssymbol.h:791
bool mForceRHR
Definition: qgssymbol.h:801
QgsSymbolLayerList mLayers
Definition: qgssymbol.h:786
Q_DECL_DEPRECATED const QgsVectorLayer * layer() const
Definition: qgssymbol.cpp:1234
QgsSymbolAnimationSettings mAnimationSettings
Definition: qgssymbol.h:803
void startFeatureRender(const QgsFeature &feature, QgsRenderContext &context, int layer=-1)
Called before symbol layers will be rendered for a particular feature.
Definition: qgssymbol.cpp:1848
void renderFeature(const QgsFeature &feature, QgsRenderContext &context, int layer=-1, bool selected=false, bool drawVertexMarker=false, Qgis::VertexMarkerType currentVertexMarkerType=Qgis::VertexMarkerType::SemiTransparentCircle, double currentVertexMarkerSize=0.0) SIP_THROW(QgsCsException)
Render a feature.
Definition: qgssymbol.cpp:1283
QColor color() const
Returns the symbol's color.
Definition: qgssymbol.cpp:908
Qgis::SymbolType type() const
Returns the symbol's type.
Definition: qgssymbol.h:152
QgsSymbol(Qgis::SymbolType type, const QgsSymbolLayerList &layers)
Constructor for a QgsSymbol of the specified type.
Definition: qgssymbol.cpp:59
void setAnimationSettings(const QgsSymbolAnimationSettings &settings)
Sets a the symbol animation settings.
Definition: qgssymbol.cpp:699
void startRender(QgsRenderContext &context, const QgsFields &fields=QgsFields())
Begins the rendering process for the symbol.
Definition: qgssymbol.cpp:825
Q_DECL_DEPRECATED void setLayer(const QgsVectorLayer *layer)
Definition: qgssymbol.cpp:1227
void exportImage(const QString &path, const QString &format, QSize size)
Export the symbol as an image format, to the specified path and with the given size.
Definition: qgssymbol.cpp:1020
void stopFeatureRender(const QgsFeature &feature, QgsRenderContext &context, int layer=-1)
Called after symbol layers have been rendered for a particular feature.
Definition: qgssymbol.cpp:1872
RenderUnit
Rendering size units.
Definition: qgsunittypes.h:168
@ RenderUnknownUnit
Mixed or unknown units.
Definition: qgsunittypes.h:175
@ RenderMillimeters
Millimeters.
Definition: qgsunittypes.h:169
Represents a vector layer which manages a vector based data sets.
QgsVectorLayer * clone() const override
Returns a new instance equivalent to this one.
double tolerance() const
Gets the tolerance of simplification in map units. Represents the maximum distance in map units betwe...
bool forceLocalOptimization() const
Gets where the simplification executes, after fetch the geometries from provider, or when supported,...
SimplifyHints simplifyHints() const
Gets the simplification hints of the vector layer managed.
SimplifyAlgorithm simplifyAlgorithm() const
Gets the local simplification algorithm of the vector layer managed.
GeometryType
The geometry types are used to group QgsWkbTypes::Type in a coarse way.
Definition: qgswkbtypes.h:141
@ GeometryCollection
Definition: qgswkbtypes.h:79
static QString displayString(Type type) SIP_HOLDGIL
Returns a non-translated display string type for a WKB type, e.g., the geometry name used in WKT geom...
static bool isCurvedType(Type type) SIP_HOLDGIL
Returns true if the WKB type is a curved type or can contain curved geometries.
Definition: qgswkbtypes.h:911
static Type flatType(Type type) SIP_HOLDGIL
Returns the flat type for a WKB type.
Definition: qgswkbtypes.h:732
Contains geos related utilities and functions.
Definition: qgsgeos.h:37
#define FALLTHROUGH
Definition: qgis.h:3526
#define Q_NOWARN_DEPRECATED_POP
Definition: qgis.h:3499
QString qgsDoubleToString(double a, int precision=17)
Returns a string representation of a double.
Definition: qgis.h:2854
#define Q_NOWARN_DEPRECATED_PUSH
Definition: qgis.h:3498
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition: qgis.h:2915
#define QgsDebugMsgLevel(str, level)
Definition: qgslogger.h:39
#define QgsDebugMsg(str)
Definition: qgslogger.h:38
QMap< int, QgsPropertyDefinition > QgsPropertiesDefinition
Definition of available properties.
QList< QgsSymbolLayer * > QgsSymbolLayerList
Definition: qgssymbol.h:29
Single variable definition for use within a QgsExpressionContextScope.
Utility class for identifying a unique vertex within a geometry.
Definition: qgsvertexid.h:31