VipsStartFn ()

void *(*VipsStartFn) (VipsImage *out,void *a,void *b);

Start a new processing sequence for this generate function. This allocatesper-thread state, such as an input region.

See also:vips_start_one(),vips_start_many().

VipsGenerateFn ()

int(*VipsGenerateFn) (VipsRegion *out,void *seq,void *a,void *b,gboolean *stop);

Fillout->valid with pixels.seq contains per-thread state, such as theinput regions. Setstop toTRUE to stop processing.

See also:vips_image_generate(),vips_stop_many().

VipsStopFn ()

int(*VipsStopFn) (void *seq,void *a,void *b);

Stop a processing sequence. This freesper-thread state, such as an input region.

See also:vips_stop_one(),vips_stop_many().

VIPS_IMAGE_SIZEOF_ELEMENT()

#define             VIPS_IMAGE_SIZEOF_ELEMENT(I)

VIPS_IMAGE_SIZEOF_PEL()

#define             VIPS_IMAGE_SIZEOF_PEL(I)

VIPS_IMAGE_SIZEOF_LINE()

#define             VIPS_IMAGE_SIZEOF_LINE(I)

VIPS_IMAGE_N_ELEMENTS()

#define             VIPS_IMAGE_N_ELEMENTS(I)

VIPS_IMAGE_N_PELS()

#define             VIPS_IMAGE_N_PELS(I)

VIPS_IMAGE_ADDR()

#define             VIPS_IMAGE_ADDR(I, X, Y)

This macro returns a pointer to a pixel in an image, cast to aVipsPel *.It only works forimages which are fully available in memory, so memory buffers and smallmapped images only.

If VIPS_DEBUG is defined, you get a version that checks bounds for you.

See also:vips_image_wio_input(),vips_image_inplace(),VIPS_REGION_ADDR().

VIPS_MATRIX()

#define             VIPS_MATRIX(I, X, Y)

This macro returns a pointer to a pixel in an image, cast to a double*. Theimage must have a single band, beVIPS_FORMAT_DOUBLE and befully available in memory, so memory buffers and smallmapped images only.

If VIPS_DEBUG is defined, you get a version that checks bounds and imagetype for you.

See also:vips_image_wio_input(),vips_image_inplace(),vips_check_matrix().

vips_progress_set ()

voidvips_progress_set (gboolean progress);

If set, vips will print messages about the progress of computation tostdout. This can also be enabled with the --vips-progress option, or bysetting the environment variable VIPS_PROGRESS.

vips_image_invalidate_all ()

voidvips_image_invalidate_all (VipsImage *image);

Invalidate all pixel caches onimage and any downstream images, thatis, images which depend on this image. Additionally, all operations whichdepend upon this image are dropped from the VIPS operation cache.

You should call this function afterdestructively modifying an image with something likevips_draw_circle().

The“invalidate” signal is emitted for all invalidated images.

See also:vips_region_invalidate().

vips_image_minimise_all ()

voidvips_image_minimise_all (VipsImage *image);

Minimise memory use on this image and any upstream images, that is, imageswhich this image depends upon. This function is called automatically at theend of a computation, but it might be useful to call at other times.

The“minimise” signal is emitted for all minimised images.

vips_image_is_sequential ()

gbooleanvips_image_is_sequential (VipsImage *image);

TRUE if any of the images upstream fromimage were opened in sequentialmode. Some operations change behaviour slightly in sequential mode tooptimize memory behaviour.

vips_image_set_progress ()

voidvips_image_set_progress (VipsImage *image,gboolean progress);

vips signals evaluation progress via the“preeval”,“eval” and“posteval”signals. Progress is signalled on the most-downstream image for whichvips_image_set_progress() was called.

vips_image_iskilled ()

gbooleanvips_image_iskilled (VipsImage *image);

Ifimage has been killed (seevips_image_set_kill()), set an error message,clear theVipsImage.kill flag and returnTRUE. Otherwise returnFALSE.

Handy for loops which need to run sets of threads which can fail.

See also:vips_image_set_kill().

vips_image_set_kill ()

voidvips_image_set_kill (VipsImage *image,gboolean kill);

Set theVipsImage.kill flag on an image. Handy for stopping sets ofthreads.

