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


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

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)

    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

.arrayjoin(im, **opts) ⇒ Vips::Image

Join an array of images.

Parameters:

  • im (Array<Image>)

    Array of input images

  • opts (Hash)

    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)

    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)

    Set of options

Options Hash (**opts):

  • :bands (Integer)

    Number of bands in image

Returns:


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

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

Load csv from file.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :skip (Integer)

    Skip this many lines at the start of the file

  • :lines (Integer)

    Read this many lines from the file

  • :whitespace (String)

    Set of whitespace characters

  • :separator (String)

    Set of separator characters

  • :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 862

.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)

    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 630

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

Load a fits image.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    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 1176

.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)

    Set of options

Returns:


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

.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)

    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 612

.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)

    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 578

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

Load gif with giflib.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :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 1006

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

Load gif with giflib.

Parameters:

  • buffer (VipsBlob)

    Buffer to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :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 1018

.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)

    Set of options

Options Hash (**opts):

  • :uchar (Boolean)

    Output an unsigned char image

Returns:


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

.heifload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

Load a heif image.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :page (Integer)

    Load this page from the file

  • :n (Integer)

    Load this many pages

  • :thumbnail (Boolean)

    Fetch thumbnail image

  • :autorotate (Boolean)

    Rotate image using exif orientation

  • :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 1206

.heifload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

Load a heif image.

Parameters:

  • buffer (VipsBlob)

    Buffer to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :page (Integer)

    Load this page from the file

  • :n (Integer)

    Load this many pages

  • :thumbnail (Boolean)

    Fetch thumbnail image

  • :autorotate (Boolean)

    Rotate image using exif orientation

  • :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 1220

.identity(**opts) ⇒ Vips::Image

Make a 1d image where pixel values are indexes.

Parameters:

  • opts (Hash)

    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 829

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

Load jpeg from file.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :shrink (Integer)

    Shrink factor on load

  • :autorotate (Boolean)

    Rotate image using exif orientation

  • :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 1060

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

Load jpeg from buffer.

Parameters:

  • buffer (VipsBlob)

    Buffer to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :shrink (Integer)

    Shrink factor on load

  • :autorotate (Boolean)

    Rotate image using exif orientation

  • :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 1072

.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)

    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 621

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

Load file with imagemagick.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    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 1150

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

Load buffer with imagemagick.

Parameters:

  • buffer (VipsBlob)

    Buffer to load from

  • opts (Hash)

    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 1163

.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)

    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 704

.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)

    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 733

.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)

    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 718

.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)

    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 791

.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)

    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 749

.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)

    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 776

.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)

    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 762

.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)

    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 665

.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)

    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 690

.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)

    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 677

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

Load mat from file.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    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 1050

.matrix_from_array(width, height, array) ⇒ Object


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

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)

    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 876

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

Invoke a vips operation with Operation.call.


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

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::Image.new_from_array [1, 2, 3]

or

image = Vips::Image.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:


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
366
367
# File 'lib/vips/image.rb', line 332

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 binary 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)

    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:


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

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::Image.new_from_file "fred.jpg[shrink=2]"

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

image = Vips::Image.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)

    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:


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

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::p2str(Vips::vips_filename_get_filename name)
  option_string = Vips::p2str(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

.niftiload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

Load a nifti image.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    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 1196

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

Load an openexr image.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    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 1186

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

Load file with openslide.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :attach_associated (Boolean)

    Attach all asssociated images

  • :level (Integer)

    Load this level from the file

  • :autocrop (Boolean)

    Crop to image bounds

  • :associated (String)

    Load this associated image

  • :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 1136

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

Load pdf with libpoppler.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :page (Integer)

    Load this page from the file

  • :n (Integer)

    Load this many pages

  • :dpi (Float)

    Render at this DPI

  • :scale (Float)

    Scale output by this factor

  • :background (Array<Double>)

    Background value

  • :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 940

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

Load pdf with libpoppler.

Parameters:

  • buffer (VipsBlob)

    Buffer to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :page (Integer)

    Load this page from the file

  • :n (Integer)

    Load this many pages

  • :dpi (Float)

    Render at this DPI

  • :scale (Float)

    Scale output by this factor

  • :background (Array<Double>)

    Background value

  • :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 955

.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)

    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 853

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

Load png from file.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    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 1030

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

Load png from buffer.

Parameters:

  • buffer (VipsBlob)

    Buffer to load from

  • opts (Hash)

    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 1040

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

Load ppm from file.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    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

.profile_load(name, **opts) ⇒ VipsBlob

Load named icc profile.

Parameters:

  • name (String)

    Profile name

  • opts (Hash)

    Set of options

Returns:

  • (VipsBlob)

    Loaded profile


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

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

Load a radiance image from a file.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    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 930

.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)

    Set of options

Options Hash (**opts):

  • :offset (guint64)

    Offset in bytes from start of file

  • :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 886

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

Returns:

  • (Boolean)

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

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

.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)

    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 655

.sum(im, **opts) ⇒ Vips::Image

Sum an array of images.

Parameters:

  • im (Array<Image>)

    Array of input images

  • opts (Hash)

    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)

    Set of options

Options Hash (**opts):

  • :dpi (Float)

    Render at this DPI

  • :scale (Float)

    Scale output by this factor

  • :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 970

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

Load svg with rsvg.

