Class: Vips::Image

Inherits:
Object show all
Defined in:
lib/vips/image.rb,
lib/vips/methods.rb

Overview

This class represents a libvips image. See the Vips module documentation for an introduction to using this class.

Defined Under Namespace

Modules: ImageLayout Classes: GenericPtr, ManagedStruct, Struct

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Object

#get_pspec, #get_typeof_error, print_all

Methods inherited from GObject::GObject

ffi_managed_struct, #ffi_managed_struct, #ffi_struct, ffi_struct, #initialize

Constructor Details

This class inherits a constructor from GObject::GObject

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args, **options) ⇒ Object

Invoke a vips operation with Operation.call, using self as the first input argument.

Parameters:

  • name (String) —

    vips operation to call

Returns:

  • result of vips operation



201
202
203
 
# File 'lib/vips/image.rb', line 201

def method_missing name, *args, **options
    Vips::Operation.call name.to_s, [self, *args], options
end

Class Method Details

.analyzeload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load an analyze6 image.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 900

.arrayjoin(im, opts = {}) ⇒ Vips::Image

Join an array of images.

Parameters:

  • im (Array<Image>) —

    Array of input images

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :across (Integer) —

    Number of images across grid

  • :shim (Integer) —

    Pixels between images

  • :background (Array<Double>) —

    Colour for new pixels

  • :halign (Vips::Align) —

    Align on the left, centre or right

  • :valign (Vips::Align) —

    Align on the top, centre or bottom

  • :hspacing (Integer) —

    Horizontal spacing between images

  • :vspacing (Integer) —

    Vertical spacing between images

Returns:




# File 'lib/vips/methods.rb', line 362

.bandrank(im, opts = {}) ⇒ Vips::Image

Band-wise rank of a set of images.

Parameters:

  • im (Array<Image>) —

    Array of input images

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :index (Integer) —

    Select this band element from sorted list

Returns:




# File 'lib/vips/methods.rb', line 414

.black(width, height, opts = {}) ⇒ Vips::Image

Make a black image.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :bands (Integer) —

    Number of bands in image

Returns:




# File 'lib/vips/methods.rb', line 562

.complex?(format) ⇒ Boolean

Returns:

  • (Boolean) 


93
94
95
96
 
# File 'lib/vips/image.rb', line 93

def self.complex? format
    format_number = GObject::GValue.from_nick BAND_FORMAT_TYPE, format
    Vips::vips_band_format_iscomplex(format_number) != 0
end

.csvload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load csv from file.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :skip (Integer) —

    Skip this many lines at the start of the file

  • :lines (Integer) —

    Read this many lines from the file

  • :fail (Boolean) —

    Fail on first error

  • :whitespace (String) —

    Set of whitespace characters

  • :separator (String) —

    Set of separator characters

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 852

.eye(width, height, opts = {}) ⇒ Vips::Image

Make an image showing the eye's spatial response.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :uchar (Boolean) —

    Output an unsigned char image

  • :factor (Float) —

    Maximum spatial frequency

Returns:




# File 'lib/vips/methods.rb', line 620

.fitsload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load a fits image.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 1159

.float?(format) ⇒ Boolean

Returns:

  • (Boolean) 


98
99
100
101
 
# File 'lib/vips/image.rb', line 98

def self.float? format
    format_number = GObject::GValue.from_nick BAND_FORMAT_TYPE, format
    Vips::vips_band_format_isfloat(format_number) != 0
end

.fractsurf(width, height, fractal_dimension, opts = {}) ⇒ Vips::Image

Make a fractal surface.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • fractal_dimension (Float) —

    Fractal dimension

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 827

.gaussmat(sigma, min_ampl, opts = {}) ⇒ Vips::Image

Make a gaussian image.

Parameters:

  • sigma (Float) —

    Sigma of Gaussian

  • min_ampl (Float) —

    Minimum amplitude of Gaussian

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :separable (Boolean) —

    Generate separable Gaussian

  • :precision (Vips::Precision) —

    Generate with this precision

Returns:




# File 'lib/vips/methods.rb', line 602

.gaussnoise(width, height, opts = {}) ⇒ Vips::Image

Make a gaussnoise image.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :sigma (Float) —

    Standard deviation of pixels in generated image

  • :mean (Float) —

    Mean of pixels in generated image

Returns:




# File 'lib/vips/methods.rb', line 570

.gifload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load gif with giflib.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :n (Integer) —

    Load this many pages

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :page (Integer) —

    Load this page from the file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 994