See also:vips_image_iskilled().

vips_filename_get_filename ()

char *vips_filename_get_filename (constchar *vips_filename);

Given a vips filename like "fred.jpg[Q=90]", return a new string ofjust the filename part, "fred.jpg" in this case.

Useful for language bindings.

See also:vips_filename_get_options().

vips_filename_get_options ()

char *vips_filename_get_options (constchar *vips_filename);

Given a vips filename like "fred.jpg[Q=90]", return a new string ofjust the options part, "[Q=90]" in this case.

Useful for language bindings.

See also:vips_filename_get_filename().

vips_image_new ()

VipsImage *vips_image_new (void);

vips_image_new() creates a new, emptyVipsImage.If you write to one of these images, vips will just attach some callbacks,no pixels will be generated.

Write pixels to an image withvips_image_generate() orvips_image_write_line(). Write a whole image to another image withvips_image_write().

[constructor]

vips_image_new_memory ()

VipsImage *vips_image_new_memory (void);

vips_image_new_memory() creates a newVipsImage which, when written to, willcreate a memory image.

See also:vips_image_new().

[skip]

vips_image_memory ()

VipsImage *vips_image_memory (void);

A renamedvips_image_new_memory() ... Some gobject binding systems do notlike more than one_new() method.

See also:vips_image_new_memory().

[constructor]

vips_image_new_from_file ()

VipsImage *vips_image_new_from_file (constchar *name,...);

Optional arguments:

vips_image_new_from_file() opensname for reading. It can load filesin many image formats, including VIPS, TIFF, PNG, JPEG, FITS, Matlab,OpenEXR, CSV, WebP, Radiance, RAW, PPM and others.

Load options may be appended tofilename as "[name=value,...]" or given asa NULL-terminated list of name-value pairs at the end of the arguments.Options given in the function call override options given in the filename.Many loaders add extra options, seevips_jpegload(), for example.

vips_image_new_from_file() always returns immediately with the headerfields filled in. No pixels are actually read until you first access them.

access lets you set aVipsAccess hint giving the expected access patternfor this file.VIPS_ACCESS_RANDOM means you can fetch pixels randomly from the image.This is the default mode.VIPS_ACCESS_SEQUENTIAL means you will read thewhole image exactly once, top-to-bottom. In this mode, vips can avoidconverting the whole image in one go, for a large memory saving. You areallowed to make small non-local references, so area operations likeconvolution will work.

InVIPS_ACCESS_RANDOM mode, small images are decompressed to memory andthen processed from there. Large images are decompressed to temporaryrandom-access files on disc and then processed from there.

Setmemory toTRUE to force loading via memory. The default is to loadlarge random access images via temporary disc files. Seevips_image_new_temp_file() for anexplanation of how VIPS selects a location for the temporary file.

The disc threshold can be set with the "--vips-disc-threshold"command-line argument, or theVIPS_DISC_THRESHOLD environment variable.The value is a simple integer, but can take a unit postfix of "k","m" or "g" to indicate kilobytes, megabytes or gigabytes.The default threshold is 100 MB.

For example:

123

VipsImage*image=vips_image_new_from_file("fred.tif","page",12,NULL);

Will open "fred.tif", reading page 12.

12

VipsImage*image=vips_image_new_from_file("fred.jpg[shrink=2]",NULL);

Will open "fred.jpg", downsampling by a factor of two.

Usevips_foreign_find_load() orvips_foreign_is_a() to see what format afile is in and therefore what options are available. If you need morecontrol over the loading process, you can call loaders directly, seevips_jpegload(), for example.

See also:vips_foreign_find_load(),vips_foreign_is_a(),vips_image_write_to_file().

[constructor]

vips_image_new_from_file_RW ()

VipsImage *vips_image_new_from_file_RW (constchar *filename);

Opens the named file for simultaneous reading and writing. This will onlywork for VIPS files in a format native to your machine. It is only forpaintbox-type applications.

See also:vips_draw_circle().

[constructor]

vips_image_new_from_file_raw ()

VipsImage *vips_image_new_from_file_raw (constchar *filename,int xsize,int ysize,int bands,guint64 offset);

