path: root/kdejava/koala/org/kde/koala/KImageEffect.java

//Auto-generated by kalyptus. DO NOT EDIT.
package org.kde.koala;

import org.kde.qt.Qt;
import org.kde.qt.TQColor;
import org.kde.qt.TQRect;
import org.kde.qt.QtSupport;
import org.kde.qt.TQImage;
import org.kde.qt.TQPoint;
import org.kde.qt.TQSize;

/**

 This class includes various TQImage 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.
 		@short    This class includes various TQImage based graphical effects.

*/
public class KImageEffect implements QtSupport {
	private long _qt;
	private boolean _allocatedInJavaWorld = true;
	protected KImageEffect(Class dummy){}

	/**	
		 This enum provides a gradient type specification
				@short    This enum provides a gradient type specification 
		@see KImageEffect#blend
		@see KImageEffect#gradient
		@see KImageEffect#unbalancedGradient
	*/
	public static final int VerticalGradient = 0;
	public static final int HorizontalGradient = 1;
	public static final int DiagonalGradient = 2;
	public static final int CrossDiagonalGradient = 3;
	public static final int PyramidGradient = 4;
	public static final int RectangleGradient = 5;
	public static final int PipeCrossGradient = 6;
	public static final int EllipticGradient = 7;

	/**	
		 This enum provides a RGB channel specification
				@short    This enum provides a RGB channel specification 
		@see KImageEffect#blend
		@see KImageEffect#channelIntensity
		@see KImageEffect#modulate
	*/
	public static final int Red = 0;
	public static final int Green = 1;
	public static final int Blue = 2;
	public static final int Gray = 3;
	public static final int All = 4;

	/**	
		 This enum provides a lighting direction specification
				@short    This enum provides a lighting direction specification 
		@see KImageEffect#hash
	*/
	public static final int NorthLite = 0;
	public static final int NWLite = 1;
	public static final int WestLite = 2;
	public static final int SWLite = 3;
	public static final int SouthLite = 4;
	public static final int SELite = 5;
	public static final int EastLite = 6;
	public static final int NELite = 7;

	/**	
		 This enum provides a modulation type specification
				@short    This enum provides a modulation type specification 
		@see KImageEffect#modulate
	*/
	public static final int Intensity = 0;
	public static final int Saturation = 1;
	public static final int HueShift = 2;
	public static final int Contrast = 3;

	/**	
		 This enum provides a noise type specification
				@short    This enum provides a noise type specification 
		@see KImageEffect#addNoise
	*/
	public static final int UniformNoise = 0;
	public static final int GaussianNoise = 1;
	public static final int MultiplicativeGaussianNoise = 2;
	public static final int ImpulseNoise = 3;
	public static final int LaplacianNoise = 4;
	public static final int PoissonNoise = 5;

	/**	
		 This enum provides a rotation specification.
				@short    This enum provides a rotation specification.
		@see KImageEffect#rotate
	*/
	public static final int Rotate90 = 0;
	public static final int Rotate180 = 1;
	public static final int Rotate270 = 2;

	/**	
		 This enum lists possible bumpmapping implementations.
				@short    This enum lists possible bumpmapping implementations.
		@see KImageEffect#bumpmap
	*/
	public static final int Linear = 0;
	public static final int Spherical = 1;
	public static final int Sinuosidal = 2;

	/**	
		 Disposition of a source image on top of a destination image.
				@short    Disposition of a source image on top of a destination image.
		@see KImageEffect#computeDestinationRect
		@see KImageEffect#blendOnLower
	*/
	public static final int NoImage = 0;
	public static final int Centered = 1;
	public static final int Tiled = 2;
	public static final int CenterTiled = 3;
	public static final int CenteredMaxpect = 4;
	public static final int TiledMaxpect = 5;
	public static final int Scaled = 6;
	public static final int CenteredAutoFit = 7;

