QGIS API Documentation 3.39.0-Master (67e056379ed)
Loading...
Searching...
No Matches
qgsalgorithmextractlabels.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsalgorithmextractlabels.cpp - QgsExtractLabelsAlgorithm
3 ---------------------
4 begin : 30.12.2021
5 copyright : (C) 2021 by Mathieu Pellerin
6 email : nirvn dot asia 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
22#include "qgslabelsink.h"
23#include "qgslayertree.h"
24#include "qgsvectorlayer.h"
25#include "qgsscalecalculator.h"
26#include "qgstextlabelfeature.h"
29
30#include "pal/feature.h"
31#include "pal/labelposition.h"
32
33#include <QPainter>
34
35#include <cmath>
36
38
39QString QgsExtractLabelsAlgorithm::name() const
40{
41 return QStringLiteral( "extractlabels" );
42}
43
44QString QgsExtractLabelsAlgorithm::displayName() const
45{
46 return QObject::tr( "Extract labels" );
47}
48
49QStringList QgsExtractLabelsAlgorithm::tags() const
50{
51 return QObject::tr( "map themes,font,position" ).split( ',' );
52}
53
54Qgis::ProcessingAlgorithmFlags QgsExtractLabelsAlgorithm::flags() const
55{
57}
58
59QString QgsExtractLabelsAlgorithm::group() const
60{
61 return QObject::tr( "Cartography" );
62}
63
64QString QgsExtractLabelsAlgorithm::groupId() const
65{
66 return QStringLiteral( "cartography" );
67}
68
69void QgsExtractLabelsAlgorithm::initAlgorithm( const QVariantMap & )
70{
71 addParameter( new QgsProcessingParameterExtent(
72 QStringLiteral( "EXTENT" ),
73 QObject::tr( "Map extent" ) ) );
74
75 addParameter( new QgsProcessingParameterScale(
76 QStringLiteral( "SCALE" ),
77 QObject::tr( "Map scale" ) ) );
78
79 std::unique_ptr<QgsProcessingParameterMapTheme> mapThemeParameter = std::make_unique<QgsProcessingParameterMapTheme>(
80 QStringLiteral( "MAP_THEME" ),
81 QObject::tr( "Map theme" ),
82 QVariant(), true );
83 mapThemeParameter->setHelp( QObject::tr( "This parameter is optional. When left unset, the algorithm will fallback to extracting labels from all currently visible layers in the project." ) );
84 addParameter( mapThemeParameter.release() );
85
86 addParameter( new QgsProcessingParameterBoolean(
87 QStringLiteral( "INCLUDE_UNPLACED" ),
88 QObject::tr( "Include unplaced labels" ),
89 QVariant( true ), true ) );
90
91 std::unique_ptr<QgsProcessingParameterNumber> dpiParameter = std::make_unique<QgsProcessingParameterNumber>(
92 QStringLiteral( "DPI" ),
93 QObject::tr( "Map resolution (in DPI)" ),
95 QVariant( 96.0 ), true );
96 dpiParameter->setFlags( dpiParameter->flags() | Qgis::ProcessingParameterFlag::Advanced );
97 addParameter( dpiParameter.release() );
98
99 addParameter( new QgsProcessingParameterFeatureSink(
100 QStringLiteral( "OUTPUT" ),
101 QObject::tr( "Extracted labels" ),
103}
104
105QString QgsExtractLabelsAlgorithm::shortDescription() const
106{
107 return QObject::tr( "Converts map labels to a point layer with relevant details saved as attributes." );
108}
109
110QString QgsExtractLabelsAlgorithm::shortHelpString() const
111{
112 return QObject::tr( "This algorithm extracts label information from a rendered map at a given extent and scale.\n\n"
113 "If a map theme is provided, the rendered map will match the visibility and symbology of that theme. If left blank, all visible layers from the project will be used.\n\n"
114 "Extracted label information include: position (served as point geometries), the associated layer name and feature ID, label text, rotation (in degree, clockwise), multiline alignment, and font details." );
115}
116
117QgsExtractLabelsAlgorithm *QgsExtractLabelsAlgorithm::createInstance() const
118{
119 return new QgsExtractLabelsAlgorithm();
120}
121
122class ExtractLabelSink : public QgsLabelSink
123{
124 public:
125 ExtractLabelSink( const QMap<QString, QString> &mapLayerNames, QgsProcessingFeedback *feedback )
126 : mMapLayerNames( mapLayerNames )
127 , mFeedback( feedback )
128 {
129 }
130
131 void drawLabel( const QString &layerId, QgsRenderContext &context, pal::LabelPosition *label, const QgsPalLayerSettings &settings ) override
132 {
133 processLabel( layerId, context, label, settings, false );
134 }
135
136 void drawUnplacedLabel( const QString &layerId, QgsRenderContext &context, pal::LabelPosition *label, const QgsPalLayerSettings &settings ) override
137 {
138 processLabel( layerId, context, label, settings, true );
139 }
140
141 void processLabel( const QString &layerId, QgsRenderContext &context, pal::LabelPosition *label, const QgsPalLayerSettings &settings, bool unplacedLabel )
142 {
143 if ( mFeedback->isCanceled() )
144 {
145 context.setRenderingStopped( true );
146 }
147
148 const QgsFeatureId fid = label->getFeaturePart()->featureId();
149 switch ( settings.placement )
150 {
153 {
154 if ( !mCurvedWarningPushed.contains( layerId ) )
155 {
156 mCurvedWarningPushed << layerId;
157 mFeedback->pushWarning( QObject::tr( "Curved placement not supported, skipping labels from layer %1" ).arg( mMapLayerNames.value( layerId ) ) );
158 }
159 return;
160 }
161
169 break;
170 }
171
172 QgsTextLabelFeature *labelFeature = dynamic_cast<QgsTextLabelFeature *>( label->getFeaturePart()->feature() );
173 if ( !labelFeature )
174 return;
175
176 QgsPalLayerSettings labelSettings( settings );
177 const QMap< QgsPalLayerSettings::Property, QVariant > &dataDefinedValues = labelFeature->dataDefinedValues();
178
179 if ( dataDefinedValues.contains( QgsPalLayerSettings::Property::MultiLineWrapChar ) )
180 {
181 labelSettings.wrapChar = dataDefinedValues.value( QgsPalLayerSettings::Property::MultiLineWrapChar ).toString();
182 }
183 if ( dataDefinedValues.contains( QgsPalLayerSettings::Property::AutoWrapLength ) )
184 {
185 labelSettings.autoWrapLength = dataDefinedValues.value( QgsPalLayerSettings::Property::AutoWrapLength ).toInt();
186 }
187 const QString labelText = QgsPalLabeling::splitToLines( labelFeature->text( -1 ),
188 labelSettings.wrapChar,
189 labelSettings.autoWrapLength,
190 labelSettings.useMaxLineLengthForAutoWrap ).join( '\n' );
191
192 QString labelAlignment;
193 if ( dataDefinedValues.contains( QgsPalLayerSettings::Property::MultiLineAlignment ) )
194 {
195 labelSettings.multilineAlign = static_cast< Qgis::LabelMultiLineAlignment >( dataDefinedValues.value( QgsPalLayerSettings::Property::MultiLineAlignment ).toInt() );
196 }
197 switch ( labelSettings.multilineAlign )
198 {
200 labelAlignment = QStringLiteral( "right" );
201 break;
202
204 labelAlignment = QStringLiteral( "center" );
205 break;
206
208 labelAlignment = QStringLiteral( "left" );
209 break;
210
212 labelAlignment = QStringLiteral( "justify" );
213 break;
214
216 switch ( label->getQuadrant() )
217 {
221 labelAlignment = QStringLiteral( "right" );
222 break;
223
227 labelAlignment = QStringLiteral( "center" );
228 break;
229
233 labelAlignment = QStringLiteral( "left" );
234 break;
235 }
236 break;
237 }
238
239 const double labelRotation = !qgsDoubleNear( label->getAlpha(), 0.0 )
240 ? -( label->getAlpha() * 180 / M_PI ) + 360
241 : 0.0;
242
243 const QFont font = labelFeature->definedFont();
244 const QString fontFamily = font.family();
245 const QString fontStyle = font.styleName();
246 const double fontSize = static_cast<double>( font.pixelSize() ) * 72 / context.painter()->device()->logicalDpiX();
247 const bool fontItalic = font.italic();
248 const bool fontBold = font.bold();
249 const bool fontUnderline = font.underline();
250 const double fontLetterSpacing = font.letterSpacing();
251 const double fontWordSpacing = font.wordSpacing();
252
253 QgsTextFormat format = labelSettings.format();
254 if ( dataDefinedValues.contains( QgsPalLayerSettings::Property::Size ) )
255 {
256 format.setSize( dataDefinedValues.value( QgsPalLayerSettings::Property::Size ).toDouble() );
257 }
258 if ( dataDefinedValues.contains( QgsPalLayerSettings::Property::Color ) )
259 {
260 format.setColor( dataDefinedValues.value( QgsPalLayerSettings::Property::Color ).value<QColor>() );
261 }
262 if ( dataDefinedValues.contains( QgsPalLayerSettings::Property::FontOpacity ) )
263 {
264 format.setOpacity( dataDefinedValues.value( QgsPalLayerSettings::Property::FontOpacity ).toDouble() / 100.0 );
265 }
266 if ( dataDefinedValues.contains( QgsPalLayerSettings::Property::MultiLineHeight ) )
267 {
268 format.setLineHeight( dataDefinedValues.value( QgsPalLayerSettings::Property::MultiLineHeight ).toDouble() );
269 }
270
271 const QString formatColor = format.color().name();
272 const double formatOpacity = format.opacity() * 100;
273 const double formatLineHeight = format.lineHeight();
274
275 QgsTextBufferSettings buffer = format.buffer();
276 if ( dataDefinedValues.contains( QgsPalLayerSettings::Property::BufferDraw ) )
277 {
278 buffer.setEnabled( dataDefinedValues.value( QgsPalLayerSettings::Property::BufferDraw ).toBool() );
279 }
280 const bool bufferDraw = buffer.enabled();
281 double bufferSize = 0.0;
282 QString bufferColor;
283 double bufferOpacity = 0.0;
284 if ( bufferDraw )
285 {
286 if ( dataDefinedValues.contains( QgsPalLayerSettings::Property::BufferSize ) )
287 {
288 buffer.setSize( dataDefinedValues.value( QgsPalLayerSettings::Property::BufferSize ).toDouble() );
289 }
290 if ( dataDefinedValues.contains( QgsPalLayerSettings::Property::BufferColor ) )
291 {
292 buffer.setColor( dataDefinedValues.value( QgsPalLayerSettings::Property::BufferColor ).value<QColor>() );
293 }
294 if ( dataDefinedValues.contains( QgsPalLayerSettings::Property::BufferOpacity ) )
295 {
296 buffer.setOpacity( dataDefinedValues.value( QgsPalLayerSettings::Property::BufferOpacity ).toDouble() / 100.0 );
297 }
298
299 bufferSize = buffer.sizeUnit() == Qgis::RenderUnit::Percentage
300 ? context.convertToPainterUnits( format.size(), format.sizeUnit(), format.sizeMapUnitScale() ) * buffer.size() / 100
301 : context.convertToPainterUnits( buffer.size(), buffer.sizeUnit(), buffer.sizeMapUnitScale() );
302 bufferSize = bufferSize * 72 / context.painter()->device()->logicalDpiX();
303 bufferColor = buffer.color().name();
304 bufferOpacity = buffer.opacity() * 100;
305 }
306
307 QgsAttributes attributes;
308 attributes << mMapLayerNames.value( layerId ) << fid
309 << labelText << label->getWidth() << label->getHeight() << labelRotation << unplacedLabel
310 << fontFamily << fontSize << fontItalic << fontBold << fontUnderline << fontStyle << fontLetterSpacing << fontWordSpacing
311 << labelAlignment << formatLineHeight << formatColor << formatOpacity
312 << bufferDraw << bufferSize << bufferColor << bufferOpacity;
313
314 double x = label->getX();
315 double y = label->getY();
316 QgsGeometry geometry( new QgsPoint( x, y ) );
317
318 QgsFeature feature;
319 feature.setAttributes( attributes );
320 feature.setGeometry( geometry );
321 features << feature;
322 }
323
324 QList<QgsFeature> features;
325
326 private:
327
328 QMap<QString, QString> mMapLayerNames;
329 QList<QString> mCurvedWarningPushed;
330
331 QgsProcessingFeedback *mFeedback = nullptr;
332};
333
334QVariantMap QgsExtractLabelsAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
335{
336 const QgsRectangle extent = parameterAsExtent( parameters, QStringLiteral( "EXTENT" ), context );
337 const double scale = parameterAsDouble( parameters, QStringLiteral( "SCALE" ), context );
338 if ( qgsDoubleNear( scale, 0.0 ) )
339 {
340 throw QgsProcessingException( QObject::tr( "Invalid scale value, a number greater than 0 is required" ) );
341 }
342 double dpi = parameterAsDouble( parameters, QStringLiteral( "DPI" ), context );
343 if ( qgsDoubleNear( dpi, 0.0 ) )
344 {
345 dpi = 96.0;
346 }
347
348 QgsScaleCalculator calculator;
349 calculator.setDpi( dpi );
350 calculator.setMapUnits( mCrs.mapUnits() );
351 const QSize imageSize = calculator.calculateImageSize( extent, scale ).toSize();
352
353 QgsFields fields;
354 fields.append( QgsField( QStringLiteral( "Layer" ), QMetaType::Type::QString, QString(), 0, 0 ) );
355 fields.append( QgsField( QStringLiteral( "FeatureID" ), QMetaType::Type::LongLong, QString(), 20 ) );
356 fields.append( QgsField( QStringLiteral( "LabelText" ), QMetaType::Type::QString, QString(), 0, 0 ) );
357 fields.append( QgsField( QStringLiteral( "LabelWidth" ), QMetaType::Type::Double, QString(), 20, 8 ) );
358 fields.append( QgsField( QStringLiteral( "LabelHeight" ), QMetaType::Type::Double, QString(), 20, 8 ) );
359 fields.append( QgsField( QStringLiteral( "LabelRotation" ), QMetaType::Type::Double, QString(), 20, 2 ) );
360 fields.append( QgsField( QStringLiteral( "LabelUnplaced" ), QMetaType::Type::Bool, QString(), 1, 0 ) );
361 fields.append( QgsField( QStringLiteral( "Family" ), QMetaType::Type::QString, QString(), 0, 0 ) );
362 fields.append( QgsField( QStringLiteral( "Size" ), QMetaType::Type::Double, QString(), 20, 4 ) );
363 fields.append( QgsField( QStringLiteral( "Italic" ), QMetaType::Type::Bool, QString(), 1, 0 ) );
364 fields.append( QgsField( QStringLiteral( "Bold" ), QMetaType::Type::Bool, QString(), 1, 0 ) );
365 fields.append( QgsField( QStringLiteral( "Underline" ), QMetaType::Type::Bool, QString(), 1, 0 ) );
366 fields.append( QgsField( QStringLiteral( "FontStyle" ), QMetaType::Type::QString, QString(), 0, 0 ) );
367 fields.append( QgsField( QStringLiteral( "FontLetterSpacing" ), QMetaType::Type::Double, QString(), 20, 4 ) );
368 fields.append( QgsField( QStringLiteral( "FontWordSpacing" ), QMetaType::Type::Double, QString(), 20, 4 ) );
369 fields.append( QgsField( QStringLiteral( "MultiLineAlignment" ), QMetaType::Type::QString, QString(), 0, 0 ) );
370 fields.append( QgsField( QStringLiteral( "MultiLineHeight" ), QMetaType::Type::Double, QString(), 20, 2 ) );
371 fields.append( QgsField( QStringLiteral( "Color" ), QMetaType::Type::QString, QString(), 7, 0 ) );
372 fields.append( QgsField( QStringLiteral( "FontOpacity" ), QMetaType::Type::Double, QString(), 20, 1 ) );
373 fields.append( QgsField( QStringLiteral( "BufferDraw" ), QMetaType::Type::Bool, QString(), 1, 0 ) );
374 fields.append( QgsField( QStringLiteral( "BufferSize" ), QMetaType::Type::Double, QString(), 20, 4 ) );
375 fields.append( QgsField( QStringLiteral( "BufferColor" ), QMetaType::Type::QString, QString(), 7, 0 ) );
376 fields.append( QgsField( QStringLiteral( "BufferOpacity" ), QMetaType::Type::Double, QString(), 20, 1 ) );
377
378 QString dest;
379 std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Point, mCrs, QgsFeatureSink::RegeneratePrimaryKey ) );
380 if ( !sink )
381 throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
382
383 QgsMapSettings mapSettings;
384 mapSettings.setDestinationCrs( mCrs );
385 mapSettings.setExtent( extent );
386 mapSettings.setOutputSize( imageSize );
387 mapSettings.setOutputDpi( dpi );
388 mapSettings.setFlag( Qgis::MapSettingsFlag::DrawLabeling, true );
391 mapSettings.setLayers( mMapLayers );
392 mapSettings.setLayerStyleOverrides( mMapThemeStyleOverrides );
393 mapSettings.setLabelingEngineSettings( mLabelSettings );
394
395 //build the expression context
396 QgsExpressionContext expressionContext;
397 expressionContext << QgsExpressionContextUtils::globalScope()
400 mapSettings.setExpressionContext( expressionContext );
401
402 QgsNullPaintDevice nullPaintDevice;
403 nullPaintDevice.setOutputSize( imageSize );
404 nullPaintDevice.setOutputDpi( static_cast< int >( std::round( dpi ) ) );
405 QPainter painter( &nullPaintDevice );
406
407 QgsMapRendererCustomPainterJob renderJob( mapSettings, &painter );
408 ExtractLabelSink labelSink( mMapLayerNames, feedback );
409 renderJob.setLabelSink( &labelSink );
410
411 feedback->pushInfo( QObject::tr( "Extracting labels" ) );
412
413 QgsProcessingMultiStepFeedback multiStepFeedback( 10, feedback );
414 multiStepFeedback.setCurrentStep( 0 );
415
416 QEventLoop loop;
417 QObject::connect( feedback, &QgsFeedback::canceled, &renderJob, &QgsMapRendererCustomPainterJob::cancel );
418 QObject::connect( &renderJob, &QgsMapRendererJob::renderingLayersFinished, feedback, [feedback]() { feedback->pushInfo( QObject::tr( "Calculating label placement" ) ); } );
419 int labelsCollectedFromLayers = 0;
420 QObject::connect( &renderJob, &QgsMapRendererJob::layerRenderingStarted, feedback, [this, &multiStepFeedback, &labelsCollectedFromLayers]( const QString & layerId )
421 {
422 multiStepFeedback.pushInfo( QObject::tr( "Collecting labelled features from %1" ).arg( mMapLayerNames.value( layerId ) ) );
423 multiStepFeedback.setProgress( 100.0 * static_cast< double >( labelsCollectedFromLayers ) / mMapLayers.size() );
424 labelsCollectedFromLayers++;
425 } );
426
427 QObject::connect( renderJob.labelingEngineFeedback(), &QgsLabelingEngineFeedback::labelRegistrationAboutToBegin, &multiStepFeedback, [&multiStepFeedback]()
428 {
429 multiStepFeedback.setCurrentStep( 1 );
430 multiStepFeedback.pushInfo( QObject::tr( "Registering labels" ) );
431 } );
432
433 QObject::connect( renderJob.labelingEngineFeedback(), &QgsLabelingEngineFeedback::providerRegistrationAboutToBegin, &multiStepFeedback, [this, &multiStepFeedback]( QgsAbstractLabelProvider * provider )
434 {
435 multiStepFeedback.setCurrentStep( 2 );
436 if ( !provider->layerId().isEmpty() )
437 {
438 multiStepFeedback.pushInfo( QObject::tr( "Adding labels from %1" ).arg( mMapLayerNames.value( provider->layerId() ) ) );
439 }
440 } );
441 QObject::connect( renderJob.labelingEngineFeedback(), &QgsLabelingEngineFeedback::candidateCreationAboutToBegin, &multiStepFeedback, [this, &multiStepFeedback]( QgsAbstractLabelProvider * provider )
442 {
443 multiStepFeedback.setCurrentStep( 3 );
444 if ( !provider->layerId().isEmpty() )
445 {
446 multiStepFeedback.pushInfo( QObject::tr( "Generating label placement candidates for %1" ).arg( mMapLayerNames.value( provider->layerId() ) ) );
447 }
448 } );
449 QObject::connect( renderJob.labelingEngineFeedback(), &QgsLabelingEngineFeedback::obstacleCostingAboutToBegin, &multiStepFeedback, [&multiStepFeedback]()
450 {
451 multiStepFeedback.setCurrentStep( 4 );
452 multiStepFeedback.setProgressText( QObject::tr( "Calculating obstacle costs" ) );
453 } );
454 QObject::connect( renderJob.labelingEngineFeedback(), &QgsLabelingEngineFeedback::calculatingConflictsAboutToBegin, &multiStepFeedback, [&multiStepFeedback]()
455 {
456 multiStepFeedback.setCurrentStep( 5 );
457 multiStepFeedback.setProgressText( QObject::tr( "Calculating label conflicts" ) );
458 } );
459 QObject::connect( renderJob.labelingEngineFeedback(), &QgsLabelingEngineFeedback::finalizingCandidatesAboutToBegin, &multiStepFeedback, [&multiStepFeedback]()
460 {
461 multiStepFeedback.setCurrentStep( 6 );
462 multiStepFeedback.setProgressText( QObject::tr( "Finalizing candidates" ) );
463 } );
464 QObject::connect( renderJob.labelingEngineFeedback(), &QgsLabelingEngineFeedback::reductionAboutToBegin, &multiStepFeedback, [&multiStepFeedback]()
465 {
466 multiStepFeedback.setCurrentStep( 7 );
467 multiStepFeedback.setProgressText( QObject::tr( "Reducing problem" ) );
468 } );
469 QObject::connect( renderJob.labelingEngineFeedback(), &QgsLabelingEngineFeedback::solvingPlacementAboutToBegin, &multiStepFeedback, [&multiStepFeedback]()
470 {
471 multiStepFeedback.setCurrentStep( 8 );
472 multiStepFeedback.setProgressText( QObject::tr( "Determining optimal label placements" ) );
473 } );
474 QObject::connect( renderJob.labelingEngineFeedback(), &QgsLabelingEngineFeedback::solvingPlacementFinished, &multiStepFeedback, [&multiStepFeedback]()
475 {
476 multiStepFeedback.setProgressText( QObject::tr( "Labeling complete" ) );
477 } );
478
479 QObject::connect( renderJob.labelingEngineFeedback(), &QgsLabelingEngineFeedback::progressChanged, &multiStepFeedback, [&multiStepFeedback]( double progress )
480 {
481 multiStepFeedback.setProgress( progress );
482 } );
483
484 QObject::connect( &renderJob, &QgsMapRendererJob::finished, &loop, [&loop]() { loop.exit(); } );
485 renderJob.start();
486 loop.exec();
487
488 qDeleteAll( mMapLayers );
489 mMapLayers.clear();
490
491 multiStepFeedback.setCurrentStep( 9 );
492 feedback->pushInfo( QObject::tr( "Writing %n label(s) to output layer", "", labelSink.features.count() ) );
493 const double step = !labelSink.features.empty() ? 100.0 / labelSink.features.count() : 1;
494 long long index = -1;
495 for ( QgsFeature &feature : labelSink.features )
496 {
497 index++;
498 multiStepFeedback.setProgress( step * index );
499 if ( feedback->isCanceled() )
500 break;
501
502 if ( !sink->addFeature( feature, QgsFeatureSink::FastInsert ) )
503 throw QgsProcessingException( writeFeatureError( sink.get(), parameters, QStringLiteral( "OUTPUT" ) ) );
504 }
505 sink.reset();
506
507 if ( QgsVectorLayer *vl = qobject_cast< QgsVectorLayer * >( QgsProcessingUtils::mapLayerFromString( dest, context ) ) )
508 {
509 vl->setRenderer( new QgsNullSymbolRenderer() );
510 if ( vl->renderer() )
511 {
512 vl->renderer()->setReferenceScale( scale );
513
514 QgsPalLayerSettings settings;
515 QgsPropertyCollection settingsProperties;
516
517 settings.fieldName = QStringLiteral( "LabelText" );
518 settings.obstacleSettings().setIsObstacle( false );
523
524 QgsTextFormat textFormat;
525 textFormat.setSize( 9 );
527 textFormat.setColor( QColor( 0, 0, 0 ) );
528
529 QgsTextBufferSettings buffer = textFormat.buffer();
531
532 textFormat.setBuffer( buffer );
533 settings.setFormat( textFormat );
534
535 settingsProperties.setProperty( QgsPalLayerSettings::Property::Color, QgsProperty::fromExpression( QStringLiteral( "if(\"LabelUnplaced\",'255,0,0',\"Color\")" ) ) );
536 settingsProperties.setProperty( QgsPalLayerSettings::Property::FontOpacity, QgsProperty::fromField( QStringLiteral( "FontOpacity" ) ) );
537 settingsProperties.setProperty( QgsPalLayerSettings::Property::Family, QgsProperty::fromField( QStringLiteral( "Family" ) ) );
538 settingsProperties.setProperty( QgsPalLayerSettings::Property::Italic, QgsProperty::fromField( QStringLiteral( "Italic" ) ) );
539 settingsProperties.setProperty( QgsPalLayerSettings::Property::Bold, QgsProperty::fromField( QStringLiteral( "Bold" ) ) );
540 settingsProperties.setProperty( QgsPalLayerSettings::Property::Underline, QgsProperty::fromField( QStringLiteral( "Underline" ) ) );
541 settingsProperties.setProperty( QgsPalLayerSettings::Property::Size, QgsProperty::fromField( QStringLiteral( "Size" ) ) );
542 settingsProperties.setProperty( QgsPalLayerSettings::Property::FontLetterSpacing, QgsProperty::fromField( QStringLiteral( "FontLetterSpacing" ) ) );
543 settingsProperties.setProperty( QgsPalLayerSettings::Property::FontWordSpacing, QgsProperty::fromField( QStringLiteral( "FontWordSpacing" ) ) );
544 settingsProperties.setProperty( QgsPalLayerSettings::Property::MultiLineAlignment, QgsProperty::fromField( QStringLiteral( "MultiLineAlignment" ) ) );
545 settingsProperties.setProperty( QgsPalLayerSettings::Property::MultiLineHeight, QgsProperty::fromField( QStringLiteral( "MultiLineHeight" ) ) );
546 settingsProperties.setProperty( QgsPalLayerSettings::Property::LabelRotation, QgsProperty::fromField( QStringLiteral( "LabelRotation" ) ) );
547 settingsProperties.setProperty( QgsPalLayerSettings::Property::BufferDraw, QgsProperty::fromField( QStringLiteral( "BufferDraw" ) ) );
548 settingsProperties.setProperty( QgsPalLayerSettings::Property::BufferSize, QgsProperty::fromField( QStringLiteral( "BufferSize" ) ) );
549 settingsProperties.setProperty( QgsPalLayerSettings::Property::BufferColor, QgsProperty::fromField( QStringLiteral( "BufferColor" ) ) );
550 settingsProperties.setProperty( QgsPalLayerSettings::Property::BufferOpacity, QgsProperty::fromField( QStringLiteral( "BufferOpacity" ) ) );
551 settingsProperties.setProperty( QgsPalLayerSettings::Property::Show, QgsProperty::fromExpression( QStringLiteral( "\"LabelUnplaced\"=false" ) ) );
552 settings.setDataDefinedProperties( settingsProperties );
553
555 vl->setLabeling( labeling );
556 vl->setLabelsEnabled( true );
557
558 QString errorMessage;
559 vl->saveStyleToDatabase( QString(), QString(), true, QString(), errorMessage );
560 }
561 }
562
563 QVariantMap outputs;
564 outputs.insert( QStringLiteral( "OUTPUT" ), dest );
565 return outputs;
566}
567
568
569bool QgsExtractLabelsAlgorithm::prepareAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback * )
570{
571 // Retrieve and clone layers
572 const QString mapTheme = parameterAsString( parameters, QStringLiteral( "MAP_THEME" ), context );
573 if ( !mapTheme.isEmpty() && context.project()->mapThemeCollection()->hasMapTheme( mapTheme ) )
574 {
575 const QList<QgsMapLayer *> constLayers = context.project()->mapThemeCollection()->mapThemeVisibleLayers( mapTheme );
576 for ( const QgsMapLayer *l : constLayers )
577 {
578 // only copy vector layers as other layer types aren't actors in the labeling process
579 if ( l->type() == Qgis::LayerType::Vector )
580 mMapLayers.push_back( l->clone() );
581 }
582 mMapThemeStyleOverrides = context.project()->mapThemeCollection( )->mapThemeStyleOverrides( mapTheme );
583 }
584
585 if ( mMapLayers.isEmpty() )
586 {
587 QList<QgsMapLayer *> layers;
588 QgsLayerTree *root = context.project()->layerTreeRoot();
589 const QList<QgsLayerTreeLayer *> layerTreeLayers = root->findLayers();
590 layers.reserve( layerTreeLayers.size() );
591 for ( QgsLayerTreeLayer *nodeLayer : layerTreeLayers )
592 {
593 QgsMapLayer *layer = nodeLayer->layer();
594 if ( nodeLayer->isVisible() && root->layerOrder().contains( layer ) )
595 layers << layer;
596 }
597
598 for ( const QgsMapLayer *l : std::as_const( layers ) )
599 {
600 if ( l->type() == Qgis::LayerType::Vector )
601 mMapLayers.push_back( l->clone() );
602 }
603 }
604
605 for ( const QgsMapLayer *l : std::as_const( mMapLayers ) )
606 {
607 mMapLayerNames.insert( l->id(), l->name() );
608 }
609
610 mCrs = parameterAsExtentCrs( parameters, QStringLiteral( "EXTENT" ), context );
611 if ( !mCrs.isValid() )
612 mCrs = context.project()->crs();
613
614 bool includeUnplaced = parameterAsBoolean( parameters, QStringLiteral( "INCLUDE_UNPLACED" ), context );
615 mLabelSettings = context.project()->labelingEngineSettings();
616 mLabelSettings.setFlag( Qgis::LabelingFlag::DrawUnplacedLabels, includeUnplaced );
617 mLabelSettings.setFlag( Qgis::LabelingFlag::CollectUnplacedLabels, includeUnplaced );
618
619 return true;
620}
621
622
@ VectorPoint
Vector point layers.
@ OverPoint
Arranges candidates over a point (or centroid of a polygon), or at a preset offset from the point....
@ Curved
Arranges candidates following the curvature of a line feature. Applies to line layers only.
@ AroundPoint
Arranges candidates in a circle around a point (or centroid of a polygon). Applies to point or polygo...
@ Line
Arranges candidates parallel to a generalised line representing the feature or parallel to a polygon'...
@ Free
Arranges candidates scattered throughout a polygon feature. Candidates are rotated to respect the pol...
@ OrderedPositionsAroundPoint
Candidates are placed in predefined positions around a point. Preference is given to positions with g...
@ Horizontal
Arranges horizontal candidates scattered throughout a polygon feature. Applies to polygon layers only...
@ PerimeterCurved
Arranges candidates following the curvature of a polygon's boundary. Applies to polygon layers only.
@ OutsidePolygons
Candidates are placed outside of polygon boundaries. Applies to polygon layers only....
@ CollectUnplacedLabels
Whether unplaced labels should be collected in the labeling results (regardless of whether they are b...
@ DrawUnplacedLabels
Whether to render unplaced labels as an indicator/warning for users.
QFlags< ProcessingAlgorithmFlag > ProcessingAlgorithmFlags
Flags indicating how and when an algorithm operates and should be exposed to users.
Definition qgis.h:3076
LabelMultiLineAlignment
Text alignment for multi-line labels.
Definition qgis.h:1092
@ FollowPlacement
Alignment follows placement of label, e.g., labels to the left of a feature will be drawn with right ...
@ Vector
Vector layer.
@ Percentage
Percentage of another measurement (e.g., canvas size, feature size)
@ Points
Points (e.g., for font sizes)
@ RequiresProject
The algorithm requires that a valid QgsProject is available from the processing context in order to e...
@ Advanced
Parameter is an advanced parameter which should be hidden from users by default.
@ AllowOverlapIfRequired
Avoids overlapping labels when possible, but permit overlaps if labels for features cannot otherwise ...
@ UseRenderingOptimization
Enable vector simplification and other rendering optimizations.
@ DrawLabeling
Enable drawing of labels on top of the map.
@ SkipSymbolRendering
Disable symbol rendering while still drawing labels if enabled (since QGIS 3.24)
The QgsAbstractLabelProvider class is an interface class.
Abstract base class - its implementations define different approaches to the labeling of a vector lay...
A vector of attributes.
static QgsExpressionContextScope * projectScope(const QgsProject *project)
Creates a new scope which contains variables and functions relating to a QGIS project.
static QgsExpressionContextScope * mapSettingsScope(const QgsMapSettings &mapSettings)
Creates a new scope which contains variables and functions relating to a QgsMapSettings object.
static QgsExpressionContextScope * globalScope()
Creates a new scope which contains variables and functions relating to the global QGIS context.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
@ FastInsert
Use faster inserts, at the cost of updating the passed features to reflect changes made at the provid...
@ RegeneratePrimaryKey
This flag indicates, that a primary key field cannot be guaranteed to be unique and the sink should i...
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:58
void setAttributes(const QgsAttributes &attrs)
Sets the feature's attributes.
void setGeometry(const QgsGeometry &geometry)
Set the feature's geometry.
bool isCanceled() const
Tells whether the operation has been canceled already.
Definition qgsfeedback.h:53
void progressChanged(double progress)
Emitted when the feedback object reports a progress change.
void canceled()
Internal routines can connect to this signal if they use event loop.
Encapsulate a field in an attribute table or data source.
Definition qgsfield.h:53
Container of fields for a vector layer.
Definition qgsfields.h:46
bool append(const QgsField &field, Qgis::FieldOrigin origin=Qgis::FieldOrigin::Provider, int originIndex=-1)
Appends a field.
Definition qgsfields.cpp:69
A geometry is the spatial representation of a feature.
void setIsObstacle(bool isObstacle)
Sets whether features are obstacles to labels of other layers.
void setOverlapHandling(Qgis::LabelOverlapHandling handling)
Sets the technique used to handle overlapping labels.
void setAllowDegradedPlacement(bool allow)
Sets whether labels can be placed in inferior fallback positions if they cannot otherwise be placed.
void setQuadrant(Qgis::LabelQuadrantPosition quadrant)
Sets the quadrant in which to offset labels from the point.
Abstract base class that can be used to intercept rendered labels from a labeling / rendering job.
virtual void drawUnplacedLabel(const QString &layerId, QgsRenderContext &context, pal::LabelPosition *label, const QgsPalLayerSettings &settings)
The drawLabel method is called for each unplaced label.
virtual void drawLabel(const QString &layerId, QgsRenderContext &context, pal::LabelPosition *label, const QgsPalLayerSettings &settings)=0
The drawLabel method is called for each label that is being drawn.
void obstacleCostingAboutToBegin()
Emitted when the obstacle costing is about to begin.
void solvingPlacementAboutToBegin()
Emitted when the problem solving step is about to begin.
void calculatingConflictsAboutToBegin()
Emitted when the conflict handling step is about to begin.
void reductionAboutToBegin()
Emitted when the candidate reduction step is about to begin.
void labelRegistrationAboutToBegin()
Emitted when the label registration is about to begin.
void solvingPlacementFinished()
Emitted when the problem solving step is finished.
void finalizingCandidatesAboutToBegin()
Emitted when the label candidates are about to be finalized.
void candidateCreationAboutToBegin(QgsAbstractLabelProvider *provider)
Emitted when the label candidate creation is about to begin for a provider.
void providerRegistrationAboutToBegin(QgsAbstractLabelProvider *provider)
Emitted when the label registration is about to begin for a provider.
void setFlag(Qgis::LabelingFlag f, bool enabled=true)
Sets whether a particual flag is enabled.
QList< QgsLayerTreeLayer * > findLayers() const
Find all layer nodes.
Layer tree node points to a map layer.
Namespace with helper functions for layer tree operations.
QList< QgsMapLayer * > layerOrder() const
The order in which layers will be rendered on the canvas.
Base class for all map layer types.
Definition qgsmaplayer.h:75
Job implementation that renders everything sequentially using a custom painter.
void cancel() override
Stop the rendering job - does not return until the job has terminated.
void renderingLayersFinished()
Emitted when the layers are rendered.
void finished()
emitted when asynchronous rendering is finished (or canceled).
void layerRenderingStarted(const QString &layerId)
Emitted just before rendering starts for a particular layer.
The QgsMapSettings class contains configuration for rendering of the map.
void setLayers(const QList< QgsMapLayer * > &layers)
Sets the list of layers to render in the map.
void setOutputDpi(double dpi)
Sets the dpi (dots per inch) used for conversion between real world units (e.g.
void setLayerStyleOverrides(const QMap< QString, QString > &overrides)
Sets the map of map layer style overrides (key: layer ID, value: style name) where a different style ...
void setExtent(const QgsRectangle &rect, bool magnified=true)
Sets the coordinates of the rectangle which should be rendered.
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.
void setLabelingEngineSettings(const QgsLabelingEngineSettings &settings)
Sets the global configuration of the labeling engine.
void setOutputSize(QSize size)
Sets the size of the resulting map image, in pixels.
void setFlag(Qgis::MapSettingsFlag flag, bool on=true)
Enable or disable a particular flag (other flags are not affected)
void setDestinationCrs(const QgsCoordinateReferenceSystem &crs)
Sets the destination crs (coordinate reference system) for the map render.
bool hasMapTheme(const QString &name) const
Returns whether a map theme with a matching name exists.
QList< QgsMapLayer * > mapThemeVisibleLayers(const QString &name) const
Returns the list of layers that are visible for the specified map theme.
QMap< QString, QString > mapThemeStyleOverrides(const QString &name)
Gets layer style overrides (for QgsMapSettings) of the visible layers for given map theme.
Null painter device that can be used for map renderer jobs which use custom painters.
void setOutputSize(const QSize &size)
Sets the size of the device in pixels.
void setOutputDpi(const int dpi)
Sets the dpi of the device.
Null symbol renderer.
static QStringList splitToLines(const QString &text, const QString &wrapCharacter, int autoWrapLength=0, bool useMaxLineLengthWhenAutoWrapping=true)
Splits a text string to a list of separate lines, using a specified wrap character (wrapCharacter).
Contains settings for how a map layer will be labeled.
const QgsLabelObstacleSettings & obstacleSettings() const
Returns the label obstacle settings.
const QgsLabelPlacementSettings & placementSettings() const
Returns the label placement settings.
void setFormat(const QgsTextFormat &format)
Sets the label text formatting settings, e.g., font settings, buffer settings, etc.
Qgis::LabelPlacement placement
Label placement mode.
void setDataDefinedProperties(const QgsPropertyCollection &collection)
Sets the label's property collection, used for data defined overrides.
@ LabelRotation
Label rotation.
@ Italic
Use italic style.
@ BufferOpacity
Buffer opacity.
@ FontLetterSpacing
Letter spacing.
QString fieldName
Name of field (or an expression) to use for label text.
const QgsLabelPointSettings & pointSettings() const
Returns the label point settings, which contain settings related to how the label engine places and f...
Point geometry type, with support for z-dimension and m-values.
Definition qgspoint.h:49
virtual Qgis::ProcessingAlgorithmFlags flags() const
Returns the flags indicating how and when the algorithm operates and should be exposed to users.
Contains information about the context in which a processing algorithm is executed.
QgsProject * project() const
Returns the project in which the algorithm is being executed.
Custom exception class for processing related exceptions.
Base class for providing feedback from a processing algorithm.
virtual void pushInfo(const QString &info)
Pushes a general informational message from the algorithm.
Processing feedback object for multi-step operations.
A boolean parameter for processing algorithms.
A rectangular map extent parameter for processing algorithms.
A feature sink output for processing algorithms.
A double numeric parameter for map scale values.
static QgsMapLayer * mapLayerFromString(const QString &string, QgsProcessingContext &context, bool allowLoadingNewLayers=true, QgsProcessingUtils::LayerHint typeHint=QgsProcessingUtils::LayerHint::UnknownType, QgsProcessing::LayerOptionsFlags flags=QgsProcessing::LayerOptionsFlags())
Interprets a string as a map layer within the supplied context.
QgsMapThemeCollection * mapThemeCollection
Definition qgsproject.h:115
QgsLayerTree * layerTreeRoot() const
Returns pointer to the root (invisible) node of the project's layer tree.
QgsCoordinateReferenceSystem crs
Definition qgsproject.h:112
const QgsLabelingEngineSettings & labelingEngineSettings() const
Returns project's global labeling engine settings.
A grouped map of multiple QgsProperty objects, each referenced by a integer key value.
void setProperty(int key, const QgsProperty &property)
Adds a property to the collection and takes ownership of it.
static QgsProperty fromExpression(const QString &expression, bool isActive=true)
Returns a new ExpressionBasedProperty created from the specified expression.
static QgsProperty fromField(const QString &fieldName, bool isActive=true)
Returns a new FieldBasedProperty created from the specified field name.
A rectangle specified with double values.
Contains information about the context of a rendering operation.
void setRenderingStopped(bool stopped)
Sets whether the rendering operation has been stopped and any ongoing rendering should be canceled im...
double convertToPainterUnits(double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property=Qgis::RenderSubcomponentProperty::Generic) const
Converts a size from the specified units to painter units (pixels).
QPainter * painter()
Returns the destination QPainter for the render operation.
Calculates scale for a given combination of canvas size, map extent, and monitor dpi.
void setDpi(double dpi)
Sets the dpi (dots per inch) for the output resolution, to be used in scale calculations.
void setMapUnits(Qgis::DistanceUnit mapUnits)
Set the map units.
QSizeF calculateImageSize(const QgsRectangle &mapExtent, double scale) const
Calculate the image size in pixel (physical) units.
Container for settings relating to a text buffer.
Qgis::RenderUnit sizeUnit() const
Returns the units for the buffer size.
double size() const
Returns the size of the buffer.
void setColor(const QColor &color)
Sets the color for the buffer.
void setOpacity(double opacity)
Sets the buffer opacity.
QgsMapUnitScale sizeMapUnitScale() const
Returns the map unit scale object for the buffer size.
bool enabled() const
Returns whether the buffer is enabled.
double opacity() const
Returns the buffer opacity.
void setSizeUnit(Qgis::RenderUnit unit)
Sets the units used for the buffer size.
void setEnabled(bool enabled)
Sets whether the text buffer will be drawn.
QColor color() const
Returns the color of the buffer.
void setSize(double size)
Sets the size of the buffer.
Container for all settings relating to text rendering.
void setColor(const QColor &color)
Sets the color that text will be rendered in.
void setSize(double size)
Sets the size for rendered text.
QgsMapUnitScale sizeMapUnitScale() const
Returns the map unit scale object for the size.
double lineHeight() const
Returns the line height for text.
void setSizeUnit(Qgis::RenderUnit unit)
Sets the units for the size of rendered text.
void setOpacity(double opacity)
Sets the text's opacity.
void setBuffer(const QgsTextBufferSettings &bufferSettings)
Sets the text's buffer settings.
Qgis::RenderUnit sizeUnit() const
Returns the units for the size of rendered text.
double opacity() const
Returns the text's opacity.
double size() const
Returns the size for rendered text.
QColor color() const
Returns the color that text will be rendered in.
QgsTextBufferSettings & buffer()
Returns a reference to the text buffer settings.
void setLineHeight(double height)
Sets the line height for text.
Class that adds extra information to QgsLabelFeature for text labels.
QFont definedFont() const
Font to be used for rendering.
const QMap< QgsPalLayerSettings::Property, QVariant > & dataDefinedValues() const
Gets data-defined values.
QString text(int partId) const
Returns the text component corresponding to a specified label part.
Basic implementation of the labeling interface.
Represents a vector layer which manages a vector based data sets.
QgsFeatureId featureId() const
Returns the unique ID of the feature.
Definition feature.cpp:166
QgsLabelFeature * feature()
Returns the parent feature.
Definition feature.h:94
LabelPosition is a candidate feature label position.
double getAlpha() const
Returns the angle to rotate text (in radians).
double getHeight() const
Quadrant getQuadrant() const
double getWidth() const
FeaturePart * getFeaturePart() const
Returns the feature corresponding to this labelposition.
double getX(int i=0) const
Returns the down-left x coordinate.
double getY(int i=0) const
Returns the down-left y coordinate.
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition qgis.h:5465
qint64 QgsFeatureId
64 bit feature ids negative numbers are used for uncommitted/newly added features