Class: Vips::Image

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

Overview

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

Defined Under Namespace

Modules: ImageLayout Classes: GenericPtr, ManagedStruct, Struct

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Object

#get_pspec, #get_typeof_error, print_all, #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.



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

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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

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

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

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

Load csv from file.

Options Hash (**opts):

  • :skip (Integer) —

    Skip this many lines at the start of the file

  • :lines (Integer) —

    Read this many lines from the file

  • :whitespace (String) —

    Set of whitespace characters

  • :separator (String) —

    Set of separator characters

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

.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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Make a fractal surface.




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

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

Make a gaussian image.

Options Hash (**opts):

  • :separable (Boolean) —

    Generate separable Gaussian

  • :precision (Vips::Precision) —

    Generate with this precision




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

.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




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

.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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

.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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

.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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Make a laplacian of gaussian image.

Options Hash (**opts):

  • :separable (Boolean) —

    Generate separable Logmatian

  • :precision (Vips::Precision) —

    Generate with this precision




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

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

Load file with imagemagick.

Options Hash (**opts):

  • :density (String) —

    Canvas resolution for rendering vector formats like SVG

  • :page (Integer) —

    Load this page from the file

  • :n (Integer) —

    Load this many pages

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load buffer with imagemagick.

Options Hash (**opts):

  • :density (String) —

    Canvas resolution for rendering vector formats like SVG

  • :page (Integer) —

    Load this page from the file

  • :n (Integer) —

    Load this many pages

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

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

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

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

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

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

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

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

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

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

.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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.matrix_from_array(width, height, array) ⇒ Object 



323
324
325
326
327
328
329
 
# File 'lib/vips/image.rb', line 323

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

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

Load matrix from file.

Options Hash (**opts):

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Invoke a vips operation with Operation.call.



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

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:



357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
 
# File 'lib/vips/image.rb', line 357

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

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

    array = array.flatten
  else
    height = 1
    width = array.length
  end

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

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

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

  return image
end

.new_from_buffer(data, option_string, **opts) ⇒ Image

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

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

or alternatively:

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

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

$ vips jpegload_buffer

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

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

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:



277
278
279
280
281
282
 
# File 'lib/vips/image.rb', line 277

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:



233
234
235
236
237
238
239
240
241
242
243
244
 
# File 'lib/vips/image.rb', line 233

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



316
317
318
319
320
321
 
# File 'lib/vips/image.rb', line 316

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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load pdf with libpoppler.

Options Hash (**opts):

  • :page (Integer) —

    Load this page from the file

  • :n (Integer) —

    Load this many pages

  • :dpi (Float) —

    Render at this DPI

  • :scale (Float) —

    Scale output by this factor

  • :background (Array<Double>) —

    Background value

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load pdf with libpoppler.

Options Hash (**opts):

  • :page (Integer) —

    Load this page from the file

  • :n (Integer) —

    Load this many pages

  • :dpi (Float) —

    Render at this DPI

  • :scale (Float) —

    Scale output by this factor

  • :background (Array<Double>) —

    Background value

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.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




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

.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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.profile_load(name, **opts) ⇒ VipsBlob

Load named icc profile.




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

.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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.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

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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



176
177
178
179
180
181
 
# File 'lib/vips/image.rb', line 176

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

  super
end

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

Make a 2d sine wave.

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 654

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

Sum an array of images.




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

.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

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.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

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

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

.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




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

.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




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

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

Load tiff from file.

Options Hash (**opts):

  • :page (Integer) —

    Load this page from the image

  • :n (Integer) —

    Load this many pages

  • :autorotate (Boolean) —

    Rotate image using orientation tag

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Load tiff from buffer.

Options Hash (**opts):

  • :page (Integer) —

    Load this page from the image

  • :n (Integer) —

    Load this many pages

  • :autorotate (Boolean) —

    Rotate image using orientation tag

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

.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

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.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

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

.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

  • :memory (Boolean) —

    Force open via memory

  • :access (Vips::Access) —

    Required access pattern for this file

  • :fail (Boolean) —

    Fail on first error

  • :flags (Vips::ForeignFlags) —

    Output Flags for this file




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

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

Make a worley noise image.

Options Hash (**opts):

  • :cell_size (Integer) —

    Size of Worley cells




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

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

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