This function maps the named file and returns aVipsImage you can use toread it.

It returns an 8-bit image withbands bands. If the image is not 8-bit, usevips_copy() to transform the descriptor after loading it.

See also:vips_copy(),vips_rawload(),vips_image_new_from_file().

[constructor]

vips_image_new_from_memory ()

VipsImage *vips_image_new_from_memory (constvoid *data,size_t size,int width,int height,int bands,VipsBandFormat format);

This function wraps aVipsImage around a memory area. The memory areamust be a simple array, for example RGBRGBRGB, left-to-right,top-to-bottom. Usevips_image_new_from_buffer() to load an area of memorycontaining an image in a format.

VIPS does not takeresponsibility for the area of memory, it's up to you to make sure it'sfreed when the image is closed. See for example“close”.

Because VIPS is "borrowing"data from the caller, this function isextremely dangerous. Unless you are very careful, you will get crashes ormemory corruption. Usevips_image_new_from_memory_copy() instead if you areat all unsure.

Usevips_copy() to set other image properties.

See also:vips_image_new(),vips_image_write_to_memory(),vips_image_new_from_memory_copy().

[constructor]

vips_image_new_from_memory_copy ()

VipsImage *vips_image_new_from_memory_copy (constvoid *data,size_t size,int width,int height,int bands,VipsBandFormat format);

Likevips_image_new_from_memory(), but VIPS will make a copy of the memoryarea. This means more memory use and an extra copy operation, but is muchsimpler and safer.

See also:vips_image_new_from_memory().

[constructor]

vips_image_new_from_buffer ()

VipsImage *vips_image_new_from_buffer (constvoid *buf,size_t len,constchar *option_string,...);

Loads an image from the formatted area of memorybuf,len using theloader recommended byvips_foreign_find_load_buffer().To load an unformatted area of memory, usevips_image_new_from_memory().

VIPS does not takeresponsibility for the area of memory, it's up to you to make sure it'sfreed when the image is closed. See for example“close”.

Load options may be given inoption_string as "[name=value,...]" or given asa NULL-terminated list of name-value pairs at the end of the arguments.Options given in the function call override options given in the filename.

See also:vips_image_write_to_buffer().

[constructor]

vips_image_new_from_source ()

VipsImage *vips_image_new_from_source (VipsSource *source,constchar *option_string,...);

Loads an image from the formatted sourceinput,loader recommended byvips_foreign_find_load_source().

Load options may be given inoption_string as "[name=value,...]" or given asa NULL-terminated list of name-value pairs at the end of the arguments.Options given in the function call override options given in the string.

See also:vips_image_write_to_target().

[constructor]

vips_image_new_matrix ()

VipsImage *vips_image_new_matrix (int width,int height);

This convenience function makes an image which is a matrix: a one-bandVIPS_FORMAT_DOUBLE image held in memory.

UseVIPS_IMAGE_ADDR(), orVIPS_MATRIX() to address pixels in the image.

Usevips_image_set_double() to set "scale" and "offset", if required.

See also:vips_image_new_matrixv()

[constructor]

vips_image_new_matrixv ()

VipsImage *vips_image_new_matrixv (int width,int height,...);

Asvips_image_new_matrix(), but initialise the matrix from the argumentlist. Afterheight should bewidth *height double constants which areused to set the matrix elements.

See also:vips_image_new_matrix()

[constructor]

vips_image_new_matrix_from_array ()

VipsImage *vips_image_new_matrix_from_array (int width,int height,constdouble *array,int size);

A binding-friendly version ofvips_image_new_matrixv().

[constructor]

vips_image_matrix_from_array ()

VipsImage *vips_image_matrix_from_array (int width,int height,constdouble *array,int size);

A renamedvips_image_new_matrix_from_array(). Some gobject bindings do notlike more than one _new method.

[skip]

vips_image_new_from_image ()

VipsImage *vips_image_new_from_image (VipsImage *image,constdouble *c,int n);

Creates a new image with width, height, format, interpretation, resolutionand offset taken fromimage, but with number of bands taken fromn and thevalue of each band element set fromc.

See also:vips_image_new_from_image1()

[constructor]

vips_image_new_from_image1 ()

VipsImage *vips_image_new_from_image1 (VipsImage *image,double c);

