View Source Vix.Vips.Operation (vix v0.9.0)

Vips Operations

See libvips documentation for more detailed description of the operation.

Vips operation functions are generated using vips-introspection and are up-to-date with libvips version installed. Documentation in the hexdocs might not match for you.

Link to this section Summary

Types

gsf_output_csv_quoting_mode()

vips_access()

vips_align()

vips_angle()

vips_angle45()

vips_band_format()

vips_blend_mode()

vips_coding()

vips_combine()

vips_combine_mode()

vips_compass_direction()

vips_demand_style()

vips_direction()

vips_extend()

vips_fail_on()

vips_foreign_dz_container()

vips_foreign_dz_depth()

vips_foreign_dz_layout()

vips_foreign_flags()

vips_foreign_heif_compression()

vips_foreign_png_filter()

vips_foreign_ppm_format()

vips_foreign_subsample()

vips_foreign_tiff_compression()

vips_foreign_tiff_predictor()

vips_foreign_tiff_resunit()

vips_foreign_webp_preset()

vips_intent()

vips_interesting()

vips_interpretation()

vips_kernel()

vips_operation_boolean()

vips_operation_complex()

vips_operation_complex2()

vips_operation_complexget()

vips_operation_math()

vips_operation_math2()

vips_operation_morphology()

vips_operation_relational()

vips_operation_round()

vips_pcs()

vips_precision()

vips_region_shrink()

vips_size()

Functions

abs(in, optional \\ [])

Absolute value of an image

abs!(in, optional \\ [])

Same as abs/2, except it returns only the value (not a tuple) and raises on error.

add(left, right, optional \\ [])

Add two images

add!(left, right, optional \\ [])

Same as add/3, except it returns only the value (not a tuple) and raises on error.

affine(in, matrix, optional \\ [])

Affine transform of an image

affine!(in, matrix, optional \\ [])

Same as affine/3, except it returns only the value (not a tuple) and raises on error.

analyzeload(filename, optional \\ [])

Load an analyze6 image

analyzeload!(filename, optional \\ [])

Same as analyzeload/2, except it returns only the value (not a tuple) and raises on error.

arrayjoin(in, optional \\ [])

Join an array of images

arrayjoin!(in, optional \\ [])

Same as arrayjoin/2, except it returns only the value (not a tuple) and raises on error.

autorot(in, optional \\ [])

Autorotate image by exif tag

autorot!(in, optional \\ [])

Same as autorot/2, except it returns only the value (not a tuple) and raises on error.

avg(in, optional \\ [])

Find image average

avg!(in, optional \\ [])

Same as avg/2, except it returns only the value (not a tuple) and raises on error.

bandbool(in, boolean, optional \\ [])

Boolean operation across image bands

bandbool!(in, boolean, optional \\ [])

Same as bandbool/3, except it returns only the value (not a tuple) and raises on error.

bandfold(in, optional \\ [])

Fold up x axis into bands

bandfold!(in, optional \\ [])

Same as bandfold/2, except it returns only the value (not a tuple) and raises on error.

bandjoin(in, optional \\ [])

Bandwise join a set of images

bandjoin!(in, optional \\ [])

Same as bandjoin/2, except it returns only the value (not a tuple) and raises on error.

bandjoin_const(in, c, optional \\ [])

Append a constant band to an image

bandjoin_const!(in, c, optional \\ [])

Same as bandjoin_const/3, except it returns only the value (not a tuple) and raises on error.

bandmean(in, optional \\ [])

Band-wise average

bandmean!(in, optional \\ [])

Same as bandmean/2, except it returns only the value (not a tuple) and raises on error.

bandrank(in, optional \\ [])

Band-wise rank of a set of images

bandrank!(in, optional \\ [])

Same as bandrank/2, except it returns only the value (not a tuple) and raises on error.

bandunfold(in, optional \\ [])

Unfold image bands into x axis

bandunfold!(in, optional \\ [])

Same as bandunfold/2, except it returns only the value (not a tuple) and raises on error.

black(width, height, optional \\ [])

Make a black image

black!(width, height, optional \\ [])

Same as black/3, except it returns only the value (not a tuple) and raises on error.

boolean(left, right, boolean, optional \\ [])

Boolean operation on two images

boolean!(left, right, boolean, optional \\ [])

Same as boolean/4, except it returns only the value (not a tuple) and raises on error.

boolean_const(in, boolean, c, optional \\ [])

Boolean operations against a constant

boolean_const!(in, boolean, c, optional \\ [])

Same as boolean_const/4, except it returns only the value (not a tuple) and raises on error.

buildlut(in, optional \\ [])

Build a look-up table

buildlut!(in, optional \\ [])

Same as buildlut/2, except it returns only the value (not a tuple) and raises on error.

byteswap(in, optional \\ [])

Byteswap an image

byteswap!(in, optional \\ [])

Same as byteswap/2, except it returns only the value (not a tuple) and raises on error.

cache(in, optional \\ [])

Cache an image

cache!(in, optional \\ [])

Same as cache/2, except it returns only the value (not a tuple) and raises on error.

canny(in, optional \\ [])

Canny edge detector

canny!(in, optional \\ [])

Same as canny/2, except it returns only the value (not a tuple) and raises on error.

case(index, cases, optional \\ [])

Use pixel values to pick cases from an array of images

case!(index, cases, optional \\ [])

Same as case/3, except it returns only the value (not a tuple) and raises on error.

cast(in, format, optional \\ [])

Cast an image

cast!(in, format, optional \\ [])

Same as cast/3, except it returns only the value (not a tuple) and raises on error.

cmc2lch(in, optional \\ [])

Transform lch to cmc

cmc2lch!(in, optional \\ [])

Same as cmc2lch/2, except it returns only the value (not a tuple) and raises on error.

cmyk2xyz(in, optional \\ [])

Transform cmyk to xyz

cmyk2xyz!(in, optional \\ [])

Same as cmyk2xyz/2, except it returns only the value (not a tuple) and raises on error.

colourspace(in, space, optional \\ [])

Convert to a new colorspace

colourspace!(in, space, optional \\ [])

Same as colourspace/3, except it returns only the value (not a tuple) and raises on error.

compass(in, mask, optional \\ [])

Convolve with rotating mask

compass!(in, mask, optional \\ [])

Same as compass/3, except it returns only the value (not a tuple) and raises on error.

complex(in, cmplx, optional \\ [])

Perform a complex operation on an image

complex!(in, cmplx, optional \\ [])

Same as complex/3, except it returns only the value (not a tuple) and raises on error.

complex2(left, right, cmplx, optional \\ [])

Complex binary operations on two images

complex2!(left, right, cmplx, optional \\ [])

Same as complex2/4, except it returns only the value (not a tuple) and raises on error.

complexform(left, right, optional \\ [])

Form a complex image from two real images

complexform!(left, right, optional \\ [])

Same as complexform/3, except it returns only the value (not a tuple) and raises on error.

complexget(in, get, optional \\ [])

Get a component from a complex image

complexget!(in, get, optional \\ [])

Same as complexget/3, except it returns only the value (not a tuple) and raises on error.

composite(in, mode, optional \\ [])

Blend an array of images with an array of blend modes

composite!(in, mode, optional \\ [])

Same as composite/3, except it returns only the value (not a tuple) and raises on error.

composite2(base, overlay, mode, optional \\ [])

Blend a pair of images with a blend mode

composite2!(base, overlay, mode, optional \\ [])

Same as composite2/4, except it returns only the value (not a tuple) and raises on error.

conv(in, mask, optional \\ [])

Convolution operation

conv!(in, mask, optional \\ [])

Same as conv/3, except it returns only the value (not a tuple) and raises on error.

conva(in, mask, optional \\ [])

Approximate integer convolution

conva!(in, mask, optional \\ [])

Same as conva/3, except it returns only the value (not a tuple) and raises on error.

convasep(in, mask, optional \\ [])

Approximate separable integer convolution

convasep!(in, mask, optional \\ [])

Same as convasep/3, except it returns only the value (not a tuple) and raises on error.

convf(in, mask, optional \\ [])

Float convolution operation

convf!(in, mask, optional \\ [])

Same as convf/3, except it returns only the value (not a tuple) and raises on error.

convi(in, mask, optional \\ [])

Int convolution operation

convi!(in, mask, optional \\ [])

Same as convi/3, except it returns only the value (not a tuple) and raises on error.

convsep(in, mask, optional \\ [])

Seperable convolution operation

convsep!(in, mask, optional \\ [])

Same as convsep/3, except it returns only the value (not a tuple) and raises on error.

copy(in, optional \\ [])

Copy an image

copy!(in, optional \\ [])

Same as copy/2, except it returns only the value (not a tuple) and raises on error.

countlines(in, direction, optional \\ [])

Count lines in an image

countlines!(in, direction, optional \\ [])

Same as countlines/3, except it returns only the value (not a tuple) and raises on error.

csvload(filename, optional \\ [])

Load csv

csvload!(filename, optional \\ [])

Same as csvload/2, except it returns only the value (not a tuple) and raises on error.

csvsave(in, filename, optional \\ [])

Save image to csv

csvsave!(in, filename, optional \\ [])

Same as csvsave/3, except it returns only the value (not a tuple) and raises on error.

de00(left, right, optional \\ [])

Calculate de00

de00!(left, right, optional \\ [])

Same as de00/3, except it returns only the value (not a tuple) and raises on error.

de76(left, right, optional \\ [])

Calculate de76

de76!(left, right, optional \\ [])

Same as de76/3, except it returns only the value (not a tuple) and raises on error.

decmc(left, right, optional \\ [])

Calculate decmc

decmc!(left, right, optional \\ [])

Same as decmc/3, except it returns only the value (not a tuple) and raises on error.

deviate(in, optional \\ [])

Find image standard deviation

deviate!(in, optional \\ [])

Same as deviate/2, except it returns only the value (not a tuple) and raises on error.

divide(left, right, optional \\ [])

Divide two images

divide!(left, right, optional \\ [])

Same as divide/3, except it returns only the value (not a tuple) and raises on error.

dzsave(in, filename, optional \\ [])

Save image to deepzoom file

dzsave!(in, filename, optional \\ [])

Same as dzsave/3, except it returns only the value (not a tuple) and raises on error.

dzsave_buffer(in, optional \\ [])

Save image to dz buffer

dzsave_buffer!(in, optional \\ [])

Same as dzsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

embed(in, x, y, width, height, optional \\ [])

Embed an image in a larger image

embed!(in, x, y, width, height, optional \\ [])

Same as embed/6, except it returns only the value (not a tuple) and raises on error.

extract_area(input, left, top, width, height, optional \\ [])

Extract an area from an image

extract_area!(input, left, top, width, height, optional \\ [])

Same as extract_area/6, except it returns only the value (not a tuple) and raises on error.

extract_band(in, band, optional \\ [])

Extract band from an image

extract_band!(in, band, optional \\ [])

Same as extract_band/3, except it returns only the value (not a tuple) and raises on error.

eye(width, height, optional \\ [])

Make an image showing the eye's spatial response

eye!(width, height, optional \\ [])

Same as eye/3, except it returns only the value (not a tuple) and raises on error.

falsecolour(in, optional \\ [])

False-color an image

falsecolour!(in, optional \\ [])

Same as falsecolour/2, except it returns only the value (not a tuple) and raises on error.

fastcor(in, ref, optional \\ [])

Fast correlation

fastcor!(in, ref, optional \\ [])

Same as fastcor/3, except it returns only the value (not a tuple) and raises on error.

fill_nearest(in, optional \\ [])

Fill image zeros with nearest non-zero pixel

fill_nearest!(in, optional \\ [])

Same as fill_nearest/2, except it returns only the value (not a tuple) and raises on error.

find_trim(in, optional \\ [])

Search an image for non-edge areas

find_trim!(in, optional \\ [])

Same as find_trim/2, except it returns only the value (not a tuple) and raises on error.

fitsload(filename, optional \\ [])

Load a fits image

fitsload!(filename, optional \\ [])

Same as fitsload/2, except it returns only the value (not a tuple) and raises on error.

fitssave(in, filename, optional \\ [])

Save image to fits file

fitssave!(in, filename, optional \\ [])

Same as fitssave/3, except it returns only the value (not a tuple) and raises on error.

flatten(in, optional \\ [])

Flatten alpha out of an image

flatten!(in, optional \\ [])

Same as flatten/2, except it returns only the value (not a tuple) and raises on error.

flip(in, direction, optional \\ [])

Flip an image

flip!(in, direction, optional \\ [])

Same as flip/3, except it returns only the value (not a tuple) and raises on error.

float2rad(in, optional \\ [])

Transform float rgb to radiance coding

float2rad!(in, optional \\ [])

Same as float2rad/2, except it returns only the value (not a tuple) and raises on error.

fractsurf(width, height, fractal-dimension, optional \\ [])

Make a fractal surface

fractsurf!(width, height, fractal-dimension, optional \\ [])

Same as fractsurf/4, except it returns only the value (not a tuple) and raises on error.

freqmult(in, mask, optional \\ [])

Frequency-domain filtering

freqmult!(in, mask, optional \\ [])

Same as freqmult/3, except it returns only the value (not a tuple) and raises on error.

fwfft(in, optional \\ [])

Forward fft

fwfft!(in, optional \\ [])

Same as fwfft/2, except it returns only the value (not a tuple) and raises on error.

gamma(in, optional \\ [])

Gamma an image

gamma!(in, optional \\ [])

Same as gamma/2, except it returns only the value (not a tuple) and raises on error.

gaussblur(in, sigma, optional \\ [])

Gaussian blur

gaussblur!(in, sigma, optional \\ [])

Same as gaussblur/3, except it returns only the value (not a tuple) and raises on error.

gaussmat(sigma, min-ampl, optional \\ [])

Make a gaussian image

gaussmat!(sigma, min-ampl, optional \\ [])

Same as gaussmat/3, except it returns only the value (not a tuple) and raises on error.

gaussnoise(width, height, optional \\ [])

Make a gaussnoise image

gaussnoise!(width, height, optional \\ [])

Same as gaussnoise/3, except it returns only the value (not a tuple) and raises on error.

getpoint(in, x, y, optional \\ [])

Read a point from an image

getpoint!(in, x, y, optional \\ [])

Same as getpoint/4, except it returns only the value (not a tuple) and raises on error.

gifload(filename, optional \\ [])

Load gif with libnsgif

gifload!(filename, optional \\ [])

Same as gifload/2, except it returns only the value (not a tuple) and raises on error.

gifload_buffer(buffer, optional \\ [])

Load gif with libnsgif

gifload_buffer!(buffer, optional \\ [])

Same as gifload_buffer/2, except it returns only the value (not a tuple) and raises on error.

gifsave(in, filename, optional \\ [])

Save as gif

gifsave!(in, filename, optional \\ [])

Same as gifsave/3, except it returns only the value (not a tuple) and raises on error.

gifsave_buffer(in, optional \\ [])

Save as gif

gifsave_buffer!(in, optional \\ [])

Same as gifsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

globalbalance(in, optional \\ [])

Global balance an image mosaic

globalbalance!(in, optional \\ [])

Same as globalbalance/2, except it returns only the value (not a tuple) and raises on error.

gravity(in, direction, width, height, optional \\ [])

Place an image within a larger image with a certain gravity

gravity!(in, direction, width, height, optional \\ [])

Same as gravity/5, except it returns only the value (not a tuple) and raises on error.

grey(width, height, optional \\ [])

Make a grey ramp image

grey!(width, height, optional \\ [])

Same as grey/3, except it returns only the value (not a tuple) and raises on error.

grid(in, tile-height, across, down, optional \\ [])

Grid an image

grid!(in, tile-height, across, down, optional \\ [])

Same as grid/5, except it returns only the value (not a tuple) and raises on error.

heifload(filename, optional \\ [])

Load a heif image

heifload!(filename, optional \\ [])

Same as heifload/2, except it returns only the value (not a tuple) and raises on error.

heifload_buffer(buffer, optional \\ [])

Load a heif image

heifload_buffer!(buffer, optional \\ [])

Same as heifload_buffer/2, except it returns only the value (not a tuple) and raises on error.

heifsave(in, filename, optional \\ [])

Save image in heif format

heifsave!(in, filename, optional \\ [])

Same as heifsave/3, except it returns only the value (not a tuple) and raises on error.

heifsave_buffer(in, optional \\ [])

Save image in heif format

heifsave_buffer!(in, optional \\ [])

Same as heifsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

hist_cum(in, optional \\ [])

Form cumulative histogram

hist_cum!(in, optional \\ [])

Same as hist_cum/2, except it returns only the value (not a tuple) and raises on error.

hist_entropy(in, optional \\ [])

Estimate image entropy

hist_entropy!(in, optional \\ [])

Same as hist_entropy/2, except it returns only the value (not a tuple) and raises on error.

hist_equal(in, optional \\ [])

Histogram equalisation

hist_equal!(in, optional \\ [])

Same as hist_equal/2, except it returns only the value (not a tuple) and raises on error.

hist_find(in, optional \\ [])

Find image histogram

hist_find!(in, optional \\ [])

Same as hist_find/2, except it returns only the value (not a tuple) and raises on error.

hist_find_indexed(in, index, optional \\ [])

Find indexed image histogram

hist_find_indexed!(in, index, optional \\ [])

Same as hist_find_indexed/3, except it returns only the value (not a tuple) and raises on error.

hist_find_ndim(in, optional \\ [])

Find n-dimensional image histogram

hist_find_ndim!(in, optional \\ [])

Same as hist_find_ndim/2, except it returns only the value (not a tuple) and raises on error.

hist_ismonotonic(in, optional \\ [])

Test for monotonicity

hist_ismonotonic!(in, optional \\ [])

Same as hist_ismonotonic/2, except it returns only the value (not a tuple) and raises on error.

hist_local(in, width, height, optional \\ [])

Local histogram equalisation

hist_local!(in, width, height, optional \\ [])

Same as hist_local/4, except it returns only the value (not a tuple) and raises on error.

hist_match(in, ref, optional \\ [])

Match two histograms

hist_match!(in, ref, optional \\ [])

Same as hist_match/3, except it returns only the value (not a tuple) and raises on error.

hist_norm(in, optional \\ [])

Normalise histogram

hist_norm!(in, optional \\ [])

Same as hist_norm/2, except it returns only the value (not a tuple) and raises on error.

hist_plot(in, optional \\ [])

Plot histogram

hist_plot!(in, optional \\ [])

Same as hist_plot/2, except it returns only the value (not a tuple) and raises on error.

hough_circle(in, optional \\ [])

Find hough circle transform

hough_circle!(in, optional \\ [])

Same as hough_circle/2, except it returns only the value (not a tuple) and raises on error.

hough_line(in, optional \\ [])

Find hough line transform

hough_line!(in, optional \\ [])

Same as hough_line/2, except it returns only the value (not a tuple) and raises on error.

hsv2srgb(in, optional \\ [])

Transform hsv to srgb

hsv2srgb!(in, optional \\ [])

Same as hsv2srgb/2, except it returns only the value (not a tuple) and raises on error.

icc_export(in, optional \\ [])

Output to device with icc profile

icc_export!(in, optional \\ [])

Same as icc_export/2, except it returns only the value (not a tuple) and raises on error.

icc_import(in, optional \\ [])

Import from device with icc profile

icc_import!(in, optional \\ [])

Same as icc_import/2, except it returns only the value (not a tuple) and raises on error.

icc_transform(in, output-profile, optional \\ [])

Transform between devices with icc profiles

icc_transform!(in, output-profile, optional \\ [])

Same as icc_transform/3, except it returns only the value (not a tuple) and raises on error.

identity(optional \\ [])

Make a 1d image where pixel values are indexes

identity!(optional \\ [])

Same as identity/1, except it returns only the value (not a tuple) and raises on error.

ifthenelse(cond, in1, in2, optional \\ [])

Ifthenelse an image

ifthenelse!(cond, in1, in2, optional \\ [])

Same as ifthenelse/4, except it returns only the value (not a tuple) and raises on error.

insert(main, sub, x, y, optional \\ [])

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

insert!(main, sub, x, y, optional \\ [])

Same as insert/5, except it returns only the value (not a tuple) and raises on error.

invert(in, optional \\ [])

Invert an image

invert!(in, optional \\ [])

Same as invert/2, except it returns only the value (not a tuple) and raises on error.

invertlut(in, optional \\ [])

Build an inverted look-up table

invertlut!(in, optional \\ [])

Same as invertlut/2, except it returns only the value (not a tuple) and raises on error.

invfft(in, optional \\ [])

Inverse fft

invfft!(in, optional \\ [])

Same as invfft/2, except it returns only the value (not a tuple) and raises on error.

join(in1, in2, direction, optional \\ [])

Join a pair of images

join!(in1, in2, direction, optional \\ [])

Same as join/4, except it returns only the value (not a tuple) and raises on error.

jp2kload(filename, optional \\ [])

Load jpeg2000 image

jp2kload!(filename, optional \\ [])

Same as jp2kload/2, except it returns only the value (not a tuple) and raises on error.

jp2kload_buffer(buffer, optional \\ [])

Load jpeg2000 image

jp2kload_buffer!(buffer, optional \\ [])

Same as jp2kload_buffer/2, except it returns only the value (not a tuple) and raises on error.

jp2ksave(in, filename, optional \\ [])

Save image in jpeg2000 format

jp2ksave!(in, filename, optional \\ [])

Same as jp2ksave/3, except it returns only the value (not a tuple) and raises on error.

jp2ksave_buffer(in, optional \\ [])

Save image in jpeg2000 format

jp2ksave_buffer!(in, optional \\ [])

Same as jp2ksave_buffer/2, except it returns only the value (not a tuple) and raises on error.

jpegload(filename, optional \\ [])

Load jpeg from file

jpegload!(filename, optional \\ [])

Same as jpegload/2, except it returns only the value (not a tuple) and raises on error.

jpegload_buffer(buffer, optional \\ [])

Load jpeg from buffer

jpegload_buffer!(buffer, optional \\ [])

Same as jpegload_buffer/2, except it returns only the value (not a tuple) and raises on error.

jpegsave(in, filename, optional \\ [])

Save image to jpeg file

jpegsave!(in, filename, optional \\ [])

Same as jpegsave/3, except it returns only the value (not a tuple) and raises on error.

jpegsave_buffer(in, optional \\ [])

Save image to jpeg buffer

jpegsave_buffer!(in, optional \\ [])

Same as jpegsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

jpegsave_mime(in, optional \\ [])

Save image to jpeg mime

jpegsave_mime!(in, optional \\ [])

Same as jpegsave_mime/2, except it returns only the value (not a tuple) and raises on error.

jxlload(filename, optional \\ [])

Load jpeg-xl image

jxlload!(filename, optional \\ [])

Same as jxlload/2, except it returns only the value (not a tuple) and raises on error.

jxlload_buffer(buffer, optional \\ [])

Load jpeg-xl image

jxlload_buffer!(buffer, optional \\ [])

Same as jxlload_buffer/2, except it returns only the value (not a tuple) and raises on error.

jxlsave(in, filename, optional \\ [])

Save image in jpeg-xl format

jxlsave!(in, filename, optional \\ [])

Same as jxlsave/3, except it returns only the value (not a tuple) and raises on error.

jxlsave_buffer(in, optional \\ [])

Save image in jpeg-xl format

jxlsave_buffer!(in, optional \\ [])

Same as jxlsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

lab2labq(in, optional \\ [])

Transform float lab to labq coding

lab2labq!(in, optional \\ [])

Same as lab2labq/2, except it returns only the value (not a tuple) and raises on error.

lab2labs(in, optional \\ [])

Transform float lab to signed short

lab2labs!(in, optional \\ [])

Same as lab2labs/2, except it returns only the value (not a tuple) and raises on error.

lab2lch(in, optional \\ [])

Transform lab to lch

lab2lch!(in, optional \\ [])

Same as lab2lch/2, except it returns only the value (not a tuple) and raises on error.

lab2xyz(in, optional \\ [])

Transform cielab to xyz

lab2xyz!(in, optional \\ [])

Same as lab2xyz/2, except it returns only the value (not a tuple) and raises on error.

labelregions(in, optional \\ [])

Label regions in an image

labelregions!(in, optional \\ [])

Same as labelregions/2, except it returns only the value (not a tuple) and raises on error.

labq2lab(in, optional \\ [])

Unpack a labq image to float lab

labq2lab!(in, optional \\ [])

Same as labq2lab/2, except it returns only the value (not a tuple) and raises on error.

labq2labs(in, optional \\ [])

Unpack a labq image to short lab

labq2labs!(in, optional \\ [])

Same as labq2labs/2, except it returns only the value (not a tuple) and raises on error.

labq2srgb(in, optional \\ [])

Convert a labq image to srgb

labq2srgb!(in, optional \\ [])

Same as labq2srgb/2, except it returns only the value (not a tuple) and raises on error.

labs2lab(in, optional \\ [])

Transform signed short lab to float

labs2lab!(in, optional \\ [])

Same as labs2lab/2, except it returns only the value (not a tuple) and raises on error.

labs2labq(in, optional \\ [])

Transform short lab to labq coding

labs2labq!(in, optional \\ [])

Same as labs2labq/2, except it returns only the value (not a tuple) and raises on error.

lch2cmc(in, optional \\ [])

Transform lch to cmc

lch2cmc!(in, optional \\ [])

Same as lch2cmc/2, except it returns only the value (not a tuple) and raises on error.

lch2lab(in, optional \\ [])

Transform lch to lab

lch2lab!(in, optional \\ [])

Same as lch2lab/2, except it returns only the value (not a tuple) and raises on error.

linear(in, a, b, optional \\ [])

Calculate (a * in + b)

linear!(in, a, b, optional \\ [])

Same as linear/4, except it returns only the value (not a tuple) and raises on error.

linecache(in, optional \\ [])

Cache an image as a set of lines

linecache!(in, optional \\ [])

Same as linecache/2, except it returns only the value (not a tuple) and raises on error.

logmat(sigma, min-ampl, optional \\ [])

Make a laplacian of gaussian image

logmat!(sigma, min-ampl, optional \\ [])

Same as logmat/3, except it returns only the value (not a tuple) and raises on error.

magickload(filename, optional \\ [])

Load file with imagemagick7

magickload!(filename, optional \\ [])

Same as magickload/2, except it returns only the value (not a tuple) and raises on error.

magickload_buffer(buffer, optional \\ [])

Load buffer with imagemagick7

magickload_buffer!(buffer, optional \\ [])

Same as magickload_buffer/2, except it returns only the value (not a tuple) and raises on error.

magicksave(in, filename, optional \\ [])

Save file with imagemagick

magicksave!(in, filename, optional \\ [])

Same as magicksave/3, except it returns only the value (not a tuple) and raises on error.

magicksave_buffer(in, optional \\ [])

Save image to magick buffer

magicksave_buffer!(in, optional \\ [])

Same as magicksave_buffer/2, except it returns only the value (not a tuple) and raises on error.

mapim(in, index, optional \\ [])

Resample with a map image

mapim!(in, index, optional \\ [])

Same as mapim/3, except it returns only the value (not a tuple) and raises on error.

maplut(in, lut, optional \\ [])

Map an image though a lut

maplut!(in, lut, optional \\ [])

Same as maplut/3, except it returns only the value (not a tuple) and raises on error.

mask_butterworth(width, height, order, frequency-cutoff, amplitude-cutoff, optional \\ [])

Make a butterworth filter

mask_butterworth!(width, height, order, frequency-cutoff, amplitude-cutoff, optional \\ [])

Same as mask_butterworth/6, except it returns only the value (not a tuple) and raises on error.

mask_butterworth_band( width, height, order, frequency-cutoff-x, frequency-cutoff-y, radius, amplitude-cutoff, optional \\ [] )

Make a butterworth_band filter

mask_butterworth_band!( width, height, order, frequency-cutoff-x, frequency-cutoff-y, radius, amplitude-cutoff, optional \\ [] )

Same as mask_butterworth_band/8, except it returns only the value (not a tuple) and raises on error.

mask_butterworth_ring( width, height, order, frequency-cutoff, amplitude-cutoff, ringwidth, optional \\ [] )

Make a butterworth ring filter

mask_butterworth_ring!( width, height, order, frequency-cutoff, amplitude-cutoff, ringwidth, optional \\ [] )

Same as mask_butterworth_ring/7, except it returns only the value (not a tuple) and raises on error.

mask_fractal(width, height, fractal-dimension, optional \\ [])

Make fractal filter

mask_fractal!(width, height, fractal-dimension, optional \\ [])

Same as mask_fractal/4, except it returns only the value (not a tuple) and raises on error.

mask_gaussian(width, height, frequency-cutoff, amplitude-cutoff, optional \\ [])

Make a gaussian filter

mask_gaussian!(width, height, frequency-cutoff, amplitude-cutoff, optional \\ [])

Same as mask_gaussian/5, except it returns only the value (not a tuple) and raises on error.

mask_gaussian_band( width, height, frequency-cutoff-x, frequency-cutoff-y, radius, amplitude-cutoff, optional \\ [] )

Make a gaussian filter

mask_gaussian_band!( width, height, frequency-cutoff-x, frequency-cutoff-y, radius, amplitude-cutoff, optional \\ [] )

Same as mask_gaussian_band/7, except it returns only the value (not a tuple) and raises on error.

mask_gaussian_ring(width, height, frequency-cutoff, amplitude-cutoff, ringwidth, optional \\ [])

Make a gaussian ring filter

mask_gaussian_ring!(width, height, frequency-cutoff, amplitude-cutoff, ringwidth, optional \\ [])

Same as mask_gaussian_ring/6, except it returns only the value (not a tuple) and raises on error.

mask_ideal(width, height, frequency-cutoff, optional \\ [])

Make an ideal filter

mask_ideal!(width, height, frequency-cutoff, optional \\ [])

