class Pixie::Image

• Pixie::Image
• Reference
• Object

Included Modules

• Pixie::Helpers

Defined in:

Constructors

• .new(width : Int, height : Int, background_color : Pixel = Pixel::TRANSPARENT)

  Creates a new blank image using the given width, height, and background color.

• .new(wand : Pointer(LibMagick::MagickWand))

  Creates a new Image from the given LibMagick::MagickWand instance.

• .new(image : Pointer(LibMagick::Image))

  Creates a new Image from the given LibMagick::Image instance.

• .new(input : String | Bytes | IO)

  Creates a new Image from the given stream.

• .new(images : Array(String) | Array(Bytes) | Array(IO))

  Creates a new Image from the given Array, where each element is a layer in the image.

• .new(image : Image)

  Creates a new Image from the given Pixie::Image instance.

• .new

  Creates a new Image with no data.

Class Method Summary

• .import_pixels(pixels : Iterable(Int), width : Int, height : Int, depth : Int, map : String)

  Create an image from a map of pixels.

Instance Method Summary

• #==(other : Image)
• #[](index : Int)

  Get the individual image (layer) at the given index.

• #[](format : String)

  Get image details using special formatting characters.

• #adaptive_blur(radius : Float, sigma : Float)

  Apply an adaptive blur to the image.

• #adaptive_resize(width : Int, height : Int, preserve_aspect_ratio : Bool = false)

  Apply an adaptive resize to the image.

• #adaptive_sharpen(radius : Float, sigma : Float)

  Apply an adaptive sharpen to the image.

• #adaptive_threshold(width : Int, height : Int, bias : Float)

  Apply an adaptive threshold to the image.

• #add_image(image : Image)

  Add an image to the image set.

• #add_noise(noise_type : LibMagick::NoiseType, attenuate : Float = 1.0)

  Add noise to the image.

• #affine_transform(brush : Brush)
• #animate(server_name : String = ":0")

  Animate the image sequence using the given server name.

• #annotate(brush : Brush, x : Float, y : Float, angle : Float, text : String)
• #append(top_to_bottom : Bool = false)

  Append all images together into a single image.

• #auto_gamma

  Automatically adjust the gamma level of this image.

• #auto_level

  Automatically adjust the level of this image.

• #auto_orient

  Automatically orient the image based on its EXIF data.

• #auto_threshold(method : LibMagick::AutoThresholdMethod)

  Automatically threshold the image using the given method.

• #background_color

  Return the background color of the image as a Pixie::Pixel.

• #black_threshold(threshold : Pixel)

  Set the black threshold of the image.

• #blob

  Get the image as a Bytes instance.

• #blue_primary

  Returns the chromaticity blue primary point for the image as an x, y, z tuple.

• #blue_shift(factor : Float)

  Set the blue shift factor of the image.

• #blur(radius : Float, sigma : Float)

  Blur the image using the given radius and sigma.

• #border(border_color : Pixel, width : Int, height : Int, compose : LibMagick::CompositeOperator = :undefined)

  Add a border to the image using the given Pixie::Pixel.

• #border_color

  Return the border color of the image as a Pixie::Pixel.

• #brightness_contrast(brightness : Float, contrast : Float)

  Apply a brightness and contrast adjustment to the image.

• #bytesize
• #canny_edge(radius : Float, sigma : Float, lower_percent : Float, upper_percent : Float)

  Detect edges in the image using the given radius.

• #channel_fx(expression : String)

  Applies a channel expression to the specified image.

• #charcoal(radius : Float, sigma : Float)

  Apply a charcoal effect to the image using the given radius and sigma.

• #chop(width : Int, height : Int, x : Int, y : Int)

  Removes a region of a canvas and collapses the canvas to occupy the removed portion.

• #clahe(width : Int, height : Int, number_bins : Float, clip_limit : Float)

  a variant of adaptive histogram equalization in which the contrast amplification is limited, so as to reduce this problem standard non-contrast limited AHE.

• #clamp

  Restricts the color range from 0 to the quantum depth.

• #clear
• #clip

  Clips along the first path from the 8BIM profile, if present.

• #clip_path(pathname : String, inside : Bool = false)

  Clips along the named paths from the 8BIM profile, if present.

• #clone
• #clut(clut : Image, method : LibMagick::PixelInterpolateMethod)

  Replaces colors in the image from a color lookup table.

• #coalesce

  Composites a set of images while respecting any page offsets and disposal methods.

