Class: Vips::Image

Inherits:

Object

Object
GObject::GObject
Object
Vips::Image

show all

Defined in:: lib/vips/image.rb,
lib/vips/methods.rb

Overview

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

Defined Under Namespace

Modules: ImageLayout Classes: GenericPtr, ManagedStruct, Struct

Instance Attribute Summary

Attributes inherited from GObject::GObject

#ptr, #references

Class Method Summary collapse

.analyzeload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load an analyze6 image.
.arrayjoin(im, **opts) ⇒ Vips::Image
Join an array of images.
.bandrank(im, **opts) ⇒ Vips::Image
Band-wise rank of a set of images.
.black(width, height, **opts) ⇒ Vips::Image
Make a black image.
.complex?(format) ⇒ Boolean
.csvload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load csv.
.csvload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load csv.
.dcrawload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load raw camera files.
.dcrawload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load raw camera files.
.dcrawload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load raw camera files.
.eye(width, height, **opts) ⇒ Vips::Image
Make an image showing the eye's spatial response.
.fitsload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load a fits image.
.fitsload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load fits from a source.
.float?(format) ⇒ Boolean
.fractsurf(width, height, fractal_dimension, **opts) ⇒ Vips::Image
Make a fractal surface.
.gaussmat(sigma, min_ampl, **opts) ⇒ Vips::Image
Make a gaussian image.
.gaussnoise(width, height, **opts) ⇒ Vips::Image
Make a gaussnoise image.
.gifload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load gif with libnsgif.
.gifload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load gif with libnsgif.
.gifload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load gif from source.
.grey(width, height, **opts) ⇒ Vips::Image
Make a grey ramp image.
.heifload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load a heif image.
.heifload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load a heif image.
.heifload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load a heif image.
.identity(**opts) ⇒ Vips::Image
Make a 1d image where pixel values are indexes.
.jp2kload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load jpeg2000 image.
.jp2kload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load jpeg2000 image.
.jp2kload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load jpeg2000 image.
.jpegload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load jpeg from file.
.jpegload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load jpeg from buffer.
.jpegload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load image from jpeg source.
.jxlload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load jpeg-xl image.
.jxlload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load jpeg-xl image.
.jxlload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load jpeg-xl image.
.logmat(sigma, min_ampl, **opts) ⇒ Vips::Image
Make a laplacian of gaussian image.
.magickload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load file with imagemagick7.
.magickload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load buffer with imagemagick7.
.magickload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load source with imagemagick7.
.mask_butterworth(width, height, order, frequency_cutoff, amplitude_cutoff, **opts) ⇒ Vips::Image
Make a butterworth filter.
.mask_butterworth_band(width, height, order, frequency_cutoff_x, frequency_cutoff_y, radius, amplitude_cutoff, **opts) ⇒ Vips::Image
Make a butterworth_band filter.
.mask_butterworth_ring(width, height, order, frequency_cutoff, amplitude_cutoff, ringwidth, **opts) ⇒ Vips::Image
Make a butterworth ring filter.
.mask_fractal(width, height, fractal_dimension, **opts) ⇒ Vips::Image
Make fractal filter.
.mask_gaussian(width, height, frequency_cutoff, amplitude_cutoff, **opts) ⇒ Vips::Image
Make a gaussian filter.
.mask_gaussian_band(width, height, frequency_cutoff_x, frequency_cutoff_y, radius, amplitude_cutoff, **opts) ⇒ Vips::Image
Make a gaussian filter.
.mask_gaussian_ring(width, height, frequency_cutoff, amplitude_cutoff, ringwidth, **opts) ⇒ Vips::Image
Make a gaussian ring filter.
.mask_ideal(width, height, frequency_cutoff, **opts) ⇒ Vips::Image
Make an ideal filter.
.mask_ideal_band(width, height, frequency_cutoff_x, frequency_cutoff_y, radius, **opts) ⇒ Vips::Image
Make an ideal band filter.
.mask_ideal_ring(width, height, frequency_cutoff, ringwidth, **opts) ⇒ Vips::Image
Make an ideal ring filter.
.matload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load mat from file.
.matrix_from_array(width, height, array) ⇒ Object
.matrixload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load matrix.
.matrixload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load matrix.
.method_missing(name, *args, **options) ⇒ Object
Invoke a vips operation with Operation.call.
.new_from_array(array, scale = 1, offset = 0) ⇒ Image
Create a new Image from a 1D or 2D array.
.new_from_buffer(data, option_string, **opts) ⇒ Image
Create a new Image for an image encoded in a format such as JPEG in a binary string.
.new_from_file(name, **opts) ⇒ Image
Return a new Image for a file on disc.
.new_from_memory(data, width, height, bands, format) ⇒ Image
Create a new Image from a C-style array held in memory.
.new_from_memory_copy(data, width, height, bands, format) ⇒ Image
Create a new Image from memory and copies the memory area.
.new_from_source(source, option_string, **opts) ⇒ Image
Create a new Image from a source.
.openexrload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load an openexr image.
.openslideload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load file with openslide.
.openslideload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load source with openslide.
.pdfload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load pdf from file (poppler).
.pdfload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load pdf from buffer (poppler).
.pdfload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load pdf from source (poppler).
.perlin(width, height, **opts) ⇒ Vips::Image
Make a perlin noise image.
.pngload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load png from file.
.pngload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load png from buffer.
.pngload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load png from source.
.ppmload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load ppm from file.
.ppmload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load ppm from buffer.
.ppmload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load ppm from source.
.profile_load(name, **opts) ⇒ VipsBlob
Load named icc profile.
.radload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load a radiance image from a file.
.radload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load rad from buffer.
.radload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load rad from source.
.rawload(filename, width, height, bands, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load raw data from a file.
.respond_to_missing?(name, include_all = false) ⇒ Boolean
.run_cmplx(image, &block) ⇒ Object
run a complex operation on a complex image, or an image with an even number of bands ...
.sdf(width, height, shape, **opts) ⇒ Vips::Image
Create an sdf image.
.sines(width, height, **opts) ⇒ Vips::Image
Make a 2d sine wave.
.smap(x, &block) ⇒ Object
handy for overloads ...
.sum(im, **opts) ⇒ Vips::Image
Sum an array of images.
.svgload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load svg with rsvg.
.svgload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load svg with rsvg.
.svgload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load svg from source.
.switch(tests, **opts) ⇒ Vips::Image
Find the index of the first non-zero pixel in tests.
.system(cmd_format, **opts) ⇒ nil, Hash<Symbol => Object>
Run an external command.
.text(text, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Make a text image.
.thumbnail(filename, width, **opts) ⇒ Vips::Image
Generate thumbnail from file.
.thumbnail_buffer(buffer, width, **opts) ⇒ Vips::Image
Generate thumbnail from buffer.
.thumbnail_source(source, width, **opts) ⇒ Vips::Image
Generate thumbnail from source.
.tiffload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load tiff from file.
.tiffload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load tiff from buffer.
.tiffload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load tiff from source.
.tonelut(**opts) ⇒ Vips::Image
Build a look-up table.
.uhdrload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load a uhdr image.
.uhdrload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load a uhdr image.
.uhdrload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load a uhdr image.
.vipsload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load vips from file.
.vipsload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load vips from source.
.webpload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load webp from file.
.webpload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load webp from buffer.
.webpload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Load webp from source.
.worley(width, height, **opts) ⇒ Vips::Image
Make a worley noise image.
.xyz(width, height, **opts) ⇒ Vips::Image
Make an image where pixel values are coordinates.
.zone(width, height, **opts) ⇒ Vips::Image
Make a zone plate.

Instance Method Summary collapse

#! ⇒ Image
Equivalent to image ^ -1.
#!=(other) ⇒ Image
Compare inequality to nil, an image, constant or array.
#%(other) ⇒ Image
Remainder after integer division with an image, constant or array.
#&(other) ⇒ Image
Integer bitwise AND with an image, constant or array.
#*(other) ⇒ Image
Multiply an image, constant or array.
#**(other) ⇒ Image
Raise to power of an image, constant or array.
#+(other) ⇒ Image
Add an image, constant or array.
#+@ ⇒ Image
Image.
#-(other) ⇒ Image
Subtract an image, constant or array.
#-@ ⇒ Image
Equivalent to image * -1.
#/(other) ⇒ Image
Divide an image, constant or array.
#<(other) ⇒ Image
Relational less than with an image, constant or array.
#<<(other) ⇒ Image
Integer left shift with an image, constant or array.
#<=(other) ⇒ Image
Relational less than or equal to with an image, constant or array.
#==(other) ⇒ Image
Compare equality to nil, an image, constant or array.
#>(other) ⇒ Image
Relational more than with an image, constant or array.
#>=(other) ⇒ Image
Relational more than or equal to with an image, constant or array.
#>>(other) ⇒ Image
Integer right shift with an image, constant or array.
#[](index) ⇒ Image
Fetch bands using a number or a range.
#^(other) ⇒ Image
Integer bitwise EOR with an image, constant or array.
#abs(**opts) ⇒ Vips::Image
Absolute value of an image.
#acos ⇒ Image
Return the inverse cosine of an image in degrees.
#acosh ⇒ Image
Return the inverse hyperbolic cosine of an image in radians.
#add(right, **opts) ⇒ Vips::Image
Add two images.
#add_alpha ⇒ Image
Append an alpha channel to an image.
#addalpha(**opts) ⇒ Vips::Image
Append an alpha channel.
#affine(matrix, **opts) ⇒ Vips::Image
Affine transform of an image.
#asin ⇒ Image
Return the inverse sine of an image in degrees.
#asinh ⇒ Image
Return the inverse hyperbolic sine of an image in radians.
#atan ⇒ Image
Return the inverse tangent of an image in degrees.
#atanh ⇒ Image
Return the inverse hyperbolic tangent of an image in radians.
#autorot(**opts) ⇒ Vips::Image, Hash<Symbol => Object>
Autorotate image by exif tag.
#avg(**opts) ⇒ Float
Find image average.
#bandand ⇒ Image
AND the bands of an image together.
#bandbool(boolean, **opts) ⇒ Vips::Image
Boolean operation across image bands.
#bandeor ⇒ Image
EOR the bands of an image together.
#bandfold(**opts) ⇒ Vips::Image
Fold up x axis into bands.
#bandjoin(other) ⇒ Image
Join a set of images bandwise.
#bandjoin_const(c, **opts) ⇒ Vips::Image
Append a constant band to an image.
#bandmean(**opts) ⇒ Vips::Image
Band-wise average.
#bandor ⇒ Image
OR the bands of an image together.
#bands ⇒ Integer
Get number of image bands.
#bandsplit ⇒ Array<Image>
Split an n-band image into n separate images.
#bandunfold(**opts) ⇒ Vips::Image
Unfold image bands into x axis.
#boolean(right, boolean, **opts) ⇒ Vips::Image
Boolean operation on two images.
#boolean_const(boolean, c, **opts) ⇒ Vips::Image
Boolean operations against a constant.
#buildlut(**opts) ⇒ Vips::Image
Build a look-up table.
#byteswap(**opts) ⇒ Vips::Image
Byteswap an image.
#canny(**opts) ⇒ Vips::Image
Canny edge detector.
#case(cases, **opts) ⇒ Vips::Image
Use pixel values to pick cases from an array of images.
#cast(format, **opts) ⇒ Vips::Image
Cast an image.
#ceil ⇒ Image
Return the smallest integral value not less than the argument.
#clamp(**opts) ⇒ Vips::Image
Clamp values of an image.
#CMC2LCh(**opts) ⇒ Vips::Image
Transform lch to cmc.
#CMYK2XYZ(**opts) ⇒ Vips::Image
Transform cmyk to xyz.
#coding ⇒ Symbol
Get image coding.
#colourspace(space, **opts) ⇒ Vips::Image
Convert to a new colorspace.
#compass(mask, **opts) ⇒ Vips::Image
Convolve with rotating mask.
#complex(cmplx, **opts) ⇒ Vips::Image
Perform a complex operation on an image.
#complex2(right, cmplx, **opts) ⇒ Vips::Image
Complex binary operations on two images.
#complexform(right, **opts) ⇒ Vips::Image
Form a complex image from two real images.
#complexget(get, **opts) ⇒ Vips::Image
Get a component from a complex image.
#composite(overlay, mode, **opts) ⇒ Image
Composite a set of images with a set of blend modes.
#composite2(overlay, mode, **opts) ⇒ Vips::Image
Blend a pair of images with a blend mode.
#conj ⇒ Image
Return the complex conjugate of an image.
#conv(mask, **opts) ⇒ Vips::Image
Convolution operation.
#conva(mask, **opts) ⇒ Vips::Image
Approximate integer convolution.
#convasep(mask, **opts) ⇒ Vips::Image
Approximate separable integer convolution.
#convf(mask, **opts) ⇒ Vips::Image
Float convolution operation.
#convi(mask, **opts) ⇒ Vips::Image
Int convolution operation.
#convsep(mask, **opts) ⇒ Vips::Image
Separable convolution operation.
#copy(**opts) ⇒ Vips::Image
Copy an image.
#copy_memory ⇒ Image
Copy an image to a memory area.
#cos ⇒ Image
Return the cosine of an image in degrees.
#cosh ⇒ Image
Return the hyperbolic cosine of an image in radians.
#countlines(direction, **opts) ⇒ Float
Count lines in an image.
#crop(left, top, width, height, **opts) ⇒ Vips::Image
Extract an area from an image.
#cross_phase(other) ⇒ Image
Calculate the cross phase of two images.
#csvsave(filename, **opts) ⇒ nil
Save image to csv.
#csvsave_target(target, **opts) ⇒ nil
Save image to csv.
#dE00(right, **opts) ⇒ Vips::Image
Calculate de00.
#dE76(right, **opts) ⇒ Vips::Image
Calculate de76.
#dECMC(right, **opts) ⇒ Vips::Image
Calculate decmc.
#deviate(**opts) ⇒ Float
Find image standard deviation.
#dilate(mask) ⇒ Image
Dilate with a structuring element.
#divide(right, **opts) ⇒ Vips::Image
Divide two images.
#draw_circle(ink, cx, cy, radius, **opts) ⇒ Vips::Image
Draw a circle on an image.
#draw_flood(ink, x, y, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Flood-fill an area.
#draw_image(sub, x, y, **opts) ⇒ Vips::Image
Paint an image into another image.
#draw_line(ink, x1, y1, x2, y2, **opts) ⇒ Vips::Image
Draw a line on an image.
#draw_mask(ink, mask, x, y, **opts) ⇒ Vips::Image
Draw a mask on an image.
#draw_point(ink, left, top, **opts) ⇒ Image
Draw a point on an image.
#draw_rect(ink, left, top, width, height, **opts) ⇒ Vips::Image
Paint a rectangle on an image.
#draw_smudge(left, top, width, height, **opts) ⇒ Vips::Image
Blur a rectangle on an image.
#dzsave(filename, **opts) ⇒ nil
Save image to deepzoom file.
#dzsave_buffer(**opts) ⇒ VipsBlob
Save image to dz buffer.
#dzsave_target(target, **opts) ⇒ nil
Save image to deepzoom target.
#embed(x, y, width, height, **opts) ⇒ Vips::Image
Embed an image in a larger image.
#erode(mask) ⇒ Image
Erode with a structuring element.
#exp ⇒ Image
Return e ** pixel.
#exp10 ⇒ Image
Return 10 ** pixel.
#extract_area(left, top, width, height, **opts) ⇒ Vips::Image
Extract an area from an image.
#extract_band(band, **opts) ⇒ Vips::Image
Extract band from an image.
#falsecolour(**opts) ⇒ Vips::Image
False-color an image.
#fastcor(ref, **opts) ⇒ Vips::Image
Fast correlation.
#filename ⇒ String
Get image filename, if any.
#fill_nearest(**opts) ⇒ Vips::Image, Hash<Symbol => Object>
Fill image zeros with nearest non-zero pixel.
#find_trim(**opts) ⇒ Array<Integer, Integer, Integer, Integer>
Search an image for non-edge areas.
#fitssave(filename, **opts) ⇒ nil
Save image to fits file.
#flatten(**opts) ⇒ Vips::Image
Flatten alpha out of an image.
#flip(direction, **opts) ⇒ Vips::Image
Flip an image.
#fliphor ⇒ Image
Flip horizontally.
#flipver ⇒ Image
Flip vertically.
#float2rad(**opts) ⇒ Vips::Image
Transform float rgb to radiance coding.
#floor ⇒ Image
Return the largest integral value not greater than the argument.
#format ⇒ Symbol
Get image format.
#freqmult(mask, **opts) ⇒ Vips::Image
Frequency-domain filtering.
#fwfft(**opts) ⇒ Vips::Image
Forward fft.
#gamma(**opts) ⇒ Vips::Image
Gamma an image.
#gaussblur(sigma, **opts) ⇒ Vips::Image
Gaussian blur.
#get(name) ⇒ Object
Get a metadata item from an image.
#get_fields ⇒ [String]
Get the names of all fields on an image.
#get_gainmap ⇒ Image
Get the gainmap (if any) from an image.
#get_typeof(name) ⇒ Integer
Get the GType of a metadata field.
#get_value(name) ⇒ Object
compatibility: old name for get.
#getpoint(x, y, **opts) ⇒ Array<Double>
Read a point from an image.
#gifsave(filename, **opts) ⇒ nil
Save as gif.
#gifsave_buffer(**opts) ⇒ VipsBlob
Save as gif.
#gifsave_target(target, **opts) ⇒ nil
Save as gif.
#globalbalance(**opts) ⇒ Vips::Image
Global balance an image mosaic.
#gravity(direction, width, height, **opts) ⇒ Vips::Image
Place an image within a larger image with a certain gravity.
#grid(tile_height, across, down, **opts) ⇒ Vips::Image
Grid an image.
#has_alpha? ⇒ Boolean
Detect if image has an alpha channel.
#heifsave(filename, **opts) ⇒ nil
Save image in heif format.
#heifsave_buffer(**opts) ⇒ VipsBlob
Save image in heif format.
#heifsave_target(target, **opts) ⇒ nil
Save image in heif format.
#height ⇒ Integer
Get image height, in pixels.
#hist_cum(**opts) ⇒ Vips::Image
Form cumulative histogram.
#hist_entropy(**opts) ⇒ Float
Estimate image entropy.
#hist_equal(**opts) ⇒ Vips::Image
Histogram equalisation.
#hist_find(**opts) ⇒ Vips::Image
Find image histogram.
#hist_find_indexed(index, **opts) ⇒ Vips::Image
Find indexed image histogram.
#hist_find_ndim(**opts) ⇒ Vips::Image
Find n-dimensional image histogram.
#hist_ismonotonic(**opts) ⇒ Boolean
Test for monotonicity.
#hist_local(width, height, **opts) ⇒ Vips::Image
Local histogram equalisation.
#hist_match(ref, **opts) ⇒ Vips::Image
Match two histograms.
#hist_norm(**opts) ⇒ Vips::Image
Normalise histogram.
#hist_plot(**opts) ⇒ Vips::Image
Plot histogram.
#hough_circle(**opts) ⇒ Vips::Image
Find hough circle transform.
#hough_line(**opts) ⇒ Vips::Image
Find hough line transform.
#HSV2sRGB(**opts) ⇒ Vips::Image
Transform hsv to srgb.
#icc_export(**opts) ⇒ Vips::Image
Output to device with icc profile.
#icc_import(**opts) ⇒ Vips::Image
Import from device with icc profile.
#icc_transform(output_profile, **opts) ⇒ Vips::Image
Transform between devices with icc profiles.
#ifthenelse(th, el, **opts) ⇒ Image
Select pixels from th if self is non-zero and from el if self is zero.
#imag ⇒ Image
Return the imaginary part of a complex image.
#insert(sub, x, y, **opts) ⇒ Vips::Image
Insert image @sub into @main at @x, @y.
#inspect ⇒ Object
#interpretation ⇒ Symbol
Get image interpretation.
#invert(**opts) ⇒ Vips::Image
Invert an image.
#invertlut(**opts) ⇒ Vips::Image
Build an inverted look-up table.
#invfft(**opts) ⇒ Vips::Image
Inverse fft.
#join(in2, direction, **opts) ⇒ Vips::Image
Join a pair of images.
#jp2ksave(filename, **opts) ⇒ nil
Save image in jpeg2000 format.
#jp2ksave_buffer(**opts) ⇒ VipsBlob
Save image in jpeg2000 format.
#jp2ksave_target(target, **opts) ⇒ nil
Save image in jpeg2000 format.
#jpegsave(filename, **opts) ⇒ nil
Save as jpeg.
#jpegsave_buffer(**opts) ⇒ VipsBlob
Save as jpeg.
#jpegsave_mime(**opts) ⇒ nil
Save image to jpeg mime.
#jpegsave_target(target, **opts) ⇒ nil
Save as jpeg.
#jxlsave(filename, **opts) ⇒ nil
Save image in jpeg-xl format.
#jxlsave_buffer(**opts) ⇒ VipsBlob
Save image in jpeg-xl format.
#jxlsave_target(target, **opts) ⇒ nil
Save image in jpeg-xl format.
#Lab2LabQ(**opts) ⇒ Vips::Image
Transform float lab to labq coding.
#Lab2LabS(**opts) ⇒ Vips::Image
Transform float lab to signed short.
#Lab2LCh(**opts) ⇒ Vips::Image
Transform lab to lch.
#Lab2XYZ(**opts) ⇒ Vips::Image
Transform cielab to xyz.
#labelregions(**opts) ⇒ Vips::Image, Hash<Symbol => Object>
Label regions in an image.
#LabQ2Lab(**opts) ⇒ Vips::Image
Unpack a labq image to float lab.
#LabQ2LabS(**opts) ⇒ Vips::Image
Unpack a labq image to short lab.
#LabQ2sRGB(**opts) ⇒ Vips::Image
Convert a labq image to srgb.
#LabS2Lab(**opts) ⇒ Vips::Image
Transform signed short lab to float.
#LabS2LabQ(**opts) ⇒ Vips::Image
Transform short lab to labq coding.
#LCh2CMC(**opts) ⇒ Vips::Image
Transform lch to cmc.
#LCh2Lab(**opts) ⇒ Vips::Image
Transform lch to lab.
#linear(a, b, **opts) ⇒ Vips::Image
Calculate (a * in + b).
#linecache(**opts) ⇒ Vips::Image
Cache an image as a set of lines.
#log ⇒ Image
Return the natural log of an image.
#log10 ⇒ Image
Return the log base 10 of an image.
#magicksave(filename, **opts) ⇒ nil
Save file with imagemagick.
#magicksave_buffer(**opts) ⇒ VipsBlob
Save image to magick buffer.
#mapim(index, **opts) ⇒ Vips::Image
Resample with a map image.
#maplut(lut, **opts) ⇒ Vips::Image
Map an image though a lut.
#match(sec, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, **opts) ⇒ Vips::Image
First-order match of two images.
#math(math, **opts) ⇒ Vips::Image
Apply a math operation to an image.
#math2(right, math2, **opts) ⇒ Vips::Image
Binary math operations.
#math2_const(math2, c, **opts) ⇒ Vips::Image
Binary math operations with a constant.
#matrixinvert(**opts) ⇒ Vips::Image
Invert a matrix.
#matrixmultiply(right, **opts) ⇒ Vips::Image
Multiply two matrices.
#matrixprint(**opts) ⇒ nil
Print matrix.
#matrixsave(filename, **opts) ⇒ nil
Save image to matrix.
#matrixsave_target(target, **opts) ⇒ nil
Save image to matrix.
#max(**opts) ⇒ Float, Hash<Symbol => Object>
Find image maximum.
#maxpair(right, **opts) ⇒ Vips::Image
Maximum of a pair of images.
#maxpos ⇒ Real
Return the coordinates of the image maximum.
#measure(h, v, **opts) ⇒ Vips::Image
Measure a set of patches on a color chart.
#median(size = 3) ⇒ Image
a median filter.
#merge(sec, direction, dx, dy, **opts) ⇒ Vips::Image
Merge two images.
#method_missing(name, *args, **options) ⇒ Object
Invoke a vips operation with Operation.call, using self as the first input argument.
#min(**opts) ⇒ Float, Hash<Symbol => Object>
Find image minimum.
#minpair(right, **opts) ⇒ Vips::Image
Minimum of a pair of images.
#minpos ⇒ Real
Return the coordinates of the image minimum.
#morph(mask, morph, **opts) ⇒ Vips::Image
Morphology operation.
#mosaic(sec, direction, xref, yref, xsec, ysec, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Mosaic two images.
#mosaic1(sec, direction, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, **opts) ⇒ Vips::Image
First-order mosaic of two images.
#msb(**opts) ⇒ Vips::Image
Pick most-significant byte from an image.
#multiply(right, **opts) ⇒ Vips::Image
Multiply two images.
#mutate {|mutable| ... } ⇒ Object
Mutate an image with a block.
#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.
#offset ⇒ Float
Get offset metadata.
#Oklab2Oklch(**opts) ⇒ Vips::Image
Transform oklab to oklch.
#Oklab2XYZ(**opts) ⇒ Vips::Image
Transform oklab to xyz.
#Oklch2Oklab(**opts) ⇒ Vips::Image
Transform oklch to oklab.
#parent_get_typeof ⇒ Object
#percent(percent, **opts) ⇒ Integer
Find threshold for percent of pixels.
#phasecor(in2, **opts) ⇒ Vips::Image
Calculate phase correlation.
#pngsave(filename, **opts) ⇒ nil
Save image to file as png.
#pngsave_buffer(**opts) ⇒ VipsBlob
Save image to buffer as png.
#pngsave_target(target, **opts) ⇒ nil
Save image to target as png.
#polar ⇒ Image
Return an image with rectangular pixels converted to polar.
#ppmsave(filename, **opts) ⇒ nil
Save image to ppm file.
#ppmsave_target(target, **opts) ⇒ nil
Save to ppm.
#premultiply(**opts) ⇒ Vips::Image
Premultiply image alpha.
#prewitt(**opts) ⇒ Vips::Image
Prewitt edge detector.
#profile(**opts) ⇒ Array<Vips::Image, Vips::Image>
Find image profiles.
#project(**opts) ⇒ Array<Vips::Image, Vips::Image>
Find image projections.
#quadratic(coeff, **opts) ⇒ Vips::Image
Resample an image with a quadratic transform.
#rad2float(**opts) ⇒ Vips::Image
Unpack radiance coding to float rgb.
#radsave(filename, **opts) ⇒ nil
Save image to radiance file.
#radsave_buffer(**opts) ⇒ VipsBlob
Save image to radiance buffer.
#radsave_target(target, **opts) ⇒ nil
Save image to radiance target.
#rank(width, height, index, **opts) ⇒ Vips::Image
Rank filter.
#rawsave(filename, **opts) ⇒ nil
Save image to raw file.
#rawsave_buffer(**opts) ⇒ VipsBlob
Write raw image to buffer.
#rawsave_target(target, **opts) ⇒ nil
Write raw image to target.
#real ⇒ Image
Return the real part of a complex image.
#recomb(m, **opts) ⇒ Vips::Image
Linear recombination with matrix.
#rect ⇒ Image
Return an image with polar pixels converted to rectangular.
#reduce(hshrink, vshrink, **opts) ⇒ Vips::Image
Reduce an image.
#reduceh(hshrink, **opts) ⇒ Vips::Image
Shrink an image horizontally.
#reducev(vshrink, **opts) ⇒ Vips::Image
Shrink an image vertically.
#relational(right, relational, **opts) ⇒ Vips::Image
Relational operation on two images.
#relational_const(relational, c, **opts) ⇒ Vips::Image
Relational operations against a constant.
#remainder(right, **opts) ⇒ Vips::Image
Remainder after integer division of two images.
#remainder_const(c, **opts) ⇒ Vips::Image
Remainder after integer division of an image and a constant.
#remosaic(old_str, new_str, **opts) ⇒ Vips::Image
Rebuild an mosaiced image.
#remove(name) ⇒ Object
This method is deprecated.
#replicate(across, down, **opts) ⇒ Vips::Image
Replicate an image.
#resize(scale, **opts) ⇒ Vips::Image
Resize an image.
#respond_to?(name, include_all = false) ⇒ Boolean
#respond_to_missing?(name, include_all = false) ⇒ Boolean
#rint ⇒ Image
Return the nearest integral value.
#rot(angle, **opts) ⇒ Vips::Image
Rotate an image.
#rot180 ⇒ Image
Rotate by 180 degrees clockwise.
#rot270 ⇒ Image
Rotate by 270 degrees clockwise.
#rot45(**opts) ⇒ Vips::Image
Rotate an image.
#rot90 ⇒ Image
Rotate by 90 degrees clockwise.
#rotate(angle, **opts) ⇒ Vips::Image
Rotate an image by a number of degrees.
#round(round, **opts) ⇒ Vips::Image
Perform a round function on an image.
#scale ⇒ Float
Get scale metadata.
#scaleimage(**opts) ⇒ Vips::Image
Scale an image to uchar.
#scharr(**opts) ⇒ Vips::Image
Scharr edge detector.
#scRGB2BW(**opts) ⇒ Vips::Image
Convert scrgb to bw.
#scRGB2sRGB(**opts) ⇒ Vips::Image
Convert scrgb to srgb.
#scRGB2XYZ(**opts) ⇒ Vips::Image
Transform scrgb to xyz.
#sequential(**opts) ⇒ Vips::Image
Check sequential access.
#set(name, value) ⇒ Object
This method is deprecated.
#set_kill(kill) ⇒ Object
Kill computation of this time.
#set_progress(state) ⇒ Object
Turn progress signalling on and off.
#set_type(gtype, name, value) ⇒ Object
This method is deprecated.
#set_value(name, value) ⇒ Object
This method is deprecated.
#sharpen(**opts) ⇒ Vips::Image
Unsharp masking for print.
#shrink(hshrink, vshrink, **opts) ⇒ Vips::Image
Shrink an image.
#shrinkh(hshrink, **opts) ⇒ Vips::Image
Shrink an image horizontally.
#shrinkv(vshrink, **opts) ⇒ Vips::Image
Shrink an image vertically.
#sign(**opts) ⇒ Vips::Image
Unit vector of pixel.
#similarity(**opts) ⇒ Vips::Image
Similarity transform of an image.
#sin ⇒ Image
Return the sine of an image in degrees.
#sinh ⇒ Image
Return the hyperbolic sine of an image in radians.
#size ⇒ Integer
Get the image size.
#smartcrop(width, height, **opts) ⇒ Vips::Image, Hash<Symbol => Object>
Extract an area from an image.
#sobel(**opts) ⇒ Vips::Image
Sobel edge detector.
#spcor(ref, **opts) ⇒ Vips::Image
Spatial correlation.
#spectrum(**opts) ⇒ Vips::Image
Make displayable power spectrum.
#sRGB2HSV(**opts) ⇒ Vips::Image
Transform srgb to hsv.
#sRGB2scRGB(**opts) ⇒ Vips::Image
Convert an srgb image to scrgb.
#stats(**opts) ⇒ Vips::Image
Find many image stats.
#stdif(width, height, **opts) ⇒ Vips::Image
Statistical difference.
#subsample(xfac, yfac, **opts) ⇒ Vips::Image
Subsample an image.
#subtract(right, **opts) ⇒ Vips::Image
Subtract two images.
#tan ⇒ Image
Return the tangent of an image in degrees.
#tanh ⇒ Image
Return the hyperbolic tangent of an image in radians.
#thumbnail_image(width, **opts) ⇒ Vips::Image
Generate thumbnail from image.
#tiffsave(filename, **opts) ⇒ nil
Save image to tiff file.
#tiffsave_buffer(**opts) ⇒ VipsBlob
Save image to tiff buffer.
#tiffsave_target(target, **opts) ⇒ nil
Save image to tiff target.
#tilecache(**opts) ⇒ Vips::Image
Cache an image as a set of tiles.
#to_a ⇒ Array
Convert to an Array.
#to_enum ⇒ Enumerator
Convert to an Enumerator.
#transpose3d(**opts) ⇒ Vips::Image
Transpose3d an image.
#uhdr2scRGB(**opts) ⇒ Vips::Image
Transform uhdr to scrgb.
#uhdrsave(filename, **opts) ⇒ nil
Save image in ultrahdr format.
#uhdrsave_buffer(**opts) ⇒ VipsBlob
Save image in ultrahdr format.
#uhdrsave_target(target, **opts) ⇒ nil
Save image in ultrahdr format.
#unpremultiply(**opts) ⇒ Vips::Image
Unpremultiply image alpha.
#vipssave(filename, **opts) ⇒ nil
Save image to file in vips format.
#vipssave_target(target, **opts) ⇒ nil
Save image to target in vips format.
#webpsave(filename, **opts) ⇒ nil
Save as webp.
#webpsave_buffer(**opts) ⇒ VipsBlob
Save as webp.
#webpsave_mime(**opts) ⇒ nil
Save image to webp mime.
#webpsave_target(target, **opts) ⇒ nil
Save as webp.
#width ⇒ Integer
Get image width, in pixels.
#wrap(**opts) ⇒ Vips::Image
Wrap image origin.
#write_to_buffer(format_string, **opts) ⇒ String
Write this image to a memory buffer.
#write_to_file(name, **opts) ⇒ Object
Write this image to a file.
#write_to_memory ⇒ String
Write this image to a large memory buffer.
#write_to_target(target, format_string, **opts) ⇒ Object
Write this image to a target.
#xoffset ⇒ Integer
Get image xoffset.
#xres ⇒ Float
Get image x resolution.
#XYZ2CMYK(**opts) ⇒ Vips::Image
Transform xyz to cmyk.
#XYZ2Lab(**opts) ⇒ Vips::Image
Transform xyz to lab.
#XYZ2Oklab(**opts) ⇒ Vips::Image
Transform xyz to oklab.
#XYZ2scRGB(**opts) ⇒ Vips::Image
Transform xyz to scrgb.
#XYZ2Yxy(**opts) ⇒ Vips::Image
Transform xyz to yxy.
#yoffset ⇒ Integer
Get image yoffset.
#yres ⇒ Float
Get image y resolution.
#Yxy2XYZ(**opts) ⇒ Vips::Image
Transform yxy to xyz.
#zoom(xfac, yfac, **opts) ⇒ Vips::Image
Zoom an image.
#|(other) ⇒ Image
Integer bitwise OR with an image, constant or array.
#~ ⇒ Image
Equivalent to image ^ -1.

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.

Parameters:

name (String) —
vips operation to call

Returns:

result of vips operation



232
233
234

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

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

Class Method Details

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

Load an analyze6 image.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Join an array of images.

Parameters:

im (Array<Image>) —
Array of input images
opts (Hash) —
Set of options

Options Hash (**opts):

:across (Integer) —
Number of images across grid
:shim (Integer) —
Pixels between images
:background (Array<Double>) —
Colour for new pixels
:halign (Vips::Align) —
Align on the left, centre or right
:valign (Vips::Align) —
Align on the top, centre or bottom
:hspacing (Integer) —
Horizontal spacing between images
:vspacing (Integer) —
Vertical spacing between images

Returns:

(Vips::Image) —
Output image

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

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

Band-wise rank of a set of images.

Parameters:

im (Array<Image>) —
Array of input images
opts (Hash) —
Set of options

Options Hash (**opts):

:index (Integer) —
Select this band element from sorted list

Returns:

(Vips::Image) —
Output image

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

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

Make a black image.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
opts (Hash) —
Set of options

Options Hash (**opts):

:bands (Integer) —
Number of bands in image

Returns:

(Vips::Image) —
Output image

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

.complex?(format) ⇒ `Boolean`

Returns:

(Boolean)

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

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

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

Load csv.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:skip (Integer) —
Skip this many lines at the start of the file
:lines (Integer) —
Read this many lines from the file
:whitespace (String) —
Set of whitespace characters
:separator (String) —
Set of separator characters
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load csv.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:skip (Integer) —
Skip this many lines at the start of the file
:lines (Integer) —
Read this many lines from the file
:whitespace (String) —
Set of whitespace characters
:separator (String) —
Set of separator characters
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load raw camera files.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:bitdepth (Integer) —
Number of bits per pixel
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load raw camera files.

Parameters:

buffer (VipsBlob) —
Buffer to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:bitdepth (Integer) —
Number of bits per pixel
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load raw camera files.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:bitdepth (Integer) —
Number of bits per pixel
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Make an image showing the eye's spatial response.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
opts (Hash) —
Set of options

Options Hash (**opts):

:uchar (Boolean) —
Output an unsigned char image
:factor (Float) —
Maximum spatial frequency

Returns:

(Vips::Image) —
Output image

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

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

Load a fits image.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load fits from a source.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

.float?(format) ⇒ `Boolean`

Returns:

(Boolean)

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

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

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

Make a fractal surface.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
fractal_dimension (Float) —
Fractal dimension
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Make a gaussian image.

Parameters:

sigma (Float) —
Sigma of Gaussian
min_ampl (Float) —
Minimum amplitude of Gaussian
opts (Hash) —
Set of options

Options Hash (**opts):

:separable (Boolean) —
Generate separable Gaussian
:precision (Vips::Precision) —
Generate with this precision

Returns:

(Vips::Image) —
Output image

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

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

Make a gaussnoise image.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
opts (Hash) —
Set of options

Options Hash (**opts):

:sigma (Float) —
Standard deviation of pixels in generated image
:mean (Float) —
Mean of pixels in generated image
:seed (Integer) —
Random number seed

Returns:

(Vips::Image) —
Output image

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

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

Load gif with libnsgif.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:n (Integer) —
Number of pages to load, -1 for all
:page (Integer) —
First page to load
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load gif with libnsgif.

Parameters:

buffer (VipsBlob) —
Buffer to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:n (Integer) —
Number of pages to load, -1 for all
:page (Integer) —
First page to load
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load gif from source.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:n (Integer) —
Number of pages to load, -1 for all
:page (Integer) —
First page to load
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Make a grey ramp image.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
opts (Hash) —
Set of options

Options Hash (**opts):

:uchar (Boolean) —
Output an unsigned char image

Returns:

(Vips::Image) —
Output image

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

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

Load a heif image.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:thumbnail (Boolean) —
Fetch thumbnail image
:unlimited (Boolean) —
Remove all denial of service limits
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load a heif image.

Parameters:

buffer (VipsBlob) —
Buffer to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:thumbnail (Boolean) —
Fetch thumbnail image
:unlimited (Boolean) —
Remove all denial of service limits
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load a heif image.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:thumbnail (Boolean) —
Fetch thumbnail image
:unlimited (Boolean) —
Remove all denial of service limits
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Make a 1d image where pixel values are indexes.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:bands (Integer) —
Number of bands in LUT
:ushort (Boolean) —
Create a 16-bit LUT
:size (Integer) —
Size of 16-bit LUT

Returns:

(Vips::Image) —
Output image

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

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

Load jpeg2000 image.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
Load this page from the image
:oneshot (Boolean) —
Load images a frame at a time
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load jpeg2000 image.

Parameters:

buffer (VipsBlob) —
Buffer to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
Load this page from the image
:oneshot (Boolean) —
Load images a frame at a time
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load jpeg2000 image.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
Load this page from the image
:oneshot (Boolean) —
Load images a frame at a time
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load jpeg from file.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:shrink (Integer) —
Shrink factor on load
:autorotate (Boolean) —
Rotate image using exif orientation
:unlimited (Boolean) —
Remove all denial of service limits
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load jpeg from buffer.

Parameters:

buffer (VipsBlob) —
Buffer to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:shrink (Integer) —
Shrink factor on load
:autorotate (Boolean) —
Rotate image using exif orientation
:unlimited (Boolean) —
Remove all denial of service limits
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load image from jpeg source.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:shrink (Integer) —
Shrink factor on load
:autorotate (Boolean) —
Rotate image using exif orientation
:unlimited (Boolean) —
Remove all denial of service limits
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load jpeg-xl image.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load jpeg-xl image.

Parameters:

buffer (VipsBlob) —
Buffer to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load jpeg-xl image.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Make a laplacian of gaussian image.

Parameters:

sigma (Float) —
Radius of Gaussian
min_ampl (Float) —
Minimum amplitude of Gaussian
opts (Hash) —
Set of options

Options Hash (**opts):

:separable (Boolean) —
Generate separable Gaussian
:precision (Vips::Precision) —
Generate with this precision

Returns:

(Vips::Image) —
Output image

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

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

Load file with imagemagick7.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:density (String) —
Canvas resolution for rendering vector formats like SVG
:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load buffer with imagemagick7.

Parameters:

buffer (VipsBlob) —
Buffer to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:density (String) —
Canvas resolution for rendering vector formats like SVG
:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load source with imagemagick7.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:density (String) —
Canvas resolution for rendering vector formats like SVG
:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Make a butterworth filter.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
order (Float) —
Filter order
frequency_cutoff (Float) —
Frequency cutoff
amplitude_cutoff (Float) —
Amplitude cutoff
opts (Hash) —
Set of options

Options Hash (**opts):

:uchar (Boolean) —
Output an unsigned char image
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter
:optical (Boolean) —
Rotate quadrants to optical space

Returns:

(Vips::Image) —
Output image

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

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

Make a butterworth_band filter.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
order (Float) —
Filter order
frequency_cutoff_x (Float) —
Frequency cutoff x
frequency_cutoff_y (Float) —
Frequency cutoff y
radius (Float) —
Radius of circle
amplitude_cutoff (Float) —
Amplitude cutoff
opts (Hash) —
Set of options

Options Hash (**opts):

:uchar (Boolean) —
Output an unsigned char image
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter
:optical (Boolean) —
Rotate quadrants to optical space

Returns:

(Vips::Image) —
Output image

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

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

Make a butterworth ring filter.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
order (Float) —
Filter order
frequency_cutoff (Float) —
Frequency cutoff
amplitude_cutoff (Float) —
Amplitude cutoff
ringwidth (Float) —
Ringwidth
opts (Hash) —
Set of options

Options Hash (**opts):

:uchar (Boolean) —
Output an unsigned char image
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter
:optical (Boolean) —
Rotate quadrants to optical space

Returns:

(Vips::Image) —
Output image

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

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

Make fractal filter.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
fractal_dimension (Float) —
Fractal dimension
opts (Hash) —
Set of options

Options Hash (**opts):

:uchar (Boolean) —
Output an unsigned char image
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter
:optical (Boolean) —
Rotate quadrants to optical space

Returns:

(Vips::Image) —
Output image

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

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

Make a gaussian filter.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
frequency_cutoff (Float) —
Frequency cutoff
amplitude_cutoff (Float) —
Amplitude cutoff
opts (Hash) —
Set of options

Options Hash (**opts):

:uchar (Boolean) —
Output an unsigned char image
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter
:optical (Boolean) —
Rotate quadrants to optical space

Returns:

(Vips::Image) —
Output image

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

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

Make a gaussian filter.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
frequency_cutoff_x (Float) —
Frequency cutoff x
frequency_cutoff_y (Float) —
Frequency cutoff y
radius (Float) —
Radius of circle
amplitude_cutoff (Float) —
Amplitude cutoff
opts (Hash) —
Set of options

Options Hash (**opts):

:uchar (Boolean) —
Output an unsigned char image
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter
:optical (Boolean) —
Rotate quadrants to optical space

Returns:

(Vips::Image) —
Output image

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

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

Make a gaussian ring filter.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
frequency_cutoff (Float) —
Frequency cutoff
amplitude_cutoff (Float) —
Amplitude cutoff
ringwidth (Float) —
Ringwidth
opts (Hash) —
Set of options

Options Hash (**opts):

:uchar (Boolean) —
Output an unsigned char image
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter
:optical (Boolean) —
Rotate quadrants to optical space

Returns:

(Vips::Image) —
Output image

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

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

Make an ideal filter.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
frequency_cutoff (Float) —
Frequency cutoff
opts (Hash) —
Set of options

Options Hash (**opts):

:uchar (Boolean) —
Output an unsigned char image
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter
:optical (Boolean) —
Rotate quadrants to optical space

Returns:

(Vips::Image) —
Output image

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

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

Make an ideal band filter.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
frequency_cutoff_x (Float) —
Frequency cutoff x
frequency_cutoff_y (Float) —
Frequency cutoff y
radius (Float) —
Radius of circle
opts (Hash) —
Set of options

Options Hash (**opts):

:uchar (Boolean) —
Output an unsigned char image
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter
:optical (Boolean) —
Rotate quadrants to optical space

Returns:

(Vips::Image) —
Output image

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

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

Make an ideal ring filter.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
frequency_cutoff (Float) —
Frequency cutoff
ringwidth (Float) —
Ringwidth
opts (Hash) —
Set of options

Options Hash (**opts):

:uchar (Boolean) —
Output an unsigned char image
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter
:optical (Boolean) —
Rotate quadrants to optical space

Returns:

(Vips::Image) —
Output image

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

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

Load mat from file.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

.matrix_from_array(width, height, array) ⇒ `Object`

Raises:

(Vips::Error)

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

def self.matrix_from_array width, height, array
  ptr = FFI::MemoryPointer.new :double, array.length
  ptr.write_array_of_double array
  img_ptr = Vips.vips_image_new_matrix_from_array width, height,
    ptr, array.length
  raise Vips::Error if img_ptr.null?
  Vips::Image.new img_ptr
end

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

Load matrix.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load matrix.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Invoke a vips operation with Operation.call.



237
238
239

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

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]

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

for a simple sharpening mask.

Parameters:

array (Array) —
the pixel data as an array of numbers
scale (Real) (defaults to: 1) —
the convolution scale
offset (Real) (defaults to: 0) —
the convolution offset

Returns:

(Image) —
the image

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

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

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

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

  unless array.length == width * height
    raise Vips::Error, "Bad array dimensions."
  end

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

  image = Vips::Image.matrix_from_array width, height, array

  image.mutate do |mutable|
    # be careful to set them as double
    mutable.set_type! GObject::GDOUBLE_TYPE, "scale", scale.to_f
    mutable.set_type! GObject::GDOUBLE_TYPE, "offset", offset.to_f
  end
end

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

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

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

or alternatively:

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

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

$ vips jpegload_buffer

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

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

Parameters:

data (String) —
the data to load from
option_string (String) —
load options as a string
opts (Hash) —
set of options

Options Hash (**opts):

:disc (Boolean) — default: true —
Open large images via a temporary disc file
:access (Vips::Access) — default: :random —
Access mode for file

Returns:

(Image) —
the loaded image

Raises:

(Vips::Error)

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

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

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

.new_from_file(name, **opts) ⇒ `Image`

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

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

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

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

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

$ vips jpegload

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

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

Parameters:

name (String) —
the filename to load from
opts (Hash) —
set of options

Options Hash (**opts):

:disc (Boolean) — default: true —
Open large images via a temporary disc file
:access (Vips::Access) — default: :random —
Access mode for file

Returns:

(Image) —
the loaded image

Raises:

(Vips::Error)

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

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

  filename = Vips.p2str(Vips.vips_filename_get_filename(name))
  option_string = Vips.p2str(Vips.vips_filename_get_options(name))
  loader = Vips.vips_foreign_find_load filename
  raise Vips::Error if loader.nil?

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

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

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

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

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

Creating a new image from a memory pointer:

ptr = FFI::MemoryPointer.new(:uchar, 10*10)
# => #<FFI::MemoryPointer address=0x00007fc236db31d0 size=100>
x = Vips::Image.new_from_memory(ptr, 10, 10, 1, :uchar)

Creating a new image from an address only pointer:

ptr = call_to_external_c_library(w: 10, h: 10)
# => #<FFI::Pointer address=0x00007f9780813a00>
ptr_slice = ptr.slice(0, 10*10)
# => #<FFI::Pointer address=0x00007f9780813a00 size=100>
x = Vips::Image.new_from_memory(ptr_slice, 10, 10, 1, :uchar)

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

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

Parameters:

data (String, FFI::Pointer) —
the data to load from
width (Integer) —
width in pixels
height (Integer) —
height in pixels
bands (Integer) —
number of bands
format (Symbol) —
band format

Returns:

(Image) —
the loaded image

Raises:

(Vips::Error)

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

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

  if data.is_a?(FFI::Pointer)
    # A pointer needs to know about the size of the memory it points to.
    # If you have an address-only pointer, use the .slice method to wrap
    # the pointer in a size aware pointer.
    if data.size == UNKNOWN_POINTER_SIZE
      raise Vips::Error, "size of memory is unknown"
    end
    size = data.size
  else
    size = data.bytesize
  end

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

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

  image
end

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

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

Parameters:

data (String, FFI::Pointer) —
the data to load from
width (Integer) —
width in pixels
height (Integer) —
height in pixels
bands (Integer) —
number of bands
format (Symbol) —
band format

Returns:

(Image) —
the loaded image

Raises:

(Vips::Error)

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

def self.new_from_memory_copy data, width, height, bands, format
  format_number = GObject::GValue.enum_from_nick BAND_FORMAT_TYPE, format

  if data.is_a?(FFI::Pointer)
    if data.size == UNKNOWN_POINTER_SIZE
      raise Vips::Error, "size of memory is unknown"
    end
    size = data.size
  else
    size = data.bytesize
  end

  vi = Vips.vips_image_new_from_memory_copy data, size,
    width, height, bands, format_number
  raise Vips::Error if vi.null?
  new(vi)
end

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

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

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

or alternatively:

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

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

$ vips jpegload_source

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

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

Parameters:

source (Vips::Source) —
the source to load from
option_string (String) —
load options as a string
opts (Hash) —
set of options

Options Hash (**opts):

:disc (Boolean) — default: true —
Open large images via a temporary disc file
:access (Vips::Access) — default: :random —
Access mode for file

Returns:

(Image) —
the loaded image

Raises:

(Vips::Error)

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

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

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

  # keep a secret ref to the source object ... the libvips loader will
  # keep a ref to the C source object, but we need the ruby wrapper object
  # to stay alive too
  result.references << source

  result
end

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

Load an openexr image.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load file with openslide.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:level (Integer) —
Load this level from the file
:autocrop (Boolean) —
Crop to image bounds
:associated (String) —
Load this associated image
:attach_associated (Boolean) —
Attach all associated images
:rgb (Boolean) —
Output RGB (not RGBA)
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load source with openslide.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:level (Integer) —
Load this level from the file
:autocrop (Boolean) —
Crop to image bounds
:associated (String) —
Load this associated image
:attach_associated (Boolean) —
Attach all associated images
:rgb (Boolean) —
Output RGB (not RGBA)
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load pdf from file (poppler).

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:dpi (Float) —
DPI to render at
:scale (Float) —
Factor to scale by
:background (Array<Double>) —
Background colour
:password (String) —
Password to decrypt with
:page_box (Vips::ForeignPdfPageBox) —
The region of the page to render
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load pdf from buffer (poppler).

Parameters:

buffer (VipsBlob) —
Buffer to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:dpi (Float) —
DPI to render at
:scale (Float) —
Factor to scale by
:background (Array<Double>) —
Background colour
:password (String) —
Password to decrypt with
:page_box (Vips::ForeignPdfPageBox) —
The region of the page to render
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load pdf from source (poppler).

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:dpi (Float) —
DPI to render at
:scale (Float) —
Factor to scale by
:background (Array<Double>) —
Background colour
:password (String) —
Password to decrypt with
:page_box (Vips::ForeignPdfPageBox) —
The region of the page to render
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Make a perlin noise image.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
opts (Hash) —
Set of options

Options Hash (**opts):

:cell_size (Integer) —
Size of Perlin cells
:uchar (Boolean) —
Output an unsigned char image
:seed (Integer) —
Random number seed

Returns:

(Vips::Image) —
Output image

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

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

Load png from file.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:unlimited (Boolean) —
Remove all denial of service limits
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load png from buffer.

Parameters:

buffer (VipsBlob) —
Buffer to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:unlimited (Boolean) —
Remove all denial of service limits
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load png from source.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:unlimited (Boolean) —
Remove all denial of service limits
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load ppm from file.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load ppm from buffer.

Parameters:

buffer (VipsBlob) —
Buffer to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load ppm from source.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

.profile_load(name, **opts) ⇒ `VipsBlob`

Load named icc profile.

Parameters:

name (String) —
Profile name
opts (Hash) —
Set of options

Returns:

(VipsBlob) —
Loaded profile

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

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

Load a radiance image from a file.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load rad from buffer.

Parameters:

buffer (VipsBlob) —
Buffer to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load rad from source.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load raw data from a file.

Parameters:

filename (String) —
Filename to load from
width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
bands (Integer) —
Number of bands in image
opts (Hash) —
Set of options

Options Hash (**opts):

:offset (guint64) —
Offset in bytes from start of file
:format (Vips::BandFormat) —
Pixel format in image
:interpretation (Vips::Interpretation) —
Pixel interpretation
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Returns:

(Boolean)

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

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

  super
end

.run_cmplx(image, &block) ⇒ `Object`

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

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

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

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

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

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

  image = block.call(image)

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

  image
end

.sdf(width, height, shape, **opts) ⇒ `Vips::Image`

Create an sdf image.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
shape (Vips::SdfShape) —
SDF shape to create
opts (Hash) —
Set of options

Options Hash (**opts):

:r (Float) —
Radius
:a (Array<Double>) —
Point a
:b (Array<Double>) —
Point b
:corners (Array<Double>) —
Corner radii

Returns:

(Vips::Image) —
Output image

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

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

Make a 2d sine wave.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
opts (Hash) —
Set of options

Options Hash (**opts):

:uchar (Boolean) —
Output an unsigned char image
:hfreq (Float) —
Horizontal spatial frequency
:vfreq (Float) —
Vertical spatial frequency

Returns:

(Vips::Image) —
Output image

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

.smap(x, &block) ⇒ `Object`

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



116
117
118

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

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

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

Sum an array of images.

Parameters:

im (Array<Image>) —
Array of input images
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Load svg with rsvg.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:dpi (Float) —
Render at this DPI
:scale (Float) —
Scale output by this factor
:unlimited (Boolean) —
Allow SVG of any size
:stylesheet (String) —
Custom CSS
:high_bitdepth (Boolean) —
Enable scRGB 128-bit output (32-bit per channel)
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load svg with rsvg.

Parameters:

buffer (VipsBlob) —
Buffer to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:dpi (Float) —
Render at this DPI
:scale (Float) —
Scale output by this factor
:unlimited (Boolean) —
Allow SVG of any size
:stylesheet (String) —
Custom CSS
:high_bitdepth (Boolean) —
Enable scRGB 128-bit output (32-bit per channel)
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load svg from source.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:dpi (Float) —
Render at this DPI
:scale (Float) —
Scale output by this factor
:unlimited (Boolean) —
Allow SVG of any size
:stylesheet (String) —
Custom CSS
:high_bitdepth (Boolean) —
Enable scRGB 128-bit output (32-bit per channel)
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

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

Parameters:

tests (Array<Image>) —
Table of images to test
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Run an external command.

Parameters:

cmd_format (String) —
Command to run
opts (Hash) —
Set of options

Options Hash (**opts):

:im (Array<Image>) —
Array of input images
:in_format (String) —
Format for input filename
:out_format (String) —
Format for output filename
:cache (Boolean) —
Cache this call
:out (Vips::Image) —
Output Output image
:log (String) —
Output Command log

Returns:

(nil, Hash<Symbol => Object>) —
Hash of optional output items

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

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

Make a text image.

Parameters:

text (String) —
Text to render
opts (Hash) —
Set of options

Options Hash (**opts):

:font (String) —
Font to render with
:width (Integer) —
Maximum image width in pixels
:height (Integer) —
Maximum image height in pixels
:align (Vips::Align) —
Align on the low, centre or high edge
:justify (Boolean) —
Justify lines
:dpi (Integer) —
DPI to render at
:spacing (Integer) —
Line spacing
:fontfile (String) —
Load this font file
:rgba (Boolean) —
Enable RGBA output
:wrap (Vips::TextWrap) —
Wrap lines on word or character boundaries
:autofit_dpi (Integer) —
Output DPI selected by autofit

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Generate thumbnail from file.

Parameters:

filename (String) —
Filename to read from
width (Integer) —
Size to this width
opts (Hash) —
Set of options

Options Hash (**opts):

:height (Integer) —
Size to this height
:size (Vips::Size) —
Only upsize, only downsize, or both
:no_rotate (Boolean) —
Don't use orientation tags to rotate image upright
:crop (Vips::Interesting) —
Reduce to fill target rectangle, then crop
:linear (Boolean) —
Reduce in linear light
:input_profile (String) —
Fallback input profile
:output_profile (String) —
Fallback output profile
:intent (Vips::Intent) —
Rendering intent
:fail_on (Vips::FailOn) —
Error level to fail on

Returns:

(Vips::Image) —
Output image

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

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

Generate thumbnail from buffer.

Parameters:

buffer (VipsBlob) —
Buffer to load from
width (Integer) —
Size to this width
opts (Hash) —
Set of options

Options Hash (**opts):

:option_string (String) —
Options that are passed on to the underlying loader
:height (Integer) —
Size to this height
:size (Vips::Size) —
Only upsize, only downsize, or both
:no_rotate (Boolean) —
Don't use orientation tags to rotate image upright
:crop (Vips::Interesting) —
Reduce to fill target rectangle, then crop
:linear (Boolean) —
Reduce in linear light
:input_profile (String) —
Fallback input profile
:output_profile (String) —
Fallback output profile
:intent (Vips::Intent) —
Rendering intent
:fail_on (Vips::FailOn) —
Error level to fail on

Returns:

(Vips::Image) —
Output image

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

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

Generate thumbnail from source.

Parameters:

source (Vips::Source) —
Source to load from
width (Integer) —
Size to this width
opts (Hash) —
Set of options

Options Hash (**opts):

:option_string (String) —
Options that are passed on to the underlying loader
:height (Integer) —
Size to this height
:size (Vips::Size) —
Only upsize, only downsize, or both
:no_rotate (Boolean) —
Don't use orientation tags to rotate image upright
:crop (Vips::Interesting) —
Reduce to fill target rectangle, then crop
:linear (Boolean) —
Reduce in linear light
:input_profile (String) —
Fallback input profile
:output_profile (String) —
Fallback output profile
:intent (Vips::Intent) —
Rendering intent
:fail_on (Vips::FailOn) —
Error level to fail on

Returns:

(Vips::Image) —
Output image

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

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

Load tiff from file.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:autorotate (Boolean) —
Rotate image using orientation tag
:subifd (Integer) —
Subifd index
:unlimited (Boolean) —
Remove all denial of service limits
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load tiff from buffer.

Parameters:

buffer (VipsBlob) —
Buffer to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:autorotate (Boolean) —
Rotate image using orientation tag
:subifd (Integer) —
Subifd index
:unlimited (Boolean) —
Remove all denial of service limits
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load tiff from source.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:autorotate (Boolean) —
Rotate image using orientation tag
:subifd (Integer) —
Subifd index
:unlimited (Boolean) —
Remove all denial of service limits
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Build a look-up table.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:in_max (Integer) —
Size of LUT to build
:out_max (Integer) —
Maximum value in output LUT
:Lb (Float) —
Lowest value in output
:Lw (Float) —
Highest value in output
:Ps (Float) —
Position of shadow
:Pm (Float) —
Position of mid-tones
:Ph (Float) —
Position of highlights
:S (Float) —
Adjust shadows by this much
:M (Float) —
Adjust mid-tones by this much
:H (Float) —
Adjust highlights by this much

Returns:

(Vips::Image) —
Output image

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

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

Load a uhdr image.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:shrink (Integer) —
Shrink factor on load
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load a uhdr image.

Parameters:

buffer (VipsBlob) —
Buffer to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:shrink (Integer) —
Shrink factor on load
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load a uhdr image.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:shrink (Integer) —
Shrink factor on load
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load vips from file.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load vips from source.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load webp from file.

Parameters:

filename (String) —
Filename to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:scale (Float) —
Factor to scale by
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load webp from buffer.

Parameters:

buffer (VipsBlob) —
Buffer to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:scale (Float) —
Factor to scale by
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Load webp from source.

Parameters:

source (Vips::Source) —
Source to load from
opts (Hash) —
Set of options

Options Hash (**opts):

:page (Integer) —
First page to load
:n (Integer) —
Number of pages to load, -1 for all
:scale (Float) —
Factor to scale by
:memory (Boolean) —
Force open via memory
:access (Vips::Access) —
Required access pattern for this file
:fail_on (Vips::FailOn) —
Error level to fail on
:revalidate (Boolean) —
Don't use a cached result for this operation
:flags (Vips::ForeignFlags) —
Output Flags for this file

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Make a worley noise image.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
opts (Hash) —
Set of options

Options Hash (**opts):

:cell_size (Integer) —
Size of Worley cells
:seed (Integer) —
Random number seed

Returns:

(Vips::Image) —
Output image

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

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

Make an image where pixel values are coordinates.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
opts (Hash) —
Set of options

Options Hash (**opts):

:csize (Integer) —
Size of third dimension
:dsize (Integer) —
Size of fourth dimension
:esize (Integer) —
Size of fifth dimension

Returns:

(Vips::Image) —
Output image

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

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

Make a zone plate.

Parameters:

width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
opts (Hash) —
Set of options

Options Hash (**opts):

:uchar (Boolean) —
Output an unsigned char image

Returns:

(Vips::Image) —
Output image

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

Instance Method Details

#! ⇒ `Image`

Equivalent to image ^ -1

Returns:

(Image) —
image with bits flipped



1129
1130
1131

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

def !
  self ^ -1
end

#!=(other) ⇒ `Image`

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

Parameters:

other (nil, Image, Real, Array<Real>) —
test inequality to this

Returns:

(Image) —
result of inequality

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

def != other
  # for equality, we must allow tests against nil
  other.nil? || call_enum("relational", other, :noteq)
end

#%(other) ⇒ `Image`

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

Parameters:

other (Image, Real, Array<Real>) —
self modulo this

Returns:

(Image) —
result of modulo

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

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

#&(other) ⇒ `Image`

Integer bitwise AND with an image, constant or array.

Parameters:

other (Image, Real, Array<Real>) —
bitwise AND with this

Returns:

(Image) —
result of bitwise AND



1114
1115
1116

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

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

#*(other) ⇒ `Image`

Multiply an image, constant or array.

Parameters:

other (Image, Real, Array<Real>) —
Thing to multiply by self

Returns:

(Image) —
result of multiplication

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

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

#**(other) ⇒ `Image`

Raise to power of an image, constant or array.

Parameters:

other (Image, Real, Array<Real>) —
self to the power of this

Returns:

(Image) —
result of power



1082
1083
1084

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

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

#+(other) ⇒ `Image`

Add an image, constant or array.

Parameters:

other (Image, Real, Array<Real>) —
Thing to add to self

Returns:

(Image) —
result of addition

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

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

#+@ ⇒ `Image`

Returns image.

Returns:

(Image) —
image



1141
1142
1143

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

def +@
  self
end

#-(other) ⇒ `Image`

Subtract an image, constant or array.

Parameters:

other (Image, Real, Array<Real>) —
Thing to subtract from self

Returns:

(Image) —
result of subtraction

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

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

#-@ ⇒ `Image`

Equivalent to image * -1

Returns:

(Image) —
negative of image



1148
1149
1150

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

def -@
  self * -1
end

#/(other) ⇒ `Image`

Divide an image, constant or array.

Parameters:

other (Image, Real, Array<Real>) —
Thing to divide self by

Returns:

(Image) —
result of division

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

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

#<(other) ⇒ `Image`

Relational less than with an image, constant or array.

Parameters:

other (Image, Real, Array<Real>) —
relational less than with this

Returns:

(Image) —
result of less than



1156
1157
1158

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

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

#<<(other) ⇒ `Image`

Integer left shift with an image, constant or array.

Parameters:

other (Image, Real, Array<Real>) —
shift left by this much

Returns:

(Image) —
result of left shift



1090
1091
1092

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

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

#<=(other) ⇒ `Image`

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

Parameters:

other (Image, Real, Array<Real>) —
relational less than or equal to with this

Returns:

(Image) —
result of less than or equal to



1165
1166
1167

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

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

#==(other) ⇒ `Image`

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

Parameters:

other (nil, Image, Real, Array<Real>) —
test equality to this

Returns:

(Image) —
result of equality

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

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

#>(other) ⇒ `Image`

Relational more than with an image, constant or array.

Parameters:

other (Image, Real, Array<Real>) —
relational more than with this

Returns:

(Image) —
result of more than



1173
1174
1175

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

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

#>=(other) ⇒ `Image`

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

Parameters:

other (Image, Real, Array<Real>) —
relational more than or equal to with this

Returns:

(Image) —
result of more than or equal to



1182
1183
1184

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

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

#>>(other) ⇒ `Image`

Integer right shift with an image, constant or array.

Parameters:

other (Image, Real, Array<Real>) —
shift right by this much

Returns:

(Image) —
result of right shift



1098
1099
1100

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

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

#[](index) ⇒ `Image`

Fetch bands using a number or a range

Parameters:

index (Numeric, Range) —
extract these band(s)

Returns:

(Image) —
extracted band(s)

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

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

#^(other) ⇒ `Image`

Integer bitwise EOR with an image, constant or array.

Parameters:

other (Image, Real, Array<Real>) —
bitwise EOR with this

Returns:

(Image) —
result of bitwise EOR



1122
1123
1124

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

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

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

Absolute value of an image.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#acos ⇒ `Image`

Return the inverse cosine of an image in degrees.

Returns:

(Image) —
inverse cosine of each pixel



1474
1475
1476

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

def acos
  math :acos
end

#acosh ⇒ `Image`

Return the inverse hyperbolic cosine of an image in radians.

Returns:

(Image) —
inverse cosine of each pixel



1516
1517
1518

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

def acosh
  math :acosh
end

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

Add two images.

Parameters:

right (Vips::Image) —
Right-hand image argument
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#add_alpha ⇒ `Image`

Append an alpha channel to an image.

Returns:

(Image) —
new image

Raises:

(Vips::Error)

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

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

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

#addalpha(**opts) ⇒ `Vips::Image`

Append an alpha channel.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#affine(matrix, **opts) ⇒ `Vips::Image`

Affine transform of an image.

Parameters:

matrix (Array<Double>) —
Transformation matrix
opts (Hash) —
Set of options

Options Hash (**opts):

:interpolate (Vips::Interpolate) —
Interpolate pixels with this
:oarea (Array<Integer>) —
Area of output to generate
:odx (Float) —
Horizontal output displacement
:ody (Float) —
Vertical output displacement
:idx (Float) —
Horizontal input displacement
:idy (Float) —
Vertical input displacement
:background (Array<Double>) —
Background value
:premultiplied (Boolean) —
Images have premultiplied alpha
:extend (Vips::Extend) —
How to generate the extra pixels

Returns:

(Vips::Image) —
Output image

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

#asin ⇒ `Image`

Return the inverse sine of an image in degrees.

Returns:

(Image) —
inverse sine of each pixel



1467
1468
1469

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

def asin
  math :asin
end

#asinh ⇒ `Image`

Return the inverse hyperbolic sine of an image in radians.

Returns:

(Image) —
inverse sine of each pixel



1509
1510
1511

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

def asinh
  math :asinh
end

#atan ⇒ `Image`

Return the inverse tangent of an image in degrees.

Returns:

(Image) —
inverse tangent of each pixel



1481
1482
1483

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

def atan
  math :atan
end

#atanh ⇒ `Image`

Return the inverse hyperbolic tangent of an image in radians.

Returns:

(Image) —
inverse tangent of each pixel



1523
1524
1525

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

def atanh
  math :atanh
end

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

Autorotate image by exif tag.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:angle (Vips::Angle) —
Output Angle image was rotated by
:flip (Boolean) —
Output Whether the image was flipped or not

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

#avg(**opts) ⇒ `Float`

Find image average.

Parameters:

opts (Hash) —
Set of options

Returns:

(Float) —
Output value

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

#bandand ⇒ `Image`

AND the bands of an image together

Returns:

(Image) —
all bands ANDed together



1283
1284
1285

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

def bandand
  bandbool :and
end

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

Boolean operation across image bands.

Parameters:

boolean (Vips::OperationBoolean) —
Boolean to perform
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#bandeor ⇒ `Image`

EOR the bands of an image together

Returns:

(Image) —
all bands EORed together



1297
1298
1299

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

def bandeor
  bandbool :eor
end

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

Fold up x axis into bands.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:factor (Integer) —
Fold by this factor

Returns:

(Vips::Image) —
Output image

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

#bandjoin(other) ⇒ `Image`

Join a set of images bandwise.

Parameters:

other (Image, Array<Image>, Real, Array<Real>) —
bands to append

Returns:

(Image) —
many band image

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

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

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

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

#bandjoin_const(c, **opts) ⇒ `Vips::Image`

Append a constant band to an image.

Parameters:

c (Array<Double>) —
Array of constants to add
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Band-wise average.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#bandor ⇒ `Image`

OR the bands of an image together

Returns:

(Image) —
all bands ORed together



1290
1291
1292

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

def bandor
  bandbool :or
end

#bands ⇒ `Integer`

Get number of image bands.

Returns:

(Integer) —
number of image bands



904
905
906

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

def bands
  Vips.vips_image_get_bands self
end

#bandsplit ⇒ `Array<Image>`

Split an n-band image into n separate images.

Returns:

(Array<Image>) —
Array of n one-band images



1304
1305
1306

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

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

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

Unfold image bands into x axis.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:factor (Integer) —
Unfold by this factor

Returns:

(Vips::Image) —
Output image

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

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

Boolean operation on two images.

Parameters:

right (Vips::Image) —
Right-hand image argument
boolean (Vips::OperationBoolean) —
Boolean to perform
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Boolean operations against a constant.

Parameters:

boolean (Vips::OperationBoolean) —
Boolean to perform
c (Array<Double>) —
Array of constants
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Build a look-up table.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Byteswap an image.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Canny edge detector.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:sigma (Float) —
Sigma of Gaussian
:precision (Vips::Precision) —
Convolve with this precision

Returns:

(Vips::Image) —
Output image

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

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

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

Parameters:

cases (Array<Image>) —
Array of case images
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Cast an image.

Parameters:

format (Vips::BandFormat) —
Format to cast to
opts (Hash) —
Set of options

Options Hash (**opts):

:shift (Boolean) —
Shift integer values up and down

Returns:

(Vips::Image) —
Output image

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

#ceil ⇒ `Image`

Return the smallest integral value not less than the argument.

Returns:

(Image) —
ceil of image



1269
1270
1271

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

def ceil
  round :ceil
end

#clamp(**opts) ⇒ `Vips::Image`

Clamp values of an image.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:min (Float) —
Minimum value
:max (Float) —
Maximum value

Returns:

(Vips::Image) —
Output image

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

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

Transform lch to cmc.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Transform cmyk to xyz.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#coding ⇒ `Symbol`

Get image coding.

Returns:

(Symbol) —
image coding



925
926
927

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

def coding
  get "coding"
end

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

Convert to a new colorspace.

Parameters:

space (Vips::Interpretation) —
Destination color space
opts (Hash) —
Set of options

Options Hash (**opts):

:source_space (Vips::Interpretation) —
Source color space

Returns:

(Vips::Image) —
Output image

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

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

Convolve with rotating mask.

Parameters:

mask (Vips::Image) —
Input matrix image
opts (Hash) —
Set of options

Options Hash (**opts):

:times (Integer) —
Rotate and convolve this many times
:angle (Vips::Angle45) —
Rotate mask by this much between convolutions
:combine (Vips::Combine) —
Combine convolution results like this
:precision (Vips::Precision) —
Convolve with this precision
:layers (Integer) —
Use this many layers in approximation
:cluster (Integer) —
Cluster lines closer than this in approximation

Returns:

(Vips::Image) —
Output image

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

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

Perform a complex operation on an image.

Parameters:

cmplx (Vips::OperationComplex) —
Complex to perform
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Complex binary operations on two images.

Parameters:

right (Vips::Image) —
Right-hand image argument
cmplx (Vips::OperationComplex2) —
Binary complex operation to perform
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Form a complex image from two real images.

Parameters:

right (Vips::Image) —
Right-hand image argument
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Get a component from a complex image.

Parameters:

get (Vips::OperationComplexget) —
Complex to perform
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

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

Parameters:

overlay (Image, Array<Image>) —
images to composite
mode (BlendMode, Array<BlendMode>) —
blend modes to use
opts (Hash) —
Set of options

Options Hash (**opts):

:x (Array<Integer>) —
x positions of overlay
:y (Array<Integer>) —
y positions of overlay
:compositing_space (Vips::Interpretation) —
Composite images in this colour space
:premultiplied (Boolean) —
Images have premultiplied alpha

Returns:

(Image) —
blended image

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

def composite overlay, mode, **opts
  unless overlay.is_a? Array
    overlay = [overlay]
  end
  unless mode.is_a? Array
    mode = [mode]
  end

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

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

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

Blend a pair of images with a blend mode.

Parameters:

overlay (Vips::Image) —
Overlay image
mode (Vips::BlendMode) —
VipsBlendMode to join with
opts (Hash) —
Set of options

Options Hash (**opts):

:x (Integer) —
x position of overlay
:y (Integer) —
y position of overlay
:compositing_space (Vips::Interpretation) —
Composite images in this colour space
:premultiplied (Boolean) —
Images have premultiplied alpha

Returns:

(Vips::Image) —
Output image

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

#conj ⇒ `Image`

Return the complex conjugate of an image.

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

Returns:

(Image) —
complex conjugate



1431
1432
1433

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

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

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

Convolution operation.

Parameters:

mask (Vips::Image) —
Input matrix image
opts (Hash) —
Set of options

Options Hash (**opts):

:precision (Vips::Precision) —
Convolve with this precision
:layers (Integer) —
Use this many layers in approximation
:cluster (Integer) —
Cluster lines closer than this in approximation

Returns:

(Vips::Image) —
Output image

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

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

Approximate integer convolution.

Parameters:

mask (Vips::Image) —
Input matrix image
opts (Hash) —
Set of options

Options Hash (**opts):

:layers (Integer) —
Use this many layers in approximation
:cluster (Integer) —
Cluster lines closer than this in approximation

Returns:

(Vips::Image) —
Output image

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

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

Approximate separable integer convolution.

Parameters:

mask (Vips::Image) —
Input matrix image
opts (Hash) —
Set of options

Options Hash (**opts):

:layers (Integer) —
Use this many layers in approximation

Returns:

(Vips::Image) —
Output image

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

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

Float convolution operation.

Parameters:

mask (Vips::Image) —
Input matrix image
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Int convolution operation.

Parameters:

mask (Vips::Image) —
Input matrix image
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Separable convolution operation.

Parameters:

mask (Vips::Image) —
Input matrix image
opts (Hash) —
Set of options

Options Hash (**opts):

:precision (Vips::Precision) —
Convolve with this precision
:layers (Integer) —
Use this many layers in approximation
:cluster (Integer) —
Cluster lines closer than this in approximation

Returns:

(Vips::Image) —
Output image

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

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

Copy an image.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:width (Integer) —
Image width in pixels
:height (Integer) —
Image height in pixels
:bands (Integer) —
Number of bands in image
:format (Vips::BandFormat) —
Pixel format in image
:coding (Vips::Coding) —
Pixel coding
:interpretation (Vips::Interpretation) —
Pixel interpretation
:xres (Float) —
Horizontal resolution in pixels/mm
:yres (Float) —
Vertical resolution in pixels/mm
:xoffset (Integer) —
Horizontal offset of origin
:yoffset (Integer) —
Vertical offset of origin

Returns:

(Vips::Image) —
Output image

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

#copy_memory ⇒ `Image`

Copy an image to a memory area.

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

Returns:

(Image) —
new memory image

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

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

#cos ⇒ `Image`

Return the cosine of an image in degrees.

Returns:

(Image) —
cosine of each pixel



1453
1454
1455

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

def cos
  math :cos
end

#cosh ⇒ `Image`

Return the hyperbolic cosine of an image in radians.

Returns:

(Image) —
cosine of each pixel



1495
1496
1497

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

def cosh
  math :cosh
end

#countlines(direction, **opts) ⇒ `Float`

Count lines in an image.

Parameters:

direction (Vips::Direction) —
Countlines left-right or up-down
opts (Hash) —
Set of options

Returns:

(Float) —
Number of lines

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

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

Extract an area from an image.

Parameters:

left (Integer) —
Left edge of extract area
top (Integer) —
Top edge of extract area
width (Integer) —
Width of extract area
height (Integer) —
Height of extract area
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#cross_phase(other) ⇒ `Image`

Calculate the cross phase of two images.

Parameters:

other (Image, Real, Array<Real>) —
cross phase with this

Returns:

(Image) —
cross phase



1439
1440
1441

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

def cross_phase other
  complex2 other, :cross_phase
end

#csvsave(filename, **opts) ⇒ `nil`

Save image to csv.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:separator (String) —
Separator characters
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#csvsave_target(target, **opts) ⇒ `nil`

Save image to csv.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:separator (String) —
Separator characters
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

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

Calculate de00.

Parameters:

right (Vips::Image) —
Right-hand input image
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Calculate de76.

Parameters:

right (Vips::Image) —
Right-hand input image
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Calculate decmc.

Parameters:

right (Vips::Image) —
Right-hand input image
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#deviate(**opts) ⇒ `Float`

Find image standard deviation.

Parameters:

opts (Hash) —
Set of options

Returns:

(Float) —
Output value

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

#dilate(mask) ⇒ `Image`

Dilate with a structuring element.

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

Parameters:

mask (Image, Array<Real>, Array<Array<Real>>) —
structuring element

Returns:

(Image) —
dilated image



1589
1590
1591

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

def dilate mask
  morph mask, :dilate
end

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

Divide two images.

Parameters:

right (Vips::Image) —
Right-hand image argument
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Draw a circle on an image.

Parameters:

ink (Array<Double>) —
Color for pixels
cx (Integer) —
Centre of draw_circle
cy (Integer) —
Centre of draw_circle
radius (Integer) —
Radius in pixels
opts (Hash) —
Set of options

Options Hash (**opts):

:fill (Boolean) —
Draw a solid object

Returns:

(Vips::Image) —
Image to draw on

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

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

Flood-fill an area.

Parameters:

ink (Array<Double>) —
Color for pixels
x (Integer) —
DrawFlood start point
y (Integer) —
DrawFlood start point
opts (Hash) —
Set of options

Options Hash (**opts):

:test (Vips::Image) —
Test pixels in this image
:equal (Boolean) —
DrawFlood while equal to edge
:left (Integer) —
Output Left edge of modified area
:top (Integer) —
Output Top edge of modified area
:width (Integer) —
Output Width of modified area
:height (Integer) —
Output Height of modified area

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Image to draw on, Hash of optional output items

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

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

Paint an image into another image.

Parameters:

sub (Vips::Image) —
Sub-image to insert into main image
x (Integer) —
Draw image here
y (Integer) —
Draw image here
opts (Hash) —
Set of options

Options Hash (**opts):

:mode (Vips::CombineMode) —
Combining mode

Returns:

(Vips::Image) —
Image to draw on

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

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

Draw a line on an image.

Parameters:

ink (Array<Double>) —
Color for pixels
x1 (Integer) —
Start of draw_line
y1 (Integer) —
Start of draw_line
x2 (Integer) —
End of draw_line
y2 (Integer) —
End of draw_line
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Image to draw on

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

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

Draw a mask on an image.

Parameters:

ink (Array<Double>) —
Color for pixels
mask (Vips::Image) —
Mask of pixels to draw
x (Integer) —
Draw mask here
y (Integer) —
Draw mask here
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Image to draw on

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

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

Draw a point on an image.

See #draw_rect.

Returns:

(Image) —
modified image



1029
1030
1031

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

def draw_point ink, left, top, **opts
  draw_rect ink, left, top, 1, 1, **opts
end

#draw_rect(ink, left, top, width, height, **opts) ⇒ `Vips::Image`

Paint a rectangle on an image.

Parameters:

ink (Array<Double>) —
Color for pixels
left (Integer) —
Rect to fill
top (Integer) —
Rect to fill
width (Integer) —
Rect to fill
height (Integer) —
Rect to fill
opts (Hash) —
Set of options

Options Hash (**opts):

:fill (Boolean) —
Draw a solid object

Returns:

(Vips::Image) —
Image to draw on

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

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

Blur a rectangle on an image.

Parameters:

left (Integer) —
Rect to fill
top (Integer) —
Rect to fill
width (Integer) —
Rect to fill
height (Integer) —
Rect to fill
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Image to draw on

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

#dzsave(filename, **opts) ⇒ `nil`

Save image to deepzoom file.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:imagename (String) —
Image name
:layout (Vips::ForeignDzLayout) —
Directory layout
: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
: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
:id (String) —
Resource ID
:Q (Integer) —
Q factor
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#dzsave_buffer(**opts) ⇒ `VipsBlob`

Save image to dz buffer.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:imagename (String) —
Image name
:layout (Vips::ForeignDzLayout) —
Directory layout
: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
: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
:id (String) —
Resource ID
:Q (Integer) —
Q factor
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(VipsBlob) —
Buffer to save to

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

#dzsave_target(target, **opts) ⇒ `nil`

Save image to deepzoom target.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:imagename (String) —
Image name
:layout (Vips::ForeignDzLayout) —
Directory layout
: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
: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
:id (String) —
Resource ID
:Q (Integer) —
Q factor
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

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

Embed an image in a larger image.

Parameters:

x (Integer) —
Left edge of input in output
y (Integer) —
Top edge of input in output
width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
opts (Hash) —
Set of options

Options Hash (**opts):

:extend (Vips::Extend) —
How to generate the extra pixels
:background (Array<Double>) —
Color for background pixels

Returns:

(Vips::Image) —
Output image

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

#erode(mask) ⇒ `Image`

Erode with a structuring element.

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

Parameters:

mask (Image, Array<Real>, Array<Array<Real>>) —
structuring element

Returns:

(Image) —
eroded image



1577
1578
1579

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

def erode mask
  morph mask, :erode
end

#exp ⇒ `Image`

Return e ** pixel.

Returns:

(Image) —
e ** pixel



1544
1545
1546

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

def exp
  math :exp
end

#exp10 ⇒ `Image`

Return 10 ** pixel.

Returns:

(Image) —
10 ** pixel



1551
1552
1553

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

def exp10
  math :exp10
end

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

Extract an area from an image.

Parameters:

left (Integer) —
Left edge of extract area
top (Integer) —
Top edge of extract area
width (Integer) —
Width of extract area
height (Integer) —
Height of extract area
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Extract band from an image.

Parameters:

band (Integer) —
Band to extract
opts (Hash) —
Set of options

Options Hash (**opts):

:n (Integer) —
Number of bands to extract

Returns:

(Vips::Image) —
Output image

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

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

False-color an image.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Fast correlation.

Parameters:

ref (Vips::Image) —
Input reference image
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#filename ⇒ `String`

Get image filename, if any.

Returns:

(String) —
image filename



932
933
934

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

def filename
  get "filename"
end

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

Fill image zeros with nearest non-zero pixel.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:distance (Vips::Image) —
Output Distance to nearest non-zero pixel

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Value of nearest non-zero pixel, Hash of optional output items

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

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

Search an image for non-edge areas.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:threshold (Float) —
Object threshold
:background (Array<Double>) —
Color for background pixels
:line_art (Boolean) —
Enable line art mode

Returns:

(Array<Integer, Integer, Integer, Integer>) —
Left edge of image, Top edge of extract area, Width of extract area, Height of extract area

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

#fitssave(filename, **opts) ⇒ `nil`

Save image to fits file.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

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

Flatten alpha out of an image.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:background (Array<Double>) —
Background value
:max_alpha (Float) —
Maximum value of alpha channel

Returns:

(Vips::Image) —
Output image

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

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

Flip an image.

Parameters:

direction (Vips::Direction) —
Direction to flip image
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#fliphor ⇒ `Image`

Flip horizontally.

Returns:

(Image) —
image flipped horizontally



1558
1559
1560

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

def fliphor
  flip :horizontal
end

#flipver ⇒ `Image`

Flip vertically.

Returns:

(Image) —
image flipped vertically



1565
1566
1567

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

def flipver
  flip :vertical
end

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

Transform float rgb to radiance coding.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#floor ⇒ `Image`

Return the largest integral value not greater than the argument.

Returns:

(Image) —
floor of image



1262
1263
1264

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

def floor
  round :floor
end

#format ⇒ `Symbol`

Get image format.

Returns:

(Symbol) —
image format



911
912
913

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

def format
  get "format"
end

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

Frequency-domain filtering.

Parameters:

mask (Vips::Image) —
Input mask image
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Forward fft.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Gamma an image.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:exponent (Float) —
Gamma factor

Returns:

(Vips::Image) —
Output image

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

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

Gaussian blur.

Parameters:

sigma (Float) —
Sigma of Gaussian
opts (Hash) —
Set of options

Options Hash (**opts):

:min_ampl (Float) —
Minimum amplitude of Gaussian
:precision (Vips::Precision) —
Convolve with this precision

Returns:

(Vips::Image) —
Output image

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

#get(name) ⇒ `Object`

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

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

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

and profile will be an array containing the profile.

Parameters:

name (String) —
Metadata field to get

Returns:

(Object) —
Value of field

Raises:

(Vips::Error)

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

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.

Returns:

([String]) —
array of field names

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

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_gainmap ⇒ `Image`

Get the gainmap (if any) from an image.

After modifying the gainmap, you should write it back to the image in a mutable block, see [#mutate], in the field "gainmap".

For example:

gainmap = image.get_gainmap
unless gainmap.nil?
  new_gainmap = gainmap.crop left, top, width, height
  image = image.mutate do |x|
    x.set_type! Vips::IMAGE_TYPE, "gainmap", new_gainmap
  end
end

Returns:

(Image) —
the gainmap image, or nil

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

def get_gainmap
  if Vips.at_least_libvips?(8, 18)
    vi = Vips.vips_image_get_gainmap self
    Image.new(vi) unless vi.null?
  end
end

#get_typeof(name) ⇒ `Integer`

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

Parameters:

name (String) —
Metadata field to fetch

Returns:

(Integer) —
GType

See Also:

#get

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

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



876
877
878

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

def get_value name
  get name
end

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

Read a point from an image.

Parameters:

x (Integer) —
Point to read
y (Integer) —
Point to read
opts (Hash) —
Set of options

Options Hash (**opts):

:unpack_complex (Boolean) —
Complex pixels should be unpacked

Returns:

(Array<Double>) —
Array of output values

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

#gifsave(filename, **opts) ⇒ `nil`

Save as gif.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:dither (Float) —
Amount of dithering
:effort (Integer) —
Quantisation effort
:bitdepth (Integer) —
Number of bits per pixel
:interframe_maxerror (Float) —
Maximum inter-frame error for transparency
:reuse (Boolean) —
Reuse palette from input
:interpalette_maxerror (Float) —
Maximum inter-palette error for palette reusage
:interlace (Boolean) —
Generate an interlaced (progressive) GIF
:keep_duplicate_frames (Boolean) —
Keep duplicate frames in the output instead of combining them
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#gifsave_buffer(**opts) ⇒ `VipsBlob`

Save as gif.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:dither (Float) —
Amount of dithering
:effort (Integer) —
Quantisation effort
:bitdepth (Integer) —
Number of bits per pixel
:interframe_maxerror (Float) —
Maximum inter-frame error for transparency
:reuse (Boolean) —
Reuse palette from input
:interpalette_maxerror (Float) —
Maximum inter-palette error for palette reusage
:interlace (Boolean) —
Generate an interlaced (progressive) GIF
:keep_duplicate_frames (Boolean) —
Keep duplicate frames in the output instead of combining them
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(VipsBlob) —
Buffer to save to

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

#gifsave_target(target, **opts) ⇒ `nil`

Save as gif.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:dither (Float) —
Amount of dithering
:effort (Integer) —
Quantisation effort
:bitdepth (Integer) —
Number of bits per pixel
:interframe_maxerror (Float) —
Maximum inter-frame error for transparency
:reuse (Boolean) —
Reuse palette from input
:interpalette_maxerror (Float) —
Maximum inter-palette error for palette reusage
:interlace (Boolean) —
Generate an interlaced (progressive) GIF
:keep_duplicate_frames (Boolean) —
Keep duplicate frames in the output instead of combining them
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

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

Global balance an image mosaic.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:gamma (Float) —
Image gamma
:int_output (Boolean) —
Integer output

Returns:

(Vips::Image) —
Output image

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

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

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

Parameters:

direction (Vips::CompassDirection) —
Direction to place image within width/height
width (Integer) —
Image width in pixels
height (Integer) —
Image height in pixels
opts (Hash) —
Set of options

Options Hash (**opts):

:extend (Vips::Extend) —
How to generate the extra pixels
:background (Array<Double>) —
Color for background pixels

Returns:

(Vips::Image) —
Output image

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

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

Grid an image.

Parameters:

tile_height (Integer) —
Chop into tiles this high
across (Integer) —
Number of tiles across
down (Integer) —
Number of tiles down
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#has_alpha? ⇒ `Boolean`

Detect if image has an alpha channel

Returns:

(Boolean) —
true if image has an alpha channel.



993
994
995

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

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

#heifsave(filename, **opts) ⇒ `nil`

Save image in heif format.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:Q (Integer) —
Q factor
:bitdepth (Integer) —
Number of bits per pixel
:lossless (Boolean) —
Enable lossless compression
:compression (Vips::ForeignHeifCompression) —
Compression format
:effort (Integer) —
CPU effort
:subsample_mode (Vips::ForeignSubsample) —
Select chroma subsample operation mode
:encoder (Vips::ForeignHeifEncoder) —
Select encoder to use
:tune (String) —
Tuning parameters
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#heifsave_buffer(**opts) ⇒ `VipsBlob`

Save image in heif format.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:Q (Integer) —
Q factor
:bitdepth (Integer) —
Number of bits per pixel
:lossless (Boolean) —
Enable lossless compression
:compression (Vips::ForeignHeifCompression) —
Compression format
:effort (Integer) —
CPU effort
:subsample_mode (Vips::ForeignSubsample) —
Select chroma subsample operation mode
:encoder (Vips::ForeignHeifEncoder) —
Select encoder to use
:tune (String) —
Tuning parameters
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(VipsBlob) —
Buffer to save to

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

#heifsave_target(target, **opts) ⇒ `nil`

Save image in heif format.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:Q (Integer) —
Q factor
:bitdepth (Integer) —
Number of bits per pixel
:lossless (Boolean) —
Enable lossless compression
:compression (Vips::ForeignHeifCompression) —
Compression format
:effort (Integer) —
CPU effort
:subsample_mode (Vips::ForeignSubsample) —
Select chroma subsample operation mode
:encoder (Vips::ForeignHeifEncoder) —
Select encoder to use
:tune (String) —
Tuning parameters
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#height ⇒ `Integer`

Get image height, in pixels.

Returns:

(Integer) —
image height, in pixels



897
898
899

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

def height
  Vips.vips_image_get_height self
end

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

Form cumulative histogram.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#hist_entropy(**opts) ⇒ `Float`

Estimate image entropy.

Parameters:

opts (Hash) —
Set of options

Returns:

(Float) —
Output value

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

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

Histogram equalisation.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:band (Integer) —
Equalise with this band

Returns:

(Vips::Image) —
Output image

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

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

Find image histogram.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:band (Integer) —
Find histogram of band

Returns:

(Vips::Image) —
Output histogram

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

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

Find indexed image histogram.

Parameters:

index (Vips::Image) —
Index image
opts (Hash) —
Set of options

Options Hash (**opts):

:combine (Vips::Combine) —
Combine bins like this

Returns:

(Vips::Image) —
Output histogram

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

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

Find n-dimensional image histogram.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:bins (Integer) —
Number of bins in each dimension

Returns:

(Vips::Image) —
Output histogram

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

#hist_ismonotonic(**opts) ⇒ `Boolean`

Test for monotonicity.

Parameters:

opts (Hash) —
Set of options

Returns:

(Boolean) —
true if in is monotonic

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

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

Local histogram equalisation.

Parameters:

width (Integer) —
Window width in pixels
height (Integer) —
Window height in pixels
opts (Hash) —
Set of options

Options Hash (**opts):

:max_slope (Integer) —
Maximum slope (CLAHE)

Returns:

(Vips::Image) —
Output image

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

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

Match two histograms.

Parameters:

ref (Vips::Image) —
Reference histogram
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Normalise histogram.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Plot histogram.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Find hough circle transform.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:scale (Integer) —
Scale down dimensions by this factor
:min_radius (Integer) —
Smallest radius to search for
:max_radius (Integer) —
Largest radius to search for

Returns:

(Vips::Image) —
Output image

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

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

Find hough line transform.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:width (Integer) —
Horizontal size of parameter space
:height (Integer) —
Vertical size of parameter space

Returns:

(Vips::Image) —
Output image

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

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

Transform hsv to srgb.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Output to device with icc profile.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:pcs (Vips::PCS) —
Set Profile Connection Space
:intent (Vips::Intent) —
Rendering intent
:black_point_compensation (Boolean) —
Enable black point compensation
:output_profile (String) —
Filename to load output profile from
:depth (Integer) —
Output device space depth in bits

Returns:

(Vips::Image) —
Output image

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

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

Import from device with icc profile.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:pcs (Vips::PCS) —
Set Profile Connection Space
:intent (Vips::Intent) —
Rendering intent
:black_point_compensation (Boolean) —
Enable black point compensation
:embedded (Boolean) —
Use embedded input profile, if available
:input_profile (String) —
Filename to load input profile from

Returns:

(Vips::Image) —
Output image

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

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

Transform between devices with icc profiles.

Parameters:

output_profile (String) —
Filename to load output profile from
opts (Hash) —
Set of options

Options Hash (**opts):

:pcs (Vips::PCS) —
Set Profile Connection Space
:intent (Vips::Intent) —
Rendering intent
:black_point_compensation (Boolean) —
Enable black point compensation
:embedded (Boolean) —
Use embedded input profile, if available
:input_profile (String) —
Filename to load input profile from
:depth (Integer) —
Output device space depth in bits

Returns:

(Vips::Image) —
Output image

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

#ifthenelse(th, el, **opts) ⇒ `Image`

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

Parameters:

th (Image, Real, Array<Real>) —
true values
el (Image, Real, Array<Real>) —
false values
opts (Hash) —
set of options

Options Hash (**opts):

:blend (Boolean) — default: false —
Blend smoothly between th and el

Returns:

(Image) —
merged image

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

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

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

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

#imag ⇒ `Image`

Return the imaginary part of a complex image.

Returns:

(Image) —
imaginary part of complex image



1393
1394
1395

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

def imag
  complexget :imag
end

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

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

Parameters:

sub (Vips::Image) —
Sub-image to insert into main image
x (Integer) —
Left edge of sub in main
y (Integer) —
Top edge of sub in main
opts (Hash) —
Set of options

Options Hash (**opts):

:expand (Boolean) —
Expand output to hold all of both inputs
:background (Array<Double>) —
Color for new pixels

Returns:

(Vips::Image) —
Output image

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

#inspect ⇒ `Object`



198
199
200

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

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

#interpretation ⇒ `Symbol`

Get image interpretation.

Returns:

(Symbol) —
image interpretation



918
919
920

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

def interpretation
  get "interpretation"
end

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

Invert an image.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Build an inverted look-up table.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:size (Integer) —
LUT size to generate

Returns:

(Vips::Image) —
Output image

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

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

Inverse fft.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:real (Boolean) —
Output only the real part of the transform

Returns:

(Vips::Image) —
Output image

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

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

Join a pair of images.

Parameters:

in2 (Vips::Image) —
Second input image
direction (Vips::Direction) —
Join left-right or up-down
opts (Hash) —
Set of options

Options Hash (**opts):

:expand (Boolean) —
Expand output to hold all of both inputs
:shim (Integer) —
Pixels between images
:background (Array<Double>) —
Colour for new pixels
:align (Vips::Align) —
Align on the low, centre or high coordinate edge

Returns:

(Vips::Image) —
Output image

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

#jp2ksave(filename, **opts) ⇒ `nil`

Save image in jpeg2000 format.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:tile_width (Integer) —
Tile width in pixels
:tile_height (Integer) —
Tile height in pixels
:lossless (Boolean) —
Enable lossless compression
:Q (Integer) —
Q factor
:subsample_mode (Vips::ForeignSubsample) —
Select chroma subsample operation mode
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#jp2ksave_buffer(**opts) ⇒ `VipsBlob`

Save image in jpeg2000 format.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:tile_width (Integer) —
Tile width in pixels
:tile_height (Integer) —
Tile height in pixels
:lossless (Boolean) —
Enable lossless compression
:Q (Integer) —
Q factor
:subsample_mode (Vips::ForeignSubsample) —
Select chroma subsample operation mode
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(VipsBlob) —
Buffer to save to

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

#jp2ksave_target(target, **opts) ⇒ `nil`

Save image in jpeg2000 format.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:tile_width (Integer) —
Tile width in pixels
:tile_height (Integer) —
Tile height in pixels
:lossless (Boolean) —
Enable lossless compression
:Q (Integer) —
Q factor
:subsample_mode (Vips::ForeignSubsample) —
Select chroma subsample operation mode
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#jpegsave(filename, **opts) ⇒ `nil`

Save as jpeg.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:Q (Integer) —
Q factor
:optimize_coding (Boolean) —
Compute optimal Huffman coding tables
:interlace (Boolean) —
Generate an interlaced (progressive) jpeg
:trellis_quant (Boolean) —
Apply trellis quantisation to each 8x8 block
:overshoot_deringing (Boolean) —
Apply overshooting to samples with extreme values
:optimize_scans (Boolean) —
Split spectrum of DCT coefficients into separate scans
:quant_table (Integer) —
Use predefined quantization table with given index
:subsample_mode (Vips::ForeignSubsample) —
Select chroma subsample operation mode
:restart_interval (Integer) —
Add restart markers every specified number of mcu
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#jpegsave_buffer(**opts) ⇒ `VipsBlob`

Save as jpeg.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:Q (Integer) —
Q factor
:optimize_coding (Boolean) —
Compute optimal Huffman coding tables
:interlace (Boolean) —
Generate an interlaced (progressive) jpeg
:trellis_quant (Boolean) —
Apply trellis quantisation to each 8x8 block
:overshoot_deringing (Boolean) —
Apply overshooting to samples with extreme values
:optimize_scans (Boolean) —
Split spectrum of DCT coefficients into separate scans
:quant_table (Integer) —
Use predefined quantization table with given index
:subsample_mode (Vips::ForeignSubsample) —
Select chroma subsample operation mode
:restart_interval (Integer) —
Add restart markers every specified number of mcu
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(VipsBlob) —
Buffer to save to

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

#jpegsave_mime(**opts) ⇒ `nil`

Save image to jpeg mime.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:Q (Integer) —
Q factor
:optimize_coding (Boolean) —
Compute optimal Huffman coding tables
:interlace (Boolean) —
Generate an interlaced (progressive) jpeg
:trellis_quant (Boolean) —
Apply trellis quantisation to each 8x8 block
:overshoot_deringing (Boolean) —
Apply overshooting to samples with extreme values
:optimize_scans (Boolean) —
Split spectrum of DCT coefficients into separate scans
:quant_table (Integer) —
Use predefined quantization table with given index
:subsample_mode (Vips::ForeignSubsample) —
Select chroma subsample operation mode
:restart_interval (Integer) —
Add restart markers every specified number of mcu
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#jpegsave_target(target, **opts) ⇒ `nil`

Save as jpeg.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:Q (Integer) —
Q factor
:optimize_coding (Boolean) —
Compute optimal Huffman coding tables
:interlace (Boolean) —
Generate an interlaced (progressive) jpeg
:trellis_quant (Boolean) —
Apply trellis quantisation to each 8x8 block
:overshoot_deringing (Boolean) —
Apply overshooting to samples with extreme values
:optimize_scans (Boolean) —
Split spectrum of DCT coefficients into separate scans
:quant_table (Integer) —
Use predefined quantization table with given index
:subsample_mode (Vips::ForeignSubsample) —
Select chroma subsample operation mode
:restart_interval (Integer) —
Add restart markers every specified number of mcu
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#jxlsave(filename, **opts) ⇒ `nil`

Save image in jpeg-xl format.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:tier (Integer) —
Decode speed tier
:distance (Float) —
Target butteraugli distance
:effort (Integer) —
Encoding effort
:lossless (Boolean) —
Enable lossless compression
:Q (Integer) —
Quality factor
:bitdepth (Integer) —
Bit depth
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#jxlsave_buffer(**opts) ⇒ `VipsBlob`

Save image in jpeg-xl format.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:tier (Integer) —
Decode speed tier
:distance (Float) —
Target butteraugli distance
:effort (Integer) —
Encoding effort
:lossless (Boolean) —
Enable lossless compression
:Q (Integer) —
Quality factor
:bitdepth (Integer) —
Bit depth
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(VipsBlob) —
Buffer to save to

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

#jxlsave_target(target, **opts) ⇒ `nil`

Save image in jpeg-xl format.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:tier (Integer) —
Decode speed tier
:distance (Float) —
Target butteraugli distance
:effort (Integer) —
Encoding effort
:lossless (Boolean) —
Enable lossless compression
:Q (Integer) —
Quality factor
:bitdepth (Integer) —
Bit depth
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

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

Transform float lab to labq coding.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Transform float lab to signed short.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Transform lab to lch.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Transform cielab to xyz.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:temp (Array<Double>) —
Color temperature

Returns:

(Vips::Image) —
Output image

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

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

Label regions in an image.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:segments (Integer) —
Output Number of discrete contiguous regions

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Mask of region labels, Hash of optional output items

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

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

Unpack a labq image to float lab.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Unpack a labq image to short lab.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Convert a labq image to srgb.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Transform signed short lab to float.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Transform short lab to labq coding.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Transform lch to cmc.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Transform lch to lab.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Calculate (a * in + b).

Parameters:

a (Array<Double>) —
Multiply by this
b (Array<Double>) —
Add this
opts (Hash) —
Set of options

Options Hash (**opts):

:uchar (Boolean) —
Output should be uchar

Returns:

(Vips::Image) —
Output image

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

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

Cache an image as a set of lines.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:tile_height (Integer) —
Tile height in pixels
:access (Vips::Access) —
Expected access pattern
:threaded (Boolean) —
Allow threaded access
:persistent (Boolean) —
Keep cache between evaluations

Returns:

(Vips::Image) —
Output image

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

#log ⇒ `Image`

Return the natural log of an image.

Returns:

(Image) —
natural log of each pixel



1530
1531
1532

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

def log
  math :log
end

#log10 ⇒ `Image`

Return the log base 10 of an image.

Returns:

(Image) —
base 10 log of each pixel



1537
1538
1539

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

def log10
  math :log10
end

#magicksave(filename, **opts) ⇒ `nil`

Save file with imagemagick.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:format (String) —
Format to save in
:quality (Integer) —
Quality to use
:optimize_gif_frames (Boolean) —
Apply GIF frames optimization
:optimize_gif_transparency (Boolean) —
Apply GIF transparency optimization
:bitdepth (Integer) —
Number of bits per pixel
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#magicksave_buffer(**opts) ⇒ `VipsBlob`

Save image to magick buffer.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:format (String) —
Format to save in
:quality (Integer) —
Quality to use
:optimize_gif_frames (Boolean) —
Apply GIF frames optimization
:optimize_gif_transparency (Boolean) —
Apply GIF transparency optimization
:bitdepth (Integer) —
Number of bits per pixel
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(VipsBlob) —
Buffer to save to

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

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

Resample with a map image.

Parameters:

index (Vips::Image) —
Index pixels with this
opts (Hash) —
Set of options

Options Hash (**opts):

:interpolate (Vips::Interpolate) —
Interpolate pixels with this
:background (Array<Double>) —
Background value
:premultiplied (Boolean) —
Images have premultiplied alpha
:extend (Vips::Extend) —
How to generate the extra pixels

Returns:

(Vips::Image) —
Output image

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

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

Map an image though a lut.

Parameters:

lut (Vips::Image) —
Look-up table image
opts (Hash) —
Set of options

Options Hash (**opts):

:band (Integer) —
Apply one-band lut to this band of in

Returns:

(Vips::Image) —
Output image

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

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

First-order match of two images.

Parameters:

sec (Vips::Image) —
Secondary image
xr1 (Integer) —
Position of first reference tie-point
yr1 (Integer) —
Position of first reference tie-point
xs1 (Integer) —
Position of first secondary tie-point
ys1 (Integer) —
Position of first secondary tie-point
xr2 (Integer) —
Position of second reference tie-point
yr2 (Integer) —
Position of second reference tie-point
xs2 (Integer) —
Position of second secondary tie-point
ys2 (Integer) —
Position of second secondary tie-point
opts (Hash) —
Set of options

Options Hash (**opts):

:hwindow (Integer) —
Half window size
:harea (Integer) —
Half area size
:search (Boolean) —
Search to improve tie-points
:interpolate (Vips::Interpolate) —
Interpolate pixels with this

Returns:

(Vips::Image) —
Output image

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

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

Apply a math operation to an image.

Parameters:

math (Vips::OperationMath) —
Math to perform
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Binary math operations.

Parameters:

right (Vips::Image) —
Right-hand image argument
math2 (Vips::OperationMath2) —
Math to perform
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Binary math operations with a constant.

Parameters:

math2 (Vips::OperationMath2) —
Math to perform
c (Array<Double>) —
Array of constants
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Invert a matrix.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output matrix

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

#matrixmultiply(right, **opts) ⇒ `Vips::Image`

Multiply two matrices.

Parameters:

right (Vips::Image) —
Second matrix to multiply
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output matrix

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

#matrixprint(**opts) ⇒ `nil`

Print matrix.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#matrixsave(filename, **opts) ⇒ `nil`

Save image to matrix.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#matrixsave_target(target, **opts) ⇒ `nil`

Save image to matrix.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

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

Find image maximum.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:size (Integer) —
Number of maximum values to find
:x (Integer) —
Output Horizontal position of maximum
:y (Integer) —
Output Vertical position of maximum
:out_array (Array<Double>) —
Output Array of output values
:x_array (Array<Integer>) —
Output Array of horizontal positions
:y_array (Array<Integer>) —
Output Array of vertical positions

Returns:

(Float, Hash<Symbol => Object>) —
Output value, Hash of optional output items

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

#maxpair(right, **opts) ⇒ `Vips::Image`

Maximum of a pair of images.

Parameters:

right (Vips::Image) —
Right-hand image argument
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#maxpos ⇒ `Real`

Return the coordinates of the image maximum.

Returns:

(Real, Real, Real) —
maximum value, x coordinate of maximum, y coordinate of maximum

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

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

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

Measure a set of patches on a color chart.

Parameters:

h (Integer) —
Number of patches across chart
v (Integer) —
Number of patches down chart
opts (Hash) —
Set of options

Options Hash (**opts):

:left (Integer) —
Left edge of extract area
:top (Integer) —
Top edge of extract area
:width (Integer) —
Width of extract area
:height (Integer) —
Height of extract area

Returns:

(Vips::Image) —
Output array of statistics

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

#median(size = 3) ⇒ `Image`

a median filter

Parameters:

size (Integer) (defaults to: 3) —
size of filter window

Returns:

(Image) —
result of median filter



1379
1380
1381

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

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

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

Merge two images.

Parameters:

sec (Vips::Image) —
Secondary image
direction (Vips::Direction) —
Horizontal or vertical merge
dx (Integer) —
Horizontal displacement from sec to ref
dy (Integer) —
Vertical displacement from sec to ref
opts (Hash) —
Set of options

Options Hash (**opts):

:mblend (Integer) —
Maximum blend size

Returns:

(Vips::Image) —
Output image

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

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

Find image minimum.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:size (Integer) —
Number of minimum values to find
:x (Integer) —
Output Horizontal position of minimum
:y (Integer) —
Output Vertical position of minimum
:out_array (Array<Double>) —
Output Array of output values
:x_array (Array<Integer>) —
Output Array of horizontal positions
:y_array (Array<Integer>) —
Output Array of vertical positions

Returns:

(Float, Hash<Symbol => Object>) —
Output value, Hash of optional output items

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

#minpair(right, **opts) ⇒ `Vips::Image`

Minimum of a pair of images.

Parameters:

right (Vips::Image) —
Right-hand image argument
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#minpos ⇒ `Real`

Return the coordinates of the image minimum.

Returns:

(Real, Real, Real) —
minimum value, x coordinate of minimum, y coordinate of minimum

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

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

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

Morphology operation.

Parameters:

mask (Vips::Image) —
Input matrix image
morph (Vips::OperationMorphology) —
Morphological operation to perform
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Mosaic two images.

Parameters:

sec (Vips::Image) —
Secondary image
direction (Vips::Direction) —
Horizontal or vertical mosaic
xref (Integer) —
Position of reference tie-point
yref (Integer) —
Position of reference tie-point
xsec (Integer) —
Position of secondary tie-point
ysec (Integer) —
Position of secondary tie-point
opts (Hash) —
Set of options

Options Hash (**opts):

:hwindow (Integer) —
Half window size
:harea (Integer) —
Half area size
:mblend (Integer) —
Maximum blend size
:bandno (Integer) —
Band to search for features on
:dx0 (Integer) —
Output Detected integer offset
:dy0 (Integer) —
Output Detected integer offset
:scale1 (Float) —
Output Detected scale
:angle1 (Float) —
Output Detected rotation
:dy1 (Float) —
Output Detected first-order displacement
:dx1 (Float) —
Output Detected first-order displacement

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

First-order mosaic of two images.

Parameters:

sec (Vips::Image) —
Secondary image
direction (Vips::Direction) —
Horizontal or vertical mosaic
xr1 (Integer) —
Position of first reference tie-point
yr1 (Integer) —
Position of first reference tie-point
xs1 (Integer) —
Position of first secondary tie-point
ys1 (Integer) —
Position of first secondary tie-point
xr2 (Integer) —
Position of second reference tie-point
yr2 (Integer) —
Position of second reference tie-point
xs2 (Integer) —
Position of second secondary tie-point
ys2 (Integer) —
Position of second secondary tie-point
opts (Hash) —
Set of options

Options Hash (**opts):

:hwindow (Integer) —
Half window size
:harea (Integer) —
Half area size
:search (Boolean) —
Search to improve tie-points
:interpolate (Vips::Interpolate) —
Interpolate pixels with this
:mblend (Integer) —
Maximum blend size

Returns:

(Vips::Image) —
Output image

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

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

Pick most-significant byte from an image.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:band (Integer) —
Band to msb

Returns:

(Vips::Image) —
Output image

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

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

Multiply two images.

Parameters:

right (Vips::Image) —
Right-hand image argument
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

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

For example:

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

See MutableImage.

Yields:

(mutable)

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

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

#new_from_image(value) ⇒ `Image`

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

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

Parameters:

value (Real, Array<Real>) —
value to put in each pixel

Returns:

(Image) —
constant image

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

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

#offset ⇒ `Float`

Get offset metadata.

Returns:

(Float) —
image offset

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

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

  get "offset"
end

#Oklab2Oklch(**opts) ⇒ `Vips::Image`

Transform oklab to oklch.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#Oklab2XYZ(**opts) ⇒ `Vips::Image`

Transform oklab to xyz.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#Oklch2Oklab(**opts) ⇒ `Vips::Image`

Transform oklch to oklab.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#parent_get_typeof ⇒ `Object`

83	# File 'lib/vips/image.rb', line 83 alias_method :parent_get_typeof, :get_typeof

#percent(percent, **opts) ⇒ `Integer`

Find threshold for percent of pixels.

Parameters:

percent (Float) —
Percent of pixels
opts (Hash) —
Set of options

Returns:

(Integer) —
Threshold above which lie percent of pixels

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

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

Calculate phase correlation.

Parameters:

in2 (Vips::Image) —
Second input image
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#pngsave(filename, **opts) ⇒ `nil`

Save image to file as png.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:compression (Integer) —
Compression factor
:interlace (Boolean) —
Interlace image
:filter (Vips::ForeignPngFilter) —
libpng row filter flag(s)
:palette (Boolean) —
Quantise to 8bpp palette
:Q (Integer) —
Quantisation quality
:dither (Float) —
Amount of dithering
:bitdepth (Integer) —
Write as a 1, 2, 4, 8 or 16 bit image
:effort (Integer) —
Quantisation CPU effort
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#pngsave_buffer(**opts) ⇒ `VipsBlob`

Save image to buffer as png.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:compression (Integer) —
Compression factor
:interlace (Boolean) —
Interlace image
:filter (Vips::ForeignPngFilter) —
libpng row filter flag(s)
:palette (Boolean) —
Quantise to 8bpp palette
:Q (Integer) —
Quantisation quality
:dither (Float) —
Amount of dithering
:bitdepth (Integer) —
Write as a 1, 2, 4, 8 or 16 bit image
:effort (Integer) —
Quantisation CPU effort
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(VipsBlob) —
Buffer to save to

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

#pngsave_target(target, **opts) ⇒ `nil`

Save image to target as png.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:compression (Integer) —
Compression factor
:interlace (Boolean) —
Interlace image
:filter (Vips::ForeignPngFilter) —
libpng row filter flag(s)
:palette (Boolean) —
Quantise to 8bpp palette
:Q (Integer) —
Quantisation quality
:dither (Float) —
Amount of dithering
:bitdepth (Integer) —
Write as a 1, 2, 4, 8 or 16 bit image
:effort (Integer) —
Quantisation CPU effort
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#polar ⇒ `Image`

Return an image with rectangular pixels converted to polar.

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

Returns:

(Image) —
image converted to polar coordinates

See Also:



1406
1407
1408

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

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

#ppmsave(filename, **opts) ⇒ `nil`

Save image to ppm file.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:format (Vips::ForeignPpmFormat) —
Format to save in
:ascii (Boolean) —
Save as ascii
:bitdepth (Integer) —
Set to 1 to write as a 1 bit image
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#ppmsave_target(target, **opts) ⇒ `nil`

Save to ppm.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:format (Vips::ForeignPpmFormat) —
Format to save in
:ascii (Boolean) —
Save as ascii
:bitdepth (Integer) —
Set to 1 to write as a 1 bit image
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

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

Premultiply image alpha.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:max_alpha (Float) —
Maximum value of alpha channel

Returns:

(Vips::Image) —
Output image

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

#prewitt(**opts) ⇒ `Vips::Image`

Prewitt edge detector.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Find image profiles.

Parameters:

opts (Hash) —
Set of options

Returns:

(Array<Vips::Image, Vips::Image>) —
First non-zero pixel in column, First non-zero pixel in row

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

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

Find image projections.

Parameters:

opts (Hash) —
Set of options

Returns:

(Array<Vips::Image, Vips::Image>) —
Sums of columns, Sums of rows

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

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

Resample an image with a quadratic transform.

Parameters:

coeff (Vips::Image) —
Coefficient matrix
opts (Hash) —
Set of options

Options Hash (**opts):

:interpolate (Vips::Interpolate) —
Interpolate values with this

Returns:

(Vips::Image) —
Output image

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

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

Unpack radiance coding to float rgb.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#radsave(filename, **opts) ⇒ `nil`

Save image to radiance file.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#radsave_buffer(**opts) ⇒ `VipsBlob`

Save image to radiance buffer.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(VipsBlob) —
Buffer to save to

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

#radsave_target(target, **opts) ⇒ `nil`

Save image to radiance target.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

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

Rank filter.

Parameters:

width (Integer) —
Window width in pixels
height (Integer) —
Window height in pixels
index (Integer) —
Select pixel at index
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#rawsave(filename, **opts) ⇒ `nil`

Save image to raw file.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#rawsave_buffer(**opts) ⇒ `VipsBlob`

Write raw image to buffer.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(VipsBlob) —
Buffer to save to

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

#rawsave_target(target, **opts) ⇒ `nil`

Write raw image to target.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#real ⇒ `Image`

Return the real part of a complex image.

Returns:

(Image) —
real part of complex image



1386
1387
1388

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

def real
  complexget :real
end

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

Linear recombination with matrix.

Parameters:

m (Vips::Image) —
Matrix of coefficients
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#rect ⇒ `Image`

Return an image with polar pixels converted to rectangular.

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

Returns:

(Image) —
image converted to rectangular coordinates

See Also:



1419
1420
1421

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

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

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

Reduce an image.

Parameters:

hshrink (Float) —
Horizontal shrink factor
vshrink (Float) —
Vertical shrink factor
opts (Hash) —
Set of options

Options Hash (**opts):

:kernel (Vips::Kernel) —
Resampling kernel
:gap (Float) —
Reducing gap

Returns:

(Vips::Image) —
Output image

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

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

Shrink an image horizontally.

Parameters:

hshrink (Float) —
Horizontal shrink factor
opts (Hash) —
Set of options

Options Hash (**opts):

:kernel (Vips::Kernel) —
Resampling kernel
:gap (Float) —
Reducing gap

Returns:

(Vips::Image) —
Output image

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

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

Shrink an image vertically.

Parameters:

vshrink (Float) —
Vertical shrink factor
opts (Hash) —
Set of options

Options Hash (**opts):

:kernel (Vips::Kernel) —
Resampling kernel
:gap (Float) —
Reducing gap

Returns:

(Vips::Image) —
Output image

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

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

Relational operation on two images.

Parameters:

right (Vips::Image) —
Right-hand image argument
relational (Vips::OperationRelational) —
Relational to perform
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Relational operations against a constant.

Parameters:

relational (Vips::OperationRelational) —
Relational to perform
c (Array<Double>) —
Array of constants
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Remainder after integer division of two images.

Parameters:

right (Vips::Image) —
Right-hand image argument
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Remainder after integer division of an image and a constant.

Parameters:

c (Array<Double>) —
Array of constants
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#remosaic(old_str, new_str, **opts) ⇒ `Vips::Image`

Rebuild an mosaiced image.

Parameters:

old_str (String) —
Search for this string
new_str (String) —
And swap for this string
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#remove(name) ⇒ `Object`

This method is deprecated.

Please use MutableImage#remove! instead.



871
872
873

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

def remove name
  Vips.vips_image_remove self, name
end

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

Replicate an image.

Parameters:

across (Integer) —
Repeat this many times horizontally
down (Integer) —
Repeat this many times vertically
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Resize an image.

Parameters:

scale (Float) —
Scale image by this factor
opts (Hash) —
Set of options

Options Hash (**opts):

:kernel (Vips::Kernel) —
Resampling kernel
:gap (Float) —
Reducing gap
:vscale (Float) —
Vertical scale image by this factor

Returns:

(Vips::Image) —
Output image

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

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

Returns:

(Boolean)

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

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

  super
end

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

Returns:

(Boolean)

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

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

  super
end

#rint ⇒ `Image`

Return the nearest integral value.

Returns:

(Image) —
rint of image



1276
1277
1278

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

def rint
  round :rint
end

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

Rotate an image.

Parameters:

angle (Vips::Angle) —
Angle to rotate image
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#rot180 ⇒ `Image`

Rotate by 180 degrees clockwise.

Returns:

(Image) —
rotated image



1603
1604
1605

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

def rot180
  rot :d180
end

#rot270 ⇒ `Image`

Rotate by 270 degrees clockwise.

Returns:

(Image) —
rotated image



1610
1611
1612

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

def rot270
  rot :d270
end

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

Rotate an image.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:angle (Vips::Angle45) —
Angle to rotate image

Returns:

(Vips::Image) —
Output image

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

#rot90 ⇒ `Image`

Rotate by 90 degrees clockwise.

Returns:

(Image) —
rotated image



1596
1597
1598

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

def rot90
  rot :d90
end

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

Rotate an image by a number of degrees.

Parameters:

angle (Float) —
Rotate clockwise by this many degrees
opts (Hash) —
Set of options

Options Hash (**opts):

:interpolate (Vips::Interpolate) —
Interpolate pixels with this
:background (Array<Double>) —
Background value
:odx (Float) —
Horizontal output displacement
:ody (Float) —
Vertical output displacement
:idx (Float) —
Horizontal input displacement
:idy (Float) —
Vertical input displacement

Returns:

(Vips::Image) —
Output image

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

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

Perform a round function on an image.

Parameters:

round (Vips::OperationRound) —
Rounding operation to perform
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#scale ⇒ `Float`

Get scale metadata.

Returns:

(Float) —
image scale

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

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

  get "scale"
end

#scaleimage(**opts) ⇒ `Vips::Image`

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

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image



1641
1642
1643

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

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

#scharr(**opts) ⇒ `Vips::Image`

Scharr edge detector.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Convert scrgb to bw.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:depth (Integer) —
Output device space depth in bits

Returns:

(Vips::Image) —
Output image

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

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

Convert scrgb to srgb.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:depth (Integer) —
Output device space depth in bits

Returns:

(Vips::Image) —
Output image

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

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

Transform scrgb to xyz.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Check sequential access.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:tile_height (Integer) —
Tile height in pixels

Returns:

(Vips::Image) —
Output image

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

#set(name, value) ⇒ `Object`

This method is deprecated.

Please use MutableImage#set! instead.



864
865
866

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

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.

Parameters:

kill (Boolean) —
stop computation

See Also:

Object#signal_connect



733
734
735

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

def set_kill kill
  Vips.vips_image_set_kill(self, kill ? 1 : 0)
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.

Parameters:

state (Boolean) —
progress signalling state

See Also:

Object#signal_connect



722
723
724

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

def set_progress state
  Vips.vips_image_set_progress(self, state ? 1 : 0)
end

#set_type(gtype, name, value) ⇒ `Object`

This method is deprecated.

Please use MutableImage#set_type! instead.

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

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

#set_value(name, value) ⇒ `Object`

This method is deprecated.

Please use MutableImage#set! instead.



883
884
885

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

def set_value name, value
  set name, value
end

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

Unsharp masking for print.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:sigma (Float) —
Sigma of Gaussian
:x1 (Float) —
Flat/jaggy threshold
:y2 (Float) —
Maximum brightening
:y3 (Float) —
Maximum darkening
:m1 (Float) —
Slope for flat areas
:m2 (Float) —
Slope for jaggy areas

Returns:

(Vips::Image) —
Output image

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

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

Shrink an image.

Parameters:

hshrink (Float) —
Horizontal shrink factor
vshrink (Float) —
Vertical shrink factor
opts (Hash) —
Set of options

Options Hash (**opts):

:ceil (Boolean) —
Round-up output dimensions

Returns:

(Vips::Image) —
Output image

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

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

Shrink an image horizontally.

Parameters:

hshrink (Integer) —
Horizontal shrink factor
opts (Hash) —
Set of options

Options Hash (**opts):

:ceil (Boolean) —
Round-up output dimensions

Returns:

(Vips::Image) —
Output image

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

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

Shrink an image vertically.

Parameters:

vshrink (Integer) —
Vertical shrink factor
opts (Hash) —
Set of options

Options Hash (**opts):

:ceil (Boolean) —
Round-up output dimensions

Returns:

(Vips::Image) —
Output image

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

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

Unit vector of pixel.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Similarity transform of an image.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:scale (Float) —
Scale by this factor
:angle (Float) —
Rotate clockwise by this many degrees
:interpolate (Vips::Interpolate) —
Interpolate pixels with this
:background (Array<Double>) —
Background value
:odx (Float) —
Horizontal output displacement
:ody (Float) —
Vertical output displacement
:idx (Float) —
Horizontal input displacement
:idy (Float) —
Vertical input displacement

Returns:

(Vips::Image) —
Output image

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

#sin ⇒ `Image`

Return the sine of an image in degrees.

Returns:

(Image) —
sine of each pixel



1446
1447
1448

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

def sin
  math :sin
end

#sinh ⇒ `Image`

Return the hyperbolic sine of an image in radians.

Returns:

(Image) —
sine of each pixel



1488
1489
1490

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

def sinh
  math :sinh
end

#size ⇒ `Integer`

Get the image size.

Returns:

(Integer, Integer) —
image width and height



985
986
987

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

def size
  [width, height]
end

#smartcrop(width, height, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

Extract an area from an image.

Parameters:

width (Integer) —
Width of extract area
height (Integer) —
Height of extract area
opts (Hash) —
Set of options

Options Hash (**opts):

:interesting (Vips::Interesting) —
How to measure interestingness
:premultiplied (Boolean) —
Input image already has premultiplied alpha
:attention_x (Integer) —
Output Horizontal position of attention centre
:attention_y (Integer) —
Output Vertical position of attention centre

Returns:

(Vips::Image, Hash<Symbol => Object>) —
Output image, Hash of optional output items

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

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

Sobel edge detector.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Spatial correlation.

Parameters:

ref (Vips::Image) —
Input reference image
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Make displayable power spectrum.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Transform srgb to hsv.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Convert an srgb image to scrgb.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

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

Find many image stats.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output array of statistics

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

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

Statistical difference.

Parameters:

width (Integer) —
Window width in pixels
height (Integer) —
Window height in pixels
opts (Hash) —
Set of options

Options Hash (**opts):

:s0 (Float) —
New deviation
:b (Float) —
Weight of new deviation
:m0 (Float) —
New mean
:a (Float) —
Weight of new mean

Returns:

(Vips::Image) —
Output image

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

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

Subsample an image.

Parameters:

xfac (Integer) —
Horizontal subsample factor
yfac (Integer) —
Vertical subsample factor
opts (Hash) —
Set of options

Options Hash (**opts):

:point (Boolean) —
Point sample

Returns:

(Vips::Image) —
Output image

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

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

Subtract two images.

Parameters:

right (Vips::Image) —
Right-hand image argument
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#tan ⇒ `Image`

Return the tangent of an image in degrees.

Returns:

(Image) —
tangent of each pixel



1460
1461
1462

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

def tan
  math :tan
end

#tanh ⇒ `Image`

Return the hyperbolic tangent of an image in radians.

Returns:

(Image) —
tangent of each pixel



1502
1503
1504

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

def tanh
  math :tanh
end

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

Generate thumbnail from image.

Parameters:

width (Integer) —
Size to this width
opts (Hash) —
Set of options

Options Hash (**opts):

:height (Integer) —
Size to this height
:size (Vips::Size) —
Only upsize, only downsize, or both
:no_rotate (Boolean) —
Don't use orientation tags to rotate image upright
:crop (Vips::Interesting) —
Reduce to fill target rectangle, then crop
:linear (Boolean) —
Reduce in linear light
:input_profile (String) —
Fallback input profile
:output_profile (String) —
Fallback output profile
:intent (Vips::Intent) —
Rendering intent
:fail_on (Vips::FailOn) —
Error level to fail on

Returns:

(Vips::Image) —
Output image

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

#tiffsave(filename, **opts) ⇒ `nil`

Save image to tiff file.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:compression (Vips::ForeignTiffCompression) —
Compression for this file
:Q (Integer) —
Q factor
:predictor (Vips::ForeignTiffPredictor) —
Compression prediction
: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
:bitdepth (Integer) —
Write as a 1, 2, 4 or 8 bit image
:resunit (Vips::ForeignTiffResunit) —
Resolution unit
:xres (Float) —
Horizontal resolution in pixels/mm
:yres (Float) —
Vertical resolution in pixels/mm
:bigtiff (Boolean) —
Write a bigtiff image
:properties (Boolean) —
Write a properties document to IMAGEDESCRIPTION
:region_shrink (Vips::RegionShrink) —
Method to shrink regions
:level (Integer) —
Deflate (1-9, default 6) or ZSTD (1-22, default 9) compression level
:lossless (Boolean) —
Enable WEBP lossless mode
:depth (Vips::ForeignDzDepth) —
Pyramid depth
:subifd (Boolean) —
Save pyr layers as sub-IFDs
:premultiply (Boolean) —
Save with premultiplied alpha
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#tiffsave_buffer(**opts) ⇒ `VipsBlob`

Save image to tiff buffer.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:compression (Vips::ForeignTiffCompression) —
Compression for this file
:Q (Integer) —
Q factor
:predictor (Vips::ForeignTiffPredictor) —
Compression prediction
: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
:bitdepth (Integer) —
Write as a 1, 2, 4 or 8 bit image
:resunit (Vips::ForeignTiffResunit) —
Resolution unit
:xres (Float) —
Horizontal resolution in pixels/mm
:yres (Float) —
Vertical resolution in pixels/mm
:bigtiff (Boolean) —
Write a bigtiff image
:properties (Boolean) —
Write a properties document to IMAGEDESCRIPTION
:region_shrink (Vips::RegionShrink) —
Method to shrink regions
:level (Integer) —
Deflate (1-9, default 6) or ZSTD (1-22, default 9) compression level
:lossless (Boolean) —
Enable WEBP lossless mode
:depth (Vips::ForeignDzDepth) —
Pyramid depth
:subifd (Boolean) —
Save pyr layers as sub-IFDs
:premultiply (Boolean) —
Save with premultiplied alpha
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(VipsBlob) —
Buffer to save to

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

#tiffsave_target(target, **opts) ⇒ `nil`

Save image to tiff target.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:compression (Vips::ForeignTiffCompression) —
Compression for this file
:Q (Integer) —
Q factor
:predictor (Vips::ForeignTiffPredictor) —
Compression prediction
: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
:bitdepth (Integer) —
Write as a 1, 2, 4 or 8 bit image
:resunit (Vips::ForeignTiffResunit) —
Resolution unit
:xres (Float) —
Horizontal resolution in pixels/mm
:yres (Float) —
Vertical resolution in pixels/mm
:bigtiff (Boolean) —
Write a bigtiff image
:properties (Boolean) —
Write a properties document to IMAGEDESCRIPTION
:region_shrink (Vips::RegionShrink) —
Method to shrink regions
:level (Integer) —
Deflate (1-9, default 6) or ZSTD (1-22, default 9) compression level
:lossless (Boolean) —
Enable WEBP lossless mode
:depth (Vips::ForeignDzDepth) —
Pyramid depth
:subifd (Boolean) —
Save pyr layers as sub-IFDs
:premultiply (Boolean) —
Save with premultiplied alpha
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

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

Cache an image as a set of tiles.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:tile_width (Integer) —
Tile width in pixels
:tile_height (Integer) —
Tile height in pixels
:max_tiles (Integer) —
Maximum number of tiles to cache
:access (Vips::Access) —
Expected access pattern
:threaded (Boolean) —
Allow threaded access
:persistent (Boolean) —
Keep cache between evaluations

Returns:

(Vips::Image) —
Output image

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

#to_a ⇒ `Array`

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

Returns:

(Array) —
Array of Arrays of Arrays of Numerics



1255
1256
1257

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

def to_a
  to_enum.to_a
end

#to_enum ⇒ `Enumerator`

Convert to an Enumerator. Similar to #to_a but lazier.

Returns:

(Enumerator) —
Enumerator of Enumerators of Arrays of Numerics

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

def to_enum
  # 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] + "*"

  # we render the image to a big string, then unpack into
  # one-dimensional array as a Ruby array of the correct type
  array = write_to_memory.unpack template

  # gather bands of a pixel together
  pixel_array = array.each_slice bands

  # gather pixels of a row together
  pixel_array.each_slice width
end

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

Transpose3d an image.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:page_height (Integer) —
Height of each input page

Returns:

(Vips::Image) —
Output image

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

#uhdr2scRGB(**opts) ⇒ `Vips::Image`

Transform uhdr to scrgb.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

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

#uhdrsave(filename, **opts) ⇒ `nil`

Save image in ultrahdr format.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:Q (Integer) —
Q factor
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

#uhdrsave_buffer(**opts) ⇒ `VipsBlob`

Save image in ultrahdr format.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:Q (Integer) —
Q factor
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(VipsBlob) —
Buffer to save to

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

#uhdrsave_target(target, **opts) ⇒ `nil`

Save image in ultrahdr format.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:Q (Integer) —
Q factor
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

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

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

Unpremultiply image alpha.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:max_alpha (Float) —
Maximum value of alpha channel
:alpha_band (Integer) —
Unpremultiply with this alpha

Returns:

(Vips::Image) —
Output image

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

#vipssave(filename, **opts) ⇒ `nil`

Save image to file in vips format.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

# File 'lib/vips/methods.rb', line 1779

#vipssave_target(target, **opts) ⇒ `nil`

Save image to target in vips format.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

# File 'lib/vips/methods.rb', line 1789

#webpsave(filename, **opts) ⇒ `nil`

Save as webp.

Parameters:

filename (String) —
Filename to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:Q (Integer) —
Q factor
:lossless (Boolean) —
Enable lossless compression
:exact (Boolean) —
Preserve color values from transparent pixels
: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 minimum size
:kmin (Integer) —
Minimum number of frames between key frames
:kmax (Integer) —
Maximum number of frames between key frames
:effort (Integer) —
Level of CPU effort to reduce file size
:target_size (Integer) —
Desired target size in bytes
:mixed (Boolean) —
Allow mixed encoding (might reduce file size)
:smart_deblock (Boolean) —
Enable auto-adjusting of the deblocking filter
:passes (Integer) —
Number of entropy-analysis passes (in [1..10])
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

# File 'lib/vips/methods.rb', line 2181

#webpsave_buffer(**opts) ⇒ `VipsBlob`

Save as webp.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:Q (Integer) —
Q factor
:lossless (Boolean) —
Enable lossless compression
:exact (Boolean) —
Preserve color values from transparent pixels
: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 minimum size
:kmin (Integer) —
Minimum number of frames between key frames
:kmax (Integer) —
Maximum number of frames between key frames
:effort (Integer) —
Level of CPU effort to reduce file size
:target_size (Integer) —
Desired target size in bytes
:mixed (Boolean) —
Allow mixed encoding (might reduce file size)
:smart_deblock (Boolean) —
Enable auto-adjusting of the deblocking filter
:passes (Integer) —
Number of entropy-analysis passes (in [1..10])
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(VipsBlob) —
Buffer to save to

# File 'lib/vips/methods.rb', line 2206

#webpsave_mime(**opts) ⇒ `nil`

Save image to webp mime.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:Q (Integer) —
Q factor
:lossless (Boolean) —
Enable lossless compression
:exact (Boolean) —
Preserve color values from transparent pixels
: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 minimum size
:kmin (Integer) —
Minimum number of frames between key frames
:kmax (Integer) —
Maximum number of frames between key frames
:effort (Integer) —
Level of CPU effort to reduce file size
:target_size (Integer) —
Desired target size in bytes
:mixed (Boolean) —
Allow mixed encoding (might reduce file size)
:smart_deblock (Boolean) —
Enable auto-adjusting of the deblocking filter
:passes (Integer) —
Number of entropy-analysis passes (in [1..10])
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

# File 'lib/vips/methods.rb', line 2255

#webpsave_target(target, **opts) ⇒ `nil`

Save as webp.

Parameters:

target (Vips::Target) —
Target to save to
opts (Hash) —
Set of options

Options Hash (**opts):

:Q (Integer) —
Q factor
:lossless (Boolean) —
Enable lossless compression
:exact (Boolean) —
Preserve color values from transparent pixels
: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 minimum size
:kmin (Integer) —
Minimum number of frames between key frames
:kmax (Integer) —
Maximum number of frames between key frames
:effort (Integer) —
Level of CPU effort to reduce file size
:target_size (Integer) —
Desired target size in bytes
:mixed (Boolean) —
Allow mixed encoding (might reduce file size)
:smart_deblock (Boolean) —
Enable auto-adjusting of the deblocking filter
:passes (Integer) —
Number of entropy-analysis passes (in [1..10])
:keep (Vips::ForeignKeep) —
Which metadata to retain
:background (Array<Double>) —
Background value
:page_height (Integer) —
Set page height for multipage save
:profile (String) —
Filename of ICC profile to embed

Returns:

(nil)

# File 'lib/vips/methods.rb', line 2230

#width ⇒ `Integer`

Get image width, in pixels.

Returns:

(Integer) —
image width, in pixels



890
891
892

# File 'lib/vips/image.rb', line 890

def width
  Vips.vips_image_get_width self
end

#wrap(**opts) ⇒ `Vips::Image`

Wrap image origin.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:x (Integer) —
Left edge of input in output
:y (Integer) —
Top edge of input in output

Returns:

(Vips::Image) —
Output image

# File 'lib/vips/methods.rb', line 534

#write_to_buffer(format_string, **opts) ⇒ `String`

Write this image to a memory buffer. Save options may be encoded in the format_string or given as a hash. For example:

buffer = image.write_to_buffer ".jpg[Q=90]"

or equivalently:

image.write_to_buffer ".jpg", Q: 90

The full set of save options depend on the selected saver. Try something like:

$ vips jpegsave

to see all the available options for JPEG save.

Parameters:

format_string (String) —
save format plus options
opts (Hash) —
set of options

Options Hash (**opts):

:strip (Boolean) — default: false —
Strip all metadata from image
:background (Array<Float>) — default: 0 —
Background colour to flatten alpha against, if necessary

Returns:

(String) —
the image saved in the specified format

Raises:

(Vips::Error)

# File 'lib/vips/image.rb', line 633

def write_to_buffer format_string, **opts
  raise Vips::Error, "filename is nil" if format_string.nil?
  filename = Vips.p2str(Vips.vips_filename_get_filename(format_string))
  option_string = Vips.p2str(Vips.vips_filename_get_options(format_string))

  # try to save with the new target API first, only fall back to the old
  # buffer API if there's no target save for this filetype
  saver = nil
  if Vips.at_least_libvips?(8, 9)
    Vips.vips_error_freeze
    saver = Vips.vips_foreign_find_save_target filename
    Vips.vips_error_thaw
  end

  if !saver.nil?
    target = Vips::Target.new_to_memory
    Vips::Operation.call saver, [self, target], opts, option_string
    buffer = target.get("blob")
  else
    saver = Vips.vips_foreign_find_save_buffer filename
    raise Vips::Error if saver.nil?

    buffer = Vips::Operation.call saver, [self], opts, option_string
    raise Vips::Error if buffer.nil?
  end

  write_gc

  buffer
end

#write_to_file(name, **opts) ⇒ `Object`

Write this image to a file. Save options may be encoded in the filename or given as a hash. For example:

image.write_to_file "fred.jpg[Q=90]"

or equivalently:

image.write_to_file "fred.jpg", Q: 90

The full set of save options depend on the selected saver. Try something like:

$ vips jpegsave

to see all the available options for JPEG save.

Parameters:

opts (Hash) —
set of options
name (String) —
filename to write to

Options Hash (**opts):

:strip (Boolean) — default: false —
Strip all metadata from image
:background (Array<Float>) — default: 0 —
Background colour to flatten alpha against, if necessary

Raises:

(Vips::Error)

# File 'lib/vips/image.rb', line 595

def write_to_file name, **opts
  raise Vips::Error, "filename is nil" if name.nil?

  filename = Vips.p2str(Vips.vips_filename_get_filename(name))
  option_string = Vips.p2str(Vips.vips_filename_get_options(name))
  saver = Vips.vips_foreign_find_save filename
  raise Vips::Error if saver.nil?

  Vips::Operation.call saver, [self, filename], opts, option_string

  write_gc
end

#write_to_memory ⇒ `String`

Write this image to a large memory buffer.

Returns:

(String) —
the pixels as a huge binary string

Raises:

(Vips::Error)

# File 'lib/vips/image.rb', line 704

def write_to_memory
  len = Vips::SizeStruct.new
  ptr = Vips.vips_image_write_to_memory self, len
  raise Vips::Error if ptr.null?

  # 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.

Parameters:

target (Vips::Target) —
the target to write to
format_string (String) —
save format plus string options
opts (Hash) —
set of options

Options Hash (**opts):

:strip (Boolean) — default: false —
Strip all metadata from image
:background (Array<Float>) — default: 0 —
Background colour to flatten alpha against, if necessary

Raises:

(Vips::Error)

# File 'lib/vips/image.rb', line 690

def write_to_target target, format_string, **opts
  raise Vips::Error, "filename is nil" if format_string.nil?
  filename = Vips.p2str(Vips.vips_filename_get_filename(format_string))
  option_string = Vips.p2str(Vips.vips_filename_get_options(format_string))
  saver = Vips.vips_foreign_find_save_target filename
  raise Vips::Error if saver.nil?

  Vips::Operation.call saver, [self, target], opts, option_string
  write_gc
end

#xoffset ⇒ `Integer`

Get image xoffset.

Returns:

(Integer) —
image xoffset



939
940
941

# File 'lib/vips/image.rb', line 939

def xoffset
  get "xoffset"
end

#xres ⇒ `Float`

Get image x resolution.

Returns:

(Float) —
image x resolution



953
954
955

# File 'lib/vips/image.rb', line 953

def xres
  get "xres"
end

#XYZ2CMYK(**opts) ⇒ `Vips::Image`

Transform xyz to cmyk.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips/methods.rb', line 2896

#XYZ2Lab(**opts) ⇒ `Vips::Image`

Transform xyz to lab.

Parameters:

opts (Hash) —
Set of options

Options Hash (**opts):

:temp (Array<Double>) —
Colour temperature

Returns:

(Vips::Image) —
Output image

# File 'lib/vips/methods.rb', line 2718

#XYZ2Oklab(**opts) ⇒ `Vips::Image`

Transform xyz to oklab.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips/methods.rb', line 2707

#XYZ2scRGB(**opts) ⇒ `Vips::Image`

Transform xyz to scrgb.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips/methods.rb', line 2759

#XYZ2Yxy(**opts) ⇒ `Vips::Image`

Transform xyz to yxy.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips/methods.rb', line 2744

#yoffset ⇒ `Integer`

Get image yoffset.

Returns:

(Integer) —
image yoffset



946
947
948

# File 'lib/vips/image.rb', line 946

def yoffset
  get "yoffset"
end

#yres ⇒ `Float`

Get image y resolution.

Returns:

(Float) —
image y resolution



960
961
962

# File 'lib/vips/image.rb', line 960

def yres
  get "yres"
end

#Yxy2XYZ(**opts) ⇒ `Vips::Image`

Transform yxy to xyz.

Parameters:

opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips/methods.rb', line 2749

#zoom(xfac, yfac, **opts) ⇒ `Vips::Image`

Zoom an image.

Parameters:

xfac (Integer) —
Horizontal zoom factor
yfac (Integer) —
Vertical zoom factor
opts (Hash) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips/methods.rb', line 541

#|(other) ⇒ `Image`

Integer bitwise OR with an image, constant or array.

Parameters:

other (Image, Real, Array<Real>) —
bitwise OR with this

Returns:

(Image) —
result of bitwise OR



1106
1107
1108

# File 'lib/vips/image.rb', line 1106

def | other
  call_enum "boolean", other, :or
end

#~ ⇒ `Image`

Equivalent to image ^ -1

Returns:

(Image) —
image with bits flipped



1136
1137
1138

# File 'lib/vips/image.rb', line 1136

def ~
  self ^ -1
end

Class: Vips::Image

Overview

Defined Under Namespace

Instance Attribute Summary

Attributes inherited from GObject::GObject

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Object

Methods inherited from GObject::GObject

Constructor Details

Dynamic Method Handling

#method_missing(name, *args, **options) ⇒ Object

Class Method Details

.analyzeload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.arrayjoin(im, **opts) ⇒ Vips::Image

.bandrank(im, **opts) ⇒ Vips::Image

.black(width, height, **opts) ⇒ Vips::Image

.complex?(format) ⇒ Boolean

.csvload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.csvload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.dcrawload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.dcrawload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.dcrawload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.eye(width, height, **opts) ⇒ Vips::Image

.fitsload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.fitsload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.float?(format) ⇒ Boolean

.fractsurf(width, height, fractal_dimension, **opts) ⇒ Vips::Image

.gaussmat(sigma, min_ampl, **opts) ⇒ Vips::Image

.gaussnoise(width, height, **opts) ⇒ Vips::Image

.gifload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.gifload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.gifload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.grey(width, height, **opts) ⇒ Vips::Image

.heifload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.heifload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.heifload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.identity(**opts) ⇒ Vips::Image

.jp2kload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.jp2kload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.jp2kload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.jpegload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.jpegload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.jpegload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.jxlload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.jxlload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.jxlload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.logmat(sigma, min_ampl, **opts) ⇒ Vips::Image

.magickload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.magickload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.magickload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.mask_butterworth(width, height, order, frequency_cutoff, amplitude_cutoff, **opts) ⇒ Vips::Image

.mask_butterworth_band(width, height, order, frequency_cutoff_x, frequency_cutoff_y, radius, amplitude_cutoff, **opts) ⇒ Vips::Image

.mask_butterworth_ring(width, height, order, frequency_cutoff, amplitude_cutoff, ringwidth, **opts) ⇒ Vips::Image

.mask_fractal(width, height, fractal_dimension, **opts) ⇒ Vips::Image

.mask_gaussian(width, height, frequency_cutoff, amplitude_cutoff, **opts) ⇒ Vips::Image

.mask_gaussian_band(width, height, frequency_cutoff_x, frequency_cutoff_y, radius, amplitude_cutoff, **opts) ⇒ Vips::Image

.mask_gaussian_ring(width, height, frequency_cutoff, amplitude_cutoff, ringwidth, **opts) ⇒ Vips::Image

.mask_ideal(width, height, frequency_cutoff, **opts) ⇒ Vips::Image

.mask_ideal_band(width, height, frequency_cutoff_x, frequency_cutoff_y, radius, **opts) ⇒ Vips::Image

.mask_ideal_ring(width, height, frequency_cutoff, ringwidth, **opts) ⇒ Vips::Image

.matload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.matrix_from_array(width, height, array) ⇒ Object

.matrixload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.matrixload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.method_missing(name, *args, **options) ⇒ Object

.new_from_array(array, scale = 1, offset = 0) ⇒ Image

.new_from_buffer(data, option_string, **opts) ⇒ Image

.new_from_file(name, **opts) ⇒ Image

.new_from_memory(data, width, height, bands, format) ⇒ Image

.new_from_memory_copy(data, width, height, bands, format) ⇒ Image

.new_from_source(source, option_string, **opts) ⇒ Image

.openexrload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.openslideload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.openslideload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.pdfload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.pdfload_buffer(buffer, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.pdfload_source(source, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

.perlin(width, height, **opts) ⇒ Vips::Image

.pngload(filename, **opts) ⇒ Vips::Image, Hash<Symbol => Object>

#method_missing(name, *args, **options) ⇒ `Object`

.analyzeload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.arrayjoin(im, **opts) ⇒ `Vips::Image`

.bandrank(im, **opts) ⇒ `Vips::Image`

.black(width, height, **opts) ⇒ `Vips::Image`

.complex?(format) ⇒ `Boolean`

.csvload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.csvload_source(source, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.dcrawload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.dcrawload_buffer(buffer, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.dcrawload_source(source, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.eye(width, height, **opts) ⇒ `Vips::Image`

.fitsload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.fitsload_source(source, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.float?(format) ⇒ `Boolean`

.fractsurf(width, height, fractal_dimension, **opts) ⇒ `Vips::Image`

.gaussmat(sigma, min_ampl, **opts) ⇒ `Vips::Image`

.gaussnoise(width, height, **opts) ⇒ `Vips::Image`

.gifload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.gifload_buffer(buffer, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.gifload_source(source, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.grey(width, height, **opts) ⇒ `Vips::Image`

.heifload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.heifload_buffer(buffer, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.heifload_source(source, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.identity(**opts) ⇒ `Vips::Image`

.jp2kload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.jp2kload_buffer(buffer, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.jp2kload_source(source, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.jpegload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.jpegload_buffer(buffer, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.jpegload_source(source, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.jxlload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.jxlload_buffer(buffer, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.jxlload_source(source, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.logmat(sigma, min_ampl, **opts) ⇒ `Vips::Image`

.magickload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.magickload_buffer(buffer, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.magickload_source(source, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.mask_butterworth(width, height, order, frequency_cutoff, amplitude_cutoff, **opts) ⇒ `Vips::Image`

.mask_butterworth_band(width, height, order, frequency_cutoff_x, frequency_cutoff_y, radius, amplitude_cutoff, **opts) ⇒ `Vips::Image`

.mask_butterworth_ring(width, height, order, frequency_cutoff, amplitude_cutoff, ringwidth, **opts) ⇒ `Vips::Image`

.mask_fractal(width, height, fractal_dimension, **opts) ⇒ `Vips::Image`

.mask_gaussian(width, height, frequency_cutoff, amplitude_cutoff, **opts) ⇒ `Vips::Image`

.mask_gaussian_band(width, height, frequency_cutoff_x, frequency_cutoff_y, radius, amplitude_cutoff, **opts) ⇒ `Vips::Image`

.mask_gaussian_ring(width, height, frequency_cutoff, amplitude_cutoff, ringwidth, **opts) ⇒ `Vips::Image`

.mask_ideal(width, height, frequency_cutoff, **opts) ⇒ `Vips::Image`

.mask_ideal_band(width, height, frequency_cutoff_x, frequency_cutoff_y, radius, **opts) ⇒ `Vips::Image`

.mask_ideal_ring(width, height, frequency_cutoff, ringwidth, **opts) ⇒ `Vips::Image`

.matload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.matrix_from_array(width, height, array) ⇒ `Object`

.matrixload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.matrixload_source(source, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.method_missing(name, *args, **options) ⇒ `Object`

.new_from_array(array, scale = 1, offset = 0) ⇒ `Image`

.new_from_buffer(data, option_string, **opts) ⇒ `Image`

.new_from_file(name, **opts) ⇒ `Image`

.new_from_memory(data, width, height, bands, format) ⇒ `Image`

.new_from_memory_copy(data, width, height, bands, format) ⇒ `Image`

.new_from_source(source, option_string, **opts) ⇒ `Image`

.openexrload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.openslideload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.openslideload_source(source, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.pdfload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.pdfload_buffer(buffer, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.pdfload_source(source, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.perlin(width, height, **opts) ⇒ `Vips::Image`

.pngload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.pngload_buffer(buffer, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.pngload_source(source, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.ppmload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.ppmload_buffer(buffer, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.ppmload_source(source, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.profile_load(name, **opts) ⇒ `VipsBlob`

.radload(filename, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.radload_buffer(buffer, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.radload_source(source, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.rawload(filename, width, height, bands, **opts) ⇒ `Vips::Image`, `Hash<Symbol => Object>`

.respond_to_missing?(name, include_all = false) ⇒ `Boolean`

.run_cmplx(image, &block) ⇒ `Object`