QGIS API Documentation  2.11.0-Master
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules 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 
247  QgsFeatureRendererV2* renderer = layer->rendererV2();
248  if ( renderer && renderer->capabilities() & QgsFeatureRendererV2::ScaleDependent )
249  {
250  // setup scale for scale dependent visibility (rule based)
251  renderer->startRender( context, layer->pendingFields() );
252  filter = renderer->capabilities() & QgsFeatureRendererV2::Filter;
253  }
254 
255  for ( ; f_it != featureList.end(); ++f_it )
256  {
257  QMap< QString, QString > derivedAttributes = commonDerivedAttributes;
258 
259  QgsFeatureId fid = f_it->id();
260 
261  if ( filter && !renderer->willRenderFeature( *f_it ) )
262  continue;
263 
264  featureCount++;
265 
266  derivedAttributes.unite( featureDerivedAttributes( &( *f_it ), layer ) );
267 
268  derivedAttributes.insert( tr( "feature id" ), fid < 0 ? tr( "new feature" ) : FID_TO_STRING( fid ) );
269 
270  results->append( IdentifyResult( qobject_cast<QgsMapLayer *>( layer ), *f_it, derivedAttributes ) );
271  }
272 
273  if ( renderer && renderer->capabilities() & QgsFeatureRendererV2::ScaleDependent )
274  {
275  renderer->stopRender( context );
276  }
277 
278  QgsDebugMsg( "Feature count on identify: " + QString::number( featureCount ) );
279 
281  return featureCount > 0;
282 }
283 
284 QMap< QString, QString > QgsMapToolIdentify::featureDerivedAttributes( QgsFeature *feature, QgsMapLayer *layer )
285 {
286  // Calculate derived attributes and insert:
287  // measure distance or area depending on geometry type
288  QMap< QString, QString > derivedAttributes;
289 
290  // init distance/area calculator
291  QString ellipsoid = QgsProject::instance()->readEntry( "Measure", "/Ellipsoid", GEO_NONE );
292  QgsDistanceArea calc;
294  calc.setEllipsoid( ellipsoid );
295  calc.setSourceCrs( layer->crs().srsid() );
296 
298  QGis::GeometryType geometryType = QGis::NoGeometry;
299 
300  if ( feature->constGeometry() )
301  {
302  geometryType = feature->constGeometry()->type();
303  wkbType = feature->constGeometry()->wkbType();
304  }
305 
306  if ( geometryType == QGis::Line )
307  {
308  double dist = calc.measure( feature->constGeometry() );
309  QGis::UnitType myDisplayUnits;
310  convertMeasurement( calc, dist, myDisplayUnits, false );
311  QString str = calc.textUnit( dist, 3, myDisplayUnits, false ); // dist and myDisplayUnits are out params
312  derivedAttributes.insert( tr( "Length" ), str );
313  if ( wkbType == QGis::WKBLineString || wkbType == QGis::WKBLineString25D )
314  {
315  // Add the start and end points in as derived attributes
317  str = QLocale::system().toString( pnt.x(), 'g', 10 );
318  derivedAttributes.insert( tr( "firstX", "attributes get sorted; translation for lastX should be lexically larger than this one" ), str );
319  str = QLocale::system().toString( pnt.y(), 'g', 10 );
320  derivedAttributes.insert( tr( "firstY" ), str );
321  pnt = mCanvas->mapSettings().layerToMapCoordinates( layer, feature->constGeometry()->asPolyline().last() );
322  str = QLocale::system().toString( pnt.x(), 'g', 10 );
323  derivedAttributes.insert( tr( "lastX", "attributes get sorted; translation for firstX should be lexically smaller than this one" ), str );
324  str = QLocale::system().toString( pnt.y(), 'g', 10 );
325  derivedAttributes.insert( tr( "lastY" ), str );
326  }
327  }
328  else if ( geometryType == QGis::Polygon )
329  {
330  double area = calc.measure( feature->constGeometry() );
331  double perimeter = calc.measurePerimeter( feature->constGeometry() );
332  QGis::UnitType myDisplayUnits;
333  convertMeasurement( calc, area, myDisplayUnits, true ); // area and myDisplayUnits are out params
334  QString str = calc.textUnit( area, 3, myDisplayUnits, true );
335  derivedAttributes.insert( tr( "Area" ), str );
336  convertMeasurement( calc, perimeter, myDisplayUnits, false ); // perimeter and myDisplayUnits are out params
337  str = calc.textUnit( perimeter, 3, myDisplayUnits, false );
338  derivedAttributes.insert( tr( "Perimeter" ), str );
339  }
340  else if ( geometryType == QGis::Point &&
341  ( wkbType == QGis::WKBPoint || wkbType == QGis::WKBPoint25D ) )
342  {
343  // Include the x and y coordinates of the point as a derived attribute
344  QgsPoint pnt = mCanvas->mapSettings().layerToMapCoordinates( layer, feature->constGeometry()->asPoint() );
345  QString str = QLocale::system().toString( pnt.x(), 'g', 10 );
346  derivedAttributes.insert( "X", str );
347  str = QLocale::system().toString( pnt.y(), 'g', 10 );
348  derivedAttributes.insert( "Y", str );
349  }
350 
351  return derivedAttributes;
352 }
353 
354 bool QgsMapToolIdentify::identifyRasterLayer( QList<IdentifyResult> *results, QgsRasterLayer *layer, QgsPoint point, QgsRectangle viewExtent, double mapUnitsPerPixel )
355 {
356  QgsDebugMsg( "point = " + point.toString() );
357  if ( !layer )
358  return false;
359 
360  QgsRasterDataProvider *dprovider = layer->dataProvider();
361  if ( !dprovider )
362  return false;
363 
364  int capabilities = dprovider->capabilities();
365  if ( !( capabilities & QgsRasterDataProvider::Identify ) )
366  return false;
367 
368  QgsPoint pointInCanvasCrs = point;
369  try
370  {
371  point = toLayerCoordinates( layer, point );
372  }
373  catch ( QgsCsException &cse )
374  {
375  Q_UNUSED( cse );
376  QgsDebugMsg( QString( "coordinate not reprojectable: %1" ).arg( cse.what() ) );
377  return false;
378  }
379  QgsDebugMsg( QString( "point = %1 %2" ).arg( point.x() ).arg( point.y() ) );
380 
381  if ( !layer->extent().contains( point ) )
382  return false;
383 
384  QMap< QString, QString > attributes, derivedAttributes;
385 
387 
388  // check if the format is really supported otherwise use first supported format
389  if ( !( QgsRasterDataProvider::identifyFormatToCapability( format ) & capabilities ) )
390  {
392  else if ( capabilities & QgsRasterInterface::IdentifyValue ) format = QgsRaster::IdentifyFormatValue;
393  else if ( capabilities & QgsRasterInterface::IdentifyHtml ) format = QgsRaster::IdentifyFormatHtml;
394  else if ( capabilities & QgsRasterInterface::IdentifyText ) format = QgsRaster::IdentifyFormatText;
395  else return false;
396  }
397 
398  QgsRasterIdentifyResult identifyResult;
399  // We can only use current map canvas context (extent, width, height) if layer is not reprojected,
400  if ( mCanvas->hasCrsTransformEnabled() && dprovider->crs() != mCanvas->mapSettings().destinationCrs() )
401  {
402  // To get some reasonable response for point/line WMS vector layers we must
403  // use a context with approximately a resolution in layer CRS units
404  // corresponding to current map canvas resolution (for examplei UMN Mapserver
405  // in msWMSFeatureInfo() -> msQueryByRect() is using requested pixel
406  // + TOLERANCE (layer param) for feature selection)
407  //
408  QgsRectangle r;
409  r.setXMinimum( pointInCanvasCrs.x() - mapUnitsPerPixel / 2. );
410  r.setXMaximum( pointInCanvasCrs.x() + mapUnitsPerPixel / 2. );
411  r.setYMinimum( pointInCanvasCrs.y() - mapUnitsPerPixel / 2. );
412  r.setYMaximum( pointInCanvasCrs.y() + mapUnitsPerPixel / 2. );
413  r = toLayerCoordinates( layer, r ); // will be a bit larger
414  // Mapserver (6.0.3, for example) does not work with 1x1 pixel box
415  // but that is fixed (the rect is enlarged) in the WMS provider
416  identifyResult = dprovider->identify( point, format, r, 1, 1 );
417  }
418  else
419  {
420  // It would be nice to use the same extent and size which was used for drawing,
421  // so that WCS can use cache from last draw, unfortunately QgsRasterLayer::draw()
422  // is doing some tricks with extent and size to allign raster to output which
423  // would be difficult to replicate here.
424  // Note: cutting the extent may result in slightly different x and y resolutions
425  // and thus shifted point calculated back in QGIS WMS (using average resolution)
426  //viewExtent = dprovider->extent().intersect( &viewExtent );
427 
428  // Width and height are calculated from not projected extent and we hope that
429  // are similar to source width and height used to reproject layer for drawing.
430  // TODO: may be very dangerous, because it may result in different resolutions
431  // in source CRS, and WMS server (QGIS server) calcs wrong coor using average resolution.
432  int width = qRound( viewExtent.width() / mapUnitsPerPixel );
433  int height = qRound( viewExtent.height() / mapUnitsPerPixel );
434 
435  QgsDebugMsg( QString( "viewExtent.width = %1 viewExtent.height = %2" ).arg( viewExtent.width() ).arg( viewExtent.height() ) );
436  QgsDebugMsg( QString( "width = %1 height = %2" ).arg( width ).arg( height ) );
437  QgsDebugMsg( QString( "xRes = %1 yRes = %2 mapUnitsPerPixel = %3" ).arg( viewExtent.width() / width ).arg( viewExtent.height() / height ).arg( mapUnitsPerPixel ) );
438 
439  identifyResult = dprovider->identify( point, format, viewExtent, width, height );
440  }
441 
442  derivedAttributes.insert( tr( "(clicked coordinate)" ), point.toString() );
443 
444  if ( identifyResult.isValid() )
445  {
446  QMap<int, QVariant> values = identifyResult.results();
447  QgsGeometry geometry;
448  if ( format == QgsRaster::IdentifyFormatValue )
449  {
450  foreach ( int bandNo, values.keys() )
451  {
452  QString valueString;
453  if ( values.value( bandNo ).isNull() )
454  {
455  valueString = tr( "no data" );
456  }
457  else
458  {
459  double value = values.value( bandNo ).toDouble();
460  valueString = QgsRasterBlock::printValue( value );
461  }
462  attributes.insert( dprovider->generateBandName( bandNo ), valueString );
463  }
464  QString label = layer->name();
465  results->append( IdentifyResult( qobject_cast<QgsMapLayer *>( layer ), label, attributes, derivedAttributes ) );
466  }
467  else if ( format == QgsRaster::IdentifyFormatFeature )
468  {
469  foreach ( int i, values.keys() )
470  {
471  QVariant value = values.value( i );
472  if ( value.type() == QVariant::Bool && !value.toBool() )
473  {
474  // sublayer not visible or not queryable
475  continue;
476  }
477 
478  if ( value.type() == QVariant::String )
479  {
480  // error
481  // TODO: better error reporting
482  QString label = layer->subLayers().value( i );
483  attributes.clear();
484  attributes.insert( tr( "Error" ), value.toString() );
485 
486  results->append( IdentifyResult( qobject_cast<QgsMapLayer *>( layer ), label, attributes, derivedAttributes ) );
487  continue;
488  }
489 
490  // list of feature stores for a single sublayer
491  QgsFeatureStoreList featureStoreList = values.value( i ).value<QgsFeatureStoreList>();
492 
493  foreach ( QgsFeatureStore featureStore, featureStoreList )
494  {
495  foreach ( QgsFeature feature, featureStore.features() )
496  {
497  attributes.clear();
498  // WMS sublayer and feature type, a sublayer may contain multiple feature types.
499  // Sublayer name may be the same as layer name and feature type name
500  // may be the same as sublayer. We try to avoid duplicities in label.
501  QString sublayer = featureStore.params().value( "sublayer" ).toString();
502  QString featureType = featureStore.params().value( "featureType" ).toString();
503  // Strip UMN MapServer '_feature'
504  featureType.remove( "_feature" );
505  QStringList labels;
506  if ( sublayer.compare( layer->name(), Qt::CaseInsensitive ) != 0 )
507  {
508  labels << sublayer;
509  }
510  if ( featureType.compare( sublayer, Qt::CaseInsensitive ) != 0 || labels.isEmpty() )
511  {
512  labels << featureType;
513  }
514 
515  QMap< QString, QString > derAttributes = derivedAttributes;
516  derAttributes.unite( featureDerivedAttributes( &feature, layer ) );
517 
518  IdentifyResult identifyResult( qobject_cast<QgsMapLayer *>( layer ), labels.join( " / " ), featureStore.fields(), feature, derAttributes );
519 
520  identifyResult.mParams.insert( "getFeatureInfoUrl", featureStore.params().value( "getFeatureInfoUrl" ) );
521  results->append( identifyResult );
522  }
523  }
524  }
525  }
526  else // text or html
527  {
528  QgsDebugMsg( QString( "%1 html or text values" ).arg( values.size() ) );
529  foreach ( int bandNo, values.keys() )
530  {
531  QString value = values.value( bandNo ).toString();
532  attributes.clear();
533  attributes.insert( "", value );
534 
535  QString label = layer->subLayers().value( bandNo );
536  results->append( IdentifyResult( qobject_cast<QgsMapLayer *>( layer ), label, attributes, derivedAttributes ) );
537  }
538  }
539  }
540  else
541  {
542  attributes.clear();
543  QString value = identifyResult.error().message( QgsErrorMessage::Text );
544  attributes.insert( tr( "Error" ), value );
545  QString label = tr( "Identify error" );
546  results->append( IdentifyResult( qobject_cast<QgsMapLayer *>( layer ), label, attributes, derivedAttributes ) );
547  }
548 
549  return true;
550 }
551 
552 void QgsMapToolIdentify::convertMeasurement( QgsDistanceArea &calc, double &measure, QGis::UnitType &u, bool isArea )
553 {
554  // Helper for converting between meters and feet
555  // The parameter &u is out only...
556 
557  // Get the canvas units
558  QGis::UnitType myUnits = mCanvas->mapUnits();
559 
560  calc.convertMeasurement( measure, myUnits, displayUnits(), isArea );
561  u = myUnits;
562 }
563 
564 QGis::UnitType QgsMapToolIdentify::displayUnits()
565 {
566  return mCanvas->mapUnits();
567 }
568 
570 {
571  QgsDebugMsg( "Entered" );
572  QList<IdentifyResult> results;
573  if ( identifyRasterLayer( &results, layer, mLastPoint, mLastExtent, mLastMapUnitsPerPixel ) )
574  {
575  emit changedRasterResults( results );
576  }
577 }
578 
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.
QgsFeatureRendererV2 * rendererV2()
Return renderer V2.
virtual bool willRenderFeature(QgsFeature &feat)
return whether the renderer will render a feature or not.
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:213
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)
#define QgsDebugMsg(str)
Definition: qgslogger.h:33
virtual QgsCoordinateReferenceSystem crs()=0
This class provides qgis with the ability to render raster datasets onto the mapcanvas.
UnitType
Map units that qgis supports.
Definition: qgis.h:229
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
GeometryType
Definition: qgis.h:155
T & first()
QString join(const QString &separator) const
bool setEllipsoid(const QString &ellipsoid)
sets ellipsoid by its acronym
WkbType
Used for symbology operations.
Definition: qgis.h:53
The feature class encapsulates a single feature including its id, geometry and a list of field/values...
Definition: qgsfeature.h:119
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()
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
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
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:77
QgsMapCanvas * mCanvas
pointer to map canvas
Definition: qgsmaptool.h:188
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:191
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:48
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()
IdentifyFormat
Definition: qgsraster.h:54
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:93
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)
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:48
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:351
const QgsGeometry * constGeometry() const
Gets a const pointer to the geometry object associated with this feature.
Definition: qgsfeature.cpp:68
bool toBool() const
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
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.
const QgsFields & pendingFields() const
returns field list in the to-be-committed state
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)