Class: Vips::Image

Inherits:

Object

Object
Vips::Image

show all

Defined in:

lib/vips8/image.rb,
lib/vips8/methods.rb

Overview

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

Instance Attribute Summary (collapse)

- (Integer) bands readonly
Image bands.
- (Vips::Coding) coding readonly
Image coding.
- (String) filename readonly
Image filename.
- (Vips::BandFormat) format readonly
Image format.
- (Integer) height readonly
Image height, in pixels.
- (Vips::Interpretation) interpretation readonly
Image interpretation.
- (Integer) width readonly
Image width, in pixels.
- (Float) xres readonly
Horizontal image resolution, in pixels per mm.
- (Float) yres readonly
Vertical image resolution, in pixels per mm.

Class Method Summary (collapse)

+ (Vips::Image) analyzeload(filename, opts = {})
Load an analyze6 image.
+ (Vips::Image) arrayjoin
Join an array of images.
+ (Vips::Image) bandrank
Band-wise rank of a set of images.
+ (Vips::Image) black(width, height, opts = {})
Make a black image.
+ (Vips::Image) csvload(filename, opts = {})
Load csv from file.
+ (Vips::Image) eye(width, height, opts = {})
Make an image showing the eye's spatial response.
+ (Vips::Image) fitsload(filename, opts = {})
Load a fits image.
+ (Vips::Image) fractsurf(width, height, fractal_dimension, opts = {})
Make a fractal surface.
+ (Vips::Image) gaussmat(sigma, min_ampl, opts = {})
Make a gaussian image.
+ (Vips::Image) gaussnoise(width, height, opts = {})
Make a gaussnoise image.
+ (Vips::Image) grey(width, height, opts = {})
Make a grey ramp image.
+ (Vips::Image) identity(opts = {})
Make a 1d image where pixel values are indexes.
+ (Vips::Image) jpegload(filename, opts = {})
Load jpeg from file.
+ (Vips::Image) jpegload_buffer(buffer, opts = {})
Load jpeg from buffer.
+ (Vips::Image) logmat(sigma, min_ampl, opts = {})
Make a laplacian of gaussian image.
+ (Vips::Image) magickload(filename, opts = {})
Load file with imagemagick.
+ (Vips::Image) magickload_buffer(buffer, opts = {})
Load buffer with imagemagick.
+ (Vips::Image) mask_butterworth(width, height, order, frequency_cutoff, amplitude_cutoff, opts = {})
Make a butterworth filter.
+ (Vips::Image) mask_butterworth_band(width, height, order, frequency_cutoff_x, frequency_cutoff_y, radius, amplitude_cutoff, opts = {})
Make a butterworth_band filter.
+ (Vips::Image) mask_butterworth_ring(width, height, order, frequency_cutoff, amplitude_cutoff, ringwidth, opts = {})
Make a butterworth ring filter.
+ (Vips::Image) mask_fractal(width, height, fractal_dimension, opts = {})
Make fractal filter.
+ (Vips::Image) mask_gaussian(width, height, frequency_cutoff, amplitude_cutoff, opts = {})
Make a gaussian filter.
+ (Vips::Image) mask_gaussian_band(width, height, frequency_cutoff_x, frequency_cutoff_y, radius, amplitude_cutoff, opts = {})
Make a gaussian filter.
+ (Vips::Image) mask_gaussian_ring(width, height, frequency_cutoff, amplitude_cutoff, ringwidth, opts = {})
Make a gaussian ring filter.
+ (Vips::Image) mask_ideal(width, height, frequency_cutoff, opts = {})
Make an ideal filter.
+ (Vips::Image) mask_ideal_band(width, height, frequency_cutoff_x, frequency_cutoff_y, radius, opts = {})
Make an ideal band filter.
+ (Vips::Image) mask_ideal_ring(width, height, frequency_cutoff, ringwidth, opts = {})
Make an ideal ring filter.
+ (Vips::Image) matload(filename, opts = {})
Load mat from file.
+ (Vips::Image) matrixload(filename, opts = {})
Load matrix from file.
+ (Object) method_missing(name, *args)
Invoke a vips operation with call.
+ (Image) new_from_array(array, scale = 1, offset = 0)
Create a new Image from a 1D or 2D array.
+ (Image) new_from_buffer(data, option_string, opts = {})
Create a new Image for an image encoded in a format, such as JPEG, in a memory string.
+ (Image) new_from_file(name, opts = {})
Return a new Image for a file on disc.
+ (Vips::Image) openexrload(filename, opts = {})
Load an openexr image.
+ (Vips::Image) openslideload(filename, opts = {})
Load file with openslide.
+ (Vips::Image) pngload(filename, opts = {})
Load png from file.
+ (Vips::Image) pngload_buffer(buffer, opts = {})
Load png from buffer.
+ (Vips::Image) ppmload(filename, opts = {})
Load ppm from file.
+ (Vips::Image) radload(filename, opts = {})
Load a radiance image from a file.
+ (Vips::Image) rawload(filename, width, height, bands, opts = {})
Load raw data from a file.
+ (Vips::Image) sines(width, height, opts = {})
Make a 2d sine wave.
+ (Vips::Image) sum
Sum an array of images.
+ (Object) system(cmd_format, opts = {})
Run an external command.
+ (Vips::Image) text(text, opts = {})
Make a text image.
+ (Vips::Image) tiffload(filename, opts = {})
Load tiff from file.
+ (Vips::Image) tiffload_buffer(buffer, opts = {})
Load tiff from buffer.
+ (Vips::Image) tonelut(opts = {})
Build a look-up table.
+ (Vips::Image) vipsload(filename, opts = {})
Load vips from file.
+ (Vips::Image) webpload(filename, opts = {})
Load webp from file.
+ (Vips::Image) webpload_buffer(buffer, opts = {})
Load webp from buffer.
+ (Vips::Image) xyz(width, height, opts = {})
Make an image where pixel values are coordinates.
+ (Vips::Image) zone(width, height, opts = {})
Make a zone plate.

Instance Method Summary (collapse)