Parameters:

  • buffer (VipsBlob)

    Buffer to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :dpi (Float)

    Render at this DPI

  • :scale (Float)

    Scale output by this factor

  • :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 994

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

Run an external command.

Parameters:

  • cmd_format (String)

    Command to run

  • opts (Hash)

    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)

    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

  • :justify (Boolean)

    Justify lines

  • :spacing (Integer)

    Line spacing

  • :fontfile (String)

    Load this font file

  • :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 587

.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)

    Set of options

Options Hash (**opts):

  • :height (Integer)

    Size to this height

  • :size (Vips::Size)

    Only upsize, only downsize, or both

  • :no_rotate (Boolean)

    Don't 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 1601

.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)

    Set of options

Options Hash (**opts):

  • :option_string (String)

    Options that are passed on to the underlying loader

  • :height (Integer)

    Size to this height

  • :size (Vips::Size)

    Only upsize, only downsize, or both

  • :no_rotate (Boolean)

    Don't 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 1616

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

Load tiff from file.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :page (Integer)

    Load this page from the image

  • :n (Integer)

    Load this many pages

  • :autorotate (Boolean)

    Rotate image using orientation tag

  • :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 1110

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

Load tiff from buffer.

Parameters:

  • buffer (VipsBlob)

    Buffer to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :page (Integer)

    Load this page from the image

  • :n (Integer)

    Load this many pages

  • :autorotate (Boolean)

    Rotate image using orientation tag

  • :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 1123

.tonelut(**opts) ⇒ Vips::Image

Build a look-up table.

Parameters:

  • opts (Hash)

    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 814

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

Load vips from file.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    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

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

Load webp from file.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :page (Integer)

    Load this page from the file

  • :n (Integer)

    Load this many pages

  • :scale (Float)

    Scale factor on load

  • :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 1084

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

Load webp from buffer.

Parameters:

  • buffer (VipsBlob)

    Buffer to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :page (Integer)

    Load this page from the file

  • :n (Integer)

    Load this many pages

  • :scale (Float)

    Scale factor on load

  • :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 1097

.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)

    Set of options

Options Hash (**opts):

  • :cell_size (Integer)

    Size of Worley cells

Returns:


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

.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)

    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 602

.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)

    Set of options

Options Hash (**opts):

  • :uchar (Boolean)

    Output an unsigned char image

Returns:


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

Instance Method Details

#!Image

Equivalent to image ^ -1

Returns:

  • (Image)

    image with bits flipped


848
849
850
# File 'lib/vips/image.rb', line 848

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


922
923
924
925
926
927
928
929
# File 'lib/vips/image.rb', line 922

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


792
793
794
795
# File 'lib/vips/image.rb', line 792

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


833
834
835
# File 'lib/vips/image.rb', line 833

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


774
775
776
777
# File 'lib/vips/image.rb', line 774

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


801
802
803
# File 'lib/vips/image.rb', line 801

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


756
757
758
759
# File 'lib/vips/image.rb', line 756

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

#[email protected]Image

Returns image

Returns:


860
861
862
# File 'lib/vips/image.rb', line 860

def [email protected]
  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


765
766
767
768
# File 'lib/vips/image.rb', line 765

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

#[email protected]Image

Equivalent to image * -1

Returns:

  • (Image)

    negative of image


867
868
869
# File 'lib/vips/image.rb', line 867

def [email protected]
  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


783
784
785
786
# File 'lib/vips/image.rb', line 783

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


875
876
877
# File 'lib/vips/image.rb', line 875

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


809
810
811
# File 'lib/vips/image.rb', line 809

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


884
885
886
# File 'lib/vips/image.rb', line 884

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


909
910
911
912
913
914
915
916
# File 'lib/vips/image.rb', line 909

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


892
893
894
# File 'lib/vips/image.rb', line 892

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


901
902
903
# File 'lib/vips/image.rb', line 901

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


817
818
819
# File 'lib/vips/image.rb', line 817

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)


935
936
937
938
939
940
941
942
943
944
# File 'lib/vips/image.rb', line 935

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


841
842
843
# File 'lib/vips/image.rb', line 841

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

#abs(**opts) ⇒ Vips::Image

Absolute value of an image.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#acosImage

Return the inverse cosine of an image in degrees.

Returns:

  • (Image)

    inverse cosine of each pixel


1192
1193
1194
# File 'lib/vips/image.rb', line 1192

def acos
  math :acos
end

#add(right, **opts) ⇒ Vips::Image

Add two images.

Parameters:

  • right (Vips::Image)

    Right-hand image argument

  • opts (Hash)

    Set of options

Returns:


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

#add_alphaImage

Append an alpha channel to an image.

Returns:

Raises:


722
723
724
725
726
727
728
# File 'lib/vips/image.rb', line 722

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)

    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 1704

#asinImage

Return the inverse sine of an image in degrees.

Returns:

  • (Image)

    inverse sine of each pixel


1185
1186
1187
# File 'lib/vips/image.rb', line 1185

def asin
  math :asin
end

#atanImage

Return the inverse tangent of an image in degrees.

Returns:

  • (Image)

    inverse tangent of each pixel


1199
1200
1201
# File 'lib/vips/image.rb', line 1199

def atan
  math :atan
end

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

Autorotate image by exif tag.

Parameters:

  • opts (Hash)

    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)

    Set of options

Returns:

  • (Float)

    Output value


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

#bandandImage

AND the bands of an image together

Returns:

  • (Image)

    all bands ANDed together


