View Source Vix.Vips.Operation (vix v0.11.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

Functions

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

Absolute value of an image

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

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

Affine transform of an image

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

Load an analyze6 image

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

Join an array of images

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

Autorotate image by exif tag

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

Find image average

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

Boolean operation across image bands

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

Fold up x axis into bands

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

Bandwise join a set of images

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

Append a constant band to an image

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

Band-wise average

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

Band-wise rank of a set of images

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

Unfold image bands into x axis

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

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

Boolean operation on two images

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

Boolean operations against a constant

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

Build a look-up table

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

Byteswap an image

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

Cache an image

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

Canny edge detector

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

Use pixel values to pick cases from an array of images

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

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

Transform lch to cmc

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

Transform cmyk to xyz

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

Convert to a new colorspace

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

Convolve with rotating mask

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

Complex binary operations on two images

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

Perform a complex operation on an image

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

Form a complex image from two real images

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

Get a component from a complex image

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

Blend a pair of images with a blend mode

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

Blend an array of images with an array of blend modes

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

Convolution operation

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

Approximate integer convolution

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

Approximate separable integer convolution

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

Float convolution operation

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

Int convolution operation

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

Seperable convolution operation

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

Copy an image

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

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

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

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

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

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

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

Find image standard deviation

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

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

Save image to deepzoom file

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

Save image to dz buffer

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

Embed an image in a larger image

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

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

Extract band from an image

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

Make an image showing the eye's spatial response

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

False-color an image

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

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

Fill image zeros with nearest non-zero pixel

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

Search an image for non-edge areas

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

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

Save image to fits file

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

Flatten alpha out of an image

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

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

Transform float rgb to radiance coding

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

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

Frequency-domain filtering

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

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

Gamma an image

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

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

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

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

Read a point from an image

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

Load gif with libnsgif

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

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

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

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

Global balance an image mosaic

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

Place an image within a larger image with a certain gravity

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

Make a grey ramp image

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

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

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

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

Save image in heif format

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

Save image in heif format

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

Form cumulative histogram

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

Estimate image entropy

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

Histogram equalisation

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

Find image histogram

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

Find indexed image histogram

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

Find n-dimensional image histogram

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

Test for monotonicity

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

Local histogram equalisation

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

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

Normalise histogram

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

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

Find hough circle transform

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

Find hough line transform

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

Transform hsv to srgb

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

Output to device with icc profile

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

Import from device with icc profile

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

Transform between devices with icc profiles

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

Make a 1d image where pixel values are indexes

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

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

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

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

Invert an image

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

Build an inverted look-up table

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

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

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

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

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

Save image in jpeg2000 format

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

Save image in jpeg2000 format

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

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

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

Save image to jpeg file

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

Save image to jpeg buffer

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

Save image to jpeg mime

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

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

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

Save image in jpeg-xl format

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

Save image in jpeg-xl format

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

Transform float lab to labq coding

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

Transform float lab to signed short

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

Transform lab to lch

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

Transform cielab to xyz

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

Label regions in an image

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

Unpack a labq image to float lab

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

Unpack a labq image to short lab

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

Convert a labq image to srgb

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

Transform signed short lab to float

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

Transform short lab to labq coding

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

Transform lch to cmc

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

Transform lch to lab

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

Calculate (a * in + b)

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

Cache an image as a set of lines

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

Make a laplacian of gaussian image

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

Load file with imagemagick7

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

Load buffer with imagemagick7

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

Save file with imagemagick

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

Save image to magick buffer

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

Resample with a map image

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

Map an image though a lut

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

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

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

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

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

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

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

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

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

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

Binary math operations with a constant

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

Apply a math operation to an image

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

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

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

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

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

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

Find image maximum

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

Measure a set of patches on a color chart

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

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

Find image minimum

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

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

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

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

Pick most-significant byte from an image

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

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

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

Load file with openslide

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

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

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

Find threshold for percent of pixels

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

Make a perlin noise image

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

Calculate phase correlation

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

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

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

Save image to png file

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

Save image to png buffer

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

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

Save image to ppm file

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

Premultiply image alpha

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

Find image profiles

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

Load named icc profile

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

Find image projections

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

Resample an image with a quadratic transform

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

Unpack radiance coding to float rgb

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

Load a radiance image from a file

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

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

Save image to radiance file

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

Save image to radiance buffer

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

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

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

Save image to raw file

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

Write raw image to file descriptor

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

Linear recombination with matrix

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

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

Shrink an image horizontally

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

Shrink an image vertically

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

Relational operation on two images

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

Relational operations against a constant

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

Remainder after integer division of two images

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

Remainder after integer division of an image and a constant

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

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

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

Rotate an image

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

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

Rotate an image by a number of degrees

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

Perform a round function on an image

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

Scale an image to uchar

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

Convert scrgb to bw

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

Convert an scrgb image to srgb

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

Transform scrgb to xyz

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

Check sequential access

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

Unsharp masking for print

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

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

Shrink an image horizontally

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

Shrink an image vertically

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

Unit vector of pixel

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

Similarity transform of an image

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

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

Extract an area from an image

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

Sobel edge detector

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

Spatial correlation

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

Make displayable power spectrum

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

Transform srgb to hsv

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

Convert an srgb image to scrgb

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

Find many image stats

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

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

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

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

Sum an array of images

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

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

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

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

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

Run an external command

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

Make a text image

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

Generate thumbnail from file

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

Generate thumbnail from buffer

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

Generate thumbnail from image

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

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

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

Save image to tiff file

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

Save image to tiff buffer

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

Cache an image as a set of tiles

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

Build a look-up table

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

Transpose3d an image

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

Unpremultiply image alpha

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

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

Save image to file in vips format

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

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

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

Save image to webp file

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

Save image to webp buffer

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

Make a worley noise image

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

Wrap image origin

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

Transform xyz to cmyk

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

Transform xyz to lab

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

Transform xyz to scrgb

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

Transform xyz to yxy

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

Make an image where pixel values are coordinates

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

Transform yxy to xyz

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

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

Link to this section Types

Link to this type

gsf_output_csv_quoting_mode()

View Source
@type gsf_output_csv_quoting_mode() ::
  :GSF_OUTPUT_CSV_QUOTING_MODE_NEVER | :GSF_OUTPUT_CSV_QUOTING_MODE_AUTO
@type vips_access() ::
  :VIPS_ACCESS_RANDOM
  | :VIPS_ACCESS_SEQUENTIAL
  | :VIPS_ACCESS_SEQUENTIAL_UNBUFFERED
@type vips_align() :: :VIPS_ALIGN_LOW | :VIPS_ALIGN_CENTRE | :VIPS_ALIGN_HIGH
@type 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
@type vips_angle() ::
  :VIPS_ANGLE_D0 | :VIPS_ANGLE_D90 | :VIPS_ANGLE_D180 | :VIPS_ANGLE_D270
@type 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
@type 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
@type vips_coding() ::
  :VIPS_CODING_ERROR | :VIPS_CODING_NONE | :VIPS_CODING_LABQ | :VIPS_CODING_RAD
@type vips_combine() :: :VIPS_COMBINE_MAX | :VIPS_COMBINE_SUM | :VIPS_COMBINE_MIN
@type vips_combine_mode() :: :VIPS_COMBINE_MODE_SET | :VIPS_COMBINE_MODE_ADD
Link to this type

vips_compass_direction()

View Source
@type 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
@type vips_demand_style() ::
  :VIPS_DEMAND_STYLE_ERROR
  | :VIPS_DEMAND_STYLE_SMALLTILE
  | :VIPS_DEMAND_STYLE_FATSTRIP
  | :VIPS_DEMAND_STYLE_THINSTRIP
@type vips_direction() :: :VIPS_DIRECTION_HORIZONTAL | :VIPS_DIRECTION_VERTICAL
@type vips_extend() ::
  :VIPS_EXTEND_BLACK
  | :VIPS_EXTEND_COPY
  | :VIPS_EXTEND_REPEAT
  | :VIPS_EXTEND_MIRROR
  | :VIPS_EXTEND_WHITE
  | :VIPS_EXTEND_BACKGROUND
@type vips_fail_on() ::
  :VIPS_FAIL_ON_NONE
  | :VIPS_FAIL_ON_TRUNCATED
  | :VIPS_FAIL_ON_ERROR
  | :VIPS_FAIL_ON_WARNING
Link to this type

vips_foreign_dz_container()

View Source
@type vips_foreign_dz_container() ::
  :VIPS_FOREIGN_DZ_CONTAINER_FS
  | :VIPS_FOREIGN_DZ_CONTAINER_ZIP
  | :VIPS_FOREIGN_DZ_CONTAINER_SZI
Link to this type

vips_foreign_dz_depth()

View Source
@type vips_foreign_dz_depth() ::
  :VIPS_FOREIGN_DZ_DEPTH_ONEPIXEL
  | :VIPS_FOREIGN_DZ_DEPTH_ONETILE
  | :VIPS_FOREIGN_DZ_DEPTH_ONE
Link to this type

vips_foreign_dz_layout()

View Source
@type 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
@type vips_foreign_flags() :: [
  :VIPS_FOREIGN_NONE
  | :VIPS_FOREIGN_PARTIAL
  | :VIPS_FOREIGN_BIGENDIAN
  | :VIPS_FOREIGN_SEQUENTIAL
]
Link to this type

vips_foreign_heif_compression()

View Source
@type vips_foreign_heif_compression() ::
  :VIPS_FOREIGN_HEIF_COMPRESSION_HEVC
  | :VIPS_FOREIGN_HEIF_COMPRESSION_AVC
  | :VIPS_FOREIGN_HEIF_COMPRESSION_JPEG
  | :VIPS_FOREIGN_HEIF_COMPRESSION_AV1
Link to this type

vips_foreign_png_filter()

View Source
@type 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
]
Link to this type

