QGIS API Documentation 3.43.0-Master (c4a2e9c6d2f)
qgsalgorithmconstantraster.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsalgorithmconstantraster.cpp
3 ---------------------
4 begin : November 2019
5 copyright : (C) 2019 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 <limits>
19#include "math.h"
21#include "qgsrasterfilewriter.h"
22
24
25QString QgsConstantRasterAlgorithm::name() const
26{
27 return QStringLiteral( "createconstantrasterlayer" );
28}
29
30QString QgsConstantRasterAlgorithm::displayName() const
31{
32 return QObject::tr( "Create constant raster layer" );
33}
34
35QStringList QgsConstantRasterAlgorithm::tags() const
36{
37 return QObject::tr( "raster,create,constant" ).split( ',' );
38}
39
40QString QgsConstantRasterAlgorithm::group() const
41{
42 return QObject::tr( "Raster creation" );
43}
44
45QString QgsConstantRasterAlgorithm::groupId() const
46{
47 return QStringLiteral( "rastercreation" );
48}
49
50QString QgsConstantRasterAlgorithm::shortHelpString() const
51{
52 return QObject::tr( "Generates raster layer for given extent and cell "
53 "size filled with the specified value.\n"
54 "Additionally an output data type can be specified. "
55 "The algorithm will abort if a value has been entered that "
56 "cannot be represented by the selected output raster data type." );
57}
58
59QgsConstantRasterAlgorithm *QgsConstantRasterAlgorithm::createInstance() const
60{
61 return new QgsConstantRasterAlgorithm();
62}
63
64void QgsConstantRasterAlgorithm::initAlgorithm( const QVariantMap & )
65{
66 addParameter( new QgsProcessingParameterExtent( QStringLiteral( "EXTENT" ), QObject::tr( "Desired extent" ) ) );
67 addParameter( new QgsProcessingParameterCrs( QStringLiteral( "TARGET_CRS" ), QObject::tr( "Target CRS" ), QStringLiteral( "ProjectCrs" ) ) );
68 addParameter( new QgsProcessingParameterNumber( QStringLiteral( "PIXEL_SIZE" ), QObject::tr( "Pixel size" ), Qgis::ProcessingNumberParameterType::Double, 1, false, 0 ) );
69 addParameter( new QgsProcessingParameterNumber( QStringLiteral( "NUMBER" ), QObject::tr( "Constant value" ), Qgis::ProcessingNumberParameterType::Double, 1, false ) );
70
71 QStringList rasterDataTypes; //currently supported raster data types that can be handled QgsRasterBlock::writeValue()
72 rasterDataTypes << QStringLiteral( "Byte" )
73 << QStringLiteral( "Integer16" )
74 << QStringLiteral( "Unsigned Integer16" )
75 << QStringLiteral( "Integer32" )
76 << QStringLiteral( "Unsigned Integer32" )
77 << QStringLiteral( "Float32" )
78 << QStringLiteral( "Float64" );
79
80 //QGIS3: parameter set to Float32 by default so that existing models/scripts don't break
81 std::unique_ptr<QgsProcessingParameterDefinition> rasterTypeParameter = std::make_unique<QgsProcessingParameterEnum>( QStringLiteral( "OUTPUT_TYPE" ), QObject::tr( "Output raster data type" ), rasterDataTypes, false, 5, false );
82 rasterTypeParameter->setFlags( Qgis::ProcessingParameterFlag::Advanced );
83 addParameter( rasterTypeParameter.release() );
84
85 // backwards compatibility parameter
86 // TODO QGIS 4: remove parameter and related logic
87 auto createOptsParam = std::make_unique<QgsProcessingParameterString>( QStringLiteral( "CREATE_OPTIONS" ), QObject::tr( "Creation options" ), QVariant(), false, true );
88 createOptsParam->setMetadata( QVariantMap( { { QStringLiteral( "widget_wrapper" ), QVariantMap( { { QStringLiteral( "widget_type" ), QStringLiteral( "rasteroptions" ) } } ) } } ) );
89 createOptsParam->setFlags( createOptsParam->flags() | Qgis::ProcessingParameterFlag::Hidden );
90 addParameter( createOptsParam.release() );
91
92 auto creationOptsParam = std::make_unique<QgsProcessingParameterString>( QStringLiteral( "CREATION_OPTIONS" ), QObject::tr( "Creation options" ), QVariant(), false, true );
93 creationOptsParam->setMetadata( QVariantMap( { { QStringLiteral( "widget_wrapper" ), QVariantMap( { { QStringLiteral( "widget_type" ), QStringLiteral( "rasteroptions" ) } } ) } } ) );
94 creationOptsParam->setFlags( creationOptsParam->flags() | Qgis::ProcessingParameterFlag::Advanced );
95 addParameter( creationOptsParam.release() );
96
97 addParameter( new QgsProcessingParameterRasterDestination( QStringLiteral( "OUTPUT" ), QObject::tr( "Constant" ) ) );
98}
99
100QVariantMap QgsConstantRasterAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
101{
102 const QgsCoordinateReferenceSystem crs = parameterAsCrs( parameters, QStringLiteral( "TARGET_CRS" ), context );
103 const QgsRectangle extent = parameterAsExtent( parameters, QStringLiteral( "EXTENT" ), context, crs );
104 const double pixelSize = parameterAsDouble( parameters, QStringLiteral( "PIXEL_SIZE" ), context );
105 const double value = parameterAsDouble( parameters, QStringLiteral( "NUMBER" ), context );
106 const int typeId = parameterAsInt( parameters, QStringLiteral( "OUTPUT_TYPE" ), context );
107
108 if ( pixelSize <= 0 )
109 {
110 throw QgsProcessingException( QObject::tr( "Pixel size must be greater than 0." ) );
111 }
112
113 //implement warning if input float has decimal places but is written to integer raster
114 double fractpart;
115 double intpart;
116 fractpart = abs( std::modf( value, &intpart ) ); //@abs: negative values may be entered
117
118 Qgis::DataType rasterDataType = Qgis::DataType::Float32; //standard output type
119 switch ( typeId )
120 {
121 case 0:
122 rasterDataType = Qgis::DataType::Byte;
123 if ( value < std::numeric_limits<quint8>::min() || value > std::numeric_limits<quint8>::max() )
124 throw QgsProcessingException( QObject::tr( "Raster datasets of type %3 only accept positive values between %1 and %2" ).arg( std::numeric_limits<quint8>::min() ).arg( std::numeric_limits<quint8>::max() ).arg( QLatin1String( "Byte" ) ) );
125 if ( fractpart > 0 )
126 feedback->reportError( QObject::tr( "The entered constant value has decimals but will be written to a raster dataset of type %1. The decimals of the constant value will be omitted." ).arg( QLatin1String( "Byte" ) ) );
127 break;
128 case 1:
129 rasterDataType = Qgis::DataType::Int16;
130 if ( value < std::numeric_limits<qint16>::min() || value > std::numeric_limits<qint16>::max() )
131 throw QgsProcessingException( QObject::tr( "Raster datasets of type %3 only accept values between %1 and %2" ).arg( std::numeric_limits<qint16>::min() ).arg( std::numeric_limits<qint16>::max() ).arg( QLatin1String( "Integer16" ) ) );
132 if ( fractpart > 0 )
133 feedback->reportError( QObject::tr( "The entered constant value has decimals but will be written to a raster dataset of type %1. The decimals of the constant value will be omitted." ).arg( QLatin1String( "Integer16" ) ) );
134 break;
135 case 2:
136 rasterDataType = Qgis::DataType::UInt16;
137 if ( value < std::numeric_limits<quint16>::min() || value > std::numeric_limits<quint16>::max() )
138 throw QgsProcessingException( QObject::tr( "Raster datasets of type %3 only accept positive values between %1 and %2" ).arg( std::numeric_limits<quint16>::min() ).arg( std::numeric_limits<quint16>::max() ).arg( "Unsigned Integer16" ) );
139 if ( fractpart > 0 )
140 feedback->reportError( QObject::tr( "The entered constant value has decimals but will be written to a raster dataset of type %1. The decimals of the constant value will be omitted." ).arg( QLatin1String( "Unsigned Integer16" ) ) );
141 break;
142 case 3:
143 rasterDataType = Qgis::DataType::Int32;
144 if ( value < std::numeric_limits<qint32>::min() || value > std::numeric_limits<qint32>::max() )
145 throw QgsProcessingException( QObject::tr( "Raster datasets of type %3 only accept values between %1 and %2" ).arg( std::numeric_limits<qint32>::min() ).arg( std::numeric_limits<qint32>::max() ).arg( QLatin1String( "Integer32" ) ) );
146 if ( fractpart > 0 )
147 feedback->reportError( QObject::tr( "The entered constant value has decimals but will be written to a raster dataset of type %1. The decimals of the constant value will be omitted." ).arg( QLatin1String( "Integer32" ) ) );
148 break;
149 case 4:
150 rasterDataType = Qgis::DataType::UInt32;
151 if ( value < std::numeric_limits<quint32>::min() || value > std::numeric_limits<quint32>::max() )
152 throw QgsProcessingException( QObject::tr( "Raster datasets of type %3 only accept positive values between %1 and %2" ).arg( std::numeric_limits<quint32>::min() ).arg( std::numeric_limits<quint32>::max() ).arg( QLatin1String( "Unsigned Integer32" ) ) );
153 if ( fractpart > 0 )
154 feedback->reportError( QObject::tr( "The entered constant value has decimals but will be written to a raster dataset of type %1. The decimals of the constant value will be omitted." ).arg( QLatin1String( "Unsigned Integer32" ) ) );
155 break;
156 case 5:
157 rasterDataType = Qgis::DataType::Float32;
158 break;
159 case 6:
160 rasterDataType = Qgis::DataType::Float64;
161 break;
162 default:
163 break;
164 }
165
166 QString creationOptions = parameterAsString( parameters, QStringLiteral( "CREATION_OPTIONS" ), context ).trimmed();
167 // handle backwards compatibility parameter CREATE_OPTIONS
168 const QString optionsString = parameterAsString( parameters, QStringLiteral( "CREATE_OPTIONS" ), context );
169 if ( !optionsString.isEmpty() )
170 creationOptions = optionsString;
171
172 const QString outputFile = parameterAsOutputLayer( parameters, QStringLiteral( "OUTPUT" ), context );
173 const QFileInfo fi( outputFile );
174 const QString outputFormat = QgsRasterFileWriter::driverForExtension( fi.suffix() );
175
176 // round up width and height to the nearest integer as GDAL does (e.g. in gdal_rasterize)
177 // see https://github.com/qgis/QGIS/issues/43547
178 const int rows = static_cast<int>( 0.5 + extent.height() / pixelSize );
179 const int cols = static_cast<int>( 0.5 + extent.width() / pixelSize );
180
181 //build new raster extent based on number of columns and cellsize
182 //this prevents output cellsize being calculated too small
183 const QgsRectangle rasterExtent = QgsRectangle( extent.xMinimum(), extent.yMaximum() - ( rows * pixelSize ), extent.xMinimum() + ( cols * pixelSize ), extent.yMaximum() );
184
185 auto writer = std::make_unique<QgsRasterFileWriter>( outputFile );
186 writer->setOutputProviderKey( QStringLiteral( "gdal" ) );
187 if ( !creationOptions.isEmpty() )
188 {
189 writer->setCreationOptions( creationOptions.split( '|' ) );
190 }
191 writer->setOutputFormat( outputFormat );
192 std::unique_ptr<QgsRasterDataProvider> provider( writer->createOneBandRaster( rasterDataType, cols, rows, rasterExtent, crs ) );
193 if ( !provider )
194 throw QgsProcessingException( QObject::tr( "Could not create raster output: %1" ).arg( outputFile ) );
195 if ( !provider->isValid() )
196 throw QgsProcessingException( QObject::tr( "Could not create raster output %1: %2" ).arg( outputFile, provider->error().message( QgsErrorMessage::Text ) ) );
197
198 //Thoughts on noData:
199 //Setting a noData value is disabled so that the user is protected from accidentally creating an empty raster (eg. when value is set to -9999)
200 //We could also allow creating empty rasters by exposing a noData value parameter (usecases?).
201
202 //prepare raw data depending on raster data type
203 QgsRasterBlock block( rasterDataType, cols, 1 );
204 block.fill( value );
205
206 const double step = rows > 0 ? 100.0 / rows : 1;
207
208 for ( int i = 0; i < rows; i++ )
209 {
210 if ( feedback->isCanceled() )
211 {
212 break;
213 }
214
215 if ( !provider->writeBlock( &block, 1, 0, i ) )
216 {
217 throw QgsProcessingException( QObject::tr( "Could not write raster block: %1" ).arg( provider->error().summary() ) );
218 }
219 feedback->setProgress( i * step );
220 }
221
222 QVariantMap outputs;
223 outputs.insert( QStringLiteral( "OUTPUT" ), outputFile );
224 return outputs;
225}
226
DataType
Raster data types.
Definition qgis.h:351
@ Float32
Thirty two bit floating point (float)
@ Int16
Sixteen bit signed integer (qint16)
@ UInt16
Sixteen bit unsigned integer (quint16)
@ Byte
Eight bit unsigned integer (quint8)
@ Int32
Thirty two bit signed integer (qint32)
@ Float64
Sixty four bit floating point (double)
@ UInt32
Thirty two bit unsigned integer (quint32)
@ Hidden
Parameter is hidden and should not be shown to users.
@ Advanced
Parameter is an advanced parameter which should be hidden from users by default.
Represents a coordinate reference system (CRS).
bool isCanceled() const
Tells whether the operation has been canceled already.
Definition qgsfeedback.h:53
void setProgress(double progress)
Sets the current progress for the feedback object.
Definition qgsfeedback.h:61
Contains information about the context in which a processing algorithm is executed.
Custom exception class for processing related exceptions.
Base class for providing feedback from a processing algorithm.
virtual void reportError(const QString &error, bool fatalError=false)
Reports that the algorithm encountered an error while executing.
A coordinate reference system parameter for processing algorithms.
A rectangular map extent parameter for processing algorithms.
A numeric parameter for processing algorithms.
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
Raster data container.
static QString driverForExtension(const QString &extension)
Returns the GDAL driver name for a specified file extension.
A rectangle specified with double values.
double xMinimum
double yMaximum
const QgsCoordinateReferenceSystem & crs