Class: Vips::Image

Inherits:

Object

• Object
• Vips::Image

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

Instance Attribute Summary

• #bands ⇒ Integer readonly

  Image bands.

• #coding ⇒ Vips::Coding readonly

  Image coding.

• #filename ⇒ String readonly

  Image filename.

• #format ⇒ Vips::BandFormat readonly

  Image format.

• #height ⇒ Integer readonly

  Image height, in pixels.

• #interpretation ⇒ Vips::Interpretation readonly

  Image interpretation.

• #width ⇒ Integer readonly

  Image width, in pixels.

• #xres ⇒ Float readonly

  Horizontal image resolution, in pixels per mm.

• #yres ⇒ Float readonly

  Vertical image resolution, in pixels per mm.

Class Method Summary

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

  Load an analyze6 image.

• .arrayjoin ⇒ Vips::Image

  Join an array of images.

• .bandrank ⇒ Vips::Image

  Band-wise rank of a set of images.

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

  Make a black image.

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

  Load csv from file.

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

• .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 giflib.

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

  Load gif with giflib.

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

  Make a grey ramp image.

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

  Make a 1d image where pixel values are indexes.

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

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

  Make a laplacian of gaussian image.

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

  Load file with imagemagick.

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

  Load buffer with imagemagick.

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

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

  Load matrix from file.

• .method_missing(name, *args) ⇒ Object

  Invoke a vips operation with 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 memory string.

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

  Return a new Image for a file on disc.

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

  Load an openexr image.

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

  Load file with openslide.

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

  Load pdf with libpoppler.

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

  Load pdf with libpoppler.

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

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

  Load ppm from file.

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

  Load a radiance image from a file.

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

  Load raw data from a file.

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

  Make a 2d sine wave.

• .sum ⇒ 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.

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

  Run an external command.

• .text(text, opts = {}) ⇒ Vips::Image

  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.

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

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

  Build a look-up table.

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

  Load vips from file.

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

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

• #! ⇒ 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.

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

  Add two images.

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

  Affine transform of an image.

• #asin ⇒ Image

  Return the inverse sine of an image in degrees.

• #atan ⇒ Image

  Return the inverse tangent of an image in degrees.

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

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

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

  Cache an image.

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

  Cast an image.

• #ceil ⇒ Image

  Return the smallest integral value not less than the argument.

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

  Transform lch to cmc.

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

  Convert to a new colourspace.

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

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

  Seperable convolution operation.

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

  Copy an image.

• #cos ⇒ Image

  Return the cosine of an image in degrees.

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

  Count lines in an image.

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

  Save image to csv file.

• #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_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 = {}) ⇒ Vips::Blob

  Save image to dz buffer.

• #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-colour an image.

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

  Fast correlation.

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

• #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) ⇒ Integer, GValue

  Fetch a GValue from an image.

• #get_typeof(name) ⇒ Integer

  Fetch a GType from an image.

• #get_value(name) ⇒ Object

  Get a metadata item from an image.

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

  Read a point from an image.

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

  Global balance an image mosaic.

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

  Grid an image.

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

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

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

  Save image to jpeg file.

• #jpegsave_buffer(opts = {}) ⇒ Vips::Blob

  Save image to jpeg buffer.

• #jpegsave_mime(opts = {}) ⇒ nil

  Save image to jpeg mime.

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

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

  Resample with an mapim 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.

• #matrixprint(opts = {}) ⇒ nil

  Print matrix.

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

  Save image to matrix file.

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

  Find image maximum.

• #maxpos ⇒ Real

  Return the coordinates of the image maximum.

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

  Measure a set of patches on a colour chart.

• #median(size = 3) ⇒ Image

  a median filter.

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

  Merge two images.

• #method_missing(name, *args) ⇒ Object

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

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

  Find image minimum.

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

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

• #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 png file.

• #pngsave_buffer(opts = {}) ⇒ Vips::Blob

  Save image to png buffer.

• #polar ⇒ Image

  Return an image with rectangular pixels converted to polar.

• #ppmsave(filename, opts = {}) ⇒ nil

  Save image to ppm file.

• #premultiply(opts = {}) ⇒ Vips::Image

  Premultiply image alpha.

• #profile(opts = {}) ⇒ Array<] First non-zero pixel in column, First non-zero pixel in row

  Find image profiles.

• #project(opts = {}) ⇒ Array<] Sums of columns, Sums of rows

  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 = {}) ⇒ Vips::Blob

  Save image to radiance buffer.

• #rank(width, height, index, opts = {}) ⇒ Vips::Image

  Rank filter.

• #rawsave(filename, opts = {}) ⇒ nil

  Save image to raw file.

• #rawsave_fd(fd, opts = {}) ⇒ nil

  Write raw image to file descriptor.

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

• #replicate(across, down, opts = {}) ⇒ Vips::Image

  Replicate an image.

• #resize(scale, opts = {}) ⇒ Vips::Image

  Resize an image.

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

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

  Perform a round function on an image.

• #scale(opts = {}) ⇒ Vips::Image

  Scale an image to uchar.

• #scaleimage(opts = {}) ⇒ Vips::Image

  Scale an image to uchar.

• #scRGB2BW(opts = {}) ⇒ Vips::Image

  Convert scrgb to bw.

• #scRGB2sRGB(opts = {}) ⇒ Vips::Image

  Convert an scrgb image to srgb.

• #scRGB2XYZ(opts = {}) ⇒ Vips::Image

  Transform scrgb to xyz.

• #sequential(opts = {}) ⇒ Vips::Image

  Check sequential access.

• #set(name, value) ⇒ Object

  Set a GValue on an image.

• #set_value(name, value) ⇒ Object

  Set a metadata item on an image.

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

• #size ⇒ Integer

  Get the image size.

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

  Extract an area from an image.

• #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 image average.

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

• #tiffsave(filename, opts = {}) ⇒ nil

  Save image to tiff file.

• #tiffsave_buffer(opts = {}) ⇒ Vips::Blob

  Save image to tiff buffer.

• #tilecache(opts = {}) ⇒ Vips::Image

  Cache an image as a set of tiles.

• #to_a ⇒ Array

  Convert to an Array.

• #unpremultiply(opts = {}) ⇒ Vips::Image

  Unpremultiply image alpha.

• #vipssave(filename, opts = {}) ⇒ nil

  Save image to vips file.

• #webpsave(filename, opts = {}) ⇒ nil

  Save image to webp file.

• #webpsave_buffer(opts = {}) ⇒ Vips::Blob

  Save image to webp buffer.

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

• #XYZ2Lab(opts = {}) ⇒ Vips::Image

  Transform xyz to lab.

• #XYZ2scRGB(opts = {}) ⇒ Vips::Image

  Transform xyz to scrgb.

• #XYZ2Yxy(opts = {}) ⇒ Vips::Image

  Transform xyz to yxy.

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

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args) ⇒ Object

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

Parameters:

• name (String) —

  vips operation to call

Returns:

• result of vips operation

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

def method_missing(name, *args)
    Vips::call_base name.to_s, self, "", args
end

Instance Attribute Details

#bands ⇒ Integer (readonly)

Returns image bands.

Returns:

• (Integer) —

  image bands

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

#coding ⇒ Vips::Coding (readonly)

Returns image coding.

Returns:

• (Vips::Coding) —

  image coding

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

#filename ⇒ String (readonly)

Returns image filename.

Returns:

• (String) —

  image filename

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

#format ⇒ Vips::BandFormat (readonly)

Returns image format.

Returns:

• (Vips::BandFormat) —

  image format

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

#height ⇒ Integer (readonly)

Returns image height, in pixels.

Returns:

• (Integer) —

  image height, in pixels

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

#interpretation ⇒ Vips::Interpretation (readonly)

Returns image interpretation.

Returns:

• (Vips::Interpretation) —

  image interpretation

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

#width ⇒ Integer (readonly)

Returns image width, in pixels.

Returns:

• (Integer) —

  image width, in pixels

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

#xres ⇒ Float (readonly)

Returns horizontal image resolution, in pixels per mm.

Returns:

• (Float) —

  horizontal image resolution, in pixels per mm

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

#yres ⇒ Float (readonly)

Returns vertical image resolution, in pixels per mm.

Returns:

• (Float) —

  vertical image resolution, in pixels per mm

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

Class Method Details

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

Load an analyze6 image.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :fail (Boolean) —

  Fail on first warning

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

.arrayjoin ⇒ Vips::Image

Join an array of images.

Parameters:

• in (Array<Image>) —

  Array of input images

• opts (Hash) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

.bandrank ⇒ Vips::Image

Band-wise rank of a set of images.

Parameters:

• in (Array<Image>) —

  Array of input images

• opts (Hash) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Make a black image.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

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

  Set of options

Options Hash (opts):

• :bands (Integer) —

  Number of bands in image

Returns:

• (Vips::Image) —

  Output image

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

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

Load csv from file.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :skip (Integer) —

  Skip this many lines at the start of the file

• :fail (Boolean) —

  Fail on first warning

• :lines (Integer) —

  Read this many lines from the file

• :whitespace (String) —

  Set of whitespace characters

• :separator (String) —

  Set of separator characters

• :flags (Vips::ForeignFlags) —

  Output Flags for this file

Returns:

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

  Output image, Hash of optional output items

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

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

Make an image showing the eye's spatial response.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

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

  Set of options

Options Hash (opts):

• :uchar (Boolean) —

  Output an unsigned char image

• :factor (Float) —

  Maximum spatial frequency

Returns:

• (Vips::Image) —

  Output image

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

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

Load a fits image.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :fail (Boolean) —

  Fail on first warning

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

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

Make a fractal surface.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

• fractal_dimension (Float) —

  Fractal dimension

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Make a gaussian image.

Parameters:

• sigma (Float) —

  Sigma of Gaussian

• min_ampl (Float) —

  Minimum amplitude of Gaussian

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

  Set of options

Options Hash (opts):

• :separable (Boolean) —

  Generate separable Gaussian

• :precision (Vips::Precision) —

  Generate with this precision

Returns:

• (Vips::Image) —

  Output image

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

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

Make a gaussnoise image.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

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

  Set of options

Options Hash (opts):

• :mean (Float) —

  Mean of pixels in generated image

• :sigma (Float) —

  Standard deviation of pixels in generated image

Returns:

• (Vips::Image) —

  Output image

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

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

Load gif with giflib.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :n (Integer) —

  Load this many pages

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :page (Integer) —

  Load this page from the file

• :fail (Boolean) —

  Fail on first warning

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

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

Load gif with giflib.

Parameters:

• buffer (Vips::Blob) —

  Buffer to load from

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

  Set of options

Options Hash (opts):

• :n (Integer) —

  Load this many pages

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :page (Integer) —

  Load this page from the file