- (Image) !
Equivalent to image ^ -1.
- (Image) !=(other)
Compare inequality to nil, an image, constant or array.
- (Image) %(other)
Remainder after integer division with an image, constant or array.
- (Image) &(other)
Integer bitwise AND with an image, constant or array.
- (Image) *(other)
Multiply an image, constant or array.
- (Image) **(other)
Raise to power of an image, constant or array.
- (Image) +(other)
Add an image, constant or array.
- (Image) +@
Image.
- (Image) -(other)
Subtract an image, constant or array.
- (Image) -@
Equivalent to image * -1.
- (Image) /(other)
Divide an image, constant or array.
- (Image) <(other)
Relational less than with an image, constant or array.
- (Image) <<(other)
Integer left shift with an image, constant or array.
- (Image) <=(other)
Relational less than or equal to with an image, constant or array.
- (Image) ==(other)
Compare equality to nil, an image, constant or array.
- (Image) >(other)
Relational more than with an image, constant or array.
- (Image) >=(other)
Relational more than or equal to with an image, constant or array.
- (Image) >>(other)
Integer right shift with an image, constant or array.
- (Image) [](index)
Fetch bands using a number or a range.
- (Image) ^(other)
Integer bitwise EOR with an image, constant or array.
- (Vips::Image) abs(opts = {})
Absolute value of an image.
- (Image) acos
Return the inverse cosine of an image in degrees.
- (Vips::Image) add(right, opts = {})
Add two images.
- (Vips::Image) affine(matrix, opts = {})
Affine transform of an image.
- (Image) asin
Return the inverse sine of an image in degrees.
- (Image) atan
Return the inverse tangent of an image in degrees.
- (Vips::Image) autorot(opts = {})
Autorotate image by exif tag.
- (Float) avg(opts = {})
Find image average.
- (Image) bandand
AND the bands of an image together.
- (Vips::Image) bandbool(boolean, opts = {})
Boolean operation across image bands.
- (Image) bandeor
EOR the bands of an image together.
- (Vips::Image) bandfold(opts = {})
Fold up x axis into bands.
- (Image) bandjoin(other)
Join a set of images bandwise.
- (Vips::Image) bandjoin_const(c, opts = {})
Append a constant band to an image.
- (Vips::Image) bandmean(opts = {})
Band-wise average.
- (Image) bandor
OR the bands of an image together.
- (Array<Image>) bandsplit
Split an n-band image into n separate images.
- (Vips::Image) bandunfold(opts = {})
Unfold image bands into x axis.
- (Vips::Image) boolean(right, boolean, opts = {})
Boolean operation on two images.
- (Vips::Image) boolean_const(c, boolean, opts = {})
Boolean operations against a constant.
- (Vips::Image) buildlut(opts = {})
Build a look-up table.
- (Vips::Image) byteswap(opts = {})
Byteswap an image.
- (Vips::Image) cache(opts = {})
Cache an image.
- (Vips::Image) cast(format, opts = {})
Cast an image.
- (Image) ceil
Return the smallest integral value not less than the argument.
- (Vips::Image) CMC2LCh(opts = {})
Transform lch to cmc.
- (Vips::Image) colourspace(space, opts = {})
Convert to a new colourspace.
- (Vips::Image) compass(mask, opts = {})
Convolve with rotating mask.
- (Vips::Image) complex(cmplx, opts = {})
Perform a complex operation on an image.
- (Vips::Image) complex2(right, cmplx, opts = {})
Complex binary operations on two images.
- (Vips::Image) complexform(right, opts = {})
Form a complex image from two real images.
- (Vips::Image) complexget(get, opts = {})
Get a component from a complex image.
- (Image) conj
Return the complex conjugate of an image.
- (Vips::Image) conv(mask, opts = {})
Convolution operation.
- (Vips::Image) convsep(mask, opts = {})
Seperable convolution operation.
- (Vips::Image) copy(opts = {})
Copy an image.
- (Image) cos
Return the cosine of an image in degrees.
- (Float) countlines(direction, opts = {})
Count lines in an image.
- (Object) csvsave(filename, opts = {})
Save image to csv file.
- (Vips::Image) dE00(right, opts = {})
Calculate de00.
- (Vips::Image) dE76(right, opts = {})
Calculate de76.
- (Vips::Image) dECMC(right, opts = {})
Calculate decmc.
- (Float) deviate(opts = {})
Find image standard deviation.
- (Image) dilate(mask)
Dilate with a structuring element.
- (Vips::Image) divide(right, opts = {})
Divide two images.
- (Vips::Image) draw_circle(ink, cx, cy, radius, opts = {})
Draw a circle on an image.
- (Vips::Image) draw_flood(ink, x, y, opts = {})
Flood-fill an area.
- (Vips::Image) draw_image(sub, x, y, opts = {})
Paint an image into another image.
- (Vips::Image) draw_line(ink, x1, y1, x2, y2, opts = {})
Draw a line on an image.
- (Vips::Image) draw_mask(ink, mask, x, y, opts = {})
Draw a mask on an image.
- (Vips::Image) draw_rect(ink, left, top, width, height, opts = {})
Paint a rectangle on an image.
- (Vips::Image) draw_smudge(left, top, width, height, opts = {})
Blur a rectangle on an image.
- (Object) dzsave(filename, opts = {})
Save image to deep zoom format.
- (Vips::Image) embed(x, y, width, height, opts = {})
Embed an image in a larger image.
- (Image) erode(mask)
Erode with a structuring element.
- (Image) exp
Return e ** pixel.
- (Image) exp10
Return 10 ** pixel.
- (Vips::Image) extract_area(left, top, width, height, opts = {})
Extract an area from an image.
- (Vips::Image) extract_band(band, opts = {})
Extract band from an image.
- (Vips::Image) falsecolour(opts = {})
False-colour an image.
- (Vips::Image) fastcor(ref, opts = {})
Fast correlation.
- (Object) fitssave(filename, opts = {})
Save image to fits file.
- (Vips::Image) flatten(opts = {})
Flatten alpha out of an image.
- (Vips::Image) flip(direction, opts = {})
Flip an image.
- (Image) fliphor
Flip horizontally.
- (Image) flipver
Flip vertically.
- (Vips::Image) float2rad(opts = {})
Transform float rgb to radiance coding.
- (Image) floor
Return the largest integral value not greater than the argument.
- (Vips::Image) freqmult(mask, opts = {})
Frequency-domain filtering.
- (Vips::Image) fwfft(opts = {})
Forward fft.
- (Vips::Image) gamma(opts = {})
Gamma an image.
- (Vips::Image) gaussblur(sigma, opts = {})
Gaussian blur.
- (GValue) get(name)
Fetch a GValue from an image.
- (void) get_value(name)
Get a metadata item from an image.
- (Array<Double>) getpoint(x, y, opts = {})
Read a point from an image.
- (Vips::Image) globalbalance(opts = {})
Global balance an image mosaic.
- (Vips::Image) grid(tile_height, across, down, opts = {})
Grid an image.
- (Vips::Image) hist_cum(opts = {})
Form cumulative histogram.
- (Float) hist_entropy(opts = {})
Estimate image entropy.
- (Vips::Image) hist_equal(opts = {})
Histogram equalisation.
- (Vips::Image) hist_find(opts = {})
Find image histogram.
- (Vips::Image) hist_find_indexed(index, opts = {})
Find indexed image histogram.
- (Vips::Image) hist_find_ndim(opts = {})
Find n-dimensional image histogram.
- (Boolean) hist_ismonotonic(opts = {})
Test for monotonicity.
- (Vips::Image) hist_local(width, height, opts = {})
Local histogram equalisation.
- (Vips::Image) hist_match(ref, opts = {})
Match two histograms.
- (Vips::Image) hist_norm(opts = {})
Normalise histogram.
- (Vips::Image) hist_plot(opts = {})
Plot histogram.
- (Vips::Image) hough_circle(opts = {})
Find hough circle transform.
- (Vips::Image) hough_line(opts = {})
Find hough line transform.
- (Vips::Image) HSV2sRGB(opts = {})
Transform hsv to srgb.
- (Vips::Image) icc_export(opts = {})
Output to device with icc profile.
- (Vips::Image) icc_import(opts = {})
Import from device with icc profile.
- (Vips::Image) icc_transform(output_profile, opts = {})
Transform between devices with icc profiles.
- (Image) ifthenelse(th, el, opts = {})
Select pixels from th if self is non-zero and from el if self is zero.
- (Image) imag
Return the imaginary part of a complex image.
- (Vips::Image) insert(sub, x, y, opts = {})
Insert image @sub into @main at @x, @y.
- (Vips::Image) invert(opts = {})
Invert an image.
- (Vips::Image) invertlut(opts = {})
Build an inverted look-up table.
- (Vips::Image) invfft(opts = {})
Inverse fft.
- (Vips::Image) join(in2, direction, opts = {})
Join a pair of images.
- (Object) jpegsave(filename, opts = {})
Save image to jpeg file.
- (Vips::Blob) jpegsave_buffer(opts = {})
Save image to jpeg buffer.
- (Object) jpegsave_mime(opts = {})
Save image to jpeg mime.
- (Vips::Image) Lab2LabQ(opts = {})
Transform float lab to labq coding.
- (Vips::Image) Lab2LabS(opts = {})
Transform float lab to signed short.
- (Vips::Image) Lab2LCh(opts = {})
Transform lab to lch.
- (Vips::Image) Lab2XYZ(opts = {})
Transform cielab to xyz.
- (Vips::Image) labelregions(opts = {})
Label regions in an image.
- (Vips::Image) LabQ2Lab(opts = {})
Unpack a labq image to float lab.
- (Vips::Image) LabQ2LabS(opts = {})
Unpack a labq image to short lab.
- (Vips::Image) LabQ2sRGB(opts = {})
Convert a labq image to srgb.
- (Vips::Image) LabS2Lab(opts = {})
Transform signed short lab to float.
- (Vips::Image) LabS2LabQ(opts = {})
Transform short lab to labq coding.
- (Vips::Image) LCh2CMC(opts = {})
Transform lch to cmc.
- (Vips::Image) LCh2Lab(opts = {})
Transform lch to lab.
- (Vips::Image) linear(a, b, opts = {})
Calculate (a * in + b).
- (Vips::Image) linecache(opts = {})
Cache an image as a set of lines.
- (Image) log
Return the natural log of an image.
- (Image) log10
Return the log base 10 of an image.
- (Vips::Image) mapim(index, opts = {})
Resample with an mapim image.
- (Vips::Image) maplut(lut, opts = {})
Map an image though a lut.
- (Vips::Image) match(sec, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, opts = {})
First-order match of two images.
- (Vips::Image) math(math, opts = {})
Apply a math operation to an image.
- (Vips::Image) math2(right, math2, opts = {})
Binary math operations.
- (Vips::Image) math2_const(c, math2, opts = {})
Pow( @in, @c ).
- (Object) matrixprint(opts = {})
Print matrix.
- (Object) matrixsave(filename, opts = {})
Save image to matrix file.
- (Float) max(opts = {})
Find image maximum.
- (Real) maxpos
Return the coordinates of the image maximum.
- (Vips::Image) measure(h, v, opts = {})
Measure a set of patches on a colour chart.
- (Image) median(size = 3)
a median filter.
- (Vips::Image) merge(sec, direction, dx, dy, opts = {})
Merge two images.
- (Object) method_missing(name, *args)
Invoke a vips operation with call, using self as the first input image argument.
- (Float) min(opts = {})
Find image minimum.
- (Real) minpos
Return the coordinates of the image minimum.
- (Vips::Image) morph(mask, morph, opts = {})
Morphology operation.
- (Vips::Image) mosaic(sec, direction, xref, yref, xsec, ysec, opts = {})
Mosaic two images.
- (Vips::Image) mosaic1(sec, direction, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, opts = {})
First-order mosaic of two images.
- (Vips::Image) msb(opts = {})
Pick most-significant byte from an image.
- (Vips::Image) multiply(right, opts = {})
Multiply two images.
- (Integer) percent(percent, opts = {})
Find threshold for percent of pixels.
- (Vips::Image) phasecor(in2, opts = {})
Calculate phase correlation.
- (Object) pngsave(filename, opts = {})
Save image to png file.
- (Vips::Blob) pngsave_buffer(opts = {})
Save image to png buffer.
- (Image) polar
Return an image with rectangular pixels converted to polar.
- (Object) ppmsave(filename, opts = {})
Save image to ppm file.
- (Vips::Image) premultiply(opts = {})
Premultiply image alpha.
- (Array<Vips::Image, Vips::Image>) profile(opts = {})
Find image profiles.
- (Array<Vips::Image, Vips::Image>) project(opts = {})
Find image projections.
- (Vips::Image) quadratic(coeff, opts = {})
Resample an image with a quadratic transform.
- (Vips::Image) rad2float(opts = {})
Unpack radiance coding to float rgb.
- (Object) radsave(filename, opts = {})
Save image to radiance file.
- (Vips::Image) rank(width, height, index, opts = {})
Rank filter.
- (Object) rawsave(filename, opts = {})
Save image to raw file.
- (Object) rawsave_fd(fd, opts = {})
Write raw image to file descriptor.
- (Image) real
Return the real part of a complex image.
- (Vips::Image) recomb(m, opts = {})
Linear recombination with matrix.
- (Image) rect
Return an image with polar pixels converted to rectangular.
- (Vips::Image) relational(right, relational, opts = {})
Relational operation on two images.
- (Vips::Image) relational_const(c, relational, opts = {})
Relational operations against a constant.
- (Vips::Image) remainder(right, opts = {})
Remainder after integer division of two images.
- (Vips::Image) remainder_const(c, opts = {})
Remainder after integer division of an image and a constant.
- (Vips::Image) replicate(across, down, opts = {})
Replicate an image.
- (Vips::Image) resize(scale, opts = {})
Resize an image.
- (Image) rint
Return the nearest integral value.
- (Vips::Image) rot(angle, opts = {})
Rotate an image.
- (Image) rot180
Rotate by 180 degrees clockwise.
- (Image) rot270
Rotate by 270 degrees clockwise.
- (Vips::Image) rot45(opts = {})
Rotate an image.
- (Image) rot90
Rotate by 90 degrees clockwise.
- (Vips::Image) round(round, opts = {})
Perform a round function on an image.
- (Vips::Image) scale(opts = {})
Scale an image to uchar.
- (Vips::Image) scRGB2BW(opts = {})
Convert scrgb to bw.
- (Vips::Image) scRGB2sRGB(opts = {})
Convert an scrgb image to srgb.
- (Vips::Image) scRGB2XYZ(opts = {})
Transform scrgb to xyz.
- (Vips::Image) sequential(opts = {})
Check sequential access.
- (Object) set(name, value)
Set a GValue on an image.
- (Object) set_value(name, value)
Set a metadata item on an image.
- (Vips::Image) sharpen(opts = {})
Unsharp masking for print.
- (Vips::Image) shrink(xshrink, yshrink, opts = {})
Shrink an image.
- (Vips::Image) shrink2(xshrink, yshrink, opts = {})
Shrink an image.
- (Vips::Image) shrinkh(xshrink, opts = {})
Shrink an image horizontally.
- (Vips::Image) shrinkv(yshrink, opts = {})
Shrink an image vertically.
- (Vips::Image) sign(opts = {})
Unit vector of pixel.
- (Vips::Image) similarity(opts = {})
Similarity transform of an image.
- (Image) sin
Return the sine of an image in degrees.
- (Vips::Image) spcor(ref, opts = {})
Spatial correlation.
- (Vips::Image) spectrum(opts = {})
Make displayable power spectrum.
- (Vips::Image) sRGB2HSV(opts = {})
Transform srgb to hsv.
- (Vips::Image) sRGB2scRGB(opts = {})
Convert an srgb image to scrgb.
- (Vips::Image) stats(opts = {})
Find image average.
- (Vips::Image) stdif(width, height, opts = {})
Statistical difference.
- (Vips::Image) subsample(xfac, yfac, opts = {})
Subsample an image.
- (Vips::Image) subtract(right, opts = {})
Subtract two images.
- (Image) tan
Return the tangent of an image in degrees.
- (Object) tiffsave(filename, opts = {})
Save image to tiff file.
- (Vips::Image) tilecache(opts = {})
Cache an image as a set of tiles.
- (Vips::Image) unpremultiply(opts = {})
Unpremultiply image alpha.
- (Object) vipssave(filename, opts = {})
Save image to vips file.
- (Object) webpsave(filename, opts = {})
Save image to webp file.
- (Vips::Blob) webpsave_buffer(opts = {})
Save image to webp buffer.
- (Vips::Image) wrap(opts = {})
Wrap image origin.
- (String) write_to_buffer(format_string, opts = {})
Write this image to a memory buffer.
- (Object) write_to_file(name, opts = {})
Write this image to a file.
- (Vips::Image) XYZ2Lab(opts = {})
Transform xyz to lab.
- (Vips::Image) XYZ2scRGB(opts = {})
Transform xyz to scrgb.
- (Vips::Image) XYZ2Yxy(opts = {})
Transform xyz to yxy.
- (Vips::Image) Yxy2XYZ(opts = {})
Transform yxy to xyz.
- (Vips::Image) zoom(xfac, yfac, opts = {})
Zoom an image.
- (Image) |(other)
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