vips_foreign_ppm_format()

View Source
@type vips_foreign_ppm_format() ::
  :VIPS_FOREIGN_PPM_FORMAT_PBM
  | :VIPS_FOREIGN_PPM_FORMAT_PGM
  | :VIPS_FOREIGN_PPM_FORMAT_PPM
  | :VIPS_FOREIGN_PPM_FORMAT_PFM
Link to this type

vips_foreign_subsample()

View Source
@type vips_foreign_subsample() ::
  :VIPS_FOREIGN_SUBSAMPLE_AUTO
  | :VIPS_FOREIGN_SUBSAMPLE_ON
  | :VIPS_FOREIGN_SUBSAMPLE_OFF
Link to this type

vips_foreign_tiff_compression()

View Source
@type 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
Link to this type

vips_foreign_tiff_predictor()

View Source
@type vips_foreign_tiff_predictor() ::
  :VIPS_FOREIGN_TIFF_PREDICTOR_NONE
  | :VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL
  | :VIPS_FOREIGN_TIFF_PREDICTOR_FLOAT
Link to this type

vips_foreign_tiff_resunit()

View Source
@type vips_foreign_tiff_resunit() ::
  :VIPS_FOREIGN_TIFF_RESUNIT_CM | :VIPS_FOREIGN_TIFF_RESUNIT_INCH
