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

Instance Attribute Summary

Attributes inherited from GObject::GObject

#ptr, #references

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Object

#get_pspec, #get_typeof_error, print_all, #signal_connect

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.



223
224
225
 
# File 'lib/vips/image.rb', line 223

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.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Join an array of images.

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




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

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

Band-wise rank of a set of images.

Options Hash (**opts):

  • :index (Integer) —

    Select this band element from sorted list




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

.black(width, height, **opts) ⇒ Vips::Image

Make a black image.

Options Hash (**opts):

  • :bands (Integer) —

    Number of bands in image




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

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

Load csv.

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load csv.

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.eye(width, height, **opts) ⇒ Vips::Image

Make an image showing the eye's spatial response.

Options Hash (**opts):

  • :uchar (Boolean) —

    Output an unsigned char image

  • :factor (Float) —

    Maximum spatial frequency




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

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

Load a fits image.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.fractsurf(width, height, fractal_dimension, **opts) ⇒ Vips::Image

Make a fractal surface.




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

.gaussmat(sigma, min_ampl, **opts) ⇒ Vips::Image

Make a gaussian image.

Options Hash (**opts):

  • :separable (Boolean) —

    Generate separable Gaussian

  • :integer (Boolean) —

    Generate integer Gaussian

  • :precision (Vips::Precision) —

    Generate with this precision




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

.gaussnoise(width, height, **opts) ⇒ Vips::Image

Make a gaussnoise image.

Options Hash (**opts):

  • :sigma (Float) —

    Standard deviation of pixels in generated image

  • :mean (Float) —

    Mean of pixels in generated image

  • :seed (Integer) —

    Random number seed




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

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

Load gif with giflib.

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load gif with giflib.

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load gif with giflib.

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.grey(width, height, **opts) ⇒ Vips::Image

Make a grey ramp image.

Options Hash (**opts):

  • :uchar (Boolean) —

    Output an unsigned char image




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

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

Load a heif image.

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load a heif image.

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load a heif image.

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Make a 1d image where pixel values are indexes.

Options Hash (**opts):

  • :bands (Integer) —

    Number of bands in LUT

  • :ushort (Boolean) —

    Create a 16-bit LUT

  • :size (Integer) —

    Size of 16-bit LUT




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

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

Load jpeg from file.

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load jpeg from buffer.

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load image from jpeg source.

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.logmat(sigma, min_ampl, **opts) ⇒ Vips::Image

Make a laplacian of gaussian image.

Options Hash (**opts):

  • :separable (Boolean) —

    Generate separable Logmatian

  • :integer (Boolean) —

    Generate integer Logmatian

  • :precision (Vips::Precision) —

    Generate with this precision




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

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

Load file with imagemagick.

Options Hash (**opts):

  • :all_frames (Boolean) —

    Read all frames from an image

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load buffer with imagemagick.

Options Hash (**opts):

  • :all_frames (Boolean) —

    Read all frames from an image

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.mask_butterworth(width, height, order, frequency_cutoff, amplitude_cutoff, **opts) ⇒ Vips::Image

Make a butterworth filter.

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




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

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

Make a butterworth_band filter.

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




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

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

Make a butterworth ring filter.

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




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

.mask_fractal(width, height, fractal_dimension, **opts) ⇒ Vips::Image

Make fractal filter.

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




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

.mask_gaussian(width, height, frequency_cutoff, amplitude_cutoff, **opts) ⇒ Vips::Image

Make a gaussian filter.

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




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

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

Make a gaussian filter.

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




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

.mask_gaussian_ring(width, height, frequency_cutoff, amplitude_cutoff, ringwidth, **opts) ⇒ Vips::Image

Make a gaussian ring filter.

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




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

.mask_ideal(width, height, frequency_cutoff, **opts) ⇒ Vips::Image

Make an ideal filter.

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




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

.mask_ideal_band(width, height, frequency_cutoff_x, frequency_cutoff_y, radius, **opts) ⇒ Vips::Image

Make an ideal band filter.

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




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

.mask_ideal_ring(width, height, frequency_cutoff, ringwidth, **opts) ⇒ Vips::Image

Make an ideal ring filter.

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




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

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

Load mat from file.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.matrix_from_array(width, height, array) ⇒ Object 



421
422
423
424
425
426
427
 
# File 'lib/vips/image.rb', line 421

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.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load matrix.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Invoke a vips operation with Operation.call.



228
229
230
 
# File 'lib/vips/image.rb', line 228

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.

Raises:



455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
 
# File 'lib/vips/image.rb', line 455

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.length == width * height
    raise Vips::Error, "Bad array dimensions."
  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?

  image.mutate do |mutable|
    # be careful to set them as double
    mutable.set_type! GObject::GDOUBLE_TYPE, "scale", scale.to_f
    mutable.set_type! GObject::GDOUBLE_TYPE, "offset", offset.to_f
  end
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.

Options Hash (**opts):

  • :disc (Boolean) — default: true —

    Open large images via a temporary disc file

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

    Access mode for file

Raises:



312
313
314
315
316
317
 
# File 'lib/vips/image.rb', line 312

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.

Options Hash (**opts):

  • :disc (Boolean) — default: true —

    Open large images via a temporary disc file

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

    Access mode for file

Raises:



268
269
270
271
272
273
274
275
276
277
278
279
 
# File 'lib/vips/image.rb', line 268

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

.new_from_memory(data, width, height, bands, format) ⇒ Image

Create a new Vips::Image from a C-style array held in memory. For example:

image = Vips::Image.black(16, 16) + 128
data = image.write_to_memory

x = Vips::Image.new_from_memory data,
  image.width, image.height, image.bands, image.format

new_from_memory keeps a reference to the array of pixels you pass in to try to prevent that memory from being freed by the Ruby GC while it is being used.

See new_from_memory_copy for a version of this method which does not keep a reference.

Raises:



342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
 
# File 'lib/vips/image.rb', line 342

def self.new_from_memory data, width, height, bands, format
  size = data.bytesize

  # prevent data from being freed with JRuby FFI
  if defined?(JRUBY_VERSION) && !data.is_a?(FFI::Pointer)
    data = ::FFI::MemoryPointer.new(:char, data.bytesize).write_bytes data
  end

  format_number = GObject::GValue.from_nick BAND_FORMAT_TYPE, format
  vi = Vips.vips_image_new_from_memory data, size,
    width, height, bands, format_number
  raise Vips::Error if vi.null?
  image = new(vi)

  # keep a secret ref to the underlying object .. this reference will be
  # inherited by things that in turn depend on us, so the memory we are
  # using will not be freed
  image.references << data

  image
end

.new_from_memory_copy(data, width, height, bands, format) ⇒ Image

Create a new Vips::Image from memory and copies the memory area. See new_from_memory for a version of this method which does not copy the memory area.

Raises:



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

def self.new_from_memory_copy data, width, height, bands, format
  format_number = GObject::GValue.from_nick BAND_FORMAT_TYPE, format
  vi = Vips.vips_image_new_from_memory_copy data, data.bytesize,
    width, height, bands, format_number
  raise Vips::Error if vi.null?
  new(vi)
end

.new_from_source(source, option_string, **opts) ⇒ Image

Create a new Vips::Image from a source. Load options may be passed as strings or appended as a hash. For example:

source = Vips::Source.new_from_file("k2.jpg")
image = Vips::Image.new_from_source source, "shrink=2"

or alternatively:

image = Vips::Image.new_from_source source, "", shrink: 2

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

