QGIS API Documentation 3.27.0-Master (1d7a28cfd2)
qgsannotationpolygonitem.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsannotationpolygonitem.cpp
3 ----------------
4 begin : July 2020
5 copyright : (C) 2020 by Nyall Dawson
6 email : nyall dot dawson at gmail dot com
7 ***************************************************************************/
8
9/***************************************************************************
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 ***************************************************************************/
17
19#include "qgssymbol.h"
20#include "qgssymbollayerutils.h"
21#include "qgssurface.h"
22#include "qgsfillsymbol.h"
25
28 , mPolygon( polygon )
29 , mSymbol( std::make_unique< QgsFillSymbol >() )
30{
31
32}
33
35
37{
38 return QStringLiteral( "polygon" );
39}
40
42{
43
44 auto transformRing = [&context]( QPolygonF & pts )
45 {
46 //transform the QPolygonF to screen coordinates
47 if ( context.coordinateTransform().isValid() )
48 {
49 try
50 {
52 }
53 catch ( QgsCsException & )
54 {
55 // we don't abort the rendering here, instead we remove any invalid points and just plot those which ARE valid
56 }
57 }
58
59 // remove non-finite points, e.g. infinite or NaN points caused by reprojecting errors
60 pts.erase( std::remove_if( pts.begin(), pts.end(),
61 []( const QPointF point )
62 {
63 return !std::isfinite( point.x() ) || !std::isfinite( point.y() );
64 } ), pts.end() );
65
66 QPointF *ptr = pts.data();
67 for ( int i = 0; i < pts.size(); ++i, ++ptr )
68 {
69 context.mapToPixel().transformInPlace( ptr->rx(), ptr->ry() );
70 }
71 };
72
73 QPolygonF exterior = mPolygon->exteriorRing()->asQPolygonF();
74 transformRing( exterior );
75 QVector<QPolygonF> rings;
76 rings.reserve( mPolygon->numInteriorRings() );
77 for ( int i = 0; i < mPolygon->numInteriorRings(); ++i )
78 {
79 QPolygonF ring = mPolygon->interiorRing( i )->asQPolygonF();
80 transformRing( ring );
81 rings.append( ring );
82 }
83
84 mSymbol->startRender( context );
85 mSymbol->renderPolygon( exterior, rings.empty() ? nullptr : &rings, nullptr, context );
86 mSymbol->stopRender( context );
87}
88
89bool QgsAnnotationPolygonItem::writeXml( QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context ) const
90{
91 element.setAttribute( QStringLiteral( "wkt" ), mPolygon->asWkt() );
92 element.appendChild( QgsSymbolLayerUtils::saveSymbol( QStringLiteral( "lineSymbol" ), mSymbol.get(), document, context ) );
93
94 writeCommonProperties( element, document, context );
95 return true;
96}
97
98QList<QgsAnnotationItemNode> QgsAnnotationPolygonItem::nodes() const
99{
100 QList< QgsAnnotationItemNode > res;
101
102 auto processRing = [&res]( const QgsCurve * ring, int ringId )
103 {
104 // we don't want a duplicate node for the closed ring vertex
105 const int count = ring->isClosed() ? ring->numPoints() - 1 : ring->numPoints();
106 res.reserve( res.size() + count );
107 for ( int i = 0; i < count; ++i )
108 {
109 res << QgsAnnotationItemNode( QgsVertexId( 0, ringId, i ), QgsPointXY( ring->xAt( i ), ring->yAt( i ) ), Qgis::AnnotationItemNodeType::VertexHandle );
110 }
111 };
112
113 if ( const QgsCurve *ring = mPolygon->exteriorRing() )
114 {
115 processRing( ring, 0 );
116 }
117 for ( int i = 0; i < mPolygon->numInteriorRings(); ++i )
118 {
119 processRing( mPolygon->interiorRing( i ), i + 1 );
120 }
121
122 return res;
123}
124
126{
127 switch ( operation->type() )
128 {
130 {
131 QgsAnnotationItemEditOperationMoveNode *moveOperation = dynamic_cast< QgsAnnotationItemEditOperationMoveNode * >( operation );
132 if ( mPolygon->moveVertex( moveOperation->nodeId(), QgsPoint( moveOperation->after() ) ) )
134 break;
135 }
136
138 {
139 QgsAnnotationItemEditOperationDeleteNode *deleteOperation = qgis::down_cast< QgsAnnotationItemEditOperationDeleteNode * >( operation );
140 if ( mPolygon->deleteVertex( deleteOperation->nodeId() ) )
142 break;
143 }
144
146 {
147 QgsAnnotationItemEditOperationAddNode *addOperation = qgis::down_cast< QgsAnnotationItemEditOperationAddNode * >( operation );
148
149 QgsPoint segmentPoint;
150 QgsVertexId endOfSegmentVertex;
151 mPolygon->closestSegment( addOperation->point(), segmentPoint, endOfSegmentVertex );
152 if ( mPolygon->insertVertex( endOfSegmentVertex, segmentPoint ) )
154 break;
155 }
156
158 {
159 QgsAnnotationItemEditOperationTranslateItem *moveOperation = qgis::down_cast< QgsAnnotationItemEditOperationTranslateItem * >( operation );
160 const QTransform transform = QTransform::fromTranslate( moveOperation->translationX(), moveOperation->translationY() );
161 mPolygon->transform( transform );
163 }
164 }
165
167}
168
170{
171 switch ( operation->type() )
172 {
174 {
175 QgsAnnotationItemEditOperationMoveNode *moveOperation = dynamic_cast< QgsAnnotationItemEditOperationMoveNode * >( operation );
176 std::unique_ptr< QgsCurvePolygon > modifiedPolygon( mPolygon->clone() );
177 if ( modifiedPolygon->moveVertex( moveOperation->nodeId(), QgsPoint( moveOperation->after() ) ) )
178 {
179 return new QgsAnnotationItemEditOperationTransientResults( QgsGeometry( std::move( modifiedPolygon ) ) );
180 }
181 break;
182 }
183
185 {
186 QgsAnnotationItemEditOperationTranslateItem *moveOperation = qgis::down_cast< QgsAnnotationItemEditOperationTranslateItem * >( operation );
187 const QTransform transform = QTransform::fromTranslate( moveOperation->translationX(), moveOperation->translationY() );
188 std::unique_ptr< QgsCurvePolygon > modifiedPolygon( mPolygon->clone() );
189 modifiedPolygon->transform( transform );
190 return new QgsAnnotationItemEditOperationTransientResults( QgsGeometry( std::move( modifiedPolygon ) ) );
191 }
192
195 break;
196 }
197 return nullptr;
198}
199
201{
202 return new QgsAnnotationPolygonItem( new QgsPolygon() );
203}
204
205bool QgsAnnotationPolygonItem::readXml( const QDomElement &element, const QgsReadWriteContext &context )
206{
207 const QString wkt = element.attribute( QStringLiteral( "wkt" ) );
209 if ( const QgsCurvePolygon *polygon = qgsgeometry_cast< const QgsCurvePolygon * >( geometry.constGet() ) )
210 mPolygon.reset( polygon->clone() );
211
212 const QDomElement symbolElem = element.firstChildElement( QStringLiteral( "symbol" ) );
213 if ( !symbolElem.isNull() )
214 setSymbol( QgsSymbolLayerUtils::loadSymbol< QgsFillSymbol >( symbolElem, context ) );
215
216 readCommonProperties( element, context );
217 return true;
218}
219
221{
222 std::unique_ptr< QgsAnnotationPolygonItem > item = std::make_unique< QgsAnnotationPolygonItem >( mPolygon->clone() );
223 item->setSymbol( mSymbol->clone() );
224 item->copyCommonProperties( this );;
225 return item.release();
226}
227
229{
230 return mPolygon->boundingBox();
231}
232
234{
235 return mSymbol.get();
236}
237
239{
240 mSymbol.reset( symbol );
241}
@ VertexHandle
Node is a handle for manipulating vertices.
AnnotationItemEditOperationResult
Results from an edit operation on an annotation item.
Definition: qgis.h:1199
@ Invalid
Operation has invalid parameters for the item, no change occurred.
@ Success
Item was modified successfully.
@ ItemCleared
The operation results in the item being cleared, and the item should be removed from the layer as a r...
Abstract base class for annotation item edit operations.
@ TranslateItem
Translate (move) an item.
virtual Type type() const =0
Returns the operation type.
Annotation item edit operation consisting of adding a node.
QgsPoint point() const
Returns the node position (in layer coordinates).
Annotation item edit operation consisting of deleting a node.
QgsVertexId nodeId() const
Returns the deleted node ID.
Annotation item edit operation consisting of moving a node.
QgsPoint after() const
Returns the node position after the move occurred (in layer coordinates).
QgsVertexId nodeId() const
Returns the associated node ID.
Encapsulates the transient results of an in-progress annotation edit operation.
Annotation item edit operation consisting of translating (moving) an item.
double translationY() const
Returns the y-axis translation, in layer units.
double translationX() const
Returns the x-axis translation, in layer units.
Contains information about a node used for editing an annotation item.
Abstract base class for annotation items which are drawn with QgsAnnotationLayers.
bool writeCommonProperties(QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context) const
Writes common properties from the base class into an XML element.
bool readCommonProperties(const QDomElement &element, const QgsReadWriteContext &context)
Reads common properties from the base class from the given DOM element.
An annotation item which renders a fill symbol for a polygon geometry.
bool readXml(const QDomElement &element, const QgsReadWriteContext &context) override
Reads the item's state from the given DOM element.
void render(QgsRenderContext &context, QgsFeedback *feedback) override
Renders the item to the specified render context.
const QgsCurvePolygon * geometry() const
Returns the geometry of the item.
QgsAnnotationItemEditOperationTransientResults * transientEditResults(QgsAbstractAnnotationItemEditOperation *operation) override
Retrieves the results of a transient (in progress) edit operation on the item.
void setSymbol(QgsFillSymbol *symbol)
Sets the symbol used to render the polygon item.
const QgsFillSymbol * symbol() const
Returns the symbol used to render the item.
QgsRectangle boundingBox() const override
Returns the bounding box of the item's geographic location, in the parent layer's coordinate referenc...
QString type() const override
Returns a unique (untranslated) string identifying the type of item.
bool writeXml(QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context) const override
Writes the item's state into an XML element.
Qgis::AnnotationItemEditOperationResult applyEdit(QgsAbstractAnnotationItemEditOperation *operation) override
Applies an edit operation to the item.
QgsAnnotationPolygonItem * clone() override
Returns a clone of the item.
QList< QgsAnnotationItemNode > nodes() const override
Returns the nodes for the item, used for editing the item.
~QgsAnnotationPolygonItem() override
static QgsAnnotationPolygonItem * create()
Creates a new polygon annotation item.
QgsAnnotationPolygonItem(QgsCurvePolygon *polygon)
Constructor for QgsAnnotationPolygonItem, with the specified polygon geometry.
void transformPolygon(QPolygonF &polygon, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward) const SIP_THROW(QgsCsException)
Transforms a polygon to the destination coordinate system.
bool isValid() const
Returns true if the coordinate transform is valid, ie both the source and destination CRS have been s...
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgsexception.h:66
Curve polygon geometry type.
Abstract base class for curved geometry type.
Definition: qgscurve.h:36
virtual int numPoints() const =0
Returns the number of points in the curve.
virtual bool isClosed() const SIP_HOLDGIL
Returns true if the curve is closed.
Definition: qgscurve.cpp:53
virtual double xAt(int index) const =0
Returns the x-coordinate of the specified node in the line string.
virtual double yAt(int index) const =0
Returns the y-coordinate of the specified node in the line string.
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition: qgsfeedback.h:45
A fill symbol type, for rendering Polygon and MultiPolygon geometries.
Definition: qgsfillsymbol.h:30
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:164
static QgsGeometry fromWkt(const QString &wkt)
Creates a new geometry from a WKT string.
void transformInPlace(double &x, double &y) const
Transforms device coordinates to map coordinates.
A class to represent a 2D point.
Definition: qgspointxy.h:59
Point geometry type, with support for z-dimension and m-values.
Definition: qgspoint.h:49
Polygon geometry type.
Definition: qgspolygon.h:34
The class is used as a container of context for various read/write operations on other objects.
A rectangle specified with double values.
Definition: qgsrectangle.h:42
Contains information about the context of a rendering operation.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
QgsCoordinateTransform coordinateTransform() const
Returns the current coordinate transform for the context.
static QDomElement saveSymbol(const QString &symbolName, const QgsSymbol *symbol, QDomDocument &doc, const QgsReadWriteContext &context)
Writes a symbol definition to XML.
Utility class for identifying a unique vertex within a geometry.
Definition: qgsvertexid.h:31