Link to this type

vips_foreign_webp_preset()

View Source
@type 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
@type vips_intent() ::
  :VIPS_INTENT_PERCEPTUAL
  | :VIPS_INTENT_RELATIVE
  | :VIPS_INTENT_SATURATION
  | :VIPS_INTENT_ABSOLUTE
@type vips_interesting() ::
  :VIPS_INTERESTING_NONE
  | :VIPS_INTERESTING_CENTRE
  | :VIPS_INTERESTING_ENTROPY
  | :VIPS_INTERESTING_ATTENTION
  | :VIPS_INTERESTING_LOW
  | :VIPS_INTERESTING_HIGH
  | :VIPS_INTERESTING_ALL
@type 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
@type vips_kernel() ::
  :VIPS_KERNEL_NEAREST
  | :VIPS_KERNEL_LINEAR
  | :VIPS_KERNEL_CUBIC
  | :VIPS_KERNEL_MITCHELL
  | :VIPS_KERNEL_LANCZOS2
  | :VIPS_KERNEL_LANCZOS3
Link to this type

vips_operation_boolean()

View Source
@type vips_operation_boolean() ::
  :VIPS_OPERATION_BOOLEAN_AND
  | :VIPS_OPERATION_BOOLEAN_OR
  | :VIPS_OPERATION_BOOLEAN_EOR
  | :VIPS_OPERATION_BOOLEAN_LSHIFT
  | :VIPS_OPERATION_BOOLEAN_RSHIFT
