VIPS from C3VIPS LibraryUsing VIPSHow to use the VIPS library from CIntroduction
VIPS comes with a convenient, high-level C API. You should read the API
docs for full details, but this section will try to give a brief
overview.
Library startup
When your program starts, use VIPS_INIT()
to start up the VIPS library. You should pass it the name
of your program, usually argv[0]. Use
vips_shutdown() when you exit. VIPS_INIT() is a macro to let it check
that the libvips library you have linked to matches the libvips headers
you included.
You can add the VIPS flags to your %GObject command-line processing
with vips_add_option_entries().
The #VipsImage class
The basic data object is the #VipsImage. You can create an
image from a file on disc or from an area of memory, either
as a C-style array, or as a formatted object, like JPEG. See
vips_image_new_from_file() and friends. Loading an
image is fast: VIPS read just enough of the image to be able to get
the various properties, such as width, but no decoding occurs until
pixel values are really needed.
Once you have an image, you can get properties from it in the usual way.
You can use projection functions, like vips_image_get_width() or
g_object_get(), to get %GObject properties. All VIPS objects are
immutable, meaning you can only get properties, you can't set them.
See VIPS Header to read about
image properties.
Reference counting
VIPS is based on the %GObject library and is therefore reference counted.
vips_image_new_from_file() returns an object with a count of 1.
When you are done with an image, use g_object_unref() to dispose of it.
If you pass an image to an operation and that operation needs to keep a
copy of the image, it will ref it. So you can unref an image as soon as
you no longer need it, you don't need to hang on to it in case anyone
else is still using it.
See #VipsOperation for more detail on VIPS
reference counting conventions.
VIPS operations
Use things like vips_embed() to manipulate your images. You use it from
C like this:
const char *filename;
VipsImage *in = vips_image_new_from_file (filename, NULL);
const int x = 10;
const int y = 10;
const int width = 1000;
const int height = 1000;
VipsImage *out;
if (vips_embed (in, &out, x, y, width, height, NULL))
error_handling();
Now out will hold a reference to a 1000 by 1000 pixel
image, with in pasted 10 right and 10 down from the top
left-hand corner. The remainder of the image will be black. If
in is too large, it will be clipped at the image edges.
Operations can take optional arguments. You give these as a set of
NULL-terminated name-value pairs at the end of the call. For example,
you can write:
if (vips_embed (in, &out, x, y, width, height,
"extend", VIPS_EXTEND_COPY,
NULL))
error_handling();
And now the new edge pixels, which were black, will be filled with a copy
of the edge pixels of in. Operation options are listed
at the top of each operation's entry in the docs. Alternatively,
the vips program is handy for getting a
summary of an operation's parameters. For example:
$ vips embed
embed an image in a larger image
usage:
embed in out x y width height
where:
in - Input image, input VipsImage
out - Output image, output VipsImage
x - Left edge of input in output, input gint
default: 0
min: -1000000000, max: 1000000000
y - Top edge of input in output, input gint
default: 0
min: -1000000000, max: 1000000000
width - Image width in pixels, input gint
default: 1
min: 1, max: 1000000000
height - Image height in pixels, input gint
default: 1
min: 1, max: 1000000000
optional arguments:
extend - How to generate the extra pixels, input VipsExtend
default: black
allowed: black, copy, repeat, mirror, white, background
background - Colour for background pixels, input VipsArrayDouble
operation flags: sequential-unbuffered
See #VipsOperation for more information on running operations on images.
When you are done, you can write
the final image to a disc file, to a formatted memory buffer, or to
C-style memory array. See vips_image_write_to_file() and friends.
Getting pixels
Use #VipsRegion to read pixels out of images. You can use
VIPS_IMAGE_ADDR() as well, but this can need a large amount of
memory to work. See extending
for an introduction to writing your own operations.
Error handling
VIPS keeps a log of error message, see VIPS Error to find out how to get and
clear the error log.
ExampleVIPS from C example
/* compile with:
*
* gcc -g -Wall try211.c `pkg-config vips --cflags --libs`
*/
#include <stdio.h>
#include <vips/vips.h>
int
main( int argc, char **argv )
{
VipsImage *in;
double mean;
VipsImage *out;
if( VIPS_INIT( argv[0] ) )
vips_error_exit( NULL );
if( argc != 3 )
vips_error_exit( "usage: %s infile outfile", argv[0] );
if( !(in = vips_image_new_from_file( argv[1], NULL )) )
vips_error_exit( NULL );
printf( "image width = %d\n", vips_image_get_width( in ) );
if( vips_avg( in, &mean, NULL ) )
vips_error_exit( NULL );
printf( "mean pixel value = %g\n", mean );
if( vips_invert( in, &out, NULL ) )
vips_error_exit( NULL );
g_object_unref( in );
if( vips_image_write_to_file( out, argv[2], NULL ) )
vips_error_exit( NULL );
g_object_unref( out );
return( 0 );
}