1004
1005
1006
# File 'lib/vips/image.rb', line 1004

def bandand
  bandbool :and
end

#bandbool(boolean, **opts) ⇒ Vips::Image

Boolean operation across image bands.

Parameters:

Returns:


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

#bandeorImage

EOR the bands of an image together

Returns:

  • (Image)

    all bands EORed together


1018
1019
1020
# File 'lib/vips/image.rb', line 1018

def bandeor
  bandbool :eor
end

#bandfold(**opts) ⇒ Vips::Image

Fold up x axis into bands.

Parameters:

  • opts (Hash)

    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


1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
# File 'lib/vips/image.rb', line 1033

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)

    Set of options

Returns:


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

#bandmean(**opts) ⇒ Vips::Image

Band-wise average.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#bandorImage

OR the bands of an image together

Returns:

  • (Image)

    all bands ORed together


1011
1012
1013
# File 'lib/vips/image.rb', line 1011

def bandor
  bandbool :or
end

#bandsInteger

Get number of image bands.

Returns:

  • (Integer)

    number of image bands


623
624
625
# File 'lib/vips/image.rb', line 623

def bands
  get "bands"
end

#bandsplitArray<Image>

Split an n-band image into n separate images.

Returns:

  • (Array<Image>)

    Array of n one-band images


1025
1026
1027
# File 'lib/vips/image.rb', line 1025

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

#bandunfold(**opts) ⇒ Vips::Image

Unfold image bands into x axis.

Parameters:

  • opts (Hash)

    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)

    Set of options

Returns:


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

#buildlut(**opts) ⇒ Vips::Image

Build a look-up table.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#byteswap(**opts) ⇒ Vips::Image

Byteswap an image.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#cache(**opts) ⇒ Vips::Image

Cache an image.

Parameters:

  • opts (Hash)

    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

#canny(**opts) ⇒ Vips::Image

Canny edge detector.

Parameters:

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :sigma (Float)

    Sigma of Gaussian

  • :precision (Vips::Precision)

    Convolve with this precision

Returns:


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

#cast(format, **opts) ⇒ Vips::Image

Cast an image.

Parameters:

  • format (Vips::BandFormat)

    Format to cast to

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :shift (Boolean)

    Shift integer values up and down

Returns:


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

#ceilImage

Return the smallest integral value not less than the argument.

Returns:

  • (Image)

    ceil of image


990
991
992
# File 'lib/vips/image.rb', line 990

def ceil
  round :ceil
end

#CMC2LCh(**opts) ⇒ Vips::Image

Transform lch to cmc.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#CMYK2XYZ(**opts) ⇒ Vips::Image

Transform cmyk to xyz.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#codingSymbol

Get image coding.

Returns:

  • (Symbol)

    image coding


644
645
646
# File 'lib/vips/image.rb', line 644

def coding
  get "coding"
end

#colourspace(space, **opts) ⇒ Vips::Image

Convert to a new colorspace.

Parameters:

Options Hash (**opts):

Returns:


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

#compass(mask, **opts) ⇒ Vips::Image

Convolve with rotating mask.

Parameters:

  • mask (Vips::Image)

    Input matrix image

  • opts (Hash)

    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 2043

#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:

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)

    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(overlay, mode, **opts) ⇒ Image

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

Parameters:

  • overlay (Image, Array<Image>)

    images to composite

  • mode (BlendMode, Array<BlendMode>)

    blend modes to use

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :compositing_space (Vips::Interpretation)

    Composite images in this colour space

  • :premultiplied (Boolean)

    Images have premultiplied alpha

Returns:

  • (Image)

    blended image


1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
# File 'lib/vips/image.rb', line 1056

def composite overlay, mode, **opts
  unless overlay.is_a? Array
    overlay = [overlay]
  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] + overlay, mode, opts)
end

#composite2(overlay, mode, **opts) ⇒ Vips::Image

Blend a pair of images with a blend mode.

Parameters:

Options Hash (**opts):

  • :x (Integer)

    x position of overlay

  • :y (Integer)

    y position of overlay

  • :compositing_space (Vips::Interpretation)

    Composite images in this colour space

  • :premultiplied (Boolean)

    Images have premultiplied alpha

Returns:


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

#conjImage

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


1149
1150
1151
# File 'lib/vips/image.rb', line 1149

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)

    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 2014

#conva(mask, **opts) ⇒ Vips::Image

Approximate integer convolution.

Parameters:

  • mask (Vips::Image)

    Input matrix image

  • opts (Hash)

    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 2023

#convasep(mask, **opts) ⇒ Vips::Image

Approximate separable integer convolution.

Parameters:

  • mask (Vips::Image)

    Input matrix image

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :layers (Integer)

    Use this many layers in approximation

Returns:


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

#convf(mask, **opts) ⇒ Vips::Image

Float convolution operation.

Parameters:

  • mask (Vips::Image)

    Input matrix image

  • opts (Hash)

    Set of options

Returns:


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

#convi(mask, **opts) ⇒ Vips::Image

Int convolution operation.

Parameters:

  • mask (Vips::Image)

    Input matrix image

  • opts (Hash)

    Set of options

Returns:


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

#convsep(mask, **opts) ⇒ Vips::Image

Seperable convolution operation.

Parameters:

  • mask (Vips::Image)

    Input matrix image

  • opts (Hash)

    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 2055

#copy(**opts) ⇒ Vips::Image

Copy an image.

