Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 807 insertions, 0 deletions

diff --git a/kdefx/kimageeffect.h b/kdefx/kimageeffect.h
new file mode 100644
index 000000000..7bca73820
--- /dev/null
+++ b/kdefx/kimageeffect.h
@@ -0,0 +1,807 @@
+/* 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 <kdelibs_export.h>
+
+class QImage;
+class QSize;
+class QColor;
+class QPoint;
+class QRect;
+
+/**
+ * This class includes various QImage based graphical effects.
+ *
+ * Everything is
+ * static, so there is no need to create an instance of this class. You can
+ * just call the static methods. They are encapsulated here merely to provide
+ * a common namespace.
+ */
+class KDEFX_EXPORT KImageEffect
+{
+public:
+    /**
+     * This enum provides a gradient type specification
+     * @see KImageEffect::blend(), KImageEffect::gradient(),
+     * KImageEffect::unbalancedGradient()
+     */
+    enum GradientType { VerticalGradient,
+			HorizontalGradient,
+                        DiagonalGradient,
+			CrossDiagonalGradient,
+                        PyramidGradient,
+			RectangleGradient,
+                        PipeCrossGradient,
+			EllipticGradient
+    };
+
+    /**
+     * This enum provides a RGB channel specification
+     * @see KImageEffect::blend(), KImageEffect::channelIntensity(),
+     * KImageEffect::modulate()
+     */
+    enum RGBComponent { Red,   //!< Red channel
+			Green, //!< Green channel
+			Blue,  //!< Blue channel
+			Gray,  //!< Grey channel
+			All    //!< All channels
+    };
+
+    /**
+     * This enum provides a lighting direction specification
+     * @see KImageEffect::hash()
+     */
+    enum Lighting {NorthLite, //!< Lighting from the top of the image
+		   NWLite,    //!< Lighting from the top left of the image
+		   WestLite,  //!< Lighting from the left of the image
+		   SWLite,    //!< Lighting from the bottom left of the image
+                   SouthLite, //!< Lighting from the bottom of the image
+		   SELite,    //!< Lighting from the bottom right of the image
+		   EastLite,  //!< Lighting from the right of the image
+		   NELite     //!< Lighting from the top right of the image
+    };
+
+    /**
+     * This enum provides a modulation type specification
+     * @see KImageEffect::modulate()
+     */
+    enum ModulationType { Intensity,  //!< Modulate image intensity
+			  Saturation, //!< Modulate image saturation
+			  HueShift,   //!< Modulate image hue
+			  Contrast    //!< Modulate image contrast
+    };
+
+    /**
+     * This enum provides a noise type specification
+     * @see KImageEffect::addNoise()
+     */
+    enum NoiseType { UniformNoise=0,              //!< Uniform distribution
+		     GaussianNoise,               //!< Gaussian distribution
+		     MultiplicativeGaussianNoise, //!< Multiplicative Gaussian distribution
+                     ImpulseNoise,                //!< Impulse distribution
+		     LaplacianNoise,              //!< Laplacian distribution
+		     PoissonNoise                 //!< Poisson distribution
+    };
+
+    /**
+     * This enum provides a rotation specification.
+     * @see KImageEffect::rotate()
+     */
+    enum RotateDirection{ Rotate90,  //!< Rotate 90 degrees to the right.
+			  Rotate180, //!< Rotate 180 degrees.
+			  Rotate270  //!< Rotate 90 degrees to the left.
+    };
+
+    /**
+     * This enum lists possible bumpmapping implementations.
+     * @see KImageEffect::bumpmap()
+     */
+    enum BumpmapType {
+        Linear,
+        Spherical,
+        Sinuosidal
+    };
+
+    /**
+     * Create a gradient from color a to color b of the specified type.
+     *
+     * @param size The desired size of the gradient.
+     * @param ca Color a
+     * @param cb Color b
+     * @param type The type of gradient.
+     * @param ncols The number of colors to use when not running on a
+     * truecolor display. The gradient will be dithered to this number of
+     * colors. Pass 0 to prevent dithering.
+     */
+    static QImage gradient(const QSize &size, const QColor &ca,
+                           const QColor &cb, GradientType type, int ncols=3);
+
+    /**
+     * Create an unbalanced gradient.
+     *
+     * An unbalanced gradient is a gradient where the transition from
+     * color a to color b is not linear, but in this case, exponential.
+     *
+     * @param size The desired size of the gradient.
+     * @param ca Color a
+     * @param cb Color b
+     * @param type The type of gradient.
+     * @param xfactor The x decay length. Use a value between -200 and 200.
+     * @param yfactor The y decay length.
+     * @param ncols The number of colors. See KImageEffect:gradient.
+     */
+    static QImage unbalancedGradient(const QSize &size, const QColor &ca,
+	    const QColor &cb, GradientType type, int xfactor = 100,
+	    int yfactor = 100, int ncols = 3);
+
+    /**
+     * Blends a color into the destination image, using an opacity
+     * value for blending one into another. Very fast direct pixel
+     * manipulation is used.
+     *
+     * This function uses MMX and SSE2 instructions to blend the
+     * image on processors that support it.
+     *
+     * @param clr source color to be blended into the destination image.
+     * @param dst destination image in which the source will be blended into.
+     * @param opacity opacity (between 0.0 and 1.0) which determines how much
+     *             the source color will be blended into the destination image.
+     * @return The destination image (dst) containing the result.
+     * @author Karol Szwed (gallium@kde.org)
+     * @author Fredrik H&ouml;glund (fredrik@kde.org)
+     */
+    static QImage& blend(const QColor& clr, QImage& dst, float opacity);
+
+    /**
+     * Blend the src image into the destination image, using an opacity
+     * value for blending one into another. Very fast direct pixel
+     * manipulation is used.
+     *
+     * This function uses MMX and SSE2 instructions to blend the
+     * images on processors that support it.
+     *
+     * @param src source image to be blended into the destination image.
+     * @param dst destination image in which the source will be blended into.
+     * @param opacity opacity (between 0.0 and 1.0) which determines how much
+     *             the source image will be blended into the destination image.
+     * @return The destination image (dst) containing the result.
+     * @author Karol Szwed (gallium@kde.org)
+     * @author Fredrik H&ouml;glund (fredrik@kde.org)
+     */
+    static QImage& blend(QImage& src, QImage& dst, float opacity);
+
+    /**
+     * Blend the provided image into a background of the indicated color.
+     *
+     * @param initial_intensity this parameter takes values from -1 to 1:
+     *              a) if positive: how much to fade the image in its
+     *                              less affected spot
+     *              b) if negative: roughly indicates how much of the image
+     *                              remains unaffected
+     * @param bgnd indicates the color of the background to blend in
+     * @param eff lets you choose what kind of blending you like
+     * @param anti_dir blend in the opposite direction (makes no much sense
+     *                  with concentric blending effects)
+     * @param image must be 32bpp
+     */
+    static QImage& blend(QImage &image, float initial_intensity,
+                      const QColor &bgnd, GradientType eff,
+                      bool anti_dir=false);
+
+    /**
+     * Blend an image into another one, using a gradient type
+     * for blending from one to another.
+     *
+     * @param image1 source1 and result of blending
+     * @param image2 source2 of blending
+     * @param gt gradient type for blending between source1 and source2
+     * @param xf x decay length for unbalanced gradient tpye
+     * @param yf y decay length for unbalanced gradient tpye
+     */
+    static QImage& blend(QImage &image1,QImage &image2,
+			 GradientType gt, int xf=100, int yf=100);
+
+    /**
+     * Blend an image into another one, using a color channel of a
+     * third image for the decision of blending from one to another.
+     *
+     * @param image1 Source 1 and result of blending
+     * @param image2 Source 2 of blending
+     * @param blendImage If the gray value of of pixel is 0, the result
+     *               for this pixel is that of image1; for a gray value
+     *               of 1, the pixel of image2 is used; for a value
+     *               in between, a corresponding blending is used.
+     * @param channel The RBG channel to use for the blending decision.
+     */
+    static QImage& blend(QImage &image1, QImage &image2,
+			 QImage &blendImage, RGBComponent channel);
+
+    /**
+     * Blend an image into another one, using alpha in the expected way.
+     * @param upper the "upper" image
+     * @param lower the "lower" image
+     * @param output the target image
+     * @author Rik Hemsley (rikkus) <rik@kde.org>
+     */
+    static bool blend(const QImage & upper, const QImage & lower, QImage & output);
+// Not yet...    static bool blend(const QImage & image1, const QImage & image2, QImage & output, const QRect & destRect);
+
+    /**
+     * Blend an image into another one, using alpha in the expected way and
+     * over coordinates @p x and @p y with respect to the lower image.
+     * The output is a QImage which is the @p upper image already blended
+     * with the @p lower one, so its size will be (in general) the same than
+     * @p upper instead of the same size than @p lower like the method above.
+     * In fact, the size of @p output is like upper's one only when it can be
+     * painted on lower, if there has to be some clipping, output's size will
+     * be the clipped area and x and y will be set to the correct up-left corner
+     * where the clipped rectangle begins.
+     * @param x x-coordinate of lower image
+     * @param y y-coordinate of lower image
+     * @param upper the "upper" image
+     * @param lower the "lower" image
+     * @param output the target image
+     */
+    static bool blend(int &x, int &y, const QImage & upper, const QImage & lower, QImage & output);
+
+    /**
+     * Blend an image into another one, using alpha in the expected way and
+     * over coordinates @p x and @p y with respect to the lower image.
+     * The output is painted in the own @p lower image. This is an optimization
+     * of the blend method above provided by convenience.
+     * @param x x-coordinate of lower image
+     * @param y y-coordinate of lower image
+     * @param upper the "upper" image
+     * @param lower the "lower" image, which becomes the output image
+     */
+    static bool blendOnLower(int x, int y, const QImage & upper, const QImage & lower);
+
+    /**
+     * Blend part of an image into part of another, using the alpha channel in
+     * the expected way.
+     * Note that the destination rectangle will be correctly clipped.
+     *
+     * @param upper the "upper" image
+     * @param upperOffset Offset for the part of the upper image to be used.
+     * @param lower the "lower" image
+     * @param lowerRect Rectangle for the part of the lower image where the
+     *                  blending will occur.
+     * @since 3.2
+     */
+    static void blendOnLower(const QImage &upper, const QPoint &upperOffset,
+                             QImage &lower, const QRect &lowerRect);
+
+    /**
+     * Blend part of an image into part of another, using the opacity value
+     * and the alpha channel in the expected way.
+     * Note that the destination rectangle will be correctly clipped.
+     *
+     * @param upper the "upper" image
+     * @param upperOffset Offset for the part of the upper image to be used.
+     * @param lower the "lower" image
+     * @param lowerRect Rectangle for the part of the lower image where the
+     *                  blending will occur.
+     * @param opacity Opacity (between 0.0 and 1.0) which determines how much
+     *             the source image will be blended into the destination image.
+     * @since 3.2
+     */
+    static void blendOnLower(const QImage &upper, const QPoint &upperOffset,
+                             QImage &lower, const QRect &lowerRect, float opacity);
+
+    /**
+     * Disposition of a source image on top of a destination image.
+     * @see KImageEffect::computeDestinationRect, KImageEffect::blendOnLower
+     * @since 3.2
+     */
+    enum Disposition { NoImage = 0, //!< Don't overlay
+		       Centered,    //!< Center top image on botton image
+		       Tiled,       //!< Tile top image on bottom image
+		       CenterTiled, //!< Center and tile top image on bottom image
+		       CenteredMaxpect, //!< Center and scale aspect
+		       TiledMaxpect, //!< Tile and scale aspect
+		       Scaled,      //!< Scale
+		       CenteredAutoFit //!< Center and scale or scale aspect
+    };
+
+    /**
+     * Compute the destination rectangle where to draw the upper image on top
+     * of another image using the given disposition. For tiled
+     * disposition, the rectangle should be duplicated on the whole area to
+     * obtained the wanted effect.
+     *
+     * @param lowerSize The size of the destination image.
+     * @param disposition The wanted disposition.
+     * @param upper The upper image. Note that this image may be scaled to
+     *               adjust to the requested disposition.
+     *
+     * @return the computed rectangle. Its size may exceed @e lowerSize.
+     * @since 3.2
+     */
+    static QRect computeDestinationRect(const QSize &lowerSize,
+                                      Disposition disposition, QImage &upper);
+
+    /**
+     * Blend an image on top of another using a given disposition and a given
+     * opacity. The alpha channel of the upper image is used in the expected
+     * way. Beware the upper image may be modified.
+     * @since 3.2
+     */
+    static void blendOnLower(QImage &upper, QImage &lower,
+                             Disposition disposition, float opacity);
+
+    /**
+     * Modifies the intensity of a pixmap's RGB channel component.
+     *
+     * @param image The QImage to process.
+     * @param percent Percent value. Use a negative value to dim.
+     * @param channel Which channel(s) should be modified
+     * @return The @p image, provided for convenience.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage& channelIntensity(QImage &image, float percent,
+                                    RGBComponent channel);
+
+    /**
+     * Fade an image to a certain background color.
+     *
+     * The number of colors will not be changed.
+     *
+     * @param image The QImage to process.
+     * @param val   The strength of the effect. 0 <= val <= 1.
+     * @param color The background color.
+     * @return Returns the image(), provided for convenience.
+     */
+    static QImage& fade(QImage &image, float val, const QColor &color);
+
+
+    /**
+     * This recolors a pixmap. The most dark color will become color a,
+     * the most bright one color b, and in between.
+     *
+     * @param image A QImage to process.
+     * @param ca Color a
+     * @param cb Color b
+     * @param ncols The number of colors to dither the image to.
+     * Pass 0 to prevent dithering.
+     */
+    static QImage& flatten(QImage &image, const QColor &ca,
+           const QColor &cb, int ncols=0);
+
+    /**
+     * Build a hash on any given QImage
+     *
+     * @param image The QImage to process
+     * @param lite The hash faces the indicated lighting (cardinal poles).
+     * @param spacing How many unmodified pixels in between hashes.
+     * @return Returns the image(), provided for convenience.
+     */
+    static QImage& hash(QImage &image, Lighting lite=NorthLite,
+                        unsigned int spacing=0);
+
+    /**
+     * Either brighten or dim the image by a specified percent.
+     * For example, .50 will modify the colors by 50%.
+     *
+     * This function uses MMX instructions to process the image
+     * on processors that support it.
+     *
+     * @param image The QImage to process.
+     * @param percent The percent value. Use a negative value to dim.
+     * @return Returns The image(), provided for convenience.
+     * @author Daniel M. Duley (mosfet)
+     * @author Benjamin Roe (ben@benroe.com)
+     */
+    static QImage& intensity(QImage &image, float percent);
+
+    /**
+     * Modulate the image with a color channel of another image.
+     *
+     * @param image The QImage to modulate and result.
+     * @param modImage The QImage to use for modulation.
+     * @param reverse Invert the meaning of image/modImage; result is image!
+     * @param type The modulation Type to use.
+     * @param factor The modulation amplitude; with 0 no effect [-200;200].
+     * @param channel The RBG channel of image2 to use for modulation.
+     * @return Returns the image(), provided for convenience.
+     */
+    static QImage& modulate(QImage &image, QImage &modImage, bool reverse,
+		ModulationType type, int factor, RGBComponent channel);
+
+    /**
+     * Convert an image to grayscale.
+     *
+     * @param image The QImage to process.
+     * @param fast Set to @p true in order to use a faster but non-photographic
+     * quality algorithm. Appropriate for things such as toolbar icons.
+     * @return Returns the image(), provided for convenience.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage& toGray(QImage &image, bool fast = false);
+
+    /**
+     * Desaturate an image evenly.
+     *
+     * @param image The QImage to process.
+     * @param desat A value between 0 and 1 setting the degree of desaturation
+     * @return Returns the image(), provided for convenience.
+     */
+    static QImage& desaturate(QImage &image, float desat = 0.3);
+
+    /**
+     * Fast, but low quality contrast of an image. Also see contrastHSV.
+     *
+     * @param image The QImage to process.
+     * @param c A contrast value between -255 to 255.
+     * @return The image(), provided for convenience.
+     * @author Daniel M. Duley (mosfet)
+     * ### KDE 4: remove
+     */
+    static QImage& contrast(QImage &image, int c);
+
+    /**
+     * Dither an image using Floyd-Steinberg dithering for low-color
+     * situations.
+     *
+     * @param image The QImage to process.
+     * @param palette The color palette to use
+     * @param size The size of the palette
+     * @return Returns the image(), provided for convenience.
+     */
+    static QImage& dither(QImage &image, const QColor *palette, int size);
+
+    /**
+     * Calculate the image for a selected image, for instance a selected icon
+     * on the desktop.
+     * @param img the QImage to select
+     * @param col the selected color, usually from QColorGroup::highlight().
+     */
+    static QImage& selectedImage( QImage &img, const QColor &col );
+
+    /**
+     * High quality, expensive HSV contrast. You can do a faster one by just
+     * taking a intensity threshold (ie: 128) and incrementing RGB color
+     * channels above it and decrementing those below it, but this gives much
+     * better results.
+     *
+     * @param img The QImage to process.
+     * @param sharpen If true sharpness is increase, (spiffed). Otherwise
+     * it is decreased, (dulled).
+     * @author Daniel M. Duley (mosfet)
+     */
+    static void contrastHSV(QImage &img, bool sharpen=true);
+
+    /**
+     * Normalises the pixel values to span the full range of color values.
+     * This is a contrast enhancement technique.
+     * @param img the image that is normalised
+     * @author Daniel M. Duley (mosfet)
+     */
+    static void normalize(QImage &img);
+
+    /**
+     * Performs histogram equalisation on the reference
+     * image.
+     * @param img the image that is equalised
+     * @author Daniel M. Duley (mosfet)
+     */
+    static void equalize(QImage &img);
+
+    /**
+     * Thresholds the reference image. You can also threshold images by using
+     * ThresholdDither in the various QPixmap/QImage convert methods, but this
+     * lets you specify a threshold value.
+     *
+     * @param img The QImage to process.
+     * @param value The threshold value.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static void threshold(QImage &img, unsigned int value=128);
+
+    /**
+     * Produces a 'solarization' effect seen when exposing a photographic
+     * film to light during the development process.
+     *
+     * @param img The QImage to process.
+     * @param factor The extent of the solarization (0-99.9)
+     * @author Daniel M. Duley (mosfet)
+     */
+    static void solarize(QImage &img, double factor=50.0);
+
+    /**
+     * Embosses the source image. This involves highlighting the edges
+     * and applying various other enhancements in order to get a metal
+     * effect.
+     *
+     * @param src The QImage to process.
+     * @param radius The radius of the gaussian not counting the
+     * center pixel. Use 0 and a suitable radius will be automatically used.
+     * @param sigma The standard deviation of the gaussian. Use 1 if you're not
+     * sure.
+     * @return The embossed image. The original is not changed.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage emboss(QImage &src, double radius, double sigma);
+
+    /**
+     * Convenience method.
+     */
+    static QImage emboss(QImage &src);
+
+    /**
+     * Minimizes speckle noise in the source image using the 8 hull
+     * algorithm.
+     *
+     * @param src The QImage to process.
+     * @return The despeckled image. The original is not changed.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage despeckle(QImage &src);
+
+    /**
+     * Produces a neat little "charcoal" effect.
+     *
+     * @param src The QImage to process.
+     * @param radius The radius of the gaussian not counting the
+     * center pixel. Use 0 and a suitable radius will be automatically used.
+     * @param sigma The standard deviation of the gaussian. Use 1 if you're not
+     * sure.
+     * @return The charcoal image. The original is not changed.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage charcoal(QImage &src, double radius, double sigma);
+
+    /**
+     * This is provided for binary compatability only! Use the above method
+     * with a radius and sigma instead!
+     */
+     static QImage charcoal(QImage &src, double factor=50.0);
+
+    /**
+     * Rotates the image by the specified amount
+     *
+     * @param src The QImage to process.
+     * @param r The rotate direction.
+     * @return The rotated image. The original is not changed.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage rotate(QImage &src, RotateDirection r);
+
+    /**
+     * Scales an image using simple pixel sampling. This does not produce
+     * nearly as nice a result as QImage::smoothScale(), but has the
+     * advantage of being much faster - only a few milliseconds.
+     *
+     * @param src The QImage to process.
+     * @param w The new width.
+     * @param h The new height.
+     * @return The scaled image. The original is not changed.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage sample(QImage &src, int w, int h);
+
+    /**
+     * Adds noise to an image.
+     *
+     * @param src The QImage to process.
+     * @param type The algorithm used to generate the noise.
+     * @return The image with noise added. The original is not changed.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage addNoise(QImage &src, NoiseType type = GaussianNoise);
+
+    /**
+     * Blurs an image by convolving pixel neighborhoods.
+     *
+     * @param src The QImage to process.
+     * @param radius The radius of the gaussian not counting the
+     * center pixel. Use 0 and a suitable radius will be automatically used.
+     * @param sigma The standard deviation of the gaussian. Use 1 if you're not
+     * sure.
+     * @return The blurred image. The original is not changed.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage blur(QImage &src, double radius, double sigma);
+
+    /**
+     * This is provided for binary compatability only! Use the above method
+     * with a radius and sigma instead!
+     */
+    static QImage blur(QImage &src, double factor=50.0);
+
+    /**
+     * Detects edges in an image using pixel neighborhoods and an edge
+     * detection mask.
+     *
+     * @param src The QImage to process.
+     * @param radius The radius of the gaussian not counting the
+     * center pixel. Use 0 and a suitable radius will be automatically used.
+     * @return The image with edges detected. The original is not changed.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage edge(QImage &src, double radius);
+
+    /**
+     * Implodes an image by a specified percent.
+     *
+     * @param src The QImage to process.
+     * @param factor The extent of the implosion.
+     * @param background An RGBA value to use for the background. After the
+     * effect some pixels may be "empty". This value is used for those pixels.
+     * @return The imploded image. The original is not changed.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage implode(QImage &src, double factor=30.0,
+                   unsigned int background = 0xFFFFFFFF);
+
+    /**
+     * Produces an oil painting effect.
+     *
+     * @param src The QImage to process.
+     * @param radius The radius of the gaussian not counting the
+     * center pixel. Use 0 and a suitable radius will be automatically used.
+     * @return The new image. The original is not changed.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage oilPaintConvolve(QImage &src, double radius);
+
+    /**
+     * This is provided for binary compatability only! Use the above method
+     * instead!
+     */
+    static QImage oilPaint(QImage &src, int radius=3);
+
+    /**
+     * Sharpens the pixels in the image using pixel neighborhoods.
+     *
+     * @param src The QImage to process.
+     * @param radius The radius of the gaussian not counting the
+     * center pixel. Use 0 and a suitable radius will be automatically used.
+     * @param sigma The standard deviation of the gaussian. Use 1 if you're not
+     * sure.
+     * @return The sharpened image. The original is not changed.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage sharpen(QImage &src, double radius, double sigma);
+
+    /**
+     * This is provided for binary compatability only! Use the above method
+     * instead!
+     */
+    static QImage sharpen(QImage &src, double factor=30.0);
+
+    /**
+     * Randomly displaces pixels.
+     *
+     * @param src The QImage to process.
+     * @param amount The vicinity for choosing a random pixel to swap.
+     * @return The image with pixels displaced. The original is not changed.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage spread(QImage &src, unsigned int amount=3);
+
+    /**
+     * Shades the image using a distance light source.
+     *
+     * @param src The QImage to process.
+     * @param color_shading If true do color shading, otherwise do grayscale.
+     * @param azimuth Determines the light source and direction.
+     * @param elevation Determines the light source and direction.
+     * @return The shaded image. The original is not changed.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage shade(QImage &src, bool color_shading=true, double azimuth=30.0,
+                        double elevation=30.0);
+    /**
+     * Swirls the image by a specified amount
+     *
+     * @param src The QImage to process.
+     * @param degrees The tightness of the swirl.
+     * @param background An RGBA value to use for the background. After the
+     * effect some pixels may be "empty". This value is used for those pixels.
+     * @return The swirled image. The original is not changed.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage swirl(QImage &src, double degrees=50.0, unsigned int background =
+                         0xFFFFFFFF);
+
+    /**
+     * Modifies the pixels along a sine wave.
+     *
+     * @param src        The QImage to process.
+     * @param amplitude  The amplitude of the sine wave.
+     * @param frequency  The frequency of the sine wave.
+     * @param background An RGBA value to use for the background. After the
+     * effect some pixels may be "empty". This value is used for those pixels.
+     * @return The new image. The original is not changed.
+     * @author Daniel M. Duley (mosfet)
+     */
+    static QImage wave(QImage &src, double amplitude=25.0, double frequency=150.0,
+                        unsigned int background = 0xFFFFFFFF);
+
+    /**
+     * A bumpmapping algorithm.
+     *
+     * @param img the image you want bumpmap
+     * @param map the map used
+     * @param azimuth azimuth
+     * @param elevation elevation
+     * @param depth depth (not the depth of the image, but of the map)
+     * @param xofs X offset
+     * @param yofs Y offset
+     * @param waterlevel level that full transparency should represent
+     * @param ambient ambient lighting factor
+     * @param compensate compensate for darkening
+     * @param invert invert bumpmap
+     * @param type type of the bumpmap
+     * @param tiled tile the bumpmap over the image through the Y offset
+     *
+     * @return The destination image (dst) containing the result.
+     * @author Zack Rusin <zack@kde.org>
+     */
+    static QImage bumpmap(QImage &img, QImage &map, double azimuth, double elevation,
+                          int depth, int xofs, int yofs, int waterlevel,
+                          int ambient, bool compensate, bool invert,
+                          BumpmapType type, bool tiled);
+
+private:
+
+    /**
+     * Helper function to fast calc some altered (lighten, shaded) colors
+     *
+     */
+    static unsigned int lHash(unsigned int c);
+    static unsigned int uHash(unsigned int c);
+
+    /**
+     * Helper function to find the nearest color to the RBG triplet
+     */
+    static int nearestColor( int r, int g, int b, const QColor *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(QImage *image, double x, double y,
+                                         unsigned int background);
+    /* Various convolve routines */
+    static int getOptimalKernelWidth(double radius, double sigma);
+    static bool convolveImage(QImage *image, QImage *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