$ vips jpegload_source

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

Loading is fast: only enough data is read to be able to fill out the header. Pixels will only be read and decompressed when they are needed.

Options Hash (**opts):

  • :disc (Boolean) — default: true —

    Open large images via a temporary disc file

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

    Access mode for file

Raises:



414
415
416
417
418
419
 
# File 'lib/vips/image.rb', line 414

def self.new_from_source source, option_string, **opts
  loader = Vips.vips_foreign_find_load_source source
  raise Vips::Error if loader.nil?

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

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

Load a nifti image.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load an openexr image.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load file with openslide.

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load pdf from file.

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load pdf from buffer.

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load pdf from source.

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.perlin(width, height, **opts) ⇒ Vips::Image

Make a perlin noise image.

Options Hash (**opts):

  • :cell_size (Integer) —

    Size of Perlin cells

  • :uchar (Boolean) —

    Output an unsigned char image

  • :seed (Integer) —

    Random number seed




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

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

Load png from file.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load png from buffer.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load png from source.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load ppm from file.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load ppm base class.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.profile_load(name, **opts) ⇒ VipsBlob

Load named icc profile.




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

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

Load a radiance image from a file.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load rad from buffer.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load rad from source.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load raw data from a file.

Options Hash (**opts):

  • :offset (guint64) —

    Offset in bytes from start of file

  • :format (Vips::BandFormat) —

    Pixel format in image

  • :interpretation (Vips::Interpretation) —

    Pixel interpretation

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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



211
212
213
214
215
216
 
# File 'lib/vips/image.rb', line 211

def self.respond_to_missing? 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.

Options Hash (**opts):

  • :uchar (Boolean) —

    Output an unsigned char image

  • :hfreq (Float) —

    Horizontal spatial frequency

  • :vfreq (Float) —

    Vertical spatial frequency




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

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

Sum an array of images.




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

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

Load svg with rsvg.

Options Hash (**opts):

  • :dpi (Float) —

    Render at this DPI

  • :scale (Float) —

    Scale output by this factor

  • :unlimited (Boolean) —

    Allow SVG of any size

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load svg with rsvg.

Options Hash (**opts):

  • :dpi (Float) —

    Render at this DPI

  • :scale (Float) —

    Scale output by this factor

  • :unlimited (Boolean) —

    Allow SVG of any size

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load svg from source.

Options Hash (**opts):

  • :dpi (Float) —

    Render at this DPI

  • :scale (Float) —

    Scale output by this factor

  • :unlimited (Boolean) —

    Allow SVG of any size

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.switch(tests, **opts) ⇒ Vips::Image

Find the index of the first non-zero pixel in tests.




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

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

Run an external command.

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




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

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

Make a text image.

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




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

.thumbnail(filename, width, **opts) ⇒ Vips::Image

Generate thumbnail from file.

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

  • :auto_rotate (Boolean) —

    Use orientation tags to rotate image upright




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

.thumbnail_buffer(buffer, width, **opts) ⇒ Vips::Image

Generate thumbnail from buffer.

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

  • :auto_rotate (Boolean) —

    Use orientation tags to rotate image upright




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

.thumbnail_source(source, width, **opts) ⇒ Vips::Image

Generate thumbnail from source.

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

  • :auto_rotate (Boolean) —

    Use orientation tags to rotate image upright




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

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

Load tiff from file.

Options Hash (**opts):

  • :page (Integer) —

    Load this page from the image

  • :subifd (Integer) —

    Select subifd index

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load tiff from buffer.

Options Hash (**opts):

  • :page (Integer) —

    Load this page from the image

  • :subifd (Integer) —

    Select subifd index

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load tiff from source.

Options Hash (**opts):

  • :page (Integer) —

    Load this page from the image

  • :subifd (Integer) —

    Select subifd index

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

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Build a look-up table.

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




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

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

Load vips from file.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load webp from file.

Options Hash (**opts):

  • :page (Integer) —

    Load this page from the file

  • :n (Integer) —

    Load this many pages

  • :scale (Float) —

    Scale factor on load

  • :shrink (Integer) —

    Shrink factor on load

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load webp from buffer.

Options Hash (**opts):

  • :page (Integer) —

    Load this page from the file

  • :n (Integer) —

    Load this many pages

  • :scale (Float) —

    Scale factor on load

  • :shrink (Integer) —

    Shrink factor on load

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load webp from source.

Options Hash (**opts):

  • :page (Integer) —

    Load this page from the file

  • :n (Integer) —

    Load this many pages

  • :scale (Float) —

    Scale factor on load

  • :shrink (Integer) —

    Shrink factor on load

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :sequential (Boolean) —

    Sequential read only

  • :fail (Boolean) —

    Fail on first error

  • :disc (Boolean) —

    Open to disc

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.worley(width, height, **opts) ⇒ Vips::Image

Make a worley noise image.

Options Hash (**opts):

  • :cell_size (Integer) —

    Size of Worley cells

  • :seed (Integer) —

    Random number seed




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

.xyz(width, height, **opts) ⇒ Vips::Image

Make an image where pixel values are coordinates.

Options Hash (**opts):

  • :csize (Integer) —

    Size of third dimension

  • :dsize (Integer) —

    Size of fourth dimension

  • :esize (Integer) —

    Size of fifth dimension




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

.zone(width, height, **opts) ⇒ Vips::Image

Make a zone plate.

Options Hash (**opts):

  • :uchar (Boolean) —

    Output an unsigned char image




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

Instance Method Details

#! ⇒ Image

Equivalent to image ^ -1



1034
1035
1036
 
# File 'lib/vips/image.rb', line 1034

def !
  self ^ -1
end

#!=(other) ⇒ Image

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



1108
1109
1110
1111
1112
1113
1114
1115
 
# File 'lib/vips/image.rb', line 1108

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.



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

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

#&(other) ⇒ Image

Integer bitwise AND with an image, constant or array.



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

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

#*(other) ⇒ Image

Multiply an image, constant or array.



960
961
962
963
 
# File 'lib/vips/image.rb', line 960

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

#**(other) ⇒ Image

Raise to power of an image, constant or array.



987
988
989
 
# File 'lib/vips/image.rb', line 987

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

#+(other) ⇒ Image

Add an image, constant or array.



942
943
944
945
 
# File 'lib/vips/image.rb', line 942

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

#+@ ⇒ Image 



1046
1047
1048
 
# File 'lib/vips/image.rb', line 1046

def +@
  self
end

#-(other) ⇒ Image

Subtract an image, constant or array.



951
952
953
954
 
# File 'lib/vips/image.rb', line 951

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

#-@ ⇒ Image

Equivalent to image * -1



1053
1054
1055
 
# File 'lib/vips/image.rb', line 1053

def -@
  self * -1
end

#/(other) ⇒ Image

Divide an image, constant or array.



969
970
971
972
 
# File 'lib/vips/image.rb', line 969

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.



1061
1062
1063
 
# File 'lib/vips/image.rb', line 1061

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

#<<(other) ⇒ Image

Integer left shift with an image, constant or array.



995
996
997
 
# File 'lib/vips/image.rb', line 995

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

#<=(other) ⇒ Image

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



1070
1071
1072
 
# File 'lib/vips/image.rb', line 1070

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

#==(other) ⇒ Image

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



1095
1096
1097
1098
1099
1100
1101
1102
 
# File 'lib/vips/image.rb', line 1095

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.



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

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

#>=(other) ⇒ Image

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



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

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