• :fail (Boolean) —

  Fail on first warning

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

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

Make a grey ramp image.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

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

  Set of options

Options Hash (opts):

• :uchar (Boolean) —

  Output an unsigned char image

Returns:

• (Vips::Image) —

  Output image

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

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

Make a 1d image where pixel values are indexes.

Parameters:

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

  Set of options

Options Hash (opts):

• :bands (Integer) —

  Number of bands in LUT

• :ushort (Boolean) —

  Create a 16-bit LUT

• :size (Integer) —

  Size of 16-bit LUT

Returns:

• (Vips::Image) —

  Output image

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

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

Load jpeg from file.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :shrink (Integer) —

  Shrink factor on load

• :fail (Boolean) —

  Fail on first warning

• :autorotate (Boolean) —

  Rotate image using exif orientation

• :flags (Vips::ForeignFlags) —

  Output Flags for this file

Returns:

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

  Output image, Hash of optional output items

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

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

Load jpeg from buffer.

Parameters:

• buffer (Vips::Blob) —

  Buffer to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :shrink (Integer) —

  Shrink factor on load

• :fail (Boolean) —

  Fail on first warning

• :autorotate (Boolean) —

  Rotate image using exif orientation

• :flags (Vips::ForeignFlags) —

  Output Flags for this file

Returns:

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

  Output image, Hash of optional output items

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

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

Make a laplacian of gaussian image.

Parameters:

• sigma (Float) —

  Radius of Logmatian

• min_ampl (Float) —

  Minimum amplitude of Logmatian

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

  Set of options

Options Hash (opts):

• :separable (Boolean) —

  Generate separable Logmatian

• :precision (Vips::Precision) —

  Generate with this precision

Returns:

• (Vips::Image) —

  Output image

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

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

Load file with imagemagick.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :density (String) —

  Canvas resolution for rendering vector formats like SVG

• :page (Integer) —

  Load this page from the file

• :n (Integer) —

  Load this many pages

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :fail (Boolean) —

  Fail on first warning

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

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

Load buffer with imagemagick.

Parameters:

• buffer (Vips::Blob) —

  Buffer to load from

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

  Set of options

Options Hash (opts):

• :density (String) —

  Canvas resolution for rendering vector formats like SVG

• :page (Integer) —

  Load this page from the file

• :n (Integer) —

  Load this many pages

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :fail (Boolean) —

  Fail on first warning

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

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

Make a butterworth filter.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

• order (Float) —

  Filter order

• frequency_cutoff (Float) —

  Frequency cutoff

• amplitude_cutoff (Float) —

  Amplitude cutoff

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

  Set of options

Options Hash (opts):

• :uchar (Boolean) —

  Output an unsigned char image

• :optical (Boolean) —

  Rotate quadrants to optical space

• :reject (Boolean) —

  Invert the sense of the filter

• :nodc (Boolean) —

  Remove DC component

Returns:

• (Vips::Image) —

  Output image

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

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

Make a butterworth_band filter.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

• order (Float) —

  Filter order

• frequency_cutoff_x (Float) —

  Frequency cutoff x

• frequency_cutoff_y (Float) —

  Frequency cutoff y

• radius (Float) —

  radius of circle

• amplitude_cutoff (Float) —

  Amplitude cutoff

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

  Set of options

Options Hash (opts):

• :uchar (Boolean) —

  Output an unsigned char image

• :optical (Boolean) —

  Rotate quadrants to optical space

• :reject (Boolean) —

  Invert the sense of the filter

• :nodc (Boolean) —

  Remove DC component

Returns:

• (Vips::Image) —

  Output image

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

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

Make a butterworth ring filter.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

• order (Float) —

  Filter order

• frequency_cutoff (Float) —

  Frequency cutoff

• amplitude_cutoff (Float) —

  Amplitude cutoff

• ringwidth (Float) —

  Ringwidth

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

  Set of options

Options Hash (opts):

• :uchar (Boolean) —

  Output an unsigned char image

• :optical (Boolean) —

  Rotate quadrants to optical space

• :reject (Boolean) —

  Invert the sense of the filter

• :nodc (Boolean) —

  Remove DC component

Returns:

• (Vips::Image) —

  Output image

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

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

Make fractal filter.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

• fractal_dimension (Float) —

  Fractal dimension

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

  Set of options

Options Hash (opts):

• :uchar (Boolean) —

  Output an unsigned char image

• :optical (Boolean) —

  Rotate quadrants to optical space

• :reject (Boolean) —

  Invert the sense of the filter

• :nodc (Boolean) —

  Remove DC component

Returns:

• (Vips::Image) —

  Output image

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

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

Make a gaussian filter.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

• frequency_cutoff (Float) —

  Frequency cutoff

• amplitude_cutoff (Float) —

  Amplitude cutoff

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

  Set of options

Options Hash (opts):

• :uchar (Boolean) —

  Output an unsigned char image

• :optical (Boolean) —

  Rotate quadrants to optical space

• :reject (Boolean) —

  Invert the sense of the filter

• :nodc (Boolean) —

  Remove DC component

Returns:

• (Vips::Image) —

  Output image

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

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

Make a gaussian filter.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

• frequency_cutoff_x (Float) —

  Frequency cutoff x

• frequency_cutoff_y (Float) —

  Frequency cutoff y

• radius (Float) —

  radius of circle

• amplitude_cutoff (Float) —

  Amplitude cutoff

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

  Set of options

Options Hash (opts):

• :uchar (Boolean) —

  Output an unsigned char image

• :optical (Boolean) —

  Rotate quadrants to optical space

• :reject (Boolean) —

  Invert the sense of the filter

• :nodc (Boolean) —

  Remove DC component

Returns:

• (Vips::Image) —

  Output image

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

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

Make a gaussian ring filter.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

• frequency_cutoff (Float) —

  Frequency cutoff

• amplitude_cutoff (Float) —

  Amplitude cutoff

• ringwidth (Float) —

  Ringwidth

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

  Set of options

Options Hash (opts):

• :uchar (Boolean) —

  Output an unsigned char image

• :optical (Boolean) —

  Rotate quadrants to optical space

• :reject (Boolean) —

  Invert the sense of the filter

• :nodc (Boolean) —

  Remove DC component

Returns:

• (Vips::Image) —

  Output image

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

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

Make an ideal filter.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

• frequency_cutoff (Float) —

  Frequency cutoff

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

  Set of options

Options Hash (opts):

• :uchar (Boolean) —

  Output an unsigned char image

• :optical (Boolean) —

  Rotate quadrants to optical space

• :reject (Boolean) —

  Invert the sense of the filter

• :nodc (Boolean) —

  Remove DC component

Returns:

• (Vips::Image) —

  Output image

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

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

Make an ideal band filter.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

• frequency_cutoff_x (Float) —

  Frequency cutoff x

• frequency_cutoff_y (Float) —

  Frequency cutoff y

• radius (Float) —

  radius of circle

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

  Set of options

Options Hash (opts):

• :uchar (Boolean) —

  Output an unsigned char image

• :optical (Boolean) —

  Rotate quadrants to optical space

• :reject (Boolean) —

  Invert the sense of the filter

• :nodc (Boolean) —

  Remove DC component

Returns:

• (Vips::Image) —

  Output image

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

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

Make an ideal ring filter.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

• frequency_cutoff (Float) —

  Frequency cutoff

• ringwidth (Float) —

  Ringwidth

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

  Set of options

Options Hash (opts):

• :uchar (Boolean) —

  Output an unsigned char image

• :optical (Boolean) —

  Rotate quadrants to optical space

• :reject (Boolean) —

  Invert the sense of the filter

• :nodc (Boolean) —

  Remove DC component

Returns:

• (Vips::Image) —

  Output image

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

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

Load mat from file.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :fail (Boolean) —

  Fail on first warning

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

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

Load matrix from file.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :fail (Boolean) —

  Fail on first warning

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

.method_missing(name, *args) ⇒ Object

Invoke a vips operation with Vips.call.

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

def self.method_missing(name, *args)
    Vips::call_base name.to_s, nil, "", args
end

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

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

For example:

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

or

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

for a simple sharpening mask.

Parameters:

• array (Array) —

  the pixel data as an array of numbers

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

  the convolution scale

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

  the convolution offset

Returns:

• (Image) —

  the image

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

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
    if not 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
        if not array.all? {|x| x.is_a? Array}
            raise Vips::Error, "Not a 2D array."
        end
        if not array.all? {|x| x.length == width}
            raise Vips::Error, "Array not rectangular."
        end
        array = array.flatten
    else
        height = 1
        width = array.length
    end

    if not 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
    if image == nil
        raise Vips::Error
    end

    # be careful to set them as double
    image.set_double 'scale', scale.to_f
    image.set_double 'offset', offset.to_f

    return image
end

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

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

image = Vips::new_from_from_buffer memory_buffer, "shrink=2"

or alternatively:

image = Vips::new_from_from_buffer memory_buffer, "", :shrink => 2

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

$ vips jpegload_buffer

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

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

Parameters:

• data (String) —

  the data to load from

• option_string (String) —

  load options as a string

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

  set of options

Options Hash (opts):

• :disc (Boolean) — default: true —

  Open large images via a temporary disc file

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

  Access mode for file

Returns:

• (Image) —

  the loaded image

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

def self.new_from_buffer(data, option_string, opts = {})
    loader = Vips::Foreign.find_load_buffer data
    if loader == nil
        raise Vips::Error
    end

    Vips::call_base loader, nil, option_string, [data, opts]
end

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

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

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

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

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

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

$ vips jpegload

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

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

Parameters:

• name (String) —

  the filename to load from

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

  set of options

Options Hash (opts):

• :disc (Boolean) — default: true —

  Open large images via a temporary disc file

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

  Access mode for file

Returns:

• (Image) —

  the loaded image

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

def self.new_from_file(name, opts = {})
    # very common, and Vips::filename_get_filename will segv if we pass
    # this
    if name == nil
        raise Error, "filename is nil"
    end
    filename = Vips::filename_get_filename name
    option_string = Vips::filename_get_options name
    loader = Vips::Foreign.find_load filename
    if loader == nil
        raise Vips::Error
    end

    Vips::call_base loader, nil, option_string, [filename, opts]
end

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

Load an openexr image.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :fail (Boolean) —

  Fail on first warning

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

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

Load file with openslide.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :level (Integer) —

  Load this level from the file

• :fail (Boolean) —

  Fail on first warning

• :autocrop (Boolean) —

  Crop to image bounds

• :associated (String) —

  Load this associated image

• :flags (Vips::ForeignFlags) —

  Output Flags for this file

Returns:

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

  Output image, Hash of optional output items

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

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

Load pdf with libpoppler.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :page (Integer) —

  Load this page from the file