Link to this type

vips_operation_complex2()

View Source
@type vips_operation_complex2() :: :VIPS_OPERATION_COMPLEX2_CROSS_PHASE
Link to this type

vips_operation_complex()

View Source
@type vips_operation_complex() ::
  :VIPS_OPERATION_COMPLEX_POLAR
  | :VIPS_OPERATION_COMPLEX_RECT
  | :VIPS_OPERATION_COMPLEX_CONJ
Link to this type

vips_operation_complexget()

View Source
@type vips_operation_complexget() ::
  :VIPS_OPERATION_COMPLEXGET_REAL | :VIPS_OPERATION_COMPLEXGET_IMAG
Link to this type

vips_operation_math2()

View Source
@type vips_operation_math2() ::
  :VIPS_OPERATION_MATH2_POW
  | :VIPS_OPERATION_MATH2_WOP
  | :VIPS_OPERATION_MATH2_ATAN2
@type 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
Link to this type

vips_operation_morphology()

View Source
@type vips_operation_morphology() ::
  :VIPS_OPERATION_MORPHOLOGY_ERODE | :VIPS_OPERATION_MORPHOLOGY_DILATE
Link to this type

vips_operation_relational()

View Source
@type 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
Link to this type

vips_operation_round()

View Source
@type vips_operation_round() ::
  :VIPS_OPERATION_ROUND_RINT
  | :VIPS_OPERATION_ROUND_CEIL
  | :VIPS_OPERATION_ROUND_FLOOR
@type vips_pcs() :: :VIPS_PCS_LAB | :VIPS_PCS_XYZ
@type vips_precision() ::
  :VIPS_PRECISION_INTEGER | :VIPS_PRECISION_FLOAT | :VIPS_PRECISION_APPROXIMATE
@type 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
@type vips_size() ::
  :VIPS_SIZE_BOTH | :VIPS_SIZE_UP | :VIPS_SIZE_DOWN | :VIPS_SIZE_FORCE

Link to this section Functions

Link to this function

abs!(in, optional \\ [])

View Source
@spec 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.

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

Absolute value of an image

arguments

Arguments

  • in - Input image
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • 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. Default: nil
  • interpolate - Interpolate pixels with this.
Link to this function

analyzeload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

analyzeload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

arrayjoin!(in, optional \\ [])

View Source
@spec 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.

Link to this function

arrayjoin(in, optional \\ [])

View Source
@spec 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. Default: nil
  • shim - Pixels between images. Default: 0
  • across - Number of images across grid. Default: 1
Link to this function

autorot!(in, optional \\ [])

View Source
@spec 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.

Link to this function

autorot(in, optional \\ [])

View Source
@spec 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)
Link to this function

avg!(in, optional \\ [])

View Source
@spec 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.

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

Find image average

arguments

Arguments

  • in - Input image
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

bandfold!(in, optional \\ [])

View Source
@spec 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.

Link to this function

bandfold(in, optional \\ [])

View Source
@spec 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
Link to this function

bandjoin!(in, optional \\ [])

View Source
@spec 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.

Link to this function

bandjoin(in, optional \\ [])

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

bandmean!(in, optional \\ [])

View Source
@spec 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.

Link to this function

bandmean(in, optional \\ [])

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

Band-wise average

arguments

Arguments

  • in - Input image argument
Link to this function

bandrank!(in, optional \\ [])

View Source
@spec 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.

Link to this function

bandrank(in, optional \\ [])

View Source
@spec 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
Link to this function

bandunfold!(in, optional \\ [])

View Source
@spec 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.

Link to this function

bandunfold(in, optional \\ [])

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

buildlut!(in, optional \\ [])

View Source
@spec 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.

Link to this function

buildlut(in, optional \\ [])

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

Build a look-up table

arguments

Arguments

  • in - Matrix of XY coordinates
Link to this function

byteswap!(in, optional \\ [])

View Source
@spec 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.

Link to this function

byteswap(in, optional \\ [])

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

Byteswap an image

arguments

Arguments

  • in - Input image
