QVariantMap QgsProcessingFeatureBasedAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
prepareSource( parameters, context );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest,
outputFields( mSource->fields() ),
outputWkbType( mSource->wkbType() ),
outputCrs( mSource->sourceCrs() ),
sinkFlags() ) );
if ( !sink )
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
// prepare expression context for feature iteration
QgsExpressionContext prevContext = context.expressionContext();
QgsExpressionContext algContext = prevContext;
algContext.appendScopes( createExpressionContext( parameters, context, mSource.get() ).takeScopes() );
context.setExpressionContext( algContext );
long count = mSource->featureCount();
QgsFeature f;
QgsFeatureIterator it = mSource->getFeatures( request(), sourceFlags() );
double step = count > 0 ? 100.0 / count : 1;
int current = 0;
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
{
break;
}
context.expressionContext().setFeature( f );
const QgsFeatureList transformed = processFeature( f, context, feedback );
for ( QgsFeature transformedFeature : transformed )
sink->addFeature( transformedFeature, QgsFeatureSink::FastInsert );
feedback->setProgress( current * step );
current++;
}
mSource.reset();
// probably not necessary - context's aren't usually recycled, but can't hurt
context.setExpressionContext( prevContext );
QVariantMap outputs;
outputs.insert( QStringLiteral( "OUTPUT" ), dest );
return outputs;
}
QgsExpressionContext QgsPointDisplacementRendererWidget::createExpressionContext() const
{
QgsExpressionContext context;
if ( mContext.expressionContext() )
context = *mContext.expressionContext();
else
context.appendScopes( mContext.globalProjectAtlasMapLayerScopes( mLayer ) );
QgsExpressionContextScope scope;
scope.addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_CLUSTER_COLOR, "", true ) );
scope.addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_CLUSTER_SIZE, 0, true ) );
QList< QgsExpressionContextScope > scopes = mContext.additionalExpressionContextScopes();
scopes << scope;
Q_FOREACH ( const QgsExpressionContextScope &s, scopes )
{
context << new QgsExpressionContextScope( s );
}
QgsExpressionContext QgsPointClusterRendererWidget::createExpressionContext() const
{
QgsExpressionContext context;
if ( mContext.expressionContext() )
context = *mContext.expressionContext();
else
context.appendScopes( mContext.globalProjectAtlasMapLayerScopes( mLayer ) );
QgsExpressionContextScope scope;
scope.addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_CLUSTER_COLOR, "", true ) );
scope.addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_CLUSTER_SIZE, 0, true ) );
QList< QgsExpressionContextScope > scopes = mContext.additionalExpressionContextScopes();
scopes << scope;
const auto constScopes = scopes;
for ( const QgsExpressionContextScope &s : constScopes )
{
context << new QgsExpressionContextScope( s );
}
return context;
}
void QgsSymbolLegendNode::exportSymbolToJson( const QgsLegendSettings &settings, const QgsRenderContext &context, QJsonObject &json ) const
{
const QgsSymbol *s = mItem.symbol();
if ( !s )
{
return;
}
QgsRenderContext ctx;
ctx.setScaleFactor( settings.dpi() / 25.4 );
ctx.setRendererScale( settings.mapScale() );
ctx.setMapToPixel( QgsMapToPixel( 1 / ( settings.mmPerMapUnit() * ctx.scaleFactor() ) ) );
ctx.setForceVectorOutput( true );
// ensure that a minimal expression context is available
QgsExpressionContext expContext = context.expressionContext();
expContext.appendScopes( QgsExpressionContextUtils::globalProjectLayerScopes( nullptr ) );
ctx.setExpressionContext( expContext );
const QPixmap pix = QgsSymbolLayerUtils::symbolPreviewPixmap( mItem.symbol(), minimumIconSize(), 0, &ctx );
QImage img( pix.toImage().convertToFormat( QImage::Format_ARGB32_Premultiplied ) );
int opacity = 255;
if ( QgsVectorLayer *vectorLayer = qobject_cast<QgsVectorLayer *>( layerNode()->layer() ) )
opacity = ( 255 * vectorLayer->opacity() );
if ( opacity != 255 )
{
QPainter painter;
painter.begin( &img );
painter.setCompositionMode( QPainter::CompositionMode_DestinationIn );
painter.fillRect( pix.rect(), QColor( 0, 0, 0, opacity ) );
painter.end();
}
QByteArray byteArray;
QBuffer buffer( &byteArray );
img.save( &buffer, "PNG" );
const QString base64 = QString::fromLatin1( byteArray.toBase64().data() );
json[ "icon" ] = base64;
}
QgsFeatureIterator QgsVectorLayerUtils::getValuesIterator( const QgsVectorLayer *layer, const QString &fieldOrExpression, bool &ok, bool selectedOnly )
{
std::unique_ptr<QgsExpression> expression;
QgsExpressionContext context;
int attrNum = layer->fields().lookupField( fieldOrExpression );
if ( attrNum == -1 )
{
// try to use expression
expression.reset( new QgsExpression( fieldOrExpression ) );
context.appendScopes( QgsExpressionContextUtils::globalProjectLayerScopes( layer ) );
if ( expression->hasParserError() || !expression->prepare( &context ) )
{
ok = false;
return QgsFeatureIterator();
}
}
QSet<QString> lst;
if ( !expression )
lst.insert( fieldOrExpression );
else
lst = expression->referencedColumns();
QgsFeatureRequest request = QgsFeatureRequest()
.setFlags( ( expression && expression->needsGeometry() ) ?
QgsFeatureRequest::NoFlags :
QgsFeatureRequest::NoGeometry )
.setSubsetOfAttributes( lst, layer->fields() );
ok = true;
if ( !selectedOnly )
{
return layer->getFeatures( request );
}
else
{
return layer->getSelectedFeatures( request );
}
}
QList<QVariant> QgsVectorLayerUtils::getValues( const QgsVectorLayer *layer, const QString &fieldOrExpression, bool &ok, bool selectedOnly, QgsFeedback *feedback )
{
QList<QVariant> values;
QgsFeatureIterator fit = getValuesIterator( layer, fieldOrExpression, ok, selectedOnly );
if ( ok )
{
std::unique_ptr<QgsExpression> expression;
QgsExpressionContext context;
int attrNum = layer->fields().lookupField( fieldOrExpression );
if ( attrNum == -1 )
{
// use expression, already validated in the getValuesIterator() function
expression.reset( new QgsExpression( fieldOrExpression ) );
context.appendScopes( QgsExpressionContextUtils::globalProjectLayerScopes( layer ) );
}
QgsFeature f;
while ( fit.nextFeature( f ) )
{
if ( expression )
{
context.setFeature( f );
QVariant v = expression->evaluate( &context );
values << v;
}
else
{
values << f.attribute( attrNum );
}
if ( feedback && feedback->isCanceled() )
{
ok = false;
return values;
}
}
}
return values;
}
QSizeF QgsSymbolLegendNode::drawSymbol( const QgsLegendSettings &settings, ItemContext *ctx, double itemHeight ) const
{
QgsSymbol *s = mItem.symbol();
if ( !s )
{
return QSizeF();
}
// setup temporary render context
QgsRenderContext context;
context.setScaleFactor( settings.dpi() / 25.4 );
context.setRendererScale( settings.mapScale() );
context.setMapToPixel( QgsMapToPixel( 1 / ( settings.mmPerMapUnit() * context.scaleFactor() ) ) );
context.setForceVectorOutput( true );
context.setPainter( ctx ? ctx->painter : nullptr );
if ( ctx && ctx->context )
{
context.setExpressionContext( ctx->context->expressionContext() );
}
else
{
// setup a minimal expression context
QgsExpressionContext expContext;
expContext.appendScopes( QgsExpressionContextUtils::globalProjectLayerScopes( nullptr ) );
context.setExpressionContext( expContext );
}
//Consider symbol size for point markers
double height = settings.symbolSize().height();
double width = settings.symbolSize().width();
//Center small marker symbols
double widthOffset = 0;
double heightOffset = 0;
if ( QgsMarkerSymbol *markerSymbol = dynamic_cast<QgsMarkerSymbol *>( s ) )
{
// allow marker symbol to occupy bigger area if necessary
double size = markerSymbol->size( context ) / context.scaleFactor();
height = size;
width = size;
if ( width < settings.symbolSize().width() )
{
widthOffset = ( settings.symbolSize().width() - width ) / 2.0;
}
if ( height < settings.symbolSize().height() )
{
heightOffset = ( settings.symbolSize().height() - height ) / 2.0;
}
}
if ( ctx && ctx->painter )
{
double currentXPosition = ctx->point.x();
double currentYCoord = ctx->point.y() + ( itemHeight - settings.symbolSize().height() ) / 2;
QPainter *p = ctx->painter;
//setup painter scaling to dots so that raster symbology is drawn to scale
double dotsPerMM = context.scaleFactor();
int opacity = 255;
if ( QgsVectorLayer *vectorLayer = qobject_cast<QgsVectorLayer *>( layerNode()->layer() ) )
opacity = ( 255 * vectorLayer->opacity() );
p->save();
p->setRenderHint( QPainter::Antialiasing );
p->translate( currentXPosition + widthOffset, currentYCoord + heightOffset );
p->scale( 1.0 / dotsPerMM, 1.0 / dotsPerMM );
if ( opacity != 255 && settings.useAdvancedEffects() )
{
//semi transparent layer, so need to draw symbol to an image (to flatten it first)
//create image which is same size as legend rect, in case symbol bleeds outside its alloted space
QSize tempImageSize( width * dotsPerMM, height * dotsPerMM );
QImage tempImage = QImage( tempImageSize, QImage::Format_ARGB32 );
tempImage.fill( Qt::transparent );
QPainter imagePainter( &tempImage );
context.setPainter( &imagePainter );
s->drawPreviewIcon( &imagePainter, tempImageSize, &context );
context.setPainter( ctx->painter );
//reduce opacity of image
imagePainter.setCompositionMode( QPainter::CompositionMode_DestinationIn );
imagePainter.fillRect( tempImage.rect(), QColor( 0, 0, 0, opacity ) );
imagePainter.end();
//draw rendered symbol image
p->drawImage( 0, 0, tempImage );
}
else
{
s->drawPreviewIcon( p, QSize( width * dotsPerMM, height * dotsPerMM ), &context );
}
if ( !mTextOnSymbolLabel.isEmpty() )
{
QFontMetricsF fm( mTextOnSymbolTextFormat.scaledFont( context ) );
qreal yBaselineVCenter = ( height * dotsPerMM + fm.ascent() - fm.descent() ) / 2;
QgsTextRenderer::drawText( QPointF( width * dotsPerMM / 2, yBaselineVCenter ), 0, QgsTextRenderer::AlignCenter,
QStringList() << mTextOnSymbolLabel, context, mTextOnSymbolTextFormat );
}
p->restore();
}
return QSizeF( std::max( width + 2 * widthOffset, static_cast< double >( settings.symbolSize().width() ) ),
std::max( height + 2 * heightOffset, static_cast< double >( settings.symbolSize().height() ) ) );
}