• :fail (Boolean) —

  Fail on first warning

• :n (Integer) —

  Load this many pages

• :dpi (Float) —

  Render at this DPI

• :scale (Float) —

  Scale output by this factor

• :flags (Vips::ForeignFlags) —

  Output Flags for this file

Returns:

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

  Output image, Hash of optional output items

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

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

Load pdf with libpoppler.

Parameters:

• buffer (Vips::Blob) —

  Buffer to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :page (Integer) —

  Load this page from the file

• :fail (Boolean) —

  Fail on first warning

• :n (Integer) —

  Load this many pages

• :dpi (Float) —

  Render at this DPI

• :scale (Float) —

  Scale output by this factor

• :flags (Vips::ForeignFlags) —

  Output Flags for this file

Returns:

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

  Output image, Hash of optional output items

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

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

Make a perlin noise image.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

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

  Set of options

Options Hash (opts):

• :cell_size (Integer) —

  Size of Perlin cells

• :uchar (Boolean) —

  Output an unsigned char image

Returns:

• (Vips::Image) —

  Output image

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

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

Load png from file.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :fail (Boolean) —

  Fail on first warning

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

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

Load png from buffer.

Parameters:

• buffer (Vips::Blob) —

  Buffer to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :fail (Boolean) —

  Fail on first warning

• :flags (Vips::ForeignFlags) —

  Output Flags for this file

Returns:

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

  Output image, Hash of optional output items

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

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

Load ppm from file.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :fail (Boolean) —

  Fail on first warning

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

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

Load a radiance image from a file.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :fail (Boolean) —

  Fail on first warning

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

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

Load raw data from a file.

Parameters:

• filename (String) —

  Filename to load from

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

• bands (Integer) —

  Number of bands in image

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :fail (Boolean) —

  Fail on first warning

• :offset (Integer) —

  Offset in bytes from start of file

• :flags (Vips::ForeignFlags) —

  Output Flags for this file

Returns:

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

  Output image, Hash of optional output items

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

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

Make a 2d sine wave.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

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

  Set of options

Options Hash (opts):

• :uchar (Boolean) —

  Output an unsigned char image

• :hfreq (Float) —

  Horizontal spatial frequency

• :vfreq (Float) —

  Vertical spatial frequency

Returns:

• (Vips::Image) —

  Output image

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

.sum ⇒ Vips::Image

Sum an array of images.

Parameters:

• in (Array<Image>) —

  Array of input images

• opts (Hash) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Load svg with rsvg.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :fail (Boolean) —

  Fail on first warning

• :dpi (Float) —

  Render at this DPI

• :scale (Float) —

  Scale output by this factor

• :flags (Vips::ForeignFlags) —

  Output Flags for this file

Returns:

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

  Output image, Hash of optional output items

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

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

Load svg with rsvg.

Parameters:

• buffer (Vips::Blob) —

  Buffer to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :fail (Boolean) —

  Fail on first warning

• :dpi (Float) —

  Render at this DPI

• :scale (Float) —

  Scale output by this factor

• :flags (Vips::ForeignFlags) —

  Output Flags for this file

Returns:

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

  Output image, Hash of optional output items

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

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

Run an external command.

Parameters:

• cmd_format (String) —

  Command to run

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

  Set of options

Options Hash (opts):

• :in (Array<Image>) —

  Array of input images

• :in_format (String) —

  Format for input filename

• :out_format (String) —

  Format for output filename

• :out (Vips::Image) —

  Output Output image

• :log (String) —

  Output Command log

Returns:

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

  Hash of optional output items

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

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

Make a text image.

Parameters:

• text (String) —

  Text to render

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

  Set of options

Options Hash (opts):

• :font (String) —

  Font to render with

• :width (Integer) —

  Maximum image width in pixels

• :align (Vips::Align) —

  Align on the low, centre or high edge

• :dpi (Integer) —

  DPI to render at

• :spacing (Integer) —

  Line spacing

Returns:

• (Vips::Image) —

  Output image

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

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

Generate thumbnail from file.

Parameters:

• filename (String) —

  Filename to read from

• width (Integer) —

  Size to this width

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

  Set of options

Options Hash (opts):

• :height (Integer) —

  Size to this height

• :size (Vips::Size) —

  Only upsize, only downsize, or both

• :auto_rotate (Boolean) —

  Use orientation tags to rotate image upright

• :crop (Vips::Interesting) —

  Reduce to fill target rectangle, then crop

• :linear (Boolean) —

  Reduce in linear light

• :import_profile (String) —

  Fallback import profile

• :export_profile (String) —

  Fallback export profile

Returns:

• (Vips::Image) —

  Output image

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

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

Generate thumbnail from buffer.

Parameters:

• buffer (Vips::Blob) —

  Buffer to load from

• width (Integer) —

  Size to this width

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

  Set of options

Options Hash (opts):

• :height (Integer) —

  Size to this height

• :size (Vips::Size) —

  Only upsize, only downsize, or both

• :auto_rotate (Boolean) —

  Use orientation tags to rotate image upright

• :crop (Vips::Interesting) —

  Reduce to fill target rectangle, then crop

• :linear (Boolean) —

  Reduce in linear light

• :import_profile (String) —

  Fallback import profile

• :export_profile (String) —

  Fallback export profile

Returns:

• (Vips::Image) —

  Output image

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

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

Load tiff from file.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :page (Integer) —

  Load this page from the image

• :fail (Boolean) —

  Fail on first warning

• :n (Integer) —

  Load this many pages

• :autorotate (Boolean) —

  Rotate image using orientation tag

• :flags (Vips::ForeignFlags) —

  Output Flags for this file

Returns:

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

  Output image, Hash of optional output items

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

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

Load tiff from buffer.

Parameters:

• buffer (Vips::Blob) —

  Buffer to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :page (Integer) —

  Load this page from the image

• :fail (Boolean) —

  Fail on first warning

• :n (Integer) —

  Load this many pages

• :autorotate (Boolean) —

  Rotate image using orientation tag

• :flags (Vips::ForeignFlags) —

  Output Flags for this file

Returns:

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

  Output image, Hash of optional output items

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

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

Build a look-up table.

Parameters:

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

  Set of options

Options Hash (opts):

• :in_max (Integer) —

  Size of LUT to build

• :out_max (Integer) —

  Maximum value in output LUT

• :Lb (Float) —

  Lowest value in output

• :Lw (Float) —

  Highest value in output

• :Ps (Float) —

  Position of shadow

• :Pm (Float) —

  Position of mid-tones

• :Ph (Float) —

  Position of highlights

• :S (Float) —

  Adjust shadows by this much

• :M (Float) —

  Adjust mid-tones by this much

• :H (Float) —

  Adjust highlights by this much

Returns:

• (Vips::Image) —

  Output image

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

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

Load vips from file.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :fail (Boolean) —

  Fail on first warning

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

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

Load webp from file.

Parameters:

• filename (String) —

  Filename to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :shrink (Integer) —

  Shrink factor on load

• :fail (Boolean) —

  Fail on first warning

• :flags (Vips::ForeignFlags) —

  Output Flags for this file

Returns:

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

  Output image, Hash of optional output items

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

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

Load webp from buffer.

Parameters:

• buffer (Vips::Blob) —

  Buffer to load from

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

  Set of options

Options Hash (opts):

• :disc (Boolean) —

  Open to disc

• :access (Vips::Access) —

  Required access pattern for this file

• :shrink (Integer) —

  Shrink factor on load

• :fail (Boolean) —

  Fail on first warning

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

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

Make a worley noise image.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

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

  Set of options

Options Hash (opts):

• :cell_size (Integer) —

  Size of Worley cells

Returns:

• (Vips::Image) —

  Output image

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

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

Make an image where pixel values are coordinates.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

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

  Set of options

Options Hash (opts):

• :csize (Integer) —

  Size of third dimension

• :dsize (Integer) —

  Size of fourth dimension

• :esize (Integer) —

  Size of fifth dimension

Returns:

• (Vips::Image) —

  Output image

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

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

Make a zone plate.

Parameters:

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

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

  Set of options

Options Hash (opts):

• :uchar (Boolean) —

  Output an unsigned char image

Returns:

• (Vips::Image) —

  Output image

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

Instance Method Details

#! ⇒ Image

Equivalent to image ^ -1

Returns:

• (Image) —

  image with bits flipped

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

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 960

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

#%(other) ⇒ Image

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

Parameters:

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

  self modulo this

Returns:

• (Image) —

  result of modulo

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

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

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

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 812

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

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

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 794

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

#+@ ⇒ Image

Returns image.

Returns:

• (Image) —

  image

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

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 803

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

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

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 821

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

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

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

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

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

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

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 947

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

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

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

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

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

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

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 973

def [](index)
    if index.is_a? Range
        n = index.end - index.begin
        n += 1 if not index.exclude_end?
        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

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

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

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

Absolute value of an image.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

#acos ⇒ Image

Return the inverse cosine of an image in degrees.

Returns:

• (Image) —

  inverse cosine of each pixel

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

def acos
    math :acos
end

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

Add two images.

Parameters:

• right (Vips::Image) —

  Right-hand image argument

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Affine transform of an image.

Parameters:

• matrix (Array<Double>) —

  Transformation matrix

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

  Set of options

Options Hash (opts):

• :interpolate (Vips::Interpolate) —

  Interpolate pixels with this

• :oarea (Array<Integer>) —

  Area of output to generate

• :odx (Float) —

  Horizontal output displacement

• :ody (Float) —

  Vertical output displacement

• :idx (Float) —

  Horizontal input displacement

• :idy (Float) —

  Vertical input displacement

Returns:

• (Vips::Image) —

  Output image

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

#asin ⇒ Image

Return the inverse sine of an image in degrees.

Returns:

• (Image) —

  inverse sine of each pixel

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

def asin
    math :asin
end

#atan ⇒ Image

Return the inverse tangent of an image in degrees.

Returns:

• (Image) —

  inverse tangent of each pixel

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

def atan
    math :atan
end

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

Autorotate image by exif tag.

Parameters:

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

  Set of options

Options Hash (opts):

• :angle (Vips::Angle) —

  Output Angle image was rotated by

Returns:

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

  Output image, Hash of optional output items

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

#avg(opts = {}) ⇒ Float

Find image average.

Parameters:

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

  Set of options

Returns:

• (Float) —

  Output value

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

#bandand ⇒ Image

AND the bands of an image together

Returns:

• (Image) —

  all bands ANDed together

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

def bandand
    bandbool :and
end

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

Boolean operation across image bands.

Parameters:

• boolean (Vips::OperationBoolean) —

  boolean to perform

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

#bandeor ⇒ Image

EOR the bands of an image together

Returns:

• (Image) —

  all bands EORed together

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

