magick

Class MagickImage

java.lang.Object
- magick.Magick
- - magick.MagickImage

public class MagickImage

extends Magick

Encapsulation of the ImageMagick Image object. We use MagickImage here so as not to be confused with java.awt.Image.

Author:: Eric Yeo

Constructor Summary
`MagickImage()` Constructor.
`MagickImage(ImageInfo imageInfo)` Constructor that also reads an image file specified in the parameter.
`MagickImage(ImageInfo imageInfo, boolean ping)` Constructor that also reads an image file specified in the parameter.
`MagickImage(ImageInfo imageInfo, byte[] blob)` Constructor that takes the image to be read from memory.
`MagickImage(MagickImage[] images)` Construct a MagickImage that is made up of all the images in the specified array.

Method Summary
`MagickImage`	`addNoiseImage(int noiseType)` Adds random noise to the image.
`void`	`allocateImage(ImageInfo imageInfo)` Allocate a blank image object.
`void`	`annotateImage(DrawInfo info)`
`MagickImage`	`averageImages()` The Average() method takes a set of images and averages them together.
`void`	`blobToImage(ImageInfo imageInfo, byte[] blob)` Takes from memory an image in a known format and read it into itself.
`MagickImage`	`blurImage(double raduis, double sigma)` Blurs an image.
`MagickImage`	`borderImage(Rectangle borderInfo)` Surrounds the image with a border of the color defined by the border color member of the image structure.
`MagickImage[]`	`breakFrames()` Destructively create array of image frames.
`MagickImage`	`charcoalImage(double raduis, double sigma)` Creates a new image that is a copy of an existing one with the edges highlighted, producing a 'charcoal-drawing' effect.
`MagickImage`	`chopImage(Rectangle chopInfo)` Creates a new image that is a subregion of the original.
`MagickImage`	`cloneImage(int columns, int rows, boolean clonePixels)` Returns a copy of all fields of the input image.
`boolean`	`colorFloodfillImage(DrawInfo drawInfo, PixelPacket target, int x, int y, int method)` Changes the color value of any pixel that matches target and is an immediate neighbor.
`MagickImage`	`colorizeImage(String opacity, PixelPacket target)` Colourises the image with a pen colour.
`boolean`	`compositeImage(int compOp, MagickImage compImage, int xOff, int yOff)` Composite the image supplied onto itself at the specified offsets.
`void`	`constituteImage(int width, int height, String map, byte[] pixels)` Create a new image of 8-bit component of the specified dimensions.
`void`	`constituteImage(int width, int height, String map, float[] pixels)` Create a new image of float component of the specified dimensions.
`void`	`constituteImage(int width, int height, String map, int[] pixels)` Create a new image of 32-bit component of the specified dimensions.
`boolean`	`contrastImage(boolean sharpen)` Enhances the intensity differences between the lighter and darker elements of the image.
`MagickImage`	`convolveImage(int order, double[] kernel)` Applies a general image convolution kernel to an image returns the results.
`MagickImage`	`cropImage(Rectangle chopInfo)` Creates a new image that is a subregion of the original.
`void`	`cycleColormapImage(int amount)` Cycles the image colormap by a specified amount.
`MagickImage`	`despeckleImage()` Creates a new image that is a copy of an existing one with the speckle noise minified.
`void`	`destroyImages()` Called by finalize to deallocate the image handle.
`boolean`	`dispatchImage(int x, int y, int width, int height, String map, byte[] pixels)` Get the pixels as 8-bit components from the image.
`boolean`	`dispatchImage(int x, int y, int width, int height, String map, float[] pixels)` Get the pixels as float components from the image.
`boolean`	`dispatchImage(int x, int y, int width, int height, String map, int[] pixels)` Get the pixels as 32-bit components from the image.
`boolean`	`drawImage(DrawInfo aInfo)` Draws a primitive (line, rectangle, ellipse) on the image.
`MagickImage`	`edgeImage(double raduis)` Finds edges in an image.
`MagickImage`	`embossImage(double raduis, double sigma)` Returns a grayscale image with a three-dimensional effect.
`MagickImage`	`enhanceImage()` Applies a digital filter that improves the quality of a noisy image.
`boolean`	`equalizeImage()` Performs histogram equalization.
`protected void`	`finalize()` This method will clean up the handle.
`MagickImage`	`flipImage()` Creates a new image that reflects each scanline in the vertical direction.
`MagickImage`	`flopImage()` Creates a new image that reflects each scanline in the horizontal direction
`boolean`	`gammaImage(String gamma)` Converts the reference image to gamma corrected colors.
`MagickImage`	`gaussianBlurImage(double raduis, double sigma)` Blurs the image using a gaussian operator.
`PixelPacket`	`getBackgroundColor()` Get the current background colour.
`PixelPacket`	`getBorderColor()` Get the current border colour used by method borderImage.
`ProfileInfo`	`getColorProfile()` Obtain the color profile from the image.
`PixelPacket[]`	`getColormap()` Get the entire colour map.
`PixelPacket`	`getColormap(int index)` Get the colour specified by the index.
`int`	`getColors()` The number of colors in the colourmap.
`int`	`getColorspace()` Get the colorspace of the image.
`int`	`getCompression()` Get the CompressionType of the image.
`int`	`getDelay()` Get the time in 1/100ths of a second (0 to 65535) which must expire before displaying the next image in an animated sequence.
`int`	`getDepth()` Return the depth of the image.
`Dimension`	`getDimension()`
`int`	`getDispose()` Get the GIF disposal method.
`String`	`getFileName()` Return the image file name of the image.
`int`	`getFilter()`
`ProfileInfo`	`getGenericProfile(int i)` Return the generic profile specified by the index.
`int`	`getGenericProfileCount()` Return the number of generic profiles.
`String`	`getImageAttribute(String key)` Searches the list of image attributes and returns the value of the attribute if it exists otherwise null.
`String`	`getImageFormat()`
`int`	`getImageType()` Get the image type from the MagickImage
`ProfileInfo`	`getIptcProfile()` Obtain the IPTC profile from the image.
`int`	`getIterations()` Get the number of iterations to loop an animation (e.g.
`String`	`getMagick()` Return the image format (i.e., Gif, Jpeg,...)
`int`	`getNumFrames()`
`int`	`getNumberColors()` Return the number of unique colors in an image.
`PixelPacket`	`getOnePixel(int x, int y)` Get the colour at the specified row and column
`int`	`getQuality()`
`int`	`getStorageClass()` Return the storage class of the image.
`int`	`getTotalColors()` Get the The number of colors in the image after QuantizeImage(), or QuantizeImages().
`int`	`getUnits()` Get the units attribute of the image.
`double`	`getXResolution()` Get the x_resolution attribute in the image.
`double`	`getYResolution()` Get the y_resolution attribute in the image.
`boolean`	`hasFrames()` Check if the image has multiple frames.
`byte[]`	`imageToBlob(ImageInfo imageInfo)` Returns an array that contents the image format.
`MagickImage`	`implodeImage(double amount)` Implodes the image's pixels about the center.
`boolean`	`isAnimatedImage()` Returns True if the Gif image is Animated otherwise False is returned.
`boolean`	`isGrayImage()` Returns True if the image is grayscale otherwise False is returned.
`boolean`	`isMonochromeImage()` Returns True if the image is monochrome otherwise False is returned.
`boolean`	`levelImage(String levels)` Adjusts the levels of an image given these points: black, mid, and white.
`MagickImage`	`magnifyImage()` Creates a new image that is a integral size greater than an existing one.
`boolean`	`matteFloodfillImage(PixelPacket target, int matte, int x, int y, int method)` Floodfills the designated area with a matte value.
`MagickImage`	`medianFilterImage(double radius)` Applies a digital filter that improves the quality of a noisy image.
`MagickImage`	`minifyImage()` Creates a new image that is a integral size less than an existing one.
`boolean`	`modulateImage(String modulate)` Modulates the hue, saturation, and brightness of an image.
`MagickImage`	`montageImages(MontageInfo montageInfo)` Create a montage of all the images in the list.
`boolean`	`negateImage(int grayscale)` Negates the colors in the reference image.
`protected MagickImage`	`nextImage()` Return image object for next image in sequence of frames.
`boolean`	`normalizeImage()` Normalizes the pixel values to span the full range of color values.
`MagickImage`	`oilPaintImage(double radius)` Applies a special effect filter that simulates an oil painting.
`boolean`	`opaqueImage(PixelPacket target, PixelPacket penColor)` Changes the color of an opaque pixel to the pen color.
`void`	`pingImage(ImageInfo imageInfo)` Pings the image.
`boolean`	`profileImage(String profileName, byte[] profileData)` ProfileImage adds or removes a ICM, IPTC, or generic profile from an image.
`boolean`	`quantizeImage(QuantizeInfo quantizeInfo)` Analyzes the colors within a reference image and chooses a fixed number of colors to represent the image.
`boolean`	`raiseImage(Rectangle raiseInfo, boolean raise)` Creates a simulated three-dimensional button-like effect by lightening and darkening the edges of the image.
`void`	`readImage(ImageInfo imageInfo)` Read the image specified in the ImageInfo object.
`MagickImage`	`reduceNoiseImage(double radius)` This operation attempts to reduce the 'noise' in the image.
`boolean`	`rgbTransformImage(int colorspace)` Converts the reference image from RGB to an alternate colorspace.
`MagickImage`	`rollImage(int xOffset, int yOffset)` Rolls an image vertically and horizontally.
`MagickImage`	`rotateImage(double degrees)` Creates a new image that is a rotated copy of an existing one.
`MagickImage`	`sampleImage(int cols, int rows)` Creates a new image that is a scaled size of an existing one using pixel sampling.
`MagickImage`	`scaleImage(int cols, int rows)` Return a new image that is a scaled version of the original.
`int`	`segmentImage(int colorspace, double cluster_threshold, double smoothing_threshold)` Segment an image by analyzing the histograms of the color components and identifying units that are homogeneous using the fuzzy c-means technique.
`void`	`setBackgroundColor(PixelPacket color)` Set the background colour.
`void`	`setBorderColor(PixelPacket color)` Set the border colour for the method borderImage.
`void`	`setColorProfile(ProfileInfo profile)` Set a new color profile for the image.
`void`	`setCompression(int value)` Set the compression attribute.
`void`	`setDelay(int delay)` Set the time in 1/100ths of a second (0 to 65535) which must expire before displaying the next image in an animated sequence.
`void`	`setDispose(int dispose)` Set the GIF disposal method.
`void`	`setFileName(String fileName)`
`void`	`setFilter(int filter)`
`void`	`setGrayscale()` Deprecated. Use QuantizeInfo with MagickImage.quantizeImage to acheive the same effect.
`boolean`	`setImageAttribute(String key, String value)` Searches the list of image attributes and replaces the attribute value.
`void`	`setImageFormat(String imageFormat)`
`void`	`setIptcProfile(ProfileInfo profile)` Set a new IPTC profile for the image.
`void`	`setIterations(int iterations)` Set the number of iterations to loop an animation (e.g.
`void`	`setMagick(String imageFormat)`
`void`	`setNumberColors(int numberColors)`
`void`	`setUnits(int resolutionType)` Set the units attribute of the image.
`void`	`setXResolution(double xRes)` Set the x_resolution attribute in the image.
`void`	`setYResolution(double yRes)` Get the y_resolution attribute in the image.
`MagickImage`	`sharpenImage(double raduis, double sigma)` Creates a new image that is a copy of an existing one with the pixels sharpened.
`MagickImage`	`shearImage(double x_shear, double y_shear)` Creates a new image that is a shear_image copy of an existing one.
`boolean`	`signatureImage()` Determine signature of image and place signature in the image's attributes.
`int`	`sizeBlob()` Returns the current length of the image file or blob.
`void`	`solarizeImage(double threshold)` 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.
`boolean`	`sortColormapByIntensity()` Sorts the colormap of a PseudoClass image by decreasing color intensity.
`MagickImage`	`spreadImage(int radius)` A special effects method that randomly displaces each pixel in a block defined by the radius parameter.
`MagickImage`	`swirlImage(double degress)` Swirls the pixels about the center of the image, where degrees indicates the sweep of the arc through which each pixel is moved.
`void`	`syncImage()` Initializes the red, green, and blue intensities of each pixel as defined by the colormap index.
`void`	`textureImage(MagickImage image)` Layers a texture onto the background of an image.
`boolean`	`thresholdImage(double threshold)` Thresholds the reference image.
`void`	`transformImage(String cropGeometry, String imageGeometry)` Creates a new image that is a transformed size of of existing one as specified by the crop and image geometries.
`boolean`	`transformRgbImage(int colorspace)` Converts the reference image from an alternate colorspace.
`boolean`	`transparentImage(PixelPacket color, int opacity)` Creates a matte image associated with the image.
`MagickImage`	`unsharpMaskImage(double raduis, double sigma, double amount, double threshold)` Creates a new image that is a copy of an existing one with the pixels sharpened using an "unsharp" masking technique.
`MagickImage`	`waveImage(double amplitude, double wavelength)` Creates a "ripple" effect in the image by shifting the pixels vertically along a sine wave whose amplitude and wavelength is specified by the given parameters.
`boolean`	`writeImage(ImageInfo imageInfo)` Write the image specified in the ImageInfo object.
`MagickImage`	`zoomImage(int cols, int rows)` Creates a new image that is a scaled size of an existing one.

Methods inherited from class magick.Magick
`parseImageGeometry`

MagickImage

public MagickImage()

Constructor.

MagickImage

public MagickImage(ImageInfo imageInfo)
            throws MagickException

Constructor that also reads an image file specified in the parameter.
Parameters:
imageInfo - the ImageInfo for an image file to read
Throws:
MagickException - on error on error

MagickImage

public MagickImage(ImageInfo imageInfo,
                   boolean ping)
            throws MagickException

Constructor that also reads an image file specified in the parameter.
Parameters:
imageInfo - the ImageInfo for an image file to read
Throws:
MagickException - on error

MagickImage

public MagickImage(ImageInfo imageInfo,
                   byte[] blob)
            throws MagickException

Constructor that takes the image to be read from memory.
Parameters:
imageInfo - the ImageInfo instance for default settings, etc
blob - the image to be read in memory
Throws:
MagickException - on error

MagickImage

public MagickImage(MagickImage[] images)
            throws MagickException

Construct a MagickImage that is made up of all the images in the specified array. If any of the images contains multiple frames, the frames are also appended to the new image. All the images are cloned.
Parameters:
images - array of images to linked

addNoiseImage

public MagickImage addNoiseImage(int noiseType)
            throws MagickException

Adds random noise to the image.
Parameters:
noiseType - The type of noise: Uniform, Gaussian, Multiplicative, Impulse, Laplacian, or Poisson.
Returns:
An image with additional noise.
Throws:
MagickException - on error
See Also:
NoiseType

allocateImage

public void allocateImage(ImageInfo imageInfo)

Allocate a blank image object.
Parameters:
imageInfo - specifies the parameters for the blank image

annotateImage

public void annotateImage(DrawInfo info)

averageImages

public MagickImage averageImages()
            throws MagickException

The Average() method takes a set of images and averages them together. Each image in the set must have the same width and height.
Returns:
an image with the pixel component of each image averaged.
Throws:
MagickException - upon errors

blobToImage

public void blobToImage(ImageInfo imageInfo,
                        byte[] blob)
            throws MagickException

Takes from memory an image in a known format and read it into itself.
Parameters:
imageInfo - a ImageInfo instance
blob - memory containing an image in a known format
Throws:
MagickException - on error

blurImage

public MagickImage blurImage(double raduis,
                             double sigma)
            throws MagickException

Blurs an image. We convolve the image with a Gaussian operator of the given radius and standard deviation (sigma). For reasonable results, the radius should be larger than sigma. Use a radius of 0 and BlurImage() selects a suitable radius for you.
Parameters:
raduis - The radius of the gaussian, in pixels, not counting the center pixel
sigma - The standard deviation of the gaussian, in pixels
Returns:
A blurred image.
Throws:
MagickException - on error

borderImage

public MagickImage borderImage(Rectangle borderInfo)
            throws MagickException

Surrounds the image with a border of the color defined by the border color member of the image structure. The width and height of the border are defined by the corresponding members of the Rectangle.
Parameters:
borderInfo - the rectangle for which border is drawn
Returns:
an Image with a border around it
Throws:
MagickException - on error
See Also:
setBorderColor(PixelPacket), getBorderColor()

breakFrames

public MagickImage[] breakFrames()
            throws MagickException

Destructively create array of image frames. Contains this image as the first object and frames in sequence.
Returns:
an array of image frame
Throws:
MagickException - on error

charcoalImage

public MagickImage charcoalImage(double raduis,
                                 double sigma)
            throws MagickException

Creates a new image that is a copy of an existing one with the edges highlighted, producing a 'charcoal-drawing' effect.
Parameters:
raduis - The radius of the pixel neighborhood.
sigma - The standard deviation of the gaussian, in pixels
Returns:
A charcoal-like image.
Throws:
MagickException - on error

chopImage

public MagickImage chopImage(Rectangle chopInfo)
            throws MagickException

Creates a new image that is a subregion of the original.
Parameters:
chopInfo - the rectange to chop the image
Throws:
MagickException - on error

cloneImage

public MagickImage cloneImage(int columns,
                              int rows,
                              boolean clonePixels)
            throws MagickException

Returns a copy of all fields of the input image. The the pixel memory is allocated but the pixel data is copy is optional.
Returns:
a cloned image
Throws:
MagickException - on error

colorFloodfillImage

public boolean colorFloodfillImage(DrawInfo drawInfo,
                                   PixelPacket target,
                                   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.
Parameters:
drawInfo - The draw info
target - The RGB value of the target colour
x - the starting x location of the operation
y - the starting y location of the operation
method - either FloodfillMethod or FilltoBorderMethod
Returns:
true or false depending on success or failure respectively
Throws:
MagickException - if any error occurs
See Also:
PaintMethod

colorizeImage

public MagickImage colorizeImage(String opacity,
                                 PixelPacket target)
            throws MagickException

Colourises the image with a pen colour.
Parameters:
opacity - string percentage value for opacity
target - a colour value
Throws:
MagickException - on error

compositeImage

public boolean compositeImage(int compOp,
                              MagickImage compImage,
                              int xOff,
                              int yOff)
            throws MagickException

Composite the image supplied onto itself at the specified offsets.
Throws:
MagickException - on error

constituteImage

public void constituteImage(int width,
                            int height,
                            String map,
                            byte[] pixels)
            throws MagickException

Create a new image of 8-bit component of the specified dimensions.
Parameters:
width - the width of the new image
height - the height of the new image
map - the components of a pixel
pixels - the raw image in an array of pixels
Throws:
MagickException - on error

constituteImage

public void constituteImage(int width,
                            int height,
                            String map,
                            float[] pixels)
            throws MagickException

Create a new image of float component of the specified dimensions.
Parameters:
width - the width of the new image
height - the height of the new image
map - the components of a pixel
pixels - the raw image in an array of pixels
Throws:
MagickException - on error

constituteImage

public void constituteImage(int width,
                            int height,
                            String map,
                            int[] pixels)
            throws MagickException

Create a new image of 32-bit component of the specified dimensions.
Parameters:
width - the width of the new image
height - the height of the new image
map - the components of a pixel
pixels - the raw image in an array of pixels
Throws:
MagickException - on error

contrastImage

public boolean contrastImage(boolean sharpen)
            throws MagickException

Enhances the intensity differences between the lighter and darker elements of the image.
Returns:
a boolean value to indicate success
Throws:
MagickException - on error

convolveImage

public MagickImage convolveImage(int order,
                                 double[] kernel)
            throws MagickException

Applies a general image convolution kernel to an image returns the results. ConvolveImage allocates the memory necessary for the new Image structure and returns a pointer to the new image.
Parameters:
order - The number of columns and rows in the filter kernel.
kernel - An array of double representing the convolution kernel
Returns:
a convoled image
Throws:
MagickException - on error

cropImage

public MagickImage cropImage(Rectangle chopInfo)
            throws MagickException

Creates a new image that is a subregion of the original.
Parameters:
chopInfo - the subimage
Returns:
a subimage of the original
Throws:
MagickException - on error

cycleColormapImage

public void cycleColormapImage(int amount)
            throws MagickException

Cycles the image colormap by a specified amount.
Throws:
MagickException - on error

despeckleImage

public MagickImage despeckleImage()
            throws MagickException

Creates a new image that is a copy of an existing one with the speckle noise minified. It uses the eight hull algorithm described in Applied Optics, Vol. 24, No. 10, 15 May 1985, ``Geometric filter for Speckle Reduction'', by Thomas R Crimmins. Each pixel in the image is replaced by one of its eight of its surrounding pixels using a polarity and negative hull function.
Returns:
a despeckled image
Throws:
MagickException - on error

destroyImages

public void destroyImages()

Called by finalize to deallocate the image handle.

dispatchImage

public boolean dispatchImage(int x,
                             int y,
                             int width,
                             int height,
                             String map,
                             byte[] pixels)
            throws MagickException

Get the pixels as 8-bit components from the image.
Parameters:
x - x coordinate of the origin of the subimage
y - y coordinate of the origin of the subimage
width - width of the subimage
height - height of the subimage
map - component order of the pixels
pixels - pixels of the subimage
Returns:
a boolean value indicating success
Throws:
MagickException - on error

dispatchImage

public boolean dispatchImage(int x,
                             int y,
                             int width,
                             int height,
                             String map,
                             float[] pixels)
            throws MagickException

Get the pixels as float components from the image.
Parameters:
x - x coordinate of the origin of the subimage
y - y coordinate of the origin of the subimage
width - width of the subimage
height - height of the subimage
map - component order of the pixels
pixels - pixels of the subimage
Returns:
a boolean value indicating success
Throws:
MagickException - on error

dispatchImage

public boolean dispatchImage(int x,
                             int y,
                             int width,
                             int height,
                             String map,
                             int[] pixels)
            throws MagickException

Get the pixels as 32-bit components from the image.
Parameters:
x - x coordinate of the origin of the subimage
y - y coordinate of the origin of the subimage
width - width of the subimage
height - height of the subimage
map - component order of the pixels
pixels - pixels of the subimage
Returns:
a boolean value indicating success
Throws:
MagickException - on error

drawImage

public boolean drawImage(DrawInfo aInfo)
            throws MagickException

Draws a primitive (line, rectangle, ellipse) on the image.
Returns:
a boolean value to indicate success
Throws:
MagickException - on error

edgeImage

public MagickImage edgeImage(double raduis)
            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.
Parameters:
raduis - The radius of the pixel neighborhood.
Returns:
A new image with the edges hilighted.
Throws:
MagickException - on error

embossImage

public MagickImage embossImage(double raduis,
                               double sigma)
            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.
Parameters:
raduis - The radius of the pixel neighborhood.
sigma - The standard deviation of the Gaussian, in pixels
Returns:
A new, embossed, image.
Throws:
MagickException - on error

enhanceImage

public MagickImage enhanceImage()
            throws MagickException

Applies a digital filter that improves the quality of a noisy image.
Returns:
A new, enhanced, image.
Throws:
MagickException - on error

equalizeImage

public boolean equalizeImage()
            throws MagickException

Performs histogram equalization.
Returns:
a boolean value to indicate success
Throws:
MagickException - on error

finalize

protected void finalize()

This method will clean up the handle.

flipImage

public MagickImage flipImage()
            throws MagickException

Creates a new image that reflects each scanline in the vertical direction.
Returns:
a new image that has been flipped
Throws:
MagickException - on error

flopImage

public MagickImage flopImage()
            throws MagickException

Creates a new image that reflects each scanline in the horizontal direction
Returns:
a new image that has been flopped
Throws:
MagickException - on error

gammaImage

public boolean gammaImage(String gamma)
            throws MagickException

Converts the reference image to gamma corrected colors.
Returns:
a boolean value to indicate success
Throws:
MagickException - on error

gaussianBlurImage

public MagickImage gaussianBlurImage(double raduis,
                                     double sigma)
            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.
Parameters:
raduis - The radius of the Gaussian, in pixels, not counting the center pixel
sigma - The standard deviation of the Gaussian, in pixels.
Returns:
A new, blurred, image.
Throws:
MagickException - on error

getBackgroundColor

public PixelPacket getBackgroundColor()
            throws MagickException

Get the current background colour.
Returns:
the current background colour
Throws:
MagickException - on error

getBorderColor

public PixelPacket getBorderColor()
            throws MagickException

Get the current border colour used by method borderImage.
Returns:
the current border colour
Throws:
MagickException - on error
See Also:
borderImage(Rectangle)

getColorProfile

public ProfileInfo getColorProfile()
            throws MagickException

Obtain the color profile from the image.
Returns:
the color profile of the image
Throws:
MagickException - if an error occurs
See Also:
profileImage(String,byte[])

getColormap

public PixelPacket[] getColormap()
            throws MagickException

Get the entire colour map.
Returns:
the colour map of the image
Throws:
MagickException - upon error

getColormap

public PixelPacket getColormap(int index)
            throws MagickException

Get the colour specified by the index.
Parameters:
index - the index for which to return a colour
Returns:
the colour of the index
Throws:
MagickException - upon error

getColors

public int getColors()
            throws MagickException

The number of colors in the colourmap.
Returns:
the current number of colors in the image
Throws:
MagickException - upon error
See Also:
quantizeImage(QuantizeInfo)

getColorspace

public int getColorspace()
            throws MagickException

Get the colorspace of the image.
Returns:
the colorspace as defined in ColorspaceType
Throws:
MagickException - on error

getCompression

public int getCompression()
            throws MagickException

Get the CompressionType of the image.
Returns:
the compression as defined in CompressionType
Throws:
MagickException - on error
Author:
Susan Dorr
See Also:
CompressionType

getDelay

public int getDelay()
            throws MagickException

Get the time in 1/100ths of a second (0 to 65535) which must expire before displaying the next image in an animated sequence. This option is useful for regulating the animation of a sequence of GIF images within Netscape.
Parameters:
Throws:
MagickException - upon error

getDepth

public int getDepth()
            throws MagickException

Return the depth of the image.
Returns:
the depth of the image.
Throws:
MagickException - on error

getDimension

public Dimension getDimension()
            throws MagickException

getDispose

public int getDispose()
            throws MagickException

Get the GIF disposal method. This option is used to control how successive frames are rendered (how the preceding frame is disposed of) when creating a GIF animation.
Returns:
the current disposal method for GIF animation
Throws:
MagickException - upon error

getFileName

public String getFileName()
            throws MagickException

Return the image file name of the image.
Returns:
the file name of the image
Throws:
MagickException - on error

getFilter

public int getFilter()
            throws MagickException

getGenericProfile

public ProfileInfo getGenericProfile(int i)
            throws MagickException

Return the generic profile specified by the index.
Parameters:
Returns:
a generic ProfileInfo if found, null otheriwse.
Throws:
MagickException - if an error occurs

getGenericProfileCount

public int getGenericProfileCount()
            throws MagickException

Return the number of generic profiles.
Returns:
number of generic profiles
Throws:
MagickException - if the profile count cannot be retrieved

getImageAttribute

public String getImageAttribute(String key)
            throws MagickException

Searches the list of image attributes and returns the value of the attribute if it exists otherwise null.
Parameters:
key - the key of the attribute
Returns:
the value of the attribute if exists, otherwise, null.
Throws:
MagickException - on error

getImageFormat

public String getImageFormat()
            throws MagickException

getImageType

public int getImageType()
            throws MagickException

Get the image type from the MagickImage
Parameters:
Author:
Susan Dorr

getIptcProfile

public ProfileInfo getIptcProfile()
            throws MagickException

Obtain the IPTC profile from the image.
Returns:
the IPTC profile of the image
Throws:
MagickException - if an error occurs
See Also:
profileImage(String,byte[])

getIterations

public int getIterations()
            throws MagickException

Get the number of iterations to loop an animation (e.g. Netscape loop extension) for.
Returns:
the current number of iterations
Throws:
MagickException - upon error

getMagick

public String getMagick()
            throws MagickException

Return the image format (i.e., Gif, Jpeg,...)
Returns:
the string representing the image format
Throws:
MagickException - on error
Author:
Abdulbaset Gaddah

getNumFrames

public int getNumFrames()
            throws MagickException

getNumberColors

public int getNumberColors()
            throws MagickException

Return the number of unique colors in an image.
Returns:
the number of unique colors
Throws:
MagickException - on error
Author:
Abdulbaset Gaddah

getOnePixel

public PixelPacket getOnePixel(int x,
                               int y)
            throws MagickException

Get the colour at the specified row and column
Parameters:
x - the x position of the pixel to fetch
y - the y position of the pixel to fetch
Returns:
the colour of the index
Throws:
MagickException - upon error

getQuality

public int getQuality()
            throws MagickException

Returns:
the quality the image was saved
Throws:
MagickException - on error

getStorageClass

public int getStorageClass()
            throws MagickException

Return the storage class of the image.
Returns:
the store class as defined in ClassType
Throws:
MagickException - on error
See Also:
ClassType

getTotalColors

public int getTotalColors()
            throws MagickException

Get the The number of colors in the image after QuantizeImage(), or QuantizeImages().
Returns:
the current number of colors in the image
Throws:
MagickException - upon error

getUnits

public int getUnits()
            throws MagickException

Get the units attribute of the image.
Returns:
A integer representing the resolution type as defined in ResolutionType
Throws:
MagickException - on error
See Also:
ResolutionType

getXResolution

public double getXResolution()
            throws MagickException

Get the x_resolution attribute in the image.
Returns:
x_resolution value
Throws:
MagickException - on error

getYResolution

public double getYResolution()
            throws MagickException

Get the y_resolution attribute in the image.
Returns:
y_resolution value
Throws:
MagickException - on error

hasFrames

public boolean hasFrames()
            throws MagickException

Check if the image has multiple frames.
Returns:
true if the image has multiple frames, false, otherwise.
Throws:
MagickException - on error

imageToBlob

public byte[] imageToBlob(ImageInfo imageInfo)

Returns an array that contents the image format.
Parameters:
imageInfo - the magick member of this object determines output format
Returns:
a byte array containing the image in the specified format

implodeImage

public MagickImage implodeImage(double amount)
            throws MagickException

Implodes the image's pixels about the center.
Parameters:
amount - Amount of implosion if positive, explosion if negative.
Returns:
A new, imploded, image.
Throws:
MagickException - on error

isAnimatedImage

public boolean isAnimatedImage()
            throws MagickException

Returns True if the Gif image is Animated otherwise False is returned.
Returns:
a boolean value representing the animated status of the image
Throws:
MagickException - on error
Author:
Abdulbaset Gaddah

isGrayImage

public boolean isGrayImage()
            throws MagickException

Returns True if the image is grayscale otherwise False is returned.
Returns:
a boolean value to indicate success
Throws:
MagickException - on error

isMonochromeImage

public boolean isMonochromeImage()
            throws MagickException

Returns True if the image is monochrome otherwise False is returned.
Returns:
a boolean value to indicate success
Throws:
MagickException - on error

levelImage

public boolean levelImage(String levels)
            throws MagickException

Adjusts the levels of an image given these points: black, mid, and white.
Parameters:
Returns:
true if successful, false otherwise.

magnifyImage

public MagickImage magnifyImage()
            throws MagickException

Creates a new image that is a integral size greater than an existing one.
Returns:
a magnified image
Throws:
MagickException - on error

matteFloodfillImage

public boolean matteFloodfillImage(PixelPacket target,
                                   int matte,
                                   int x,
                                   int y,
                                   int method)
            throws MagickException

Floodfills the designated area with a matte value.
Returns:
a boolean value to indicate success
Throws:
MagickException - on error

medianFilterImage

public MagickImage medianFilterImage(double radius)
            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.
Parameters:
radius - The radius of the pixel neighborhood.
Returns:
A new, filtered, image.
Throws:
MagickException - on error

minifyImage

public MagickImage minifyImage()
            throws MagickException

Creates a new image that is a integral size less than an existing one.
Returns:
a minified image
Throws:
MagickException - on error

modulateImage

public boolean modulateImage(String modulate)
            throws MagickException

Modulates the hue, saturation, and brightness of an image.
Returns:
a boolean value to indicate success
Throws:
MagickException - on error

montageImages

public MagickImage montageImages(MontageInfo montageInfo)
            throws MagickException

Create a montage of all the images in the list.
Parameters:
montageInfo - parameter used in the creation of the montage
Returns:
a montage of all images in the list
Throws:
MagickException - if an error occurs

negateImage

public boolean negateImage(int grayscale)
            throws MagickException

Negates the colors in the reference image. The Grayscale option means that only grayscale values within the image are negated.
Returns:
a boolean value to indicate success
Throws:
MagickException - on error

nextImage

protected MagickImage nextImage()
            throws MagickException

Return image object for next image in sequence of frames. Also sets the next image pointer to NULL.
Returns:
next image or null if end of list.
Throws:
MagickException - on error

normalizeImage

public boolean normalizeImage()
            throws MagickException

Normalizes the pixel values to span the full range of color values. This is a contrast enhancement technique.
Returns:
a boolean value to indicate success
Throws:
MagickException - on error

oilPaintImage

public MagickImage oilPaintImage(double radius)
            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.
Parameters:
radius - The radius of the pixel neighborhood.
Returns:
A new, simulated oil-painting, image.
Throws:
MagickException - on error

opaqueImage

public boolean opaqueImage(PixelPacket target,
                           PixelPacket penColor)
            throws MagickException

Changes the color of an opaque pixel to the pen color.
Parameters:
target - the color to search for in the image
penColor - the color to replace it with
Returns:
a boolean value to indicate success
Throws:
MagickException - on error

pingImage

public void pingImage(ImageInfo imageInfo)
            throws MagickException

Pings the image.
Parameters:
imageInfo - the ImageInfo for an image file to read

profileImage

public boolean profileImage(String profileName,
                            byte[] profileData)
            throws MagickException

ProfileImage adds or removes a ICM, IPTC, or generic profile from an image. If the profile name is defined it is deleted from the image. If a filename is given, one or more profiles are read and added to the image.
Parameters:
profileName - name of profile to add or remove
Returns:
Returns a true if the profile is successfully added or removed
Throws:
MagickException - if an error occurs

quantizeImage

public boolean quantizeImage(QuantizeInfo quantizeInfo)
            throws MagickException

Analyzes the colors within a reference image and chooses a fixed number of colors to represent the image. The goal of the algorithm is to minimize the difference between the input and output image while minimizing the processing time.
Parameters:
quantizeInfo - contains parameters for quantization
Returns:
a boolean value indicating success of the process
Throws:
MagickException - on error

raiseImage

public boolean raiseImage(Rectangle raiseInfo,
                          boolean raise)
            throws MagickException

Creates a simulated three-dimensional button-like effect by lightening and darkening the edges of the image. Members width and height of raiseInfo define the width of the vertical and horizontal edge of the effect.
Parameters:
raiseInfo - the rectangle for which border is drawn
raise - true to create raise effect, false to lower
Returns:
true if successful, false otherwise
Throws:
MagickException - on error

readImage

public void readImage(ImageInfo imageInfo)
            throws MagickException

Read the image specified in the ImageInfo object.
Parameters:
imageInfo - specifies the file to read from
Throws:
MagickException - on error

reduceNoiseImage

public MagickImage reduceNoiseImage(double radius)
            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.
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.
Parameters:
radius - The radius of the pixel neighborhood.
Returns:
A new, filtered, image.
Throws:
MagickException - on error

rgbTransformImage

public boolean rgbTransformImage(int colorspace)
            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].
Parameters:
colorspace - the target colorspace to transform to
Returns:
a boolean value to indicate success
Throws:
MagickException - on error

rollImage

public MagickImage rollImage(int xOffset,
                             int yOffset)
            throws MagickException

Rolls an image vertically and horizontally.
Parameters:
xOffset - An integer that specifies the number of columns \ to roll in the horizontal direction
yOffset - An integer that specifies the number of rows to \ roll in the vertical direction
Returns:
the rolled image
Throws:
MagickException - on error

rotateImage

public MagickImage rotateImage(double degrees)
            throws MagickException

Creates a new image that is a rotated copy of an existing one. Positive angles rotate counter-clockwise (right-hand rule), while negative angles rotate clockwise. Rotated images are usually larger than the originals and have 'empty' triangular corners. X axis. Empty triangles left over from shearing the image are filled with the color defined by the pixel at location (0,0).
Parameters:
Returns:
A image that is a rotation of self
Throws:
MagickException - on error

sampleImage

public MagickImage sampleImage(int cols,
                               int rows)
            throws MagickException

Creates a new image that is a scaled size of an existing one using pixel sampling.
Parameters:
cols - An integer that specifies the number of columns in \ the sampled image
rows - An integer that specifies the number of rows in the \ sampled image
Returns:
the sampled image
Throws:
MagickException - on error

scaleImage

public MagickImage scaleImage(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.
Parameters:
cols - An integer that specifies the number of columns in \ the scaled image
rows - An integer that specifies the number of rows in the \ scaled image
Returns:
the scaled image
Throws:
MagickException - on error

segmentImage

public int segmentImage(int colorspace,
                        double cluster_threshold,
                        double smoothing_threshold)
            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.
Parameters:
colorspace - A 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.
cluster_threshold - Specify cluster threshold as the number of pixels in each cluster must exceed the the cluster threshold to be considered valid.
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.
Returns:
The actual number of colors allocated in the colormap.
Throws:
MagickException - on error
See Also:
ColorspaceType

setBackgroundColor

public void setBackgroundColor(PixelPacket color)
            throws MagickException

Set the background colour.
Parameters:
color - the background colour
Throws:
MagickException - on error

setBorderColor

public void setBorderColor(PixelPacket color)
            throws MagickException

Set the border colour for the method borderImage.
Parameters:
color - the border colour
Throws:
MagickException - on error
See Also:
borderImage(Rectangle)

setColorProfile

public void setColorProfile(ProfileInfo profile)
            throws MagickException

Set a new color profile for the image.
Parameters:
profile - a new color profile. This parameter cannot be null.
Throws:
MagickException - if an error occurs
See Also:
profileImage(String,byte[])

setCompression

public void setCompression(int value)
            throws MagickException

Set the compression attribute.
Parameters:
value - a value from CompressionType
Throws:
MagickException - on error
See Also:
CompressionType

setDelay

public void setDelay(int delay)
            throws MagickException

Set the time in 1/100ths of a second (0 to 65535) which must expire before displaying the next image in an animated sequence. This option is useful for regulating the animation of a sequence of GIF images within Netscape.
Parameters:
delay - the time delay in 1/100th of a second
Throws:
MagickException - upon error

setDispose

public void setDispose(int dispose)
            throws MagickException

Set the GIF disposal method. This option is used to control how successive frames are rendered (how the preceding frame is disposed of) when creating a GIF animation.
Parameters:
dispose - the disposal method for GIF animation
Throws:
MagickException - upon error

setFileName

public void setFileName(String fileName)
            throws MagickException

setFilter

public void setFilter(int filter)
            throws MagickException

setGrayscale

public void setGrayscale()
            throws MagickException

Deprecated. Use QuantizeInfo with MagickImage.quantizeImage to acheive the same effect.
Convert any colored image to grayscale.
Throws:
MagickException - on error

setImageAttribute

public boolean setImageAttribute(String key,
                                 String value)
            throws MagickException

Searches the list of image attributes and replaces the attribute value. If it is not found in the list, the attribute name and value is added to the list. SetImageAttribute returns True if the attribute is successfully replaced or added to the list, otherwise False. If the value is null, the matching key is deleted from the list.
Parameters:
key - the key of the attribute
value - the value of the attribute
Returns:
true if the attribute is replace or false if added
Throws:
MagickException - on error

setImageFormat

public void setImageFormat(String imageFormat)
            throws MagickException

setIptcProfile

public void setIptcProfile(ProfileInfo profile)
            throws MagickException

Set a new IPTC profile for the image.
Parameters:
profile - a new IPTC profile. This parameter cannot be null.
Throws:
MagickException - if an error occurs
See Also:
profileImage(String,byte[])

setIterations

public void setIterations(int iterations)
            throws MagickException

Set the number of iterations to loop an animation (e.g. Netscape loop extension) for.
Parameters:
iterations - the number of iterations
Throws:
MagickException - upon error

setMagick

public void setMagick(String imageFormat)
            throws MagickException

setNumberColors

public void setNumberColors(int numberColors)
            throws MagickException

setUnits

public void setUnits(int resolutionType)
            throws MagickException

Set the units attribute of the image.
Parameters:
Throws:
MagickException - on error
See Also:
ResolutionType

setXResolution

public void setXResolution(double xRes)
            throws MagickException

Set the x_resolution attribute in the image.
Parameters:
xRes - x_resolution value
Throws:
MagickException - on error

setYResolution

public void setYResolution(double yRes)
            throws MagickException

Get the y_resolution attribute in the image.
Parameters:
yRes - y_resolution value
Throws:
MagickException - on error

sharpenImage

public MagickImage sharpenImage(double raduis,
                                double sigma)
            throws MagickException

Creates a new image that is a copy of an existing one with the pixels sharpened.
Parameters:
raduis - The radius of the gaussian, in pixels, not counting \ the center pixel
sigma - The standard deviation of the gaussian, in pixels
Returns:
a sharpened image.
Throws:
MagickException - on error

shearImage

public MagickImage shearImage(double x_shear,
                              double y_shear)
            throws MagickException

Creates a new image that is a shear_image copy of an existing one. Shearing slides one edge of an image along the X or Y axis, creating a parallelogram. An X direction shear slides an edge along the X axis, while a Y direction shear slides an edge along the Y axis. The amount of the shear is controlled by a shear angle. For X direction shears, x_shear is measured relative to the Y axis, and similarly, for Y direction shears y_shear is measured relative to the X axis. Empty triangles left over from shearing the image are filled with the color defined by the pixel at location (0,0).
Parameters:
x_shear - x direction shear amount
y_shear - y direction shear amount
Returns:
a sheared image constructor from self.
Throws:
MagickException - on error

signatureImage

public boolean signatureImage()
            throws MagickException

Determine signature of image and place signature in the image's attributes.
Returns:
true if successful, false, otherwise
Throws:
MagickException - on error
Author:
Elizabeth Barham <soggytrousers@yahoo.com>

sizeBlob

public int sizeBlob()
            throws MagickException

Returns the current length of the image file or blob.
Returns:
current length of the image file or blob

solarizeImage

public void solarizeImage(double 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.
Parameters:
threshold - Ranges from 0 to MaxRGB and is a measure of the extent of the solarization.
Throws:
MagickException - on error

sortColormapByIntensity

public boolean sortColormapByIntensity()
            throws MagickException

Sorts the colormap of a PseudoClass image by decreasing color intensity.
Returns:
a boolean value indicating success
Throws:
MagickException - on error

spreadImage

public MagickImage spreadImage(int radius)
            throws MagickException

A special effects method that randomly displaces each pixel in a block defined by the radius parameter.
Parameters:
radius - Choose a random pixel in a neighborhood of this extent.
Returns:
A new, spread, image.
Throws:
MagickException - on error

swirlImage

public MagickImage swirlImage(double degress)
            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.
Parameters:
Returns:
A new, swirled, image.
Throws:
MagickException - on error

syncImage

public void syncImage()
            throws MagickException

Initializes the red, green, and blue intensities of each pixel as defined by the colormap index.
Throws:
MagickException - on error

textureImage

public void textureImage(MagickImage image)
            throws MagickException

Layers a texture onto the background of an image.
Parameters:
image - the image to use for texture
Throws:
MagickException - on error

thresholdImage

public boolean thresholdImage(double threshold)
            throws MagickException

Thresholds the reference image.
Parameters:
threshold - the threshold value
Returns:
a boolean value indicating success
Throws:
MagickException - on error

transformImage

public void transformImage(String cropGeometry,
                           String imageGeometry)
            throws MagickException

Creates a new image that is a transformed size of of existing one as specified by the crop and image geometries. If a crop geometry is specified a subregion of the image is obtained. If the specified image size, as defined by the image and scale geometries, is smaller than the actual image size, the image is first minified to an integral of the specified image size with an antialias digital filter. The image is then scaled to the exact specified image size with pixel replication. If the specified image size is greater than the actual image size, the image is first enlarged to an integral of the specified image size with bilinear interpolation. The image is then scaled to the exact specified image size with pixel replication.
Parameters:
cropGeometry - a crop geometry string. This geometry \ defines a subregion of the image.
imageGeometry - a image geometry string. The specified \ width and height of this geometry string are absolute.
Throws:
MagickException - on error

transformRgbImage

public boolean transformRgbImage(int colorspace)
            throws MagickException

Converts the reference image from 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].
Parameters:
colorspace - An unsigned integer value defines which \ colorspace to transform the image to
Returns:
a boolean value indicating success
Throws:
MagickException - on error

transparentImage

public boolean transparentImage(PixelPacket color,
                                int opacity)
            throws MagickException

Creates a matte image associated with the image.
Parameters:
color - The color to search for in the image
opacity - The opacity of the transparent image
Returns:
a boolean value indicating success
Throws:
MagickException - on error

unsharpMaskImage

public MagickImage unsharpMaskImage(double raduis,
                                    double sigma,
                                    double amount,
                                    double threshold)
            throws MagickException

Creates a new image that is a copy of an existing one with the pixels sharpened using an "unsharp" masking technique.
This process starts by building a temporary, blurred, copy of the image. Then each pixel in this "unsharp" image is compared against its corresponding pixel in the original image. If their difference is above a threshold, a percentage of the difference is added back into the original pixel.
The first two arguments, radius and sigma, specify the blurring used to create the "unsharp" image. See gaussianBlurImage(double,double) for a detail explanation. It will suffice to say that the larger the radius and sigma the more this blurred image will diverge from the original.
The last two arguments, threshold and amount, specify the difference threshold required to apply an adjustment to each pixel and, once the threshold is reached, the amount of the difference to be added back into the original pixels. A high threshold will cause the algorithm to only adjust edge pixels. Specifying a threshold will adjust every pixel.
Parameters:
raduis - The radius of the gaussian, in pixels, not counting the center pixel
sigma - The standard deviation of the gaussian, in pixels
amount - The percentage of the difference between the original and the blur image that is added back into the original.
threshold - The threshold in pixels needed to apply the diffence amount.
Returns:
A sharpened image.
Throws:
MagickException - on error

waveImage

public MagickImage waveImage(double amplitude,
                             double wavelength)
            throws MagickException

Creates a "ripple" effect in the image by shifting the pixels vertically along a sine wave whose amplitude and wavelength is specified by the given parameters.
Parameters:
amplitude - Define the amplitude of the sine wave.
wavelength - Define the wave-length of the sine wave.
Returns:
A new, "waved", image.
Throws:
MagickException - on error

writeImage

public boolean writeImage(ImageInfo imageInfo)
            throws MagickException

Write the image specified in the ImageInfo object.
Parameters:
imageInfo - specifies the writing parameters
Throws:
MagickException - on error

zoomImage

public MagickImage zoomImage(int cols,
                             int rows)
            throws MagickException

Creates a new image that is a scaled size of an existing one.
Returns:
the zoomed image
Throws:
MagickException - on error

Overview Package Tree Index Deprecated About
Prev Class \| Next Class	Frames \| No Frames
Summary: Nested \| Field \| Method \| Constr	Detail: Nested \| Field \| Method \| Constr

magick

Class MagickImage

Constructor Summary

Method Summary

Methods inherited from class magick.Magick

Constructor Details

MagickImage

MagickImage

MagickImage

MagickImage

MagickImage

Method Details

addNoiseImage

allocateImage

annotateImage

averageImages

blobToImage

blurImage

borderImage

breakFrames

charcoalImage

chopImage

cloneImage

colorFloodfillImage

colorizeImage

compositeImage

constituteImage

constituteImage

constituteImage

contrastImage

convolveImage

cropImage

cycleColormapImage

despeckleImage

destroyImages

dispatchImage

dispatchImage

dispatchImage

drawImage

edgeImage

embossImage

enhanceImage

equalizeImage

finalize

flipImage

flopImage

gammaImage

gaussianBlurImage

getBackgroundColor

getBorderColor

getColorProfile

getColormap

getColormap

getColors

getColorspace

getCompression

getDelay

getDepth

getDimension

getDispose

getFileName

getFilter

getGenericProfile

getGenericProfileCount

getImageAttribute

getImageFormat

getImageType

getIptcProfile

getIterations

getMagick

getNumFrames

getNumberColors

getOnePixel

getQuality

getStorageClass

getTotalColors

getUnits

getXResolution

getYResolution

hasFrames