Instance Method Details

#! ⇒ Image

Equivalent to image ^ -1



930
931
932
 
# File 'lib/vips/image.rb', line 930

def !
  self ^ -1
end

#!=(other) ⇒ Image

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



1004
1005
1006
1007
1008
1009
1010
1011
 
# File 'lib/vips/image.rb', line 1004

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.



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

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

#&(other) ⇒ Image

Integer bitwise AND with an image, constant or array.



915
916
917
 
# File 'lib/vips/image.rb', line 915

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

#*(other) ⇒ Image

Multiply an image, constant or array.



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

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

#**(other) ⇒ Image

Raise to power of an image, constant or array.



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

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

#+(other) ⇒ Image

Add an image, constant or array.



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

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

#+@ ⇒ Image 



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

def +@
  self
end

#-(other) ⇒ Image

Subtract an image, constant or array.



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

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

#-@ ⇒ Image

Equivalent to image * -1



949
950
951
 
# File 'lib/vips/image.rb', line 949

def -@
  self * -1
end

#/(other) ⇒ Image

Divide an image, constant or array.



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

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.



957
958
959
 
# File 'lib/vips/image.rb', line 957

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

#<<(other) ⇒ Image

Integer left shift with an image, constant or array.



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

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

#<=(other) ⇒ Image

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



966
967
968
 
# File 'lib/vips/image.rb', line 966

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

#==(other) ⇒ Image

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



991
992
993
994
995
996
997
998
 
# File 'lib/vips/image.rb', line 991

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.



974
975
976
 
# File 'lib/vips/image.rb', line 974

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

#>=(other) ⇒ Image

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



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

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

#>>(other) ⇒ Image

Integer right shift with an image, constant or array.



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

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

#[](index) ⇒ Image

Fetch bands using a number or a range



1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
 
# File 'lib/vips/image.rb', line 1017

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.



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

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

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

Absolute value of an image.




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

#acos ⇒ Image

Return the inverse cosine of an image in degrees.



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

def acos
  math :acos
end

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

Add two images.




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

#add_alpha ⇒ Image

Append an alpha channel to an image.

Raises:



804
805
806
807
808
809
810
 
# File 'lib/vips/image.rb', line 804

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

  • :extend (Vips::Extend) —

    How to generate the extra pixels




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

#asin ⇒ Image

Return the inverse sine of an image in degrees.



1267
1268
1269
 
# File 'lib/vips/image.rb', line 1267

def asin
  math :asin
end

#atan ⇒ Image

Return the inverse tangent of an image in degrees.



1281
1282
1283
 
# File 'lib/vips/image.rb', line 1281

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




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

#avg(**opts) ⇒ Float

Find image average.




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

#bandand ⇒ Image

AND the bands of an image together



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

def bandand
  bandbool :and
end

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

Boolean operation across image bands.




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

#bandeor ⇒ Image

EOR the bands of an image together



1100
1101
1102
 
# File 'lib/vips/image.rb', line 1100

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 469

#bandjoin(other) ⇒ Image

Join a set of images bandwise.



1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
 
# File 'lib/vips/image.rb', line 1115

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 407

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

Band-wise average.




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

#bandor ⇒ Image

OR the bands of an image together



1093
1094
1095
 
# File 'lib/vips/image.rb', line 1093

def bandor
  bandbool :or
end

#bands ⇒ Integer

Get number of image bands.



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

def bands
  get "bands"
end

#bandsplit ⇒ Array<Image>

Split an n-band image into n separate images.



1107
1108
1109
 
# File 'lib/vips/image.rb', line 1107

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 475

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

Boolean operation on two images.




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

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

Boolean operations against a constant.




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

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

Build a look-up table.




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

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

Byteswap an image.




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

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

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

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

#ceil ⇒ Image

Return the smallest integral value not less than the argument.



1072
1073
1074
 
# File 'lib/vips/image.rb', line 1072

def ceil
  round :ceil
end

#close ⇒ Object 



74
75
76
 
# File 'lib/vips/image.rb', line 74

def close
  Vips.vips_image_invalidate_all(self)
end

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

Transform lch to cmc.




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

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

Transform cmyk to xyz.




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

#coding ⇒ Symbol

Get image coding.



726
727
728
 
