Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgspalettedrasterrenderer.cpp
3 : : -----------------------------
4 : : begin : December 2011
5 : : copyright : (C) 2011 by Marco Hugentobler
6 : : email : marco at sourcepole dot ch
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 "qgspalettedrasterrenderer.h"
19 : : #include "qgsrastertransparency.h"
20 : : #include "qgsrasterviewport.h"
21 : : #include "qgssymbollayerutils.h"
22 : : #include "qgsstyleentityvisitor.h"
23 : : #include "qgsmessagelog.h"
24 : : #include "qgsrasteriterator.h"
25 : : #include "qgslayertreemodellegendnode.h"
26 : :
27 : : #include <QColor>
28 : : #include <QDomDocument>
29 : : #include <QDomElement>
30 : : #include <QImage>
31 : : #include <QVector>
32 : : #include <memory>
33 : : #include <set>
34 : : #include <QRegularExpression>
35 : : #include <QTextStream>
36 : :
37 : : const int QgsPalettedRasterRenderer::MAX_FLOAT_CLASSES = 65536;
38 : :
39 : 0 : QgsPalettedRasterRenderer::QgsPalettedRasterRenderer( QgsRasterInterface *input, int bandNumber, const ClassData &classes )
40 : 0 : : QgsRasterRenderer( input, QStringLiteral( "paletted" ) )
41 : 0 : , mBand( bandNumber )
42 : 0 : , mClassData( classes )
43 : 0 : {
44 : 0 : updateArrays();
45 : 0 : }
46 : :
47 : 0 : QgsPalettedRasterRenderer *QgsPalettedRasterRenderer::clone() const
48 : : {
49 : 0 : QgsPalettedRasterRenderer *renderer = new QgsPalettedRasterRenderer( nullptr, mBand, mClassData );
50 : 0 : if ( mSourceColorRamp )
51 : 0 : renderer->setSourceColorRamp( mSourceColorRamp->clone() );
52 : :
53 : 0 : renderer->copyCommonProperties( this );
54 : 0 : return renderer;
55 : 0 : }
56 : :
57 : 0 : QgsRasterRenderer *QgsPalettedRasterRenderer::create( const QDomElement &elem, QgsRasterInterface *input )
58 : : {
59 : 0 : if ( elem.isNull() )
60 : : {
61 : 0 : return nullptr;
62 : : }
63 : :
64 : 0 : int bandNumber = elem.attribute( QStringLiteral( "band" ), QStringLiteral( "-1" ) ).toInt();
65 : 0 : ClassData classData;
66 : :
67 : 0 : QDomElement paletteElem = elem.firstChildElement( QStringLiteral( "colorPalette" ) );
68 : 0 : if ( !paletteElem.isNull() )
69 : : {
70 : 0 : QDomNodeList paletteEntries = paletteElem.elementsByTagName( QStringLiteral( "paletteEntry" ) );
71 : :
72 : 0 : QDomElement entryElem;
73 : : double value;
74 : :
75 : 0 : for ( int i = 0; i < paletteEntries.size(); ++i )
76 : : {
77 : 0 : QColor color;
78 : 0 : QString label;
79 : 0 : entryElem = paletteEntries.at( i ).toElement();
80 : 0 : value = entryElem.attribute( QStringLiteral( "value" ), QStringLiteral( "0" ) ).toDouble();
81 : 0 : color = QColor( entryElem.attribute( QStringLiteral( "color" ), QStringLiteral( "#000000" ) ) );
82 : 0 : color.setAlpha( entryElem.attribute( QStringLiteral( "alpha" ), QStringLiteral( "255" ) ).toInt() );
83 : 0 : label = entryElem.attribute( QStringLiteral( "label" ) );
84 : 0 : QgsDebugMsgLevel( QStringLiteral( "Value: %1, label: %2, color: %3" ).arg( value ).arg( label, entryElem.attribute( QStringLiteral( "color" ) ) ), 4 );
85 : 0 : classData << Class( value, color, label );
86 : 0 : }
87 : 0 : }
88 : :
89 : 0 : QgsPalettedRasterRenderer *r = new QgsPalettedRasterRenderer( input, bandNumber, classData );
90 : 0 : r->readXml( elem );
91 : :
92 : : // try to load color ramp (optional)
93 : 0 : QDomElement sourceColorRampElem = elem.firstChildElement( QStringLiteral( "colorramp" ) );
94 : 0 : if ( !sourceColorRampElem.isNull() && sourceColorRampElem.attribute( QStringLiteral( "name" ) ) == QLatin1String( "[source]" ) )
95 : : {
96 : 0 : r->setSourceColorRamp( QgsSymbolLayerUtils::loadColorRamp( sourceColorRampElem ) );
97 : 0 : }
98 : :
99 : 0 : return r;
100 : 0 : }
101 : :
102 : 0 : QgsPalettedRasterRenderer::ClassData QgsPalettedRasterRenderer::classes() const
103 : : {
104 : 0 : return mClassData;
105 : : }
106 : :
107 : 0 : QString QgsPalettedRasterRenderer::label( double idx ) const
108 : : {
109 : 0 : const auto constMClassData = mClassData;
110 : 0 : for ( const Class &c : constMClassData )
111 : : {
112 : 0 : if ( c.value == idx )
113 : 0 : return c.label;
114 : : }
115 : :
116 : 0 : return QString();
117 : 0 : }
118 : :
119 : 0 : void QgsPalettedRasterRenderer::setLabel( double idx, const QString &label )
120 : : {
121 : 0 : ClassData::iterator cIt = mClassData.begin();
122 : 0 : for ( ; cIt != mClassData.end(); ++cIt )
123 : : {
124 : 0 : if ( cIt->value == idx )
125 : : {
126 : 0 : cIt->label = label;
127 : 0 : return;
128 : : }
129 : 0 : }
130 : 0 : }
131 : :
132 : 0 : QgsRasterBlock *QgsPalettedRasterRenderer::block( int, QgsRectangle const &extent, int width, int height, QgsRasterBlockFeedback *feedback )
133 : : {
134 : 0 : std::unique_ptr< QgsRasterBlock > outputBlock( new QgsRasterBlock() );
135 : 0 : if ( !mInput || mClassData.isEmpty() )
136 : : {
137 : 0 : return outputBlock.release();
138 : : }
139 : :
140 : 0 : std::shared_ptr< QgsRasterBlock > inputBlock( mInput->block( mBand, extent, width, height, feedback ) );
141 : :
142 : 0 : if ( !inputBlock || inputBlock->isEmpty() )
143 : : {
144 : 0 : QgsDebugMsg( QStringLiteral( "No raster data!" ) );
145 : 0 : return outputBlock.release();
146 : : }
147 : :
148 : 0 : double currentOpacity = mOpacity;
149 : :
150 : : //rendering is faster without considering user-defined transparency
151 : 0 : bool hasTransparency = usesTransparency();
152 : :
153 : 0 : std::shared_ptr< QgsRasterBlock > alphaBlock;
154 : :
155 : 0 : if ( mAlphaBand > 0 && mAlphaBand != mBand )
156 : : {
157 : 0 : alphaBlock.reset( mInput->block( mAlphaBand, extent, width, height, feedback ) );
158 : 0 : if ( !alphaBlock || alphaBlock->isEmpty() )
159 : : {
160 : 0 : return outputBlock.release();
161 : : }
162 : 0 : }
163 : 0 : else if ( mAlphaBand == mBand )
164 : : {
165 : 0 : alphaBlock = inputBlock;
166 : 0 : }
167 : :
168 : 0 : if ( !outputBlock->reset( Qgis::ARGB32_Premultiplied, width, height ) )
169 : : {
170 : 0 : return outputBlock.release();
171 : : }
172 : :
173 : 0 : const QRgb myDefaultColor = renderColorForNodataPixel();
174 : :
175 : : //use direct data access instead of QgsRasterBlock::setValue
176 : : //because of performance
177 : : Q_ASSERT( outputBlock ); // to make cppcheck happy
178 : 0 : unsigned int *outputData = ( unsigned int * )( outputBlock->bits() );
179 : :
180 : 0 : qgssize rasterSize = ( qgssize )width * height;
181 : 0 : bool isNoData = false;
182 : 0 : for ( qgssize i = 0; i < rasterSize; ++i )
183 : : {
184 : 0 : const double value = inputBlock->valueAndNoData( i, isNoData );
185 : 0 : if ( isNoData )
186 : : {
187 : 0 : outputData[i] = myDefaultColor;
188 : 0 : continue;
189 : : }
190 : 0 : if ( !mColors.contains( value ) )
191 : : {
192 : 0 : outputData[i] = myDefaultColor;
193 : 0 : continue;
194 : : }
195 : :
196 : 0 : if ( !hasTransparency )
197 : : {
198 : 0 : outputData[i] = mColors.value( value );
199 : 0 : }
200 : : else
201 : : {
202 : 0 : currentOpacity = mOpacity;
203 : 0 : if ( mRasterTransparency )
204 : : {
205 : 0 : currentOpacity = mRasterTransparency->alphaValue( value, mOpacity * 255 ) / 255.0;
206 : 0 : }
207 : 0 : if ( mAlphaBand > 0 )
208 : : {
209 : 0 : currentOpacity *= alphaBlock->value( i ) / 255.0;
210 : 0 : }
211 : :
212 : 0 : QRgb c = mColors.value( value );
213 : 0 : outputData[i] = qRgba( currentOpacity * qRed( c ), currentOpacity * qGreen( c ), currentOpacity * qBlue( c ), currentOpacity * qAlpha( c ) );
214 : : }
215 : 0 : }
216 : :
217 : 0 : return outputBlock.release();
218 : 0 : }
219 : :
220 : 0 : void QgsPalettedRasterRenderer::writeXml( QDomDocument &doc, QDomElement &parentElem ) const
221 : : {
222 : 0 : if ( parentElem.isNull() )
223 : : {
224 : 0 : return;
225 : : }
226 : :
227 : 0 : QDomElement rasterRendererElem = doc.createElement( QStringLiteral( "rasterrenderer" ) );
228 : 0 : _writeXml( doc, rasterRendererElem );
229 : :
230 : 0 : rasterRendererElem.setAttribute( QStringLiteral( "band" ), mBand );
231 : 0 : QDomElement colorPaletteElem = doc.createElement( QStringLiteral( "colorPalette" ) );
232 : 0 : ClassData::const_iterator it = mClassData.constBegin();
233 : 0 : for ( ; it != mClassData.constEnd(); ++it )
234 : : {
235 : 0 : QColor color = it->color;
236 : 0 : QDomElement colorElem = doc.createElement( QStringLiteral( "paletteEntry" ) );
237 : 0 : colorElem.setAttribute( QStringLiteral( "value" ), it->value );
238 : 0 : colorElem.setAttribute( QStringLiteral( "color" ), color.name() );
239 : 0 : colorElem.setAttribute( QStringLiteral( "alpha" ), color.alpha() );
240 : 0 : if ( !it->label.isEmpty() )
241 : : {
242 : 0 : colorElem.setAttribute( QStringLiteral( "label" ), it->label );
243 : 0 : }
244 : 0 : colorPaletteElem.appendChild( colorElem );
245 : 0 : }
246 : 0 : rasterRendererElem.appendChild( colorPaletteElem );
247 : :
248 : : // save source color ramp
249 : 0 : if ( mSourceColorRamp )
250 : : {
251 : 0 : QDomElement colorRampElem = QgsSymbolLayerUtils::saveColorRamp( QStringLiteral( "[source]" ), mSourceColorRamp.get(), doc );
252 : 0 : rasterRendererElem.appendChild( colorRampElem );
253 : 0 : }
254 : :
255 : 0 : parentElem.appendChild( rasterRendererElem );
256 : 0 : }
257 : :
258 : 0 : void QgsPalettedRasterRenderer::toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const
259 : : {
260 : : // create base structure
261 : 0 : QgsRasterRenderer::toSld( doc, element, props );
262 : :
263 : : // look for RasterSymbolizer tag
264 : 0 : QDomNodeList elements = element.elementsByTagName( QStringLiteral( "sld:RasterSymbolizer" ) );
265 : 0 : if ( elements.size() == 0 )
266 : 0 : return;
267 : :
268 : : // there SHOULD be only one
269 : 0 : QDomElement rasterSymbolizerElem = elements.at( 0 ).toElement();
270 : :
271 : : // add Channel Selection tags
272 : 0 : QDomElement channelSelectionElem = doc.createElement( QStringLiteral( "sld:ChannelSelection" ) );
273 : 0 : rasterSymbolizerElem.appendChild( channelSelectionElem );
274 : :
275 : : // for the mapped band
276 : 0 : QDomElement channelElem = doc.createElement( QStringLiteral( "sld:GrayChannel" ) );
277 : 0 : channelSelectionElem.appendChild( channelElem );
278 : :
279 : : // set band
280 : 0 : QDomElement sourceChannelNameElem = doc.createElement( QStringLiteral( "sld:SourceChannelName" ) );
281 : 0 : sourceChannelNameElem.appendChild( doc.createTextNode( QString::number( band() ) ) );
282 : 0 : channelElem.appendChild( sourceChannelNameElem );
283 : :
284 : : // add ColorMap tag
285 : 0 : QDomElement colorMapElem = doc.createElement( QStringLiteral( "sld:ColorMap" ) );
286 : 0 : colorMapElem.setAttribute( QStringLiteral( "type" ), QStringLiteral( "values" ) );
287 : 0 : if ( this->classes().size() >= 255 )
288 : 0 : colorMapElem.setAttribute( QStringLiteral( "extended" ), QStringLiteral( "true" ) );
289 : 0 : rasterSymbolizerElem.appendChild( colorMapElem );
290 : :
291 : : // for each color set a ColorMapEntry tag nested into "sld:ColorMap" tag
292 : : // e.g. <ColorMapEntry color="#EEBE2F" quantity="-300" label="label" opacity="0"/>
293 : 0 : QList<QgsPalettedRasterRenderer::Class> classes = this->classes();
294 : 0 : QList<QgsPalettedRasterRenderer::Class>::const_iterator classDataIt = classes.constBegin();
295 : 0 : for ( ; classDataIt != classes.constEnd(); ++classDataIt )
296 : : {
297 : 0 : QDomElement colorMapEntryElem = doc.createElement( QStringLiteral( "sld:ColorMapEntry" ) );
298 : 0 : colorMapElem.appendChild( colorMapEntryElem );
299 : :
300 : : // set colorMapEntryElem attributes
301 : 0 : colorMapEntryElem.setAttribute( QStringLiteral( "color" ), classDataIt->color.name() );
302 : 0 : colorMapEntryElem.setAttribute( QStringLiteral( "quantity" ), QString::number( classDataIt->value ) );
303 : 0 : colorMapEntryElem.setAttribute( QStringLiteral( "label" ), classDataIt->label );
304 : 0 : if ( classDataIt->color.alphaF() != 1.0 )
305 : : {
306 : 0 : colorMapEntryElem.setAttribute( QStringLiteral( "opacity" ), QString::number( classDataIt->color.alphaF() ) );
307 : 0 : }
308 : 0 : }
309 : 0 : }
310 : :
311 : 0 : bool QgsPalettedRasterRenderer::accept( QgsStyleEntityVisitorInterface *visitor ) const
312 : : {
313 : 0 : if ( mSourceColorRamp )
314 : : {
315 : 0 : QgsStyleColorRampEntity entity( mSourceColorRamp.get() );
316 : 0 : if ( !visitor->visit( QgsStyleEntityVisitorInterface::StyleLeaf( &entity ) ) )
317 : 0 : return false;
318 : 0 : }
319 : :
320 : 0 : return true;
321 : 0 : }
322 : :
323 : 0 : QList< QPair< QString, QColor > > QgsPalettedRasterRenderer::legendSymbologyItems() const
324 : : {
325 : 0 : QList< QPair< QString, QColor > > symbolItems;
326 : 0 : for ( const QgsPalettedRasterRenderer::Class &classData : mClassData )
327 : : {
328 : 0 : const QString lab = classData.label.isEmpty() ? QString::number( classData.value ) : classData.label;
329 : 0 : symbolItems << qMakePair( lab, classData.color );
330 : 0 : }
331 : 0 : return symbolItems;
332 : 0 : }
333 : :
334 : :
335 : 0 : QList<QgsLayerTreeModelLegendNode *> QgsPalettedRasterRenderer::createLegendNodes( QgsLayerTreeLayer *nodeLayer )
336 : : {
337 : 0 : QList<QgsLayerTreeModelLegendNode *> res;
338 : :
339 : 0 : const QString name = displayBandName( mBand );
340 : 0 : if ( !name.isEmpty() )
341 : : {
342 : 0 : res << new QgsSimpleLegendNode( nodeLayer, name );
343 : 0 : }
344 : :
345 : 0 : const QList< QPair< QString, QColor > > items = legendSymbologyItems();
346 : 0 : res.reserve( res.size() + items.size() );
347 : 0 : for ( const QPair< QString, QColor > &item : items )
348 : : {
349 : 0 : res << new QgsRasterSymbolLegendNode( nodeLayer, item.second, item.first );
350 : : }
351 : :
352 : 0 : return res;
353 : 0 : }
354 : :
355 : :
356 : 0 : QList<int> QgsPalettedRasterRenderer::usesBands() const
357 : : {
358 : 0 : QList<int> bandList;
359 : 0 : if ( mBand != -1 )
360 : : {
361 : 0 : bandList << mBand;
362 : 0 : }
363 : 0 : return bandList;
364 : 0 : }
365 : :
366 : 0 : void QgsPalettedRasterRenderer::setSourceColorRamp( QgsColorRamp *ramp )
367 : : {
368 : 0 : mSourceColorRamp.reset( ramp );
369 : 0 : }
370 : :
371 : 0 : QgsColorRamp *QgsPalettedRasterRenderer::sourceColorRamp() const
372 : : {
373 : 0 : return mSourceColorRamp.get();
374 : : }
375 : :
376 : 0 : QgsPalettedRasterRenderer::ClassData QgsPalettedRasterRenderer::colorTableToClassData( const QList<QgsColorRampShader::ColorRampItem> &table )
377 : : {
378 : 0 : QList<QgsColorRampShader::ColorRampItem>::const_iterator colorIt = table.constBegin();
379 : 0 : QgsPalettedRasterRenderer::ClassData classes;
380 : 0 : for ( ; colorIt != table.constEnd(); ++colorIt )
381 : : {
382 : 0 : classes << QgsPalettedRasterRenderer::Class( colorIt->value, colorIt->color, colorIt->label );
383 : 0 : }
384 : 0 : return classes;
385 : 0 : }
386 : :
387 : 0 : QgsPalettedRasterRenderer::ClassData QgsPalettedRasterRenderer::classDataFromString( const QString &string )
388 : : {
389 : 0 : QgsPalettedRasterRenderer::ClassData classes;
390 : :
391 : 0 : QRegularExpression linePartRx( QStringLiteral( "[\\s,:]+" ) );
392 : :
393 : : #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
394 : : const QStringList parts = string.split( '\n', QString::SkipEmptyParts );
395 : : #else
396 : 0 : const QStringList parts = string.split( '\n', Qt::SkipEmptyParts );
397 : : #endif
398 : 0 : for ( const QString &part : parts )
399 : : {
400 : : #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
401 : : const QStringList lineParts = part.split( linePartRx, QString::SkipEmptyParts );
402 : : #else
403 : 0 : const QStringList lineParts = part.split( linePartRx, Qt::SkipEmptyParts );
404 : : #endif
405 : 0 : bool ok = false;
406 : 0 : switch ( lineParts.count() )
407 : : {
408 : : case 1:
409 : : {
410 : 0 : int value = lineParts.at( 0 ).toInt( &ok );
411 : 0 : if ( !ok )
412 : 0 : continue;
413 : :
414 : 0 : classes << Class( value );
415 : 0 : break;
416 : : }
417 : :
418 : : case 2:
419 : : {
420 : 0 : int value = lineParts.at( 0 ).toInt( &ok );
421 : 0 : if ( !ok )
422 : 0 : continue;
423 : :
424 : 0 : QColor c( lineParts.at( 1 ) );
425 : :
426 : 0 : classes << Class( value, c );
427 : 0 : break;
428 : : }
429 : :
430 : : default:
431 : : {
432 : 0 : if ( lineParts.count() < 4 )
433 : 0 : continue;
434 : :
435 : 0 : int value = lineParts.at( 0 ).toInt( &ok );
436 : 0 : if ( !ok )
437 : 0 : continue;
438 : :
439 : 0 : bool rOk = false;
440 : 0 : double r = lineParts.at( 1 ).toDouble( &rOk );
441 : 0 : bool gOk = false;
442 : 0 : double g = lineParts.at( 2 ).toDouble( &gOk );
443 : 0 : bool bOk = false;
444 : 0 : double b = lineParts.at( 3 ).toDouble( &bOk );
445 : :
446 : 0 : QColor c;
447 : 0 : if ( rOk && gOk && bOk )
448 : : {
449 : 0 : c = QColor( r, g, b );
450 : 0 : }
451 : :
452 : 0 : if ( lineParts.count() >= 5 )
453 : : {
454 : 0 : double alpha = lineParts.at( 4 ).toDouble( &ok );
455 : 0 : if ( ok )
456 : 0 : c.setAlpha( alpha );
457 : 0 : }
458 : :
459 : 0 : QString label;
460 : 0 : if ( lineParts.count() > 5 )
461 : : {
462 : 0 : label = lineParts.mid( 5 ).join( ' ' );
463 : 0 : }
464 : :
465 : 0 : classes << Class( value, c, label );
466 : : break;
467 : 0 : }
468 : : }
469 : :
470 : 0 : }
471 : 0 : return classes;
472 : 0 : }
473 : :
474 : 0 : QgsPalettedRasterRenderer::ClassData QgsPalettedRasterRenderer::classDataFromFile( const QString &path )
475 : : {
476 : 0 : QFile inputFile( path );
477 : 0 : QString input;
478 : 0 : if ( inputFile.open( QIODevice::ReadOnly ) )
479 : : {
480 : 0 : QTextStream in( &inputFile );
481 : 0 : input = in.readAll();
482 : 0 : inputFile.close();
483 : 0 : }
484 : 0 : return classDataFromString( input );
485 : 0 : }
486 : :
487 : 0 : QString QgsPalettedRasterRenderer::classDataToString( const QgsPalettedRasterRenderer::ClassData &classes )
488 : : {
489 : 0 : QStringList out;
490 : : // must be sorted
491 : 0 : QgsPalettedRasterRenderer::ClassData cd = classes;
492 : 0 : std::sort( cd.begin(), cd.end(), []( const Class & a, const Class & b ) -> bool
493 : : {
494 : 0 : return a.value < b.value;
495 : : } );
496 : :
497 : 0 : const auto constCd = cd;
498 : 0 : for ( const Class &c : constCd )
499 : : {
500 : 0 : out << QStringLiteral( "%1 %2 %3 %4 %5 %6" ).arg( c.value ).arg( c.color.red() )
501 : 0 : .arg( c.color.green() ).arg( c.color.blue() ).arg( c.color.alpha() ).arg( c.label );
502 : : }
503 : 0 : return out.join( '\n' );
504 : 0 : }
505 : :
506 : 0 : QgsPalettedRasterRenderer::ClassData QgsPalettedRasterRenderer::classDataFromRaster( QgsRasterInterface *raster, int bandNumber, QgsColorRamp *ramp, QgsRasterBlockFeedback *feedback )
507 : : {
508 : 0 : if ( !raster )
509 : 0 : return ClassData();
510 : :
511 : 0 : ClassData data;
512 : 0 : qlonglong numClasses = 0;
513 : :
514 : 0 : if ( feedback )
515 : 0 : feedback->setProgress( 0 );
516 : :
517 : : // Collect unique values for float rasters
518 : 0 : if ( raster->dataType( bandNumber ) == Qgis::DataType::Float32 || raster->dataType( bandNumber ) == Qgis::DataType::Float64 )
519 : : {
520 : :
521 : 0 : if ( feedback && feedback->isCanceled() )
522 : : {
523 : 0 : return data;
524 : : }
525 : :
526 : 0 : std::set<double> values;
527 : :
528 : 0 : int maxWidth = QgsRasterIterator::DEFAULT_MAXIMUM_TILE_WIDTH;
529 : 0 : int maxHeight = QgsRasterIterator::DEFAULT_MAXIMUM_TILE_HEIGHT;
530 : :
531 : 0 : QgsRasterIterator iter( raster );
532 : 0 : iter.startRasterRead( bandNumber, raster->xSize(), raster->ySize(), raster->extent(), feedback );
533 : :
534 : 0 : int nbBlocksWidth = static_cast< int >( std::ceil( 1.0 * raster->xSize() / maxWidth ) );
535 : 0 : int nbBlocksHeight = static_cast< int >( std::ceil( 1.0 * raster->ySize() / maxHeight ) );
536 : 0 : int nbBlocks = nbBlocksWidth * nbBlocksHeight;
537 : :
538 : 0 : int iterLeft = 0;
539 : 0 : int iterTop = 0;
540 : 0 : int iterCols = 0;
541 : 0 : int iterRows = 0;
542 : 0 : std::unique_ptr< QgsRasterBlock > rasterBlock;
543 : 0 : QgsRectangle blockExtent;
544 : 0 : bool isNoData = false;
545 : 0 : while ( iter.readNextRasterPart( bandNumber, iterCols, iterRows, rasterBlock, iterLeft, iterTop, &blockExtent ) )
546 : : {
547 : 0 : if ( feedback )
548 : 0 : feedback->setProgress( 100 * ( ( iterTop / maxHeight * nbBlocksWidth ) + iterLeft / maxWidth ) / nbBlocks );
549 : :
550 : 0 : if ( feedback && feedback->isCanceled() )
551 : 0 : break;
552 : :
553 : 0 : for ( int row = 0; row < iterRows; row++ )
554 : : {
555 : 0 : if ( feedback && feedback->isCanceled() )
556 : 0 : break;
557 : :
558 : 0 : for ( int column = 0; column < iterCols; column++ )
559 : : {
560 : 0 : if ( feedback && feedback->isCanceled() )
561 : 0 : break;
562 : :
563 : 0 : const double currentValue = rasterBlock->valueAndNoData( row, column, isNoData );
564 : 0 : if ( numClasses >= MAX_FLOAT_CLASSES )
565 : : {
566 : 0 : QgsMessageLog::logMessage( QStringLiteral( "Number of classes exceeded maximum (%1)." ).arg( MAX_FLOAT_CLASSES ), QStringLiteral( "Raster" ) );
567 : 0 : break;
568 : : }
569 : 0 : if ( !isNoData && values.find( currentValue ) == values.end() )
570 : : {
571 : 0 : values.insert( currentValue );
572 : 0 : data.push_back( Class( currentValue, QColor(), QLocale().toString( currentValue ) ) );
573 : 0 : numClasses++;
574 : 0 : }
575 : 0 : }
576 : 0 : }
577 : : }
578 : : // must be sorted
579 : 0 : std::sort( data.begin(), data.end(), []( const Class & a, const Class & b ) -> bool
580 : : {
581 : 0 : return a.value < b.value;
582 : : } );
583 : 0 : }
584 : : else
585 : : {
586 : : // get min and max value from raster
587 : 0 : QgsRasterBandStats stats = raster->bandStatistics( bandNumber, QgsRasterBandStats::Min | QgsRasterBandStats::Max, QgsRectangle(), 0, feedback );
588 : 0 : if ( feedback && feedback->isCanceled() )
589 : 0 : return ClassData();
590 : :
591 : 0 : double min = stats.minimumValue;
592 : 0 : double max = stats.maximumValue;
593 : : // need count of every individual value
594 : 0 : int bins = std::ceil( max - min ) + 1;
595 : 0 : if ( bins <= 0 )
596 : 0 : return ClassData();
597 : :
598 : 0 : QgsRasterHistogram histogram = raster->histogram( bandNumber, bins, min, max, QgsRectangle(), 0, false, feedback );
599 : 0 : if ( feedback && feedback->isCanceled() )
600 : 0 : return ClassData();
601 : :
602 : 0 : double interval = ( histogram.maximum - histogram.minimum + 1 ) / histogram.binCount;
603 : 0 : double currentValue = histogram.minimum;
604 : 0 : for ( int idx = 0; idx < histogram.binCount; ++idx )
605 : : {
606 : 0 : int count = histogram.histogramVector.at( idx );
607 : 0 : if ( count > 0 )
608 : : {
609 : 0 : data << Class( currentValue, QColor(), QLocale().toString( currentValue ) );
610 : 0 : numClasses++;
611 : 0 : }
612 : 0 : currentValue += interval;
613 : 0 : }
614 : 0 : }
615 : :
616 : : // assign colors from ramp
617 : 0 : if ( ramp && numClasses > 0 )
618 : : {
619 : 0 : int i = 0;
620 : :
621 : 0 : if ( QgsRandomColorRamp *randomRamp = dynamic_cast<QgsRandomColorRamp *>( ramp ) )
622 : : {
623 : : //ramp is a random colors ramp, so inform it of the total number of required colors
624 : : //this allows the ramp to pregenerate a set of visually distinctive colors
625 : 0 : randomRamp->setTotalColorCount( data.count() );
626 : 0 : }
627 : :
628 : 0 : if ( numClasses > 1 )
629 : 0 : numClasses -= 1; //avoid duplicate first color
630 : :
631 : 0 : QgsPalettedRasterRenderer::ClassData::iterator cIt = data.begin();
632 : 0 : for ( ; cIt != data.end(); ++cIt )
633 : : {
634 : 0 : if ( feedback )
635 : : {
636 : : // Show no less than 1%, then the max between class fill and real progress
637 : 0 : feedback->setProgress( std::max<int>( 1, 100 * ( i + 1 ) / numClasses ) );
638 : 0 : }
639 : 0 : cIt->color = ramp->color( i / static_cast<double>( numClasses ) );
640 : 0 : i++;
641 : 0 : }
642 : 0 : }
643 : 0 : return data;
644 : 0 : }
645 : :
646 : 0 : void QgsPalettedRasterRenderer::updateArrays()
647 : : {
648 : 0 : mColors.clear();
649 : 0 : ClassData::const_iterator it = mClassData.constBegin();
650 : 0 : for ( ; it != mClassData.constEnd(); ++it )
651 : : {
652 : 0 : mColors[it->value] = qPremultiply( it->color.rgba() );
653 : 0 : }
654 : 0 : }
|
