QGIS API Documentation  2.11.0-Master
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
qgsmaptoolidentify.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsmaptoolidentify.cpp - map tool for identifying features
3  ---------------------
4  begin : January 2006
5  copyright : (C) 2006 by Martin Dobias
6  email : wonder.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 "qgsapplication.h"
17 #include "qgscursors.h"
18 #include "qgsdistancearea.h"
19 #include "qgsfeature.h"
20 #include "qgsfeaturestore.h"
21 #include "qgsfield.h"
22 #include "qgsgeometry.h"
23 #include "qgsidentifymenu.h"
24 #include "qgslogger.h"
25 #include "qgsmapcanvas.h"
26 #include "qgsmaptoolidentify.h"
27 #include "qgsmaptopixel.h"
28 #include "qgsmessageviewer.h"
29 #include "qgsmaplayer.h"
30 #include "qgsrasterlayer.h"
33 #include "qgsvectordataprovider.h"
34 #include "qgsvectorlayer.h"
35 #include "qgsproject.h"
36 #include "qgsmaplayerregistry.h"
37 #include "qgsrendererv2.h"
38 
39 #include <QSettings>
40 #include <QMouseEvent>
41 #include <QCursor>
42 #include <QPixmap>
43 #include <QStatusBar>
44 #include <QVariant>
45 #include <QMenu>
46 
48  : QgsMapTool( canvas )
49  , mIdentifyMenu( new QgsIdentifyMenu( mCanvas ) )
50  , mLastMapUnitsPerPixel( -1.0 )
51 {
52  // set cursor
53  QPixmap myIdentifyQPixmap = QPixmap(( const char ** ) identify_cursor );
54  mCursor = QCursor( myIdentifyQPixmap, 1, 1 );
55 }
56 
58 {
59  delete mIdentifyMenu;
60 }
61 
63 {
64  Q_UNUSED( e );
65 }
66 
68 {
69  Q_UNUSED( e );
70 }
71 
73 {
74  Q_UNUSED( e );
75 }
76 
78 {
79  return identify( x, y, mode, layerList, AllLayers );
80 }
81 
83 {
84  return identify( x, y, mode, QList<QgsMapLayer*>(), layerType );
85 }
86 
88 {
89  QList<IdentifyResult> results;
90 
91  mLastPoint = mCanvas->getCoordinateTransform()->toMapCoordinates( x, y );
92  mLastExtent = mCanvas->extent();
93  mLastMapUnitsPerPixel = mCanvas->mapUnitsPerPixel();
94 
95  if ( mode == DefaultQgsSetting )
96  {
97  QSettings settings;
98  mode = static_cast<IdentifyMode>( settings.value( "/Map/identifyMode", 0 ).toInt() );
99  }
100 
101  if ( mode == LayerSelection )
102  {
103  QList<IdentifyResult> results = identify( x, y, TopDownAll, layerList, layerType );
104  QPoint globalPos = mCanvas->mapToGlobal( QPoint( x + 5, y + 5 ) );
105  return mIdentifyMenu->exec( results, globalPos );
106  }
107  else if ( mode == ActiveLayer && layerList.isEmpty() )
108  {
109  QgsMapLayer *layer = mCanvas->currentLayer();
110 
111  if ( !layer )
112  {
113  emit identifyMessage( tr( "No active layer. To identify features, you must choose an active layer." ) );
114  return results;
115  }
116 
117  QApplication::setOverrideCursor( Qt::WaitCursor );
118 
119  identifyLayer( &results, layer, mLastPoint, mLastExtent, mLastMapUnitsPerPixel, layerType );
120  }
121  else
122  {
123  QApplication::setOverrideCursor( Qt::WaitCursor );
124 
125  QStringList noIdentifyLayerIdList = QgsProject::instance()->readListEntry( "Identify", "/disabledLayers" );
126 
127  int layerCount;
128  if ( layerList.isEmpty() )
129  layerCount = mCanvas->layerCount();
130  else
131  layerCount = layerList.count();
132 
133 
134  for ( int i = 0; i < layerCount; i++ )
135  {
136 
137  QgsMapLayer *layer;
138  if ( layerList.isEmpty() )
139  layer = mCanvas->layer( i );
140  else
141  layer = layerList.value( i );
142 
143  emit identifyProgress( i, mCanvas->layerCount() );
144  emit identifyMessage( tr( "Identifying on %1..." ).arg( layer->name() ) );
145 
146  if ( noIdentifyLayerIdList.contains( layer->id() ) )
147  continue;
148 
149  if ( identifyLayer( &results, layer, mLastPoint, mLastExtent, mLastMapUnitsPerPixel, layerType ) )
150  {
151  if ( mode == TopDownStopAtFirst )
152  break;
153  }
154  }
155 
157  emit identifyMessage( tr( "Identifying done." ) );
158  }
159 
161 
162  return results;
163 }
164 
166 {
168 }
169 
171 {
173 }
174 
175 bool QgsMapToolIdentify::identifyLayer( QList<IdentifyResult> *results, QgsMapLayer *layer, QgsPoint point, QgsRectangle viewExtent, double mapUnitsPerPixel, LayerType layerType )
176 {
177  if ( layer->type() == QgsMapLayer::RasterLayer && layerType.testFlag( RasterLayer ) )
178  {
179  return identifyRasterLayer( results, qobject_cast<QgsRasterLayer *>( layer ), point, viewExtent, mapUnitsPerPixel );
180  }
181  else if ( layer->type() == QgsMapLayer::VectorLayer && layerType.testFlag( VectorLayer ) )
182  {
183  return identifyVectorLayer( results, qobject_cast<QgsVectorLayer *>( layer ), point );
184  }
185  else
186  {
187  return false;
188  }
189 }
190 
192 {
193  if ( !layer || !layer->hasGeometryType() )
194  return false;
195 
196  if ( layer->hasScaleBasedVisibility() &&
197  ( layer->minimumScale() > mCanvas->mapSettings().scale() ||
198  layer->maximumScale() <= mCanvas->mapSettings().scale() ) )
199  {
200  QgsDebugMsg( "Out of scale limits" );
201  return false;
202  }
203 
204  QApplication::setOverrideCursor( Qt::WaitCursor );
205 
206  QMap< QString, QString > commonDerivedAttributes;
207 
208  commonDerivedAttributes.insert( tr( "(clicked coordinate)" ), point.toString() );
209 
210  int featureCount = 0;
211 
212  QgsFeatureList featureList;
213 
214  // toLayerCoordinates will throw an exception for an 'invalid' point.
215  // For example, if you project a world map onto a globe using EPSG 2163
216  // and then click somewhere off the globe, an exception will be thrown.
217  try
218  {
219  // create the search rectangle
220  double searchRadius = searchRadiusMU( mCanvas );
221 
222  QgsRectangle r;
223  r.setXMinimum( point.x() - searchRadius );
224  r.setXMaximum( point.x() + searchRadius );
225  r.setYMinimum( point.y() - searchRadius );
226  r.setYMaximum( point.y() + searchRadius );
227 
228  r = toLayerCoordinates( layer, r );
229 
230  QgsFeatureIterator fit = layer->getFeatures( QgsFeatureRequest().setFilterRect( r ).setFlags( QgsFeatureRequest::ExactIntersect ) );
231  QgsFeature f;
232  while ( fit.nextFeature( f ) )
233  featureList << QgsFeature( f );
234  }
235  catch ( QgsCsException & cse )
236  {
237  Q_UNUSED( cse );
238  // catch exception for 'invalid' point and proceed with no features found
239  QgsDebugMsg( QString( "Caught CRS exception %1" ).arg( cse.what() ) );
240  }
241 
242  QgsFeatureList::iterator f_it = featureList.begin();
243 
244  bool filter = false;
245 
248  QgsFeatureRendererV2* renderer = layer->rendererV2();
249  if ( renderer && renderer->capabilities() & QgsFeatureRendererV2::ScaleDependent )
250  {
251  // setup scale for scale dependent visibility (rule based)
252  renderer->startRender( context, layer->fields() );
253  filter = renderer->capabilities() & QgsFeatureRendererV2::Filter;
254  }
255 
256  for ( ; f_it != featureList.end(); ++f_it )
257  {
258  QMap< QString, QString > derivedAttributes = commonDerivedAttributes;
259 
260  QgsFeatureId fid = f_it->id();
261  context.expressionContext().setFeature( *f_it );
262 
263  if ( filter && !renderer->willRenderFeature( *f_it, context ) )
264  continue;
265 
266  featureCount++;
267 
268  derivedAttributes.unite( featureDerivedAttributes( &( *f_it ), layer ) );
269 
270  derivedAttributes.insert( tr( "feature id" ), fid < 0 ? tr( "new feature" ) : FID_TO_STRING( fid ) );
271 
272  results->append( IdentifyResult( qobject_cast<QgsMapLayer *>( layer ), *f_it, derivedAttributes ) );
273  }
274 
275  if ( renderer && renderer->capabilities() & QgsFeatureRendererV2::ScaleDependent )
276  {
277  renderer->stopRender( context );
278  }
279 
280  QgsDebugMsg( "Feature count on identify: " + QString::number( featureCount ) );
281 
283  return featureCount > 0;
284 }
285 
286 QMap< QString, QString > QgsMapToolIdentify::featureDerivedAttributes( QgsFeature *feature, QgsMapLayer *layer )
287 {
288  // Calculate derived attributes and insert:
289  // measure distance or area depending on geometry type
290  QMap< QString, QString > derivedAttributes;
291 
292  // init distance/area calculator
293  QString ellipsoid = QgsProject::instance()->readEntry( "Measure", "/Ellipsoid", GEO_NONE );
294  QgsDistanceArea calc;
296  calc.setEllipsoid( ellipsoid );
297  calc.setSourceCrs( layer->crs().srsid() );
298 
300  QGis::GeometryType geometryType = QGis::NoGeometry;
301 
302  if ( feature->constGeometry() )
303  {
304  geometryType = feature->constGeometry()->type();
305  wkbType = feature->constGeometry()->wkbType();
306  }
307 
308  if ( geometryType == QGis::Line )
309  {
310  double dist = calc.measure( feature->constGeometry() );
311  QGis::UnitType myDisplayUnits;
312  convertMeasurement( calc, dist, myDisplayUnits, false );
313  QString str = calc.textUnit( dist, 3, myDisplayUnits, false ); // dist and myDisplayUnits are out params
314  derivedAttributes.insert( tr( "Length" ), str );
315  if ( wkbType == QGis::WKBLineString || wkbType == QGis::WKBLineString25D )
316  {
317  // Add the start and end points in as derived attributes
319  str = QLocale::system().toString( pnt.x(), 'g', 10 );
320  derivedAttributes.insert( tr( "firstX", "attributes get sorted; translation for lastX should be lexically larger than this one" ), str );
321  str = QLocale::system().toString( pnt.y(), 'g', 10 );
322  derivedAttributes.insert( tr( "firstY" ), str );
323  pnt = mCanvas->mapSettings().layerToMapCoordinates( layer, feature->constGeometry()->asPolyline().last() );
324  str = QLocale::system().toString( pnt.x(), 'g', 10 );
325  derivedAttributes.insert( tr( "lastX", "attributes get sorted; translation for firstX should be lexically smaller than this one" ), str );
326  str = QLocale::system().toString( pnt.y(), 'g', 10 );
327  derivedAttributes.insert( tr( "lastY" ), str );
328  }
329  }
330  else if ( geometryType == QGis::Polygon )
331  {
332  double area = calc.measure( feature->constGeometry() );
333  double perimeter = calc.measurePerimeter( feature->constGeometry() );
334  QGis::UnitType myDisplayUnits;
335  convertMeasurement( calc, area, myDisplayUnits, true ); // area and myDisplayUnits are out params
336  QString str = calc.textUnit( area, 3, myDisplayUnits, true );
337  derivedAttributes.insert( tr( "Area" ), str );
338  convertMeasurement( calc, perimeter, myDisplayUnits, false ); // perimeter and myDisplayUnits are out params
339  str = calc.textUnit( perimeter, 3, myDisplayUnits, false );
340  derivedAttributes.insert( tr( "Perimeter" ), str );
341  }
342  else if ( geometryType == QGis::Point &&
343  ( wkbType == QGis::WKBPoint || wkbType == QGis::WKBPoint25D ) )
344  {
345  // Include the x and y coordinates of the point as a derived attribute
346  QgsPoint pnt = mCanvas->mapSettings().layerToMapCoordinates( layer, feature->constGeometry()->asPoint() );
347  QString str = QLocale::system().toString( pnt.x(), 'g', 10 );
348  derivedAttributes.insert( "X", str );
349  str = QLocale::system().toString( pnt.y(), 'g', 10 );
350  derivedAttributes.insert( "Y", str );
351  }
352 
353  return derivedAttributes;
354 }
355 
356 bool QgsMapToolIdentify::identifyRasterLayer( QList<IdentifyResult> *results, QgsRasterLayer *layer, QgsPoint point, QgsRectangle viewExtent, double mapUnitsPerPixel )
357 {
358  QgsDebugMsg( "point = " + point.toString() );
359  if ( !layer )
360  return false;
361 
362  QgsRasterDataProvider *dprovider = layer->dataProvider();
363  if ( !dprovider )
364  return false;
365 
366  int capabilities = dprovider->capabilities();
367  if ( !( capabilities & QgsRasterDataProvider::Identify ) )
368  return false;
369 
370  QgsPoint pointInCanvasCrs = point;
371  try
372  {
373  point = toLayerCoordinates( layer, point );
374  }
375  catch ( QgsCsException &cse )
376  {
377  Q_UNUSED( cse );
378  QgsDebugMsg( QString( "coordinate not reprojectable: %1" ).arg( cse.what() ) );
379  return false;
380  }
381  QgsDebugMsg( QString( "point = %1 %2" ).arg( point.x() ).arg( point.y() ) );
382 
383  if ( !layer->extent().contains( point ) )
384  return false;
385 
386  QMap< QString, QString > attributes, derivedAttributes;
387 
389 
390  // check if the format is really supported otherwise use first supported format
391  if ( !( QgsRasterDataProvider::identifyFormatToCapability( format ) & capabilities ) )
392  {
394  else if ( capabilities & QgsRasterInterface::IdentifyValue ) format = QgsRaster::IdentifyFormatValue;
395  else if ( capabilities & QgsRasterInterface::IdentifyHtml ) format = QgsRaster::IdentifyFormatHtml;
396  else if ( capabilities & QgsRasterInterface::IdentifyText ) format = QgsRaster::IdentifyFormatText;
397  else return false;
398  }
399 
400  QgsRasterIdentifyResult identifyResult;
401  // We can only use current map canvas context (extent, width, height) if layer is not reprojected,
402  if ( mCanvas->hasCrsTransformEnabled() && dprovider->crs() != mCanvas->mapSettings().destinationCrs() )
403  {
404  // To get some reasonable response for point/line WMS vector layers we must
405  // use a context with approximately a resolution in layer CRS units
406  // corresponding to current map canvas resolution (for examplei UMN Mapserver
407  // in msWMSFeatureInfo() -> msQueryByRect() is using requested pixel
408  // + TOLERANCE (layer param) for feature selection)
409  //
410  QgsRectangle r;
411  r.setXMinimum( pointInCanvasCrs.x() - mapUnitsPerPixel / 2. );
412  r.setXMaximum( pointInCanvasCrs.x() + mapUnitsPerPixel / 2. );
413  r.setYMinimum( pointInCanvasCrs.y() - mapUnitsPerPixel / 2. );
414  r.setYMaximum( pointInCanvasCrs.y() + mapUnitsPerPixel / 2. );
415  r = toLayerCoordinates( layer, r ); // will be a bit larger
416  // Mapserver (6.0.3, for example) does not work with 1x1 pixel box
417  // but that is fixed (the rect is enlarged) in the WMS provider
418  identifyResult = dprovider->identify( point, format, r, 1, 1 );
419  }
420  else
421  {
422  // It would be nice to use the same extent and size which was used for drawing,
423  // so that WCS can use cache from last draw, unfortunately QgsRasterLayer::draw()
424  // is doing some tricks with extent and size to allign raster to output which
425  // would be difficult to replicate here.
426  // Note: cutting the extent may result in slightly different x and y resolutions
427  // and thus shifted point calculated back in QGIS WMS (using average resolution)
428  //viewExtent = dprovider->extent().intersect( &viewExtent );
429 
430  // Width and height are calculated from not projected extent and we hope that
431  // are similar to source width and height used to reproject layer for drawing.
432  // TODO: may be very dangerous, because it may result in different resolutions
433  // in source CRS, and WMS server (QGIS server) calcs wrong coor using average resolution.
434  int width = qRound( viewExtent.width() / mapUnitsPerPixel );
435  int height = qRound( viewExtent.height() / mapUnitsPerPixel );
436 
437  QgsDebugMsg( QString( "viewExtent.width = %1 viewExtent.height = %2" ).arg( viewExtent.width() ).arg( viewExtent.height() ) );
438  QgsDebugMsg( QString( "width = %1 height = %2" ).arg( width ).arg( height ) );
439  QgsDebugMsg( QString( "xRes = %1 yRes = %2 mapUnitsPerPixel = %3" ).arg( viewExtent.width() / width ).arg( viewExtent.height() / height ).arg( mapUnitsPerPixel ) );
440 
441  identifyResult = dprovider->identify( point, format, viewExtent, width, height );
442  }
443 
444  derivedAttributes.insert( tr( "(clicked coordinate)" ), point.toString() );
445 
446  if ( identifyResult.isValid() )
447  {
448  QMap<int, QVariant> values = identifyResult.results();
449  QgsGeometry geometry;
450  if ( format == QgsRaster::IdentifyFormatValue )
451  {
452  foreach ( int bandNo, values.keys() )
453  {
454  QString valueString;
455  if ( values.value( bandNo ).isNull() )
456  {
457  valueString = tr( "no data" );
458  }
459  else
460  {
461  double value = values.value( bandNo ).toDouble();
462  valueString = QgsRasterBlock::printValue( value );
463  }
464  attributes.insert( dprovider->generateBandName( bandNo ), valueString );
465  }
466  QString label = layer->name();
467  results->append( IdentifyResult( qobject_cast<QgsMapLayer *>( layer ), label, attributes, derivedAttributes ) );
468  }
469  else if ( format == QgsRaster::IdentifyFormatFeature )
470  {
471  foreach ( int i, values.keys() )
472  {
473  QVariant value = values.value( i );
474  if ( value.type() == QVariant::Bool && !value.toBool() )
475  {
476  // sublayer not visible or not queryable
477  continue;
478  }
479 
480  if ( value.type() == QVariant::String )
481  {
482  // error
483  // TODO: better error reporting
484  QString label = layer->subLayers().value( i );
485  attributes.clear();
486  attributes.insert( tr( "Error" ), value.toString() );
487 
488  results->append( IdentifyResult( qobject_cast<QgsMapLayer *>( layer ), label, attributes, derivedAttributes ) );
489  continue;
490  }
491 
492  // list of feature stores for a single sublayer
493  QgsFeatureStoreList featureStoreList = values.value( i ).value<QgsFeatureStoreList>();
494 
495  foreach ( QgsFeatureStore featureStore, featureStoreList )
496  {
497  foreach ( QgsFeature feature, featureStore.features() )
498  {
499  attributes.clear();
500  // WMS sublayer and feature type, a sublayer may contain multiple feature types.
501  // Sublayer name may be the same as layer name and feature type name
502  // may be the same as sublayer. We try to avoid duplicities in label.
503  QString sublayer = featureStore.params().value( "sublayer" ).toString();
504  QString featureType = featureStore.params().value( "featureType" ).toString();
505  // Strip UMN MapServer '_feature'
506  featureType.remove( "_feature" );
507  QStringList labels;
508  if ( sublayer.compare( layer->name(), Qt::CaseInsensitive ) != 0 )
509  {
510  labels << sublayer;
511  }
512  if ( featureType.compare( sublayer, Qt::CaseInsensitive ) != 0 || labels.isEmpty() )
513  {
514  labels << featureType;
515  }
516 
517  QMap< QString, QString > derAttributes = derivedAttributes;
518  derAttributes.unite( featureDerivedAttributes( &feature, layer ) );
519 
520  IdentifyResult identifyResult( qobject_cast<QgsMapLayer *>( layer ), labels.join( " / " ), featureStore.fields(), feature, derAttributes );
521 
522  identifyResult.mParams.insert( "getFeatureInfoUrl", featureStore.params().value( "getFeatureInfoUrl" ) );
523  results->append( identifyResult );
524  }
525  }
526  }
527  }
528  else // text or html
529  {
530  QgsDebugMsg( QString( "%1 HTML or text values" ).arg( values.size() ) );
531  foreach ( int bandNo, values.keys() )
532  {
533  QString value = values.value( bandNo ).toString();
534  attributes.clear();
535  attributes.insert( "", value );
536 
537  QString label = layer->subLayers().value( bandNo );
538  results->append( IdentifyResult( qobject_cast<QgsMapLayer *>( layer ), label, attributes, derivedAttributes ) );
539  }
540  }
541  }
542  else
543  {
544  attributes.clear();
545  QString value = identifyResult.error().message( QgsErrorMessage::Text );
546  attributes.insert( tr( "Error" ), value );
547  QString label = tr( "Identify error" );
548  results->append( IdentifyResult( qobject_cast<QgsMapLayer *>( layer ), label, attributes, derivedAttributes ) );
549  }
550 
551  return true;
552 }
553 
554 void QgsMapToolIdentify::convertMeasurement( QgsDistanceArea &calc, double &measure, QGis::UnitType &u, bool isArea )
555 {
556  // Helper for converting between meters and feet
557  // The parameter &u is out only...
558 
559  // Get the canvas units
560  QGis::UnitType myUnits = mCanvas->mapUnits();
561 
562  calc.convertMeasurement( measure, myUnits, displayUnits(), isArea );
563  u = myUnits;
564 }
565 
566 QGis::UnitType QgsMapToolIdentify::displayUnits()
567 {
568  return mCanvas->mapUnits();
569 }
570 
572 {
573  QgsDebugMsg( "Entered" );
574  QList<IdentifyResult> results;
575  if ( identifyRasterLayer( &results, layer, mLastPoint, mLastExtent, mLastMapUnitsPerPixel ) )
576  {
577  emit changedRasterResults( results );
578  }
579 }
580 
bool isValid() const
Returns true if valid.
Wrapper for iterator of features from vector data provider or vector layer.
Container for features with the same fields and crs.
IdentifyFormat
Definition: qgsraster.h:54
A rectangle specified with double values.
Definition: qgsrectangle.h:35
Base class for all map layer types.
Definition: qgsmaplayer.h:49
QgsPoint layerToMapCoordinates(QgsMapLayer *theLayer, QgsPoint point) const
transform point coordinates from layer's CRS to output CRS
virtual QStringList subLayers() const override
Returns the sublayers of this layer - Useful for providers that manage their own layers, such as WMS.
QgsMapLayer::LayerType type() const
Get the type of the layer.
Definition: qgsmaplayer.cpp:93
static QString printValue(double value)
Print double value with all necessary significant digits.
static double searchRadiusMU(const QgsRenderContext &context)
Get search radius in map units for given context.
Definition: qgsmaptool.cpp:219
GeometryType
Definition: qgis.h:155
void convertMeasurement(double &measure, QGis::UnitType &measureUnits, QGis::UnitType displayUnits, bool isArea) const
Helper for conversion between physical units.
double scale() const
Return the calculated scale of the map.
double mapUnitsPerPixel() const
Returns the mapUnitsPerPixel (map units per pixel) for the canvas.
void changedRasterResults(QList< IdentifyResult > &)
int layerCount() const
return number of layers on the map
virtual void activate() override
called when set as currently active map tool
void setXMaximum(double x)
Set the maximum x value.
Definition: qgsrectangle.h:167
QString toString(qlonglong i) const
Use exact geometry intersection (slower) instead of bounding boxes.
void identifyProgress(int, int)
QMap< Key, T > & unite(const QMap< Key, T > &other)
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
#define QgsDebugMsg(str)
Definition: qgslogger.h:33
virtual QgsCoordinateReferenceSystem crs()=0
Get the QgsCoordinateReferenceSystem for this layer.
QgsFields fields() const
Returns the list of fields of this layer.
long srsid() const
Get the SrsId - if possible.
This class provides qgis with the ability to render raster datasets onto the mapcanvas.
virtual void canvasReleaseEvent(QMouseEvent *e) override
Overridden mouse release event.
void setSourceCrs(long srsid)
sets source spatial reference system (by QGIS CRS)
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest())
Query the provider for features specified in request.
bool contains(const QgsRectangle &rect) const
return true when rectangle contains other rectangle
T & last()
float minimumScale() const
Returns the minimum scale denominator at which the layer is visible.
bool hasCrsTransformEnabled()
A simple helper method to find out if on the fly projections are enabled or not.
bool contains(const QString &str, Qt::CaseSensitivity cs) const
#define FID_TO_STRING(fid)
Definition: qgsfeature.h:89
QGis::GeometryType type() const
Returns type of the geometry as a QGis::GeometryType.
QPoint mapToGlobal(const QPoint &pos) const
static Capability identifyFormatToCapability(QgsRaster::IdentifyFormat format)
const QgsMapSettings & mapSettings() const
Get access to properties used for map rendering.
QList< QgsMapToolIdentify::IdentifyResult > exec(const QList< QgsMapToolIdentify::IdentifyResult > idResults, QPoint pos)
exec
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:75
WkbType
Used for symbology operations.
Definition: qgis.h:53
T & first()
QString join(const QString &separator) const
bool setEllipsoid(const QString &ellipsoid)
sets ellipsoid by its acronym
The feature class encapsulates a single feature including its id, geometry and a list of field/values...
Definition: qgsfeature.h:162
QString & remove(int position, int n)
virtual void canvasPressEvent(QMouseEvent *e) override
Overridden mouse press event.
bool identifyLayer(QList< IdentifyResult > *results, QgsMapLayer *layer, QgsPoint point, QgsRectangle viewExtent, double mapUnitsPerPixel, LayerType layerType=AllLayers)
Call the right method depending on layer type.
void clear()
virtual Q_DECL_DEPRECATED bool willRenderFeature(QgsFeature &feat)
return whether the renderer will render a feature or not.
QString tr(const char *sourceText, const char *disambiguation, int n)
QgsMapToolIdentify(QgsMapCanvas *canvas)
constructor
Map canvas is a class for displaying all GIS data types on a canvas.
Definition: qgsmapcanvas.h:105
QMap< int, QVariant > results() const
Get results.
double x() const
Get the x value of the point.
Definition: qgspoint.h:126
const QString GEO_NONE
Constant that holds the string representation for "No ellips/No CRS".
Definition: qgis.cpp:74
virtual void startRender(QgsRenderContext &context, const QgsFields &fields)=0
Needs to be called when a new render cycle is started.
QLocale system()
T value(int i) const
virtual void stopRender(QgsRenderContext &context)=0
Raster identify results container.
QList< Key > keys() const
const QString & name() const
Get the display name of the layer.
virtual void activate()
called when set as currently active map tool
Definition: qgsmaptool.cpp:83
QgsMapCanvas * mCanvas
pointer to map canvas
Definition: qgsmaptool.h:192
virtual void canvasMoveEvent(QMouseEvent *e) override
Overridden mouse move event.
QgsIdentifyMenu * mIdentifyMenu
double measure(const QgsGeometry *geometry) const
general measurement (line distance or polygon area)
virtual QgsRasterIdentifyResult identify(const QgsPoint &thePoint, QgsRaster::IdentifyFormat theFormat, const QgsRectangle &theExtent=QgsRectangle(), int theWidth=0, int theHeight=0)
Identify raster value(s) found on the point position.
QCursor mCursor
cursor used in map tool
Definition: qgsmaptool.h:195
QgsFeatureRendererV2 * rendererV2()
Return renderer V2.
QStringList readListEntry(const QString &scope, const QString &key, QStringList def=QStringList(), bool *ok=0) const
Key value accessors.
void formatChanged(QgsRasterLayer *layer)
QString number(int n, int base)
int count(const T &value) const
void append(const T &value)
bool hasScaleBasedVisibility() const
Returns whether scale based visibility is enabled for the layer.
virtual void deactivate() override
called when map tool is being deactivated
int toInt(bool *ok) const
float maximumScale() const
Returns the maximum scale denominator at which the layer is visible.
const QgsCoordinateReferenceSystem & destinationCrs() const
returns CRS of destination coordinate reference system
void setYMinimum(double y)
Set the minimum y value.
Definition: qgsrectangle.h:172
bool isEmpty() const
QgsPoint toLayerCoordinates(QgsMapLayer *layer, const QPoint &point)
transformation from screen coordinates to layer's coordinates
Definition: qgsmaptool.cpp:54
This class wraps a request for features to a vector layer (or directly its vector data provider)...
void setOverrideCursor(const QCursor &cursor)
QString toString() const
String representation of the point (x,y)
Definition: qgspoint.cpp:126
void restoreOverrideCursor()
double measurePerimeter(const QgsGeometry *geometry) const
measures perimeter of polygon
QString id() const
Get this layer's unique ID, this ID is used to access this layer from map layer registry.
Definition: qgsmaplayer.cpp:99
virtual QString generateBandName(int theBandNumber) const
helper function to create zero padded band names
QGis::WkbType wkbType() const
Returns type of the geometry as a WKB type (point / linestring / polygon etc.)
void identifyMessage(QString)
The QgsIdentifyMenu class builds a menu to be used with identify results (.
QGis::UnitType mapUnits() const
Get the current canvas map units.
virtual void deactivate()
called when map tool is being deactivated
Definition: qgsmaptool.cpp:99
QVariant customProperty(const QString &value, const QVariant &defaultValue=QVariant()) const
Read a custom property from layer.
QString message(QgsErrorMessage::Format theFormat=QgsErrorMessage::Html) const
Full error messages description.
Definition: qgserror.cpp:50
A class to represent a point.
Definition: qgspoint.h:63
iterator end()
virtual int capabilities() const
Returns a bitmask containing the supported capabilities.
QgsMapLayer * currentLayer()
returns current layer (set by legend widget)
QgsExpressionContext & expressionContext()
Gets the expression context.
QgsPoint toMapCoordinates(int x, int y) const
static QString textUnit(double value, int decimals, QGis::UnitType u, bool isArea, bool keepBaseUnit=false)
Abstract base class for all map tools.
Definition: qgsmaptool.h:49
General purpose distance and area calculator.
QgsPolyline asPolyline() const
Return contents of the geometry as a polyline if wkbType is WKBLineString, otherwise an empty list...
QString what() const
Definition: qgsexception.h:35
bool hasGeometryType() const
Returns true if this is a geometry layer and false in case of NoGeometry (table only) or UnknownGeome...
QVariant value(const QString &key, const QVariant &defaultValue) const
Contains information about the context of a rendering operation.
QString readEntry(const QString &scope, const QString &key, const QString &def=QString::null, bool *ok=0) const
void setYMaximum(double y)
Set the maximum y value.
Definition: qgsrectangle.h:177
static QgsRenderContext fromMapSettings(const QgsMapSettings &mapSettings)
create initialized QgsRenderContext instance from given QgsMapSettings
QList< IdentifyResult > identify(int x, int y, QList< QgsMapLayer * > layerList=QList< QgsMapLayer * >(), IdentifyMode mode=DefaultQgsSetting)
Performs the identification.
static QgsProject * instance()
access to canonical QgsProject instance
Definition: qgsproject.cpp:352
const QgsGeometry * constGeometry() const
Gets a const pointer to the geometry object associated with this feature.
Definition: qgsfeature.cpp:68
bool toBool() const
UnitType
Map units that qgis supports.
Definition: qgis.h:229
const QgsMapToPixel * getCoordinateTransform()
Get the current coordinate transform.
bool identifyRasterLayer(QList< IdentifyResult > *results, QgsRasterLayer *layer, QgsPoint point, QgsRectangle viewExtent, double mapUnitsPerPixel)
qint64 QgsFeatureId
Definition: qgsfeature.h:31
double y() const
Get the y value of the point.
Definition: qgspoint.h:134
const QgsCoordinateReferenceSystem & crs() const
Returns layer's spatial reference system.
QgsFields & fields()
Get fields list.
iterator insert(const Key &key, const T &value)
static QgsRaster::IdentifyFormat identifyFormatFromName(QString formatName)
QgsRasterDataProvider * dataProvider()
Returns the data provider.
QgsRectangle extent() const
Returns the current zoom exent of the map canvas.
Custom exception class for Coordinate Reference System related exceptions.
static QgsExpressionContextScope * layerScope(const QgsMapLayer *layer)
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
const char * identify_cursor[]
Definition: qgscursors.cpp:135
virtual int capabilities()
returns bitwise OR-ed capabilities of the renderer
bool nextFeature(QgsFeature &f)
Type type() const
double width() const
Width of the rectangle.
Definition: qgsrectangle.h:202
QgsPoint asPoint() const
Return contents of the geometry as a point if wkbType is WKBPoint, otherwise returns [0...
QgsError error() const
Get error.
virtual QgsRectangle extent()
Return the extent of the layer.
Represents a vector layer which manages a vector based data sets.
int compare(const QString &other) const
QString toString() const
QMap< QString, QVariant > params() const
Get map of optional parameters.
iterator begin()
int size() const
QgsFeatureList & features()
Get features list reference.
QgsMapLayer * layer(int index)
return the map layer at position index in the layer stack
void setXMinimum(double x)
Set the minimum x value.
Definition: qgsrectangle.h:162
void setEllipsoidalMode(bool flag)
sets whether coordinates must be projected to ellipsoid before measuring
double height() const
Height of the rectangle.
Definition: qgsrectangle.h:207
const T value(const Key &key) const
Base class for raster data providers.
bool identifyVectorLayer(QList< IdentifyResult > *results, QgsVectorLayer *layer, QgsPoint point)