• #collect_unique_colors
• #color_correct(collection : String)

  accepts a lightweight Color Correction Collection (CCC) file which solely contains one or more color corrections and applies the color correction to the image.

• #color_matrix(matrix : LibMagick::KernelInfo)

  Apply color transformation to an image.

• #colorize(colorize : Pixel, blend : Pixel)

  Blends the fill color with each pixel in the image.

• #colormap_color(index)
• #colors
• #colorspace
• #combine(colorspace : LibMagick::ColorspaceType)

  Combines one or more images into a single image.

• #comment(comment : String)

  Adds a comment to your image.

• #compare(reference : Image, metric : LibMagick::MetricType, distortion : Float)

  Compares an image to a reconstructed image and returns the specified difference image.

• #compare_layers(method : LibMagick::LayerMethod)

  Compares each image with the next in a sequence and returns the maximum bounding region of any pixel differences it discovers.

• #complex(op : LibMagick::ComplexOperator)

  Performs complex mathematics on an image sequence using the given oprtator.

• #composite(source : Image, operator : LibMagick::CompositeOperator, clip_to_self : Bool, x : Int, y : Int)

  Composites two images together using the given operator.

• #composite(source : Image, compose : LibMagick::CompositeOperator, gravity : LibMagick::GravityType)

  Composites two images together using the given operator and gravity.

• #composite_layers(source : Image, compose : LibMagick::CompositeOperator, x : Int, y : Int)

  Composite the images in the source wand over the images in the destination wand in sequence, starting with the current image in both lists.

• #composite_operator
• #compression
• #compression_quality
• #connected_components(connectivity : Int)

  Returns the connected-components of the image uniquely labeled.

• #constitute(columns : Int, rows : Int, map : String, storage : LibMagick::StorageType, pixels : Array(U)) forall U

  Adds an image to the wand comprised of the pixel data you supply.

• #contrast(sharpen : Bool)

  Enhances the intensity differences between the lighter and darker elements of the image.

• #contrast_stretch(black_point : Float, white_point : Float)

  Enhances the contrast of a color image by adjusting the pixels color to span the entire range of colors available.

• #convolve(kernel : LibMagick::KernelInfo)

  Applies a custom convolution kernel to the image.

• #crop(width : Int, height : Int, x : Int, y : Int)

  Extracts a region of the image.

• #cycle_colormap(displace : Int)

  Displaces an image's colormap by a given number of positions.

• #decipher(passphrase : String)

  Converts cipher pixels to plain pixels.

• #deconstruct

  Compares each image with the next in a sequence and returns the maximum bounding region of any pixel differences it discovers.

• #delay
• #delete_property(name : String)

  Delete a specific property of the image.

• #depth
• #deskew(threshold : Float)

  Removes skew from the image.

• #despeckle

  Reduces the speckle noise in an image while perserving the edges of the original image.

• #display(x_server : String = ":0")

  Displays an image using the given X server.

• #displays(x_server : String = ":0")

  Displays an image sequence using the given X server.

• #dispose
• #distort(method : LibMagick::DistortMethod, args : Array(Float64), best_fit : Bool = false)

  Distorts an image using various distortion methods, by mapping color lookups of the source image to a new destination image usally of the same size as the source image, unless best_fit is set to true.

• #distortion(reference : Wand, metric : LibMagick::MetricType)
• #distortions(reference : Wand, metric : LibMagick::MetricType, channel : LibMagick::ChannelType)
• #draw(brush : Brush)
• #draw(&block : Brush -> )
• #edge(radius : Float = 0.0)

  Enhances edges within the image with a convolution filter of the given radius.

• #emboss(radius : Float = 0.0, sigma : Float = 0.0)

  Enhance edges within the image with a convolution filter of the given radius and sigma.

• #encipher(passphrase : String)
• #endian
• #enhance
• #enhance_local_contrast(radius : Float64, strength : Float64)
• #equalize
• #evaluate(operator : LibMagick::MagickEvaluateOperator, value : Float)
• #evaluate(operator : LibMagick::MagickEvaluateOperator)
• #exif

  Return EXIF data for the image as a Hash(String, String).

• #extent(width : Int, height : Int, x : Int, y : Int)

  Extend the image as defined by the geometry, gravity, and wand background color.