Link to this function

cache!(in, optional \\ [])

View Source
@spec 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.

Link to this function

cache(in, optional \\ [])

View Source
@spec 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
Link to this function

canny!(in, optional \\ [])

View Source
@spec 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.

Link to this function

canny(in, optional \\ [])

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

cmc2lch!(in, optional \\ [])

View Source
@spec 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.

Link to this function

cmc2lch(in, optional \\ [])

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

Transform lch to cmc

arguments

Arguments

  • in - Input image
Link to this function

cmyk2xyz!(in, optional \\ [])

View Source
@spec 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.

Link to this function

cmyk2xyz(in, optional \\ [])

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

Transform cmyk to xyz

arguments

Arguments

  • in - Input image
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec composite!([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 composite/3, except it returns only the value (not a tuple) and raises on error.

Link to this function

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

View Source
@spec composite([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 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. Default: nil
  • x - Array of x coordinates to join at. Default: nil
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

copy!(in, optional \\ [])

View Source
@spec 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.

Link to this function

copy(in, optional \\ [])

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

csvload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

csvload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • strip - Strip all metadata from image. Default: false
  • separator - Separator characters. Default: "\t"
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

deviate!(in, optional \\ [])

View Source
@spec 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.

Link to this function

deviate(in, optional \\ [])

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

Find image standard deviation

arguments

Arguments

  • in - Input image
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • 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
Link to this function

dzsave_buffer!(in, optional \\ [])

View Source
@spec 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.

Link to this function

dzsave_buffer(in, optional \\ [])

View Source
@spec 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. Default: nil
  • 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • extend - How to generate the extra pixels. Default: :VIPS_EXTEND_BLACK
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

falsecolour!(in, optional \\ [])

View Source
@spec 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.

Link to this function

falsecolour(in, optional \\ [])

View Source
@spec falsecolour(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

False-color an image

arguments

Arguments

  • in - Input image
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

fill_nearest!(in, optional \\ [])

View Source
@spec 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.

Link to this function

fill_nearest(in, optional \\ [])

View Source
@spec 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())
Link to this function

find_trim!(in, optional \\ [])

View Source
@spec 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.

Link to this function

find_trim(in, optional \\ [])

View Source
@spec 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. Default: nil
  • 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

Link to this function

fitsload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

fitsload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • strip - Strip all metadata from image. Default: false
Link to this function

flatten!(in, optional \\ [])

View Source
@spec 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.

Link to this function

flatten(in, optional \\ [])

View Source
@spec 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. Default: nil
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

float2rad!(in, optional \\ [])

View Source
@spec 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.

Link to this function

float2rad(in, optional \\ [])

View Source
@spec float2rad(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform float rgb to radiance coding

arguments

Arguments

  • in - Input image
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

fwfft!(in, optional \\ [])

View Source
@spec 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.

Link to this function

fwfft(in, optional \\ [])

View Source
@spec fwfft(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Forward fft

arguments

Arguments

  • in - Input image
Link to this function

gamma!(in, optional \\ [])

View Source
@spec 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.

Link to this function

gamma(in, optional \\ [])

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

gifload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

gifload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

gifload_buffer!(buffer, optional \\ [])

View Source
@spec 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.

Link to this function

gifload_buffer(buffer, optional \\ [])

View Source
@spec 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)
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • 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
Link to this function

gifsave_buffer!(in, optional \\ [])

View Source
@spec 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.

Link to this function

gifsave_buffer(in, optional \\ [])

View Source
@spec 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. Default: nil
  • 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
Link to this function

globalbalance!(in, optional \\ [])

View Source
@spec 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.

Link to this function

globalbalance(in, optional \\ [])

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • extend - How to generate the extra pixels. Default: :VIPS_EXTEND_BLACK
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

heifload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

heifload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

heifload_buffer!(buffer, optional \\ [])

View Source
@spec 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.

Link to this function

heifload_buffer(buffer, optional \\ [])

View Source
@spec 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)
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • 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
Link to this function

heifsave_buffer!(in, optional \\ [])

View Source
@spec 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.

Link to this function

heifsave_buffer(in, optional \\ [])

View Source
@spec 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. Default: nil
  • 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
Link to this function

hist_cum!(in, optional \\ [])

View Source
@spec 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.

Link to this function

hist_cum(in, optional \\ [])

View Source
@spec hist_cum(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Form cumulative histogram

arguments

Arguments

  • in - Input image
Link to this function

hist_entropy!(in, optional \\ [])

View Source
@spec 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.

Link to this function

hist_entropy(in, optional \\ [])

View Source
@spec hist_entropy(Vix.Vips.Image.t(), []) :: {:ok, float()} | {:error, term()}

Estimate image entropy

arguments

Arguments

  • in - Input histogram image
Link to this function

hist_equal!(in, optional \\ [])

View Source
@spec 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.

Link to this function

hist_equal(in, optional \\ [])

View Source
@spec 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
Link to this function

hist_find!(in, optional \\ [])

View Source
@spec 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.

Link to this function

hist_find(in, optional \\ [])

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

hist_find_ndim!(in, optional \\ [])

View Source
@spec 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.

Link to this function

hist_find_ndim(in, optional \\ [])

View Source
@spec 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
Link to this function

hist_ismonotonic!(in, optional \\ [])

View Source
@spec 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.

Link to this function

hist_ismonotonic(in, optional \\ [])

View Source
@spec hist_ismonotonic(Vix.Vips.Image.t(), []) :: {:ok, boolean()} | {:error, term()}

Test for monotonicity

arguments

Arguments

  • in - Input histogram image
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

hist_norm!(in, optional \\ [])

View Source
@spec 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.

Link to this function

hist_norm(in, optional \\ [])

View Source
@spec hist_norm(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Normalise histogram

arguments

Arguments

  • in - Input image
Link to this function

hist_plot!(in, optional \\ [])

View Source
@spec 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.

Link to this function

hist_plot(in, optional \\ [])

View Source
@spec hist_plot(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Plot histogram

arguments

Arguments

  • in - Input image
Link to this function

hough_circle!(in, optional \\ [])

View Source
@spec 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.

Link to this function

hough_circle(in, optional \\ [])

View Source
@spec 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
Link to this function

hough_line!(in, optional \\ [])

View Source
@spec 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.

Link to this function

hough_line(in, optional \\ [])

View Source
@spec 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
Link to this function

hsv2srgb!(in, optional \\ [])

View Source
@spec 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.

Link to this function

hsv2srgb(in, optional \\ [])

View Source
@spec hsv2srgb(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform hsv to srgb

arguments

Arguments

  • in - Input image
Link to this function

icc_export!(in, optional \\ [])

View Source
@spec 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.

Link to this function

icc_export(in, optional \\ [])

View Source
@spec 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
Link to this function

icc_import!(in, optional \\ [])

View Source
@spec 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.

Link to this function

icc_import(in, optional \\ [])

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

identity!(optional \\ [])

View Source
@spec 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.

Link to this function

identity(optional \\ [])

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • expand - Expand output to hold all of both inputs. Default: false
Link to this function

invert!(in, optional \\ [])

View Source
@spec 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.

Link to this function

invert(in, optional \\ [])

View Source
@spec invert(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Invert an image

arguments

Arguments

  • in - Input image
Link to this function

invertlut!(in, optional \\ [])

View Source
@spec 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.

Link to this function

invertlut(in, optional \\ [])

View Source
@spec 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
Link to this function

invfft!(in, optional \\ [])

View Source
@spec 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.

Link to this function

invfft(in, optional \\ [])

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • shim - Pixels between images. Default: 0
  • expand - Expand output to hold all of both inputs. Default: false
Link to this function

jp2kload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

jp2kload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

jp2kload_buffer!(buffer, optional \\ [])

View Source
@spec 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.

Link to this function

jp2kload_buffer(buffer, optional \\ [])

View Source
@spec 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)
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • 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
Link to this function

jp2ksave_buffer!(in, optional \\ [])

View Source
@spec 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.

Link to this function

jp2ksave_buffer(in, optional \\ [])

View Source
@spec 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. Default: nil
  • 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
Link to this function

jpegload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

jpegload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

jpegload_buffer!(buffer, optional \\ [])

View Source
@spec 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.

Link to this function

jpegload_buffer(buffer, optional \\ [])

View Source
@spec 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)
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • 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
Link to this function

jpegsave_buffer!(in, optional \\ [])

View Source
@spec 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.

Link to this function

jpegsave_buffer(in, optional \\ [])

View Source
@spec 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. Default: nil
  • 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
Link to this function

jpegsave_mime!(in, optional \\ [])

View Source
@spec 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.

Link to this function

jpegsave_mime(in, optional \\ [])

View Source
@spec 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. Default: nil
  • 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
Link to this function

jxlload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

jxlload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

jxlload_buffer!(buffer, optional \\ [])

View Source
@spec 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.

Link to this function

jxlload_buffer(buffer, optional \\ [])

View Source
@spec 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)
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • 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
Link to this function

jxlsave_buffer!(in, optional \\ [])

View Source
@spec 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.

Link to this function

jxlsave_buffer(in, optional \\ [])

View Source
@spec 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. Default: nil
  • 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
Link to this function

lab2labq!(in, optional \\ [])

View Source
@spec 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.

Link to this function

lab2labq(in, optional \\ [])

View Source
@spec lab2labq(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform float lab to labq coding

arguments

Arguments

  • in - Input image
Link to this function

lab2labs!(in, optional \\ [])

View Source
@spec 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.

Link to this function

lab2labs(in, optional \\ [])

View Source
@spec lab2labs(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform float lab to signed short

arguments

Arguments

  • in - Input image
Link to this function

lab2lch!(in, optional \\ [])

View Source
@spec 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.

Link to this function

lab2lch(in, optional \\ [])

View Source
@spec lab2lch(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform lab to lch

arguments

Arguments

  • in - Input image
Link to this function

lab2xyz!(in, optional \\ [])

View Source
@spec 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.

Link to this function

lab2xyz(in, optional \\ [])

View Source
@spec 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. Default: nil
Link to this function

labelregions!(in, optional \\ [])

View Source
@spec 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.

Link to this function

labelregions(in, optional \\ [])

View Source
@spec 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())
Link to this function

labq2lab!(in, optional \\ [])

View Source
@spec 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.

Link to this function

labq2lab(in, optional \\ [])

View Source
@spec labq2lab(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Unpack a labq image to float lab

arguments

Arguments

  • in - Input image
Link to this function

labq2labs!(in, optional \\ [])

View Source
@spec 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.

Link to this function

labq2labs(in, optional \\ [])

View Source
@spec labq2labs(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Unpack a labq image to short lab

arguments

Arguments

  • in - Input image
Link to this function

labq2srgb!(in, optional \\ [])

View Source
@spec 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.

Link to this function

labq2srgb(in, optional \\ [])

View Source
@spec labq2srgb(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Convert a labq image to srgb

arguments

Arguments

  • in - Input image
Link to this function

labs2lab!(in, optional \\ [])

View Source
@spec 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.

Link to this function

labs2lab(in, optional \\ [])

View Source
@spec labs2lab(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform signed short lab to float

arguments

Arguments

  • in - Input image
Link to this function

labs2labq!(in, optional \\ [])

View Source
@spec 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.

Link to this function

labs2labq(in, optional \\ [])

View Source
@spec labs2labq(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform short lab to labq coding

arguments

Arguments

  • in - Input image
Link to this function

lch2cmc!(in, optional \\ [])

View Source
@spec 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.

Link to this function

lch2cmc(in, optional \\ [])

View Source
@spec lch2cmc(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform lch to cmc

arguments

Arguments

  • in - Input image
Link to this function

lch2lab!(in, optional \\ [])

View Source
@spec 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.

Link to this function

lch2lab(in, optional \\ [])

View Source
@spec lch2lab(Vix.Vips.Image.t(), []) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform lch to lab

arguments

Arguments

  • in - Input image
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

linecache!(in, optional \\ [])

View Source
@spec 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.

Link to this function

linecache(in, optional \\ [])

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

magickload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

magickload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

magickload_buffer!(buffer, optional \\ [])

View Source
@spec 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.

Link to this function

magickload_buffer(buffer, optional \\ [])

View Source
@spec 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)
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • 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
Link to this function

magicksave_buffer!(in, optional \\ [])

View Source
@spec 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.

Link to this function

magicksave_buffer(in, optional \\ [])

View Source
@spec 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. Default: nil
  • 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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.
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

matload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

matload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

matrixinvert!(in, optional \\ [])

View Source
@spec 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.

Link to this function

matrixinvert(in, optional \\ [])

View Source
@spec matrixinvert(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Invert an matrix

arguments

Arguments

  • in - An square matrix
Link to this function

matrixload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

matrixload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

matrixprint!(in, optional \\ [])

View Source
@spec 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.

Link to this function

matrixprint(in, optional \\ [])

View Source
@spec 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. Default: nil
  • strip - Strip all metadata from image. Default: false
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • strip - Strip all metadata from image. Default: false
Link to this function

max!(in, optional \\ [])

View Source
@spec 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.

@spec 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())
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

min!(in, optional \\ [])

View Source
@spec 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.

@spec 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())
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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())
Link to this function

msb!(in, optional \\ [])

View Source
@spec 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.

@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

openexrload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

openexrload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

openslideload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

openslideload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

pdfload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

pdfload(filename, optional \\ [])

View Source
@spec 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. Default: nil
  • 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)
Link to this function

pdfload_buffer!(buffer, optional \\ [])

View Source
@spec 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.

Link to this function

pdfload_buffer(buffer, optional \\ [])

View Source
@spec 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. Default: nil
  • 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)
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

pngload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

pngload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

pngload_buffer!(buffer, optional \\ [])

View Source
@spec 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.

Link to this function

pngload_buffer(buffer, optional \\ [])

View Source
@spec 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)
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • 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
Link to this function

pngsave_buffer!(in, optional \\ [])

View Source
@spec 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.

Link to this function

pngsave_buffer(in, optional \\ [])

View Source
@spec 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. Default: nil
  • 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
Link to this function

ppmload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

ppmload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • 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
Link to this function

premultiply!(in, optional \\ [])

View Source
@spec 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.

Link to this function

premultiply(in, optional \\ [])

View Source
@spec 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
Link to this function

profile!(in, optional \\ [])

View Source
@spec 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.

Link to this function

profile(in, optional \\ [])

View Source
@spec 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

Link to this function

profile_load!(name, optional \\ [])

View Source
@spec 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.

Link to this function

profile_load(name, optional \\ [])

View Source
@spec profile_load(String.t(), []) :: {:ok, binary()} | {:error, term()}

Load named icc profile

arguments

Arguments

  • name - Profile name
Link to this function

project!(in, optional \\ [])

View Source
@spec 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.

Link to this function

project(in, optional \\ [])

View Source
@spec 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

Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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.
Link to this function

rad2float!(in, optional \\ [])

View Source
@spec 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.

Link to this function

rad2float(in, optional \\ [])

View Source
@spec rad2float(Vix.Vips.Image.t(), []) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Unpack radiance coding to float rgb

arguments

Arguments

  • in - Input image
Link to this function

radload!(filename, optional \\ [])

View Source
@spec 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.

Link to this function

radload(filename, optional \\ [])

View Source
@spec 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)
Link to this function

radload_buffer!(buffer, optional \\ [])

View Source
@spec 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.

Link to this function

radload_buffer(buffer, optional \\ [])

View Source
@spec 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)
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • strip - Strip all metadata from image. Default: false
Link to this function

radsave_buffer!(in, optional \\ [])

View Source
@spec 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.

Link to this function

radsave_buffer(in, optional \\ [])

View Source
@spec 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. Default: nil
  • strip - Strip all metadata from image. Default: false
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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)
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • strip - Strip all metadata from image. Default: false
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • strip - Strip all metadata from image. Default: false
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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.
Link to this function

rot45!(in, optional \\ [])

View Source
@spec 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.

Link to this function

rot45(in, optional \\ [])

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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
Link to this function

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

View Source
@spec 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.

Link to this function

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

View Source
@spec 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. Default: nil
  • interpolate - Interpolate pixels with this.
Link to this function

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

View Source

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

Link to this function

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

View Source
@spec 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
Link to this function

scale!(in, optional \\ [])

View Source
@spec 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.

Link to this function

scale(in, optional \\ [])

View Source
@spec scale(Vix.Vips.Image.t(), log: boolean(), exp: