kimageeffect.h

/* This file is part of the KDE libraries
 Copyright (C) 1998, 1999, 2001, 2002 Daniel M. Duley <mosfet@interaccess.com>
 (C) 1998, 1999 Christian Tibirna <ctibirna@total.net>
 (C) 1998, 1999 Dirk Mueller <mueller@kde.org>
 
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
 
1. Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.
 
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
*/
 
// $Id$
 
#ifndef __KIMAGE_EFFECT_H
#define __KIMAGE_EFFECT_H
 
#include <tdelibs_export.h>
 
class TQImage;
class TQSize;
class TQColor;
class TQPoint;
class TQRect;
 
class TDEFX_EXPORT KImageEffect
{
public:
    enum GradientType { VerticalGradient,
            HorizontalGradient,
                        DiagonalGradient,
            CrossDiagonalGradient,
                        PyramidGradient,
            RectangleGradient,
                        PipeCrossGradient,
            EllipticGradient
    };
 
    enum RGBComponent { Red,   
            Green, 
            Blue,  
            Gray,  
            All    
    };
 
    enum Lighting {NorthLite, 
           NWLite,    
           WestLite,  
           SWLite,    
                   SouthLite, 
           SELite,    
           EastLite,  
           NELite     
    };
 
    enum ModulationType { Intensity,  
              Saturation, 
              HueShift,   
              Contrast    
    };
 
    enum NoiseType { UniformNoise=0,              
             GaussianNoise,               
             MultiplicativeGaussianNoise, 
                     ImpulseNoise,                
             LaplacianNoise,              
             PoissonNoise                 
    };
 
    enum RotateDirection{ Rotate90,  
              Rotate180, 
              Rotate270  
    };
 
    enum BumpmapType {
        Linear,
        Spherical,
        Sinuosidal
    };
 
    static TQImage gradient(const TQSize &size, const TQColor &ca,
                           const TQColor &cb, GradientType type, int ncols=3);
 
    static TQImage unbalancedGradient(const TQSize &size, const TQColor &ca,
        const TQColor &cb, GradientType type, int xfactor = 100,
        int yfactor = 100, int ncols = 3);
 
    static TQImage& blend(const TQColor& clr, TQImage& dst, float opacity);
 
    static TQImage& blend(TQImage& src, TQImage& dst, float opacity);
 
    static TQImage& blend(TQImage &image, float initial_intensity,
                      const TQColor &bgnd, GradientType eff,
                      bool anti_dir=false);
 
    static TQImage& blend(TQImage &image1,TQImage &image2,
             GradientType gt, int xf=100, int yf=100);
 
    static TQImage& blend(TQImage &image1, TQImage &image2,
             TQImage &blendImage, RGBComponent channel);
 
    static bool blend(const TQImage & upper, const TQImage & lower, TQImage & output);
// Not yet...    static bool blend(const TQImage & image1, const TQImage & image2, TQImage & output, const TQRect & destRect);
 
    static bool blend(int &x, int &y, const TQImage & upper, const TQImage & lower, TQImage & output);
 
    static bool blendOnLower(int x, int y, const TQImage & upper, const TQImage & lower);
 
    static void blendOnLower(const TQImage &upper, const TQPoint &upperOffset,
                             TQImage &lower, const TQRect &lowerRect);
 
    static void blendOnLower(const TQImage &upper, const TQPoint &upperOffset,
                             TQImage &lower, const TQRect &lowerRect, float opacity);
 
    enum Disposition { NoImage = 0, 
               Centered,    
               Tiled,       
               CenterTiled, 
               CenteredMaxpect, 
               TiledMaxpect, 
               Scaled,      
               CenteredAutoFit 
    };
 
    static TQRect computeDestinationRect(const TQSize &lowerSize,
                                      Disposition disposition, TQImage &upper);
 
    static void blendOnLower(TQImage &upper, TQImage &lower,
                             Disposition disposition, float opacity);
 
    static TQImage& channelIntensity(TQImage &image, float percent,
                                    RGBComponent channel);
 