Same as mask_ideal/4, except it returns only the value (not a tuple) and raises on error.

mask_ideal_band(width, height, frequency-cutoff-x, frequency-cutoff-y, radius, optional \\ [])

Make an ideal band filter

mask_ideal_band!(width, height, frequency-cutoff-x, frequency-cutoff-y, radius, optional \\ [])

Same as mask_ideal_band/6, except it returns only the value (not a tuple) and raises on error.

mask_ideal_ring(width, height, frequency-cutoff, ringwidth, optional \\ [])

Make an ideal ring filter

mask_ideal_ring!(width, height, frequency-cutoff, ringwidth, optional \\ [])

Same as mask_ideal_ring/5, except it returns only the value (not a tuple) and raises on error.

match(ref, sec, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, optional \\ [])

First-order match of two images

match!(ref, sec, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, optional \\ [])

Same as match/11, except it returns only the value (not a tuple) and raises on error.

math(in, math, optional \\ [])

Apply a math operation to an image

math!(in, math, optional \\ [])

Same as math/3, except it returns only the value (not a tuple) and raises on error.

math2(left, right, math2, optional \\ [])

Binary math operations

math2!(left, right, math2, optional \\ [])

Same as math2/4, except it returns only the value (not a tuple) and raises on error.

math2_const(in, math2, c, optional \\ [])

Binary math operations with a constant

math2_const!(in, math2, c, optional \\ [])

Same as math2_const/4, except it returns only the value (not a tuple) and raises on error.

matload(filename, optional \\ [])

Load mat from file

matload!(filename, optional \\ [])

Same as matload/2, except it returns only the value (not a tuple) and raises on error.

matrixinvert(in, optional \\ [])

Invert an matrix

matrixinvert!(in, optional \\ [])

Same as matrixinvert/2, except it returns only the value (not a tuple) and raises on error.

matrixload(filename, optional \\ [])

Load matrix

matrixload!(filename, optional \\ [])

Same as matrixload/2, except it returns only the value (not a tuple) and raises on error.

matrixprint(in, optional \\ [])

Print matrix

matrixprint!(in, optional \\ [])

Same as matrixprint/2, except it returns only the value (not a tuple) and raises on error.

matrixsave(in, filename, optional \\ [])

Save image to matrix

matrixsave!(in, filename, optional \\ [])

Same as matrixsave/3, except it returns only the value (not a tuple) and raises on error.

max(in, optional \\ [])

Find image maximum

max!(in, optional \\ [])

Same as max/2, except it returns only the value (not a tuple) and raises on error.

measure(in, h, v, optional \\ [])

Measure a set of patches on a color chart

measure!(in, h, v, optional \\ [])

Same as measure/4, except it returns only the value (not a tuple) and raises on error.

merge(ref, sec, direction, dx, dy, optional \\ [])

Merge two images

merge!(ref, sec, direction, dx, dy, optional \\ [])

Same as merge/6, except it returns only the value (not a tuple) and raises on error.

min(in, optional \\ [])

Find image minimum

min!(in, optional \\ [])

Same as min/2, except it returns only the value (not a tuple) and raises on error.

morph(in, mask, morph, optional \\ [])

Morphology operation

morph!(in, mask, morph, optional \\ [])

Same as morph/4, except it returns only the value (not a tuple) and raises on error.

mosaic(ref, sec, direction, xref, yref, xsec, ysec, optional \\ [])

Mosaic two images

mosaic!(ref, sec, direction, xref, yref, xsec, ysec, optional \\ [])

Same as mosaic/8, except it returns only the value (not a tuple) and raises on error.

mosaic1(ref, sec, direction, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, optional \\ [])

First-order mosaic of two images

mosaic1!(ref, sec, direction, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, optional \\ [])

Same as mosaic1/12, except it returns only the value (not a tuple) and raises on error.

msb(in, optional \\ [])

Pick most-significant byte from an image

msb!(in, optional \\ [])

Same as msb/2, except it returns only the value (not a tuple) and raises on error.

multiply(left, right, optional \\ [])

Multiply two images

multiply!(left, right, optional \\ [])

Same as multiply/3, except it returns only the value (not a tuple) and raises on error.

openexrload(filename, optional \\ [])

Load an openexr image

openexrload!(filename, optional \\ [])

Same as openexrload/2, except it returns only the value (not a tuple) and raises on error.

openslideload(filename, optional \\ [])

Load file with openslide

openslideload!(filename, optional \\ [])

Same as openslideload/2, except it returns only the value (not a tuple) and raises on error.

pdfload(filename, optional \\ [])

Load pdf from file

pdfload!(filename, optional \\ [])

Same as pdfload/2, except it returns only the value (not a tuple) and raises on error.

pdfload_buffer(buffer, optional \\ [])

Load pdf from buffer

pdfload_buffer!(buffer, optional \\ [])

Same as pdfload_buffer/2, except it returns only the value (not a tuple) and raises on error.

percent(in, percent, optional \\ [])

Find threshold for percent of pixels

percent!(in, percent, optional \\ [])

Same as percent/3, except it returns only the value (not a tuple) and raises on error.

perlin(width, height, optional \\ [])

Make a perlin noise image

perlin!(width, height, optional \\ [])

Same as perlin/3, except it returns only the value (not a tuple) and raises on error.

phasecor(in, in2, optional \\ [])

Calculate phase correlation

phasecor!(in, in2, optional \\ [])

Same as phasecor/3, except it returns only the value (not a tuple) and raises on error.

pngload(filename, optional \\ [])

Load png from file

pngload!(filename, optional \\ [])

Same as pngload/2, except it returns only the value (not a tuple) and raises on error.

pngload_buffer(buffer, optional \\ [])

Load png from buffer

pngload_buffer!(buffer, optional \\ [])

Same as pngload_buffer/2, except it returns only the value (not a tuple) and raises on error.

pngsave(in, filename, optional \\ [])

Save image to png file

pngsave!(in, filename, optional \\ [])

Same as pngsave/3, except it returns only the value (not a tuple) and raises on error.

pngsave_buffer(in, optional \\ [])

Save image to png buffer

pngsave_buffer!(in, optional \\ [])

Same as pngsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

ppmload(filename, optional \\ [])

Load ppm from file

ppmload!(filename, optional \\ [])

Same as ppmload/2, except it returns only the value (not a tuple) and raises on error.

ppmsave(in, filename, optional \\ [])

Save image to ppm file

ppmsave!(in, filename, optional \\ [])

Same as ppmsave/3, except it returns only the value (not a tuple) and raises on error.

premultiply(in, optional \\ [])

Premultiply image alpha

premultiply!(in, optional \\ [])

Same as premultiply/2, except it returns only the value (not a tuple) and raises on error.

profile(in, optional \\ [])

Find image profiles

profile!(in, optional \\ [])

Same as profile/2, except it returns only the value (not a tuple) and raises on error.

profile_load(name, optional \\ [])

Load named icc profile

profile_load!(name, optional \\ [])

Same as profile_load/2, except it returns only the value (not a tuple) and raises on error.

project(in, optional \\ [])

Find image projections

project!(in, optional \\ [])

Same as project/2, except it returns only the value (not a tuple) and raises on error.

quadratic(in, coeff, optional \\ [])

Resample an image with a quadratic transform

quadratic!(in, coeff, optional \\ [])

Same as quadratic/3, except it returns only the value (not a tuple) and raises on error.

rad2float(in, optional \\ [])

Unpack radiance coding to float rgb

rad2float!(in, optional \\ [])

Same as rad2float/2, except it returns only the value (not a tuple) and raises on error.

radload(filename, optional \\ [])

Load a radiance image from a file

radload!(filename, optional \\ [])

Same as radload/2, except it returns only the value (not a tuple) and raises on error.

radload_buffer(buffer, optional \\ [])

Load rad from buffer

radload_buffer!(buffer, optional \\ [])

Same as radload_buffer/2, except it returns only the value (not a tuple) and raises on error.

radsave(in, filename, optional \\ [])

Save image to radiance file

radsave!(in, filename, optional \\ [])

Same as radsave/3, except it returns only the value (not a tuple) and raises on error.

radsave_buffer(in, optional \\ [])

Save image to radiance buffer

radsave_buffer!(in, optional \\ [])

Same as radsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

rank(in, width, height, index, optional \\ [])

Rank filter

rank!(in, width, height, index, optional \\ [])

Same as rank/5, except it returns only the value (not a tuple) and raises on error.

rawload(filename, width, height, bands, optional \\ [])

Load raw data from a file

rawload!(filename, width, height, bands, optional \\ [])

Same as rawload/5, except it returns only the value (not a tuple) and raises on error.

rawsave(in, filename, optional \\ [])

Save image to raw file

rawsave!(in, filename, optional \\ [])

Same as rawsave/3, except it returns only the value (not a tuple) and raises on error.

rawsave_fd(in, fd, optional \\ [])

Write raw image to file descriptor

rawsave_fd!(in, fd, optional \\ [])

Same as rawsave_fd/3, except it returns only the value (not a tuple) and raises on error.

recomb(in, m, optional \\ [])

Linear recombination with matrix

recomb!(in, m, optional \\ [])

Same as recomb/3, except it returns only the value (not a tuple) and raises on error.

reduce(in, hshrink, vshrink, optional \\ [])

Reduce an image

reduce!(in, hshrink, vshrink, optional \\ [])

Same as reduce/4, except it returns only the value (not a tuple) and raises on error.

reduceh(in, hshrink, optional \\ [])

Shrink an image horizontally

reduceh!(in, hshrink, optional \\ [])

Same as reduceh/3, except it returns only the value (not a tuple) and raises on error.

reducev(in, vshrink, optional \\ [])

Shrink an image vertically

reducev!(in, vshrink, optional \\ [])

Same as reducev/3, except it returns only the value (not a tuple) and raises on error.

relational(left, right, relational, optional \\ [])

Relational operation on two images

relational!(left, right, relational, optional \\ [])

Same as relational/4, except it returns only the value (not a tuple) and raises on error.

relational_const(in, relational, c, optional \\ [])

Relational operations against a constant

relational_const!(in, relational, c, optional \\ [])

Same as relational_const/4, except it returns only the value (not a tuple) and raises on error.

remainder(left, right, optional \\ [])

Remainder after integer division of two images

remainder!(left, right, optional \\ [])

Same as remainder/3, except it returns only the value (not a tuple) and raises on error.

remainder_const(in, c, optional \\ [])

Remainder after integer division of an image and a constant

remainder_const!(in, c, optional \\ [])

Same as remainder_const/3, except it returns only the value (not a tuple) and raises on error.

replicate(in, across, down, optional \\ [])

Replicate an image

replicate!(in, across, down, optional \\ [])

Same as replicate/4, except it returns only the value (not a tuple) and raises on error.

resize(in, scale, optional \\ [])

Resize an image

resize!(in, scale, optional \\ [])

Same as resize/3, except it returns only the value (not a tuple) and raises on error.

rot(in, angle, optional \\ [])

Rotate an image

rot!(in, angle, optional \\ [])

Same as rot/3, except it returns only the value (not a tuple) and raises on error.

rot45(in, optional \\ [])

Rotate an image

rot45!(in, optional \\ [])

Same as rot45/2, except it returns only the value (not a tuple) and raises on error.

rotate(in, angle, optional \\ [])

Rotate an image by a number of degrees

rotate!(in, angle, optional \\ [])

Same as rotate/3, except it returns only the value (not a tuple) and raises on error.

round(in, round, optional \\ [])

Perform a round function on an image

round!(in, round, optional \\ [])

Same as round/3, except it returns only the value (not a tuple) and raises on error.

scale(in, optional \\ [])

Scale an image to uchar

scale!(in, optional \\ [])

Same as scale/2, except it returns only the value (not a tuple) and raises on error.

scrgb2bw(in, optional \\ [])

Convert scrgb to bw

scrgb2bw!(in, optional \\ [])

Same as scrgb2bw/2, except it returns only the value (not a tuple) and raises on error.

scrgb2srgb(in, optional \\ [])

Convert an scrgb image to srgb

scrgb2srgb!(in, optional \\ [])

Same as scrgb2srgb/2, except it returns only the value (not a tuple) and raises on error.

scrgb2xyz(in, optional \\ [])

Transform scrgb to xyz

scrgb2xyz!(in, optional \\ [])

Same as scrgb2xyz/2, except it returns only the value (not a tuple) and raises on error.

sequential(in, optional \\ [])

Check sequential access

sequential!(in, optional \\ [])

Same as sequential/2, except it returns only the value (not a tuple) and raises on error.

sharpen(in, optional \\ [])

Unsharp masking for print

sharpen!(in, optional \\ [])

Same as sharpen/2, except it returns only the value (not a tuple) and raises on error.

shrink(in, hshrink, vshrink, optional \\ [])

Shrink an image

shrink!(in, hshrink, vshrink, optional \\ [])

Same as shrink/4, except it returns only the value (not a tuple) and raises on error.

shrinkh(in, hshrink, optional \\ [])

Shrink an image horizontally

shrinkh!(in, hshrink, optional \\ [])

Same as shrinkh/3, except it returns only the value (not a tuple) and raises on error.

shrinkv(in, vshrink, optional \\ [])

Shrink an image vertically

shrinkv!(in, vshrink, optional \\ [])

Same as shrinkv/3, except it returns only the value (not a tuple) and raises on error.

sign(in, optional \\ [])

Unit vector of pixel

sign!(in, optional \\ [])

Same as sign/2, except it returns only the value (not a tuple) and raises on error.

similarity(in, optional \\ [])

Similarity transform of an image

similarity!(in, optional \\ [])

Same as similarity/2, except it returns only the value (not a tuple) and raises on error.

sines(width, height, optional \\ [])

Make a 2d sine wave

sines!(width, height, optional \\ [])

Same as sines/3, except it returns only the value (not a tuple) and raises on error.

smartcrop(input, width, height, optional \\ [])

Extract an area from an image

smartcrop!(input, width, height, optional \\ [])

Same as smartcrop/4, except it returns only the value (not a tuple) and raises on error.

sobel(in, optional \\ [])

Sobel edge detector

sobel!(in, optional \\ [])

Same as sobel/2, except it returns only the value (not a tuple) and raises on error.

spcor(in, ref, optional \\ [])

Spatial correlation

spcor!(in, ref, optional \\ [])

Same as spcor/3, except it returns only the value (not a tuple) and raises on error.

spectrum(in, optional \\ [])

Make displayable power spectrum

spectrum!(in, optional \\ [])

Same as spectrum/2, except it returns only the value (not a tuple) and raises on error.

srgb2hsv(in, optional \\ [])

Transform srgb to hsv

srgb2hsv!(in, optional \\ [])

Same as srgb2hsv/2, except it returns only the value (not a tuple) and raises on error.

srgb2scrgb(in, optional \\ [])

Convert an srgb image to scrgb

srgb2scrgb!(in, optional \\ [])

Same as srgb2scrgb/2, except it returns only the value (not a tuple) and raises on error.

stats(in, optional \\ [])

Find many image stats

stats!(in, optional \\ [])

Same as stats/2, except it returns only the value (not a tuple) and raises on error.

stdif(in, width, height, optional \\ [])

Statistical difference

stdif!(in, width, height, optional \\ [])

Same as stdif/4, except it returns only the value (not a tuple) and raises on error.

subsample(input, xfac, yfac, optional \\ [])

Subsample an image

subsample!(input, xfac, yfac, optional \\ [])

Same as subsample/4, except it returns only the value (not a tuple) and raises on error.

subtract(left, right, optional \\ [])

Subtract two images

subtract!(left, right, optional \\ [])

Same as subtract/3, except it returns only the value (not a tuple) and raises on error.

sum(in, optional \\ [])

Sum an array of images

sum!(in, optional \\ [])

Same as sum/2, except it returns only the value (not a tuple) and raises on error.

svgload(filename, optional \\ [])

Load svg with rsvg

svgload!(filename, optional \\ [])

Same as svgload/2, except it returns only the value (not a tuple) and raises on error.

svgload_buffer(buffer, optional \\ [])

Load svg with rsvg

svgload_buffer!(buffer, optional \\ [])

Same as svgload_buffer/2, except it returns only the value (not a tuple) and raises on error.

switch(tests, optional \\ [])

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

switch!(tests, optional \\ [])

Same as switch/2, except it returns only the value (not a tuple) and raises on error.

system(cmd-format, optional \\ [])

Run an external command

system!(cmd-format, optional \\ [])

Same as system/2, except it returns only the value (not a tuple) and raises on error.

text(text, optional \\ [])

Make a text image

text!(text, optional \\ [])

Same as text/2, except it returns only the value (not a tuple) and raises on error.

thumbnail(filename, width, optional \\ [])

Generate thumbnail from file

thumbnail!(filename, width, optional \\ [])

Same as thumbnail/3, except it returns only the value (not a tuple) and raises on error.

thumbnail_buffer(buffer, width, optional \\ [])

Generate thumbnail from buffer

thumbnail_buffer!(buffer, width, optional \\ [])

Same as thumbnail_buffer/3, except it returns only the value (not a tuple) and raises on error.

thumbnail_image(in, width, optional \\ [])

Generate thumbnail from image

thumbnail_image!(in, width, optional \\ [])

Same as thumbnail_image/3, except it returns only the value (not a tuple) and raises on error.

tiffload(filename, optional \\ [])

Load tiff from file

tiffload!(filename, optional \\ [])

Same as tiffload/2, except it returns only the value (not a tuple) and raises on error.

tiffload_buffer(buffer, optional \\ [])

Load tiff from buffer

tiffload_buffer!(buffer, optional \\ [])

Same as tiffload_buffer/2, except it returns only the value (not a tuple) and raises on error.

tiffsave(in, filename, optional \\ [])

Save image to tiff file

tiffsave!(in, filename, optional \\ [])

Same as tiffsave/3, except it returns only the value (not a tuple) and raises on error.

tiffsave_buffer(in, optional \\ [])

Save image to tiff buffer

tiffsave_buffer!(in, optional \\ [])

Same as tiffsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

tilecache(in, optional \\ [])

Cache an image as a set of tiles

tilecache!(in, optional \\ [])

Same as tilecache/2, except it returns only the value (not a tuple) and raises on error.

tonelut(optional \\ [])

Build a look-up table

tonelut!(optional \\ [])

Same as tonelut/1, except it returns only the value (not a tuple) and raises on error.

transpose3d(in, optional \\ [])

Transpose3d an image

transpose3d!(in, optional \\ [])

Same as transpose3d/2, except it returns only the value (not a tuple) and raises on error.

unpremultiply(in, optional \\ [])

Unpremultiply image alpha

unpremultiply!(in, optional \\ [])

Same as unpremultiply/2, except it returns only the value (not a tuple) and raises on error.

vipsload(filename, optional \\ [])

Load vips from file

vipsload!(filename, optional \\ [])

Same as vipsload/2, except it returns only the value (not a tuple) and raises on error.

vipssave(in, filename, optional \\ [])

Save image to file in vips format

vipssave!(in, filename, optional \\ [])

Same as vipssave/3, except it returns only the value (not a tuple) and raises on error.

webpload(filename, optional \\ [])

Load webp from file

webpload!(filename, optional \\ [])

Same as webpload/2, except it returns only the value (not a tuple) and raises on error.

webpload_buffer(buffer, optional \\ [])

Load webp from buffer

webpload_buffer!(buffer, optional \\ [])

Same as webpload_buffer/2, except it returns only the value (not a tuple) and raises on error.

webpsave(in, filename, optional \\ [])

Save image to webp file

webpsave!(in, filename, optional \\ [])

Same as webpsave/3, except it returns only the value (not a tuple) and raises on error.

webpsave_buffer(in, optional \\ [])

Save image to webp buffer

webpsave_buffer!(in, optional \\ [])

Same as webpsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

worley(width, height, optional \\ [])

Make a worley noise image

worley!(width, height, optional \\ [])

Same as worley/3, except it returns only the value (not a tuple) and raises on error.

wrap(in, optional \\ [])

Wrap image origin

wrap!(in, optional \\ [])

Same as wrap/2, except it returns only the value (not a tuple) and raises on error.

xyz(width, height, optional \\ [])

Make an image where pixel values are coordinates

xyz!(width, height, optional \\ [])

Same as xyz/3, except it returns only the value (not a tuple) and raises on error.

xyz2cmyk(in, optional \\ [])

Transform xyz to cmyk

xyz2cmyk!(in, optional \\ [])

Same as xyz2cmyk/2, except it returns only the value (not a tuple) and raises on error.

xyz2lab(in, optional \\ [])

Transform xyz to lab

xyz2lab!(in, optional \\ [])

Same as xyz2lab/2, except it returns only the value (not a tuple) and raises on error.

xyz2scrgb(in, optional \\ [])

Transform xyz to scrgb

xyz2scrgb!(in, optional \\ [])

Same as xyz2scrgb/2, except it returns only the value (not a tuple) and raises on error.

xyz2yxy(in, optional \\ [])

Transform xyz to yxy

xyz2yxy!(in, optional \\ [])

Same as xyz2yxy/2, except it returns only the value (not a tuple) and raises on error.

yxy2xyz(in, optional \\ [])

Transform yxy to xyz

yxy2xyz!(in, optional \\ [])

Same as yxy2xyz/2, except it returns only the value (not a tuple) and raises on error.

zone(width, height, optional \\ [])

Make a zone plate

zone!(width, height, optional \\ [])

Same as zone/3, except it returns only the value (not a tuple) and raises on error.

zoom(input, xfac, yfac, optional \\ [])

Zoom an image

zoom!(input, xfac, yfac, optional \\ [])

Same as zoom/4, except it returns only the value (not a tuple) and raises on error.

Link to this section Types

gsf_output_csv_quoting_mode()

Specs

gsf_output_csv_quoting_mode() ::
  :GSF_OUTPUT_CSV_QUOTING_MODE_NEVER | :GSF_OUTPUT_CSV_QUOTING_MODE_AUTO

vips_access()

Specs

vips_access() ::
  :VIPS_ACCESS_RANDOM
  | :VIPS_ACCESS_SEQUENTIAL
  | :VIPS_ACCESS_SEQUENTIAL_UNBUFFERED

vips_align()

Specs

vips_align() :: :VIPS_ALIGN_LOW | :VIPS_ALIGN_CENTRE | :VIPS_ALIGN_HIGH

vips_angle()

Specs

vips_angle() ::
  :VIPS_ANGLE_D0 | :VIPS_ANGLE_D90 | :VIPS_ANGLE_D180 | :VIPS_ANGLE_D270

vips_angle45()

Specs

vips_angle45() ::
  :VIPS_ANGLE45_D0
  | :VIPS_ANGLE45_D45
  | :VIPS_ANGLE45_D90
  | :VIPS_ANGLE45_D135
  | :VIPS_ANGLE45_D180
  | :VIPS_ANGLE45_D225
  | :VIPS_ANGLE45_D270
  | :VIPS_ANGLE45_D315

vips_band_format()

Specs

vips_band_format() ::
  :VIPS_FORMAT_NOTSET
  | :VIPS_FORMAT_UCHAR
  | :VIPS_FORMAT_CHAR
  | :VIPS_FORMAT_USHORT
  | :VIPS_FORMAT_SHORT
  | :VIPS_FORMAT_UINT
  | :VIPS_FORMAT_INT
  | :VIPS_FORMAT_FLOAT
  | :VIPS_FORMAT_COMPLEX
  | :VIPS_FORMAT_DOUBLE
  | :VIPS_FORMAT_DPCOMPLEX

vips_blend_mode()

Specs

vips_blend_mode() ::
  :VIPS_BLEND_MODE_CLEAR
  | :VIPS_BLEND_MODE_SOURCE
  | :VIPS_BLEND_MODE_OVER
  | :VIPS_BLEND_MODE_IN
  | :VIPS_BLEND_MODE_OUT
  | :VIPS_BLEND_MODE_ATOP
  | :VIPS_BLEND_MODE_DEST
  | :VIPS_BLEND_MODE_DEST_OVER
  | :VIPS_BLEND_MODE_DEST_IN
  | :VIPS_BLEND_MODE_DEST_OUT
  | :VIPS_BLEND_MODE_DEST_ATOP
  | :VIPS_BLEND_MODE_XOR
  | :VIPS_BLEND_MODE_ADD
  | :VIPS_BLEND_MODE_SATURATE
  | :VIPS_BLEND_MODE_MULTIPLY
  | :VIPS_BLEND_MODE_SCREEN
  | :VIPS_BLEND_MODE_OVERLAY
  | :VIPS_BLEND_MODE_DARKEN
  | :VIPS_BLEND_MODE_LIGHTEN
  | :VIPS_BLEND_MODE_COLOUR_DODGE
  | :VIPS_BLEND_MODE_COLOUR_BURN
  | :VIPS_BLEND_MODE_HARD_LIGHT
  | :VIPS_BLEND_MODE_SOFT_LIGHT
  | :VIPS_BLEND_MODE_DIFFERENCE
  | :VIPS_BLEND_MODE_EXCLUSION

vips_coding()

Specs

vips_coding() ::
  :VIPS_CODING_ERROR | :VIPS_CODING_NONE | :VIPS_CODING_LABQ | :VIPS_CODING_RAD

vips_combine()

Specs

vips_combine() :: :VIPS_COMBINE_MAX | :VIPS_COMBINE_SUM | :VIPS_COMBINE_MIN

vips_combine_mode()

Specs

vips_combine_mode() :: :VIPS_COMBINE_MODE_SET | :VIPS_COMBINE_MODE_ADD

vips_compass_direction()

Specs

vips_compass_direction() ::
  :VIPS_COMPASS_DIRECTION_CENTRE
  | :VIPS_COMPASS_DIRECTION_NORTH
  | :VIPS_COMPASS_DIRECTION_EAST
  | :VIPS_COMPASS_DIRECTION_SOUTH
  | :VIPS_COMPASS_DIRECTION_WEST
  | :VIPS_COMPASS_DIRECTION_NORTH_EAST
  | :VIPS_COMPASS_DIRECTION_SOUTH_EAST
  | :VIPS_COMPASS_DIRECTION_SOUTH_WEST
  | :VIPS_COMPASS_DIRECTION_NORTH_WEST

vips_demand_style()

Specs

vips_demand_style() ::
  :VIPS_DEMAND_STYLE_ERROR
  | :VIPS_DEMAND_STYLE_SMALLTILE
  | :VIPS_DEMAND_STYLE_FATSTRIP
  | :VIPS_DEMAND_STYLE_THINSTRIP

vips_direction()

Specs

vips_direction() :: :VIPS_DIRECTION_HORIZONTAL | :VIPS_DIRECTION_VERTICAL

vips_extend()

Specs

vips_extend() ::
  :VIPS_EXTEND_BLACK
  | :VIPS_EXTEND_COPY
  | :VIPS_EXTEND_REPEAT
  | :VIPS_EXTEND_MIRROR
  | :VIPS_EXTEND_WHITE
  | :VIPS_EXTEND_BACKGROUND

vips_fail_on()

Specs

vips_fail_on() ::
  :VIPS_FAIL_ON_NONE
  | :VIPS_FAIL_ON_TRUNCATED
  | :VIPS_FAIL_ON_ERROR
  | :VIPS_FAIL_ON_WARNING

vips_foreign_dz_container()

Specs

vips_foreign_dz_container() ::
  :VIPS_FOREIGN_DZ_CONTAINER_FS
  | :VIPS_FOREIGN_DZ_CONTAINER_ZIP
  | :VIPS_FOREIGN_DZ_CONTAINER_SZI

vips_foreign_dz_depth()

Specs

vips_foreign_dz_depth() ::
  :VIPS_FOREIGN_DZ_DEPTH_ONEPIXEL
  | :VIPS_FOREIGN_DZ_DEPTH_ONETILE
  | :VIPS_FOREIGN_DZ_DEPTH_ONE

vips_foreign_dz_layout()

Specs

vips_foreign_dz_layout() ::
  :VIPS_FOREIGN_DZ_LAYOUT_DZ
  | :VIPS_FOREIGN_DZ_LAYOUT_ZOOMIFY
  | :VIPS_FOREIGN_DZ_LAYOUT_GOOGLE
  | :VIPS_FOREIGN_DZ_LAYOUT_IIIF
  | :VIPS_FOREIGN_DZ_LAYOUT_IIIF3

vips_foreign_flags()

Specs

vips_foreign_flags() :: [
  :VIPS_FOREIGN_NONE
  | :VIPS_FOREIGN_PARTIAL
  | :VIPS_FOREIGN_BIGENDIAN
  | :VIPS_FOREIGN_SEQUENTIAL
]

vips_foreign_heif_compression()

Specs

vips_foreign_heif_compression() ::
  :VIPS_FOREIGN_HEIF_COMPRESSION_HEVC
  | :VIPS_FOREIGN_HEIF_COMPRESSION_AVC
  | :VIPS_FOREIGN_HEIF_COMPRESSION_JPEG
  | :VIPS_FOREIGN_HEIF_COMPRESSION_AV1

vips_foreign_png_filter()

Specs

vips_foreign_png_filter() :: [
  :VIPS_FOREIGN_PNG_FILTER_NONE
  | :VIPS_FOREIGN_PNG_FILTER_SUB
  | :VIPS_FOREIGN_PNG_FILTER_UP
  | :VIPS_FOREIGN_PNG_FILTER_AVG
  | :VIPS_FOREIGN_PNG_FILTER_PAETH
]

vips_foreign_ppm_format()

Specs

vips_foreign_ppm_format() ::
  :VIPS_FOREIGN_PPM_FORMAT_PBM
  | :VIPS_FOREIGN_PPM_FORMAT_PGM
  | :VIPS_FOREIGN_PPM_FORMAT_PPM
  | :VIPS_FOREIGN_PPM_FORMAT_PFM

vips_foreign_subsample()

Specs

