Image.capture(silent=false
, frame=false
, descend=false
, screen=false
, borders=false
) [
{ optional arguments } ] ->
image
Reads an image from an X window. Unless you identify a window to capture via the optional arguments block, when capture
is invoked
the cursor will turn into a cross. Click the cursor on the window to be captured.
Within the optional arguments block, specify
options.filename = "root"
to capture the entire desktop. To programatically specify the window to be captured, use
options.filename = window_id
, where window_id is the id displayed by xwininfo(1).
true
, suppress the beeps that signal the start and finish of the capture process. The bell rings once to signal the start of the
capture and twice to signal the finish.
true
, include the window frame.true
,
obtain image by descending window hierarchy.
true
, specifies that
the GetImage request used to obtain the image should be done on the root window, rather than directly on the specified window. In this way, you can
obtain pieces of other windows that overlap the specified window, and more importantly, you can capture menus or other popups that are independent
windows but appear over the specified window.
true
, include the border in the image.A new image.
img = Magick::Image.capture { |options| options.filename = "root" }
Image.combine(red_ch=nil, green_ch=nil, blue_ch=nil, opacity_ch=nil) ->image
Combines the grayscale value of the pixels in each image to form a new image.
The red channel of the image specified in the first argument is used as the red channel in the new image. The green channel of the image specified in the second argument is used as the green channel in the new image. The blue channel of the image specified in the third argument is used as the blue channel in the new image. The opacity channel of the image specified in the fourth argument is used as the opacity channel in the new image.
Any of the arguments may be nil. Trailing nil arguments may be omitted. You must specify at least one image argument.
A new image
The same results can be obtained using the composite method and the CopyRed/Green/Blue/OpacityCompositeOp CompositeOperator enum values.
CombineImages
Image.constitute(width, height, map, pixels) -> image
Creates an image from an array of pixels. This method is the reverse of
dispatch
.
Integers
or all Floats
. If the elements are Integers
, the Integers
must be in the range [0..QuantumRange]. If the elements are
Floats
, they must be in the range [0..1].
An image constructed from the pixel data.
image = Magick::Image.constitute(width, height, "RGB", pixels)
ConstituteImage
Image.from_blob(string) [ { optional arguments } ] -> array
Creates an array of images from a BLOB, that is, a Binary Large OBject. In RMagick, a BLOB is a string.
A blob can be a string containing an image file such as a JPEG or GIF. The string can contain a multi-image file such as an animated GIF or a Photoshop image with multiple layers. A blob can also be one of the strings produced by to_blob. Control the format of the created image(s) by setting additional Image::Info attributes in the optional block argument.
An array of one or more images constructed from the BLOB.
See to_blob.
BlobToImage
Image.new(columns, rows [, fill]) [ { optional arguments } ] -> image
A new image.
img = Magick::Image.new(256, 64) { |options| options.background_color = 'red' }
AllocateImage
Image.ping(filename) [ { optional arguments } ] -> array
Image.ping(file) [ { optional arguments } ] -> array
Creates one or more images from the image file, omitting the pixel data. Only the attributes are stored in the images. This method is faster than read and uses less memory.
An image file name or open file object. You can specify other arguments by setting Image::Info attributes in the optional block.
An array containing 0 or more images.
cheetah = Magick::Image.ping("Cheetah.jpg") #=> [Cheetah.jpg JPEG 1024x768 DirectClass 8-bit 101684b] p cheetah[0].rows #=> 768 p cheetah[0].columns #=> 1024
PingImage
Image.read(filename) [ { optional arguments } ] -> array
Image.read(file) [ { optional arguments } ] -> array
Reads all the images from the specified file.
Note: Because an image file can contain multiple images or multiple image layers, read
always
returns an array containing 0 or more elements, one element for each image or image layer in the file.
An image file name or open file object. You can specify other arguments by setting Image::Info attributes in the optional block.
An array containing 0 or more Image objects. If the file is a multi-image file such as an animated GIF or a Photoshop PSD file with multiple layers, the array contains an Image object for each image or layer in the file.
animated = Magick::Image.read("animated.gif") #=> [animated.gif GIF 127x120+0+0 PseudoClass 256c 8-bit 54395b # animated.gif[1] GIF 127x120+0+0 PseudoClass 256c 8-bit 54395b, # animated.gif[2] GIF 127x120+0+0 PseudoClass 256c 8-bit 54395b]
The read method does not accept a StringIO object. If you want to create an image from a string buffer, use from_blob.
ReadImage
Image.read_inline(content) [ { optional arguments } ] -> array
Converts a Base64-encoded image or multi-image sequence to an array of Image objects.
A Base64-encoded string. Generally no optional arguments are required. If the image format cannot be deduced from the image data, you can use the format attribute. If you want to extract a subset of an image sequence, see here.
An array containing 0 or more Image objects. If the content is a multi-image sequence such as an animated GIF or a Photoshop PSD file with multiple layers, the array contains an Image object for each image or layer in the file.
content = "R0lGODlhnAEuAferAAAAAAcIBggJBgw..." img = Magick::Image.read_inline(content)
img[key] -> string
Returns the value of the image property identified by
key. An image may have any number of properties. Each property is identified by a string (or symbol) key. The property value is
a string. ImageMagick predefines some properties, including Label
, Comment
, Signature
, and in some cases
EXIF
.
String
or a Symbol
.
The value of the property.
mom['Label'] = 'My Mother'
GetImageAttribute
ImageMagick calls properties "attributes." I use the word "properties" to reduce the confusion with image object attributes such as
rows
and columns
.
img[key] = string -> self
Sets the value of an image property. An image may have any number of properties.
self
SetImageAttribute
img <=> other_image -> -1, 0, 1
Compares two images and returns -1, 0, or 1 if
img is less than, equal to, or greater than other_image as determined by comparing the signatures of
the images. If one of the arguments is not an image, this method raises a TypeError exception (in Ruby 1.6) or returns nil
(in Ruby 1.8)
In addition to <=>, Image
mixes in the Comparable
module, which defines the <, <=, == >=, >, and
between?
methods.
The difference
method compares images (for equality only) but also returns information about the amount two images differ, which may be
more useful.
The value of img.signature
<=> other_image.signature
.
signature, difference, compare_channel
SignatureImage
img.adaptive_blur(radius=0.0, sigma=1.0) -> image
Adaptively blurs the image by blurring more intensely near image edges and less intensely far from edges. The adaptive_blur method blurs 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 adaptive_blur selects a suitable radius for you.
A new image
AdaptiveBlurImage
img.adaptive_blur(radius=0.0, sigma=1.0 [,channel...]) -> image
The same as adaptive_blur
except only the specified channels are blurred.
adaptive_blur
method, above.
A new image
AdaptiveBlurImageChannel
img.adaptive_resize(new_width, new_height) -> image
img.adaptive_resize(scale_factor) -> image
Resizes the image with data dependent triangulation.
You can specify the new size in two ways. Either specify the new width and height explicitly, or specify a scale factor, a number that represents the percentage change.
Use the change_geometry method to compute new dimensions for an image with constraints such as "maintain the current proportions."
A new image
AdaptiveResizeImage
img.adaptive_sharpen(radius=0.0, sigma=1.0) -> image
Adaptively sharpens the image by sharpening more intensely near image edges and less intensely far from edges. The adaptive_sharpen method sharpens 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 adaptive_sharpen selects a suitable radius for you.
A new image
AdaptiveSharpenImage
img.adaptive_sharpen(radius=0.0, sigma=1.0 [,channel...]) -> image
The same as adaptive_sharpen
except only the specified channels are sharpened.
adaptive_sharpen
method, above.
A new image
AdaptiveSharpenImageChannel
img.adaptive_threshold(width=3, height=3, offset=0) -> image
Selects an individual threshold for each pixel based on the range of intensity values in its local neighborhood. This allows for thresholding of an image whose global intensity histogram doesn't contain distinctive peaks.
A new image
bilevel_channel, random_threshold_channel, threshold
AdaptiveThresholdImage
img.add_compose_mask(mask) -> self
Associates a mask with an image that will be used as the destination image in a composite operation. The areas of the destination image that are masked by white pixels will be modified by the composite method, while areas masked by black pixels are unchanged.
See Using a Compose Mask to Limit the Composed Area in Anthony Thyssen's Examples of ImageMagick Usage.
The mask image must have the same dimensions as the destination image.
self
composite, delete_compose_mask
This method uses a copy of the argument as the mask. If you change the mask image you must call this method again to update the mask.
SetImageMask
img.add_noise(noise_type) -> image
Adds random noise to the image. The amount of time
add_noise
requires depends on the NoiseType argument.
A NoiseType value.
A new image
The RandomNoise type was added in ImageMagick 6.3.5.
AddNoiseImage
img.add_profile(filename) -> self
Adds an ICC (a.k.a. ICM), IPTC, or generic profile. If the file contains more than one profile all the profiles are added.
The filename of a file containing the profile.
self
img.add_profile('my_cmyk.icm')
The iptc_profile and color_profile attributes provide very similar functionality, except that these attributes accept the profile data in the form of a string. The profile! method can also be used to add a profile. The type of profile must be specified and the profile data must be in the form of a string. Also see delete_profile and each_profile.
ProfileImage
img.add_noise_channel(noise_type [,channel...]) -> image
Adds random noise to the specified channel or channels in the image.
add_noise
method, above.
A new image
AddNoiseImageChannel
img.affine_transform(matrix) -> image
Transforms the image as specified by the affine matrix.
See Coordinate system transformations in the Scalable Vector Graphics (SVG) 1.0 Specification for more information about transformation matrices.
An
AffineMatrix
object.
A new image
The affine matrix in this example skews the receiver by π/6 radians along both axes.
AffineTransformImage
img.alpha(type) -> type
Set a flag to indicate whether or not to use alpha channel data.
One of the following values of the AlphaChannelOption enumeration:
The argument.
Available in ImageMagick 6.3.5 and later.
SetImageAlphaChannel
img.alpha? -> true
or
false
Returns true
if the alpha channel will be used, false
otherwise.
GetImageAlphaChannel
img.annotate(draw, width, height, x, y, text) [ { additional parameters } ] -> self
This is the same method as the annotate
method in the Draw class, except that the first argument is a Draw object. Refer to the
documentation for Draw#annotate for more information. Some users feel like annotate
is better placed in
Image than in Draw. Okay, here it is!
self
img.auto_gamma_channel([channel...]) -> image
"Automagically" adjust the gamma level of an image.
A new image
img.auto_level_channel([channel...]) -> image
"Automagically" adjust the color levels of an image.
A new image
img.auto_orient -> image
Rotates or flips the image based on the image's EXIF orientation tag. Note that only some models of modern digital cameras can tag an image with the
orientation. If the image does not have an orientation tag, or the image is already properly oriented, then
auto_orient
returns an exact copy of the image.
A new image
FlipImage, FlopImage, RotateImage, TransposeImage, TransverseImage
img.auto_orient! -> self
Rotates or flips the image based on the image's EXIF orientation tag. Note that only some models of modern digital cameras can tag an image with the
orientation. If the image does not have an orientation tag, or the image is already properly oriented, then
auto_orient!
returns nil
.
self. or nil
if the image is already properly oriented
img.bilevel_channel(threshold [,channel...]) -> image
Changes the value of individual pixels based on the intensity of each pixel channel. The result is a high-contrast image.
A new image
bilevel_channel(2*QuantumRange/3, RedChannel)
adaptive_threshold, random_threshold_channel
BilevelImageChannel
img.black_threshold(red_channel [, green_channel [, blue_channel [, opacity_channel]]]) -> image
Forces all pixels below the threshold into black while leaving all pixels above the threshold unchanged.
Each channel argument is a number between 0 and QuantumRange. All arguments except the first may be omitted. If the green_channel or blue_channel argument is omitted, the default value is the red_channel value. If the opacity_channel argument is omitted, the default value is OpaqueOpacity.
A new image
white_threshold, bilevel_channel
BlackThresholdImage
img.blend(overlay, src_percentage, dst_percentage,
x_offset=0, y_offset=0) -> image
img.blend(overlay, src_percentage, dst_percentage,
gravity, x_offset=0, y_offset=0) -> image
Adds the overlay image to the target image according to src_percent and dst_percent.
This method corresponds to the -blend option of ImageMagick's
composite
command.
The blend
method can be called with or without a gravity argument. The gravity,
x_offset, and y_offset arguments are described in the documentation for
watermark.
See "Blend Two Images Together".
A new image
img.blue_shift(factor=1.5) -> image
Simulate a scene at nighttime in the moonlight.
A new image
Available in ImageMagick 6.5.4-3 and later.
BlueShiftImage
img.blur_channel(radius=0.0, sigma=1.0[, channel...]]) -> image
Blurs the specified channel.
We convolve the image with a Gaussian operator of the given radius and standard deviation (sigma) . The blur_channel
method differs from
gaussian_blur_channel
in that it uses a separable kernel which is faster but mathematically equivalent to the non-separable kernel.
For reasonable results, the radius should be larger than sigma. Use a radius of 0 and
blur_channel
selects a suitable radius for you.
A new image
blur_image, gaussian_blur_channel, motion_blur, radial_blur, selective_blur_channel
BlurImageChannel
img.blur_image(radius=0.0, sigma=1.0) -> image
Blurs the 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 blur_image
selects a suitable radius for you.
A new image.
blur_channel, gaussian_blur, motion_blur, radial_blur, selective_blur_channel
BlurImage
img.border(width, height, color) -> image
Add a border around the image.
A new image
BorderImage
img.border!(width, height, color) -> self
img.bounding_box -> rectangle
The image's bounding box. The bounding box is the rectangle that encloses all the pixels not in the border color. Uses the current fuzz value.
In this example, the bounding box is the gray square enclosing the blue circle. (The coordinates and red circles were added after the bounding box was computed.)
img.change_geometry(string) {|cols,rows,image| block} ->
??? (see Returns)
img.change_geometry(geometry) {|cols,rows,image| block} ->
??? (see Returns)
The change_geometry
method supports resizing a method by specifying constraints. For example, you can specify that the image should be
resized such that the aspect ratio should be retained but the resulting image should be no larger than 640 pixels wide and 480 pixels tall.
The argument may be either a
geometry string or a Geometry object. Change_geometry
yields to the
block, passing new width and height values based on the argument with respect to self
. The return value is the return value of the block.
Geometry
object
The value returned by the block
mona = Magick::Image.read('MonaLisa.jpg').first mona.change_geometry!('320x240') { |cols, rows, img| img.resize!(cols, rows) }
ParseSizeString
change_geometry!
is an alias for change_geometry
.
img.changed? -> true
or
false
true
if any pixel has been altered since the image was constituted.
IsTaintImage
img.channel(channel) -> image
Extracts a channel from the image. A channel is a particular color component of each pixel in the [image].
A ChannelType value.
An image in which the RGB values of all the pixels have been set to a gray corresponding to the specified channel value. For example, given a pixel in the original image with the value R=255, G=128, B=0 and the RedChannel argument, the equivalent pixel in the result image will have the value R=255, G=255, and B=255. For the BlueChannel argument, the pixel would have the value R=0, G=0, B=0.
The channel image preserves the tone of the selected RGB component.
ChannelImage
img.channel_depth([channel...]) -> number
Returns the maximum depth for the specified channel or channels.
The maximum depth
GetImageChannelDepth
img.channel_extrema([channel...]) -> [number, number]
Returns the minimum and maximum intensity values for the specified channel or channels.
An array. The first element in the array is the minimum value. The second element is the maximum value.
GetImageChannelExtrema
img.channel_mean([channel...]) -> [number, number]
Returns the mean and standard deviation values for the specified channel or channels.
An array. The first element in the array is the mean value. The second element is the standard deviation.
GetImageChannelMean
img.charcoal(radius=0.0, sigma=1.0) -> image
Adds a "charcoal" effect to the image. You can alter the intensity of the effect by changing the radius and sigma arguments.
A new image
CharcoalImage
img.check_destroyed -> nil
Raises DestroyedImageError if the image has been destroyed. Returns nil otherwise.
img.chop(x, y, width, height) -> image
Removes the specified rectangle and collapses the rest of the image to fill the removed portion.
A new image
The chop rectangle is highlighted in the "before" image. The result may seem counter-intuitive!
ChopImage
img.clone -> image
Same as dup except the frozen state of the original is propagated to the new copy.
A new image
img.clut(clut_image [, channel...]) -> self
Replace the channel values in the target image with a lookup of its replacement value in an LUT gradient image.
The LUT image should be either a single row or column image of replacement colors. The lookup is controlled by the -interpolate setting, especially for an LUT which is not the full length needed by the IM installed Quality (Q) level. Good settings for this is the default 'bilinear' or 'bicubic' interpolation setting for a smooth color gradient, or 'integer' for a direct unsmoothed lookup of color values.
This method is especially suited to replacing a grayscale image with specific color gradient from the CLUT image.
Note that color replacements involving transparency (alpha/matte channel) will lookup the replacement alpha/matte value using the alpha/matte value of the original image. As such correct alpha channel lookup for a pure gray-scale original image will require a copy of that grayscale to be transferred into its alpha channel before applying the -clut operator.
self
ImageMagick's -clut option.
img.color_fill_to_border(x, y, fill_color) -> image
Changes any pixel that is a neighbor of the target pixel and is not the border color to the fill color.
A new image
In this example, the aquamarine fill starts at the center of the circle and fills to the black border. All non-black pixels are replaced by the fill
color. Contrast the result of
color_fill_to_border
with that of color_floodfill
example, below.
ColorFloodfillImage
img.color_floodfill(x, y, fill_color) -> image
Changes any pixel that is the same color and is a neighbor of the target pixel to the fill color.
A new image
In this example, the aquamarine fill starts at the center of the circle and replaces all neighboring white pixels. Contrast the result of
color_floodfill
with that of color_fill_to_border
, above.
ColorFloodfillImage
img.color_histogram() -> hash
Computes the number of times each unique color appears in the image.
A hash. Each key in the hash is a
pixel representing a color that appears in the image. The value associated with the key is the number of times that
color appears in the image. Caution: if the image contains many colors the hash will be very large. You may want to use the
quantize
method to reduce the number of colors before using
color_histogram
.
This histogram was produced by sorting the hash returned by
color_histogram
by increasing frequency.
GetImageHistogram
img.colorize(red_pct, green_pct, blue_pct, [matte_pct, ] fill) -> image
Blend the fill color with the image pixels. The red_pct, green_pct, blue_pct and matte_pct arguments are the percentage to blend with the red, green, blue and matte channels.
.25
is 25%. The matte_pct argument is optional.
A new image
This example converts a color image to a "sepia-tone-ish" image using the quantize and colorize
methods.
ColorizeImage
img.colormap(index[, new_color]) -> string
Returns the color in the color map at the specified index. If the new_color argument is specified, replaces the color at that index with the new color.
Raises IndexError if the image does not contain a color map. Only PseudoClass images have a color map.
colormap
raises an IndexError. You can get
the number of colors in the color map from the colors attribute.
The name of the color at the specified location in the color map
img.color_point(x, y, fill) -> image
A new image
f.color_point(50,50, 'red')
GetImagePixels, SyncImagePixels
img.color_reset!(fill) -> self
Sets all the pixels in the image to the specified fill color.
f.color_reset!(red)
img.compare_channel(img, metric [, channel...]) [ { optional arguments } ] -> [image, float]
Compares img with the receiver.
compare_channel
yields to a block in which you can set optional arguments by setting attributes on self. In both
cases color may be either a color name or a pixel.
An array. The first element is a difference image, the second is a the value of the computed distortion represented as a Float
.
difference, <=>, distortion_channel
ImageCompareChannels
This method was named channel_compare
in earlier releases of RMagick. That name remains an alias for compare_channel
.
dest.composite(src, x, y,
composite_op) -> image
dest.composite(src, gravity, composite_op) ->
image
dest.composite(src, gravity, x,
y, composite_op) ->
image
The composite method can be called three different ways:
A new image
This example shows the effect of some of the composite operators.
composite!, dissolve, watermark
CompositeImage
dest.composite!(src, x, y,
composite_op) -> self
dest.composite!(src, gravity, composite_op) ->
self
dest.composite!(src, gravity, x,
y, composite_op) ->
self
dest.composite_affine(src, affine) -> image
AffineMatrix
A new image
DrawAffineImage
dest.composite_mathematics(src, a, b,
c, d, gravity) -> image
dest.composite_mathematics(src, a, b,
c, d, x, y) -> image
dest.composite_mathematics(src, a, b,
c, d, gravity, x, y) ->
image
Merge the source and destination images according to the formula a*Sc*Dc + b*Sc + c*Dc + d where Sc is the source pixel and Dc is the destination pixel.
Equivalent to the
-compose Mathematics -set option:compose:args a,b,c,d
options to ImagMagick's convert
command. See
Examples of ImageMagick Usage.
A new image
CompositeImage
img.composite_tiled(src, composite_op = Magick::OverCompositeOp) -> image
Composites multiple copies of the source image across and down the image, producing the same results as ImageMagick's composite command with the -tile option.
A new image
CompositeImage
img.composite_tiled!(src, composite_op = Magick::OverCompositeOp) -> self
In-place form of composite_tiled.
self
CompositeImage
img.compress_colormap! -> self
Removes duplicate or unused entries in the colormap. Only
PseudoClass images have a colormap. If the image is DirectClass
then
compress_colormap!
converts it to PseudoClass
.
f = Magick::Image.read('cbezier1.gif').first #=> cbezier1.gif GIF 500x350+0+0 PseudoClass 128c 8-bit 177503b f.colors #=> 128 f.compress_colormap! #=> cbezier1.gif GIF 500x350+0+0 PseudoClass 108c 8-bit 177503b f.colors #=> 108
CompressColormap
img.contrast(sharpen=false
) -> image
Enhances or reduces the intensity differences between the lighter and darker elements of the image.
true
, the contrast is increased, otherwise it is reduced.
A new image
In this example the contrast is reduced in each successive image.
contrast_stretch_channel, sigmoidal_contrast_channel
ContrastImage
img.contrast_stretch_channel(black_point [, white_point] [, channel...]) -> image
This method is a simple image enhancement technique that attempts to improve the contrast in an image by `stretching' the range of intensity values it contains to span a desired range of values. It differs from the more sophisticated histogram equalization in that it can only apply a linear scaling function to the image pixel values. As a result the `enhancement' is less harsh.
all pixels - black_point pixels
.
A new image
ContrastStretchImage
img.convolve(order, kernel) -> image
Applies a custom convolution kernel to the image.
Float
values.A new image
convolve_channel. The edge, emboss, gaussian_blur, motion_blur and sharpen methods use convolution to do their work.
ConvolveImage
See Convolution in the Hypermedia Image Processing Reference
img.convolve_channel(order, kernel [, channel...]) -> image
Applies a custom convolution kernel to the specified channel or channels in the image.
Float
values.A new image
ConvolveImageChannel
img.copy -> other_image
f2 = f.copy
CloneImage
img.crop(x, y, width,
height) -> image
img.crop(gravity, x, y,
width, height) -> image
img.crop(gravity, width, height) ->
image
Extracts the specified rectangle from the image.
The crop method can be called three different ways:
crop
method retains the offset information in the cropped image. This may cause the image to appear to be surrounded by blank or black
space when viewed with an external viewer. This only occurs when the image is saved in a format (such as GIF) that saves offset information. To reset the
offset data, add true
as the last argument to crop
. For example,
cropped = img.crop(x, y, width, height, true)
You can add true
as the last argument with any of the three argument list formats described above.
A new image
The crop rectangle is highlighted in the "before" image.
CropImage
img.crop!(x, y, width,
height) -> self
img.crop!(gravity, x, y,
width, height) -> self
img.crop!(gravity, width, height) ->
self
img.crop_resized(width, height, gravity=CenterGravity) -> image
An alias for resize_to_fill.
img.cycle_colormap(amount) -> image
Displaces the colormap by a given number of positions. If you cycle the colormap a number of times you can produce a psychedelic effect.
The returned image is always a PseudoClass
image, regardless of the type of the original image.
The number of positions to cycle.
A new image
Mouse over the image to see an animation made by cycling the colormap between each copy.
CycleColormapImage
img.decipher(passphrase) -> image
Decipher an enciphered image.
The passphrase used to encipher the image.
A new image
deciphered_img = img.decipher("magic word")
DecipherImage
img.delete_compose_mask() -> self
Deletes the mask added by add_compose_mask.
self
SetImageMask
img.delete_profile(profile_name) -> self
Deletes the specified profile. This method is effectively the same as passing a nil
2nd argument to
profile!.
The profile name, "IPTC" or "ICC" for example. Specify "*" to delete all the profiles in the image.
Setting the iptc_profile attribute or color_profile attribute to nil causes the profile to be deleted. Also see strip! and add_profile.
ProfileImage
img.deskew(threshold=0.40, auto_crop_width=nil) -> image
Straightens an image. A threshold of 40% works for most images.
A new image
img2 = img.deskew
img.despeckle -> image
Reduces the speckle noise while preserving the edges.
A new image
DespeckleImage
img.destroy! -> self
Returns all the memory associated with the image to the system. After an image has been destroyed, all Image methods (except destroyed? and inspect) called on the image will raise a DestroyedImageError.
It is not possible to recover a destroyed image.
self
img.destroyed? -> true
or
false
Returns true if the image has been destroyed, false otherwise.
img.difference(other) -> array
Compares two images and computes statistics about their difference.
A small normalized mean square error...suggests the images are very similar in spatial layout and color.
An array of three Float
values:
After difference
returns, these values are also available from the mean_error_per_pixel,
normalized_mean_error, and
normalized_maximum_error
attributes.
img.dispatch(x, y, columns,
rows, map, float=false
) -> array
Extracts the pixel data from the specified rectangle and returns it as an array of either Integer
or Float
values.
The array returned by dispatch
is suitable for use as an argument to constitute
.
String
reflecting the order of the pixel data.
It can be any combination or order of R = red, G = green, B = blue, A = alpha, C = cyan, Y = yellow, M = magenta, K = black, or I = intensity (for
grayscale).
true
, the returned array elements will be Float
values in the range 0..1. If false
, the returned array
elements will be Integer
values in the range 0..QuantumRange.
pixels = f.dispatch(0, 0, f.columns, f.rows, "RGB")
constitute, export_pixels, get_pixels
ExportImagePixels
This method is deprecated in ImageMagick. Use the
export_pixels
method instead.
img.displace(displacement_map, x_amplitude,
y_amplitude, x_offset=0, y_offset=0) -> image
img.displace(displacement_map, x_amplitude,
y_amplitude, gravity, x_offset=0, y_offset=0) ->
image
Uses displacement_map to move color from img to the output image.
This method corresponds to the -displace option of ImageMagick's
composite
command.
The displace
method can be called with or without a gravity argument. The gravity,
x_offset, and y_offset arguments are described in the documentation for
watermark.
See "Composite Displacement Maps" in Anthony Thyssen's Examples of ImageMagick Usage.
A new image
img.display [ { optional arguments } ] -> self
Display the image on an X Window screen. By default, the screen is the local monitor. Right-click the window to display a context menu.
You can specify additional arguments by setting Info attributes in a block associated with the method call. Specifically, you can set the name of a
non-default X Window screen with the
server_name
attribute.
self
The display method is not supported on native MS Windows.
DisplayImages
img.dissolve(overlay, src_percentage,
dst_percentage, x_offset=0, y_offset=0) -> image
img.dissolve(overlay, src_percentage,
dst_percentage, gravity, x_offset=0, y_offset=0)
-> image
Composites the overlay image into the target image. The opacity of img is multiplied by dst_percentage and opacity of overlay is multiplied by src_percentage.
This method corresponds to the -dissolve option of ImageMagick's
composite
command.
The dissolve
method can be called with or without a gravity argument. The gravity,
x_offset, and y_offset arguments are described in the documentation for
watermark.
See " Dissolve One Image Over Another" in Anthony Thyssen's Examples of ImageMagick Usage.
bgnd.dissolve(overlay, 0.50, 1.0)
A new image
img.distort(type, points,
bestfit=false
) [ { optional arguments } ] ->
image
Distort an image using the specified distortion type and its required arguments. This method is equivalent to ImageMagick's -distort option.
distort
yields to a block in which you can set optional arguments by calling methods on self.
A new image
result = img.distort(Magick::ScaleRotateTranslateDistortion, [0]) do |options| options.define "distort:viewport", "44x44+15+0" options.define "distort:scale", 2 end
See Distortion Operator in Anthony Thyssen's excellent Examples of ImageMagick Usage for more information about distortion operations.
img.distortion_channel(reconstructed_image, metric[, channel...]) -> float
(C)ompares one or more image channels of an image to a reconstructed image and returns the specified distortion metric.
The distortion metric, represented as a floating-point number.
GetImageChannelDistortion
img.dup -> other_image