bool QgsOgrFeatureIterator::readFeature( OGRFeatureH fet, QgsFeature& feature ) const
{
feature.setFeatureId( OGR_F_GetFID( fet ) );
feature.initAttributes( mSource->mFields.count() );
feature.setFields( mSource->mFields ); // allow name-based attribute lookups
bool useIntersect = mRequest.flags() & QgsFeatureRequest::ExactIntersect;
bool geometryTypeFilter = mSource->mOgrGeometryTypeFilter != wkbUnknown;
if ( mFetchGeometry || useIntersect || geometryTypeFilter )
{
OGRGeometryH geom = OGR_F_GetGeometryRef( fet );
if ( geom )
{
feature.setGeometry( QgsOgrUtils::ogrGeometryToQgsGeometry( geom ) );
}
else
feature.clearGeometry();
if ( mSource->mOgrGeometryTypeFilter == wkbGeometryCollection &&
geom && wkbFlatten( OGR_G_GetGeometryType( geom ) ) == wkbGeometryCollection )
{
// OK
}
else if (( useIntersect && ( !feature.hasGeometry() || !feature.geometry().intersects( mRequest.filterRect() ) ) )
|| ( geometryTypeFilter && ( !feature.hasGeometry() || QgsOgrProvider::ogrWkbSingleFlatten(( OGRwkbGeometryType )feature.geometry().wkbType() ) != mSource->mOgrGeometryTypeFilter ) ) )
{
OGR_F_Destroy( fet );
return false;
}
}
if ( !mFetchGeometry )
{
feature.clearGeometry();
}
// fetch attributes
if ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes )
{
QgsAttributeList attrs = mRequest.subsetOfAttributes();
for ( QgsAttributeList::const_iterator it = attrs.begin(); it != attrs.end(); ++it )
{
getFeatureAttribute( fet, feature, *it );
}
}
else
{
// all attributes
for ( int idx = 0; idx < mSource->mFields.count(); ++idx )
{
getFeatureAttribute( fet, feature, idx );
}
}
return true;
}
QgsFeature QgsConvexHullAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &, QgsProcessingFeedback *feedback )
{
QgsFeature f = feature;
if ( f.hasGeometry() )
{
QgsGeometry outputGeometry = f.geometry().convexHull();
if ( !outputGeometry )
feedback->reportError( outputGeometry.lastError() );
f.setGeometry( outputGeometry );
if ( outputGeometry )
{
QgsAttributes attrs = f.attributes();
attrs << outputGeometry.constGet()->area()
<< outputGeometry.constGet()->perimeter();
f.setAttributes( attrs );
}
else
{
QgsAttributes attrs = f.attributes();
attrs << QVariant()
<< QVariant();
f.setAttributes( attrs );
}
}
return f;
}
QgsGeometry::OperationResult QgsVectorLayerEditUtils::addPart( QgsCurve *ring, QgsFeatureId featureId )
{
if ( !mLayer->isSpatial() )
return QgsGeometry::AddPartSelectedGeometryNotFound;
QgsGeometry geometry;
bool firstPart = false;
QgsFeature f;
if ( !mLayer->getFeatures( QgsFeatureRequest().setFilterFid( featureId ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( f ) )
return QgsGeometry::AddPartSelectedGeometryNotFound;
if ( !f.hasGeometry() )
{
//no existing geometry, so adding first part to null geometry
firstPart = true;
}
else
{
geometry = f.geometry();
}
QgsGeometry::OperationResult errorCode = geometry.addPart( ring, mLayer->geometryType() );
if ( errorCode == QgsGeometry::Success )
{
if ( firstPart && QgsWkbTypes::isSingleType( mLayer->wkbType() )
&& mLayer->dataProvider()->doesStrictFeatureTypeCheck() )
{
//convert back to single part if required by layer
geometry.convertToSingleType();
}
mLayer->editBuffer()->changeGeometry( featureId, geometry );
}
return errorCode;
}
QgsFeatureList QgsConvexHullAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &, QgsProcessingFeedback *feedback )
{
QgsFeature f = feature;
if ( f.hasGeometry() )
{
QgsGeometry outputGeometry;
if ( QgsWkbTypes::flatType( f.geometry().wkbType() ) == QgsWkbTypes::Point )
{
feedback->reportError( QObject::tr( "Cannot calculate convex hull for a single Point feature (try 'Minimum bounding geometry' algorithm instead)." ) );
f.clearGeometry();
}
else
{
outputGeometry = f.geometry().convexHull();
if ( outputGeometry.isNull() )
feedback->reportError( outputGeometry.lastError() );
f.setGeometry( outputGeometry );
}
if ( !outputGeometry.isNull() )
{
QgsAttributes attrs = f.attributes();
attrs << outputGeometry.constGet()->area()
<< outputGeometry.constGet()->perimeter();
f.setAttributes( attrs );
}
else
{
QgsAttributes attrs = f.attributes();
attrs << QVariant()
<< QVariant();
f.setAttributes( attrs );
}
}
return QgsFeatureList() << f;
}
void QgsNetworkAnalysisAlgorithmBase::loadPoints( QgsFeatureSource *source, QVector< QgsPointXY > &points, QHash< int, QgsAttributes > &attributes, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
feedback->pushInfo( QObject::tr( "Loading points…" ) );
QgsFeature feat;
int i = 0;
int pointId = 1;
double step = source->featureCount() > 0 ? 100.0 / source->featureCount() : 0;
QgsFeatureIterator features = source->getFeatures( QgsFeatureRequest().setDestinationCrs( mNetwork->sourceCrs(), context.transformContext() ) );
while ( features.nextFeature( feat ) )
{
i++;
if ( feedback->isCanceled() )
{
break;
}
feedback->setProgress( i * step );
if ( !feat.hasGeometry() )
continue;
QgsGeometry geom = feat.geometry();
QgsAbstractGeometry::vertex_iterator it = geom.vertices_begin();
while ( it != geom.vertices_end() )
{
points.push_back( QgsPointXY( *it ) );
attributes.insert( pointId, feat.attributes() );
it++;
pointId++;
}
}
}
bool QgsVectorLayerExporter::addFeature( QgsFeature &feat, Flags )
{
QgsAttributes attrs = feat.attributes();
QgsFeature newFeat;
if ( feat.hasGeometry() )
newFeat.setGeometry( feat.geometry() );
newFeat.initAttributes( mAttributeCount );
for ( int i = 0; i < attrs.count(); ++i )
{
// add only mapped attributes (un-mapped ones will not be present in the
// destination layer)
int dstIdx = mOldToNewAttrIdx.value( i, -1 );
if ( dstIdx < 0 )
continue;
QgsDebugMsgLevel( QStringLiteral( "moving field from pos %1 to %2" ).arg( i ).arg( dstIdx ), 3 );
newFeat.setAttribute( dstIdx, attrs.at( i ) );
}
mFeatureBuffer.append( newFeat );
if ( mFeatureBuffer.count() >= FEATURE_BUFFER_SIZE )
{
return flushBuffer();
}
return true;
}
void topolTest::fillFeatureList( QgsVectorLayer *layer, const QgsRectangle &extent )
{
QgsFeatureIterator fit;
if ( extent.isEmpty() )
{
fit = layer->getFeatures( QgsFeatureRequest().setSubsetOfAttributes( QgsAttributeList() ) );
}
else
{
fit = layer->getFeatures( QgsFeatureRequest()
.setFilterRect( extent )
.setFlags( QgsFeatureRequest::ExactIntersect )
.setSubsetOfAttributes( QgsAttributeList() ) );
}
QgsFeature f;
while ( fit.nextFeature( f ) )
{
if ( f.hasGeometry() )
{
mFeatureList1 << FeatureLayer( layer, f );
}
}
}
QgsFeatureList QgsAddXYFieldsAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
if ( mTransformNeedsInitialization )
{
mTransform = QgsCoordinateTransform( mSourceCrs, mCrs, context.transformContext() );
mTransformNeedsInitialization = false;
}
QVariant x;
QVariant y;
if ( feature.hasGeometry() )
{
if ( feature.geometry().isMultipart() )
throw QgsProcessingException( QObject::tr( "Multipoint features are not supported - please convert to single point features first." ) );
const QgsPointXY point = feature.geometry().asPoint();
try
{
const QgsPointXY transformed = mTransform.transform( point );
x = transformed.x();
y = transformed.y();
}
catch ( QgsCsException & )
{
feedback->reportError( QObject::tr( "Could not transform point to destination CRS" ) );
}
}
QgsFeature f = feature;
QgsAttributes attributes = f.attributes();
attributes << x << y;
f.setAttributes( attributes );
return QgsFeatureList() << f;
}
QgsFeatureList QgsSnapToGridAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
QgsFeature f = feature;
if ( f.hasGeometry() )
{
double intervalX = mIntervalX;
if ( mDynamicIntervalX )
intervalX = mIntervalXProperty.valueAsDouble( context.expressionContext(), intervalX );
double intervalY = mIntervalY;
if ( mDynamicIntervalY )
intervalY = mIntervalYProperty.valueAsDouble( context.expressionContext(), intervalY );
double intervalZ = mIntervalZ;
if ( mDynamicIntervalZ )
intervalZ = mIntervalZProperty.valueAsDouble( context.expressionContext(), intervalZ );
double intervalM = mIntervalM;
if ( mDynamicIntervalM )
intervalM = mIntervalMProperty.valueAsDouble( context.expressionContext(), intervalM );
QgsGeometry outputGeometry = f.geometry().snappedToGrid( intervalX, intervalY, intervalZ, intervalM );
if ( !outputGeometry )
{
feedback->reportError( QObject::tr( "Error snapping geometry %1" ).arg( feature.id() ) );
}
f.setGeometry( outputGeometry );
}
return QgsFeatureList() << f;
}
bool QgsSpatialIndex::featureInfo( const QgsFeature &f, QgsRectangle &rect, QgsFeatureId &id )
{
if ( !f.hasGeometry() )
return false;
id = f.id();
rect = f.geometry().boundingBox();
return true;
}
bool QgsPointDisplacementRenderer::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;
QgsSymbolV2* symbol = firstSymbolForFeature( mRenderer, 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;
}
if ( selected )
mSelectedFeatures.insert( feature.id() );
double searchDistance = mTolerance * QgsSymbolLayerV2Utils::mapUnitScaleFactor( context, mToleranceUnit, mToleranceMapUnitScale );
QList<QgsFeatureId> intersectList = mSpatialIndex->intersects( searchRect( feature.geometry().asPoint(), searchDistance ) );
if ( intersectList.empty() )
{
mSpatialIndex->insertFeature( feature );
// create new group
DisplacementGroup newGroup;
newGroup.insert( feature.id(), qMakePair( feature, symbol ) );
mDisplacementGroups.push_back( newGroup );
// add to group index
mGroupIndex.insert( feature.id(), mDisplacementGroups.count() - 1 );
return true;
}
//go through all the displacement group maps and search an entry where the id equals the result of the spatial search
QgsFeatureId existingEntry = intersectList.at( 0 );
int groupIdx = mGroupIndex[ existingEntry ];
DisplacementGroup& group = mDisplacementGroups[groupIdx];
// add to a group
group.insert( feature.id(), qMakePair( feature, symbol ) );
// add to group index
mGroupIndex.insert( feature.id(), groupIdx );
return true;
}
bool QgsSpatialIndex::featureInfo( const QgsFeature& f, SpatialIndex::Region& r, QgsFeatureId &id )
{
if ( !f.hasGeometry() )
return false;
QgsGeometry g = f.geometry();
id = f.id();
r = rectToRegion( g.boundingBox() );
return true;
}
QgsFeatureList QgsPromoteToMultipartAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &, QgsProcessingFeedback * )
{
QgsFeature f = feature;
if ( f.hasGeometry() && !f.geometry().isMultipart() )
{
QgsGeometry g = f.geometry();
g.convertToMultiType();
f.setGeometry( g );
}
return QgsFeatureList() << f;
}
void QgsSpatialQueryDialog::zoomFeature( QgsVectorLayer* lyr, QgsFeatureId fid )
{
static QgsVectorLayer* lyrCheck = nullptr;
static bool hasMsg = false;
if ( ! lyrCheck || lyrCheck != lyr )
{
lyrCheck = lyr;
hasMsg = true;
}
else
{
hasMsg = false;
}
QgsFeature feat;
if ( !lyr->getFeatures( QgsFeatureRequest().setFilterFid( fid ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( feat ) )
{
return;
}
if ( !feat.hasGeometry() )
{
return;
}
// Set system reference
QgsCoordinateReferenceSystem srsSource = lyr->dataProvider()->crs();
QgsCoordinateReferenceSystem srcMapcanvas = mIface->mapCanvas()->mapSettings().destinationCrs();
if ( ! srsSource.isValid() )
{
if ( hasMsg )
{
QString crsMapcanvas = srcMapcanvas.authid();
bool isFly = mIface->mapCanvas()->mapSettings().hasCrsTransformEnabled();
QString msgFly = tr( "Map \"%1\" \"on the fly\" transformation." ).arg( isFly ? tr( "enable" ) : tr( "disable" ) );
QString msg = tr( "Coordinate reference system(CRS) of\n\"%1\" is invalid(see CRS of provider)." ).arg( lyr->name() );
msg.append( tr( "\n\nCRS of map is %1.\n%2." ).arg( crsMapcanvas, msgFly ) );
msg.append( "\n\nUsing CRS of map for all features!" );
QMessageBox::warning( this, tr( "Zoom to feature" ), msg, QMessageBox::Ok );
}
mIface->mapCanvas()->setExtent( feat.geometry().boundingBox() );
}
else if ( srsSource == srcMapcanvas )
{
mIface->mapCanvas()->setExtent( feat.geometry().boundingBox() );
}
else
{
QgsCoordinateTransform coordTransform( srsSource, srcMapcanvas );
QgsRectangle rectExtent = coordTransform.transform( feat.geometry().boundingBox() );
mIface->mapCanvas()->setExtent( rectExtent );
}
mIface->mapCanvas()->refresh();
} // void QgsSpatialQueryDialog::zoomFeature( QgsVectorLayer* lyr, QgsFeatureId fid )
void QgsRelationReferenceWidget::highlightFeature( QgsFeature f, CanvasExtent canvasExtent )
{
if ( !mCanvas )
return;
if ( !f.isValid() )
{
f = referencedFeature();
if ( !f.isValid() )
return;
}
if ( !f.hasGeometry() )
{
return;
}
QgsGeometry geom = f.geometry();
// scale or pan
if ( canvasExtent == Scale )
{
QgsRectangle featBBox = geom.boundingBox();
featBBox = mCanvas->mapSettings().layerToMapCoordinates( mReferencedLayer, featBBox );
QgsRectangle extent = mCanvas->extent();
if ( !extent.contains( featBBox ) )
{
extent.combineExtentWith( featBBox );
extent.scale( 1.1 );
mCanvas->setExtent( extent );
mCanvas->refresh();
}
}
else if ( canvasExtent == Pan )
{
QgsGeometry centroid = geom.centroid();
QgsPointXY center = centroid.asPoint();
center = mCanvas->mapSettings().layerToMapCoordinates( mReferencedLayer, center );
mCanvas->zoomByFactor( 1.0, ¢er ); // refresh is done in this method
}
// highlight
deleteHighlight();
mHighlight = new QgsHighlight( mCanvas, f, mReferencedLayer );
QgsIdentifyMenu::styleHighlight( mHighlight );
mHighlight->show();
QTimer *timer = new QTimer( this );
timer->setSingleShot( true );
connect( timer, &QTimer::timeout, this, &QgsRelationReferenceWidget::deleteHighlight );
timer->start( 3000 );
}
QgsFeature QgsMergeLinesAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &, QgsProcessingFeedback *feedback )
{
if ( !feature.hasGeometry() )
return feature;
QgsFeature out = feature;
QgsGeometry outputGeometry = feature.geometry().mergeLines();
if ( !outputGeometry )
feedback->reportError( QObject::tr( "Error merging lines for feature %1" ).arg( feature.id() ) );
out.setGeometry( outputGeometry );
return out;
}
QgsFeatureList QgsCentroidAlgorithm::processFeature( const QgsFeature &f, QgsProcessingContext &, QgsProcessingFeedback *feedback )
{
QgsFeature feature = f;
if ( feature.hasGeometry() )
{
feature.setGeometry( feature.geometry().centroid() );
if ( !feature.geometry() )
{
feedback->pushInfo( QObject::tr( "Error calculating centroid for feature %1" ).arg( feature.id() ) );
}
}
return QgsFeatureList() << feature;
}
bool QgsOgrFeatureIterator::checkFeature( gdal::ogr_feature_unique_ptr &fet, QgsFeature &feature )
{
if ( !readFeature( std::move( fet ), feature ) )
return false;
if ( !mFilterRect.isNull() && ( !feature.hasGeometry() || feature.geometry().isEmpty() ) )
return false;
// we have a feature, end this cycle
feature.setValid( true );
geometryToDestinationCrs( feature, mTransform );
return true;
}
QgsFeatureList QgsSubdivideAlgorithm::processFeature( const QgsFeature &f, QgsProcessingContext &, QgsProcessingFeedback *feedback )
{
QgsFeature feature = f;
if ( feature.hasGeometry() )
{
feature.setGeometry( feature.geometry().subdivide( mMaxNodes ) );
if ( !feature.geometry() )
{
feedback->reportError( QObject::tr( "Error calculating subdivision for feature %1" ).arg( feature.id() ) );
}
}
return QgsFeatureList() << feature;
}
bool QgsVectorLayerTools::copyMoveFeatures( QgsVectorLayer* layer, QgsFeatureRequest& request, double dx, double dy, QString* errorMsg ) const
{
bool res = false;
if ( !layer || !layer->isEditable() )
{
return false;
}
QgsFeatureIterator fi = layer->getFeatures( request );
QgsFeature f;
QgsAttributeList pkAttrList = layer->pkAttributeList();
int browsedFeatureCount = 0;
int couldNotWriteCount = 0;
int noGeometryCount = 0;
QgsFeatureIds fidList;
while ( fi.nextFeature( f ) )
{
browsedFeatureCount++;
// remove pkey values
Q_FOREACH ( auto idx, pkAttrList )
{
f.setAttribute( idx, QVariant() );
}
// translate
if ( f.hasGeometry() )
{
QgsGeometry geom = f.geometry();
geom.translate( dx, dy );
f.setGeometry( geom );
#ifdef QGISDEBUG
const QgsFeatureId fid = f.id();
#endif
// paste feature
if ( !layer->addFeature( f, false ) )
{
couldNotWriteCount++;
QgsDebugMsg( QString( "Could not add new feature. Original copied feature id: %1" ).arg( fid ) );
}
else
{
fidList.insert( f.id() );
}
}
else
{
noGeometryCount++;
}
}
QgsGeometry::OperationResult QgsVectorLayerEditUtils::addRing( QgsCurve *ring, const QgsFeatureIds &targetFeatureIds, QgsFeatureId *modifiedFeatureId )
{
if ( !mLayer->isSpatial() )
{
delete ring;
return QgsGeometry::AddRingNotInExistingFeature;
}
QgsGeometry::OperationResult addRingReturnCode = QgsGeometry::AddRingNotInExistingFeature; //default: return code for 'ring not inserted'
QgsFeature f;
QgsFeatureIterator fit;
if ( !targetFeatureIds.isEmpty() )
{
//check only specified features
fit = mLayer->getFeatures( QgsFeatureRequest().setFilterFids( targetFeatureIds ) );
}
else
{
//check all intersecting features
QgsRectangle bBox = ring->boundingBox();
fit = mLayer->getFeatures( QgsFeatureRequest().setFilterRect( bBox ).setFlags( QgsFeatureRequest::ExactIntersect ) );
}
//find first valid feature we can add the ring to
while ( fit.nextFeature( f ) )
{
if ( !f.hasGeometry() )
continue;
//add ring takes ownership of ring, and deletes it if there's an error
QgsGeometry g = f.geometry();
addRingReturnCode = g.addRing( static_cast< QgsCurve * >( ring->clone() ) );
if ( addRingReturnCode == 0 )
if ( addRingReturnCode == QgsGeometry::Success )
{
mLayer->editBuffer()->changeGeometry( f.id(), g );
if ( modifiedFeatureId )
*modifiedFeatureId = f.id();
//setModified( true, true );
break;
}
}
delete ring;
return addRingReturnCode;
}
bool QgsOgrFeatureIterator::fetchFeature( QgsFeature& feature )
{
feature.setValid( false );
if ( mClosed || !ogrLayer )
return false;
if ( mRequest.filterType() == QgsFeatureRequest::FilterFid )
{
bool result = fetchFeatureWithId( mRequest.filterFid(), feature );
close(); // the feature has been read or was not found: we have finished here
return result;
}
else if ( mRequest.filterType() == QgsFeatureRequest::FilterFids )
{
while ( mFilterFidsIt != mFilterFids.constEnd() )
{
QgsFeatureId nextId = *mFilterFidsIt;
mFilterFidsIt++;
if ( fetchFeatureWithId( nextId, feature ) )
return true;
}
close();
return false;
}
OGRFeatureH fet;
while (( fet = OGR_L_GetNextFeature( ogrLayer ) ) )
{
if ( !readFeature( fet, feature ) )
continue;
else
OGR_F_Destroy( fet );
if ( !mRequest.filterRect().isNull() && !feature.hasGeometry() )
continue;
// we have a feature, end this cycle
feature.setValid( true );
return true;
} // while
close();
return false;
}
QgsFeature QgsMinimumEnclosingCircleAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &, QgsProcessingFeedback * )
{
QgsFeature f = feature;
if ( f.hasGeometry() )
{
double radius = 0;
QgsPointXY center;
QgsGeometry outputGeometry = f.geometry().minimalEnclosingCircle( center, radius, mSegments );
f.setGeometry( outputGeometry );
QgsAttributes attrs = f.attributes();
attrs << radius
<< M_PI *radius *radius;
f.setAttributes( attrs );
}
return f;
}
QgsRectangle QgsFeatureSource::sourceExtent() const
{
QgsRectangle r;
QgsFeatureRequest req;
req.setNoAttributes();
QgsFeatureIterator it = getFeatures( req );
QgsFeature f;
while ( it.nextFeature( f ) )
{
if ( f.hasGeometry() )
r.combineExtentWith( f.geometry().boundingBox() );
}
return r;
}
void QgsGeometryAnalyzer::bufferFeature( QgsFeature& f, int nProcessedFeatures, QgsVectorFileWriter* vfw, bool dissolve,
QgsGeometry& dissolveGeometry, double bufferDistance, int bufferDistanceField )
{
if ( !f.hasGeometry() )
{
return;
}
double currentBufferDistance;
QgsGeometry featureGeometry = f.geometry();
QgsGeometry bufferGeometry;
//create buffer
if ( bufferDistanceField == -1 )
{
currentBufferDistance = bufferDistance;
}
else
{
currentBufferDistance = f.attribute( bufferDistanceField ).toDouble();
}
bufferGeometry = featureGeometry.buffer( currentBufferDistance, 5 );
if ( dissolve )
{
if ( nProcessedFeatures == 0 )
{
dissolveGeometry = bufferGeometry;
}
else
{
dissolveGeometry = dissolveGeometry.combine( bufferGeometry );
}
}
else //dissolve
{
QgsFeature newFeature;
newFeature.setGeometry( bufferGeometry );
newFeature.setAttributes( f.attributes() );
//add it to vector file writer
if ( vfw )
{
vfw->addFeature( newFeature );
}
}
}
QVariantMap QgsCentroidAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) const
{
std::unique_ptr< QgsFeatureSource > source( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
if ( !source )
return QVariantMap();
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT_LAYER" ), context, source->fields(), QgsWkbTypes::Point, source->sourceCrs(), dest ) );
if ( !sink )
return QVariantMap();
long count = source->featureCount();
if ( count <= 0 )
return QVariantMap();
QgsFeature f;
QgsFeatureIterator it = source->getFeatures();
double step = 100.0 / count;
int current = 0;
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
{
break;
}
QgsFeature out = f;
if ( out.hasGeometry() )
{
out.setGeometry( f.geometry().centroid() );
if ( !out.geometry() )
{
QgsMessageLog::logMessage( QObject::tr( "Error calculating centroid for feature %1" ).arg( f.id() ), QObject::tr( "Processing" ), QgsMessageLog::WARNING );
}
}
sink->addFeature( out );
feedback->setProgress( current * step );
current++;
}
QVariantMap outputs;
outputs.insert( QStringLiteral( "OUTPUT_LAYER" ), dest );
return outputs;
}
void QgsPointSample::addSamplePoints( QgsFeature& inputFeature, QgsVectorFileWriter& writer, int nPoints, double minDistance )
{
if ( !inputFeature.hasGeometry() )
return;
QgsGeometry geom = inputFeature.geometry();
QgsRectangle geomRect = geom.boundingBox();
if ( geomRect.isEmpty() )
{
return;
}
QgsSpatialIndex sIndex; //to check minimum distance
QMap< QgsFeatureId, QgsPoint > pointMapForFeature;
int nIterations = 0;
int maxIterations = nPoints * 200;
int points = 0;
double randX = 0;
double randY = 0;
while ( nIterations < maxIterations && points < nPoints )
{
randX = (( double )mt_rand() / MD_RAND_MAX ) * geomRect.width() + geomRect.xMinimum();
randY = (( double )mt_rand() / MD_RAND_MAX ) * geomRect.height() + geomRect.yMinimum();
QgsPoint randPoint( randX, randY );
QgsGeometry ptGeom = QgsGeometry::fromPoint( randPoint );
if ( ptGeom.within( geom ) && checkMinDistance( randPoint, sIndex, minDistance, pointMapForFeature ) )
{
//add feature to writer
QgsFeature f( mNCreatedPoints );
f.setAttribute( QStringLiteral( "id" ), mNCreatedPoints + 1 );
f.setAttribute( QStringLiteral( "station_id" ), points + 1 );
f.setAttribute( QStringLiteral( "stratum_id" ), inputFeature.id() );
f.setGeometry( ptGeom );
writer.addFeature( f );
sIndex.insertFeature( f );
pointMapForFeature.insert( mNCreatedPoints, randPoint );
++points;
++mNCreatedPoints;
}
++nIterations;
}
}
QgsGeometry QgsGeometryAnalyzer::dissolveFeature( const QgsFeature& f, const QgsGeometry& dissolveInto )
{
if ( !f.hasGeometry() )
{
return dissolveInto;
}
QgsGeometry featureGeometry = f.geometry();
if ( dissolveInto.isEmpty() )
{
return featureGeometry;
}
else
{
return dissolveInto.combine( featureGeometry );
}
}
void QgsGeometryAnalyzer::centroidFeature( QgsFeature& f, QgsVectorFileWriter* vfw )
{
if ( !f.hasGeometry() )
{
return;
}
QgsGeometry featureGeometry = f.geometry();
QgsFeature newFeature;
newFeature.setGeometry( featureGeometry.centroid() );
newFeature.setAttributes( f.attributes() );
//add it to vector file writer
if ( vfw )
{
vfw->addFeature( newFeature );
}
}
void QgsLockedFeature::updateGeometry( const QgsGeometry *geom )
{
delete mGeometry;
if ( !geom )
{
QgsFeature f;
mLayer->getFeatures( QgsFeatureRequest().setFilterFid( mFeatureId ) ).nextFeature( f );
if ( f.hasGeometry() )
mGeometry = new QgsGeometry( f.geometry() );
else
mGeometry = new QgsGeometry();
}
else
{
mGeometry = new QgsGeometry( *geom );
}
}