• #features(distance)
• #filename
• #finalize
• #flip
• #flood_fill_paint(fill : Pixel, fuzz : Float, border_color : Pixel, x : Int, y : Int, invert : Bool = false)
• #flop
• #format
• #forward_fourier_transform(magnitude : Float)
• #frame(matte_color : Pixel, width : Int, height : Int, inner_bevel : Int, outer_bevel : Int, compose : LibMagick::CompositeOperator)
• #function(function : LibMagick::MagickFunction, args : Array(Float64))
• #fuzz
• #fx(expression : String)
• #gamma(gamma : Float)
• #gamma
• #gaussian_blur(radius : Float, sigma : Float)
• #get_region(width, height, x, y)
• #gravity
• #green_primary

  Returns the chromaticity green primary point for the image as an x, y, z tuple.

• #has_alpha?

  Returns true if the image has an alpha channel.

• #has_next?

  Returns true if there are multiple images in the image set, and #pos is less than the number of images.

• #has_prev?

  Returns true if there are multiple images in the image set, and #pos is greater than zero.

• #hash

  Generates an UInt64 hash value for this object.

• #height

  Return the height of the image.

• #histogram(n_colors = nil)
• #hough_line(width, height, threshold)
• #identify
• #identify_type
• #image_similarity(reference : Wand, metric : LibMagick::MetricType, threshold : Float64)
• #implode(radius, method : PixelInterpolateMethod = :average)
• #import_pixels(pixels : Iterable(Int), width, height, depth : Int, map : String = "RGB")
• #intent
• #interlace_scheme
• #interpolative_resize(width, height, method : LibMagick::PixelInterpolateMethod = :average, preserve_aspect_ratio : Bool = false)
• #inverse_fourier_transform(phase_image : Pixie::Wand, magnitude = false)
• #iterations
• #kurtosis

  TODO Figure out how to specify a channel

• #kuwahara_filter(radius : Float64, sigma : Float64)
• #label(label : String)
• #layers

  Returns an Array(Image), where each image is a layer in the image.

• #level(black_point : Float64, gamma : Float64, white_point : Float64)
• #level_colors(black_color : Pixel, white_color : Pixel, invert = false)
• #levelize(black_point : Float64, white_point : Float64, gamma : Float64)
• #linear_stretch(black_point : Float64, white_point : Float64)
• #liquid_rescale(width : Int, height : Int, delta_x : Float64 = 0.0, rigidity : Float64 = 0.0)
• #lower(width : Int, height : Int, x : Int, y : Int)
• #magnify
• #matte_color
• #mean
• #mean_shift(width : Int, height : Int, color_distance : Float64)
• #merge_layers(method : LibMagick::LayerMethod = :merge)
• #minify
• #modulate(brightness : Float64, saturation : Float64, hue : Float64)
• #montage(thumbnail_geometry : String | Nil = nil, tile_geometry : String | Nil = nil, brush : Brush = Brush.new, mode : LibMagick::MontageMode = :undefined, frame : String | Nil = nil)

  Create a montage from the images in the current set.

• #morphology(n_frames : Int)
• #morphology_method(method : LibMagick::MorphologyMethod, iterations : Int, kernel : Pointer(LibMagick::KernelInfo))
• #motion_blur(radius : Float64, sigma : Float64, angle : Float64)
• #negate(gray : Bool)
• #next

  Returns the next image in the image set.

• #normalize
• #oil_paint(radius : Float64, sigma : Float64)
• #opaque_paint(target_color : Pixel, fill_color : Pixel, fuzz : Float64, invert : Bool = false)
• #optimize_layers
• #optimize_transparency
• #ordered_dither(threshold_map : String)
• #orientation
• #page
• #path : String | Nil

  The location of the current working file

• #pixel(x, y)

  Get the pixel at the given x and y coordinates.

• #pixel_interpolation_method
• #pixels(x : Int = 0, y : Int = 0, columns : Int = width, rows : Int = height, map : String = "RGB", storage : LibMagick::StorageType = :char)

  Extract pixel data from the image and return it as a multi-dimensional array of rows and columns, each containing an array of pixel data represnting the given map (defaulting to RGB).

• #polaroid(brush : Brush, caption : String, angle : Float64, method : LibMagick::PixelInterpolateMethod = :average)
• #polynomial(n_terms : Int, terms : Float64)
• #pos

  Returns the current position in the image set.

• #posterize(levels : Int, dither_method : LibMagick::DitherMethod = :none)
• #prev

  Returns the previous image in the image set.

