qgsbrightnesscontrastfilter.cpp

Go to the documentation of this file.

/***************************************************************************
                         qgsbrightnesscontrastfilter.cpp
                         ---------------------
    begin                : February 2013
    copyright            : (C) 2013 by Alexander Bruy
    email                : alexander dot bruy at gmail dot com
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgsbrightnesscontrastfilter.h"
 
#include "qgsrasterdataprovider.h"
 
#include <QDomDocument>
#include <QDomElement>
#include <QString>
 
using namespace Qt::StringLiterals;
 
QgsBrightnessContrastFilter::QgsBrightnessContrastFilter( QgsRasterInterface *input )
  : QgsRasterInterface( input )
{}
 
QgsBrightnessContrastFilter *QgsBrightnessContrastFilter::clone() const
{
  QgsDebugMsgLevel( u"Entered"_s, 4 );
  QgsBrightnessContrastFilter *filter = new QgsBrightnessContrastFilter( nullptr );
  filter->setBrightness( mBrightness );
  filter->setContrast( mContrast );
  filter->setGamma( mGamma );
  return filter;
}
 
int QgsBrightnessContrastFilter::bandCount() const
{
  if ( mOn )
  {
    return 1;
  }
 
  if ( mInput )
  {
    return mInput->bandCount();
  }
 
  return 0;
}
 
Qgis::DataType QgsBrightnessContrastFilter::dataType( int bandNo ) const
{
  if ( mOn )
  {
    return Qgis::DataType::ARGB32_Premultiplied;
  }
 
  if ( mInput )
  {
    return mInput->dataType( bandNo );
  }
 
  return Qgis::DataType::UnknownDataType;
}
 
bool QgsBrightnessContrastFilter::setInput( QgsRasterInterface *input )
{
  QgsDebugMsgLevel( u"Entered"_s, 4 );
 
  // Brightness filter can only work with single band ARGB32_Premultiplied
  if ( !input )
  {
    QgsDebugMsgLevel( u"No input"_s, 4 );
    return false;
  }
 
  if ( !mOn )
  {
    // In off mode we can connect to anything
    QgsDebugMsgLevel( u"OK"_s, 4 );
    mInput = input;
    return true;
  }
 
  if ( input->bandCount() < 1 )
  {
    QgsDebugError( u"No input band"_s );
    return false;
  }
 
  if ( input->dataType( 1 ) != Qgis::DataType::ARGB32_Premultiplied && input->dataType( 1 ) != Qgis::DataType::ARGB32 )
  {
    QgsDebugError( u"Unknown input data type"_s );
    return false;
  }
 
  mInput = input;
  QgsDebugMsgLevel( u"OK"_s, 4 );
  return true;
}
 
QgsRasterBlock *QgsBrightnessContrastFilter::block( int bandNo, QgsRectangle const &extent, int width, int height, QgsRasterBlockFeedback *feedback )
{
  Q_UNUSED( bandNo )
  QgsDebugMsgLevel( u"width = %1 height = %2 extent = %3"_s.arg( width ).arg( height ).arg( extent.toString() ), 4 );
 
  auto outputBlock = std::make_unique<QgsRasterBlock>();
  if ( !mInput )
  {
    return outputBlock.release();
  }
 
  // At this moment we know that we read rendered image
  int bandNumber = 1;
  std::unique_ptr< QgsRasterBlock > inputBlock( mInput->block( bandNumber, extent, width, height, feedback ) );
  if ( !inputBlock || inputBlock->isEmpty() )
  {
    QgsDebugError( u"No raster data!"_s );
    return outputBlock.release();
  }
 
  if ( mBrightness == 0 && mContrast == 0 && mGamma == 1.0 )
  {
    QgsDebugMsgLevel( u"No brightness/contrast/gamma changes."_s, 4 );
    return inputBlock.release();
  }
 
  if ( !outputBlock->reset( Qgis::DataType::ARGB32_Premultiplied, width, height ) )
  {
    return outputBlock.release();
  }
 
  // adjust image
  QRgb myNoDataColor = qRgba( 0, 0, 0, 0 );
  QRgb myColor;
 
  int r, g, b, alpha;
  double f = std::pow( ( mContrast + 100 ) / 100.0, 2 );
  double gammaCorrection = 1.0 / mGamma;
 
  for ( qgssize i = 0; i < ( qgssize ) width * height; i++ )
  {
    if ( inputBlock->color( i ) == myNoDataColor )
    {
      outputBlock->setColor( i, myNoDataColor );
      continue;
    }
 
    myColor = inputBlock->color( i );
    alpha = qAlpha( myColor );
 
    r = adjustColorComponent( qRed( myColor ), alpha, mBrightness, f, gammaCorrection );
    g = adjustColorComponent( qGreen( myColor ), alpha, mBrightness, f, gammaCorrection );
    b = adjustColorComponent( qBlue( myColor ), alpha, mBrightness, f, gammaCorrection );
 
    outputBlock->setColor( i, qRgba( r, g, b, alpha ) );
  }
 
  return outputBlock.release();
}
 
void QgsBrightnessContrastFilter::setBrightness( int brightness )
{
  mBrightness = std::clamp( brightness, -255, 255 );
}
 
void QgsBrightnessContrastFilter::setContrast( int contrast )
{
  mContrast = std::clamp( contrast, -100, 100 );
}
 
void QgsBrightnessContrastFilter::setGamma( double gamma )
{
  mGamma = std::clamp( gamma, 0.1, 10.0 );
}
 
int QgsBrightnessContrastFilter::adjustColorComponent( int colorComponent, int alpha, int brightness, double contrastFactor, double gammaCorrection ) const
{
  if ( alpha == 255 )
  {
    // Opaque pixel, do simpler math
    return std::clamp( ( int ) ( 255 * std::pow( ( ( ( ( ( ( colorComponent / 255.0 ) - 0.5 ) * contrastFactor ) + 0.5 ) * 255 ) + brightness ) / 255.0, gammaCorrection ) ), 0, 255 );
  }
  else if ( alpha == 0 )
  {
    // Totally transparent pixel
    return 0;
  }
  else
  {
    // Semi-transparent pixel. We need to adjust the math since we are using Qgis::DataType::ARGB32_Premultiplied
    // and color values have been premultiplied by alpha
    double alphaFactor = alpha / 255.;
    double adjustedColor = colorComponent / alphaFactor;
 
    // Make sure to return a premultiplied color
    return alphaFactor * std::clamp( 255 * std::pow( ( ( ( ( ( ( adjustedColor / 255.0 ) - 0.5 ) * contrastFactor ) + 0.5 ) * 255 ) + brightness ) / 255, gammaCorrection ), 0., 255. );
  }
}
 
void QgsBrightnessContrastFilter::writeXml( QDomDocument &doc, QDomElement &parentElem ) const
{
  if ( parentElem.isNull() )
  {
    return;
  }
 
  QDomElement filterElem = doc.createElement( u"brightnesscontrast"_s );
 
  filterElem.setAttribute( u"brightness"_s, QString::number( mBrightness ) );
  filterElem.setAttribute( u"contrast"_s, QString::number( mContrast ) );
  filterElem.setAttribute( u"gamma"_s, QString::number( mGamma ) );
  parentElem.appendChild( filterElem );
}
 
void QgsBrightnessContrastFilter::readXml( const QDomElement &filterElem )
{
  if ( filterElem.isNull() )
  {
    return;
  }
 
  mBrightness = filterElem.attribute( u"brightness"_s, u"0"_s ).toInt();
  mContrast = filterElem.attribute( u"contrast"_s, u"0"_s ).toInt();
  mGamma = filterElem.attribute( u"gamma"_s, u"1"_s ).toDouble();
}