def bandeor
    bandbool :eor
end

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

Fold up x axis into bands.

Parameters:

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

  Set of options

Options Hash (opts):

• :factor (Integer) —

  Fold by this factor

Returns:

• (Vips::Image) —

  Output image

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

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

def bandjoin(other)
    if not other.is_a? Array
        other = [other]
    end

    # if other is just Numeric, we can use bandjoin_const
    not_all_real = (other.map {|x| not x.is_a?(Numeric)}).include?(true)

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

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

Append a constant band to an image.

Parameters:

• c (Array<Double>) —

  Array of constants to add

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Band-wise average.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

#bandor ⇒ Image

OR the bands of an image together

Returns:

• (Image) —

  all bands ORed together

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

def bandor
    bandbool :or
end

#bandsplit ⇒ Array<Image>

Split an n-band image into n separate images.

Returns:

• (Array<Image>) —

  Array of n one-band images

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

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

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

Unfold image bands into x axis.

Parameters:

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

  Set of options

Options Hash (opts):

• :factor (Integer) —

  Unfold by this factor

Returns:

• (Vips::Image) —

  Output image

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

#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) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Boolean operations against a constant.

Parameters:

• boolean (Vips::OperationBoolean) —

  boolean to perform

• c (Array<Double>) —

  Array of constants

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Build a look-up table.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Byteswap an image.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Cache an image.

Parameters:

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

  Set of options

Options Hash (opts):

• :tile_width (Integer) —

  Tile width in pixels

• :tile_height (Integer) —

  Tile height in pixels

• :max_tiles (Integer) —

  Maximum number of tiles to cache

Returns:

• (Vips::Image) —

  Output image

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

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

Cast an image.

Parameters:

• format (Vips::BandFormat) —

  Format to cast to

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

  Set of options

Options Hash (opts):

• :shift (Boolean) —

  Shift integer values up and down

Returns:

• (Vips::Image) —

  Output image

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

#ceil ⇒ Image

Return the smallest integral value not less than the argument.

Returns:

• (Image) —

  ceil of image

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

def ceil
    round :ceil
end

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

Transform lch to cmc.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Convert to a new colourspace.

Parameters:

• space (Vips::Interpretation) —

  Destination colour space

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

  Set of options

Options Hash (opts):

• :source_space (Vips::Interpretation) —

  Source colour space

Returns:

• (Vips::Image) —

  Output image

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

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

Convolve with rotating mask.

Parameters:

• mask (Vips::Image) —

  Input matrix image

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

  Set of options

Options Hash (opts):

• :times (Integer) —

  Rotate and convolve this many times

• :angle (Vips::Angle45) —

  Rotate mask by this much between convolutions

• :combine (Vips::Combine) —

  Combine convolution results like this

• :precision (Vips::Precision) —

  Convolve with this precision

• :layers (Integer) —

  Use this many layers in approximation

• :cluster (Integer) —

  Cluster lines closer than this in approximation

Returns:

• (Vips::Image) —

  Output image

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

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

Perform a complex operation on an image.

Parameters:

• cmplx (Vips::OperationComplex) —

  complex to perform

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Complex binary operations on two images.

Parameters:

• right (Vips::Image) —

  Right-hand image argument

• cmplx (Vips::OperationComplex2) —

  binary complex operation to perform

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Form a complex image from two real images.

Parameters:

• right (Vips::Image) —

  Right-hand image argument

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Get a component from a complex image.

Parameters:

• get (Vips::OperationComplexget) —

  complex to perform

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

#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

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

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

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

Convolution operation.

Parameters:

• mask (Vips::Image) —

  Input matrix image

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

  Set of options

Options Hash (opts):

• :precision (Vips::Precision) —

  Convolve with this precision

• :layers (Integer) —

  Use this many layers in approximation

• :cluster (Integer) —

  Cluster lines closer than this in approximation

Returns:

• (Vips::Image) —

  Output image

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

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

Approximate integer convolution.

Parameters:

• mask (Vips::Image) —

  Input matrix image

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

  Set of options

Options Hash (opts):

• :layers (Integer) —

  Use this many layers in approximation

• :cluster (Integer) —

  Cluster lines closer than this in approximation

Returns:

• (Vips::Image) —

  Output image

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

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

Approximate separable integer convolution.

Parameters:

• mask (Vips::Image) —

  Input matrix image

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

  Set of options

Options Hash (opts):

• :layers (Integer) —

  Use this many layers in approximation

Returns:

• (Vips::Image) —

  Output image

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

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

Float convolution operation.

Parameters:

• mask (Vips::Image) —

  Input matrix image

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Int convolution operation.

Parameters:

• mask (Vips::Image) —

  Input matrix image

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Seperable convolution operation.

Parameters:

• mask (Vips::Image) —

  Input matrix image

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

  Set of options

Options Hash (opts):

• :precision (Vips::Precision) —

  Convolve with this precision

• :layers (Integer) —

  Use this many layers in approximation

• :cluster (Integer) —

  Cluster lines closer than this in approximation

Returns:

• (Vips::Image) —

  Output image

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

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

Copy an image.

Parameters:

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

  Set of options

Options Hash (opts):

• :width (Integer) —

  Image width in pixels

• :height (Integer) —

  Image height in pixels

• :bands (Integer) —

  Number of bands in image

• :format (Vips::BandFormat) —

  Pixel format in image

• :coding (Vips::Coding) —

  Pixel coding

• :interpretation (Vips::Interpretation) —

  Pixel interpretation

• :xres (Float) —

  Horizontal resolution in pixels/mm

• :yres (Float) —

  Vertical resolution in pixels/mm

• :xoffset (Integer) —

  Horizontal offset of origin

• :yoffset (Integer) —

  Vertical offset of origin

Returns:

• (Vips::Image) —

  Output image

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

#cos ⇒ Image

Return the cosine of an image in degrees.

Returns:

• (Image) —

  cosine of each pixel

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

def cos
    math :cos
end

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

Count lines in an image.

Parameters:

• direction (Vips::Direction) —

  Countlines left-right or up-down

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

  Set of options

Returns:

• (Float) —

  Number of lines

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

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

Save image to csv file.

Parameters:

• filename (String) —

  Filename to save to

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

  Set of options

Options Hash (opts):

• :separator (String) —

  Separator characters

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (nil)

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

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

Calculate de00.

Parameters:

• right (Vips::Image) —

  Right-hand input image

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Calculate de76.

Parameters:

• right (Vips::Image) —

  Right-hand input image

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Calculate decmc.

Parameters:

• right (Vips::Image) —

  Right-hand input image

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

#deviate(opts = {}) ⇒ Float

Find image standard deviation.

Parameters:

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

  Set of options

Returns:

• (Float) —

  Output value

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

#dilate(mask) ⇒ Image

Dilate with a structuring element.

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

Parameters:

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

  structuring element

Returns:

• (Image) —

  dilated image

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

def dilate(mask)
    morph mask, :dilate
end

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

Divide two images.

Parameters:

• right (Vips::Image) —

  Right-hand image argument

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Draw a circle on an image.

Parameters:

• ink (Array<Double>) —

  Color for pixels

• cx (Integer) —

  Centre of draw_circle

• cy (Integer) —

  Centre of draw_circle

• radius (Integer) —

  Radius in pixels

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

  Set of options

Options Hash (opts):

• :fill (Boolean) —

  Draw a solid object

Returns:

• (Vips::Image) —

  Image to draw on

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

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

Flood-fill an area.

Parameters:

• ink (Array<Double>) —

  Color for pixels

• x (Integer) —

  DrawFlood start point

• y (Integer) —

  DrawFlood start point

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

  Set of options

Options Hash (opts):

• :test (Vips::Image) —

  Test pixels in this image

• :equal (Boolean) —

  DrawFlood while equal to edge

• :left (Integer) —

  Output Left edge of modified area

• :top (Integer) —

  Output top edge of modified area

• :width (Integer) —

  Output width of modified area

• :height (Integer) —

  Output height of modified area

Returns:

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

  Image to draw on, Hash of optional output items

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

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

Paint an image into another image.

Parameters:

• sub (Vips::Image) —

  Sub-image to insert into main image

• x (Integer) —

  Draw image here

• y (Integer) —

  Draw image here

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

  Set of options

Options Hash (opts):

• :mode (Vips::CombineMode) —

  Combining mode

Returns:

• (Vips::Image) —

  Image to draw on

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

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

Draw a line on an image.

Parameters:

• ink (Array<Double>) —

  Color for pixels

• x1 (Integer) —

  Start of draw_line

• y1 (Integer) —

  Start of draw_line

• x2 (Integer) —

  End of draw_line

• y2 (Integer) —

  End of draw_line

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

  Set of options

Returns:

• (Vips::Image) —

  Image to draw on

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

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

Draw a mask on an image.

Parameters:

• ink (Array<Double>) —

  Color for pixels

• mask (Vips::Image) —

  Mask of pixels to draw

• x (Integer) —

  Draw mask here

• y (Integer) —

  Draw mask here

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

  Set of options

Returns:

• (Vips::Image) —

  Image to draw on

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

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

Paint a rectangle on an image.

Parameters:

• ink (Array<Double>) —

  Color for pixels

• left (Integer) —

  Rect to fill

• top (Integer) —

  Rect to fill

• width (Integer) —

  Rect to fill

• height (Integer) —

  Rect to fill

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

  Set of options

Options Hash (opts):

• :fill (Boolean) —

  Draw a solid object

Returns:

• (Vips::Image) —

  Image to draw on

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

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

Blur a rectangle on an image.

Parameters:

• left (Integer) —

  Rect to fill

• top (Integer) —

  Rect to fill

• width (Integer) —

  Rect to fill

• height (Integer) —

  Rect to fill

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

  Set of options

Returns:

• (Vips::Image) —

  Image to draw on

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

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

Save image to deepzoom file.

Parameters:

• filename (String) —

  Filename to save to

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

  Set of options

Options Hash (opts):

• :basename (String) —

  Base name to save to

• :layout (Vips::ForeignDzLayout) —

  Directory layout

• :suffix (String) —

  Filename suffix for tiles

• :overlap (Integer) —

  Tile overlap in pixels

• :tile_size (Integer) —

  Tile size in pixels

• :depth (Vips::ForeignDzDepth) —

  Pyramid depth

• :centre (Boolean) —

  Center image in tile

• :angle (Vips::Angle) —

  Rotate image during save

• :container (Vips::ForeignDzContainer) —

  Pyramid container type

• :properties (Boolean) —

  Write a properties file to the output directory

• :compression (Integer) —

  ZIP deflate compression level

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (nil)

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

#dzsave_buffer(opts = {}) ⇒ Vips::Blob

Save image to dz buffer.

Parameters:

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

  Set of options

