A view is a rectangle in an image. Within the view pixels
      can be addressed by specifying their [i][j]
      coordinates. The i, j index values can identify a single pixel or
      multiple pixels. Pixels can be accessed or modified
      individually or collectively. Pixel channels (that
      is, the red, green, blue, and opacity components) can be
      accessed or modified individually or collectively. The
      sync method stores modified pixels
      back into the image.
Image::View.new(img, x, y, width, height) -> view
The easiest way to use an Image::View object
      is to create it with the Image#view method, which provides a
      block-scoped view and automatic syncing. You probably won't
      want to create a view by calling new.
It is an error to specify a view that exceeds the boundaries of the image.
view[i][j] -> pixel or array
Return one or more pixels in the view. If i and j are each
      a single integer value, returns a single pixel. For any other
      indexes, returns an array of one or more pixels. If any index
      exceeds the boundaries of the view, raises
      IndexError.
The i index identifies a set of rows in the view. The j index identifies a set of columns in the view. The pixels that are returned are the intersection of these two sets. The indexes can be:
j is omitted, all the columns are
        used.length rows or
        columns starting with start. If
        start is negative, starts at the bottom row or
        right column of the view.eacheach by returning a sequence of objects that
        can be converted to integers. An array with integer values
        or a range of integers are two examples.# Get the 2nd pixel in the 4th row of the view. pixel = view[3][1] # returns a pixel # Returns an array with only one value pixels = view[[3]][[1]] # Get all the pixels in the 4th row pixels = view[3][] # Use arrays to specify a non-contiguous set of rows and columns pixels = view[[1,3,5]][[2,4,6]] # Use ranges to specify a contiguous set of rows and columns pixels = view[1..5][2..6]
[i][j].red -> integer or
      array
      [i][j].green -> integer or
      array
      [i][j].blue
      -> integer or array
      [i][j].opacity -> integer or
      array
If the indexes identify a single pixel, these methods
      return the value of the red, green, blue, or opacity channel
      of that pixel. If the indexes identify more than one pixel,
      these methods return an array of values. See
      [][] for a description of possible index
      arguments.
# Get the value of the green channel of # the top-left pixel in the view. view[0][0] = Pixel(0,128,255) g = view[0][0].green # returns 128 # Get the maximum value of the red channel # for all the pixels in the top row of the view. m = view[0][].red.max
view[i][j] = rvalue
Replaces each pixel identified by the indexes with a
      duplicate of rvalue. The rvalue is
      either a Pixel object or a color name. If
      rvalue is a color name, calls
      Pixel.from_color to create a pixel.
The indexes are the same as [][], above.
[i][j].red = integer
      [i][j].green = integer
      [i][j].blue
      = integer
      [i][j].opacity = integer
Assigns integer to the red, green, blue, or opacity channel of the pixel or pixels identified by the indexes.
# Set the red channel of all the pixels in the 2nd # row of the view to QuantumRange view[1][].red = QuantumRange # Set the green channel of the pixel at [20][30] to # half that of its left-hand neighbor. view[20][30].green = view[20][29].green * 0.5
view.sync(force=false) ->
      true or false
If any of the pixels in the view have been modified, this method stores them in the image. If no pixels have been modified, this method has no effect.
true, forces the view pixels to be
        stored in the image even if none have been modified.true if the pixels were
      stored in the image either because the dirty
      flag was true or force was
      true, false otherwise.
    view.dirty -> true or
      false
      view.dirty = true or false