#>>(other) ⇒ Image

Integer right shift with an image, constant or array.



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

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

#[](index) ⇒ Image

Fetch bands using a number or a range



1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
 
# File 'lib/vips/image.rb', line 1121

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.



1027
1028
1029
 
# File 'lib/vips/image.rb', line 1027

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

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

Absolute value of an image.




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

#acos ⇒ Image

Return the inverse cosine of an image in degrees.



1379
1380
1381
 
# File 'lib/vips/image.rb', line 1379

def acos
  math :acos
end

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

Add two images.




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

#add_alpha ⇒ Image

Append an alpha channel to an image.

Raises:



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

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.

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

  • :premultiplied (Boolean) —

    Images have premultiplied alpha

  • :extend (Vips::Extend) —

    How to generate the extra pixels




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

#asin ⇒ Image

Return the inverse sine of an image in degrees.



1372
1373
1374
 
# File 'lib/vips/image.rb', line 1372

def asin
  math :asin
end

#atan ⇒ Image

Return the inverse tangent of an image in degrees.



1386
1387
1388
 
# File 'lib/vips/image.rb', line 1386

def atan
  math :atan
end

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

Autorotate image by exif tag.

Options Hash (**opts):

  • :angle (Vips::Angle) —

    Output Angle image was rotated by

  • :flip (Boolean) —

    Output Whether the image was flipped or not




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

#avg(**opts) ⇒ Float

Find image average.




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

#bandand ⇒ Image

AND the bands of an image together



1188
1189
1190
 
# File 'lib/vips/image.rb', line 1188

def bandand
  bandbool :and
end

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

Boolean operation across image bands.




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

#bandeor ⇒ Image

EOR the bands of an image together



1202
1203
1204
 
# File 'lib/vips/image.rb', line 1202

def bandeor
  bandbool :eor
end

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

Fold up x axis into bands.

Options Hash (**opts):

  • :factor (Integer) —

    Fold by this factor




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

#bandjoin(other) ⇒ Image

Join a set of images bandwise.



1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
 
# File 'lib/vips/image.rb', line 1217

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.




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

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

Band-wise average.




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

#bandor ⇒ Image

OR the bands of an image together



1195
1196
1197
 
# File 'lib/vips/image.rb', line 1195

def bandor
  bandbool :or
end

#bands ⇒ Integer

Get number of image bands.



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

def bands
  Vips.vips_image_get_bands self
end

#bandsplit ⇒ Array<Image>

Split an n-band image into n separate images.



1209
1210
1211
 
# File 'lib/vips/image.rb', line 1209

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

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

Unfold image bands into x axis.

Options Hash (**opts):

  • :factor (Integer) —

    Unfold by this factor




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

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

Boolean operation on two images.




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

#boolean_const(boolean, c, **opts) ⇒ Vips::Image

Boolean operations against a constant.




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

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

Build a look-up table.




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

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

Byteswap an image.




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

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

Cache an image.

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




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

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

Canny edge detector.

Options Hash (**opts):

  • :sigma (Float) —

    Sigma of Gaussian

  • :precision (Vips::Precision) —

    Convolve with this precision




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

#case(cases, **opts) ⇒ Vips::Image

Use pixel values to pick cases from an array of images.




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

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

Cast an image.

Options Hash (**opts):

  • :shift (Boolean) —

    Shift integer values up and down




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

#ceil ⇒ Image

Return the smallest integral value not less than the argument.



1174
1175
1176
 
# File 'lib/vips/image.rb', line 1174

def ceil
  round :ceil
end

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

Transform lch to cmc.




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

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

Transform cmyk to xyz.




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

#coding ⇒ Symbol

Get image coding.



830
831
832
 
# File 'lib/vips/image.rb', line 830

def coding
  get "coding"
end

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

Convert to a new colorspace.

Options Hash (**opts):




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

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

Convolve with rotating mask.

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




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

#complex(cmplx, **opts) ⇒ Vips::Image

Perform a complex operation on an image.




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

#complex2(right, cmplx, **opts) ⇒ Vips::Image

Complex binary operations on two images.




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

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

Form a complex image from two real images.




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

#complexget(get, **opts) ⇒ Vips::Image

Get a component from a complex image.




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

#composite(overlay, mode, **opts) ⇒ Image

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

Options Hash (**opts):

  • :x (Array<Integer>) —

    x positions of overlay

  • :y (Array<Integer>) —

    y positions of overlay

  • :compositing_space (Vips::Interpretation) —

    Composite images in this colour space

  • :premultiplied (Boolean) —

    Images have premultiplied alpha



1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
 
# File 'lib/vips/image.rb', line 1243

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.

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




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

#conj ⇒ Image

Return the complex conjugate of an image.

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



1336
1337
1338
 
# File 'lib/vips/image.rb', line 1336

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

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

Convolution operation.

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




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

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

Approximate integer convolution.

Options Hash (**opts):

  • :layers (Integer) —

    Use this many layers in approximation

  • :cluster (Integer) —

    Cluster lines closer than this in approximation




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

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

Approximate separable integer convolution.

Options Hash (**opts):

  • :layers (Integer) —

    Use this many layers in approximation




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

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

Float convolution operation.




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

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

Int convolution operation.




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

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

Seperable convolution operation.

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




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

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

Copy an image.

Options Hash (**opts):

  • :swap (Boolean) —

    Swap bytes in image between little and big-endian

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




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

#copy_memory ⇒ Image

Copy an image to a memory area.

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



924
925
926
927
 
# File 'lib/vips/image.rb', line 924

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

#cos ⇒ Image

Return the cosine of an image in degrees.



1358
1359
1360
 
# File 'lib/vips/image.rb', line 1358

def cos
  math :cos
end

#countlines(direction, **opts) ⇒ Float

Count lines in an image.




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

#crop(left, top, width, height, **opts) ⇒ Vips::Image

Extract an area from an image.




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

#cross_phase(other) ⇒ Image

Calculate the cross phase of two images.



1344
1345
1346
 
# File 'lib/vips/image.rb', line 1344

def cross_phase other
  complex2 other, :cross_phase
end

#csvsave(filename, **opts) ⇒ nil

Save image to csv.

Options Hash (**opts):

  • :separator (String) —

    Separator characters

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#csvsave_target(target, **opts) ⇒ nil

Save image to csv.

Options Hash (**opts):

  • :separator (String) —

    Separator characters

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

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

Calculate de00.




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

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

Calculate de76.




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

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

Calculate decmc.




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

#deviate(**opts) ⇒ Float

Find image standard deviation.




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



1452
1453
1454
 
# File 'lib/vips/image.rb', line 1452

def dilate mask
  morph mask, :dilate
end

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

Divide two images.




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

#draw_circle(ink, cx, cy, radius, **opts) ⇒ Vips::Image

Draw a circle on an image.

Options Hash (**opts):

  • :fill (Boolean) —

    Draw a solid object




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

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

Flood-fill an area.

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




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

#draw_image(sub, x, y, **opts) ⇒ Vips::Image

Paint an image into another image.

Options Hash (**opts):

  • :mode (Vips::CombineMode) —

    Combining mode




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

#draw_line(ink, x1, y1, x2, y2, **opts) ⇒ Vips::Image

Draw a line on an image.




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

#draw_mask(ink, mask, x, y, **opts) ⇒ Vips::Image

Draw a mask on an image.




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

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

Draw a point on an image.

See #draw_rect.



934
935
936
 
# File 'lib/vips/image.rb', line 934

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.

