Vips – 8.0: Operator index / Alphabetical
Description: Reference for Vips-8.0: Operator index / Alphabetical

#### Operator index / Alphabetical [src]

libvips has a set of operators, each of which computes some useful image processing operation. Each operator is implemented as a `GObject` class, for example `VipsGamma`. Classes are identified by their unique `VipsObject:nickname`, in this case `gamma`.

From the command-line, C++ and most language bindings, you use the nickname to call the operator. For example in C++:

    vips::VImage fred = ...;
    vips::VImage jim = fred.gamma();

or Python:

    fred = jim.gamma()

libvips has a set of C wrapper functions for calling operators, in this case `vips_gamma()`:

    VipsImage *fred = ...;
    VipsImage *jim;

    if (vips_gamma(fred, &jim, NULL))
        ...error;

Some operators have many C convenience functions.

# All libvips operators

This table lists all the libvips operators with their C convenience functions and a short description. It’s supposed to be useful for searching. See the API docs each function links to for more details.

Operator | Description | C functions
--- | --- | ---
`CMC2LCh` | Transform lch to cmc | `vips_CMC2LCh()`
`CMYK2XYZ` | Transform cmyk to xyz | `vips_CMYK2XYZ()`
`HSV2sRGB` | Transform hsv to srgb | `vips_HSV2sRGB()`
`LCh2CMC` | Transform lch to cmc | `vips_LCh2CMC()`
`LCh2Lab` | Transform lch to lab | `vips_LCh2Lab()`
`Lab2LCh` | Transform lab to lch | `vips_Lab2LCh()`
`Lab2LabQ` | Transform float lab to labq coding | `vips_Lab2LabQ()`
`Lab2LabS` | Transform float lab to signed short | `vips_Lab2LabS()`
`Lab2XYZ` | Transform cielab to xyz | `vips_Lab2XYZ()`
`LabQ2Lab` | Unpack a labq image to float lab | `vips_LabQ2Lab()`
`LabQ2LabS` | Unpack a labq image to short lab | `vips_LabQ2LabS()`
`LabQ2sRGB` | Convert a labq image to srgb | `vips_LabQ2sRGB()`
`LabS2Lab` | Transform signed short lab to float | `vips_LabS2Lab()`
`LabS2LabQ` | Transform short lab to labq coding | `vips_LabS2LabQ()`
`Oklab2Oklch` | Transform oklab to oklch | `vips_Oklab2Oklch()`
`Oklab2XYZ` | Transform oklab to xyz | `vips_Oklab2XYZ()`
`Oklch2Oklab` | Transform oklch to oklab | `vips_Oklch2Oklab()`
`XYZ2CMYK` | Transform xyz to cmyk | `vips_XYZ2CMYK()`
`XYZ2Lab` | Transform xyz to lab | `vips_XYZ2Lab()`
`XYZ2Oklab` | Transform xyz to oklab | `vips_XYZ2Oklab()`
`XYZ2Yxy` | Transform xyz to yxy | `vips_XYZ2Yxy()`
`XYZ2scRGB` | Transform xyz to scrgb | `vips_XYZ2scRGB()`
`Yxy2XYZ` | Transform yxy to xyz | `vips_Yxy2XYZ()`
`abs` | Absolute value of an image | `vips_abs()`
`add` | Add two images | `vips_add()`
`addalpha` | Append an alpha channel | `vips_addalpha()`
`affine` | Affine transform of an image | `vips_affine()`
`analyzeload` | Load an analyze6 image | `vips_analyzeload()`
`arrayjoin` | Join an array of images | `vips_arrayjoin()`
`autorot` | Autorotate image by exif tag | `vips_autorot()`
`avg` | Find image average | `vips_avg()`
`bandbool` | Boolean operation across image bands | `vips_bandbool()`, `vips_bandand()`, `vips_bandor()`, `vips_bandeor()`, `vips_bandmean()`
`bandfold` | Fold up x axis into bands | `vips_bandfold()`
`bandjoin` | Bandwise join a set of images | `vips_bandjoin()`, `vips_bandjoin2()`
`bandjoin_const` | Append a constant band to an image | `vips_bandjoin_const()`, `vips_bandjoin_const1()`
`bandmean` | Band-wise average | `vips_bandmean()`
`bandrank` | Band-wise rank of a set of images | `vips_bandrank()`
`bandunfold` | Unfold image bands into x axis | `vips_bandunfold()`
`black` | Make a black image | `vips_black()`
`boolean` | Boolean operation on two images | `vips_boolean()`, `vips_andimage()`, `vips_orimage()`, `vips_eorimage()`, `vips_lshift()`, `vips_rshift()`
`boolean_const` | Boolean operations against a constant | `vips_boolean_const()`, `vips_andimage_const()`, `vips_orimage_const()`, `vips_eorimage_const()`, `vips_lshift_const()`, `vips_rshift_const()`, `vips_boolean_const1()`, `vips_andimage_const1()`, `vips_orimage_const1()`, `vips_eorimage_const1()`, `vips_lshift_const1()`, `vips_rshift_const1()`
`buildlut` | Build a look-up table | `vips_buildlut()`
`byteswap` | Byteswap an image | `vips_byteswap()`
`canny` | Canny edge detector | `vips_canny()`
`case` | Use pixel values to pick cases from an array of images | `vips_case()`
`cast` | Cast an image | `vips_cast()`, `vips_cast_uchar()`, `vips_cast_char()`, `vips_cast_ushort()`, `vips_cast_short()`, `vips_cast_uint()`, `vips_cast_int()`, `vips_cast_float()`, `vips_cast_double()`, `vips_cast_complex()`, `vips_cast_dpcomplex()`
`clamp` | Clamp values of an image | `vips_clamp()`
`colourspace` | Convert to a new colorspace | `vips_colourspace()`
`compass` | Convolve with rotating mask | `vips_compass()`
`complex` | Perform a complex operation on an image | `vips_complex()`, `vips_polar()`, `vips_rect()`, `vips_conj()`
`complex2` | Complex binary operations on two images | `vips_complex2()`, `vips_cross_phase()`
`complexform` | Form a complex image from two real images | `vips_complexform()`
`complexget` | Get a component from a complex image | `vips_complexget()`, `vips_real()`, `vips_imag()`
`composite` | Blend an array of images with an array of blend modes | `vips_composite()`
`composite2` | Blend a pair of images with a blend mode | `vips_composite2()`
`conv` | Convolution operation | `vips_conv()`
`conva` | Approximate integer convolution | `vips_conva()`
`convasep` | Approximate separable integer convolution | `vips_convasep()`
`convf` | Float convolution operation | `vips_convf()`
`convi` | Int convolution operation | `vips_convi()`
`convsep` | Separable convolution operation | `vips_convsep()`
`copy` | Copy an image | `vips_copy()`
`countlines` | Count lines in an image | `vips_countlines()`
`csvload` | Load csv | `vips_csvload()`
`csvload_source` | Load csv | `vips_csvload_source()`
`csvsave` | Save image to csv | `vips_csvsave()`
`csvsave_target` | Save image to csv | `vips_csvsave_target()`
`dE00` | Calculate de00 | `vips_dE00()`
`dE76` | Calculate de76 | `vips_dE76()`
`dECMC` | Calculate decmc | `vips_dECMC()`
`dcrawload` | Load raw camera files | `vips_dcrawload()`
`dcrawload_buffer` | Load raw camera files | `vips_dcrawload_buffer()`
`dcrawload_source` | Load raw camera files | `vips_dcrawload_source()`
`deviate` | Find image standard deviation | `vips_deviate()`
`divide` | Divide two images | `vips_divide()`
`draw_circle` | Draw a circle on an image | `vips_draw_circle()`, `vips_draw_circle1()`
`draw_flood` | Flood-fill an area | `vips_draw_flood()`, `vips_draw_flood1()`
`draw_image` | Paint an image into another image | `vips_draw_image()`
`draw_line` | Draw a line on an image | `vips_draw_line()`, `vips_draw_line1()`
`draw_mask` | Draw a mask on an image | `vips_draw_mask()`, `vips_draw_mask1()`
`draw_rect` | Paint a rectangle on an image | `vips_draw_rect()`, `vips_draw_rect1()`, `vips_draw_point()`, `vips_draw_point1()`
`draw_smudge` | Blur a rectangle on an image | `vips_draw_smudge()`
`dzsave` | Save image to deepzoom file | `vips_dzsave()`
`dzsave_buffer` | Save image to dz buffer | `vips_dzsave_buffer()`
`dzsave_target` | Save image to deepzoom target | `vips_dzsave_target()`
`embed` | Embed an image in a larger image | `vips_embed()`
`extract_area` | Extract an area from an image | `vips_extract_area()`, `vips_crop()`
`extract_band` | Extract band from an image | `vips_extract_band()`
`eye` | Make an image showing the eye’s spatial response | `vips_eye()`
`falsecolour` | False-color an image | `vips_falsecolour()`
`fastcor` | Fast correlation | `vips_fastcor()`
`fill_nearest` | Fill image zeros with nearest non-zero pixel | `vips_fill_nearest()`
`find_trim` | Search an image for non-edge areas | `vips_find_trim()`
`fitsload` | Load a fits image | `vips_fitsload()`
`fitsload_source` | Load fits from a source | `vips_fitsload_source()`
`fitssave` | Save image to fits file | `vips_fitssave()`
`flatten` | Flatten alpha out of an image | `vips_flatten()`
`flip` | Flip an image | `vips_flip()`
`float2rad` | Transform float rgb to radiance coding | `vips_float2rad()`
`fractsurf` | Make a fractal surface | `vips_fractsurf()`
`freqmult` | Frequency-domain filtering | `vips_freqmult()`
`fwfft` | Forward fft | `vips_fwfft()`
`gamma` | Gamma an image | `vips_gamma()`
`gaussblur` | Gaussian blur | `vips_gaussblur()`
`gaussmat` | Make a gaussian image | `vips_gaussmat()`
`gaussnoise` | Make a gaussnoise image | `vips_gaussnoise()`
`getpoint` | Read a point from an image | `vips_getpoint()`
`gifload` | Load gif with libnsgif | `vips_gifload()`
`gifload_buffer` | Load gif with libnsgif | `vips_gifload_buffer()`
`gifload_source` | Load gif from source | `vips_gifload_source()`
`gifsave` | Save as gif | `vips_gifsave()`
`gifsave_buffer` | Save as gif | `vips_gifsave_buffer()`
`gifsave_target` | Save as gif | `vips_gifsave_target()`
`globalbalance` | Global balance an image mosaic | `vips_globalbalance()`
`gravity` | Place an image within a larger image with a certain gravity | `vips_gravity()`
`grey` | Make a grey ramp image | `vips_grey()`
`grid` | Grid an image | `vips_grid()`
`heifload` | Load a heif image | `vips_heifload()`
`heifload_buffer` | Load a heif image | `vips_heifload_buffer()`
`heifload_source` | Load a heif image | `vips_heifload_source()`
`heifsave` | Save image in heif format | `vips_heifsave()`
`heifsave_buffer` | Save image in heif format | `vips_heifsave_buffer()`
`heifsave_target` | Save image in heif format | `vips_heifsave_target()`
`hist_cum` | Form cumulative histogram | `vips_hist_cum()`
`hist_entropy` | Estimate image entropy | `vips_hist_entropy()`
`hist_equal` | Histogram equalisation | `vips_hist_equal()`
`hist_find` | Find image histogram | `vips_hist_find()`
`hist_find_indexed` | Find indexed image histogram | `vips_hist_find_indexed()`
`hist_find_ndim` | Find n-dimensional image histogram | `vips_hist_find_ndim()`
`hist_ismonotonic` | Test for monotonicity | `vips_hist_ismonotonic()`
`hist_local` | Local histogram equalisation | `vips_hist_local()`
`hist_match` | Match two histograms | `vips_hist_match()`
`hist_norm` | Normalise histogram | `vips_hist_norm()`
`hist_plot` | Plot histogram | `vips_hist_plot()`
`hough_circle` | Find hough circle transform | `vips_hough_circle()`
`hough_line` | Find hough line transform | `vips_hough_line()`
`icc_export` | Output to device with icc profile | `vips_icc_export()`
`icc_import` | Import from device with icc profile | `vips_icc_import()`
`icc_transform` | Transform between devices with icc profiles | `vips_icc_transform()`
`identity` | Make a 1d image where pixel values are indexes | `vips_identity()`
`ifthenelse` | Ifthenelse an image | `vips_ifthenelse()`
`insert` | Insert image `sub` into `main` at `x`, `y` | `vips_insert()`
`invert` | Invert an image | `vips_invert()`
`invertlut` | Build an inverted look-up table | `vips_invertlut()`
`invfft` | Inverse fft | `vips_invfft()`
`join` | Join a pair of images | `vips_join()`
`jp2kload` | Load jpeg2000 image | `vips_jp2kload()`
`jp2kload_buffer` | Load jpeg2000 image | `vips_jp2kload_buffer()`
`jp2kload_source` | Load jpeg2000 image | `vips_jp2kload_source()`
`jp2ksave` | Save image in jpeg2000 format | `vips_jp2ksave()`
`jp2ksave_buffer` | Save image in jpeg2000 format | `vips_jp2ksave_buffer()`
`jp2ksave_target` | Save image in jpeg2000 format | `vips_jp2ksave_target()`
`jpegload` | Load jpeg from file | `vips_jpegload()`
`jpegload_buffer` | Load jpeg from buffer | `vips_jpegload_buffer()`
`jpegload_source` | Load image from jpeg source | `vips_jpegload_source()`
`jpegsave` | Save as jpeg | `vips_jpegsave()`
`jpegsave_buffer` | Save as jpeg | `vips_jpegsave_buffer()`
`jpegsave_mime` | Save image to jpeg mime | `vips_jpegsave_mime()`
`jpegsave_target` | Save as jpeg | `vips_jpegsave_target()`
`jxlload` | Load jpeg-xl image | `vips_jxlload()`
`jxlload_buffer` | Load jpeg-xl image | `vips_jxlload_buffer()`
`jxlload_source` | Load jpeg-xl image | `vips_jxlload_source()`
`jxlsave` | Save image in jpeg-xl format | `vips_jxlsave()`
`jxlsave_buffer` | Save image in jpeg-xl format | `vips_jxlsave_buffer()`
`jxlsave_target` | Save image in jpeg-xl format | `vips_jxlsave_target()`
`labelregions` | Label regions in an image | `vips_labelregions()`
`linear` | Calculate (a * in + b) | `vips_linear()`, `vips_linear1()`
`linecache` | Cache an image as a set of lines | `vips_linecache()`
`logmat` | Make a laplacian of gaussian image | `vips_logmat()`
`magickload` | Load file with imagemagick | `vips_magickload()`
`magickload_buffer` | Load buffer with imagemagick | `vips_magickload_buffer()`
`magickload_source` | Load source with imagemagick | `vips_magickload_source()`
`magicksave` | Save file with imagemagick | `vips_magicksave()`
`magicksave_buffer` | Save image to magick buffer | `vips_magicksave_buffer()`
`mapim` | Resample with a map image | `vips_mapim()`
`maplut` | Map an image though a lut | `vips_maplut()`
`mask_butterworth` | Make a butterworth filter | `vips_mask_butterworth()`
`mask_butterworth_band` | Make a butterworth_band filter | `vips_mask_butterworth_band()`
`mask_butterworth_ring` | Make a butterworth ring filter | `vips_mask_butterworth_ring()`
`mask_fractal` | Make fractal filter | `vips_mask_fractal()`
`mask_gaussian` | Make a gaussian filter | `vips_mask_gaussian()`
`mask_gaussian_band` | Make a gaussian filter | `vips_mask_gaussian_band()`
`mask_gaussian_ring` | Make a gaussian ring filter | `vips_mask_gaussian_ring()`
`mask_ideal` | Make an ideal filter | `vips_mask_ideal()`
`mask_ideal_band` | Make an ideal band filter | `vips_mask_ideal_band()`
`mask_ideal_ring` | Make an ideal ring filter | `vips_mask_ideal_ring()`
`match` | First-order match of two images | `vips_match()`
`math` | Apply a math operation to an image | `vips_math()`, `vips_sin()`, `vips_cos()`, `vips_tan()`, `vips_asin()`, `vips_acos()`, `vips_atan()`, `vips_sinh()`, `vips_cosh()`, `vips_tanh()`, `vips_asinh()`, `vips_acosh()`, `vips_atanh()`, `vips_exp()`, `vips_exp10()`, `vips_log()`, `vips_log10()`
`math2` | Binary math operations | `vips_math2()`, `vips_pow()`, `vips_wop()`, `vips_atan2()`
`math2_const` | Binary math operations with a constant | `vips_math2_const()`, `vips_andimage_const()`, `vips_orimage_const()`, `vips_eorimage_const()`, `vips_lshift_const()`, `vips_rshift_const()`, `vips_math2_const1()`, `vips_andimage_const1()`, `vips_orimage_const1()`, `vips_eorimage_const1()`, `vips_lshift_const1()`, `vips_rshift_const1()`
`matload` | Load mat from file | `vips_matload()`
`matrixinvert` | Invert a matrix | `vips_matrixinvert()`
`matrixload` | Load matrix | `vips_matrixload()`
`matrixload_source` | Load matrix | `vips_matrixload_source()`
`matrixmultiply` | Multiply two matrices | `vips_matrixmultiply()`
`matrixprint` | Print matrix | `vips_matrixprint()`
`matrixsave` | Save image to matrix | `vips_matrixsave()`
`matrixsave_target` | Save image to matrix | `vips_matrixsave_target()`
`max` | Find image maximum | `vips_max()`
`maxpair` | Maximum of a pair of images | `vips_maxpair()`
`measure` | Measure a set of patches on a color chart | `vips_measure()`
`merge` | Merge two images | `vips_merge()`
`min` | Find image minimum | `vips_min()`
`minpair` | Minimum of a pair of images | `vips_minpair()`
`morph` | Morphology operation | `vips_morph()`
`mosaic` | Mosaic two images | `vips_mosaic()`
`mosaic1` | First-order mosaic of two images | `vips_mosaic1()`
`msb` | Pick most-significant byte from an image | `vips_msb()`
`multiply` | Multiply two images | `vips_multiply()`
`niftiload` | Load nifti volume | `vips_niftiload()`
`niftiload_source` | Load nifti volumes | `vips_niftiload_source()`
`niftisave` | Save image to nifti file | `vips_niftisave()`
`openexrload` | Load an openexr image | `vips_openexrload()`
`openslideload` | Load file with openslide | `vips_openslideload()`
`openslideload_source` | Load source with openslide | `vips_openslideload_source()`
`pdfload` | Load pdf from file | `vips_pdfload()`
`pdfload_buffer` | Load pdf from buffer | `vips_pdfload_buffer()`
`pdfload_source` | Load pdf from source | `vips_pdfload_source()`
`percent` | Find threshold for percent of pixels | `vips_percent()`
`perlin` | Make a perlin noise image | `vips_perlin()`
`phasecor` | Calculate phase correlation | `vips_phasecor()`
`pngload` | Load png from file | `vips_pngload()`
`pngload_buffer` | Load png from buffer | `vips_pngload_buffer()`
`pngload_source` | Load png from source | `vips_pngload_source()`
`pngsave` | Save image to file as png | `vips_pngsave()`
`pngsave_buffer` | Save image to buffer as png | `vips_pngsave_buffer()`
`pngsave_target` | Save image to target as png | `vips_pngsave_target()`
`ppmload` | Load ppm from file | `vips_ppmload()`
`ppmload_buffer` | Load ppm from buffer | `vips_ppmload_buffer()`
`ppmload_source` | Load ppm from source | `vips_ppmload_source()`
`ppmsave` | Save image to ppm file | `vips_ppmsave()`
`ppmsave_target` | Save to ppm | `vips_ppmsave_target()`
`premultiply` | Premultiply image alpha | `vips_premultiply()`
`prewitt` | Prewitt edge detector | `vips_prewitt()`
`profile` | Find image profiles | `vips_profile()`
`profile_load` | Load named icc profile | `vips_profile_load()`
`project` | Find image projections | `vips_project()`
`quadratic` | Resample an image with a quadratic transform | `vips_quadratic()`
`rad2float` | Unpack radiance coding to float rgb | `vips_rad2float()`
`radload` | Load a radiance image from a file | `vips_radload()`
`radload_buffer` | Load rad from buffer | `vips_radload_buffer()`
`radload_source` | Load rad from source | `vips_radload_source()`
`radsave` | Save image to radiance file | `vips_radsave()`
`radsave_buffer` | Save image to radiance buffer | `vips_radsave_buffer()`
`radsave_target` | Save image to radiance target | `vips_radsave_target()`
`rank` | Rank filter | `vips_rank()`, `vips_median()`
`rawload` | Load raw data from a file | `vips_rawload()`
`rawsave` | Save image to raw file | `vips_rawsave()`
`rawsave_buffer` | Write raw image to buffer | `vips_rawsave_buffer()`
`rawsave_target` | Write raw image to target | `vips_rawsave_target()`
`recomb` | Linear recombination with matrix | `vips_recomb()`
`reduce` | Reduce an image | `vips_reduce()`
`reduceh` | Shrink an image horizontally | `vips_reduceh()`
`reducev` | Shrink an image vertically | `vips_reducev()`
`relational` | Relational operation on two images | `vips_relational()`, `vips_equal()`, `vips_notequal()`, `vips_less()`, `vips_lesseq()`, `vips_more()`, `vips_moreeq()`
`relational_const` | Relational operations against a constant | `vips_relational_const()`, `vips_equal_const()`, `vips_notequal_const()`, `vips_less_const()`, `vips_lesseq_const()`, `vips_more_const()`, `vips_moreeq_const()`, `vips_relational_const1()`, `vips_equal_const1()`, `vips_notequal_const1()`, `vips_less_const1()`, `vips_lesseq_const1()`, `vips_more_const1()`, `vips_moreeq_const1()`
`remainder` | Remainder after integer division of two images | `vips_remainder()`
`remainder_const` | Remainder after integer division of an image and a constant | `vips_remainder_const()`, `vips_remainder_const1()`
`remosaic` | Rebuild an mosaiced image | `vips_remosaic()`
`replicate` | Replicate an image | `vips_replicate()`
`resize` | Resize an image | `vips_resize()`
`rot` | Rotate an image | `vips_rot()`
`rot45` | Rotate an image | `vips_rot45()`
`rotate` | Rotate an image by a number of degrees | `vips_rotate()`
`round` | Perform a round function on an image | `vips_round()`, `vips_floor()`, `vips_ceil()`, `vips_rint()`
`sRGB2HSV` | Transform srgb to hsv | `vips_sRGB2HSV()`
`sRGB2scRGB` | Convert an srgb image to scrgb | `vips_sRGB2scRGB()`
`scRGB2BW` | Convert scrgb to bw | `vips_scRGB2BW()`
`scRGB2XYZ` | Transform scrgb to xyz | `vips_scRGB2XYZ()`
`scRGB2sRGB` | Convert scrgb to srgb | `vips_scRGB2sRGB()`
`scale` | Scale an image to uchar | `vips_scale()`
`scharr` | Scharr edge detector | `vips_scharr()`
`sdf` | Create an sdf image | `vips_sdf()`
`sequential` | Check sequential access | `vips_sequential()`
`sharpen` | Unsharp masking for print | `vips_sharpen()`
`shrink` | Shrink an image | `vips_shrink()`
`shrinkh` | Shrink an image horizontally | `vips_shrinkh()`
`shrinkv` | Shrink an image vertically | `vips_shrinkv()`
`sign` | Unit vector of pixel | `vips_sign()`
`similarity` | Similarity transform of an image | `vips_similarity()`
`sines` | Make a 2d sine wave | `vips_sines()`
`smartcrop` | Extract an area from an image | `vips_smartcrop()`
`sobel` | Sobel edge detector | `vips_sobel()`
`spcor` | Spatial correlation | `vips_spcor()`
`spectrum` | Make displayable power spectrum | `vips_spectrum()`
`stats` | Find many image stats | `vips_stats()`
`stdif` | Statistical difference | `vips_stdif()`
`subsample` | Subsample an image | `vips_subsample()`
`subtract` | Subtract two images | `vips_subtract()`
`sum` | Sum an array of images | `vips_sum()`
`svgload` | Load svg with rsvg | `vips_svgload()`
`svgload_buffer` | Load svg with rsvg | `vips_svgload_buffer()`
`svgload_source` | Load svg from source | `vips_svgload_source()`
`switch` | Find the index of the first non-zero pixel in tests | `vips_switch()`
`system` | Run an external command | `vips_system()`
`text` | Make a text image | `vips_text()`
`thumbnail` | Generate thumbnail from file | `vips_thumbnail()`
`thumbnail_buffer` | Generate thumbnail from buffer | `vips_thumbnail_buffer()`
`thumbnail_image` | Generate thumbnail from image | `vips_thumbnail_image()`
`thumbnail_source` | Generate thumbnail from source | `vips_thumbnail_source()`
`tiffload` | Load tiff from file | `vips_tiffload()`
`tiffload_buffer` | Load tiff from buffer | `vips_tiffload_buffer()`
`tiffload_source` | Load tiff from source | `vips_tiffload_source()`
`tiffsave` | Save image to tiff file | `vips_tiffsave()`
`tiffsave_buffer` | Save image to tiff buffer | `vips_tiffsave_buffer()`
`tiffsave_target` | Save image to tiff target | `vips_tiffsave_target()`
`tilecache` | Cache an image as a set of tiles | `vips_tilecache()`
`tonelut` | Build a look-up table | `vips_tonelut()`
`transpose3d` | Transpose3d an image | `vips_transpose3d()`
`uhdr2scRGB` | Transform uhdr to scrgb | `vips_uhdr2scRGB()`
`uhdrload` | Load a uhdr image | `vips_uhdrload()`
`uhdrload_buffer` | Load a uhdr image | `vips_uhdrload_buffer()`
`uhdrload_source` | Load a uhdr image | `vips_uhdrload_source()`
`uhdrsave` | Save image in ultrahdr format | `vips_uhdrsave()`
`uhdrsave_buffer` | Save image in ultrahdr format | `vips_uhdrsave_buffer()`
`uhdrsave_target` | Save image in ultrahdr format | `vips_uhdrsave_target()`
`unpremultiply` | Unpremultiply image alpha | `vips_unpremultiply()`
`vipsload` | Load vips from file | `vips_vipsload()`
`vipsload_source` | Load vips from source | `vips_vipsload_source()`
`vipssave` | Save image to file in vips format | `vips_vipssave()`
`vipssave_target` | Save image to target in vips format | `vips_vipssave_target()`
`webpload` | Load webp from file | `vips_webpload()`
`webpload_buffer` | Load webp from buffer | `vips_webpload_buffer()`
`webpload_source` | Load webp from source | `vips_webpload_source()`
`webpsave` | Save as webp | `vips_webpsave()`
`webpsave_buffer` | Save as webp | `vips_webpsave_buffer()`
`webpsave_mime` | Save image to webp mime | `vips_webpsave_mime()`
`webpsave_target` | Save as webp | `vips_webpsave_target()`
`worley` | Make a worley noise image | `vips_worley()`
`wrap` | Wrap image origin | `vips_wrap()`
`xyz` | Make an image where pixel values are coordinates | `vips_xyz()`
`zone` | Make a zone plate | `vips_zone()`
`zoom` | Zoom an image | `vips_zoom()`