Any modification to a pixel in the view causes the
      dirty attribute to be set to true.
      You can (although normally you don't need to) set
      dirty=true to force sync to store
      the pixels in the image, or set dirty=false to
      keep sync from storing the pixels.
x -> integer
      y -> integer
      width -> integer
      height -> integer
The x, y, width, and height arguments specified when the view was created.
The Geometry class contains the same information as an ImageMagick geometry string. Geometry objects are interchangeable with geometry strings.
Geometry.new(width=nil, height=nil, x=nil, y=nil, flag=nil) -> geometry
Constructs a new Geometry object.
A geometry string has the general form
      "WxH+x+y[!@%<>]. In a Geometry object,
| Constant name | Geometry string flag | Explanation | 
| PercentGeometry | % | Normally the attributes are treated as pixels. Use
          this flag when the widthandheightattributes represent
          percentages. For example, 125x75 means 125% of
          the height and 75% of the width. Thexandyattributes are not affected by this
          flag. | 
| AspectGeometry | ! | Use this flag when you want to force the new image to
          have exactly the size specified by the the widthandheightattributes. | 
| LessGeometry | < | Use this flag when you want to change the size of the image only if both its width and height are smaller the values specified by those attributes. The image size is changed proportionally. | 
| GreaterGeometry | > | Use this flag when you want to change the size of the image if either its width and height exceed the values specified by those attributes. The image size is changed proportionally. | 
| AreaGeometry | @ | This flag is useful only with a single widthattribute. When present, it means thewidthattribute represents the total area of
          the image in pixels. | 
| MinimumGeometry | ^ | Use ^ to set a minimum image size limit. The geometry 640x480^, for example, means the image width will not be less than 640 and the image height will not be less than 480 pixels after the resize. One of those dimensions will match the requested size, but the image will likely overflow the space requested to preserve its aspect ratio. | 
If any attribute is omitted the default is nil or 0.
g = Magick::Geometry.new(100,200,nil,nil,Magick::AspectGeometry)
Geometry.from_s(string) -> geometry
Constructs a new Geometry object from a
    geometry string.
geom.to_s() -> string
Returns the string equivalent of the Geometry
    object..
A pixel describes the smallest individually addressable part of an image. In the RGB colorspace, a pixel's color is described by its intensity in the red, green, and blue channels. Its opacity is described by its intensity in the opacity (also called alpha, or matte) channel. In the CMYK colorspace a pixel's color is described by its intensity in the cyan, magenta, yellow and black (K) channels. Intensity is a value between 0 and QuantumRange.
Usually, RMagick methods operate on entire images or on groups of pixels that have been selected by their position or color. Some methods, such as pixel_color and view, operate on individual pixels or even on the RGBA (or CMYK) components thereof.
Pixel.new(red, green, blue, opacity) -> pixel
Constructs a pixel object from the specified red, green, blue, and opacity intensities. The intensity is a number between 0 and QuantumRange.
red,
        green, blue, and
        opacity, respectively.Pixel.from_color(color_name) -> pixel
Constructs a new Pixel object from the color name. Raises ArgumentError if the name is unknown.
Pixel.from_hsla(hue, saturation, lightness, alpha=1.0) -> pixel
Constructs a pixel object from the specified arguments.
pixel1 <=> pixel2 -> -1, 0, or 1
Returns -1, 0, or 1 depending on if pixel1 is "less than," equal, or "greater than" the pixel2.
Since there is no way to rank order pixels, and thus determine if one pixel is "greater than" or "less than" another, this method uses an arbitrary algorithm that ensures these two conditions:
-1, 0, or 1
pixel.fcmp(pixel, fuzz=0.0,
      colorspace=RGBColorspace) ->
      true or false
Returns true if the argument is the same color as pixel.
true or false
pixel.intensity() -> integer
Returns the intensity of the pixel. The intensity is computed as 0.299*R+0.587*G+0.114*B.
pixel.to_color(compliance=AllCompliance, matte=false, depth=QuantumDepth, hex=false) ->
      string
Returns the color name corresponding the the pixel values. If there is no such named color in the specified color standard, returns a string in the form "rgb(r,g,b,a)".
to_color to search for a color name in any of
        the 3 defined color standards.Compare this method to Image#to_color, in which the matte and depth values are taken from an image.
pixel.to_HSL -> array
Converts the RGB representation of the pixel to hue, saturation, lightness, and alpha values.
An array of the form [hue, saturation, lightness,
      alpha]. Each value is in the range specified for it,
      as described in from_hsla,
      above.
These classes are created by the Struct class and are used
      to create objects used as attribute and argument values in
      other RMagick classes. Like all the classes created by
      Struct, these classes define both getter and setter methods
      for their attributes. That is, for an attribute x
      both the x and x= methods are
      defined.
The Pixel and Geometry classes
      define additional constructors and conversion methods.
AffineMatrix.new(sx, rx, ry, sy, tx, ty) -> matrix
An AffineMatrix object describes a coordinate transformation. This object is used as an argument to the Image#affine_transform, Image#composite_affine, and Draw#affine methods.
Chromaticity.new(red_primary, green_primary, blue_primary, white_point) -> chromaticity
A Chromaticity object represents chromaticity values for the Image#chromaticity attribute.
The attribute values are Primary objects.
Point.new(x, y) -> point
The value of the pixels_per_em attribute in
      the TypeMetric struct returned by Draw#get_type_metrics is a
      Point object..
Primary.new(x, y, z) -> primary
See class Chromaticity.
Rectangle.new(width, height, x, y) -> rectangle
The value of the Image#tile_info and Image#bounding_box attributes.
Segment.new(x1, y1, x2, y2) -> segment
The Image#new and ImageList#new_image methods accept a
    Fill object as an optional third argument. A
    Fill object is an instance of a Fill
    class. Fill classes are designed to support custom
    background fills. Each Fill class defines only two
    methods, initialize and fill. The
    initialize method is called from the application
    to create an instance of the fill class. It accepts any
    arguments and does whatever is necessary to create the fill.
    The fill method is called from the initialize
    method of the new image object, after the image is completely
    initialized. The fill method gets the image as its
    only argument and sends whatever methods are necessary to the
    image to fill the image's background.
RMagick supplies three Fill classes,
    HatchFill,
    GradientFill, and
    TextureFill. These classes are
    explained below. The HatchFill class is intended
    as an example of how to write a Fill class and is
    written in pure Ruby. You can read it in RMagick.rb.
GradientFill.new(x1, y1, x2, y2, start_color, end_color) -> gradient_fill
Creates a gradient fill. The x1, y1, and x2, y2 arguments describe either a line or a point. If x1 != x2 or y1 != y2, then the arguments describe the starting line for the gradient. The gradient will start with start_color at the starting line and gradually transform to end_color as the distance increases from the starting line.
If x1 == x2 and y1 == y2, the gradient radiates from the specified point, gradually transforming from start_color to end_color.
The line or point does not have to lie within the image bounds.
HatchFill.new(background_color, hatch_color='white', dist=10) -> hatch_fill
Creates a cross-hatched fill.
TextureFill.new(texture_image) -> texture_fill
Creates a texture fill by tiling the texture_image to fill the image.
The texture to be used as the background. May be an image or imagelist. If texture_image is an imagelist, uses the current image.
RMagick raises this exception when an ImageMagick function returns an error condition.
RMagick raises this exception when ImageMagick raises a fatal (unrecoverable) error condition.
RMagick raises this exception when any Image method (except destroyed? and inspect) is called after an image has been destroyed.