Options Hash (**opts):

  • :fill (Boolean) —

    Draw a solid object




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

#draw_smudge(left, top, width, height, **opts) ⇒ Vips::Image

Blur a rectangle on an image.




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

#dzsave(filename, **opts) ⇒ nil

Save image to deepzoom file.

Options Hash (**opts):

  • :dirname (String) —

    Directory name to save to

  • :basename (String) —

    Base name to save to

  • :layout (Vips::ForeignDzLayout) —

    Directory layout

  • :suffix (String) —

    Filename suffix for tiles

  • :overlap (Integer) —

    Tile overlap in pixels

  • :tile_size (Integer) —

    Tile size in pixels

  • :tile_height (Integer) —

    Tile height in pixels

  • :tile_width (Integer) —

    Tile width 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

  • :no_strip (Boolean) —

    Don't strip tile metadata

  • :id (String) —

    Resource ID

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#dzsave_buffer(**opts) ⇒ VipsBlob

Save image to dz buffer.

Options Hash (**opts):

  • :dirname (String) —

    Directory name to save to

  • :basename (String) —

    Base name to save to

  • :layout (Vips::ForeignDzLayout) —

    Directory layout

  • :suffix (String) —

    Filename suffix for tiles

  • :overlap (Integer) —

    Tile overlap in pixels

  • :tile_size (Integer) —

    Tile size in pixels

  • :tile_height (Integer) —

    Tile height in pixels

  • :tile_width (Integer) —

    Tile width 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

  • :no_strip (Boolean) —

    Don't strip tile metadata

  • :id (String) —

    Resource ID

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#embed(x, y, width, height, **opts) ⇒ Vips::Image

Embed an image in a larger image.

Options Hash (**opts):

  • :extend (Vips::Extend) —

    How to generate the extra pixels

  • :background (Array<Double>) —

    Color for background pixels




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

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



1440
1441
1442
 
# File 'lib/vips/image.rb', line 1440

def erode mask
  morph mask, :erode
end

#exp ⇒ Image

Return e ** pixel.



1407
1408
1409
 
# File 'lib/vips/image.rb', line 1407

def exp
  math :exp
end

#exp10 ⇒ Image

Return 10 ** pixel.



1414
1415
1416
 
# File 'lib/vips/image.rb', line 1414

def exp10
  math :exp10
end

#extract_area(left, top, width, height, **opts) ⇒ Vips::Image

Extract an area from an image.




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

#extract_band(band, **opts) ⇒ Vips::Image

Extract band from an image.

Options Hash (**opts):

  • :n (Integer) —

    Number of bands to extract




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

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

False-color an image.




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

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

Fast correlation.




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

#filename ⇒ String

Get image filename, if any.



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

def filename
  get "filename"
end

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

Fill image zeros with nearest non-zero pixel.

Options Hash (**opts):

  • :distance (Vips::Image) —

    Output Distance to nearest non-zero pixel




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

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

Search an image for non-edge areas.

Options Hash (**opts):

  • :threshold (Float) —

    Object threshold

  • :background (Array<Double>) —

    Color for background pixels




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

#fitssave(filename, **opts) ⇒ nil

Save image to fits file.

Options Hash (**opts):

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

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

Flatten alpha out of an image.

Options Hash (**opts):

  • :background (Array<Double>) —

    Background value

  • :max_alpha (Float) —

    Maximum value of alpha channel




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

#flip(direction, **opts) ⇒ Vips::Image

Flip an image.




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

#fliphor ⇒ Image

Flip horizontally.



1421
1422
1423
 
# File 'lib/vips/image.rb', line 1421

def fliphor
  flip :horizontal
end

#flipver ⇒ Image

Flip vertically.



1428
1429
1430
 
# File 'lib/vips/image.rb', line 1428

def flipver
  flip :vertical
end

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

Transform float rgb to radiance coding.




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

#floor ⇒ Image

Return the largest integral value not greater than the argument.



1167
1168
1169
 
# File 'lib/vips/image.rb', line 1167

def floor
  round :floor
end

#format ⇒ Symbol

Get image format.



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

def format
  get "format"
end

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

Frequency-domain filtering.




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

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

Forward fft.




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

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

Gamma an image.

Options Hash (**opts):

  • :exponent (Float) —

    Gamma factor




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

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

Gaussian blur.

Options Hash (**opts):

  • :min_ampl (Float) —

    Minimum amplitude of Gaussian

  • :precision (Vips::Precision) —

    Convolve with this precision




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

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

Raises:



697
698
699
700
701
702
703
704
705
706
707
708
709
710
 
# File 'lib/vips/image.rb', line 697

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
  raise Vips::Error if Vips.vips_image_get(self, name, gvalue) != 0
  result = gvalue.get
  gvalue.unset

  result
end

#get_fields ⇒ [String]

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



716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
 
# File 'lib/vips/image.rb', line 716

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.

See Also:



673
674
675
676
677
678
679
680
681
682
 
# File 'lib/vips/image.rb', line 673

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



781
782
783
 
# File 'lib/vips/image.rb', line 781

def get_value name
  get name
end

#getpoint(x, y, **opts) ⇒ Array<Double>

Read a point from an image.




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

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

Global balance an image mosaic.

Options Hash (**opts):

  • :gamma (Float) —

    Image gamma

  • :int_output (Boolean) —

    Integer output




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

#gravity(direction, width, height, **opts) ⇒ Vips::Image

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

Options Hash (**opts):

  • :extend (Vips::Extend) —

    How to generate the extra pixels

  • :background (Array<Double>) —

    Color for background pixels




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

#grid(tile_height, across, down, **opts) ⇒ Vips::Image

Grid an image.




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

#has_alpha? ⇒ Boolean

Detect if image has an alpha channel



898
899
900
 
# File 'lib/vips/image.rb', line 898

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

#heifsave(filename, **opts) ⇒ nil

Save image in heif format.

Options Hash (**opts):

  • :Q (Integer) —

    Q factor

  • :lossless (Boolean) —

    Enable lossless compression

  • :compression (Vips::ForeignHeifCompression) —

    Compression format

  • :speed (Integer) —

    CPU effort

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#heifsave_buffer(**opts) ⇒ VipsBlob

Save image in heif format.

Options Hash (**opts):

  • :Q (Integer) —

    Q factor

  • :lossless (Boolean) —

    Enable lossless compression

  • :compression (Vips::ForeignHeifCompression) —

    Compression format

  • :speed (Integer) —

    CPU effort

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#heifsave_target(target, **opts) ⇒ nil

Save image in heif format.

Options Hash (**opts):

  • :Q (Integer) —

    Q factor

  • :lossless (Boolean) —

    Enable lossless compression

  • :compression (Vips::ForeignHeifCompression) —

    Compression format

  • :speed (Integer) —

    CPU effort

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#height ⇒ Integer

Get image height, in pixels.



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

def height
  Vips.vips_image_get_height self
end

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

Form cumulative histogram.




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

#hist_entropy(**opts) ⇒ Float

Estimate image entropy.




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

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

Histogram equalisation.

Options Hash (**opts):

  • :band (Integer) —

    Equalise with this band




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

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

Find image histogram.

Options Hash (**opts):

  • :band (Integer) —

    Find histogram of band




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

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

Find indexed image histogram.

Options Hash (**opts):

  • :combine (Vips::Combine) —

    Combine bins like this




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

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

Find n-dimensional image histogram.

