qgsimageoperation.h

Go to the documentation of this file.

/***************************************************************************
                           qgsimageoperation.h
                           --------------------
    begin                : January 2015
    copyright            : (C) 2015 by Nyall Dawson
    email                : [email protected]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef QGSIMAGEOPERATION_H
#define QGSIMAGEOPERATION_H

#include <QImage>
#include <QColor>
#include <QtCore/qmath.h>

class QgsVectorColorRampV2;

class CORE_EXPORT QgsImageOperation
{

  public:

    enum GrayscaleMode
    {
      GrayscaleLightness, /*< keep the lightness of the color, drops the saturation */
      GrayscaleLuminosity, /*< grayscale by perceptual luminosity (weighted sum of color RGB components) */
      GrayscaleAverage /*< grayscale by taking average of color RGB components */
    };

    enum FlipType
    {
      FlipHorizontal, /*< flip the image horizontally */
      FlipVertical /*< flip the image vertically */
    };

    static void convertToGrayscale( QImage &image, const GrayscaleMode mode = GrayscaleLuminosity );

    static void adjustBrightnessContrast( QImage &image, const int brightness, const double contrast );

    static void adjustHueSaturation( QImage &image, const double saturation, const QColor& colorizeColor = QColor(),
                                     const double colorizeStrength = 1.0 );

    static void multiplyOpacity( QImage &image, const double factor );

    static void overlayColor( QImage &image, const QColor& color );

    struct DistanceTransformProperties
    {
      DistanceTransformProperties()
          : shadeExterior( true )
          , useMaxDistance( true )
          , spread( 10.0 )
          , ramp( NULL )
      { }

      bool shadeExterior;
      bool useMaxDistance;
      double spread;
      QgsVectorColorRampV2* ramp;
    };

    static void distanceTransform( QImage &image, const DistanceTransformProperties& properties );

    static void stackBlur( QImage &image, const int radius, const bool alphaOnly = false );

    static QImage* gaussianBlur( QImage &image, const int radius );

    static void flipImage( QImage &image, FlipType type );

  private:

    //for blocked operations
    enum LineOperationDirection
    {
      ByRow,
      ByColumn
    };
    template <class BlockOperation> static void runBlockOperationInThreads( QImage &image, BlockOperation& operation, LineOperationDirection direction );
    struct ImageBlock
    {
      unsigned int beginLine;
      unsigned int endLine;
      unsigned int lineLength;
      QImage* image;
    };

    //for rect operations
    template <typename RectOperation> static void runRectOperation( QImage &image, RectOperation& operation );
    template <class RectOperation> static void runRectOperationOnWholeImage( QImage &image, RectOperation& operation );

    //for per pixel operations
    template <class PixelOperation> static void runPixelOperation( QImage &image, PixelOperation& operation );
    template <class PixelOperation> static void runPixelOperationOnWholeImage( QImage &image, PixelOperation& operation );
    template <class PixelOperation>
    struct ProcessBlockUsingPixelOperation
    {
      ProcessBlockUsingPixelOperation( PixelOperation& operation )
          : mOperation( operation ) { }

      typedef void result_type;

      void operator()( ImageBlock& block )
      {
        for ( unsigned int y = block.beginLine; y < block.endLine; ++y )
        {
          QRgb* ref = ( QRgb* )block.image->scanLine( y );
          for ( unsigned int x = 0; x < block.lineLength; ++x )
          {
            mOperation( ref[x], x, y );
          }
        }
      }

      PixelOperation& mOperation;
    };

    //for linear operations
    template <typename LineOperation> static void runLineOperation( QImage &image, LineOperation& operation );
    template <class LineOperation> static void runLineOperationOnWholeImage( QImage &image, LineOperation& operation );
    template <class LineOperation>
    struct ProcessBlockUsingLineOperation
    {
      ProcessBlockUsingLineOperation( LineOperation& operation )
          : mOperation( operation ) { }

      typedef void result_type;

      void operator()( ImageBlock& block )
      {
        //do something with whole lines
        int bpl = block.image->bytesPerLine();
        if ( mOperation.direction() == ByRow )
        {
          for ( unsigned int y = block.beginLine; y < block.endLine; ++y )
          {
            QRgb* ref = ( QRgb* )block.image->scanLine( y );
            mOperation( ref, block.lineLength, bpl );
          }
        }
        else
        {
          //by column
          unsigned char* ref = block.image->scanLine( 0 ) + 4 * block.beginLine;
          for ( unsigned int x = block.beginLine; x < block.endLine; ++x, ref += 4 )
          {
            mOperation(( QRgb* )ref, block.lineLength, bpl );
          }
        }
      }

      LineOperation& mOperation;
    };


    //individual operation implementations

    class GrayscalePixelOperation
    {
      public:
        GrayscalePixelOperation( const GrayscaleMode mode )
            : mMode( mode )
        {  }

        void operator()( QRgb& rgb, const int x, const int y );

      private:
        GrayscaleMode mMode;
    };
    static void grayscaleLightnessOp( QRgb& rgb );
    static void grayscaleLuminosityOp( QRgb& rgb );
    static void grayscaleAverageOp( QRgb& rgb );


    class BrightnessContrastPixelOperation
    {
      public:
        BrightnessContrastPixelOperation( const int brightness, const double contrast )
            : mBrightness( brightness )
            , mContrast( contrast )
        {  }

        void operator()( QRgb& rgb, const int x, const int y );

      private:
        int mBrightness;
        double mContrast;
    };


    class HueSaturationPixelOperation
    {
      public:
        HueSaturationPixelOperation( const double saturation, const bool colorize,
                                     const int colorizeHue, const int colorizeSaturation,
                                     const double colorizeStrength )
            : mSaturation( saturation )
            , mColorize( colorize )
            , mColorizeHue( colorizeHue )
            , mColorizeSaturation( colorizeSaturation )
            , mColorizeStrength( colorizeStrength )
        {  }

        void operator()( QRgb& rgb, const int x, const int y );

      private:
        double mSaturation; // [0, 2], 1 = no change
        bool mColorize;
        int mColorizeHue;
        int mColorizeSaturation;
        double mColorizeStrength; // [0,1]
    };
    static int adjustColorComponent( int colorComponent, int brightness, double contrastFactor );


    class MultiplyOpacityPixelOperation
    {
      public:
        MultiplyOpacityPixelOperation( const double factor )
            : mFactor( factor )
        { }

        void operator()( QRgb& rgb, const int x, const int y );

      private:
        double mFactor;
    };

    class ConvertToArrayPixelOperation
    {
      public:
        ConvertToArrayPixelOperation( const int width, double * array, const bool exterior = true, const int alphaThreshold = 255 )
            : mWidth( width )
            , mArray( array )
            , mExterior( exterior )
            , mAlphaThreshold( alphaThreshold )
        {
        }

        void operator()( QRgb& rgb, const int x, const int y );

      private:
        int mWidth;
        double * mArray;
        bool mExterior;
        int mAlphaThreshold;
    };

    class ShadeFromArrayOperation
    {
      public:
        ShadeFromArrayOperation( const int width, double* array, const double spread,
                                 const DistanceTransformProperties& properties )
            : mWidth( width )
            , mArray( array )
            , mSpread( spread )
            , mProperties( properties )
        {
          mSpreadSquared = qPow( mSpread, 2.0 );
        }

        void operator()( QRgb& rgb, const int x, const int y );

      private:
        int mWidth;
        double * mArray;
        double mSpread;
        double mSpreadSquared;
        const DistanceTransformProperties& mProperties;
    };
    static void distanceTransform2d( double *im, int width, int height );
    static void distanceTransform1d( double *f, int n, int *v, double *z, double *d );
    static double maxValueInDistanceTransformArray( const double *array, const unsigned int size );


    class StackBlurLineOperation
    {
      public:
        StackBlurLineOperation( int alpha, LineOperationDirection direction, bool forwardDirection, int i1, int i2 )
            : mAlpha( alpha )
            , mDirection( direction )
            , mForwardDirection( forwardDirection )
            , mi1( i1 )
            , mi2( i2 )
        { }

        typedef void result_type;

        LineOperationDirection direction() { return mDirection; }

        void operator()( QRgb* startRef, const int lineLength, const int bytesPerLine );

      private:
        int mAlpha;
        LineOperationDirection mDirection;
        bool mForwardDirection;
        int mi1;
        int mi2;
    };

    static double *createGaussianKernel( const int radius );

    class GaussianBlurOperation
    {
      public:
        GaussianBlurOperation( int radius, LineOperationDirection direction, QImage* destImage, double* kernel )
            : mRadius( radius )
            , mDirection( direction )
            , mDestImage( destImage )
            , mDestImageBpl( destImage->bytesPerLine() )
            , mKernel( kernel )
        {}

        typedef void result_type;

        void operator()( ImageBlock& block );

      private:
        int mRadius;
        LineOperationDirection mDirection;
        QImage* mDestImage;
        int mDestImageBpl;
        double* mKernel;

        inline QRgb gaussianBlurVertical( const int posy, unsigned char *sourceFirstLine, const int sourceBpl, const int height );
        inline QRgb gaussianBlurHorizontal( const int posx, unsigned char *sourceFirstLine, const int width );
    };

    //flip


    class FlipLineOperation
    {
      public:
        FlipLineOperation( LineOperationDirection direction )
            : mDirection( direction )
        { }

        typedef void result_type;

        LineOperationDirection direction() { return mDirection; }

        void operator()( QRgb* startRef, const int lineLength, const int bytesPerLine );

      private:
        LineOperationDirection mDirection;
    };


};

#endif // QGSIMAGEOPERATION_H