QList<double> QgsGeometryAnalyzer::simpleMeasure( QgsGeometry& mpGeometry )
{
QList<double> list;
double perim;
if ( mpGeometry.wkbType() == QgsWkbTypes::Point )
{
QgsPoint pt = mpGeometry.asPoint();
list.append( pt.x() );
list.append( pt.y() );
}
else
{
QgsDistanceArea measure;
list.append( measure.measureArea( mpGeometry ) );
if ( mpGeometry.type() == QgsWkbTypes::PolygonGeometry )
{
perim = perimeterMeasure( mpGeometry, measure );
list.append( perim );
}
}
return list;
}
void QgsGeometryAnalyzer::simplifyFeature( QgsFeature &f, QgsVectorFileWriter *vfw, double tolerance )
{
if ( !f.hasGeometry() )
{
return;
}
QgsGeometry featureGeometry = f.geometry();
// simplify feature
QgsGeometry tmpGeometry = featureGeometry.simplify( tolerance );
QgsFeature newFeature;
newFeature.setGeometry( tmpGeometry );
newFeature.setAttributes( f.attributes() );
//add it to vector file writer
if ( vfw )
{
vfw->addFeature( newFeature );
}
}
void QgsGeometryAnalyzer::dissolveFeature( QgsFeature& f, int nProcessedFeatures, QgsGeometry** dissolveGeometry )
{
QgsGeometry* featureGeometry = f.geometry();
if ( !featureGeometry )
{
return;
}
if ( nProcessedFeatures == 0 )
{
int geomSize = featureGeometry->wkbSize();
*dissolveGeometry = new QgsGeometry();
unsigned char* wkb = new unsigned char[geomSize];
memcpy( wkb, featureGeometry->asWkb(), geomSize );
( *dissolveGeometry )->fromWkb( wkb, geomSize );
}
else
{
*dissolveGeometry = ( *dissolveGeometry )->combine( featureGeometry );
}
}
bool QgsVectorLayerEditUtils::deleteVertex( QgsFeatureId atFeatureId, int atVertex )
{
if ( !L->hasGeometryType() )
return false;
QgsGeometry geometry;
if ( !cache()->geometry( atFeatureId, geometry ) )
{
// it's not in cache: let's fetch it from layer
QgsFeature f;
if ( !L->getFeatures( QgsFeatureRequest().setFilterFid( atFeatureId ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( f ) || !f.constGeometry() )
return false; // geometry not found
geometry = *f.constGeometry();
}
if ( !geometry.deleteVertex( atVertex ) )
return false;
L->editBuffer()->changeGeometry( atFeatureId, &geometry );
return true;
}
void QgsGeometryAnalyzer::centroidFeature( QgsFeature& f, QgsVectorFileWriter* vfw )
{
QgsGeometry* featureGeometry = f.geometry();
QgsGeometry* tmpGeometry = 0;
if ( !featureGeometry )
{
return;
}
tmpGeometry = featureGeometry->centroid();
QgsFeature newFeature;
newFeature.setGeometry( tmpGeometry );
newFeature.setAttributes( f.attributes() );
//add it to vector file writer
if ( vfw )
{
vfw->addFeature( newFeature );
}
}
bool QgsSpatialQuery::hasValidGeometry( QgsFeature &feature )
{
if ( ! feature.isValid() )
{
return false;
}
QgsGeometry *geom = feature.geometry();
if ( NULL == geom )
{
return false;
}
if ( geom->isGeosEmpty() || !geom->isGeosValid() )
{
return false;
}
return true;
} // bool QgsSpatialQuery::hasValidGeometry(QgsFeature &feature)
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();
}
}
}
bool QgsTransectSample::otherTransectWithinDistance( QgsGeometry* geom, double minDistLayerUnit, double minDistance, QgsSpatialIndex& sIndex,
const QMap< QgsFeatureId, QgsGeometry* >& lineFeatureMap, QgsDistanceArea& da )
{
if ( !geom )
{
return false;
}
QgsGeometry* buffer = geom->buffer( minDistLayerUnit, 8 );
if ( !buffer )
{
return false;
}
QgsRectangle rect = buffer->boundingBox();
QList<QgsFeatureId> lineIdList = sIndex.intersects( rect );
QList<QgsFeatureId>::const_iterator lineIdIt = lineIdList.constBegin();
for ( ; lineIdIt != lineIdList.constEnd(); ++lineIdIt )
{
const QMap< QgsFeatureId, QgsGeometry* >::const_iterator idMapIt = lineFeatureMap.find( *lineIdIt );
if ( idMapIt != lineFeatureMap.constEnd() )
{
double dist = 0;
QgsPoint pt1, pt2;
closestSegmentPoints( *geom, *( idMapIt.value() ), dist, pt1, pt2 );
dist = da.measureLine( pt1, pt2 ); //convert degrees to meters if necessary
if ( dist < minDistance )
{
delete buffer;
return true;
}
}
}
delete buffer;
return false;
}
bool QgsGPXFeatureIterator::readRoute( const QgsRoute& rte, QgsFeature& feature )
{
if ( rte.points.size() == 0 )
return false;
QgsGeometry* theGeometry = readRouteGeometry( rte );
if ( mRequest.filterType() == QgsFeatureRequest::FilterRect )
{
const QgsRectangle& rect = mRequest.filterRect();
if (( rte.xMax < rect.xMinimum() ) || ( rte.xMin > rect.xMaximum() ) ||
( rte.yMax < rect.yMinimum() ) || ( rte.yMin > rect.yMaximum() ) )
return false;
if ( !theGeometry->intersects( rect ) ) //use geos for precise intersection test
{
delete theGeometry;
return false;
}
}
if ( !( mRequest.flags() & QgsFeatureRequest::NoGeometry ) )
{
feature.setGeometry( theGeometry );
}
else
{
delete theGeometry;
}
feature.setFeatureId( rte.id );
feature.setValid( true );
feature.setFields( &mSource->mFields ); // allow name-based attribute lookups
feature.initAttributes( mSource->mFields.count() );
readAttributes( feature, rte );
return true;
}
int QgsVectorLayerEditUtils::addPart( QgsCurveV2* ring, QgsFeatureId featureId )
{
if ( !L->hasGeometryType() )
return 6;
QgsGeometry geometry;
bool firstPart = false;
if ( !cache()->geometry( featureId, geometry ) ) // maybe it's in cache
{
// it's not in cache: let's fetch it from layer
QgsFeature f;
if ( !L->getFeatures( QgsFeatureRequest().setFilterFid( featureId ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( f ) )
return 6; //not found
if ( !f.constGeometry() || f.constGeometry()->isEmpty() )
{
//no existing geometry, so adding first part to null geometry
firstPart = true;
}
else
{
geometry = *f.geometry();
}
}
int errorCode = geometry.addPart( ring, L->geometryType() );
if ( errorCode == 0 )
{
if ( firstPart && QgsWKBTypes::isSingleType( QGis::fromOldWkbType( L->wkbType() ) )
&& L->dataProvider()->doesStrictFeatureTypeCheck() )
{
//convert back to single part if required by layer
geometry.convertToSingleType();
}
L->editBuffer()->changeGeometry( featureId, &geometry );
}
return errorCode;
}
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;
}
int QgsVectorLayerEditUtils::addPart( const QList<QgsPoint> &points, QgsFeatureId featureId )
{
if ( !L->hasGeometryType() )
return 6;
QgsGeometry geometry;
if ( !cache()->geometry( featureId, geometry ) ) // maybe it's in cache
{
// it's not in cache: let's fetch it from layer
QgsFeature f;
if ( !L->getFeatures( QgsFeatureRequest().setFilterFid( featureId ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( f ) || !f.geometry() )
return 6; //geometry not found
geometry = *f.geometry();
}
int errorCode = geometry.addPart( points, L->geometryType() );
if ( errorCode == 0 )
{
L->editBuffer()->changeGeometry( featureId, &geometry );
}
return errorCode;
}
int QgsVectorLayerEditUtils::translateFeature( QgsFeatureId featureId, double dx, double dy )
{
if ( !L->hasGeometryType() )
return 1;
QgsGeometry geometry;
if ( !cache()->geometry( featureId, geometry ) ) // maybe it's in cache
{
// it's not in cache: let's fetch it from layer
QgsFeature f;
if ( !L->getFeatures( QgsFeatureRequest().setFilterFid( featureId ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( f ) || !f.constGeometry() )
return 1; //geometry not found
geometry = *f.constGeometry();
}
int errorCode = geometry.translate( dx, dy );
if ( errorCode == 0 )
{
L->editBuffer()->changeGeometry( featureId, &geometry );
}
return errorCode;
}
bool TopolError::fixSnap()
{
bool ok;
QgsFeature f1, f2;
FeatureLayer fl = mFeaturePairs.at( 1 );
ok = fl.layer->getFeatures( ( QgsFeatureRequest().setFilterFid( fl.feature.id() ) ) ).nextFeature( f2 );
fl = mFeaturePairs.first();
ok = ok && fl.layer->getFeatures( QgsFeatureRequest().setFilterFid( fl.feature.id() ) ).nextFeature( f1 );
if ( !ok )
return false;
QgsGeometry ge = f1.geometry();
QgsPolylineXY line = ge.asPolyline();
QgsPolylineXY conflictLine = mConflict.asPolyline();
line.last() = conflictLine.last();
QgsGeometry newG = QgsGeometry::fromPolylineXY( line );
bool ret = fl.layer->changeGeometry( f1.id(), newG );
return ret;
}
void TestQgsGeometrySnapper::snapPointToPoint()
{
QgsVectorLayer* rl = new QgsVectorLayer( QStringLiteral( "Point" ), QStringLiteral( "x" ), QStringLiteral( "memory" ) );
QgsGeometry refGeom = QgsGeometry::fromWkt( QStringLiteral( "Point(0 0)" ) );
QgsFeature ff( 0 );
ff.setGeometry( refGeom );
QgsGeometry refGeom2 = QgsGeometry::fromWkt( QStringLiteral( "Point(1 0)" ) );
QgsFeature ff2( 2 );
ff2.setGeometry( refGeom2 );
QgsFeatureList flist;
flist << ff << ff2;
rl->dataProvider()->addFeatures( flist );
QgsGeometry pointGeom = QgsGeometry::fromWkt( QStringLiteral( "Point(0.1 -0.1)" ) );
QgsGeometrySnapper snapper( rl );
QgsGeometry result = snapper.snapGeometry( pointGeom, 1 );
QCOMPARE( result.exportToWkt(), QStringLiteral( "Point (0 0)" ) );
pointGeom = QgsGeometry::fromWkt( QStringLiteral( "Point(0.6 -0.1)" ) );
result = snapper.snapGeometry( pointGeom, 1 );
QCOMPARE( result.exportToWkt(), QStringLiteral( "Point (1 0)" ) );
}
void QgsMapToolDeleteRing::canvasReleaseEvent( QgsMapMouseEvent *e )
{
Q_UNUSED( e );
delete mRubberBand;
mRubberBand = nullptr;
if ( mPressedFid == -1 )
return;
QgsFeature f;
vlayer->getFeatures( QgsFeatureRequest().setFilterFid( mPressedFid ) ).nextFeature( f );
QgsGeometry g = f.geometry();
if ( g.deleteRing( mPressedRingNum, mPressedPartNum ) )
{
vlayer->beginEditCommand( tr( "Ring deleted" ) );
vlayer->changeGeometry( mPressedFid, g );
vlayer->endEditCommand();
vlayer->triggerRepaint();
}
}
bool QgsGPXFeatureIterator::readTrack( const QgsTrack& trk, QgsFeature& feature )
{
//QgsDebugMsg( QString( "GPX feature track segments: %1" ).arg( trk.segments.size() ) );
QgsGeometry* theGeometry = readTrackGeometry( trk );
if ( mRequest.filterType() == QgsFeatureRequest::FilterRect )
{
const QgsRectangle& rect = mRequest.filterRect();
if (( trk.xMax < rect.xMinimum() ) || ( trk.xMin > rect.xMaximum() ) ||
( trk.yMax < rect.yMinimum() ) || ( trk.yMin > rect.yMaximum() ) )
return false;
if ( !theGeometry->intersects( rect ) ) //use geos for precise intersection test
{
delete theGeometry;
return false;
}
}
if ( !( mRequest.flags() & QgsFeatureRequest::NoGeometry ) )
{
feature.setGeometry( theGeometry );
}
else
{
delete theGeometry;
}
feature.setFeatureId( trk.id );
feature.setValid( true );
feature.setFields( &mSource->mFields ); // allow name-based attribute lookups
feature.initAttributes( mSource->mFields.count() );
readAttributes( feature, trk );
return true;
}
void QgsGeometrySegmentLengthCheck::collectErrors( QList<QgsGeometryCheckError*>& errors, QStringList &/*messages*/, QAtomicInt* progressCounter , const QgsFeatureIds &ids ) const
{
const QgsFeatureIds& featureIds = ids.isEmpty() ? mFeaturePool->getFeatureIds() : ids;
Q_FOREACH ( QgsFeatureId featureid, featureIds )
{
if ( progressCounter ) progressCounter->fetchAndAddRelaxed( 1 );
QgsFeature feature;
if ( !mFeaturePool->get( featureid, feature ) )
{
continue;
}
QgsGeometry featureGeom = feature.geometry();
QgsAbstractGeometry* geom = featureGeom.geometry();
for ( int iPart = 0, nParts = geom->partCount(); iPart < nParts; ++iPart )
{
for ( int iRing = 0, nRings = geom->ringCount( iPart ); iRing < nRings; ++iRing )
{
int nVerts = QgsGeometryCheckerUtils::polyLineSize( geom, iPart, iRing );
if ( nVerts < 2 )
{
continue;
}
for ( int iVert = 0, jVert = nVerts - 1; iVert < nVerts; jVert = iVert++ )
{
QgsPointV2 pi = geom->vertexAt( QgsVertexId( iPart, iRing, iVert ) );
QgsPointV2 pj = geom->vertexAt( QgsVertexId( iPart, iRing, jVert ) );
double dist = qSqrt( QgsGeometryUtils::sqrDistance2D( pi, pj ) );
if ( dist < mMinLength )
{
errors.append( new QgsGeometryCheckError( this, featureid, QgsPointV2( 0.5 * ( pi.x() + pj.x() ), 0.5 * ( pi.y() + pj.y() ) ), QgsVertexId( iPart, iRing, iVert ), dist, QgsGeometryCheckError::ValueLength ) );
}
}
}
}
}
}
void eval_geometry_method()
{
QFETCH( QString, string );
QFETCH( void*, geomptr );
QFETCH( bool, evalError );
QFETCH( bool, needGeom );
QFETCH( void*, resultptr );
QgsGeometry* geom = ( QgsGeometry* ) geomptr;
QgsGeometry* result = ( QgsGeometry* ) resultptr;
QgsFeature f;
f.setGeometry( geom );
QgsExpression exp( string );
QCOMPARE( exp.hasParserError(), false );
QCOMPARE( exp.needsGeometry(), needGeom );
QVariant out = exp.evaluate( &f );
QCOMPARE( exp.hasEvalError(), evalError );
QCOMPARE( out.canConvert<QgsGeometry>(), true );
QgsGeometry outGeom = out.value<QgsGeometry>();
QCOMPARE( outGeom.exportToWkt(), result->exportToWkt() );
}
static void buildSnapIndex( QgsFeatureIterator &fi, QgsSpatialIndex &index, QVector<AnchorPoint> &pnts, QgsFeedback *feedback, int &count, int totalCount )
{
QgsFeature f;
int pntId = 0;
while ( fi.nextFeature( f ) )
{
if ( feedback->isCanceled() )
break;
QgsGeometry g = f.geometry();
for ( auto it = g.vertices_begin(); it != g.vertices_end(); ++it )
{
QgsPoint pt = *it;
QgsRectangle rect( pt.x(), pt.y(), pt.x(), pt.y() );
QList<QgsFeatureId> ids = index.intersects( rect );
if ( ids.isEmpty() )
{
// add to tree and to structure
index.insertFeature( pntId, pt.boundingBox() );
AnchorPoint xp;
xp.x = pt.x();
xp.y = pt.y();
xp.anchor = -1;
pnts.append( xp );
pntId++;
}
}
++count;
feedback->setProgress( 100. * count / totalCount );
}
}
void QgsOverlayAnalyzer::intersectFeature( QgsFeature &f, QgsVectorFileWriter *vfw,
QgsVectorLayer *vl, QgsSpatialIndex *index )
{
if ( !f.hasGeometry() )
{
return;
}
QgsGeometry featureGeometry = f.geometry();
QgsGeometry intersectGeometry;
QgsFeature overlayFeature;
QList<QgsFeatureId> intersects = index->intersects( featureGeometry.boundingBox() );
QgsFeatureRequest req = QgsFeatureRequest().setFilterFids( intersects.toSet() );
QgsFeatureIterator intersectIt = vl->getFeatures( req );
QgsFeature outFeature;
while ( intersectIt.nextFeature( overlayFeature ) )
{
if ( featureGeometry.intersects( overlayFeature.geometry() ) )
{
intersectGeometry = featureGeometry.intersection( overlayFeature.geometry() );
outFeature.setGeometry( intersectGeometry );
QgsAttributes attributesA = f.attributes();
QgsAttributes attributesB = overlayFeature.attributes();
combineAttributeMaps( attributesA, attributesB );
outFeature.setAttributes( attributesA );
//add it to vector file writer
if ( vfw )
{
vfw->addFeature( outFeature );
}
}
}
}
void QgsGeometryHoleCheck::collectErrors( QList<QgsGeometryCheckError*>& errors, QStringList &/*messages*/, QAtomicInt* progressCounter , const QgsFeatureIds &ids ) const
{
const QgsFeatureIds& featureIds = ids.isEmpty() ? mFeaturePool->getFeatureIds() : ids;
Q_FOREACH ( QgsFeatureId featureid, featureIds )
{
if ( progressCounter ) progressCounter->fetchAndAddRelaxed( 1 );
QgsFeature feature;
if ( !mFeaturePool->get( featureid, feature ) )
{
continue;
}
QgsGeometry featureGeom = feature.geometry();
QgsAbstractGeometry* geom = featureGeom.geometry();
for ( int iPart = 0, nParts = geom->partCount(); iPart < nParts; ++iPart )
{
// Rings after the first one are interiors
for ( int iRing = 1, nRings = geom->ringCount( iPart ); iRing < nRings; ++iRing )
{
errors.append( new QgsGeometryCheckError( this, featureid, QgsGeometryCheckerUtils::getGeomPart( geom, iPart )->centroid(), QgsVertexId( iPart, iRing ) ) );
}
}
}
}
void QgsWFSData::calculateExtentFromFeatures() const
{
if ( mFeatures.size() < 1 )
{
return;
}
QgsRectangle bbox;
QgsFeature* currentFeature = 0;
QgsGeometry* currentGeometry = 0;
bool bboxInitialised = false; //gets true once bbox has been set to the first geometry
for ( int i = 0; i < mFeatures.size(); ++i )
{
currentFeature = mFeatures[i];
if ( !currentFeature )
{
continue;
}
currentGeometry = currentFeature->geometry();
if ( currentGeometry )
{
if ( !bboxInitialised )
{
bbox = currentGeometry->boundingBox();
bboxInitialised = true;
}
else
{
bbox.unionRect( currentGeometry->boundingBox() );
}
}
}
( *mExtent ) = bbox;
}
ErrorList topolTest::checkMultipart( double tolerance, QgsVectorLayer *layer1, QgsVectorLayer *layer2, bool isExtent )
{
Q_UNUSED( tolerance );
Q_UNUSED( layer2 );
Q_UNUSED( layer1 );
Q_UNUSED( isExtent );
int i = 0;
ErrorList errorList;
QList<FeatureLayer>::Iterator it;
for ( it = mFeatureList1.begin(); it != mFeatureList1.end(); ++it )
{
if ( !( ++i % 100 ) )
emit progress( ++i );
if ( testCancelled() )
break;
QgsGeometry* g = it->feature.geometry();
if ( !g )
{
QgsMessageLog::logMessage( tr( "Missing geometry in multipart check." ), tr( "Topology plugin" ) );
continue;
}
if ( !g->asGeos() )
continue;
if ( g->isMultipart() )
{
QgsRectangle r = g->boundingBox();
QList<FeatureLayer> fls;
fls << *it << *it;
QgsGeometry* conflict = new QgsGeometry( *g );
TopolErroMultiPart* err = new TopolErroMultiPart( r, conflict, fls );
errorList << err;
}
}
return errorList;
}
QgsPoint QgsGeometryAnalyzer::createPointOffset( double x, double y, double dist, const QgsGeometry& lineGeom ) const
{
QgsPoint p( x, y );
QgsPoint minDistPoint;
int afterVertexNr;
lineGeom.closestSegmentWithContext( p, minDistPoint, afterVertexNr );
int beforeVertexNr = afterVertexNr - 1;
QgsPoint beforeVertex = lineGeom.vertexAt( beforeVertexNr );
QgsPoint afterVertex = lineGeom.vertexAt( afterVertexNr );
//get normal vector
double dx = afterVertex.x() - beforeVertex.x();
double dy = afterVertex.y() - beforeVertex.y();
double normalX = -dy;
double normalY = dx;
double normalLength = sqrt( normalX * normalX + normalY * normalY );
normalX *= ( dist / normalLength );
normalY *= ( dist / normalLength );
double debugLength = sqrt( normalX * normalX + normalY * normalY ); //control
Q_UNUSED( debugLength );
return QgsPoint( x - normalX, y - normalY ); //negative values -> left side, positive values -> right side
}
QgsFeature QgsFixGeometriesAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingFeedback *feedback )
{
if ( !feature.hasGeometry() )
return feature;
QgsFeature outputFeature = feature;
QgsGeometry outputGeometry = outputFeature.geometry().makeValid();
if ( !outputGeometry )
{
feedback->pushInfo( QObject::tr( "makeValid failed for feature %1 " ).arg( feature.id() ) );
outputFeature.clearGeometry();
return outputFeature;
}
if ( outputGeometry.wkbType() == QgsWkbTypes::Unknown ||
QgsWkbTypes::flatType( outputGeometry.wkbType() ) == QgsWkbTypes::GeometryCollection )
{
// keep only the parts of the geometry collection with correct type
const QVector< QgsGeometry > tmpGeometries = outputGeometry.asGeometryCollection();
QVector< QgsGeometry > matchingParts;
for ( const QgsGeometry &g : tmpGeometries )
{
if ( g.type() == feature.geometry().type() )
matchingParts << g;
}
if ( !matchingParts.empty() )
outputGeometry = QgsGeometry::collectGeometry( matchingParts );
else
outputGeometry = QgsGeometry();
}
outputGeometry.convertToMultiType();
outputFeature.setGeometry( outputGeometry );
return outputFeature;
}
void QgsZonalStatistics::statisticsFromPreciseIntersection( const QgsGeometry &poly, int pixelOffsetX,
int pixelOffsetY, int nCellsX, int nCellsY, double cellSizeX, double cellSizeY, const QgsRectangle &rasterBBox, FeatureStats &stats )
{
stats.reset();
double currentY = rasterBBox.yMaximum() - pixelOffsetY * cellSizeY - cellSizeY / 2;
QgsGeometry pixelRectGeometry;
double hCellSizeX = cellSizeX / 2.0;
double hCellSizeY = cellSizeY / 2.0;
double pixelArea = cellSizeX * cellSizeY;
double weight = 0;
QgsRectangle featureBBox = poly.boundingBox().intersect( &rasterBBox );
QgsRectangle intersectBBox = rasterBBox.intersect( &featureBBox );
QgsRasterBlock *block = mRasterProvider->block( mRasterBand, intersectBBox, nCellsX, nCellsY );
for ( int i = 0; i < nCellsY; ++i )
{
double currentX = rasterBBox.xMinimum() + cellSizeX / 2.0 + pixelOffsetX * cellSizeX;
for ( int j = 0; j < nCellsX; ++j )
{
if ( !validPixel( block->value( i, j ) ) )
{
continue;
}
pixelRectGeometry = QgsGeometry::fromRect( QgsRectangle( currentX - hCellSizeX, currentY - hCellSizeY, currentX + hCellSizeX, currentY + hCellSizeY ) );
if ( !pixelRectGeometry.isNull() )
{
//intersection
QgsGeometry intersectGeometry = pixelRectGeometry.intersection( poly );
if ( !intersectGeometry.isNull() )
{
double intersectionArea = intersectGeometry.area();
if ( intersectionArea >= 0.0 )
{
weight = intersectionArea / pixelArea;
stats.addValue( block->value( i, j ), weight );
}
}
pixelRectGeometry = QgsGeometry();
}
currentX += cellSizeX;
}
currentY -= cellSizeY;
}
delete block;
}
void eval_geometry_method_data()
{
QTest::addColumn<QString>( "string" );
QTest::addColumn<void*>( "geomptr" );
QTest::addColumn<bool>( "evalError" );
QTest::addColumn<bool>( "needGeom" );
QTest::addColumn<void*>( "resultptr" );
QgsPolyline polygon_ring;
polygon_ring << QgsPoint( 0, 0 ) << QgsPoint( 10, 10 ) << QgsPoint( 10, 0 ) << QgsPoint( 0, 0 );
QgsPolygon polygon;
polygon << polygon_ring;
QgsGeometry* geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "buffer" ) << "buffer( $geometry, 1.0, 3)" << ( void* ) geom << false << true << ( void* ) geom->buffer( 1.0, 3 );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "buffer" ) << "buffer( $geometry, 2.0)" << ( void* ) geom << false << true << ( void* ) geom->buffer( 2.0, 8 );
QgsPoint point1( 10, 20 );
QgsPoint point2( 30, 20 );
QgsGeometry* pnt1 = QgsGeometry::fromPoint( point1 );
QgsGeometry* pnt2 = QgsGeometry::fromPoint( point2 );
QTest::newRow( "union" ) << "union( $geometry, geomFromWKT('" + pnt2->exportToWkt() + "') )" << ( void* ) pnt1 << false << true << ( void* ) pnt1->combine( pnt2 );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "intersection" ) << "intersection( $geometry, geomFromWKT('POLYGON((0 0, 0 10, 10 0, 0 0))') )" << ( void* ) geom << false << true << ( void* ) QgsGeometry::fromWkt( "POLYGON ((0 0,5 5,10 0,0 0))" );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "difference" ) << "difference( $geometry, geomFromWKT('POLYGON((0 0, 0 10, 10 0, 0 0))') )" << ( void* ) geom << false << true << ( void* ) QgsGeometry::fromWkt( "POLYGON ((5 5,10 10,10 0,5 5))" );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "symDifference" ) << "symDifference( $geometry, geomFromWKT('POLYGON((0 0, 0 10, 10 0, 0 0))') )" << ( void* ) geom << false << true << ( void* ) QgsGeometry::fromWkt( "MULTIPOLYGON(((5 5,0 0,0 10,5 5)),((5 5,10 10,10 0,5 5)))" );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "centroid polygon" ) << "centroid( $geometry )" << ( void* ) geom << false << true << ( void* ) geom->centroid();
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "centroid self intersecting polygon" ) << "centroid( geomFromWKT('POLYGON((0 0, 0 2, 2 -0.1, 2 2.1, 0 0))') )" << ( void* ) geom << false << false << ( void* ) QgsGeometry::fromWkt( "POINT (8.0 1.0)" );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "centroid multi polygon" ) << "centroid( geomFromWKT('MULTIPOLYGON(((0 0,0 1,1 1,1 0,0 0)),((2 0,2 1,3 1,3 0,2 0)))') )" << ( void* ) geom << false << false << ( void* ) QgsGeometry::fromWkt( "POINT (1.5 0.5)" );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "convexHull simple" ) << "convexHull( $geometry )" << ( void* ) geom << false << true << ( void* ) geom->convexHull();
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "convexHull multi" ) << "convexHull( geomFromWKT('GEOMETRYCOLLECTION(POINT(0 1), POINT(0 0), POINT(1 0), POINT(1 1))') )" << ( void* ) geom << false << false << ( void* ) QgsGeometry::fromWkt( "POLYGON ((0 0,0 1,1 1,1 0,0 0))" );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "bounds" ) << "bounds( $geometry )" << ( void* ) geom << false << true << ( void* ) QgsGeometry::fromRect( geom->boundingBox() );
}
QVector<QgsPoint> QgsMapToolSimplify::getPointList( QgsFeature& f )
{
QgsGeometry* line = f.geometry();
if (( line->type() != QGis::Line && line->type() != QGis::Polygon ) || line->isMultipart() )
{
return QVector<QgsPoint>();
}
if (( line->type() == QGis::Line ) )
{
return line->asPolyline();
}
else
{
if ( line->asPolygon().size() > 1 )
{
return QVector<QgsPoint>();
}
return line->asPolygon()[0];
}
}
int QgsMapToolDeleteRing::ringNumInMultiPolygon( const QgsGeometry &g, int vertexNr, int &partNum )
{
QgsMultiPolygon mpolygon = g.asMultiPolygon();
for ( int part = 0; part < mpolygon.count(); part++ )
{
const QgsPolygon &polygon = mpolygon[part];
for ( int ring = 0; ring < polygon.count(); ring++ )
{
if ( vertexNr < polygon[ring].count() )
{
partNum = part;
return ring;
}
vertexNr -= polygon[ring].count();
}
}
return -1;
}