QgsGeometry QgsAtlasComposition::currentGeometry( const QgsCoordinateReferenceSystem& crs ) const
{
if ( !mCoverageLayer || !mCurrentFeature.isValid() || !mCurrentFeature.hasGeometry() )
{
return QgsGeometry();
}
if ( !crs.isValid() )
{
// no projection, return the native geometry
return mCurrentFeature.geometry();
}
QMap<long, QgsGeometry>::const_iterator it = mGeometryCache.constFind( crs.srsid() );
if ( it != mGeometryCache.constEnd() )
{
// we have it in cache, return it
return it.value();
}
if ( mCoverageLayer->crs() == crs )
{
return mCurrentFeature.geometry();
}
QgsGeometry transformed = mCurrentFeature.geometry();
transformed.transform( QgsCoordinateTransformCache::instance()->transform( mCoverageLayer->crs().authid(), crs.authid() ) );
mGeometryCache[crs.srsid()] = transformed;
return transformed;
}
void QgsAbstractFeatureIterator::geometryToDestinationCrs( QgsFeature &feature, const QgsCoordinateTransform &transform ) const
{
if ( transform.isValid() && feature.hasGeometry() )
{
try
{
QgsGeometry g = feature.geometry();
g.transform( transform );
feature.setGeometry( g );
}
catch ( QgsCsException & )
{
// transform error
if ( mRequest.transformErrorCallback() )
{
mRequest.transformErrorCallback()( feature );
}
// remove geometry - we can't reproject so better not return a geometry in a different crs
feature.clearGeometry();
}
}
}
QgsFeature QgsTransformAlgorithm::processFeature( const QgsFeature &f, QgsProcessingContext &, QgsProcessingFeedback * )
{
QgsFeature feature = f;
if ( !mCreatedTransform )
{
mCreatedTransform = true;
mTransform = QgsCoordinateTransform( sourceCrs(), mDestCrs, mTransformContext );
}
if ( feature.hasGeometry() )
{
QgsGeometry g = feature.geometry();
if ( g.transform( mTransform ) == 0 )
{
feature.setGeometry( g );
}
else
{
feature.clearGeometry();
}
}
return feature;
}
void CDTMapToolSelectTrainingSamples::canvasReleaseEvent(QgsMapMouseEvent *e)
{
if ( e->button() == Qt::LeftButton )
{
if ( mDragging )
{
mCanvas->panActionEnd( e->pos() );
mDragging = false;
}
else // add pan to mouse cursor
{
// transform the mouse pos to map coordinates
QgsPoint center = mCanvas->getCoordinateTransform()->toMapPoint( e->x(), e->y() );
mCanvas->setExtent( QgsRectangle( center, center ) );
mCanvas->refresh();
}
}
else if (e->button()==Qt::RightButton)
{
QgsVectorLayer* vlayer = NULL;
if ( !mapCanvas->currentLayer()
|| ( vlayer = qobject_cast<QgsVectorLayer *>( mapCanvas->currentLayer() ) ) == NULL )
return;
QRect selectRect( 0, 0, 0, 0 );
int boxSize = 1;
selectRect.setLeft ( e->pos().x() - boxSize );
selectRect.setRight ( e->pos().x() + boxSize );
selectRect.setTop ( e->pos().y() - boxSize );
selectRect.setBottom( e->pos().y() + boxSize );
const QgsMapToPixel* transform = mapCanvas->getCoordinateTransform();
QgsPoint ll = transform->toMapCoordinates( selectRect.left(), selectRect.bottom() );
QgsPoint ur = transform->toMapCoordinates( selectRect.right(), selectRect.top() );
QgsPolyline points;
points.push_back(ll);
points.push_back(QgsPoint( ur.x(), ll.y() ));
points.push_back(ur);
points.push_back(QgsPoint( ll.x(), ur.y() ));
QgsPolygon polygon;
polygon.push_back(points);
QgsGeometry selectGeom = *(QgsGeometry::fromPolygon(polygon) );
if ( mapCanvas->mapSettings().hasCrsTransformEnabled() )
{
QgsCoordinateTransform ct( mapCanvas->mapSettings().destinationCrs(), vlayer->crs() );
selectGeom.transform( ct );
}
QgsFeatureIterator fit = vlayer->getFeatures( QgsFeatureRequest().setFilterRect( selectGeom.boundingBox() ).setFlags( QgsFeatureRequest::ExactIntersect ) );
QgsFeature f;
qint64 closestFeatureId = 0;
bool foundSingleFeature = false;
double closestFeatureDist = std::numeric_limits<double>::max();
while ( fit.nextFeature( f ) )
{
QgsGeometry* g = f.geometry();
if ( !selectGeom.intersects( g ) )
continue;
foundSingleFeature = true;
double distance = g->distance( selectGeom );
if ( distance <= closestFeatureDist )
{
closestFeatureDist = distance;
closestFeatureId = f.attribute("GridCode").toInt();
}
}
if ( foundSingleFeature )
addSingleSample( closestFeatureId );
}
}
bool QgsHeatmapRenderer::renderFeature( QgsFeature& feature, QgsRenderContext& context, int layer, bool selected, bool drawVertexMarker )
{
Q_UNUSED( layer );
Q_UNUSED( selected );
Q_UNUSED( drawVertexMarker );
if ( !context.painter() )
{
return false;
}
if ( !feature.constGeometry() || feature.constGeometry()->type() != QGis::Point )
{
//can only render point type
return false;
}
double weight = 1.0;
if ( !mWeightExpressionString.isEmpty() )
{
QVariant value;
if ( mWeightAttrNum == -1 )
{
Q_ASSERT( mWeightExpression.data() );
value = mWeightExpression->evaluate( &feature );
}
else
{
QgsAttributes attrs = feature.attributes();
value = attrs.value( mWeightAttrNum );
}
bool ok = false;
double evalWeight = value.toDouble( &ok );
if ( ok )
{
weight = evalWeight;
}
}
int width = context.painter()->device()->width() / mRenderQuality;
int height = context.painter()->device()->height() / mRenderQuality;
//transform geometry if required
QgsGeometry* transformedGeom = 0;
const QgsCoordinateTransform* xform = context.coordinateTransform();
if ( xform )
{
transformedGeom = new QgsGeometry( *feature.constGeometry() );
transformedGeom->transform( *xform );
}
//convert point to multipoint
QgsMultiPoint multiPoint = convertToMultipoint( transformedGeom ? transformedGeom : feature.constGeometry() );
delete transformedGeom;
transformedGeom = 0;
//loop through all points in multipoint
for ( QgsMultiPoint::const_iterator pointIt = multiPoint.constBegin(); pointIt != multiPoint.constEnd(); ++pointIt )
{
QgsPoint pixel = context.mapToPixel().transform( *pointIt );
int pointX = pixel.x() / mRenderQuality;
int pointY = pixel.y() / mRenderQuality;
for ( int x = qMax( pointX - mRadiusPixels, 0 ); x < qMin( pointX + mRadiusPixels, width ); ++x )
{
for ( int y = qMax( pointY - mRadiusPixels, 0 ); y < qMin( pointY + mRadiusPixels, height ); ++y )
{
int index = y * width + x;
if ( index >= mValues.count( ) )
{
continue;
}
double distanceSquared = pow( pointX - x, 2.0 ) + pow( pointY - y, 2.0 );
if ( distanceSquared > mRadiusSquared )
{
continue;
}
double score = weight * quarticKernel( sqrt( distanceSquared ), mRadiusPixels );
double value = mValues[ index ] + score;
if ( value > mCalculatedMaxValue )
{
mCalculatedMaxValue = value;
}
mValues[ index ] = value;
}
}
}
mFeaturesRendered++;
#if 0
//TODO - enable progressive rendering
if ( mFeaturesRendered % 200 == 0 )
{
renderImage( context );
}
#endif
return true;
}
bool QgsPointDistanceRenderer::renderFeature( QgsFeature& feature, QgsRenderContext& context, int layer, bool selected, bool drawVertexMarker )
{
Q_UNUSED( drawVertexMarker );
Q_UNUSED( context );
Q_UNUSED( layer );
//check if there is already a point at that position
if ( !feature.hasGeometry() )
return false;
QgsMarkerSymbol* symbol = firstSymbolForFeature( feature, context );
//if the feature has no symbol (eg, no matching rule in a rule-based renderer), skip it
if ( !symbol )
return false;
//point position in screen coords
QgsGeometry geom = feature.geometry();
QgsWkbTypes::Type geomType = geom.wkbType();
if ( QgsWkbTypes::flatType( geomType ) != QgsWkbTypes::Point )
{
//can only render point type
return false;
}
QString label;
if ( mDrawLabels )
{
label = getLabel( feature );
}
QgsCoordinateTransform xform = context.coordinateTransform();
QgsFeature transformedFeature = feature;
if ( xform.isValid() )
{
geom.transform( xform );
transformedFeature.setGeometry( geom );
}
double searchDistance = mTolerance * QgsSymbolLayerUtils::mapUnitScaleFactor( context, mToleranceUnit, mToleranceMapUnitScale );
QgsPoint point = transformedFeature.geometry().asPoint();
QList<QgsFeatureId> intersectList = mSpatialIndex->intersects( searchRect( point, searchDistance ) );
if ( intersectList.empty() )
{
mSpatialIndex->insertFeature( transformedFeature );
// create new group
ClusteredGroup newGroup;
newGroup << GroupedFeature( transformedFeature, symbol, selected, label );
mClusteredGroups.push_back( newGroup );
// add to group index
mGroupIndex.insert( transformedFeature.id(), mClusteredGroups.count() - 1 );
mGroupLocations.insert( transformedFeature.id(), point );
}
else
{
// find group with closest location to this point (may be more than one within search tolerance)
QgsFeatureId minDistFeatureId = intersectList.at( 0 );
double minDist = mGroupLocations.value( minDistFeatureId ).distance( point );
for ( int i = 1; i < intersectList.count(); ++i )
{
QgsFeatureId candidateId = intersectList.at( i );
double newDist = mGroupLocations.value( candidateId ).distance( point );
if ( newDist < minDist )
{
minDist = newDist;
minDistFeatureId = candidateId;
}
}
int groupIdx = mGroupIndex[ minDistFeatureId ];
ClusteredGroup& group = mClusteredGroups[groupIdx];
// calculate new centroid of group
QgsPoint oldCenter = mGroupLocations.value( minDistFeatureId );
mGroupLocations[ minDistFeatureId ] = QgsPoint(( oldCenter.x() * group.size() + point.x() ) / ( group.size() + 1.0 ),
( oldCenter.y() * group.size() + point.y() ) / ( group.size() + 1.0 ) );
// add to a group
group << GroupedFeature( transformedFeature, symbol, selected, label );
// add to group index
mGroupIndex.insert( transformedFeature.id(), groupIdx );
}
return true;
}
void QgsPalLabeling::registerDiagramFeature( QgsVectorLayer* layer, QgsFeature& feat, const QgsRenderContext& context )
{
//get diagram layer settings, diagram renderer
QHash<QgsVectorLayer*, QgsDiagramLayerSettings>::iterator layerIt = mActiveDiagramLayers.find( layer );
if ( layerIt == mActiveDiagramLayers.constEnd() )
{
return;
}
//convert geom to geos
QgsGeometry* geom = feat.geometry();
if ( layerIt.value().ct && !willUseLayer( layer ) ) // reproject the geometry if feature not already transformed for labeling
{
geom->transform( *( layerIt.value().ct ) );
}
GEOSGeometry* geos_geom = geom->asGeos();
if ( geos_geom == 0 )
{
return; // invalid geometry
}
//create PALGeometry with diagram = true
QgsPalGeometry* lbl = new QgsPalGeometry( feat.id(), "", GEOSGeom_clone( geos_geom ) );
lbl->setIsDiagram( true );
// record the created geometry - it will be deleted at the end.
layerIt.value().geometries.append( lbl );
double diagramWidth = 0;
double diagramHeight = 0;
QgsDiagramRendererV2* dr = layerIt.value().renderer;
if ( dr )
{
QSizeF diagSize = dr->sizeMapUnits( feat.attributeMap(), context );
if ( diagSize.isValid() )
{
diagramWidth = diagSize.width();
diagramHeight = diagSize.height();
}
//append the diagram attributes to lbl
QList<int> diagramAttrib = dr->diagramAttributes();
QList<int>::const_iterator diagAttIt = diagramAttrib.constBegin();
for ( ; diagAttIt != diagramAttrib.constEnd(); ++diagAttIt )
{
lbl->addDiagramAttribute( *diagAttIt, feat.attributeMap()[*diagAttIt] );
}
}
// register feature to the layer
int ddColX = layerIt.value().xPosColumn;
int ddColY = layerIt.value().yPosColumn;
double ddPosX = 0.0;
double ddPosY = 0.0;
bool ddPos = ( ddColX >= 0 && ddColY >= 0 );
if ( ddPos )
{
bool posXOk, posYOk;
//data defined diagram position is always centered
ddPosX = feat.attributeMap()[ddColX].toDouble( &posXOk ) - diagramWidth / 2.0;
ddPosY = feat.attributeMap()[ddColY].toDouble( &posYOk ) - diagramHeight / 2.0;
if ( !posXOk || !posYOk )
{
ddPos = false;
}
else
{
const QgsCoordinateTransform* ct = layerIt.value().ct;
if ( ct )
{
double z = 0;
ct->transformInPlace( ddPosX, ddPosY, z );
}
}
}
try
{
if ( !layerIt.value().palLayer->registerFeature( lbl->strId(), lbl, diagramWidth, diagramHeight, "", ddPosX, ddPosY, ddPos ) )
{
return;
}
}
catch ( std::exception &e )
{
Q_UNUSED( e );
QgsDebugMsg( QString( "Ignoring feature %1 due PAL exception: " ).arg( feat.id() ) + QString::fromLatin1( e.what() ) );
return;
}
pal::Feature* palFeat = layerIt.value().palLayer->getFeature( lbl->strId() );
QgsPoint ptZero = layerIt.value().xform->toMapCoordinates( 0, 0 );
QgsPoint ptOne = layerIt.value().xform->toMapCoordinates( 1, 0 );
palFeat->setDistLabel( qAbs( ptOne.x() - ptZero.x() ) * layerIt.value().dist );
}
void QgsPalLayerSettings::registerFeature( QgsFeature& f, const QgsRenderContext& context )
{
QString labelText;
if ( formatNumbers == true
&& ( f.attributeMap()[fieldIndex].type() == QVariant::Int || f.attributeMap()[fieldIndex].type() == QVariant::Double ) )
{
QString numberFormat;
double d = f.attributeMap()[fieldIndex].toDouble();
if ( d > 0 && plusSign == true )
{
numberFormat.append( "+" );
}
numberFormat.append( "%1" );
labelText = numberFormat.arg( d, 0, 'f', decimals );
}
else
{
labelText = f.attributeMap()[fieldIndex].toString();
}
double labelX, labelY; // will receive label size
QFont labelFont = textFont;
//data defined label size?
QMap< DataDefinedProperties, int >::const_iterator it = dataDefinedProperties.find( QgsPalLayerSettings::Size );
if ( it != dataDefinedProperties.constEnd() )
{
//find out size
QVariant size = f.attributeMap().value( *it );
if ( size.isValid() )
{
double sizeDouble = size.toDouble();
if ( sizeDouble <= 0 )
{
return;
}
labelFont.setPixelSize( sizeToPixel( sizeDouble, context ) );
}
QFontMetricsF labelFontMetrics( labelFont );
calculateLabelSize( &labelFontMetrics, labelText, labelX, labelY );
}
else
{
calculateLabelSize( fontMetrics, labelText, labelX, labelY );
}
QgsGeometry* geom = f.geometry();
if ( ct ) // reproject the geometry if necessary
geom->transform( *ct );
if ( !checkMinimumSizeMM( context, geom, minFeatureSize ) )
{
return;
}
// CLIP the geometry if it is bigger than the extent
QgsGeometry* geomClipped = NULL;
GEOSGeometry* geos_geom;
bool do_clip = !extentGeom->contains( geom );
if ( do_clip )
{
geomClipped = geom->intersection( extentGeom ); // creates new geometry
geos_geom = geomClipped->asGeos();
}
else
{
geos_geom = geom->asGeos();
}
if ( geos_geom == NULL )
return; // invalid geometry
GEOSGeometry* geos_geom_clone = GEOSGeom_clone( geos_geom );
if ( do_clip )
delete geomClipped;
//data defined position / alignment / rotation?
bool dataDefinedPosition = false;
bool dataDefinedRotation = false;
double xPos = 0.0, yPos = 0.0, angle = 0.0;
bool ddXPos, ddYPos;
QMap< DataDefinedProperties, int >::const_iterator dPosXIt = dataDefinedProperties.find( QgsPalLayerSettings::PositionX );
if ( dPosXIt != dataDefinedProperties.constEnd() )
{
QMap< DataDefinedProperties, int >::const_iterator dPosYIt = dataDefinedProperties.find( QgsPalLayerSettings::PositionY );
if ( dPosYIt != dataDefinedProperties.constEnd() )
{
//data defined position. But field values could be NULL -> positions will be generated by PAL
xPos = f.attributeMap().value( *dPosXIt ).toDouble( &ddXPos );
yPos = f.attributeMap().value( *dPosYIt ).toDouble( &ddYPos );
if ( ddXPos && ddYPos )
{
dataDefinedPosition = true;
//x/y shift in case of alignment
double xdiff = 0;
double ydiff = 0;
//horizontal alignment
QMap< DataDefinedProperties, int >::const_iterator haliIt = dataDefinedProperties.find( QgsPalLayerSettings::Hali );
if ( haliIt != dataDefinedProperties.end() )
{
QString haliString = f.attributeMap().value( *haliIt ).toString();
if ( haliString.compare( "Center", Qt::CaseInsensitive ) == 0 )
{
xdiff -= labelX / 2.0;
}
else if ( haliString.compare( "Right", Qt::CaseInsensitive ) == 0 )
{
xdiff -= labelX;
}
}
//vertical alignment
QMap< DataDefinedProperties, int >::const_iterator valiIt = dataDefinedProperties.find( QgsPalLayerSettings::Vali );
if ( valiIt != dataDefinedProperties.constEnd() )
{
QString valiString = f.attributeMap().value( *valiIt ).toString();
if ( valiString.compare( "Bottom", Qt::CaseInsensitive ) != 0 )
{
if ( valiString.compare( "Top", Qt::CaseInsensitive ) == 0 || valiString.compare( "Cap", Qt::CaseInsensitive ) == 0 )
{
ydiff -= labelY;
}
else
{
QFontMetrics labelFontMetrics( labelFont );
double descentRatio = labelFontMetrics.descent() / labelFontMetrics.height();
if ( valiString.compare( "Base", Qt::CaseInsensitive ) == 0 )
{
ydiff -= labelY * descentRatio;
}
else if ( valiString.compare( "Half", Qt::CaseInsensitive ) == 0 )
{
ydiff -= labelY * descentRatio;
ydiff -= labelY * 0.5 * ( 1 - descentRatio );
}
}
}
}
//data defined rotation?
QMap< DataDefinedProperties, int >::const_iterator rotIt = dataDefinedProperties.find( QgsPalLayerSettings::Rotation );
if ( rotIt != dataDefinedProperties.constEnd() )
{
dataDefinedRotation = true;
angle = f.attributeMap().value( *rotIt ).toDouble() * M_PI / 180;
//adjust xdiff and ydiff because the hali/vali point needs to be the rotation center
double xd = xdiff * cos( angle ) - ydiff * sin( angle );
double yd = xdiff * sin( angle ) + ydiff * cos( angle );
xdiff = xd;
ydiff = yd;
}
//project xPos and yPos from layer to map CRS
double z = 0;
if ( ct )
{
ct->transformInPlace( xPos, yPos, z );
}
yPos += ydiff;
xPos += xdiff;
}
}
}
QgsPalGeometry* lbl = new QgsPalGeometry( f.id(), labelText, geos_geom_clone );
// record the created geometry - it will be deleted at the end.
geometries.append( lbl );
// register feature to the layer
try
{
if ( !palLayer->registerFeature( lbl->strId(), lbl, labelX, labelY, labelText.toUtf8().constData(),
xPos, yPos, dataDefinedPosition, angle, dataDefinedRotation ) )
return;
}
catch ( std::exception &e )
{
Q_UNUSED( e );
QgsDebugMsg( QString( "Ignoring feature %1 due PAL exception: " ).arg( f.id() ) + QString::fromLatin1( e.what() ) );
return;
}
// TODO: only for placement which needs character info
pal::Feature* feat = palLayer->getFeature( lbl->strId() );
feat->setLabelInfo( lbl->info( fontMetrics, xform, rasterCompressFactor ) );
// TODO: allow layer-wide feature dist in PAL...?
//data defined label-feature distance?
double distance = dist;
QMap< DataDefinedProperties, int >::const_iterator dDistIt = dataDefinedProperties.find( QgsPalLayerSettings::LabelDistance );
if ( dDistIt != dataDefinedProperties.constEnd() )
{
distance = f.attributeMap().value( *dDistIt ).toDouble();
}
if ( distance != 0 )
{
if ( distInMapUnits ) //convert distance from mm/map units to pixels
{
distance /= context.mapToPixel().mapUnitsPerPixel();
}
else //mm
{
distance *= vectorScaleFactor;
}
feat->setDistLabel( qAbs( ptOne.x() - ptZero.x() )* distance );
}
//add parameters for data defined labeling to QgsPalGeometry
QMap< DataDefinedProperties, int >::const_iterator dIt = dataDefinedProperties.constBegin();
for ( ; dIt != dataDefinedProperties.constEnd(); ++dIt )
{
lbl->addDataDefinedValue( dIt.key(), f.attributeMap()[dIt.value()] );
}
}
QgsFeatureIds QgsMapToolSelectUtils::getMatchingFeatures( QgsMapCanvas *canvas, const QgsGeometry &selectGeometry, bool doContains, bool singleSelect )
{
QgsFeatureIds newSelectedFeatures;
if ( selectGeometry.type() != QgsWkbTypes::PolygonGeometry )
return newSelectedFeatures;
QgsVectorLayer *vlayer = QgsMapToolSelectUtils::getCurrentVectorLayer( canvas );
if ( !vlayer )
return newSelectedFeatures;
// toLayerCoordinates will throw an exception for any 'invalid' points in
// the rubber band.
// For example, if you project a world map onto a globe using EPSG 2163
// and then click somewhere off the globe, an exception will be thrown.
QgsGeometry selectGeomTrans = selectGeometry;
try
{
QgsCoordinateTransform ct( canvas->mapSettings().destinationCrs(), vlayer->crs(), QgsProject::instance() );
if ( !ct.isShortCircuited() && selectGeomTrans.type() == QgsWkbTypes::PolygonGeometry )
{
// convert add more points to the edges of the rectangle
// improve transformation result
QgsPolygonXY poly( selectGeomTrans.asPolygon() );
if ( poly.size() == 1 && poly.at( 0 ).size() == 5 )
{
const QgsPolylineXY &ringIn = poly.at( 0 );
QgsPolygonXY newpoly( 1 );
newpoly[0].resize( 41 );
QgsPolylineXY &ringOut = newpoly[0];
ringOut[ 0 ] = ringIn.at( 0 );
int i = 1;
for ( int j = 1; j < 5; j++ )
{
QgsVector v( ( ringIn.at( j ) - ringIn.at( j - 1 ) ) / 10.0 );
for ( int k = 0; k < 9; k++ )
{
ringOut[ i ] = ringOut[ i - 1 ] + v;
i++;
}
ringOut[ i++ ] = ringIn.at( j );
}
selectGeomTrans = QgsGeometry::fromPolygonXY( newpoly );
}
}
selectGeomTrans.transform( ct );
}
catch ( QgsCsException &cse )
{
Q_UNUSED( cse );
// catch exception for 'invalid' point and leave existing selection unchanged
QgsDebugMsg( QStringLiteral( "Caught CRS exception " ) );
QgisApp::instance()->messageBar()->pushMessage(
QObject::tr( "CRS Exception" ),
QObject::tr( "Selection extends beyond layer's coordinate system" ),
Qgis::Warning,
QgisApp::instance()->messageTimeout() );
return newSelectedFeatures;
}
QgsDebugMsgLevel( "Selection layer: " + vlayer->name(), 3 );
QgsDebugMsgLevel( "Selection polygon: " + selectGeomTrans.asWkt(), 3 );
QgsDebugMsgLevel( "doContains: " + QString( doContains ? "T" : "F" ), 3 );
QgsRenderContext context = QgsRenderContext::fromMapSettings( canvas->mapSettings() );
context.expressionContext() << QgsExpressionContextUtils::layerScope( vlayer );
std::unique_ptr< QgsFeatureRenderer > r;
if ( vlayer->renderer() )
{
r.reset( vlayer->renderer()->clone() );
r->startRender( context, vlayer->fields() );
}
QgsFeatureRequest request;
request.setFilterRect( selectGeomTrans.boundingBox() );
request.setFlags( QgsFeatureRequest::ExactIntersect );
if ( r )
request.setSubsetOfAttributes( r->usedAttributes( context ), vlayer->fields() );
else
request.setNoAttributes();
QgsFeatureIterator fit = vlayer->getFeatures( request );
QgsFeature f;
QgsFeatureId closestFeatureId = 0;
bool foundSingleFeature = false;
double closestFeatureDist = std::numeric_limits<double>::max();
while ( fit.nextFeature( f ) )
{
context.expressionContext().setFeature( f );
// make sure to only use features that are visible
if ( r && !r->willRenderFeature( f, context ) )
continue;
QgsGeometry g = f.geometry();
if ( doContains )
{
if ( !selectGeomTrans.contains( g ) )
continue;
}
else
{
if ( !selectGeomTrans.intersects( g ) )
continue;
}
if ( singleSelect )
{
foundSingleFeature = true;
double distance = g.distance( selectGeomTrans );
if ( distance <= closestFeatureDist )
{
closestFeatureDist = distance;
closestFeatureId = f.id();
}
}
else
{
newSelectedFeatures.insert( f.id() );
}
}
if ( singleSelect && foundSingleFeature )
{
newSelectedFeatures.insert( closestFeatureId );
}
if ( r )
r->stopRender( context );
QgsDebugMsg( "Number of new selected features: " + QString::number( newSelectedFeatures.size() ) );
return newSelectedFeatures;
}