- (`Object`) method_missing(name, *args)

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



306
307
308

# File 'lib/vips8/image.rb', line 306

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

Instance Attribute Details

- (`Integer`) bands (readonly)

Returns image bands

Returns:

(Integer) —
image bands

# File 'lib/vips8/image.rb', line 545

- (`Vips::Coding`) coding (readonly)

Returns image coding

Returns:

(Vips::Coding) —
image coding

# File 'lib/vips8/image.rb', line 545

- (`String`) filename (readonly)

Returns image filename

Returns:

(String) —
image filename

# File 'lib/vips8/image.rb', line 545

- (`Vips::BandFormat`) format (readonly)

Returns image format

Returns:

(Vips::BandFormat) —
image format

# File 'lib/vips8/image.rb', line 545

- (`Integer`) height (readonly)

Returns image height, in pixels

Returns:

(Integer) —
image height, in pixels

# File 'lib/vips8/image.rb', line 545

- (`Vips::Interpretation`) interpretation (readonly)

Returns image interpretation

Returns:

(Vips::Interpretation) —
image interpretation

# File 'lib/vips8/image.rb', line 545

- (`Integer`) width (readonly)

Returns image width, in pixels

Returns:

(Integer) —
image width, in pixels

# File 'lib/vips8/image.rb', line 545

- (`Float`) xres (readonly)

Returns horizontal image resolution, in pixels per mm

Returns:

(Float) —
horizontal image resolution, in pixels per mm

# File 'lib/vips8/image.rb', line 545

- (`Float`) yres (readonly)

Returns vertical image resolution, in pixels per mm

Returns:

(Float) —
vertical image resolution, in pixels per mm

# File 'lib/vips8/image.rb', line 545

Class Method Details

+ (`Vips::Image`) analyzeload(filename, opts = {})

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
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 847

+ (`Vips::Image`) arrayjoin

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/vips8/methods.rb', line 346

+ (`Vips::Image`) bandrank

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/vips8/methods.rb', line 390

+ (`Vips::Image`) black(width, height, opts = {})

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/vips8/methods.rb', line 536

+ (`Vips::Image`) csvload(filename, opts = {})

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
:lines (Integer) —
Read this many lines from the file
:whitespace (String) —
Set of whitespace characters
:separator (String) —
Set of separator characters
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 825

+ (`Vips::Image`) eye(width, height, opts = {})

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/vips8/methods.rb', line 592

+ (`Vips::Image`) fitsload(filename, opts = {})

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
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1001

+ (`Vips::Image`) fractsurf(width, height, fractal_dimension, opts = {})

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/vips8/methods.rb', line 799

+ (`Vips::Image`) gaussmat(sigma, min_ampl, opts = {})

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/vips8/methods.rb', line 574

+ (`Vips::Image`) gaussnoise(width, height, opts = {})

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/vips8/methods.rb', line 544

+ (`Vips::Image`) grey(width, height, opts = {})

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/vips8/methods.rb', line 601

+ (`Vips::Image`) identity(opts = {})

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/vips8/methods.rb', line 791

+ (`Vips::Image`) jpegload(filename, opts = {})

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) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 905

+ (`Vips::Image`) jpegload_buffer(buffer, opts = {})

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) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 917

+ (`Vips::Image`) logmat(sigma, min_ampl, opts = {})

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/vips8/methods.rb', line 583

+ (`Vips::Image`) magickload(filename, opts = {})

Load file with imagemagick.

Parameters:

filename (String) —
Filename to load from
opts (Hash) (defaults to: {}) —
Set of options

Options Hash (opts):

:all_frames (Boolean) —
Read all frames from an image
:density (String) —
Canvas resolution for rendering vector formats like SVG
:disc (Boolean) —
Open to disc
:access (Vips::Access) —
Required access pattern for this file
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 979

+ (`Vips::Image`) magickload_buffer(buffer, opts = {})

Load buffer with imagemagick.

Parameters:

buffer (Vips::Blob) —
Buffer to load from
opts (Hash) (defaults to: {}) —
Set of options

Options Hash (opts):

:all_frames (Boolean) —
Read all frames from an image
:density (String) —
Canvas resolution for rendering vector formats like SVG
:disc (Boolean) —
Open to disc
:access (Vips::Access) —
Required access pattern for this file
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 990

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

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
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 666

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

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/vips8/methods.rb', line 695

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

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
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 680

