gimp_pixel_rgn_init ()

void
gimp_pixel_rgn_init (GimpPixelRgn *pr,
                     GimpDrawable *drawable,
                     gint x,
                     gint y,
                     gint width,
                     gint height,
                     gint dirty,
                     gint shadow);

Initialize the pixel region pointed by pr with the specified parameters.

The dirty and shadow flags can be used as follows:

gimp_pixel_rgn_resize ()

void
gimp_pixel_rgn_resize (GimpPixelRgn *pr,
                       gint x,
                       gint y,
                       gint width,
                       gint height);

Change the position and size of a previously initialized pixel region.

gimp_pixel_rgn_get_pixel ()

void
gimp_pixel_rgn_get_pixel (GimpPixelRgn *pr,
                          guchar *buf,
                          gint x,
                          gint y);

Fill the buffer pointed by buf with the value of the pixel at (x , y ) in the region pr . buf should be large enough to hold the pixel value (1 guchar for an indexed or grayscale drawable, 2 guchar for indexed with alpha or grayscale with alpha drawable, 3 guchar for rgb drawable and 4 guchar for rgb with alpha drawable.

gimp_pixel_rgn_get_row ()

void
gimp_pixel_rgn_get_row (GimpPixelRgn *pr,
                        guchar *buf,
                        gint x,
                        gint y,
                        gint width);

Get several pixels of a region in a row. This function fills the buffer buf with the values of the pixels from (x , y ) to (x +width -1, y ). buf should be large enough to hold all these values.

gimp_pixel_rgn_get_col ()

void
gimp_pixel_rgn_get_col (GimpPixelRgn *pr,
                        guchar *buf,
                        gint x,
                        gint y,
                        gint height);

Get several pixels of a region's column. This function fills the buffer buf with the values of the pixels from (x , y ) to (x , y +height -1). buf should be large enough to hold all these values.

gimp_pixel_rgn_get_rect ()

void
gimp_pixel_rgn_get_rect (GimpPixelRgn *pr,
                         guchar *buf,
                         gint x,
                         gint y,
                         gint width,
                         gint height);

Get all the pixel values from the rectangle defined by x , y , width and height . This function fills the buffer buf with the values of the pixels from (x , y ) to (x +width -1, y +height -1). buf should be large enough to hold all these values (width *height *bpp).

gimp_pixel_rgn_set_pixel ()

void
gimp_pixel_rgn_set_pixel (GimpPixelRgn *pr,
                          const guchar *buf,
                          gint x,
                          gint y);

Set the pixel at (x , y ) to the values from buf .

gimp_pixel_rgn_set_row ()

void
gimp_pixel_rgn_set_row (GimpPixelRgn *pr,
                        const guchar *buf,
                        gint x,
                        gint y,
                        gint width);

Set several pixels of a region in a row. This function draws the pixels from (x , y ) to (x +width -1, y ) using the values of the buffer buf . buf should be large enough to hold all these values.

gimp_pixel_rgn_set_col ()

void
gimp_pixel_rgn_set_col (GimpPixelRgn *pr,
                        const guchar *buf,
                        gint x,
                        gint y,
                        gint height);

Set several pixels of a region's column. This function draws the pixels from (x , y ) to (x , y +height -1) using the values from the buffer buf . buf should be large enough to hold all these values.

gimp_pixel_rgn_set_rect ()

void
gimp_pixel_rgn_set_rect (GimpPixelRgn *pr,
                         const guchar *buf,
                         gint x,
                         gint y,
                         gint width,
                         gint height);

Set all the pixel of the rectangle defined by x , y , width and height . This function draws the rectangle from (x , y ) to (x +width -1, y +height -1), using the pixel values from the buffer buf . buf should be large enough to hold all these values (width *height *bpp).

gimp_pixel_rgns_register ()

gpointer
gimp_pixel_rgns_register (gint nrgns,
                          ...);

This is the varargs version of gimp_pixel_rgns_register2.

gimp_pixel_rgns_register2 ()

gpointer
gimp_pixel_rgns_register2 (gint nrgns,
                           GimpPixelRgn **prs);

It takes a number of initialized regions of the same size and provides a pixel region iterator the iterator can be used to iterate over the registered pixel regions. While iterating the registered pixel regions will cover subsets of the original pixel regions, chosen for optimized access to the image data.

Note that the given regions themselves are changed by this function, so they are resized to the first subsets.

This function has to be used together with gimp_pixel_rgns_process in a loop.

gimp_pixel_rgns_process ()

gpointer
gimp_pixel_rgns_process (gpointer pri_ptr);

This function update the regions registered previously with one of the gimp_pixel_rgns_register* functions to their next tile.

GimpPixelRgn

typedef struct {
  guchar       *data;          /* pointer to region data */
  GimpDrawable *drawable;      /* pointer to drawable */
  gint          bpp;           /* bytes per pixel */
  gint          rowstride;     /* bytes per pixel row */
  gint          x, y;          /* origin */
  gint          w, h;          /* width and height of region */
  guint         dirty : 1;     /* will this region be dirtied? */
  guint         shadow : 1;    /* will this region use the shadow or normal tiles */
  gint          process_count; /* used internally */
} GimpPixelRgn;