Creates a new image with width, height, format, interpretation, resolutionand offset taken fromimage, but with one band and each pixel having thevaluec.

See also:vips_image_new_from_image()

[constructor]

vips_image_set_delete_on_close ()

voidvips_image_set_delete_on_close (VipsImage *image,gboolean delete_on_close);

Sets the delete_on_close flag for the image. If this flag is set, whenimage is finalized, the filename held inimage->filename at the time ofthis call is deleted.

This function is clearly extremely dangerous, use with great caution.

See also:vips_image_new_temp_file().

vips_get_disc_threshold ()

guint64vips_get_disc_threshold (void);

Return the number of bytes at which we flip between open via memory andopen via disc. This defaults to 100mb, but can be changed with theVIPS_DISC_THRESHOLD environment variable or the --vips-disc-thresholdcommand-line flag. Seevips_image_new_from_file().

vips_image_new_temp_file ()

VipsImage *vips_image_new_temp_file (constchar *format);

Make aVipsImage which, when written to, will create a temporary file ondisc. The file will be automatically deleted when the image is destroyed.format is something like "%s.v" for a vips file.

The file is created in the temporary directory. This is set with theenvironment variable TMPDIR. If this is not set, then on Unix systems, vipswill default to /tmp. On Windows, vips usesGetTempPath() to find thetemporary directory.

See also:vips_image_new().

[constructor]

vips_image_write ()

intvips_image_write (VipsImage *image,VipsImage *out);

Writeimage toout. Usevips_image_new() and friends to create theVipsImage you want to write to.

See also:vips_image_new(),vips_copy(),vips_image_write_to_file().

vips_image_write_to_file ()

intvips_image_write_to_file (VipsImage *image,constchar *name,...);

Writesin toname using the saver recommended byvips_foreign_find_save().

Save options may be appended tofilename as "[name=value,...]" or given asa NULL-terminated list of name-value pairs at the end of the arguments.Options given in the function call override options given in the filename.

See also:vips_image_new_from_file().

vips_image_write_to_buffer ()

intvips_image_write_to_buffer (VipsImage *in,constchar *suffix,void **buf,size_t *size,...);

Writesin to a memory buffer in a format specified bysuffix.

Save options may be appended tosuffix as "[name=value,...]" or given asa NULL-terminated list of name-value pairs at the end of the arguments.Options given in the function call override options given in the filename.

Currently only TIFF, JPEG and PNG formats are supported.

You can call the various save operations directly if you wish, seevips_jpegsave_buffer(), for example.

See also:vips_image_write_to_memory(),vips_image_new_from_buffer().

vips_image_write_to_target ()

intvips_image_write_to_target (VipsImage *in,constchar *suffix,VipsTarget *target,...);

Writesin tooutput in formatsuffix.

Save options may be appended tosuffix as "[name=value,...]" or given asa NULL-terminated list of name-value pairs at the end of the arguments.Options given in the function call override options given in the filename.

You can call the various save operations directly if you wish, seevips_jpegsave_target(), for example.

See also:vips_image_write_to_file().

vips_image_write_to_memory ()

void *vips_image_write_to_memory (VipsImage *in,size_t *size);

Writesin to memory as a simple, unformatted C-style array.

The caller is responsible for freeing this memory withg_free().

See also:vips_image_write_to_buffer().

vips_image_decode_predict ()

intvips_image_decode_predict (VipsImage *in,int *bands,VipsBandFormat *format);

We often need to know what an image will decode to without actuallydecoding it, for example, in arg checking.

See also:vips_image_decode().

vips_image_decode ()

intvips_image_decode (VipsImage *in,VipsImage **out);

A convenience function to unpack to a format that we can compute with.out.coding is alwaysVIPS_CODING_NONE.

This unpacks LABQ to plain LAB. Usevips_LabQ2LabS() for a bit more speedif you need it.

See also:vips_image_encode(),vips_LabQ2Lab(),vips_rad2float().

vips_image_encode ()

intvips_image_encode (VipsImage *in,VipsImage **out,VipsCoding coding);

A convenience function to pack to a coding. The inverse ofvips_image_decode().

See also:vips_image_decode().