Parameters:

  • opts (Hash)

    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_memoryImage

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


738
739
740
741
# File 'lib/vips/image.rb', line 738

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

#cosImage

Return the cosine of an image in degrees.

Returns:

  • (Image)

    cosine of each pixel


1171
1172
1173
# File 'lib/vips/image.rb', line 1171

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)

    Set of options

Returns:

  • (Float)

    Number of lines


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

#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


1157
1158
1159
# File 'lib/vips/image.rb', line 1157

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)

    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 1234

#dE00(right, **opts) ⇒ Vips::Image

Calculate de00.

Parameters:

  • right (Vips::Image)

    Right-hand input image

  • opts (Hash)

    Set of options

Returns:


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

#dE76(right, **opts) ⇒ Vips::Image

Calculate de76.

Parameters:

  • right (Vips::Image)

    Right-hand input image

  • opts (Hash)

    Set of options

Returns:


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

#dECMC(right, **opts) ⇒ Vips::Image

Calculate decmc.

Parameters:

  • right (Vips::Image)

    Right-hand input image

  • opts (Hash)

    Set of options

Returns:


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

#deviate(**opts) ⇒ Float

Find image standard deviation.

Parameters:

  • opts (Hash)

    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


1265
1266
1267
# File 'lib/vips/image.rb', line 1265

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)

    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)

    Set of options

Options Hash (**opts):

  • :fill (Boolean)

    Draw a solid object

Returns:


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

#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)

    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 2215

#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)

    Set of options

Options Hash (**opts):

  • :mode (Vips::CombineMode)

    Combining mode

Returns:


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

#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)

    Set of options

Returns:


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

#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)

    Set of options

Returns:


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

#draw_point(ink, left, top, **opts) ⇒ Image

Draw a point on an image.

See #draw_rect.

Returns:

  • (Image)

    modified image


748
749
750
# File 'lib/vips/image.rb', line 748

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)

    Set of options

Options Hash (**opts):

  • :fill (Boolean)

    Draw a solid object

Returns:


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

#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)

    Set of options

Returns:


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

#dzsave(filename, **opts) ⇒ nil

Save image to deepzoom file.

Parameters:

  • filename (String)

    Filename to save to

  • opts (Hash)

    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

  • :region_shrink (Vips::RegionShrink)

    Method to shrink regions

  • :skip_blanks (Integer)

    Skip tiles which are nearly equal to the background

  • :strip (Boolean)

    Strip all metadata from image

  • :background (Array<Double>)

    Background value

Returns:

  • (nil)

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

#dzsave_buffer(**opts) ⇒ VipsBlob

Save image to dz buffer.

Parameters:

  • opts (Hash)

    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

  • :region_shrink (Vips::RegionShrink)

    Method to shrink regions

  • :skip_blanks (Integer)

    Skip tiles which are nearly equal to the background

  • :strip (Boolean)

    Strip all metadata from image

  • :background (Array<Double>)

    Background value

Returns:

  • (VipsBlob)

    Buffer to save to


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

#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)

    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


1253
1254
1255
# File 'lib/vips/image.rb', line 1253

def erode mask
  morph mask, :erode
end

#expImage

Return e ** pixel.

Returns:


1220
1221
1222
# File 'lib/vips/image.rb', line 1220

def exp
  math :exp
end

#exp10Image

Return 10 ** pixel.

Returns:

  • (Image)

    10 ** pixel


1227
1228
1229
# File 'lib/vips/image.rb', line 1227

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)

    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)

    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)

    Set of options

Returns:


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

#fastcor(ref, **opts) ⇒ Vips::Image

Fast correlation.

Parameters:

  • ref (Vips::Image)

    Input reference image

  • opts (Hash)

    Set of options

Returns:


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

#filenameString

Get image filename, if any.

Returns:

  • (String)

    image filename


651
652
653
# File 'lib/vips/image.rb', line 651

def filename
  get "filename"
end

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

Fill image zeros with nearest non-zero pixel.

Parameters:

  • opts (Hash)

    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 2169

#find_trim(**opts) ⇒ Array<Integer, Integer, Integer, Integer>

Search an image for non-edge areas.

Parameters:

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :threshold (Float)

    Object threshold

  • :background (Array<Double>)

    Color for background pixels

Returns:

  • (Array<Integer, Integer, Integer, Integer>)

    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)

    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 1551

#flatten(**opts) ⇒ Vips::Image

Flatten alpha out of an image.

Parameters:

  • opts (Hash)

    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)

    Set of options

Returns:


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

#fliphorImage

Flip horizontally.

Returns:

  • (Image)

    image flipped horizontally


1234
1235
1236
# File 'lib/vips/image.rb', line 1234

def fliphor
  flip :horizontal
end

#flipverImage

Flip vertically.

Returns:

  • (Image)

    image flipped vertically


1241
1242
1243
# File 'lib/vips/image.rb', line 1241

def flipver
  flip :vertical
end

#float2rad(**opts) ⇒ Vips::Image

Transform float rgb to radiance coding.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#floorImage

Return the largest integral value not greater than the argument.

Returns:

  • (Image)

    floor of image


983
984
985
# File 'lib/vips/image.rb', line 983

def floor
  round :floor
end

#formatSymbol

Get image format.

Returns:

  • (Symbol)

    image format


630
631
632
# File 'lib/vips/image.rb', line 630

def format
  get "format"
end