Options Hash (opts):

• :basename (String) —

  Base name to save to

• :layout (Vips::ForeignDzLayout) —

  Directory layout

• :suffix (String) —

  Filename suffix for tiles

• :overlap (Integer) —

  Tile overlap in pixels

• :tile_size (Integer) —

  Tile size in pixels

• :depth (Vips::ForeignDzDepth) —

  Pyramid depth

• :centre (Boolean) —

  Center image in tile

• :angle (Vips::Angle) —

  Rotate image during save

• :container (Vips::ForeignDzContainer) —

  Pyramid container type

• :properties (Boolean) —

  Write a properties file to the output directory

• :compression (Integer) —

  ZIP deflate compression level

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (Vips::Blob) —

  Buffer to save to

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

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

Embed an image in a larger image.

Parameters:

• x (Integer) —

  Left edge of input in output

• y (Integer) —

  Top edge of input in output

• width (Integer) —

  Image width in pixels

• height (Integer) —

  Image height in pixels

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

  Set of options

Options Hash (opts):

• :extend (Vips::Extend) —

  How to generate the extra pixels

• :background (Array<Double>) —

  Color for background pixels

Returns:

• (Vips::Image) —

  Output image

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

#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

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

def erode(mask)
    morph mask, :erode
end

#exp ⇒ Image

Return e ** pixel.

Returns:

• (Image) —

  e ** pixel

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

def exp
    math :exp
end

#exp10 ⇒ Image

Return 10 ** pixel.

Returns:

• (Image) —

  10 ** pixel

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

def exp10
    math :exp10
end

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

Extract an area from an image.

Parameters:

• left (Integer) —

  Left edge of extract area

• top (Integer) —

  Top edge of extract area

• width (Integer) —

  Width of extract area

• height (Integer) —

  Height of extract area

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Extract band from an image.

Parameters:

• band (Integer) —

  Band to extract

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

  Set of options

Options Hash (opts):

• :n (Integer) —

  Number of bands to extract

Returns:

• (Vips::Image) —

  Output image

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

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

False-colour an image.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Fast correlation.

Parameters:

• ref (Vips::Image) —

  Input reference image

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Save image to fits file.

Parameters:

• filename (String) —

  Filename to save to

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

  Set of options

Options Hash (opts):

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (nil)

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

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

Flatten alpha out of an image.

Parameters:

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

  Set of options

Options Hash (opts):

• :background (Array<Double>) —

  Background value

• :max_alpha (Float) —

  Maximum value of alpha channel

Returns:

• (Vips::Image) —

  Output image

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

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

Flip an image.

Parameters:

• direction (Vips::Direction) —

  Direction to flip image

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

#fliphor ⇒ Image

Flip horizontally.

Returns:

• (Image) —

  image flipped horizontally

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

def fliphor
    flip :horizontal
end

#flipver ⇒ Image

Flip vertically.

Returns:

• (Image) —

  image flipped vertically

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

def flipver
    flip :vertical
end

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

Transform float rgb to radiance coding.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

#floor ⇒ Image

Return the largest integral value not greater than the argument.

Returns:

• (Image) —

  floor of image

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

def floor
    round :floor
end

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

Frequency-domain filtering.

Parameters:

• mask (Vips::Image) —

  Input mask image

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Forward fft.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Gamma an image.

Parameters:

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

  Set of options

Options Hash (opts):

• :exponent (Float) —

  Gamma factor

Returns:

• (Vips::Image) —

  Output image

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

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

Gaussian blur.

Parameters:

• sigma (Float) —

  Sigma of Gaussian

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

  Set of options

Options Hash (opts):

• :min_ampl (Float) —

  Minimum amplitude of Gaussian

• :precision (Vips::Precision) —

  Convolve with this precision

Returns:

• (Vips::Image) —

  Output image

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

#get(name) ⇒ Integer, GValue

Fetch a GValue from an image. The return status is 0 for success, -1 for failure.

Parameters:

• name (String) —

  Metadata field to fetch

Returns:

• (Integer, GValue) —

  Return status, GValue from image

See Also:

• #get_value
• #get_typeof

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

#get_typeof(name) ⇒ Integer

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

Parameters:

• name (String) —

  Metadata field to fetch

Returns:

• (Integer) —

  GType

See Also:

• #get
• #get_value

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

#get_value(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_value "icc-profile-data"

and profile will be an array containing the profile.

Parameters:

• name (String) —

  Metadata field to set

Returns:

• (Object) —

  Value of field

See Also:

• #get

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

def get_value(name)
    ret, gval = get name
    if ret != 0
        raise Vips::Error, "Field #{name} not found."
    end
    value = gval.value

    Argument::unwrap(value)
end

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

Read a point from an image.

Parameters:

• x (Integer) —

  Point to read

• y (Integer) —

  Point to read

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

  Set of options

Returns:

• (Array<Double>) —

  Array of output values

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

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

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

Global balance an image mosaic.

Parameters:

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

  Set of options

Options Hash (opts):

• :gamma (Float) —

  Image gamma

• :int_output (Boolean) —

  Integer output

Returns:

• (Vips::Image) —

  Output image

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

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

Grid an image.

Parameters:

• tile_height (Integer) —

  chop into tiles this high

• across (Integer) —

  number of tiles across

• down (Integer) —

  number of tiles down

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Form cumulative histogram.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

#hist_entropy(opts = {}) ⇒ Float

Estimate image entropy.

Parameters:

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

  Set of options

Returns:

• (Float) —

  Output value

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

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

Histogram equalisation.

Parameters:

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

  Set of options

Options Hash (opts):

• :band (Integer) —

  Equalise with this band

Returns:

• (Vips::Image) —

  Output image

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

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

Find image histogram.

Parameters:

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

  Set of options

Options Hash (opts):

• :band (Integer) —

  Find histogram of band

Returns:

• (Vips::Image) —

  Output histogram

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

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

Find indexed image histogram.

Parameters:

• index (Vips::Image) —

  Index image

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

  Set of options

Returns:

• (Vips::Image) —

  Output histogram

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

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

Find n-dimensional image histogram.

Parameters:

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

  Set of options

Options Hash (opts):

• :bins (Integer) —

  Number of bins in each dimension

Returns:

• (Vips::Image) —

  Output histogram

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

#hist_ismonotonic(opts = {}) ⇒ Boolean

Test for monotonicity.

Parameters:

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

  Set of options

Returns:

• (Boolean) —

  true if in is monotonic

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

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

Local histogram equalisation.

Parameters:

• width (Integer) —

  Window width in pixels

• height (Integer) —

  Window height in pixels

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

  Set of options

Options Hash (opts):

• :max_slope (Integer) —

  Maximum slope (CLAHE)

Returns:

• (Vips::Image) —

  Output image

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

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

Match two histograms.

Parameters:

• ref (Vips::Image) —

  Reference histogram

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Normalise histogram.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Plot histogram.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Find hough circle transform.

Parameters:

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

  Set of options

Options Hash (opts):

• :scale (Integer) —

  Scale down dimensions by this factor

• :min_radius (Integer) —

  Smallest radius to search for

• :max_radius (Integer) —

  Largest radius to search for

Returns:

• (Vips::Image) —

  Output image

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

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

Find hough line transform.

Parameters:

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

  Set of options

Options Hash (opts):

• :width (Integer) —

  horizontal size of parameter space

• :height (Integer) —

  Vertical size of parameter space

Returns:

• (Vips::Image) —

  Output image

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

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

Transform hsv to srgb.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Output to device with icc profile.

Parameters:

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

  Set of options

Options Hash (opts):

• :intent (Vips::Intent) —

  Rendering intent

• :pcs (Vips::PCS) —

  Set Profile Connection Space

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

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

Import from device with icc profile.

Parameters:

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

  Set of options

Options Hash (opts):

• :intent (Vips::Intent) —

  Rendering intent

• :pcs (Vips::PCS) —

  Set Profile Connection Space

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

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

Transform between devices with icc profiles.

Parameters:

• output_profile (String) —

  Filename to load output profile from

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

  Set of options

Options Hash (opts):

• :intent (Vips::Intent) —

  Rendering intent

• :pcs (Vips::PCS) —

  Set Profile Connection Space

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

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

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

Parameters:

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

  true values

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

  false values

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

  set of options

Options Hash (opts):

• :blend (Boolean) — default: false —

  Blend smoothly between th and el

Returns:

• (Image) —

  merged image

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

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

    if not th.is_a? Vips::Image
        th = Argument::imageize match_image, th
    end
    if not el.is_a? Vips::Image
        el = Argument::imageize match_image, el
    end

    Vips::call_base "ifthenelse", self, "", [th, el, opts]
end

#imag ⇒ Image

Return the imaginary part of a complex image.

Returns:

• (Image) —

  imaginary part of complex image

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

def imag
    complexget :imag
end

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

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

Parameters:

• sub (Vips::Image) —

  Sub-image to insert into main image

• x (Integer) —

  Left edge of sub in main

• y (Integer) —

  Top edge of sub in main

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

  Set of options

Options Hash (opts):

• :expand (Boolean) —

  Expand output to hold all of both inputs

• :background (Array<Double>) —

  Color for new pixels

Returns:

• (Vips::Image) —

  Output image

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

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

Invert an image.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Build an inverted look-up table.

Parameters:

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

  Set of options

Options Hash (opts):

• :size (Integer) —

  LUT size to generate

Returns:

• (Vips::Image) —

  Output image

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

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

Inverse fft.

Parameters:

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

  Set of options

Options Hash (opts):

• :real (Boolean) —

  Output only the real part of the transform

Returns:

• (Vips::Image) —

  Output image

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

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

Join a pair of images.

Parameters:

• in2 (Vips::Image) —

  Second input image

• direction (Vips::Direction) —

  Join left-right or up-down

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

  Set of options

Options Hash (opts):

• :expand (Boolean) —

  Expand output to hold all of both inputs

• :shim (Integer) —

  Pixels between images

• :background (Array<Double>) —

  Colour for new pixels

• :align (Vips::Align) —

  Align on the low, centre or high coordinate edge

Returns:

• (Vips::Image) —

  Output image

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

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

Save image to jpeg file.

Parameters:

• filename (String) —

  Filename to save to

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

  Set of options

Options Hash (opts):

• :Q (Integer) —

  Q factor

• :profile (String) —

  ICC profile to embed

• :optimize_coding (Boolean) —

  Compute optimal Huffman coding tables

• :interlace (Boolean) —

  Generate an interlaced (progressive) jpeg

• :no_subsample (Boolean) —

  Disable chroma subsample

• :trellis_quant (Boolean) —

  Apply trellis quantisation to each 8x8 block

• :overshoot_deringing (Boolean) —

  Apply overshooting to samples with extreme values