+ (`Vips::Image`) mask_fractal(width, height, fractal_dimension, opts = {})

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
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter
:optical (Boolean) —
Rotate quadrants to optical space

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 753

+ (`Vips::Image`) mask_gaussian(width, height, frequency_cutoff, amplitude_cutoff, opts = {})

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
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter
:optical (Boolean) —
Rotate quadrants to optical space

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 711

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

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
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 738

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

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
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 724

+ (`Vips::Image`) mask_ideal(width, height, frequency_cutoff, opts = {})

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
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter
:optical (Boolean) —
Rotate quadrants to optical space

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 627

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

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
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 652

+ (`Vips::Image`) mask_ideal_ring(width, height, frequency_cutoff, ringwidth, opts = {})

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
:nodc (Boolean) —
Remove DC component
:reject (Boolean) —
Invert the sense of the filter
:optical (Boolean) —
Rotate quadrants to optical space

Returns:

(Vips::Image) —
Output image

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

+ (`Vips::Image`) matload(filename, opts = {})

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
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 896

+ (`Vips::Image`) matrixload(filename, opts = {})

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
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 838

+ (`Object`) method_missing(name, *args)

Invoke a vips operation with Vips.call.



311
312
313

# File 'lib/vips8/image.rb', line 311

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

+ (`Image`) new_from_array(array, scale = 1, offset = 0)

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]

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/vips8/image.rb', line 431

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

+ (`Image`) new_from_buffer(data, option_string, opts = {})

Create a new Vips::Image for an image encoded in a format, such as JPEG, in a memory string. Load options may be passed encoded 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. Only JPEG, PNG and TIFF images can be read from memory buffers.

Loading is fast: only enough of the image is loaded to be able to fill out the header. Pixels will only be processed 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/vips8/image.rb', line 396

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] + args
end

+ (`Image`) new_from_file(name, opts = {})

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.

Loading is fast: only enough of the image is loaded to be able to fill out the header. Pixels will only be processed 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/vips8/image.rb', line 350

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

+ (`Vips::Image`) openexrload(filename, opts = {})

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
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1010

+ (`Vips::Image`) openslideload(filename, opts = {})

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
:autocrop (Boolean) —
Crop to image bounds
:associated (String) —
Load this associated image
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 967

+ (`Vips::Image`) pngload(filename, opts = {})

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
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

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

+ (`Vips::Image`) pngload_buffer(buffer, opts = {})

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
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 887

+ (`Vips::Image`) ppmload(filename, opts = {})

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
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

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

+ (`Vips::Image`) radload(filename, opts = {})

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
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 807

+ (`Vips::Image`) rawload(filename, width, height, bands, opts = {})

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
:offset (Integer) —
Offset in bytes from start of file
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 856

+ (`Vips::Image`) sines(width, height, opts = {})

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/vips8/methods.rb', line 617

+ (`Vips::Image`) sum

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/vips8/methods.rb', line 79

+ (`Object`) system(cmd_format, opts = {})

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 image
:log (String) —
Command log

Returns:

[]

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

+ (`Vips::Image`) text(text, opts = {})

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 width
: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/vips8/methods.rb', line 553

+ (`Vips::Image`) tiffload(filename, opts = {})

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
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 947

+ (`Vips::Image`) tiffload_buffer(buffer, opts = {})

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
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 957

+ (`Vips::Image`) tonelut(opts = {})

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/vips8/methods.rb', line 776

+ (`Vips::Image`) vipsload(filename, opts = {})

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
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 869

+ (`Vips::Image`) webpload(filename, opts = {})

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
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

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

+ (`Vips::Image`) webpload_buffer(buffer, opts = {})

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
:flags (Vips::ForeignFlags) —
Flags for this file

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 938

+ (`Vips::Image`) xyz(width, height, opts = {})

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/vips8/methods.rb', line 564

+ (`Vips::Image`) zone(width, height, opts = {})

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/vips8/methods.rb', line 609

Instance Method Details

- (`Image`) !

Equivalent to image ^ -1

Returns:

(Image) —
image with bits flipped



741
742
743

# File 'lib/vips8/image.rb', line 741

def !
    self ^ -1
end

- (`Image`) !=(other)

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/vips8/image.rb', line 820

def !=(other)
    if other == nil
        true
    elsif other.is_a?(Vips::Image) 
        relational(other, :noteq) 
    else
        relational_const(other, :noteq)
    end
end

- (`Image`) %(other)

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/vips8/image.rb', line 679

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

- (`Image`) &(other)

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/vips8/image.rb', line 724

def &(other)
    other.is_a?(Vips::Image) ? 
        boolean(other, :and) : boolean_const(other, :and)
end

- (`Image`) *(other)

Multiply an image, constant or array.

Parameters:

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

Returns:

(Image) —
result of multiplication



662
663
664

# File 'lib/vips8/image.rb', line 662

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

- (`Image`) **(other)

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/vips8/image.rb', line 688

def **(other)
    other.is_a?(Vips::Image) ? 
        math2(other, :pow) : math2_const(other, :pow)
end

- (`Image`) +(other)

Add an image, constant or array.

Parameters:

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

Returns:

(Image) —
result of addition



645
646
647

# File 'lib/vips8/image.rb', line 645

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

- (`Image`) +@

Returns image

Returns:

(Image) —
image



753
754
755

# File 'lib/vips8/image.rb', line 753

def +@
    self
end

- (`Image`) -(other)

Subtract an image, constant or array.

Parameters:

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

Returns:

(Image) —
result of subtraction

# File 'lib/vips8/image.rb', line 653

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



760
761
762

# File 'lib/vips8/image.rb', line 760

def -@
    self * -1
end

- (`Image`) /(other)

Divide an image, constant or array.

Parameters:

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

Returns:

(Image) —
result of division

# File 'lib/vips8/image.rb', line 670

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

- (`Image`) <(other)

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/vips8/image.rb', line 768

def <(other)
    other.is_a?(Vips::Image) ? 
        relational(other, :less) : relational_const(other, :less)
end

- (`Image`) <<(other)

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/vips8/image.rb', line 697

def <<(other)
    other.is_a?(Vips::Image) ? 
        boolean(other, :lshift) : boolean_const(other, :lshift)
end

- (`Image`) <=(other)

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/vips8/image.rb', line 778

def <=(other)
    other.is_a?(Vips::Image) ? 
        relational(other, :lesseq) : relational_const(other, :lesseq)
end

- (`Image`) ==(other)

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/vips8/image.rb', line 806

def ==(other)
    if other == nil
        false
    elsif other.is_a?(Vips::Image)  
        relational(other, :equal) 
    else
        relational_const(other, :equal)
    end
end

- (`Image`) >(other)

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/vips8/image.rb', line 787

def >(other)
    other.is_a?(Vips::Image) ? 
        relational(other, :more) : relational_const(other, :more)
end

- (`Image`) >=(other)

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/vips8/image.rb', line 797

def >=(other)
    other.is_a?(Vips::Image) ? 
        relational(other, :moreeq) : relational_const(other, :moreeq)
end

- (`Image`) >>(other)

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/vips8/image.rb', line 706

def >>(other)
    other.is_a?(Vips::Image) ? 
        boolean(other, :rshift) : boolean_const(other, :rshift)
end

- (`Image`) [](index)

Fetch bands using a number or a range

Parameters:

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

Returns:

(Image) —
extracted band(s)

# File 'lib/vips8/image.rb', line 834

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

- (`Image`) ^(other)

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/vips8/image.rb', line 733

def ^(other)
    other.is_a?(Vips::Image) ? 
        boolean(other, :eor) : boolean_const(other, :eor)
end

- (`Vips::Image`) abs(opts = {})

Absolute value of an image.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

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

- (`Image`) acos

Return the inverse cosine of an image in degrees.

Returns:

(Image) —
inverse cosine of each pixel



1034
1035
1036

# File 'lib/vips8/image.rb', line 1034

def acos
    math :acos
end

- (`Vips::Image`) add(right, opts = {})

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/vips8/methods.rb', line 15

- (`Vips::Image`) affine(matrix, opts = {})

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/vips8/methods.rb', line 1261

- (`Image`) asin

Return the inverse sine of an image in degrees.

Returns:

(Image) —
inverse sine of each pixel



1027
1028
1029

# File 'lib/vips8/image.rb', line 1027

def asin
    math :asin
end

- (`Image`) atan

Return the inverse tangent of an image in degrees.

Returns:

(Image) —
inverse tangent of each pixel



1041
1042
1043

# File 'lib/vips8/image.rb', line 1041

def atan
    math :atan
end

- (`Vips::Image`) autorot(opts = {})

Autorotate image by exif tag.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Options Hash (opts):

:angle (Vips::Angle) —
Angle image was rotated by

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 434

- (`Float`) avg(opts = {})

Find image average.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Float) —
Output value

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

- (`Image`) bandand

AND the bands of an image together

Returns:

(Image) —
all bands ANDed together



870
871
872

# File 'lib/vips8/image.rb', line 870

def bandand
    bandbool :and
end

- (`Vips::Image`) bandbool(boolean, opts = {})

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/vips8/methods.rb', line 402

- (`Image`) bandeor

EOR the bands of an image together

Returns:

(Image) —
all bands EORed together



884
885
886

# File 'lib/vips8/image.rb', line 884

def bandeor
    bandbool :eor
end

