QGIS API Documentation 3.39.0-Master (67e056379ed)
Loading...
Searching...
No Matches
qgsalgorithmalignsingleraster.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsalgorithmalignsingleraster.cpp
3 ---------------------
4 begin : July 2023
5 copyright : (C) 2023 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
20#include "qgsalignraster.h"
21#include "qgsalignrasterdata.h"
22#include "qgis.h"
23
25
26Qgis::ProcessingAlgorithmFlags QgsAlignSingleRasterAlgorithm::flags() const
27{
29}
30
31QString QgsAlignSingleRasterAlgorithm::name() const
32{
33 return QStringLiteral( "alignsingleraster" );
34}
35
36QString QgsAlignSingleRasterAlgorithm::displayName() const
37{
38 return QObject::tr( "Align raster" );
39}
40
41QStringList QgsAlignSingleRasterAlgorithm::tags() const
42{
43 return QObject::tr( "raster,align,resample,rescale" ).split( ',' );
44}
45
46QString QgsAlignSingleRasterAlgorithm::group() const
47{
48 return QObject::tr( "Raster tools" );
49}
50
51QString QgsAlignSingleRasterAlgorithm::groupId() const
52{
53 return QStringLiteral( "rastertools" );
54}
55
56QString QgsAlignSingleRasterAlgorithm::shortHelpString() const
57{
58 return QObject::tr( "Aligns raster by resampling it to the same cell size and reprojecting to the same CRS as a reference raster." );
59}
60
61QgsAlignSingleRasterAlgorithm *QgsAlignSingleRasterAlgorithm::createInstance() const
62{
63 return new QgsAlignSingleRasterAlgorithm();
64}
65
66void QgsAlignSingleRasterAlgorithm::initAlgorithm( const QVariantMap & )
67{
68 addParameter( new QgsProcessingParameterRasterLayer( QStringLiteral( "INPUT" ), QObject::tr( "Input layer" ) ) );
69
70 QStringList resamplingMethods;
71 resamplingMethods << QObject::tr( "Nearest Neighbour" )
72 << QObject::tr( "Bilinear (2x2 Kernel)" )
73 << QObject::tr( "Cubic (4x4 Kernel)" )
74 << QObject::tr( "Cubic B-Spline (4x4 Kernel)" )
75 << QObject::tr( "Lanczos (6x6 Kernel)" )
76 << QObject::tr( "Average" )
77 << QObject::tr( "Mode" )
78 << QObject::tr( "Maximum" )
79 << QObject::tr( "Minimum" )
80 << QObject::tr( "Median" )
81 << QObject::tr( "First Quartile (Q1)" )
82 << QObject::tr( "Third Quartile (Q3)" );
83 addParameter( new QgsProcessingParameterEnum( QStringLiteral( "RESAMPLING_METHOD" ), QObject::tr( "Resampling method" ), resamplingMethods, false, 0, false ) );
84 addParameter( new QgsProcessingParameterBoolean( QStringLiteral( "RESCALE" ), QObject::tr( "Rescale values according to the cell size" ), false ) );
85 addParameter( new QgsProcessingParameterRasterLayer( QStringLiteral( "REFERENCE_LAYER" ), QObject::tr( "Reference layer" ) ) );
86 addParameter( new QgsProcessingParameterCrs( QStringLiteral( "CRS" ), QObject::tr( "Override reference CRS" ), QVariant(), true ) );
87 addParameter( new QgsProcessingParameterNumber( QStringLiteral( "CELL_SIZE_X" ), QObject::tr( "Override reference cell size X" ), Qgis::ProcessingNumberParameterType::Double, QVariant(), true, 1e-9 ) );
88 addParameter( new QgsProcessingParameterNumber( QStringLiteral( "CELL_SIZE_Y" ), QObject::tr( "Override reference cell size Y" ), Qgis::ProcessingNumberParameterType::Double, QVariant(), true, 1e-9 ) );
89 addParameter( new QgsProcessingParameterNumber( QStringLiteral( "GRID_OFFSET_X" ), QObject::tr( "Override reference grid offset X" ), Qgis::ProcessingNumberParameterType::Double, QVariant(), true, 1e-9 ) );
90 addParameter( new QgsProcessingParameterNumber( QStringLiteral( "GRID_OFFSET_Y" ), QObject::tr( "Override reference grid offset Y" ), Qgis::ProcessingNumberParameterType::Double, QVariant(), true, 1e-9 ) );
91 addParameter( new QgsProcessingParameterExtent( QStringLiteral( "EXTENT" ), QObject::tr( "Clip to extent" ), QVariant(), true ) );
92 addParameter( new QgsProcessingParameterRasterDestination( QStringLiteral( "OUTPUT" ), QObject::tr( "Aligned raster" ) ) );
93}
94
95struct QgsAlignRasterProgress : public QgsAlignRaster::ProgressHandler
96{
97 explicit QgsAlignRasterProgress( QgsFeedback *feedback ) : mFeedback( feedback ) {}
98 bool progress( double complete ) override
99 {
100 mFeedback->setProgress( complete * 100 );
101 return true;
102 }
103
104 protected:
105 QgsFeedback *mFeedback = nullptr;
106};
107
108
109QVariantMap QgsAlignSingleRasterAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
110{
111 QgsRasterLayer *inputLayer = parameterAsRasterLayer( parameters, QStringLiteral( "INPUT" ), context );
112 if ( !inputLayer )
113 throw QgsProcessingException( invalidRasterError( parameters, QStringLiteral( "INPUT" ) ) );
114
115 QgsRasterLayer *referenceLayer = parameterAsRasterLayer( parameters, QStringLiteral( "REFERENCE_LAYER" ), context );
116 if ( !referenceLayer )
117 throw QgsProcessingException( invalidRasterError( parameters, QStringLiteral( "REFERENCE_LAYER" ) ) );
118
119 const int method = parameterAsInt( parameters, QStringLiteral( "RESAMPLING_METHOD" ), context );
120 const bool rescale = parameterAsBoolean( parameters, QStringLiteral( "RESCALE" ), context );
121 const QString outputFile = parameterAsOutputLayer( parameters, QStringLiteral( "OUTPUT" ), context );
122
124 switch ( method )
125 {
126 case 0:
128 break;
129 case 1:
131 break;
132 case 2:
134 break;
135 case 3:
137 break;
138 case 4:
140 break;
141 case 5:
143 break;
144 case 6:
146 break;
147 case 7:
149 break;
150 case 8:
152 break;
153 case 9:
155 break;
156 case 10:
158 break;
159 case 11:
161 break;
162 default:
163 break;
164 }
165
166 QgsAlignRasterData::RasterItem item( inputLayer->source(), outputFile );
167 item.resampleMethod = resampleAlg;
168 item.rescaleValues = rescale;
169
171 items << item;
172
173 QgsAlignRaster rasterAlign;
174 rasterAlign.setRasters( items );
175
176 QString customCRSWkt;
177 QSizeF customCellSize;
178 QPointF customGridOffset( -1, -1 );
179
180 if ( parameters.value( QStringLiteral( "CRS" ) ).isValid() )
181 {
182 QgsCoordinateReferenceSystem crs = parameterAsCrs( parameters, QStringLiteral( "CRS" ), context );
184 }
185
186 bool hasXValue = parameters.value( QStringLiteral( "CELL_SIZE_X" ) ).isValid();
187 bool hasYValue = parameters.value( QStringLiteral( "CELL_SIZE_Y" ) ).isValid();
188 if ( ( hasXValue && !hasYValue ) || ( !hasXValue && hasYValue ) )
189 {
190 throw QgsProcessingException( QObject::tr( "Either set both X and Y cell size values or keep both as 'Not set'." ) );
191 }
192 else if ( hasXValue && hasYValue )
193 {
194 double xSize = parameterAsDouble( parameters, QStringLiteral( "CELL_SIZE_X" ), context );
195 double ySize = parameterAsDouble( parameters, QStringLiteral( "CELL_SIZE_Y" ), context );
196 customCellSize = QSizeF( xSize, ySize );
197 }
198
199 hasXValue = parameters.value( QStringLiteral( "GRID_OFFSET_X" ) ).isValid();
200 hasYValue = parameters.value( QStringLiteral( "GRID_OFFSET_Y" ) ).isValid();
201 if ( ( hasXValue && !hasYValue ) || ( !hasXValue && hasYValue ) )
202 {
203 throw QgsProcessingException( QObject::tr( "Either set both X and Y grid offset values or keep both as 'Not set'." ) );
204 }
205 else if ( hasXValue && hasYValue )
206 {
207 double xSize = parameterAsDouble( parameters, QStringLiteral( "GRID_OFFSET_X" ), context );
208 double ySize = parameterAsDouble( parameters, QStringLiteral( "GRID_OFFSET_Y" ), context );
209 customGridOffset = QPointF( xSize, ySize );
210 }
211
212 if ( parameters.value( QStringLiteral( "EXTENT" ) ).isValid() )
213 {
214 QgsRectangle extent = parameterAsExtent( parameters, QStringLiteral( "EXTENT" ), context );
215 rasterAlign.setClipExtent( extent );
216 }
217
218 rasterAlign.setProgressHandler( new QgsAlignRasterProgress( feedback ) );
219
220 bool result = rasterAlign.setParametersFromRaster( referenceLayer->source(), customCRSWkt, customCellSize, customGridOffset );
221 if ( !result )
222 {
223 throw QgsProcessingException( QObject::tr( "It is not possible to reproject reference raster to target CRS." ) );
224 }
225
226 result = rasterAlign.run();
227 if ( !result )
228 {
229 throw QgsProcessingException( QObject::tr( "Failed to align rasters: %1" ).arg( rasterAlign.errorMessage() ) );
230 }
231
232 QVariantMap outputs;
233 outputs.insert( QStringLiteral( "OUTPUT" ), outputFile );
234 return outputs;
235}
236
GdalResampleAlgorithm
Resampling algorithm to be used (equivalent to GDAL's enum GDALResampleAlg)
Definition qgis.h:4881
@ RA_Lanczos
Lanczos windowed sinc interpolation (6x6 kernel)
@ RA_Q3
Third quartile (selects the third quartile of all non-NODATA contributing pixels)
@ RA_CubicSpline
Cubic B-Spline Approximation (4x4 kernel)
@ RA_Q1
First quartile (selects the first quartile of all non-NODATA contributing pixels)
@ RA_Min
Minimum (selects the minimum of all non-NODATA contributing pixels)
@ RA_Median
Median (selects the median of all non-NODATA contributing pixels)
@ RA_NearestNeighbour
Nearest neighbour (select on one input pixel)
@ RA_Average
Average (computes the average of all non-NODATA contributing pixels)
@ RA_Max
Maximum (selects the maximum of all non-NODATA contributing pixels)
@ RA_Bilinear
Bilinear (2x2 kernel)
@ RA_Mode
Mode (selects the value which appears most often of all the sampled points)
@ RA_Cubic
Cubic Convolution Approximation (4x4 kernel)
QFlags< ProcessingAlgorithmFlag > ProcessingAlgorithmFlags
Flags indicating how and when an algorithm operates and should be exposed to users.
Definition qgis.h:3076
@ PreferredGdal
Preferred format for conversion of CRS to WKT for use with the GDAL library.
@ HideFromToolbox
Algorithm should be hidden from the toolbox.
QgsAlignRaster takes one or more raster layers and warps (resamples) them so they have the same:
bool setParametersFromRaster(const RasterInfo &rasterInfo, const QString &customCRSWkt=QString(), QSizeF customCellSize=QSizeF(), QPointF customGridOffset=QPointF(-1, -1))
Set destination CRS, cell size and grid offset from a raster file.
bool run()
Run the alignment process.
void setClipExtent(double xmin, double ymin, double xmax, double ymax)
Configure clipping extent (region of interest).
void setProgressHandler(ProgressHandler *progressHandler)
Assign a progress handler instance. Does not take ownership. nullptr can be passed.
QList< QgsAlignRasterData::RasterItem > List
QString errorMessage() const
Returns the error from a previous run() call.
void setRasters(const List &list)
Sets list of rasters that will be aligned.
This class represents a coordinate reference system (CRS).
QString toWkt(Qgis::CrsWktVariant variant=Qgis::CrsWktVariant::Wkt1Gdal, bool multiline=false, int indentationWidth=4) const
Returns a WKT representation of this CRS.
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition qgsfeedback.h:44
QString source() const
Returns the source for the layer.
virtual Qgis::ProcessingAlgorithmFlags flags() const
Returns the flags indicating how and when the algorithm operates and should be exposed to users.
Contains information about the context in which a processing algorithm is executed.
Custom exception class for processing related exceptions.
Base class for providing feedback from a processing algorithm.
A boolean parameter for processing algorithms.
A coordinate reference system parameter for processing algorithms.
An enum based parameter for processing algorithms, allowing for selection from predefined values.
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 ...
A raster layer parameter for processing algorithms.
Represents a raster layer.
A rectangle specified with double values.
const QgsCoordinateReferenceSystem & crs
Definition of one raster layer for alignment.
Helper struct to be sub-classed for progress reporting.
virtual bool progress(double complete)=0
Method to be overridden for progress reporting.