#freqmult(mask, **opts) ⇒ Vips::Image

Frequency-domain filtering.

Parameters:

  • mask (Vips::Image)

    Input mask image

  • opts (Hash)

    Set of options

Returns:


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

#fwfft(**opts) ⇒ Vips::Image

Forward fft.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#gamma(**opts) ⇒ Vips::Image

Gamma an image.

Parameters:

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :exponent (Float)

    Gamma factor

Returns:


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

#gaussblur(sigma, **opts) ⇒ Vips::Image

Gaussian blur.

Parameters:

  • sigma (Float)

    Sigma of Gaussian

  • opts (Hash)

    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 2094

#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:


512
513
514
515
516
517
518
519
520
521
522
523
524
# File 'lib/vips/image.rb', line 512

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

  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


530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
# File 'lib/vips/image.rb', line 530

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

  names
end

#get_typeof(name) ⇒ Integer

Get the GType of a metadata field. The result is 0 if no such field exists.

Parameters:

  • name (String)

    Metadata field to fetch

Returns:

  • (Integer)

    GType

See Also:


488
489
490
491
492
493
494
495
496
497
# File 'lib/vips/image.rb', line 488

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


597
598
599
# File 'lib/vips/image.rb', line 597

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)

    Set of options

Returns:

  • (Array<Double>)

    Array of output values


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

#globalbalance(**opts) ⇒ Vips::Image

Global balance an image mosaic.

Parameters:

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :gamma (Float)

    Image gamma

  • :int_output (Boolean)

    Integer output

Returns:


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

#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)

    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)

    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.


712
713
714
# File 'lib/vips/image.rb', line 712

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

#heifsave(filename, **opts) ⇒ nil

Save image in heif format.

Parameters:

  • filename (String)

    Filename to load from

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :page_height (Integer)

    Set page height for multipage save

  • :Q (Integer)

    Q factor

  • :lossless (Boolean)

    Enable lossless compression

  • :strip (Boolean)

    Strip all metadata from image

  • :background (Array<Double>)

    Background value

Returns:

  • (nil)

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

#heifsave_buffer(**opts) ⇒ VipsBlob

Save image in heif format.

Parameters:

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :page_height (Integer)

    Set page height for multipage save

  • :Q (Integer)

    Q factor

  • :lossless (Boolean)

    Enable lossless 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 1591

#heightInteger

Get image height, in pixels.

Returns:

  • (Integer)

    image height, in pixels


616
617
618
# File 'lib/vips/image.rb', line 616

def height
  get "height"
end

#hist_cum(**opts) ⇒ Vips::Image

Form cumulative histogram.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#hist_entropy(**opts) ⇒ Float

Estimate image entropy.

Parameters:

  • opts (Hash)

    Set of options

Returns:

  • (Float)

    Output value


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

#hist_equal(**opts) ⇒ Vips::Image

Histogram equalisation.

Parameters:

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :band (Integer)

    Equalise with this band

Returns:


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

#hist_find(**opts) ⇒ Vips::Image

Find image histogram.

Parameters:

  • opts (Hash)

    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)

    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)

    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)

    Set of options

Returns:

  • (Boolean)

    true if in is monotonic


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

#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)

    Set of options

Options Hash (**opts):

  • :max_slope (Integer)

    Maximum slope (CLAHE)

Returns:


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

#hist_match(ref, **opts) ⇒ Vips::Image

Match two histograms.

Parameters:

  • ref (Vips::Image)

    Reference histogram

  • opts (Hash)

    Set of options

Returns:


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

#hist_norm(**opts) ⇒ Vips::Image

Normalise histogram.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#hist_plot(**opts) ⇒ Vips::Image

Plot histogram.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#hough_circle(**opts) ⇒ Vips::Image

Find hough circle transform.

Parameters:

  • opts (Hash)

    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)

    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)

    Set of options

Returns:


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

#icc_export(**opts) ⇒ Vips::Image

Output to device with icc profile.

Parameters:

  • opts (Hash)

    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 1874

#icc_import(**opts) ⇒ Vips::Image

Import from device with icc profile.

Parameters:

  • opts (Hash)

    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 1865

#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)

    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 1883

#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)

    set of options

Options Hash (**opts):

  • :blend (Boolean) — default: false

    Blend smoothly between th and el

Returns:

  • (Image)

    merged image


1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
# File 'lib/vips/image.rb', line 1299

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

#imagImage

Return the imaginary part of a complex image.

Returns:

  • (Image)

    imaginary part of complex image


1111
1112
1113
# File 'lib/vips/image.rb', line 1111

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)

    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

#inspectObject


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

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

#interpretationSymbol

Get image interpretation.

Returns:

  • (Symbol)

    image interpretation


637
638
639
# File 'lib/vips/image.rb', line 637

def interpretation
  get "interpretation"
end

#invert(**opts) ⇒ Vips::Image

Invert an image.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#invertlut(**opts) ⇒ Vips::Image

Build an inverted look-up table.

Parameters:

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :size (Integer)

    LUT size to generate

Returns:


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

#invfft(**opts) ⇒ Vips::Image

Inverse fft.

Parameters:

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :real (Boolean)

    Output only the real part of the transform

Returns:


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

#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)

    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)

    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 1392

#jpegsave_buffer(**opts) ⇒ VipsBlob

Save image to jpeg buffer.

Parameters:

  • opts (Hash)

    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 1410

#jpegsave_mime(**opts) ⇒ nil