vips_foreign_subsample() ::
  :VIPS_FOREIGN_SUBSAMPLE_AUTO
  | :VIPS_FOREIGN_SUBSAMPLE_ON
  | :VIPS_FOREIGN_SUBSAMPLE_OFF

vips_foreign_tiff_compression()

Specs

vips_foreign_tiff_compression() ::
  :VIPS_FOREIGN_TIFF_COMPRESSION_NONE
  | :VIPS_FOREIGN_TIFF_COMPRESSION_JPEG
  | :VIPS_FOREIGN_TIFF_COMPRESSION_DEFLATE
  | :VIPS_FOREIGN_TIFF_COMPRESSION_PACKBITS
  | :VIPS_FOREIGN_TIFF_COMPRESSION_CCITTFAX4
  | :VIPS_FOREIGN_TIFF_COMPRESSION_LZW
  | :VIPS_FOREIGN_TIFF_COMPRESSION_WEBP
  | :VIPS_FOREIGN_TIFF_COMPRESSION_ZSTD
  | :VIPS_FOREIGN_TIFF_COMPRESSION_JP2K

vips_foreign_tiff_predictor()

Specs

vips_foreign_tiff_predictor() ::
  :VIPS_FOREIGN_TIFF_PREDICTOR_NONE
  | :VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL
  | :VIPS_FOREIGN_TIFF_PREDICTOR_FLOAT

vips_foreign_tiff_resunit()

Specs

vips_foreign_tiff_resunit() ::
  :VIPS_FOREIGN_TIFF_RESUNIT_CM | :VIPS_FOREIGN_TIFF_RESUNIT_INCH

vips_foreign_webp_preset()

Specs

vips_foreign_webp_preset() ::
  :VIPS_FOREIGN_WEBP_PRESET_DEFAULT
  | :VIPS_FOREIGN_WEBP_PRESET_PICTURE
  | :VIPS_FOREIGN_WEBP_PRESET_PHOTO
  | :VIPS_FOREIGN_WEBP_PRESET_DRAWING
  | :VIPS_FOREIGN_WEBP_PRESET_ICON
  | :VIPS_FOREIGN_WEBP_PRESET_TEXT

vips_intent()

Specs

vips_intent() ::
  :VIPS_INTENT_PERCEPTUAL
  | :VIPS_INTENT_RELATIVE
  | :VIPS_INTENT_SATURATION
  | :VIPS_INTENT_ABSOLUTE

vips_interesting()

Specs

vips_interesting() ::
  :VIPS_INTERESTING_NONE
  | :VIPS_INTERESTING_CENTRE
  | :VIPS_INTERESTING_ENTROPY
  | :VIPS_INTERESTING_ATTENTION
  | :VIPS_INTERESTING_LOW
  | :VIPS_INTERESTING_HIGH
  | :VIPS_INTERESTING_ALL

vips_interpretation()

Specs

vips_interpretation() ::
  :VIPS_INTERPRETATION_ERROR
  | :VIPS_INTERPRETATION_MULTIBAND
  | :VIPS_INTERPRETATION_B_W
  | :VIPS_INTERPRETATION_HISTOGRAM
  | :VIPS_INTERPRETATION_XYZ
  | :VIPS_INTERPRETATION_LAB
  | :VIPS_INTERPRETATION_CMYK
  | :VIPS_INTERPRETATION_LABQ
  | :VIPS_INTERPRETATION_RGB
  | :VIPS_INTERPRETATION_CMC
  | :VIPS_INTERPRETATION_LCH
  | :VIPS_INTERPRETATION_LABS
  | :VIPS_INTERPRETATION_sRGB
  | :VIPS_INTERPRETATION_YXY
  | :VIPS_INTERPRETATION_FOURIER
  | :VIPS_INTERPRETATION_RGB16
  | :VIPS_INTERPRETATION_GREY16
  | :VIPS_INTERPRETATION_MATRIX
  | :VIPS_INTERPRETATION_scRGB
  | :VIPS_INTERPRETATION_HSV

vips_kernel()

Specs

vips_kernel() ::
  :VIPS_KERNEL_NEAREST
  | :VIPS_KERNEL_LINEAR
  | :VIPS_KERNEL_CUBIC
  | :VIPS_KERNEL_MITCHELL
  | :VIPS_KERNEL_LANCZOS2
  | :VIPS_KERNEL_LANCZOS3

vips_operation_boolean()

Specs

vips_operation_boolean() ::
  :VIPS_OPERATION_BOOLEAN_AND
  | :VIPS_OPERATION_BOOLEAN_OR
  | :VIPS_OPERATION_BOOLEAN_EOR
  | :VIPS_OPERATION_BOOLEAN_LSHIFT
  | :VIPS_OPERATION_BOOLEAN_RSHIFT

vips_operation_complex()

Specs

vips_operation_complex() ::
  :VIPS_OPERATION_COMPLEX_POLAR
  | :VIPS_OPERATION_COMPLEX_RECT
  | :VIPS_OPERATION_COMPLEX_CONJ

vips_operation_complex2()

Specs

vips_operation_complex2() :: :VIPS_OPERATION_COMPLEX2_CROSS_PHASE

vips_operation_complexget()

Specs

vips_operation_complexget() ::
  :VIPS_OPERATION_COMPLEXGET_REAL | :VIPS_OPERATION_COMPLEXGET_IMAG

vips_operation_math()

Specs

vips_operation_math() ::
  :VIPS_OPERATION_MATH_SIN
  | :VIPS_OPERATION_MATH_COS
  | :VIPS_OPERATION_MATH_TAN
  | :VIPS_OPERATION_MATH_ASIN
  | :VIPS_OPERATION_MATH_ACOS
  | :VIPS_OPERATION_MATH_ATAN
  | :VIPS_OPERATION_MATH_LOG
  | :VIPS_OPERATION_MATH_LOG10
  | :VIPS_OPERATION_MATH_EXP
  | :VIPS_OPERATION_MATH_EXP10
  | :VIPS_OPERATION_MATH_SINH
  | :VIPS_OPERATION_MATH_COSH
  | :VIPS_OPERATION_MATH_TANH
  | :VIPS_OPERATION_MATH_ASINH
  | :VIPS_OPERATION_MATH_ACOSH
  | :VIPS_OPERATION_MATH_ATANH

vips_operation_math2()

Specs

vips_operation_math2() ::
  :VIPS_OPERATION_MATH2_POW
  | :VIPS_OPERATION_MATH2_WOP
  | :VIPS_OPERATION_MATH2_ATAN2

vips_operation_morphology()

Specs

vips_operation_morphology() ::
  :VIPS_OPERATION_MORPHOLOGY_ERODE | :VIPS_OPERATION_MORPHOLOGY_DILATE

vips_operation_relational()

Specs

vips_operation_relational() ::
  :VIPS_OPERATION_RELATIONAL_EQUAL
  | :VIPS_OPERATION_RELATIONAL_NOTEQ
  | :VIPS_OPERATION_RELATIONAL_LESS
  | :VIPS_OPERATION_RELATIONAL_LESSEQ
  | :VIPS_OPERATION_RELATIONAL_MORE
  | :VIPS_OPERATION_RELATIONAL_MOREEQ

vips_operation_round()

Specs

vips_operation_round() ::
  :VIPS_OPERATION_ROUND_RINT
  | :VIPS_OPERATION_ROUND_CEIL
  | :VIPS_OPERATION_ROUND_FLOOR

vips_pcs()

Specs

vips_pcs() :: :VIPS_PCS_LAB | :VIPS_PCS_XYZ

vips_precision()

Specs

vips_precision() ::
  :VIPS_PRECISION_INTEGER | :VIPS_PRECISION_FLOAT | :VIPS_PRECISION_APPROXIMATE

vips_region_shrink()

Specs

vips_region_shrink() ::
  :VIPS_REGION_SHRINK_MEAN
  | :VIPS_REGION_SHRINK_MEDIAN
  | :VIPS_REGION_SHRINK_MODE
  | :VIPS_REGION_SHRINK_MAX
  | :VIPS_REGION_SHRINK_MIN
  | :VIPS_REGION_SHRINK_NEAREST

vips_size()

Specs

vips_size() ::
  :VIPS_SIZE_BOTH | :VIPS_SIZE_UP | :VIPS_SIZE_DOWN | :VIPS_SIZE_FORCE

Link to this section Functions

abs(in, optional \\ [])

Specs

