QGIS API Documentation  3.8.0-Zanzibar (11aff65)
qgshighlight.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgshighlight.cpp - widget to highlight features on the map
3  --------------------------------------
4  Date : 02-03-2011
5  Copyright : (C) 2011 by Juergen E. Fischer, norBIT GmbH
6  Email : jef at norbit dot de
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 <QImage>
17 
18 #include "qgsmarkersymbollayer.h"
19 #include "qgslinesymbollayer.h"
20 
21 #include "qgscoordinatetransform.h"
22 #include "qgsfillsymbollayer.h"
23 #include "qgsgeometry.h"
24 #include "qgshighlight.h"
25 #include "qgsmapcanvas.h"
26 #include "qgsmaplayer.h"
27 #include "qgsrendercontext.h"
28 #include "qgssymbollayer.h"
29 #include "qgssymbol.h"
30 #include "qgsvectorlayer.h"
31 #include "qgsrenderer.h"
33 
34 /* Few notes about highlighting (RB):
35  - The highlight fill must always be partially transparent because above highlighted layer
36  may be another layer which must remain partially visible.
37  - Because single highlight color does not work well with layers using similar layer color
38  there were considered various possibilities but no optimal solution was found.
39  What does not work:
40  - lighter/darker color: it would work more or less for fully opaque highlight, but
41  overlaying transparent lighter color over original has small visual effect.
42  - complemetary color: mixing transparent (128) complement color with original color
43  results in grey for all colors
44  - contrast line style/ fill pattern: impression is not highligh but just different style
45  - line buffer with contrast (or 2 contrast) color: the same as with patterns, no highlight impression
46  - fill with highlight or contrast color but opaque and using pattern
47  (e.g. Qt::Dense7Pattern): again no highlight impression
48 */
49 
51  : QgsMapCanvasItem( mapCanvas )
52  , mLayer( layer )
53 {
54  mGeometry = !geom.isNull() ? new QgsGeometry( geom ) : nullptr;
55  init();
56 }
57 
59  : QgsMapCanvasItem( mapCanvas )
60  , mLayer( layer )
61  , mFeature( feature )
62 {
63  init();
64 }
65 
66 void QgsHighlight::init()
67 {
69  if ( ct.isValid() )
70  {
71  if ( mGeometry )
72  {
73  mGeometry->transform( ct );
74  }
75  else if ( mFeature.hasGeometry() )
76  {
77  QgsGeometry g = mFeature.geometry();
78  g.transform( ct );
79  mFeature.setGeometry( g );
80  }
81  }
82 
83  updateRect();
84  update();
85  setColor( QColor( Qt::lightGray ) );
86 }
87 
89 {
90  delete mGeometry;
91 }
92 
93 
94 void QgsHighlight::setColor( const QColor &color )
95 {
96  mColor = color;
97  mPen.setColor( color );
98  QColor fillColor( color.red(), color.green(), color.blue(), 63 );
99  mBrush.setColor( fillColor );
100  mBrush.setStyle( Qt::SolidPattern );
101 }
102 
104 {
105  mFillColor = fillColor;
106  mBrush.setColor( fillColor );
107  mBrush.setStyle( Qt::SolidPattern );
108 }
109 
110 std::unique_ptr<QgsFeatureRenderer> QgsHighlight::createRenderer( QgsRenderContext &context, const QColor &color, const QColor &fillColor )
111 {
112  std::unique_ptr<QgsFeatureRenderer> renderer;
113  QgsVectorLayer *layer = qobject_cast<QgsVectorLayer *>( mLayer );
114  if ( layer && layer->renderer() )
115  {
116  renderer.reset( layer->renderer()->clone() );
117  }
118  if ( renderer )
119  {
120  const auto constSymbols = renderer->symbols( context );
121  for ( QgsSymbol *symbol : constSymbols )
122  {
123  if ( !symbol ) continue;
124  setSymbol( symbol, context, color, fillColor );
125  }
126  }
127  return renderer;
128 }
129 
130 void QgsHighlight::setSymbol( QgsSymbol *symbol, const QgsRenderContext &context, const QColor &color, const QColor &fillColor )
131 {
132  if ( !symbol ) return;
133 
134 
135  for ( int i = symbol->symbolLayerCount() - 1; i >= 0; i-- )
136  {
137  QgsSymbolLayer *symbolLayer = symbol->symbolLayer( i );
138  if ( !symbolLayer ) continue;
139 
140  if ( symbolLayer->subSymbol() )
141  {
142  setSymbol( symbolLayer->subSymbol(), context, color, fillColor );
143  }
144  else
145  {
146  symbolLayer->setColor( color ); // line symbology layers
147  symbolLayer->setStrokeColor( color ); // marker and fill symbology layers
148  symbolLayer->setFillColor( fillColor ); // marker and fill symbology layers
149 
150  // Data defined widths overwrite what we set here (widths do not work with data defined)
151  QgsSimpleMarkerSymbolLayer *simpleMarker = dynamic_cast<QgsSimpleMarkerSymbolLayer *>( symbolLayer );
152  if ( simpleMarker )
153  {
154  simpleMarker->setStrokeWidth( getSymbolWidth( context, simpleMarker->strokeWidth(), simpleMarker->strokeWidthUnit() ) );
155  }
156  QgsSimpleLineSymbolLayer *simpleLine = dynamic_cast<QgsSimpleLineSymbolLayer *>( symbolLayer );
157  if ( simpleLine )
158  {
159  simpleLine->setWidth( getSymbolWidth( context, simpleLine->width(), simpleLine->widthUnit() ) );
160  }
161  QgsSimpleFillSymbolLayer *simpleFill = dynamic_cast<QgsSimpleFillSymbolLayer *>( symbolLayer );
162  if ( simpleFill )
163  {
164  simpleFill->setStrokeWidth( getSymbolWidth( context, simpleFill->strokeWidth(), simpleFill->outputUnit() ) );
165  }
168  }
169  }
170 }
171 
172 double QgsHighlight::getSymbolWidth( const QgsRenderContext &context, double width, QgsUnitTypes::RenderUnit unit )
173 {
174  // if necessary scale mm to map units
175  double scale = 1.;
176  if ( unit == QgsUnitTypes::RenderMapUnits )
177  {
179  }
180  width = std::max( width + 2 * mBuffer * scale, mMinWidth * scale );
181  return width;
182 }
183 
185 {
186  mWidth = width;
187  mPen.setWidth( width );
188 }
189 
190 void QgsHighlight::paintPoint( QPainter *p, const QgsPointXY &point )
191 {
192  QPolygonF r( 5 );
193 
194  double d = mMapCanvas->extent().width() * 0.005;
195  r[0] = toCanvasCoordinates( point + QgsVector( -d, -d ) ) - pos();
196  r[1] = toCanvasCoordinates( point + QgsVector( d, -d ) ) - pos();
197  r[2] = toCanvasCoordinates( point + QgsVector( d, d ) ) - pos();
198  r[3] = toCanvasCoordinates( point + QgsVector( -d, d ) ) - pos();
199  r[4] = r[0];
200 
201  p->drawPolygon( r );
202 }
203 
204 void QgsHighlight::paintLine( QPainter *p, QgsPolylineXY line )
205 {
206  QPolygonF polygon( line.size() );
207 
208  for ( int i = 0; i < line.size(); i++ )
209  {
210  polygon[i] = toCanvasCoordinates( line[i] ) - pos();
211  }
212 
213  p->drawPolyline( polygon );
214 }
215 
216 void QgsHighlight::paintPolygon( QPainter *p, const QgsPolygonXY &polygon )
217 {
218  // OddEven fill rule by default
219  QPainterPath path;
220 
221  p->setPen( mPen );
222  p->setBrush( mBrush );
223 
224  for ( const auto &sourceRing : polygon )
225  {
226  if ( sourceRing.empty() )
227  continue;
228 
229  QPolygonF ring;
230  ring.reserve( sourceRing.size() + 1 );
231 
232  QPointF lastVertex;
233  for ( const auto &sourceVertex : sourceRing )
234  {
235  //adding point only if it is more than a pixel apart from the previous one
236  const QPointF curVertex = toCanvasCoordinates( sourceVertex ) - pos();
237  if ( ring.isEmpty() || std::abs( ring.back().x() - curVertex.x() ) > 1 || std::abs( ring.back().y() - curVertex.y() ) > 1 )
238  {
239  ring.push_back( curVertex );
240  }
241  lastVertex = curVertex;
242  }
243 
244  ring.push_back( ring.at( 0 ) );
245 
246  path.addPolygon( ring );
247  }
248 
249  p->drawPath( path );
250 }
251 
253 {
254  if ( isVisible() ) updateRect();
255 }
256 
257 void QgsHighlight::paint( QPainter *p )
258 {
259  if ( mGeometry )
260  {
261  p->setPen( mPen );
262  p->setBrush( mBrush );
263 
264  switch ( mGeometry->type() )
265  {
267  {
268  if ( !mGeometry->isMultipart() )
269  {
270  paintPoint( p, mGeometry->asPoint() );
271  }
272  else
273  {
274  QgsMultiPointXY m = mGeometry->asMultiPoint();
275  for ( int i = 0; i < m.size(); i++ )
276  {
277  paintPoint( p, m[i] );
278  }
279  }
280  }
281  break;
282 
284  {
285  if ( !mGeometry->isMultipart() )
286  {
287  paintLine( p, mGeometry->asPolyline() );
288  }
289  else
290  {
291  QgsMultiPolylineXY m = mGeometry->asMultiPolyline();
292 
293  for ( int i = 0; i < m.size(); i++ )
294  {
295  paintLine( p, m[i] );
296  }
297  }
298  break;
299  }
300 
302  {
303  if ( !mGeometry->isMultipart() )
304  {
305  paintPolygon( p, mGeometry->asPolygon() );
306  }
307  else
308  {
309  QgsMultiPolygonXY m = mGeometry->asMultiPolygon();
310  for ( int i = 0; i < m.size(); i++ )
311  {
312  paintPolygon( p, m[i] );
313  }
314  }
315  break;
316  }
317 
320  return;
321  }
322  }
323  else if ( mFeature.hasGeometry() )
324  {
325  QgsVectorLayer *layer = qobject_cast<QgsVectorLayer *>( mLayer );
326  if ( !layer )
327  return;
328  QgsMapSettings mapSettings = mMapCanvas->mapSettings();
329  QgsRenderContext context = QgsRenderContext::fromMapSettings( mapSettings );
331 
332 
333  // Because lower level outlines must be covered by upper level fill color
334  // we render first with temporary opaque color, which is then replaced
335  // by final transparent fill color.
336  QColor tmpColor( 255, 0, 0, 255 );
337  QColor tmpFillColor( 0, 255, 0, 255 );
338 
339  std::unique_ptr< QgsFeatureRenderer > renderer = createRenderer( context, tmpColor, tmpFillColor );
340  if ( layer && renderer )
341  {
342 
343  QSize imageSize( mMapCanvas->mapSettings().outputSize() );
344  QImage image = QImage( imageSize.width(), imageSize.height(), QImage::Format_ARGB32 );
345  image.fill( 0 );
346  QPainter imagePainter( &image );
347  imagePainter.setRenderHint( QPainter::Antialiasing, true );
348 
349  context.setPainter( &imagePainter );
350 
351  renderer->startRender( context, layer->fields() );
352  context.expressionContext().setFeature( mFeature );
353  renderer->renderFeature( mFeature, context );
354  renderer->stopRender( context );
355 
356  imagePainter.end();
357 
358  // true output color
359  int penRed = mPen.color().red();
360  int penGreen = mPen.color().green();
361  int penBlue = mPen.color().blue();
362  // coefficient to subtract alpha using green (temporary fill)
363  double k = ( 255. - mBrush.color().alpha() ) / 255.;
364  QRgb *line = nullptr;
365  for ( int r = 0; r < image.height(); r++ )
366  {
367  line = reinterpret_cast<QRgb *>( image.scanLine( r ) );
368  for ( int c = 0; c < image.width(); c++ )
369  {
370  int alpha = qAlpha( line[c] );
371  if ( alpha > 0 )
372  {
373  int green = qGreen( line[c] );
374  line[c] = qRgba( penRed, penGreen, penBlue, qBound<int>( 0, alpha - ( green * k ), 255 ) );
375  }
376  }
377  }
378 
379  p->drawImage( 0, 0, image );
380  }
381  }
382 }
383 
385 {
386  if ( mGeometry )
387  {
388  QgsRectangle r = mGeometry->boundingBox();
389 
390  if ( r.isEmpty() )
391  {
392  double d = mMapCanvas->extent().width() * 0.005;
393  r.setXMinimum( r.xMinimum() - d );
394  r.setYMinimum( r.yMinimum() - d );
395  r.setXMaximum( r.xMaximum() + d );
396  r.setYMaximum( r.yMaximum() + d );
397  }
398 
399  setRect( r );
400  setVisible( mGeometry );
401  }
402  else if ( mFeature.hasGeometry() )
403  {
404  // We are currently using full map canvas extent for two reasons:
405  // 1) currently there is no method in QgsFeatureRenderer to get rendered feature
406  // bounding box
407  // 2) using different extent would result in shifted fill patterns
408 
409  // This is an hack to pass QgsMapCanvasItem::setRect what it
410  // expects (encoding of position and size of the item)
412  QgsPointXY topLeft = m2p.toMapCoordinates( 0, 0 );
413  double res = m2p.mapUnitsPerPixel();
414  QSizeF imageSize = mMapCanvas->mapSettings().outputSize();
415  QgsRectangle rect( topLeft.x(), topLeft.y(), topLeft.x() + imageSize.width()*res, topLeft.y() - imageSize.height()*res );
416  setRect( rect );
417 
418  setVisible( true );
419  }
420  else
421  {
422  setRect( QgsRectangle() );
423  }
424 }
A rectangle specified with double values.
Definition: qgsrectangle.h:41
Base class for all map layer types.
Definition: qgsmaplayer.h:78
QgsMapLayer * layer() const
Returns the layer for which this highlight has been created.
Definition: qgshighlight.h:139
QgsHighlight(QgsMapCanvas *mapCanvas, const QgsGeometry &geom, QgsMapLayer *layer)
Constructor for QgsHighlight.
void updatePosition() override
called on changed extent or resize event to update position of the item
QgsRectangle rect() const
returns canvas item rectangle in map units
bool isMultipart() const
Returns true if WKB of the geometry is of WKBMulti* type.
QColor color() const
Returns the line/stroke color.
Definition: qgshighlight.h:82
Abstract base class for all rendered symbols.
Definition: qgssymbol.h:61
OperationResult transform(const QgsCoordinateTransform &ct, QgsCoordinateTransform::TransformDirection direction=QgsCoordinateTransform::ForwardTransform, bool transformZ=false) SIP_THROW(QgsCsException)
Transforms this geometry as described by the coordinate transform ct.
virtual QgsSymbol * subSymbol()
Returns the symbol&#39;s sub symbol, if present.
void setXMaximum(double x)
Set the maximum x value.
Definition: qgsrectangle.h:135
Simple marker symbol layer, consisting of a rendered shape with solid fill color and an stroke...
virtual void setWidth(double width)
Sets the width of the line symbol layer.
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
double y
Definition: qgspointxy.h:48
A class to represent a 2D point.
Definition: qgspointxy.h:43
A simple line symbol layer, which renders lines using a line in a variety of styles (e...
void setFillColor(const QColor &fillColor)
Fill color for the highlight.
QVector< QgsPolylineXY > QgsPolygonXY
Polygon: first item of the list is outer ring, inner rings (if any) start from second item...
Definition: qgsgeometry.h:73
An abstract class for items that can be placed on the map canvas.
void setStrokeWidth(double w)
Sets the width of the marker&#39;s stroke.
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:111
int symbolLayerCount() const
Returns the total number of symbol layers contained in the symbol.
Definition: qgssymbol.h:150
QVector< QgsPointXY > QgsMultiPointXY
A collection of QgsPoints that share a common collection of attributes.
Definition: qgsgeometry.h:79
The feature class encapsulates a single feature including its id, geometry and a list of field/values...
Definition: qgsfeature.h:55
bool hasGeometry() const
Returns true if the feature has an associated geometry.
Definition: qgsfeature.cpp:197
Map canvas is a class for displaying all GIS data types on a canvas.
Definition: qgsmapcanvas.h:73
~QgsHighlight() override
virtual double width() const
Returns the estimated width for the line symbol layer.
bool isValid() const
Returns true if the coordinate transform is valid, ie both the source and destination CRS have been s...
QVector< QgsPolygonXY > QgsMultiPolygonXY
A collection of QgsPolygons that share a common collection of attributes.
Definition: qgsgeometry.h:90
void setStrokeWidth(double strokeWidth)
double strokeWidth() const
Returns the width of the marker&#39;s stroke.
The QgsMapSettings class contains configuration for rendering of the map.
virtual void setColor(const QColor &color)
The fill color.
QVector< QgsPolylineXY > QgsMultiPolylineXY
A collection of QgsPolylines that share a common collection of attributes.
Definition: qgsgeometry.h:83
QgsMultiPolylineXY asMultiPolyline() const
Returns the contents of the geometry as a multi-linestring.
QgsCoordinateTransform layerTransform(const QgsMapLayer *layer) const
Returns the coordinate transform from layer&#39;s CRS to destination CRS.
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
Perform transforms between map coordinates and device coordinates.
Definition: qgsmaptopixel.h:37
QgsFields fields() const FINAL
Returns the list of fields of this layer.
QgsUnitTypes::RenderUnit widthUnit() const
Returns the units for the line&#39;s width.
bool isEmpty() const
Returns true if the rectangle is empty.
Definition: qgsrectangle.h:426
QgsPolygonXY asPolygon() const
Returns the contents of the geometry as a polygon.
double width() const
Returns the width of the rectangle.
Definition: qgsrectangle.h:202
void setYMinimum(double y)
Set the minimum y value.
Definition: qgsrectangle.h:140
void updateRect()
recalculates needed rectangle
QgsRectangle extent() const
Returns the current zoom extent of the map canvas.
void setRect(const QgsRectangle &r, bool resetRotation=true)
sets canvas item rectangle in map units
void setPainter(QPainter *p)
Sets the destination QPainter for the render operation.
QColor fillColor() const
Returns the fill color.
Definition: qgshighlight.h:93
QgsFeatureRenderer * renderer()
Returns renderer.
double mapUnitsPerPixel() const
Returns current map units per pixel.
A store for object properties.
Definition: qgsproperty.h:229
QgsSymbolLayer * symbolLayer(int layer)
Returns a specific symbol layer contained in the symbol.
Definition: qgssymbol.cpp:358
const QgsMapToPixel & mapToPixel() const
double x
Definition: qgspointxy.h:47
virtual void setStrokeColor(const QColor &color)
Set stroke color.
A class to represent a vector.
Definition: qgsvector.h:29
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
Definition: qgsrectangle.h:177
QgsExpressionContext & expressionContext()
Gets the expression context.
double xMaximum() const
Returns the x maximum value (right side of rectangle).
Definition: qgsrectangle.h:162
const QgsMapSettings & mapSettings() const
Gets access to properties used for map rendering.
QgsUnitTypes::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
QgsUnitTypes::RenderUnit strokeWidthUnit() const
Returns the unit for the width of the marker&#39;s stroke.
QVector< QgsPointXY > QgsPolylineXY
Polyline as represented as a vector of two-dimensional points.
Definition: qgsgeometry.h:49
Contains information about the context of a rendering operation.
double convertToPainterUnits(double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale()) const
Converts a size from the specified units to painter units (pixels).
virtual void setFillColor(const QColor &color)
Set fill color.
QgsPointXY asPoint() const
Returns the contents of the geometry as a 2-dimensional point.
void setColor(const QColor &color)
Set line/stroke to color, polygon fill to color with alpha = 63.
void setYMaximum(double y)
Set the maximum y value.
Definition: qgsrectangle.h:145
static QgsRenderContext fromMapSettings(const QgsMapSettings &mapSettings)
create initialized QgsRenderContext instance from given QgsMapSettings
QgsMapCanvas * mMapCanvas
pointer to map canvas
QgsRectangle boundingBox() const
Returns the bounding box of the geometry.
void paint(QPainter *p) override
function to be implemented by derived classes
void setGeometry(const QgsGeometry &geometry)
Set the feature&#39;s geometry.
Definition: qgsfeature.cpp:137
Class for doing transforms between two map coordinate systems.
double xMinimum() const
Returns the x minimum value (left side of rectangle).
Definition: qgsrectangle.h:167
double yMaximum() const
Returns the y maximum value (top side of rectangle).
Definition: qgsrectangle.h:172
QgsPolylineXY asPolyline() const
Returns the contents of the geometry as a polyline.
QgsMultiPointXY asMultiPoint() const
Returns the contents of the geometry as a multi-point.
QgsWkbTypes::GeometryType type
Definition: qgsgeometry.h:115
QgsGeometry geometry
Definition: qgsfeature.h:67
int width() const
Returns the stroke width.
Definition: qgshighlight.h:107
static QgsExpressionContextScope * layerScope(const QgsMapLayer *layer)
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
QPointF toCanvasCoordinates(const QgsPointXY &point) const
transformation from map coordinates to screen coordinates
Represents a vector layer which manages a vector based data sets.
QgsMultiPolygonXY asMultiPolygon() const
Returns the contents of the geometry as a multi-polygon.
QSize outputSize() const
Returns the size of the resulting map image.
QgsPointXY toMapCoordinates(int x, int y) const
Transform device coordinates to map (world) coordinates.
virtual QgsFeatureRenderer * clone() const =0
Create a deep copy of this renderer.
void setXMinimum(double x)
Set the minimum x value.
Definition: qgsrectangle.h:130
RenderUnit
Rendering size units.
Definition: qgsunittypes.h:111
virtual void setDataDefinedProperty(Property key, const QgsProperty &property)
Sets a data defined property for the layer.
void setWidth(int width)
Set stroke width.