Options Hash (**opts):

  • :bins (Integer) —

    Number of bins in each dimension




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

#hist_ismonotonic(**opts) ⇒ Boolean

Test for monotonicity.




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

#hist_local(width, height, **opts) ⇒ Vips::Image

Local histogram equalisation.

Options Hash (**opts):

  • :max_slope (Integer) —

    Maximum slope (CLAHE)




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

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

Match two histograms.




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

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

Normalise histogram.




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

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

Plot histogram.




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

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

Find hough circle transform.

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




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

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

Find hough line transform.

Options Hash (**opts):

  • :width (Integer) —

    horizontal size of parameter space

  • :height (Integer) —

    Vertical size of parameter space




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

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

Transform hsv to srgb.




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

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

Output to device with icc profile.

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




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

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

Import from device with icc profile.

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




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

#icc_transform(output_profile, **opts) ⇒ Vips::Image

Transform between devices with icc profiles.

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




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

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

Options Hash (**opts):

  • :blend (Boolean) — default: false —

    Blend smoothly between th and el



1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
 
# File 'lib/vips/image.rb', line 1486

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

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

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

#imag ⇒ Image

Return the imaginary part of a complex image.



1298
1299
1300
 
# File 'lib/vips/image.rb', line 1298

def imag
  complexget :imag
end

#insert(sub, x, y, **opts) ⇒ Vips::Image

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

Options Hash (**opts):

  • :expand (Boolean) —

    Expand output to hold all of both inputs

  • :background (Array<Double>) —

    Color for new pixels




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

#inspect ⇒ Object 



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

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

#interpretation ⇒ Symbol

Get image interpretation.



823
824
825
 
# File 'lib/vips/image.rb', line 823

def interpretation
  get "interpretation"
end

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

Invert an image.




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

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

Build an inverted look-up table.

Options Hash (**opts):

  • :size (Integer) —

    LUT size to generate




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

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

Inverse fft.

Options Hash (**opts):

  • :real (Boolean) —

    Output only the real part of the transform




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

#join(in2, direction, **opts) ⇒ Vips::Image

Join a pair of images.

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




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

#jpegsave(filename, **opts) ⇒ nil

Save image to jpeg file.

Options Hash (**opts):

  • :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 spectrum of DCT coefficients into separate scans

  • :quant_table (Integer) —

    Use predefined quantization table with given index

  • :subsample_mode (Vips::ForeignJpegSubsample) —

    Select chroma subsample operation mode

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#jpegsave_buffer(**opts) ⇒ VipsBlob

Save image to jpeg buffer.

Options Hash (**opts):

  • :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 spectrum of DCT coefficients into separate scans

  • :quant_table (Integer) —

    Use predefined quantization table with given index

  • :subsample_mode (Vips::ForeignJpegSubsample) —

    Select chroma subsample operation mode

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#jpegsave_mime(**opts) ⇒ nil

Save image to jpeg mime.

Options Hash (**opts):

  • :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 spectrum of DCT coefficients into separate scans

  • :quant_table (Integer) —

    Use predefined quantization table with given index

  • :subsample_mode (Vips::ForeignJpegSubsample) —

    Select chroma subsample operation mode

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#jpegsave_target(target, **opts) ⇒ nil

Save image to jpeg target.

Options Hash (**opts):

  • :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 spectrum of DCT coefficients into separate scans

  • :quant_table (Integer) —

    Use predefined quantization table with given index

  • :subsample_mode (Vips::ForeignJpegSubsample) —

    Select chroma subsample operation mode

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

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

Transform float lab to labq coding.




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

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

Transform float lab to signed short.




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

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

Transform lab to lch.




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

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

Transform cielab to xyz.

Options Hash (**opts):

  • :temp (Array<Double>) —

    Color temperature




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

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

Label regions in an image.

Options Hash (**opts):

  • :segments (Integer) —

    Output Number of discrete contigious regions




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

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

Unpack a labq image to float lab.




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

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

Unpack a labq image to short lab.




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

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

Convert a labq image to srgb.




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

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

Transform signed short lab to float.




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

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

Transform short lab to labq coding.




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

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

Transform lch to cmc.




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

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

Transform lch to lab.




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

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

Calculate (a * in + b).

Options Hash (**opts):

  • :uchar (Boolean) —

    Output should be uchar




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

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

Cache an image as a set of lines.

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




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

#log ⇒ Image

Return the natural log of an image.



1393
1394
1395
 
# File 'lib/vips/image.rb', line 1393

def log
  math :log
end

#log10 ⇒ Image

Return the log base 10 of an image.



1400
1401
1402
 
# File 'lib/vips/image.rb', line 1400

def log10
  math :log10
end

#magicksave(filename, **opts) ⇒ nil

Save file with imagemagick.

Options Hash (**opts):

  • :format (String) —

    Format to save in

  • :quality (Integer) —

    Quality to use

  • :optimize_gif_frames (Boolean) —

    Apply GIF frames optimization

  • :optimize_gif_transparency (Boolean) —

    Apply GIF transparency optimization

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#magicksave_buffer(**opts) ⇒ VipsBlob

Save image to magick buffer.

Options Hash (**opts):

  • :format (String) —

    Format to save in

  • :quality (Integer) —

    Quality to use

  • :optimize_gif_frames (Boolean) —

    Apply GIF frames optimization

  • :optimize_gif_transparency (Boolean) —

    Apply GIF transparency optimization

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

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

Resample with a map image.

Options Hash (**opts):




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

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

Map an image though a lut.

Options Hash (**opts):

  • :band (Integer) —

    apply one-band lut to this band of in




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

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

First-order match of two images.

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




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

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

Apply a math operation to an image.




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

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

Binary math operations.




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

#math2_const(math2, c, **opts) ⇒ Vips::Image

Binary math operations with a constant.




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

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

Invert an matrix.




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

#matrixprint(**opts) ⇒ nil

Print matrix.

Options Hash (**opts):

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#matrixsave(filename, **opts) ⇒ nil

Save image to matrix.

Options Hash (**opts):

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#matrixsave_target(target, **opts) ⇒ nil

Save image to matrix.

Options Hash (**opts):

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

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

Find image maximum.

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




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

#maxpos ⇒ Real

Return the coordinates of the image maximum.



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

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

#measure(h, v, **opts) ⇒ Vips::Image

Measure a set of patches on a color chart.

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




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

#median(size = 3) ⇒ Image

a median filter



1284
1285
1286
 
# File 'lib/vips/image.rb', line 1284

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

#merge(sec, direction, dx, dy, **opts) ⇒ Vips::Image

Merge two images.

Options Hash (**opts):

  • :mblend (Integer) —

    Maximum blend size




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

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

Find image minimum.

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




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

#minpos ⇒ Real

Return the coordinates of the image minimum.



1273
1274
1275
1276
1277
1278
 
# File 'lib/vips/image.rb', line 1273

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

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

Morphology operation.




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

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

Mosaic two images.

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




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

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

First-order mosaic of two images.

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




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

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

Pick most-significant byte from an image.

Options Hash (**opts):

  • :band (Integer) —

    Band to msb




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

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

Multiply two images.




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

#mutate {|mutable| ... } ⇒ Object

Mutate an image with a block. Inside the block, you can call methods which modify the image, such as setting or removing metadata, or modifying pixels.

For example:

image = image.mutate do |x|
  (0 ... 1).step(0.01) do |i|
    x.draw_line! 255, x.width * i, 0, 0, x.height * (1 - i)
  end
end

See MutableImage.