- (`Vips::Image`) bandfold(opts = {})

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/vips8/methods.rb', line 446

- (`Image`) bandjoin(other)

Join a set of images bandwise.

Parameters:

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

Returns:

(Image) —
many band image

# File 'lib/vips8/image.rb', line 899

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

    Vips::Image.bandjoin([self] + other)
end

- (`Vips::Image`) bandjoin_const(c, opts = {})

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/vips8/methods.rb', line 384

- (`Vips::Image`) bandmean(opts = {})

Band-wise average.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 397

- (`Image`) bandor

OR the bands of an image together

Returns:

(Image) —
all bands ORed together



877
878
879

# File 'lib/vips8/image.rb', line 877

def bandor
    bandbool :or
end

- (`Array<Image>`) bandsplit

Split an n-band image into n separate images.

Returns:

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



891
892
893

# File 'lib/vips8/image.rb', line 891

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

- (`Vips::Image`) bandunfold(opts = {})

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/vips8/methods.rb', line 452

- (`Vips::Image`) boolean(right, boolean, opts = {})

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/vips8/methods.rb', line 52

- (`Vips::Image`) boolean_const(c, boolean, opts = {})

Boolean operations against a constant.

Parameters:

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

Returns:

(Vips::Image) —
Output image

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

- (`Vips::Image`) buildlut(opts = {})

Build a look-up table.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 765

- (`Vips::Image`) byteswap(opts = {})

Byteswap an image.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

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

- (`Vips::Image`) cache(opts = {})

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/vips8/methods.rb', line 300

- (`Vips::Image`) cast(format, opts = {})

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/vips8/methods.rb', line 415

- (`Image`) ceil

Return the smallest integral value not less than the argument.

Returns:

(Image) —
ceil of image



856
857
858

# File 'lib/vips8/image.rb', line 856

def ceil
    round :ceil
end

- (`Vips::Image`) CMC2LCh(opts = {})

Transform lch to cmc.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1329

- (`Vips::Image`) colourspace(space, opts = {})

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/vips8/methods.rb', line 1295

- (`Vips::Image`) compass(mask, opts = {})

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/vips8/methods.rb', line 1550

- (`Vips::Image`) complex(cmplx, opts = {})

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/vips8/methods.rb', line 147

- (`Vips::Image`) complex2(right, cmplx, opts = {})

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/vips8/methods.rb', line 66

- (`Vips::Image`) complexform(right, opts = {})

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/vips8/methods.rb', line 73

- (`Vips::Image`) complexget(get, opts = {})

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/vips8/methods.rb', line 153

- (`Image`) conj

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



999
1000
1001

# File 'lib/vips8/image.rb', line 999

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

- (`Vips::Image`) conv(mask, opts = {})

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/vips8/methods.rb', line 1541

- (`Vips::Image`) convsep(mask, opts = {})

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/vips8/methods.rb', line 1562

- (`Vips::Image`) copy(opts = {})

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/vips8/methods.rb', line 257

- (`Image`) cos

Return the cosine of an image in degrees.

Returns:

(Image) —
cosine of each pixel



1013
1014
1015

# File 'lib/vips8/image.rb', line 1013

def cos
    math :cos
end

- (`Float`) countlines(direction, opts = {})

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/vips8/methods.rb', line 1645

- (`Object`) csvsave(filename, opts = {})

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:

[]

# File 'lib/vips8/methods.rb', line 1037

- (`Vips::Image`) dE00(right, opts = {})

Calculate de00.

Parameters:

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

Returns:

(Vips::Image) —
Output image

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

- (`Vips::Image`) dE76(right, opts = {})

Calculate de76.

Parameters:

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

Returns:

(Vips::Image) —
Output image

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

- (`Vips::Image`) dECMC(right, opts = {})

Calculate decmc.

Parameters:

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

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1450

- (`Float`) deviate(opts = {})

Find image standard deviation.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Float) —
Output value

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

- (`Image`) dilate(mask)

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



1107
1108
1109

# File 'lib/vips8/image.rb', line 1107

def dilate(mask)
    morph mask, :dilate
end

- (`Vips::Image`) divide(right, opts = {})

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/vips8/methods.rb', line 33

- (`Vips::Image`) draw_circle(ink, cx, cy, radius, opts = {})

Draw a circle on an image.

Parameters:

ink (Array<Double>) —
Colour 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/vips8/methods.rb', line 1687

- (`Vips::Image`) draw_flood(ink, x, y, opts = {})

Flood-fill an area.

Parameters:

ink (Array<Double>) —
Colour 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) —
Left edge of modified area
:top (Integer) —
top edge of modified area
:width (Integer) —
width of modified area
:height (Integer) —
height of modified area

Returns:

(Vips::Image) —
Image to draw on

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

- (`Vips::Image`) draw_image(sub, x, y, opts = {})

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/vips8/methods.rb', line 1711

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

Draw a line on an image.

Parameters:

ink (Array<Double>) —
Colour 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/vips8/methods.rb', line 1677

- (`Vips::Image`) draw_mask(ink, mask, x, y, opts = {})

Draw a mask on an image.

Parameters:

ink (Array<Double>) —
Colour 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/vips8/methods.rb', line 1668

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

Paint a rectangle on an image.

Parameters:

ink (Array<Double>) —
Colour 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/vips8/methods.rb', line 1657

- (`Vips::Image`) draw_smudge(left, top, width, height, opts = {})

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/vips8/methods.rb', line 1720

- (`Object`) dzsave(filename, opts = {})

Save image to deep zoom format.

Parameters:

filename (String) —
Filename to save to
opts (Hash) (defaults to: {}) —
Set of options

Options Hash (opts):

:layout (Vips::ForeignDzLayout) —
Directory layout
:suffix (String) —
Filename suffix for tiles
:overlap (Integer) —
Tile overlap in pixels
:tile_size (Integer) —
Tile size in pixels
:centre (Boolean) —
Center image in tile
:depth (Vips::ForeignDzDepth) —
Pyramid depth
:angle (Vips::Angle) —
Rotate image during save
:container (Vips::ForeignDzContainer) —
Pyramid container type
:properties (Boolean) —
Write a properties file to the output directory
:strip (Boolean) —
Strip all metadata from image
:background (Array<Double>) —
Background value

Returns:

[]

# File 'lib/vips8/methods.rb', line 1085

- (`Vips::Image`) embed(x, y, width, height, opts = {})

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>) —
Colour for background pixels

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 308

- (`Image`) erode(mask)

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



1095
1096
1097

# File 'lib/vips8/image.rb', line 1095

def erode(mask)
    morph mask, :erode
end

- (`Image`) exp

Return e ** pixel.

Returns:

(Image) —
e ** pixel



1062
1063
1064

# File 'lib/vips8/image.rb', line 1062

def exp
    math :exp
end

- (`Image`) exp10

Return 10 ** pixel.

Returns:

(Image) —
10 ** pixel



1069
1070
1071

# File 'lib/vips8/image.rb', line 1069

def exp10
    math :exp10
end

- (`Vips::Image`) extract_area(left, top, width, height, opts = {})

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/vips8/methods.rb', line 359

- (`Vips::Image`) extract_band(band, opts = {})

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/vips8/methods.rb', line 377

- (`Vips::Image`) falsecolour(opts = {})

False-colour an image.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 525

- (`Vips::Image`) fastcor(ref, opts = {})

Fast correlation.

Parameters:

ref (Vips::Image) —
Input reference image
opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

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

- (`Object`) fitssave(filename, opts = {})

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:

[]

# File 'lib/vips8/methods.rb', line 1213

- (`Vips::Image`) flatten(opts = {})

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/vips8/methods.rb', line 458

- (`Vips::Image`) flip(direction, opts = {})

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/vips8/methods.rb', line 319

- (`Image`) fliphor

Flip horizontally.

Returns:

(Image) —
image flipped horizontally



1076
1077
1078

# File 'lib/vips8/image.rb', line 1076

def fliphor
    flip :horizontal
end

- (`Image`) flipver

Flip vertically.

Returns:

(Image) —
image flipped vertically



1083
1084
1085

# File 'lib/vips8/image.rb', line 1083

def flipver
    flip :vertical
end

- (`Vips::Image`) float2rad(opts = {})

Transform float rgb to radiance coding.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1389

- (`Image`) floor

Return the largest integral value not greater than the argument.

Returns:

(Image) —
floor of image



849
850
851

# File 'lib/vips8/image.rb', line 849

def floor
    round :floor
end

- (`Vips::Image`) freqmult(mask, opts = {})

Frequency-domain filtering.

Parameters:

mask (Vips::Image) —
Input mask image
opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1613

- (`Vips::Image`) fwfft(opts = {})

Forward fft.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1602

- (`Vips::Image`) gamma(opts = {})

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/vips8/methods.rb', line 530

- (`Vips::Image`) gaussblur(sigma, opts = {})

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/vips8/methods.rb', line 1594

- (`GValue`) get(name)

Fetch a GValue from an image

Parameters:

name (String) —
Metadata field to fetch

Returns:

(GValue) —
GValue from image

See Also:

get_value

# File 'lib/vips8/image.rb', line 571

- (`void`) get_value(name)

This method returns an undefined value.

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

See Also:

# File 'lib/vips8/image.rb', line 631

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

    Argument::unwrap(value)
end