• :optimize_scans (Boolean) —

  Split the spectrum of DCT coefficients into separate scans

• :quant_table (Integer) —

  Use predefined quantization table with given index

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (nil)

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

#jpegsave_buffer(opts = {}) ⇒ Vips::Blob

Save image to jpeg buffer.

Parameters:

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

  Set of options

Options Hash (opts):

• :Q (Integer) —

  Q factor

• :profile (String) —

  ICC profile to embed

• :optimize_coding (Boolean) —

  Compute optimal Huffman coding tables

• :interlace (Boolean) —

  Generate an interlaced (progressive) jpeg

• :no_subsample (Boolean) —

  Disable chroma subsample

• :trellis_quant (Boolean) —

  Apply trellis quantisation to each 8x8 block

• :overshoot_deringing (Boolean) —

  Apply overshooting to samples with extreme values

• :optimize_scans (Boolean) —

  Split the spectrum of DCT coefficients into separate scans

• :quant_table (Integer) —

  Use predefined quantization table with given index

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (Vips::Blob) —

  Buffer to save to

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

#jpegsave_mime(opts = {}) ⇒ nil

Save image to jpeg mime.

Parameters:

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

  Set of options

Options Hash (opts):

• :Q (Integer) —

  Q factor

• :profile (String) —

  ICC profile to embed

• :optimize_coding (Boolean) —

  Compute optimal Huffman coding tables

• :interlace (Boolean) —

  Generate an interlaced (progressive) jpeg

• :no_subsample (Boolean) —

  Disable chroma subsample

• :trellis_quant (Boolean) —

  Apply trellis quantisation to each 8x8 block

• :overshoot_deringing (Boolean) —

  Apply overshooting to samples with extreme values

• :optimize_scans (Boolean) —

  Split the spectrum of DCT coefficients into separate scans

• :quant_table (Integer) —

  Use predefined quantization table with given index

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (nil)

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

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

Transform float lab to labq coding.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Transform float lab to signed short.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Transform lab to lch.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Transform cielab to xyz.

Parameters:

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

  Set of options

Options Hash (opts):

• :temp (Array<Double>) —

  Color temperature

Returns:

• (Vips::Image) —

  Output image

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

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

Label regions in an image.

Parameters:

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

  Set of options

Options Hash (opts):

• :segments (Integer) —

  Output Number of discrete contigious regions

Returns:

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

  Mask of region labels, Hash of optional output items

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

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

Unpack a labq image to float lab.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Unpack a labq image to short lab.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Convert a labq image to srgb.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Transform signed short lab to float.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Transform short lab to labq coding.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Transform lch to cmc.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Transform lch to lab.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Calculate (a * in + b).

Parameters:

• a (Array<Double>) —

  Multiply by this

• b (Array<Double>) —

  Add this

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

  Set of options

Options Hash (opts):

• :uchar (Boolean) —

  Output should be uchar

Returns:

• (Vips::Image) —

  Output image

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

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

Cache an image as a set of lines.

Parameters:

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

  Set of options

Options Hash (opts):

• :tile_height (Integer) —

  Tile height in pixels

• :access (Vips::Access) —

  Expected access pattern

• :threaded (Boolean) —

  Allow threaded access

• :persistent (Boolean) —

  Keep cache between evaluations

Returns:

• (Vips::Image) —

  Output image

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

#log ⇒ Image

Return the natural log of an image.

Returns:

• (Image) —

  natural log of each pixel

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

def log
    math :log
end

#log10 ⇒ Image

Return the log base 10 of an image.

Returns:

• (Image) —

  base 10 log of each pixel

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

def log10
    math :log10
end

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

Resample with an mapim image.

Parameters:

• index (Vips::Image) —

  Index pixels with this

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

  Set of options

Options Hash (opts):

• :interpolate (Vips::Interpolate) —

  Interpolate pixels with this

Returns:

• (Vips::Image) —

  Output image

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

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

Map an image though a lut.

Parameters:

• lut (Vips::Image) —

  Look-up table image

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

  Set of options

Options Hash (opts):

• :band (Integer) —

  apply one-band lut to this band of in

Returns:

• (Vips::Image) —

  Output image

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

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

First-order match of two images.

Parameters:

• sec (Vips::Image) —

  Secondary image

• xr1 (Integer) —

  Position of first reference tie-point

• yr1 (Integer) —

  Position of first reference tie-point

• xs1 (Integer) —

  Position of first secondary tie-point

• ys1 (Integer) —

  Position of first secondary tie-point

• xr2 (Integer) —

  Position of second reference tie-point

• yr2 (Integer) —

  Position of second reference tie-point

• xs2 (Integer) —

  Position of second secondary tie-point

• ys2 (Integer) —

  Position of second secondary tie-point

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

  Set of options

Options Hash (opts):

• :hwindow (Integer) —

  Half window size

• :harea (Integer) —

  Half area size

• :search (Boolean) —

  Search to improve tie-points

• :interpolate (Vips::Interpolate) —

  Interpolate pixels with this

Returns:

• (Vips::Image) —

  Output image

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

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

Apply a math operation to an image.

Parameters:

• math (Vips::OperationMath) —

  math to perform

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

#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) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Binary math operations with a constant.

Parameters:

• math2 (Vips::OperationMath2) —

  math to perform

• c (Array<Double>) —

  Array of constants

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

#matrixprint(opts = {}) ⇒ nil

Print matrix.

Parameters:

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

  Set of options

Options Hash (opts):

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (nil)

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

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

Save image to matrix file.

Parameters:

• filename (String) —

  Filename to save to

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

  Set of options

Options Hash (opts):

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (nil)

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

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

Find image maximum.

Parameters:

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

  Set of options

Options Hash (opts):

• :size (Integer) —

  Number of maximum values to find

• :x (Integer) —

  Output Horizontal position of maximum

• :y (Integer) —

  Output Vertical position of maximum

• :out_array (Array<Double>) —

  Output Array of output values

• :x_array (Array<Integer>) —

  Output Array of horizontal positions

• :y_array (Array<Integer>) —

  Output Array of vertical positions

Returns:

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

  Output value, Hash of optional output items

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

#maxpos ⇒ Real

Return the coordinates of the image maximum.

Returns:

• (Real, Real, Real) —

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

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

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

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

Measure a set of patches on a colour chart.

Parameters:

• h (Integer) —

  Number of patches across chart

• v (Integer) —

  Number of patches down chart

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

  Set of options

Options Hash (opts):

• :left (Integer) —

  Left edge of extract area

• :top (Integer) —

  Top edge of extract area

• :width (Integer) —

  Width of extract area

• :height (Integer) —

  Height of extract area

Returns:

• (Vips::Image) —

  Output array of statistics

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

#median(size = 3) ⇒ Image

a median filter

Parameters:

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

  size of filter window

Returns:

• (Image) —

  result of median filter

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

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

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

Merge two images.

Parameters:

• sec (Vips::Image) —

  Secondary image

• direction (Vips::Direction) —

  Horizontal or vertcial merge

• dx (Integer) —

  Horizontal displacement from sec to ref

• dy (Integer) —

  Vertical displacement from sec to ref

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

  Set of options

Options Hash (opts):

• :mblend (Integer) —

  Maximum blend size

Returns:

• (Vips::Image) —

  Output image

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

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

Find image minimum.

Parameters:

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

  Set of options

Options Hash (opts):

• :size (Integer) —

  Number of minimum values to find

• :x (Integer) —

  Output Horizontal position of minimum

• :y (Integer) —

  Output Vertical position of minimum

• :out_array (Array<Double>) —

  Output Array of output values

• :x_array (Array<Integer>) —

  Output Array of horizontal positions

• :y_array (Array<Integer>) —

  Output Array of vertical positions

Returns:

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

  Output value, Hash of optional output items

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

#minpos ⇒ Real

Return the coordinates of the image minimum.

Returns:

• (Real, Real, Real) —

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

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

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

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

Morphology operation.

Parameters:

• mask (Vips::Image) —

  Input matrix image

• morph (Vips::OperationMorphology) —

  Morphological operation to perform

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Mosaic two images.

Parameters:

• sec (Vips::Image) —

  Secondary image

• direction (Vips::Direction) —

  Horizontal or vertcial mosaic

• xref (Integer) —

  Position of reference tie-point

• yref (Integer) —

  Position of reference tie-point

• xsec (Integer) —

  Position of secondary tie-point

• ysec (Integer) —

  Position of secondary tie-point

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

  Set of options

Options Hash (opts):

• :hwindow (Integer) —

  Half window size

• :harea (Integer) —

  Half area size

• :mblend (Integer) —

  Maximum blend size

• :bandno (Integer) —

  Band to search for features on

• :dx0 (Integer) —

  Output Detected integer offset

• :dy0 (Integer) —

  Output Detected integer offset

• :scale1 (Float) —

  Output Detected scale

• :angle1 (Float) —

  Output Detected rotation

• :dx1 (Float) —

  Output Detected first-order displacement

• :dy1 (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 1998

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

First-order mosaic of two images.

Parameters:

• sec (Vips::Image) —

  Secondary image

• direction (Vips::Direction) —

  Horizontal or vertcial mosaic

• xr1 (Integer) —

  Position of first reference tie-point

• yr1 (Integer) —

  Position of first reference tie-point

• xs1 (Integer) —

  Position of first secondary tie-point

• ys1 (Integer) —

  Position of first secondary tie-point

• xr2 (Integer) —

  Position of second reference tie-point

• yr2 (Integer) —

  Position of second reference tie-point

• xs2 (Integer) —

  Position of second secondary tie-point

• ys2 (Integer) —

  Position of second secondary tie-point

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

  Set of options

Options Hash (opts):

• :hwindow (Integer) —

  Half window size

• :harea (Integer) —

  Half area size

• :search (Boolean) —

  Search to improve tie-points

• :interpolate (Vips::Interpolate) —

  Interpolate pixels with this

• :mblend (Integer) —

  Maximum blend size

• :bandno (Integer) —

  Band to search for features on

Returns:

• (Vips::Image) —

  Output image

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

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

Pick most-significant byte from an image.

Parameters:

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

  Set of options

Options Hash (opts):

• :band (Integer) —

  Band to msb

Returns:

• (Vips::Image) —

  Output image

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

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

Multiply two images.

Parameters:

• right (Vips::Image) —

  Right-hand image argument

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

#new_from_image(value) ⇒ Image

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

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

Parameters:

• pixel (Real, Array<Real>) —

  value to put in each pixel

Returns:

• (Image) —

  constant image

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

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

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

Find threshold for percent of pixels.

Parameters:

• percent (Float) —

  Percent of pixels

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

  Set of options

Returns:

• (Integer) —

  Threshold above which lie percent of pixels

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

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

Calculate phase correlation.

Parameters:

• in2 (Vips::Image) —

  Second input image

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Save image to png file.

Parameters:

• filename (String) —

  Filename to save to

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

  Set of options

Options Hash (opts):

• :compression (Integer) —

  Compression factor

• :interlace (Boolean) —

  Interlace image

• :profile (String) —

  ICC profile to embed

• :filter (Vips::ForeignPngFilter) —

  libpng row filter flag(s)

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (nil)

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

#pngsave_buffer(opts = {}) ⇒ Vips::Blob

Save image to png buffer.

Parameters:

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

  Set of options

Options Hash (opts):

• :compression (Integer) —

  Compression factor

• :interlace (Boolean) —

  Interlace image

• :profile (String) —

  ICC profile to embed

• :filter (Vips::ForeignPngFilter) —

  libpng row filter flag(s)

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (Vips::Blob) —

  Buffer to save to

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

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

• xyz

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

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

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

Save image to ppm file.

Parameters:

• filename (String) —

  Filename to save to

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

  Set of options

Options Hash (opts):

• :ascii (Boolean) —

  save as ascii

• :squash (Boolean) —

  save as one bit

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (nil)

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

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

Premultiply image alpha.

Parameters:

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

  Set of options

Options Hash (opts):

• :max_alpha (Float) —

  Maximum value of alpha channel

Returns:

• (Vips::Image) —

  Output image

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

#profile(opts = {}) ⇒ Array<] First non-zero pixel in column, First non-zero pixel in row

Find image profiles.

Parameters:

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

  Set of options

Returns:

• (Array<] First non-zero pixel in column, First non-zero pixel in row) —

  Array<] First non-zero pixel in column, First non-zero pixel in row

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