Save image to jpeg mime.

Parameters:

  • opts (Hash)

    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 1427

#Lab2LabQ(**opts) ⇒ Vips::Image

Transform float lab to labq coding.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#Lab2LabS(**opts) ⇒ Vips::Image

Transform float lab to signed short.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#Lab2LCh(**opts) ⇒ Vips::Image

Transform lab to lch.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#Lab2XYZ(**opts) ⇒ Vips::Image

Transform cielab to xyz.

Parameters:

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :temp (Array<Double>)

    Color temperature

Returns:


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

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

Label regions in an image.

Parameters:

  • opts (Hash)

    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 2163

#LabQ2Lab(**opts) ⇒ Vips::Image

Unpack a labq image to float lab.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#LabQ2LabS(**opts) ⇒ Vips::Image

Unpack a labq image to short lab.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#LabQ2sRGB(**opts) ⇒ Vips::Image

Convert a labq image to srgb.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#LabS2Lab(**opts) ⇒ Vips::Image

Transform signed short lab to float.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#LabS2LabQ(**opts) ⇒ Vips::Image

Transform short lab to labq coding.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#LCh2CMC(**opts) ⇒ Vips::Image

Transform lch to cmc.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#LCh2Lab(**opts) ⇒ Vips::Image

Transform lch to lab.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#linear(a, b, **opts) ⇒ Vips::Image

Calculate (a * in + b).

Parameters:

  • a (Array<Double>)

    Multiply by this

  • b (Array<Double>)

    Add this

  • opts (Hash)

    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)

    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

#logImage

Return the natural log of an image.

Returns:

  • (Image)

    natural log of each pixel


1206
1207
1208
# File 'lib/vips/image.rb', line 1206

def log
  math :log
end

#log10Image

Return the log base 10 of an image.

Returns:

  • (Image)

    base 10 log of each pixel


1213
1214
1215
# File 'lib/vips/image.rb', line 1213

def log10
  math :log10
end

#magicksave(filename, **opts) ⇒ nil

Save file with imagemagick.

Parameters:

  • filename (String)

    Filename to save to

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :format (String)

    Format to save in

  • :quality (Integer)

    Quality to use

  • :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 1530

#magicksave_buffer(**opts) ⇒ VipsBlob

Save image to magick buffer.

Parameters:

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :format (String)

    Format to save in

  • :quality (Integer)

    Quality to use

  • :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 1541

#mapim(index, **opts) ⇒ Vips::Image

Resample with a map image.

Parameters:

  • index (Vips::Image)

    Index pixels with this

  • opts (Hash)

    Set of options

Options Hash (**opts):

Returns:


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

#maplut(lut, **opts) ⇒ Vips::Image

Map an image though a lut.

Parameters:

  • lut (Vips::Image)

    Look-up table image

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :band (Integer)

    apply one-band lut to this band of in

Returns:


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

#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)

    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 2299

#math(math, **opts) ⇒ Vips::Image

Apply a math operation to an image.

Parameters:

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)

    Set of options

Returns:


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

#matrixprint(**opts) ⇒ nil

Print matrix.

Parameters:

  • opts (Hash)

    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 1253

#matrixsave(filename, **opts) ⇒ nil

Save image to matrix file.

Parameters:

  • filename (String)

    Filename to save to

  • opts (Hash)

    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

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

Find image maximum.

Parameters:

  • opts (Hash)

    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

#maxposReal

Return the coordinates of the image maximum.

Returns:

  • (Real, Real, Real)

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


1075
1076
1077
1078
1079
1080
# File 'lib/vips/image.rb', line 1075

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)

    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


1097
1098
1099
# File 'lib/vips/image.rb', line 1097

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)

    Set of options

Options Hash (**opts):

  • :mblend (Integer)

    Maximum blend size

Returns:


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

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

Find image minimum.

Parameters:

  • opts (Hash)

    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

#minposReal

Return the coordinates of the image minimum.

Returns:

  • (Real, Real, Real)

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


1086
1087
1088
1089
1090
1091
# File 'lib/vips/image.rb', line 1086

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)

    Set of options

Returns:


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

#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)

    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 2257

#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)

    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 2278

#msb(**opts) ⇒ Vips::Image

Pick most-significant byte from an image.

Parameters:

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :band (Integer)

    Band to msb

Returns:


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

#multiply(right, **opts) ⇒ Vips::Image

Multiply two images.

Parameters:

  • right (Vips::Image)

    Right-hand image argument

  • opts (Hash)

    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


378
379
380
381
382
383
# File 'lib/vips/image.rb', line 378

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

#niftisave(filename, **opts) ⇒ nil

Save image to nifti file.

Parameters:

  • filename (String)

    Filename to save to

  • opts (Hash)

    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 1560

#offsetFloat

Get offset metadata.

Returns:

  • (Float)

    image offset


695
696
697
698
699
# File 'lib/vips/image.rb', line 695

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

  get "offset"
end

#parent_get_typeofObject


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

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)

    Set of options

Returns:

  • (Integer)

    Threshold above which lie percent of pixels


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

#phasecor(in2, **opts) ⇒ Vips::Image

Calculate phase correlation.

Parameters:

  • in2 (Vips::Image)

    Second input image

  • opts (Hash)

    Set of options

Returns:


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

#pngsave(filename, **opts) ⇒ nil

Save image to png file.