- (`Array<Double>`) getpoint(x, y, opts = {})

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/vips8/image.rb', line 934

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

- (`Vips::Image`) globalbalance(opts = {})

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/vips8/methods.rb', line 1806

- (`Vips::Image`) grid(tile_height, across, down, opts = {})

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/vips8/methods.rb', line 477

- (`Vips::Image`) hist_cum(opts = {})

Form cumulative histogram.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1497

- (`Float`) hist_entropy(opts = {})

Estimate image entropy.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Float) —
Output value

# File 'lib/vips8/methods.rb', line 1536

- (`Vips::Image`) hist_equal(opts = {})

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/vips8/methods.rb', line 1513

- (`Vips::Image`) hist_find(opts = {})

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/vips8/methods.rb', line 196

- (`Vips::Image`) hist_find_indexed(index, opts = {})

Find indexed image histogram.

Parameters:

index (Vips::Image) —
Index image
opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output histogram

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

- (`Vips::Image`) hist_find_ndim(opts = {})

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/vips8/methods.rb', line 202

- (`Boolean`) hist_ismonotonic(opts = {})

Test for monotonicity.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Boolean) —
true if in is monotonic

# File 'lib/vips8/methods.rb', line 1531

- (`Vips::Image`) hist_local(width, height, opts = {})

Local histogram equalisation.

Parameters:

width (Integer) —
Window width in pixels
height (Integer) —
Window height in pixels
opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1524

- (`Vips::Image`) hist_match(ref, opts = {})

Match two histograms.

Parameters:

ref (Vips::Image) —
Reference histogram
opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

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

- (`Vips::Image`) hist_norm(opts = {})

Normalise histogram.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1508

- (`Vips::Image`) hist_plot(opts = {})

Plot histogram.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1519

- (`Vips::Image`) hough_circle(opts = {})

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/vips8/methods.rb', line 221

- (`Vips::Image`) hough_line(opts = {})

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/vips8/methods.rb', line 214

- (`Vips::Image`) HSV2sRGB(opts = {})

Transform hsv to srgb.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1404

- (`Vips::Image`) icc_export(opts = {})

Output to device with icc profile.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Options Hash (opts):

:pcs (Vips::PCS) —
Set Profile Connection Space
:intent (Vips::Intent) —
Rendering intent
:output_profile (String) —
Filename to load output profile from
:depth (Integer) —
Output device space depth in bits

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1418

- (`Vips::Image`) icc_import(opts = {})

Import from device with icc profile.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Options Hash (opts):

:pcs (Vips::PCS) —
Set Profile Connection Space
:intent (Vips::Intent) —
Rendering intent
:embedded (Boolean) —
Use embedded input profile, if available
:input_profile (String) —
Filename to load input profile from

Returns:

(Vips::Image) —
Output image

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

- (`Vips::Image`) icc_transform(output_profile, opts = {})

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

:pcs (Vips::PCS) —
Set Profile Connection Space
:intent (Vips::Intent) —
Rendering intent
:embedded (Boolean) —
Use embedded input profile, if available
:input_profile (String) —
Filename to load input profile from
:depth (Integer) —
Output device space depth in bits

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1427

- (`Image`) ifthenelse(th, el, opts = {})

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/vips8/image.rb', line 1141

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] + args
end

- (`Image`) imag

Return the imaginary part of a complex image.

Returns:

(Image) —
imaginary part of complex image



961
962
963

# File 'lib/vips8/image.rb', line 961

def imag
    complexget :imag
end

- (`Vips::Image`) insert(sub, x, y, opts = {})

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>) —
Colour for new pixels

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 325

- (`Vips::Image`) invert(opts = {})

Invert an image.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

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

- (`Vips::Image`) invertlut(opts = {})

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/vips8/methods.rb', line 770

- (`Vips::Image`) invfft(opts = {})

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/vips8/methods.rb', line 1607

- (`Vips::Image`) join(in2, direction, opts = {})

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

:align (Vips::Align) —
Align on the low, centre or high coordinate edge
:expand (Boolean) —
Expand output to hold all of both inputs
:shim (Integer) —
Pixels between images
:background (Array<Double>) —
Colour for new pixels

Returns:

(Vips::Image) —
Output image

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

- (`Object`) jpegsave(filename, opts = {})

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
:strip (Boolean) —
Strip all metadata from image
:background (Array<Double>) —
Background value

Returns:

[]

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

- (`Vips::Blob`) jpegsave_buffer(opts = {})

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
:strip (Boolean) —
Strip all metadata from image
:background (Array<Double>) —
Background value

Returns:

(Vips::Blob) —
Buffer to save to

# File 'lib/vips8/methods.rb', line 1141

- (`Object`) jpegsave_mime(opts = {})

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
:strip (Boolean) —
Strip all metadata from image
:background (Array<Double>) —
Background value

Returns:

[]

# File 'lib/vips8/methods.rb', line 1156

- (`Vips::Image`) Lab2LabQ(opts = {})

Transform float lab to labq coding.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

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

- (`Vips::Image`) Lab2LabS(opts = {})

Transform float lab to signed short.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1379

- (`Vips::Image`) Lab2LCh(opts = {})

Transform lab to lch.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1314

- (`Vips::Image`) Lab2XYZ(opts = {})

Transform cielab to xyz.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Options Hash (opts):

:temp (Array<Double>) —
Colour temperature

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1302

- (`Vips::Image`) labelregions(opts = {})

Label regions in an image.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Options Hash (opts):

:segments (Integer) —
Number of discrete contigious regions

Returns:

(Vips::Image) —
Mask of region labels

# File 'lib/vips8/methods.rb', line 1651

- (`Vips::Image`) LabQ2Lab(opts = {})

Unpack a labq image to float lab.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1354

- (`Vips::Image`) LabQ2LabS(opts = {})

Unpack a labq image to short lab.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

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

- (`Vips::Image`) LabQ2sRGB(opts = {})

Convert a labq image to srgb.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1394

- (`Vips::Image`) LabS2Lab(opts = {})

Transform signed short lab to float.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1374

- (`Vips::Image`) LabS2LabQ(opts = {})

Transform short lab to labq coding.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1369

- (`Vips::Image`) LCh2CMC(opts = {})

Transform lch to cmc.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1324

- (`Vips::Image`) LCh2Lab(opts = {})

Transform lch to lab.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1319

- (`Vips::Image`) linear(a, b, opts = {})

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/vips8/methods.rb', line 90

- (`Vips::Image`) linecache(opts = {})

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/vips8/methods.rb', line 283

- (`Image`) log

Return the natural log of an image.

Returns:

(Image) —
natural log of each pixel



1048
1049
1050

# File 'lib/vips8/image.rb', line 1048

def log
    math :log
end

- (`Image`) log10

Return the log base 10 of an image.

Returns:

(Image) —
base 10 log of each pixel



1055
1056
1057

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

def log10
    math :log10
end

- (`Vips::Image`) mapim(index, opts = {})

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/vips8/methods.rb', line 1221

- (`Vips::Image`) maplut(lut, opts = {})

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/vips8/methods.rb', line 1473

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

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/vips8/methods.rb', line 1781

- (`Vips::Image`) math(math, opts = {})

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/vips8/methods.rb', line 98

- (`Vips::Image`) math2(right, math2, opts = {})

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/vips8/methods.rb', line 59

- (`Vips::Image`) math2_const(c, math2, opts = {})

Pow( @in, @c ).

Parameters:

c (Array<Double>) —
Array of constants
math2 (Vips::OperationMath2) —
math to perform
opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

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

- (`Object`) matrixprint(opts = {})

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:

[]

# File 'lib/vips8/methods.rb', line 1054

- (`Object`) matrixsave(filename, opts = {})

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:

[]

# File 'lib/vips8/methods.rb', line 1046

- (`Float`) max(opts = {})

Find image maximum.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Options Hash (opts):

:size (Integer) —
Number of maximum values to find
:x (Integer) —
Horizontal position of maximum
:y (Integer) —
Vertical position of maximum
:out_array (Array<Double>) —
Array of output values
:x_array (Array<Integer>) —
Array of horizontal positions
:y_array (Array<Integer>) —
Array of vertical positions

Returns:

(Float) —
Output value

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

- (`Real`) maxpos

Return the coordinates of the image maximum.

Returns:

(Real, Real, Real) —
maximum value, x coordinate of maximum, y coordinate of maximum

# File 'lib/vips8/image.rb', line 911

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

- (`Vips::Image`) measure(h, v, opts = {})

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/vips8/methods.rb', line 239

- (`Image`) median(size = 3)

a median filter

Parameters:

size (Integer) (defaults to: 3) —
size of filter window

Returns:

(Image) —
result of median filter



947
948
949

# File 'lib/vips8/image.rb', line 947

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

- (`Vips::Image`) merge(sec, direction, dx, dy, opts = {})

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/vips8/methods.rb', line 1729

- (`Float`) min(opts = {})

Find image minimum.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Options Hash (opts):

:size (Integer) —
Number of minimum values to find
:x (Integer) —
Horizontal position of minimum
:y (Integer) —
Vertical position of minimum
:out_array (Array<Double>) —
Array of output values
:x_array (Array<Integer>) —
Array of horizontal positions
:y_array (Array<Integer>) —
Array of vertical positions

Returns:

(Float) —
Output value

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