Yields:

  • (mutable) 


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

def mutate
  mutable = Vips::MutableImage.new self
  yield mutable
  mutable.image
end

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



505
506
507
508
509
510
 
# File 'lib/vips/image.rb', line 505

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.

Options Hash (**opts):

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#offset ⇒ Float

Get offset metadata.



881
882
883
884
885
 
# File 'lib/vips/image.rb', line 881

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

  get "offset"
end

#parent_get_typeof ⇒ Object 



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

alias_method :parent_get_typeof, :get_typeof

#percent(percent, **opts) ⇒ Integer

Find threshold for percent of pixels.




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

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

Calculate phase correlation.




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

#pngsave(filename, **opts) ⇒ nil

Save image to png file.

Options Hash (**opts):

  • :compression (Integer) —

    Compression factor

  • :interlace (Boolean) —

    Interlace image

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

  • :bitdepth (Integer) —

    Write as a 1, 2, 4 or 8 bit image

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#pngsave_buffer(**opts) ⇒ VipsBlob

Save image to png buffer.

Options Hash (**opts):

  • :compression (Integer) —

    Compression factor

  • :interlace (Boolean) —

    Interlace image

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

  • :bitdepth (Integer) —

    Write as a 1, 2, 4 or 8 bit image

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#pngsave_target(target, **opts) ⇒ nil

Save image to target as png.

Options Hash (**opts):

  • :compression (Integer) —

    Compression factor

  • :interlace (Boolean) —

    Interlace image

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

  • :bitdepth (Integer) —

    Write as a 1, 2, 4 or 8 bit image

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#polar ⇒ Image

Return an image with rectangular pixels converted to polar.

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

See Also:



1311
1312
1313
 
# File 'lib/vips/image.rb', line 1311

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

#ppmsave(filename, **opts) ⇒ nil

Save image to ppm file.

Options Hash (**opts):

  • :ascii (Boolean) —

    save as ascii

  • :squash (Boolean) —

    save as one bit

  • :bitdepth (Integer) —

    set to 1 to write as a 1 bit image

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#ppmsave_target(target, **opts) ⇒ nil

Save to ppm.

Options Hash (**opts):

  • :ascii (Boolean) —

    save as ascii

  • :squash (Boolean) —

    save as one bit

  • :bitdepth (Integer) —

    set to 1 to write as a 1 bit image

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

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

Premultiply image alpha.

Options Hash (**opts):

  • :max_alpha (Float) —

    Maximum value of alpha channel




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

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

Find image profiles.




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

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

Find image projections.




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

#quadratic(coeff, **opts) ⇒ Vips::Image

Resample an image with a quadratic transform.

Options Hash (**opts):




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

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

Unpack radiance coding to float rgb.




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

#radsave(filename, **opts) ⇒ nil

Save image to radiance file.

Options Hash (**opts):

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#radsave_buffer(**opts) ⇒ VipsBlob

Save image to radiance buffer.

Options Hash (**opts):

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#radsave_target(target, **opts) ⇒ nil

Save image to radiance target.

Options Hash (**opts):

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#rank(width, height, index, **opts) ⇒ Vips::Image

Rank filter.




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

#rawsave(filename, **opts) ⇒ nil

Save image to raw file.

Options Hash (**opts):

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#rawsave_fd(fd, **opts) ⇒ nil

Write raw image to file descriptor.

Options Hash (**opts):

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#real ⇒ Image

Return the real part of a complex image.



1291
1292
1293
 
# File 'lib/vips/image.rb', line 1291

def real
  complexget :real
end

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

Linear recombination with matrix.




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

#rect ⇒ Image

Return an image with polar pixels converted to rectangular.

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

See Also:



1324
1325
1326
 
# File 'lib/vips/image.rb', line 1324

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

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

Reduce an image.

Options Hash (**opts):

  • :kernel (Vips::Kernel) —

    Resampling kernel

  • :centre (Boolean) —

    Use centre sampling convention

  • :xshrink (Float) —

    Horizontal shrink factor

  • :yshrink (Float) —

    Vertical shrink factor




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

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

Shrink an image horizontally.

Options Hash (**opts):

  • :xshrink (Float) —

    Horizontal shrink factor

  • :kernel (Vips::Kernel) —

    Resampling kernel

  • :centre (Boolean) —

    Use centre sampling convention




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

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

Shrink an image vertically.

Options Hash (**opts):

  • :yshrink (Float) —

    Vertical shrink factor

  • :kernel (Vips::Kernel) —

    Resampling kernel

  • :centre (Boolean) —

    Use centre sampling convention




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

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

Relational operation on two images.




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

#relational_const(relational, c, **opts) ⇒ Vips::Image

Relational operations against a constant.




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

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

Remainder after integer division of two images.




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

#remainder_const(c, **opts) ⇒ Vips::Image

Remainder after integer division of an image and a constant.




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

#remove(name) ⇒ Object

This method is deprecated.

Please use MutableImage#remove! instead.



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

def remove name
  Vips.vips_image_remove self, name
end

#replicate(across, down, **opts) ⇒ Vips::Image

Replicate an image.




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

#resize(scale, **opts) ⇒ Vips::Image

Resize an image.

Options Hash (**opts):

  • :interpolate (Vips::Interpolate) —

    Interpolate pixels with this

  • :kernel (Vips::Kernel) —

    Resampling kernel

  • :centre (Boolean) —

    Use centre sampling convention

  • :vscale (Float) —

    Vertical scale image by this factor

  • :idx (Float) —

    Horizontal input displacement

  • :idy (Float) —

    Vertical input displacement




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

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



193
194
195
196
197
198
199
200
201
202
 
# File 'lib/vips/image.rb', line 193

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

  super
end

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



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

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

  super
end

#rint ⇒ Image

Return the nearest integral value.



1181
1182
1183
 
# File 'lib/vips/image.rb', line 1181

def rint
  round :rint
end

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

Rotate an image.




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

#rot180 ⇒ Image

Rotate by 180 degrees clockwise.



1466
1467
1468
 
# File 'lib/vips/image.rb', line 1466

def rot180
  rot :d180
end

#rot270 ⇒ Image

Rotate by 270 degrees clockwise.



1473
1474
1475
 
# File 'lib/vips/image.rb', line 1473

def rot270
  rot :d270
end

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

Rotate an image.

Options Hash (**opts):




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

#rot90 ⇒ Image

Rotate by 90 degrees clockwise.



1459
1460
1461
 
# File 'lib/vips/image.rb', line 1459

def rot90
  rot :d90
end

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

Rotate an image by a number of degrees.

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




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

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

Perform a round function on an image.




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

#scale ⇒ Float

Get scale metadata.



872
873
874
875
876
 
# File 'lib/vips/image.rb', line 872

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.



1504
1505
1506
 
# File 'lib/vips/image.rb', line 1504

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

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

Convert scrgb to bw.

Options Hash (**opts):

  • :depth (Integer) —

    Output device space depth in bits




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

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

Convert an scrgb image to srgb.

Options Hash (**opts):

  • :depth (Integer) —

    Output device space depth in bits




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

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

Transform scrgb to xyz.




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

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

Check sequential access.

Options Hash (**opts):

  • :trace (Boolean) —

    trace pixel requests

  • :tile_height (Integer) —

    Tile height in pixels

  • :access (Vips::Access) —

    Expected access pattern




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

#set(name, value) ⇒ Object

This method is deprecated.

Please use MutableImage#set! instead.



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