vips_image_isMSBfirst ()

gbooleanvips_image_isMSBfirst (VipsImage *image);

ReturnTRUE ifimage is in most-significant-byte first form. This is the byte order used on the SPARCarchitecture and others.

vips_image_isfile ()

gbooleanvips_image_isfile (VipsImage *image);

ReturnTRUE ifimage represents a file on disc in some way.

vips_image_ispartial ()

gbooleanvips_image_ispartial (VipsImage *image);

ReturnTRUE ifim represents a partial image (a delayed calculation).

vips_image_hasalpha ()

gbooleanvips_image_hasalpha (VipsImage *image);

Look at an image's interpretation and see if it has extra alpha bands. Forexample, a 4-bandVIPS_INTERPRETATION_sRGB would, but a six-bandVIPS_INTERPRETATION_MULTIBAND would not.

ReturnTRUE ifimage has an alpha channel.

vips_image_copy_memory ()

VipsImage *vips_image_copy_memory (VipsImage *image);

This function allocates memory, rendersimage into it, builds a newimage around the memory area, and returns that.

If the image is already a simple area of memory, it just refsimage andreturns it.

Call this before using the draw operations to make sure you have amemory image that can be modified.

vips_copy() adds a null "copy" node to a pipeline. Use thatinstead if you want to change metadata and not pixels.

This operation is thread-safe, unlikevips_image_wio_input().

If you are sure thatimage is not shared with another thread (perhaps youhave made it yourself), usevips_image_wio_input() instead.

See also:vips_image_wio_input().

vips_image_wio_input ()

intvips_image_wio_input (VipsImage *image);

Check that an image is readable via theVIPS_IMAGE_ADDR() macro, that is,that the entire image is in memory and all pixels can be read withVIPS_IMAGE_ADDR(). If itisn't, try to transform it so thatVIPS_IMAGE_ADDR() can work.

Since this function modifiesimage, it is not thread-safe. Only call it onimages which you are sure have not been shared with another thread. If theimage might have been shared, use the less efficientvips_image_copy_memory() instead.

See also:vips_image_copy_memory(),vips_image_pio_input(),vips_image_inplace(),VIPS_IMAGE_ADDR().

vips_image_pio_input ()

intvips_image_pio_input (VipsImage *image);

Check that an image is readable withvips_region_prepare() and friends.If it isn't, try to transform the image so thatvips_region_prepare() canwork.

See also:vips_image_pio_output(),vips_region_prepare().

vips_image_pio_output ()

intvips_image_pio_output (VipsImage *image);

Check that an image is writeable withvips_image_generate(). If it isn't,try to transform the image so thatvips_image_generate() can work.

See also:vips_image_pio_input().

vips_image_inplace ()

intvips_image_inplace (VipsImage *image);

Getsimage ready for an in-place operation, such asvips_draw_circle().After calling this function you can both read and write the image withVIPS_IMAGE_ADDR().

This method is called for you by the base class of the draw operations,there's no need to call it yourself.

Since this function modifiesimage, it is not thread-safe. Only call it onimages which you are sure have not been shared with another thread.All in-place operations are inherently not thread-safe, so you need to takegreat care in any case.

See also:vips_draw_circle(),vips_image_wio_input().

vips_image_write_prepare ()

intvips_image_write_prepare (VipsImage *image);

Call this after setting header fields (width, height, and so on) toallocate resources ready for writing.

Normally this function is called for you byvips_image_generate() orvips_image_write_line(). You will need to call it yourself if you plan towrite directly to the ->data member of a memory image.

vips_image_write_line ()

intvips_image_write_line (VipsImage *image,int ypos,VipsPel *linebuffer);

Write a line of pixels to an image. This function must be called repeatedlywithypos increasing from 0 to“height” .linebuffer must beVIPS_IMAGE_SIZEOF_LINE() bytes long.

See also:vips_image_generate().

vips_band_format_isint ()

gbooleanvips_band_format_isint (VipsBandFormat format);

ReturnTRUE ifformat is one of the integer types.

vips_band_format_isuint ()

gbooleanvips_band_format_isuint (VipsBandFormat format);

ReturnTRUE ifformat is one of the unsigned integer types.

vips_band_format_is8bit ()

