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

Vips Operations

NOTE: Vips operation functions are generated using vips-introspection, so the bindings are up-to-date with vips version installed. Documentation in the hexdocs might not match for you.

Link to this section Summary

Functions

Absolute value of an image

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

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

Affine transform of an image

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

Join an array of images

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

Autorotate image by exif tag

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

Find image average

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

Boolean operation across image bands

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

Fold up x axis into bands

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

Bandwise join a set of images

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

Append a constant band to an image

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

Band-wise average

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

Band-wise rank of a set of images

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

Unfold image bands into x axis

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

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

Boolean operation on two images

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

Boolean operations against a constant

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

Build a look-up table

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

Byteswap an image

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

Cache an image

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

Canny edge detector

Same as canny/2, 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 case/3, except it returns only the value (not a tuple) and raises on error.

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

Transform lch to cmc

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

Transform cmyk to xyz

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

Convert to a new colorspace

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

Convolve with rotating mask

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

Perform a complex operation on an image

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

Complex binary operations on two images

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

Form a complex image from two real images

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

Get a component from a complex image

Same as complexget/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 composite/3, except it returns only the value (not a tuple) and raises on error.

Blend a pair of images with a blend mode

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

Convolution operation

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

Approximate integer convolution

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

Approximate separable integer convolution

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

Float convolution operation

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

Int convolution operation

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

Seperable convolution operation

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

Copy an image

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

Same as countlines/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.

Find image standard deviation

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

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

Embed an image in a larger image

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

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

Extract band from an image

Same as extract_band/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 eye/3, except it returns only the value (not a tuple) and raises on error.

False-color an image

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

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

Fill image zeros with nearest non-zero pixel

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

Search an image for non-edge areas

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

Flatten alpha out of an image

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

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

Transform float rgb to radiance coding

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

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

Frequency-domain filtering

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

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

Gamma an image

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

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.

Read a point from an image

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

Global balance an image mosaic

Same as globalbalance/2, 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 gravity/5, except it returns only the value (not a tuple) and raises on error.

Make a grey ramp image

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

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

Form cumulative histogram

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

Estimate image entropy

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

Histogram equalisation

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

Find image histogram

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

Find indexed image histogram

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

Find n-dimensional image histogram

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

Test for monotonicity

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

Local histogram equalisation

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

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

Normalise histogram

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

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

Find hough circle transform

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

Find hough line transform

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

Transform hsv to srgb

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

Output to device with icc profile

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

Import from device with icc profile

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

Transform between devices with icc profiles

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

Make a 1d image where pixel values are indexes

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

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

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

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

Invert an image

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

Build an inverted look-up table

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

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.

Transform float lab to labq coding

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

Transform float lab to signed short

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

Transform lab to lch

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

Transform cielab to xyz

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

Label regions in an image

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

Unpack a labq image to float lab

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

Unpack a labq image to short lab

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

Convert a labq image to srgb

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

Transform signed short lab to float

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

Transform short lab to labq coding

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

Transform lch to cmc

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

Transform lch to lab

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

Calculate (a * in + b)

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

Cache an image as a set of lines

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

Make a laplacian of gaussian image

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

Resample with a map image

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

Map an image though a lut

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

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.

Apply a math operation to an image

Same as math/3, 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.

Binary math operations with a constant

Same as math2_const/4, 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.

Find image maximum

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

Measure a set of patches on a color chart

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

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

Find image minimum

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

Same as morph/4, 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 mosaic1/12, except it returns only the value (not a tuple) and raises on error.

Pick most-significant byte from an image

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

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

Find threshold for percent of pixels

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

Make a perlin noise image

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

Calculate phase correlation

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

Premultiply image alpha

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

Find image profiles

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

Find image projections

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

Resample an image with a quadratic transform

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

Unpack radiance coding to float rgb

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

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

Linear recombination with matrix

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

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

Shrink an image horizontally

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

Shrink an image vertically

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

Relational operation on two images

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

Relational operations against a constant

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

Remainder after integer division of two images

Same as remainder/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 remainder_const/3, except it returns only the value (not a tuple) and raises on error.

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 rot/3, except it returns only the value (not a tuple) and raises on error.

Rotate an image

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

Rotate an image by a number of degrees

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

Perform a round function on an image

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

Scale an image to uchar

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

Convert scrgb to bw

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

Convert an scrgb image to srgb

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

Transform scrgb to xyz

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

Check sequential access

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

Unsharp masking for print

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

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

Shrink an image horizontally

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

Shrink an image vertically

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

Unit vector of pixel

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

Similarity transform of an image

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

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

Extract an area from an image

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

Sobel edge detector

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

Spatial correlation

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

Make displayable power spectrum

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

Transform srgb to hsv

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

Convert an srgb image to scrgb

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

Find many image stats

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

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.

Sum an array of images

Same as sum/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 switch/2, except it returns only the value (not a tuple) and raises on error.

Run an external command

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

Make a text image

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

Generate thumbnail from file

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

Generate thumbnail from image

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

Cache an image as a set of tiles

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

Build a look-up table

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

Transpose3d an image

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

Unpremultiply image alpha

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

Make a worley noise image

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

Wrap image origin

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

Make an image where pixel values are coordinates

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

Transform xyz to cmyk

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

Transform xyz to lab

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

Transform xyz to scrgb

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

Transform xyz to yxy

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

Transform yxy to xyz

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

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

Specs

gsf_output_csv_quoting_mode() ::
  :GSF_OUTPUT_CSV_QUOTING_MODE_NEVER | :GSF_OUTPUT_CSV_QUOTING_MODE_AUTO

Specs

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

Specs

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

Specs

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

Specs

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

Specs

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

Specs

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

Specs

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

Specs

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

Specs

vips_combine_mode() :: :VIPS_COMBINE_MODE_SET | :VIPS_COMBINE_MODE_ADD
Link to this type

vips_compass_direction()

View Source

Specs

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

Specs

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

Specs

vips_direction() :: :VIPS_DIRECTION_HORIZONTAL | :VIPS_DIRECTION_VERTICAL

Specs

vips_extend() ::
  :VIPS_EXTEND_BLACK
  | :VIPS_EXTEND_COPY
  | :VIPS_EXTEND_REPEAT
  | :VIPS_EXTEND_MIRROR
  | :VIPS_EXTEND_WHITE
  | :VIPS_EXTEND_BACKGROUND
Link to this type

vips_foreign_dz_container()

View Source

Specs

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

Specs

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

Specs

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

Specs

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

Specs

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

vips_foreign_jpeg_subsample()

View Source

Specs

vips_foreign_jpeg_subsample() ::
  :VIPS_FOREIGN_JPEG_SUBSAMPLE_AUTO
  | :VIPS_FOREIGN_JPEG_SUBSAMPLE_ON
  | :VIPS_FOREIGN_JPEG_SUBSAMPLE_OFF
Link to this type

vips_foreign_png_filter()

View Source

Specs

vips_foreign_png_filter() :: [
  :VIPS_FOREIGN_PNG_FILTER_NONE
  | :VIPS_FOREIGN_PNG_FILTER_SUB
  | :VIPS_FOREIGN_PNG_FILTER_UP
  | :VIPS_FOREIGN_PNG_FILTER_AVG
  | :VIPS_FOREIGN_PNG_FILTER_PAETH
]
Link to this type

vips_foreign_tiff_compression()

View Source

Specs

vips_foreign_tiff_compression() ::
  :VIPS_FOREIGN_TIFF_COMPRESSION_NONE
  | :VIPS_FOREIGN_TIFF_COMPRESSION_JPEG
  | :VIPS_FOREIGN_TIFF_COMPRESSION_DEFLATE
  | :VIPS_FOREIGN_TIFF_COMPRESSION_PACKBITS
  | :VIPS_FOREIGN_TIFF_COMPRESSION_CCITTFAX4
  | :VIPS_FOREIGN_TIFF_COMPRESSION_LZW
  | :VIPS_FOREIGN_TIFF_COMPRESSION_WEBP
  | :VIPS_FOREIGN_TIFF_COMPRESSION_ZSTD
Link to this type

vips_foreign_tiff_predictor()

View Source

Specs

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

Specs

vips_foreign_tiff_resunit() ::
  :VIPS_FOREIGN_TIFF_RESUNIT_CM | :VIPS_FOREIGN_TIFF_RESUNIT_INCH
Link to this type

vips_foreign_webp_preset()

View Source

Specs

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

Specs

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

Specs

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

Specs

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

Specs

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

Specs

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_complex()

View Source

Specs

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

vips_operation_complex2()

View Source

Specs

