magickimage.java

手机图像自动转换

    /**
     * Draws a primitive (line, rectangle, ellipse) on the image.
     * @return a boolean value to indicate success
     * @exception MagickException on error
     */
    public native boolean drawImage(DrawInfo aInfo)
	throws MagickException;

    /**
     * Finds edges in an image. Radius defines the radius of the convolution
     * filter. Use a radius of 0 and Edge() selects a suitable radius for you.
     *
     * @param raduis The radius of the pixel neighborhood.
     *
     * @return A new image with the edges hilighted.
     * @exception MagickException on error
     */
    public native MagickImage edgeImage(double raduis)
	throws MagickException;

    /**
     * Returns a grayscale image with a three-dimensional effect.
     * We convolve the image with a Gaussian operator of the given radius
     * and standard deviation (sigma). For reasonable results, radius
     * should be larger than sigma. Use a radius of 0 and Emboss() selects
     * a suitable radius for you.
     *
     * @param raduis The radius of the pixel neighborhood.
     * @param sigma The standard deviation of the Gaussian, in pixels
     *
     * @return A new, embossed, image.
     * @exception MagickException on error
     */
    public native MagickImage embossImage(double raduis, double sigma)
	throws MagickException;

    /**
     * Applies a digital filter that improves the quality of a noisy image.
     *
     * @return A new, enhanced, image.
     * @exception MagickException on error
     */
    public native MagickImage enhanceImage()
	throws MagickException;

    /**
     *  Performs histogram equalization.
     * @return a boolean value to indicate success
     * @exception MagickException on error
     */
    public native boolean equalizeImage()
	throws MagickException;

    /**
     * Creates a new image that reflects each scanline
     * in the vertical direction.
     * @return a new image that has been flipped
     * @exception MagickException on error
     */
    public native MagickImage flipImage()
	throws MagickException;

    /**
     * Creates a new image that reflects each scanline in the
     * horizontal direction 
     * @return a new image that has been flopped
     * @exception MagickException on error
     */
    public native MagickImage flopImage()
	throws MagickException;

    /**
     * Converts the reference image to gamma corrected colors.
     * @return a boolean value to indicate success
     * @exception MagickException on error
     */
    public native boolean gammaImage(String gamma)
	throws MagickException;

    /**
     * Blurs the image using a gaussian operator. The effectiveness of the
     * operator - and the amount of blurring - is controlled by selecting
     * a 'radius' and a 'sigma'. The radius sets the circle around each
     * pixel of the 'neighborhood' used for calculating an average pixel
     * color. Sigma determines how much the calculated average affects the
     * pixel.
     *
     * @param raduis The radius of the Gaussian, in pixels, not counting
     *               the center pixel
     * @param sigma The standard deviation of the Gaussian, in pixels.
     *
     * @return A new, blurred, image.
     * @exception MagickException on error
     */
    public native MagickImage gaussianBlurImage(double raduis, double sigma)
	throws MagickException;

    /**
     * Implodes the image's pixels about the center. 
     *
     * @param amount Amount of implosion if positive, explosion if negative.
     *
     * @return A new, imploded, image.
     * @exception MagickException on error
     */
    public native MagickImage implodeImage(double amount)
	throws MagickException;

    /**
     * Returns True if the image is grayscale otherwise False is returned.
     * @return a boolean value to indicate success
     * @exception MagickException on error
     */
    public native boolean isGrayImage()
	throws MagickException;

    /**
     * Returns True if the image is monochrome otherwise False is returned.
     * @return a boolean value to indicate success
     * @exception MagickException on error
     */
    public native boolean isMonochromeImage()
	throws MagickException;

    /**
     * Creates a new image that is a integral size greater
     * than an existing one. 
     *
     * @return a magnified image
     * @exception MagickException on error
     */
    public native MagickImage magnifyImage()
	throws MagickException;

    /**
     * Floodfills the designated area with a matte value.
     * @return a boolean value to indicate success
     * @exception MagickException on error
     */
    public native boolean matteFloodfillImage(PixelPacket target,
					      int matte,
					      int x,
					      int y,
					      int method)
	throws MagickException;

    /**
     * Changes the color value of any pixel that matches target
     * and is an immediate neighbor. If the method FillToBorderMethod
     * is specified, the color value is changed for any neighbor pixel
     * that does not match the bordercolor member of image.
     *
     * By default target must match a particular pixel color exactly.
     * However, in many cases two colors may differ by a small amount.
     * The fuzz member of image defines how much tolerance is acceptable to
     * consider two colors as the same.  For example, set fuzz to 10 and the
     * color red at intensities of 100 and 102 respectively are now
     * interpreted as the same color for the purposes of the floodfill.
     *
     * @param drawInfo The draw info
     * @param target The RGB value of the target colour
     * @param x the starting x location of the operation
     * @param y the starting y location of the operation
     * @param method either FloodfillMethod or FilltoBorderMethod
     * @return true or false depending on success or failure respectively
     * @throws MagickException if any error occurs
     * @see magick.PaintMethod
     */
    public native boolean colorFloodfillImage(DrawInfo drawInfo,
                                              PixelPacket target,
                                              int x,
                                              int y,
                                              int method)
        throws MagickException;

    /**
     * Applies a digital filter that improves the quality of a noisy image.
     * Each pixel is replaced by the median in a set of neighboring pixels
     * as defined by radius.
     *
     * @param radius The radius of the pixel neighborhood.
     *
     * @return A new, filtered, image.
     * @exception MagickException on error
     */
    public native MagickImage medianFilterImage(double radius)
	throws MagickException;

    /**
     * Creates a new image that is a integral size less than an existing one.
     * @return a minified image
     * @exception MagickException on error
     */
    public native MagickImage minifyImage()
	throws MagickException;

    /**
     * Modulates the hue, saturation, and brightness of an image.
     * @return a boolean value to indicate success
     * @exception MagickException on error
     */
    public native boolean modulateImage(String modulate)
	throws MagickException;

    /**
     * Negates the colors in the reference image. The Grayscale
     * option means that only grayscale values within the image are negated.
     * @return a boolean value to indicate success
     * @exception MagickException on error
     */
    public native boolean negateImage(int grayscale)
	throws MagickException;

    /**
     * Normalizes the pixel values to span the full range of color values. 
     * This is a contrast enhancement technique.
     * @return a boolean value to indicate success
     * @exception MagickException on error
     */
    public native boolean normalizeImage()
	throws MagickException;

    /**
     * Applies a special effect filter that simulates an oil painting.
     * Each pixel is replaced by the most frequent color occurring in a
     * circular region defined by radius.
     *
     * @param radius The radius of the pixel neighborhood.
     *
     * @return A new, simulated oil-painting, image.
     * @exception MagickException on error
     */
    public native MagickImage oilPaintImage(double radius)
	throws MagickException;

    /**
     * Changes the color of an opaque pixel to the pen color.
     * @param target the color to search for in the image
     * @param penColor the color to replace it with
     * @return a boolean value to indicate success
     * @exception MagickException on error
     */
    public native boolean opaqueImage(PixelPacket target, PixelPacket penColor)
	throws MagickException;

    /**
     * This operation attempts to reduce the 'noise' in the image. This
     * can be used to eliminate minor dust and scratches from scanned
     * images.
     *<p>
     * The principal function of the noise peak elimination filter is to
     * smooth the objects within an image without losing edge information
     * and without creating undesired structures. The central idea of the
     * algorithm is to replace a pixel with its next neighbor in value in
     * a circular neighborhood if this pixel has been found to be noise. A
     * pixel is defined as noise if the pixel is a minimum or maximum
     * within the neighborhood.
     *
     * @param radius The radius of the pixel neighborhood.
     *
     * @return A new, filtered, image.
     * @exception MagickException on error
     */
    public native MagickImage reduceNoiseImage(double radius)
	throws MagickException;

    /**
     * Converts the reference image from RGB to an alternate colorspace.
     * The transformation matrices are not the standard ones: the weights
     * are rescaled to normalized the range of the transformed values to
     * be [0..MaxRGB].
     * @param colorspace the target colorspace to transform to
     * @return a boolean value to indicate success
     * @exception MagickException on error
     */
    public native boolean rgbTransformImage(int colorspace)
	throws MagickException;

    /**
     * Rolls an image vertically and horizontally.
     * @param xOffset An integer that specifies the number of columns \
                      to roll in the horizontal direction
     * @param yOffset An integer that specifies the number of rows to \
                      roll in the vertical direction
     * @return the rolled image
     * @exception MagickException on error
     */
    public native MagickImage rollImage(int xOffset, int yOffset)
	throws MagickException;

    /**
     * Creates a new image that is a scaled size of an existing one
     * using pixel sampling.
     * @param cols An integer that specifies the number of columns in \
                   the sampled image
     * @param rows An integer that specifies the number of rows in the \
                   sampled image
     * @return the sampled image
     * @exception MagickException on error
     */
    public native MagickImage sampleImage(int cols, int rows)
	throws MagickException;

    /**
     * Return a new image that is a scaled version of the
     * original. To scale a scanline from x pixels to y pixels, each new
     * pixel represents x/y old pixels. To read x/y pixels, read
     * (x/y rounded up) pixels but only count the required fraction of
     * the last old pixel read in your new pixel. The remainder of the
     * old pixel will be counted in the next new pixel.
     * @param cols An integer that specifies the number of columns in \
                   the scaled image
     * @param rows An integer that specifies the number of rows in the \
                   scaled image
     * @return the scaled image
     * @exception MagickException on error
     */
    public native MagickImage scaleImage(int cols, int rows)
	throws MagickException;

    /**
     * Segment an image by analyzing the histograms of the color components
     * and identifying units that are homogeneous using the fuzzy c-means
     * technique.
     *
     * @param colorspace A {@link ColorspaceType} value that indicates the
     *                   colorspace. Empirical evidence suggests that
     *                   distances in YUV or YIQ correspond to perceptual
     *                   color differences more closely than do distances
     *                   in RGB space. The image is then returned to RGB
     *                   colorspace after color reduction.
     * @param cluster_threshold Specify cluster threshold as the number of
     *                   pixels in each cluster must exceed the the
     *                   cluster threshold to be considered valid.
     * @param smoothing_threshold Smoothing threshold eliminates noise in
     *                   the second derivative of the histogram. As the
     *                   value is increased, you can expect a smoother
     *                   second derivative. The default is 1.5.
     *
     * @return The actual number of colors allocated in the colormap.
     * @exception MagickException on error
     * @see ColorspaceType
     */
    public native int segmentImage(int colorspace, double cluster_threshold,
                                                   double smoothing_threshold)
	throws MagickException;

    /**
     * Applies a special effect to the image, similar to the effect achieved
     * in a photo darkroom by selectively exposing areas of photo sensitive
     * paper to light.
     *
     * @param threshold Ranges from 0 to MaxRGB and is a measure of the
     *                  extent of the solarization.
     *
     * @exception MagickException on error
     */
    public native void solarizeImage(double threshold)
	throws MagickException;

    /**
     * Sorts the colormap of a PseudoClass image by decreasing
     * color intensity.
     * @return a boolean value indicating success
     * @exception MagickException on error
     */
    public native boolean sortColormapByIntensity()
	throws MagickException;

    /**
     * A special effects method that randomly displaces each pixel in a
     * block defined by the radius parameter.
     *
     * @param radius Choose a random pixel in a neighborhood of this extent.
     *
     * @return A new, spread, image.
     * @exception MagickException on error
     */
    public native MagickImage spreadImage(int radius)
	throws MagickException;

    /**
     * Swirls the pixels about the center of the image, where degrees
     * indicates the sweep of the arc through which each pixel is moved.
     * You get a more dramatic effect as the degrees move from 1 to 360.
     *
     * @param degrees Defines the tightness of the swirling effect.
     *
     * @return A new, swirled, image.
     * @exception MagickException on error
     */
    public native MagickImage swirlImage(double degress)
	throws MagickException;

    /**
     * Initializes the red, green, and blue intensities of each
     * pixel as defined by the colormap index.
     * @exception MagickException on error
     */
    public native void syncImage()
      throws MagickException;