QGIS API Documentation 3.34.0-Prizren (ffbdd678812)
Loading...
Searching...
No Matches
qgsrastertransparencywidget.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsrastertransparencywidget.cpp
3 ---------------------
4 begin : May 2016
5 copyright : (C) 2016 by Nathan Woodrow
6 email : woodrow dot nathan at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15#include <QWidget>
16#include <QIntValidator>
17#include <QFile>
18#include <QTextStream>
19#include <QMessageBox>
20#include <QFileDialog>
21#include <QRegularExpression>
22
23#include "qgssettings.h"
25#include "qgsrasterlayer.h"
28#include "qgsmaptoolemitpoint.h"
29#include "qgsmapsettings.h"
30#include "qgsrectangle.h"
31#include "qgsmapcanvas.h"
34#include "qgsdoublevalidator.h"
37
39 : QgsMapLayerConfigWidget( layer, canvas, parent )
40 , TRSTRING_NOT_SET( tr( "Not Set" ) )
41 , mRasterLayer( layer )
42 , mMapCanvas( canvas )
43{
44 setupUi( this );
45 connect( pbnAddValuesFromDisplay, &QToolButton::clicked, this, &QgsRasterTransparencyWidget::pbnAddValuesFromDisplay_clicked );
46 connect( pbnAddValuesManually, &QToolButton::clicked, this, &QgsRasterTransparencyWidget::pbnAddValuesManually_clicked );
47 connect( pbnDefaultValues, &QToolButton::clicked, this, &QgsRasterTransparencyWidget::pbnDefaultValues_clicked );
48 connect( pbnExportTransparentPixelValues, &QToolButton::clicked, this, &QgsRasterTransparencyWidget::pbnExportTransparentPixelValues_clicked );
49 connect( pbnImportTransparentPixelValues, &QToolButton::clicked, this, &QgsRasterTransparencyWidget::pbnImportTransparentPixelValues_clicked );
50 connect( pbnRemoveSelectedRow, &QToolButton::clicked, this, &QgsRasterTransparencyWidget::pbnRemoveSelectedRow_clicked );
51
52 mNodataColorButton->setShowNoColor( true );
53 mNodataColorButton->setColorDialogTitle( tr( "Select No Data Color" ) );
55
56 connect( mOpacityWidget, &QgsOpacityWidget::opacityChanged, this, &QgsPanelWidget::widgetChanged );
57 connect( cboxTransparencyBand, &QgsRasterBandComboBox::bandChanged, this, &QgsPanelWidget::widgetChanged );
58 connect( mSrcNoDataValueCheckBox, &QCheckBox::stateChanged, this, &QgsPanelWidget::widgetChanged );
59 connect( leNoDataValue, &QLineEdit::textEdited, this, &QgsPanelWidget::widgetChanged );
60 leNoDataValue->setValidator( new QgsDoubleValidator( std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max(), this ) );
61 connect( mNodataColorButton, &QgsColorButton::colorChanged, this, &QgsPanelWidget::widgetChanged );
62
63 mPixelSelectorTool = nullptr;
64 if ( mMapCanvas )
65 {
66 mPixelSelectorTool = new QgsMapToolEmitPoint( mMapCanvas );
67 connect( mPixelSelectorTool, &QgsMapToolEmitPoint::canvasClicked, this, &QgsRasterTransparencyWidget::pixelSelected );
68 }
69 else
70 {
71 pbnAddValuesFromDisplay->setEnabled( false );
72 }
73
75}
76
78{
79 mContext = context;
80}
81
83{
84 QgsExpressionContext expContext;
88
89 if ( QgsMapCanvas *canvas = mContext.mapCanvas() )
90 {
91 expContext << QgsExpressionContextUtils::mapSettingsScope( canvas->mapSettings() )
92 << new QgsExpressionContextScope( canvas->expressionContextScope() );
93 if ( const QgsExpressionContextScopeGenerator *generator = dynamic_cast< const QgsExpressionContextScopeGenerator * >( canvas->temporalController() ) )
94 {
95 expContext << generator->createExpressionContextScope();
96 }
97 }
98 else
99 {
101 }
102
103 if ( mRasterLayer )
104 expContext << QgsExpressionContextUtils::layerScope( mRasterLayer );
105
106 // additional scopes
107 const auto constAdditionalExpressionContextScopes = mContext.additionalExpressionContextScopes();
108 for ( const QgsExpressionContextScope &scope : constAdditionalExpressionContextScopes )
109 {
110 expContext.appendScope( new QgsExpressionContextScope( scope ) );
111 }
112
113 return expContext;
114}
115
117{
118 QgsRasterDataProvider *provider = mRasterLayer->dataProvider();
119 QgsRasterRenderer *renderer = mRasterLayer->renderer();
120 if ( provider )
121 {
122 if ( provider->dataType( 1 ) == Qgis::DataType::ARGB32
124 {
125 gboxNoDataValue->setEnabled( false );
126 gboxCustomTransparency->setEnabled( false );
127 }
128
129 cboxTransparencyBand->setShowNotSetOption( true, tr( "None" ) );
130 cboxTransparencyBand->setLayer( mRasterLayer );
131 if ( provider->sourceHasNoDataValue( 1 ) )
132 {
133 lblSrcNoDataValue->setText( QgsRasterBlock::printValue( provider->sourceNoDataValue( 1 ) ) );
134 }
135 else
136 {
137 lblSrcNoDataValue->setText( tr( "not defined" ) );
138 }
139
140 mSrcNoDataValueCheckBox->setChecked( provider->useSourceNoDataValue( 1 ) );
141
142 const bool enableSrcNoData = provider->sourceHasNoDataValue( 1 ) && !std::isnan( provider->sourceNoDataValue( 1 ) );
143
144 mSrcNoDataValueCheckBox->setEnabled( enableSrcNoData );
145 lblSrcNoDataValue->setEnabled( enableSrcNoData );
146 }
147
148 if ( renderer )
149 {
150 if ( renderer->nodataColor().isValid() )
151 mNodataColorButton->setColor( renderer->nodataColor() );
152 else
153 mNodataColorButton->setToNull();
154
155 mOpacityWidget->setOpacity( renderer->opacity() );
156
157 cboxTransparencyBand->setBand( renderer->alphaBand() );
158 }
159
160 if ( provider )
161 {
162 const QgsRasterRangeList noDataRangeList = provider->userNoDataValues( 1 );
163 QgsDebugMsgLevel( QStringLiteral( "noDataRangeList.size = %1" ).arg( noDataRangeList.size() ), 2 );
164 if ( !noDataRangeList.isEmpty() )
165 {
166 const double v = QgsRasterBlock::printValue( noDataRangeList.value( 0 ).min() ).toDouble();
167 leNoDataValue->setText( QLocale().toString( v ) );
168 }
169 else
170 {
171 leNoDataValue->setText( QString() );
172 }
173 }
174 else
175 {
176 leNoDataValue->setText( QString() );
177 }
178
181
182 populateTransparencyTable( mRasterLayer->renderer() );
183}
184
185void QgsRasterTransparencyWidget::transparencyCellTextEdited( const QString &text )
186{
187 Q_UNUSED( text )
188 QgsDebugMsgLevel( QStringLiteral( "text = %1" ).arg( text ), 2 );
189 QgsRasterRenderer *renderer = mRasterLayer->renderer();
190 if ( !renderer )
191 {
192 return;
193 }
194 const int nBands = renderer->usesBands().size();
195 if ( nBands == 1 )
196 {
197 QLineEdit *lineEdit = qobject_cast<QLineEdit *>( sender() );
198 if ( !lineEdit ) return;
199 int row = -1;
200 int column = -1;
201 for ( int r = 0; r < tableTransparency->rowCount(); r++ )
202 {
203 for ( int c = 0; c < tableTransparency->columnCount(); c++ )
204 {
205 if ( tableTransparency->cellWidget( r, c ) == sender() )
206 {
207 row = r;
208 column = c;
209 break;
210 }
211 }
212 if ( row != -1 ) break;
213 }
214 QgsDebugMsgLevel( QStringLiteral( "row = %1 column =%2" ).arg( row ).arg( column ), 2 );
215
216 if ( column == 0 )
217 {
218 QLineEdit *toLineEdit = dynamic_cast<QLineEdit *>( tableTransparency->cellWidget( row, 1 ) );
219 if ( !toLineEdit ) return;
220 const bool toChanged = mTransparencyToEdited.value( row );
221 QgsDebugMsgLevel( QStringLiteral( "toChanged = %1" ).arg( toChanged ), 2 );
222 if ( !toChanged )
223 {
224 toLineEdit->setText( lineEdit->text() );
225 }
226 }
227 else if ( column == 1 )
228 {
229 setTransparencyToEdited( row );
230 }
231 }
232 emit widgetChanged();
233}
234
235void QgsRasterTransparencyWidget::pbnAddValuesFromDisplay_clicked()
236{
237 if ( mMapCanvas && mPixelSelectorTool )
238 {
239 mMapCanvas->setMapTool( mPixelSelectorTool );
240 }
241}
242
243void QgsRasterTransparencyWidget::pbnAddValuesManually_clicked()
244{
245 QgsRasterRenderer *renderer = mRasterLayer->renderer();
246 if ( !renderer )
247 {
248 return;
249 }
250
251 tableTransparency->insertRow( tableTransparency->rowCount() );
252
253 int n = renderer->usesBands().size();
254 if ( n == 1 ) n++;
255
256 for ( int i = 0; i < n; i++ )
257 {
258 setTransparencyCell( tableTransparency->rowCount() - 1, i, std::numeric_limits<double>::quiet_NaN() );
259 }
260
261 setTransparencyCell( tableTransparency->rowCount() - 1, n, 100 );
262
263 //tableTransparency->resizeColumnsToContents();
264 //tableTransparency->resizeRowsToContents();
265}
266
267void QgsRasterTransparencyWidget::pbnDefaultValues_clicked()
268{
269 QgsRasterRenderer *r = mRasterLayer->renderer();
270 if ( !r )
271 {
272 return;
273 }
274
275 const int nBands = r->usesBands().size();
276
277 setupTransparencyTable( nBands );
278
279 //tableTransparency->resizeColumnsToContents(); // works only with values
280 //tableTransparency->resizeRowsToContents();
281
282}
283
284void QgsRasterTransparencyWidget::pbnExportTransparentPixelValues_clicked()
285{
286 const QgsSettings myQSettings;
287 const QString myLastDir = myQSettings.value( QStringLiteral( "lastRasterFileFilterDir" ), QDir::homePath() ).toString();
288 QString myFileName = QFileDialog::getSaveFileName( this, tr( "Save Pixel Values as File" ), myLastDir, tr( "Textfile" ) + " (*.txt)" );
289 if ( !myFileName.isEmpty() )
290 {
291 if ( !myFileName.endsWith( QLatin1String( ".txt" ), Qt::CaseInsensitive ) )
292 {
293 myFileName = myFileName + ".txt";
294 }
295
296 QFile myOutputFile( myFileName );
297 if ( myOutputFile.open( QFile::WriteOnly | QIODevice::Truncate ) )
298 {
299 QTextStream myOutputStream( &myOutputFile );
300 myOutputStream << "# " << tr( "QGIS Generated Transparent Pixel Value Export File" ) << '\n';
301 if ( rasterIsMultiBandColor() )
302 {
303 myOutputStream << "#\n#\n# " << tr( "Red" ) << "\t" << tr( "Green" ) << "\t" << tr( "Blue" ) << "\t" << tr( "Percent Transparent" );
304 for ( int myTableRunner = 0; myTableRunner < tableTransparency->rowCount(); myTableRunner++ )
305 {
306 myOutputStream << '\n' << QString::number( transparencyCellValue( myTableRunner, 0 ) ) << "\t"
307 << QString::number( transparencyCellValue( myTableRunner, 1 ) ) << "\t"
308 << QString::number( transparencyCellValue( myTableRunner, 2 ) ) << "\t"
309 << QString::number( transparencyCellValue( myTableRunner, 3 ) );
310 }
311 }
312 else
313 {
314 myOutputStream << "#\n#\n# " << tr( "Value" ) << "\t" << tr( "Percent Transparent" );
315
316 for ( int myTableRunner = 0; myTableRunner < tableTransparency->rowCount(); myTableRunner++ )
317 {
318 myOutputStream << '\n' << QString::number( transparencyCellValue( myTableRunner, 0 ) ) << "\t"
319 << QString::number( transparencyCellValue( myTableRunner, 1 ) ) << "\t"
320 << QString::number( transparencyCellValue( myTableRunner, 2 ) );
321 }
322 }
323 }
324 else
325 {
326 QMessageBox::warning( this, tr( "Save Pixel Values as File" ), tr( "Write access denied. Adjust the file permissions and try again.\n\n" ) );
327 }
328 }
329}
330
331void QgsRasterTransparencyWidget::pbnImportTransparentPixelValues_clicked()
332{
333 int myLineCounter = 0;
334 bool myImportError = false;
335 QString myBadLines;
336 const QgsSettings myQSettings;
337 const QString myLastDir = myQSettings.value( QStringLiteral( "lastRasterFileFilterDir" ), QDir::homePath() ).toString();
338 const QString myFileName = QFileDialog::getOpenFileName( this, tr( "Load Pixel Values from File" ), myLastDir, tr( "Textfile" ) + " (*.txt)" );
339 QFile myInputFile( myFileName );
340 if ( myInputFile.open( QFile::ReadOnly ) )
341 {
342 QTextStream myInputStream( &myInputFile );
343 QString myInputLine;
344 if ( rasterIsMultiBandColor() )
345 {
346 for ( int myTableRunner = tableTransparency->rowCount() - 1; myTableRunner >= 0; myTableRunner-- )
347 {
348 tableTransparency->removeRow( myTableRunner );
349 }
350
351 while ( !myInputStream.atEnd() )
352 {
353 myLineCounter++;
354 myInputLine = myInputStream.readLine();
355 if ( !myInputLine.isEmpty() )
356 {
357 if ( !myInputLine.simplified().startsWith( '#' ) )
358 {
359#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
360 QStringList myTokens = myInputLine.split( QRegExp( "\\s+" ), QString::SkipEmptyParts );
361#else
362 QStringList myTokens = myInputLine.split( QRegularExpression( "\\s+" ), Qt::SkipEmptyParts );
363#endif
364 if ( myTokens.count() != 4 )
365 {
366 myImportError = true;
367 myBadLines = myBadLines + QString::number( myLineCounter ) + ":\t[" + myInputLine + "]\n";
368 }
369 else
370 {
371 tableTransparency->insertRow( tableTransparency->rowCount() );
372 for ( int col = 0; col < 4; col++ )
373 {
374 setTransparencyCell( tableTransparency->rowCount() - 1, col, myTokens[col].toDouble() );
375 }
376 }
377 }
378 }
379 }
380 }
381 else
382 {
383 for ( int myTableRunner = tableTransparency->rowCount() - 1; myTableRunner >= 0; myTableRunner-- )
384 {
385 tableTransparency->removeRow( myTableRunner );
386 }
387
388 while ( !myInputStream.atEnd() )
389 {
390 myLineCounter++;
391 myInputLine = myInputStream.readLine();
392 if ( !myInputLine.isEmpty() )
393 {
394 if ( !myInputLine.simplified().startsWith( '#' ) )
395 {
396#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
397 QStringList myTokens = myInputLine.split( QRegExp( "\\s+" ), QString::SkipEmptyParts );
398#else
399 QStringList myTokens = myInputLine.split( QRegularExpression( "\\s+" ), Qt::SkipEmptyParts );
400#endif
401 if ( myTokens.count() != 3 && myTokens.count() != 2 ) // 2 for QGIS < 1.9 compatibility
402 {
403 myImportError = true;
404 myBadLines = myBadLines + QString::number( myLineCounter ) + ":\t[" + myInputLine + "]\n";
405 }
406 else
407 {
408 if ( myTokens.count() == 2 )
409 {
410 myTokens.insert( 1, myTokens[0] ); // add 'to' value, QGIS < 1.9 compatibility
411 }
412 tableTransparency->insertRow( tableTransparency->rowCount() );
413 for ( int col = 0; col < 3; col++ )
414 {
415 setTransparencyCell( tableTransparency->rowCount() - 1, col, myTokens[col].toDouble() );
416 }
417 }
418 }
419 }
420 }
421 }
422
423 if ( myImportError )
424 {
425 QMessageBox::warning( this, tr( "Load Pixel Values from File" ), tr( "The following lines contained errors\n\n%1" ).arg( myBadLines ) );
426 }
427 }
428 else if ( !myFileName.isEmpty() )
429 {
430 QMessageBox::warning( this, tr( "Load Pixel Values from File" ), tr( "Read access denied. Adjust the file permissions and try again.\n\n" ) );
431 }
432 //tableTransparency->resizeColumnsToContents();
433 //tableTransparency->resizeRowsToContents();
434 emit widgetChanged();
435}
436
437void QgsRasterTransparencyWidget::pbnRemoveSelectedRow_clicked()
438{
439 if ( 0 < tableTransparency->rowCount() )
440 {
441 tableTransparency->removeRow( tableTransparency->currentRow() );
442 }
443 emit widgetChanged();
444}
445
446bool QgsRasterTransparencyWidget::rasterIsMultiBandColor()
447{
448 return mRasterLayer && nullptr != dynamic_cast<QgsMultiBandColorRenderer *>( mRasterLayer->renderer() );
449}
450
452{
453 //set NoDataValue
454 QgsRasterRangeList myNoDataRangeList;
455 if ( "" != leNoDataValue->text() )
456 {
457 bool myDoubleOk = false;
458 const double myNoDataValue = QgsDoubleValidator::toDouble( leNoDataValue->text(), &myDoubleOk );
459 if ( myDoubleOk )
460 {
461 const QgsRasterRange myNoDataRange( myNoDataValue, myNoDataValue );
462 myNoDataRangeList << myNoDataRange;
463 }
464 }
465 if ( QgsRasterDataProvider *provider = mRasterLayer->dataProvider() )
466 {
467 for ( int bandNo = 1; bandNo <= provider->bandCount(); bandNo++ )
468 {
469 provider->setUserNoDataValue( bandNo, myNoDataRangeList );
470 provider->setUseSourceNoDataValue( bandNo, mSrcNoDataValueCheckBox->isChecked() );
471 }
472 }
473
474 //transparency settings
475 QgsRasterRenderer *rasterRenderer = mRasterLayer->renderer();
476 if ( rasterRenderer )
477 {
478 rasterRenderer->setAlphaBand( cboxTransparencyBand->currentBand() );
479 rasterRenderer->setNodataColor( mNodataColorButton->color() );
480
481 //Walk through each row in table and test value. If not valid set to 0.0 and continue building transparency list
482 QgsRasterTransparency *rasterTransparency = new QgsRasterTransparency();
483 if ( tableTransparency->columnCount() == 4 )
484 {
486 QList<QgsRasterTransparency::TransparentThreeValuePixel> myTransparentThreeValuePixelList;
487 myTransparentThreeValuePixelList.reserve( tableTransparency->rowCount() );
488 for ( int myListRunner = 0; myListRunner < tableTransparency->rowCount(); myListRunner++ )
489 {
490 myTransparentPixel.red = transparencyCellValue( myListRunner, 0 );
491 myTransparentPixel.green = transparencyCellValue( myListRunner, 1 );
492 myTransparentPixel.blue = transparencyCellValue( myListRunner, 2 );
493 myTransparentPixel.percentTransparent = transparencyCellValue( myListRunner, 3 );
494 myTransparentThreeValuePixelList.append( myTransparentPixel );
495 }
496 rasterTransparency->setTransparentThreeValuePixelList( myTransparentThreeValuePixelList );
497 }
498 else if ( tableTransparency->columnCount() == 3 )
499 {
501 QList<QgsRasterTransparency::TransparentSingleValuePixel> myTransparentSingleValuePixelList;
502 myTransparentSingleValuePixelList.reserve( tableTransparency->rowCount() );
503 for ( int myListRunner = 0; myListRunner < tableTransparency->rowCount(); myListRunner++ )
504 {
505 myTransparentPixel.min = transparencyCellValue( myListRunner, 0 );
506 myTransparentPixel.max = transparencyCellValue( myListRunner, 1 );
507 myTransparentPixel.percentTransparent = transparencyCellValue( myListRunner, 2 );
508
509 myTransparentSingleValuePixelList.append( myTransparentPixel );
510 }
511 rasterTransparency->setTransparentSingleValuePixelList( myTransparentSingleValuePixelList );
512 }
513
514 rasterRenderer->setRasterTransparency( rasterTransparency );
515
516 //set global transparency
517 rasterRenderer->setOpacity( mOpacityWidget->opacity() );
518 }
519
521}
522
524{
525 button->blockSignals( true );
527 connect( button, &QgsPropertyOverrideButton::changed, this, &QgsRasterTransparencyWidget::updateProperty );
529 button->blockSignals( false );
530}
531
533{
534 const auto propertyOverrideButtons { findChildren< QgsPropertyOverrideButton * >() };
535 for ( QgsPropertyOverrideButton *button : propertyOverrideButtons )
536 {
537 updateDataDefinedButton( button );
538 }
539}
540
542{
543 if ( !button )
544 return;
545
546 if ( button->propertyKey() < 0 )
547 return;
548
549 const QgsRasterPipe::Property key = static_cast< QgsRasterPipe::Property >( button->propertyKey() );
550 whileBlocking( button )->setToProperty( mPropertyCollection.property( key ) );
551}
552
553void QgsRasterTransparencyWidget::updateProperty()
554{
555 QgsPropertyOverrideButton *button = qobject_cast<QgsPropertyOverrideButton *>( sender() );
556 const QgsRasterPipe::Property key = static_cast< QgsRasterPipe::Property >( button->propertyKey() );
558 emit widgetChanged();
559}
560
561void QgsRasterTransparencyWidget::pixelSelected( const QgsPointXY &canvasPoint )
562{
563 QgsRasterRenderer *renderer = mRasterLayer->renderer();
564 if ( !renderer )
565 {
566 return;
567 }
568
569 //Get the pixel values and add a new entry to the transparency table
570 if ( mMapCanvas && mPixelSelectorTool && mRasterLayer->dataProvider() )
571 {
572 mMapCanvas->unsetMapTool( mPixelSelectorTool );
573
574 const QgsMapSettings &ms = mMapCanvas->mapSettings();
575 const QgsPointXY myPoint = ms.mapToLayerCoordinates( mRasterLayer, canvasPoint );
576
577 const QgsRectangle myExtent = ms.mapToLayerCoordinates( mRasterLayer, mMapCanvas->extent() );
578 const double mapUnitsPerPixel = mMapCanvas->mapUnitsPerPixel();
579 const int myWidth = mMapCanvas->extent().width() / mapUnitsPerPixel;
580 const int myHeight = mMapCanvas->extent().height() / mapUnitsPerPixel;
581
582 const QMap<int, QVariant> myPixelMap = mRasterLayer->dataProvider()->identify( myPoint, Qgis::RasterIdentifyFormat::Value, myExtent, myWidth, myHeight ).results();
583
584 const QList<int> bands = renderer->usesBands();
585
586 QList<double> values;
587 for ( int i = 0; i < bands.size(); ++i )
588 {
589 const int bandNo = bands.value( i );
590 if ( myPixelMap.count( bandNo ) == 1 )
591 {
592 if ( QgsVariantUtils::isNull( myPixelMap.value( bandNo ) ) )
593 {
594 return; // Don't add nodata, transparent anyway
595 }
596 const double value = myPixelMap.value( bandNo ).toDouble();
597 QgsDebugMsgLevel( QStringLiteral( "value = %1" ).arg( value, 0, 'g', 17 ), 2 );
598 values.append( value );
599 }
600 }
601 if ( bands.size() == 1 )
602 {
603 // Set 'to'
604 values.insert( 1, values.value( 0 ) );
605 }
606 tableTransparency->insertRow( tableTransparency->rowCount() );
607 for ( int i = 0; i < values.size(); i++ )
608 {
609 setTransparencyCell( tableTransparency->rowCount() - 1, i, values.value( i ) );
610 }
611 setTransparencyCell( tableTransparency->rowCount() - 1, tableTransparency->columnCount() - 1, 100 );
612 }
613
614 //tableTransparency->resizeColumnsToContents();
615 //tableTransparency->resizeRowsToContents();
616}
617
618void QgsRasterTransparencyWidget::populateTransparencyTable( QgsRasterRenderer *renderer )
619{
620 if ( !mRasterLayer )
621 {
622 return;
623 }
624
625 if ( !renderer )
626 {
627 return;
628 }
629
630 const int nBands = renderer->usesBands().size();
631 setupTransparencyTable( nBands );
632
633 const QgsRasterTransparency *rasterTransparency = renderer->rasterTransparency();
634 if ( !rasterTransparency )
635 {
636 return;
637 }
638
639 if ( nBands == 1 )
640 {
641 QList<QgsRasterTransparency::TransparentSingleValuePixel> pixelList = rasterTransparency->transparentSingleValuePixelList();
642 for ( int i = 0; i < pixelList.size(); ++i )
643 {
644 tableTransparency->insertRow( i );
645 setTransparencyCell( i, 0, pixelList[i].min );
646 setTransparencyCell( i, 1, pixelList[i].max );
647 setTransparencyCell( i, 2, pixelList[i].percentTransparent );
648 // break synchronization only if values differ
649 if ( pixelList[i].min != pixelList[i].max )
650 {
651 setTransparencyToEdited( i );
652 }
653 }
654 }
655 else if ( nBands == 3 )
656 {
657 QList<QgsRasterTransparency::TransparentThreeValuePixel> pixelList = rasterTransparency->transparentThreeValuePixelList();
658 for ( int i = 0; i < pixelList.size(); ++i )
659 {
660 tableTransparency->insertRow( i );
661 setTransparencyCell( i, 0, pixelList[i].red );
662 setTransparencyCell( i, 1, pixelList[i].green );
663 setTransparencyCell( i, 2, pixelList[i].blue );
664 setTransparencyCell( i, 3, pixelList[i].percentTransparent );
665 }
666 }
667
668 tableTransparency->resizeColumnsToContents();
669 tableTransparency->resizeRowsToContents();
670
671}
672
673void QgsRasterTransparencyWidget::setupTransparencyTable( int nBands )
674{
675 tableTransparency->clear();
676 tableTransparency->setColumnCount( 0 );
677 tableTransparency->setRowCount( 0 );
678 mTransparencyToEdited.clear();
679
680 if ( nBands == 3 )
681 {
682 tableTransparency->setColumnCount( 4 );
683 tableTransparency->setHorizontalHeaderItem( 0, new QTableWidgetItem( tr( "Red" ) ) );
684 tableTransparency->setHorizontalHeaderItem( 1, new QTableWidgetItem( tr( "Green" ) ) );
685 tableTransparency->setHorizontalHeaderItem( 2, new QTableWidgetItem( tr( "Blue" ) ) );
686 tableTransparency->setHorizontalHeaderItem( 3, new QTableWidgetItem( tr( "Percent Transparent" ) ) );
687 }
688 else //1 band
689 {
690 tableTransparency->setColumnCount( 3 );
691// Is it important to distinguish the header? It becomes difficult with range.
692#if 0
693 if ( QgsRasterLayer::PalettedColor != mRasterLayer->drawingStyle() &&
694 QgsRasterLayer::PalettedSingleBandGray != mRasterLayer->drawingStyle() &&
695 QgsRasterLayer::PalettedSingleBandPseudoColor != mRasterLayer->drawingStyle() &&
696 QgsRasterLayer::PalettedMultiBandColor != mRasterLayer->drawingStyle() )
697 {
698 tableTransparency->setHorizontalHeaderItem( 0, new QTableWidgetItem( tr( "Gray" ) ) );
699 }
700 else
701 {
702 tableTransparency->setHorizontalHeaderItem( 0, new QTableWidgetItem( tr( "Indexed Value" ) ) );
703 }
704#endif
705 tableTransparency->setHorizontalHeaderItem( 0, new QTableWidgetItem( tr( "From" ) ) );
706 tableTransparency->setHorizontalHeaderItem( 1, new QTableWidgetItem( tr( "To" ) ) );
707 tableTransparency->setHorizontalHeaderItem( 2, new QTableWidgetItem( tr( "Percent Transparent" ) ) );
708 }
709}
710
711void QgsRasterTransparencyWidget::setTransparencyCell( int row, int column, double value )
712{
713 QgsDebugMsgLevel( QStringLiteral( "value = %1" ).arg( value, 0, 'g', 17 ), 2 );
714 QgsRasterDataProvider *provider = mRasterLayer->dataProvider();
715 if ( !provider )
716 return;
717
718 QgsRasterRenderer *renderer = mRasterLayer->renderer();
719 if ( !renderer )
720 return;
721 const int nBands = renderer->usesBands().size();
722
723 QLineEdit *lineEdit = new QLineEdit();
724 lineEdit->setFrame( false ); // frame looks bad in table
725 // Without margins row selection is not displayed (important for delete row)
726 lineEdit->setContentsMargins( 1, 1, 1, 1 );
727
728 if ( column == tableTransparency->columnCount() - 1 )
729 {
730 // transparency
731 // Who needs transparency as floating point?
732 lineEdit->setValidator( new QIntValidator( nullptr ) );
733 lineEdit->setText( QString::number( static_cast<int>( value ) ) );
734 }
735 else
736 {
737 // value
738 QString valueString;
739 switch ( provider->sourceDataType( 1 ) )
740 {
743 lineEdit->setValidator( new QgsDoubleValidator( nullptr ) );
744 if ( !std::isnan( value ) )
745 {
746 const double v = QgsRasterBlock::printValue( value ).toDouble();
747 valueString = QLocale().toString( v );
748 }
749 break;
750 default:
751 lineEdit->setValidator( new QIntValidator( nullptr ) );
752 if ( !std::isnan( value ) )
753 {
754 valueString = QString::number( static_cast<int>( value ) );
755 }
756 break;
757 }
758 lineEdit->setText( valueString );
759 connect( lineEdit, &QLineEdit::textEdited, this, &QgsPanelWidget::widgetChanged );
760 }
761 tableTransparency->setCellWidget( row, column, lineEdit );
762 adjustTransparencyCellWidth( row, column );
763
764 if ( nBands == 1 && ( column == 0 || column == 1 ) )
765 {
766 connect( lineEdit, &QLineEdit::textEdited, this, &QgsRasterTransparencyWidget::transparencyCellTextEdited );
767 }
768 //tableTransparency->resizeColumnsToContents();
769 emit widgetChanged();
770}
771
772void QgsRasterTransparencyWidget::adjustTransparencyCellWidth( int row, int column )
773{
774 QLineEdit *lineEdit = dynamic_cast<QLineEdit *>( tableTransparency->cellWidget( row, column ) );
775 if ( !lineEdit ) return;
776
777 int width = std::max( lineEdit->fontMetrics().boundingRect( lineEdit->text() ).width() + 10, 100 );
778 width = std::max( width, tableTransparency->columnWidth( column ) );
779
780 lineEdit->setFixedWidth( width );
781}
782
783void QgsRasterTransparencyWidget::setTransparencyToEdited( int row )
784{
785 if ( row >= mTransparencyToEdited.size() )
786 {
787 mTransparencyToEdited.resize( row + 1 );
788 }
789 mTransparencyToEdited[row] = true;
790}
791
792double QgsRasterTransparencyWidget::transparencyCellValue( int row, int column )
793{
794 QLineEdit *lineEdit = dynamic_cast<QLineEdit *>( tableTransparency->cellWidget( row, column ) );
795 if ( !lineEdit || lineEdit->text().isEmpty() )
796 {
797 return std::numeric_limits<double>::quiet_NaN();
798 }
799 return QgsDoubleValidator::toDouble( lineEdit->text() );
800
801}
802
804{
805 return mPixelSelectorTool;
806}
@ Float32
Thirty two bit floating point (float)
@ ARGB32_Premultiplied
Color, alpha, red, green, blue, 4 bytes the same as QImage::Format_ARGB32_Premultiplied.
@ ARGB32
Color, alpha, red, green, blue, 4 bytes the same as QImage::Format_ARGB32.
@ Float64
Sixty four bit floating point (double)
@ Value
Numerical pixel value.
void colorChanged(const QColor &color)
Emitted whenever a new color is set for the button.
QgsDoubleValidator is a QLineEdit Validator that combines QDoubleValidator and QRegularExpressionVali...
static double toDouble(const QString &input, bool *ok)
Converts input string to double value.
Abstract interface for generating an expression context scope.
Single scope for storing variables and functions for use within a QgsExpressionContext.
static QgsExpressionContextScope * projectScope(const QgsProject *project)
Creates a new scope which contains variables and functions relating to a QGIS project.
static QgsExpressionContextScope * atlasScope(const QgsLayoutAtlas *atlas)
Creates a new scope which contains variables and functions relating to a QgsLayoutAtlas.
static QgsExpressionContextScope * mapSettingsScope(const QgsMapSettings &mapSettings)
Creates a new scope which contains variables and functions relating to a QgsMapSettings object.
static QgsExpressionContextScope * layerScope(const QgsMapLayer *layer)
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
static QgsExpressionContextScope * globalScope()
Creates a new scope which contains variables and functions relating to the global QGIS context.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
void appendScope(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
Map canvas is a class for displaying all GIS data types on a canvas.
void unsetMapTool(QgsMapTool *mapTool)
Unset the current map tool or last non zoom tool.
void setMapTool(QgsMapTool *mapTool, bool clean=false)
Sets the map tool currently being used on the canvas.
double mapUnitsPerPixel() const
Returns the mapUnitsPerPixel (map units per pixel) for the canvas.
const QgsMapSettings & mapSettings() const
Gets access to properties used for map rendering.
QgsRectangle extent() const
Returns the current zoom extent of the map canvas.
A panel widget that can be shown in the map style dock.
The QgsMapSettings class contains configuration for rendering of the map.
QgsPointXY mapToLayerCoordinates(const QgsMapLayer *layer, QgsPointXY point) const
transform point coordinates from output CRS to layer's CRS
A map tool that simply emits a point when clicking on the map.
void canvasClicked(const QgsPointXY &point, Qt::MouseButton button)
signal emitted on canvas click
Renderer for multiband images with the color components.
void opacityChanged(double opacity)
Emitted when the opacity is changed in the widget, where opacity ranges from 0.0 (transparent) to 1....
void widgetChanged()
Emitted when the widget state changes.
A class to represent a 2D point.
Definition qgspointxy.h:59
static QgsProject * instance()
Returns the QgsProject singleton instance.
QgsProperty property(int key) const override
Returns a matching property from the collection, if one exists.
void setProperty(int key, const QgsProperty &property)
Adds a property to the collection and takes ownership of it.
A button for controlling property overrides which may apply to a widget.
QgsProperty toProperty() const
Returns a QgsProperty object encapsulating the current state of the widget.
void changed()
Emitted when property definition changes.
void init(int propertyKey, const QgsProperty &property, const QgsPropertiesDefinition &definitions, const QgsVectorLayer *layer=nullptr, bool auxiliaryStorageEnabled=false)
Initialize a newly constructed property button (useful if button was included in a UI layout).
void registerExpressionContextGenerator(QgsExpressionContextGenerator *generator)
Register an expression context generator class that will be used to retrieve an expression context fo...
int propertyKey() const
Returns the property key linked to the button.
void bandChanged(int band)
Emitted when the currently selected band changes.
static QString printValue(double value)
Print double value with all necessary significant digits.
Base class for raster data providers.
virtual bool sourceHasNoDataValue(int bandNo) const
Returns true if source band has no data value.
virtual bool useSourceNoDataValue(int bandNo) const
Returns the source nodata value usage.
Qgis::DataType sourceDataType(int bandNo) const override=0
Returns source data type for the band specified by number, source data type may be shorter than dataT...
virtual double sourceNoDataValue(int bandNo) const
Value representing no data value.
Qgis::DataType dataType(int bandNo) const override=0
Returns data type for the band specified by number.
virtual QgsRasterIdentifyResult identify(const QgsPointXY &point, Qgis::RasterIdentifyFormat format, const QgsRectangle &boundingBox=QgsRectangle(), int width=0, int height=0, int dpi=96)
Identify raster value(s) found on the point position.
virtual QgsRasterRangeList userNoDataValues(int bandNo) const
Returns a list of user no data value ranges.
QMap< int, QVariant > results() const
Returns the identify results.
Represents a raster layer.
QgsRasterPipe * pipe()
Returns the raster pipe.
QgsRasterRenderer * renderer() const
Returns the raster's renderer.
QgsRasterDataProvider * dataProvider() override
Returns the source data provider.
QgsPropertyCollection & dataDefinedProperties()
Returns a reference to the pipe's property collection, used for data defined overrides.
static QgsPropertiesDefinition propertyDefinitions()
Returns the definitions for data defined properties available for use in raster pipes.
Property
Data definable properties.
@ RendererOpacity
Raster renderer global opacity.
void setDataDefinedProperties(const QgsPropertyCollection &collection)
Sets the pipe's property collection, used for data defined overrides.
Raster values range container.
Raster renderer pipe that applies colors to a raster.
QColor nodataColor() const
Returns the color to use for shading nodata pixels.
const QgsRasterTransparency * rasterTransparency() const
double opacity() const
Returns the opacity for the renderer, where opacity is a value between 0 (totally transparent) and 1....
virtual QList< int > usesBands() const
Returns a list of band numbers used by the renderer.
void setAlphaBand(int band)
void setOpacity(double opacity)
Sets the opacity for the renderer, where opacity is a value between 0 (totally transparent) and 1....
void setRasterTransparency(QgsRasterTransparency *t)
void setNodataColor(const QColor &color)
Sets the color to use for shading nodata pixels.
QgsExpressionContext createExpressionContext() const override
This method needs to be reimplemented in all classes which implement this interface and return an exp...
void updateDataDefinedButtons()
Updates all property override buttons to reflect the widgets's current properties.
QgsPropertyCollection mPropertyCollection
Temporary property collection.
void syncToLayer()
Sync the widget state to the layer set for the widget.
QgsMapToolEmitPoint * pixelSelectorTool() const
Returns the (possibly nullptr) map pixel selector tool.
void initializeDataDefinedButton(QgsPropertyOverrideButton *button, QgsRasterPipe::Property key)
Registers a property override button, setting up its initial value, connections and description.
QgsRasterTransparencyWidget(QgsRasterLayer *layer, QgsMapCanvas *canvas, QWidget *parent=nullptr)
Widget to control a layers transparency and related options.
void updateDataDefinedButton(QgsPropertyOverrideButton *button)
Updates a specific property override button to reflect the widgets's current properties.
void apply() override
Apply any changes on the widget to the set layer.
void setContext(const QgsSymbolWidgetContext &context)
Sets the context in which the dialog is shown, e.g., the associated map canvas and expression context...
Defines the list of pixel values to be considered as transparent or semi transparent when rendering r...
void setTransparentSingleValuePixelList(const QList< QgsRasterTransparency::TransparentSingleValuePixel > &newList)
Sets the transparent single value pixel list, replacing the whole existing list.
QList< QgsRasterTransparency::TransparentThreeValuePixel > transparentThreeValuePixelList() const
Returns the transparent three value pixel list.
void setTransparentThreeValuePixelList(const QList< QgsRasterTransparency::TransparentThreeValuePixel > &newList)
Sets the transparent three value pixel list, replacing the whole existing list.
QList< QgsRasterTransparency::TransparentSingleValuePixel > transparentSingleValuePixelList() const
Returns the transparent single value pixel list.
A rectangle specified with double values.
double width() const
Returns the width of the rectangle.
double height() const
Returns the height of the rectangle.
This class is a composition of two QSettings instances:
Definition qgssettings.h:63
QVariant value(const QString &key, const QVariant &defaultValue=QVariant(), Section section=NoSection) const
Returns the value for setting key.
Contains settings which reflect the context in which a symbol (or renderer) widget is shown,...
QList< QgsExpressionContextScope > additionalExpressionContextScopes() const
Returns the list of additional expression context scopes to show as available within the layer.
QgsMapCanvas * mapCanvas() const
Returns the map canvas associated with the widget.
static bool isNull(const QVariant &variant)
Returns true if the specified variant should be considered a NULL value.
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
QgsSignalBlocker< Object > whileBlocking(Object *object)
Temporarily blocks signals from a QObject while calling a single method from the object.
Definition qgis.h:4258
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:39
QList< QgsRasterRange > QgsRasterRangeList