.gifload_buffer(buffer, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load gif with giflib.

Parameters:

  • buffer (VipsBlob) —

    Buffer to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :n (Integer) —

    Load this many pages

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :page (Integer) —

    Load this page from the file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 1006

.grey(width, height, opts = {}) ⇒ Vips::Image

Make a grey ramp image.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :uchar (Boolean) —

    Output an unsigned char image

Returns:




# File 'lib/vips/methods.rb', line 629

.identity(opts = {}) ⇒ Vips::Image

Make a 1d image where pixel values are indexes.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :bands (Integer) —

    Number of bands in LUT

  • :ushort (Boolean) —

    Create a 16-bit LUT

  • :size (Integer) —

    Size of 16-bit LUT

Returns:




# File 'lib/vips/methods.rb', line 819

.jpegload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load jpeg from file.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :shrink (Integer) —

    Shrink factor on load

  • :fail (Boolean) —

    Fail on first error

  • :autorotate (Boolean) —

    Rotate image using exif orientation

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 1048

.jpegload_buffer(buffer, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load jpeg from buffer.

Parameters:

  • buffer (VipsBlob) —

    Buffer to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :shrink (Integer) —

    Shrink factor on load

  • :fail (Boolean) —

    Fail on first error

  • :autorotate (Boolean) —

    Rotate image using exif orientation

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 1060

.logmat(sigma, min_ampl, opts = {}) ⇒ Vips::Image

Make a laplacian of gaussian image.

Parameters:

  • sigma (Float) —

    Radius of Logmatian

  • min_ampl (Float) —

    Minimum amplitude of Logmatian

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :separable (Boolean) —

    Generate separable Logmatian

  • :precision (Vips::Precision) —

    Generate with this precision

Returns:




# File 'lib/vips/methods.rb', line 611

.magickload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load file with imagemagick.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :density (String) —

    Canvas resolution for rendering vector formats like SVG

  • :page (Integer) —

    Load this page from the file

  • :n (Integer) —

    Load this many pages

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 1133

.magickload_buffer(buffer, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load buffer with imagemagick.

Parameters:

  • buffer (VipsBlob) —

    Buffer to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :density (String) —

    Canvas resolution for rendering vector formats like SVG

  • :page (Integer) —

    Load this page from the file

  • :n (Integer) —

    Load this many pages

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 1146

.mask_butterworth(width, height, order, frequency_cutoff, amplitude_cutoff, opts = {}) ⇒ Vips::Image

Make a butterworth filter.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • order (Float) —

    Filter order

  • frequency_cutoff (Float) —

    Frequency cutoff

  • amplitude_cutoff (Float) —

    Amplitude cutoff

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :uchar (Boolean) —

    Output an unsigned char image

  • :nodc (Boolean) —

    Remove DC component

  • :reject (Boolean) —

    Invert the sense of the filter

  • :optical (Boolean) —

    Rotate quadrants to optical space

Returns:




# File 'lib/vips/methods.rb', line 694

.mask_butterworth_band(width, height, order, frequency_cutoff_x, frequency_cutoff_y, radius, amplitude_cutoff, opts = {}) ⇒ Vips::Image

Make a butterworth_band filter.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • order (Float) —

    Filter order

  • frequency_cutoff_x (Float) —

    Frequency cutoff x

  • frequency_cutoff_y (Float) —

    Frequency cutoff y

  • radius (Float) —

    radius of circle

  • amplitude_cutoff (Float) —

    Amplitude cutoff

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :uchar (Boolean) —

    Output an unsigned char image

  • :nodc (Boolean) —

    Remove DC component

  • :reject (Boolean) —

    Invert the sense of the filter

  • :optical (Boolean) —

    Rotate quadrants to optical space

Returns:




# File 'lib/vips/methods.rb', line 723

.mask_butterworth_ring(width, height, order, frequency_cutoff, amplitude_cutoff, ringwidth, opts = {}) ⇒ Vips::Image

Make a butterworth ring filter.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • order (Float) —

    Filter order

  • frequency_cutoff (Float) —

    Frequency cutoff

  • amplitude_cutoff (Float) —

    Amplitude cutoff

  • ringwidth (Float) —

    Ringwidth

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :uchar (Boolean) —

    Output an unsigned char image

  • :nodc (Boolean) —

    Remove DC component

  • :reject (Boolean) —

    Invert the sense of the filter

  • :optical (Boolean) —

    Rotate quadrants to optical space

Returns:




# File 'lib/vips/methods.rb', line 708

.mask_fractal(width, height, fractal_dimension, opts = {}) ⇒ Vips::Image

Make fractal filter.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • fractal_dimension (Float) —

    Fractal dimension

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :uchar (Boolean) —

    Output an unsigned char image

  • :nodc (Boolean) —

    Remove DC component

  • :reject (Boolean) —

    Invert the sense of the filter

  • :optical (Boolean) —

    Rotate quadrants to optical space

Returns:




# File 'lib/vips/methods.rb', line 781

.mask_gaussian(width, height, frequency_cutoff, amplitude_cutoff, opts = {}) ⇒ Vips::Image

Make a gaussian filter.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • frequency_cutoff (Float) —

    Frequency cutoff

  • amplitude_cutoff (Float) —

    Amplitude cutoff

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :uchar (Boolean) —

    Output an unsigned char image

  • :nodc (Boolean) —

    Remove DC component

  • :reject (Boolean) —

    Invert the sense of the filter

  • :optical (Boolean) —

    Rotate quadrants to optical space

Returns:




# File 'lib/vips/methods.rb', line 739

.mask_gaussian_band(width, height, frequency_cutoff_x, frequency_cutoff_y, radius, amplitude_cutoff, opts = {}) ⇒ Vips::Image

Make a gaussian filter.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • frequency_cutoff_x (Float) —

    Frequency cutoff x

  • frequency_cutoff_y (Float) —

    Frequency cutoff y

  • radius (Float) —

    radius of circle

  • amplitude_cutoff (Float) —

    Amplitude cutoff

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :uchar (Boolean) —

    Output an unsigned char image

  • :nodc (Boolean) —

    Remove DC component

  • :reject (Boolean) —

    Invert the sense of the filter

  • :optical (Boolean) —

    Rotate quadrants to optical space

Returns:




# File 'lib/vips/methods.rb', line 766

.mask_gaussian_ring(width, height, frequency_cutoff, amplitude_cutoff, ringwidth, opts = {}) ⇒ Vips::Image

Make a gaussian ring filter.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • frequency_cutoff (Float) —

    Frequency cutoff

  • amplitude_cutoff (Float) —

    Amplitude cutoff

  • ringwidth (Float) —

    Ringwidth

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :uchar (Boolean) —

    Output an unsigned char image

  • :nodc (Boolean) —

    Remove DC component

  • :reject (Boolean) —

    Invert the sense of the filter

  • :optical (Boolean) —

    Rotate quadrants to optical space

Returns:




# File 'lib/vips/methods.rb', line 752

.mask_ideal(width, height, frequency_cutoff, opts = {}) ⇒ Vips::Image

Make an ideal filter.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • frequency_cutoff (Float) —

    Frequency cutoff

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :uchar (Boolean) —

    Output an unsigned char image

  • :nodc (Boolean) —

    Remove DC component

  • :reject (Boolean) —

    Invert the sense of the filter

  • :optical (Boolean) —

    Rotate quadrants to optical space

Returns:




# File 'lib/vips/methods.rb', line 655

.mask_ideal_band(width, height, frequency_cutoff_x, frequency_cutoff_y, radius, opts = {}) ⇒ Vips::Image

Make an ideal band filter.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • frequency_cutoff_x (Float) —

    Frequency cutoff x

  • frequency_cutoff_y (Float) —

    Frequency cutoff y

  • radius (Float) —

    radius of circle

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :uchar (Boolean) —

    Output an unsigned char image

  • :nodc (Boolean) —

    Remove DC component

  • :reject (Boolean) —

    Invert the sense of the filter

  • :optical (Boolean) —

    Rotate quadrants to optical space

Returns:




# File 'lib/vips/methods.rb', line 680

.mask_ideal_ring(width, height, frequency_cutoff, ringwidth, opts = {}) ⇒ Vips::Image

Make an ideal ring filter.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • frequency_cutoff (Float) —

    Frequency cutoff

  • ringwidth (Float) —

    Ringwidth

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :uchar (Boolean) —

    Output an unsigned char image

  • :nodc (Boolean) —

    Remove DC component

  • :reject (Boolean) —

    Invert the sense of the filter

  • :optical (Boolean) —

    Rotate quadrants to optical space

Returns:




# File 'lib/vips/methods.rb', line 667

.matload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load mat from file.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 1038

.matrix_from_array(width, height, array) ⇒ Object 



297
298
299
300
301
302
303
 
# File 'lib/vips/image.rb', line 297

def self.matrix_from_array width, height, array
    ptr = FFI::MemoryPointer.new :double, array.length
    ptr.write_array_of_double array
    image = Vips::vips_image_new_matrix_from_array width, height, 
        ptr, array.length
    Vips::Image.new image
end

.matrixload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load matrix from file.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 866

.method_missing(name, *args, **options) ⇒ Object

Invoke a vips operation with Operation.call.



206
207
208
 
# File 'lib/vips/image.rb', line 206

def self.method_missing name, *args, **options
    Vips::Operation.call name.to_s, args, options
end

.new_from_array(array, scale = 1, offset = 0) ⇒ Image

Create a new Image from a 1D or 2D array. A 1D array becomes an image with height 1. Use scale and offset to set the scale and offset fields in the header. These are useful for integer convolutions.

For example:

image = Vips::new_from_array [1, 2, 3]

or

image = Vips::new_from_array [
    [-1, -1, -1],
    [-1, 16, -1],
    [-1, -1, -1]], 8

for a simple sharpening mask.

Parameters:

  • array (Array) —

    the pixel data as an array of numbers

  • scale (Real) (defaults to: 1) —

    the convolution scale

  • offset (Real) (defaults to: 0) —

    the convolution offset

Returns:

Raises:



331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
 
# File 'lib/vips/image.rb', line 331

def self.new_from_array array, scale = 1, offset = 0
    # we accept a 1D array and assume height == 1, or a 2D array
    # and check all lines are the same length
    unless array.is_a? Array
        raise Vips::Error, "Argument is not an array."
    end

    if array[0].is_a? Array
        height = array.length
        width = array[0].length
        unless array.all? {|x| x.is_a? Array}
            raise Vips::Error, "Not a 2D array."
        end
        unless array.all? {|x| x.length == width}
            raise Vips::Error, "Array not rectangular."
        end
        array = array.flatten
    else
        height = 1
        width = array.length
    end

    unless array.all? {|x| x.is_a? Numeric}
        raise Vips::Error, "Not all array elements are Numeric."
    end

    image = Vips::Image.matrix_from_array width, height, array
    raise Vips::Error if image == nil

    # be careful to set them as double
    image.set_type GObject::GDOUBLE_TYPE, 'scale', scale.to_f
    image.set_type GObject::GDOUBLE_TYPE, 'offset', offset.to_f

    return image
end

.new_from_buffer(data, option_string, opts = {}) ⇒ Image

Create a new Vips::Image for an image encoded, in a format such as JPEG, in a memory string. Load options may be passed as strings or appended as a hash. For example:

image = Vips::Image.new_from_buffer memory_buffer, "shrink=2"

or alternatively:

image = Vips::Image.new_from_buffer memory_buffer, "", shrink: 2

The options available depend on the file format. Try something like:

$ vips jpegload_buffer

at the command-line to see the available options. Not all loaders support load from buffer, but at least JPEG, PNG and TIFF images will work.

Loading is fast: only enough of the image is loaded to be able to fill out the header. Pixels will only be decompressed when they are needed.

Parameters:

  • data (String) —

    the data to load from

  • option_string (String) —

    load options as a string

  • opts (Hash) (defaults to: {}) —

    set of options

Options Hash (opts):

  • :disc (Boolean) — default: true —

    Open large images via a temporary disc file

  • :access (Vips::Access) — default: :random —

    Access mode for file

Returns:

  • (Image) —

    the loaded image

Raises:



290
291
292
293
294
295
 
# File 'lib/vips/image.rb', line 290

def self.new_from_buffer data, option_string, opts = {}
    loader = Vips::vips_foreign_find_load_buffer data, data.bytesize
    raise Vips::Error if loader == nil

    Vips::Operation.call loader, [data], opts, option_string
end

.new_from_file(name, opts = {}) ⇒ Image

Return a new Vips::Image for a file on disc. This method can load images in any format supported by vips. The filename can include load options, for example:

image = Vips::new_from_file "fred.jpg[shrink=2]"

You can also supply options as a hash, for example:

image = Vips::new_from_file "fred.jpg", shrink: 2

The full set of options available depend upon the load operation that will be executed. Try something like:

$ vips jpegload

at the command-line to see a summary of the available options for the JPEG loader.

Loading is fast: only enough of the image is loaded to be able to fill out the header. Pixels will only be decompressed when they are needed.

Parameters:

  • name (String) —

    the filename to load from

  • opts (Hash) (defaults to: {}) —

    set of options

Options Hash (opts):

  • :disc (Boolean) — default: true —

    Open large images via a temporary disc file

  • :access (Vips::Access) — default: :random —

    Access mode for file

Returns:

  • (Image) —

    the loaded image

Raises:



246
247
248
249
250
251
252
253
254
255
256
257
 
# File 'lib/vips/image.rb', line 246

def self.new_from_file name, opts = {}
    # very common, and Vips::vips_filename_get_filename will segv if we 
    # pass this
    raise Vips::Error, "filename is nil" if name == nil

    filename = Vips::vips_filename_get_filename name
    option_string = Vips::vips_filename_get_options name
    loader = Vips::vips_foreign_find_load filename
    raise Vips::Error if loader == nil

    Operation.call loader, [filename], opts, option_string
end

.openexrload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load an openexr image.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 1169

.openslideload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load file with openslide.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :level (Integer) —

    Load this level from the file

  • :autocrop (Boolean) —

    Crop to image bounds

  • :fail (Boolean) —

    Fail on first error

  • :associated (String) —

    Load this associated image

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 1120

.pdfload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load pdf with libpoppler.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :page (Integer) —

    Load this page from the file

  • :n (Integer) —

    Load this many pages

  • :fail (Boolean) —

    Fail on first error

  • :dpi (Float) —

    Render at this DPI

  • :scale (Float) —

    Scale output by this factor

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 930

.pdfload_buffer(buffer, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load pdf with libpoppler.

Parameters:

  • buffer (VipsBlob) —

    Buffer to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :page (Integer) —

    Load this page from the file

  • :n (Integer) —

    Load this many pages

  • :fail (Boolean) —

    Fail on first error

  • :dpi (Float) —

    Render at this DPI

  • :scale (Float) —

    Scale output by this factor

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 944

.perlin(width, height, opts = {}) ⇒ Vips::Image

Make a perlin noise image.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :cell_size (Integer) —

    Size of Perlin cells

  • :uchar (Boolean) —

    Output an unsigned char image

Returns:




# File 'lib/vips/methods.rb', line 843

.pngload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load png from file.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 1018

.pngload_buffer(buffer, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load png from buffer.

Parameters:

  • buffer (VipsBlob) —

    Buffer to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 1028

.ppmload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load ppm from file.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 910

.radload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load a radiance image from a file.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 920

.rawload(filename, width, height, bands, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load raw data from a file.

Parameters:

  • filename (String) —

    Filename to load from

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • bands (Integer) —

    Number of bands in image

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :offset (guint64) —

    Offset in bytes from start of file

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 876

.respond_to?(name, include_all = false) ⇒ Boolean

Returns:

  • (Boolean) 


189
190
191
192
193
194
 
# File 'lib/vips/image.rb', line 189

def self.respond_to? name, include_all = false
    # respond to all vips operations by nickname
    return true if Vips::type_find("VipsOperation", name.to_s) != 0

    super
end

.run_cmplx(image, &block) ⇒ Object

run a complex operation on a complex image, or an image with an even number of bands ... handy for things like running .polar on .index images



106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
# File 'lib/vips/image.rb', line 106

def self.run_cmplx image, &block
    original_format = image.format

    unless Image::complex? image.format
        if image.bands % 2 != 0
            raise Error, "not an even number of bands"
        end

        unless Image::float? image.format
            image = image.cast :float 
        end

        new_format = image.format == :double ? :dpcomplex : :complex
        image = image.copy format: new_format, bands: image.bands / 2
    end

    image = block.(image)

    unless Image::complex? original_format
        new_format = image.format == :dpcomplex ? :double : :float
        image = image.copy format: new_format, bands: image.bands * 2
    end

    image
end

.sines(width, height, opts = {}) ⇒ Vips::Image

Make a 2d sine wave.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :uchar (Boolean) —

    Output an unsigned char image

  • :hfreq (Float) —

    Horizontal spatial frequency

  • :vfreq (Float) —

    Vertical spatial frequency

Returns:




# File 'lib/vips/methods.rb', line 645

.smap(x, &block) ⇒ Object

handy for overloads ... want to be able to apply a function to an array or to a scalar



89
90
91
 
# File 'lib/vips/image.rb', line 89

def self.smap x, &block
    x.is_a?(Array) ? x.map {|y| smap(y, &block)} : block.(x)
end

.sum(im, opts = {}) ⇒ Vips::Image

Sum an array of images.

Parameters:

  • im (Array<Image>) —

    Array of input images

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 79

.svgload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load svg with rsvg.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :dpi (Float) —

    Render at this DPI

  • :fail (Boolean) —

    Fail on first error

  • :scale (Float) —

    Scale output by this factor

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 958

.svgload_buffer(buffer, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load svg with rsvg.

Parameters:

  • buffer (VipsBlob) —

    Buffer to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :dpi (Float) —

    Render at this DPI

  • :fail (Boolean) —

    Fail on first error

  • :scale (Float) —

    Scale output by this factor

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 982

.system(cmd_format, opts = {}) ⇒ nil, Hash<Symbol => Object>

Run an external command.

Parameters:

  • cmd_format (String) —

    Command to run

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :im (Array<Image>) —

    Array of input images

  • :out_format (String) —

    Format for output filename

  • :in_format (String) —

    Format for input filename

  • :out (Vips::Image) —

    Output Output image

  • :log (String) —

    Output Command log

Returns:

  • (nil, Hash<Symbol => Object>) —

    Hash of optional output items




# File 'lib/vips/methods.rb', line 4

.text(text, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Make a text image.

Parameters:

  • text (String) —

    Text to render

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :font (String) —

    Font to render with

  • :width (Integer) —

    Maximum image width in pixels

  • :height (Integer) —

    Maximum image height in pixels

  • :align (Vips::Align) —

    Align on the low, centre or high edge

  • :dpi (Integer) —

    DPI to render at

  • :spacing (Integer) —

    Line spacing

  • :autofit_dpi (Integer) —

    Output DPI selected by autofit

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 579

.thumbnail(filename, width, opts = {}) ⇒ Vips::Image

Generate thumbnail from file.

Parameters:

  • filename (String) —

    Filename to read from

  • width (Integer) —

    Size to this width

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :height (Integer) —

    Size to this height

  • :size (Vips::Size) —

    Only upsize, only downsize, or both

  • :auto_rotate (Boolean) —

    Use orientation tags to rotate image upright

  • :crop (Vips::Interesting) —

    Reduce to fill target rectangle, then crop

  • :linear (Boolean) —

    Reduce in linear light

  • :import_profile (String) —

    Fallback import profile

  • :export_profile (String) —

    Fallback export profile

  • :intent (Vips::Intent) —

    Rendering intent

Returns:




# File 'lib/vips/methods.rb', line 1462

.thumbnail_buffer(buffer, width, opts = {}) ⇒ Vips::Image

Generate thumbnail from buffer.

Parameters:

  • buffer (VipsBlob) —

    Buffer to load from

  • width (Integer) —

    Size to this width

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :height (Integer) —

    Size to this height

  • :size (Vips::Size) —

    Only upsize, only downsize, or both

  • :auto_rotate (Boolean) —

    Use orientation tags to rotate image upright

  • :crop (Vips::Interesting) —

    Reduce to fill target rectangle, then crop

  • :linear (Boolean) —

    Reduce in linear light

  • :import_profile (String) —

    Fallback import profile

  • :export_profile (String) —

    Fallback export profile

  • :intent (Vips::Intent) —

    Rendering intent

Returns:




# File 'lib/vips/methods.rb', line 1477

.tiffload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load tiff from file.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :page (Integer) —

    Load this page from the image

  • :n (Integer) —

    Load this many pages

  • :fail (Boolean) —

    Fail on first error

  • :autorotate (Boolean) —

    Rotate image using orientation tag

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 1094

.tiffload_buffer(buffer, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load tiff from buffer.

Parameters:

  • buffer (VipsBlob) —

    Buffer to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :page (Integer) —

    Load this page from the image

  • :n (Integer) —

    Load this many pages

  • :fail (Boolean) —

    Fail on first error

  • :autorotate (Boolean) —

    Rotate image using orientation tag

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 1107

.tonelut(opts = {}) ⇒ Vips::Image

Build a look-up table.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :in_max (Integer) —

    Size of LUT to build

  • :out_max (Integer) —

    Maximum value in output LUT

  • :Lb (Float) —

    Lowest value in output

  • :Lw (Float) —

    Highest value in output

  • :Ps (Float) —

    Position of shadow

  • :Pm (Float) —

    Position of mid-tones

  • :Ph (Float) —

    Position of highlights

  • :S (Float) —

    Adjust shadows by this much

  • :M (Float) —

    Adjust mid-tones by this much

  • :H (Float) —

    Adjust highlights by this much

Returns:




# File 'lib/vips/methods.rb', line 804

.vipsload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load vips from file.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 890

.webpload(filename, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load webp from file.

Parameters:

  • filename (String) —

    Filename to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :shrink (Integer) —

    Shrink factor on load

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 1072

.webpload_buffer(buffer, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Load webp from buffer.

Parameters:

  • buffer (VipsBlob) —

    Buffer to load from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :shrink (Integer) —

    Shrink factor on load

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 1083

.worley(width, height, opts = {}) ⇒ Vips::Image

Make a worley noise image.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :cell_size (Integer) —

    Size of Worley cells

Returns:




# File 'lib/vips/methods.rb', line 835

.xyz(width, height, opts = {}) ⇒ Vips::Image

Make an image where pixel values are coordinates.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :csize (Integer) —

    Size of third dimension

  • :dsize (Integer) —

    Size of fourth dimension

  • :esize (Integer) —

    Size of fifth dimension

Returns:




# File 'lib/vips/methods.rb', line 592

.zone(width, height, opts = {}) ⇒ Vips::Image

Make a zone plate.

Parameters:

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :uchar (Boolean) —

    Output an unsigned char image

Returns:




# File 'lib/vips/methods.rb', line 637

Instance Method Details

#! ⇒ Image

Equivalent to image ^ -1

Returns:

  • (Image) —

    image with bits flipped



843
844
845
 
# File 'lib/vips/image.rb', line 843

def !
    self ^ -1
end

#!=(other) ⇒ Image

Compare inequality to nil, an image, constant or array.

Parameters:

  • other (nil, Image, Real, Array<Real>) —

    test inequality to this

Returns:

  • (Image) —

    result of inequality



917
918
919
920
921
922
923
924
 
# File 'lib/vips/image.rb', line 917

def != other
    # for equality, we must allow tests against nil
    if other == nil
        true
    else
        call_enum "relational", other, :noteq
    end
end

#%(other) ⇒ Image

Remainder after integer division with an image, constant or array.

Parameters:

  • other (Image, Real, Array<Real>) —

    self modulo this

Returns:

  • (Image) —

    result of modulo



787
788
789
790
 
# File 'lib/vips/image.rb', line 787

def % other
    other.is_a?(Vips::Image) ? 
        remainder(other) : remainder_const(other)
end

#&(other) ⇒ Image

Integer bitwise AND with an image, constant or array.

Parameters:

  • other (Image, Real, Array<Real>) —

    bitwise AND with this

Returns:

  • (Image) —

    result of bitwise AND



828
829
830
 
# File 'lib/vips/image.rb', line 828

def & other
    call_enum "boolean", other, :and
end

#*(other) ⇒ Image

Multiply an image, constant or array.

Parameters:

  • other (Image, Real, Array<Real>) —

    Thing to multiply by self

Returns:

  • (Image) —

    result of multiplication



769
770
771
772
 
# File 'lib/vips/image.rb', line 769

def * other
    other.is_a?(Vips::Image) ? 
        multiply(other) : linear(other, 0)
end

#**(other) ⇒ Image

Raise to power of an image, constant or array.

Parameters:

  • other (Image, Real, Array<Real>) —

    self to the power of this

Returns:

  • (Image) —

    result of power



796
797
798
 
# File 'lib/vips/image.rb', line 796

def ** other
    call_enum "math2", other, :pow
end

#+(other) ⇒ Image

Add an image, constant or array.

Parameters:

  • other (Image, Real, Array<Real>) —

    Thing to add to self

Returns:

  • (Image) —

    result of addition



751
752
753
754
 
# File 'lib/vips/image.rb', line 751

def + other 
    other.is_a?(Vips::Image) ? 
        add(other) : linear(1, other)
end

#+@ ⇒ Image

Returns image.

Returns:



855
856
857
 
# File 'lib/vips/image.rb', line 855

def +@
    self
end

#-(other) ⇒ Image

Subtract an image, constant or array.

Parameters:

  • other (Image, Real, Array<Real>) —

    Thing to subtract from self

Returns:

  • (Image) —

    result of subtraction



760
761
762
763
 
# File 'lib/vips/image.rb', line 760

def - other
    other.is_a?(Vips::Image) ? 
        subtract(other) : linear(1, Image::smap(other) {|x| x * -1})
end

#-@ ⇒ Image

Equivalent to image * -1

Returns:

  • (Image) —

    negative of image



862
863
864
 
# File 'lib/vips/image.rb', line 862

def -@
    self * -1
end

#/(other) ⇒ Image

Divide an image, constant or array.

Parameters:

  • other (Image, Real, Array<Real>) —

    Thing to divide self by

Returns:

  • (Image) —

    result of division



778
779
780
781
 
# File 'lib/vips/image.rb', line 778

def / other
    other.is_a?(Vips::Image) ? 
        divide(other) : linear(Image::smap(other) {|x| 1.0 / x}, 0)
end

#<(other) ⇒ Image

Relational less than with an image, constant or array.

Parameters:

  • other (Image, Real, Array<Real>) —

    relational less than with this

Returns:

  • (Image) —

    result of less than



870
871
872
 
# File 'lib/vips/image.rb', line 870

def < other
    call_enum "relational", other, :less
end

#<<(other) ⇒ Image

Integer left shift with an image, constant or array.

Parameters:

  • other (Image, Real, Array<Real>) —

    shift left by this much

Returns:

  • (Image) —

    result of left shift



804
805
806
 
# File 'lib/vips/image.rb', line 804

def << other
    call_enum "boolean", other, :lshift
end

#<=(other) ⇒ Image

Relational less than or equal to with an image, constant or array.

Parameters:

  • other (Image, Real, Array<Real>) —

    relational less than or equal to with this

Returns:

  • (Image) —

    result of less than or equal to



879
880
881
 
# File 'lib/vips/image.rb', line 879

def <= other
    call_enum "relational", other, :lesseq
end

#==(other) ⇒ Image

Compare equality to nil, an image, constant or array.

Parameters:

  • other (nil, Image, Real, Array<Real>) —

    test equality to this

Returns:

  • (Image) —

    result of equality



904
905
906
907
908
909
910
911
 
# File 'lib/vips/image.rb', line 904

def == other
    # for equality, we must allow tests against nil
    if other == nil
        false
    else
        call_enum "relational", other, :equal
    end
end

#>(other) ⇒ Image

Relational more than with an image, constant or array.

Parameters:

  • other (Image, Real, Array<Real>) —

    relational more than with this

Returns:

  • (Image) —

    result of more than



887
888
889
 
# File 'lib/vips/image.rb', line 887

def > other
    call_enum "relational", other, :more
end

#>=(other) ⇒ Image

Relational more than or equal to with an image, constant or array.

Parameters:

  • other (Image, Real, Array<Real>) —

    relational more than or equal to with this

Returns:

  • (Image) —

    result of more than or equal to



896
897
898
 
# File 'lib/vips/image.rb', line 896

def >= other
    call_enum "relational", other, :moreeq
end

#>>(other) ⇒ Image

Integer right shift with an image, constant or array.

Parameters:

  • other (Image, Real, Array<Real>) —

    shift right by this much

Returns:

  • (Image) —

    result of right shift



812
813
814
 
# File 'lib/vips/image.rb', line 812

def >> other
    call_enum "boolean", other, :rshift
end

#[](index) ⇒ Image

Fetch bands using a number or a range

Parameters:

  • index (Numeric, Range) —

    extract these band(s)

Returns:

  • (Image) —

    extracted band(s)



930
931
932
933
934
935
936
937
938
939
 
# File 'lib/vips/image.rb', line 930

def [] index
    if index.is_a? Range
        n = index.size
        extract_band index.begin, n: n
    elsif index.is_a? Numeric
        extract_band index 
    else
        raise Vips::Error, "[] index is not range or numeric."
    end
end

#^(other) ⇒ Image

Integer bitwise EOR with an image, constant or array.

Parameters:

  • other (Image, Real, Array<Real>) —

    bitwise EOR with this

Returns:

  • (Image) —

    result of bitwise EOR



836
837
838
 
# File 'lib/vips/image.rb', line 836

def ^ other
    call_enum "boolean", other, :eor
end

#abs(opts = {}) ⇒ Vips::Image

Absolute value of an image.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 104

#acos ⇒ Image

Return the inverse cosine of an image in degrees.

Returns:

  • (Image) —

    inverse cosine of each pixel



1197
1198
1199
 
# File 'lib/vips/image.rb', line 1197

def acos
    math :acos
end

#add(right, opts = {}) ⇒ Vips::Image

Add two images.

Parameters:

  • right (Vips::Image) —

    Right-hand image argument

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 15

#add_alpha ⇒ Image

Append an alpha channel to an image.

Returns:

Raises:



717
718
719
720
721
722
723
 
# File 'lib/vips/image.rb', line 717

def add_alpha
    ptr = GenericPtr.new
    result = Vips::vips_addalpha self, ptr
    raise Vips::Error if result != 0

    Vips::Image.new ptr[:value]
end

#affine(matrix, opts = {}) ⇒ Vips::Image

Affine transform of an image.

Parameters:

  • matrix (Array<Double>) —

    Transformation matrix

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :interpolate (Vips::Interpolate) —

    Interpolate pixels with this

  • :oarea (Array<Integer>) —

    Area of output to generate

  • :odx (Float) —

    Horizontal output displacement

  • :ody (Float) —

    Vertical output displacement

  • :idx (Float) —

    Horizontal input displacement

  • :idy (Float) —

    Vertical input displacement

  • :background (Array<Double>) —

    Background value

  • :extend (Vips::Extend) —

    How to generate the extra pixels

Returns:




# File 'lib/vips/methods.rb', line 1564

#asin ⇒ Image

Return the inverse sine of an image in degrees.

Returns:

  • (Image) —

    inverse sine of each pixel



1190
1191
1192
 
# File 'lib/vips/image.rb', line 1190

def asin
    math :asin
end

#atan ⇒ Image

Return the inverse tangent of an image in degrees.

Returns:

  • (Image) —

    inverse tangent of each pixel



1204
1205
1206
 
# File 'lib/vips/image.rb', line 1204

def atan
    math :atan
end

#autorot(opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Autorotate image by exif tag.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :angle (Vips::Angle) —

    Output Angle image was rotated by

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 458

#avg(opts = {}) ⇒ Float

Find image average.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:

  • (Float) —

    Output value




# File 'lib/vips/methods.rb', line 159

#bandand ⇒ Image

AND the bands of an image together

Returns:

  • (Image) —

    all bands ANDed together



999
1000
1001
 
# File 'lib/vips/image.rb', line 999

def bandand
    bandbool :and
end

#bandbool(boolean, opts = {}) ⇒ Vips::Image

Boolean operation across image bands.

Parameters:

Returns:




# File 'lib/vips/methods.rb', line 426

#bandeor ⇒ Image

EOR the bands of an image together

Returns:

  • (Image) —

    all bands EORed together



1013
1014
1015
 
# File 'lib/vips/image.rb', line 1013

def bandeor
    bandbool :eor
end

#bandfold(opts = {}) ⇒ Vips::Image

Fold up x axis into bands.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :factor (Integer) —

    Fold by this factor

Returns:




# File 'lib/vips/methods.rb', line 470

#bandjoin(other) ⇒ Image

Join a set of images bandwise.

Parameters:

  • other (Image, Array<Image>, Real, Array<Real>) —

    bands to append

Returns:

  • (Image) —

    many band image



1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
 
# File 'lib/vips/image.rb', line 1028

def bandjoin other
    unless other.is_a? Array
        other = [other]
    end

    # if other is just Numeric, we can use bandjoin_const
    not_all_real = !other.all?{|x| x.is_a? Numeric}

    if not_all_real
        Vips::Image.bandjoin([self] + other)
    else
        bandjoin_const other
    end
end

#bandjoin_const(c, opts = {}) ⇒ Vips::Image

Append a constant band to an image.

Parameters:

  • c (Array<Double>) —

    Array of constants to add

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 408

#bandmean(opts = {}) ⇒ Vips::Image

Band-wise average.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 421

#bandor ⇒ Image

OR the bands of an image together

Returns:

  • (Image) —

    all bands ORed together



1006
1007
1008
 
# File 'lib/vips/image.rb', line 1006

def bandor
    bandbool :or
end

#bands ⇒ Integer

Get number of image bands.

Returns:

  • (Integer) —

    number of image bands



620
621
622
 
# File 'lib/vips/image.rb', line 620

def bands
    get "bands"
end

#bandsplit ⇒ Array<Image>

Split an n-band image into n separate images.

Returns:

  • (Array<Image>) —

    Array of n one-band images



1020
1021
1022
 
# File 'lib/vips/image.rb', line 1020

def bandsplit
    (0...bands).map {|i| extract_band i}
end

#bandunfold(opts = {}) ⇒ Vips::Image

Unfold image bands into x axis.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :factor (Integer) —

    Unfold by this factor

Returns:




# File 'lib/vips/methods.rb', line 476

#boolean(right, boolean, opts = {}) ⇒ Vips::Image

Boolean operation on two images.

Parameters:

Returns:




# File 'lib/vips/methods.rb', line 52

#boolean_const(boolean, c, opts = {}) ⇒ Vips::Image

Boolean operations against a constant.

Parameters:

  • boolean (Vips::OperationBoolean) —

    boolean to perform

  • c (Array<Double>) —

    Array of constants

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 133

#buildlut(opts = {}) ⇒ Vips::Image

Build a look-up table.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 793

#byteswap(opts = {}) ⇒ Vips::Image

Byteswap an image.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 537

#cache(opts = {}) ⇒ Vips::Image

Cache an image.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :max_tiles (Integer) —

    Maximum number of tiles to cache

  • :tile_height (Integer) —

    Tile height in pixels

  • :tile_width (Integer) —

    Tile width in pixels

Returns:




# File 'lib/vips/methods.rb', line 306

#cast(format, opts = {}) ⇒ Vips::Image

Cast an image.

Parameters:

  • format (Vips::BandFormat) —

    Format to cast to

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :shift (Boolean) —

    Shift integer values up and down

Returns:




# File 'lib/vips/methods.rb', line 439

#ceil ⇒ Image

Return the smallest integral value not less than the argument.

Returns:

  • (Image) —

    ceil of image



985
986
987
 
# File 'lib/vips/image.rb', line 985

def ceil
    round :ceil
end

#CMC2LCh(opts = {}) ⇒ Vips::Image

Transform lch to cmc.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1633

#coding ⇒ Symbol

Get image coding.

Returns:

  • (Symbol) —

    image coding



641
642
643
 
# File 'lib/vips/image.rb', line 641

def coding
    get "coding"
end

#colourspace(space, opts = {}) ⇒ Vips::Image

Convert to a new colorspace.

Parameters:

  • space (Vips::Interpretation) —

    Destination color space

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

Returns:




# File 'lib/vips/methods.rb', line 1599

#compass(mask, opts = {}) ⇒ Vips::Image

Convolve with rotating mask.

Parameters:

  • mask (Vips::Image) —

    Input matrix image

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :times (Integer) —

    Rotate and convolve this many times

  • :angle (Vips::Angle45) —

    Rotate mask by this much between convolutions

  • :combine (Vips::Combine) —

    Combine convolution results like this

  • :precision (Vips::Precision) —

    Convolve with this precision

  • :layers (Integer) —

    Use this many layers in approximation

  • :cluster (Integer) —

    Cluster lines closer than this in approximation

Returns:




# File 'lib/vips/methods.rb', line 1875

#complex(cmplx, opts = {}) ⇒ Vips::Image

Perform a complex operation on an image.

Parameters:

Returns:




# File 'lib/vips/methods.rb', line 147

#complex2(right, cmplx, opts = {}) ⇒ Vips::Image

Complex binary operations on two images.

Parameters:

  • right (Vips::Image) —

    Right-hand image argument

  • cmplx (Vips::OperationComplex2) —

    binary complex operation to perform

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 66

#complexform(right, opts = {}) ⇒ Vips::Image

Form a complex image from two real images.

Parameters:

  • right (Vips::Image) —

    Right-hand image argument

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 73

#complexget(get, opts = {}) ⇒ Vips::Image

Get a component from a complex image.

Parameters:

Returns:




# File 'lib/vips/methods.rb', line 153

#composite(other, mode, opts = {}) ⇒ Image

Composite a set of images with a set of blend modes.

Parameters:

  • other (Image, Array<Image>, Real, Array<Real>) —

    bands to append

Returns:

  • (Image) —

    many band image



1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
 
# File 'lib/vips/image.rb', line 1047

def composite other, mode, opts = {}
    unless other.is_a? Array
        other = [other]
    end
    unless mode.is_a? Array
        mode = [mode]
    end

    mode = mode.map do |x|
        GObject::GValue.from_nick Vips::BLEND_MODE_TYPE, x
    end

    Vips::Image.composite([self] + other, mode, opts)
end

#composite2(overlay, mode, opts = {}) ⇒ Vips::Image

Blend a pair of images with a blend mode.

Parameters:

  • overlay (Vips::Image) —

    Overlay image

  • mode (Vips::BlendMode) —

    VipsBlendMode to join with

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :compositing_space (Vips::Interpretation) —

    Composite images in this colour space

  • :premultiplied (Boolean) —

    Images have premultiplied alpha

Returns:




# File 'lib/vips/methods.rb', line 553

#conj ⇒ Image

Return the complex conjugate of an image.

The image can be complex, in which case the return image will also be complex, or must have an even number of bands, in which case pairs of bands are treated as (x, y) coordinates.

Returns:

  • (Image) —

    complex conjugate



1154
1155
1156
 
# File 'lib/vips/image.rb', line 1154

def conj
    Image::run_cmplx(self) {|x| x.complex :conj}
end

#conv(mask, opts = {}) ⇒ Vips::Image

Convolution operation.

Parameters:

  • mask (Vips::Image) —

    Input matrix image

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :precision (Vips::Precision) —

    Convolve with this precision

  • :layers (Integer) —

    Use this many layers in approximation

  • :cluster (Integer) —

    Cluster lines closer than this in approximation

Returns:




# File 'lib/vips/methods.rb', line 1846

#conva(mask, opts = {}) ⇒ Vips::Image

Approximate integer convolution.

Parameters:

  • mask (Vips::Image) —

    Input matrix image

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :layers (Integer) —

    Use this many layers in approximation

  • :cluster (Integer) —

    Cluster lines closer than this in approximation

Returns:




# File 'lib/vips/methods.rb', line 1855

#convasep(mask, opts = {}) ⇒ Vips::Image

Approximate separable integer convolution.

Parameters:

  • mask (Vips::Image) —

    Input matrix image

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :layers (Integer) —

    Use this many layers in approximation

Returns:




# File 'lib/vips/methods.rb', line 1896

#convf(mask, opts = {}) ⇒ Vips::Image

Float convolution operation.

Parameters:

  • mask (Vips::Image) —

    Input matrix image

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1863

#convi(mask, opts = {}) ⇒ Vips::Image

Int convolution operation.

Parameters:

  • mask (Vips::Image) —

    Input matrix image

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1869

#convsep(mask, opts = {}) ⇒ Vips::Image

Seperable convolution operation.

Parameters:

  • mask (Vips::Image) —

    Input matrix image

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :precision (Vips::Precision) —

    Convolve with this precision

  • :layers (Integer) —

    Use this many layers in approximation

  • :cluster (Integer) —

    Cluster lines closer than this in approximation

Returns:




# File 'lib/vips/methods.rb', line 1887

#copy(opts = {}) ⇒ Vips::Image

Copy an image.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :width (Integer) —

    Image width in pixels

  • :height (Integer) —

    Image height in pixels

  • :bands (Integer) —

    Number of bands in image

  • :format (Vips::BandFormat) —

    Pixel format in image

  • :coding (Vips::Coding) —

    Pixel coding

  • :interpretation (Vips::Interpretation) —

    Pixel interpretation

  • :xres (Float) —

    Horizontal resolution in pixels/mm

  • :yres (Float) —

    Vertical resolution in pixels/mm

  • :xoffset (Integer) —

    Horizontal offset of origin

  • :yoffset (Integer) —

    Vertical offset of origin

Returns:




# File 'lib/vips/methods.rb', line 265

#copy_memory ⇒ Image

Copy an image to a memory area.

This can be useful for reusing results, but can obviously use a lot of memory for large images. See #tilecache for a way of caching parts of an image.

Returns:

  • (Image) —

    new memory image



733
734
735
736
 
# File 'lib/vips/image.rb', line 733

def copy_memory
    new_image = Vips::vips_image_copy_memory self
    Vips::Image.new new_image
end

#cos ⇒ Image

Return the cosine of an image in degrees.

Returns:

  • (Image) —

    cosine of each pixel



1176
1177
1178
 
# File 'lib/vips/image.rb', line 1176

def cos
    math :cos
end

#countlines(direction, opts = {}) ⇒ Float

Count lines in an image.

Parameters:

  • direction (Vips::Direction) —

    Countlines left-right or up-down

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:

  • (Float) —

    Number of lines




# File 'lib/vips/methods.rb', line 1977

#cross_phase(other) ⇒ Image

Calculate the cross phase of two images.

Parameters:

  • other (Image, Real, Array<Real>) —

    cross phase with this

Returns:

  • (Image) —

    cross phase



1162
1163
1164
 
# File 'lib/vips/image.rb', line 1162

def cross_phase other
    complex2 other, :cross_phase
end

#csvsave(filename, opts = {}) ⇒ nil

Save image to csv file.

Parameters:

  • filename (String) —

    Filename to save to

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :separator (String) —

    Separator characters

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (nil) 



# File 'lib/vips/methods.rb', line 1179

#dE00(right, opts = {}) ⇒ Vips::Image

Calculate de00.

Parameters:

  • right (Vips::Image) —

    Right-hand input image

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1748

#dE76(right, opts = {}) ⇒ Vips::Image

Calculate de76.

Parameters:

  • right (Vips::Image) —

    Right-hand input image

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1742

#dECMC(right, opts = {}) ⇒ Vips::Image

Calculate decmc.

Parameters:

  • right (Vips::Image) —

    Right-hand input image

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1754

#deviate(opts = {}) ⇒ Float

Find image standard deviation.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:

  • (Float) —

    Output value




# File 'lib/vips/methods.rb', line 186

#dilate(mask) ⇒ Image

Dilate with a structuring element.

The structuring element must be an array with 0 for black, 255 for white and 128 for don't care.

Parameters:

  • mask (Image, Array<Real>, Array<Array<Real>>) —

    structuring element

Returns:

  • (Image) —

    dilated image



1270
1271
1272
 
# File 'lib/vips/image.rb', line 1270

def dilate mask
    morph mask, :dilate
end

#divide(right, opts = {}) ⇒ Vips::Image

Divide two images.

Parameters:

  • right (Vips::Image) —

    Right-hand image argument

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 33

#draw_circle(ink, cx, cy, radius, opts = {}) ⇒ Vips::Image

Draw a circle on an image.

Parameters:

  • ink (Array<Double>) —

    Color for pixels

  • cx (Integer) —

    Centre of draw_circle

  • cy (Integer) —

    Centre of draw_circle

  • radius (Integer) —

    Radius in pixels

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :fill (Boolean) —

    Draw a solid object

Returns:




# File 'lib/vips/methods.rb', line 2025

#draw_flood(ink, x, y, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Flood-fill an area.

Parameters:

  • ink (Array<Double>) —

    Color for pixels

  • x (Integer) —

    DrawFlood start point

  • y (Integer) —

    DrawFlood start point

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :test (Vips::Image) —

    Test pixels in this image

  • :equal (Boolean) —

    DrawFlood while equal to edge

  • :left (Integer) —

    Output Left edge of modified area

  • :top (Integer) —

    Output top edge of modified area

  • :width (Integer) —

    Output width of modified area

  • :height (Integer) —

    Output height of modified area

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Image to draw on, Hash of optional output items




# File 'lib/vips/methods.rb', line 2035

#draw_image(sub, x, y, opts = {}) ⇒ Vips::Image

Paint an image into another image.

Parameters:

  • sub (Vips::Image) —

    Sub-image to insert into main image

  • x (Integer) —

    Draw image here

  • y (Integer) —

    Draw image here

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :mode (Vips::CombineMode) —

    Combining mode

Returns:




# File 'lib/vips/methods.rb', line 2049

#draw_line(ink, x1, y1, x2, y2, opts = {}) ⇒ Vips::Image

Draw a line on an image.

Parameters:

  • ink (Array<Double>) —

    Color for pixels

  • x1 (Integer) —

    Start of draw_line

  • y1 (Integer) —

    Start of draw_line

  • x2 (Integer) —

    End of draw_line

  • y2 (Integer) —

    End of draw_line

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 2015

#draw_mask(ink, mask, x, y, opts = {}) ⇒ Vips::Image

Draw a mask on an image.

Parameters:

  • ink (Array<Double>) —

    Color for pixels

  • mask (Vips::Image) —

    Mask of pixels to draw

  • x (Integer) —

    Draw mask here

  • y (Integer) —

    Draw mask here

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 2006

#draw_point(ink, left, top, opts = {}) ⇒ Image

Draw a point on an image.

See #draw_rect.

Returns:

  • (Image) —

    modified image



743
744
745
 
# File 'lib/vips/image.rb', line 743

def draw_point ink, left, top, opts = {}
    draw_rect ink, left, top, 1, 1, opts
end

#draw_rect(ink, left, top, width, height, opts = {}) ⇒ Vips::Image

Paint a rectangle on an image.

Parameters:

  • ink (Array<Double>) —

    Color for pixels

  • left (Integer) —

    Rect to fill

  • top (Integer) —

    Rect to fill

  • width (Integer) —

    Rect to fill

  • height (Integer) —

    Rect to fill

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :fill (Boolean) —

    Draw a solid object

Returns:




# File 'lib/vips/methods.rb', line 1995

#draw_smudge(left, top, width, height, opts = {}) ⇒ Vips::Image

Blur a rectangle on an image.

Parameters:

  • left (Integer) —

    Rect to fill

  • top (Integer) —

    Rect to fill

  • width (Integer) —

    Rect to fill

  • height (Integer) —

    Rect to fill

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 2058

#dzsave(filename, opts = {}) ⇒ nil

Save image to deepzoom file.

Parameters:

  • filename (String) —

    Filename to save to

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :basename (String) —

    Base name to save to

  • :layout (Vips::ForeignDzLayout) —

    Directory layout

  • :page_height (Integer) —

    Set page height for multipage save

  • :suffix (String) —

    Filename suffix for tiles

  • :overlap (Integer) —

    Tile overlap in pixels

  • :tile_size (Integer) —

    Tile size in pixels

  • :centre (Boolean) —

    Center image in tile

  • :depth (Vips::ForeignDzDepth) —

    Pyramid depth

  • :angle (Vips::Angle) —

    Rotate image during save

  • :container (Vips::ForeignDzContainer) —

    Pyramid container type

  • :properties (Boolean) —

    Write a properties file to the output directory

  • :compression (Integer) —

    ZIP deflate compression level

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (nil) 



# File 'lib/vips/methods.rb', line 1261

#dzsave_buffer(opts = {}) ⇒ VipsBlob

Save image to dz buffer.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :basename (String) —

    Base name to save to

  • :layout (Vips::ForeignDzLayout) —

    Directory layout

  • :page_height (Integer) —

    Set page height for multipage save

  • :suffix (String) —

    Filename suffix for tiles

  • :overlap (Integer) —

    Tile overlap in pixels

  • :tile_size (Integer) —

    Tile size in pixels

  • :centre (Boolean) —

    Center image in tile

  • :depth (Vips::ForeignDzDepth) —

    Pyramid depth

  • :angle (Vips::Angle) —

    Rotate image during save

  • :container (Vips::ForeignDzContainer) —

    Pyramid container type

  • :properties (Boolean) —

    Write a properties file to the output directory

  • :compression (Integer) —

    ZIP deflate compression level

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (VipsBlob) —

    Buffer to save to




# File 'lib/vips/methods.rb', line 1281

#embed(x, y, width, height, opts = {}) ⇒ Vips::Image

Embed an image in a larger image.

Parameters:

  • x (Integer) —

    Left edge of input in output

  • y (Integer) —

    Top edge of input in output

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :extend (Vips::Extend) —

    How to generate the extra pixels

  • :background (Array<Double>) —

    Color for background pixels

Returns:




# File 'lib/vips/methods.rb', line 314

#erode(mask) ⇒ Image

Erode with a structuring element.

The structuring element must be an array with 0 for black, 255 for white and 128 for don't care.

Parameters:

  • mask (Image, Array<Real>, Array<Array<Real>>) —

    structuring element

Returns:

  • (Image) —

    eroded image



1258
1259
1260
 
# File 'lib/vips/image.rb', line 1258

def erode mask
    morph mask, :erode
end

#exp ⇒ Image

Return e ** pixel.

Returns:



1225
1226
1227
 
# File 'lib/vips/image.rb', line 1225

def exp
    math :exp
end

#exp10 ⇒ Image

Return 10 ** pixel.

Returns:

  • (Image) —

    10 ** pixel



1232
1233
1234
 
# File 'lib/vips/image.rb', line 1232

def exp10
    math :exp10
end

#extract_area(left, top, width, height, opts = {}) ⇒ Vips::Image

Extract an area from an image.

Parameters:

  • left (Integer) —

    Left edge of extract area

  • top (Integer) —

    Top edge of extract area

  • width (Integer) —

    Width of extract area

  • height (Integer) —

    Height of extract area

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 375

#extract_band(band, opts = {}) ⇒ Vips::Image

Extract band from an image.

Parameters:

  • band (Integer) —

    Band to extract

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :n (Integer) —

    Number of bands to extract

Returns:




# File 'lib/vips/methods.rb', line 401

#falsecolour(opts = {}) ⇒ Vips::Image

False-color an image.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 542

#fastcor(ref, opts = {}) ⇒ Vips::Image

Fast correlation.

Parameters:

  • ref (Vips::Image) —

    Input reference image

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1903

#filename ⇒ String

Get image filename, if any.

Returns:

  • (String) —

    image filename



648
649
650
 
# File 'lib/vips/image.rb', line 648

def filename
    get "filename"
end

#fill_nearest(opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Fill image zeros with nearest non-zero pixel.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :distance (Vips::Image) —

    Output Distance to nearest non-zero pixel

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Value of nearest non-zero pixel, Hash of optional output items




# File 'lib/vips/methods.rb', line 1989

#find_trim(opts = {}) ⇒ Array<] Left edge of image, ...

Search an image for non-edge areas.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :threshold (Float) —

    Object threshold

  • :background (Array<Double>) —

    Color for background pixels

Returns:

  • (Array<] Left edge of image, Top edge of extract area, Width of extract area, Height of extract area) —

    Array<] Left edge of image, Top edge of extract area, Width of extract area, Height of extract area




# File 'lib/vips/methods.rb', line 258

#fitssave(filename, opts = {}) ⇒ nil

Save image to fits file.

Parameters:

  • filename (String) —

    Filename to save to

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (nil) 



# File 'lib/vips/methods.rb', line 1453

#flatten(opts = {}) ⇒ Vips::Image

Flatten alpha out of an image.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :background (Array<Double>) —

    Background value

  • :max_alpha (Float) —

    Maximum value of alpha channel

Returns:




# File 'lib/vips/methods.rb', line 482

#flip(direction, opts = {}) ⇒ Vips::Image

Flip an image.

Parameters:

  • direction (Vips::Direction) —

    Direction to flip image

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 335

#fliphor ⇒ Image

Flip horizontally.

Returns:

  • (Image) —

    image flipped horizontally



1239
1240
1241
 
# File 'lib/vips/image.rb', line 1239

def fliphor
    flip :horizontal
end

#flipver ⇒ Image

Flip vertically.

Returns:

  • (Image) —

    image flipped vertically



1246
1247
1248
 
# File 'lib/vips/image.rb', line 1246

def flipver
    flip :vertical
end

#float2rad(opts = {}) ⇒ Vips::Image

Transform float rgb to radiance coding.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1693

#floor ⇒ Image

Return the largest integral value not greater than the argument.

Returns:

  • (Image) —

    floor of image



978
979
980
 
# File 'lib/vips/image.rb', line 978

def floor
    round :floor
end

#format ⇒ Symbol

Get image format.

Returns:

  • (Symbol) —

    image format



627
628
629
 
# File 'lib/vips/image.rb', line 627

def format
    get "format"
end

#freqmult(mask, opts = {}) ⇒ Vips::Image

Frequency-domain filtering.

Parameters:

  • mask (Vips::Image) —

    Input mask image

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1945

#fwfft(opts = {}) ⇒ Vips::Image

Forward fft.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1934

#gamma(opts = {}) ⇒ Vips::Image

Gamma an image.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :exponent (Float) —

    Gamma factor

Returns:




# File 'lib/vips/methods.rb', line 547

#gaussblur(sigma, opts = {}) ⇒ Vips::Image

Gaussian blur.

Parameters:

  • sigma (Float) —

    Sigma of Gaussian

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :min_ampl (Float) —

    Minimum amplitude of Gaussian

  • :precision (Vips::Precision) —

    Convolve with this precision

Returns:




# File 'lib/vips/methods.rb', line 1926

#get(name) ⇒ Object

Get a metadata item from an image. Ruby types are constructed automatically from the GValue, if possible.

For example, you can read the ICC profile from an image like this:

profile = image.get "icc-profile-data"

and profile will be an array containing the profile.

Parameters:

  • name (String) —

    Metadata field to get

Returns:

Raises:



508
509
510
511
512
513
514
515
516
517
518
519
520
 
# File 'lib/vips/image.rb', line 508

def get name
    # with old libvips, we must fetch properties (as opposed to
    # metadata) via VipsObject
    unless Vips::at_least_libvips?(8, 5)
        return super if parent_get_typeof(name) != 0
    end

    gvalue = GObject::GValue.alloc
    result = Vips::vips_image_get self, name, gvalue
    raise Vips::Error if result != 0 

    return gvalue.get
end

#get_fields ⇒ [String]

Get the names of all fields on an image. Use this to loop over all image metadata.

Returns:

  • ([String]) —

    array of field names



526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
 
# File 'lib/vips/image.rb', line 526

def get_fields
    # vips_image_get_fields() was added in libvips 8.5
    return [] unless Vips.respond_to? :vips_image_get_fields

    array = Vips::vips_image_get_fields self

    names = []
    p = array
    until ((q = p.read_pointer).null?)
        names << q.read_string
        GLib::g_free q
        p += FFI::Type::POINTER.size
    end
    GLib::g_free array

    return names
end

#get_typeof(name) ⇒ Integer

Fetch a GType from an image. GType will be 0 for no such field.

Parameters:

  • name (String) —

    Metadata field to fetch

Returns:

  • (Integer) —

    GType

See Also:



484
485
486
487
488
489
490
491
492
493
 
# File 'lib/vips/image.rb', line 484

def get_typeof name
    # on libvips before 8.5, property types must be searched first,
    # since vips_image_get_typeof returned built-in enums as int
    unless Vips::at_least_libvips?(8, 5)
        gtype = parent_get_typeof name
        return gtype if gtype != 0
    end

    Vips::vips_image_get_typeof self, name
end

#get_value(name) ⇒ Object

compatibility: old name for get



594
595
596
 
# File 'lib/vips/image.rb', line 594

def get_value name
    get name
end

#getpoint(x, y, opts = {}) ⇒ Array<Double>

Read a point from an image.

Parameters:

  • x (Integer) —

    Point to read

  • y (Integer) —

    Point to read

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:

  • (Array<Double>) —

    Array of output values



1089
1090
1091
1092
1093
1094
1095
1096
 
# File 'lib/vips/image.rb', line 1089

def getpoint x, y
    # vips has an operation that does this, but we can't call it via
    # gobject-introspection 3.1 since it's missing array double
    # get
    #
    # remove this def when gobject-introspection updates
    crop(x, y, 1, 1).bandsplit.map(&:avg)
end

#globalbalance(opts = {}) ⇒ Vips::Image

Global balance an image mosaic.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :gamma (Float) —

    Image gamma

  • :int_output (Boolean) —

    Integer output

Returns:




# File 'lib/vips/methods.rb', line 2137

#gravity(direction, width, height, opts = {}) ⇒ Vips::Image

Place an image within a larger image with a certain gravity.

Parameters:

  • direction (Vips::CompassDirection) —

    direction to place image within width/height

  • width (Integer) —

    Image width in pixels

  • height (Integer) —

    Image height in pixels

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :extend (Vips::Extend) —

    How to generate the extra pixels

  • :background (Array<Double>) —

    Color for background pixels

Returns:




# File 'lib/vips/methods.rb', line 325

#grid(tile_height, across, down, opts = {}) ⇒ Vips::Image

Grid an image.

Parameters:

  • tile_height (Integer) —

    chop into tiles this high

  • across (Integer) —

    number of tiles across

  • down (Integer) —

    number of tiles down

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 501

#has_alpha? ⇒ Boolean

Detect if image has an alpha channel

Returns:

  • (Boolean) —

    true if image has an alpha channel.



708
709
710
 
# File 'lib/vips/image.rb', line 708

def has_alpha?
    return Vips::vips_image_hasalpha(self) != 0
end

#height ⇒ Integer

Get image height, in pixels.

Returns:

  • (Integer) —

    image height, in pixels



613
614
615
 
# File 'lib/vips/image.rb', line 613

def height
    get "height"
end

#hist_cum(opts = {}) ⇒ Vips::Image

Form cumulative histogram.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1801

#hist_entropy(opts = {}) ⇒ Float

Estimate image entropy.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:

  • (Float) —

    Output value




# File 'lib/vips/methods.rb', line 1841

#hist_equal(opts = {}) ⇒ Vips::Image

Histogram equalisation.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :band (Integer) —

    Equalise with this band

Returns:




# File 'lib/vips/methods.rb', line 1817

#hist_find(opts = {}) ⇒ Vips::Image

Find image histogram.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :band (Integer) —

    Find histogram of band

Returns:




# File 'lib/vips/methods.rb', line 196

#hist_find_indexed(index, opts = {}) ⇒ Vips::Image

Find indexed image histogram.

Parameters:

  • index (Vips::Image) —

    Index image

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :combine (Vips::Combine) —

    Combine bins like this

Returns:




# File 'lib/vips/methods.rb', line 208

#hist_find_ndim(opts = {}) ⇒ Vips::Image

Find n-dimensional image histogram.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :bins (Integer) —

    Number of bins in each dimension

Returns:




# File 'lib/vips/methods.rb', line 202

#hist_ismonotonic(opts = {}) ⇒ Boolean

Test for monotonicity.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:

  • (Boolean) —

    true if in is monotonic




# File 'lib/vips/methods.rb', line 1836

#hist_local(width, height, opts = {}) ⇒ Vips::Image

Local histogram equalisation.

Parameters:

  • width (Integer) —

    Window width in pixels

  • height (Integer) —

    Window height in pixels

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :max_slope (Integer) —

    Maximum slope (CLAHE)

Returns:




# File 'lib/vips/methods.rb', line 1828

#hist_match(ref, opts = {}) ⇒ Vips::Image

Match two histograms.

Parameters:

  • ref (Vips::Image) —

    Reference histogram

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1806

#hist_norm(opts = {}) ⇒ Vips::Image

Normalise histogram.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1812

#hist_plot(opts = {}) ⇒ Vips::Image

Plot histogram.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1823

#hough_circle(opts = {}) ⇒ Vips::Image

Find hough circle transform.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :scale (Integer) —

    Scale down dimensions by this factor

  • :min_radius (Integer) —

    Smallest radius to search for

  • :max_radius (Integer) —

    Largest radius to search for

Returns:




# File 'lib/vips/methods.rb', line 222

#hough_line(opts = {}) ⇒ Vips::Image

Find hough line transform.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :width (Integer) —

    horizontal size of parameter space

  • :height (Integer) —

    Vertical size of parameter space

Returns:




# File 'lib/vips/methods.rb', line 215

#HSV2sRGB(opts = {}) ⇒ Vips::Image

Transform hsv to srgb.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1708

#icc_export(opts = {}) ⇒ Vips::Image

Output to device with icc profile.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :pcs (Vips::PCS) —

    Set Profile Connection Space

  • :intent (Vips::Intent) —

    Rendering intent

  • :output_profile (String) —

    Filename to load output profile from

  • :depth (Integer) —

    Output device space depth in bits

Returns:




# File 'lib/vips/methods.rb', line 1722

#icc_import(opts = {}) ⇒ Vips::Image

Import from device with icc profile.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :pcs (Vips::PCS) —

    Set Profile Connection Space

  • :intent (Vips::Intent) —

    Rendering intent

  • :embedded (Boolean) —

    Use embedded input profile, if available

  • :input_profile (String) —

    Filename to load input profile from

Returns:




# File 'lib/vips/methods.rb', line 1713

#icc_transform(output_profile, opts = {}) ⇒ Vips::Image

Transform between devices with icc profiles.

Parameters:

  • output_profile (String) —

    Filename to load output profile from

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :pcs (Vips::PCS) —

    Set Profile Connection Space

  • :intent (Vips::Intent) —

    Rendering intent

  • :embedded (Boolean) —

    Use embedded input profile, if available

  • :input_profile (String) —

    Filename to load input profile from

  • :depth (Integer) —

    Output device space depth in bits

Returns:




# File 'lib/vips/methods.rb', line 1731

#ifthenelse(th, el, opts = {}) ⇒ Image

Select pixels from th if self is non-zero and from el if self is zero. Use the :blend option to fade smoothly between th and el.

Parameters:

  • th (Image, Real, Array<Real>) —

    true values

  • el (Image, Real, Array<Real>) —

    false values

  • opts (Hash) (defaults to: {}) —

    set of options

Options Hash (opts):

  • :blend (Boolean) — default: false —

    Blend smoothly between th and el

Returns:

  • (Image) —

    merged image



1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
 
# File 'lib/vips/image.rb', line 1304

def ifthenelse(th, el, opts = {}) 
    match_image = [th, el, self].find {|x| x.is_a? Vips::Image}

    unless th.is_a? Vips::Image
        th = Operation.imageize match_image, th
    end
    unless el.is_a? Vips::Image
        el = Operation.imageize match_image, el
    end

    Vips::Operation.call "ifthenelse", [self, th, el], opts
end

#imag ⇒ Image

Return the imaginary part of a complex image.

Returns:

  • (Image) —

    imaginary part of complex image



1116
1117
1118
 
# File 'lib/vips/image.rb', line 1116

def imag
    complexget :imag
end

#insert(sub, x, y, opts = {}) ⇒ Vips::Image

Insert image @sub into @main at @x, @y.

Parameters:

  • sub (Vips::Image) —

    Sub-image to insert into main image

  • x (Integer) —

    Left edge of sub in main

  • y (Integer) —

    Top edge of sub in main

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :expand (Boolean) —

    Expand output to hold all of both inputs

  • :background (Array<Double>) —

    Color for new pixels

Returns:




# File 'lib/vips/methods.rb', line 341

#inspect ⇒ Object 



171
172
173
174
 
# File 'lib/vips/image.rb', line 171

def inspect
    "#<Image #{width}x#{height} #{format}, #{bands} bands, " +
        "#{interpretation}>"
end

#interpretation ⇒ Symbol

Get image interpretation.

Returns:

  • (Symbol) —

    image interpretation



634
635
636
 
# File 'lib/vips/image.rb', line 634

def interpretation
    get "interpretation"
end

#invert(opts = {}) ⇒ Vips::Image

Invert an image.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 85

#invertlut(opts = {}) ⇒ Vips::Image

Build an inverted look-up table.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :size (Integer) —

    LUT size to generate

Returns:




# File 'lib/vips/methods.rb', line 798

#invfft(opts = {}) ⇒ Vips::Image

Inverse fft.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :real (Boolean) —

    Output only the real part of the transform

Returns:




# File 'lib/vips/methods.rb', line 1939

#join(in2, direction, opts = {}) ⇒ Vips::Image

Join a pair of images.

Parameters:

  • in2 (Vips::Image) —

    Second input image

  • direction (Vips::Direction) —

    Join left-right or up-down

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :expand (Boolean) —

    Expand output to hold all of both inputs

  • :shim (Integer) —

    Pixels between images

  • :background (Array<Double>) —

    Colour for new pixels

  • :align (Vips::Align) —

    Align on the low, centre or high coordinate edge

Returns:




# File 'lib/vips/methods.rb', line 351

#jpegsave(filename, opts = {}) ⇒ nil

Save image to jpeg file.

Parameters:

  • filename (String) —

    Filename to save to

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :Q (Integer) —

    Q factor

  • :profile (String) —

    ICC profile to embed

  • :optimize_coding (Boolean) —

    Compute optimal Huffman coding tables

  • :interlace (Boolean) —

    Generate an interlaced (progressive) jpeg

  • :no_subsample (Boolean) —

    Disable chroma subsample

  • :trellis_quant (Boolean) —

    Apply trellis quantisation to each 8x8 block

  • :overshoot_deringing (Boolean) —

    Apply overshooting to samples with extreme values

  • :optimize_scans (Boolean) —

    Split the spectrum of DCT coefficients into separate scans

  • :quant_table (Integer) —

    Use predefined quantization table with given index

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (nil) 



# File 'lib/vips/methods.rb', line 1325

#jpegsave_buffer(opts = {}) ⇒ VipsBlob

Save image to jpeg buffer.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :Q (Integer) —

    Q factor

  • :profile (String) —

    ICC profile to embed

  • :optimize_coding (Boolean) —

    Compute optimal Huffman coding tables

  • :interlace (Boolean) —

    Generate an interlaced (progressive) jpeg

  • :no_subsample (Boolean) —

    Disable chroma subsample

  • :trellis_quant (Boolean) —

    Apply trellis quantisation to each 8x8 block

  • :overshoot_deringing (Boolean) —

    Apply overshooting to samples with extreme values

  • :optimize_scans (Boolean) —

    Split the spectrum of DCT coefficients into separate scans

  • :quant_table (Integer) —

    Use predefined quantization table with given index

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (VipsBlob) —

    Buffer to save to




# File 'lib/vips/methods.rb', line 1343

#jpegsave_mime(opts = {}) ⇒ nil

Save image to jpeg mime.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :Q (Integer) —

    Q factor

  • :profile (String) —

    ICC profile to embed

  • :optimize_coding (Boolean) —

    Compute optimal Huffman coding tables

  • :interlace (Boolean) —

    Generate an interlaced (progressive) jpeg

  • :no_subsample (Boolean) —

    Disable chroma subsample

  • :trellis_quant (Boolean) —

    Apply trellis quantisation to each 8x8 block

  • :overshoot_deringing (Boolean) —

    Apply overshooting to samples with extreme values

  • :optimize_scans (Boolean) —

    Split the spectrum of DCT coefficients into separate scans

  • :quant_table (Integer) —

    Use predefined quantization table with given index

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (nil) 



# File 'lib/vips/methods.rb', line 1360

#Lab2LabQ(opts = {}) ⇒ Vips::Image

Transform float lab to labq coding.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1663

#Lab2LabS(opts = {}) ⇒ Vips::Image

Transform float lab to signed short.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1683

#Lab2LCh(opts = {}) ⇒ Vips::Image

Transform lab to lch.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1618

#Lab2XYZ(opts = {}) ⇒ Vips::Image

Transform cielab to xyz.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :temp (Array<Double>) —

    Color temperature

Returns:




# File 'lib/vips/methods.rb', line 1606

#labelregions(opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Label regions in an image.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :segments (Integer) —

    Output Number of discrete contigious regions

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Mask of region labels, Hash of optional output items




# File 'lib/vips/methods.rb', line 1983

#LabQ2Lab(opts = {}) ⇒ Vips::Image

Unpack a labq image to float lab.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1658

#LabQ2LabS(opts = {}) ⇒ Vips::Image

Unpack a labq image to short lab.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1668

#LabQ2sRGB(opts = {}) ⇒ Vips::Image

Convert a labq image to srgb.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1698

#LabS2Lab(opts = {}) ⇒ Vips::Image

Transform signed short lab to float.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1678

#LabS2LabQ(opts = {}) ⇒ Vips::Image

Transform short lab to labq coding.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1673

#LCh2CMC(opts = {}) ⇒ Vips::Image

Transform lch to cmc.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1628

#LCh2Lab(opts = {}) ⇒ Vips::Image

Transform lch to lab.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1623

#linear(a, b, opts = {}) ⇒ Vips::Image

Calculate (a * in + b).

Parameters:

  • a (Array<Double>) —

    Multiply by this

  • b (Array<Double>) —

    Add this

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :uchar (Boolean) —

    Output should be uchar

Returns:




# File 'lib/vips/methods.rb', line 90

#linecache(opts = {}) ⇒ Vips::Image

Cache an image as a set of lines.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :tile_height (Integer) —

    Tile height in pixels

  • :access (Vips::Access) —

    Expected access pattern

  • :threaded (Boolean) —

    Allow threaded access

  • :persistent (Boolean) —

    Keep cache between evaluations

Returns:




# File 'lib/vips/methods.rb', line 291

#log ⇒ Image

Return the natural log of an image.

Returns:

  • (Image) —

    natural log of each pixel



1211
1212
1213
 
# File 'lib/vips/image.rb', line 1211

def log
    math :log
end

#log10 ⇒ Image

Return the log base 10 of an image.

Returns:

  • (Image) —

    base 10 log of each pixel



1218
1219
1220
 
# File 'lib/vips/image.rb', line 1218

def log10
    math :log10
end

#mapim(index, opts = {}) ⇒ Vips::Image

Resample with an mapim image.

Parameters:

  • index (Vips::Image) —

    Index pixels with this

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

Returns:




# File 'lib/vips/methods.rb', line 1506

#maplut(lut, opts = {}) ⇒ Vips::Image

Map an image though a lut.

Parameters:

  • lut (Vips::Image) —

    Look-up table image

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :band (Integer) —

    apply one-band lut to this band of in

Returns:




# File 'lib/vips/methods.rb', line 1777

#match(sec, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, opts = {}) ⇒ Vips::Image

First-order match of two images.

Parameters:

  • sec (Vips::Image) —

    Secondary image

  • xr1 (Integer) —

    Position of first reference tie-point

  • yr1 (Integer) —

    Position of first reference tie-point

  • xs1 (Integer) —

    Position of first secondary tie-point

  • ys1 (Integer) —

    Position of first secondary tie-point

  • xr2 (Integer) —

    Position of second reference tie-point

  • yr2 (Integer) —

    Position of second reference tie-point

  • xs2 (Integer) —

    Position of second secondary tie-point

  • ys2 (Integer) —

    Position of second secondary tie-point

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :hwindow (Integer) —

    Half window size

  • :harea (Integer) —

    Half area size

  • :search (Boolean) —

    Search to improve tie-points

  • :interpolate (Vips::Interpolate) —

    Interpolate pixels with this

Returns:




# File 'lib/vips/methods.rb', line 2119

#math(math, opts = {}) ⇒ Vips::Image

Apply a math operation to an image.

Parameters:

  • math (Vips::OperationMath) —

    math to perform

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 98

#math2(right, math2, opts = {}) ⇒ Vips::Image

Binary math operations.

Parameters:

Returns:




# File 'lib/vips/methods.rb', line 59

#math2_const(math2, c, opts = {}) ⇒ Vips::Image

Binary math operations with a constant.

Parameters:

  • math2 (Vips::OperationMath2) —

    math to perform

  • c (Array<Double>) —

    Array of constants

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 140

#matrixprint(opts = {}) ⇒ nil

Print matrix.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (nil) 



# File 'lib/vips/methods.rb', line 1198

#matrixsave(filename, opts = {}) ⇒ nil

Save image to matrix file.

Parameters:

  • filename (String) —

    Filename to save to

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (nil) 



# File 'lib/vips/methods.rb', line 1189

#max(opts = {}) ⇒ Float, Hash<Symbol => Object>

Find image maximum.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :size (Integer) —

    Number of maximum values to find

  • :x (Integer) —

    Output Horizontal position of maximum

  • :y (Integer) —

    Output Vertical position of maximum

  • :out_array (Array<Double>) —

    Output Array of output values

  • :x_array (Array<Integer>) —

    Output Array of horizontal positions

  • :y_array (Array<Integer>) —

    Output Array of vertical positions

Returns:

  • (Float, Hash<Symbol => Object>) —

    Output value, Hash of optional output items




# File 'lib/vips/methods.rb', line 175

#maxpos ⇒ Real

Return the coordinates of the image maximum.

Returns:

  • (Real, Real, Real) —

    maximum value, x coordinate of maximum, y coordinate of maximum



1066
1067
1068
1069
1070
1071
 
# File 'lib/vips/image.rb', line 1066

def maxpos
    v, opts = max x: true, y: true
    x = opts['x']
    y = opts['y']
    return v, x, y
end

#measure(h, v, opts = {}) ⇒ Vips::Image

Measure a set of patches on a color chart.

Parameters:

  • h (Integer) —

    Number of patches across chart

  • v (Integer) —

    Number of patches down chart

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :left (Integer) —

    Left edge of extract area

  • :top (Integer) —

    Top edge of extract area

  • :width (Integer) —

    Width of extract area

  • :height (Integer) —

    Height of extract area

Returns:




# File 'lib/vips/methods.rb', line 240

#median(size = 3) ⇒ Image

a median filter

Parameters:

  • size (Integer) (defaults to: 3) —

    size of filter window

Returns:

  • (Image) —

    result of median filter



1102
1103
1104
 
# File 'lib/vips/image.rb', line 1102

def median size = 3
    rank size, size, (size * size) / 2
end

#merge(sec, direction, dx, dy, opts = {}) ⇒ Vips::Image

Merge two images.

Parameters:

  • sec (Vips::Image) —

    Secondary image

  • direction (Vips::Direction) —

    Horizontal or vertcial merge

  • dx (Integer) —

    Horizontal displacement from sec to ref

  • dy (Integer) —

    Vertical displacement from sec to ref

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :mblend (Integer) —

    Maximum blend size

Returns:




# File 'lib/vips/methods.rb', line 2067

#min(opts = {}) ⇒ Float, Hash<Symbol => Object>

Find image minimum.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :size (Integer) —

    Number of minimum values to find

  • :x (Integer) —

    Output Horizontal position of minimum

  • :y (Integer) —

    Output Vertical position of minimum

  • :out_array (Array<Double>) —

    Output Array of output values

  • :x_array (Array<Integer>) —

    Output Array of horizontal positions

  • :y_array (Array<Integer>) —

    Output Array of vertical positions

Returns:

  • (Float, Hash<Symbol => Object>) —

    Output value, Hash of optional output items




# File 'lib/vips/methods.rb', line 164

#minpos ⇒ Real

Return the coordinates of the image minimum.

Returns:

  • (Real, Real, Real) —

    minimum value, x coordinate of minimum, y coordinate of minimum



1077
1078
1079
1080
1081
1082
 
# File 'lib/vips/image.rb', line 1077

def minpos
    v, opts = min x: true, y: true
    x = opts['x']
    y = opts['y']
    return v, x, y
end

#morph(mask, morph, opts = {}) ⇒ Vips::Image

Morphology operation.

Parameters:

  • mask (Vips::Image) —

    Input matrix image

  • morph (Vips::OperationMorphology) —

    Morphological operation to perform

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1962

#mosaic(sec, direction, xref, yref, xsec, ysec, opts = {}) ⇒ Vips::Image, Hash<Symbol => Object>

Mosaic two images.

Parameters:

  • sec (Vips::Image) —

    Secondary image

  • direction (Vips::Direction) —

    Horizontal or vertcial mosaic

  • xref (Integer) —

    Position of reference tie-point

  • yref (Integer) —

    Position of reference tie-point

  • xsec (Integer) —

    Position of secondary tie-point

  • ysec (Integer) —

    Position of secondary tie-point

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :hwindow (Integer) —

    Half window size

  • :harea (Integer) —

    Half area size

  • :mblend (Integer) —

    Maximum blend size

  • :bandno (Integer) —

    Band to search for features on

  • :dx0 (Integer) —

    Output Detected integer offset

  • :dy0 (Integer) —

    Output Detected integer offset

  • :scale1 (Float) —

    Output Detected scale

  • :angle1 (Float) —

    Output Detected rotation

  • :dy1 (Float) —

    Output Detected first-order displacement

  • :dx1 (Float) —

    Output Detected first-order displacement

Returns:

  • (Vips::Image, Hash<Symbol => Object>) —

    Output image, Hash of optional output items




# File 'lib/vips/methods.rb', line 2077

#mosaic1(sec, direction, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, opts = {}) ⇒ Vips::Image

First-order mosaic of two images.

Parameters:

  • sec (Vips::Image) —

    Secondary image

  • direction (Vips::Direction) —

    Horizontal or vertcial mosaic

  • xr1 (Integer) —

    Position of first reference tie-point

  • yr1 (Integer) —

    Position of first reference tie-point

  • xs1 (Integer) —

    Position of first secondary tie-point

  • ys1 (Integer) —

    Position of first secondary tie-point

  • xr2 (Integer) —

    Position of second reference tie-point

  • yr2 (Integer) —

    Position of second reference tie-point

  • xs2 (Integer) —

    Position of second secondary tie-point

  • ys2 (Integer) —

    Position of second secondary tie-point

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :hwindow (Integer) —

    Half window size

  • :harea (Integer) —

    Half area size

  • :search (Boolean) —

    Search to improve tie-points

  • :interpolate (Vips::Interpolate) —

    Interpolate pixels with this

  • :mblend (Integer) —

    Maximum blend size

  • :bandno (Integer) —

    Band to search for features on

Returns:




# File 'lib/vips/methods.rb', line 2098

#msb(opts = {}) ⇒ Vips::Image

Pick most-significant byte from an image.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :band (Integer) —

    Band to msb

Returns:




# File 'lib/vips/methods.rb', line 531

#multiply(right, opts = {}) ⇒ Vips::Image

Multiply two images.

Parameters:

  • right (Vips::Image) —

    Right-hand image argument

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 27

#new_from_image(value) ⇒ Image

A new image is created with the same width, height, format, interpretation, resolution and offset as self, but with every pixel set to the specified value.

You can pass an array to make a many-band image, or a single value to make a one-band image.

Parameters:

  • value (Real, Array<Real>) —

    value to put in each pixel

Returns:

  • (Image) —

    constant image



376
377
378
379
380
381
 
# File 'lib/vips/image.rb', line 376

def new_from_image value
    pixel = (Vips::Image.black(1, 1) + value).cast(format)
    image = pixel.embed 0, 0, width, height, extend: :copy
    image.copy interpretation: interpretation,
        xres: xres, yres: yres, xoffset: xoffset, yoffset: yoffset
end

#offset ⇒ Float

Get offset metadata.

Returns:

  • (Float) —

    image offset



692
693
694
695
696
 
# File 'lib/vips/image.rb', line 692

def offset
    return 0 if get_typeof("offset") == 0

    get "offset"
end

#parent_get_typeof ⇒ Object 



59
 
# File 'lib/vips/image.rb', line 59

alias_method :parent_get_typeof, :get_typeof

#percent(percent, opts = {}) ⇒ Integer

Find threshold for percent of pixels.

Parameters:

  • percent (Float) —

    Percent of pixels

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:

  • (Integer) —

    Threshold above which lie percent of pixels




# File 'lib/vips/methods.rb', line 1784

#phasecor(in2, opts = {}) ⇒ Vips::Image

Calculate phase correlation.

Parameters:

  • in2 (Vips::Image) —

    Second input image

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1956

#pngsave(filename, opts = {}) ⇒ nil

Save image to png file.

Parameters:

  • filename (String) —

    Filename to save to

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :compression (Integer) —

    Compression factor

  • :interlace (Boolean) —

    Interlace image

  • :page_height (Integer) —

    Set page height for multipage save

  • :profile (String) —

    ICC profile to embed

  • :filter (Vips::ForeignPngFilter) —

    libpng row filter flag(s)

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (nil) 



# File 'lib/vips/methods.rb', line 1300

#pngsave_buffer(opts = {}) ⇒ VipsBlob

Save image to png buffer.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :compression (Integer) —

    Compression factor

  • :interlace (Boolean) —

    Interlace image

  • :page_height (Integer) —

    Set page height for multipage save

  • :profile (String) —

    ICC profile to embed

  • :filter (Vips::ForeignPngFilter) —

    libpng row filter flag(s)

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (VipsBlob) —

    Buffer to save to




# File 'lib/vips/methods.rb', line 1313

#polar ⇒ Image

Return an image with rectangular pixels converted to polar.

The image can be complex, in which case the return image will also be complex, or must have an even number of bands, in which case pairs of bands are treated as (x, y) coordinates.

Returns:

  • (Image) —

    image converted to polar coordinates

See Also:



1129
1130
1131
 
# File 'lib/vips/image.rb', line 1129

def polar
    Image::run_cmplx(self) {|x| x.complex :polar}
end

#ppmsave(filename, opts = {}) ⇒ nil

Save image to ppm file.

Parameters:

  • filename (String) —

    Filename to save to

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :ascii (Boolean) —

    save as ascii

  • :squash (Boolean) —

    save as one bit

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (nil) 



# File 'lib/vips/methods.rb', line 1233

#premultiply(opts = {}) ⇒ Vips::Image

Premultiply image alpha.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :max_alpha (Float) —

    Maximum value of alpha channel

Returns:




# File 'lib/vips/methods.rb', line 489

#profile(opts = {}) ⇒ Array<] First non-zero pixel in column, First non-zero pixel in row

Find image profiles.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:

  • (Array<] First non-zero pixel in column, First non-zero pixel in row) —

    Array<] First non-zero pixel in column, First non-zero pixel in row




# File 'lib/vips/methods.rb', line 235

#project(opts = {}) ⇒ Array<] Sums of columns, Sums of rows

Find image projections.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:

  • (Array<] Sums of columns, Sums of rows) —

    Array<] Sums of columns, Sums of rows




# File 'lib/vips/methods.rb', line 230

#quadratic(coeff, opts = {}) ⇒ Vips::Image

Resample an image with a quadratic transform.

Parameters:

  • coeff (Vips::Image) —

    Coefficient matrix

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

Returns:




# File 'lib/vips/methods.rb', line 1557

#rad2float(opts = {}) ⇒ Vips::Image

Unpack radiance coding to float rgb.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1688

#radsave(filename, opts = {}) ⇒ nil

Save image to radiance file.

Parameters:

  • filename (String) —

    Filename to save to

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (nil) 



# File 'lib/vips/methods.rb', line 1244

#radsave_buffer(opts = {}) ⇒ VipsBlob

Save image to radiance buffer.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (VipsBlob) —

    Buffer to save to




# File 'lib/vips/methods.rb', line 1253

#rank(width, height, index, opts = {}) ⇒ Vips::Image

Rank filter.

Parameters:

  • width (Integer) —

    Window width in pixels

  • height (Integer) —

    Window height in pixels

  • index (Integer) —

    Select pixel at index

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1969

#rawsave(filename, opts = {}) ⇒ nil

Save image to raw file.

Parameters:

  • filename (String) —

    Filename to save to

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (nil) 



# File 'lib/vips/methods.rb', line 1206

#rawsave_fd(fd, opts = {}) ⇒ nil

Write raw image to file descriptor.

Parameters:

  • fd (Integer) —

    File descriptor to write to

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (nil) 



# File 'lib/vips/methods.rb', line 1215

#real ⇒ Image

Return the real part of a complex image.

Returns:

  • (Image) —

    real part of complex image



1109
1110
1111
 
# File 'lib/vips/image.rb', line 1109

def real
    complexget :real
end

#recomb(m, opts = {}) ⇒ Vips::Image

Linear recombination with matrix.

Parameters:

  • m (Vips::Image) —

    matrix of coefficients

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 464

#rect ⇒ Image

Return an image with polar pixels converted to rectangular.

The image can be complex, in which case the return image will also be complex, or must have an even number of bands, in which case pairs of bands are treated as (x, y) coordinates.

Returns:

  • (Image) —

    image converted to rectangular coordinates

See Also:



1142
1143
1144
 
# File 'lib/vips/image.rb', line 1142

def rect
    Image::run_cmplx(self) {|x| x.complex :rect}
end

#reduce(hshrink, vshrink, opts = {}) ⇒ Vips::Image

Reduce an image.

Parameters:

  • hshrink (Float) —

    Horizontal shrink factor

  • vshrink (Float) —

    Vertical shrink factor

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :kernel (Vips::Kernel) —

    Resampling kernel

  • :centre (Boolean) —

    Use centre sampling convention

Returns:




# File 'lib/vips/methods.rb', line 1548

#reduceh(hshrink, opts = {}) ⇒ Vips::Image

Shrink an image horizontally.

Parameters:

  • hshrink (Float) —

    Horizontal shrink factor

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :kernel (Vips::Kernel) —

    Resampling kernel

  • :centre (Boolean) —

    Use centre sampling convention

Returns:




# File 'lib/vips/methods.rb', line 1532

#reducev(vshrink, opts = {}) ⇒ Vips::Image

Shrink an image vertically.

Parameters:

  • vshrink (Float) —

    Vertical shrink factor

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :kernel (Vips::Kernel) —

    Resampling kernel

  • :centre (Boolean) —

    Use centre sampling convention

Returns:




# File 'lib/vips/methods.rb', line 1540

#relational(right, relational, opts = {}) ⇒ Vips::Image

Relational operation on two images.

Parameters:

Returns:




# File 'lib/vips/methods.rb', line 39

#relational_const(relational, c, opts = {}) ⇒ Vips::Image

Relational operations against a constant.

Parameters:

  • relational (Vips::OperationRelational) —

    relational to perform

  • c (Array<Double>) —

    Array of constants

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 120

#remainder(right, opts = {}) ⇒ Vips::Image

Remainder after integer division of two images.

Parameters:

  • right (Vips::Image) —

    Right-hand image argument

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 46

#remainder_const(c, opts = {}) ⇒ Vips::Image

Remainder after integer division of an image and a constant.

Parameters:

  • c (Array<Double>) —

    Array of constants

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 127

#remove(name) ⇒ Object

Remove a metadata item from an image.

Parameters:

  • name (String) —

    Metadata field to remove



589
590
591
 
# File 'lib/vips/image.rb', line 589

def remove name
    Vips::vips_image_remove self, name
end

#replicate(across, down, opts = {}) ⇒ Vips::Image

Replicate an image.

Parameters:

  • across (Integer) —

    Repeat this many times horizontally

  • down (Integer) —

    Repeat this many times vertically

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 432

#resize(scale, opts = {}) ⇒ Vips::Image

Resize an image.

Parameters:

  • scale (Float) —

    Scale image by this factor

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :kernel (Vips::Kernel) —

    Resampling kernel

  • :vscale (Float) —

    Vertical scale image by this factor

Returns:




# File 'lib/vips/methods.rb', line 1591

#respond_to?(name, include_all = false) ⇒ Boolean

Returns:

  • (Boolean) 


176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/vips/image.rb', line 176

def respond_to? name, include_all = false
    # To support keyword args, we need to tell Ruby that final image
    # arguments cannot be hashes of keywords. 
    #
    # https://makandracards.com/makandra/36013-heads-up-ruby-implicitly-converts-a-hash-to-keyword-arguments
    return false if name == :to_hash

    # respond to all vips operations by nickname
    return true if Vips::type_find("VipsOperation", name.to_s) != 0

    super
end

#rint ⇒ Image

Return the nearest integral value.

Returns:

  • (Image) —

    rint of image



992
993
994
 
# File 'lib/vips/image.rb', line 992

def rint
    round :rint
end

#rot(angle, opts = {}) ⇒ Vips::Image

Rotate an image.

Parameters:

  • angle (Vips::Angle) —

    Angle to rotate image

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 446

#rot180 ⇒ Image

Rotate by 180 degrees clockwise.

Returns:

  • (Image) —

    rotated image



1284
1285
1286
 
# File 'lib/vips/image.rb', line 1284

def rot180
    rot :d180
end

#rot270 ⇒ Image

Rotate by 270 degrees clockwise.

Returns:

  • (Image) —

    rotated image



1291
1292
1293
 
# File 'lib/vips/image.rb', line 1291

def rot270
    rot :d270
end

#rot45(opts = {}) ⇒ Vips::Image

Rotate an image.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

Returns:




# File 'lib/vips/methods.rb', line 452

#rot90 ⇒ Image

Rotate by 90 degrees clockwise.

Returns:

  • (Image) —

    rotated image



1277
1278
1279
 
# File 'lib/vips/image.rb', line 1277

def rot90
    rot :d90
end

#round(round, opts = {}) ⇒ Vips::Image

Perform a round function on an image.

Parameters:

  • round (Vips::OperationRound) —

    rounding operation to perform

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 114

#scale ⇒ Float

Get scale metadata.

Returns:

  • (Float) —

    image scale



683
684
685
686
687
 
# File 'lib/vips/image.rb', line 683

def scale
    return 1 if get_typeof("scale") == 0

    get "scale"
end

#scaleimage(opts = {}) ⇒ Vips::Image

Scale an image to uchar. This is the vips scale operation, but renamed to avoid a clash with the .scale property.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:



1322
1323
1324
 
# File 'lib/vips/image.rb', line 1322

def scaleimage opts = {}
    Vips::Image.scale self, opts
end

#scRGB2BW(opts = {}) ⇒ Vips::Image

Convert scrgb to bw.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :depth (Integer) —

    Output device space depth in bits

Returns:




# File 'lib/vips/methods.rb', line 1765

#scRGB2sRGB(opts = {}) ⇒ Vips::Image

Convert an scrgb image to srgb.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :depth (Integer) —

    Output device space depth in bits

Returns:




# File 'lib/vips/methods.rb', line 1771

#scRGB2XYZ(opts = {}) ⇒ Vips::Image

Transform scrgb to xyz.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1648

#sequential(opts = {}) ⇒ Vips::Image

Check sequential access.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :tile_height (Integer) —

    Tile height in pixels

Returns:




# File 'lib/vips/methods.rb', line 300

#set(name, value) ⇒ Object

Set the value of a metadata item on an image. The metadata item must already exist. Ruby types are automatically transformed into the matching GValue, if possible.

For example, you can use this to set an image's ICC profile:

x = y.set "icc-profile-data", profile

where profile is an ICC profile held as a binary string object.

Parameters:

  • name (String) —

    Metadata field to set

  • value (Object) —

    Value to set

See Also:



582
583
584
 
# File 'lib/vips/image.rb', line 582

def set name, value
    set_type get_typeof(name), name, value
end

#set_type(gtype, name, value) ⇒ Object

Create a metadata item on an image, of the specifed type. Ruby types are automatically transformed into the matching GType, if possible.

For example, you can use this to set an image's ICC profile:

x = y.set_type Vips::BLOB_TYPE, "icc-profile-data", profile

where profile is an ICC profile held as a binary string object.

Parameters:

  • gtype (Integer) —

    GType of item

  • name (String) —

    Metadata field to set

  • value (Object) —

    Value to set

See Also:



560
561
562
563
564
565
 
# File 'lib/vips/image.rb', line 560

def set_type gtype, name, value
    gvalue = GObject::GValue.alloc
    gvalue.init gtype
    gvalue.set value
    Vips::vips_image_set self, name, gvalue
end

#set_value(name, value) ⇒ Object

compatibility: old name for set



599
600
601
 
# File 'lib/vips/image.rb', line 599

def set_value name, value
    set name, value
end

#sharpen(opts = {}) ⇒ Vips::Image

Unsharp masking for print.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :sigma (Float) —

    Sigma of Gaussian

  • :x1 (Float) —

    Flat/jaggy threshold

  • :y2 (Float) —

    Maximum brightening

  • :y3 (Float) —

    Maximum darkening

  • :m1 (Float) —

    Slope for flat areas

  • :m2 (Float) —

    Slope for jaggy areas

Returns:




# File 'lib/vips/methods.rb', line 1915

#shrink(hshrink, vshrink, opts = {}) ⇒ Vips::Image

Shrink an image.

Parameters:

  • hshrink (Float) —

    Horizontal shrink factor

  • vshrink (Float) —

    Vertical shrink factor

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1513

#shrinkh(hshrink, opts = {}) ⇒ Vips::Image

Shrink an image horizontally.

Parameters:

  • hshrink (Integer) —

    Horizontal shrink factor

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1520

#shrinkv(vshrink, opts = {}) ⇒ Vips::Image

Shrink an image vertically.

Parameters:

  • vshrink (Integer) —

    Vertical shrink factor

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1526

#sign(opts = {}) ⇒ Vips::Image

Unit vector of pixel.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 109

#similarity(opts = {}) ⇒ Vips::Image

Similarity transform of an image.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :background (Array<Double>) —

    Background value

  • :interpolate (Vips::Interpolate) —

    Interpolate pixels with this

  • :scale (Float) —

    Scale by this factor

  • :angle (Float) —

    Rotate anticlockwise by this many degrees

  • :odx (Float) —

    Horizontal output displacement

  • :ody (Float) —

    Vertical output displacement

  • :idx (Float) —

    Horizontal input displacement

  • :idy (Float) —

    Vertical input displacement

Returns:




# File 'lib/vips/methods.rb', line 1578

#sin ⇒ Image

Return the sine of an image in degrees.

Returns:

  • (Image) —

    sine of each pixel



1169
1170
1171
 
# File 'lib/vips/image.rb', line 1169

def sin
    math :sin 
end

#size ⇒ Integer

Get the image size.

Returns:

  • (Integer, Integer) —

    image width and height



701
702
703
 
# File 'lib/vips/image.rb', line 701

def size
    [width, height]
end

#smartcrop(width, height, opts = {}) ⇒ Vips::Image

Extract an area from an image.

Parameters:

  • width (Integer) —

    Width of extract area

  • height (Integer) —

    Height of extract area

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

Returns:




# File 'lib/vips/methods.rb', line 393

#spcor(ref, opts = {}) ⇒ Vips::Image

Spatial correlation.

Parameters:

  • ref (Vips::Image) —

    Input reference image

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1909

#spectrum(opts = {}) ⇒ Vips::Image

Make displayable power spectrum.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1951

#sRGB2HSV(opts = {}) ⇒ Vips::Image

Transform srgb to hsv.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1703

#sRGB2scRGB(opts = {}) ⇒ Vips::Image

Convert an srgb image to scrgb.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1760

#stats(opts = {}) ⇒ Vips::Image

Find image average.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 191

#stdif(width, height, opts = {}) ⇒ Vips::Image

Statistical difference.

Parameters:

  • width (Integer) —

    Window width in pixels

  • height (Integer) —

    Window height in pixels

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :s0 (Float) —

    New deviation

  • :b (Float) —

    Weight of new deviation

  • :m0 (Float) —

    New mean

  • :a (Float) —

    Weight of new mean

Returns:




# File 'lib/vips/methods.rb', line 1790

#subsample(xfac, yfac, opts = {}) ⇒ Vips::Image

Subsample an image.

Parameters:

  • xfac (Integer) —

    Horizontal subsample factor

  • yfac (Integer) —

    Vertical subsample factor

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :point (Boolean) —

    Point sample

Returns:




# File 'lib/vips/methods.rb', line 523

#subtract(right, opts = {}) ⇒ Vips::Image

Subtract two images.

Parameters:

  • right (Vips::Image) —

    Right-hand image argument

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 21

#tan ⇒ Image

Return the tangent of an image in degrees.

Returns:

  • (Image) —

    tangent of each pixel



1183
1184
1185
 
# File 'lib/vips/image.rb', line 1183

def tan
    math :tan
end

#thumbnail_image(width, opts = {}) ⇒ Vips::Image

Generate thumbnail from image.

Parameters:

  • width (Integer) —

    Size to this width

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :height (Integer) —

    Size to this height

  • :size (Vips::Size) —

    Only upsize, only downsize, or both

  • :auto_rotate (Boolean) —

    Use orientation tags to rotate image upright

  • :crop (Vips::Interesting) —

    Reduce to fill target rectangle, then crop

  • :linear (Boolean) —

    Reduce in linear light

  • :import_profile (String) —

    Fallback import profile

  • :export_profile (String) —

    Fallback export profile

  • :intent (Vips::Intent) —

    Rendering intent

Returns:




# File 'lib/vips/methods.rb', line 1492

#tiffsave(filename, opts = {}) ⇒ nil

Save image to tiff file.

Parameters:

  • filename (String) —

    Filename to save to

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :compression (Vips::ForeignTiffCompression) —

    Compression for this file

  • :Q (Integer) —

    Q factor

  • :predictor (Vips::ForeignTiffPredictor) —

    Compression prediction

  • :page_height (Integer) —

    Set page height for multipage save

  • :profile (String) —

    ICC profile to embed

  • :tile (Boolean) —

    Write a tiled tiff

  • :tile_width (Integer) —

    Tile width in pixels

  • :tile_height (Integer) —

    Tile height in pixels

  • :pyramid (Boolean) —

    Write a pyramidal tiff

  • :miniswhite (Boolean) —

    Use 0 for white in 1-bit images

  • :squash (Boolean) —

    Squash images down to 1 bit

  • :resunit (Vips::ForeignTiffResunit) —

    Resolution unit

  • :xres (Float) —

    Horizontal resolution in pixels/mm

  • :yres (Float) —

    Vertical resolution in pixels/mm

  • :bigtiff (Boolean) —

    Write a bigtiff image

  • :properties (Boolean) —

    Write a properties document to IMAGEDESCRIPTION

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (nil) 



# File 'lib/vips/methods.rb', line 1406

#tiffsave_buffer(opts = {}) ⇒ VipsBlob

Save image to tiff buffer.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :compression (Vips::ForeignTiffCompression) —

    Compression for this file

  • :Q (Integer) —

    Q factor

  • :predictor (Vips::ForeignTiffPredictor) —

    Compression prediction

  • :page_height (Integer) —

    Set page height for multipage save

  • :profile (String) —

    ICC profile to embed

  • :tile (Boolean) —

    Write a tiled tiff

  • :tile_width (Integer) —

    Tile width in pixels

  • :tile_height (Integer) —

    Tile height in pixels

  • :pyramid (Boolean) —

    Write a pyramidal tiff

  • :miniswhite (Boolean) —

    Use 0 for white in 1-bit images

  • :squash (Boolean) —

    Squash images down to 1 bit

  • :resunit (Vips::ForeignTiffResunit) —

    Resolution unit

  • :xres (Float) —

    Horizontal resolution in pixels/mm

  • :yres (Float) —

    Vertical resolution in pixels/mm

  • :bigtiff (Boolean) —

    Write a bigtiff image

  • :properties (Boolean) —

    Write a properties document to IMAGEDESCRIPTION

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (VipsBlob) —

    Buffer to save to




# File 'lib/vips/methods.rb', line 1430

#tilecache(opts = {}) ⇒ Vips::Image

Cache an image as a set of tiles.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :tile_width (Integer) —

    Tile width in pixels

  • :tile_height (Integer) —

    Tile height in pixels

  • :max_tiles (Integer) —

    Maximum number of tiles to cache

  • :access (Vips::Access) —

    Expected access pattern

  • :threaded (Boolean) —

    Allow threaded access

  • :persistent (Boolean) —

    Keep cache between evaluations

Returns:




# File 'lib/vips/methods.rb', line 280

#to_a ⇒ Array

Convert to an Array. This will be slow for large images.

Returns:

  • (Array) —

    array of Fixnum



944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
 
# File 'lib/vips/image.rb', line 944

def to_a
    # we render the image to a big string, then unpack 
    # as a Ruby array of the correct type
    memory = write_to_memory

    # make the template for unpack
    template = {
        :char => 'c',
        :uchar => 'C',
        :short => 's_',
        :ushort => 'S_',
        :int => 'i_',
        :uint => 'I_',
        :float => 'f',
        :double => 'd',
        :complex => 'f',
        :dpcomplex => 'd'
    }[format] + '*'

    # and unpack into something like [1, 2, 3, 4 ..]
    array = memory.unpack(template)

    # gather band elements together
    pixel_array = array.each_slice(bands).to_a

    # build rows 
    row_array = pixel_array.each_slice(width).to_a

    return row_array
end

#unpremultiply(opts = {}) ⇒ Vips::Image

Unpremultiply image alpha.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :max_alpha (Float) —

    Maximum value of alpha channel

Returns:




# File 'lib/vips/methods.rb', line 495

#vipssave(filename, opts = {}) ⇒ nil

Save image to vips file.

Parameters:

  • filename (String) —

    Filename to save to

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (nil) 



# File 'lib/vips/methods.rb', line 1224

#webpsave(filename, opts = {}) ⇒ nil

Save image to webp file.

Parameters:

  • filename (String) —

    Filename to save to

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :Q (Integer) —

    Q factor

  • :lossless (Boolean) —

    enable lossless compression

  • :preset (Vips::ForeignWebpPreset) —

    Preset for lossy compression

  • :smart_subsample (Boolean) —

    Enable high quality chroma subsampling

  • :near_lossless (Boolean) —

    Enable preprocessing in lossless mode (uses Q)

  • :alpha_q (Integer) —

    Change alpha plane fidelity for lossy compression

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (nil) 



# File 'lib/vips/methods.rb', line 1377

#webpsave_buffer(opts = {}) ⇒ VipsBlob

Save image to webp buffer.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :Q (Integer) —

    Q factor

  • :lossless (Boolean) —

    enable lossless compression

  • :preset (Vips::ForeignWebpPreset) —

    Preset for lossy compression

  • :smart_subsample (Boolean) —

    Enable high quality chroma subsampling

  • :near_lossless (Boolean) —

    Enable preprocessing in lossless mode (uses Q)

  • :alpha_q (Integer) —

    Change alpha plane fidelity for lossy compression

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

Returns:

  • (VipsBlob) —

    Buffer to save to




# File 'lib/vips/methods.rb', line 1392

#width ⇒ Integer

Get image width, in pixels.

Returns:

  • (Integer) —

    image width, in pixels



606
607
608
 
# File 'lib/vips/image.rb', line 606

def width
    get "width"
end

#wrap(opts = {}) ⇒ Vips::Image

Wrap image origin.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :x (Integer) —

    Left edge of input in output

  • :y (Integer) —

    Top edge of input in output

Returns:




# File 'lib/vips/methods.rb', line 509

#write_to_buffer(format_string, opts = {}) ⇒ String

Write this image to a memory buffer. Save options may be encoded in the format_string or given as a hash. For example:

buffer = image.write_to_buffer ".jpg[Q=90]"

or equivalently:

image.write_to_buffer ".jpg", Q: 90

The full set of save options depend on the selected saver. Try something like:

$ vips jpegsave

to see all the available options for JPEG save.

Parameters:

  • format_string (String) —

    save format plus options

  • opts (Hash) (defaults to: {}) —

    set of options

Options Hash (opts):

  • :strip (Boolean) — default: false —

    Strip all metadata from image

  • :background (Array<Float>) — default: 0 —

    Background colour to flatten alpha against, if necessary

Returns:

  • (String) —

    the image saved in the specified format

Raises:



450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
 
# File 'lib/vips/image.rb', line 450

def write_to_buffer format_string, opts = {}
    filename = Vips::vips_filename_get_filename format_string
    option_string = Vips::vips_filename_get_options format_string
    saver = Vips::vips_foreign_find_save_buffer filename
    if saver == nil
        raise Vips::Error, "No known saver for '#{filename}'."
    end

    buffer = Vips::Operation.call saver, [self], opts, option_string
    raise Vips::Error if buffer == nil

    write_gc

    return buffer
end

#write_to_file(name, opts = {}) ⇒ Object

Write this image to a file. Save options may be encoded in the filename or given as a hash. For example:

image.write_to_file "fred.jpg[Q=90]"

or equivalently:

image.write_to_file "fred.jpg", Q: 90

The full set of save options depend on the selected saver. Try something like:

$ vips jpegsave

to see all the available options for JPEG save.

Parameters:

  • opts (Hash) (defaults to: {}) —

    set of options

  • name (String) —

    filename to write to

Options Hash (opts):

  • :strip (Boolean) — default: false —

    Strip all metadata from image

  • :background (Array<Float>) — default: 0 —

    Background colour to flatten alpha against, if necessary



412
413
414
415
416
417
418
419
420
421
422
423
 
# File 'lib/vips/image.rb', line 412

def write_to_file name, opts = {}
    filename = Vips::vips_filename_get_filename name
    option_string = Vips::vips_filename_get_options name
    saver = Vips::vips_foreign_find_save filename
    if saver == nil
        raise Vips::Error, "No known saver for '#{filename}'."
    end

    Vips::Operation.call saver, [self, filename], opts, option_string

    write_gc
end

#write_to_memory ⇒ String

Write this image to a large memory buffer.

Returns:

  • (String) —

    the pixels as a huge binary string



469
470
471
472
473
474
475
476
477
 
# File 'lib/vips/image.rb', line 469

def write_to_memory
    len = Vips::SizeStruct.new
    ptr = Vips::vips_image_write_to_memory self, len

    # wrap up as an autopointer
    ptr = FFI::AutoPointer.new(ptr, GLib::G_FREE)

    ptr.get_bytes 0, len[:value]
end

#xoffset ⇒ Integer

Get image xoffset.

Returns:

  • (Integer) —

    image xoffset



655
656
657
 
# File 'lib/vips/image.rb', line 655

def xoffset
    get "xoffset"
end

#xres ⇒ Float

Get image x resolution.

Returns:

  • (Float) —

    image x resolution



669
670
671
 
# File 'lib/vips/image.rb', line 669

def xres
    get "xres"
end

#XYZ2Lab(opts = {}) ⇒ Vips::Image

Transform xyz to lab.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Options Hash (opts):

  • :temp (Array<Double>) —

    Colour temperature

Returns:




# File 'lib/vips/methods.rb', line 1612

#XYZ2scRGB(opts = {}) ⇒ Vips::Image

Transform xyz to scrgb.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1653

#XYZ2Yxy(opts = {}) ⇒ Vips::Image

Transform xyz to yxy.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1638

#yoffset ⇒ Integer

Get image yoffset.

Returns:

  • (Integer) —

    image yoffset



662
663
664
 
# File 'lib/vips/image.rb', line 662

def yoffset
    get "yoffset"
end

#yres ⇒ Float

Get image y resolution.

Returns:

  • (Float) —

    image y resolution



676
677
678
 
# File 'lib/vips/image.rb', line 676

def yres
    get "yres"
end

#Yxy2XYZ(opts = {}) ⇒ Vips::Image

Transform yxy to xyz.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 1643

#zoom(xfac, yfac, opts = {}) ⇒ Vips::Image

Zoom an image.

Parameters:

  • xfac (Integer) —

    Horizontal zoom factor

  • yfac (Integer) —

    Vertical zoom factor

  • opts (Hash) (defaults to: {}) —

    Set of options

Returns:




# File 'lib/vips/methods.rb', line 516

#|(other) ⇒ Image

Integer bitwise OR with an image, constant or array.

Parameters:

  • other (Image, Real, Array<Real>) —

    bitwise OR with this

Returns:

  • (Image) —

    result of bitwise OR



820
821
822
 
# File 'lib/vips/image.rb', line 820

def | other
    call_enum "boolean", other, :or
end

#~ ⇒ Image

Equivalent to image ^ -1

Returns:

  • (Image) —

    image with bits flipped



850
851
852
 
# File 'lib/vips/image.rb', line 850

def ~
    self ^ -1
end