Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgsalgorithmrandomraster.cpp
3 : : ---------------------
4 : : begin : May 2020
5 : : copyright : (C) 2020 by Clemens Raffler
6 : : email : clemens dot raffler 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 "qgsalgorithmrandomraster.h"
19 : : #include "qgsrasterfilewriter.h"
20 : : #include "qgsstringutils.h"
21 : : #include "random"
22 : : #include "limits"
23 : :
24 : : ///@cond PRIVATE
25 : :
26 : : //
27 : : // QgsRandomRasterAlgorithmBase
28 : : //
29 : 0 : QString QgsRandomRasterAlgorithmBase::group() const
30 : : {
31 : 0 : return QObject::tr( "Raster creation" );
32 : : }
33 : :
34 : 0 : QString QgsRandomRasterAlgorithmBase::groupId() const
35 : : {
36 : 0 : return QStringLiteral( "rastercreation" );
37 : : }
38 : :
39 : 0 : void QgsRandomRasterAlgorithmBase::initAlgorithm( const QVariantMap & )
40 : : {
41 : 0 : addParameter( new QgsProcessingParameterExtent( QStringLiteral( "EXTENT" ), QObject::tr( "Desired extent" ) ) );
42 : 0 : addParameter( new QgsProcessingParameterCrs( QStringLiteral( "TARGET_CRS" ), QObject::tr( "Target CRS" ), QStringLiteral( "ProjectCrs" ) ) );
43 : 0 : addParameter( new QgsProcessingParameterNumber( QStringLiteral( "PIXEL_SIZE" ), QObject::tr( "Pixel size" ),
44 : 0 : QgsProcessingParameterNumber::Double, 1, false, 0.01 ) );
45 : :
46 : : //add specific parameters
47 : 0 : addAlgorithmParams();
48 : :
49 : 0 : addParameter( new QgsProcessingParameterRasterDestination( QStringLiteral( "OUTPUT" ), QObject::tr( "Output raster" ) ) );
50 : 0 : }
51 : :
52 : 0 : bool QgsRandomRasterAlgorithmBase::prepareAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
53 : : {
54 : : Q_UNUSED( feedback );
55 : 0 : mCrs = parameterAsCrs( parameters, QStringLiteral( "TARGET_CRS" ), context );
56 : 0 : mExtent = parameterAsExtent( parameters, QStringLiteral( "EXTENT" ), context, mCrs );
57 : 0 : mPixelSize = parameterAsDouble( parameters, QStringLiteral( "PIXEL_SIZE" ), context );
58 : :
59 : 0 : return true;
60 : 0 : }
61 : :
62 : 0 : QVariantMap QgsRandomRasterAlgorithmBase::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
63 : : {
64 : 0 : int typeId = parameterAsInt( parameters, QStringLiteral( "OUTPUT_TYPE" ), context );
65 : : //prepare specific parameters
66 : 0 : mRasterDataType = getRasterDataType( typeId );
67 : 0 : prepareRandomParameters( parameters, context );
68 : :
69 : 0 : std::random_device rd {};
70 : 0 : std::mt19937 mersenneTwister{rd()};
71 : :
72 : 0 : const QString outputFile = parameterAsOutputLayer( parameters, QStringLiteral( "OUTPUT" ), context );
73 : 0 : QFileInfo fi( outputFile );
74 : 0 : const QString outputFormat = QgsRasterFileWriter::driverForExtension( fi.suffix() );
75 : :
76 : 0 : int rows = std::max( std::ceil( mExtent.height() / mPixelSize ), 1.0 );
77 : 0 : int cols = std::max( std::ceil( mExtent.width() / mPixelSize ), 1.0 );
78 : :
79 : : //build new raster extent based on number of columns and cellsize
80 : : //this prevents output cellsize being calculated too small
81 : 0 : QgsRectangle rasterExtent = QgsRectangle( mExtent.xMinimum(), mExtent.yMaximum() - ( rows * mPixelSize ), mExtent.xMinimum() + ( cols * mPixelSize ), mExtent.yMaximum() );
82 : :
83 : 0 : std::unique_ptr< QgsRasterFileWriter > writer = std::make_unique< QgsRasterFileWriter >( outputFile );
84 : 0 : writer->setOutputProviderKey( QStringLiteral( "gdal" ) );
85 : 0 : writer->setOutputFormat( outputFormat );
86 : 0 : std::unique_ptr<QgsRasterDataProvider > provider( writer->createOneBandRaster( mRasterDataType, cols, rows, rasterExtent, mCrs ) );
87 : 0 : if ( !provider )
88 : 0 : throw QgsProcessingException( QObject::tr( "Could not create raster output: %1" ).arg( outputFile ) );
89 : 0 : if ( !provider->isValid() )
90 : 0 : throw QgsProcessingException( QObject::tr( "Could not create raster output %1: %2" ).arg( outputFile, provider->error().message( QgsErrorMessage::Text ) ) );
91 : :
92 : 0 : double step = rows > 0 ? 100.0 / rows : 1;
93 : :
94 : 0 : for ( int row = 0; row < rows ; row++ )
95 : : {
96 : 0 : if ( feedback->isCanceled() )
97 : : {
98 : 0 : break;
99 : : }
100 : : //prepare raw data depending on raster data type
101 : 0 : QgsRasterBlock block( mRasterDataType, cols, 1 );
102 : 0 : switch ( mRasterDataType )
103 : : {
104 : : case Qgis::Byte:
105 : : {
106 : 0 : std::vector<quint8> byteRow( cols );
107 : 0 : for ( int col = 0; col < cols; col++ )
108 : : {
109 : 0 : byteRow[col] = static_cast<quint8>( generateRandomLongValue( mersenneTwister ) );
110 : 0 : }
111 : 0 : block.setData( QByteArray( reinterpret_cast<const char *>( byteRow.data() ), QgsRasterBlock::typeSize( Qgis::Byte ) * cols ) );
112 : : break;
113 : 0 : }
114 : : case Qgis::Int16:
115 : : {
116 : 0 : std::vector<qint16> int16Row( cols );
117 : 0 : for ( int col = 0; col < cols; col++ )
118 : : {
119 : 0 : int16Row[col] = static_cast<qint16>( generateRandomLongValue( mersenneTwister ) );
120 : 0 : }
121 : 0 : block.setData( QByteArray( reinterpret_cast<const char *>( int16Row.data() ), QgsRasterBlock::typeSize( Qgis::Int16 ) * cols ) );
122 : : break;
123 : 0 : }
124 : : case Qgis::UInt16:
125 : : {
126 : 0 : std::vector<quint16> uInt16Row( cols );
127 : 0 : for ( int col = 0; col < cols; col++ )
128 : : {
129 : 0 : uInt16Row[col] = static_cast<quint16>( generateRandomLongValue( mersenneTwister ) );
130 : 0 : }
131 : 0 : block.setData( QByteArray( reinterpret_cast<const char *>( uInt16Row.data() ), QgsRasterBlock::typeSize( Qgis::UInt16 ) * cols ) );
132 : : break;
133 : 0 : }
134 : : case Qgis::Int32:
135 : : {
136 : 0 : std::vector<qint32> int32Row( cols );
137 : 0 : for ( int col = 0; col < cols; col++ )
138 : : {
139 : 0 : int32Row[col] = generateRandomLongValue( mersenneTwister );
140 : 0 : }
141 : 0 : block.setData( QByteArray( reinterpret_cast<const char *>( int32Row.data() ), QgsRasterBlock::typeSize( Qgis::Int32 ) * cols ) );
142 : : break;
143 : 0 : }
144 : : case Qgis::UInt32:
145 : : {
146 : 0 : std::vector<quint32> uInt32Row( cols );
147 : 0 : for ( int col = 0; col < cols; col++ )
148 : : {
149 : 0 : uInt32Row[col] = static_cast<quint32>( generateRandomLongValue( mersenneTwister ) );
150 : 0 : }
151 : 0 : block.setData( QByteArray( reinterpret_cast<const char *>( uInt32Row.data() ), QgsRasterBlock::typeSize( Qgis::UInt32 ) * cols ) );
152 : : break;
153 : 0 : }
154 : : case Qgis::Float32:
155 : : {
156 : 0 : std::vector<float> float32Row( cols );
157 : 0 : for ( int col = 0; col < cols; col++ )
158 : : {
159 : 0 : float32Row[col] = static_cast<float>( generateRandomDoubleValue( mersenneTwister ) );
160 : 0 : }
161 : 0 : block.setData( QByteArray( reinterpret_cast<const char *>( float32Row.data() ), QgsRasterBlock::typeSize( Qgis::Float32 ) * cols ) );
162 : : break;
163 : 0 : }
164 : : case Qgis::Float64:
165 : : {
166 : 0 : std::vector<double> float64Row( cols );
167 : 0 : for ( int col = 0; col < cols; col++ )
168 : : {
169 : 0 : float64Row[col] = generateRandomDoubleValue( mersenneTwister );
170 : 0 : }
171 : 0 : block.setData( QByteArray( reinterpret_cast<const char *>( float64Row.data() ), QgsRasterBlock::typeSize( Qgis::Float64 ) * cols ) );
172 : : break;
173 : 0 : }
174 : : default:
175 : 0 : break;
176 : : }
177 : 0 : provider->writeBlock( &block, 1, 0, row );
178 : 0 : feedback->setProgress( row * step );
179 : 0 : }
180 : :
181 : 0 : QVariantMap outputs;
182 : 0 : outputs.insert( QStringLiteral( "OUTPUT" ), outputFile );
183 : 0 : return outputs;
184 : 0 : }
185 : :
186 : : //
187 : : //QgsRandomUniformRasterAlgorithm
188 : : //
189 : 0 : QString QgsRandomUniformRasterAlgorithm::name() const
190 : : {
191 : 0 : return QStringLiteral( "createrandomuniformrasterlayer" );
192 : : }
193 : :
194 : 0 : QString QgsRandomUniformRasterAlgorithm::displayName() const
195 : : {
196 : 0 : return QObject::tr( "Create random raster layer (uniform distribution)" );
197 : : }
198 : :
199 : 0 : QStringList QgsRandomUniformRasterAlgorithm::tags() const
200 : : {
201 : 0 : return QObject::tr( "raster,create,random" ).split( ',' );
202 : 0 : }
203 : :
204 : 0 : QString QgsRandomUniformRasterAlgorithm::shortHelpString() const
205 : : {
206 : 0 : return QObject::tr( "Generates a raster layer for given extent and cell size "
207 : : "filled with random values.\n"
208 : : "By default, the values will range between the minimum and "
209 : : "maximum value of the specified output raster type. This can "
210 : : "be overridden by using the advanced parameters for lower and "
211 : : "upper bound value. If the bounds have the same value or both "
212 : : "are zero (default) the algorithm will create random values in "
213 : : "the full value range of the chosen raster data type. "
214 : : "Choosing bounds outside the acceptable range of the output "
215 : : "raster type will abort the algorithm." );
216 : : }
217 : :
218 : 0 : QgsRandomUniformRasterAlgorithm *QgsRandomUniformRasterAlgorithm::createInstance() const
219 : : {
220 : 0 : return new QgsRandomUniformRasterAlgorithm();
221 : 0 : }
222 : :
223 : 0 : void QgsRandomUniformRasterAlgorithm::addAlgorithmParams()
224 : : {
225 : 0 : QStringList rasterDataTypes = QStringList();
226 : 0 : rasterDataTypes << QStringLiteral( "Byte" )
227 : 0 : << QStringLiteral( "Integer16" )
228 : 0 : << QStringLiteral( "Unsigned Integer16" )
229 : 0 : << QStringLiteral( "Integer32" )
230 : 0 : << QStringLiteral( "Unsigned Integer32" )
231 : 0 : << QStringLiteral( "Float32" )
232 : 0 : << QStringLiteral( "Float64" );
233 : :
234 : 0 : std::unique_ptr< QgsProcessingParameterDefinition > rasterTypeParameter = std::make_unique< QgsProcessingParameterEnum >( QStringLiteral( "OUTPUT_TYPE" ), QObject::tr( "Output raster data type" ), rasterDataTypes, false, 5, false );
235 : 0 : rasterTypeParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
236 : 0 : addParameter( rasterTypeParameter.release() );
237 : :
238 : 0 : std::unique_ptr< QgsProcessingParameterNumber > lowerBoundParameter = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "LOWER_BOUND" ), QStringLiteral( "Lower bound for random number range" ), QgsProcessingParameterNumber::Double, QVariant(), true );
239 : 0 : lowerBoundParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
240 : 0 : addParameter( lowerBoundParameter.release() );
241 : :
242 : 0 : std::unique_ptr< QgsProcessingParameterNumber > upperBoundParameter = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "UPPER_BOUND" ), QStringLiteral( "Upper bound for random number range" ), QgsProcessingParameterNumber::Double, QVariant(), true );
243 : 0 : upperBoundParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
244 : 0 : addParameter( upperBoundParameter.release() );
245 : 0 : }
246 : :
247 : 0 : Qgis::DataType QgsRandomUniformRasterAlgorithm::getRasterDataType( int typeId )
248 : : {
249 : 0 : switch ( typeId )
250 : : {
251 : : case 0:
252 : 0 : return Qgis::Byte;
253 : : case 1:
254 : 0 : return Qgis::Int16;
255 : : case 2:
256 : 0 : return Qgis::UInt16;
257 : : case 3:
258 : 0 : return Qgis::Int32;
259 : : case 4:
260 : 0 : return Qgis::UInt32;
261 : : case 5:
262 : 0 : return Qgis::Float32;
263 : : case 6:
264 : 0 : return Qgis::Float64;
265 : : default:
266 : 0 : return Qgis::Float32;
267 : : }
268 : 0 : }
269 : :
270 : 0 : bool QgsRandomUniformRasterAlgorithm::prepareRandomParameters( const QVariantMap ¶meters, QgsProcessingContext &context )
271 : : {
272 : 0 : mRandomUpperBound = parameterAsDouble( parameters, QStringLiteral( "UPPER_BOUND" ), context );
273 : 0 : mRandomLowerBound = parameterAsDouble( parameters, QStringLiteral( "LOWER_BOUND" ), context );
274 : :
275 : 0 : if ( mRandomLowerBound > mRandomUpperBound )
276 : 0 : throw QgsProcessingException( QObject::tr( "The chosen lower bound for random number range is greater than the upper bound. The lower bound value must be smaller than the upper bound value." ) );
277 : :
278 : 0 : int typeId = parameterAsInt( parameters, QStringLiteral( "OUTPUT_TYPE" ), context );
279 : 0 : Qgis::DataType rasterDataType = getRasterDataType( typeId );
280 : :
281 : 0 : switch ( rasterDataType )
282 : : {
283 : : case Qgis::Byte:
284 : 0 : if ( mRandomLowerBound < std::numeric_limits<quint8>::min() || mRandomUpperBound > std::numeric_limits<quint8>::max() )
285 : 0 : throw QgsProcessingException( QObject::tr( "Raster datasets of type %3 only accept positive values between %1 and %2. Please choose other bounds for random values." ).arg( std::numeric_limits<quint8>::min() ).arg( std::numeric_limits<quint8>::max() ).arg( QLatin1String( "Byte" ) ) );
286 : 0 : if ( ( qgsDoubleNear( mRandomLowerBound, 0.0 ) && qgsDoubleNear( mRandomUpperBound, 0.0 ) ) || qgsDoubleNear( mRandomUpperBound, mRandomLowerBound ) )
287 : : {
288 : : //if parameters unset (=both are 0 or equal) --> use the whole value range
289 : 0 : mRandomUpperBound = std::numeric_limits<quint8>::max();
290 : 0 : mRandomLowerBound = std::numeric_limits<quint8>::min();
291 : 0 : }
292 : 0 : break;
293 : : case Qgis::Int16:
294 : 0 : if ( mRandomLowerBound < std::numeric_limits<qint16>::min() || mRandomUpperBound > std::numeric_limits<qint16>::max() )
295 : 0 : throw QgsProcessingException( QObject::tr( "Raster datasets of type %3 only accept values between %1 and %2. Please choose other bounds for random values." ).arg( std::numeric_limits<qint16>::min() ).arg( std::numeric_limits<qint16>::max() ).arg( QLatin1String( "Integer16" ) ) );
296 : 0 : if ( ( qgsDoubleNear( mRandomLowerBound, 0.0 ) && qgsDoubleNear( mRandomUpperBound, 0.0 ) ) || qgsDoubleNear( mRandomUpperBound, mRandomLowerBound ) )
297 : : {
298 : 0 : mRandomUpperBound = std::numeric_limits<qint16>::max();
299 : 0 : mRandomLowerBound = std::numeric_limits<qint16>::min();
300 : 0 : }
301 : 0 : break;
302 : : case Qgis::UInt16:
303 : 0 : if ( mRandomLowerBound < std::numeric_limits<quint16>::min() || mRandomUpperBound > std::numeric_limits<quint16>::max() )
304 : 0 : throw QgsProcessingException( QObject::tr( "Raster datasets of type %3 only accept positive values between %1 and %2. Please choose other bounds for random values." ).arg( std::numeric_limits<quint16>::min() ).arg( std::numeric_limits<quint16>::max() ).arg( QLatin1String( "Unsigned Integer16" ) ) );
305 : 0 : if ( ( qgsDoubleNear( mRandomLowerBound, 0.0 ) && qgsDoubleNear( mRandomUpperBound, 0.0 ) ) || qgsDoubleNear( mRandomUpperBound, mRandomLowerBound ) )
306 : : {
307 : 0 : mRandomUpperBound = std::numeric_limits<quint16>::max();
308 : 0 : mRandomLowerBound = std::numeric_limits<quint16>::min();
309 : 0 : }
310 : 0 : break;
311 : : case Qgis::Int32:
312 : 0 : if ( mRandomLowerBound < std::numeric_limits<qint32>::min() || mRandomUpperBound > std::numeric_limits<qint32>::max() )
313 : 0 : throw QgsProcessingException( QObject::tr( "Raster datasets of type %3 only accept values between %1 and %2. Please choose other bounds for random values." ).arg( std::numeric_limits<qint32>::min() ).arg( std::numeric_limits<qint32>::max() ).arg( QLatin1String( "Integer32" ) ) );
314 : 0 : if ( ( qgsDoubleNear( mRandomLowerBound, 0.0 ) && qgsDoubleNear( mRandomUpperBound, 0.0 ) ) || qgsDoubleNear( mRandomUpperBound, mRandomLowerBound ) )
315 : : {
316 : 0 : mRandomUpperBound = std::numeric_limits<qint32>::max();
317 : 0 : mRandomLowerBound = std::numeric_limits<qint32>::min();
318 : 0 : }
319 : 0 : break;
320 : : case Qgis::UInt32:
321 : 0 : if ( mRandomLowerBound < std::numeric_limits<quint32>::min() || mRandomUpperBound > std::numeric_limits<quint32>::max() )
322 : 0 : throw QgsProcessingException( QObject::tr( "Raster datasets of type %3 only accept positive values between %1 and %2. Please choose other bounds for random values." ).arg( std::numeric_limits<quint32>::min() ).arg( std::numeric_limits<quint32>::max() ).arg( QLatin1String( "Unsigned Integer32" ) ) );
323 : 0 : if ( ( qgsDoubleNear( mRandomLowerBound, 0.0 ) && qgsDoubleNear( mRandomUpperBound, 0.0 ) ) || qgsDoubleNear( mRandomUpperBound, mRandomLowerBound ) )
324 : : {
325 : 0 : mRandomUpperBound = std::numeric_limits<quint32>::max();
326 : 0 : mRandomLowerBound = std::numeric_limits<quint32>::min();
327 : 0 : }
328 : 0 : break;
329 : : case Qgis::Float32:
330 : 0 : if ( ( qgsDoubleNear( mRandomLowerBound, 0.0 ) && qgsDoubleNear( mRandomUpperBound, 0.0 ) ) || qgsDoubleNear( mRandomUpperBound, mRandomLowerBound ) )
331 : : {
332 : 0 : mRandomUpperBound = std::numeric_limits<float>::max();
333 : 0 : mRandomLowerBound = std::numeric_limits<float>::min();
334 : 0 : }
335 : 0 : break;
336 : : case Qgis::Float64:
337 : 0 : if ( ( qgsDoubleNear( mRandomLowerBound, 0.0 ) && qgsDoubleNear( mRandomUpperBound, 0.0 ) ) || qgsDoubleNear( mRandomUpperBound, mRandomLowerBound ) )
338 : : {
339 : 0 : mRandomUpperBound = std::numeric_limits<double>::max();
340 : 0 : mRandomLowerBound = std::numeric_limits<double>::min();
341 : 0 : }
342 : 0 : break;
343 : : default:
344 : 0 : break;
345 : : }
346 : :
347 : 0 : mRandomUniformIntDistribution = std::uniform_int_distribution<long>( mRandomLowerBound, mRandomUpperBound );
348 : 0 : mRandomUniformDoubleDistribution = std::uniform_real_distribution<double>( mRandomLowerBound, mRandomUpperBound );
349 : :
350 : 0 : return true;
351 : 0 : }
352 : :
353 : 0 : long QgsRandomUniformRasterAlgorithm::generateRandomLongValue( std::mt19937 &mersenneTwister )
354 : : {
355 : 0 : return mRandomUniformIntDistribution( mersenneTwister );
356 : : }
357 : :
358 : 0 : double QgsRandomUniformRasterAlgorithm::generateRandomDoubleValue( std::mt19937 &mersenneTwister )
359 : : {
360 : 0 : return mRandomUniformDoubleDistribution( mersenneTwister );
361 : : }
362 : :
363 : : //
364 : : // QgsRandomBinomialRasterAlgorithm
365 : : //
366 : 0 : QString QgsRandomBinomialRasterAlgorithm::name() const
367 : : {
368 : 0 : return QStringLiteral( "createrandombinomialrasterlayer" );
369 : : }
370 : :
371 : 0 : QString QgsRandomBinomialRasterAlgorithm::displayName() const
372 : : {
373 : 0 : return QObject::tr( "Create random raster layer (binomial distribution)" );
374 : : }
375 : :
376 : 0 : QStringList QgsRandomBinomialRasterAlgorithm::tags() const
377 : : {
378 : 0 : return QObject::tr( "raster,create,binomial,random" ).split( ',' );
379 : 0 : }
380 : :
381 : 0 : QString QgsRandomBinomialRasterAlgorithm::shortHelpString() const
382 : : {
383 : 0 : return QObject::tr( "Generates a raster layer for given extent and cell size "
384 : : "filled with binomially distributed random values.\n"
385 : : "By default, the values will be chosen given an N of 10 and a probability of 0.5. "
386 : : "This can be overridden by using the advanced parameter for N and probability. "
387 : : "The raster data type is set to Integer types (Integer16 by default). "
388 : : "The binomial distribution random values are defined as positive integer numbers. "
389 : : "A floating point raster will represent a cast of integer values "
390 : : "to floating point." );
391 : : }
392 : :
393 : 0 : QgsRandomBinomialRasterAlgorithm *QgsRandomBinomialRasterAlgorithm::createInstance() const
394 : : {
395 : 0 : return new QgsRandomBinomialRasterAlgorithm();
396 : 0 : }
397 : :
398 : :
399 : 0 : void QgsRandomBinomialRasterAlgorithm::addAlgorithmParams( )
400 : : {
401 : 0 : QStringList rasterDataTypes = QStringList();
402 : 0 : rasterDataTypes << QStringLiteral( "Integer16" )
403 : 0 : << QStringLiteral( "Unsigned Integer16" )
404 : 0 : << QStringLiteral( "Integer32" )
405 : 0 : << QStringLiteral( "Unsigned Integer32" )
406 : 0 : << QStringLiteral( "Float32" )
407 : 0 : << QStringLiteral( "Float64" );
408 : :
409 : 0 : std::unique_ptr< QgsProcessingParameterDefinition > rasterTypeParameter = std::make_unique< QgsProcessingParameterEnum >( QStringLiteral( "OUTPUT_TYPE" ), QObject::tr( "Output raster data type" ), rasterDataTypes, false, 0, false );
410 : 0 : rasterTypeParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
411 : 0 : addParameter( rasterTypeParameter.release() );
412 : :
413 : 0 : std::unique_ptr< QgsProcessingParameterNumber > nParameter = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "N" ), QStringLiteral( "N" ), QgsProcessingParameterNumber::Integer, 10, true, 0 );
414 : 0 : nParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
415 : 0 : addParameter( nParameter.release() );
416 : :
417 : 0 : std::unique_ptr< QgsProcessingParameterNumber > probabilityParameter = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "PROBABILITY" ), QStringLiteral( "Probability" ), QgsProcessingParameterNumber::Double, 0.5, true, 0 );
418 : 0 : probabilityParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
419 : 0 : addParameter( probabilityParameter.release() );
420 : 0 : }
421 : :
422 : 0 : Qgis::DataType QgsRandomBinomialRasterAlgorithm::getRasterDataType( int typeId )
423 : : {
424 : 0 : switch ( typeId )
425 : : {
426 : : case 0:
427 : 0 : return Qgis::Int16;
428 : : case 1:
429 : 0 : return Qgis::UInt16;
430 : : case 2:
431 : 0 : return Qgis::Int32;
432 : : case 3:
433 : 0 : return Qgis::UInt32;
434 : : case 4:
435 : 0 : return Qgis::Float32;
436 : : case 5:
437 : 0 : return Qgis::Float64;
438 : : default:
439 : 0 : return Qgis::Float32;
440 : : }
441 : 0 : }
442 : :
443 : 0 : bool QgsRandomBinomialRasterAlgorithm::prepareRandomParameters( const QVariantMap ¶meters, QgsProcessingContext &context )
444 : : {
445 : 0 : int n = parameterAsInt( parameters, QStringLiteral( "N" ), context );
446 : 0 : double probability = parameterAsDouble( parameters, QStringLiteral( "PROBABILITY" ), context );
447 : 0 : mRandombinomialDistribution = std::binomial_distribution<long>( n, probability );
448 : 0 : return true;
449 : 0 : }
450 : :
451 : 0 : long QgsRandomBinomialRasterAlgorithm::generateRandomLongValue( std::mt19937 &mersenneTwister )
452 : : {
453 : 0 : return mRandombinomialDistribution( mersenneTwister );
454 : : }
455 : :
456 : 0 : double QgsRandomBinomialRasterAlgorithm::generateRandomDoubleValue( std::mt19937 &mersenneTwister )
457 : : {
458 : 0 : return static_cast<double>( mRandombinomialDistribution( mersenneTwister ) );
459 : : }
460 : :
461 : : //
462 : : // QgsRandomExponentialRasterAlgorithm
463 : : //
464 : 0 : QString QgsRandomExponentialRasterAlgorithm::name() const
465 : : {
466 : 0 : return QStringLiteral( "createrandomexponentialrasterlayer" );
467 : : }
468 : :
469 : 0 : QString QgsRandomExponentialRasterAlgorithm::displayName() const
470 : : {
471 : 0 : return QObject::tr( "Create random raster layer (exponential distribution)" );
472 : : }
473 : :
474 : 0 : QStringList QgsRandomExponentialRasterAlgorithm::tags() const
475 : : {
476 : 0 : return QObject::tr( "raster,create,random,exponential" ).split( ',' );
477 : 0 : }
478 : :
479 : 0 : QString QgsRandomExponentialRasterAlgorithm::shortHelpString() const
480 : : {
481 : 0 : return QObject::tr( "Generates a raster layer for given extent and cell size "
482 : : "filled with exponentially distributed random values.\n"
483 : : "By default, the values will be chosen given a lambda of 1.0. "
484 : : "This can be overridden by using the advanced parameter for lambda. "
485 : : "The raster data type is set to Float32 by default as "
486 : : "the exponential distribution random values are floating point numbers." );
487 : : }
488 : :
489 : 0 : QgsRandomExponentialRasterAlgorithm *QgsRandomExponentialRasterAlgorithm::createInstance() const
490 : : {
491 : 0 : return new QgsRandomExponentialRasterAlgorithm();
492 : 0 : }
493 : :
494 : :
495 : 0 : void QgsRandomExponentialRasterAlgorithm::addAlgorithmParams()
496 : : {
497 : 0 : QStringList rasterDataTypes = QStringList();
498 : 0 : rasterDataTypes << QStringLiteral( "Float32" )
499 : 0 : << QStringLiteral( "Float64" );
500 : :
501 : 0 : std::unique_ptr< QgsProcessingParameterDefinition > rasterTypeParameter = std::make_unique< QgsProcessingParameterEnum >( QStringLiteral( "OUTPUT_TYPE" ), QObject::tr( "Output raster data type" ), rasterDataTypes, false, 0, false );
502 : 0 : rasterTypeParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
503 : 0 : addParameter( rasterTypeParameter.release() );
504 : :
505 : 0 : std::unique_ptr< QgsProcessingParameterNumber > lambdaParameter = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "LAMBDA" ), QStringLiteral( "Lambda" ), QgsProcessingParameterNumber::Double, 1.0, true, 0.000001 );
506 : 0 : lambdaParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
507 : 0 : addParameter( lambdaParameter.release() );
508 : 0 : }
509 : :
510 : 0 : Qgis::DataType QgsRandomExponentialRasterAlgorithm::getRasterDataType( int typeId )
511 : : {
512 : 0 : switch ( typeId )
513 : : {
514 : : case 0:
515 : 0 : return Qgis::Float32;
516 : : case 1:
517 : 0 : return Qgis::Float64;
518 : : default:
519 : 0 : return Qgis::Float32;
520 : : }
521 : 0 : }
522 : :
523 : 0 : bool QgsRandomExponentialRasterAlgorithm::prepareRandomParameters( const QVariantMap ¶meters, QgsProcessingContext &context )
524 : : {
525 : 0 : double lambda = parameterAsDouble( parameters, QStringLiteral( "LAMBDA" ), context );
526 : 0 : mRandomExponentialDistribution = std::exponential_distribution<double>( lambda );
527 : 0 : return true;
528 : 0 : }
529 : :
530 : 0 : long QgsRandomExponentialRasterAlgorithm::generateRandomLongValue( std::mt19937 &mersenneTwister )
531 : : {
532 : 0 : return static_cast<long>( mRandomExponentialDistribution( mersenneTwister ) );
533 : : }
534 : :
535 : 0 : double QgsRandomExponentialRasterAlgorithm::generateRandomDoubleValue( std::mt19937 &mersenneTwister )
536 : : {
537 : 0 : return mRandomExponentialDistribution( mersenneTwister );
538 : : }
539 : :
540 : : //
541 : : // QgsRandomGammaRasterAlgorithm
542 : : //
543 : 0 : QString QgsRandomGammaRasterAlgorithm::name() const
544 : : {
545 : 0 : return QStringLiteral( "createrandomgammarasterlayer" );
546 : : }
547 : :
548 : 0 : QString QgsRandomGammaRasterAlgorithm::displayName() const
549 : : {
550 : 0 : return QObject::tr( "Create random raster layer (gamma distribution)" );
551 : : }
552 : :
553 : 0 : QStringList QgsRandomGammaRasterAlgorithm::tags() const
554 : : {
555 : 0 : return QObject::tr( "raster,create,random,gamma" ).split( ',' );
556 : 0 : }
557 : :
558 : 0 : QString QgsRandomGammaRasterAlgorithm::shortHelpString() const
559 : : {
560 : 0 : return QObject::tr( "Generates a raster layer for given extent and cell size "
561 : : "filled with gamma distributed random values.\n"
562 : : "By default, the values will be chosen given an alpha and beta value of 1.0. "
563 : : "This can be overridden by using the advanced parameter for alpha and beta. "
564 : : "The raster data type is set to Float32 by default as "
565 : : "the gamma distribution random values are floating point numbers." );
566 : : }
567 : :
568 : 0 : QgsRandomGammaRasterAlgorithm *QgsRandomGammaRasterAlgorithm::createInstance() const
569 : : {
570 : 0 : return new QgsRandomGammaRasterAlgorithm();
571 : 0 : }
572 : :
573 : :
574 : 0 : void QgsRandomGammaRasterAlgorithm::addAlgorithmParams()
575 : : {
576 : 0 : QStringList rasterDataTypes = QStringList();
577 : 0 : rasterDataTypes << QStringLiteral( "Float32" )
578 : 0 : << QStringLiteral( "Float64" );
579 : :
580 : 0 : std::unique_ptr< QgsProcessingParameterDefinition > rasterTypeParameter = std::make_unique< QgsProcessingParameterEnum >( QStringLiteral( "OUTPUT_TYPE" ), QObject::tr( "Output raster data type" ), rasterDataTypes, false, 0, false );
581 : 0 : rasterTypeParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
582 : 0 : addParameter( rasterTypeParameter.release() );
583 : :
584 : 0 : std::unique_ptr< QgsProcessingParameterNumber > alphaParameter = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "ALPHA" ), QStringLiteral( "Alpha" ), QgsProcessingParameterNumber::Double, 1.0, true, 0.000001 );
585 : 0 : alphaParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
586 : 0 : addParameter( alphaParameter.release() );
587 : :
588 : 0 : std::unique_ptr< QgsProcessingParameterNumber > betaParameter = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "BETA" ), QStringLiteral( "Beta" ), QgsProcessingParameterNumber::Double, 1.0, true, 0.000001 );
589 : 0 : betaParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
590 : 0 : addParameter( betaParameter.release() );
591 : 0 : }
592 : :
593 : 0 : Qgis::DataType QgsRandomGammaRasterAlgorithm::getRasterDataType( int typeId )
594 : : {
595 : 0 : switch ( typeId )
596 : : {
597 : : case 0:
598 : 0 : return Qgis::Float32;
599 : : case 1:
600 : 0 : return Qgis::Float64;
601 : : default:
602 : 0 : return Qgis::Float32;
603 : : }
604 : 0 : }
605 : :
606 : 0 : bool QgsRandomGammaRasterAlgorithm::prepareRandomParameters( const QVariantMap ¶meters, QgsProcessingContext &context )
607 : : {
608 : 0 : double alpha = parameterAsDouble( parameters, QStringLiteral( "ALPHA" ), context );
609 : 0 : double beta = parameterAsDouble( parameters, QStringLiteral( "BETA" ), context );
610 : 0 : mRandomGammaDistribution = std::gamma_distribution<double>( alpha, beta );
611 : 0 : return true;
612 : 0 : }
613 : :
614 : 0 : long QgsRandomGammaRasterAlgorithm::generateRandomLongValue( std::mt19937 &mersenneTwister )
615 : : {
616 : 0 : return static_cast<long>( mRandomGammaDistribution( mersenneTwister ) );
617 : : }
618 : :
619 : 0 : double QgsRandomGammaRasterAlgorithm::generateRandomDoubleValue( std::mt19937 &mersenneTwister )
620 : : {
621 : 0 : return mRandomGammaDistribution( mersenneTwister );
622 : : }
623 : :
624 : : //
625 : : // QgsRandomGeometricRasterAlgorithm
626 : : //
627 : 0 : QString QgsRandomGeometricRasterAlgorithm::name() const
628 : : {
629 : 0 : return QStringLiteral( "createrandomgeometricrasterlayer" );
630 : : }
631 : :
632 : 0 : QString QgsRandomGeometricRasterAlgorithm::displayName() const
633 : : {
634 : 0 : return QObject::tr( "Create random raster layer (geometric distribution)" );
635 : : }
636 : :
637 : 0 : QStringList QgsRandomGeometricRasterAlgorithm::tags() const
638 : : {
639 : 0 : return QObject::tr( "raster,create,random,geometric" ).split( ',' );
640 : 0 : }
641 : :
642 : 0 : QString QgsRandomGeometricRasterAlgorithm::shortHelpString() const
643 : : {
644 : 0 : return QObject::tr( "Generates a raster layer for given extent and cell size "
645 : : "filled with geometrically distributed random values.\n"
646 : : "By default, the values will be chosen given a probability of 0.5. "
647 : : "This can be overridden by using the advanced parameter for mean "
648 : : "value. The raster data type is set to Integer types (Integer16 by default). "
649 : : "The geometric distribution random values are defined as positive integer numbers. "
650 : : "A floating point raster will represent a cast of "
651 : : "integer values to floating point." );
652 : : }
653 : :
654 : 0 : QgsRandomGeometricRasterAlgorithm *QgsRandomGeometricRasterAlgorithm::createInstance() const
655 : : {
656 : 0 : return new QgsRandomGeometricRasterAlgorithm();
657 : 0 : }
658 : :
659 : :
660 : 0 : void QgsRandomGeometricRasterAlgorithm::addAlgorithmParams()
661 : : {
662 : 0 : QStringList rasterDataTypes = QStringList();
663 : 0 : rasterDataTypes << QStringLiteral( "Integer16" )
664 : 0 : << QStringLiteral( "Unsigned Integer16" )
665 : 0 : << QStringLiteral( "Integer32" )
666 : 0 : << QStringLiteral( "Unsigned Integer32" )
667 : 0 : << QStringLiteral( "Float32" )
668 : 0 : << QStringLiteral( "Float64" );
669 : :
670 : 0 : std::unique_ptr< QgsProcessingParameterDefinition > rasterTypeParameter = std::make_unique< QgsProcessingParameterEnum >( QStringLiteral( "OUTPUT_TYPE" ), QObject::tr( "Output raster data type" ), rasterDataTypes, false, 0, false );
671 : 0 : rasterTypeParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
672 : 0 : addParameter( rasterTypeParameter.release() );
673 : :
674 : 0 : std::unique_ptr< QgsProcessingParameterNumber > probabilityParameter = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "PROBABILITY" ), QStringLiteral( "Probability" ), QgsProcessingParameterNumber::Double, 0.5, true, 0.00001 );
675 : 0 : probabilityParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
676 : 0 : addParameter( probabilityParameter.release() );
677 : 0 : }
678 : :
679 : 0 : Qgis::DataType QgsRandomGeometricRasterAlgorithm::getRasterDataType( int typeId )
680 : : {
681 : 0 : switch ( typeId )
682 : : {
683 : : case 0:
684 : 0 : return Qgis::Int16;
685 : : case 1:
686 : 0 : return Qgis::UInt16;
687 : : case 2:
688 : 0 : return Qgis::Int32;
689 : : case 3:
690 : 0 : return Qgis::UInt32;
691 : : case 4:
692 : 0 : return Qgis::Float32;
693 : : case 5:
694 : 0 : return Qgis::Float64;
695 : : default:
696 : 0 : return Qgis::Float32;
697 : : }
698 : 0 : }
699 : :
700 : 0 : bool QgsRandomGeometricRasterAlgorithm::prepareRandomParameters( const QVariantMap ¶meters, QgsProcessingContext &context )
701 : : {
702 : 0 : double probability = parameterAsDouble( parameters, QStringLiteral( "PROBABILITY" ), context );
703 : 0 : mRandomGeometricDistribution = std::geometric_distribution<long>( probability );
704 : 0 : return true;
705 : 0 : }
706 : :
707 : 0 : long QgsRandomGeometricRasterAlgorithm::generateRandomLongValue( std::mt19937 &mersenneTwister )
708 : : {
709 : 0 : return mRandomGeometricDistribution( mersenneTwister );
710 : : }
711 : :
712 : 0 : double QgsRandomGeometricRasterAlgorithm::generateRandomDoubleValue( std::mt19937 &mersenneTwister )
713 : : {
714 : 0 : return static_cast<double>( mRandomGeometricDistribution( mersenneTwister ) );
715 : : }
716 : :
717 : : //
718 : : // QgsRandomNegativeBinomialRasterAlgorithm
719 : : //
720 : 0 : QString QgsRandomNegativeBinomialRasterAlgorithm::name() const
721 : : {
722 : 0 : return QStringLiteral( "createrandomnegativebinomialrasterlayer" );
723 : : }
724 : :
725 : 0 : QString QgsRandomNegativeBinomialRasterAlgorithm::displayName() const
726 : : {
727 : 0 : return QObject::tr( "Create random raster layer (negative binomial distribution)" );
728 : : }
729 : :
730 : 0 : QStringList QgsRandomNegativeBinomialRasterAlgorithm::tags() const
731 : : {
732 : 0 : return QObject::tr( "raster,create,random,negative,binomial,negative-binomial" ).split( ',' );
733 : 0 : }
734 : :
735 : 0 : QString QgsRandomNegativeBinomialRasterAlgorithm::shortHelpString() const
736 : : {
737 : 0 : return QObject::tr( "Generates a raster layer for given extent and cell size "
738 : : "filled with negative binomially distributed random values.\n"
739 : : "By default, the values will be chosen given a distribution parameter k of 10.0 "
740 : : "and a probability of 0.5. "
741 : : "This can be overridden by using the advanced parameters for k and probability. "
742 : : "The raster data type is set to Integer types (Integer 16 by default). "
743 : : "The negative binomial distribution random values are defined as positive integer numbers. "
744 : : "A floating point raster will represent a cast of "
745 : : "integer values to floating point." );
746 : : }
747 : :
748 : 0 : QgsRandomNegativeBinomialRasterAlgorithm *QgsRandomNegativeBinomialRasterAlgorithm::createInstance() const
749 : : {
750 : 0 : return new QgsRandomNegativeBinomialRasterAlgorithm();
751 : 0 : }
752 : :
753 : :
754 : 0 : void QgsRandomNegativeBinomialRasterAlgorithm::addAlgorithmParams( )
755 : : {
756 : 0 : QStringList rasterDataTypes = QStringList();
757 : 0 : rasterDataTypes << QStringLiteral( "Integer16" )
758 : 0 : << QStringLiteral( "Unsigned Integer16" )
759 : 0 : << QStringLiteral( "Integer32" )
760 : 0 : << QStringLiteral( "Unsigned Integer32" )
761 : 0 : << QStringLiteral( "Float32" )
762 : 0 : << QStringLiteral( "Float64" );
763 : :
764 : 0 : std::unique_ptr< QgsProcessingParameterDefinition > rasterTypeParameter = std::make_unique< QgsProcessingParameterEnum >( QStringLiteral( "OUTPUT_TYPE" ), QObject::tr( "Output raster data type" ), rasterDataTypes, false, 0, false );
765 : 0 : rasterTypeParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
766 : 0 : addParameter( rasterTypeParameter.release() );
767 : :
768 : 0 : std::unique_ptr< QgsProcessingParameterNumber > kParameter = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "K_PARAMETER" ), QStringLiteral( "Distribution parameter k" ), QgsProcessingParameterNumber::Integer, 10, true, 0.00001 );
769 : 0 : kParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
770 : 0 : addParameter( kParameter.release() );
771 : :
772 : 0 : std::unique_ptr< QgsProcessingParameterNumber > probabilityParameter = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "PROBABILITY" ), QStringLiteral( "Probability" ), QgsProcessingParameterNumber::Double, 0.5, true, 0.00001 );
773 : 0 : probabilityParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
774 : 0 : addParameter( probabilityParameter.release() );
775 : 0 : }
776 : :
777 : 0 : Qgis::DataType QgsRandomNegativeBinomialRasterAlgorithm::getRasterDataType( int typeId )
778 : : {
779 : 0 : switch ( typeId )
780 : : {
781 : : case 0:
782 : 0 : return Qgis::Int16;
783 : : case 1:
784 : 0 : return Qgis::UInt16;
785 : : case 2:
786 : 0 : return Qgis::Int32;
787 : : case 3:
788 : 0 : return Qgis::UInt32;
789 : : case 4:
790 : 0 : return Qgis::Float32;
791 : : case 5:
792 : 0 : return Qgis::Float64;
793 : : default:
794 : 0 : return Qgis::Float32;
795 : : }
796 : 0 : }
797 : :
798 : 0 : bool QgsRandomNegativeBinomialRasterAlgorithm::prepareRandomParameters( const QVariantMap ¶meters, QgsProcessingContext &context )
799 : : {
800 : 0 : int k = parameterAsInt( parameters, QStringLiteral( "K_PARAMETER" ), context );
801 : 0 : double probability = parameterAsDouble( parameters, QStringLiteral( "PROBABILITY" ), context );
802 : 0 : mRandomNegativeBinomialDistribution = std::negative_binomial_distribution<long>( k, probability );
803 : 0 : return true;
804 : 0 : }
805 : :
806 : 0 : long QgsRandomNegativeBinomialRasterAlgorithm::generateRandomLongValue( std::mt19937 &mersenneTwister )
807 : : {
808 : 0 : return mRandomNegativeBinomialDistribution( mersenneTwister );
809 : : }
810 : :
811 : 0 : double QgsRandomNegativeBinomialRasterAlgorithm::generateRandomDoubleValue( std::mt19937 &mersenneTwister )
812 : : {
813 : 0 : return static_cast<double>( mRandomNegativeBinomialDistribution( mersenneTwister ) );
814 : : }
815 : :
816 : : //
817 : : // QgsRandomNormalRasterAlgorithm
818 : : //
819 : 0 : QString QgsRandomNormalRasterAlgorithm::name() const
820 : : {
821 : 0 : return QStringLiteral( "createrandomnormalrasterlayer" );
822 : : }
823 : :
824 : 0 : QString QgsRandomNormalRasterAlgorithm::displayName() const
825 : : {
826 : 0 : return QObject::tr( "Create random raster layer (normal distribution)" );
827 : : }
828 : :
829 : 0 : QStringList QgsRandomNormalRasterAlgorithm::tags() const
830 : : {
831 : 0 : return QObject::tr( "raster,create,normal,distribution,random" ).split( ',' );
832 : 0 : }
833 : :
834 : 0 : QString QgsRandomNormalRasterAlgorithm::shortHelpString() const
835 : : {
836 : 0 : return QObject::tr( "Generates a raster layer for given extent and cell size "
837 : : "filled with normally distributed random values.\n"
838 : : "By default, the values will be chosen given a mean of 0.0 and "
839 : : "a standard deviation of 1.0. This can be overridden by "
840 : : "using the advanced parameters for mean and standard deviation "
841 : : "value. The raster data type is set to Float32 by default "
842 : : "as the normal distribution random values are floating point numbers." );
843 : : }
844 : :
845 : 0 : QgsRandomNormalRasterAlgorithm *QgsRandomNormalRasterAlgorithm::createInstance() const
846 : : {
847 : 0 : return new QgsRandomNormalRasterAlgorithm();
848 : 0 : }
849 : :
850 : 0 : void QgsRandomNormalRasterAlgorithm::addAlgorithmParams()
851 : : {
852 : 0 : QStringList rasterDataTypes = QStringList();
853 : 0 : rasterDataTypes << QStringLiteral( "Float32" )
854 : 0 : << QStringLiteral( "Float64" );
855 : :
856 : 0 : std::unique_ptr< QgsProcessingParameterDefinition > rasterTypeParameter = std::make_unique< QgsProcessingParameterEnum >( QStringLiteral( "OUTPUT_TYPE" ), QObject::tr( "Output raster data type" ), rasterDataTypes, false, 0, false );
857 : 0 : rasterTypeParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
858 : 0 : addParameter( rasterTypeParameter.release() );
859 : :
860 : 0 : std::unique_ptr< QgsProcessingParameterNumber > meanParameter = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "MEAN" ), QStringLiteral( "Mean of normal distribution" ), QgsProcessingParameterNumber::Double, 0, true );
861 : 0 : meanParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
862 : 0 : addParameter( meanParameter.release() );
863 : :
864 : 0 : std::unique_ptr< QgsProcessingParameterNumber > stdevParameter = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "STDDEV" ), QStringLiteral( "Standard deviation of normal distribution" ), QgsProcessingParameterNumber::Double, 1, true, 0 );
865 : 0 : stdevParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
866 : 0 : addParameter( stdevParameter.release() );
867 : 0 : }
868 : :
869 : 0 : Qgis::DataType QgsRandomNormalRasterAlgorithm::getRasterDataType( int typeId )
870 : : {
871 : 0 : switch ( typeId )
872 : : {
873 : : case 0:
874 : 0 : return Qgis::Float32;
875 : : case 1:
876 : 0 : return Qgis::Float64;
877 : : default:
878 : 0 : return Qgis::Float32;
879 : : }
880 : 0 : }
881 : :
882 : 0 : bool QgsRandomNormalRasterAlgorithm::prepareRandomParameters( const QVariantMap ¶meters, QgsProcessingContext &context )
883 : : {
884 : 0 : double mean = parameterAsDouble( parameters, QStringLiteral( "MEAN" ), context );
885 : 0 : double stddev = parameterAsDouble( parameters, QStringLiteral( "STDDEV" ), context );
886 : 0 : mRandomNormalDistribution = std::normal_distribution<double>( mean, stddev );
887 : 0 : return true;
888 : 0 : }
889 : :
890 : 0 : long QgsRandomNormalRasterAlgorithm::generateRandomLongValue( std::mt19937 &mersenneTwister )
891 : : {
892 : 0 : return static_cast<long>( mRandomNormalDistribution( mersenneTwister ) );
893 : : }
894 : :
895 : 0 : double QgsRandomNormalRasterAlgorithm::generateRandomDoubleValue( std::mt19937 &mersenneTwister )
896 : : {
897 : 0 : return mRandomNormalDistribution( mersenneTwister );
898 : : }
899 : :
900 : : //
901 : : // QgsRandomPoissonRasterAlgorithm
902 : : //
903 : 0 : QString QgsRandomPoissonRasterAlgorithm::name() const
904 : : {
905 : 0 : return QStringLiteral( "createrandompoissonrasterlayer" );
906 : : }
907 : :
908 : 0 : QString QgsRandomPoissonRasterAlgorithm::displayName() const
909 : : {
910 : 0 : return QObject::tr( "Create random raster layer (poisson distribution)" );
911 : : }
912 : :
913 : 0 : QStringList QgsRandomPoissonRasterAlgorithm::tags() const
914 : : {
915 : 0 : return QObject::tr( "raster,create,random,poisson" ).split( ',' );
916 : 0 : }
917 : :
918 : 0 : QString QgsRandomPoissonRasterAlgorithm::shortHelpString() const
919 : : {
920 : 0 : return QObject::tr( "Generates a raster layer for given extent and cell size "
921 : : "filled with poisson distributed random values.\n"
922 : : "By default, the values will be chosen given a mean of 1.0. "
923 : : "This can be overridden by using the advanced parameter for mean "
924 : : "value. The raster data type is set to Integer types (Integer16 by default). "
925 : : "The poisson distribution random values are positive integer numbers. "
926 : : "A floating point raster will represent a cast of integer values to floating point." );
927 : : }
928 : :
929 : 0 : QgsRandomPoissonRasterAlgorithm *QgsRandomPoissonRasterAlgorithm::createInstance() const
930 : : {
931 : 0 : return new QgsRandomPoissonRasterAlgorithm();
932 : 0 : }
933 : :
934 : :
935 : 0 : void QgsRandomPoissonRasterAlgorithm::addAlgorithmParams()
936 : : {
937 : 0 : QStringList rasterDataTypes = QStringList();
938 : 0 : rasterDataTypes << QStringLiteral( "Integer16" )
939 : 0 : << QStringLiteral( "Unsigned Integer16" )
940 : 0 : << QStringLiteral( "Integer32" )
941 : 0 : << QStringLiteral( "Unsigned Integer32" )
942 : 0 : << QStringLiteral( "Float32" )
943 : 0 : << QStringLiteral( "Float64" );
944 : :
945 : 0 : std::unique_ptr< QgsProcessingParameterDefinition > rasterTypeParameter = std::make_unique< QgsProcessingParameterEnum >( QStringLiteral( "OUTPUT_TYPE" ), QObject::tr( "Output raster data type" ), rasterDataTypes, false, 0, false );
946 : 0 : rasterTypeParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
947 : 0 : addParameter( rasterTypeParameter.release() );
948 : :
949 : 0 : std::unique_ptr< QgsProcessingParameterNumber > upperBoundParameter = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "MEAN" ), QStringLiteral( "Mean" ), QgsProcessingParameterNumber::Double, 1.0, true, 0 );
950 : 0 : upperBoundParameter->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
951 : 0 : addParameter( upperBoundParameter.release() );
952 : 0 : }
953 : :
954 : 0 : Qgis::DataType QgsRandomPoissonRasterAlgorithm::getRasterDataType( int typeId )
955 : : {
956 : 0 : switch ( typeId )
957 : : {
958 : : case 0:
959 : 0 : return Qgis::Int16;
960 : : case 1:
961 : 0 : return Qgis::UInt16;
962 : : case 2:
963 : 0 : return Qgis::Int32;
964 : : case 3:
965 : 0 : return Qgis::UInt32;
966 : : case 4:
967 : 0 : return Qgis::Float32;
968 : : case 5:
969 : 0 : return Qgis::Float64;
970 : : default:
971 : 0 : return Qgis::Float32;
972 : : }
973 : 0 : }
974 : :
975 : 0 : bool QgsRandomPoissonRasterAlgorithm::prepareRandomParameters( const QVariantMap ¶meters, QgsProcessingContext &context )
976 : : {
977 : 0 : double mean = parameterAsDouble( parameters, QStringLiteral( "MEAN" ), context );
978 : 0 : mRandomPoissonDistribution = std::poisson_distribution<long>( mean );
979 : 0 : return true;
980 : 0 : }
981 : :
982 : 0 : long QgsRandomPoissonRasterAlgorithm::generateRandomLongValue( std::mt19937 &mersenneTwister )
983 : : {
984 : 0 : return mRandomPoissonDistribution( mersenneTwister );
985 : : }
986 : :
987 : 0 : double QgsRandomPoissonRasterAlgorithm::generateRandomDoubleValue( std::mt19937 &mersenneTwister )
988 : : {
989 : 0 : return static_cast<double>( mRandomPoissonDistribution( mersenneTwister ) );
990 : : }
991 : :
992 : : ///@endcond
|
