QGIS API Documentation  2.17.0-Master (8784312)
qgspointdisplacementrenderer.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgspointdisplacementrenderer.cpp
3  --------------------------------
4  begin : January 26, 2010
5  copyright : (C) 2010 by Marco Hugentobler
6  email : marco at hugis dot net
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 "qgsgeometry.h"
20 #include "qgslogger.h"
21 #include "qgsspatialindex.h"
22 #include "qgssymbolv2.h"
23 #include "qgssymbollayerv2utils.h"
24 #include "qgsvectorlayer.h"
26 #include "qgspainteffect.h"
27 #include "qgspainteffectregistry.h"
28 #include "qgsfontutils.h"
29 #include "qgsmultipointv2.h"
30 #include "qgspointv2.h"
31 #include "qgsunittypes.h"
32 #include "qgswkbptr.h"
33 
34 #include <QDomElement>
35 #include <QPainter>
36 
37 #include <cmath>
38 
39 #ifndef M_SQRT2
40 #define M_SQRT2 1.41421356237309504880
41 #endif
42 
44  : QgsFeatureRendererV2( "pointDisplacement" )
45  , mLabelAttributeName( labelAttributeName )
46  , mLabelIndex( -1 )
47  , mTolerance( 3 )
48  , mToleranceUnit( QgsSymbolV2::MM )
49  , mPlacement( Ring )
50  , mCircleWidth( 0.4 )
51  , mCircleColor( QColor( 125, 125, 125 ) )
52  , mCircleRadiusAddition( 0 )
53  , mMaxLabelScaleDenominator( -1 )
54  , mSpatialIndex( nullptr )
55 {
57  mCenterSymbol = new QgsMarkerSymbolV2(); //the symbol for the center of a displacement group
58  mDrawLabels = true;
59 }
60 
62 {
63  delete mCenterSymbol;
64  delete mRenderer;
65 }
66 
68 {
69  QgsPointDisplacementRenderer* r = new QgsPointDisplacementRenderer( mLabelAttributeName );
70  if ( mRenderer )
71  r->setEmbeddedRenderer( mRenderer->clone() );
72  r->setCircleWidth( mCircleWidth );
73  r->setCircleColor( mCircleColor );
74  r->setLabelFont( mLabelFont );
75  r->setLabelColor( mLabelColor );
76  r->setPlacement( mPlacement );
77  r->setCircleRadiusAddition( mCircleRadiusAddition );
78  r->setMaxLabelScaleDenominator( mMaxLabelScaleDenominator );
79  r->setTolerance( mTolerance );
80  r->setToleranceUnit( mToleranceUnit );
81  r->setToleranceMapUnitScale( mToleranceMapUnitScale );
82  if ( mCenterSymbol )
83  {
84  r->setCenterSymbol( mCenterSymbol->clone() );
85  }
86  copyRendererData( r );
87  return r;
88 }
89 
91 {
92  mRenderer->toSld( doc, element );
93 }
94 
95 
96 bool QgsPointDisplacementRenderer::renderFeature( QgsFeature& feature, QgsRenderContext& context, int layer, bool selected, bool drawVertexMarker )
97 {
98  Q_UNUSED( drawVertexMarker );
99  Q_UNUSED( context );
100  Q_UNUSED( layer );
101 
102  //check, if there is already a point at that position
103  if ( !feature.constGeometry() )
104  return false;
105 
106  QgsSymbolV2* symbol = firstSymbolForFeature( mRenderer, feature, context );
107 
108  //if the feature has no symbol (eg, no matching rule in a rule-based renderer), skip it
109  if ( !symbol )
110  return false;
111 
112  //point position in screen coords
113  const QgsGeometry* geom = feature.constGeometry();
114  QGis::WkbType geomType = geom->wkbType();
115  if ( geomType != QGis::WKBPoint && geomType != QGis::WKBPoint25D )
116  {
117  //can only render point type
118  return false;
119  }
120 
121  if ( selected )
122  mSelectedFeatures.insert( feature.id() );
123 
124  double searchDistance = mTolerance * QgsSymbolLayerV2Utils::mapUnitScaleFactor( context, mToleranceUnit, mToleranceMapUnitScale );
125  QList<QgsFeatureId> intersectList = mSpatialIndex->intersects( searchRect( feature.constGeometry()->asPoint(), searchDistance ) );
126  if ( intersectList.empty() )
127  {
128  mSpatialIndex->insertFeature( feature );
129  // create new group
130  DisplacementGroup newGroup;
131  newGroup.insert( feature.id(), qMakePair( feature, symbol ) );
132  mDisplacementGroups.push_back( newGroup );
133  // add to group index
134  mGroupIndex.insert( feature.id(), mDisplacementGroups.count() - 1 );
135  return true;
136  }
137 
138  //go through all the displacement group maps and search an entry where the id equals the result of the spatial search
139  QgsFeatureId existingEntry = intersectList.at( 0 );
140 
141  int groupIdx = mGroupIndex[ existingEntry ];
142  DisplacementGroup& group = mDisplacementGroups[groupIdx];
143 
144  // add to a group
145  group.insert( feature.id(), qMakePair( feature, symbol ) );
146  // add to group index
147  mGroupIndex.insert( feature.id(), groupIdx );
148  return true;
149 }
150 
151 void QgsPointDisplacementRenderer::drawGroup( const DisplacementGroup& group, QgsRenderContext& context )
152 {
153  const QgsFeature& feature = group.begin().value().first;
154  bool selected = mSelectedFeatures.contains( feature.id() ); // maybe we should highlight individual features instead of the whole group?
155 
156 
157 
158  //get list of labels and symbols
159  QStringList labelAttributeList;
160  QList< QgsMarkerSymbolV2* > symbolList;
161  QgsFeatureList featureList;
162 
163  QgsMultiPointV2* groupMultiPoint = new QgsMultiPointV2();
164  for ( DisplacementGroup::const_iterator attIt = group.constBegin(); attIt != group.constEnd(); ++attIt )
165  {
166  labelAttributeList << ( mDrawLabels ? getLabel( attIt.value().first ) : QString() );
167  symbolList << dynamic_cast<QgsMarkerSymbolV2*>( attIt.value().second );
168  featureList << attIt.value().first;
169  groupMultiPoint->addGeometry( attIt.value().first.constGeometry()->geometry()->clone() );
170  }
171 
172  //calculate centroid of all points, this will be center of group
173  QgsGeometry groupGeom( groupMultiPoint );
174  QgsGeometry* centroid = groupGeom.centroid();
175  QPointF pt;
176  QgsConstWkbPtr wkbPtr( centroid->asWkb(), centroid->wkbSize() );
177  _getPoint( pt, context, wkbPtr );
178  delete centroid;
179 
180  //calculate max diagonal size from all symbols in group
181  double diagonal = 0;
182  Q_FOREACH ( QgsMarkerSymbolV2* symbol, symbolList )
183  {
184  if ( symbol )
185  {
186  diagonal = qMax( diagonal, QgsSymbolLayerV2Utils::convertToPainterUnits( context,
187  M_SQRT2 * symbol->size(),
188  symbol->sizeUnit(), symbol->sizeMapUnitScale() ) );
189  }
190  }
191 
192  QgsSymbolV2RenderContext symbolContext( context, QgsSymbolV2::MM, 1.0, selected );
193 
194  QList<QPointF> symbolPositions;
195  QList<QPointF> labelPositions;
196  double circleRadius = -1.0;
197  calculateSymbolAndLabelPositions( symbolContext, pt, symbolList.size(), diagonal, symbolPositions, labelPositions, circleRadius );
198 
199  //draw Circle
200  if ( circleRadius > 0 )
201  drawCircle( circleRadius, symbolContext, pt, symbolList.size() );
202 
203  //draw mid point
204  if ( labelAttributeList.size() > 1 )
205  {
206  if ( mCenterSymbol )
207  {
208  mCenterSymbol->renderPoint( pt, &feature, context, -1, selected );
209  }
210  else
211  {
212  context.painter()->drawRect( QRectF( pt.x() - symbolContext.outputLineWidth( 1 ), pt.y() - symbolContext.outputLineWidth( 1 ), symbolContext.outputLineWidth( 2 ), symbolContext.outputLineWidth( 2 ) ) );
213  }
214  }
215 
216  //draw symbols on the circle
217  drawSymbols( featureList, context, symbolList, symbolPositions, selected );
218  //and also the labels
219  drawLabels( pt, symbolContext, labelPositions, labelAttributeList );
220 }
221 
223 {
224  delete mRenderer;
225  mRenderer = r;
226 }
227 
229 {
230  return mRenderer;
231 }
232 
234 {
235  if ( !mRenderer )
236  return;
237 
238  mRenderer->setLegendSymbolItem( key, symbol );
239 }
240 
242 {
243  if ( !mRenderer )
244  return false;
245 
246  return mRenderer->legendSymbolItemsCheckable();
247 }
248 
250 {
251  if ( !mRenderer )
252  return false;
253 
254  return mRenderer->legendSymbolItemChecked( key );
255 }
256 
258 {
259  if ( !mRenderer )
260  return;
261 
262  return mRenderer->checkLegendSymbolItem( key, state );
263 }
264 
266 {
267  QList<QString> attributeList;
268  if ( !mLabelAttributeName.isEmpty() )
269  {
270  attributeList.push_back( mLabelAttributeName );
271  }
272  if ( mRenderer )
273  {
274  attributeList += mRenderer->usedAttributes();
275  }
276  return attributeList;
277 }
278 
280 {
281  if ( !mRenderer )
282  {
283  return 0;
284  }
285  return mRenderer->capabilities();
286 }
287 
289 {
290  if ( !mRenderer )
291  {
292  return QgsSymbolV2List();
293  }
294  return mRenderer->symbols( context );
295 }
296 
298 {
299  if ( !mRenderer )
300  {
301  return nullptr;
302  }
303  return mRenderer->symbolForFeature( feature, context );
304 }
305 
307 {
308  if ( !mRenderer )
309  return nullptr;
310  return mRenderer->originalSymbolForFeature( feat, context );
311 }
312 
314 {
315  if ( !mRenderer )
316  {
317  return QgsSymbolV2List();
318  }
319  return mRenderer->symbolsForFeature( feature, context );
320 }
321 
323 {
324  if ( !mRenderer )
325  return QgsSymbolV2List();
326  return mRenderer->originalSymbolsForFeature( feat, context );
327 }
328 
330 {
331  if ( !mRenderer )
332  {
333  return false;
334  }
335  return mRenderer->willRenderFeature( feat, context );
336 }
337 
338 
340 {
341  mRenderer->startRender( context, fields );
342 
343  mDisplacementGroups.clear();
344  mGroupIndex.clear();
345  mSpatialIndex = new QgsSpatialIndex;
346  mSelectedFeatures.clear();
347 
348  if ( mLabelAttributeName.isEmpty() )
349  {
350  mLabelIndex = -1;
351  }
352  else
353  {
354  mLabelIndex = fields.fieldNameIndex( mLabelAttributeName );
355  }
356 
357  if ( mMaxLabelScaleDenominator > 0 && context.rendererScale() > mMaxLabelScaleDenominator )
358  {
359  mDrawLabels = false;
360  }
361  else
362  {
363  mDrawLabels = true;
364  }
365 
366  if ( mCenterSymbol )
367  {
368  mCenterSymbol->startRender( context, &fields );
369  }
370  return;
371 }
372 
374 {
375  QgsDebugMsg( "QgsPointDisplacementRenderer::stopRender" );
376 
377  //printInfoDisplacementGroups(); //just for debugging
378 
379  Q_FOREACH ( const DisplacementGroup& group, mDisplacementGroups )
380  {
381  drawGroup( group, context );
382  }
383 
384  mDisplacementGroups.clear();
385  mGroupIndex.clear();
386  delete mSpatialIndex;
387  mSpatialIndex = nullptr;
388  mSelectedFeatures.clear();
389 
390  mRenderer->stopRender( context );
391  if ( mCenterSymbol )
392  {
393  mCenterSymbol->stopRender( context );
394  }
395 }
396 
398 {
400  r->setLabelAttributeName( symbologyElem.attribute( "labelAttributeName" ) );
402  if ( !QgsFontUtils::setFromXmlChildNode( labelFont, symbologyElem, "labelFontProperties" ) )
403  {
404  labelFont.fromString( symbologyElem.attribute( "labelFont", "" ) );
405  }
406  r->setLabelFont( labelFont );
407  r->setPlacement( static_cast< Placement >( symbologyElem.attribute( "placement", "0" ).toInt() ) );
408  r->setCircleWidth( symbologyElem.attribute( "circleWidth", "0.4" ).toDouble() );
409  r->setCircleColor( QgsSymbolLayerV2Utils::decodeColor( symbologyElem.attribute( "circleColor", "" ) ) );
410  r->setLabelColor( QgsSymbolLayerV2Utils::decodeColor( symbologyElem.attribute( "labelColor", "" ) ) );
411  r->setCircleRadiusAddition( symbologyElem.attribute( "circleRadiusAddition", "0.0" ).toDouble() );
412  r->setMaxLabelScaleDenominator( symbologyElem.attribute( "maxLabelScaleDenominator", "-1" ).toDouble() );
413  r->setTolerance( symbologyElem.attribute( "tolerance", "0.00001" ).toDouble() );
414  r->setToleranceUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( symbologyElem.attribute( "toleranceUnit", "MapUnit" ) ) );
415  r->setToleranceMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( symbologyElem.attribute( "toleranceUnitScale" ) ) );
416 
417  //look for an embedded renderer <renderer-v2>
418  QDomElement embeddedRendererElem = symbologyElem.firstChildElement( "renderer-v2" );
419  if ( !embeddedRendererElem.isNull() )
420  {
421  r->setEmbeddedRenderer( QgsFeatureRendererV2::load( embeddedRendererElem ) );
422  }
423 
424  //center symbol
425  QDomElement centerSymbolElem = symbologyElem.firstChildElement( "symbol" );
426  if ( !centerSymbolElem.isNull() )
427  {
428  r->setCenterSymbol( QgsSymbolLayerV2Utils::loadSymbol<QgsMarkerSymbolV2>( centerSymbolElem ) );
429  }
430  return r;
431 }
432 
434 {
435  QDomElement rendererElement = doc.createElement( RENDERER_TAG_NAME );
436  rendererElement.setAttribute( "forceraster", ( mForceRaster ? "1" : "0" ) );
437  rendererElement.setAttribute( "type", "pointDisplacement" );
438  rendererElement.setAttribute( "labelAttributeName", mLabelAttributeName );
439  rendererElement.appendChild( QgsFontUtils::toXmlElement( mLabelFont, doc, "labelFontProperties" ) );
440  rendererElement.setAttribute( "circleWidth", QString::number( mCircleWidth ) );
441  rendererElement.setAttribute( "circleColor", QgsSymbolLayerV2Utils::encodeColor( mCircleColor ) );
442  rendererElement.setAttribute( "labelColor", QgsSymbolLayerV2Utils::encodeColor( mLabelColor ) );
443  rendererElement.setAttribute( "circleRadiusAddition", QString::number( mCircleRadiusAddition ) );
444  rendererElement.setAttribute( "placement", static_cast< int >( mPlacement ) );
445  rendererElement.setAttribute( "maxLabelScaleDenominator", QString::number( mMaxLabelScaleDenominator ) );
446  rendererElement.setAttribute( "tolerance", QString::number( mTolerance ) );
447  rendererElement.setAttribute( "toleranceUnit", QgsSymbolLayerV2Utils::encodeOutputUnit( mToleranceUnit ) );
448  rendererElement.setAttribute( "toleranceUnitScale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mToleranceMapUnitScale ) );
449 
450  if ( mRenderer )
451  {
452  QDomElement embeddedRendererElem = mRenderer->save( doc );
453  rendererElement.appendChild( embeddedRendererElem );
454  }
455  if ( mCenterSymbol )
456  {
457  QDomElement centerSymbolElem = QgsSymbolLayerV2Utils::saveSymbol( "centerSymbol", mCenterSymbol, doc );
458  rendererElement.appendChild( centerSymbolElem );
459  }
460 
462  mPaintEffect->saveProperties( doc, rendererElement );
463 
464  if ( !mOrderBy.isEmpty() )
465  {
466  QDomElement orderBy = doc.createElement( "orderby" );
467  mOrderBy.save( orderBy );
468  rendererElement.appendChild( orderBy );
469  }
470  rendererElement.setAttribute( "enableorderby", ( mOrderByEnabled ? "1" : "0" ) );
471 
472  return rendererElement;
473 }
474 
476 {
477  if ( mRenderer )
478  {
479  return mRenderer->legendSymbologyItems( iconSize );
480  }
481  return QgsLegendSymbologyList();
482 }
483 
485 {
486  if ( mRenderer )
487  {
488  return mRenderer->legendSymbolItems( scaleDenominator, rule );
489  }
490  return QgsLegendSymbolList();
491 }
492 
493 
494 QgsRectangle QgsPointDisplacementRenderer::searchRect( const QgsPoint& p, double distance ) const
495 {
496  return QgsRectangle( p.x() - distance, p.y() - distance, p.x() + distance, p.y() + distance );
497 }
498 
499 void QgsPointDisplacementRenderer::printInfoDisplacementGroups()
500 {
501  int nGroups = mDisplacementGroups.size();
502  QgsDebugMsg( "number of displacement groups:" + QString::number( nGroups ) );
503  for ( int i = 0; i < nGroups; ++i )
504  {
505  QgsDebugMsg( "***************displacement group " + QString::number( i ) );
506  DisplacementGroup::const_iterator it = mDisplacementGroups.at( i ).constBegin();
507  for ( ; it != mDisplacementGroups.at( i ).constEnd(); ++it )
508  {
509  QgsDebugMsg( FID_TO_STRING( it.key() ) );
510  }
511  }
512 }
513 
514 QString QgsPointDisplacementRenderer::getLabel( const QgsFeature& f )
515 {
516  QString attribute;
517  QgsAttributes attrs = f.attributes();
518  if ( mLabelIndex >= 0 && mLabelIndex < attrs.count() )
519  {
520  attribute = attrs.at( mLabelIndex ).toString();
521  }
522  return attribute;
523 }
524 
526 {
527  delete mCenterSymbol;
528  mCenterSymbol = symbol;
529 }
530 
531 
532 
533 void QgsPointDisplacementRenderer::calculateSymbolAndLabelPositions( QgsSymbolV2RenderContext& symbolContext, QPointF centerPoint, int nPosition,
534  double symbolDiagonal, QList<QPointF>& symbolPositions, QList<QPointF>& labelShifts, double& circleRadius ) const
535 {
536  symbolPositions.clear();
537  labelShifts.clear();
538 
539  if ( nPosition < 1 )
540  {
541  return;
542  }
543  else if ( nPosition == 1 ) //If there is only one feature, draw it exactly at the center position
544  {
545  symbolPositions.append( centerPoint );
546  labelShifts.append( QPointF( symbolDiagonal / 2.0, -symbolDiagonal / 2.0 ) );
547  return;
548  }
549 
550  double circleAdditionPainterUnits = symbolContext.outputLineWidth( mCircleRadiusAddition );
551 
552  switch ( mPlacement )
553  {
554  case Ring:
555  {
556  double minDiameterToFitSymbols = nPosition * symbolDiagonal / ( 2.0 * M_PI );
557  double radius = qMax( symbolDiagonal / 2, minDiameterToFitSymbols ) + circleAdditionPainterUnits;
558 
559  double fullPerimeter = 2 * M_PI;
560  double angleStep = fullPerimeter / nPosition;
561  for ( double currentAngle = 0.0; currentAngle < fullPerimeter; currentAngle += angleStep )
562  {
563  double sinusCurrentAngle = sin( currentAngle );
564  double cosinusCurrentAngle = cos( currentAngle );
565  QPointF positionShift( radius * sinusCurrentAngle, radius * cosinusCurrentAngle );
566  QPointF labelShift(( radius + symbolDiagonal / 2 ) * sinusCurrentAngle, ( radius + symbolDiagonal / 2 ) * cosinusCurrentAngle );
567  symbolPositions.append( centerPoint + positionShift );
568  labelShifts.append( labelShift );
569  }
570 
571  circleRadius = radius;
572  break;
573  }
574  case ConcentricRings:
575  {
576  double centerDiagonal = QgsSymbolLayerV2Utils::convertToPainterUnits( symbolContext.renderContext(),
577  M_SQRT2 * mCenterSymbol->size(),
578  mCenterSymbol->sizeUnit(), mCenterSymbol->sizeMapUnitScale() );
579 
580  int pointsRemaining = nPosition;
581  int ringNumber = 1;
582  double firstRingRadius = centerDiagonal / 2.0 + symbolDiagonal / 2.0;
583  while ( pointsRemaining > 0 )
584  {
585  double radiusCurrentRing = qMax( firstRingRadius + ( ringNumber - 1 ) * symbolDiagonal + ringNumber * circleAdditionPainterUnits, 0.0 );
586  int maxPointsCurrentRing = qMax( floor( 2 * M_PI * radiusCurrentRing / symbolDiagonal ), 1.0 );
587  int actualPointsCurrentRing = qMin( maxPointsCurrentRing, pointsRemaining );
588 
589  double angleStep = 2 * M_PI / actualPointsCurrentRing;
590  double currentAngle = 0.0;
591  for ( int i = 0; i < actualPointsCurrentRing; ++i )
592  {
593  double sinusCurrentAngle = sin( currentAngle );
594  double cosinusCurrentAngle = cos( currentAngle );
595  QPointF positionShift( radiusCurrentRing * sinusCurrentAngle, radiusCurrentRing * cosinusCurrentAngle );
596  QPointF labelShift(( radiusCurrentRing + symbolDiagonal / 2 ) * sinusCurrentAngle, ( radiusCurrentRing + symbolDiagonal / 2 ) * cosinusCurrentAngle );
597  symbolPositions.append( centerPoint + positionShift );
598  labelShifts.append( labelShift );
599  currentAngle += angleStep;
600  }
601 
602  pointsRemaining -= actualPointsCurrentRing;
603  ringNumber++;
604  circleRadius = radiusCurrentRing;
605  }
606  break;
607  }
608  }
609 }
610 
611 void QgsPointDisplacementRenderer::drawCircle( double radiusPainterUnits, QgsSymbolV2RenderContext& context, QPointF centerPoint, int nSymbols )
612 {
613  QPainter* p = context.renderContext().painter();
614  if ( nSymbols < 2 || !p ) //draw circle only if multiple features
615  {
616  return;
617  }
618 
619  //draw Circle
620  QPen circlePen( mCircleColor );
621  circlePen.setWidthF( context.outputLineWidth( mCircleWidth ) );
622  p->setPen( circlePen );
623  p->drawArc( QRectF( centerPoint.x() - radiusPainterUnits, centerPoint.y() - radiusPainterUnits, 2 * radiusPainterUnits, 2 * radiusPainterUnits ), 0, 5760 );
624 }
625 
626 void QgsPointDisplacementRenderer::drawSymbols( const QgsFeatureList& features, QgsRenderContext& context,
627  const QList< QgsMarkerSymbolV2* >& symbolList, const QList<QPointF>& symbolPositions, bool selected )
628 {
629  QList<QPointF>::const_iterator symbolPosIt = symbolPositions.constBegin();
631  QgsFeatureList::const_iterator featIt = features.constBegin();
632  for ( ; symbolPosIt != symbolPositions.constEnd() && symbolIt != symbolList.constEnd() && featIt != features.constEnd();
633  ++symbolPosIt, ++symbolIt, ++featIt )
634  {
635  if ( *symbolIt )
636  {
637  context.expressionContext().setFeature( *featIt );
638  ( *symbolIt )->startRender( context );
639  ( *symbolIt )->renderPoint( *symbolPosIt, &( *featIt ), context, -1, selected );
640  ( *symbolIt )->stopRender( context );
641  }
642  }
643 }
644 
645 void QgsPointDisplacementRenderer::drawLabels( QPointF centerPoint, QgsSymbolV2RenderContext& context, const QList<QPointF>& labelShifts, const QStringList& labelList )
646 {
647  QPainter* p = context.renderContext().painter();
648  if ( !p )
649  {
650  return;
651  }
652 
653  QPen labelPen( mLabelColor );
654  p->setPen( labelPen );
655 
656  //scale font (for printing)
657  QFont pixelSizeFont = mLabelFont;
658  pixelSizeFont.setPixelSize( context.outputLineWidth( mLabelFont.pointSizeF() * 0.3527 ) );
659  QFont scaledFont = pixelSizeFont;
660  scaledFont.setPixelSize( pixelSizeFont.pixelSize() * context.renderContext().rasterScaleFactor() );
661  p->setFont( scaledFont );
662 
663  QFontMetricsF fontMetrics( pixelSizeFont );
664  QPointF currentLabelShift; //considers the signs to determine the label position
665 
666  QList<QPointF>::const_iterator labelPosIt = labelShifts.constBegin();
667  QStringList::const_iterator text_it = labelList.constBegin();
668 
669  for ( ; labelPosIt != labelShifts.constEnd() && text_it != labelList.constEnd(); ++labelPosIt, ++text_it )
670  {
671  currentLabelShift = *labelPosIt;
672  if ( currentLabelShift.x() < 0 )
673  {
674  currentLabelShift.setX( currentLabelShift.x() - fontMetrics.width( *text_it ) );
675  }
676  if ( currentLabelShift.y() > 0 )
677  {
678  currentLabelShift.setY( currentLabelShift.y() + fontMetrics.ascent() );
679  }
680 
681  QPointF drawingPoint( centerPoint + currentLabelShift );
682  p->save();
683  p->translate( drawingPoint.x(), drawingPoint.y() );
684  p->scale( 1.0 / context.renderContext().rasterScaleFactor(), 1.0 / context.renderContext().rasterScaleFactor() );
685  p->drawText( QPointF( 0, 0 ), *text_it );
686  p->restore();
687  }
688 }
689 
690 QgsSymbolV2* QgsPointDisplacementRenderer::firstSymbolForFeature( QgsFeatureRendererV2* r, QgsFeature& f, QgsRenderContext &context )
691 {
692  if ( !r )
693  {
694  return nullptr;
695  }
696 
697  QgsSymbolV2List symbolList = r->symbolsForFeature( f, context );
698  if ( symbolList.size() < 1 )
699  {
700  return nullptr;
701  }
702 
703  return symbolList.at( 0 );
704 }
705 
707 {
708  if ( renderer->type() == "pointDisplacement" )
709  {
710  return dynamic_cast<QgsPointDisplacementRenderer*>( renderer->clone() );
711  }
712 
713  if ( renderer->type() == "singleSymbol" ||
714  renderer->type() == "categorizedSymbol" ||
715  renderer->type() == "graduatedSymbol" ||
716  renderer->type() == "RuleRenderer" )
717  {
719  pointRenderer->setEmbeddedRenderer( renderer->clone() );
720  return pointRenderer;
721  }
722  return nullptr;
723 }
QgsFeatureId id() const
Get the feature ID for this feature.
Definition: qgsfeature.cpp:65
static QString encodeOutputUnit(QgsSymbolV2::OutputUnit unit)
virtual bool addGeometry(QgsAbstractGeometryV2 *g) override
Adds a geometry and takes ownership.
void clear()
#define RENDERER_TAG_NAME
Definition: qgsrendererv2.h:49
void CORE_EXPORT save(QDomElement &elem) const
Serialize to XML.
A rectangle specified with double values.
Definition: qgsrectangle.h:35
QgsPointDisplacementRenderer * clone() const override
QgsMapUnitScale sizeMapUnitScale() const
Returns the size map unit scale for the whole symbol.
int pixelSize() const
QList< QgsFeatureId > intersects(const QgsRectangle &rect) const
Returns features that intersect the specified rectangle.
QgsFeatureRequest::OrderBy orderBy() const
Get the order in which features shall be processed by this renderer.
QList< QgsSymbolV2 * > QgsSymbolV2List
Definition: qgsrendererv2.h:40
virtual void checkLegendSymbolItem(const QString &key, bool state=true) override
item in symbology was checked
QDomNode appendChild(const QDomNode &newChild)
virtual void setLegendSymbolItem(const QString &key, QgsSymbolV2 *symbol) override
Sets the symbol to be used for a legend symbol item.
OutputUnit sizeUnit() const
Returns the size units for the whole symbol (including all symbol layers).
void push_back(const T &value)
QString attribute(const QString &name, const QString &defValue) const
static QgsFeatureRendererV2 * create(QDomElement &symbologyElem)
create a renderer from XML element
static double mapUnitScaleFactor(const QgsRenderContext &c, QgsSymbolV2::OutputUnit u, const QgsMapUnitScale &scale=QgsMapUnitScale())
Returns scale factor painter units -> map units.
qreal pointSizeF() const
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
#define QgsDebugMsg(str)
Definition: qgslogger.h:33
virtual Q_DECL_DEPRECATED QgsSymbolV2 * originalSymbolForFeature(QgsFeature &feature)
Return symbol for feature.
void setLabelAttributeName(const QString &name)
static QString encodeColor(const QColor &color)
int fieldNameIndex(const QString &fieldName) const
Look up field&#39;s index from name also looks up case-insensitive if there is no match otherwise...
Definition: qgsfield.cpp:534
double size() const
Returns the size for the whole symbol, which is the maximum size of all marker symbol layers in the s...
double rendererScale() const
virtual QDomElement save(QDomDocument &doc)
store renderer info to XML element
void setCenterSymbol(QgsMarkerSymbolV2 *symbol)
Sets the center symbol (takes ownership)
void scale(qreal sx, qreal sy)
const_iterator constBegin() const
const T & at(int i) const
static bool isDefaultStack(QgsPaintEffect *effect)
Tests whether a paint effect matches the default effects stack.
QgsLegendSymbologyList legendSymbologyItems(QSize iconSize) override
return a list of symbology items for the legend
#define FID_TO_STRING(fid)
Definition: qgsfeature.h:89
static QDomElement saveSymbol(const QString &symbolName, QgsSymbolV2 *symbol, QDomDocument &doc)
void save()
Container of fields for a vector layer.
Definition: qgsfield.h:193
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:76
static QgsPointDisplacementRenderer * convertFromRenderer(const QgsFeatureRendererV2 *renderer)
creates a QgsPointDisplacementRenderer from an existing renderer.
WkbType
Used for symbology operations.
Definition: qgis.h:61
QDomElement save(QDomDocument &doc) override
store renderer info to XML element
virtual QgsSymbolV2List symbolsForFeature(QgsFeature &feat, QgsRenderContext &context) override
Proxy that will call this method on the embedded renderer.
static QString encodeMapUnitScale(const QgsMapUnitScale &mapUnitScale)
virtual QList< QString > usedAttributes()=0
Returns a set of attributes required for this renderer.
Multi point geometry collection.
QgsPointDisplacementRenderer(const QString &labelAttributeName="")
const_iterator insert(const T &value)
The feature class encapsulates a single feature including its id, geometry and a list of field/values...
Definition: qgsfeature.h:187
void clear()
double toDouble(bool *ok) const
virtual void startRender(QgsRenderContext &context, const QgsFields &fields) override
Needs to be called when a new render cycle is started.
virtual Q_DECL_DEPRECATED bool willRenderFeature(QgsFeature &feat)
Returns whether the renderer will render a feature or not.
virtual bool legendSymbolItemChecked(const QString &key)
items of symbology items in legend is checked
qreal width(const QString &text) const
QgsPaintEffect * mPaintEffect
double x() const
Get the x value of the point.
Definition: qgspoint.h:185
virtual void checkLegendSymbolItem(const QString &key, bool state=true)
item in symbology was checked
virtual QgsLegendSymbologyList legendSymbologyItems(QSize iconSize)
return a list of symbology items for the legend
int size() const
virtual void startRender(QgsRenderContext &context, const QgsFields &fields)=0
Needs to be called when a new render cycle is started.
void setToleranceUnit(QgsSymbolV2::OutputUnit unit)
Sets the units for the tolerance distance.
T value(int i) const
virtual void stopRender(QgsRenderContext &context)=0
Needs to be called when a render cycle has finished to clean up.
static QgsSymbolV2::OutputUnit decodeOutputUnit(const QString &str)
QString type() const
Definition: qgsrendererv2.h:92
virtual Q_DECL_DEPRECATED QgsSymbolV2List originalSymbolsForFeature(QgsFeature &feat)
Equivalent of originalSymbolsForFeature() call extended to support renderers that may use more symbol...
void drawRect(const QRectF &rectangle)
void setPixelSize(int pixelSize)
virtual QgsFeatureRendererV2 * clone() const =0
void setFont(const QFont &font)
The output shall be in millimeters.
Definition: qgssymbolv2.h:67
QString number(int n, int base)
virtual Q_DECL_DEPRECATED QgsSymbolV2 * symbolForFeature(QgsFeature &feature)
To be overridden.
qreal x() const
qreal y() const
void append(const T &value)
virtual QgsSymbolV2List originalSymbolsForFeature(QgsFeature &feat, QgsRenderContext &context) override
Proxy that will call this method on the embedded renderer.
bool empty() const
void startRender(QgsRenderContext &context, const QgsFields *fields=nullptr)
bool fromString(const QString &descrip)
const Key & key() const
void drawArc(const QRectF &rectangle, int startAngle, int spanAngle)
static double convertToPainterUnits(const QgsRenderContext &c, double size, QgsSymbolV2::OutputUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale())
Converts a size from the specied units to painter units.
virtual QgsLegendSymbolList legendSymbolItems(double scaleDenominator=-1, const QString &rule="")
return a list of item text / symbol
QgsAttributes attributes() const
Returns the feature&#39;s attributes.
Definition: qgsfeature.cpp:110
void setPen(const QColor &color)
void setAttribute(const QString &name, const QString &value)
int toInt(bool *ok, int base) const
bool isEmpty() const
bool isEmpty() const
const_iterator constEnd() const
#define M_PI
virtual void toSld(QDomDocument &doc, QDomElement &element) const override
used from subclasses to create SLD Rule elements following SLD v1.1 specs
void setWidthF(qreal width)
virtual QgsSymbolV2 * originalSymbolForFeature(QgsFeature &feat, QgsRenderContext &context) override
Proxy that will call this method on the embedded renderer.
void drawText(const QPointF &position, const QString &text)
double rasterScaleFactor() const
static bool setFromXmlChildNode(QFont &font, const QDomElement &element, const QString &childNode)
Sets the properties of a font to match the properties stored in an XML child node.
QGis::WkbType wkbType() const
Returns type of the geometry as a WKB type (point / linestring / polygon etc.)
void setPlacement(Placement placement)
Sets the placement method used for dispersing the points.
QgsGeometry * centroid() const
Returns the center of mass of a geometry.
static QgsFeatureRendererV2 * defaultRenderer(QGis::GeometryType geomType)
return a new renderer - used by default in vector layers
virtual Q_DECL_DEPRECATED QgsSymbolV2List symbols()
For symbol levels.
T & value() const
A class to represent a point.
Definition: qgspoint.h:117
iterator begin()
bool renderFeature(QgsFeature &feature, QgsRenderContext &context, int layer=-1, bool selected=false, bool drawVertexMarker=false) override
Reimplemented from QgsFeatureRendererV2.
virtual bool willRenderFeature(QgsFeature &feat, QgsRenderContext &context) override
Proxy that will call this method on the embedded renderer.
QList< QPair< QString, QPixmap > > QgsLegendSymbologyList
virtual bool legendSymbolItemChecked(const QString &key) override
items of symbology items in legend is checked
void stopRender(QgsRenderContext &context) override
Needs to be called when a render cycle has finished to clean up.
QgsExpressionContext & expressionContext()
Gets the expression context.
void copyRendererData(QgsFeatureRendererV2 *destRenderer) const
Clones generic renderer data to another renderer.
virtual void toSld(QDomDocument &doc, QDomElement &element) const
used from subclasses to create SLD Rule elements following SLD v1.1 specs
A renderer that automatically displaces points with the same position.
virtual QgsSymbolV2 * symbolForFeature(QgsFeature &feature, QgsRenderContext &context) override
Proxy that will call this method on the embedded renderer.
bool contains(const T &value) const
bool isNull() const
void restore()
void setEmbeddedRenderer(QgsFeatureRendererV2 *r) override
Sets an embedded renderer (subrenderer) for this feature renderer.
const T & at(int i) const
virtual bool saveProperties(QDomDocument &doc, QDomElement &element) const
Saves the current state of the effect to a DOM element.
Contains information about the context of a rendering operation.
bool insertFeature(const QgsFeature &f)
Add feature to index.
QPainter * painter()
void stopRender(QgsRenderContext &context)
int wkbSize() const
Returns the size of the WKB in asWkb().
QgsLegendSymbolList legendSymbolItems(double scaleDenominator=-1, const QString &rule="") override
qreal ascent() const
virtual Q_DECL_DEPRECATED QgsSymbolV2List symbolsForFeature(QgsFeature &feat)
Returns list of symbols used for rendering the feature.
static QgsFeatureRendererV2 * load(QDomElement &symbologyElem)
create a renderer from XML element
QgsFeatureRequest::OrderBy mOrderBy
virtual bool legendSymbolItemsCheckable() const
items of symbology items in legend should be checkable
QgsRenderContext & renderContext()
Definition: qgssymbolv2.h:355
void setX(qreal x)
void setY(qreal y)
QDomElement firstChildElement(const QString &tagName) const
int count(const T &value) const
const QgsGeometry * constGeometry() const
Gets a const pointer to the geometry object associated with this feature.
Definition: qgsfeature.cpp:82
void renderPoint(QPointF point, const QgsFeature *f, QgsRenderContext &context, int layer=-1, bool selected=false)
void translate(const QPointF &offset)
qint64 QgsFeatureId
Definition: qgsfeature.h:31
double y() const
Get the y value of the point.
Definition: qgspoint.h:193
virtual int capabilities() override
Proxy that will call this method on the embedded renderer.
static QColor decodeColor(const QString &str)
iterator insert(const Key &key, const T &value)
void setToleranceMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale object for the distance tolerance.
static QgsConstWkbPtr _getPoint(QPointF &pt, QgsRenderContext &context, QgsConstWkbPtr &wkb)
Creates a point in screen coordinates from a wkb string in map coordinates.
virtual bool legendSymbolItemsCheckable() const override
items of symbology items in legend should be checkable
static QDomElement toXmlElement(const QFont &font, QDomDocument &document, const QString &elementName)
Returns a DOM element containing the properties of the font.
double outputLineWidth(double width) const
static QgsMapUnitScale decodeMapUnitScale(const QString &str)
const_iterator constEnd() const
virtual int capabilities()
returns bitwise OR-ed capabilities of the renderer
QDomElement createElement(const QString &tagName)
void clear()
const_iterator constBegin() const
QgsPoint asPoint() const
Return contents of the geometry as a point if wkbType is WKBPoint, otherwise returns [0...
A vector of attributes.
Definition: qgsfeature.h:115
virtual QList< QString > usedAttributes() override
Partial proxy that will call this method on the embedded renderer.
QList< QPair< QString, QgsSymbolV2 * > > QgsLegendSymbolList
Definition: qgsrendererv2.h:44
const unsigned char * asWkb() const
Returns the buffer containing this geometry in WKB format.
virtual void setLegendSymbolItem(const QString &key, QgsSymbolV2 *symbol)
Sets the symbol to be used for a legend symbol item.
const QgsFeatureRendererV2 * embeddedRenderer() const override
Returns the current embedded renderer (subrenderer) for this feature renderer.
virtual QgsMarkerSymbolV2 * clone() const override
void setTolerance(double t)
Sets the tolerance distance for grouping points.