	public KImageEffect() {
		newKImageEffect();
	}
	private native void newKImageEffect();
	/**	
		 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.
		     		@short    Create a gradient from color a to color b of the specified type.
	*/
	public static native TQImage gradient(TQSize size, TQColor ca, TQColor cb, int type, int ncols);
	public static native TQImage gradient(TQSize size, TQColor ca, TQColor cb, int type);
	/**	
		 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.
		     		@short    Create an unbalanced gradient.
	*/
	public static native TQImage unbalancedGradient(TQSize size, TQColor ca, TQColor cb, int type, int xfactor, int yfactor, int ncols);
	public static native TQImage unbalancedGradient(TQSize size, TQColor ca, TQColor cb, int type, int xfactor, int yfactor);
	public static native TQImage unbalancedGradient(TQSize size, TQColor ca, TQColor cb, int type, int xfactor);
	public static native TQImage unbalancedGradient(TQSize size, TQColor ca, TQColor cb, int type);
	/**	
		 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 Fredrik Höglund (fredrik@kde.org)
     
		@short    Blends a color into the destination image, using an opacity  value for blending one into another.
	*/
	public static native TQImage blend(TQColor clr, TQImage 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 Fredrik Höglund (fredrik@kde.org)
     
		@short    Blend the src image into the destination image, using an opacity  value for blending one into another.
	*/
	public static native TQImage blend(TQImage src, TQImage 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
		     		@short    Blend the provided image into a background of the indicated color.
	*/
	public static native TQImage blend(TQImage image, float initial_intensity, TQColor bgnd, int eff, boolean anti_dir);
	public static native TQImage blend(TQImage image, float initial_intensity, TQColor bgnd, int eff);
	/**	
		 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
		     		@short    Blend an image into another one, using a gradient type  for blending from one to another.
	*/
	public static native TQImage blend(TQImage image1, TQImage image2, int gt, int xf, int yf);
	public static native TQImage blend(TQImage image1, TQImage image2, int gt, int xf);
	public static native TQImage blend(TQImage image1, TQImage image2, int gt);
	/**	
		 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.
		     		@short    Blend an image into another one, using a color channel of a  third image for the decision of blending from one to another.
	*/
	public static native TQImage blend(TQImage image1, TQImage image2, TQImage blendImage, int 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>
     
		@short    Blend an image into another one, using alpha in the expected way.
	*/
	public static native boolean blend(TQImage upper, TQImage lower, TQImage output);
	/**	
		 Blend an image into another one, using alpha in the expected way and
		 over coordinates <code>x</code> and <code>y</code> with respect to the lower image.
		 The output is a TQImage which is the <code>upper</code> image already blended
		 with the <code>lower</code> one, so its size will be (in general) the same than
		 <code>upper</code> instead of the same size than <code>lower</code> like the method above.
		 In fact, the size of <code>output</code> 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
		     		@short    Blend an image into another one, using alpha in the expected way and  over coordinates <code>x</code> and <code>y</code> with respect to the lower image.
	*/
	public static native boolean blend(int[] x, int[] y, TQImage upper, TQImage lower, TQImage output);
	/**	
		 Blend an image into another one, using alpha in the expected way and
		 over coordinates <code>x</code> and <code>y</code> with respect to the lower image.
		 The output is painted in the own <code>lower</code> 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
		     		@short    Blend an image into another one, using alpha in the expected way and  over coordinates <code>x</code> and <code>y</code> with respect to the lower image.
	*/
	public static native boolean blendOnLower(int x, int y, TQImage upper, TQImage 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.
				@short    Blend part of an image into part of another, using the alpha channel in  the expected way.
	*/
	public static native void blendOnLower(TQImage upper, TQPoint upperOffset, TQImage lower, TQRect 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.
				@short    Blend part of an image into part of another, using the opacity value  and the alpha channel in the expected way.
	*/
	public static native void blendOnLower(TQImage upper, TQPoint upperOffset, TQImage lower, TQRect lowerRect, float opacity);
	/**	
		 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.

		@short    Compute the destination rectangle where to draw the upper image on top  of another image using the given disposition.
	*/
	public static native TQRect computeDestinationRect(TQSize lowerSize, int disposition, TQImage 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.
				@short    Blend an image on top of another using a given disposition and a given  opacity.
	*/
	public static native void blendOnLower(TQImage upper, TQImage lower, int disposition, float opacity);
	/**	
		 Modifies the intensity of a pixmap's RGB channel component.
			@param image The TQImage to process.
			@param percent Percent value. Use a negative value to dim.
			@param channel Which channel(s) should be modified
				@return The <code>image</code>, provided for convenience.

		@author Daniel M. Duley (mosfet)
     
		@short    Modifies the intensity of a pixmap's RGB channel component.
	*/
	public static native TQImage channelIntensity(TQImage image, float percent, int channel);
	/**	
		 Fade an image to a certain background color.
			 The number of colors will not be changed.
			@param image The TQImage to process.
			@param val The strength of the effect. 0 <= val <= 1.
			@param color The background color.
				@return Returns the image(), provided for convenience.
     
		@short    Fade an image to a certain background color.
	*/
	public static native TQImage fade(TQImage image, float val, TQColor 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 TQImage 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.
		     		@short    This recolors a pixmap.
	*/
	public static native TQImage flatten(TQImage image, TQColor ca, TQColor cb, int ncols);
	public static native TQImage flatten(TQImage image, TQColor ca, TQColor cb);
	/**	
		 Build a hash on any given TQImage
			@param image The TQImage 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.
     
		@short    Build a hash on any given TQImage
	*/
	public static native TQImage hash(TQImage image, int lite, int spacing);
	public static native TQImage hash(TQImage image, int lite);
	public static native TQImage hash(TQImage image);
	/**	
		 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 TQImage to process.
			@param percent The percent value. Use a negative value to dim.
				@return Returns The image(), provided for convenience.

		@author Benjamin Roe (ben@benroe.com)
     
		@short    Either brighten or dim the image by a specified percent.
	*/
	public static native TQImage intensity(TQImage image, float percent);
	/**	
		 Modulate the image with a color channel of another image.
			@param image The TQImage to modulate and result.
			@param modImage The TQImage 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.
     
		@short    Modulate the image with a color channel of another image.
	*/
	public static native TQImage modulate(TQImage image, TQImage modImage, boolean reverse, int type, int factor, int channel);
	/**	
		 Convert an image to grayscale.
			@param image The TQImage to process.
			@param fast Set to <code>true</code> 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)
     
		@short    Convert an image to grayscale.
	*/
	public static native TQImage toGray(TQImage image, boolean fast);
	public static native TQImage toGray(TQImage image);
	/**	
		 Desaturate an image evenly.
			@param image The TQImage to process.
			@param desat A value between 0 and 1 setting the degree of desaturation
				@return Returns the image(), provided for convenience.
     
		@short    Desaturate an image evenly.
	*/
	public static native TQImage desaturate(TQImage image, float desat);
	public static native TQImage desaturate(TQImage image);
	/**	
		 Fast, but low quality contrast of an image. Also see contrastHSV.
			@param image The TQImage 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
     
		@short    Fast, but low quality contrast of an image.
	*/
	public static native TQImage contrast(TQImage image, int c);
	/**	
		 Dither an image using Floyd-Steinberg dithering for low-color
		 situations.
			@param image The TQImage to process.
			@param palette The color palette to use
			@param size The size of the palette
				@return Returns the image(), provided for convenience.
     
		@short    Dither an image using Floyd-Steinberg dithering for low-color  situations.
	*/
	public static native TQImage dither(TQImage image, TQColor palette, int size);
	/**	
		 Calculate the image for a selected image, for instance a selected icon
		 on the desktop.
			@param img the TQImage to select
			@param col the selected color, usually from TQColorGroup.highlight().
		     		@short    Calculate the image for a selected image, for instance a selected icon  on the desktop.
	*/
	public static native TQImage selectedImage(TQImage img, TQColor 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 TQImage to process.
			@param sharpen If true sharpness is increase, (spiffed). Otherwise
		 it is decreased, (dulled).
				@author Daniel M. Duley (mosfet)
     
		@short    High quality, expensive HSV contrast.
	*/
	public static native void contrastHSV(TQImage img, boolean sharpen);
	public static native void contrastHSV(TQImage img);
	/**	
		 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)
     
		@short    Normalises the pixel values to span the full range of color values.
	*/
	public static native void normalize(TQImage img);
	/**	
		 Performs histogram equalisation on the reference
		 image.
			@param img the image that is equalised
				@author Daniel M. Duley (mosfet)
     
		@short    Performs histogram equalisation on the reference  image.
	*/
	public static native void equalize(TQImage img);
	/**	
		 Thresholds the reference image. You can also threshold images by using
		 ThresholdDither in the various TQPixmap/TQImage convert methods, but this
		 lets you specify a threshold value.
			@param img The TQImage to process.
			@param value The threshold value.
				@author Daniel M. Duley (mosfet)
     
		@short    Thresholds the reference image.
	*/
	public static native void threshold(TQImage img, int value);
	public static native void threshold(TQImage img);
	/**	
		 Produces a 'solarization' effect seen when exposing a photographic
		 film to light during the development process.
			@param img The TQImage to process.
			@param factor The extent of the solarization (0-99.9)
				@author Daniel M. Duley (mosfet)
     
		@short    Produces a 'solarization' effect seen when exposing a photographic  film to light during the development process.
	*/
	public static native void solarize(TQImage img, double factor);
	public static native void solarize(TQImage img);
	/**	
		 Embosses the source image. This involves highlighting the edges
		 and applying various other enhancements in order to get a metal
		 effect.
			@param src The TQImage 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)
     
		@short    Embosses the source image.
	*/
	public static native TQImage emboss(TQImage src, double radius, double sigma);
	/**	
		 Convenience method.
		     		@short    Convenience method.
	*/
	public static native TQImage emboss(TQImage src);
	/**	
		 Minimizes speckle noise in the source image using the 8 hull
		 algorithm.
			@param src The TQImage to process.
				@return The despeckled image. The original is not changed.

		@author Daniel M. Duley (mosfet)
     
		@short    Minimizes speckle noise in the source image using the 8 hull  algorithm.
	*/
	public static native TQImage despeckle(TQImage src);
	/**	
		 Produces a neat little "charcoal" effect.
			@param src The TQImage 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)
     
		@short    Produces a neat little "charcoal" effect.
	*/
	public static native TQImage charcoal(TQImage src, double radius, double sigma);
	/**	
		 This is provided for binary compatability only! Use the above method
		 with a radius and sigma instead!
		     		@short    This is provided for binary compatability only! Use the above method  with a radius and sigma instead!
	*/
	public static native TQImage charcoal(TQImage src, double factor);
	public static native TQImage charcoal(TQImage src);
	/**	
		 Rotates the image by the specified amount
			@param src The TQImage to process.
			@param r The rotate direction.
				@return The rotated image. The original is not changed.

		@author Daniel M. Duley (mosfet)
     
		@short    Rotates the image by the specified amount
	*/
	public static native TQImage rotate(TQImage src, int r);
	/**	
		 Scales an image using simple pixel sampling. This does not produce
		 nearly as nice a result as TQImage.smoothScale(), but has the
		 advantage of being much faster - only a few milliseconds.
			@param src The TQImage 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)
     
		@short    Scales an image using simple pixel sampling.
	*/
	public static native TQImage sample(TQImage src, int w, int h);
	/**	
		 Adds noise to an image.
			@param src The TQImage 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)
     
		@short    Adds noise to an image.
	*/
	public static native TQImage addNoise(TQImage src, int type);
	public static native TQImage addNoise(TQImage src);
	/**	
		 Blurs an image by convolving pixel neighborhoods.
			@param src The TQImage 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)
     
		@short    Blurs an image by convolving pixel neighborhoods.
	*/
	public static native TQImage blur(TQImage src, double radius, double sigma);
	/**	
		 This is provided for binary compatability only! Use the above method
		 with a radius and sigma instead!
		     		@short    This is provided for binary compatability only! Use the above method  with a radius and sigma instead!
	*/
	public static native TQImage blur(TQImage src, double factor);
	public static native TQImage blur(TQImage src);
	/**	
		 Detects edges in an image using pixel neighborhoods and an edge
		 detection mask.
			@param src The TQImage 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)
     
		@short    Detects edges in an image using pixel neighborhoods and an edge  detection mask.
	*/
	public static native TQImage edge(TQImage src, double radius);
	/**	
		 Implodes an image by a specified percent.
			@param src The TQImage 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)
     
		@short    Implodes an image by a specified percent.
	*/
	public static native TQImage implode(TQImage src, double factor, int background);
	public static native TQImage implode(TQImage src, double factor);
	public static native TQImage implode(TQImage src);
	/**	
		 Produces an oil painting effect.
			@param src The TQImage 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)
     
		@short    Produces an oil painting effect.
	*/
	public static native TQImage oilPaintConvolve(TQImage src, double radius);
	/**	
		 This is provided for binary compatability only! Use the above method
		 instead!
		     		@short    This is provided for binary compatability only! Use the above method  instead!
	*/
	public static native TQImage oilPaint(TQImage src, int radius);
	public static native TQImage oilPaint(TQImage src);
	/**	
		 Sharpens the pixels in the image using pixel neighborhoods.
			@param src The TQImage 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)
     
		@short    Sharpens the pixels in the image using pixel neighborhoods.
	*/
	public static native TQImage sharpen(TQImage src, double radius, double sigma);
	/**	
		 This is provided for binary compatability only! Use the above method
		 instead!
		     		@short    This is provided for binary compatability only! Use the above method  instead!
	*/
	public static native TQImage sharpen(TQImage src, double factor);
	public static native TQImage sharpen(TQImage src);
	/**	
		 Randomly displaces pixels.
			@param src The TQImage 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)
     
		@short    Randomly displaces pixels.
	*/
	public static native TQImage spread(TQImage src, int amount);
	public static native TQImage spread(TQImage src);
	/**	
		 Shades the image using a distance light source.
			@param src The TQImage 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)
     
		@short    Shades the image using a distance light source.
	*/
	public static native TQImage shade(TQImage src, boolean color_shading, double azimuth, double elevation);
	public static native TQImage shade(TQImage src, boolean color_shading, double azimuth);
	public static native TQImage shade(TQImage src, boolean color_shading);
	public static native TQImage shade(TQImage src);
	/**	
		 Swirls the image by a specified amount
			@param src The TQImage 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)
     
		@short    Swirls the image by a specified amount
	*/
	public static native TQImage swirl(TQImage src, double degrees, int background);
	public static native TQImage swirl(TQImage src, double degrees);
	public static native TQImage swirl(TQImage src);
	/**	
		 Modifies the pixels along a sine wave.
			@param src The TQImage 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)
     
		@short    Modifies the pixels along a sine wave.
	*/
	public static native TQImage wave(TQImage src, double amplitude, double frequency, int background);
	public static native TQImage wave(TQImage src, double amplitude, double frequency);
	public static native TQImage wave(TQImage src, double amplitude);
	public static native TQImage wave(TQImage src);
	/**	
		 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>
     
		@short    A bumpmapping algorithm.
	*/
	public static native TQImage bumpmap(TQImage img, TQImage map, double azimuth, double elevation, int depth, int xofs, int yofs, int waterlevel, int ambient, boolean compensate, boolean invert, int type, boolean tiled);
	/** Deletes the wrapped C++ instance */
	protected native void finalize() throws InternalError;
	/** Delete the wrapped C++ instance ahead of finalize() */
	public native void dispose();
	/** Has the wrapped C++ instance been deleted? */
	public native boolean isDisposed();
}