- (`Real`) minpos

Return the coordinates of the image minimum.

Returns:

(Real, Real, Real) —
minimum value, x coordinate of minimum, y coordinate of minimum

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

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

- (`Vips::Image`) morph(mask, morph, opts = {})

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/vips8/methods.rb', line 1630

- (`Vips::Image`) mosaic(sec, direction, xref, yref, xsec, ysec, opts = {})

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) —
Detected integer offset
:dy0 (Integer) —
Detected integer offset
:scale1 (Float) —
Detected scale
:angle1 (Float) —
Detected rotation
:dx1 (Float) —
Detected first-order displacement
:dy1 (Float) —
Detected first-order displacement

Returns:

(Vips::Image) —
Output image

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

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

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/vips8/methods.rb', line 1760

- (`Vips::Image`) msb(opts = {})

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/vips8/methods.rb', line 514

- (`Vips::Image`) multiply(right, opts = {})

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/vips8/methods.rb', line 27

- (`Integer`) percent(percent, opts = {})

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/vips8/methods.rb', line 1480

- (`Vips::Image`) phasecor(in2, opts = {})

Calculate phase correlation.

Parameters:

in2 (Vips::Image) —
Second input image
opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1624

- (`Object`) pngsave(filename, opts = {})

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:

[]

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

- (`Vips::Blob`) pngsave_buffer(opts = {})

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/vips8/methods.rb', line 1114

- (`Image`) polar

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:



974
975
976

# File 'lib/vips8/image.rb', line 974

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

- (`Object`) ppmsave(filename, opts = {})

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:

[]

# File 'lib/vips8/methods.rb', line 1027

- (`Vips::Image`) premultiply(opts = {})

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/vips8/methods.rb', line 465

- (`Array<Vips::Image, Vips::Image>`) profile(opts = {})

Find image profiles.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Array<Vips::Image, Vips::Image>) —
First non-zero pixel in column, First non-zero pixel in row

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

- (`Array<Vips::Image, Vips::Image>`) project(opts = {})

Find image projections.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Array<Vips::Image, Vips::Image>) —
Sums of columns, Sums of rows

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

- (`Vips::Image`) quadratic(coeff, opts = {})

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/vips8/methods.rb', line 1254

- (`Vips::Image`) rad2float(opts = {})

Unpack radiance coding to float rgb.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1384

- (`Object`) radsave(filename, opts = {})

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:

[]

# File 'lib/vips8/methods.rb', line 1019

- (`Vips::Image`) rank(width, height, index, opts = {})

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/vips8/methods.rb', line 1637

- (`Object`) rawsave(filename, opts = {})

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:

[]

# File 'lib/vips8/methods.rb', line 1061

- (`Object`) rawsave_fd(fd, opts = {})

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:

[]

# File 'lib/vips8/methods.rb', line 1069

- (`Image`) real

Return the real part of a complex image.

Returns:

(Image) —
real part of complex image



954
955
956

# File 'lib/vips8/image.rb', line 954

def real
    complexget :real
end

- (`Vips::Image`) recomb(m, opts = {})

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/vips8/methods.rb', line 440

- (`Image`) rect

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:



987
988
989

# File 'lib/vips8/image.rb', line 987

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

- (`Vips::Image`) relational(right, relational, opts = {})

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/vips8/methods.rb', line 39

- (`Vips::Image`) relational_const(c, relational, opts = {})

Relational operations against a constant.

Parameters:

c (Array<Double>) —
Array of constants
relational (Vips::OperationRelational) —
relational to perform
opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

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

- (`Vips::Image`) remainder(right, opts = {})

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/vips8/methods.rb', line 46

- (`Vips::Image`) remainder_const(c, opts = {})

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/vips8/methods.rb', line 127

- (`Vips::Image`) replicate(across, down, opts = {})

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/vips8/methods.rb', line 408

- (`Vips::Image`) resize(scale, opts = {})

Resize an image.

Parameters:

scale (Float) —
Scale image by this factor
opts (Hash) (defaults to: {}) —
Set of options

Options Hash (opts):

:interpolate (Vips::Interpolate) —
Interpolate pixels with this
:vscale (Float) —
Vertical scale image by this factor
:idx (Float) —
Horizontal input displacement
:idy (Float) —
Vertical input displacement

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1285

- (`Image`) rint

Return the nearest integral value.

Returns:

(Image) —
rint of image



863
864
865

# File 'lib/vips8/image.rb', line 863

def rint
    round :rint
end

- (`Vips::Image`) rot(angle, opts = {})

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/vips8/methods.rb', line 422

- (`Image`) rot180

Rotate by 180 degrees clockwise.

Returns:

(Image) —
rotated image



1121
1122
1123

# File 'lib/vips8/image.rb', line 1121

def rot180
    rot :d180
end

- (`Image`) rot270

Rotate by 270 degrees clockwise.

Returns:

(Image) —
rotated image



1128
1129
1130

# File 'lib/vips8/image.rb', line 1128

def rot270
    rot :d270
end

- (`Vips::Image`) rot45(opts = {})

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/vips8/methods.rb', line 428

- (`Image`) rot90

Rotate by 90 degrees clockwise.

Returns:

(Image) —
rotated image



1114
1115
1116

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

def rot90
    rot :d90
end

- (`Vips::Image`) round(round, opts = {})

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/vips8/methods.rb', line 114

- (`Vips::Image`) scale(opts = {})

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/vips8/methods.rb', line 485

- (`Vips::Image`) scRGB2BW(opts = {})

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/vips8/methods.rb', line 1461

- (`Vips::Image`) scRGB2sRGB(opts = {})

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/vips8/methods.rb', line 1467

- (`Vips::Image`) scRGB2XYZ(opts = {})

Transform scrgb to xyz.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

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

- (`Vips::Image`) sequential(opts = {})

Check sequential access.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Options Hash (opts):

:trace (Boolean) —
trace pixel requests
:tile_height (Integer) —
Tile height in pixels
:access (Vips::Access) —
Expected access pattern

Returns:

(Vips::Image) —
Output image

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

- (`Object`) set(name, value)

Set a GValue on an image

Parameters:

name (String) —
Metadata field to set
value (GValue) —
GValue to set

See Also:

set_value

# File 'lib/vips8/image.rb', line 564

- (`Object`) set_value(name, value)

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 (void) —
Value to set

See Also:

# File 'lib/vips8/image.rb', line 592

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

- (`Vips::Image`) sharpen(opts = {})

Unsharp masking for print.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Options Hash (opts):

:radius (Integer) —
Mask radius
: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/vips8/methods.rb', line 1583

- (`Vips::Image`) shrink(xshrink, yshrink, opts = {})

Shrink an image.

Parameters:

xshrink (Float) —
Horizontal shrink factor
yshrink (Float) —
Vertical shrink factor
opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1228

- (`Vips::Image`) shrink2(xshrink, yshrink, opts = {})

Shrink an image.

Parameters:

xshrink (Float) —
Horizontal shrink factor
yshrink (Float) —
Vertical shrink factor
opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1247

- (`Vips::Image`) shrinkh(xshrink, opts = {})

Shrink an image horizontally.

Parameters:

xshrink (Integer) —
Horizontal shrink factor
opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1235

- (`Vips::Image`) shrinkv(yshrink, opts = {})

Shrink an image vertically.

Parameters:

yshrink (Integer) —
Vertical shrink factor
opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1241

- (`Vips::Image`) sign(opts = {})

Unit vector of pixel.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

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

- (`Vips::Image`) similarity(opts = {})

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/vips8/methods.rb', line 1273

- (`Image`) sin

Return the sine of an image in degrees.

Returns:

(Image) —
sine of each pixel



1006
1007
1008

# File 'lib/vips8/image.rb', line 1006

def sin
    math :sin 
end

- (`Vips::Image`) spcor(ref, opts = {})

Spatial correlation.

Parameters:

ref (Vips::Image) —
Input reference image
opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

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

- (`Vips::Image`) spectrum(opts = {})

Make displayable power spectrum.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1619

- (`Vips::Image`) sRGB2HSV(opts = {})

Transform srgb to hsv.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

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

- (`Vips::Image`) sRGB2scRGB(opts = {})

Convert an srgb image to scrgb.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1456

- (`Vips::Image`) stats(opts = {})

Find image average.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output array of statistics

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

- (`Vips::Image`) stdif(width, height, opts = {})

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
:s0 (Float) —
New deviation
:b (Float) —
Weight of new deviation
:m0 (Float) —
New mean

Returns:

(Vips::Image) —
Output image

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

- (`Vips::Image`) subsample(xfac, yfac, opts = {})

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/vips8/methods.rb', line 506

- (`Vips::Image`) subtract(right, opts = {})

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/vips8/methods.rb', line 21

- (`Image`) tan

Return the tangent of an image in degrees.

Returns:

(Image) —
tangent of each pixel



1020
1021
1022

# File 'lib/vips8/image.rb', line 1020

def tan
    math :tan
end

- (`Object`) tiffsave(filename, opts = {})

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
:miniswhite (Boolean) —
Use 0 for white in 1-bit images
:squash (Boolean) —
Squash images down to 1 bit
:resunit (Vips::ForeignTiffResunit) —
Resolution unit
:xres (Float) —
Horizontal resolution in pixels/mm
:yres (Float) —
Vertical resolution in pixels/mm
:bigtiff (Boolean) —
Write a bigtiff image
:properties (Boolean) —
Write a properties document to IMAGEDESCRIPTION
:strip (Boolean) —
Strip all metadata from image
:background (Array<Double>) —
Background value