gbooleanvips_band_format_is8bit (VipsBandFormat format);

ReturnTRUE ifformat is uchar or schar.

vips_band_format_isfloat ()

gbooleanvips_band_format_isfloat (VipsBandFormat format);

ReturnTRUE ifformat is one of the float types.

vips_band_format_iscomplex ()

gbooleanvips_band_format_iscomplex (VipsBandFormat format);

ReturnTRUE iffmt is one of the complex types.

vips_system ()

intvips_system (constchar *cmd_format,...);

Optional arguments:

vips_system() runs a command, optionally passing a set of images in andoptionally getting an image back. The command's stdout is returned inlog.

First, ifin is set, the array of images are written to files. Seevips_image_new_temp_file() to see how temporary files are created.Ifin_format issomething like %s.png, the file will be written in PNG format. Bydefault,in_format is %s.tif.

Ifout_format is set, an output filename is formed in the same way. Anytrailing [options] are stripped fromout_format.

The command string to run is made by substituting the first set of %sincmd_format for the names of the input files, ifin is set, and thenthe next %s for the output filename, ifout_format is set.You can put a number between the % and the s to change the orderin which the substitution occurs.

The command is executed withpopen() and the output captured inlog.

After the command finishes, ifout_format is set, the output image isopened and returned inout. You can append [options] toout_format tocontrol how this open happens.Closingout image will automatically delete the output file.

Finally the input images are deleted.

For example, this call will run the ImageMagick convert program on animage, using JPEG files to pass images into and out of the convert command.

123456789101112

VipsArrayImage*in;VipsImage*out;char*log;if(vips_system("convert %s -swirl 45 %s","in",in,"out",&out,"in_format","%s.jpg","out_format","%s.jpg","log",&log,NULL))error...

vips_array_image_new ()

VipsArrayImage *vips_array_image_new (VipsImage **array,int n);

Allocate a new array of images and copyarray into it. Free withvips_area_unref().

The images will all be reffed by this function. Theywill be automatically unreffed for you byvips_area_unref().

Add an extra NULL element at the end, handy for eg.vips_image_pipeline_array() etc.

See also:VipsArea.

[constructor]

vips_array_image_newv ()

VipsArrayImage *vips_array_image_newv (int n,...);

Allocate a new array ofnVipsImage and copy @... into it. Free withvips_area_unref().

The images will all be reffed by this function. Theywill be automatically unreffed for you byvips_area_unref().

Add an extra NULL element at the end, handy for eg.vips_image_pipeline_array() etc.

See also:vips_array_image_new()

[constructor]

vips_array_image_new_from_string ()

VipsArrayImage *vips_array_image_new_from_string (constchar *string,VipsAccess flags);

vips_array_image_empty ()

VipsArrayImage *vips_array_image_empty (void);

Make an empty image array.Handy withvips_array_image_add() for bindingswhich can't handle object array arguments.

See also:vips_array_image_add().

[constructor]

vips_array_image_append ()

VipsArrayImage *vips_array_image_append (VipsArrayImage *array,VipsImage *image);

Make a newVipsArrayImage, one larger thanarray, withimage appendedto the end.Handy withvips_array_image_empty() for bindingswhich can't handle object array arguments.

See also:vips_array_image_empty().

vips_array_image_get ()

VipsImage **vips_array_image_get (VipsArrayImage *array,int *n);

Fetch an image array from aVipsArrayImage. Useful for language bindings.

vips_value_get_array_image ()

VipsImage **vips_value_get_array_image (constGValue *value,int *n);

Return the start of the array of images held byvalue.optionally return the number of elements inn.

See also:vips_value_set_array_image().

vips_value_set_array_image ()

voidvips_value_set_array_image (GValue *value,int n);

Setvalue to hold an array of images. Pass in the array length inn.

See also:vips_array_image_get().

vips_reorder_prepare_many ()

intvips_reorder_prepare_many (VipsImage *image,VipsRegion **regions,VipsRect *r);

vips_reorder_prepare_many() runsvips_region_prepare() on each region inregions, requesting the pixels inr.

It tries to request the regions in the order which will cause leastrecomputation. This can give a large speedup, in some cases.