vips_operation_complex2() :: :VIPS_OPERATION_COMPLEX2_CROSS_PHASE
Link to this type

vips_operation_complexget()

View Source

Specs

vips_operation_complexget() ::
  :VIPS_OPERATION_COMPLEXGET_REAL | :VIPS_OPERATION_COMPLEXGET_IMAG

Specs

vips_operation_math() ::
  :VIPS_OPERATION_MATH_SIN
  | :VIPS_OPERATION_MATH_COS
  | :VIPS_OPERATION_MATH_TAN
  | :VIPS_OPERATION_MATH_ASIN
  | :VIPS_OPERATION_MATH_ACOS
  | :VIPS_OPERATION_MATH_ATAN
  | :VIPS_OPERATION_MATH_LOG
  | :VIPS_OPERATION_MATH_LOG10
  | :VIPS_OPERATION_MATH_EXP
  | :VIPS_OPERATION_MATH_EXP10
Link to this type

vips_operation_math2()

View Source

Specs

vips_operation_math2() :: :VIPS_OPERATION_MATH2_POW | :VIPS_OPERATION_MATH2_WOP
Link to this type

vips_operation_morphology()

View Source

Specs

vips_operation_morphology() ::
  :VIPS_OPERATION_MORPHOLOGY_ERODE | :VIPS_OPERATION_MORPHOLOGY_DILATE
Link to this type

vips_operation_relational()

View Source

Specs

vips_operation_relational() ::
  :VIPS_OPERATION_RELATIONAL_EQUAL
  | :VIPS_OPERATION_RELATIONAL_NOTEQ
  | :VIPS_OPERATION_RELATIONAL_LESS
  | :VIPS_OPERATION_RELATIONAL_LESSEQ
  | :VIPS_OPERATION_RELATIONAL_MORE
  | :VIPS_OPERATION_RELATIONAL_MOREEQ
Link to this type

vips_operation_round()

View Source

Specs

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

Specs

vips_pcs() :: :VIPS_PCS_LAB | :VIPS_PCS_XYZ

Specs

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

Specs

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

Specs

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

Link to this section Functions

Specs

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

Absolute value of an image

Arguments

  • in - Input image
Link to this function

abs!(in, optional \\ [])

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Add two images

Arguments

  • left - Left-hand image argument
  • right - Right-hand image argument
Link to this function

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

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Affine transform of an image

Arguments

  • in - Input image argument
  • matrix - Transformation matrix

Optional

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

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

View Source

Specs

affine!(Vix.Vips.Image.t(), [float()],
  extend: vips_extend(),
  premultiplied: boolean(),
  background: [float()],
  idy: float(),
  idx: float(),
  ody: float(),
  odx: float(),
  oarea: [integer()]
) :: 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

arrayjoin(in, optional \\ [])

View Source

Specs

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

Join an array of images

Arguments

  • in - Array of input images

Optional

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

arrayjoin!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

autorot(in, optional \\ [])

View Source

Specs

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

Autorotate image by exif tag

Arguments

  • in - Input image

Returns

Ordered values in the returned tuple

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

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

autorot!(in, optional \\ [])

View Source

Specs

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

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

Specs

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

Find image average

Arguments

  • in - Input image
Link to this function

avg!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Boolean operation across image bands

Arguments

  • in - Input image argument
  • boolean - boolean to perform
Link to this function

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

View Source

Specs

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

Link to this function

bandfold(in, optional \\ [])

View Source

Specs

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

Fold up x axis into bands

Arguments

  • in - Input image

Optional

  • factor - Fold by this factor. Default: 0
Link to this function

bandfold!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

bandjoin(in, optional \\ [])

View Source

Specs

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

Bandwise join a set of images

Arguments

  • in - Array of input images
Link to this function

bandjoin!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Append a constant band to an image

Arguments

  • in - Input image
  • c - Array of constants to add
Link to this function

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

View Source

Specs

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

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

Link to this function

bandmean(in, optional \\ [])

View Source

Specs

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

Band-wise average

Arguments

  • in - Input image argument
Link to this function

bandmean!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

bandrank(in, optional \\ [])

View Source

Specs

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

Band-wise rank of a set of images

Arguments

  • in - Array of input images

Optional

  • index - Select this band element from sorted list. Default: -1
Link to this function

bandrank!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

bandunfold(in, optional \\ [])

View Source

Specs

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

Unfold image bands into x axis

Arguments

  • in - Input image

Optional

  • factor - Unfold by this factor. Default: 0
Link to this function

bandunfold!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Make a black image

Arguments

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

Optional

  • bands - Number of bands in image. Default: 1
Link to this function

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Boolean operation on two images

Arguments

  • left - Left-hand image argument
  • right - Right-hand image argument
  • boolean - boolean to perform
Link to this function

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

View Source

Specs

Same as boolean/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

Specs

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

Boolean operations against a constant

Arguments

  • in - Input image
  • boolean - boolean to perform
  • c - Array of constants
Link to this function

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

View Source

Specs

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

Link to this function

buildlut(in, optional \\ [])

View Source

Specs

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

Build a look-up table

Arguments

  • in - Matrix of XY coordinates
Link to this function

buildlut!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

byteswap(in, optional \\ [])

View Source

Specs

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

Byteswap an image

Arguments

  • in - Input image
Link to this function

byteswap!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

cache(in, optional \\ [])

View Source

Specs

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

Cache an image

Arguments

  • in - Input image

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

cache!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

canny(in, optional \\ [])

View Source

Specs

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

Canny edge detector

Arguments

  • in - Input image

Optional

  • precision - Convolve with this precision. Default: :VIPS_PRECISION_FLOAT
  • sigma - Sigma of Gaussian. Default: 1.4
Link to this function

canny!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Use pixel values to pick cases from an array of images

Arguments

  • index - Index image
  • cases - Array of case images
Link to this function

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

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Cast an image

Arguments

  • in - Input image
  • format - Format to cast to

Optional

  • shift - Shift integer values up and down. Default: false
Link to this function

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

View Source

Specs

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

Link to this function

cmc2lch(in, optional \\ [])

View Source

Specs

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

Transform lch to cmc

Arguments

  • in - Input image
Link to this function

cmc2lch!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

cmyk2xyz(in, optional \\ [])

View Source

Specs

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

Transform cmyk to xyz

Arguments

  • in - Input image
Link to this function

cmyk2xyz!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Convert to a new colorspace

Arguments

  • in - Input image
  • space - Destination color space

Optional

  • source-space - Source color space. Default: :VIPS_INTERPRETATION_sRGB
Link to this function

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Convolve with rotating mask

Arguments

  • in - Input image argument
  • mask - Input matrix image

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

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Perform a complex operation on an image

Arguments

  • in - Input image
  • cmplx - complex to perform
Link to this function

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

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Complex binary operations on two images

Arguments

  • left - Left-hand image argument
  • right - Right-hand image argument
  • cmplx - binary complex operation to perform
Link to this function

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

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Form a complex image from two real images

Arguments

  • left - Left-hand image argument
  • right - Right-hand image argument
Link to this function

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

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Get a component from a complex image

Arguments

  • in - Input image
  • get - complex to perform
Link to this function

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

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Blend an array of images with an array of blend modes

Arguments

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

Optional

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

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Blend a pair of images with a blend mode

Arguments

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

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

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Convolution operation

Arguments

  • in - Input image argument
  • mask - Input matrix image

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

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Approximate integer convolution

Arguments

  • in - Input image argument
  • mask - Input matrix image

Optional

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

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Approximate separable integer convolution

Arguments

  • in - Input image argument
  • mask - Input matrix image

Optional

  • layers - Use this many layers in approximation. Default: 5
Link to this function

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Float convolution operation

Arguments

  • in - Input image argument
  • mask - Input matrix image
Link to this function

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

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Int convolution operation

Arguments

  • in - Input image argument
  • mask - Input matrix image
Link to this function

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

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Seperable convolution operation

Arguments

  • in - Input image argument
  • mask - Input matrix image

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

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

View Source

Specs

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

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

Link to this function

copy(in, optional \\ [])

View Source

Specs

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

Copy an image

Arguments

  • in - Input image

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

copy!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Count lines in an image

Arguments

  • in - Input image argument
  • direction - Countlines left-right or up-down
Link to this function

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Calculate de00

Arguments

  • left - Left-hand input image
  • right - Right-hand input image
Link to this function

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

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Calculate de76

Arguments

  • left - Left-hand input image
  • right - Right-hand input image
Link to this function

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

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Calculate decmc

Arguments

  • left - Left-hand input image
  • right - Right-hand input image
Link to this function

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

View Source

Specs

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

Link to this function