def set name, value
  set_type get_typeof(name), name, value
end

#set_kill(kill) ⇒ Object

Kill computation of this time.

Set true to stop computation of this image. You can call this from a progress handler, for example.

See Also:



663
664
665
 
# File 'lib/vips/image.rb', line 663

def set_kill kill
  Vips.vips_image_set_kill self, kill
end

#set_progress(state) ⇒ Object

Turn progress signalling on and off.

If this is on, the most-downstream image from this image will issue progress signals.

See Also:



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

def set_progress state
  Vips.vips_image_set_progress self, state
end

#set_type(gtype, name, value) ⇒ Object

This method is deprecated.

Please use MutableImage#set_type! instead.



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

def set_type gtype, name, value
  gvalue = GObject::GValue.alloc
  gvalue.init gtype
  gvalue.set value
  Vips.vips_image_set self, name, gvalue
  gvalue.unset
end

#set_value(name, value) ⇒ Object

This method is deprecated.

Please use MutableImage#set! instead.



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

def set_value name, value
  set name, value
end

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

Unsharp masking for print.

Options Hash (**opts):

  • :radius (Integer) —

    radius of Gaussian

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




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

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

Shrink an image.

Options Hash (**opts):

  • :xshrink (Float) —

    Horizontal shrink factor

  • :yshrink (Float) —

    Vertical shrink factor




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

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

Shrink an image horizontally.

Options Hash (**opts):

  • :xshrink (Integer) —

    Horizontal shrink factor




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

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

Shrink an image vertically.

Options Hash (**opts):

  • :yshrink (Integer) —

    Vertical shrink factor




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

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

Unit vector of pixel.




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

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

Similarity transform of an image.

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




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

#sin ⇒ Image

Return the sine of an image in degrees.



1351
1352
1353
 
# File 'lib/vips/image.rb', line 1351

def sin
  math :sin
end

#size ⇒ Integer

Get the image size.



890
891
892
 
# File 'lib/vips/image.rb', line 890

def size
  [width, height]
end

#smartcrop(width, height, **opts) ⇒ Vips::Image

Extract an area from an image.

Options Hash (**opts):




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

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

Sobel edge detector.




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

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

Spatial correlation.




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

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

Make displayable power spectrum.




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

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

Transform srgb to hsv.




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

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

Convert an srgb image to scrgb.




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

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

Find many image stats.




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

#stdif(width, height, **opts) ⇒ Vips::Image

Statistical difference.

Options Hash (**opts):

  • :s0 (Float) —

    New deviation

  • :b (Float) —

    Weight of new deviation

  • :m0 (Float) —

    New mean

  • :a (Float) —

    Weight of new mean




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

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

Subsample an image.

Options Hash (**opts):

  • :point (Boolean) —

    Point sample




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

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

Subtract two images.




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

#tan ⇒ Image

Return the tangent of an image in degrees.



1365
1366
1367
 
# File 'lib/vips/image.rb', line 1365

def tan
  math :tan
end

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

Generate thumbnail from image.

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

  • :auto_rotate (Boolean) —

    Use orientation tags to rotate image upright




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

#tiffsave(filename, **opts) ⇒ nil

Save image to tiff file.

Options Hash (**opts):

  • :compression (Vips::ForeignTiffCompression) —

    Compression for this file

  • :Q (Integer) —

    Q factor

  • :predictor (Vips::ForeignTiffPredictor) —

    Compression prediction

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

  • :squash (Boolean) —

    Squash images down to 1 bit

  • :miniswhite (Boolean) —

    Use 0 for white in 1-bit images

  • :bitdepth (Integer) —

    Write as a 1, 2, 4 or 8 bit image

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

  • :rgbjpeg (Boolean) —

    Output RGB JPEG rather than YCbCr

  • :properties (Boolean) —

    Write a properties document to IMAGEDESCRIPTION

  • :region_shrink (Vips::RegionShrink) —

    Method to shrink regions

  • :level (Integer) —

    ZSTD compression level

  • :subifd (Boolean) —

    Save pyr layers as sub-IFDs

  • :lossless (Boolean) —

    Enable WEBP lossless mode

  • :depth (Vips::ForeignDzDepth) —

    Pyramid depth

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#tiffsave_buffer(**opts) ⇒ VipsBlob

Save image to tiff buffer.

Options Hash (**opts):

  • :compression (Vips::ForeignTiffCompression) —

    Compression for this file

  • :Q (Integer) —

    Q factor

  • :predictor (Vips::ForeignTiffPredictor) —

    Compression prediction

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

  • :squash (Boolean) —

    Squash images down to 1 bit

  • :miniswhite (Boolean) —

    Use 0 for white in 1-bit images

  • :bitdepth (Integer) —

    Write as a 1, 2, 4 or 8 bit image

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

  • :rgbjpeg (Boolean) —

    Output RGB JPEG rather than YCbCr

  • :properties (Boolean) —

    Write a properties document to IMAGEDESCRIPTION

  • :region_shrink (Vips::RegionShrink) —

    Method to shrink regions

  • :level (Integer) —

    ZSTD compression level

  • :subifd (Boolean) —

    Save pyr layers as sub-IFDs

  • :lossless (Boolean) —

    Enable WEBP lossless mode

  • :depth (Vips::ForeignDzDepth) —

    Pyramid depth

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

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

Cache an image as a set of tiles.

Options Hash (**opts):

  • :tile_width (Integer) —

    Tile width in pixels

  • :tile_height (Integer) —

    Tile height in pixels

  • :max_tiles (Integer) —

    Maximum number of tiles to cache

  • :access (Vips::Access) —

    Expected access pattern

  • :threaded (Boolean) —

    Allow threaded access

  • :persistent (Boolean) —

    Keep cache between evaluations




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

#to_a ⇒ Array

Convert to an Array. This will be slow for large images.



1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
 
# File 'lib/vips/image.rb', line 1135

def to_a
  # we render the image to a big string, then unpack
  # as a Ruby array of the correct type
  memory = write_to_memory

  # make the template for unpack
  template = {
    char: "c",
    uchar: "C",
    short: "s_",
    ushort: "S_",
    int: "i_",
    uint: "I_",
    float: "f",
    double: "d",
    complex: "f",
    dpcomplex: "d"
  }[format] + "*"

  # and unpack into something like [1, 2, 3, 4 ..]
  array = memory.unpack(template)

  # gather band elements together
  pixel_array = array.each_slice(bands).to_a

  # build rows
  pixel_array.each_slice(width).to_a
end

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

Transpose3d an image.

Options Hash (**opts):

  • :page_height (Integer) —

    Height of each input page




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

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

Unpremultiply image alpha.

Options Hash (**opts):

  • :max_alpha (Float) —

    Maximum value of alpha channel

  • :alpha_band (Integer) —

    Unpremultiply with this alpha




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

#vipssave(filename, **opts) ⇒ nil

Save image to vips file.

Options Hash (**opts):

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#webpsave(filename, **opts) ⇒ nil

Save image to webp file.

Options Hash (**opts):

  • :Q (Integer) —

    Q factor

  • :lossless (Boolean) —

    enable lossless compression

  • :preset (Vips::ForeignWebpPreset) —

    Preset for lossy compression

  • :smart_subsample (Boolean) —

    Enable high quality chroma subsampling

  • :near_lossless (Boolean) —

    Enable preprocessing in lossless mode (uses Q)

  • :alpha_q (Integer) —

    Change alpha plane fidelity for lossy compression

  • :min_size (Boolean) —

    Optimise for minium size

  • :kmin (Integer) —

    Minimum number of frames between key frames

  • :kmax (Integer) —

    Maximum number of frames between key frames

  • :reduction_effort (Integer) —

    Level of CPU effort to reduce file size

  • :profile (String) —

    ICC profile to embed

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#webpsave_buffer(**opts) ⇒ VipsBlob