#project(opts = {}) ⇒ Array<] Sums of columns, Sums of rows

Find image projections.

Parameters:

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

  Set of options

Returns:

• (Array<] Sums of columns, Sums of rows) —

  Array<] Sums of columns, Sums of rows

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

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

Resample an image with a quadratic transform.

Parameters:

• coeff (Vips::Image) —

  Coefficient matrix

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

  Set of options

Options Hash (opts):

• :interpolate (Vips::Interpolate) —

  Interpolate values with this

Returns:

• (Vips::Image) —

  Output image

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

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

Unpack radiance coding to float rgb.

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Save image to radiance file.

Parameters:

• filename (String) —

  Filename to save to

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

  Set of options

Options Hash (opts):

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (nil)

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

#radsave_buffer(opts = {}) ⇒ Vips::Blob

Save image to radiance buffer.

Parameters:

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

  Set of options

Options Hash (opts):

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (Vips::Blob) —

  Buffer to save to

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

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

Rank filter.

Parameters:

• width (Integer) —

  Window width in pixels

• height (Integer) —

  Window height in pixels

• index (Integer) —

  Select pixel at index

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Save image to raw file.

Parameters:

• filename (String) —

  Filename to save to

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

  Set of options

Options Hash (opts):

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (nil)

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

#rawsave_fd(fd, opts = {}) ⇒ nil

Write raw image to file descriptor.

Parameters:

• fd (Integer) —

  File descriptor to write to

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

  Set of options

Options Hash (opts):

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (nil)

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

#real ⇒ Image

Return the real part of a complex image.

Returns:

• (Image) —

  real part of complex image

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

def real
    complexget :real
end

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

Linear recombination with matrix.

Parameters:

• m (Vips::Image) —

  matrix of coefficients

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

• xyz

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

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

#reduce(hshrink, vshrink, opts = {}) ⇒ Vips::Image

Reduce an image.

Parameters:

• hshrink (Float) —

  Horizontal shrink factor

• vshrink (Float) —

  Vertical shrink factor

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

  Set of options

Options Hash (opts):

• :kernel (Vips::Kernel) —

  Resampling kernel

• :centre (Boolean) —

  Use centre sampling convention

Returns:

• (Vips::Image) —

  Output image

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

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

Shrink an image horizontally.

Parameters:

• hshrink (Float) —

  Horizontal shrink factor

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

  Set of options

Options Hash (opts):

• :kernel (Vips::Kernel) —

  Resampling kernel

• :centre (Boolean) —

  Use centre sampling convention

Returns:

• (Vips::Image) —

  Output image

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

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

Shrink an image vertically.

Parameters:

• vshrink (Float) —

  Vertical shrink factor

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

  Set of options

Options Hash (opts):

• :kernel (Vips::Kernel) —

  Resampling kernel

• :centre (Boolean) —

  Use centre sampling convention

Returns:

• (Vips::Image) —

  Output image

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

#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) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Relational operations against a constant.

Parameters:

• relational (Vips::OperationRelational) —

  relational to perform

• c (Array<Double>) —

  Array of constants

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Remainder after integer division of two images.

Parameters:

• right (Vips::Image) —

  Right-hand image argument

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Remainder after integer division of an image and a constant.

Parameters:

• c (Array<Double>) —

  Array of constants

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Replicate an image.

Parameters:

• across (Integer) —

  Repeat this many times horizontally

• down (Integer) —

  Repeat this many times vertically

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Resize an image.

Parameters:

• scale (Float) —

  Scale image by this factor

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

  Set of options

Options Hash (opts):

• :kernel (Vips::Kernel) —

  Resampling kernel

• :centre (Boolean) —

  Use centre sampling convention

• :vscale (Float) —

  Vertical scale image by this factor

Returns:

• (Vips::Image) —

  Output image

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

#rint ⇒ Image

Return the nearest integral value.

Returns:

• (Image) —

  rint of image

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

def rint
    round :rint
end

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

Rotate an image.

Parameters:

• angle (Vips::Angle) —

  Angle to rotate image

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

#rot180 ⇒ Image

Rotate by 180 degrees clockwise.

Returns:

• (Image) —

  rotated image

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

def rot180
    rot :d180
end

#rot270 ⇒ Image

Rotate by 270 degrees clockwise.

Returns:

• (Image) —

  rotated image

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

def rot270
    rot :d270
end

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

Rotate an image.

Parameters:

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

  Set of options

Options Hash (opts):

• :angle (Vips::Angle45) —

  Angle to rotate image

Returns:

• (Vips::Image) —

  Output image

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

#rot90 ⇒ Image

Rotate by 90 degrees clockwise.

Returns:

• (Image) —

  rotated image

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

def rot90
    rot :d90
end

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

Perform a round function on an image.

Parameters:

• round (Vips::OperationRound) —

  rounding operation to perform

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

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

Scale an image to uchar.

Parameters:

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

  Set of options

Options Hash (opts):

• :log (Boolean) —

  Log scale

• :exp (Float) —

  Exponent for log scale

Returns:

• (Vips::Image) —

  Output image

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

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

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

Parameters:

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

  Set of options

Returns:

• (Vips::Image) —

  Output image

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

def scaleimage(opts = {})
    Vips::Image.scale self, opts
end

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

Convert scrgb to bw.

Parameters:

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

  Set of options

Options Hash (opts):

• :depth (Integer) —

  Output device space depth in bits

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1692

#scRGB2sRGB(opts = {}) ⇒ Vips::Image

Convert an scrgb image to srgb.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :depth (Integer) —

  Output device space depth in bits

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1698

#scRGB2XYZ(opts = {}) ⇒ Vips::Image

Transform scrgb to xyz.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1575

#sequential(opts = {}) ⇒ Vips::Image

Check sequential access.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :tile_height (Integer) —

  Tile height in pixels

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 292

#set(name, value) ⇒ Object

Set a GValue on an image

Parameters:

• name (String) —

  Metadata field to set

• value (GValue) —

  GValue to set

See Also:

• #set_value

# File 'lib/vips/image.rb', line 713

#set_value(name, value) ⇒ Object

Set a metadata item on an image. Ruby types are automatically transformed into the matching GValue, if possible.

For example, you can use this to set an image's ICC profile:

x = y.set_value "icc-profile-data", profile

where profile is an ICC profile held as a binary string object.

Parameters:

• name (String) —

  Metadata field to set

• value (Object) —

  Value to set

See Also:

• #set

# File 'lib/vips/image.rb', line 758

def set_value(name, value)
    gtype = get_typeof name
    if gtype != 0
        # array-ize
        value = Argument::arrayize gtype, value

        # blob-ize
        if gtype.type_is_a? GLib::Type["VipsBlob"]
            if not value.is_a? Vips::Blob
                value = Vips::Blob.copy value
            end
        end

        # image-ize
        if gtype.type_is_a? GLib::Type["VipsImage"]
            if not value.is_a? Vips::Image
                value = imageize match_image, value
            end
        end

    end

    set name, value
end

#sharpen(opts = {}) ⇒ Vips::Image

Unsharp masking for print.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :sigma (Float) —

  Sigma of Gaussian

• :x1 (Float) —

  Flat/jaggy threshold

• :y2 (Float) —

  Maximum brightening

• :y3 (Float) —

  Maximum darkening

• :m1 (Float) —

  Slope for flat areas

• :m2 (Float) —

  Slope for jaggy areas

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1842

#shrink(hshrink, vshrink, opts = {}) ⇒ Vips::Image

Shrink an image.

Parameters:

• hshrink (Float) —

  Horizontal shrink factor

• vshrink (Float) —

  Vertical shrink factor

• opts (Hash) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1442

#shrinkh(hshrink, opts = {}) ⇒ Vips::Image

Shrink an image horizontally.

Parameters:

• hshrink (Integer) —

  Horizontal shrink factor

• opts (Hash) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1449

#shrinkv(vshrink, opts = {}) ⇒ Vips::Image

Shrink an image vertically.

Parameters:

• vshrink (Integer) —

  Vertical shrink factor

• opts (Hash) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1455

#sign(opts = {}) ⇒ Vips::Image

Unit vector of pixel.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 109

#similarity(opts = {}) ⇒ Vips::Image

Similarity transform of an image.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :interpolate (Vips::Interpolate) —

  Interpolate pixels with this

• :scale (Float) —

  Scale by this factor

• :angle (Float) —

  Rotate anticlockwise by this many degrees

• :odx (Float) —

  Horizontal output displacement

• :ody (Float) —

  Vertical output displacement

• :idx (Float) —

  Horizontal input displacement

• :idy (Float) —

  Vertical input displacement

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1505

#sin ⇒ Image

Return the sine of an image in degrees.

Returns:

• (Image) —

  sine of each pixel

# File 'lib/vips/image.rb', line 1188

def sin
    math :sin 
end

#size ⇒ Integer

Get the image size.

Returns:

• (Integer, Integer) —

  image width and height

# File 'lib/vips/image.rb', line 786

def size
    [width, height]
end

#smartcrop(width, height, opts = {}) ⇒ Vips::Image

Extract an area from an image.