deviate(in, optional \\ [])

View Source

Specs

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

Find image standard deviation

Arguments

  • in - Input image
Link to this function

deviate!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Divide two images

Arguments

  • left - Left-hand image argument
  • right - Right-hand image argument
Link to this function

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

View Source

Specs

Same as divide/3, 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

Specs

embed(Vix.Vips.Image.t(), integer(), integer(), integer(), integer(),
  background: [float()],
  extend: vips_extend()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Embed an image in a larger image

Arguments

  • 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

  • background - Color for background pixels.
  • extend - How to generate the extra pixels. Default: :VIPS_EXTEND_BLACK
Link to this function

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

View Source

Specs

embed!(Vix.Vips.Image.t(), integer(), integer(), integer(), integer(),
  background: [float()],
  extend: vips_extend()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

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

Extract an area from an image

Arguments

  • 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_area!(input, left, top, width, height, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Extract band from an image

Arguments

  • in - Input image
  • band - Band to extract

Optional

  • n - Number of bands to extract. Default: 1
Link to this function

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

eye(integer(), integer(), factor: float(), uchar: boolean()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make an image showing the eye's spatial response

Arguments

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

Optional

  • factor - Maximum spatial frequency. Default: 0.5
  • uchar - Output an unsigned char image. Default: false
Link to this function

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

View Source

Specs

eye!(integer(), integer(), factor: float(), uchar: boolean()) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

falsecolour(in, optional \\ [])

View Source

Specs

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

False-color an image

Arguments

  • in - Input image
Link to this function

falsecolour!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Fast correlation

Arguments

  • in - Input image argument
  • ref - Input reference image
Link to this function

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

View Source

Specs

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

Link to this function

fill_nearest(in, optional \\ [])

View Source

Specs

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

Fill image zeros with nearest non-zero pixel

Arguments

  • in - Input image argument

Returns

Ordered values in the returned tuple

  • out - Value of nearest non-zero pixel. (Vix.Vips.Image.t())

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

fill_nearest!(in, optional \\ [])

View Source

Specs

fill_nearest!(Vix.Vips.Image.t(), []) ::
  {Vix.Vips.Image.t(), [{:distance, Vix.Vips.Image.t()}]} | no_return()

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

Link to this function

find_trim(in, optional \\ [])

View Source

Specs

find_trim(Vix.Vips.Image.t(), background: [float()], threshold: float()) ::
  {:ok, {integer(), integer(), integer(), integer(), []}} | {:error, term()}

Search an image for non-edge areas

Arguments

  • in - Image to find_trim

Optional

  • background - Color for background pixels.
  • threshold - Object threshold. Default: 10.0

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

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

Link to this function

find_trim!(in, optional \\ [])

View Source

Specs

find_trim!(Vix.Vips.Image.t(), background: [float()], threshold: float()) ::
  {integer(), integer(), integer(), integer(), []} | no_return()

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

Link to this function

flatten(in, optional \\ [])

View Source

Specs

flatten(Vix.Vips.Image.t(), "max-alpha": float(), background: [float()]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Flatten alpha out of an image

Arguments

  • in - Input image

Optional

  • max-alpha - Maximum value of alpha channel. Default: 255.0
  • background - Background value.
Link to this function

flatten!(in, optional \\ [])

View Source

Specs

flatten!(Vix.Vips.Image.t(), "max-alpha": float(), background: [float()]) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

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

Flip an image

Arguments

  • in - Input image
  • direction - Direction to flip image
Link to this function

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

View Source

Specs

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

Link to this function

float2rad(in, optional \\ [])

View Source

Specs

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

Transform float rgb to radiance coding

Arguments

  • in - Input image
Link to this function

float2rad!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Make a fractal surface

Arguments

  • width - Image width in pixels
  • height - Image height in pixels
  • fractal-dimension - Fractal dimension
Link to this function

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Frequency-domain filtering

Arguments

  • in - Input image
  • mask - Input mask image
Link to this function

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

View Source

Specs

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

Link to this function

fwfft(in, optional \\ [])

View Source

Specs

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

Forward fft

Arguments

  • in - Input image
Link to this function

fwfft!(in, optional \\ [])

View Source

Specs

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

Link to this function

gamma(in, optional \\ [])

View Source

Specs

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

Gamma an image

Arguments

  • in - Input image

Optional

  • exponent - Gamma factor. Default: 2.4
Link to this function

gamma!(in, optional \\ [])

View Source

Specs

gamma!(Vix.Vips.Image.t(), [{:exponent, float()}]) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

gaussblur(Vix.Vips.Image.t(), float(),
  precision: vips_precision(),
  "min-ampl": float()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Gaussian blur

Arguments

  • in - Input image
  • sigma - Sigma of Gaussian

Optional

  • precision - Convolve with this precision. Default: :VIPS_PRECISION_INTEGER
  • min-ampl - Minimum amplitude of Gaussian. Default: 0.2
Link to this function

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

View Source

Specs

gaussblur!(Vix.Vips.Image.t(), float(),
  precision: vips_precision(),
  "min-ampl": float()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

gaussmat(float(), float(),
  precision: vips_precision(),
  integer: boolean(),
  separable: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a gaussian image

Arguments

  • sigma - Sigma of Gaussian
  • min-ampl - Minimum amplitude of Gaussian

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

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

View Source

Specs

gaussmat!(float(), float(),
  precision: vips_precision(),
  integer: boolean(),
  separable: boolean()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

gaussnoise(integer(), integer(), mean: float(), sigma: float()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a gaussnoise image

Arguments

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

Optional

  • 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

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

View Source

Specs

gaussnoise!(integer(), 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

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

View Source

Specs

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

Read a point from an image

Arguments

  • in - Input image
  • x - Point to read
  • y - Point to read
Link to this function

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

View Source

Specs

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

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

Link to this function

globalbalance(in, optional \\ [])

View Source

Specs

globalbalance(Vix.Vips.Image.t(), "int-output": boolean(), gamma: float()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Global balance an image mosaic

Arguments

  • in - Input image

Optional

  • int-output - Integer output. Default: false
  • gamma - Image gamma. Default: 1.6
Link to this function

globalbalance!(in, optional \\ [])

View Source

Specs

globalbalance!(Vix.Vips.Image.t(), "int-output": boolean(), gamma: float()) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

gravity(Vix.Vips.Image.t(), vips_compass_direction(), integer(), integer(),
  background: [float()],
  extend: vips_extend()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Place an image within a larger image with a certain gravity

Arguments

  • in - Input image
  • direction - direction to place image within width/height
  • width - Image width in pixels
  • height - Image height in pixels

Optional

  • background - Color for background pixels.
  • extend - How to generate the extra pixels. Default: :VIPS_EXTEND_BLACK
Link to this function

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

View Source

Specs

gravity!(Vix.Vips.Image.t(), vips_compass_direction(), integer(), integer(),
  background: [float()],
  extend: vips_extend()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

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

Make a grey ramp image

Arguments

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

Optional

  • uchar - Output an unsigned char image. Default: false
Link to this function

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

View Source

Specs

grey!(integer(), integer(), [{:uchar, boolean()}]) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

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

Grid an image

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

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

View Source

Specs

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

Link to this function

hist_cum(in, optional \\ [])

View Source

Specs

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

Form cumulative histogram

Arguments

  • in - Input image
Link to this function

hist_cum!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

hist_entropy(in, optional \\ [])

View Source

Specs

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

Estimate image entropy

Arguments

  • in - Input histogram image
Link to this function

hist_entropy!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

hist_equal(in, optional \\ [])

View Source

Specs

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

Histogram equalisation

Arguments

  • in - Input image

Optional

  • band - Equalise with this band. Default: -1
Link to this function

hist_equal!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

hist_find(in, optional \\ [])

View Source

Specs

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

Find image histogram

Arguments

  • in - Input image

Optional

  • band - Find histogram of band. Default: -1
Link to this function

hist_find!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Find indexed image histogram

Arguments

  • in - Input image
  • index - Index image

Optional

  • combine - Combine bins like this. Default: :VIPS_COMBINE_SUM
Link to this function

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

View Source

Specs

hist_find_indexed!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), [
  {:combine, vips_combine()}
]) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

hist_find_ndim(in, optional \\ [])

View Source

Specs

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

Find n-dimensional image histogram

Arguments

  • in - Input image

Optional

  • bins - Number of bins in each dimension. Default: 10
Link to this function

hist_find_ndim!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

hist_ismonotonic(in, optional \\ [])

View Source

Specs

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

Test for monotonicity

Arguments

  • in - Input histogram image
Link to this function

hist_ismonotonic!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

hist_local(Vix.Vips.Image.t(), integer(), integer(), [{:"max-slope", integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Local histogram equalisation

Arguments

  • in - Input image
  • width - Window width in pixels
  • height - Window height in pixels

Optional

  • max-slope - Maximum slope (CLAHE). Default: 0
Link to this function

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

View Source

Specs

hist_local!(Vix.Vips.Image.t(), integer(), integer(), [
  {:"max-slope", integer()}
]) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

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

Match two histograms

Arguments

  • in - Input histogram
  • ref - Reference histogram
Link to this function

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

View Source

Specs

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

Link to this function

hist_norm(in, optional \\ [])

View Source

Specs

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

Normalise histogram

Arguments

  • in - Input image
Link to this function

hist_norm!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

hist_plot(in, optional \\ [])

View Source

Specs

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

Plot histogram

Arguments

  • in - Input image
Link to this function

hist_plot!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

hough_circle(in, optional \\ [])

View Source

Specs

hough_circle(Vix.Vips.Image.t(),
  "max-radius": integer(),
  "min-radius": integer(),
  scale: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Find hough circle transform

Arguments

  • in - Input image

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_circle!(in, optional \\ [])

View Source

Specs

hough_circle!(Vix.Vips.Image.t(),
  "max-radius": integer(),
  "min-radius": integer(),
  scale: integer()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

hough_line(in, optional \\ [])

View Source

Specs

hough_line(Vix.Vips.Image.t(), height: integer(), width: integer()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Find hough line transform

Arguments

  • in - Input image

Optional

  • height - Vertical size of parameter space. Default: 256
  • width - horizontal size of parameter space. Default: 256
Link to this function

hough_line!(in, optional \\ [])

View Source

Specs

hough_line!(Vix.Vips.Image.t(), height: integer(), width: integer()) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

hsv2srgb(in, optional \\ [])

View Source

Specs

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

Transform hsv to srgb

Arguments

  • in - Input image
Link to this function

hsv2srgb!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

icc_export(in, optional \\ [])

View Source

Specs

icc_export(Vix.Vips.Image.t(),
  depth: integer(),
  "output-profile": String.t(),
  intent: vips_intent(),
  pcs: vips_pcs()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Output to device with icc profile

Arguments

  • in - Input image

Optional

  • depth - Output device space depth in bits. Default: 8
  • output-profile - Filename to load output profile from. Default: nil
  • intent - Rendering intent. Default: :VIPS_INTENT_RELATIVE
  • pcs - Set Profile Connection Space. Default: :VIPS_PCS_LAB
Link to this function

icc_export!(in, optional \\ [])

View Source

Specs

icc_export!(Vix.Vips.Image.t(),
  depth: integer(),
  "output-profile": String.t(),
  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_import(in, optional \\ [])

View Source

Specs

icc_import(Vix.Vips.Image.t(),
  "input-profile": String.t(),
  embedded: boolean(),
  intent: vips_intent(),
  pcs: vips_pcs()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Import from device with icc profile

Arguments

  • in - Input image

Optional

  • input-profile - Filename to load input profile from. Default: nil
  • embedded - Use embedded input profile, if available. 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

Specs

icc_import!(Vix.Vips.Image.t(),
  "input-profile": String.t(),
  embedded: 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_transform(in, output-profile, optional \\ [])

View Source

Specs

icc_transform(Vix.Vips.Image.t(), String.t(),
  depth: integer(),
  "input-profile": String.t(),
  embedded: boolean(),
  intent: vips_intent(),
  pcs: vips_pcs()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transform between devices with icc profiles

Arguments

  • in - Input image
  • output-profile - Filename to load output profile from

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

Specs

icc_transform!(Vix.Vips.Image.t(), String.t(),
  depth: integer(),
  "input-profile": String.t(),
  embedded: 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

identity(optional \\ [])

View Source

Specs

identity(size: integer(), ushort: boolean(), bands: integer()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a 1d image where pixel values are indexes

Arguments

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

identity!(optional \\ [])

View Source

Specs

identity!(size: integer(), ushort: boolean(), bands: integer()) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

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

Ifthenelse an image

Arguments

  • cond - Condition input image
  • in1 - Source for TRUE pixels
  • in2 - Source for FALSE pixels

Optional

  • blend - Blend smoothly between then and else parts. Default: false
Link to this function

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

View Source

Specs

ifthenelse!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), Vix.Vips.Image.t(), [
  {:blend, boolean()}
]) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

insert(Vix.Vips.Image.t(), Vix.Vips.Image.t(), integer(), integer(),
  background: [float()],
  expand: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

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

Arguments

  • 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

  • background - Color for new pixels.
  • expand - Expand output to hold all of both inputs. Default: false
Link to this function

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

View Source

Specs

insert!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), integer(), integer(),
  background: [float()],
  expand: boolean()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

invert(in, optional \\ [])

View Source

Specs

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

Invert an image

Arguments

  • in - Input image
Link to this function

invert!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

invertlut(in, optional \\ [])

View Source

Specs

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

Build an inverted look-up table

Arguments

  • in - Matrix of XY coordinates

Optional

  • size - LUT size to generate. Default: 256
Link to this function

invertlut!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

invfft(in, optional \\ [])

View Source

Specs

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

Inverse fft

Arguments

  • in - Input image

Optional

  • real - Output only the real part of the transform. Default: false
Link to this function

invfft!(in, optional \\ [])

View Source

Specs

invfft!(Vix.Vips.Image.t(), [{:real, boolean()}]) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

join(Vix.Vips.Image.t(), Vix.Vips.Image.t(), vips_direction(),
  align: vips_align(),
  background: [float()],
  shim: integer(),
  expand: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Join a pair of images

Arguments

  • in1 - First input image
  • in2 - Second input image
  • direction - Join left-right or up-down

Optional

  • align - Align on the low, centre or high coordinate edge. Default: :VIPS_ALIGN_LOW
  • background - Colour for new pixels.
  • shim - Pixels between images. Default: 0
  • expand - Expand output to hold all of both inputs. Default: false
Link to this function

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

View Source

Specs

join!(Vix.Vips.Image.t(), Vix.Vips.Image.t(), vips_direction(),
  align: vips_align(),
  background: [float()],
  shim: integer(),
  expand: boolean()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

lab2labq(in, optional \\ [])

View Source

Specs

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

Transform float lab to labq coding

Arguments

  • in - Input image
Link to this function

lab2labq!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

lab2labs(in, optional \\ [])

View Source

Specs

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

Transform float lab to signed short

Arguments

  • in - Input image
Link to this function

lab2labs!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

lab2lch(in, optional \\ [])

View Source

Specs

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

Transform lab to lch

Arguments

  • in - Input image
Link to this function

lab2lch!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

lab2xyz(in, optional \\ [])

View Source

Specs

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

Transform cielab to xyz

Arguments

  • in - Input image

Optional

  • temp - Color temperature.
Link to this function

lab2xyz!(in, optional \\ [])

View Source

Specs

lab2xyz!(Vix.Vips.Image.t(), [{:temp, [float()]}]) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

labelregions(in, optional \\ [])

View Source

Specs

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

Label regions in an image

Arguments

  • in - Input image argument

Returns

Ordered values in the returned tuple

  • mask - Mask of region labels. (Vix.Vips.Image.t())

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

labelregions!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

labq2lab(in, optional \\ [])

View Source

Specs

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

Unpack a labq image to float lab

Arguments

  • in - Input image
Link to this function

labq2lab!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

labq2labs(in, optional \\ [])

View Source

Specs

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

Unpack a labq image to short lab

Arguments

  • in - Input image
Link to this function

labq2labs!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

labq2srgb(in, optional \\ [])

View Source

Specs

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

Convert a labq image to srgb

Arguments

  • in - Input image
Link to this function

labq2srgb!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

labs2lab(in, optional \\ [])

View Source

Specs

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

Transform signed short lab to float

Arguments

  • in - Input image
Link to this function

labs2lab!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

labs2labq(in, optional \\ [])

View Source

Specs

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

Transform short lab to labq coding

Arguments

  • in - Input image
Link to this function

labs2labq!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

lch2cmc(in, optional \\ [])

View Source

Specs

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

Transform lch to cmc

Arguments

  • in - Input image
Link to this function

lch2cmc!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

lch2lab(in, optional \\ [])

View Source

Specs

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

Transform lch to lab

Arguments

  • in - Input image
Link to this function

lch2lab!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Calculate (a * in + b)

Arguments

  • in - Input image
  • a - Multiply by this
  • b - Add this

Optional

  • uchar - Output should be uchar. Default: false
Link to this function

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

View Source

Specs

linear!(Vix.Vips.Image.t(), [float()], [float()], [{:uchar, boolean()}]) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

linecache(in, optional \\ [])

View Source

Specs

linecache(Vix.Vips.Image.t(),
  persistent: boolean(),
  threaded: boolean(),
  access: vips_access(),
  "tile-height": integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Cache an image as a set of lines

Arguments

  • in - Input image

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

linecache!(in, optional \\ [])

View Source

Specs

linecache!(Vix.Vips.Image.t(),
  persistent: boolean(),
  threaded: boolean(),
  access: vips_access(),
  "tile-height": integer()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

logmat(float(), float(),
  precision: vips_precision(),
  integer: boolean(),
  separable: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a laplacian of gaussian image

Arguments

  • sigma - Radius of Logmatian
  • min-ampl - Minimum amplitude of Logmatian

Optional

  • precision - Generate with this precision. Default: :VIPS_PRECISION_INTEGER
  • integer - Generate integer Logmatian. Default: false
  • separable - Generate separable Logmatian. Default: false
Link to this function

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

View Source

Specs

logmat!(float(), float(),
  precision: vips_precision(),
  integer: boolean(),
  separable: boolean()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

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

Resample with a map image

Arguments

  • in - Input image argument
  • index - Index pixels with this
Link to this function

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

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Map an image though a lut

Arguments

  • in - Input image
  • lut - Look-up table image

Optional

  • band - apply one-band lut to this band of in. Default: -1
Link to this function

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

mask_butterworth(integer(), integer(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a butterworth filter

Arguments

  • width - Image width in pixels
  • height - Image height in pixels
  • order - Filter order
  • frequency-cutoff - Frequency cutoff
  • amplitude-cutoff - Amplitude cutoff

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!(width, height, order, frequency-cutoff, amplitude-cutoff, optional \\ [])

View Source

Specs

mask_butterworth!(integer(), integer(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

mask_butterworth_band(
  integer(),
  integer(),
  float(),
  float(),
  float(),
  float(),
  float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a butterworth_band filter

Arguments

  • 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

  • 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

Specs

mask_butterworth_band!(
  integer(),
  integer(),
  float(),
  float(),
  float(),
  float(),
  float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

mask_butterworth_ring(integer(), integer(), float(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a butterworth ring filter

Arguments

  • width - Image width in pixels
  • height - Image height in pixels
  • order - Filter order
  • frequency-cutoff - Frequency cutoff
  • amplitude-cutoff - Amplitude cutoff
  • ringwidth - Ringwidth

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

Specs

mask_butterworth_ring!(integer(), integer(), float(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

mask_fractal(integer(), integer(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make fractal filter

Arguments

  • width - Image width in pixels
  • height - Image height in pixels
  • fractal-dimension - Fractal dimension

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

Specs

mask_fractal!(integer(), integer(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

mask_gaussian(integer(), integer(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a gaussian filter

Arguments

  • width - Image width in pixels
  • height - Image height in pixels
  • frequency-cutoff - Frequency cutoff
  • amplitude-cutoff - Amplitude cutoff

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

Specs

mask_gaussian!(integer(), integer(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

mask_gaussian_band(integer(), integer(), float(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a gaussian filter

Arguments

  • 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

  • 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

Specs

mask_gaussian_band!(integer(), integer(), float(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

mask_gaussian_ring(integer(), integer(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a gaussian ring filter

Arguments

  • width - Image width in pixels
  • height - Image height in pixels
  • frequency-cutoff - Frequency cutoff
  • amplitude-cutoff - Amplitude cutoff
  • ringwidth - Ringwidth

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

Specs

mask_gaussian_ring!(integer(), integer(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

mask_ideal(integer(), integer(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make an ideal filter

Arguments

  • width - Image width in pixels
  • height - Image height in pixels
  • frequency-cutoff - Frequency cutoff

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

Specs

mask_ideal!(integer(), integer(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

mask_ideal_band(integer(), integer(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make an ideal band filter

Arguments

  • 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

  • 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

Specs

mask_ideal_band!(integer(), integer(), float(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

mask_ideal_ring(integer(), integer(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make an ideal ring filter

Arguments

  • width - Image width in pixels
  • height - Image height in pixels
  • frequency-cutoff - Frequency cutoff
  • ringwidth - Ringwidth

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

Specs

mask_ideal_ring!(integer(), integer(), float(), float(),
  optical: boolean(),
  reject: boolean(),
  nodc: boolean(),
  uchar: boolean()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

match(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  search: boolean(),
  harea: integer(),
  hwindow: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

First-order match of two images

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

  • search - Search to improve tie-points. Default: false
  • harea - Half area size. Default: 1
  • hwindow - Half window size. Default: 1
Link to this function

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

View Source

Specs

match!(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  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

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

View Source

Specs

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

Apply a math operation to an image

Arguments

  • in - Input image
  • math - math to perform
Link to this function

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

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Binary math operations

Arguments

  • left - Left-hand image argument
  • right - Right-hand image argument
  • math2 - math to perform
Link to this function

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

View Source

Specs

Same as math2/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

Specs

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

Binary math operations with a constant

Arguments

  • in - Input image
  • math2 - math to perform
  • c - Array of constants
Link to this function

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

View Source

Specs

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

Link to this function

matrixinvert(in, optional \\ [])

View Source

Specs

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

Invert an matrix

Arguments

  • in - An square matrix
Link to this function

matrixinvert!(in, optional \\ [])

View Source

Specs

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

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

Specs

max(Vix.Vips.Image.t(), [{:size, integer()}]) ::
  {:ok,
   {float(),
    [
      "y-array": [integer()],
      "x-array": [integer()],
      "out-array": [float()],
      y: integer(),
      x: integer()
    ]}}
  | {:error, term()}

Find image maximum

Arguments

  • in - Input image

Optional

  • size - Number of maximum values to find. Default: 10

Returns

Ordered values in the returned tuple

  • out - Output value. (float())

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

max!(in, optional \\ [])

View Source

Specs

max!(Vix.Vips.Image.t(), [{:size, integer()}]) ::
  {float(),
   [
     "y-array": [integer()],
     "x-array": [integer()],
     "out-array": [float()],
     y: integer(),
     x: integer()
   ]}
  | no_return()

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

Link to this function

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

View Source

Specs

measure(Vix.Vips.Image.t(), integer(), integer(),
  height: integer(),
  width: integer(),
  top: integer(),
  left: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Measure a set of patches on a color chart

Arguments

  • in - Image to measure
  • h - Number of patches across chart
  • v - Number of patches down chart

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

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

View Source

Specs

measure!(Vix.Vips.Image.t(), integer(), integer(),
  height: integer(),
  width: integer(),
  top: integer(),
  left: integer()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

merge(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  vips_direction(),
  integer(),
  integer(),
  [{:mblend, integer()}]
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Merge two images

Arguments

  • 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

  • mblend - Maximum blend size. Default: 10
Link to this function

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

View Source

Specs

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

Specs

min(Vix.Vips.Image.t(), [{:size, integer()}]) ::
  {:ok,
   {float(),
    [
      "y-array": [integer()],
      "x-array": [integer()],
      "out-array": [float()],
      y: integer(),
      x: integer()
    ]}}
  | {:error, term()}

Find image minimum

Arguments

  • in - Input image

Optional

  • size - Number of minimum values to find. Default: 10

Returns

Ordered values in the returned tuple

  • out - Output value. (float())

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

min!(in, optional \\ [])

View Source

Specs

min!(Vix.Vips.Image.t(), [{:size, integer()}]) ::
  {float(),
   [
     "y-array": [integer()],
     "x-array": [integer()],
     "out-array": [float()],
     y: integer(),
     x: integer()
   ]}
  | no_return()

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

Link to this function

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

View Source

Specs

Morphology operation

Arguments

  • in - Input image argument
  • mask - Input matrix image
  • morph - Morphological operation to perform
Link to this function

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

View Source

Specs

Same as morph/4, 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

Specs

mosaic(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  vips_direction(),
  integer(),
  integer(),
  integer(),
  integer(),
  bandno: integer(),
  mblend: integer(),
  harea: integer(),
  hwindow: integer()
) ::
  {:ok,
   {Vix.Vips.Image.t(),
    [
      dx1: float(),
      dy1: float(),
      angle1: float(),
      scale1: float(),
      dy0: integer(),
      dx0: integer()
    ]}}
  | {:error, term()}

Mosaic two images

Arguments

  • 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

  • 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

Ordered values in the returned tuple

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

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

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

View Source

Specs

mosaic!(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  vips_direction(),
  integer(),
  integer(),
  integer(),
  integer(),
  bandno: integer(),
  mblend: integer(),
  harea: integer(),
  hwindow: integer()
) ::
  {Vix.Vips.Image.t(),
   [
     dx1: float(),
     dy1: float(),
     angle1: float(),
     scale1: float(),
     dy0: integer(),
     dx0: integer()
   ]}
  | no_return()

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

Link to this function

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

View Source

Specs

mosaic1(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  vips_direction(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  bandno: integer(),
  mblend: integer(),
  search: boolean(),
  harea: integer(),
  hwindow: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

First-order mosaic of two images

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

  • bandno - Band to search for features on. Default: 0
  • mblend - Maximum blend size. Default: 10
  • search - Search to improve tie-points. Default: false
  • harea - Half area size. Default: 15
  • hwindow - Half window size. Default: 5
Link to this function

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

View Source

Specs

mosaic1!(
  Vix.Vips.Image.t(),
  Vix.Vips.Image.t(),
  vips_direction(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  integer(),
  bandno: integer(),
  mblend: integer(),
  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.

Specs

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

Pick most-significant byte from an image

Arguments

  • in - Input image

Optional

  • band - Band to msb. Default: 0
Link to this function

msb!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Multiply two images

Arguments

  • left - Left-hand image argument
  • right - Right-hand image argument
Link to this function

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

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Find threshold for percent of pixels

Arguments

  • in - Input image
  • percent - Percent of pixels
Link to this function

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

perlin(integer(), integer(), uchar: boolean(), "cell-size": integer()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a perlin noise image

Arguments

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

Optional

  • uchar - Output an unsigned char image. Default: false
  • cell-size - Size of Perlin cells. Default: 256
Link to this function

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

View Source

Specs

perlin!(integer(), 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

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

View Source

Specs

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

Calculate phase correlation

Arguments

  • in - Input image
  • in2 - Second input image
Link to this function

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

View Source

Specs

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

Link to this function

premultiply(in, optional \\ [])

View Source

Specs

premultiply(Vix.Vips.Image.t(), [{:"max-alpha", float()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Premultiply image alpha

Arguments

  • in - Input image

Optional

  • max-alpha - Maximum value of alpha channel. Default: 255.0
Link to this function

premultiply!(in, optional \\ [])

View Source

Specs

premultiply!(Vix.Vips.Image.t(), [{:"max-alpha", float()}]) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

profile(in, optional \\ [])

View Source

Specs

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

Find image profiles

Arguments

  • in - Input image

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

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

Link to this function

profile!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

project(in, optional \\ [])

View Source

Specs

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

Find image projections

Arguments

  • in - Input image

Returns

Ordered values in the returned tuple

  • columns - Sums of columns. (Vix.Vips.Image.t())
  • rows - Sums of rows. (Vix.Vips.Image.t())

Additional

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

Link to this function

project!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Resample an image with a quadratic transform

Arguments

  • in - Input image argument
  • coeff - Coefficient matrix
Link to this function

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

View Source

Specs

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

Link to this function

rad2float(in, optional \\ [])

View Source

Specs

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

Unpack radiance coding to float rgb

Arguments

  • in - Input image
Link to this function

rad2float!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Rank filter

Arguments

  • in - Input image argument
  • width - Window width in pixels
  • height - Window height in pixels
  • index - Select pixel at index
Link to this function

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

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Linear recombination with matrix

Arguments

  • in - Input image argument
  • m - matrix of coefficients
Link to this function

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

View Source

Specs

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

Link to this function

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

View Source

Specs

reduce(Vix.Vips.Image.t(), float(), float(),
  centre: boolean(),
  kernel: vips_kernel()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Reduce an image

Arguments

  • in - Input image argument
  • hshrink - Horizontal shrink factor
  • vshrink - Vertical shrink factor

Optional

  • centre - Use centre sampling convention. Default: false
  • kernel - Resampling kernel. Default: :VIPS_KERNEL_LANCZOS3
Link to this function

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

View Source

Specs

reduce!(Vix.Vips.Image.t(), float(), float(),
  centre: boolean(),
  kernel: vips_kernel()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

reduceh(Vix.Vips.Image.t(), float(), centre: boolean(), kernel: vips_kernel()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Shrink an image horizontally

Arguments

  • in - Input image argument
  • hshrink - Horizontal shrink factor

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

Specs

reduceh!(Vix.Vips.Image.t(), float(), centre: boolean(), kernel: vips_kernel()) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

reducev(Vix.Vips.Image.t(), float(), centre: boolean(), kernel: vips_kernel()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Shrink an image vertically

Arguments

  • in - Input image argument
  • vshrink - Vertical shrink factor

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

Specs

reducev!(Vix.Vips.Image.t(), float(), centre: boolean(), kernel: vips_kernel()) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

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

Relational operation on two images

Arguments

  • left - Left-hand image argument
  • right - Right-hand image argument
  • relational - relational to perform
Link to this function

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

View Source

Specs

Same as relational/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

Specs

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

Relational operations against a constant

Arguments

  • in - Input image
  • relational - relational to perform
  • c - Array of constants
Link to this function

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Remainder after integer division of two images

Arguments

  • left - Left-hand image argument
  • right - Right-hand image argument
Link to this function

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

View Source

Specs

Same as remainder/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

Specs

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

Remainder after integer division of an image and a constant

Arguments

  • in - Input image
  • c - Array of constants
Link to this function

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Replicate an image

Arguments

  • in - Input image
  • across - Repeat this many times horizontally
  • down - Repeat this many times vertically
Link to this function

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

resize(Vix.Vips.Image.t(), float(),
  idy: float(),
  idx: float(),
  vscale: float(),
  centre: boolean(),
  kernel: vips_kernel()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Resize an image

Arguments

  • in - Input image argument
  • scale - Scale image by this factor

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

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

View Source

Specs

resize!(Vix.Vips.Image.t(), float(),
  idy: float(),
  idx: float(),
  vscale: float(),
  centre: boolean(),
  kernel: vips_kernel()
) :: 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

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

View Source

Specs

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

Rotate an image

Arguments

  • in - Input image
  • angle - Angle to rotate image
Link to this function

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

View Source

Specs

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

Link to this function

rot45(in, optional \\ [])

View Source

Specs

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

Rotate an image

Arguments

  • in - Input image

Optional

  • angle - Angle to rotate image. Default: :VIPS_ANGLE45_D45
Link to this function

rot45!(in, optional \\ [])

View Source

Specs

rot45!(Vix.Vips.Image.t(), [{:angle, vips_angle45()}]) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

rotate(Vix.Vips.Image.t(), float(),
  idy: float(),
  idx: float(),
  ody: float(),
  odx: float(),
  background: [float()]
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Rotate an image by a number of degrees

Arguments

  • in - Input image argument
  • angle - Rotate anticlockwise by this many degrees

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

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

View Source

Specs

rotate!(Vix.Vips.Image.t(), float(),
  idy: float(),
  idx: float(),
  ody: float(),
  odx: float(),
  background: [float()]
) :: 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

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

View Source

Specs

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

Perform a round function on an image

Arguments

  • in - Input image
  • round - rounding operation to perform
Link to this function

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

View Source

Specs

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

Link to this function

scale(in, optional \\ [])

View Source

Specs

scale(Vix.Vips.Image.t(), log: boolean(), exp: float()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Scale an image to uchar

Arguments

  • in - Input image

Optional

  • log - Log scale. Default: false
  • exp - Exponent for log scale. Default: 0.25
Link to this function

scale!(in, optional \\ [])

View Source

Specs

scale!(Vix.Vips.Image.t(), log: boolean(), exp: float()) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

scrgb2bw(in, optional \\ [])

View Source

Specs

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

Convert scrgb to bw

Arguments

  • in - Input image

Optional

  • depth - Output device space depth in bits. Default: 8
Link to this function

scrgb2bw!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

scrgb2srgb(in, optional \\ [])

View Source

Specs

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

Convert an scrgb image to srgb

Arguments

  • in - Input image

Optional

  • depth - Output device space depth in bits. Default: 8
Link to this function

scrgb2srgb!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

scrgb2xyz(in, optional \\ [])

View Source

Specs

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

Transform scrgb to xyz

Arguments

  • in - Input image
Link to this function

scrgb2xyz!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

sequential(in, optional \\ [])

View Source

Specs

sequential(Vix.Vips.Image.t(),
  access: vips_access(),
  "tile-height": integer(),
  trace: boolean()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Check sequential access

Arguments

  • in - Input image

Optional

  • access - Expected access pattern. Default: :VIPS_ACCESS_SEQUENTIAL
  • tile-height - Tile height in pixels. Default: 1
  • trace - trace pixel requests. Default: true
Link to this function

sequential!(in, optional \\ [])

View Source

Specs

sequential!(Vix.Vips.Image.t(),
  access: vips_access(),
  "tile-height": integer(),
  trace: boolean()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

sharpen(in, optional \\ [])

View Source

Specs

sharpen(Vix.Vips.Image.t(),
  m2: float(),
  m1: float(),
  y3: float(),
  y2: float(),
  x1: float(),
  sigma: float(),
  radius: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Unsharp masking for print

Arguments

  • in - Input image

Optional

  • m2 - Slope for jaggy areas. Default: 3.0
  • m1 - Slope for flat areas. Default: 0.0
  • y3 - Maximum darkening. Default: 20.0
  • y2 - Maximum brightening. Default: 10.0
  • x1 - Flat/jaggy threshold. Default: 2.0
  • sigma - Sigma of Gaussian. Default: 0.5
  • radius - radius of Gaussian. Default: 1
Link to this function

sharpen!(in, optional \\ [])

View Source

Specs

sharpen!(Vix.Vips.Image.t(),
  m2: float(),
  m1: float(),
  y3: float(),
  y2: float(),
  x1: float(),
  sigma: float(),
  radius: integer()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

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

Shrink an image

Arguments

  • in - Input image argument
  • hshrink - Horizontal shrink factor
  • vshrink - Vertical shrink factor
Link to this function

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Shrink an image horizontally

Arguments

  • in - Input image argument
  • hshrink - Horizontal shrink factor
Link to this function

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

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Shrink an image vertically

Arguments

  • in - Input image argument
  • vshrink - Vertical shrink factor
Link to this function

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

View Source

Specs

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

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

Link to this function

sign(in, optional \\ [])

View Source

Specs

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

Unit vector of pixel

Arguments

  • in - Input image
Link to this function

sign!(in, optional \\ [])

View Source

Specs

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

Link to this function

similarity(in, optional \\ [])

View Source

Specs

similarity(Vix.Vips.Image.t(),
  idy: float(),
  idx: float(),
  ody: float(),
  odx: float(),
  background: [float()],
  angle: float(),
  scale: float()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Similarity transform of an image

Arguments

  • in - Input image argument

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.
  • angle - Rotate anticlockwise by this many degrees. Default: 0.0
  • scale - Scale by this factor. Default: 1.0
Link to this function

similarity!(in, optional \\ [])

View Source

Specs

similarity!(Vix.Vips.Image.t(),
  idy: float(),
  idx: float(),
  ody: float(),
  odx: float(),
  background: [float()],
  angle: float(),
  scale: float()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

sines(integer(), integer(), vfreq: float(), hfreq: float(), uchar: boolean()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a 2d sine wave

Arguments

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

Optional

  • vfreq - Vertical spatial frequency. Default: 0.5
  • hfreq - Horizontal spatial frequency. Default: 0.5
  • uchar - Output an unsigned char image. Default: false
Link to this function

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

View Source

Specs

sines!(integer(), integer(), vfreq: float(), hfreq: float(), uchar: boolean()) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

smartcrop(Vix.Vips.Image.t(), integer(), integer(), [
  {:interesting, vips_interesting()}
]) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Extract an area from an image

Arguments

  • input - Input image
  • width - Width of extract area
  • height - Height of extract area

Optional

  • interesting - How to measure interestingness. Default: :VIPS_INTERESTING_ATTENTION
Link to this function

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

View Source

Specs

smartcrop!(Vix.Vips.Image.t(), integer(), integer(), [
  {:interesting, vips_interesting()}
]) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

sobel(in, optional \\ [])

View Source

Specs

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

Sobel edge detector

Arguments

  • in - Input image
Link to this function

sobel!(in, optional \\ [])

View Source

Specs

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

Link to this function

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

View Source

Specs

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

Spatial correlation

Arguments

  • in - Input image argument
  • ref - Input reference image
Link to this function

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

View Source

Specs

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

Link to this function

spectrum(in, optional \\ [])

View Source

Specs

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

Make displayable power spectrum

Arguments

  • in - Input image
Link to this function

spectrum!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

srgb2hsv(in, optional \\ [])

View Source

Specs

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

Transform srgb to hsv

Arguments

  • in - Input image
Link to this function

srgb2hsv!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

srgb2scrgb(in, optional \\ [])

View Source

Specs

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

Convert an srgb image to scrgb

Arguments

  • in - Input image
Link to this function

srgb2scrgb!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

stats(in, optional \\ [])

View Source

Specs

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

Find many image stats

Arguments

  • in - Input image
Link to this function

stats!(in, optional \\ [])

View Source

Specs

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

Link to this function

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

View Source

Specs

stdif(Vix.Vips.Image.t(), integer(), integer(),
  a: float(),
  m0: float(),
  b: float(),
  s0: float()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Statistical difference

Arguments

  • in - Input image
  • width - Window width in pixels
  • height - Window height in pixels

Optional

  • a - Weight of new mean. Default: 0.5
  • m0 - New mean. Default: 128.0
  • b - Weight of new deviation. Default: 0.5
  • s0 - New deviation. Default: 50.0
Link to this function

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

View Source

Specs

stdif!(Vix.Vips.Image.t(), integer(), integer(),
  a: float(),
  m0: float(),
  b: float(),
  s0: float()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

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

Subsample an image

Arguments

  • input - Input image
  • xfac - Horizontal subsample factor
  • yfac - Vertical subsample factor

Optional

  • point - Point sample. Default: false
Link to this function

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

View Source

Specs

subsample!(Vix.Vips.Image.t(), integer(), integer(), [{:point, boolean()}]) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

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

Subtract two images

Arguments

  • left - Left-hand image argument
  • right - Right-hand image argument
Link to this function

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

View Source

Specs

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

Specs

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

Sum an array of images

Arguments

  • in - Array of input images
Link to this function

sum!(in, optional \\ [])

View Source

Specs

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

Link to this function

switch(tests, optional \\ [])

View Source

Specs

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

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

Arguments

  • tests - Table of images to test
Link to this function

switch!(tests, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

system(String.t(),
  "in-format": String.t(),
  "out-format": String.t(),
  in: [Vix.Vips.Image.t()]
) :: {:ok, {[log: String.t(), out: Vix.Vips.Image.t()]}} | {:error, term()}

Run an external command

Arguments

  • cmd-format - Command to run

Optional

  • in-format - Format for input filename. Default: nil
  • out-format - Format for output filename. Default: nil
  • in - Array of input images.

Returns

Ordered values in the returned tuple

Additional

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

  • log - Command log. (String.t())
  • out - Output image. (Vix.Vips.Image.t())
Link to this function

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

View Source

Specs

system!(String.t(),
  "in-format": String.t(),
  "out-format": String.t(),
  in: [Vix.Vips.Image.t()]
) :: {[log: String.t(), out: Vix.Vips.Image.t()]} | no_return()

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

Link to this function

text(text, optional \\ [])

View Source

Specs

text(String.t(),
  fontfile: String.t(),
  spacing: integer(),
  justify: boolean(),
  dpi: integer(),
  align: vips_align(),
  height: integer(),
  width: integer(),
  font: String.t()
) ::
  {:ok, {Vix.Vips.Image.t(), [{:"autofit-dpi", integer()}]}} | {:error, term()}

Make a text image

Arguments

  • text - Text to render

Optional

  • fontfile - Load this font file. Default: nil
  • spacing - Line spacing. Default: 0
  • justify - Justify lines. Default: false
  • dpi - DPI to render at. Default: 72
  • align - Align on the low, centre or high edge. Default: :VIPS_ALIGN_LOW
  • height - Maximum image height in pixels. Default: 0
  • width - Maximum image width in pixels. Default: 0
  • font - Font to render with. Default: nil

Returns

Ordered values in the returned tuple

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

Additional

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

  • autofit-dpi - DPI selected by autofit. (integer())
Link to this function

text!(text, optional \\ [])

View Source

Specs

text!(String.t(),
  fontfile: String.t(),
  spacing: integer(),
  justify: boolean(),
  dpi: integer(),
  align: vips_align(),
  height: integer(),
  width: integer(),
  font: String.t()
) :: {Vix.Vips.Image.t(), [{:"autofit-dpi", integer()}]} | no_return()

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

Link to this function

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

View Source

Specs

thumbnail(String.t(), integer(),
  "auto-rotate": boolean(),
  intent: vips_intent(),
  "export-profile": String.t(),
  "import-profile": String.t(),
  linear: boolean(),
  crop: vips_interesting(),
  "no-rotate": boolean(),
  size: vips_size(),
  height: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Generate thumbnail from file

Arguments

  • filename - Filename to read from
  • width - Size to this width

Optional

  • auto-rotate - Use orientation tags to rotate image upright. Default: true
  • intent - Rendering intent. Default: :VIPS_INTENT_RELATIVE
  • export-profile - Fallback export profile. Default: nil
  • import-profile - Fallback import profile. Default: nil
  • linear - Reduce in linear light. Default: false
  • crop - Reduce to fill target rectangle, then crop. Default: :VIPS_INTERESTING_NONE
  • no-rotate - Don't use orientation tags to rotate image upright. Default: false
  • size - Only upsize, only downsize, or both. Default: :VIPS_SIZE_BOTH
  • height - Size to this height. Default: 1
Link to this function

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

View Source

Specs

thumbnail!(String.t(), integer(),
  "auto-rotate": boolean(),
  intent: vips_intent(),
  "export-profile": String.t(),
  "import-profile": String.t(),
  linear: boolean(),
  crop: vips_interesting(),
  "no-rotate": boolean(),
  size: vips_size(),
  height: integer()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

thumbnail_image(Vix.Vips.Image.t(), integer(),
  "auto-rotate": boolean(),
  intent: vips_intent(),
  "export-profile": String.t(),
  "import-profile": String.t(),
  linear: boolean(),
  crop: vips_interesting(),
  "no-rotate": boolean(),
  size: vips_size(),
  height: integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Generate thumbnail from image

Arguments

  • in - Input image argument
  • width - Size to this width

Optional

  • auto-rotate - Use orientation tags to rotate image upright. Default: true
  • intent - Rendering intent. Default: :VIPS_INTENT_RELATIVE
  • export-profile - Fallback export profile. Default: nil
  • import-profile - Fallback import profile. Default: nil
  • linear - Reduce in linear light. Default: false
  • crop - Reduce to fill target rectangle, then crop. Default: :VIPS_INTERESTING_NONE
  • no-rotate - Don't use orientation tags to rotate image upright. Default: false
  • size - Only upsize, only downsize, or both. Default: :VIPS_SIZE_BOTH
  • height - Size to this height. Default: 1
Link to this function

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

View Source

Specs

thumbnail_image!(Vix.Vips.Image.t(), integer(),
  "auto-rotate": boolean(),
  intent: vips_intent(),
  "export-profile": String.t(),
  "import-profile": String.t(),
  linear: boolean(),
  crop: vips_interesting(),
  "no-rotate": boolean(),
  size: vips_size(),
  height: integer()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

tilecache(in, optional \\ [])

View Source

Specs

tilecache(Vix.Vips.Image.t(),
  persistent: boolean(),
  threaded: boolean(),
  access: vips_access(),
  "max-tiles": integer(),
  "tile-height": integer(),
  "tile-width": integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Cache an image as a set of tiles

Arguments

  • in - Input image

Optional

  • persistent - Keep cache between evaluations. Default: false
  • threaded - Allow threaded access. Default: false
  • access - Expected access pattern. Default: :VIPS_ACCESS_RANDOM
  • max-tiles - Maximum number of tiles to cache. Default: 1000
  • tile-height - Tile height in pixels. Default: 128
  • tile-width - Tile width in pixels. Default: 128
Link to this function

tilecache!(in, optional \\ [])

View Source

Specs

tilecache!(Vix.Vips.Image.t(),
  persistent: boolean(),
  threaded: boolean(),
  access: vips_access(),
  "max-tiles": integer(),
  "tile-height": integer(),
  "tile-width": integer()
) :: Vix.Vips.Image.t() | no_return()

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

Specs

tonelut(
  H: float(),
  M: float(),
  S: float(),
  Ph: float(),
  Pm: float(),
  Ps: float(),
  Lw: float(),
  Lb: float(),
  "out-max": integer(),
  "in-max": integer()
) :: {:ok, Vix.Vips.Image.t()} | {:error, term()}

Build a look-up table

Arguments

Optional

  • H - Adjust highlights by this much. Default: 0.0
  • M - Adjust mid-tones by this much. Default: 0.0
  • S - Adjust shadows by this much. Default: 0.0
  • Ph - Position of highlights. Default: 0.8
  • Pm - Position of mid-tones. Default: 0.5
  • Ps - Position of shadow. Default: 0.2
  • Lw - Highest value in output. Default: 100.0
  • Lb - Lowest value in output. Default: 0.0
  • out-max - Maximum value in output LUT. Default: 32767
  • in-max - Size of LUT to build. Default: 32767
Link to this function

tonelut!(optional \\ [])

View Source

Specs

tonelut!(
  H: float(),
  M: float(),
  S: float(),
  Ph: float(),
  Pm: float(),
  Ps: float(),
  Lw: float(),
  Lb: float(),
  "out-max": integer(),
  "in-max": integer()
) :: Vix.Vips.Image.t() | no_return()

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

Link to this function

transpose3d(in, optional \\ [])

View Source

Specs

transpose3d(Vix.Vips.Image.t(), [{:"page-height", integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Transpose3d an image

Arguments

  • in - Input image

Optional

  • page-height - Height of each input page. Default: 0
Link to this function

transpose3d!(in, optional \\ [])

View Source

Specs

transpose3d!(Vix.Vips.Image.t(), [{:"page-height", integer()}]) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

unpremultiply(in, optional \\ [])

View Source

Specs

unpremultiply(Vix.Vips.Image.t(), "alpha-band": integer(), "max-alpha": float()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Unpremultiply image alpha

Arguments

  • in - Input image

Optional

  • alpha-band - Unpremultiply with this alpha. Default: 3
  • max-alpha - Maximum value of alpha channel. Default: 255.0
Link to this function

unpremultiply!(in, optional \\ [])

View Source

Specs

unpremultiply!(Vix.Vips.Image.t(), "alpha-band": integer(), "max-alpha": float()) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

worley(integer(), integer(), [{:"cell-size", integer()}]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make a worley noise image

Arguments

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

Optional

  • cell-size - Size of Worley cells. Default: 256
Link to this function

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

View Source

Specs

worley!(integer(), integer(), [{:"cell-size", integer()}]) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

wrap(in, optional \\ [])

View Source

Specs

wrap(Vix.Vips.Image.t(), y: integer(), x: integer()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Wrap image origin

Arguments

  • in - Input image

Optional

  • y - Top edge of input in output. Default: 0
  • x - Left edge of input in output. Default: 0
Link to this function

wrap!(in, optional \\ [])

View Source

Specs

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

Link to this function

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

View Source

Specs

xyz(integer(), integer(), esize: integer(), dsize: integer(), csize: integer()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, term()}

Make an image where pixel values are coordinates

Arguments

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

Optional

  • esize - Size of fifth dimension. Default: 1
  • dsize - Size of fourth dimension. Default: 1
  • csize - Size of third dimension. Default: 1
Link to this function

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

View Source

Specs

xyz!(integer(), integer(), esize: integer(), dsize: integer(), csize: integer()) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

xyz2cmyk(in, optional \\ [])

View Source

Specs

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

Transform xyz to cmyk

Arguments

  • in - Input image
Link to this function

xyz2cmyk!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

xyz2lab(in, optional \\ [])

View Source

Specs

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

Transform xyz to lab

Arguments

  • in - Input image

Optional

  • temp - Colour temperature.
Link to this function

xyz2lab!(in, optional \\ [])

View Source

Specs

xyz2lab!(Vix.Vips.Image.t(), [{:temp, [float()]}]) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

xyz2scrgb(in, optional \\ [])

View Source

Specs

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

Transform xyz to scrgb

Arguments

  • in - Input image
Link to this function

xyz2scrgb!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

xyz2yxy(in, optional \\ [])

View Source

Specs

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

Transform xyz to yxy

Arguments

  • in - Input image
Link to this function

xyz2yxy!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

yxy2xyz(in, optional \\ [])

View Source

Specs

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

Transform yxy to xyz

Arguments

  • in - Input image
Link to this function

yxy2xyz!(in, optional \\ [])

View Source

Specs

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

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

Link to this function

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

View Source

Specs

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

Make a zone plate

Arguments

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

Optional

  • uchar - Output an unsigned char image. Default: false
Link to this function

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

View Source

Specs

zone!(integer(), integer(), [{:uchar, boolean()}]) ::
  Vix.Vips.Image.t() | no_return()

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

Link to this function

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

View Source

Specs

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

Zoom an image

Arguments

  • input - Input image
  • xfac - Horizontal zoom factor
  • yfac - Vertical zoom factor
Link to this function

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

View Source

Specs

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