    static TQImage& fade(TQImage &image, float val, const TQColor &color);
 
 
    static TQImage& flatten(TQImage &image, const TQColor &ca,
           const TQColor &cb, int ncols=0);
 
    static TQImage& hash(TQImage &image, Lighting lite=NorthLite,
                        unsigned int spacing=0);
 
    static TQImage& intensity(TQImage &image, float percent);
 
    static TQImage& modulate(TQImage &image, TQImage &modImage, bool reverse,
        ModulationType type, int factor, RGBComponent channel);
 
    static TQImage& toGray(TQImage &image, bool fast = false);
 
    static TQImage& desaturate(TQImage &image, float desat = 0.3);
 
    static TQImage& contrast(TQImage &image, int c);
 
    static TQImage& dither(TQImage &image, const TQColor *palette, int size);
 
    static TQImage& selectedImage( TQImage &img, const TQColor &col );
 
    static void contrastHSV(TQImage &img, bool sharpen=true);
 
    static void normalize(TQImage &img);
 
    static void equalize(TQImage &img);
 
    static void threshold(TQImage &img, unsigned int value=128);
 
    static void solarize(TQImage &img, double factor=50.0);
 
    static TQImage emboss(TQImage &src, double radius, double sigma);
 
    static TQImage emboss(TQImage &src);
 
    static TQImage despeckle(TQImage &src);
 
    static TQImage charcoal(TQImage &src, double radius, double sigma);
 
     static TQImage charcoal(TQImage &src, double factor=50.0);
 
    static TQImage rotate(TQImage &src, RotateDirection r);
 
    static TQImage sample(TQImage &src, int w, int h);
 
    static TQImage addNoise(TQImage &src, NoiseType type = GaussianNoise);
 
    static TQImage blur(TQImage &src, double radius, double sigma);
 
    static TQImage blur(TQImage &src, double factor=50.0);
 
    static TQImage edge(TQImage &src, double radius);
 
    static TQImage implode(TQImage &src, double factor=30.0,
                   unsigned int background = 0xFFFFFFFF);
 
    static TQImage oilPaintConvolve(TQImage &src, double radius);
 
    static TQImage oilPaint(TQImage &src, int radius=3);
 
    static TQImage sharpen(TQImage &src, double radius, double sigma);
 
    static TQImage sharpen(TQImage &src, double factor=30.0);
 
    static TQImage spread(TQImage &src, unsigned int amount=3);
 
    static TQImage shade(TQImage &src, bool color_shading=true, double azimuth=30.0,
                        double elevation=30.0);
    static TQImage swirl(TQImage &src, double degrees=50.0, unsigned int background =
                         0xFFFFFFFF);
 
    static TQImage wave(TQImage &src, double amplitude=25.0, double frequency=150.0,
                        unsigned int background = 0xFFFFFFFF);
 
    static TQImage bumpmap(TQImage &img, TQImage &map, double azimuth, double elevation,
                          int depth, int xofs, int yofs, int waterlevel,
                          int ambient, bool compensate, bool invert,
                          BumpmapType type, bool tiled);
 
    static TQImage convertToPremultipliedAlpha(TQImage input);
 
private:
 
    static unsigned int lHash(unsigned int c);
    static unsigned int uHash(unsigned int c);
 
    static int nearestColor( int r, int g, int b, const TQColor *pal, int size );
 
    static void hull(const int x_offset, const int y_offset, const int polarity,
                     const int width, const int height,
                     unsigned int *f, unsigned int *g);
    static unsigned int generateNoise(unsigned int pixel, NoiseType type);
    static unsigned int interpolateColor(TQImage *image, double x, double y,
                                         unsigned int background);
    /* Various convolve routines */
    static int getOptimalKernelWidth(double radius, double sigma);
    static bool convolveImage(TQImage *image, TQImage *dest,
                              const unsigned int order,
                              const double *kernel);
    static void blurScanLine(double *kernel, int width,
                             unsigned int *src, unsigned int *dest,
                             int columns);
    static int getBlurKernel(int width, double sigma, double **kernel);
};
 
#endif