# File 'lib/vips/image.rb', line 726

def coding
  get "coding"
end

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

Convert to a new colorspace.

Options Hash (**opts):




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

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

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

Perform a complex operation on an image.




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

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

Complex binary operations on two images.




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

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

Form a complex image from two real images.




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

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

Get a component from a complex image.




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

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

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



1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
 
# File 'lib/vips/image.rb', line 1138

def composite overlay, mode, **options
  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, **options)
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 558

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



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

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 2013

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

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

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

Float convolution operation.




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

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

Int convolution operation.




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

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

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

Copy an image.

Options Hash (**opts):

  • :width (Integer) —

    Image width in pixels

  • :height (Integer) —

    Image height in pixels

  • :bands (Integer) —

    Number of bands in image

  • :format (Vips::BandFormat) —

    Pixel format in image

  • :coding (Vips::Coding) —

    Pixel coding

  • :interpretation (Vips::Interpretation) —

    Pixel interpretation

  • :xres (Float) —

    Horizontal resolution in pixels/mm

  • :yres (Float) —

    Vertical resolution in pixels/mm

  • :xoffset (Integer) —

    Horizontal offset of origin

  • :yoffset (Integer) —

    Vertical offset of origin




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

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



820
821
822
823
 
# File 'lib/vips/image.rb', line 820

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.



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

def cos
  math :cos
end

#countlines(direction, **opts) ⇒ Float

Count lines in an image.




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

#cross_phase(other) ⇒ Image

Calculate the cross phase of two images.



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

def cross_phase other
  complex2 other, :cross_phase
end

#csvsave(filename, **opts) ⇒ nil

Save image to csv file.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :separator (String) —

    Separator characters

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

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

Calculate de00.




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

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

Calculate de76.




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

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

Calculate decmc.




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

#deviate(**opts) ⇒ Float

Find image standard deviation.




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

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



1347
1348
1349
 
# File 'lib/vips/image.rb', line 1347

def dilate mask
  morph mask, :dilate
end

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

Divide two images.




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

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

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

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

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

Draw a line on an image.




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

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

Draw a mask on an image.




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

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

Draw a point on an image.

See #draw_rect.



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

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 2174

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

Blur a rectangle on an image.




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

#dzsave(filename, **opts) ⇒ nil

Save image to deepzoom file.

Options Hash (**opts):

  • :basename (String) —

    Base name to save to

  • :layout (Vips::ForeignDzLayout) —

    Directory layout

  • :page_height (Integer) —

    Set page height for multipage save

  • :suffix (String) —

    Filename suffix for tiles

  • :overlap (Integer) —

    Tile overlap in pixels

  • :tile_size (Integer) —

    Tile size in pixels

  • :centre (Boolean) —

    Center image in tile

  • :depth (Vips::ForeignDzDepth) —

    Pyramid depth

  • :angle (Vips::Angle) —

    Rotate image during save

  • :container (Vips::ForeignDzContainer) —

    Pyramid container type

  • :properties (Boolean) —

    Write a properties file to the output directory

  • :compression (Integer) —

    ZIP deflate compression level

  • :region_shrink (Vips::RegionShrink) —

    Method to shrink regions

  • :skip_blanks (Integer) —

    Skip tiles which are nearly equal to the background

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#dzsave_buffer(**opts) ⇒ VipsBlob

Save image to dz buffer.

Options Hash (**opts):

  • :basename (String) —

    Base name to save to

  • :layout (Vips::ForeignDzLayout) —

    Directory layout

  • :page_height (Integer) —

    Set page height for multipage save

  • :suffix (String) —

    Filename suffix for tiles

  • :overlap (Integer) —

    Tile overlap in pixels

  • :tile_size (Integer) —

    Tile size in pixels

  • :centre (Boolean) —

    Center image in tile

  • :depth (Vips::ForeignDzDepth) —

    Pyramid depth

  • :angle (Vips::Angle) —

    Rotate image during save

  • :container (Vips::ForeignDzContainer) —

    Pyramid container type

  • :properties (Boolean) —

    Write a properties file to the output directory

  • :compression (Integer) —

    ZIP deflate compression level

  • :region_shrink (Vips::RegionShrink) —

    Method to shrink regions

  • :skip_blanks (Integer) —

    Skip tiles which are nearly equal to the background

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

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

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



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

def erode mask
  morph mask, :erode
end

#exp ⇒ Image

Return e ** pixel.



1302
1303
1304
 
# File 'lib/vips/image.rb', line 1302

def exp
  math :exp
end

#exp10 ⇒ Image

Return 10 ** pixel.



1309
1310
1311
 
# File 'lib/vips/image.rb', line 1309

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 374

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

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

False-color an image.




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

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

Fast correlation.




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

#filename ⇒ String

Get image filename, if any.



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

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 2168

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

#fitssave(filename, **opts) ⇒ nil

Save image to fits file.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

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

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

Flip an image.




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

#fliphor ⇒ Image

Flip horizontally.



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

def fliphor
  flip :horizontal
end

#flipver ⇒ Image

Flip vertically.



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

def flipver
  flip :vertical
end

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

Transform float rgb to radiance coding.




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

#floor ⇒ Image

Return the largest integral value not greater than the argument.



1065
1066
1067
 
# File 'lib/vips/image.rb', line 1065

def floor
  round :floor
end

#format ⇒ Symbol

Get image format.



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

def format
  get "format"
end

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

Frequency-domain filtering.




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

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

Forward fft.




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

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

Gamma an image.

Options Hash (**opts):

  • :exponent (Float) —

    Gamma factor




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

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

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



592
593
594
595
596
597
598
599
600
601
602
603
604
605
 
# File 'lib/vips/image.rb', line 592

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.



611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
 
# File 'lib/vips/image.rb', line 611

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:



568
569
570
571
572
573
574
575
576
577
 
# File 'lib/vips/image.rb', line 568

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



679
680
681
 
# File 'lib/vips/image.rb', line 679

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 250

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

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

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

Grid an image.




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

#has_alpha? ⇒ Boolean

Detect if image has an alpha channel



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

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

#heifsave(filename, **opts) ⇒ nil

Save image in heif format.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :Q (Integer) —

    Q factor

  • :lossless (Boolean) —

    Enable lossless compression

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#heifsave_buffer(**opts) ⇒ VipsBlob

Save image in heif format.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :Q (Integer) —

    Q factor

  • :lossless (Boolean) —

    Enable lossless compression

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#height ⇒ Integer

Get image height, in pixels.



698
699
700
 
# File 'lib/vips/image.rb', line 698

def height
  get "height"
end

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

Form cumulative histogram.




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

#hist_entropy(**opts) ⇒ Float

Estimate image entropy.




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

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

Histogram equalisation.

Options Hash (**opts):

  • :band (Integer) —

    Equalise with this band




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

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

Find image histogram.

Options Hash (**opts):

  • :band (Integer) —

    Find histogram of band




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

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

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

#hist_ismonotonic(**opts) ⇒ Boolean

Test for monotonicity.




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

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

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

Match two histograms.




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

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

Normalise histogram.




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

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

Plot histogram.




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

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

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

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

Transform hsv to srgb.




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

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

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

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

#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



1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
 
# File 'lib/vips/image.rb', line 1381

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.



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

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 340

#inspect ⇒ Object 



158
159
160
 
# File 'lib/vips/image.rb', line 158

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

#interpretation ⇒ Symbol

Get image interpretation.



719
720
721
 
# File 'lib/vips/image.rb', line 719

def interpretation
  get "interpretation"
end

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

Invert an image.




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

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

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

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

#jpegsave(filename, **opts) ⇒ nil

Save image to jpeg file.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :Q (Integer) —

    Q factor

  • :profile (String) —

    ICC profile to embed

  • :optimize_coding (Boolean) —

    Compute optimal Huffman coding tables

  • :interlace (Boolean) —

    Generate an interlaced (progressive) jpeg

  • :no_subsample (Boolean) —

    Disable chroma subsample

  • :trellis_quant (Boolean) —

    Apply trellis quantisation to each 8x8 block

  • :overshoot_deringing (Boolean) —

    Apply overshooting to samples with extreme values

  • :optimize_scans (Boolean) —

    Split the spectrum of DCT coefficients into separate scans

  • :quant_table (Integer) —

    Use predefined quantization table with given index

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#jpegsave_buffer(**opts) ⇒ VipsBlob

Save image to jpeg buffer.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :Q (Integer) —

    Q factor

  • :profile (String) —

    ICC profile to embed

  • :optimize_coding (Boolean) —

    Compute optimal Huffman coding tables

  • :interlace (Boolean) —

    Generate an interlaced (progressive) jpeg

  • :no_subsample (Boolean) —

    Disable chroma subsample

  • :trellis_quant (Boolean) —

    Apply trellis quantisation to each 8x8 block

  • :overshoot_deringing (Boolean) —

    Apply overshooting to samples with extreme values

  • :optimize_scans (Boolean) —

    Split the spectrum of DCT coefficients into separate scans

  • :quant_table (Integer) —

    Use predefined quantization table with given index

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#jpegsave_mime(**opts) ⇒ nil

Save image to jpeg mime.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :Q (Integer) —

    Q factor

  • :profile (String) —

    ICC profile to embed

  • :optimize_coding (Boolean) —

    Compute optimal Huffman coding tables

  • :interlace (Boolean) —

    Generate an interlaced (progressive) jpeg

  • :no_subsample (Boolean) —

    Disable chroma subsample

  • :trellis_quant (Boolean) —

    Apply trellis quantisation to each 8x8 block

  • :overshoot_deringing (Boolean) —

    Apply overshooting to samples with extreme values

  • :optimize_scans (Boolean) —

    Split the spectrum of DCT coefficients into separate scans

  • :quant_table (Integer) —

    Use predefined quantization table with given index

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

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

Transform float lab to labq coding.




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

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

Transform float lab to signed short.




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

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

Transform lab to lch.




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

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

Transform cielab to xyz.

Options Hash (**opts):

  • :temp (Array<Double>) —

    Color temperature




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

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

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

Unpack a labq image to float lab.




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

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

Unpack a labq image to short lab.




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

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

Convert a labq image to srgb.




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

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

Transform signed short lab to float.




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

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

Transform short lab to labq coding.




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

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

Transform lch to cmc.




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

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

Transform lch to lab.




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

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

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

#log ⇒ Image

Return the natural log of an image.



1288
1289
1290
 
# File 'lib/vips/image.rb', line 1288

def log
  math :log
end

#log10 ⇒ Image

Return the log base 10 of an image.



1295
1296
1297
 
# File 'lib/vips/image.rb', line 1295

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

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#magicksave_buffer(**opts) ⇒ VipsBlob

Save image to magick buffer.

Options Hash (**opts):

  • :format (String) —

    Format to save in

  • :quality (Integer) —

    Quality to use

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

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

Resample with a map image.

Options Hash (**opts):




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

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

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

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

Apply a math operation to an image.




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

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

Binary math operations.




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

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

Binary math operations with a constant.




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

#matrixprint(**opts) ⇒ nil

Print matrix.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#matrixsave(filename, **opts) ⇒ nil

Save image to matrix file.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

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

#maxpos ⇒ Real

Return the coordinates of the image maximum.



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

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

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

Measure a set of patches on a color chart.

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 239

#median(size = 3) ⇒ Image

a median filter



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

def median size = 3
  rank size, size, (size * size) / 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 2246

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

#minpos ⇒ Real

Return the coordinates of the image minimum.



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

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

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

Morphology operation.




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

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

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

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

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

Multiply two images.




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

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



403
404
405
406
407
408
 
# File 'lib/vips/image.rb', line 403

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

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#offset ⇒ Float

Get offset metadata.



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

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

  get "offset"
end

#parent_get_typeof ⇒ Object 



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

alias_method :parent_get_typeof, :get_typeof

#percent(percent, **opts) ⇒ Integer

Find threshold for percent of pixels.




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

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

Calculate phase correlation.




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

#pngsave(filename, **opts) ⇒ nil

Save image to png file.

Options Hash (**opts):

  • :compression (Integer) —

    Compression factor

  • :interlace (Boolean) —

    Interlace image

  • :page_height (Integer) —

    Set page height for multipage save

  • :profile (String) —

    ICC profile to embed

  • :filter (Vips::ForeignPngFilter) —

    libpng row filter flag(s)

  • :palette (Boolean) —

    Quantise to 8bpp palette

  • :colours (Integer) —

    Max number of palette colours

  • :Q (Integer) —

    Quantisation quality

  • :dither (Float) —

    Amount of dithering

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#pngsave_buffer(**opts) ⇒ VipsBlob

Save image to png buffer.

Options Hash (**opts):

  • :compression (Integer) —

    Compression factor

  • :interlace (Boolean) —

    Interlace image

  • :page_height (Integer) —

    Set page height for multipage save

  • :profile (String) —

    ICC profile to embed

  • :filter (Vips::ForeignPngFilter) —

    libpng row filter flag(s)

  • :palette (Boolean) —

    Quantise to 8bpp palette

  • :colours (Integer) —

    Max number of palette colours

  • :Q (Integer) —

    Quantisation quality

  • :dither (Float) —

    Amount of dithering

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

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



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

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

#ppmsave(filename, **opts) ⇒ nil

Save image to ppm file.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :ascii (Boolean) —

    save as ascii

  • :squash (Boolean) —

    save as one bit

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

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

Premultiply image alpha.

Options Hash (**opts):

  • :max_alpha (Float) —

    Maximum value of alpha channel




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

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

Find image profiles.




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

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

Find image projections.




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

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

Resample an image with a quadratic transform.

Options Hash (**opts):




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

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

Unpack radiance coding to float rgb.




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

#radsave(filename, **opts) ⇒ nil

Save image to radiance file.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#radsave_buffer(**opts) ⇒ VipsBlob

Save image to radiance buffer.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

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

Rank filter.




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

#rawsave(filename, **opts) ⇒ nil

Save image to raw file.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#rawsave_fd(fd, **opts) ⇒ nil

Write raw image to file descriptor.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#real ⇒ Image

Return the real part of a complex image.



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

def real
  complexget :real
end

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

Linear recombination with matrix.




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

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



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

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




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

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

Shrink an image horizontally.

Options Hash (**opts):

  • :kernel (Vips::Kernel) —

    Resampling kernel

  • :centre (Boolean) —

    Use centre sampling convention




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

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

Shrink an image vertically.

Options Hash (**opts):

  • :kernel (Vips::Kernel) —

    Resampling kernel

  • :centre (Boolean) —

    Use centre sampling convention




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

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

Relational operation on two images.




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

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

Relational operations against a constant.




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

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

Remainder after integer division of two images.




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

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

Remainder after integer division of an image and a constant.




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

#remove(name) ⇒ Object

Remove a metadata item from an image.



674
675
676
 
# File 'lib/vips/image.rb', line 674

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 431

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

Resize an image.

Options Hash (**opts):

  • :kernel (Vips::Kernel) —

    Resampling kernel

  • :vscale (Float) —

    Vertical scale image by this factor




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

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



162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/vips/image.rb', line 162

def respond_to? name, include_all = false
  # To support keyword args, we need to tell Ruby that final image
  # arguments cannot be hashes of keywords.
  #
  # https://makandracards.com/makandra/
  #   36013-heads-up-ruby-implicitly-converts-a-hash-to-keyword-arguments
  return false if name == :to_hash

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

  super
end

#rint ⇒ Image

Return the nearest integral value.



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

def rint
  round :rint
end

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

Rotate an image.




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

#rot180 ⇒ Image

Rotate by 180 degrees clockwise.



1361
1362
1363
 
# File 'lib/vips/image.rb', line 1361

def rot180
  rot :d180
end

#rot270 ⇒ Image

Rotate by 270 degrees clockwise.



1368
1369
1370
 
# File 'lib/vips/image.rb', line 1368

def rot270
  rot :d270
end

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

Rotate an image.

Options Hash (**opts):




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

#rot90 ⇒ Image

Rotate by 90 degrees clockwise.



1354
1355
1356
 
# File 'lib/vips/image.rb', line 1354

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 1730

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

Perform a round function on an image.




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

#scale ⇒ Float

Get scale metadata.



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

def scale
  return 1 if get_typeof("scale") == 0

  get "scale"
end

#scaleimage(**options) ⇒ Vips::Image

Scale an image to uchar. This is the vips scale operation, but renamed to avoid a clash with the .scale property.



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

def scaleimage **options
  Vips::Image.scale self, **options
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 1916

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

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

Transform scrgb to xyz.




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

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

Check sequential access.

Options Hash (**opts):

  • :tile_height (Integer) —

    Tile height in pixels




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

#set(name, value) ⇒ Object

Set the value of a metadata item on an image. The metadata item must already exist. Ruby types are automatically transformed into the matching GValue, if possible.

For example, you can use this to set an image's ICC profile:

x = y.set "icc-profile-data", profile

where profile is an ICC profile held as a binary string object.

See Also:



667
668
669
 
# File 'lib/vips/image.rb', line 667

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:



558
559
560
 
# File 'lib/vips/image.rb', line 558

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:



547
548
549
 
# File 'lib/vips/image.rb', line 547

def set_progress state
  Vips::vips_image_set_progress self, state
end

#set_type(gtype, name, value) ⇒ Object

Create a metadata item on an image of the specifed type. Ruby types are automatically transformed into the matching GType, if possible.

For example, you can use this to set an image's ICC profile:

x = y.set_type Vips::BLOB_TYPE, "icc-profile-data", profile

where profile is an ICC profile held as a binary string object.

See Also:



644
645
646
647
648
649
650
 
# File 'lib/vips/image.rb', line 644

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

compatibility: old name for set



684
685
686
 
# File 'lib/vips/image.rb', line 684

def set_value name, value
  set name, value
end

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

Unsharp masking for print.

Options Hash (**opts):

  • :sigma (Float) —

    Sigma of Gaussian

  • :x1 (Float) —

    Flat/jaggy threshold

  • :y2 (Float) —

    Maximum brightening

  • :y3 (Float) —

    Maximum darkening

  • :m1 (Float) —

    Slope for flat areas

  • :m2 (Float) —

    Slope for jaggy areas




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

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

Shrink an image.




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

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

Shrink an image horizontally.




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

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

Shrink an image vertically.




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

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

Unit vector of pixel.




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

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

#sin ⇒ Image

Return the sine of an image in degrees.



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

def sin
  math :sin
end

#size ⇒ Integer

Get the image size.



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

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 392

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

Sobel edge detector.




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

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

Spatial correlation.




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

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

Make displayable power spectrum.




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

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

Transform srgb to hsv.




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

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

Convert an srgb image to scrgb.




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

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

Find many image stats.




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

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

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

Subsample an image.

Options Hash (**opts):

  • :point (Boolean) —

    Point sample




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

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

Subtract two images.




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

#tan ⇒ Image

Return the tangent of an image in degrees.



1260
1261
1262
 
# File 'lib/vips/image.rb', line 1260

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




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

#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

  • :page_height (Integer) —

    Set page height for multipage save

  • :profile (String) —

    ICC profile to embed

  • :tile (Boolean) —

    Write a tiled tiff

  • :tile_width (Integer) —

    Tile width in pixels

  • :tile_height (Integer) —

    Tile height in pixels

  • :pyramid (Boolean) —

    Write a pyramidal tiff

  • :miniswhite (Boolean) —

    Use 0 for white in 1-bit images

  • :squash (Boolean) —

    Squash images down to 1 bit

  • :resunit (Vips::ForeignTiffResunit) —

    Resolution unit

  • :xres (Float) —

    Horizontal resolution in pixels/mm

  • :yres (Float) —

    Vertical resolution in pixels/mm

  • :bigtiff (Boolean) —

    Write a bigtiff image

  • :properties (Boolean) —

    Write a properties document to IMAGEDESCRIPTION

  • :region_shrink (Vips::RegionShrink) —

    Method to shrink regions

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#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

  • :page_height (Integer) —

    Set page height for multipage save

  • :profile (String) —

    ICC profile to embed

  • :tile (Boolean) —

    Write a tiled tiff

  • :tile_width (Integer) —

    Tile width in pixels

  • :tile_height (Integer) —

    Tile height in pixels

  • :pyramid (Boolean) —

    Write a pyramidal tiff

  • :miniswhite (Boolean) —

    Use 0 for white in 1-bit images

  • :squash (Boolean) —

    Squash images down to 1 bit

  • :resunit (Vips::ForeignTiffResunit) —

    Resolution unit

  • :xres (Float) —

    Horizontal resolution in pixels/mm

  • :yres (Float) —

    Vertical resolution in pixels/mm

  • :bigtiff (Boolean) —

    Write a bigtiff image

  • :properties (Boolean) —

    Write a properties document to IMAGEDESCRIPTION

  • :region_shrink (Vips::RegionShrink) —

    Method to shrink regions

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

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