See also:vips_region_prepare(),vips_reorder_margin_hint().

[method]

vips_reorder_margin_hint ()

voidvips_reorder_margin_hint (VipsImage *image,int margin);

vips_reorder_margin_hint() sets a hint thatimage contains a margin, thatis, that eachvips_region_prepare() onimage will request a slightly largerregion from it's inputs. A good value formargin is (width * height) forthe window the operation uses.

This information is used byvips_image_prepare_many() to attempt to reordercomputations to minimise recomputation.

See also:vips_image_prepare_many().

[method]

vips_image_free_buffer ()

voidvips_image_free_buffer (VipsImage *image,void *buffer);

Free the externally allocated buffer found in the input image. This functionis intended to be used with g_signal_connect.

VIPS_MAGIC_INTEL

#define VIPS_MAGIC_INTEL (0xb6a6f208U)

The first four bytes of a VIPS file in Intel byte ordering.

VIPS_MAGIC_SPARC

#define VIPS_MAGIC_SPARC (0x08f2a6b6U)

The first four bytes of a VIPS file in SPARC byte ordering.

VIPS_DEFAULT_MAX_COORD

#define VIPS_DEFAULT_MAX_COORD (100000000)

VIPS_MAX_COORD

#define VIPS_MAX_COORD (vips_max_coord_get())

enum VipsDemandStyle

Seevips_image_pipelinev(). Operations can hintthe kind of demand geometry they preferto the VIPS image IO system.

These demand styles are given below in order of increasingspecialisation. When demanding output from a pipeline,vips_image_generate()will use the most general style requested by the operationsin the pipeline.

VIPS_DEMAND_STYLE_SMALLTILE --- This is the most general demand format.Output is demanded in small (around 100x100 pel) sections. This style worksreasonably efficiently, even for bizarre operations like 45 degree rotate.

VIPS_DEMAND_STYLE_FATSTRIP --- This operation would like to output stripsthe width of the image and as high as possible. This option is suitablefor area operations which do not violently transform coordinates, suchasvips_conv().

VIPS_DEMAND_STYLE_THINSTRIP --- This operation would like to output stripsthe width of the image and a few pels high. This option is suitable forpoint-to-point operations, such as those in the arithmetic package.

VIPS_DEMAND_STYLE_ANY --- This image is not being demand-read from a discfile (even indirectly) so any demand style is OK. It's used for things likevips_black() where the pixels are calculated.

See also:vips_image_pipelinev().

enum VipsImageType

enum VipsInterpretation

How the values in an image should be interpreted. For example, athree-band float image of typeVIPS_INTERPRETATION_LAB should have itspixels interpreted as coordinates in CIE Lab space.

RGB and sRGB are treated in the same way. Use the colourspace functions ifyou want some other behaviour.

The gaps in numbering are historical and must be maintained. Allocatenew numbers from the end.

enum VipsBandFormat

The format used for each band element.

Each corresponds to a native C type for the current machine. For example,VIPS_FORMAT_USHORT isunsigned short.

enum VipsCoding

How pixels are coded.

Normally, pixels are uncoded and can be manipulated as you would expect.However some file formats code pixels for compression, and sometimes it'suseful to be able to manipulate images in the coded format.

The gaps in the numbering are historical and must be maintained. Allocatenew numbers from the end.

enum VipsAccess

The type of access an operation has to supply. Seevips_tilecache()andVipsForeign.

VIPS_ACCESS_RANDOM means requests can come in any order.

VIPS_ACCESS_SEQUENTIAL means requests will be top-to-bottom, but with someamount of buffering behind the read point for small non-local accesses.

VipsProgress

typedef struct {int run;   /* Time we have been running */int eta;   /* Estimated seconds of computation left */gint64 tpels;  /* Number of pels we expect to calculate */gint64 npels;  /* Number of pels calculated so far */int percent;   /* Percent complete */GTimer *start; /* Start time */} VipsProgress;

A structure available to eval callbacks giving information on evaluationprogress. See“eval”.

The“bands” property

  “bands”int

Number of bands in image.

Owner: VipsImage

Flags: Read / Write

Allowed values: [1,100000000]

Default value: 1

The“coding” property

  “coding”VipsCoding