Save image to webp buffer.

Options Hash (**opts):

  • :Q (Integer) —

    Q factor

  • :lossless (Boolean) —

    enable lossless compression

  • :preset (Vips::ForeignWebpPreset) —

    Preset for lossy compression

  • :smart_subsample (Boolean) —

    Enable high quality chroma subsampling

  • :near_lossless (Boolean) —

    Enable preprocessing in lossless mode (uses Q)

  • :alpha_q (Integer) —

    Change alpha plane fidelity for lossy compression

  • :min_size (Boolean) —

    Optimise for minium size

  • :kmin (Integer) —

    Minimum number of frames between key frames

  • :kmax (Integer) —

    Maximum number of frames between key frames

  • :reduction_effort (Integer) —

    Level of CPU effort to reduce file size

  • :profile (String) —

    ICC profile to embed

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#webpsave_target(target, **opts) ⇒ nil

Save image to webp target.

Options Hash (**opts):

  • :Q (Integer) —

    Q factor

  • :lossless (Boolean) —

    enable lossless compression

  • :preset (Vips::ForeignWebpPreset) —

    Preset for lossy compression

  • :smart_subsample (Boolean) —

    Enable high quality chroma subsampling

  • :near_lossless (Boolean) —

    Enable preprocessing in lossless mode (uses Q)

  • :alpha_q (Integer) —

    Change alpha plane fidelity for lossy compression

  • :min_size (Boolean) —

    Optimise for minium size

  • :kmin (Integer) —

    Minimum number of frames between key frames

  • :kmax (Integer) —

    Maximum number of frames between key frames

  • :reduction_effort (Integer) —

    Level of CPU effort to reduce file size

  • :profile (String) —

    ICC profile to embed

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value

  • :page_height (Integer) —

    Set page height for multipage save




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

#width ⇒ Integer

Get image width, in pixels.



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

def width
  Vips.vips_image_get_width self
end

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

Wrap image origin.

Options Hash (**opts):

  • :x (Integer) —

    Left edge of input in output

  • :y (Integer) —

    Top edge of input in output




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

#write_to_buffer(format_string, **opts) ⇒ String

Write this image to a memory buffer. Save options may be encoded in the format_string or given as a hash. For example:

buffer = image.write_to_buffer ".jpg[Q=90]"

or equivalently:

image.write_to_buffer ".jpg", Q: 90

The full set of save options depend on the selected saver. Try something like:

$ vips jpegsave

to see all the available options for JPEG save.

Options Hash (**opts):

  • :strip (Boolean) — default: false —

    Strip all metadata from image

  • :background (Array<Float>) — default: 0 —

    Background colour to flatten alpha against, if necessary

Raises:



579
580
581
582
583
584
585
586
587
588
589
590
591
592
 
# File 'lib/vips/image.rb', line 579

def write_to_buffer format_string, **opts
  raise Vips::Error, "filename is nil" if format_string.nil?
  filename = Vips.p2str(Vips.vips_filename_get_filename(format_string))
  option_string = Vips.p2str(Vips.vips_filename_get_options(format_string))
  saver = Vips.vips_foreign_find_save_buffer filename
  raise Vips::Error if saver.nil?

  buffer = Vips::Operation.call saver, [self], opts, option_string
  raise Vips::Error if buffer.nil?

  write_gc

  buffer
end

#write_to_file(name, **opts) ⇒ Object

Write this image to a file. Save options may be encoded in the filename or given as a hash. For example:

image.write_to_file "fred.jpg[Q=90]"

or equivalently:

image.write_to_file "fred.jpg", Q: 90

The full set of save options depend on the selected saver. Try something like:

$ vips jpegsave

to see all the available options for JPEG save.

Options Hash (**opts):

  • :strip (Boolean) — default: false —

    Strip all metadata from image

  • :background (Array<Float>) — default: 0 —

    Background colour to flatten alpha against, if necessary

Raises:



541
542
543
544
545
546
547
548
549
550
551
552
 
# File 'lib/vips/image.rb', line 541

def write_to_file name, **opts
  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))
  saver = Vips.vips_foreign_find_save filename
  raise Vips::Error if saver.nil?

  Vips::Operation.call saver, [self, filename], opts, option_string

  write_gc
end

#write_to_memory ⇒ String

Write this image to a large memory buffer.

Raises:



634
635
636
637
638
639
640
641
642
643
 
# File 'lib/vips/image.rb', line 634

def write_to_memory
  len = Vips::SizeStruct.new
  ptr = Vips.vips_image_write_to_memory self, len
  raise Vips::Error if ptr.nil?

  # wrap up as an autopointer
  ptr = FFI::AutoPointer.new(ptr, GLib::G_FREE)

  ptr.get_bytes 0, len[:value]
end

#write_to_target(target, format_string, **opts) ⇒ Object

Write this image to a target. Save options may be encoded in the format_string or given as a hash. For example:

target = Vips::Target.new_to_file "k2.jpg"
image.write_to_target target, ".jpg[Q=90]"

or equivalently:

image.write_to_target target, ".jpg", Q: 90

The full set of save options depend on the selected saver. Try something like:

$ vips jpegsave_target

to see all the available options for JPEG save.

Options Hash (**opts):

  • :strip (Boolean) — default: false —

    Strip all metadata from image

  • :background (Array<Float>) — default: 0 —

    Background colour to flatten alpha against, if necessary

Raises:



620
621
622
623
624
625
626
627
628
629
 
# File 'lib/vips/image.rb', line 620

def write_to_target target, format_string, **opts
  raise Vips::Error, "filename is nil" if format_string.nil?
  filename = Vips.p2str(Vips.vips_filename_get_filename(format_string))
  option_string = Vips.p2str(Vips.vips_filename_get_options(format_string))
  saver = Vips.vips_foreign_find_save_target filename
  raise Vips::Error if saver.nil?

  Vips::Operation.call saver, [self, target], opts, option_string
  write_gc
end

#xoffset ⇒ Integer

Get image xoffset.



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

def xoffset
  get "xoffset"
end

#xres ⇒ Float

Get image x resolution.



858
859
860
 
# File 'lib/vips/image.rb', line 858

def xres
  get "xres"
end

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

Transform xyz to cmyk.




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

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

Transform xyz to lab.

Options Hash (**opts):

  • :temp (Array<Double>) —

    Colour temperature




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

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

Transform xyz to scrgb.




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

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

Transform xyz to yxy.




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

#yoffset ⇒ Integer

Get image yoffset.



851
852
853
 
# File 'lib/vips/image.rb', line 851

def yoffset
  get "yoffset"
end

#yres ⇒ Float

Get image y resolution.



865
866
867
 
# File 'lib/vips/image.rb', line 865

def yres
  get "yres"
end

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

Transform yxy to xyz.




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

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

Zoom an image.




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

#|(other) ⇒ Image

Integer bitwise OR with an image, constant or array.



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

def | other
  call_enum "boolean", other, :or
end

#~ ⇒ Image

Equivalent to image ^ -1



1041
1042
1043
 
# File 'lib/vips/image.rb', line 1041

def ~
  self ^ -1
end