QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
qgsalgorithmbasicstatistics.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsalgorithmbasicstatistics.cpp
3 ------------------------------
4 begin : June 2024
5 copyright : (C) 2024 by Alexander Bruy
6 email : alexander dot bruy at gmail dot com
7 ***************************************************************************/
8
9/***************************************************************************
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 ***************************************************************************/
17
18#include "qgsalgorithmbasicstatistics.h"
19#include "qgsstatisticalsummary.h"
20#include "qgsdatetimestatisticalsummary.h"
21#include "qgsstringstatisticalsummary.h"
22
23
24
26
27QString QgsBasicStatisticsAlgorithm::name() const
28{
29 return QStringLiteral( "basicstatisticsforfields" );
30}
31
32QString QgsBasicStatisticsAlgorithm::displayName() const
33{
34 return QObject::tr( "Basic statistics for fields" );
35}
36
37QStringList QgsBasicStatisticsAlgorithm::tags() const
38{
39 return QObject::tr( "stats,statistics,date,time,datetime,string,number,text,table,layer,sum,maximum,minimum,mean,average,standard,deviation,count,distinct,unique,variance,median,quartile,range,majority,minority,summary" ).split( ',' );
40}
41
42QString QgsBasicStatisticsAlgorithm::group() const
43{
44 return QObject::tr( "Vector analysis" );
45}
46
47QString QgsBasicStatisticsAlgorithm::groupId() const
48{
49 return QStringLiteral( "vectoranalysis" );
50}
51
52QString QgsBasicStatisticsAlgorithm::shortHelpString() const
53{
54 return QObject::tr( "Generates basic statistics from the analysis of a values in a field in the attribute table of a vector layer. Numeric, date, time and string fields are supported. The statistics returned will depend on the field type." );
55}
56
57QgsBasicStatisticsAlgorithm *QgsBasicStatisticsAlgorithm::createInstance() const
58{
59 return new QgsBasicStatisticsAlgorithm();
60}
61
62void QgsBasicStatisticsAlgorithm::initAlgorithm( const QVariantMap & )
63{
64 addParameter( new QgsProcessingParameterFeatureSource( QStringLiteral( "INPUT_LAYER" ), QObject::tr( "Input layer" ), QList<int>() << static_cast< int >( Qgis::ProcessingSourceType::Vector ) ) );
65 addParameter( new QgsProcessingParameterField( QStringLiteral( "FIELD_NAME" ), QObject::tr( "Field to calculate statistics on" ), QVariant(), QStringLiteral( "INPUT_LAYER" ) ) );
66 addParameter( new QgsProcessingParameterFeatureSink( QStringLiteral( "OUTPUT" ), QObject::tr( "Statistics" ), Qgis::ProcessingSourceType::Vector, QVariant(), true ) );
67 addParameter( new QgsProcessingParameterFileDestination( QStringLiteral( "OUTPUT_HTML_FILE" ), QObject::tr( "Statistics report" ), QObject::tr( "'HTML files (*.html)" ), QVariant(), true ) );
68
69 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "COUNT" ), QObject::tr( "Count" ) ) );
70 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "UNIQUE" ), QObject::tr( "Number of unique values" ) ) );
71 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "EMPTY" ), QObject::tr( "Number of empty (null) values" ) ) );
72 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "FILLED" ), QObject::tr( "Number of non-empty values" ) ) );
73 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "MIN" ), QObject::tr( "Minimum value" ) ) );
74 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "MAX" ), QObject::tr( "Maximum value" ) ) );
75 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "MIN_LENGTH" ), QObject::tr( "Minimum length" ) ) );
76 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "MAX_LENGTH" ), QObject::tr( "Maximum length" ) ) );
77 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "MEAN_LENGTH" ), QObject::tr( "Mean length" ) ) );
78 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "CV" ), QObject::tr( "Coefficient of Variation" ) ) );
79 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "SUM" ), QObject::tr( "Sum" ) ) );
80 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "MEAN" ), QObject::tr( "Mean value" ) ) );
81 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "STD_DEV" ), QObject::tr( "Standard deviation" ) ) );
82 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "RANGE" ), QObject::tr( "Range" ) ) );
83 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "MEDIAN" ), QObject::tr( "Median" ) ) );
84 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "MINORITY" ), QObject::tr( "Minority (rarest occurring value)" ) ) );
85 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "MAJORITY" ), QObject::tr( "Majority (most frequently occurring value)" ) ) );
86 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "FIRSTQUARTILE" ), QObject::tr( "First quartile" ) ) );
87 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "THIRDQUARTILE" ), QObject::tr( "Third quartile" ) ) );
88 addOutput( new QgsProcessingOutputNumber( QStringLiteral( "IQR" ), QObject::tr( "Interquartile Range (IQR)" ) ) );
89}
90
91QVariantMap QgsBasicStatisticsAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
92{
93 std::unique_ptr< QgsProcessingFeatureSource > source( parameterAsSource( parameters, QStringLiteral( "INPUT_LAYER" ), context ) );
94 if ( !source )
95 throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT_LAYER" ) ) );
96
97 const QString fieldName = parameterAsString( parameters, QStringLiteral( "FIELD_NAME" ), context );
98 const int fieldIndex = source->fields().lookupField( fieldName );
99 if ( fieldIndex < 0 )
100 {
101 throw QgsProcessingException( QObject::tr( "Invalid field for statistics: “%1” does not exist" ).arg( fieldName ) );
102 }
103
104 QgsField field = source->fields().at( fieldIndex );
105
106 QString outputHtml = parameterAsFileOutput( parameters, QStringLiteral( "OUTPUT_HTML_FILE" ), context );
107
108 QgsFeatureRequest request;
109 request.setFlags( Qgis::FeatureRequestFlag::NoGeometry ).setSubsetOfAttributes( QStringList() << fieldName, source->fields() );
110 QgsFeatureIterator features = source->getFeatures( request, Qgis::ProcessingFeatureSourceFlag::SkipGeometryValidityChecks );
111 const long long count = source->featureCount();
112
113 QgsFields fields;
114 fields.append( QgsField( QStringLiteral( "count" ), QMetaType::Int ) );
115 fields.append( QgsField( QStringLiteral( "unique" ), QMetaType::Int ) );
116 fields.append( QgsField( QStringLiteral( "empty" ), QMetaType::Int ) );
117 fields.append( QgsField( QStringLiteral( "filled" ), QMetaType::Int ) );
118
119 if ( field.isNumeric() )
120 {
121 fields.append( QgsField( QStringLiteral( "min" ), QMetaType::Double ) );
122 fields.append( QgsField( QStringLiteral( "max" ), QMetaType::Double ) );
123 fields.append( QgsField( QStringLiteral( "range" ), QMetaType::Double ) );
124 fields.append( QgsField( QStringLiteral( "sum" ), QMetaType::Double ) );
125 fields.append( QgsField( QStringLiteral( "mean" ), QMetaType::Double ) );
126 fields.append( QgsField( QStringLiteral( "median" ), QMetaType::Double ) );
127 fields.append( QgsField( QStringLiteral( "stddev" ), QMetaType::Double ) );
128 fields.append( QgsField( QStringLiteral( "cv" ), QMetaType::Double ) );
129 fields.append( QgsField( QStringLiteral( "minority" ), QMetaType::Double ) );
130 fields.append( QgsField( QStringLiteral( "majority" ), QMetaType::Double ) );
131 fields.append( QgsField( QStringLiteral( "q1" ), QMetaType::Double ) );
132 fields.append( QgsField( QStringLiteral( "q3" ), QMetaType::Double ) );
133 fields.append( QgsField( QStringLiteral( "iqr" ), QMetaType::Double ) );
134 }
135 else if ( field.isDateOrTime() )
136 {
137 if ( field.type() == QMetaType::Type::QDate )
138 {
139 fields.append( QgsField( QStringLiteral( "min" ), QMetaType::QDate ) );
140 fields.append( QgsField( QStringLiteral( "max" ), QMetaType::QDate ) );
141 }
142 else if ( field.type() == QMetaType::Type::QTime )
143 {
144 fields.append( QgsField( QStringLiteral( "min" ), QMetaType::QTime ) );
145 fields.append( QgsField( QStringLiteral( "max" ), QMetaType::QTime ) );
146 }
147 else
148 {
149 fields.append( QgsField( QStringLiteral( "min" ), QMetaType::QDateTime ) );
150 fields.append( QgsField( QStringLiteral( "max" ), QMetaType::QDateTime ) );
151 }
152 fields.append( QgsField( QStringLiteral( "range" ), QMetaType::Double ) );
153 }
154 else
155 {
156 fields.append( QgsField( QStringLiteral( "min" ), QMetaType::QString ) );
157 fields.append( QgsField( QStringLiteral( "max" ), QMetaType::QString ) );
158 fields.append( QgsField( QStringLiteral( "min_length" ), QMetaType::Double ) );
159 fields.append( QgsField( QStringLiteral( "max_length" ), QMetaType::Double ) );
160 fields.append( QgsField( QStringLiteral( "mean_length" ), QMetaType::Double ) );
161 fields.append( QgsField( QStringLiteral( "minority" ), QMetaType::QString ) );
162 fields.append( QgsField( QStringLiteral( "majority" ), QMetaType::QString ) );
163 }
164
165 QString destId;
166 std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, destId, fields, Qgis::WkbType::NoGeometry, QgsCoordinateReferenceSystem() ) );
167 if ( parameters.value( QStringLiteral( "OUTPUT" ) ).isValid() && !sink )
168 throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
169
170 QStringList data;
171 data << QObject::tr( "Analyzed field: %1" ).arg( fieldName );
172
173 QVariantMap outputs;
174
175 if ( field.isNumeric() )
176 {
177 outputs = calculateNumericStatistics( fieldIndex, features, count, sink.get(), data, feedback );
178 }
179 else if ( field.isDateOrTime() )
180 {
181 outputs = calculateDateTimeStatistics( fieldIndex, field, features, count, sink.get(), data, feedback );
182 }
183 else
184 {
185 outputs = calculateStringStatistics( fieldIndex, features, count, sink.get(), data, feedback );
186 }
187
188 if ( !outputHtml.isEmpty() )
189 {
190 QFile file( outputHtml );
191 if ( file.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
192 {
193 QTextStream out( &file );
194#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
195 out.setCodec( "UTF-8" );
196#endif
197 out << QStringLiteral( "<html><head><meta http-equiv=\"Content-Type\" content=\"text/html;charset=utf-8\"/></head><body>\n" );
198 for ( const QString &s : data )
199 {
200 out << QStringLiteral( "<p>%1</p>" ).arg( s );
201 }
202 out << QStringLiteral( "</body></html>" );
203
204 outputs.insert( QStringLiteral( "OUTPUT_HTML_FILE" ), outputHtml );
205 }
206 }
207
208 if ( sink )
209 {
210 outputs.insert( QStringLiteral( "OUTPUT" ), destId );
211 }
212
213 return outputs;
214}
215
216QVariantMap QgsBasicStatisticsAlgorithm::calculateNumericStatistics( const int fieldIndex, QgsFeatureIterator features, const long long count, QgsFeatureSink *sink, QStringList &data, QgsProcessingFeedback *feedback )
217{
218 const double step = count > 0 ? 100.0 / count : 1;
219 long long current = 0;
220
221 QgsFeature f;
222 QgsStatisticalSummary stat;
223
224 while ( features.nextFeature( f ) )
225 {
226 if ( feedback->isCanceled() )
227 {
228 break;
229 }
230
231 stat.addVariant( f.attribute( fieldIndex ) );
232 feedback->setProgress( current * step );
233 current++;
234 }
235 stat.finalize();
236
237 const double cv = stat.mean() != 0 ? stat.stDev() / stat.mean() : 0;
238
239 QVariantMap outputs;
240 outputs.insert( QStringLiteral( "COUNT" ), stat.count() );
241 outputs.insert( QStringLiteral( "UNIQUE" ), stat.variety() );
242 outputs.insert( QStringLiteral( "EMPTY" ), stat.countMissing() );
243 outputs.insert( QStringLiteral( "FILLED" ), count - stat.countMissing() );
244 outputs.insert( QStringLiteral( "MIN" ), stat.min() );
245 outputs.insert( QStringLiteral( "MAX" ), stat.max() );
246 outputs.insert( QStringLiteral( "RANGE" ), stat.range() );
247 outputs.insert( QStringLiteral( "SUM" ), stat.sum() );
248 outputs.insert( QStringLiteral( "MEAN" ), stat.mean() );
249 outputs.insert( QStringLiteral( "MEDIAN" ), stat.median() );
250 outputs.insert( QStringLiteral( "STD_DEV" ), stat.stDev() );
251 outputs.insert( QStringLiteral( "CV" ), cv );
252 outputs.insert( QStringLiteral( "MINORITY" ), stat.minority() );
253 outputs.insert( QStringLiteral( "MAJORITY" ), stat.majority() );
254 outputs.insert( QStringLiteral( "FIRSTQUARTILE" ), stat.firstQuartile() );
255 outputs.insert( QStringLiteral( "THIRDQUARTILE" ), stat.thirdQuartile() );
256 outputs.insert( QStringLiteral( "IQR" ), stat.interQuartileRange() );
257
258 data << QObject::tr( "Count: %1" ).arg( stat.count() )
259 << QObject::tr( "Unique values: %1" ).arg( stat.variety() )
260 << QObject::tr( "NULL (missing) values: %1" ).arg( stat.countMissing() )
261 << QObject::tr( "NOT NULL (filled) values: %1" ).arg( count - stat.countMissing() )
262 << QObject::tr( "Minimum value: %1" ).arg( stat.min() )
263 << QObject::tr( "Maximum value: %1" ).arg( stat.max() )
264 << QObject::tr( "Range: %1" ).arg( stat.range() )
265 << QObject::tr( "Sum: %1" ).arg( stat.sum(), 0, 'f' )
266 << QObject::tr( "Mean value: %1" ).arg( stat.mean(), 0, 'f' )
267 << QObject::tr( "Median value: %1" ).arg( stat.median(), 0, 'f' )
268 << QObject::tr( "Standard deviation: %1" ).arg( stat.stDev(), 0, 'f', 12 )
269 << QObject::tr( "Coefficient of Variation: %1" ).arg( cv, 0, 'f' )
270 << QObject::tr( "Minority (rarest occurring value): %1" ).arg( stat.minority() )
271 << QObject::tr( "Majority (most frequently occurring value): %1" ).arg( stat.majority() )
272 << QObject::tr( "First quartile: %1" ).arg( stat.firstQuartile(), 0, 'f' )
273 << QObject::tr( "Third quartile: %1" ).arg( stat.thirdQuartile(), 0, 'f' )
274 << QObject::tr( "Interquartile Range (IQR): %1" ).arg( stat.interQuartileRange() );
275
276 if ( sink )
277 {
278 QgsFeature f;
279 f.setAttributes( QgsAttributes() << outputs.value( QStringLiteral( "COUNT" ) )
280 << outputs.value( QStringLiteral( "UNIQUE" ) )
281 << outputs.value( QStringLiteral( "EMPTY" ) )
282 << outputs.value( QStringLiteral( "FILLED" ) )
283 << outputs.value( QStringLiteral( "MIN" ) )
284 << outputs.value( QStringLiteral( "MAX" ) )
285 << outputs.value( QStringLiteral( "RANGE" ) )
286 << outputs.value( QStringLiteral( "SUM" ) )
287 << outputs.value( QStringLiteral( "MEAN" ) )
288 << outputs.value( QStringLiteral( "MEDIAN" ) )
289 << outputs.value( QStringLiteral( "STD_DEV" ) )
290 << outputs.value( QStringLiteral( "CV" ) )
291 << outputs.value( QStringLiteral( "MINORITY" ) )
292 << outputs.value( QStringLiteral( "MAJORITY" ) )
293 << outputs.value( QStringLiteral( "FIRSTQUARTILE" ) )
294 << outputs.value( QStringLiteral( "THIRDQUARTILE" ) )
295 << outputs.value( QStringLiteral( "IQR" ) ) );
296 sink->addFeature( f, QgsFeatureSink::FastInsert );
297 }
298
299 return outputs;
300}
301
302QVariantMap QgsBasicStatisticsAlgorithm::calculateDateTimeStatistics( const int fieldIndex, QgsField field, QgsFeatureIterator features, const long long count, QgsFeatureSink *sink, QStringList &data, QgsProcessingFeedback *feedback )
303{
304 const double step = count > 0 ? 100.0 / count : 1;
305 long long current = 0;
306
307 QgsFeature f;
308 QgsDateTimeStatisticalSummary stat;
309
310 while ( features.nextFeature( f ) )
311 {
312 if ( feedback->isCanceled() )
313 {
314 break;
315 }
316
317 stat.addValue( f.attribute( fieldIndex ) );
318 feedback->setProgress( current * step );
319 current++;
320 }
321 stat.finalize();
322
323 QVariantMap outputs;
324 outputs.insert( QStringLiteral( "COUNT" ), stat.count() );
325 outputs.insert( QStringLiteral( "UNIQUE" ), stat.countDistinct() );
326 outputs.insert( QStringLiteral( "EMPTY" ), stat.countMissing() );
327 outputs.insert( QStringLiteral( "FILLED" ), stat.count() - stat.countMissing() );
328 outputs.insert( QStringLiteral( "MIN" ), stat.statistic( Qgis::DateTimeStatistic::Min ) );
329 outputs.insert( QStringLiteral( "MAX" ), stat.statistic( Qgis::DateTimeStatistic::Max ) );
330 outputs.insert( QStringLiteral( "RANGE" ), stat.range().seconds() );
331
332 data << QObject::tr( "Count: %1" ).arg( stat.count() )
333 << QObject::tr( "Unique values: %1" ).arg( stat.countDistinct() )
334 << QObject::tr( "NULL (missing) values: %1" ).arg( stat.countMissing() )
335 << QObject::tr( "NOT NULL (filled) values: %1" ).arg( stat.count() - stat.countMissing() )
336 << QObject::tr( "Minimum value: %1" ).arg( field.displayString( stat.statistic( Qgis::DateTimeStatistic::Min ) ) )
337 << QObject::tr( "Maximum value: %1" ).arg( field.displayString( stat.statistic( Qgis::DateTimeStatistic::Max ) ) )
338 << QObject::tr( "Range (seconds): %1" ).arg( stat.range().seconds() );
339
340 if ( sink )
341 {
342 QgsFeature f;
343 f.setAttributes( QgsAttributes() << outputs.value( QStringLiteral( "COUNT" ) )
344 << outputs.value( QStringLiteral( "UNIQUE" ) )
345 << outputs.value( QStringLiteral( "EMPTY" ) )
346 << outputs.value( QStringLiteral( "FILLED" ) )
347 << outputs.value( QStringLiteral( "MIN" ) )
348 << outputs.value( QStringLiteral( "MAX" ) )
349 << outputs.value( QStringLiteral( "RANGE" ) ) );
350 sink->addFeature( f, QgsFeatureSink::FastInsert );
351 }
352
353 return outputs;
354}
355
356QVariantMap QgsBasicStatisticsAlgorithm::calculateStringStatistics( const int fieldIndex, QgsFeatureIterator features, const long long count, QgsFeatureSink *sink, QStringList &data, QgsProcessingFeedback *feedback )
357{
358 const double step = count > 0 ? 100.0 / count : 1;
359 long long current = 0;
360
361 QgsFeature f;
362 QgsStringStatisticalSummary stat;
363
364 while ( features.nextFeature( f ) )
365 {
366 if ( feedback->isCanceled() )
367 {
368 break;
369 }
370
371 stat.addValue( f.attribute( fieldIndex ) );
372 feedback->setProgress( current * step );
373 current++;
374 }
375 stat.finalize();
376
377 QVariantMap outputs;
378 outputs.insert( QStringLiteral( "COUNT" ), stat.count() );
379 outputs.insert( QStringLiteral( "UNIQUE" ), stat.countDistinct() );
380 outputs.insert( QStringLiteral( "EMPTY" ), stat.countMissing() );
381 outputs.insert( QStringLiteral( "FILLED" ), stat.count() - stat.countMissing() );
382 outputs.insert( QStringLiteral( "MIN" ), stat.min() );
383 outputs.insert( QStringLiteral( "MAX" ), stat.max() );
384 outputs.insert( QStringLiteral( "MIN_LENGTH" ), stat.minLength() );
385 outputs.insert( QStringLiteral( "MAX_LENGTH" ), stat.maxLength() );
386 outputs.insert( QStringLiteral( "MEAN_LENGTH" ), stat.meanLength() );
387 outputs.insert( QStringLiteral( "MINORITY" ), stat.minority() );
388 outputs.insert( QStringLiteral( "MAJORITY" ), stat.majority() );
389
390 data << QObject::tr( "Count: %1" ).arg( stat.count() )
391 << QObject::tr( "Unique values: %1" ).arg( stat.countDistinct() )
392 << QObject::tr( "NULL (missing) values: %1" ).arg( stat.countMissing() )
393 << QObject::tr( "NOT NULL (filled) values: %1" ).arg( count - stat.countMissing() )
394 << QObject::tr( "Minimum value: %1" ).arg( stat.min() )
395 << QObject::tr( "Maximum value: %1" ).arg( stat.max() )
396 << QObject::tr( "Minimum length: %1" ).arg( stat.minLength() )
397 << QObject::tr( "Maximum length: %1" ).arg( stat.maxLength() )
398 << QObject::tr( "Mean length: %1" ).arg( stat.meanLength(), 0, 'f' )
399 << QObject::tr( "Minority: %1" ).arg( stat.minority() )
400 << QObject::tr( "Majority: %1" ).arg( stat.majority() );
401
402 if ( sink )
403 {
404 QgsFeature f;
405 f.setAttributes( QgsAttributes() << outputs.value( QStringLiteral( "COUNT" ) )
406 << outputs.value( QStringLiteral( "UNIQUE" ) )
407 << outputs.value( QStringLiteral( "EMPTY" ) )
408 << outputs.value( QStringLiteral( "FILLED" ) )
409 << outputs.value( QStringLiteral( "MIN" ) )
410 << outputs.value( QStringLiteral( "MAX" ) )
411 << outputs.value( QStringLiteral( "MIN_LENGTH" ) )
412 << outputs.value( QStringLiteral( "MAX_LENGTH" ) )
413 << outputs.value( QStringLiteral( "MEAN_LENGTH" ) )
414 << outputs.value( QStringLiteral( "MINORITY" ) )
415 << outputs.value( QStringLiteral( "MAJORITY" ) ) );
416 sink->addFeature( f, QgsFeatureSink::FastInsert );
417 }
418
419 return outputs;
420}
421
Qgis::ProcessingSourceType::Vector
@ Vector
Tables (i.e. vector layers with or without geometry). When used for a sink this indicates the sink ha...
Qgis::FeatureRequestFlag::NoGeometry
@ NoGeometry
Geometry is not required. It may still be returned if e.g. required for a filter condition.
Qgis::ProcessingFeatureSourceFlag::SkipGeometryValidityChecks
@ SkipGeometryValidityChecks
Invalid geometry checks should always be skipped. This flag can be useful for algorithms which always...
Qgis::WkbType::NoGeometry
@ NoGeometry
No geometry.
Qgis::DateTimeStatistic::Max
@ Max
Maximum (latest) datetime value.
Qgis::DateTimeStatistic::Min
@ Min
Minimum (earliest) datetime value.
QgsAttributes
A vector of attributes.
Definition qgsattributes.h:60
QgsCoordinateReferenceSystem
This class represents a coordinate reference system (CRS).
Definition qgscoordinatereferencesystem.h:212
QgsDateTimeStatisticalSummary
Calculator for summary statistics and aggregates for a list of datetimes.
Definition qgsdatetimestatisticalsummary.h:45
QgsDateTimeStatisticalSummary::statistic
QVariant statistic(Qgis::DateTimeStatistic stat) const
Returns the value of a specified statistic.
Definition qgsdatetimestatisticalsummary.cpp:130
QgsDateTimeStatisticalSummary::range
QgsInterval range() const
Returns the range (interval between earliest and latest non-null datetime values).
Definition qgsdatetimestatisticalsummary.cpp:156
QgsDateTimeStatisticalSummary::addValue
void addValue(const QVariant &value)
Adds a single datetime to the statistics calculation.
Definition qgsdatetimestatisticalsummary.cpp:60
QgsDateTimeStatisticalSummary::finalize
void finalize()
Must be called after adding all datetimes with addValue() and before retrieving any calculated dateti...
Definition qgsdatetimestatisticalsummary.cpp:89
QgsDateTimeStatisticalSummary::count
int count() const
Returns the calculated count of values.
Definition qgsdatetimestatisticalsummary.h:114
QgsDateTimeStatisticalSummary::countMissing
int countMissing() const
Returns the number of missing (null) datetime values.
Definition qgsdatetimestatisticalsummary.h:129
QgsDateTimeStatisticalSummary::countDistinct
int countDistinct() const
Returns the number of distinct datetime values.
Definition qgsdatetimestatisticalsummary.h:119
QgsFeatureIterator
Wrapper for iterator of features from vector data provider or vector layer.
Definition qgsfeatureiterator.h:290
QgsFeatureIterator::nextFeature
bool nextFeature(QgsFeature &f)
Fetch next feature and stores in f, returns true on success.
Definition qgsfeatureiterator.h:407
QgsFeatureRequest
This class wraps a request for features to a vector layer (or directly its vector data provider).
Definition qgsfeaturerequest.h:84
QgsFeatureRequest::setFlags
QgsFeatureRequest & setFlags(Qgis::FeatureRequestFlags flags)
Sets flags that affect how features will be fetched.
Definition qgsfeaturerequest.cpp:251
QgsFeatureRequest::setSubsetOfAttributes
QgsFeatureRequest & setSubsetOfAttributes(const QgsAttributeList &attrs)
Set a subset of attributes that will be fetched.
Definition qgsfeaturerequest.cpp:257
QgsFeatureSink
An interface for objects which accept features via addFeature(s) methods.
Definition qgsfeaturesink.h:33
QgsFeatureSink::addFeature
virtual bool addFeature(QgsFeature &feature, QgsFeatureSink::Flags flags=QgsFeatureSink::Flags())
Adds a single feature to the sink.
Definition qgsfeaturesink.cpp:20
QgsFeatureSink::FastInsert
@ FastInsert
Use faster inserts, at the cost of updating the passed features to reflect changes made at the provid...
Definition qgsfeaturesink.h:69
QgsFeature
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:58
QgsFeature::setAttributes
void setAttributes(const QgsAttributes &attrs)
Sets the feature's attributes.
Definition qgsfeature.cpp:160
QgsFeature::attribute
Q_INVOKABLE QVariant attribute(const QString &name) const
Lookup attribute value by attribute name.
Definition qgsfeature.cpp:335
QgsFeedback::isCanceled
bool isCanceled() const
Tells whether the operation has been canceled already.
Definition qgsfeedback.h:53
QgsFeedback::setProgress
void setProgress(double progress)
Sets the current progress for the feedback object.
Definition qgsfeedback.h:61
QgsField
Encapsulate a field in an attribute table or data source.
Definition qgsfield.h:53
QgsField::type
QMetaType::Type type
Definition qgsfield.h:60
QgsField::isDateOrTime
bool isDateOrTime
Definition qgsfield.h:57
QgsField::displayString
QString displayString(const QVariant &v) const
Formats string for display.
Definition qgsfield.cpp:316
QgsField::isNumeric
bool isNumeric
Definition qgsfield.h:56
QgsFields
Container of fields for a vector layer.
Definition qgsfields.h:46
QgsFields::append
bool append(const QgsField &field, Qgis::FieldOrigin origin=Qgis::FieldOrigin::Provider, int originIndex=-1)
Appends a field.
Definition qgsfields.cpp:69
QgsInterval::seconds
double seconds() const
Returns the interval duration in seconds.
Definition qgsinterval.h:260
QgsProcessingContext
Contains information about the context in which a processing algorithm is executed.
Definition qgsprocessingcontext.h:45
QgsProcessingException
Custom exception class for processing related exceptions.
Definition qgsexception.h:83
QgsProcessingFeedback
Base class for providing feedback from a processing algorithm.
Definition qgsprocessingfeedback.h:38
QgsProcessingOutputNumber
A numeric output for processing algorithms.
Definition qgsprocessingoutputs.h:370
QgsProcessingParameterFeatureSink
A feature sink output for processing algorithms.
Definition qgsprocessingparameters.h:3448
QgsProcessingParameterFeatureSource
An input feature source (such as vector layers) parameter for processing algorithms.
Definition qgsprocessingparameters.h:3286
QgsProcessingParameterField
A vector layer or feature source field parameter for processing algorithms.
Definition qgsprocessingparameters.h:3179
QgsProcessingParameterFileDestination
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
Definition qgsprocessingparameters.h:3677
QgsStatisticalSummary
Calculator for summary statistics for a list of doubles.
Definition qgsstatisticalsummary.h:45
QgsStatisticalSummary::addVariant
void addVariant(const QVariant &value)
Adds a single value to the statistics calculation.
Definition qgsstatisticalsummary.cpp:102
QgsStatisticalSummary::firstQuartile
double firstQuartile() const
Returns the first quartile of the values.
Definition qgsstatisticalsummary.h:240
QgsStatisticalSummary::sum
double sum() const
Returns calculated sum of values.
Definition qgsstatisticalsummary.h:143
QgsStatisticalSummary::mean
double mean() const
Returns calculated mean of values.
Definition qgsstatisticalsummary.h:149
QgsStatisticalSummary::majority
double majority() const
Returns majority of values.
Definition qgsstatisticalsummary.h:231
QgsStatisticalSummary::countMissing
int countMissing() const
Returns the number of missing (null) values.
Definition qgsstatisticalsummary.h:138
QgsStatisticalSummary::interQuartileRange
double interQuartileRange() const
Returns the inter quartile range of the values.
Definition qgsstatisticalsummary.h:258
QgsStatisticalSummary::median
double median() const
Returns calculated median of values.
Definition qgsstatisticalsummary.h:156
QgsStatisticalSummary::minority
double minority() const
Returns minority of values.
Definition qgsstatisticalsummary.h:222
QgsStatisticalSummary::min
double min() const
Returns calculated minimum from values.
Definition qgsstatisticalsummary.h:162
QgsStatisticalSummary::stDev
double stDev() const
Returns population standard deviation.
Definition qgsstatisticalsummary.h:198
QgsStatisticalSummary::thirdQuartile
double thirdQuartile() const
Returns the third quartile of the values.
Definition qgsstatisticalsummary.h:249
QgsStatisticalSummary::count
int count() const
Returns calculated count of values.
Definition qgsstatisticalsummary.h:133
QgsStatisticalSummary::range
double range() const
Returns calculated range (difference between maximum and minimum values).
Definition qgsstatisticalsummary.h:174
QgsStatisticalSummary::max
double max() const
Returns calculated maximum from values.
Definition qgsstatisticalsummary.h:168
QgsStatisticalSummary::finalize
void finalize()
Must be called after adding all values with addValues() and before retrieving any calculated statisti...
Definition qgsstatisticalsummary.cpp:117
QgsStatisticalSummary::variety
int variety() const
Returns variety of values.
Definition qgsstatisticalsummary.h:213
QgsStringStatisticalSummary
Calculator for summary statistics and aggregates for a list of strings.
Definition qgsstringstatisticalsummary.h:44
QgsStringStatisticalSummary::max
QString max() const
Returns the maximum (non-null) string value.
Definition qgsstringstatisticalsummary.h:165
QgsStringStatisticalSummary::min
QString min() const
Returns the minimum (non-null) string value.
Definition qgsstringstatisticalsummary.h:160
QgsStringStatisticalSummary::countMissing
int countMissing() const
Returns the number of missing (null) string values.
Definition qgsstringstatisticalsummary.h:155
QgsStringStatisticalSummary::count
int count() const
Returns the calculated count of values.
Definition qgsstringstatisticalsummary.h:138
QgsStringStatisticalSummary::countDistinct
int countDistinct() const
Returns the number of distinct string values.
Definition qgsstringstatisticalsummary.h:144
QgsStringStatisticalSummary::finalize
void finalize()
Must be called after adding all strings with addString() and before retrieving any calculated string ...
Definition qgsstringstatisticalsummary.cpp:78
QgsStringStatisticalSummary::addValue
void addValue(const QVariant &value)
Adds a single variant to the statistics calculation.
Definition qgsstringstatisticalsummary.cpp:69
QgsStringStatisticalSummary::minLength
int minLength() const
Returns the minimum length of strings.
Definition qgsstringstatisticalsummary.h:170
QgsStringStatisticalSummary::maxLength
int maxLength() const
Returns the maximum length of strings.
Definition qgsstringstatisticalsummary.h:175
QgsStringStatisticalSummary::majority
QString majority() const
Returns the most common string.
Definition qgsstringstatisticalsummary.h:200
QgsStringStatisticalSummary::minority
QString minority() const
Returns the least common string.
Definition qgsstringstatisticalsummary.h:190
QgsStringStatisticalSummary::meanLength
double meanLength() const
Returns the mean length of strings.
Definition qgsstringstatisticalsummary.h:180
Generated on Mon Oct 28 2024 22:06:03 for QGIS API Documentation by doxygen 1.9.8