• #preview_transform(type : LibMagick::PreviewType)
• #property(name : String)

  Get a specific property of the image.

• #quantize(n_colors : Int, colorspace : LibMagick::ColorspaceType, treedepth : Int, dither_method : LibMagick::DitherMethod = :none, measure_error : Bool = false)
• #quantize_all(n_colors : Int, colorspace : LibMagick::ColorspaceType, treedepth : Int, dither_method : LibMagick::DitherMethod = :none, measure_error : Bool = false)
• #query_fonts(pattern : String)
• #query_formats(pattern : String)
• #raise(width : Int, height : Int, x : Int, y : Int)
• #random_threshold(low : Float64, high : Float64)
• #range
• #range_threshold(low_black : Float64, low_white : Float64, hight_white : Float64, hight_black : Float64)
• #read(filename : String)
• #read(buffer : IO)
• #read(buffer : Bytes)
• #red_primary

  Returns the chromaticity red primary point for the image as an x, y, z tuple.

• #remap(affinity : Wand, method : LibMagick::DitherMethod = :none)
• #remove
• #resample(x_resolution : Float64, y_resolution : Float64, filter : LibMagick::FilterType)
• #reset_page(page : String)
• #resize(width : Int, height : Int, filter : LibMagick::FilterType = :lanczos)

  Resize the image to fit within the specified dimensions.

• #resize_to_fit(width : Int, height : Int, filter : LibMagick::FilterType = :lanczos)

  Resize the image to not be larger than the specified dimensions.

• #resolution
• #rewind

  Reset the underlying iterator to the first image in the set.

• #roll(x : Int, y : Int)
• #rotate(background : Pixel, degrees : Float64)
• #rotational_blur(angle : Float64)
• #sample(width : Int, height : Int)
• #scale(width : Int, height : Int)
• #scene
• #segment(colorspace : LibMagick::ColorspaceType, cluster_threshold : Float64, smooth_threshold : Float64, verbose = false)
• #selective_blur(radius : Float64, sigma : Float64, threshold : Float64)
• #separate(channel : LibMagick::ChannelType)
• #sepia(threshold : Float64)
• #set(image : Wand)
• #set_alpha(value : LibMagick::AlphaChannelOption)

  Set the image's alpha channel to the given LibMagick::AlphaChannelOption.

• #set_artifact(key : String, value : String)
• #set_background_color(background : Pixel)

  Set the background color of the image to the given Pixie::Pixel.

• #set_blue_primary(x, y, z)

  Set the chromaticity blue primary point for the image to the given x, y, and z values.

• #set_border_color(color : Pixel)

  Set the border color of the image to the given Pixie::Pixel.

• #set_color(color : Pixel)
• #set_colormap_color(index : Int, color : Pixel)
• #set_colorspace(colorspace : LibMagick::ColorspaceType)
• #set_composite_operator(op : LibMagick::CompositeOperator)
• #set_compression(value : LibMagick::CompressionType)
• #set_compression_quality(quality : Int)
• #set_delay(val : Int)
• #set_depth(val : Int)
• #set_dispose(val : LibMagick::DisposeType)
• #set_endian(val : LibMagick::EndianType)
• #set_extent(width : Int, height : Int)
• #set_filename(val : String)
• #set_format(val : String)
• #set_fuzz(val : Float64)
• #set_gamma(val : Float64)
• #set_gravity(val : Float64)
• #set_green_primary(x, y, z)

  Set the chromaticity green primary point for the image to the given x, y, and z values.

• #set_intent(val : LibMagick::RenderingIntent)
• #set_interlace_scheme(val : LibMagick::InterlaceType)
• #set_iterations(val : Int)
• #set_matte(val : Bool)
• #set_matte_color(val : Pixel)
• #set_orientation(val : LibMagick::OrienationType)
• #set_page(width : Int, height : Int, x : Int, y : Int)
• #set_pixel(x : Int, y : Int, color : Pixel)

  Set the pixel at the given x and y coordinates.

• #set_pixel_interpolation_method(val : LibMagick::PixelInterpolateMethod)
• #set_pos(index : Int)

  Sets the current position in the image set.

• #set_property(name : String, value : String)

  Set a specific property of the image.

• #set_red_primary(x, y, z)

  Set the chromaticity red primary point for the image to the given x, y, and z values.

