Man Linux: Main Page and Category List


       im_paintrect,  im_plotmask,  im_readpoint,  im_plotpoint,  im_fastline,
       im_fastlineuser - suck pels up, and paint them down somewhere else


       #include <vips/vips.h>

       int im_readpoint( im, x, y, ink )
       IMAGE *im;
       int x, y;
       PEL *ink;

       int im_plotpoint( im, x, y, ink )
       IMAGE *im;
       int x, y;
       PEL *ink;

       int im_plotmask( im, ix, iy, ink, mask, r )
       IMAGE *im;
       int ix, iy;
       PEL *ink;
       PEL *mask;
       Rect *r;

       int im_paintrect( im, r, ink )
       IMAGE *im;
       Rect *r;
       PEL *ink;

       int im_fastline( im, x1, y1, x2, y2, ink )
       IMAGE *im;
       int x1, y1, x2, y2;
       PEL *ink;

       int im_fastlineuser( im, x1, y1, x2, y2,
           plot_fn, client1, client2, client3 )
       IMAGE *im;
       int x1, y1, x2, y2;
       int (*plot_fn)();
       void *client1, *client2, *client3;

       int plot_fn( im, x, y, client1, client2, client3 )
       IMAGE *im;
       int x, y;
       void *client1, *client2, *client3;

       int im_lineset( IMAGE *in, IMAGE *out, IMAGE *mask, IMAGE *ink,
         int n, int *x1v, int *y1v, int *x2v, int *y2v )


       im_readpoint(3) sucks a pel from position  (x,y)  into  a  buffer;  all
       other  functions  paint  that  buffer back again in various ways. These
       functions will work for an image  of  any  type,  since  they  rely  on
       im_readpoint(3)  for  their  data. If you read a pel from one image and
       paint with it to another, it is your responsibility to check  that  the
       two images have identical pels.

       All these functions are ‘in place,’ that is, they write directly to the
       output image! Be very careful, you can destroy data.

       im_plotmask(3) takes an array of 0/255s and a Rect describing the  size
       and  offset of the array. It adds (ix,iy) to the array offset, and then
       paint pels into all array positions which are non-zero. Rect  need  not
       lie inside the image - the function clips carefully at the edges.

       im_paintrect(3) fills the rectangle described with ink. The Rect can be
       any size and at any position - the function clipps against the edges of
       the image.

       im_fastline(3)   is  a  replacement  for  im_line(3)  which  plots  the
       specified ink in the image. The start and end points must lie  entirely
       inside the image.

       im_fastlineuser(3)  does  not plot points, instead it calls a user plot
       function for every position along the line. There is no clipping -  the
       endpoints  may  be  anywhere  at  all.  Three client values are carried
       around and passed into the user function.

       im_lineset(3) copies the image and draws a set of lines  on  the  copy.
       The  lines  are  drawn using the mask image as a brush to apply the ink
       image. Useful for nip2.


       All functions return 0 on success and -1 on error.


       im_insertplace(3), im_smudge(3).


       National Gallery, 1992


       J. Cupitt

                                30 October 1992                      IM_AND(3)