Parameters:

• width (Integer) —

  Width of extract area

• height (Integer) —

  Height of extract area

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :interesting (Vips::Interesting) —

  How to measure interestingness

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 375

#spcor(ref, opts = {}) ⇒ Vips::Image

Spatial correlation.

Parameters:

• ref (Vips::Image) —

  Input reference image

• opts (Hash) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1836

#spectrum(opts = {}) ⇒ Vips::Image

Make displayable power spectrum.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1878

#sRGB2HSV(opts = {}) ⇒ Vips::Image

Transform srgb to hsv.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1630

#sRGB2scRGB(opts = {}) ⇒ Vips::Image

Convert an srgb image to scrgb.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1687

#stats(opts = {}) ⇒ Vips::Image

Find image average.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output array of statistics

# File 'lib/vips/methods.rb', line 191

#stdif(width, height, opts = {}) ⇒ Vips::Image

Statistical difference.

Parameters:

• width (Integer) —

  Window width in pixels

• height (Integer) —

  Window height in pixels

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :a (Float) —

  Weight of new mean

• :m0 (Float) —

  New mean

• :b (Float) —

  Weight of new deviation

• :s0 (Float) —

  New deviation

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1717

#subsample(xfac, yfac, opts = {}) ⇒ Vips::Image

Subsample an image.

Parameters:

• xfac (Integer) —

  Horizontal subsample factor

• yfac (Integer) —

  Vertical subsample factor

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :point (Boolean) —

  Point sample

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 512

#subtract(right, opts = {}) ⇒ Vips::Image

Subtract two images.

Parameters:

• right (Vips::Image) —

  Right-hand image argument

• opts (Hash) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 21

#tan ⇒ Image

Return the tangent of an image in degrees.

Returns:

• (Image) —

  tangent of each pixel

# File 'lib/vips/image.rb', line 1202

def tan
    math :tan
end

#tiffsave(filename, opts = {}) ⇒ nil

Save image to tiff file.

Parameters:

• filename (String) —

  Filename to save to

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :compression (Vips::ForeignTiffCompression) —

  Compression for this file

• :Q (Integer) —

  Q factor

• :predictor (Vips::ForeignTiffPredictor) —

  Compression prediction

• :profile (String) —

  ICC profile to embed

• :tile (Boolean) —

  Write a tiled tiff

• :tile_width (Integer) —

  Tile width in pixels

• :tile_height (Integer) —

  Tile height in pixels

• :pyramid (Boolean) —

  Write a pyramidal tiff

• :squash (Boolean) —

  Squash images down to 1 bit

• :miniswhite (Boolean) —

  Use 0 for white in 1-bit images

• :resunit (Vips::ForeignTiffResunit) —

  Resolution unit

• :xres (Float) —

  Horizontal resolution in pixels/mm

• :yres (Float) —

  Vertical resolution in pixels/mm

• :bigtiff (Boolean) —

  Write a bigtiff image

• :properties (Boolean) —

  Write a properties document to IMAGEDESCRIPTION

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (nil)

# File 'lib/vips/methods.rb', line 1354

#tiffsave_buffer(opts = {}) ⇒ Vips::Blob

Save image to tiff buffer.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :compression (Vips::ForeignTiffCompression) —

  Compression for this file

• :Q (Integer) —

  Q factor

• :predictor (Vips::ForeignTiffPredictor) —

  Compression prediction

• :profile (String) —

  ICC profile to embed

• :tile (Boolean) —

  Write a tiled tiff

• :tile_width (Integer) —

  Tile width in pixels

• :tile_height (Integer) —

  Tile height in pixels

• :pyramid (Boolean) —

  Write a pyramidal tiff

• :squash (Boolean) —

  Squash images down to 1 bit

• :miniswhite (Boolean) —

  Use 0 for white in 1-bit images

• :resunit (Vips::ForeignTiffResunit) —

  Resolution unit

• :xres (Float) —

  Horizontal resolution in pixels/mm

• :yres (Float) —

  Vertical resolution in pixels/mm

• :bigtiff (Boolean) —

  Write a bigtiff image

• :properties (Boolean) —

  Write a properties document to IMAGEDESCRIPTION

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (Vips::Blob) —

  Buffer to save to

# File 'lib/vips/methods.rb', line 1377

#tilecache(opts = {}) ⇒ Vips::Image

Cache an image as a set of tiles.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :tile_width (Integer) —

  Tile width in pixels

• :tile_height (Integer) —

  Tile height in pixels

• :max_tiles (Integer) —

  Maximum number of tiles to cache

• :access (Vips::Access) —

  Expected access pattern

• :threaded (Boolean) —

  Allow threaded access

• :persistent (Boolean) —

  Keep cache between evaluations

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 272

#to_a ⇒ Array

Convert to an Array. This will be slow for large images.

Returns:

• (Array) —

  array of Fixnum

# File 'lib/vips/image.rb', line 988

def to_a
    # we render the image to a big string, then unpack 
    # as a Ruby array of the correct type
    memory = write_to_memory.pack('c*')

    # 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.nick.to_sym] + '*'

    # and unpack into something like [1, 2, 3, 4 ..]
    array = memory.unpack(template)

    # gather band elements together
    pixel_array = []
    array.each_slice(bands) {|pixel| pixel_array << pixel}

    # build rows 
    row_array = []
    pixel_array.each_slice(width) {|row| row_array << row}

    return row_array
end

#unpremultiply(opts = {}) ⇒ Vips::Image

Unpremultiply image alpha.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :max_alpha (Float) —

  Maximum value of alpha channel

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 477

#vipssave(filename, opts = {}) ⇒ nil

Save image to vips file.

Parameters:

• filename (String) —

  Filename to save to

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (nil)

# File 'lib/vips/methods.rb', line 1185

#webpsave(filename, opts = {}) ⇒ nil

Save image to webp file.

Parameters:

• filename (String) —

  Filename to save to

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :Q (Integer) —

  Q factor

• :lossless (Boolean) —

  enable lossless compression

• :preset (Vips::ForeignWebpPreset) —

  Preset for lossy compression

• :smart_subsample (Boolean) —

  Enable high quality chroma subsampling

• :near_lossless (Boolean) —

  Enable preprocessing in lossless mode (uses Q)

• :alpha_q (Integer) —

  Change alpha plane fidelity for lossy compression

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (nil)

# File 'lib/vips/methods.rb', line 1327

#webpsave_buffer(opts = {}) ⇒ Vips::Blob

Save image to webp buffer.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :Q (Integer) —

  Q factor

• :lossless (Boolean) —

  enable lossless compression

• :preset (Vips::ForeignWebpPreset) —

  Preset for lossy compression

• :smart_subsample (Boolean) —

  Enable high quality chroma subsampling

• :near_lossless (Boolean) —

  Enable preprocessing in lossless mode (uses Q)

• :alpha_q (Integer) —

  Change alpha plane fidelity for lossy compression

• :strip (Boolean) —

  Strip all metadata from image

• :background (Array<Double>) —

  Background value

Returns:

• (Vips::Blob) —

  Buffer to save to

# File 'lib/vips/methods.rb', line 1341

#wrap(opts = {}) ⇒ Vips::Image

Wrap image origin.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :x (Integer) —

  Left edge of input in output

• :y (Integer) —

  Top edge of input in output

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 498

#write_to_buffer(format_string, opts = {}) ⇒ String

Write this image to a memory buffer. Save options may be encoded in the format_string or given as a hash. For example:

buffer = image.write_to_buffer ".jpg[Q=90]"

or equivalently:

image.write_to_buffer ".jpg", :Q => 90

The full set of save options depend on the selected saver. Try something like:

$ vips jpegsave

to see all the available options for JPEG save.

Parameters:

• format_string (String) —

  save format plus options

• opts (Hash) (defaults to: {}) —

  set of options

Options Hash (opts):

• :strip (Boolean) — default: false —

  Strip all metadata from image

• :background (Array<Float>) — default: 0 —

  Background colour to flatten alpha against, if necessary

Returns:

• (String) —

  the image saved in the specified format

# File 'lib/vips/image.rb', line 662

def write_to_buffer(format_string, opts = {})
    filename = Vips::filename_get_filename format_string
    option_string = Vips::filename_get_options format_string
    saver = Vips::Foreign.find_save_buffer filename
    if saver == nil
        raise Vips::Error, "No known saver for '#{filename}'."
    end

    buffer = Vips::call_base saver, self, option_string, [opts]

    write_gc

    return buffer
end

#write_to_file(name, opts = {}) ⇒ Object

Write this image to a file. Save options may be encoded in the filename or given as a hash. For example:

image.write_to_file "fred.jpg[Q=90]"

or equivalently:

image.write_to_file "fred.jpg", :Q => 90

The full set of save options depend on the selected saver. Try something like:

$ vips jpegsave

to see all the available options for JPEG save.

Parameters:

• opts (Hash) (defaults to: {}) —

  set of options

• name (String) —

  filename to write to

Options Hash (opts):

• :strip (Boolean) — default: false —

  Strip all metadata from image

• :background (Array<Float>) — default: 0 —

  Background colour to flatten alpha against, if necessary

# File 'lib/vips/image.rb', line 624

def write_to_file(name, opts = {})
    filename = Vips::filename_get_filename name
    option_string = Vips::filename_get_options name
    saver = Vips::Foreign.find_save filename
    if saver == nil
        raise Vips::Error, "No known saver for '#{filename}'."
    end

    Vips::call_base saver, self, option_string, [filename, opts]

    write_gc
end

#XYZ2Lab(opts = {}) ⇒ Vips::Image

Transform xyz to lab.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Options Hash (opts):

• :temp (Array<Double>) —

  Colour temperature

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1539

#XYZ2scRGB(opts = {}) ⇒ Vips::Image

Transform xyz to scrgb.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1580

#XYZ2Yxy(opts = {}) ⇒ Vips::Image

Transform xyz to yxy.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1565

#Yxy2XYZ(opts = {}) ⇒ Vips::Image

Transform yxy to xyz.

Parameters:

• opts (Hash) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 1570

#zoom(xfac, yfac, opts = {}) ⇒ Vips::Image

Zoom an image.

Parameters:

• xfac (Integer) —

  Horizontal zoom factor

• yfac (Integer) —

  Vertical zoom factor

• opts (Hash) (defaults to: {}) —

  Set of options

Returns:

• (Vips::Image) —

  Output image

# File 'lib/vips/methods.rb', line 505

#|(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

# File 'lib/vips/image.rb', line 863

def |(other)
    call_enum("boolean", other, :or)
end

#~ ⇒ Image

Equivalent to image ^ -1

Returns:

• (Image) —

  image with bits flipped

# File 'lib/vips/image.rb', line 893

def ~
    self ^ -1
end