QGIS API Documentation 3.41.0-Master (3440c17df1d)
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 if ( sink )
188 sink->finalize();
189
190 if ( !outputHtml.isEmpty() )
191 {
192 QFile file( outputHtml );
193 if ( file.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
194 {
195 QTextStream out( &file );
196#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
197 out.setCodec( "UTF-8" );
198#endif
199 out << QStringLiteral( "<html><head><meta http-equiv=\"Content-Type\" content=\"text/html;charset=utf-8\"/></head><body>\n" );
200 for ( const QString &s : data )
201 {
202 out << QStringLiteral( "<p>%1</p>" ).arg( s );
203 }
204 out << QStringLiteral( "</body></html>" );
205
206 outputs.insert( QStringLiteral( "OUTPUT_HTML_FILE" ), outputHtml );
207 }
208 }
209
210 if ( sink )
211 {
212 outputs.insert( QStringLiteral( "OUTPUT" ), destId );
213 }
214
215 return outputs;
216}
217
218QVariantMap QgsBasicStatisticsAlgorithm::calculateNumericStatistics( const int fieldIndex, QgsFeatureIterator features, const long long count, QgsFeatureSink *sink, QStringList &data, QgsProcessingFeedback *feedback )
219{
220 const double step = count > 0 ? 100.0 / count : 1;
221 long long current = 0;
222
223 QgsFeature f;
224 QgsStatisticalSummary stat;
225
226 while ( features.nextFeature( f ) )
227 {
228 if ( feedback->isCanceled() )
229 {
230 break;
231 }
232
233 stat.addVariant( f.attribute( fieldIndex ) );
234 feedback->setProgress( current * step );
235 current++;
236 }
237 stat.finalize();
238
239 const double cv = stat.mean() != 0 ? stat.stDev() / stat.mean() : 0;
240
241 QVariantMap outputs;
242 outputs.insert( QStringLiteral( "COUNT" ), stat.count() );
243 outputs.insert( QStringLiteral( "UNIQUE" ), stat.variety() );
244 outputs.insert( QStringLiteral( "EMPTY" ), stat.countMissing() );
245 outputs.insert( QStringLiteral( "FILLED" ), count - stat.countMissing() );
246 outputs.insert( QStringLiteral( "MIN" ), stat.min() );
247 outputs.insert( QStringLiteral( "MAX" ), stat.max() );
248 outputs.insert( QStringLiteral( "RANGE" ), stat.range() );
249 outputs.insert( QStringLiteral( "SUM" ), stat.sum() );
250 outputs.insert( QStringLiteral( "MEAN" ), stat.mean() );
251 outputs.insert( QStringLiteral( "MEDIAN" ), stat.median() );
252 outputs.insert( QStringLiteral( "STD_DEV" ), stat.stDev() );
253 outputs.insert( QStringLiteral( "CV" ), cv );
254 outputs.insert( QStringLiteral( "MINORITY" ), stat.minority() );
255 outputs.insert( QStringLiteral( "MAJORITY" ), stat.majority() );
256 outputs.insert( QStringLiteral( "FIRSTQUARTILE" ), stat.firstQuartile() );
257 outputs.insert( QStringLiteral( "THIRDQUARTILE" ), stat.thirdQuartile() );
258 outputs.insert( QStringLiteral( "IQR" ), stat.interQuartileRange() );
259
260 data << QObject::tr( "Count: %1" ).arg( stat.count() )
261 << QObject::tr( "Unique values: %1" ).arg( stat.variety() )
262 << QObject::tr( "NULL (missing) values: %1" ).arg( stat.countMissing() )
263 << QObject::tr( "NOT NULL (filled) values: %1" ).arg( count - stat.countMissing() )
264 << QObject::tr( "Minimum value: %1" ).arg( stat.min() )
265 << QObject::tr( "Maximum value: %1" ).arg( stat.max() )
266 << QObject::tr( "Range: %1" ).arg( stat.range() )
267 << QObject::tr( "Sum: %1" ).arg( stat.sum(), 0, 'f' )
268 << QObject::tr( "Mean value: %1" ).arg( stat.mean(), 0, 'f' )
269 << QObject::tr( "Median value: %1" ).arg( stat.median(), 0, 'f' )
270 << QObject::tr( "Standard deviation: %1" ).arg( stat.stDev(), 0, 'f', 12 )
271 << QObject::tr( "Coefficient of Variation: %1" ).arg( cv, 0, 'f' )
272 << QObject::tr( "Minority (rarest occurring value): %1" ).arg( stat.minority() )
273 << QObject::tr( "Majority (most frequently occurring value): %1" ).arg( stat.majority() )
274 << QObject::tr( "First quartile: %1" ).arg( stat.firstQuartile(), 0, 'f' )
275 << QObject::tr( "Third quartile: %1" ).arg( stat.thirdQuartile(), 0, 'f' )
276 << QObject::tr( "Interquartile Range (IQR): %1" ).arg( stat.interQuartileRange() );
277
278 if ( sink )
279 {
280 QgsFeature f;
281 f.setAttributes( QgsAttributes() << outputs.value( QStringLiteral( "COUNT" ) )
282 << outputs.value( QStringLiteral( "UNIQUE" ) )
283 << outputs.value( QStringLiteral( "EMPTY" ) )
284 << outputs.value( QStringLiteral( "FILLED" ) )
285 << outputs.value( QStringLiteral( "MIN" ) )
286 << outputs.value( QStringLiteral( "MAX" ) )
287 << outputs.value( QStringLiteral( "RANGE" ) )
288 << outputs.value( QStringLiteral( "SUM" ) )
289 << outputs.value( QStringLiteral( "MEAN" ) )
290 << outputs.value( QStringLiteral( "MEDIAN" ) )
291 << outputs.value( QStringLiteral( "STD_DEV" ) )
292 << outputs.value( QStringLiteral( "CV" ) )
293 << outputs.value( QStringLiteral( "MINORITY" ) )
294 << outputs.value( QStringLiteral( "MAJORITY" ) )
295 << outputs.value( QStringLiteral( "FIRSTQUARTILE" ) )
296 << outputs.value( QStringLiteral( "THIRDQUARTILE" ) )
297 << outputs.value( QStringLiteral( "IQR" ) ) );
298 sink->addFeature( f, QgsFeatureSink::FastInsert );
299 }
300
301 return outputs;
302}
303
304QVariantMap QgsBasicStatisticsAlgorithm::calculateDateTimeStatistics( const int fieldIndex, QgsField field, QgsFeatureIterator features, const long long count, QgsFeatureSink *sink, QStringList &data, QgsProcessingFeedback *feedback )
305{
306 const double step = count > 0 ? 100.0 / count : 1;
307 long long current = 0;
308
309 QgsFeature f;
310 QgsDateTimeStatisticalSummary stat;
311
312 while ( features.nextFeature( f ) )
313 {
314 if ( feedback->isCanceled() )
315 {
316 break;
317 }
318
319 stat.addValue( f.attribute( fieldIndex ) );
320 feedback->setProgress( current * step );
321 current++;
322 }
323 stat.finalize();
324
325 QVariantMap outputs;
326 outputs.insert( QStringLiteral( "COUNT" ), stat.count() );
327 outputs.insert( QStringLiteral( "UNIQUE" ), stat.countDistinct() );
328 outputs.insert( QStringLiteral( "EMPTY" ), stat.countMissing() );
329 outputs.insert( QStringLiteral( "FILLED" ), stat.count() - stat.countMissing() );
330 outputs.insert( QStringLiteral( "MIN" ), stat.statistic( Qgis::DateTimeStatistic::Min ) );
331 outputs.insert( QStringLiteral( "MAX" ), stat.statistic( Qgis::DateTimeStatistic::Max ) );
332 outputs.insert( QStringLiteral( "RANGE" ), stat.range().seconds() );
333
334 data << QObject::tr( "Count: %1" ).arg( stat.count() )
335 << QObject::tr( "Unique values: %1" ).arg( stat.countDistinct() )
336 << QObject::tr( "NULL (missing) values: %1" ).arg( stat.countMissing() )
337 << QObject::tr( "NOT NULL (filled) values: %1" ).arg( stat.count() - stat.countMissing() )
338 << QObject::tr( "Minimum value: %1" ).arg( field.displayString( stat.statistic( Qgis::DateTimeStatistic::Min ) ) )
339 << QObject::tr( "Maximum value: %1" ).arg( field.displayString( stat.statistic( Qgis::DateTimeStatistic::Max ) ) )
340 << QObject::tr( "Range (seconds): %1" ).arg( stat.range().seconds() );
341
342 if ( sink )
343 {
344 QgsFeature f;
345 f.setAttributes( QgsAttributes() << outputs.value( QStringLiteral( "COUNT" ) )
346 << outputs.value( QStringLiteral( "UNIQUE" ) )
347 << outputs.value( QStringLiteral( "EMPTY" ) )
348 << outputs.value( QStringLiteral( "FILLED" ) )
349 << outputs.value( QStringLiteral( "MIN" ) )
350 << outputs.value( QStringLiteral( "MAX" ) )
351 << outputs.value( QStringLiteral( "RANGE" ) ) );
352 sink->addFeature( f, QgsFeatureSink::FastInsert );
353 }
354
355 return outputs;
356}
357
358QVariantMap QgsBasicStatisticsAlgorithm::calculateStringStatistics( const int fieldIndex, QgsFeatureIterator features, const long long count, QgsFeatureSink *sink, QStringList &data, QgsProcessingFeedback *feedback )
359{
360 const double step = count > 0 ? 100.0 / count : 1;
361 long long current = 0;
362
363 QgsFeature f;
364 QgsStringStatisticalSummary stat;
365
366 while ( features.nextFeature( f ) )
367 {
368 if ( feedback->isCanceled() )
369 {
370 break;
371 }
372
373 stat.addValue( f.attribute( fieldIndex ) );
374 feedback->setProgress( current * step );
375 current++;
376 }
377 stat.finalize();
378
379 QVariantMap outputs;
380 outputs.insert( QStringLiteral( "COUNT" ), stat.count() );
381 outputs.insert( QStringLiteral( "UNIQUE" ), stat.countDistinct() );
382 outputs.insert( QStringLiteral( "EMPTY" ), stat.countMissing() );
383 outputs.insert( QStringLiteral( "FILLED" ), stat.count() - stat.countMissing() );
384 outputs.insert( QStringLiteral( "MIN" ), stat.min() );
385 outputs.insert( QStringLiteral( "MAX" ), stat.max() );
386 outputs.insert( QStringLiteral( "MIN_LENGTH" ), stat.minLength() );
387 outputs.insert( QStringLiteral( "MAX_LENGTH" ), stat.maxLength() );
388 outputs.insert( QStringLiteral( "MEAN_LENGTH" ), stat.meanLength() );
389 outputs.insert( QStringLiteral( "MINORITY" ), stat.minority() );
390 outputs.insert( QStringLiteral( "MAJORITY" ), stat.majority() );
391
392 data << QObject::tr( "Count: %1" ).arg( stat.count() )
393 << QObject::tr( "Unique values: %1" ).arg( stat.countDistinct() )
394 << QObject::tr( "NULL (missing) values: %1" ).arg( stat.countMissing() )
395 << QObject::tr( "NOT NULL (filled) values: %1" ).arg( count - stat.countMissing() )
396 << QObject::tr( "Minimum value: %1" ).arg( stat.min() )
397 << QObject::tr( "Maximum value: %1" ).arg( stat.max() )
398 << QObject::tr( "Minimum length: %1" ).arg( stat.minLength() )
399 << QObject::tr( "Maximum length: %1" ).arg( stat.maxLength() )
400 << QObject::tr( "Mean length: %1" ).arg( stat.meanLength(), 0, 'f' )
401 << QObject::tr( "Minority: %1" ).arg( stat.minority() )
402 << QObject::tr( "Majority: %1" ).arg( stat.majority() );
403
404 if ( sink )
405 {
406 QgsFeature f;
407 f.setAttributes( QgsAttributes() << outputs.value( QStringLiteral( "COUNT" ) )
408 << outputs.value( QStringLiteral( "UNIQUE" ) )
409 << outputs.value( QStringLiteral( "EMPTY" ) )
410 << outputs.value( QStringLiteral( "FILLED" ) )
411 << outputs.value( QStringLiteral( "MIN" ) )
412 << outputs.value( QStringLiteral( "MAX" ) )
413 << outputs.value( QStringLiteral( "MIN_LENGTH" ) )
414 << outputs.value( QStringLiteral( "MAX_LENGTH" ) )
415 << outputs.value( QStringLiteral( "MEAN_LENGTH" ) )
416 << outputs.value( QStringLiteral( "MINORITY" ) )
417 << outputs.value( QStringLiteral( "MAJORITY" ) ) );
418 sink->addFeature( f, QgsFeatureSink::FastInsert );
419 }
420
421 return outputs;
422}
423
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:25
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:161
QgsFeature::attribute
Q_INVOKABLE QVariant attribute(const QString &name) const
Lookup attribute value by attribute name.
Definition qgsfeature.cpp:336
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:317
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:70
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 Sat Nov 23 2024 09:26:05 for QGIS API Documentation by doxygen 1.9.8