• #set_resolution(x : Float64, y : Float64)
• #set_scen(scene : Int)
• #set_ticks_per_second(val : Int)
• #set_type(val : LibMagick::ImageType)
• #set_units(val : LibMagick::ResolutionType)
• #set_virtual_pixel_method(val : LibMagick::VirtualPixelMethod)
• #set_white_point(x : Float64, y : Float64, z : Float64)
• #shade(azimuth : Float64, elevation : Float64, gray : Bool = false)
• #shadow(alpha : Float64, sigma : Float64, x : Int, y : Int)
• #sharpen(radius : Float64, sigma : Float64)
• #shave(width : Int, height : Int)
• #shear(background : Pixel, x : Float64, y : Float64)
• #sigmoidal_constrast(alpha : Float64, beta : Float64, sharpen : Bool = false)
• #signature
• #size
• #sketch(radius : Float64, sigma : Float64, angle : Float64)
• #smush(offset : Int, stack : Bool = false)
• #solarize(threshold : Float64)
• #sparse_color(method : LibMagick::SparseColorMethod, args : Array(Float64))
• #splice(width : Int, height : Int, x : Int, y : Int)
• #spread(method : LibMagick::PixelInterpolateMethod, radius : Float64)
• #statistic(type : LibMagick::StatisticType, width : Int, height : Int)
• #statistics(channel : LibMagick::ChannelType)
• #stego(watermark : Wand, offset : Int)
• #stereo(offset : Wand)
• #strip
• #swirl(degrees : Float64, method : LibMagick::PixelInterpolateMethod)
• #texture(texture : Wand)
• #threshold(threshold : Float64)
• #threshold_channel(channel : LibMagick::ChannelType, threshold : Float64)
• #thumbnail(width : Int, height : Int)
• #ticks_per_second
• #tint(tint : Pixel, blend : Pixel)
• #to_io
• #to_unsafe : Pointer(LibMagick::MagickWand)
• #to_unsafe_image
• #total_ink_density
• #transform_colorspace(colorspace : LibMagick::ColorspaceType)
• #transparent_paint(target : Pixel, alpha : Float64, fuzz : Float64, invert : Bool = false)
• #transpose
• #transverse
• #trim(fuzz : Float64)
• #type
• #units
• #unsharp_mask(radius : Float64, sigma : Float64, gain : Float64, threshold : Float64)
• #vignette(radius : Float64, sigma : Float64, x : Int, y : Int)
• #virtual_pixel_method
• #wave(amplitude : Float64, length : Float64, method : LibMagick::PixelInterpolateMethod)
• #wavelet_denoise(threshold : Float64, softness : Float64)
• #white_point
• #white_threshold(threshold : Pixel)
• #width

  Return the width of the image.

• #write(path : String)
• #xmp

  Return XMP data for the image as a Hash(String, String).

Constructor Detail

image = Image.new(640, 480, Pixel::RED)

Class Method Detail

image = Image.import_pixels(pixels, 0, 0, 16, "RGB")

Instance Method Detail

image = Image.new("/path/to/image.gif")
image[0] # => Image

image = Image.new("/path/to/image.png")
image["%w"] # => "640"
image["%h"] # => "480"
image["%f"] # => "image.png"

  <ColorCorrectionCollection xmlns="urn:ASC:CDL:v1.2">
    <ColorCorrection id="cc03345">
      <SOPNode>
        <Slope> 0.9 1.2 0.5 </Slope>
        <Offset> 0.4 -0.5 0.6 </Offset>
        <Power> 1.0 0.8 1.5 </Power>
      </SOPNode>
      <SATNode>
        <Saturation> 0.85 </Saturation>
      </SATNode>
    </ColorCorrection>
  </ColorCorrectionCollection>

image = Image.new
data = Array(UInt8).new(640 * 480 * 3) { 0u8 }
image.constitute(640, 480, "RGB", :char, data)

image = Image.new("/path/to/image.png")
image.delete_property("exif:GPSLatitude")

image = Image.new("/path/to/image.png")
image.distort(:affine, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

image = Image.new("/path/to/image.gif")
image.layers # => Array(Image)

image = Image.new("/path/to/image.png")
image.pixels.each do |row|
  row.each do |col|
    puts col # => [255, 255, 255]
  end
end

image = Image.new("/path/to/image.png")
image.property("date:create") # => "2019:01:01 12:00:00"

image = Image.new("/path/to/image.png")
image.border_color = Pixel::RED

image = Image.new("/path/to/image.png")
image.set_property("exif:GPSLatitude", "40/1, 43/1, 54/1")