Returns:

[]

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

- (`Vips::Image`) tilecache(opts = {})

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/vips8/methods.rb', line 272

- (`Vips::Image`) unpremultiply(opts = {})

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/vips8/methods.rb', line 471

- (`Object`) vipssave(filename, opts = {})

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:

[]

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

- (`Object`) webpsave(filename, opts = {})

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
:strip (Boolean) —
Strip all metadata from image
:background (Array<Double>) —
Background value

Returns:

[]

# File 'lib/vips8/methods.rb', line 1171

- (`Vips::Blob`) webpsave_buffer(opts = {})

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
:strip (Boolean) —
Strip all metadata from image
:background (Array<Double>) —
Background value

Returns:

(Vips::Blob) —
Buffer to save to

# File 'lib/vips8/methods.rb', line 1181

- (`Vips::Image`) wrap(opts = {})

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/vips8/methods.rb', line 492

- (`String`) write_to_buffer(format_string, opts = {})

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.

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/vips8/image.rb', line 534

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

    Vips::call_base saver, self, option_string, [opts]
end

- (`Object`) write_to_file(name, opts = {})

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.

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/vips8/image.rb', line 498

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]
end

- (`Vips::Image`) XYZ2Lab(opts = {})

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/vips8/methods.rb', line 1308

- (`Vips::Image`) XYZ2scRGB(opts = {})

Transform xyz to scrgb.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1349

- (`Vips::Image`) XYZ2Yxy(opts = {})

Transform xyz to yxy.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1334

- (`Vips::Image`) Yxy2XYZ(opts = {})

Transform yxy to xyz.

Parameters:

opts (Hash) (defaults to: {}) —
Set of options

Returns:

(Vips::Image) —
Output image

# File 'lib/vips8/methods.rb', line 1339

- (`Vips::Image`) zoom(xfac, yfac, opts = {})

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/vips8/methods.rb', line 499

- (`Image`) |(other)

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/vips8/image.rb', line 715

def |(other)
    other.is_a?(Vips::Image) ? 
        boolean(other, :or) : boolean_const(other, :or)
end

- (`Image`) ~

Equivalent to image ^ -1

Returns:

(Image) —
image with bits flipped



748
749
750

# File 'lib/vips8/image.rb', line 748

def ~
    self ^ -1
end

Class: Vips::Image

Overview

Instance Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Dynamic Method Handling

- (Object) method_missing(name, *args)

Instance Attribute Details

- (Integer) bands (readonly)

- (Vips::Coding) coding (readonly)

- (String) filename (readonly)

- (Vips::BandFormat) format (readonly)

- (Integer) height (readonly)

- (Vips::Interpretation) interpretation (readonly)

- (Integer) width (readonly)

- (Float) xres (readonly)

- (Float) yres (readonly)

Class Method Details

+ (Vips::Image) analyzeload(filename, opts = {})

+ (Vips::Image) arrayjoin

+ (Vips::Image) bandrank

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

+ (Vips::Image) csvload(filename, opts = {})

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

+ (Vips::Image) fitsload(filename, opts = {})

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

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

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

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

+ (Vips::Image) identity(opts = {})

+ (Vips::Image) jpegload(filename, opts = {})

+ (Vips::Image) jpegload_buffer(buffer, opts = {})

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

+ (Vips::Image) magickload(filename, opts = {})

+ (Vips::Image) magickload_buffer(buffer, opts = {})

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

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

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

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

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

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

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

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

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

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

+ (Vips::Image) matload(filename, opts = {})

+ (Vips::Image) matrixload(filename, opts = {})

+ (Object) method_missing(name, *args)

+ (Image) new_from_array(array, scale = 1, offset = 0)

+ (Image) new_from_buffer(data, option_string, opts = {})

+ (Image) new_from_file(name, opts = {})

+ (Vips::Image) openexrload(filename, opts = {})

+ (Vips::Image) openslideload(filename, opts = {})

+ (Vips::Image) pngload(filename, opts = {})

+ (Vips::Image) pngload_buffer(buffer, opts = {})

+ (Vips::Image) ppmload(filename, opts = {})

+ (Vips::Image) radload(filename, opts = {})

+ (Vips::Image) rawload(filename, width, height, bands, opts = {})

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

+ (Vips::Image) sum

+ (Object) system(cmd_format, opts = {})

+ (Vips::Image) text(text, opts = {})

+ (Vips::Image) tiffload(filename, opts = {})

+ (Vips::Image) tiffload_buffer(buffer, opts = {})

+ (Vips::Image) tonelut(opts = {})

+ (Vips::Image) vipsload(filename, opts = {})

+ (Vips::Image) webpload(filename, opts = {})

+ (Vips::Image) webpload_buffer(buffer, opts = {})

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

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

Instance Method Details

- (Image) !

- (Image) !=(other)

- (Image) %(other)

- (Image) &(other)

- (Image) *(other)

- (Image) **(other)

- (Image) +(other)

- (Image) +@

- (Image) -(other)

- (`Object`) method_missing(name, *args)

- (`Integer`) bands (readonly)

- (`Vips::Coding`) coding (readonly)

- (`String`) filename (readonly)

- (`Vips::BandFormat`) format (readonly)

- (`Integer`) height (readonly)

- (`Vips::Interpretation`) interpretation (readonly)

- (`Integer`) width (readonly)

- (`Float`) xres (readonly)

- (`Float`) yres (readonly)

+ (`Vips::Image`) analyzeload(filename, opts = {})

+ (`Vips::Image`) arrayjoin

+ (`Vips::Image`) bandrank

+ (`Vips::Image`) black(width, height, opts = {})

+ (`Vips::Image`) csvload(filename, opts = {})

+ (`Vips::Image`) eye(width, height, opts = {})

+ (`Vips::Image`) fitsload(filename, opts = {})

+ (`Vips::Image`) fractsurf(width, height, fractal_dimension, opts = {})

+ (`Vips::Image`) gaussmat(sigma, min_ampl, opts = {})

+ (`Vips::Image`) gaussnoise(width, height, opts = {})

+ (`Vips::Image`) grey(width, height, opts = {})

+ (`Vips::Image`) identity(opts = {})

+ (`Vips::Image`) jpegload(filename, opts = {})

+ (`Vips::Image`) jpegload_buffer(buffer, opts = {})

+ (`Vips::Image`) logmat(sigma, min_ampl, opts = {})

+ (`Vips::Image`) magickload(filename, opts = {})

+ (`Vips::Image`) magickload_buffer(buffer, opts = {})

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

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

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

+ (`Vips::Image`) mask_fractal(width, height, fractal_dimension, opts = {})

+ (`Vips::Image`) mask_gaussian(width, height, frequency_cutoff, amplitude_cutoff, opts = {})

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

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

+ (`Vips::Image`) mask_ideal(width, height, frequency_cutoff, opts = {})

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

+ (`Vips::Image`) mask_ideal_ring(width, height, frequency_cutoff, ringwidth, opts = {})

+ (`Vips::Image`) matload(filename, opts = {})

+ (`Vips::Image`) matrixload(filename, opts = {})

+ (`Object`) method_missing(name, *args)

+ (`Image`) new_from_array(array, scale = 1, offset = 0)

+ (`Image`) new_from_buffer(data, option_string, opts = {})

+ (`Image`) new_from_file(name, opts = {})

+ (`Vips::Image`) openexrload(filename, opts = {})

+ (`Vips::Image`) openslideload(filename, opts = {})

+ (`Vips::Image`) pngload(filename, opts = {})

+ (`Vips::Image`) pngload_buffer(buffer, opts = {})

+ (`Vips::Image`) ppmload(filename, opts = {})

+ (`Vips::Image`) radload(filename, opts = {})

+ (`Vips::Image`) rawload(filename, width, height, bands, opts = {})

+ (`Vips::Image`) sines(width, height, opts = {})

+ (`Vips::Image`) sum

+ (`Object`) system(cmd_format, opts = {})

+ (`Vips::Image`) text(text, opts = {})

+ (`Vips::Image`) tiffload(filename, opts = {})

+ (`Vips::Image`) tiffload_buffer(buffer, opts = {})

+ (`Vips::Image`) tonelut(opts = {})

+ (`Vips::Image`) vipsload(filename, opts = {})

+ (`Vips::Image`) webpload(filename, opts = {})

+ (`Vips::Image`) webpload_buffer(buffer, opts = {})

+ (`Vips::Image`) xyz(width, height, opts = {})

+ (`Vips::Image`) zone(width, height, opts = {})

- (`Image`) !

- (`Image`) !=(other)

- (`Image`) %(other)

- (`Image`) &(other)

- (`Image`) *(other)

- (`Image`) **(other)

- (`Image`) +(other)

- (`Image`) +@

- (`Image`) -(other)

- (`Image`) -@

- (`Image`) /(other)

- (`Image`) <(other)

- (`Image`) <<(other)

- (`Image`) <=(other)

- (`Image`) ==(other)

- (`Image`) >(other)

- (`Image`) >=(other)

- (`Image`) >>(other)