abs(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Absolute value of an image

arguments
Arguments

in - Input image

abs!(in, optional \\ [])

Specs

abs!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as abs/2, except it returns only the value (not a tuple) and raises on error.

add(left, right, optional \\ [])

Specs

add(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Add two images

arguments
Arguments

left - Left-hand image argument
right - Right-hand image argument

add!(left, right, optional \\ [])

Specs

add!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as add/3, except it returns only the value (not a tuple) and raises on error.

affine(in, matrix, optional \\ [])

Specs

affine(Vix.Vips.Image.t(), [float()],
  extend: vips_extend(),
  premultiplied: boolean(),
  background: [float()],
  idy: float(),
  idx: float(),
  ody: float(),
  odx: float(),
  oarea: [integer()],
  interpolate: Vix.Vips.Interpolate.t()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Affine transform of an image

arguments
Arguments

in - Input image argument
matrix - Transformation matrix

optional
Optional

extend - How to generate the extra pixels. Default: :VIPS_EXTEND_BACKGROUND
premultiplied - Images have premultiplied alpha. Default: false
background - Background value.
idy - Vertical input displacement. Default: 0.0
idx - Horizontal input displacement. Default: 0.0
ody - Vertical output displacement. Default: 0.0
odx - Horizontal output displacement. Default: 0.0
oarea - Area of output to generate.
interpolate - Interpolate pixels with this.

affine!(in, matrix, optional \\ [])

Specs

affine!(Vix.Vips.Image.t(), [float()],
  extend: vips_extend(),
  premultiplied: boolean(),
  background: [float()],
  idy: float(),
  idx: float(),
  ody: float(),
  odx: float(),
  oarea: [integer()],
  interpolate: Vix.Vips.Interpolate.t()
) :: Vix.Vips.Image.t() | no_return()

Same as affine/3, except it returns only the value (not a tuple) and raises on error.

analyzeload(filename, optional \\ [])

Specs

analyzeload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load an analyze6 image

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

analyzeload!(filename, optional \\ [])

Specs

analyzeload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as analyzeload/2, except it returns only the value (not a tuple) and raises on error.

arrayjoin(in, optional \\ [])

Specs

arrayjoin([Vix.Vips.Image.t()],
  vspacing: integer(),
  hspacing: integer(),
  valign: vips_align(),
  halign: vips_align(),
  background: [float()],
  shim: integer(),
  across: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Join an array of images

arguments
Arguments

in - Array of input images

optional
Optional

vspacing - Vertical spacing between images. Default: 1
hspacing - Horizontal spacing between images. Default: 1
valign - Align on the top, centre or bottom. Default: :VIPS_ALIGN_LOW
halign - Align on the left, centre or right. Default: :VIPS_ALIGN_LOW
background - Colour for new pixels.
shim - Pixels between images. Default: 0
across - Number of images across grid. Default: 1

arrayjoin!(in, optional \\ [])

Specs

arrayjoin!([Vix.Vips.Image.t()],
  vspacing: integer(),
  hspacing: integer(),
  valign: vips_align(),
  halign: vips_align(),
  background: [float()],
  shim: integer(),
  across: integer()
) :: Vix.Vips.Image.t() | no_return()

Same as arrayjoin/2, except it returns only the value (not a tuple) and raises on error.

autorot(in, optional \\ [])

Specs

autorot(Vix.Vips.Image.t(), []) ::
  {:ok, {Vix.Vips.Image.t(), flip: boolean(), angle: vips_angle()}}
  | {:error, term()}

Autorotate image by exif tag

arguments
Arguments

in - Input image

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flip - Whether the image was flipped or not. (boolean())
angle - Angle image was rotated by. (vips_angle)

autorot!(in, optional \\ [])

Specs

autorot!(Vix.Vips.Image.t(), []) ::
  {Vix.Vips.Image.t(), flip: boolean(), angle: vips_angle()} | no_return()

Same as autorot/2, except it returns only the value (not a tuple) and raises on error.

avg(in, optional \\ [])

Specs

avg(Vix.Vips.Image.t(), []) :: {:ok, float()} | {:error, term()}

Find image average

arguments
Arguments

in - Input image

avg!(in, optional \\ [])

Specs

avg!(Vix.Vips.Image.t(), []) :: float() | no_return()

Same as avg/2, except it returns only the value (not a tuple) and raises on error.

bandbool(in, boolean, optional \\ [])

Specs

bandbool(Vix.Vips.Image.t(), vips_operation_boolean(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Boolean operation across image bands

arguments
Arguments

in - Input image argument
boolean - boolean to perform

bandbool!(in, boolean, optional \\ [])

Specs

bandbool!(Vix.Vips.Image.t(), vips_operation_boolean(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as bandbool/3, except it returns only the value (not a tuple) and raises on error.

bandfold(in, optional \\ [])

Specs

bandfold(Vix.Vips.Image.t(), [{:factor, integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Fold up x axis into bands

arguments
Arguments

in - Input image

optional
Optional

factor - Fold by this factor. Default: 0

bandfold!(in, optional \\ [])

Specs

bandfold!(Vix.Vips.Image.t(), [{:factor, integer()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as bandfold/2, except it returns only the value (not a tuple) and raises on error.

bandjoin(in, optional \\ [])

Specs

bandjoin([Vix.Vips.Image.t()], []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Bandwise join a set of images

arguments
Arguments

in - Array of input images

bandjoin!(in, optional \\ [])

Specs

bandjoin!([Vix.Vips.Image.t()], []) :: Vix.Vips.Image.t() | no_return()

Same as bandjoin/2, except it returns only the value (not a tuple) and raises on error.

bandjoin_const(in, c, optional \\ [])

Specs

bandjoin_const(Vix.Vips.Image.t(), [float()], []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Append a constant band to an image

arguments
Arguments

in - Input image
c - Array of constants to add

bandjoin_const!(in, c, optional \\ [])

Specs

bandjoin_const!(Vix.Vips.Image.t(), [float()], []) ::
  Vix.Vips.Image.t() | no_return()

Same as bandjoin_const/3, except it returns only the value (not a tuple) and raises on error.

bandmean(in, optional \\ [])

Specs

bandmean(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Band-wise average

arguments
Arguments

in - Input image argument

bandmean!(in, optional \\ [])

Specs

bandmean!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as bandmean/2, except it returns only the value (not a tuple) and raises on error.

bandrank(in, optional \\ [])

Specs

bandrank([Vix.Vips.Image.t()], [{:index, integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Band-wise rank of a set of images

arguments
Arguments

in - Array of input images

optional
Optional

index - Select this band element from sorted list. Default: -1

bandrank!(in, optional \\ [])

Specs

bandrank!([Vix.Vips.Image.t()], [{:index, integer()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as bandrank/2, except it returns only the value (not a tuple) and raises on error.

bandunfold(in, optional \\ [])

Specs

bandunfold(Vix.Vips.Image.t(), [{:factor, integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Unfold image bands into x axis

arguments
Arguments

in - Input image

optional
Optional

factor - Unfold by this factor. Default: 0

bandunfold!(in, optional \\ [])

Specs

bandunfold!(Vix.Vips.Image.t(), [{:factor, integer()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as bandunfold/2, except it returns only the value (not a tuple) and raises on error.

black(width, height, optional \\ [])

Specs

black(integer(), integer(), [{:bands, integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a black image

arguments
Arguments

width - Image width in pixels
height - Image height in pixels

optional
Optional

bands - Number of bands in image. Default: 1

black!(width, height, optional \\ [])

Specs

black!(integer(), integer(), [{:bands, integer()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as black/3, except it returns only the value (not a tuple) and raises on error.

boolean(left, right, boolean, optional \\ [])

Specs

boolean(Vix.Vips.Image.t(), Vix.Vips.Image.t(), vips_operation_boolean(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Boolean operation on two images

arguments
Arguments

left - Left-hand image argument
right - Right-hand image argument
boolean - boolean to perform

boolean!(left, right, boolean, optional \\ [])

Specs

boolean!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), vips_operation_boolean(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as boolean/4, except it returns only the value (not a tuple) and raises on error.

boolean_const(in, boolean, c, optional \\ [])

Specs

boolean_const(Vix.Vips.Image.t(), vips_operation_boolean(), [float()], []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Boolean operations against a constant

arguments
Arguments

in - Input image
boolean - boolean to perform
c - Array of constants

boolean_const!(in, boolean, c, optional \\ [])

Specs

boolean_const!(Vix.Vips.Image.t(), vips_operation_boolean(), [float()], []) ::
  Vix.Vips.Image.t() | no_return()

Same as boolean_const/4, except it returns only the value (not a tuple) and raises on error.

buildlut(in, optional \\ [])

Specs

buildlut(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Build a look-up table

arguments
Arguments

in - Matrix of XY coordinates

buildlut!(in, optional \\ [])

Specs

buildlut!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as buildlut/2, except it returns only the value (not a tuple) and raises on error.

byteswap(in, optional \\ [])

Specs

byteswap(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Byteswap an image

arguments
Arguments

in - Input image

byteswap!(in, optional \\ [])

Specs

byteswap!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as byteswap/2, except it returns only the value (not a tuple) and raises on error.

cache(in, optional \\ [])

Specs

cache(Vix.Vips.Image.t(),
  "tile-width": integer(),
  "tile-height": integer(),
  "max-tiles": integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Cache an image

arguments
Arguments

in - Input image

optional
Optional

tile-width - Tile width in pixels. Default: 128
tile-height - Tile height in pixels. Default: 128
max-tiles - Maximum number of tiles to cache. Default: 1000

cache!(in, optional \\ [])

Specs

cache!(Vix.Vips.Image.t(),
  "tile-width": integer(),
  "tile-height": integer(),
  "max-tiles": integer()
) :: Vix.Vips.Image.t() | no_return()

Same as cache/2, except it returns only the value (not a tuple) and raises on error.

canny(in, optional \\ [])

Specs

canny(Vix.Vips.Image.t(), precision: vips_precision(), sigma: float()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Canny edge detector

arguments
Arguments

in - Input image

optional
Optional

precision - Convolve with this precision. Default: :VIPS_PRECISION_FLOAT
sigma - Sigma of Gaussian. Default: 1.4

canny!(in, optional \\ [])

Specs

canny!(Vix.Vips.Image.t(), precision: vips_precision(), sigma: float()) ::
  Vix.Vips.Image.t() | no_return()

Same as canny/2, except it returns only the value (not a tuple) and raises on error.

case(index, cases, optional \\ [])

Specs

case(Vix.Vips.Image.t(), [Vix.Vips.Image.t()], []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Use pixel values to pick cases from an array of images

arguments
Arguments

index - Index image
cases - Array of case images

case!(index, cases, optional \\ [])

Specs

case!(Vix.Vips.Image.t(), [Vix.Vips.Image.t()], []) ::
  Vix.Vips.Image.t() | no_return()

Same as case/3, except it returns only the value (not a tuple) and raises on error.

cast(in, format, optional \\ [])

Specs

cast(Vix.Vips.Image.t(), vips_band_format(), [{:shift, boolean()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Cast an image

arguments
Arguments

in - Input image
format - Format to cast to

optional
Optional

shift - Shift integer values up and down. Default: false

cast!(in, format, optional \\ [])

Specs

cast!(Vix.Vips.Image.t(), vips_band_format(), [{:shift, boolean()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as cast/3, except it returns only the value (not a tuple) and raises on error.

cmc2lch(in, optional \\ [])

Specs

cmc2lch(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform lch to cmc

arguments
Arguments

in - Input image

cmc2lch!(in, optional \\ [])

Specs

cmc2lch!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as cmc2lch/2, except it returns only the value (not a tuple) and raises on error.

cmyk2xyz(in, optional \\ [])

Specs

cmyk2xyz(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform cmyk to xyz

arguments
Arguments

in - Input image

cmyk2xyz!(in, optional \\ [])

Specs

cmyk2xyz!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as cmyk2xyz/2, except it returns only the value (not a tuple) and raises on error.

colourspace(in, space, optional \\ [])

Specs

colourspace(Vix.Vips.Image.t(), vips_interpretation(), [
  {:"source-space", vips_interpretation()}
]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Convert to a new colorspace

arguments
Arguments

in - Input image
space - Destination color space

optional
Optional

source-space - Source color space. Default: :VIPS_INTERPRETATION_sRGB

colourspace!(in, space, optional \\ [])

Specs

colourspace!(Vix.Vips.Image.t(), vips_interpretation(), [
  {:"source-space", vips_interpretation()}
]) ::
  Vix.Vips.Image.t() | no_return()

Same as colourspace/3, except it returns only the value (not a tuple) and raises on error.

compass(in, mask, optional \\ [])

Specs

compass(Vix.Vips.Image.t(), Vix.Vips.Image.t(),
  cluster: integer(),
  layers: integer(),
  precision: vips_precision(),
  combine: vips_combine(),
  angle: vips_angle45(),
  times: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Convolve with rotating mask

arguments
Arguments

in - Input image argument
mask - Input matrix image

optional
Optional

cluster - Cluster lines closer than this in approximation. Default: 1
layers - Use this many layers in approximation. Default: 5
precision - Convolve with this precision. Default: :VIPS_PRECISION_FLOAT
combine - Combine convolution results like this. Default: :VIPS_COMBINE_MAX
angle - Rotate mask by this much between convolutions. Default: :VIPS_ANGLE45_D90
times - Rotate and convolve this many times. Default: 2

compass!(in, mask, optional \\ [])

Specs

compass!(Vix.Vips.Image.t(), Vix.Vips.Image.t(),
  cluster: integer(),
  layers: integer(),
  precision: vips_precision(),
  combine: vips_combine(),
  angle: vips_angle45(),
  times: integer()
) :: Vix.Vips.Image.t() | no_return()

Same as compass/3, except it returns only the value (not a tuple) and raises on error.

complex(in, cmplx, optional \\ [])

Specs

complex(Vix.Vips.Image.t(), vips_operation_complex(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Perform a complex operation on an image

arguments
Arguments

in - Input image
cmplx - complex to perform

complex!(in, cmplx, optional \\ [])

Specs

complex!(Vix.Vips.Image.t(), vips_operation_complex(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as complex/3, except it returns only the value (not a tuple) and raises on error.

complex2(left, right, cmplx, optional \\ [])

Specs

complex2(Vix.Vips.Image.t(), Vix.Vips.Image.t(), vips_operation_complex2(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Complex binary operations on two images

arguments
Arguments

left - Left-hand image argument
right - Right-hand image argument
cmplx - binary complex operation to perform

complex2!(left, right, cmplx, optional \\ [])

Specs

complex2!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), vips_operation_complex2(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as complex2/4, except it returns only the value (not a tuple) and raises on error.

complexform(left, right, optional \\ [])

Specs

complexform(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Form a complex image from two real images

arguments
Arguments

left - Left-hand image argument
right - Right-hand image argument

complexform!(left, right, optional \\ [])

Specs

complexform!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as complexform/3, except it returns only the value (not a tuple) and raises on error.

complexget(in, get, optional \\ [])

Specs

complexget(Vix.Vips.Image.t(), vips_operation_complexget(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Get a component from a complex image

arguments
Arguments

in - Input image
get - complex to perform

complexget!(in, get, optional \\ [])

Specs

complexget!(Vix.Vips.Image.t(), vips_operation_complexget(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as complexget/3, except it returns only the value (not a tuple) and raises on error.

composite(in, mode, optional \\ [])

Specs

composite([Vix.Vips.Image.t()], [integer()],
  premultiplied: boolean(),
  "compositing-space": vips_interpretation(),
  y: [integer()],
  x: [integer()]
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Blend an array of images with an array of blend modes

arguments
Arguments

in - Array of input images
mode - Array of VipsBlendMode to join with

optional
Optional

premultiplied - Images have premultiplied alpha. Default: false
compositing-space - Composite images in this colour space. Default: :VIPS_INTERPRETATION_sRGB
y - Array of y coordinates to join at.
x - Array of x coordinates to join at.

composite!(in, mode, optional \\ [])

Specs

composite!([Vix.Vips.Image.t()], [integer()],
  premultiplied: boolean(),
  "compositing-space": vips_interpretation(),
  y: [integer()],
  x: [integer()]
) :: Vix.Vips.Image.t() | no_return()

Same as composite/3, except it returns only the value (not a tuple) and raises on error.

composite2(base, overlay, mode, optional \\ [])

Specs

composite2(Vix.Vips.Image.t(), Vix.Vips.Image.t(), vips_blend_mode(),
  premultiplied: boolean(),
  "compositing-space": vips_interpretation(),
  y: integer(),
  x: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Blend a pair of images with a blend mode

arguments
Arguments

base - Base image
overlay - Overlay image
mode - VipsBlendMode to join with

optional
Optional

premultiplied - Images have premultiplied alpha. Default: false
compositing-space - Composite images in this colour space. Default: :VIPS_INTERPRETATION_sRGB
y - y position of overlay. Default: 0
x - x position of overlay. Default: 0

composite2!(base, overlay, mode, optional \\ [])

Specs

composite2!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), vips_blend_mode(),
  premultiplied: boolean(),
  "compositing-space": vips_interpretation(),
  y: integer(),
  x: integer()
) :: Vix.Vips.Image.t() | no_return()

Same as composite2/4, except it returns only the value (not a tuple) and raises on error.

conv(in, mask, optional \\ [])

Specs

conv(Vix.Vips.Image.t(), Vix.Vips.Image.t(),
  cluster: integer(),
  layers: integer(),
  precision: vips_precision()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Convolution operation

arguments
Arguments

in - Input image argument
mask - Input matrix image

optional
Optional

cluster - Cluster lines closer than this in approximation. Default: 1
layers - Use this many layers in approximation. Default: 5
precision - Convolve with this precision. Default: :VIPS_PRECISION_FLOAT

conv!(in, mask, optional \\ [])

Specs

conv!(Vix.Vips.Image.t(), Vix.Vips.Image.t(),
  cluster: integer(),
  layers: integer(),
  precision: vips_precision()
) :: Vix.Vips.Image.t() | no_return()

Same as conv/3, except it returns only the value (not a tuple) and raises on error.

conva(in, mask, optional \\ [])

Specs

conva(Vix.Vips.Image.t(), Vix.Vips.Image.t(),
  cluster: integer(),
  layers: integer()
) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Approximate integer convolution

arguments
Arguments

in - Input image argument
mask - Input matrix image

optional
Optional

cluster - Cluster lines closer than this in approximation. Default: 1
layers - Use this many layers in approximation. Default: 5

conva!(in, mask, optional \\ [])

Specs

conva!(Vix.Vips.Image.t(), Vix.Vips.Image.t(),
  cluster: integer(),
  layers: integer()
) ::
  Vix.Vips.Image.t() | no_return()

Same as conva/3, except it returns only the value (not a tuple) and raises on error.

convasep(in, mask, optional \\ [])

Specs

convasep(Vix.Vips.Image.t(), Vix.Vips.Image.t(), [{:layers, integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Approximate separable integer convolution

arguments
Arguments

in - Input image argument
mask - Input matrix image

optional
Optional

layers - Use this many layers in approximation. Default: 5

convasep!(in, mask, optional \\ [])

Specs

convasep!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), [{:layers, integer()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as convasep/3, except it returns only the value (not a tuple) and raises on error.

convf(in, mask, optional \\ [])

Specs

convf(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Float convolution operation

arguments
Arguments

in - Input image argument
mask - Input matrix image

convf!(in, mask, optional \\ [])

Specs

convf!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as convf/3, except it returns only the value (not a tuple) and raises on error.

convi(in, mask, optional \\ [])

Specs

convi(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Int convolution operation

arguments
Arguments

in - Input image argument
mask - Input matrix image

convi!(in, mask, optional \\ [])

Specs

convi!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as convi/3, except it returns only the value (not a tuple) and raises on error.

convsep(in, mask, optional \\ [])

Specs

convsep(Vix.Vips.Image.t(), Vix.Vips.Image.t(),
  cluster: integer(),
  layers: integer(),
  precision: vips_precision()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Seperable convolution operation

arguments
Arguments

in - Input image argument
mask - Input matrix image

optional
Optional

cluster - Cluster lines closer than this in approximation. Default: 1
layers - Use this many layers in approximation. Default: 5
precision - Convolve with this precision. Default: :VIPS_PRECISION_FLOAT

convsep!(in, mask, optional \\ [])

Specs

convsep!(Vix.Vips.Image.t(), Vix.Vips.Image.t(),
  cluster: integer(),
  layers: integer(),
  precision: vips_precision()
) :: Vix.Vips.Image.t() | no_return()

Same as convsep/3, except it returns only the value (not a tuple) and raises on error.

copy(in, optional \\ [])

Specs

copy(Vix.Vips.Image.t(),
  yoffset: integer(),
  xoffset: integer(),
  yres: float(),
  xres: float(),
  interpretation: vips_interpretation(),
  coding: vips_coding(),
  format: vips_band_format(),
  bands: integer(),
  height: integer(),
  width: integer(),
  swap: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Copy an image

arguments
Arguments

in - Input image

optional
Optional

yoffset - Vertical offset of origin. Default: 0
xoffset - Horizontal offset of origin. Default: 0
yres - Vertical resolution in pixels/mm. Default: 0.0
xres - Horizontal resolution in pixels/mm. Default: 0.0
interpretation - Pixel interpretation. Default: :VIPS_INTERPRETATION_MULTIBAND
coding - Pixel coding. Default: :VIPS_CODING_NONE
format - Pixel format in image. Default: :VIPS_FORMAT_UCHAR
bands - Number of bands in image. Default: 0
height - Image height in pixels. Default: 0
width - Image width in pixels. Default: 0
swap - Swap bytes in image between little and big-endian. Default: false

copy!(in, optional \\ [])

Specs

copy!(Vix.Vips.Image.t(),
  yoffset: integer(),
  xoffset: integer(),
  yres: float(),
  xres: float(),
  interpretation: vips_interpretation(),
  coding: vips_coding(),
  format: vips_band_format(),
  bands: integer(),
  height: integer(),
  width: integer(),
  swap: boolean()
) :: Vix.Vips.Image.t() | no_return()

Same as copy/2, except it returns only the value (not a tuple) and raises on error.

countlines(in, direction, optional \\ [])

Specs

countlines(Vix.Vips.Image.t(), vips_direction(), []) ::
  {:ok, float()} | {:error, term()}

Count lines in an image

arguments
Arguments

in - Input image argument
direction - Countlines left-right or up-down

countlines!(in, direction, optional \\ [])

Specs

countlines!(Vix.Vips.Image.t(), vips_direction(), []) :: float() | no_return()

Same as countlines/3, except it returns only the value (not a tuple) and raises on error.

csvload(filename, optional \\ [])

Specs

csvload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  separator: String.t(),
  whitespace: String.t(),
  lines: integer(),
  skip: integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load csv

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
separator - Set of separator characters. Default: ";,\t"
whitespace - Set of whitespace characters. Default: " "
lines - Read this many lines from the file. Default: 0
skip - Skip this many lines at the start of the file. Default: 0

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

csvload!(filename, optional \\ [])

Specs

csvload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  separator: String.t(),
  whitespace: String.t(),
  lines: integer(),
  skip: integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as csvload/2, except it returns only the value (not a tuple) and raises on error.

csvsave(in, filename, optional \\ [])

Specs

csvsave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  separator: String.t()
) :: :ok | {:error, term()}

Save image to csv

arguments
Arguments

in - Image to save
filename - Filename to save to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
separator - Separator characters. Default: "\t"

csvsave!(in, filename, optional \\ [])

Specs

csvsave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  separator: String.t()
) :: :ok | no_return()

Same as csvsave/3, except it returns only the value (not a tuple) and raises on error.

de00(left, right, optional \\ [])

Specs

de00(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Calculate de00

arguments
Arguments

left - Left-hand input image
right - Right-hand input image

de00!(left, right, optional \\ [])

Specs

de00!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as de00/3, except it returns only the value (not a tuple) and raises on error.

de76(left, right, optional \\ [])

Specs

de76(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Calculate de76

arguments
Arguments

left - Left-hand input image
right - Right-hand input image

de76!(left, right, optional \\ [])

Specs

de76!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as de76/3, except it returns only the value (not a tuple) and raises on error.

decmc(left, right, optional \\ [])

Specs

decmc(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Calculate decmc

arguments
Arguments

left - Left-hand input image
right - Right-hand input image

decmc!(left, right, optional \\ [])

Specs

decmc!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as decmc/3, except it returns only the value (not a tuple) and raises on error.

deviate(in, optional \\ [])

Specs

deviate(Vix.Vips.Image.t(), []) :: {:ok, float()} | {:error, term()}

Find image standard deviation

arguments
Arguments

in - Input image

deviate!(in, optional \\ [])

Specs

deviate!(Vix.Vips.Image.t(), []) :: float() | no_return()

Same as deviate/2, except it returns only the value (not a tuple) and raises on error.

divide(left, right, optional \\ [])

Specs

divide(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Divide two images

arguments
Arguments

left - Left-hand image argument
right - Right-hand image argument

divide!(left, right, optional \\ [])

Specs

divide!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as divide/3, except it returns only the value (not a tuple) and raises on error.

dzsave(in, filename, optional \\ [])

Specs

dzsave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  id: String.t(),
  "no-strip": boolean(),
  "skip-blanks": integer(),
  "region-shrink": vips_region_shrink(),
  compression: integer(),
  properties: boolean(),
  container: vips_foreign_dz_container(),
  angle: vips_angle(),
  depth: vips_foreign_dz_depth(),
  centre: boolean(),
  "tile-width": integer(),
  "tile-height": integer(),
  "tile-size": integer(),
  overlap: integer(),
  suffix: String.t(),
  layout: vips_foreign_dz_layout(),
  basename: String.t(),
  dirname: String.t()
) :: :ok | {:error, term()}

Save image to deepzoom file

arguments
Arguments

in - Image to save
filename - Filename to save to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
id - Resource ID. Default: "https://example.com/iiif"
no-strip - Don't strip tile metadata. Default: false
skip-blanks - Skip tiles which are nearly equal to the background. Default: -1
region-shrink - Method to shrink regions. Default: :VIPS_REGION_SHRINK_MEAN
compression - ZIP deflate compression level. Default: 0
properties - Write a properties file to the output directory. Default: false
container - Pyramid container type. Default: :VIPS_FOREIGN_DZ_CONTAINER_FS
angle - Rotate image during save. Default: :VIPS_ANGLE_D0
depth - Pyramid depth. Default: :VIPS_FOREIGN_DZ_DEPTH_ONEPIXEL
centre - Center image in tile. Default: false
tile-width - Tile width in pixels. Default: 254
tile-height - Tile height in pixels. Default: 254
tile-size - Tile size in pixels. Default: 254
overlap - Tile overlap in pixels. Default: 1
suffix - Filename suffix for tiles. Default: ".jpeg"
layout - Directory layout. Default: :VIPS_FOREIGN_DZ_LAYOUT_DZ
basename - Base name to save to. Default: nil
dirname - Directory name to save to. Default: nil

dzsave!(in, filename, optional \\ [])

Specs

dzsave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  id: String.t(),
  "no-strip": boolean(),
  "skip-blanks": integer(),
  "region-shrink": vips_region_shrink(),
  compression: integer(),
  properties: boolean(),
  container: vips_foreign_dz_container(),
  angle: vips_angle(),
  depth: vips_foreign_dz_depth(),
  centre: boolean(),
  "tile-width": integer(),
  "tile-height": integer(),
  "tile-size": integer(),
  overlap: integer(),
  suffix: String.t(),
  layout: vips_foreign_dz_layout(),
  basename: String.t(),
  dirname: String.t()
) :: :ok | no_return()

Same as dzsave/3, except it returns only the value (not a tuple) and raises on error.

dzsave_buffer(in, optional \\ [])

Specs

dzsave_buffer(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  id: String.t(),
  "no-strip": boolean(),
  "skip-blanks": integer(),
  "region-shrink": vips_region_shrink(),
  compression: integer(),
  properties: boolean(),
  container: vips_foreign_dz_container(),
  angle: vips_angle(),
  depth: vips_foreign_dz_depth(),
  centre: boolean(),
  "tile-width": integer(),
  "tile-height": integer(),
  "tile-size": integer(),
  overlap: integer(),
  suffix: String.t(),
  layout: vips_foreign_dz_layout(),
  basename: String.t(),
  dirname: String.t()
) :: {:ok, binary()} | {:error, term()}

Save image to dz buffer

arguments
Arguments

in - Image to save

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
id - Resource ID. Default: "https://example.com/iiif"
no-strip - Don't strip tile metadata. Default: false
skip-blanks - Skip tiles which are nearly equal to the background. Default: -1
region-shrink - Method to shrink regions. Default: :VIPS_REGION_SHRINK_MEAN
compression - ZIP deflate compression level. Default: 0
properties - Write a properties file to the output directory. Default: false
container - Pyramid container type. Default: :VIPS_FOREIGN_DZ_CONTAINER_FS
angle - Rotate image during save. Default: :VIPS_ANGLE_D0
depth - Pyramid depth. Default: :VIPS_FOREIGN_DZ_DEPTH_ONEPIXEL
centre - Center image in tile. Default: false
tile-width - Tile width in pixels. Default: 254
tile-height - Tile height in pixels. Default: 254
tile-size - Tile size in pixels. Default: 254
overlap - Tile overlap in pixels. Default: 1
suffix - Filename suffix for tiles. Default: ".jpeg"
layout - Directory layout. Default: :VIPS_FOREIGN_DZ_LAYOUT_DZ
basename - Base name to save to. Default: nil
dirname - Directory name to save to. Default: nil

dzsave_buffer!(in, optional \\ [])

Specs

dzsave_buffer!(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  id: String.t(),
  "no-strip": boolean(),
  "skip-blanks": integer(),
  "region-shrink": vips_region_shrink(),
  compression: integer(),
  properties: boolean(),
  container: vips_foreign_dz_container(),
  angle: vips_angle(),
  depth: vips_foreign_dz_depth(),
  centre: boolean(),
  "tile-width": integer(),
  "tile-height": integer(),
  "tile-size": integer(),
  overlap: integer(),
  suffix: String.t(),
  layout: vips_foreign_dz_layout(),
  basename: String.t(),
  dirname: String.t()
) :: binary() | no_return()

Same as dzsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

embed(in, x, y, width, height, optional \\ [])

Specs

embed(Vix.Vips.Image.t(), integer(), integer(), integer(), integer(),
  background: [float()],
  extend: vips_extend()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Embed an image in a larger image

arguments
Arguments

in - Input image
x - Left edge of input in output
y - Top edge of input in output
width - Image width in pixels
height - Image height in pixels

optional
Optional

background - Color for background pixels.
extend - How to generate the extra pixels. Default: :VIPS_EXTEND_BLACK

embed!(in, x, y, width, height, optional \\ [])

Specs

embed!(Vix.Vips.Image.t(), integer(), integer(), integer(), integer(),
  background: [float()],
  extend: vips_extend()
) :: Vix.Vips.Image.t() | no_return()

Same as embed/6, except it returns only the value (not a tuple) and raises on error.

extract_area(input, left, top, width, height, optional \\ [])

Specs

extract_area(Vix.Vips.Image.t(), integer(), integer(), integer(), integer(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Extract an area from an image

arguments
Arguments

input - Input image
left - Left edge of extract area
top - Top edge of extract area
width - Width of extract area
height - Height of extract area

extract_area!(input, left, top, width, height, optional \\ [])

Specs

extract_area!(
  Vix.Vips.Image.t(),
  integer(),
  integer(),
  integer(),
  integer(),
  []
) ::
  Vix.Vips.Image.t() | no_return()

Same as extract_area/6, except it returns only the value (not a tuple) and raises on error.

extract_band(in, band, optional \\ [])

Specs

extract_band(Vix.Vips.Image.t(), integer(), [{:n, integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Extract band from an image

arguments
Arguments

in - Input image
band - Band to extract

optional
Optional

n - Number of bands to extract. Default: 1

extract_band!(in, band, optional \\ [])

Specs

extract_band!(Vix.Vips.Image.t(), integer(), [{:n, integer()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as extract_band/3, except it returns only the value (not a tuple) and raises on error.

eye(width, height, optional \\ [])

Specs

eye(integer(), integer(), factor: float(), uchar: boolean()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make an image showing the eye's spatial response

arguments
Arguments

width - Image width in pixels
height - Image height in pixels

optional
Optional

factor - Maximum spatial frequency. Default: 0.5
uchar - Output an unsigned char image. Default: false

eye!(width, height, optional \\ [])

Specs

eye!(integer(), integer(), factor: float(), uchar: boolean()) ::
  Vix.Vips.Image.t() | no_return()

Same as eye/3, except it returns only the value (not a tuple) and raises on error.

falsecolour(in, optional \\ [])

Specs

falsecolour(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

False-color an image

arguments
Arguments

in - Input image

falsecolour!(in, optional \\ [])

Specs

falsecolour!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as falsecolour/2, except it returns only the value (not a tuple) and raises on error.

fastcor(in, ref, optional \\ [])

Specs

fastcor(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Fast correlation

arguments
Arguments

in - Input image argument
ref - Input reference image

fastcor!(in, ref, optional \\ [])

Specs

fastcor!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as fastcor/3, except it returns only the value (not a tuple) and raises on error.

fill_nearest(in, optional \\ [])

Specs

fill_nearest(Vix.Vips.Image.t(), []) ::
  {:ok, {Vix.Vips.Image.t(), [{:distance, Vix.Vips.Image.t()}]}}
  | {:error, term()}

Fill image zeros with nearest non-zero pixel

arguments
Arguments

in - Input image argument

returns
Returns

Ordered values in the returned tuple

out - Value of nearest non-zero pixel. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

distance - Distance to nearest non-zero pixel. (Vix.Vips.Image.t())

fill_nearest!(in, optional \\ [])

Specs

fill_nearest!(Vix.Vips.Image.t(), []) ::
  {Vix.Vips.Image.t(), [{:distance, Vix.Vips.Image.t()}]} | no_return()

Same as fill_nearest/2, except it returns only the value (not a tuple) and raises on error.

find_trim(in, optional \\ [])

Specs

find_trim(Vix.Vips.Image.t(), background: [float()], threshold: float()) ::
  {:ok, {integer(), integer(), integer(), integer(), []}} | {:error, term()}

Search an image for non-edge areas

arguments
Arguments

in - Image to find_trim

optional
Optional

background - Color for background pixels.
threshold - Object threshold. Default: 10.0

returns
Returns

Ordered values in the returned tuple

left - Left edge of image. (integer())
top - Top edge of extract area. (integer())
width - Width of extract area. (integer())
height - Height of extract area. (integer())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

find_trim!(in, optional \\ [])

Specs

find_trim!(Vix.Vips.Image.t(), background: [float()], threshold: float()) ::
  {integer(), integer(), integer(), integer(), []} | no_return()

Same as find_trim/2, except it returns only the value (not a tuple) and raises on error.

fitsload(filename, optional \\ [])

Specs

fitsload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load a fits image

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

fitsload!(filename, optional \\ [])

Specs

fitsload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as fitsload/2, except it returns only the value (not a tuple) and raises on error.

fitssave(in, filename, optional \\ [])

Specs

fitssave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) :: :ok | {:error, term()}

Save image to fits file

arguments
Arguments

in - Image to save
filename - Filename to save to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false

fitssave!(in, filename, optional \\ [])

Specs

fitssave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) :: :ok | no_return()

Same as fitssave/3, except it returns only the value (not a tuple) and raises on error.

flatten(in, optional \\ [])

Specs

flatten(Vix.Vips.Image.t(), "max-alpha": float(), background: [float()]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Flatten alpha out of an image

arguments
Arguments

in - Input image

optional
Optional

max-alpha - Maximum value of alpha channel. Default: 255.0
background - Background value.

flatten!(in, optional \\ [])

Specs

flatten!(Vix.Vips.Image.t(), "max-alpha": float(), background: [float()]) ::
  Vix.Vips.Image.t() | no_return()

Same as flatten/2, except it returns only the value (not a tuple) and raises on error.

flip(in, direction, optional \\ [])

Specs

flip(Vix.Vips.Image.t(), vips_direction(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Flip an image

arguments
Arguments

in - Input image
direction - Direction to flip image

flip!(in, direction, optional \\ [])

Specs

flip!(Vix.Vips.Image.t(), vips_direction(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as flip/3, except it returns only the value (not a tuple) and raises on error.

float2rad(in, optional \\ [])

Specs

float2rad(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform float rgb to radiance coding

arguments
Arguments

in - Input image

float2rad!(in, optional \\ [])

Specs

float2rad!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as float2rad/2, except it returns only the value (not a tuple) and raises on error.

fractsurf(width, height, fractal-dimension, optional \\ [])

Specs

fractsurf(integer(), integer(), float(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a fractal surface

arguments
Arguments

width - Image width in pixels
height - Image height in pixels
fractal-dimension - Fractal dimension

fractsurf!(width, height, fractal-dimension, optional \\ [])

Specs

fractsurf!(integer(), integer(), float(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as fractsurf/4, except it returns only the value (not a tuple) and raises on error.

freqmult(in, mask, optional \\ [])

Specs

freqmult(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Frequency-domain filtering

arguments
Arguments

in - Input image
mask - Input mask image

freqmult!(in, mask, optional \\ [])

Specs

freqmult!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as freqmult/3, except it returns only the value (not a tuple) and raises on error.

fwfft(in, optional \\ [])

Specs

fwfft(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Forward fft

arguments
Arguments

in - Input image

fwfft!(in, optional \\ [])

Specs

fwfft!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as fwfft/2, except it returns only the value (not a tuple) and raises on error.

gamma(in, optional \\ [])

Specs

gamma(Vix.Vips.Image.t(), [{:exponent, float()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Gamma an image

arguments
Arguments

in - Input image

optional
Optional

exponent - Gamma factor. Default: 2.4

gamma!(in, optional \\ [])

Specs

gamma!(Vix.Vips.Image.t(), [{:exponent, float()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as gamma/2, except it returns only the value (not a tuple) and raises on error.

gaussblur(in, sigma, optional \\ [])

Specs

gaussblur(Vix.Vips.Image.t(), float(),
  precision: vips_precision(),
  "min-ampl": float()
) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Gaussian blur

arguments
Arguments

in - Input image
sigma - Sigma of Gaussian

optional
Optional

precision - Convolve with this precision. Default: :VIPS_PRECISION_INTEGER
min-ampl - Minimum amplitude of Gaussian. Default: 0.2

gaussblur!(in, sigma, optional \\ [])

Specs

gaussblur!(Vix.Vips.Image.t(), float(),
  precision: vips_precision(),
  "min-ampl": float()
) ::
  Vix.Vips.Image.t() | no_return()

Same as gaussblur/3, except it returns only the value (not a tuple) and raises on error.

gaussmat(sigma, min-ampl, optional \\ [])

Specs

gaussmat(float(), float(),
  precision: vips_precision(),
  integer: boolean(),
  separable: boolean()
) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a gaussian image

arguments
Arguments

sigma - Sigma of Gaussian
min-ampl - Minimum amplitude of Gaussian

optional
Optional

precision - Generate with this precision. Default: :VIPS_PRECISION_INTEGER
integer - Generate integer Gaussian. Default: false
separable - Generate separable Gaussian. Default: false

gaussmat!(sigma, min-ampl, optional \\ [])

Specs

gaussmat!(float(), float(),
  precision: vips_precision(),
  integer: boolean(),
  separable: boolean()
) ::
  Vix.Vips.Image.t() | no_return()

Same as gaussmat/3, except it returns only the value (not a tuple) and raises on error.

gaussnoise(width, height, optional \\ [])

Specs

gaussnoise(integer(), integer(), seed: integer(), mean: float(), sigma: float()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a gaussnoise image

arguments
Arguments

width - Image width in pixels
height - Image height in pixels

optional
Optional

seed - Random number seed. Default: 0
mean - Mean of pixels in generated image. Default: 128.0
sigma - Standard deviation of pixels in generated image. Default: 30.0

gaussnoise!(width, height, optional \\ [])

Specs

gaussnoise!(integer(), integer(), seed: integer(), mean: float(), sigma: float()) ::
  Vix.Vips.Image.t() | no_return()

Same as gaussnoise/3, except it returns only the value (not a tuple) and raises on error.

getpoint(in, x, y, optional \\ [])

Specs

getpoint(Vix.Vips.Image.t(), integer(), integer(), []) ::
  {:ok, [float()]} | {:error, term()}

Read a point from an image

arguments
Arguments

in - Input image
x - Point to read
y - Point to read

getpoint!(in, x, y, optional \\ [])

Specs

getpoint!(Vix.Vips.Image.t(), integer(), integer(), []) ::
  [float()] | no_return()

Same as getpoint/4, except it returns only the value (not a tuple) and raises on error.

gifload(filename, optional \\ [])

Specs

gifload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  page: integer(),
  n: integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load gif with libnsgif

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
page - Load this page from the file. Default: 0
n - Load this many pages. Default: 1

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

gifload!(filename, optional \\ [])

Specs

gifload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  page: integer(),
  n: integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as gifload/2, except it returns only the value (not a tuple) and raises on error.

gifload_buffer(buffer, optional \\ [])

Specs

gifload_buffer(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  page: integer(),
  n: integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load gif with libnsgif

arguments
Arguments

buffer - Buffer to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
page - Load this page from the file. Default: 0
n - Load this many pages. Default: 1

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

gifload_buffer!(buffer, optional \\ [])

Specs

gifload_buffer!(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  page: integer(),
  n: integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as gifload_buffer/2, except it returns only the value (not a tuple) and raises on error.

gifsave(in, filename, optional \\ [])

Specs

gifsave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  bitdepth: integer(),
  effort: integer(),
  dither: float()
) :: :ok | {:error, term()}

Save as gif

arguments
Arguments

in - Image to save
filename - Filename to save to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
bitdepth - Number of bits per pixel. Default: 8
effort - Quantisation effort. Default: 7
dither - Amount of dithering. Default: 1.0

gifsave!(in, filename, optional \\ [])

Specs

gifsave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  bitdepth: integer(),
  effort: integer(),
  dither: float()
) :: :ok | no_return()

Same as gifsave/3, except it returns only the value (not a tuple) and raises on error.

gifsave_buffer(in, optional \\ [])

Specs

gifsave_buffer(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  bitdepth: integer(),
  effort: integer(),
  dither: float()
) :: {:ok, binary()} | {:error, term()}

Save as gif

arguments
Arguments

in - Image to save

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
bitdepth - Number of bits per pixel. Default: 8
effort - Quantisation effort. Default: 7
dither - Amount of dithering. Default: 1.0

gifsave_buffer!(in, optional \\ [])

Specs

gifsave_buffer!(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  bitdepth: integer(),
  effort: integer(),
  dither: float()
) :: binary() | no_return()

Same as gifsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

globalbalance(in, optional \\ [])

Specs

globalbalance(Vix.Vips.Image.t(), "int-output": boolean(), gamma: float()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Global balance an image mosaic

arguments
Arguments

in - Input image

optional
Optional

int-output - Integer output. Default: false
gamma - Image gamma. Default: 1.6

globalbalance!(in, optional \\ [])

Specs

globalbalance!(Vix.Vips.Image.t(), "int-output": boolean(), gamma: float()) ::
  Vix.Vips.Image.t() | no_return()

Same as globalbalance/2, except it returns only the value (not a tuple) and raises on error.

gravity(in, direction, width, height, optional \\ [])

Specs

gravity(Vix.Vips.Image.t(), vips_compass_direction(), integer(), integer(),
  background: [float()],
  extend: vips_extend()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Place an image within a larger image with a certain gravity

arguments
Arguments

in - Input image
direction - direction to place image within width/height
width - Image width in pixels
height - Image height in pixels

optional
Optional

background - Color for background pixels.
extend - How to generate the extra pixels. Default: :VIPS_EXTEND_BLACK

gravity!(in, direction, width, height, optional \\ [])

Specs

gravity!(Vix.Vips.Image.t(), vips_compass_direction(), integer(), integer(),
  background: [float()],
  extend: vips_extend()
) :: Vix.Vips.Image.t() | no_return()

Same as gravity/5, except it returns only the value (not a tuple) and raises on error.

grey(width, height, optional \\ [])

Specs

grey(integer(), integer(), [{:uchar, boolean()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a grey ramp image

arguments
Arguments

width - Image width in pixels
height - Image height in pixels

optional
Optional

uchar - Output an unsigned char image. Default: false

grey!(width, height, optional \\ [])

Specs

grey!(integer(), integer(), [{:uchar, boolean()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as grey/3, except it returns only the value (not a tuple) and raises on error.

grid(in, tile-height, across, down, optional \\ [])

Specs

grid(Vix.Vips.Image.t(), integer(), integer(), integer(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Grid an image

arguments
Arguments

in - Input image
tile-height - chop into tiles this high
across - number of tiles across
down - number of tiles down

grid!(in, tile-height, across, down, optional \\ [])

Specs

grid!(Vix.Vips.Image.t(), integer(), integer(), integer(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as grid/5, except it returns only the value (not a tuple) and raises on error.

heifload(filename, optional \\ [])

Specs

heifload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  autorotate: boolean(),
  thumbnail: boolean(),
  n: integer(),
  page: integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load a heif image

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
autorotate - Rotate image using exif orientation. Default: false
thumbnail - Fetch thumbnail image. Default: false
n - Load this many pages. Default: 1
page - Load this page from the file. Default: 0

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

heifload!(filename, optional \\ [])

Specs

heifload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  autorotate: boolean(),
  thumbnail: boolean(),
  n: integer(),
  page: integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as heifload/2, except it returns only the value (not a tuple) and raises on error.

heifload_buffer(buffer, optional \\ [])

Specs

heifload_buffer(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  autorotate: boolean(),
  thumbnail: boolean(),
  n: integer(),
  page: integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load a heif image

arguments
Arguments

buffer - Buffer to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
autorotate - Rotate image using exif orientation. Default: false
thumbnail - Fetch thumbnail image. Default: false
n - Load this many pages. Default: 1
page - Load this page from the file. Default: 0

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

heifload_buffer!(buffer, optional \\ [])

Specs

heifload_buffer!(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  autorotate: boolean(),
  thumbnail: boolean(),
  n: integer(),
  page: integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as heifload_buffer/2, except it returns only the value (not a tuple) and raises on error.

heifsave(in, filename, optional \\ [])

Specs

heifsave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  speed: integer(),
  "subsample-mode": vips_foreign_subsample(),
  effort: integer(),
  compression: vips_foreign_heif_compression(),
  lossless: boolean(),
  Q: integer()
) :: :ok | {:error, term()}

Save image in heif format

arguments
Arguments

in - Image to save
filename - Filename to save to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
speed - CPU effort. Default: 5
subsample-mode - Select chroma subsample operation mode. Default: :VIPS_FOREIGN_SUBSAMPLE_AUTO
effort - CPU effort. Default: 4
compression - Compression format. Default: :VIPS_FOREIGN_HEIF_COMPRESSION_HEVC
lossless - Enable lossless compression. Default: false
Q - Q factor. Default: 50

heifsave!(in, filename, optional \\ [])

Specs

heifsave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  speed: integer(),
  "subsample-mode": vips_foreign_subsample(),
  effort: integer(),
  compression: vips_foreign_heif_compression(),
  lossless: boolean(),
  Q: integer()
) :: :ok | no_return()

Same as heifsave/3, except it returns only the value (not a tuple) and raises on error.

heifsave_buffer(in, optional \\ [])

Specs

heifsave_buffer(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  speed: integer(),
  "subsample-mode": vips_foreign_subsample(),
  effort: integer(),
  compression: vips_foreign_heif_compression(),
  lossless: boolean(),
  Q: integer()
) :: {:ok, binary()} | {:error, term()}

Save image in heif format

arguments
Arguments

in - Image to save

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
speed - CPU effort. Default: 5
subsample-mode - Select chroma subsample operation mode. Default: :VIPS_FOREIGN_SUBSAMPLE_AUTO
effort - CPU effort. Default: 4
compression - Compression format. Default: :VIPS_FOREIGN_HEIF_COMPRESSION_HEVC
lossless - Enable lossless compression. Default: false
Q - Q factor. Default: 50

heifsave_buffer!(in, optional \\ [])

Specs

heifsave_buffer!(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  speed: integer(),
  "subsample-mode": vips_foreign_subsample(),
  effort: integer(),
  compression: vips_foreign_heif_compression(),
  lossless: boolean(),
  Q: integer()
) :: binary() | no_return()

Same as heifsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

hist_cum(in, optional \\ [])

Specs

hist_cum(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Form cumulative histogram

arguments
Arguments

in - Input image

hist_cum!(in, optional \\ [])

Specs

hist_cum!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as hist_cum/2, except it returns only the value (not a tuple) and raises on error.

hist_entropy(in, optional \\ [])

Specs

hist_entropy(Vix.Vips.Image.t(), []) :: {:ok, float()} | {:error, term()}

Estimate image entropy

arguments
Arguments

in - Input histogram image

hist_entropy!(in, optional \\ [])

Specs

hist_entropy!(Vix.Vips.Image.t(), []) :: float() | no_return()

Same as hist_entropy/2, except it returns only the value (not a tuple) and raises on error.

hist_equal(in, optional \\ [])

Specs

hist_equal(Vix.Vips.Image.t(), [{:band, integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Histogram equalisation

arguments
Arguments

in - Input image

optional
Optional

band - Equalise with this band. Default: -1

hist_equal!(in, optional \\ [])

Specs

hist_equal!(Vix.Vips.Image.t(), [{:band, integer()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as hist_equal/2, except it returns only the value (not a tuple) and raises on error.

hist_find(in, optional \\ [])

Specs

hist_find(Vix.Vips.Image.t(), [{:band, integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Find image histogram

arguments
Arguments

in - Input image

optional
Optional

band - Find histogram of band. Default: -1

hist_find!(in, optional \\ [])

Specs

hist_find!(Vix.Vips.Image.t(), [{:band, integer()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as hist_find/2, except it returns only the value (not a tuple) and raises on error.

hist_find_indexed(in, index, optional \\ [])

Specs

hist_find_indexed(Vix.Vips.Image.t(), Vix.Vips.Image.t(), [
  {:combine, vips_combine()}
]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Find indexed image histogram

arguments
Arguments

in - Input image
index - Index image

optional
Optional

combine - Combine bins like this. Default: :VIPS_COMBINE_SUM

hist_find_indexed!(in, index, optional \\ [])

Specs

hist_find_indexed!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), [
  {:combine, vips_combine()}
]) ::
  Vix.Vips.Image.t() | no_return()

Same as hist_find_indexed/3, except it returns only the value (not a tuple) and raises on error.

hist_find_ndim(in, optional \\ [])

Specs

hist_find_ndim(Vix.Vips.Image.t(), [{:bins, integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Find n-dimensional image histogram

arguments
Arguments

in - Input image

optional
Optional

bins - Number of bins in each dimension. Default: 10

hist_find_ndim!(in, optional \\ [])

Specs

hist_find_ndim!(Vix.Vips.Image.t(), [{:bins, integer()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as hist_find_ndim/2, except it returns only the value (not a tuple) and raises on error.

hist_ismonotonic(in, optional \\ [])

Specs

hist_ismonotonic(Vix.Vips.Image.t(), []) :: {:ok, boolean()} | {:error, term()}

Test for monotonicity

arguments
Arguments

in - Input histogram image

hist_ismonotonic!(in, optional \\ [])

Specs

hist_ismonotonic!(Vix.Vips.Image.t(), []) :: boolean() | no_return()

Same as hist_ismonotonic/2, except it returns only the value (not a tuple) and raises on error.

hist_local(in, width, height, optional \\ [])

Specs

hist_local(Vix.Vips.Image.t(), integer(), integer(), [{:"max-slope", integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Local histogram equalisation

arguments
Arguments

in - Input image
width - Window width in pixels
height - Window height in pixels

optional
Optional

max-slope - Maximum slope (CLAHE). Default: 0

hist_local!(in, width, height, optional \\ [])

Specs

hist_local!(Vix.Vips.Image.t(), integer(), integer(), [
  {:"max-slope", integer()}
]) ::
  Vix.Vips.Image.t() | no_return()

Same as hist_local/4, except it returns only the value (not a tuple) and raises on error.

hist_match(in, ref, optional \\ [])

Specs

hist_match(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Match two histograms

arguments
Arguments

in - Input histogram
ref - Reference histogram

hist_match!(in, ref, optional \\ [])

Specs

hist_match!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as hist_match/3, except it returns only the value (not a tuple) and raises on error.

hist_norm(in, optional \\ [])

Specs

hist_norm(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Normalise histogram

arguments
Arguments

in - Input image

hist_norm!(in, optional \\ [])

Specs

hist_norm!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as hist_norm/2, except it returns only the value (not a tuple) and raises on error.

hist_plot(in, optional \\ [])

Specs

hist_plot(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Plot histogram

arguments
Arguments

in - Input image

hist_plot!(in, optional \\ [])

Specs

hist_plot!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as hist_plot/2, except it returns only the value (not a tuple) and raises on error.

hough_circle(in, optional \\ [])

Specs

hough_circle(Vix.Vips.Image.t(),
  "max-radius": integer(),
  "min-radius": integer(),
  scale: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Find hough circle transform

arguments
Arguments

in - Input image

optional
Optional

max-radius - Largest radius to search for. Default: 20
min-radius - Smallest radius to search for. Default: 10
scale - Scale down dimensions by this factor. Default: 3

hough_circle!(in, optional \\ [])

Specs

hough_circle!(Vix.Vips.Image.t(),
  "max-radius": integer(),
  "min-radius": integer(),
  scale: integer()
) :: Vix.Vips.Image.t() | no_return()

Same as hough_circle/2, except it returns only the value (not a tuple) and raises on error.

hough_line(in, optional \\ [])

Specs

hough_line(Vix.Vips.Image.t(), height: integer(), width: integer()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Find hough line transform

arguments
Arguments

in - Input image

optional
Optional

height - Vertical size of parameter space. Default: 256
width - horizontal size of parameter space. Default: 256

hough_line!(in, optional \\ [])

Specs

hough_line!(Vix.Vips.Image.t(), height: integer(), width: integer()) ::
  Vix.Vips.Image.t() | no_return()

Same as hough_line/2, except it returns only the value (not a tuple) and raises on error.

hsv2srgb(in, optional \\ [])

Specs

hsv2srgb(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform hsv to srgb

arguments
Arguments

in - Input image

hsv2srgb!(in, optional \\ [])

Specs

hsv2srgb!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as hsv2srgb/2, except it returns only the value (not a tuple) and raises on error.

icc_export(in, optional \\ [])

Specs

icc_export(Vix.Vips.Image.t(),
  depth: integer(),
  "output-profile": String.t(),
  "black-point-compensation": boolean(),
  intent: vips_intent(),
  pcs: vips_pcs()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Output to device with icc profile

arguments
Arguments

in - Input image

optional
Optional

depth - Output device space depth in bits. Default: 8
output-profile - Filename to load output profile from. Default: nil
black-point-compensation - Enable black point compensation. Default: false
intent - Rendering intent. Default: :VIPS_INTENT_RELATIVE
pcs - Set Profile Connection Space. Default: :VIPS_PCS_LAB

icc_export!(in, optional \\ [])

Specs

icc_export!(Vix.Vips.Image.t(),
  depth: integer(),
  "output-profile": String.t(),
  "black-point-compensation": boolean(),
  intent: vips_intent(),
  pcs: vips_pcs()
) :: Vix.Vips.Image.t() | no_return()

Same as icc_export/2, except it returns only the value (not a tuple) and raises on error.

icc_import(in, optional \\ [])

Specs

icc_import(Vix.Vips.Image.t(),
  "input-profile": String.t(),
  embedded: boolean(),
  "black-point-compensation": boolean(),
  intent: vips_intent(),
  pcs: vips_pcs()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Import from device with icc profile

arguments
Arguments

in - Input image

optional
Optional

input-profile - Filename to load input profile from. Default: nil
embedded - Use embedded input profile, if available. Default: false
black-point-compensation - Enable black point compensation. Default: false
intent - Rendering intent. Default: :VIPS_INTENT_RELATIVE
pcs - Set Profile Connection Space. Default: :VIPS_PCS_LAB

icc_import!(in, optional \\ [])

Specs

icc_import!(Vix.Vips.Image.t(),
  "input-profile": String.t(),
  embedded: boolean(),
  "black-point-compensation": boolean(),
  intent: vips_intent(),
  pcs: vips_pcs()
) :: Vix.Vips.Image.t() | no_return()

Same as icc_import/2, except it returns only the value (not a tuple) and raises on error.

icc_transform(in, output-profile, optional \\ [])

Specs

icc_transform(Vix.Vips.Image.t(), String.t(),
  depth: integer(),
  "input-profile": String.t(),
  embedded: boolean(),
  "black-point-compensation": boolean(),
  intent: vips_intent(),
  pcs: vips_pcs()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform between devices with icc profiles

arguments
Arguments

in - Input image
output-profile - Filename to load output profile from

optional
Optional

depth - Output device space depth in bits. Default: 8
input-profile - Filename to load input profile from. Default: nil
embedded - Use embedded input profile, if available. Default: false
black-point-compensation - Enable black point compensation. Default: false
intent - Rendering intent. Default: :VIPS_INTENT_RELATIVE
pcs - Set Profile Connection Space. Default: :VIPS_PCS_LAB

icc_transform!(in, output-profile, optional \\ [])

Specs

icc_transform!(Vix.Vips.Image.t(), String.t(),
  depth: integer(),
  "input-profile": String.t(),
  embedded: boolean(),
  "black-point-compensation": boolean(),
  intent: vips_intent(),
  pcs: vips_pcs()
) :: Vix.Vips.Image.t() | no_return()

Same as icc_transform/3, except it returns only the value (not a tuple) and raises on error.

identity(optional \\ [])

Specs

identity(size: integer(), ushort: boolean(), bands: integer()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a 1d image where pixel values are indexes

arguments
Arguments

optional
Optional

size - Size of 16-bit LUT. Default: 65536
ushort - Create a 16-bit LUT. Default: false
bands - Number of bands in LUT. Default: 1

identity!(optional \\ [])

Specs

identity!(size: integer(), ushort: boolean(), bands: integer()) ::
  Vix.Vips.Image.t() | no_return()

Same as identity/1, except it returns only the value (not a tuple) and raises on error.

ifthenelse(cond, in1, in2, optional \\ [])

Specs

ifthenelse(Vix.Vips.Image.t(), Vix.Vips.Image.t(), Vix.Vips.Image.t(), [
  {:blend, boolean()}
]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Ifthenelse an image

arguments
Arguments

cond - Condition input image
in1 - Source for TRUE pixels
in2 - Source for FALSE pixels

optional
Optional

blend - Blend smoothly between then and else parts. Default: false

ifthenelse!(cond, in1, in2, optional \\ [])

Specs

ifthenelse!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), Vix.Vips.Image.t(), [
  {:blend, boolean()}
]) ::
  Vix.Vips.Image.t() | no_return()

Same as ifthenelse/4, except it returns only the value (not a tuple) and raises on error.

insert(main, sub, x, y, optional \\ [])

Specs

insert(Vix.Vips.Image.t(), Vix.Vips.Image.t(), integer(), integer(),
  background: [float()],
  expand: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

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

arguments
Arguments

main - Main input image
sub - Sub-image to insert into main image
x - Left edge of sub in main
y - Top edge of sub in main

optional
Optional

background - Color for new pixels.
expand - Expand output to hold all of both inputs. Default: false

insert!(main, sub, x, y, optional \\ [])

Specs

insert!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), integer(), integer(),
  background: [float()],
  expand: boolean()
) :: Vix.Vips.Image.t() | no_return()

Same as insert/5, except it returns only the value (not a tuple) and raises on error.

invert(in, optional \\ [])

Specs

invert(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Invert an image

arguments
Arguments

in - Input image

invert!(in, optional \\ [])

Specs

invert!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as invert/2, except it returns only the value (not a tuple) and raises on error.

invertlut(in, optional \\ [])

Specs

invertlut(Vix.Vips.Image.t(), [{:size, integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Build an inverted look-up table

arguments
Arguments

in - Matrix of XY coordinates

optional
Optional

size - LUT size to generate. Default: 256

invertlut!(in, optional \\ [])

Specs

invertlut!(Vix.Vips.Image.t(), [{:size, integer()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as invertlut/2, except it returns only the value (not a tuple) and raises on error.

invfft(in, optional \\ [])

Specs

invfft(Vix.Vips.Image.t(), [{:real, boolean()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Inverse fft

arguments
Arguments

in - Input image

optional
Optional

real - Output only the real part of the transform. Default: false

invfft!(in, optional \\ [])

Specs

invfft!(Vix.Vips.Image.t(), [{:real, boolean()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as invfft/2, except it returns only the value (not a tuple) and raises on error.

join(in1, in2, direction, optional \\ [])

Specs

join(Vix.Vips.Image.t(), Vix.Vips.Image.t(), vips_direction(),
  align: vips_align(),
  background: [float()],
  shim: integer(),
  expand: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Join a pair of images

arguments
Arguments

in1 - First input image
in2 - Second input image
direction - Join left-right or up-down

optional
Optional

align - Align on the low, centre or high coordinate edge. Default: :VIPS_ALIGN_LOW
background - Colour for new pixels.
shim - Pixels between images. Default: 0
expand - Expand output to hold all of both inputs. Default: false

join!(in1, in2, direction, optional \\ [])

Specs

join!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), vips_direction(),
  align: vips_align(),
  background: [float()],
  shim: integer(),
  expand: boolean()
) :: Vix.Vips.Image.t() | no_return()

Same as join/4, except it returns only the value (not a tuple) and raises on error.

jp2kload(filename, optional \\ [])

Specs

jp2kload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  page: integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load jpeg2000 image

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
page - Load this page from the image. Default: 0

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

jp2kload!(filename, optional \\ [])

Specs

jp2kload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  page: integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as jp2kload/2, except it returns only the value (not a tuple) and raises on error.

jp2kload_buffer(buffer, optional \\ [])

Specs

jp2kload_buffer(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  page: integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load jpeg2000 image

arguments
Arguments

buffer - Buffer to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
page - Load this page from the image. Default: 0

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

jp2kload_buffer!(buffer, optional \\ [])

Specs

jp2kload_buffer!(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  page: integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as jp2kload_buffer/2, except it returns only the value (not a tuple) and raises on error.

jp2ksave(in, filename, optional \\ [])

Specs

jp2ksave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "subsample-mode": vips_foreign_subsample(),
  Q: integer(),
  lossless: boolean(),
  "tile-height": integer(),
  "tile-width": integer()
) :: :ok | {:error, term()}

Save image in jpeg2000 format

arguments
Arguments

in - Image to save
filename - Filename to load from

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
subsample-mode - Select chroma subsample operation mode. Default: :VIPS_FOREIGN_SUBSAMPLE_AUTO
Q - Q factor. Default: 48
lossless - Enable lossless compression. Default: false
tile-height - Tile height in pixels. Default: 512
tile-width - Tile width in pixels. Default: 512

jp2ksave!(in, filename, optional \\ [])

Specs

jp2ksave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "subsample-mode": vips_foreign_subsample(),
  Q: integer(),
  lossless: boolean(),
  "tile-height": integer(),
  "tile-width": integer()
) :: :ok | no_return()

Same as jp2ksave/3, except it returns only the value (not a tuple) and raises on error.

jp2ksave_buffer(in, optional \\ [])

Specs

jp2ksave_buffer(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "subsample-mode": vips_foreign_subsample(),
  Q: integer(),
  lossless: boolean(),
  "tile-height": integer(),
  "tile-width": integer()
) :: {:ok, binary()} | {:error, term()}

Save image in jpeg2000 format

arguments
Arguments

in - Image to save

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
subsample-mode - Select chroma subsample operation mode. Default: :VIPS_FOREIGN_SUBSAMPLE_AUTO
Q - Q factor. Default: 48
lossless - Enable lossless compression. Default: false
tile-height - Tile height in pixels. Default: 512
tile-width - Tile width in pixels. Default: 512

jp2ksave_buffer!(in, optional \\ [])

Specs

jp2ksave_buffer!(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "subsample-mode": vips_foreign_subsample(),
  Q: integer(),
  lossless: boolean(),
  "tile-height": integer(),
  "tile-width": integer()
) :: binary() | no_return()

Same as jp2ksave_buffer/2, except it returns only the value (not a tuple) and raises on error.

jpegload(filename, optional \\ [])

Specs

jpegload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  autorotate: boolean(),
  shrink: integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load jpeg from file

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
autorotate - Rotate image using exif orientation. Default: false
shrink - Shrink factor on load. Default: 1

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

jpegload!(filename, optional \\ [])

Specs

jpegload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  autorotate: boolean(),
  shrink: integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as jpegload/2, except it returns only the value (not a tuple) and raises on error.

jpegload_buffer(buffer, optional \\ [])

Specs

jpegload_buffer(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  autorotate: boolean(),
  shrink: integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load jpeg from buffer

arguments
Arguments

buffer - Buffer to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
autorotate - Rotate image using exif orientation. Default: false
shrink - Shrink factor on load. Default: 1

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

jpegload_buffer!(buffer, optional \\ [])

Specs

jpegload_buffer!(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  autorotate: boolean(),
  shrink: integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as jpegload_buffer/2, except it returns only the value (not a tuple) and raises on error.

jpegsave(in, filename, optional \\ [])

Specs

jpegsave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "restart-interval": integer(),
  "subsample-mode": vips_foreign_subsample(),
  "quant-table": integer(),
  "optimize-scans": boolean(),
  "overshoot-deringing": boolean(),
  "trellis-quant": boolean(),
  "no-subsample": boolean(),
  interlace: boolean(),
  "optimize-coding": boolean(),
  profile: String.t(),
  Q: integer()
) :: :ok | {:error, term()}

Save image to jpeg file

arguments
Arguments

in - Image to save
filename - Filename to save to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
restart-interval - Add restart markers every specified number of mcu. Default: 0
subsample-mode - Select chroma subsample operation mode. Default: :VIPS_FOREIGN_SUBSAMPLE_AUTO
quant-table - Use predefined quantization table with given index. Default: 0
optimize-scans - Split spectrum of DCT coefficients into separate scans. Default: false
overshoot-deringing - Apply overshooting to samples with extreme values. Default: false
trellis-quant - Apply trellis quantisation to each 8x8 block. Default: false
no-subsample - Disable chroma subsample. Default: false
interlace - Generate an interlaced (progressive) jpeg. Default: false
optimize-coding - Compute optimal Huffman coding tables. Default: false
profile - ICC profile to embed. Default: nil
Q - Q factor. Default: 75

jpegsave!(in, filename, optional \\ [])

Specs

jpegsave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "restart-interval": integer(),
  "subsample-mode": vips_foreign_subsample(),
  "quant-table": integer(),
  "optimize-scans": boolean(),
  "overshoot-deringing": boolean(),
  "trellis-quant": boolean(),
  "no-subsample": boolean(),
  interlace: boolean(),
  "optimize-coding": boolean(),
  profile: String.t(),
  Q: integer()
) :: :ok | no_return()

Same as jpegsave/3, except it returns only the value (not a tuple) and raises on error.

jpegsave_buffer(in, optional \\ [])

Specs

jpegsave_buffer(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "restart-interval": integer(),
  "subsample-mode": vips_foreign_subsample(),
  "quant-table": integer(),
  "optimize-scans": boolean(),
  "overshoot-deringing": boolean(),
  "trellis-quant": boolean(),
  "no-subsample": boolean(),
  interlace: boolean(),
  "optimize-coding": boolean(),
  profile: String.t(),
  Q: integer()
) :: {:ok, binary()} | {:error, term()}

Save image to jpeg buffer

arguments
Arguments

in - Image to save

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
restart-interval - Add restart markers every specified number of mcu. Default: 0
subsample-mode - Select chroma subsample operation mode. Default: :VIPS_FOREIGN_SUBSAMPLE_AUTO
quant-table - Use predefined quantization table with given index. Default: 0
optimize-scans - Split spectrum of DCT coefficients into separate scans. Default: false
overshoot-deringing - Apply overshooting to samples with extreme values. Default: false
trellis-quant - Apply trellis quantisation to each 8x8 block. Default: false
no-subsample - Disable chroma subsample. Default: false
interlace - Generate an interlaced (progressive) jpeg. Default: false
optimize-coding - Compute optimal Huffman coding tables. Default: false
profile - ICC profile to embed. Default: nil
Q - Q factor. Default: 75

jpegsave_buffer!(in, optional \\ [])

Specs

jpegsave_buffer!(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "restart-interval": integer(),
  "subsample-mode": vips_foreign_subsample(),
  "quant-table": integer(),
  "optimize-scans": boolean(),
  "overshoot-deringing": boolean(),
  "trellis-quant": boolean(),
  "no-subsample": boolean(),
  interlace: boolean(),
  "optimize-coding": boolean(),
  profile: String.t(),
  Q: integer()
) :: binary() | no_return()

Same as jpegsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

jpegsave_mime(in, optional \\ [])

Specs

jpegsave_mime(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "restart-interval": integer(),
  "subsample-mode": vips_foreign_subsample(),
  "quant-table": integer(),
  "optimize-scans": boolean(),
  "overshoot-deringing": boolean(),
  "trellis-quant": boolean(),
  "no-subsample": boolean(),
  interlace: boolean(),
  "optimize-coding": boolean(),
  profile: String.t(),
  Q: integer()
) :: :ok | {:error, term()}

Save image to jpeg mime

arguments
Arguments

in - Image to save

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
restart-interval - Add restart markers every specified number of mcu. Default: 0
subsample-mode - Select chroma subsample operation mode. Default: :VIPS_FOREIGN_SUBSAMPLE_AUTO
quant-table - Use predefined quantization table with given index. Default: 0
optimize-scans - Split spectrum of DCT coefficients into separate scans. Default: false
overshoot-deringing - Apply overshooting to samples with extreme values. Default: false
trellis-quant - Apply trellis quantisation to each 8x8 block. Default: false
no-subsample - Disable chroma subsample. Default: false
interlace - Generate an interlaced (progressive) jpeg. Default: false
optimize-coding - Compute optimal Huffman coding tables. Default: false
profile - ICC profile to embed. Default: nil
Q - Q factor. Default: 75

jpegsave_mime!(in, optional \\ [])

Specs

jpegsave_mime!(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "restart-interval": integer(),
  "subsample-mode": vips_foreign_subsample(),
  "quant-table": integer(),
  "optimize-scans": boolean(),
  "overshoot-deringing": boolean(),
  "trellis-quant": boolean(),
  "no-subsample": boolean(),
  interlace: boolean(),
  "optimize-coding": boolean(),
  profile: String.t(),
  Q: integer()
) :: :ok | no_return()

Same as jpegsave_mime/2, except it returns only the value (not a tuple) and raises on error.

jxlload(filename, optional \\ [])

Specs

jxlload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load jpeg-xl image

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

jxlload!(filename, optional \\ [])

Specs

jxlload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as jxlload/2, except it returns only the value (not a tuple) and raises on error.

jxlload_buffer(buffer, optional \\ [])

Specs

jxlload_buffer(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load jpeg-xl image

arguments
Arguments

buffer - Buffer to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

jxlload_buffer!(buffer, optional \\ [])

Specs

jxlload_buffer!(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as jxlload_buffer/2, except it returns only the value (not a tuple) and raises on error.

jxlsave(in, filename, optional \\ [])

Specs

jxlsave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  Q: integer(),
  lossless: boolean(),
  effort: integer(),
  distance: float(),
  tier: integer()
) :: :ok | {:error, term()}

Save image in jpeg-xl format

arguments
Arguments

in - Image to save
filename - Filename to load from

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
Q - Quality factor. Default: 75
lossless - Enable lossless compression. Default: false
effort - Encoding effort. Default: 7
distance - Target butteraugli distance. Default: 1.0
tier - Decode speed tier. Default: 0

jxlsave!(in, filename, optional \\ [])

Specs

jxlsave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  Q: integer(),
  lossless: boolean(),
  effort: integer(),
  distance: float(),
  tier: integer()
) :: :ok | no_return()

Same as jxlsave/3, except it returns only the value (not a tuple) and raises on error.

jxlsave_buffer(in, optional \\ [])

Specs

jxlsave_buffer(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  Q: integer(),
  lossless: boolean(),
  effort: integer(),
  distance: float(),
  tier: integer()
) :: {:ok, binary()} | {:error, term()}

Save image in jpeg-xl format

arguments
Arguments

in - Image to save

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
Q - Quality factor. Default: 75
lossless - Enable lossless compression. Default: false
effort - Encoding effort. Default: 7
distance - Target butteraugli distance. Default: 1.0
tier - Decode speed tier. Default: 0

jxlsave_buffer!(in, optional \\ [])

Specs

jxlsave_buffer!(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  Q: integer(),
  lossless: boolean(),
  effort: integer(),
  distance: float(),
  tier: integer()
) :: binary() | no_return()

Same as jxlsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

lab2labq(in, optional \\ [])

Specs

lab2labq(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform float lab to labq coding

arguments
Arguments

in - Input image

lab2labq!(in, optional \\ [])

Specs

lab2labq!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as lab2labq/2, except it returns only the value (not a tuple) and raises on error.

lab2labs(in, optional \\ [])

Specs

lab2labs(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform float lab to signed short

arguments
Arguments

in - Input image

lab2labs!(in, optional \\ [])

Specs

lab2labs!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as lab2labs/2, except it returns only the value (not a tuple) and raises on error.

lab2lch(in, optional \\ [])

Specs

lab2lch(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform lab to lch

arguments
Arguments

in - Input image

lab2lch!(in, optional \\ [])

Specs

lab2lch!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as lab2lch/2, except it returns only the value (not a tuple) and raises on error.

lab2xyz(in, optional \\ [])

Specs

lab2xyz(Vix.Vips.Image.t(), [{:temp, [float()]}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform cielab to xyz

arguments
Arguments

in - Input image

optional
Optional

temp - Color temperature.

lab2xyz!(in, optional \\ [])

Specs

lab2xyz!(Vix.Vips.Image.t(), [{:temp, [float()]}]) ::
  Vix.Vips.Image.t() | no_return()

Same as lab2xyz/2, except it returns only the value (not a tuple) and raises on error.

labelregions(in, optional \\ [])

Specs

labelregions(Vix.Vips.Image.t(), []) ::
  {:ok, {Vix.Vips.Image.t(), [{:segments, integer()}]}} | {:error, term()}

Label regions in an image

arguments
Arguments

in - Input image argument

returns
Returns

Ordered values in the returned tuple

mask - Mask of region labels. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

segments - Number of discrete contigious regions. (integer())

labelregions!(in, optional \\ [])

Specs

labelregions!(Vix.Vips.Image.t(), []) ::
  {Vix.Vips.Image.t(), [{:segments, integer()}]} | no_return()

Same as labelregions/2, except it returns only the value (not a tuple) and raises on error.

labq2lab(in, optional \\ [])

Specs

labq2lab(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Unpack a labq image to float lab

arguments
Arguments

in - Input image

labq2lab!(in, optional \\ [])

Specs

labq2lab!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as labq2lab/2, except it returns only the value (not a tuple) and raises on error.

labq2labs(in, optional \\ [])

Specs

labq2labs(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Unpack a labq image to short lab

arguments
Arguments

in - Input image

labq2labs!(in, optional \\ [])

Specs

labq2labs!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as labq2labs/2, except it returns only the value (not a tuple) and raises on error.

labq2srgb(in, optional \\ [])

Specs

labq2srgb(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Convert a labq image to srgb

arguments
Arguments

in - Input image

labq2srgb!(in, optional \\ [])

Specs

labq2srgb!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as labq2srgb/2, except it returns only the value (not a tuple) and raises on error.

labs2lab(in, optional \\ [])

Specs

labs2lab(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform signed short lab to float

arguments
Arguments

in - Input image

labs2lab!(in, optional \\ [])

Specs

labs2lab!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as labs2lab/2, except it returns only the value (not a tuple) and raises on error.

labs2labq(in, optional \\ [])

Specs

labs2labq(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform short lab to labq coding

arguments
Arguments

in - Input image

labs2labq!(in, optional \\ [])

Specs

labs2labq!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as labs2labq/2, except it returns only the value (not a tuple) and raises on error.

lch2cmc(in, optional \\ [])

Specs

lch2cmc(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform lch to cmc

arguments
Arguments

in - Input image

lch2cmc!(in, optional \\ [])

Specs

lch2cmc!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as lch2cmc/2, except it returns only the value (not a tuple) and raises on error.

lch2lab(in, optional \\ [])

Specs

lch2lab(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform lch to lab

arguments
Arguments

in - Input image

lch2lab!(in, optional \\ [])

Specs

lch2lab!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as lch2lab/2, except it returns only the value (not a tuple) and raises on error.

linear(in, a, b, optional \\ [])

Specs

linear(Vix.Vips.Image.t(), [float()], [float()], [{:uchar, boolean()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Calculate (a * in + b)

arguments
Arguments

in - Input image
a - Multiply by this
b - Add this

optional
Optional

uchar - Output should be uchar. Default: false

linear!(in, a, b, optional \\ [])

Specs

linear!(Vix.Vips.Image.t(), [float()], [float()], [{:uchar, boolean()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as linear/4, except it returns only the value (not a tuple) and raises on error.

linecache(in, optional \\ [])

Specs

linecache(Vix.Vips.Image.t(),
  persistent: boolean(),
  threaded: boolean(),
  access: vips_access(),
  "tile-height": integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Cache an image as a set of lines

arguments
Arguments

in - Input image

optional
Optional

persistent - Keep cache between evaluations. Default: false
threaded - Allow threaded access. Default: false
access - Expected access pattern. Default: :VIPS_ACCESS_RANDOM
tile-height - Tile height in pixels. Default: 128

linecache!(in, optional \\ [])

Specs

linecache!(Vix.Vips.Image.t(),
  persistent: boolean(),
  threaded: boolean(),
  access: vips_access(),
  "tile-height": integer()
) :: Vix.Vips.Image.t() | no_return()

Same as linecache/2, except it returns only the value (not a tuple) and raises on error.

logmat(sigma, min-ampl, optional \\ [])

Specs

logmat(float(), float(),
  precision: vips_precision(),
  integer: boolean(),
  separable: boolean()
) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a laplacian of gaussian image

arguments
Arguments

sigma - Radius of Gaussian
min-ampl - Minimum amplitude of Gaussian

optional
Optional

precision - Generate with this precision. Default: :VIPS_PRECISION_INTEGER
integer - Generate integer Gaussian. Default: false
separable - Generate separable Gaussian. Default: false

logmat!(sigma, min-ampl, optional \\ [])

Specs

logmat!(float(), float(),
  precision: vips_precision(),
  integer: boolean(),
  separable: boolean()
) ::
  Vix.Vips.Image.t() | no_return()

Same as logmat/3, except it returns only the value (not a tuple) and raises on error.

magickload(filename, optional \\ [])

Specs

magickload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  "all-frames": boolean(),
  n: integer(),
  page: integer(),
  density: String.t()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load file with imagemagick7

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
all-frames - Read all frames from an image. Default: false
n - Load this many pages. Default: 1
page - Load this page from the file. Default: 0
density - Canvas resolution for rendering vector formats like SVG. Default: nil

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

magickload!(filename, optional \\ [])

Specs

magickload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  "all-frames": boolean(),
  n: integer(),
  page: integer(),
  density: String.t()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as magickload/2, except it returns only the value (not a tuple) and raises on error.

magickload_buffer(buffer, optional \\ [])

Specs

magickload_buffer(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  "all-frames": boolean(),
  n: integer(),
  page: integer(),
  density: String.t()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load buffer with imagemagick7

arguments
Arguments

buffer - Buffer to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
all-frames - Read all frames from an image. Default: false
n - Load this many pages. Default: 1
page - Load this page from the file. Default: 0
density - Canvas resolution for rendering vector formats like SVG. Default: nil

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

magickload_buffer!(buffer, optional \\ [])

Specs

magickload_buffer!(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  "all-frames": boolean(),
  n: integer(),
  page: integer(),
  density: String.t()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as magickload_buffer/2, except it returns only the value (not a tuple) and raises on error.

magicksave(in, filename, optional \\ [])

Specs

magicksave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "optimize-gif-transparency": boolean(),
  "optimize-gif-frames": boolean(),
  quality: integer(),
  format: String.t()
) :: :ok | {:error, term()}

Save file with imagemagick

arguments
Arguments

in - Image to save
filename - Filename to save to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
optimize-gif-transparency - Apply GIF transparency optimization. Default: false
optimize-gif-frames - Apply GIF frames optimization. Default: false
quality - Quality to use. Default: 0
format - Format to save in. Default: nil

magicksave!(in, filename, optional \\ [])

Specs

magicksave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "optimize-gif-transparency": boolean(),
  "optimize-gif-frames": boolean(),
  quality: integer(),
  format: String.t()
) :: :ok | no_return()

Same as magicksave/3, except it returns only the value (not a tuple) and raises on error.

magicksave_buffer(in, optional \\ [])

Specs

magicksave_buffer(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "optimize-gif-transparency": boolean(),
  "optimize-gif-frames": boolean(),
  quality: integer(),
  format: String.t()
) :: {:ok, binary()} | {:error, term()}

Save image to magick buffer

arguments
Arguments

in - Image to save

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
optimize-gif-transparency - Apply GIF transparency optimization. Default: false
optimize-gif-frames - Apply GIF frames optimization. Default: false
quality - Quality to use. Default: 0
format - Format to save in. Default: nil

magicksave_buffer!(in, optional \\ [])

Specs

magicksave_buffer!(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "optimize-gif-transparency": boolean(),
  "optimize-gif-frames": boolean(),
  quality: integer(),
  format: String.t()
) :: binary() | no_return()

Same as magicksave_buffer/2, except it returns only the value (not a tuple) and raises on error.

mapim(in, index, optional \\ [])

Specs

mapim(Vix.Vips.Image.t(), Vix.Vips.Image.t(), [
  {:interpolate, Vix.Vips.Interpolate.t()}
]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Resample with a map image

arguments
Arguments

in - Input image argument
index - Index pixels with this

optional
Optional

interpolate - Interpolate pixels with this.

mapim!(in, index, optional \\ [])

Specs

mapim!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), [
  {:interpolate, Vix.Vips.Interpolate.t()}
]) ::
  Vix.Vips.Image.t() | no_return()

Same as mapim/3, except it returns only the value (not a tuple) and raises on error.

maplut(in, lut, optional \\ [])

Specs

maplut(Vix.Vips.Image.t(), Vix.Vips.Image.t(), [{:band, integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Map an image though a lut

arguments
Arguments

in - Input image
lut - Look-up table image

optional
Optional

band - apply one-band lut to this band of in. Default: -1

maplut!(in, lut, optional \\ [])

Specs

maplut!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), [{:band, integer()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as maplut/3, except it returns only the value (not a tuple) and raises on error.

mask_butterworth(width, height, order, frequency-cutoff, amplitude-cutoff, optional \\ [])

Specs

mask_butterworth(integer(), integer(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a butterworth filter

arguments
Arguments

width - Image width in pixels
height - Image height in pixels
order - Filter order
frequency-cutoff - Frequency cutoff
amplitude-cutoff - Amplitude cutoff

optional
Optional

optical - Rotate quadrants to optical space. Default: false
reject - Invert the sense of the filter. Default: false
nodc - Remove DC component. Default: false
uchar - Output an unsigned char image. Default: false

mask_butterworth!(width, height, order, frequency-cutoff, amplitude-cutoff, optional \\ [])

Specs

mask_butterworth!(integer(), integer(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

Same as mask_butterworth/6, except it returns only the value (not a tuple) and raises on error.

mask_butterworth_band( width, height, order, frequency-cutoff-x, frequency-cutoff-y, radius, amplitude-cutoff, optional \\ [] )

Specs

mask_butterworth_band(
  integer(),
  integer(),
  float(),
  float(),
  float(),
  float(),
  float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a butterworth_band filter

arguments
Arguments

width - Image width in pixels
height - Image height in pixels
order - Filter order
frequency-cutoff-x - Frequency cutoff x
frequency-cutoff-y - Frequency cutoff y
radius - radius of circle
amplitude-cutoff - Amplitude cutoff

optional
Optional

optical - Rotate quadrants to optical space. Default: false
reject - Invert the sense of the filter. Default: false
nodc - Remove DC component. Default: false
uchar - Output an unsigned char image. Default: false

mask_butterworth_band!( width, height, order, frequency-cutoff-x, frequency-cutoff-y, radius, amplitude-cutoff, optional \\ [] )

Specs

mask_butterworth_band!(
  integer(),
  integer(),
  float(),
  float(),
  float(),
  float(),
  float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

Same as mask_butterworth_band/8, except it returns only the value (not a tuple) and raises on error.

mask_butterworth_ring( width, height, order, frequency-cutoff, amplitude-cutoff, ringwidth, optional \\ [] )

Specs

mask_butterworth_ring(integer(), integer(), float(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a butterworth ring filter

arguments
Arguments

width - Image width in pixels
height - Image height in pixels
order - Filter order
frequency-cutoff - Frequency cutoff
amplitude-cutoff - Amplitude cutoff
ringwidth - Ringwidth

optional
Optional

optical - Rotate quadrants to optical space. Default: false
reject - Invert the sense of the filter. Default: false
nodc - Remove DC component. Default: false
uchar - Output an unsigned char image. Default: false

mask_butterworth_ring!( width, height, order, frequency-cutoff, amplitude-cutoff, ringwidth, optional \\ [] )

Specs

mask_butterworth_ring!(integer(), integer(), float(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

Same as mask_butterworth_ring/7, except it returns only the value (not a tuple) and raises on error.

mask_fractal(width, height, fractal-dimension, optional \\ [])

Specs

mask_fractal(integer(), integer(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make fractal filter

arguments
Arguments

width - Image width in pixels
height - Image height in pixels
fractal-dimension - Fractal dimension

optional
Optional

optical - Rotate quadrants to optical space. Default: false
reject - Invert the sense of the filter. Default: false
nodc - Remove DC component. Default: false
uchar - Output an unsigned char image. Default: false

mask_fractal!(width, height, fractal-dimension, optional \\ [])

Specs

mask_fractal!(integer(), integer(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

Same as mask_fractal/4, except it returns only the value (not a tuple) and raises on error.

mask_gaussian(width, height, frequency-cutoff, amplitude-cutoff, optional \\ [])

Specs

mask_gaussian(integer(), integer(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a gaussian filter

arguments
Arguments

width - Image width in pixels
height - Image height in pixels
frequency-cutoff - Frequency cutoff
amplitude-cutoff - Amplitude cutoff

optional
Optional

optical - Rotate quadrants to optical space. Default: false
reject - Invert the sense of the filter. Default: false
nodc - Remove DC component. Default: false
uchar - Output an unsigned char image. Default: false

mask_gaussian!(width, height, frequency-cutoff, amplitude-cutoff, optional \\ [])

Specs

mask_gaussian!(integer(), integer(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

Same as mask_gaussian/5, except it returns only the value (not a tuple) and raises on error.

mask_gaussian_band( width, height, frequency-cutoff-x, frequency-cutoff-y, radius, amplitude-cutoff, optional \\ [] )

Specs

mask_gaussian_band(integer(), integer(), float(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a gaussian filter

arguments
Arguments

width - Image width in pixels
height - Image height in pixels
frequency-cutoff-x - Frequency cutoff x
frequency-cutoff-y - Frequency cutoff y
radius - radius of circle
amplitude-cutoff - Amplitude cutoff

optional
Optional

optical - Rotate quadrants to optical space. Default: false
reject - Invert the sense of the filter. Default: false
nodc - Remove DC component. Default: false
uchar - Output an unsigned char image. Default: false

mask_gaussian_band!( width, height, frequency-cutoff-x, frequency-cutoff-y, radius, amplitude-cutoff, optional \\ [] )

Specs

mask_gaussian_band!(integer(), integer(), float(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

Same as mask_gaussian_band/7, except it returns only the value (not a tuple) and raises on error.

mask_gaussian_ring(width, height, frequency-cutoff, amplitude-cutoff, ringwidth, optional \\ [])

Specs

mask_gaussian_ring(integer(), integer(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a gaussian ring filter

arguments
Arguments

width - Image width in pixels
height - Image height in pixels
frequency-cutoff - Frequency cutoff
amplitude-cutoff - Amplitude cutoff
ringwidth - Ringwidth

optional
Optional

optical - Rotate quadrants to optical space. Default: false
reject - Invert the sense of the filter. Default: false
nodc - Remove DC component. Default: false
uchar - Output an unsigned char image. Default: false

mask_gaussian_ring!(width, height, frequency-cutoff, amplitude-cutoff, ringwidth, optional \\ [])

Specs

mask_gaussian_ring!(integer(), integer(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

Same as mask_gaussian_ring/6, except it returns only the value (not a tuple) and raises on error.

mask_ideal(width, height, frequency-cutoff, optional \\ [])

Specs

mask_ideal(integer(), integer(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make an ideal filter

arguments
Arguments

width - Image width in pixels
height - Image height in pixels
frequency-cutoff - Frequency cutoff

optional
Optional

optical - Rotate quadrants to optical space. Default: false
reject - Invert the sense of the filter. Default: false
nodc - Remove DC component. Default: false
uchar - Output an unsigned char image. Default: false

mask_ideal!(width, height, frequency-cutoff, optional \\ [])

Specs

mask_ideal!(integer(), integer(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

Same as mask_ideal/4, except it returns only the value (not a tuple) and raises on error.

mask_ideal_band(width, height, frequency-cutoff-x, frequency-cutoff-y, radius, optional \\ [])

Specs

mask_ideal_band(integer(), integer(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make an ideal band filter

arguments
Arguments

width - Image width in pixels
height - Image height in pixels
frequency-cutoff-x - Frequency cutoff x
frequency-cutoff-y - Frequency cutoff y
radius - radius of circle

optional
Optional

optical - Rotate quadrants to optical space. Default: false
reject - Invert the sense of the filter. Default: false
nodc - Remove DC component. Default: false
uchar - Output an unsigned char image. Default: false

mask_ideal_band!(width, height, frequency-cutoff-x, frequency-cutoff-y, radius, optional \\ [])

Specs

mask_ideal_band!(integer(), integer(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

Same as mask_ideal_band/6, except it returns only the value (not a tuple) and raises on error.

mask_ideal_ring(width, height, frequency-cutoff, ringwidth, optional \\ [])

Specs

mask_ideal_ring(integer(), integer(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make an ideal ring filter

arguments
Arguments

width - Image width in pixels
height - Image height in pixels
frequency-cutoff - Frequency cutoff
ringwidth - Ringwidth

optional
Optional

optical - Rotate quadrants to optical space. Default: false
reject - Invert the sense of the filter. Default: false
nodc - Remove DC component. Default: false
uchar - Output an unsigned char image. Default: false

mask_ideal_ring!(width, height, frequency-cutoff, ringwidth, optional \\ [])

Specs

mask_ideal_ring!(integer(), integer(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

Same as mask_ideal_ring/5, except it returns only the value (not a tuple) and raises on error.

match(ref, sec, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, optional \\ [])

Specs

match(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  interpolate: Vix.Vips.Interpolate.t(),
  search: boolean(),
  harea: integer(),
  hwindow: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

First-order match of two images

arguments
Arguments

ref - Reference image
sec - Secondary image
xr1 - Position of first reference tie-point
yr1 - Position of first reference tie-point
xs1 - Position of first secondary tie-point
ys1 - Position of first secondary tie-point
xr2 - Position of second reference tie-point
yr2 - Position of second reference tie-point
xs2 - Position of second secondary tie-point
ys2 - Position of second secondary tie-point

optional
Optional

interpolate - Interpolate pixels with this.
search - Search to improve tie-points. Default: false
harea - Half area size. Default: 1
hwindow - Half window size. Default: 1

match!(ref, sec, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, optional \\ [])

Specs

match!(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  interpolate: Vix.Vips.Interpolate.t(),
  search: boolean(),
  harea: integer(),
  hwindow: integer()
) :: Vix.Vips.Image.t() | no_return()

Same as match/11, except it returns only the value (not a tuple) and raises on error.

math(in, math, optional \\ [])

Specs

math(Vix.Vips.Image.t(), vips_operation_math(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Apply a math operation to an image

arguments
Arguments

in - Input image
math - math to perform

math!(in, math, optional \\ [])

Specs

math!(Vix.Vips.Image.t(), vips_operation_math(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as math/3, except it returns only the value (not a tuple) and raises on error.

math2(left, right, math2, optional \\ [])

Specs

math2(Vix.Vips.Image.t(), Vix.Vips.Image.t(), vips_operation_math2(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Binary math operations

arguments
Arguments

left - Left-hand image argument
right - Right-hand image argument
math2 - math to perform

math2!(left, right, math2, optional \\ [])

Specs

math2!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), vips_operation_math2(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as math2/4, except it returns only the value (not a tuple) and raises on error.

math2_const(in, math2, c, optional \\ [])

Specs

math2_const(Vix.Vips.Image.t(), vips_operation_math2(), [float()], []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Binary math operations with a constant

arguments
Arguments

in - Input image
math2 - math to perform
c - Array of constants

math2_const!(in, math2, c, optional \\ [])

Specs

math2_const!(Vix.Vips.Image.t(), vips_operation_math2(), [float()], []) ::
  Vix.Vips.Image.t() | no_return()

Same as math2_const/4, except it returns only the value (not a tuple) and raises on error.

matload(filename, optional \\ [])

Specs

matload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load mat from file

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

matload!(filename, optional \\ [])

Specs

matload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as matload/2, except it returns only the value (not a tuple) and raises on error.

matrixinvert(in, optional \\ [])

Specs

matrixinvert(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Invert an matrix

arguments
Arguments

in - An square matrix

matrixinvert!(in, optional \\ [])

Specs

matrixinvert!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as matrixinvert/2, except it returns only the value (not a tuple) and raises on error.

matrixload(filename, optional \\ [])

Specs

matrixload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load matrix

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

matrixload!(filename, optional \\ [])

Specs

matrixload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as matrixload/2, except it returns only the value (not a tuple) and raises on error.

matrixprint(in, optional \\ [])

Specs

matrixprint(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) ::
  :ok | {:error, term()}

Print matrix

arguments
Arguments

in - Image to save

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false

matrixprint!(in, optional \\ [])

Specs

matrixprint!(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) ::
  :ok | no_return()

Same as matrixprint/2, except it returns only the value (not a tuple) and raises on error.

matrixsave(in, filename, optional \\ [])

Specs

matrixsave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) :: :ok | {:error, term()}

Save image to matrix

arguments
Arguments

in - Image to save
filename - Filename to save to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false

matrixsave!(in, filename, optional \\ [])

Specs

matrixsave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) :: :ok | no_return()

Same as matrixsave/3, except it returns only the value (not a tuple) and raises on error.

max(in, optional \\ [])

Specs

max(Vix.Vips.Image.t(), [{:size, integer()}]) ::
  {:ok,
   {float(),
    "y-array": [integer()],
    "x-array": [integer()],
    "out-array": [float()],
    y: integer(),
    x: integer()}}
  | {:error, term()}

Find image maximum

arguments
Arguments

in - Input image

optional
Optional

size - Number of maximum values to find. Default: 10

returns
Returns

Ordered values in the returned tuple

out - Output value. (float())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

y-array - Array of vertical positions. (list(integer()))
x-array - Array of horizontal positions. (list(integer()))
out-array - Array of output values. (list(float()))
y - Vertical position of maximum. (integer())
x - Horizontal position of maximum. (integer())

max!(in, optional \\ [])

Specs

max!(Vix.Vips.Image.t(), [{:size, integer()}]) ::
  {float(),
   "y-array": [integer()],
   "x-array": [integer()],
   "out-array": [float()],
   y: integer(),
   x: integer()}
  | no_return()

Same as max/2, except it returns only the value (not a tuple) and raises on error.

measure(in, h, v, optional \\ [])

Specs

measure(Vix.Vips.Image.t(), integer(), integer(),
  height: integer(),
  width: integer(),
  top: integer(),
  left: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Measure a set of patches on a color chart

arguments
Arguments

in - Image to measure
h - Number of patches across chart
v - Number of patches down chart

optional
Optional

height - Height of extract area. Default: 1
width - Width of extract area. Default: 1
top - Top edge of extract area. Default: 0
left - Left edge of extract area. Default: 0

measure!(in, h, v, optional \\ [])

Specs

measure!(Vix.Vips.Image.t(), integer(), integer(),
  height: integer(),
  width: integer(),
  top: integer(),
  left: integer()
) :: Vix.Vips.Image.t() | no_return()

Same as measure/4, except it returns only the value (not a tuple) and raises on error.

merge(ref, sec, direction, dx, dy, optional \\ [])

Specs

merge(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  vips_direction(),
  integer(),
  integer(),
  [
    {:mblend, integer()}
  ]
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Merge two images

arguments
Arguments

ref - Reference image
sec - Secondary image
direction - Horizontal or vertical merge
dx - Horizontal displacement from sec to ref
dy - Vertical displacement from sec to ref

optional
Optional

mblend - Maximum blend size. Default: 10

merge!(ref, sec, direction, dx, dy, optional \\ [])

Specs

merge!(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  vips_direction(),
  integer(),
  integer(),
  [
    {:mblend, integer()}
  ]
) :: Vix.Vips.Image.t() | no_return()

Same as merge/6, except it returns only the value (not a tuple) and raises on error.

min(in, optional \\ [])

Specs

min(Vix.Vips.Image.t(), [{:size, integer()}]) ::
  {:ok,
   {float(),
    "y-array": [integer()],
    "x-array": [integer()],
    "out-array": [float()],
    y: integer(),
    x: integer()}}
  | {:error, term()}

Find image minimum

arguments
Arguments

in - Input image

optional
Optional

size - Number of minimum values to find. Default: 10

returns
Returns

Ordered values in the returned tuple

out - Output value. (float())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

y-array - Array of vertical positions. (list(integer()))
x-array - Array of horizontal positions. (list(integer()))
out-array - Array of output values. (list(float()))
y - Vertical position of minimum. (integer())
x - Horizontal position of minimum. (integer())

min!(in, optional \\ [])

Specs

min!(Vix.Vips.Image.t(), [{:size, integer()}]) ::
  {float(),
   "y-array": [integer()],
   "x-array": [integer()],
   "out-array": [float()],
   y: integer(),
   x: integer()}
  | no_return()

Same as min/2, except it returns only the value (not a tuple) and raises on error.

morph(in, mask, morph, optional \\ [])

Specs

morph(Vix.Vips.Image.t(), Vix.Vips.Image.t(), vips_operation_morphology(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Morphology operation

arguments
Arguments

in - Input image argument
mask - Input matrix image
morph - Morphological operation to perform

morph!(in, mask, morph, optional \\ [])

Specs

morph!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), vips_operation_morphology(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as morph/4, except it returns only the value (not a tuple) and raises on error.

mosaic(ref, sec, direction, xref, yref, xsec, ysec, optional \\ [])

Specs

mosaic(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  vips_direction(),
  integer(),
  integer(),
  integer(),
  integer(),
  bandno: integer(),
  mblend: integer(),
  harea: integer(),
  hwindow: integer()
) ::
  {:ok,
   {Vix.Vips.Image.t(),
    dx1: float(),
    dy1: float(),
    angle1: float(),
    scale1: float(),
    dy0: integer(),
    dx0: integer()}}
  | {:error, term()}

Mosaic two images

arguments
Arguments

ref - Reference image
sec - Secondary image
direction - Horizontal or vertical mosaic
xref - Position of reference tie-point
yref - Position of reference tie-point
xsec - Position of secondary tie-point
ysec - Position of secondary tie-point

optional
Optional

bandno - Band to search for features on. Default: 0
mblend - Maximum blend size. Default: 10
harea - Half area size. Default: 15
hwindow - Half window size. Default: 5

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

dx1 - Detected first-order displacement. (float())
dy1 - Detected first-order displacement. (float())
angle1 - Detected rotation. (float())
scale1 - Detected scale. (float())
dy0 - Detected integer offset. (integer())
dx0 - Detected integer offset. (integer())

mosaic!(ref, sec, direction, xref, yref, xsec, ysec, optional \\ [])

Specs

mosaic!(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  vips_direction(),
  integer(),
  integer(),
  integer(),
  integer(),
  bandno: integer(),
  mblend: integer(),
  harea: integer(),
  hwindow: integer()
) ::
  {Vix.Vips.Image.t(),
   dx1: float(),
   dy1: float(),
   angle1: float(),
   scale1: float(),
   dy0: integer(),
   dx0: integer()}
  | no_return()

Same as mosaic/8, except it returns only the value (not a tuple) and raises on error.

mosaic1(ref, sec, direction, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, optional \\ [])

Specs

mosaic1(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  vips_direction(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  bandno: integer(),
  mblend: integer(),
  interpolate: Vix.Vips.Interpolate.t(),
  search: boolean(),
  harea: integer(),
  hwindow: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

First-order mosaic of two images

arguments
Arguments

ref - Reference image
sec - Secondary image
direction - Horizontal or vertical mosaic
xr1 - Position of first reference tie-point
yr1 - Position of first reference tie-point
xs1 - Position of first secondary tie-point
ys1 - Position of first secondary tie-point
xr2 - Position of second reference tie-point
yr2 - Position of second reference tie-point
xs2 - Position of second secondary tie-point
ys2 - Position of second secondary tie-point

optional
Optional

bandno - Band to search for features on. Default: 0
mblend - Maximum blend size. Default: 10
interpolate - Interpolate pixels with this.
search - Search to improve tie-points. Default: false
harea - Half area size. Default: 15
hwindow - Half window size. Default: 5

mosaic1!(ref, sec, direction, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, optional \\ [])

Specs

mosaic1!(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  vips_direction(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  bandno: integer(),
  mblend: integer(),
  interpolate: Vix.Vips.Interpolate.t(),
  search: boolean(),
  harea: integer(),
  hwindow: integer()
) :: Vix.Vips.Image.t() | no_return()

Same as mosaic1/12, except it returns only the value (not a tuple) and raises on error.

msb(in, optional \\ [])

Specs

msb(Vix.Vips.Image.t(), [{:band, integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Pick most-significant byte from an image

arguments
Arguments

in - Input image

optional
Optional

band - Band to msb. Default: 0

msb!(in, optional \\ [])

Specs

msb!(Vix.Vips.Image.t(), [{:band, integer()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as msb/2, except it returns only the value (not a tuple) and raises on error.

multiply(left, right, optional \\ [])

Specs

multiply(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Multiply two images

arguments
Arguments

left - Left-hand image argument
right - Right-hand image argument

multiply!(left, right, optional \\ [])

Specs

multiply!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as multiply/3, except it returns only the value (not a tuple) and raises on error.

openexrload(filename, optional \\ [])

Specs

openexrload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load an openexr image

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

openexrload!(filename, optional \\ [])

Specs

openexrload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as openexrload/2, except it returns only the value (not a tuple) and raises on error.

openslideload(filename, optional \\ [])

Specs

openslideload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  associated: String.t(),
  autocrop: boolean(),
  level: integer(),
  "attach-associated": boolean()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load file with openslide

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
associated - Load this associated image. Default: nil
autocrop - Crop to image bounds. Default: false
level - Load this level from the file. Default: 0
attach-associated - Attach all associated images. Default: false

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

openslideload!(filename, optional \\ [])

Specs

openslideload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  associated: String.t(),
  autocrop: boolean(),
  level: integer(),
  "attach-associated": boolean()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as openslideload/2, except it returns only the value (not a tuple) and raises on error.

pdfload(filename, optional \\ [])

Specs

pdfload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  background: [float()],
  scale: float(),
  dpi: float(),
  n: integer(),
  page: integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load pdf from file

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
background - Background value.
scale - Scale output by this factor. Default: 1.0
dpi - Render at this DPI. Default: 72.0
n - Load this many pages. Default: 1
page - Load this page from the file. Default: 0

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

pdfload!(filename, optional \\ [])

Specs

pdfload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  background: [float()],
  scale: float(),
  dpi: float(),
  n: integer(),
  page: integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as pdfload/2, except it returns only the value (not a tuple) and raises on error.

pdfload_buffer(buffer, optional \\ [])

Specs

pdfload_buffer(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  background: [float()],
  scale: float(),
  dpi: float(),
  n: integer(),
  page: integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load pdf from buffer

arguments
Arguments

buffer - Buffer to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
background - Background value.
scale - Scale output by this factor. Default: 1.0
dpi - Render at this DPI. Default: 72.0
n - Load this many pages. Default: 1
page - Load this page from the file. Default: 0

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

pdfload_buffer!(buffer, optional \\ [])

Specs

pdfload_buffer!(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  background: [float()],
  scale: float(),
  dpi: float(),
  n: integer(),
  page: integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as pdfload_buffer/2, except it returns only the value (not a tuple) and raises on error.

percent(in, percent, optional \\ [])

Specs

percent(Vix.Vips.Image.t(), float(), []) :: {:ok, integer()} | {:error, term()}

Find threshold for percent of pixels

arguments
Arguments

in - Input image
percent - Percent of pixels

percent!(in, percent, optional \\ [])

Specs

percent!(Vix.Vips.Image.t(), float(), []) :: integer() | no_return()

Same as percent/3, except it returns only the value (not a tuple) and raises on error.

perlin(width, height, optional \\ [])

Specs

perlin(integer(), integer(),
  seed: integer(),
  uchar: boolean(),
  "cell-size": integer()
) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a perlin noise image

arguments
Arguments

width - Image width in pixels
height - Image height in pixels

optional
Optional

seed - Random number seed. Default: 0
uchar - Output an unsigned char image. Default: false
cell-size - Size of Perlin cells. Default: 256

perlin!(width, height, optional \\ [])

Specs

perlin!(integer(), integer(),
  seed: integer(),
  uchar: boolean(),
  "cell-size": integer()
) ::
  Vix.Vips.Image.t() | no_return()

Same as perlin/3, except it returns only the value (not a tuple) and raises on error.

phasecor(in, in2, optional \\ [])

Specs

phasecor(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Calculate phase correlation

arguments
Arguments

in - Input image
in2 - Second input image

phasecor!(in, in2, optional \\ [])

Specs

phasecor!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as phasecor/3, except it returns only the value (not a tuple) and raises on error.

pngload(filename, optional \\ [])

Specs

pngload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  unlimited: boolean()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load png from file

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
unlimited - Remove all denial of service limits. Default: false

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

pngload!(filename, optional \\ [])

Specs

pngload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  unlimited: boolean()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as pngload/2, except it returns only the value (not a tuple) and raises on error.

pngload_buffer(buffer, optional \\ [])

Specs

pngload_buffer(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  unlimited: boolean()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load png from buffer

arguments
Arguments

buffer - Buffer to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
unlimited - Remove all denial of service limits. Default: false

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

pngload_buffer!(buffer, optional \\ [])

Specs

pngload_buffer!(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  unlimited: boolean()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as pngload_buffer/2, except it returns only the value (not a tuple) and raises on error.

pngsave(in, filename, optional \\ [])

Specs

pngsave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  effort: integer(),
  bitdepth: integer(),
  dither: float(),
  Q: integer(),
  colours: integer(),
  palette: boolean(),
  filter: vips_foreign_png_filter(),
  profile: String.t(),
  interlace: boolean(),
  compression: integer()
) :: :ok | {:error, term()}

Save image to png file

arguments
Arguments

in - Image to save
filename - Filename to save to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
effort - Quantisation CPU effort. Default: 7
bitdepth - Write as a 1, 2, 4, 8 or 16 bit image. Default: 0
dither - Amount of dithering. Default: 1.0
Q - Quantisation quality. Default: 100
colours - Max number of palette colours. Default: 256
palette - Quantise to 8bpp palette. Default: false
filter - libpng row filter flag(s). Default: [:VIPS_FOREIGN_PNG_FILTER_PAETH, :VIPS_FOREIGN_PNG_FILTER_AVG, :VIPS_FOREIGN_PNG_FILTER_UP, :VIPS_FOREIGN_PNG_FILTER_SUB, :VIPS_FOREIGN_PNG_FILTER_NONE]
profile - ICC profile to embed. Default: nil
interlace - Interlace image. Default: false
compression - Compression factor. Default: 6

pngsave!(in, filename, optional \\ [])

Specs

pngsave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  effort: integer(),
  bitdepth: integer(),
  dither: float(),
  Q: integer(),
  colours: integer(),
  palette: boolean(),
  filter: vips_foreign_png_filter(),
  profile: String.t(),
  interlace: boolean(),
  compression: integer()
) :: :ok | no_return()

Same as pngsave/3, except it returns only the value (not a tuple) and raises on error.

pngsave_buffer(in, optional \\ [])

Specs

pngsave_buffer(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  effort: integer(),
  bitdepth: integer(),
  dither: float(),
  Q: integer(),
  colours: integer(),
  palette: boolean(),
  filter: vips_foreign_png_filter(),
  profile: String.t(),
  interlace: boolean(),
  compression: integer()
) :: {:ok, binary()} | {:error, term()}

Save image to png buffer

arguments
Arguments

in - Image to save

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
effort - Quantisation CPU effort. Default: 7
bitdepth - Write as a 1, 2, 4, 8 or 16 bit image. Default: 0
dither - Amount of dithering. Default: 1.0
Q - Quantisation quality. Default: 100
colours - Max number of palette colours. Default: 256
palette - Quantise to 8bpp palette. Default: false
filter - libpng row filter flag(s). Default: [:VIPS_FOREIGN_PNG_FILTER_PAETH, :VIPS_FOREIGN_PNG_FILTER_AVG, :VIPS_FOREIGN_PNG_FILTER_UP, :VIPS_FOREIGN_PNG_FILTER_SUB, :VIPS_FOREIGN_PNG_FILTER_NONE]
profile - ICC profile to embed. Default: nil
interlace - Interlace image. Default: false
compression - Compression factor. Default: 6

pngsave_buffer!(in, optional \\ [])

Specs

pngsave_buffer!(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  effort: integer(),
  bitdepth: integer(),
  dither: float(),
  Q: integer(),
  colours: integer(),
  palette: boolean(),
  filter: vips_foreign_png_filter(),
  profile: String.t(),
  interlace: boolean(),
  compression: integer()
) :: binary() | no_return()

Same as pngsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

ppmload(filename, optional \\ [])

Specs

ppmload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load ppm from file

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

ppmload!(filename, optional \\ [])

Specs

ppmload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as ppmload/2, except it returns only the value (not a tuple) and raises on error.

ppmsave(in, filename, optional \\ [])

Specs

ppmsave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  bitdepth: integer(),
  squash: boolean(),
  ascii: boolean(),
  format: vips_foreign_ppm_format()
) :: :ok | {:error, term()}

Save image to ppm file

arguments
Arguments

in - Image to save
filename - Filename to save to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
bitdepth - set to 1 to write as a 1 bit image. Default: 0
squash - save as one bit. Default: false
ascii - save as ascii. Default: false
format - Format to save in. Default: :VIPS_FOREIGN_PPM_FORMAT_PPM

ppmsave!(in, filename, optional \\ [])

Specs

ppmsave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  bitdepth: integer(),
  squash: boolean(),
  ascii: boolean(),
  format: vips_foreign_ppm_format()
) :: :ok | no_return()

Same as ppmsave/3, except it returns only the value (not a tuple) and raises on error.

premultiply(in, optional \\ [])

Specs

premultiply(Vix.Vips.Image.t(), [{:"max-alpha", float()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Premultiply image alpha

arguments
Arguments

in - Input image

optional
Optional

max-alpha - Maximum value of alpha channel. Default: 255.0

premultiply!(in, optional \\ [])

Specs

premultiply!(Vix.Vips.Image.t(), [{:"max-alpha", float()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as premultiply/2, except it returns only the value (not a tuple) and raises on error.

profile(in, optional \\ [])

Specs

profile(Vix.Vips.Image.t(), []) ::
  {:ok, {Vix.Vips.Image.t(), Vix.Vips.Image.t(), []}} | {:error, term()}

Find image profiles

arguments
Arguments

in - Input image

returns
Returns

Ordered values in the returned tuple

columns - First non-zero pixel in column. (Vix.Vips.Image.t())
rows - First non-zero pixel in row. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

profile!(in, optional \\ [])

Specs

profile!(Vix.Vips.Image.t(), []) ::
  {Vix.Vips.Image.t(), Vix.Vips.Image.t(), []} | no_return()

Same as profile/2, except it returns only the value (not a tuple) and raises on error.

profile_load(name, optional \\ [])

Specs

profile_load(String.t(), []) :: {:ok, binary()} | {:error, term()}

Load named icc profile

arguments
Arguments

name - Profile name

profile_load!(name, optional \\ [])

Specs

profile_load!(String.t(), []) :: binary() | no_return()

Same as profile_load/2, except it returns only the value (not a tuple) and raises on error.

project(in, optional \\ [])

Specs

project(Vix.Vips.Image.t(), []) ::
  {:ok, {Vix.Vips.Image.t(), Vix.Vips.Image.t(), []}} | {:error, term()}

Find image projections

arguments
Arguments

in - Input image

returns
Returns

Ordered values in the returned tuple

columns - Sums of columns. (Vix.Vips.Image.t())
rows - Sums of rows. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

project!(in, optional \\ [])

Specs

project!(Vix.Vips.Image.t(), []) ::
  {Vix.Vips.Image.t(), Vix.Vips.Image.t(), []} | no_return()

Same as project/2, except it returns only the value (not a tuple) and raises on error.

quadratic(in, coeff, optional \\ [])

Specs

quadratic(Vix.Vips.Image.t(), Vix.Vips.Image.t(), [
  {:interpolate, Vix.Vips.Interpolate.t()}
]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Resample an image with a quadratic transform

arguments
Arguments

in - Input image argument
coeff - Coefficient matrix

optional
Optional

interpolate - Interpolate values with this.

quadratic!(in, coeff, optional \\ [])

Specs

quadratic!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), [
  {:interpolate, Vix.Vips.Interpolate.t()}
]) ::
  Vix.Vips.Image.t() | no_return()

Same as quadratic/3, except it returns only the value (not a tuple) and raises on error.

rad2float(in, optional \\ [])

Specs

rad2float(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Unpack radiance coding to float rgb

arguments
Arguments

in - Input image

rad2float!(in, optional \\ [])

Specs

rad2float!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as rad2float/2, except it returns only the value (not a tuple) and raises on error.

radload(filename, optional \\ [])

Specs

radload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load a radiance image from a file

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

radload!(filename, optional \\ [])

Specs

radload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as radload/2, except it returns only the value (not a tuple) and raises on error.

radload_buffer(buffer, optional \\ [])

Specs

radload_buffer(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load rad from buffer

arguments
Arguments

buffer - Buffer to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

radload_buffer!(buffer, optional \\ [])

Specs

radload_buffer!(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as radload_buffer/2, except it returns only the value (not a tuple) and raises on error.

radsave(in, filename, optional \\ [])

Specs

radsave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) :: :ok | {:error, term()}

Save image to radiance file

arguments
Arguments

in - Image to save
filename - Filename to save to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false

radsave!(in, filename, optional \\ [])

Specs

radsave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) :: :ok | no_return()

Same as radsave/3, except it returns only the value (not a tuple) and raises on error.

radsave_buffer(in, optional \\ [])

Specs

radsave_buffer(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) :: {:ok, binary()} | {:error, term()}

Save image to radiance buffer

arguments
Arguments

in - Image to save

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false

radsave_buffer!(in, optional \\ [])

Specs

radsave_buffer!(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) :: binary() | no_return()

Same as radsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

rank(in, width, height, index, optional \\ [])

Specs

rank(Vix.Vips.Image.t(), integer(), integer(), integer(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Rank filter

arguments
Arguments

in - Input image argument
width - Window width in pixels
height - Window height in pixels
index - Select pixel at index

rank!(in, width, height, index, optional \\ [])

Specs

rank!(Vix.Vips.Image.t(), integer(), integer(), integer(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as rank/5, except it returns only the value (not a tuple) and raises on error.

rawload(filename, width, height, bands, optional \\ [])

Specs

rawload(String.t(), integer(), integer(), integer(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  interpretation: vips_interpretation(),
  format: vips_band_format(),
  offset: non_neg_integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load raw data from a file

arguments
Arguments

filename - Filename to load from
width - Image width in pixels
height - Image height in pixels
bands - Number of bands in image

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
interpretation - Pixel interpretation. Default: :VIPS_INTERPRETATION_MULTIBAND
format - Pixel format in image. Default: :VIPS_FORMAT_UCHAR
offset - Offset in bytes from start of file. Default: 0

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

rawload!(filename, width, height, bands, optional \\ [])

Specs

rawload!(String.t(), integer(), integer(), integer(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  interpretation: vips_interpretation(),
  format: vips_band_format(),
  offset: non_neg_integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as rawload/5, except it returns only the value (not a tuple) and raises on error.

rawsave(in, filename, optional \\ [])

Specs

rawsave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) :: :ok | {:error, term()}

Save image to raw file

arguments
Arguments

in - Image to save
filename - Filename to save to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false

rawsave!(in, filename, optional \\ [])

Specs

rawsave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) :: :ok | no_return()

Same as rawsave/3, except it returns only the value (not a tuple) and raises on error.

rawsave_fd(in, fd, optional \\ [])

Specs

rawsave_fd(Vix.Vips.Image.t(), integer(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) :: :ok | {:error, term()}

Write raw image to file descriptor

arguments
Arguments

in - Image to save
fd - File descriptor to write to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false

rawsave_fd!(in, fd, optional \\ [])

Specs

rawsave_fd!(Vix.Vips.Image.t(), integer(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) :: :ok | no_return()

Same as rawsave_fd/3, except it returns only the value (not a tuple) and raises on error.

recomb(in, m, optional \\ [])

Specs

recomb(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Linear recombination with matrix

arguments
Arguments

in - Input image argument
m - matrix of coefficients

recomb!(in, m, optional \\ [])

Specs

recomb!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as recomb/3, except it returns only the value (not a tuple) and raises on error.

reduce(in, hshrink, vshrink, optional \\ [])

Specs

reduce(Vix.Vips.Image.t(), float(), float(),
  centre: boolean(),
  kernel: vips_kernel()
) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Reduce an image

arguments
Arguments

in - Input image argument
hshrink - Horizontal shrink factor
vshrink - Vertical shrink factor

optional
Optional

centre - Use centre sampling convention. Default: false
kernel - Resampling kernel. Default: :VIPS_KERNEL_LANCZOS3

reduce!(in, hshrink, vshrink, optional \\ [])

Specs

reduce!(Vix.Vips.Image.t(), float(), float(),
  centre: boolean(),
  kernel: vips_kernel()
) ::
  Vix.Vips.Image.t() | no_return()

Same as reduce/4, except it returns only the value (not a tuple) and raises on error.

reduceh(in, hshrink, optional \\ [])

Specs

reduceh(Vix.Vips.Image.t(), float(), centre: boolean(), kernel: vips_kernel()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Shrink an image horizontally

arguments
Arguments

in - Input image argument
hshrink - Horizontal shrink factor

optional
Optional

centre - Use centre sampling convention. Default: false
kernel - Resampling kernel. Default: :VIPS_KERNEL_LANCZOS3

reduceh!(in, hshrink, optional \\ [])

Specs

reduceh!(Vix.Vips.Image.t(), float(), centre: boolean(), kernel: vips_kernel()) ::
  Vix.Vips.Image.t() | no_return()

Same as reduceh/3, except it returns only the value (not a tuple) and raises on error.

reducev(in, vshrink, optional \\ [])

Specs

reducev(Vix.Vips.Image.t(), float(), centre: boolean(), kernel: vips_kernel()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Shrink an image vertically

arguments
Arguments

in - Input image argument
vshrink - Vertical shrink factor

optional
Optional

centre - Use centre sampling convention. Default: false
kernel - Resampling kernel. Default: :VIPS_KERNEL_LANCZOS3

reducev!(in, vshrink, optional \\ [])

Specs

reducev!(Vix.Vips.Image.t(), float(), centre: boolean(), kernel: vips_kernel()) ::
  Vix.Vips.Image.t() | no_return()

Same as reducev/3, except it returns only the value (not a tuple) and raises on error.

relational(left, right, relational, optional \\ [])

Specs

relational(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  vips_operation_relational(),
  []
) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Relational operation on two images

arguments
Arguments

left - Left-hand image argument
right - Right-hand image argument
relational - relational to perform

relational!(left, right, relational, optional \\ [])

Specs

relational!(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  vips_operation_relational(),
  []
) ::
  Vix.Vips.Image.t() | no_return()

Same as relational/4, except it returns only the value (not a tuple) and raises on error.

relational_const(in, relational, c, optional \\ [])

Specs

relational_const(Vix.Vips.Image.t(), vips_operation_relational(), [float()], []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Relational operations against a constant

arguments
Arguments

in - Input image
relational - relational to perform
c - Array of constants

relational_const!(in, relational, c, optional \\ [])

Specs

relational_const!(
  Vix.Vips.Image.t(),
  vips_operation_relational(),
  [float()],
  []
) ::
  Vix.Vips.Image.t() | no_return()

Same as relational_const/4, except it returns only the value (not a tuple) and raises on error.

remainder(left, right, optional \\ [])

Specs

remainder(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Remainder after integer division of two images

arguments
Arguments

left - Left-hand image argument
right - Right-hand image argument

remainder!(left, right, optional \\ [])

Specs

remainder!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as remainder/3, except it returns only the value (not a tuple) and raises on error.

remainder_const(in, c, optional \\ [])

Specs

remainder_const(Vix.Vips.Image.t(), [float()], []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Remainder after integer division of an image and a constant

arguments
Arguments

in - Input image
c - Array of constants

remainder_const!(in, c, optional \\ [])

Specs

remainder_const!(Vix.Vips.Image.t(), [float()], []) ::
  Vix.Vips.Image.t() | no_return()

Same as remainder_const/3, except it returns only the value (not a tuple) and raises on error.

replicate(in, across, down, optional \\ [])

Specs

replicate(Vix.Vips.Image.t(), integer(), integer(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Replicate an image

arguments
Arguments

in - Input image
across - Repeat this many times horizontally
down - Repeat this many times vertically

replicate!(in, across, down, optional \\ [])

Specs

replicate!(Vix.Vips.Image.t(), integer(), integer(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as replicate/4, except it returns only the value (not a tuple) and raises on error.

resize(in, scale, optional \\ [])

Specs

resize(Vix.Vips.Image.t(), float(),
  idy: float(),
  idx: float(),
  vscale: float(),
  centre: boolean(),
  kernel: vips_kernel(),
  interpolate: Vix.Vips.Interpolate.t()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Resize an image

arguments
Arguments

in - Input image argument
scale - Scale image by this factor

optional
Optional

idy - Vertical input displacement. Default: 0.0
idx - Horizontal input displacement. Default: 0.0
vscale - Vertical scale image by this factor. Default: 0.0
centre - Use centre sampling convention. Default: false
kernel - Resampling kernel. Default: :VIPS_KERNEL_LANCZOS3
interpolate - Interpolate pixels with this.

resize!(in, scale, optional \\ [])

Specs

resize!(Vix.Vips.Image.t(), float(),
  idy: float(),
  idx: float(),
  vscale: float(),
  centre: boolean(),
  kernel: vips_kernel(),
  interpolate: Vix.Vips.Interpolate.t()
) :: Vix.Vips.Image.t() | no_return()

Same as resize/3, except it returns only the value (not a tuple) and raises on error.

rot(in, angle, optional \\ [])

Specs

rot(Vix.Vips.Image.t(), vips_angle(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Rotate an image

arguments
Arguments

in - Input image
angle - Angle to rotate image

rot!(in, angle, optional \\ [])

Specs

rot!(Vix.Vips.Image.t(), vips_angle(), []) :: Vix.Vips.Image.t() | no_return()

Same as rot/3, except it returns only the value (not a tuple) and raises on error.

rot45(in, optional \\ [])

Specs

rot45(Vix.Vips.Image.t(), [{:angle, vips_angle45()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Rotate an image

arguments
Arguments

in - Input image

optional
Optional

angle - Angle to rotate image. Default: :VIPS_ANGLE45_D45

rot45!(in, optional \\ [])

Specs

rot45!(Vix.Vips.Image.t(), [{:angle, vips_angle45()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as rot45/2, except it returns only the value (not a tuple) and raises on error.

rotate(in, angle, optional \\ [])

Specs

rotate(Vix.Vips.Image.t(), float(),
  idy: float(),
  idx: float(),
  ody: float(),
  odx: float(),
  background: [float()],
  interpolate: Vix.Vips.Interpolate.t()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Rotate an image by a number of degrees

arguments
Arguments

in - Input image argument
angle - Rotate anticlockwise by this many degrees

optional
Optional

idy - Vertical input displacement. Default: 0.0
idx - Horizontal input displacement. Default: 0.0
ody - Vertical output displacement. Default: 0.0
odx - Horizontal output displacement. Default: 0.0
background - Background value.
interpolate - Interpolate pixels with this.

rotate!(in, angle, optional \\ [])

Specs

rotate!(Vix.Vips.Image.t(), float(),
  idy: float(),
  idx: float(),
  ody: float(),
  odx: float(),
  background: [float()],
  interpolate: Vix.Vips.Interpolate.t()
) :: Vix.Vips.Image.t() | no_return()

Same as rotate/3, except it returns only the value (not a tuple) and raises on error.

round(in, round, optional \\ [])

Specs

round(Vix.Vips.Image.t(), vips_operation_round(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Perform a round function on an image

arguments
Arguments

in - Input image
round - rounding operation to perform

round!(in, round, optional \\ [])

Specs

round!(Vix.Vips.Image.t(), vips_operation_round(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as round/3, except it returns only the value (not a tuple) and raises on error.

scale(in, optional \\ [])

Specs

scale(Vix.Vips.Image.t(), log: boolean(), exp: float()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Scale an image to uchar

arguments
Arguments

in - Input image

optional
Optional

log - Log scale. Default: false
exp - Exponent for log scale. Default: 0.25

scale!(in, optional \\ [])

Specs

scale!(Vix.Vips.Image.t(), log: boolean(), exp: float()) ::
  Vix.Vips.Image.t() | no_return()

Same as scale/2, except it returns only the value (not a tuple) and raises on error.

scrgb2bw(in, optional \\ [])

Specs

scrgb2bw(Vix.Vips.Image.t(), [{:depth, integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Convert scrgb to bw

arguments
Arguments

in - Input image

optional
Optional

depth - Output device space depth in bits. Default: 8

scrgb2bw!(in, optional \\ [])

Specs

scrgb2bw!(Vix.Vips.Image.t(), [{:depth, integer()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as scrgb2bw/2, except it returns only the value (not a tuple) and raises on error.

scrgb2srgb(in, optional \\ [])

Specs

scrgb2srgb(Vix.Vips.Image.t(), [{:depth, integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Convert an scrgb image to srgb

arguments
Arguments

in - Input image

optional
Optional

depth - Output device space depth in bits. Default: 8

scrgb2srgb!(in, optional \\ [])

Specs

scrgb2srgb!(Vix.Vips.Image.t(), [{:depth, integer()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as scrgb2srgb/2, except it returns only the value (not a tuple) and raises on error.

scrgb2xyz(in, optional \\ [])

Specs

scrgb2xyz(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform scrgb to xyz

arguments
Arguments

in - Input image

scrgb2xyz!(in, optional \\ [])

Specs

scrgb2xyz!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as scrgb2xyz/2, except it returns only the value (not a tuple) and raises on error.

sequential(in, optional \\ [])

Specs

sequential(Vix.Vips.Image.t(),
  access: vips_access(),
  "tile-height": integer(),
  trace: boolean()
) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Check sequential access

arguments
Arguments

in - Input image

optional
Optional

access - Expected access pattern. Default: :VIPS_ACCESS_SEQUENTIAL
tile-height - Tile height in pixels. Default: 1
trace - trace pixel requests. Default: true

sequential!(in, optional \\ [])

Specs

sequential!(Vix.Vips.Image.t(),
  access: vips_access(),
  "tile-height": integer(),
  trace: boolean()
) ::
  Vix.Vips.Image.t() | no_return()

Same as sequential/2, except it returns only the value (not a tuple) and raises on error.

sharpen(in, optional \\ [])

Specs

sharpen(Vix.Vips.Image.t(),
  m2: float(),
  m1: float(),
  y3: float(),
  y2: float(),
  x1: float(),
  sigma: float(),
  radius: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Unsharp masking for print

arguments
Arguments

in - Input image

optional
Optional

m2 - Slope for jaggy areas. Default: 3.0
m1 - Slope for flat areas. Default: 0.0
y3 - Maximum darkening. Default: 20.0
y2 - Maximum brightening. Default: 10.0
x1 - Flat/jaggy threshold. Default: 2.0
sigma - Sigma of Gaussian. Default: 0.5
radius - radius of Gaussian. Default: 1

sharpen!(in, optional \\ [])

Specs

sharpen!(Vix.Vips.Image.t(),
  m2: float(),
  m1: float(),
  y3: float(),
  y2: float(),
  x1: float(),
  sigma: float(),
  radius: integer()
) :: Vix.Vips.Image.t() | no_return()

Same as sharpen/2, except it returns only the value (not a tuple) and raises on error.

shrink(in, hshrink, vshrink, optional \\ [])

Specs

shrink(Vix.Vips.Image.t(), float(), float(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Shrink an image

arguments
Arguments

in - Input image argument
hshrink - Horizontal shrink factor
vshrink - Vertical shrink factor

shrink!(in, hshrink, vshrink, optional \\ [])

Specs

shrink!(Vix.Vips.Image.t(), float(), float(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as shrink/4, except it returns only the value (not a tuple) and raises on error.

shrinkh(in, hshrink, optional \\ [])

Specs

shrinkh(Vix.Vips.Image.t(), integer(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Shrink an image horizontally

arguments
Arguments

in - Input image argument
hshrink - Horizontal shrink factor

shrinkh!(in, hshrink, optional \\ [])

Specs

shrinkh!(Vix.Vips.Image.t(), integer(), []) :: Vix.Vips.Image.t() | no_return()

Same as shrinkh/3, except it returns only the value (not a tuple) and raises on error.

shrinkv(in, vshrink, optional \\ [])

Specs

shrinkv(Vix.Vips.Image.t(), integer(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Shrink an image vertically

arguments
Arguments

in - Input image argument
vshrink - Vertical shrink factor

shrinkv!(in, vshrink, optional \\ [])

Specs

shrinkv!(Vix.Vips.Image.t(), integer(), []) :: Vix.Vips.Image.t() | no_return()

Same as shrinkv/3, except it returns only the value (not a tuple) and raises on error.

sign(in, optional \\ [])

Specs

sign(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Unit vector of pixel

arguments
Arguments

in - Input image

sign!(in, optional \\ [])

Specs

sign!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as sign/2, except it returns only the value (not a tuple) and raises on error.

similarity(in, optional \\ [])

Specs

similarity(Vix.Vips.Image.t(),
  idy: float(),
  idx: float(),
  ody: float(),
  odx: float(),
  background: [float()],
  interpolate: Vix.Vips.Interpolate.t(),
  angle: float(),
  scale: float()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Similarity transform of an image

arguments
Arguments

in - Input image argument

optional
Optional

idy - Vertical input displacement. Default: 0.0
idx - Horizontal input displacement. Default: 0.0
ody - Vertical output displacement. Default: 0.0
odx - Horizontal output displacement. Default: 0.0
background - Background value.
interpolate - Interpolate pixels with this.
angle - Rotate anticlockwise by this many degrees. Default: 0.0
scale - Scale by this factor. Default: 1.0

similarity!(in, optional \\ [])

Specs

similarity!(Vix.Vips.Image.t(),
  idy: float(),
  idx: float(),
  ody: float(),
  odx: float(),
  background: [float()],
  interpolate: Vix.Vips.Interpolate.t(),
  angle: float(),
  scale: float()
) :: Vix.Vips.Image.t() | no_return()

Same as similarity/2, except it returns only the value (not a tuple) and raises on error.

sines(width, height, optional \\ [])

Specs

sines(integer(), integer(), vfreq: float(), hfreq: float(), uchar: boolean()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a 2d sine wave

arguments
Arguments

width - Image width in pixels
height - Image height in pixels

optional
Optional

vfreq - Vertical spatial frequency. Default: 0.5
hfreq - Horizontal spatial frequency. Default: 0.5
uchar - Output an unsigned char image. Default: false

sines!(width, height, optional \\ [])

Specs

sines!(integer(), integer(), vfreq: float(), hfreq: float(), uchar: boolean()) ::
  Vix.Vips.Image.t() | no_return()

Same as sines/3, except it returns only the value (not a tuple) and raises on error.

smartcrop(input, width, height, optional \\ [])

Specs

smartcrop(Vix.Vips.Image.t(), integer(), integer(), [
  {:interesting, vips_interesting()}
]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Extract an area from an image

arguments
Arguments

input - Input image
width - Width of extract area
height - Height of extract area

optional
Optional

interesting - How to measure interestingness. Default: :VIPS_INTERESTING_ATTENTION

smartcrop!(input, width, height, optional \\ [])

Specs

smartcrop!(Vix.Vips.Image.t(), integer(), integer(), [
  {:interesting, vips_interesting()}
]) ::
  Vix.Vips.Image.t() | no_return()

Same as smartcrop/4, except it returns only the value (not a tuple) and raises on error.

sobel(in, optional \\ [])

Specs

sobel(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Sobel edge detector

arguments
Arguments

in - Input image

sobel!(in, optional \\ [])

Specs

sobel!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as sobel/2, except it returns only the value (not a tuple) and raises on error.

spcor(in, ref, optional \\ [])

Specs

spcor(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Spatial correlation

arguments
Arguments

in - Input image argument
ref - Input reference image

spcor!(in, ref, optional \\ [])

Specs

spcor!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as spcor/3, except it returns only the value (not a tuple) and raises on error.

spectrum(in, optional \\ [])

Specs

spectrum(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make displayable power spectrum

arguments
Arguments

in - Input image

spectrum!(in, optional \\ [])

Specs

spectrum!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as spectrum/2, except it returns only the value (not a tuple) and raises on error.

srgb2hsv(in, optional \\ [])

Specs

srgb2hsv(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform srgb to hsv

arguments
Arguments

in - Input image

srgb2hsv!(in, optional \\ [])

Specs

srgb2hsv!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as srgb2hsv/2, except it returns only the value (not a tuple) and raises on error.

srgb2scrgb(in, optional \\ [])

Specs

srgb2scrgb(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Convert an srgb image to scrgb

arguments
Arguments

in - Input image

srgb2scrgb!(in, optional \\ [])

Specs

srgb2scrgb!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as srgb2scrgb/2, except it returns only the value (not a tuple) and raises on error.

stats(in, optional \\ [])

Specs

stats(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Find many image stats

arguments
Arguments

in - Input image

stats!(in, optional \\ [])

Specs

stats!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as stats/2, except it returns only the value (not a tuple) and raises on error.

stdif(in, width, height, optional \\ [])

Specs

stdif(Vix.Vips.Image.t(), integer(), integer(),
  a: float(),
  m0: float(),
  b: float(),
  s0: float()
) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Statistical difference

arguments
Arguments

in - Input image
width - Window width in pixels
height - Window height in pixels

optional
Optional

a - Weight of new mean. Default: 0.5
m0 - New mean. Default: 128.0
b - Weight of new deviation. Default: 0.5
s0 - New deviation. Default: 50.0

stdif!(in, width, height, optional \\ [])

Specs

stdif!(Vix.Vips.Image.t(), integer(), integer(),
  a: float(),
  m0: float(),
  b: float(),
  s0: float()
) ::
  Vix.Vips.Image.t() | no_return()

Same as stdif/4, except it returns only the value (not a tuple) and raises on error.

subsample(input, xfac, yfac, optional \\ [])

Specs

subsample(Vix.Vips.Image.t(), integer(), integer(), [{:point, boolean()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Subsample an image

arguments
Arguments

input - Input image
xfac - Horizontal subsample factor
yfac - Vertical subsample factor

optional
Optional

point - Point sample. Default: false

subsample!(input, xfac, yfac, optional \\ [])

Specs

subsample!(Vix.Vips.Image.t(), integer(), integer(), [{:point, boolean()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as subsample/4, except it returns only the value (not a tuple) and raises on error.

subtract(left, right, optional \\ [])

Specs

subtract(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Subtract two images

arguments
Arguments

left - Left-hand image argument
right - Right-hand image argument

subtract!(left, right, optional \\ [])

Specs

subtract!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as subtract/3, except it returns only the value (not a tuple) and raises on error.

sum(in, optional \\ [])

Specs

sum([Vix.Vips.Image.t()], []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Sum an array of images

arguments
Arguments

in - Array of input images

sum!(in, optional \\ [])

Specs

sum!([Vix.Vips.Image.t()], []) :: Vix.Vips.Image.t() | no_return()

Same as sum/2, except it returns only the value (not a tuple) and raises on error.

svgload(filename, optional \\ [])

Specs

svgload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  unlimited: boolean(),
  scale: float(),
  dpi: float()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load svg with rsvg

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
unlimited - Allow SVG of any size. Default: false
scale - Scale output by this factor. Default: 1.0
dpi - Render at this DPI. Default: 72.0

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

svgload!(filename, optional \\ [])

Specs

svgload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  unlimited: boolean(),
  scale: float(),
  dpi: float()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as svgload/2, except it returns only the value (not a tuple) and raises on error.

svgload_buffer(buffer, optional \\ [])

Specs

svgload_buffer(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  unlimited: boolean(),
  scale: float(),
  dpi: float()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load svg with rsvg

arguments
Arguments

buffer - Buffer to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
unlimited - Allow SVG of any size. Default: false
scale - Scale output by this factor. Default: 1.0
dpi - Render at this DPI. Default: 72.0

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

svgload_buffer!(buffer, optional \\ [])

Specs

svgload_buffer!(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  unlimited: boolean(),
  scale: float(),
  dpi: float()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as svgload_buffer/2, except it returns only the value (not a tuple) and raises on error.

switch(tests, optional \\ [])

Specs

switch([Vix.Vips.Image.t()], []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

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

arguments
Arguments

tests - Table of images to test

switch!(tests, optional \\ [])

Specs

switch!([Vix.Vips.Image.t()], []) :: Vix.Vips.Image.t() | no_return()

Same as switch/2, except it returns only the value (not a tuple) and raises on error.

system(cmd-format, optional \\ [])

Specs

system(String.t(),
  "in-format": String.t(),
  "out-format": String.t(),
  in: [Vix.Vips.Image.t()]
) ::
  {:ok, {[log: String.t(), out: Vix.Vips.Image.t()]}} | {:error, term()}

Run an external command

arguments
Arguments

cmd-format - Command to run

optional
Optional

in-format - Format for input filename. Default: nil
out-format - Format for output filename. Default: nil
in - Array of input images.

returns
Returns

Ordered values in the returned tuple

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

log - Command log. (String.t())
out - Output image. (Vix.Vips.Image.t())

system!(cmd-format, optional \\ [])

Specs

system!(String.t(),
  "in-format": String.t(),
  "out-format": String.t(),
  in: [Vix.Vips.Image.t()]
) ::
  {[log: String.t(), out: Vix.Vips.Image.t()]} | no_return()

Same as system/2, except it returns only the value (not a tuple) and raises on error.

text(text, optional \\ [])

Specs

text(String.t(),
  fontfile: String.t(),
  spacing: integer(),
  justify: boolean(),
  dpi: integer(),
  rgba: boolean(),
  align: vips_align(),
  height: integer(),
  width: integer(),
  font: String.t()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:"autofit-dpi", integer()}]}} | {:error, term()}

Make a text image

arguments
Arguments

text - Text to render

optional
Optional

fontfile - Load this font file. Default: nil
spacing - Line spacing. Default: 0
justify - Justify lines. Default: false
dpi - DPI to render at. Default: 72
rgba - Enable RGBA output. Default: false
align - Align on the low, centre or high edge. Default: :VIPS_ALIGN_LOW
height - Maximum image height in pixels. Default: 0
width - Maximum image width in pixels. Default: 0
font - Font to render with. Default: nil

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

autofit-dpi - DPI selected by autofit. (integer())

text!(text, optional \\ [])

Specs

text!(String.t(),
  fontfile: String.t(),
  spacing: integer(),
  justify: boolean(),
  dpi: integer(),
  rgba: boolean(),
  align: vips_align(),
  height: integer(),
  width: integer(),
  font: String.t()
) :: {Vix.Vips.Image.t(), [{:"autofit-dpi", integer()}]} | no_return()

Same as text/2, except it returns only the value (not a tuple) and raises on error.

thumbnail(filename, width, optional \\ [])

Specs

thumbnail(String.t(), integer(),
  "auto-rotate": boolean(),
  intent: vips_intent(),
  "export-profile": String.t(),
  "import-profile": String.t(),
  linear: boolean(),
  crop: vips_interesting(),
  "no-rotate": boolean(),
  size: vips_size(),
  height: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Generate thumbnail from file

arguments
Arguments

filename - Filename to read from
width - Size to this width

optional
Optional

auto-rotate - Use orientation tags to rotate image upright. Default: true
intent - Rendering intent. Default: :VIPS_INTENT_RELATIVE
export-profile - Fallback export profile. Default: nil
import-profile - Fallback import profile. Default: nil
linear - Reduce in linear light. Default: false
crop - Reduce to fill target rectangle, then crop. Default: :VIPS_INTERESTING_NONE
no-rotate - Don't use orientation tags to rotate image upright. Default: false
size - Only upsize, only downsize, or both. Default: :VIPS_SIZE_BOTH
height - Size to this height. Default: 1

thumbnail!(filename, width, optional \\ [])

Specs

thumbnail!(String.t(), integer(),
  "auto-rotate": boolean(),
  intent: vips_intent(),
  "export-profile": String.t(),
  "import-profile": String.t(),
  linear: boolean(),
  crop: vips_interesting(),
  "no-rotate": boolean(),
  size: vips_size(),
  height: integer()
) :: Vix.Vips.Image.t() | no_return()

Same as thumbnail/3, except it returns only the value (not a tuple) and raises on error.

thumbnail_buffer(buffer, width, optional \\ [])

Specs

thumbnail_buffer(binary(), integer(),
  "auto-rotate": boolean(),
  intent: vips_intent(),
  "export-profile": String.t(),
  "import-profile": String.t(),
  linear: boolean(),
  crop: vips_interesting(),
  "no-rotate": boolean(),
  size: vips_size(),
  height: integer(),
  "option-string": String.t()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Generate thumbnail from buffer

arguments
Arguments

buffer - Buffer to load from
width - Size to this width

optional
Optional

auto-rotate - Use orientation tags to rotate image upright. Default: true
intent - Rendering intent. Default: :VIPS_INTENT_RELATIVE
export-profile - Fallback export profile. Default: nil
import-profile - Fallback import profile. Default: nil
linear - Reduce in linear light. Default: false
crop - Reduce to fill target rectangle, then crop. Default: :VIPS_INTERESTING_NONE
no-rotate - Don't use orientation tags to rotate image upright. Default: false
size - Only upsize, only downsize, or both. Default: :VIPS_SIZE_BOTH
height - Size to this height. Default: 1
option-string - Options that are passed on to the underlying loader. Default: ""

thumbnail_buffer!(buffer, width, optional \\ [])

Specs

thumbnail_buffer!(binary(), integer(),
  "auto-rotate": boolean(),
  intent: vips_intent(),
  "export-profile": String.t(),
  "import-profile": String.t(),
  linear: boolean(),
  crop: vips_interesting(),
  "no-rotate": boolean(),
  size: vips_size(),
  height: integer(),
  "option-string": String.t()
) :: Vix.Vips.Image.t() | no_return()

Same as thumbnail_buffer/3, except it returns only the value (not a tuple) and raises on error.

thumbnail_image(in, width, optional \\ [])

Specs

thumbnail_image(Vix.Vips.Image.t(), integer(),
  "auto-rotate": boolean(),
  intent: vips_intent(),
  "export-profile": String.t(),
  "import-profile": String.t(),
  linear: boolean(),
  crop: vips_interesting(),
  "no-rotate": boolean(),
  size: vips_size(),
  height: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Generate thumbnail from image

arguments
Arguments

in - Input image argument
width - Size to this width

optional
Optional

auto-rotate - Use orientation tags to rotate image upright. Default: true
intent - Rendering intent. Default: :VIPS_INTENT_RELATIVE
export-profile - Fallback export profile. Default: nil
import-profile - Fallback import profile. Default: nil
linear - Reduce in linear light. Default: false
crop - Reduce to fill target rectangle, then crop. Default: :VIPS_INTERESTING_NONE
no-rotate - Don't use orientation tags to rotate image upright. Default: false
size - Only upsize, only downsize, or both. Default: :VIPS_SIZE_BOTH
height - Size to this height. Default: 1

thumbnail_image!(in, width, optional \\ [])

Specs

thumbnail_image!(Vix.Vips.Image.t(), integer(),
  "auto-rotate": boolean(),
  intent: vips_intent(),
  "export-profile": String.t(),
  "import-profile": String.t(),
  linear: boolean(),
  crop: vips_interesting(),
  "no-rotate": boolean(),
  size: vips_size(),
  height: integer()
) :: Vix.Vips.Image.t() | no_return()

Same as thumbnail_image/3, except it returns only the value (not a tuple) and raises on error.

tiffload(filename, optional \\ [])

Specs

tiffload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  autorotate: boolean(),
  n: integer(),
  subifd: integer(),
  page: integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load tiff from file

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
autorotate - Rotate image using orientation tag. Default: false
n - Load this many pages. Default: 1
subifd - Select subifd index. Default: -1
page - Load this page from the image. Default: 0

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

tiffload!(filename, optional \\ [])

Specs

tiffload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  autorotate: boolean(),
  n: integer(),
  subifd: integer(),
  page: integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as tiffload/2, except it returns only the value (not a tuple) and raises on error.

tiffload_buffer(buffer, optional \\ [])

Specs

tiffload_buffer(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  autorotate: boolean(),
  n: integer(),
  subifd: integer(),
  page: integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load tiff from buffer

arguments
Arguments

buffer - Buffer to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
autorotate - Rotate image using orientation tag. Default: false
n - Load this many pages. Default: 1
subifd - Select subifd index. Default: -1
page - Load this page from the image. Default: 0

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

tiffload_buffer!(buffer, optional \\ [])

Specs

tiffload_buffer!(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  autorotate: boolean(),
  n: integer(),
  subifd: integer(),
  page: integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as tiffload_buffer/2, except it returns only the value (not a tuple) and raises on error.

tiffsave(in, filename, optional \\ [])

Specs

tiffsave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  premultiply: boolean(),
  subifd: boolean(),
  depth: vips_foreign_dz_depth(),
  lossless: boolean(),
  level: integer(),
  "region-shrink": vips_region_shrink(),
  properties: boolean(),
  rgbjpeg: boolean(),
  bigtiff: boolean(),
  yres: float(),
  xres: float(),
  resunit: vips_foreign_tiff_resunit(),
  bitdepth: integer(),
  miniswhite: boolean(),
  squash: boolean(),
  pyramid: boolean(),
  "tile-height": integer(),
  "tile-width": integer(),
  tile: boolean(),
  profile: String.t(),
  predictor: vips_foreign_tiff_predictor(),
  Q: integer(),
  compression: vips_foreign_tiff_compression()
) :: :ok | {:error, term()}

Save image to tiff file

arguments
Arguments

in - Image to save
filename - Filename to save to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
premultiply - Save with premultiplied alpha. Default: false
subifd - Save pyr layers as sub-IFDs. Default: false
depth - Pyramid depth. Default: :VIPS_FOREIGN_DZ_DEPTH_ONETILE
lossless - Enable WEBP lossless mode. Default: false
level - ZSTD compression level. Default: 10
region-shrink - Method to shrink regions. Default: :VIPS_REGION_SHRINK_MEAN
properties - Write a properties document to IMAGEDESCRIPTION. Default: false
rgbjpeg - Output RGB JPEG rather than YCbCr. Default: false
bigtiff - Write a bigtiff image. Default: false
yres - Vertical resolution in pixels/mm. Default: 1.0
xres - Horizontal resolution in pixels/mm. Default: 1.0
resunit - Resolution unit. Default: :VIPS_FOREIGN_TIFF_RESUNIT_CM
bitdepth - Write as a 1, 2, 4 or 8 bit image. Default: 0
miniswhite - Use 0 for white in 1-bit images. Default: false
squash - Squash images down to 1 bit. Default: false
pyramid - Write a pyramidal tiff. Default: false
tile-height - Tile height in pixels. Default: 128
tile-width - Tile width in pixels. Default: 128
tile - Write a tiled tiff. Default: false
profile - ICC profile to embed. Default: nil
predictor - Compression prediction. Default: :VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL
Q - Q factor. Default: 75
compression - Compression for this file. Default: :VIPS_FOREIGN_TIFF_COMPRESSION_NONE

tiffsave!(in, filename, optional \\ [])

Specs

tiffsave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  premultiply: boolean(),
  subifd: boolean(),
  depth: vips_foreign_dz_depth(),
  lossless: boolean(),
  level: integer(),
  "region-shrink": vips_region_shrink(),
  properties: boolean(),
  rgbjpeg: boolean(),
  bigtiff: boolean(),
  yres: float(),
  xres: float(),
  resunit: vips_foreign_tiff_resunit(),
  bitdepth: integer(),
  miniswhite: boolean(),
  squash: boolean(),
  pyramid: boolean(),
  "tile-height": integer(),
  "tile-width": integer(),
  tile: boolean(),
  profile: String.t(),
  predictor: vips_foreign_tiff_predictor(),
  Q: integer(),
  compression: vips_foreign_tiff_compression()
) :: :ok | no_return()

Same as tiffsave/3, except it returns only the value (not a tuple) and raises on error.

tiffsave_buffer(in, optional \\ [])

Specs

tiffsave_buffer(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  premultiply: boolean(),
  subifd: boolean(),
  depth: vips_foreign_dz_depth(),
  lossless: boolean(),
  level: integer(),
  "region-shrink": vips_region_shrink(),
  properties: boolean(),
  rgbjpeg: boolean(),
  bigtiff: boolean(),
  yres: float(),
  xres: float(),
  resunit: vips_foreign_tiff_resunit(),
  bitdepth: integer(),
  miniswhite: boolean(),
  squash: boolean(),
  pyramid: boolean(),
  "tile-height": integer(),
  "tile-width": integer(),
  tile: boolean(),
  profile: String.t(),
  predictor: vips_foreign_tiff_predictor(),
  Q: integer(),
  compression: vips_foreign_tiff_compression()
) :: {:ok, binary()} | {:error, term()}

Save image to tiff buffer

arguments
Arguments

in - Image to save

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
premultiply - Save with premultiplied alpha. Default: false
subifd - Save pyr layers as sub-IFDs. Default: false
depth - Pyramid depth. Default: :VIPS_FOREIGN_DZ_DEPTH_ONETILE
lossless - Enable WEBP lossless mode. Default: false
level - ZSTD compression level. Default: 10
region-shrink - Method to shrink regions. Default: :VIPS_REGION_SHRINK_MEAN
properties - Write a properties document to IMAGEDESCRIPTION. Default: false
rgbjpeg - Output RGB JPEG rather than YCbCr. Default: false
bigtiff - Write a bigtiff image. Default: false
yres - Vertical resolution in pixels/mm. Default: 1.0
xres - Horizontal resolution in pixels/mm. Default: 1.0
resunit - Resolution unit. Default: :VIPS_FOREIGN_TIFF_RESUNIT_CM
bitdepth - Write as a 1, 2, 4 or 8 bit image. Default: 0
miniswhite - Use 0 for white in 1-bit images. Default: false
squash - Squash images down to 1 bit. Default: false
pyramid - Write a pyramidal tiff. Default: false
tile-height - Tile height in pixels. Default: 128
tile-width - Tile width in pixels. Default: 128
tile - Write a tiled tiff. Default: false
profile - ICC profile to embed. Default: nil
predictor - Compression prediction. Default: :VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL
Q - Q factor. Default: 75
compression - Compression for this file. Default: :VIPS_FOREIGN_TIFF_COMPRESSION_NONE

tiffsave_buffer!(in, optional \\ [])

Specs

tiffsave_buffer!(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  premultiply: boolean(),
  subifd: boolean(),
  depth: vips_foreign_dz_depth(),
  lossless: boolean(),
  level: integer(),
  "region-shrink": vips_region_shrink(),
  properties: boolean(),
  rgbjpeg: boolean(),
  bigtiff: boolean(),
  yres: float(),
  xres: float(),
  resunit: vips_foreign_tiff_resunit(),
  bitdepth: integer(),
  miniswhite: boolean(),
  squash: boolean(),
  pyramid: boolean(),
  "tile-height": integer(),
  "tile-width": integer(),
  tile: boolean(),
  profile: String.t(),
  predictor: vips_foreign_tiff_predictor(),
  Q: integer(),
  compression: vips_foreign_tiff_compression()
) :: binary() | no_return()

Same as tiffsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

tilecache(in, optional \\ [])

Specs

tilecache(Vix.Vips.Image.t(),
  persistent: boolean(),
  threaded: boolean(),
  access: vips_access(),
  "max-tiles": integer(),
  "tile-height": integer(),
  "tile-width": integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Cache an image as a set of tiles

arguments
Arguments

in - Input image

optional
Optional

persistent - Keep cache between evaluations. Default: false
threaded - Allow threaded access. Default: false
access - Expected access pattern. Default: :VIPS_ACCESS_RANDOM
max-tiles - Maximum number of tiles to cache. Default: 1000
tile-height - Tile height in pixels. Default: 128
tile-width - Tile width in pixels. Default: 128

tilecache!(in, optional \\ [])

Specs

tilecache!(Vix.Vips.Image.t(),
  persistent: boolean(),
  threaded: boolean(),
  access: vips_access(),
  "max-tiles": integer(),
  "tile-height": integer(),
  "tile-width": integer()
) :: Vix.Vips.Image.t() | no_return()

Same as tilecache/2, except it returns only the value (not a tuple) and raises on error.

tonelut(optional \\ [])

Specs

tonelut(
  H: float(),
  M: float(),
  S: float(),
  Ph: float(),
  Pm: float(),
  Ps: float(),
  Lw: float(),
  Lb: float(),
  "out-max": integer(),
  "in-max": integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Build a look-up table

arguments
Arguments

optional
Optional

H - Adjust highlights by this much. Default: 0.0
M - Adjust mid-tones by this much. Default: 0.0
S - Adjust shadows by this much. Default: 0.0
Ph - Position of highlights. Default: 0.8
Pm - Position of mid-tones. Default: 0.5
Ps - Position of shadow. Default: 0.2
Lw - Highest value in output. Default: 100.0
Lb - Lowest value in output. Default: 0.0
out-max - Maximum value in output LUT. Default: 32767
in-max - Size of LUT to build. Default: 32767

tonelut!(optional \\ [])

Specs

tonelut!(
  H: float(),
  M: float(),
  S: float(),
  Ph: float(),
  Pm: float(),
  Ps: float(),
  Lw: float(),
  Lb: float(),
  "out-max": integer(),
  "in-max": integer()
) :: Vix.Vips.Image.t() | no_return()

Same as tonelut/1, except it returns only the value (not a tuple) and raises on error.

transpose3d(in, optional \\ [])

Specs

transpose3d(Vix.Vips.Image.t(), [{:"page-height", integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transpose3d an image

arguments
Arguments

in - Input image

optional
Optional

page-height - Height of each input page. Default: 0

transpose3d!(in, optional \\ [])

Specs

transpose3d!(Vix.Vips.Image.t(), [{:"page-height", integer()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as transpose3d/2, except it returns only the value (not a tuple) and raises on error.

unpremultiply(in, optional \\ [])

Specs

unpremultiply(Vix.Vips.Image.t(), "alpha-band": integer(), "max-alpha": float()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Unpremultiply image alpha

arguments
Arguments

in - Input image

optional
Optional

alpha-band - Unpremultiply with this alpha. Default: 3
max-alpha - Maximum value of alpha channel. Default: 255.0

unpremultiply!(in, optional \\ [])

Specs

unpremultiply!(Vix.Vips.Image.t(), "alpha-band": integer(), "max-alpha": float()) ::
  Vix.Vips.Image.t() | no_return()

Same as unpremultiply/2, except it returns only the value (not a tuple) and raises on error.

vipsload(filename, optional \\ [])

Specs

vipsload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load vips from file

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

vipsload!(filename, optional \\ [])

Specs

vipsload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as vipsload/2, except it returns only the value (not a tuple) and raises on error.

vipssave(in, filename, optional \\ [])

Specs

vipssave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) :: :ok | {:error, term()}

Save image to file in vips format

arguments
Arguments

in - Image to save
filename - Filename to save to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false

vipssave!(in, filename, optional \\ [])

Specs

vipssave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean()
) :: :ok | no_return()

Same as vipssave/3, except it returns only the value (not a tuple) and raises on error.

webpload(filename, optional \\ [])

Specs

webpload(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  shrink: integer(),
  scale: float(),
  n: integer(),
  page: integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load webp from file

arguments
Arguments

filename - Filename to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
shrink - Shrink factor on load. Default: 1
scale - Scale factor on load. Default: 1.0
n - Load this many pages. Default: 1
page - Load this page from the file. Default: 0

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

webpload!(filename, optional \\ [])

Specs

webpload!(String.t(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  shrink: integer(),
  scale: float(),
  n: integer(),
  page: integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as webpload/2, except it returns only the value (not a tuple) and raises on error.

webpload_buffer(buffer, optional \\ [])

Specs

webpload_buffer(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  shrink: integer(),
  scale: float(),
  n: integer(),
  page: integer()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]}}
  | {:error, term()}

Load webp from buffer

arguments
Arguments

buffer - Buffer to load from

optional
Optional

disc - Open to disc. Default: true
fail - Fail on first warning. Default: false
sequential - Sequential read only. Default: false
fail-on - Error level to fail on. Default: :VIPS_FAIL_ON_NONE
access - Required access pattern for this file. Default: :VIPS_ACCESS_RANDOM
memory - Force open via memory. Default: false
shrink - Shrink factor on load. Default: 1
scale - Scale factor on load. Default: 1.0
n - Load this many pages. Default: 1
page - Load this page from the file. Default: 0

returns
Returns

Ordered values in the returned tuple

out - Output image. (Vix.Vips.Image.t())

additional
Additional

Last value of the the output tuple is a keyword list of additional optional output values

flags - Flags for this file. (vips_foreign_flags)

webpload_buffer!(buffer, optional \\ [])

Specs

webpload_buffer!(binary(),
  disc: boolean(),
  fail: boolean(),
  sequential: boolean(),
  "fail-on": vips_fail_on(),
  access: vips_access(),
  memory: boolean(),
  shrink: integer(),
  scale: float(),
  n: integer(),
  page: integer()
) :: {Vix.Vips.Image.t(), [{:flags, vips_foreign_flags()}]} | no_return()

Same as webpload_buffer/2, except it returns only the value (not a tuple) and raises on error.

webpsave(in, filename, optional \\ [])

Specs

webpsave(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "reduction-effort": integer(),
  profile: String.t(),
  effort: integer(),
  kmax: integer(),
  kmin: integer(),
  "min-size": boolean(),
  "alpha-q": integer(),
  "near-lossless": boolean(),
  "smart-subsample": boolean(),
  preset: vips_foreign_webp_preset(),
  lossless: boolean(),
  Q: integer()
) :: :ok | {:error, term()}

Save image to webp file

arguments
Arguments

in - Image to save
filename - Filename to save to

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
reduction-effort - Level of CPU effort to reduce file size. Default: 4
profile - ICC profile to embed. Default: nil
effort - Level of CPU effort to reduce file size. Default: 4
kmax - Maximum number of frames between key frames. Default: 2147483647
kmin - Minimum number of frames between key frames. Default: 2147483646
min-size - Optimise for minium size. Default: false
alpha-q - Change alpha plane fidelity for lossy compression. Default: 100
near-lossless - Enable preprocessing in lossless mode (uses Q). Default: false
smart-subsample - Enable high quality chroma subsampling. Default: false
preset - Preset for lossy compression. Default: :VIPS_FOREIGN_WEBP_PRESET_DEFAULT
lossless - enable lossless compression. Default: false
Q - Q factor. Default: 75

webpsave!(in, filename, optional \\ [])

Specs

webpsave!(Vix.Vips.Image.t(), String.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "reduction-effort": integer(),
  profile: String.t(),
  effort: integer(),
  kmax: integer(),
  kmin: integer(),
  "min-size": boolean(),
  "alpha-q": integer(),
  "near-lossless": boolean(),
  "smart-subsample": boolean(),
  preset: vips_foreign_webp_preset(),
  lossless: boolean(),
  Q: integer()
) :: :ok | no_return()

Same as webpsave/3, except it returns only the value (not a tuple) and raises on error.

webpsave_buffer(in, optional \\ [])

Specs

webpsave_buffer(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "reduction-effort": integer(),
  profile: String.t(),
  effort: integer(),
  kmax: integer(),
  kmin: integer(),
  "min-size": boolean(),
  "alpha-q": integer(),
  "near-lossless": boolean(),
  "smart-subsample": boolean(),
  preset: vips_foreign_webp_preset(),
  lossless: boolean(),
  Q: integer()
) :: {:ok, binary()} | {:error, term()}

Save image to webp buffer

arguments
Arguments

in - Image to save

optional
Optional

page-height - Set page height for multipage save. Default: 0
background - Background value.
strip - Strip all metadata from image. Default: false
reduction-effort - Level of CPU effort to reduce file size. Default: 4
profile - ICC profile to embed. Default: nil
effort - Level of CPU effort to reduce file size. Default: 4
kmax - Maximum number of frames between key frames. Default: 2147483647
kmin - Minimum number of frames between key frames. Default: 2147483646
min-size - Optimise for minium size. Default: false
alpha-q - Change alpha plane fidelity for lossy compression. Default: 100
near-lossless - Enable preprocessing in lossless mode (uses Q). Default: false
smart-subsample - Enable high quality chroma subsampling. Default: false
preset - Preset for lossy compression. Default: :VIPS_FOREIGN_WEBP_PRESET_DEFAULT
lossless - enable lossless compression. Default: false
Q - Q factor. Default: 75

webpsave_buffer!(in, optional \\ [])

Specs

webpsave_buffer!(Vix.Vips.Image.t(),
  "page-height": integer(),
  background: [float()],
  strip: boolean(),
  "reduction-effort": integer(),
  profile: String.t(),
  effort: integer(),
  kmax: integer(),
  kmin: integer(),
  "min-size": boolean(),
  "alpha-q": integer(),
  "near-lossless": boolean(),
  "smart-subsample": boolean(),
  preset: vips_foreign_webp_preset(),
  lossless: boolean(),
  Q: integer()
) :: binary() | no_return()

Same as webpsave_buffer/2, except it returns only the value (not a tuple) and raises on error.

worley(width, height, optional \\ [])

Specs

worley(integer(), integer(), seed: integer(), "cell-size": integer()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a worley noise image

arguments
Arguments

width - Image width in pixels
height - Image height in pixels

optional
Optional

seed - Random number seed. Default: 0
cell-size - Size of Worley cells. Default: 256

worley!(width, height, optional \\ [])

Specs

worley!(integer(), integer(), seed: integer(), "cell-size": integer()) ::
  Vix.Vips.Image.t() | no_return()

Same as worley/3, except it returns only the value (not a tuple) and raises on error.

wrap(in, optional \\ [])

Specs

wrap(Vix.Vips.Image.t(), y: integer(), x: integer()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Wrap image origin

arguments
Arguments

in - Input image

optional
Optional

y - Top edge of input in output. Default: 0
x - Left edge of input in output. Default: 0

wrap!(in, optional \\ [])

Specs

wrap!(Vix.Vips.Image.t(), y: integer(), x: integer()) ::
  Vix.Vips.Image.t() | no_return()

Same as wrap/2, except it returns only the value (not a tuple) and raises on error.

xyz(width, height, optional \\ [])

Specs

xyz(integer(), integer(), esize: integer(), dsize: integer(), csize: integer()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make an image where pixel values are coordinates

arguments
Arguments

width - Image width in pixels
height - Image height in pixels

optional
Optional

esize - Size of fifth dimension. Default: 1
dsize - Size of fourth dimension. Default: 1
csize - Size of third dimension. Default: 1

xyz!(width, height, optional \\ [])

Specs

xyz!(integer(), integer(), esize: integer(), dsize: integer(), csize: integer()) ::
  Vix.Vips.Image.t() | no_return()

Same as xyz/3, except it returns only the value (not a tuple) and raises on error.

xyz2cmyk(in, optional \\ [])

Specs

xyz2cmyk(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform xyz to cmyk

arguments
Arguments

in - Input image

xyz2cmyk!(in, optional \\ [])

Specs

xyz2cmyk!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as xyz2cmyk/2, except it returns only the value (not a tuple) and raises on error.

xyz2lab(in, optional \\ [])

Specs

xyz2lab(Vix.Vips.Image.t(), [{:temp, [float()]}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform xyz to lab

arguments
Arguments

in - Input image

optional
Optional

temp - Colour temperature.

xyz2lab!(in, optional \\ [])

Specs

xyz2lab!(Vix.Vips.Image.t(), [{:temp, [float()]}]) ::
  Vix.Vips.Image.t() | no_return()

Same as xyz2lab/2, except it returns only the value (not a tuple) and raises on error.

xyz2scrgb(in, optional \\ [])

Specs

xyz2scrgb(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform xyz to scrgb

arguments
Arguments

in - Input image

xyz2scrgb!(in, optional \\ [])

Specs

xyz2scrgb!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as xyz2scrgb/2, except it returns only the value (not a tuple) and raises on error.

xyz2yxy(in, optional \\ [])

Specs

xyz2yxy(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform xyz to yxy

arguments
Arguments

in - Input image

xyz2yxy!(in, optional \\ [])

Specs

xyz2yxy!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as xyz2yxy/2, except it returns only the value (not a tuple) and raises on error.

yxy2xyz(in, optional \\ [])

Specs

yxy2xyz(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform yxy to xyz

arguments
Arguments

in - Input image

yxy2xyz!(in, optional \\ [])

Specs

yxy2xyz!(Vix.Vips.Image.t(), []) :: Vix.Vips.Image.t() | no_return()

Same as yxy2xyz/2, except it returns only the value (not a tuple) and raises on error.

zone(width, height, optional \\ [])

Specs

zone(integer(), integer(), [{:uchar, boolean()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a zone plate

arguments
Arguments

width - Image width in pixels
height - Image height in pixels

optional
Optional

uchar - Output an unsigned char image. Default: false

zone!(width, height, optional \\ [])

Specs

zone!(integer(), integer(), [{:uchar, boolean()}]) ::
  Vix.Vips.Image.t() | no_return()

Same as zone/3, except it returns only the value (not a tuple) and raises on error.

zoom(input, xfac, yfac, optional \\ [])

Specs

zoom(Vix.Vips.Image.t(), integer(), integer(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Zoom an image

arguments
Arguments

input - Input image
xfac - Horizontal zoom factor
yfac - Vertical zoom factor

zoom!(input, xfac, yfac, optional \\ [])

Specs

zoom!(Vix.Vips.Image.t(), integer(), integer(), []) ::
  Vix.Vips.Image.t() | no_return()

Same as zoom/4, except it returns only the value (not a tuple) and raises on error.

Settings View Source Vix.Vips.Operation (vix v0.9.0)

Link to this section Summary

Types

Functions

Link to this section Types

gsf_output_csv_quoting_mode()

Specs

vips_access()

Specs

vips_align()

Specs

vips_angle()

Specs

vips_angle45()

Specs

vips_band_format()

Specs

vips_blend_mode()

Specs

vips_coding()

Specs

vips_combine()

Specs

vips_combine_mode()

Specs

vips_compass_direction()

Specs

vips_demand_style()

Specs

vips_direction()

Specs

vips_extend()

Specs

vips_fail_on()

Specs

vips_foreign_dz_container()

Specs

vips_foreign_dz_depth()

Specs

vips_foreign_dz_layout()

Specs

vips_foreign_flags()

Specs

vips_foreign_heif_compression()

Specs

vips_foreign_png_filter()

Specs

vips_foreign_ppm_format()

Specs

vips_foreign_subsample()

Specs

vips_foreign_tiff_compression()

Specs

vips_foreign_tiff_predictor()

Specs

vips_foreign_tiff_resunit()

Specs

vips_foreign_webp_preset()

Specs

vips_intent()

Specs

vips_interesting()

Specs

vips_interpretation()

Specs

vips_kernel()

Specs

vips_operation_boolean()

Specs

vips_operation_complex()

Specs

vips_operation_complex2()

Specs

vips_operation_complexget()

Specs

vips_operation_math()

Specs

vips_operation_math2()

Specs

vips_operation_morphology()

View Source Vix.Vips.Operation (vix v0.9.0)

arguments
Arguments

arguments
Arguments

arguments
Arguments

optional
Optional

arguments
Arguments

optional
Optional

returns
Returns

additional
Additional

arguments
Arguments

optional
Optional

arguments
Arguments

returns
Returns

additional
Additional

arguments
Arguments

arguments
Arguments

arguments
Arguments

optional
Optional

arguments
Arguments