Parameters:

  • filename (String)

    Filename to save to

  • opts (Hash)

    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)

  • :palette (Boolean)

    Quantise to 8bpp palette

  • :colours (Integer)

    Max number of palette colours

  • :Q (Integer)

    Quantisation quality

  • :dither (Float)

    Amount of dithering

  • :strip (Boolean)

    Strip all metadata from image

  • :background (Array<Double>)

    Background value

Returns:

  • (nil)

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

#pngsave_buffer(**opts) ⇒ VipsBlob

Save image to png buffer.

Parameters:

  • opts (Hash)

    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)

  • :palette (Boolean)

    Quantise to 8bpp palette

  • :colours (Integer)

    Max number of palette colours

  • :Q (Integer)

    Quantisation quality

  • :dither (Float)

    Amount of dithering

  • :strip (Boolean)

    Strip all metadata from image

  • :background (Array<Double>)

    Background value

Returns:

  • (VipsBlob)

    Buffer to save to


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

#polarImage

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:


1124
1125
1126
# File 'lib/vips/image.rb', line 1124

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)

    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 1288

#premultiply(**opts) ⇒ Vips::Image

Premultiply image alpha.

Parameters:

  • opts (Hash)

    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<Vips::Image, Vips::Image>

Find image profiles.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#project(**opts) ⇒ Array<Vips::Image, Vips::Image>

Find image projections.

Parameters:

  • opts (Hash)

    Set of options

Returns:


# 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)

    Set of options

Options Hash (**opts):

Returns:


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

#rad2float(**opts) ⇒ Vips::Image

Unpack radiance coding to float rgb.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#radsave(filename, **opts) ⇒ nil

Save image to radiance file.

Parameters:

  • filename (String)

    Filename to save to

  • opts (Hash)

    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 1299

#radsave_buffer(**opts) ⇒ VipsBlob

Save image to radiance buffer.

Parameters:

  • opts (Hash)

    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 1308

#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)

    Set of options

Returns:


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

#rawsave(filename, **opts) ⇒ nil

Save image to raw file.

Parameters:

  • filename (String)

    Filename to save to

  • opts (Hash)

    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 1261

#rawsave_fd(fd, **opts) ⇒ nil

Write raw image to file descriptor.

Parameters:

  • fd (Integer)

    File descriptor to write to

  • opts (Hash)

    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 1270

#realImage

Return the real part of a complex image.

Returns:

  • (Image)

    real part of complex image


1104
1105
1106
# File 'lib/vips/image.rb', line 1104

def real
  complexget :real
end

#recomb(m, **opts) ⇒ Vips::Image

Linear recombination with matrix.

Parameters:

  • m (Vips::Image)

    matrix of coefficients

  • opts (Hash)

    Set of options

Returns:


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

#rectImage

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:


1137
1138
1139
# File 'lib/vips/image.rb', line 1137

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)

    Set of options

Options Hash (**opts):

  • :kernel (Vips::Kernel)

    Resampling kernel

  • :centre (Boolean)

    Use centre sampling convention

Returns:


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

#reduceh(hshrink, **opts) ⇒ Vips::Image

Shrink an image horizontally.

Parameters:

  • hshrink (Float)

    Horizontal shrink factor

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :kernel (Vips::Kernel)

    Resampling kernel

  • :centre (Boolean)

    Use centre sampling convention

Returns:


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

#reducev(vshrink, **opts) ⇒ Vips::Image

Shrink an image vertically.

Parameters:

  • vshrink (Float)

    Vertical shrink factor

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :kernel (Vips::Kernel)

    Resampling kernel

  • :centre (Boolean)

    Use centre sampling convention

Returns:


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

#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)

    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)

    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)

    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


592
593
594
# File 'lib/vips/image.rb', line 592

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)

    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)

    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 1743

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

Returns:

  • (Boolean)

176
177
178
179
180
181
182
183
184
185
186
187
188
# 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

#rintImage

Return the nearest integral value.

Returns:

  • (Image)

    rint of image


997
998
999
# File 'lib/vips/image.rb', line 997

def rint
  round :rint
end

#rot(angle, **opts) ⇒ Vips::Image

Rotate an image.

Parameters:

  • angle (Vips::Angle)

    Angle to rotate image

  • opts (Hash)

    Set of options

Returns:


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

#rot180Image

Rotate by 180 degrees clockwise.

Returns:

  • (Image)

    rotated image


1279
1280
1281
# File 'lib/vips/image.rb', line 1279

def rot180
  rot :d180
end

#rot270Image

Rotate by 270 degrees clockwise.

Returns:

  • (Image)

    rotated image


1286
1287
1288
# File 'lib/vips/image.rb', line 1286

def rot270
  rot :d270
end

#rot45(**opts) ⇒ Vips::Image

Rotate an image.

Parameters:

  • opts (Hash)

    Set of options

Options Hash (**opts):

Returns:


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

#rot90Image

Rotate by 90 degrees clockwise.

Returns:

  • (Image)

    rotated image


1272
1273
1274
# File 'lib/vips/image.rb', line 1272

def rot90
  rot :d90
end

#rotate(angle, **opts) ⇒ Vips::Image

Rotate an image by a number of degrees.

Parameters:

  • angle (Float)

    Rotate anticlockwise by this many degrees

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :interpolate (Vips::Interpolate)

    Interpolate pixels with this

  • :background (Array<Double>)

    Background value

  • :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 1731

#round(round, **opts) ⇒ Vips::Image