#to_a ⇒ Array

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



1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
 
# File 'lib/vips/image.rb', line 1031

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

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

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

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

  # build rows
  row_array = pixel_array.each_slice(width).to_a

  return row_array
end

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

Transpose3d an image.

Options Hash (**opts):

  • :page_height (Integer) —

    Height of each input page




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

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

Unpremultiply image alpha.

Options Hash (**opts):

  • :max_alpha (Float) —

    Maximum value of alpha channel




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

#vipssave(filename, **opts) ⇒ nil

Save image to vips file.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#webpsave(filename, **opts) ⇒ nil

Save image to webp file.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :Q (Integer) —

    Q factor

  • :lossless (Boolean) —

    enable lossless compression

  • :preset (Vips::ForeignWebpPreset) —

    Preset for lossy compression

  • :smart_subsample (Boolean) —

    Enable high quality chroma subsampling

  • :near_lossless (Boolean) —

    Enable preprocessing in lossless mode (uses Q)

  • :alpha_q (Integer) —

    Change alpha plane fidelity for lossy compression

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

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#webpsave_buffer(**opts) ⇒ VipsBlob

Save image to webp buffer.

Options Hash (**opts):

  • :page_height (Integer) —

    Set page height for multipage save

  • :Q (Integer) —

    Q factor

  • :lossless (Boolean) —

    enable lossless compression

  • :preset (Vips::ForeignWebpPreset) —

    Preset for lossy compression

  • :smart_subsample (Boolean) —

    Enable high quality chroma subsampling

  • :near_lossless (Boolean) —

    Enable preprocessing in lossless mode (uses Q)

  • :alpha_q (Integer) —

    Change alpha plane fidelity for lossy compression

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

  • :strip (Boolean) —

    Strip all metadata from image

  • :background (Array<Double>) —

    Background value




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

#width ⇒ Integer

Get image width, in pixels.



691
692
693
 
# File 'lib/vips/image.rb', line 691

def width
  get "width"
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 514

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



475
476
477
478
479
480
481
482
483
484
485
486
487
 
# File 'lib/vips/image.rb', line 475

def write_to_buffer format_string, **opts
  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
  if saver == nil
    raise Vips::Error, "No known buffer saver for '#{filename}'."
  end

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

  return buffer
end

#write_to_file(name, **opts) ⇒ Object

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

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

or equivalently:

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

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

$ vips jpegsave

to see all the available options for JPEG save.

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



439
440
441
442
443
444
445
446
447
448
 
# File 'lib/vips/image.rb', line 439

def write_to_file name, **opts
  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
  if saver == nil
    raise Vips::Error, "No known saver for '#{filename}'."
  end

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

#write_to_memory ⇒ String

Write this image to a large memory buffer.

Raises:



529
530
531
532
533
534
535
536
537
538
 
# File 'lib/vips/image.rb', line 529

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



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

def write_to_target target, format_string, **opts
  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
  if saver == nil
    raise Vips::Error, "No known target saver for '#{filename}'."
  end

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

#xoffset ⇒ Integer

Get image xoffset.



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

def xoffset
  get "xoffset"
end

#xres ⇒ Float

Get image x resolution.



754
755
756
 
# File 'lib/vips/image.rb', line 754

def xres
  get "xres"
end

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

Transform xyz to cmyk.




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

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

Transform xyz to lab.

Options Hash (**opts):

  • :temp (Array<Double>) —

    Colour temperature




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

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

Transform xyz to scrgb.




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

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

Transform xyz to yxy.




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

#yoffset ⇒ Integer

Get image yoffset.



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

def yoffset
  get "yoffset"
end

#yres ⇒ Float

Get image y resolution.



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

def yres
  get "yres"
end

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

Transform yxy to xyz.




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

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

Zoom an image.




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

#|(other) ⇒ Image

Integer bitwise OR with an image, constant or array.



907
908
909
 
# File 'lib/vips/image.rb', line 907

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

#~ ⇒ Image

Equivalent to image ^ -1



937
938
939
 
# File 'lib/vips/image.rb', line 937

def ~
  self ^ -1
end