Pixel coding.

Owner: VipsImage

Flags: Read / Write

Default value: VIPS_CODING_NONE

The“demand” property

  “demand”VipsDemandStyle

Preferred demand style for this image.

Owner: VipsImage

Flags: Read / Write

Default value: VIPS_DEMAND_STYLE_SMALLTILE

The“filename” property

  “filename”char *

Image filename.

Owner: VipsImage

Flags: Read / Write

Default value: NULL

The“foreign-buffer” property

  “foreign-buffer”gpointer

Pointer to foreign pixels.

Owner: VipsImage

Flags: Read / Write

The“format” property

  “format”VipsBandFormat

Pixel format in image.

Owner: VipsImage

Flags: Read / Write

Default value: VIPS_FORMAT_UCHAR

The“height” property

  “height”int

Image height in pixels.

Owner: VipsImage

Flags: Read / Write

Allowed values: [1,100000000]

Default value: 1

The“interpretation” property

  “interpretation”VipsInterpretation

Pixel interpretation.

Owner: VipsImage

Flags: Read / Write

Default value: VIPS_INTERPRETATION_MULTIBAND

The“kill” property

  “kill”gboolean

Block evaluation on this image.

Owner: VipsImage

Flags: Read / Write

Default value: FALSE

The“mode” property

  “mode”char *

Open mode.

Owner: VipsImage

Flags: Read / Write

Default value: "p"

The“sizeof-header” property

  “sizeof-header”guint64

Offset in bytes from start of file.

Owner: VipsImage

Flags: Read / Write

Allowed values: <= 1000000000

Default value: 64

The“width” property

  “width”int

Image width in pixels.

Owner: VipsImage

Flags: Read / Write

Allowed values: [1,100000000]

Default value: 1

The“xoffset” property

  “xoffset”int

Horizontal offset of origin.

Owner: VipsImage

Flags: Read / Write

Allowed values: [-100000000,100000000]

Default value: 0

The“xres” property

  “xres”double

Horizontal resolution in pixels/mm.

Owner: VipsImage

Flags: Read / Write

Allowed values: [-0,1e+06]

Default value: 0

The“yoffset” property

  “yoffset”int

Vertical offset of origin.

Owner: VipsImage

Flags: Read / Write

Allowed values: [-100000000,100000000]

Default value: 0

The“yres” property

  “yres”double

Vertical resolution in pixels/mm.

Owner: VipsImage

Flags: Read / Write

Allowed values: [-0,1e+06]

Default value: 0

The“eval” signal

voiduser_function (VipsImage *image,gpointer   progress,gpointer   user_data)

The ::eval signal is emitted once per work unit (typically a 128 x128 area of pixels) during image computation.

You can use this signal to update user-interfaces with progressfeedback. Beware of updating too frequently: you will usuallyneed some throttling mechanism.

Usevips_image_set_progress() to turn on progress reporting for animage.

Flags: Run Last

The“invalidate” signal

voiduser_function (VipsImage *image,gpointer   user_data)

The ::invalidate signal is emitted when an image or one of it'supstream data sources has been destructively modified. Seevips_image_invalidate_all().

Flags: Action

The“minimise” signal

voiduser_function (VipsImage *image,gpointer   user_data)

The ::minimise signal is emitted when an image has been asked tominimise memory usage. All non-essential caches are dropped.Seevips_image_minimise_all().

Flags: Action

The“posteval” signal

voiduser_function (VipsImage *image,gpointer   progress,gpointer   user_data)

The ::posteval signal is emitted once at the end of the computationofimage. It's a good place to shut down evaluation feedback.

Usevips_image_set_progress() to turn on progress reporting for animage.

Flags: Run Last

The“preeval” signal

voiduser_function (VipsImage *image,gpointer   progress,gpointer   user_data)

The ::preeval signal is emitted once before computation ofimagestarts. It's a good place to set up evaluation feedback.

Usevips_image_set_progress() to turn on progress reporting for animage.

Flags: Run Last

The“written” signal

voiduser_function (VipsImage *image,gpointer   result,gpointer   user_data)

The ::written signal is emitted just after an image has beenwritten to. It isused by vips to implement things like write to foreign fileformats.

Flags: Action