Perform a round function on an image.

Parameters:

Returns:


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

#scaleFloat

Get scale metadata.

Returns:

  • (Float)

    image scale


686
687
688
689
690
# File 'lib/vips/image.rb', line 686

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)

    Set of options

Returns:


1317
1318
1319
# File 'lib/vips/image.rb', line 1317

def scaleimage **opts
  Vips::Image.scale self, opts
end

#scRGB2BW(**opts) ⇒ Vips::Image

Convert scrgb to bw.

Parameters:

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :depth (Integer)

    Output device space depth in bits

Returns:


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

#scRGB2sRGB(**opts) ⇒ Vips::Image

Convert an scrgb image to srgb.

Parameters:

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :depth (Integer)

    Output device space depth in bits

Returns:


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

#scRGB2XYZ(**opts) ⇒ Vips::Image

Transform scrgb to xyz.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#sequential(**opts) ⇒ Vips::Image

Check sequential access.

Parameters:

  • opts (Hash)

    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:


585
586
587
# File 'lib/vips/image.rb', line 585

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:


563
564
565
566
567
568
# File 'lib/vips/image.rb', line 563

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


602
603
604
# File 'lib/vips/image.rb', line 602

def set_value name, value
  set name, value
end

#sharpen(**opts) ⇒ Vips::Image

Unsharp masking for print.

Parameters:

  • opts (Hash)

    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 2083

#shrink(hshrink, vshrink, **opts) ⇒ Vips::Image

Shrink an image.

Parameters:

  • hshrink (Float)

    Horizontal shrink factor

  • vshrink (Float)

    Vertical shrink factor

  • opts (Hash)

    Set of options

Returns:


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

#shrinkh(hshrink, **opts) ⇒ Vips::Image

Shrink an image horizontally.

Parameters:

  • hshrink (Integer)

    Horizontal shrink factor

  • opts (Hash)

    Set of options

Returns:


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

#shrinkv(vshrink, **opts) ⇒ Vips::Image

Shrink an image vertically.

Parameters:

  • vshrink (Integer)

    Vertical shrink factor

  • opts (Hash)

    Set of options

Returns:


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

#sign(**opts) ⇒ Vips::Image

Unit vector of pixel.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#similarity(**opts) ⇒ Vips::Image

Similarity transform of an image.

Parameters:

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :scale (Float)

    Scale by this factor

  • :angle (Float)

    Rotate anticlockwise by this many degrees

  • :interpolate (Vips::Interpolate)

    Interpolate pixels with this

  • :background (Array<Double>)

    Background value

  • :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 1718

#sinImage

Return the sine of an image in degrees.

Returns:

  • (Image)

    sine of each pixel


1164
1165
1166
# File 'lib/vips/image.rb', line 1164

def sin
  math :sin
end

#sizeInteger

Get the image size.

Returns:

  • (Integer, Integer)

    image width and height


704
705
706
# File 'lib/vips/image.rb', line 704

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)

    Set of options

Options Hash (**opts):

Returns:


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

#sobel(**opts) ⇒ Vips::Image

Sobel edge detector.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#spcor(ref, **opts) ⇒ Vips::Image

Spatial correlation.

Parameters:

  • ref (Vips::Image)

    Input reference image

  • opts (Hash)

    Set of options

Returns:


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

#spectrum(**opts) ⇒ Vips::Image

Make displayable power spectrum.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#sRGB2HSV(**opts) ⇒ Vips::Image

Transform srgb to hsv.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#sRGB2scRGB(**opts) ⇒ Vips::Image

Convert an srgb image to scrgb.

Parameters:

  • opts (Hash)

    Set of options

Returns:


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

#stats(**opts) ⇒ Vips::Image

Find many image stats.

Parameters:

  • opts (Hash)

    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)

    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 1958

#subsample(xfac, yfac, **opts) ⇒ Vips::Image

Subsample an image.

Parameters:

  • xfac (Integer)

    Horizontal subsample factor

  • yfac (Integer)

    Vertical subsample factor

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :point (Boolean)

    Point sample

Returns:


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

#subtract(right, **opts) ⇒ Vips::Image

Subtract two images.

Parameters:

  • right (Vips::Image)

    Right-hand image argument

  • opts (Hash)

    Set of options

Returns:


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

#tanImage

Return the tangent of an image in degrees.

Returns:

  • (Image)

    tangent of each pixel


1178
1179
1180
# File 'lib/vips/image.rb', line 1178

def tan
  math :tan
end

#thumbnail_image(width, **opts) ⇒ Vips::Image

Generate thumbnail from image.

Parameters:

  • width (Integer)

    Size to this width

  • opts (Hash)

    Set of options

Options Hash (**opts):

  • :height (Integer)

    Size to this height

  • :size (Vips::Size)

    Only upsize, only downsize, or both

  • :no_rotate (Boolean)

    Don't 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 1632

#tiffsave(filename, **opts) ⇒ nil

Save image to tiff file.

Parameters:

  • filename (String)

    Filename to save to

  • opts (Hash)

    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

  • :region_shrink (Vips::RegionShrink)

    Method to shrink regions

  • :strip (Boolean)

    Strip all metadata from image

  • :background (Array<Double>)

    Background value

Returns:

  • (nil)

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

#tiffsave_buffer(**opts) ⇒ VipsBlob

Save image to tiff buffer.

Parameters:

  • opts (Hash)

    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)
    <