static void
poke (GimpPixelRgn *dest_rgn,
gint x,
gint y,
GimpRGB *color)
{
static guchar data[4];
gimp_rgba_get_uchar (color, &data[0], &data[1], &data[2], &data[3]);
gimp_pixel_rgn_set_pixel (dest_rgn, data, x, y);
}
void
poke (gint x,
gint y,
GimpRGB *color,
gpointer data)
{
static guchar col[4];
gimp_rgba_get_uchar (color, &col[0], &col[1], &col[2], &col[3]);
gimp_pixel_rgn_set_pixel (&dest_region, col, x, y);
}
static void
exponentialrange (GimpDrawable *drawable)
{
gint i, j, k, channels;
gint x1, y1, x2, y2;
GimpPixelRgn rgn_in, rgn_out;
guchar output[4];
/* Gets upper left and lower right coordinates,
* and layers number in the image */
gimp_drawable_mask_bounds (drawable->drawable_id,
&x1, &y1,
&x2, &y2);
channels = gimp_drawable_bpp (drawable->drawable_id);
/* Initialises two PixelRgns, one to read original data,
* and the other to write output data. That second one will
* be merged at the end by the call to
* gimp_drawable_merge_shadow() */
gimp_pixel_rgn_init (&rgn_in,
drawable,
x1, y1,
x2 - x1, y2 - y1,
FALSE, FALSE);
gimp_pixel_rgn_init (&rgn_out,
drawable,
x1, y1,
x2 - x1, y2 - y1,
TRUE, TRUE);
/* find the range [minp,maxp] */
guchar minp[4],maxp[4];
/* initial values are high for minp, low for maxp*/
for (j = 0; j < 4; j++){
minp[j]=255; // default for guchar 0..255
maxp[j]=0;
}
/* get the right range */
for (i = x1; i < x2; i++){
for (j = y1; j < y2; j++){
guchar pixel[4];
gimp_pixel_rgn_get_pixel (&rgn_in, pixel, i, j);
for (k = 0; k < channels; k++){
if(minp[k]>pixel[k]) minp[k]=pixel[k];
if(maxp[k]<pixel[k]) maxp[k]=pixel[k];
}
}
}
for (i = x1; i < x2; i++)
{
for (j = y1; j < y2; j++)
{
guchar pixel[4];
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel, /*[4]*/
i, j);
/* For each layer, compute the exponential in the same range */
for (k = 0; k < channels; k++)
{
double ex = exp(pixel[k])- exp(minp[k]);
double ran=exp(maxp[k])-exp(minp[k]);
output[k] = (guchar)( minp[k] + (maxp[k]-minp[k]) * (ex/ran) );
}
gimp_pixel_rgn_set_pixel (&rgn_out,
output,
i, j);
} /*end for j*/
if (i % 10 == 0)
gimp_progress_update ((gdouble) (i - x1) / (gdouble) (x2 - x1));
} /*end for i*/
/* Update the modified region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
x1, y1,
x2 - x1, y2 - y1);
}
static void
exponential (GimpDrawable *drawable)
{
gint i, j, k, channels;
gint x1, y1, x2, y2;
GimpPixelRgn rgn_in, rgn_out;
guchar output[4];
/* Gets upper left and lower right coordinates,
* and layers number in the image */
gimp_drawable_mask_bounds (drawable->drawable_id,
&x1, &y1,
&x2, &y2);
channels = gimp_drawable_bpp (drawable->drawable_id);
/* Initialises two PixelRgns, one to read original data,
* and the other to write output data. That second one will
* be merged at the end by the call to
* gimp_drawable_merge_shadow() */
gimp_pixel_rgn_init (&rgn_in,
drawable,
x1, y1,
x2 - x1, y2 - y1,
FALSE, FALSE);
gimp_pixel_rgn_init (&rgn_out,
drawable,
x1, y1,
x2 - x1, y2 - y1,
TRUE, TRUE);
/*
guchar minp[4],maxp[4];
for (j = 0; j < 4; j++){
minp[j]=255;
maxp[j]=0;
}
for (i = x1; i < x2; i++){
for (j = y1; j < y2; j++){
guchar pixel[4];
gimp_pixel_rgn_get_pixel (&rgn_in, pixel, i, j);
for (k = 0; k < channels; k++){
if(minp[k]>pixel[k]) minp[k]=pixel[k];
if(maxp[k]<pixel[k]) maxp[k]=pixel[k];
}
} }
*/
for (i = x1; i < x2; i++)
{
for (j = y1; j < y2; j++)
{
/* guchar pixel[9][4]; */
guchar pixel[4];
/* Get ONE pixel */
/* gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[0],
MAX (i - 1, x1), MAX (j - 1, y1));
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[1],
MAX (i - 1, x1), j);
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[2],
MAX (i - 1, x1), MIN (j + 1, y2 - 1));
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[3],
i, MAX (j - 1, y1)); */
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel, /*[4]*/
i, j);
/* gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[5],
i, MIN (j + 1, y2 - 1));
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[6],
MIN (i + 1, x2 - 1), MAX (j - 1, y1));
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[7],
MIN (i + 1, x2 - 1), j);
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[8],
MIN (i + 1, x2 - 1), MIN (j + 1, y2 - 1));
*/
/* For each layer, compute the exponential color code
(255*(-1 +exp(code))/(-1 +exp(255)) ) */
for (k = 0; k < channels; k++)
{
double ex = exp(pixel[k])-1, max=exp(255)-1;
output[k] = (guchar)(255 *(ex/max));
}
gimp_pixel_rgn_set_pixel (&rgn_out,
output,
i, j);
} /*end for j*/
if (i % 10 == 0)
gimp_progress_update ((gdouble) (i - x1) / (gdouble) (x2 - x1));
} /*end for i*/
/* Update the modified region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
x1, y1,
x2 - x1, y2 - y1);
}
static void
symmetry (GimpDrawable *drawable)
{
gint i, j, k, channels;
gint x1, y1, x2, y2;
GimpPixelRgn rgn_in, rgn_out;
guchar output[4];
/* Gets upper left and lower right coordinates,
* and layers number in the image */
gimp_drawable_mask_bounds (drawable->drawable_id,
&x1, &y1,
&x2, &y2);
channels = gimp_drawable_bpp (drawable->drawable_id);
/* Initialises two PixelRgns, one to read original data,
* and the other to write output data. That second one will
* be merged at the end by the call to
* gimp_drawable_merge_shadow() */
gimp_pixel_rgn_init (&rgn_in,
drawable,
x1, y1,
x2 - x1, y2 - y1,
FALSE, FALSE);
gimp_pixel_rgn_init (&rgn_out,
drawable,
x1, y1,
x2 - x1, y2 - y1,
TRUE, TRUE);
for (i = x1; i < x2; i++)
{
for (j = y1; j < y2; j++)
{
guchar pixel[4];
/* Get ONE pixel */
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel,
i, j);
/* For each layer */
for (k = 0; k < channels; k++)
{
output[k] = 255 - pixel[k];
}
gimp_pixel_rgn_set_pixel (&rgn_out,
output,
i, j);
} /*end for j*/
if (i % 10 == 0)
gimp_progress_update ((gdouble) (i - x1) / (gdouble) (x2 - x1));
} /*end for i*/
/* Update the modified region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
x1, y1,
x2 - x1, y2 - y1);
}
static int
pr_ass_sub(PyGimpPixelRgn *self, PyObject *v, PyObject *w)
{
GimpPixelRgn *pr = &(self->pr);
PyObject *x, *y;
const guchar *buf;
Py_ssize_t len, x1, x2, xs, y1, y2, ys;
if (w == NULL) {
PyErr_SetString(PyExc_TypeError, "can't delete subscripts");
return -1;
}
if (!PyString_Check(w)) {
PyErr_SetString(PyExc_TypeError, "must assign string to subscript");
return -1;
}
if (!PyTuple_Check(v) || PyTuple_Size(v) != 2) {
PyErr_SetString(PyExc_TypeError, "subscript must be a 2-tuple");
return -1;
}
if (!PyArg_ParseTuple(v, "OO", &x, &y))
return -1;
buf = (const guchar *)PyString_AsString(w);
len = PyString_Size(w);
if (!buf || len > INT_MAX) {
return -1;
}
if (PyInt_Check(x)) {
x1 = PyInt_AsSsize_t(x);
if (x1 < pr->x || x1 >= pr->x + pr->w) {
PyErr_SetString(PyExc_IndexError, "x subscript out of range");
return -1;
}
if (PyInt_Check(y)) {
y1 = PyInt_AsSsize_t(y);
if (y1 < pr->y || y1 >= pr->y + pr->h) {
PyErr_SetString(PyExc_IndexError, "y subscript out of range");
return -1;
}
if (len != pr->bpp) {
PyErr_SetString(PyExc_TypeError, "string is wrong length");
return -1;
}
gimp_pixel_rgn_set_pixel(pr, buf, x1, y1);
} else if (PySlice_Check(y)) {
if (PySlice_GetIndices((PySliceObject *)y, pr->y + pr->h,
&y1, &y2, &ys) ||
y1 >= y2 || ys != 1) {
PyErr_SetString(PyExc_IndexError, "invalid y slice");
return -1;
}
if (y1 == 0)
y1 = pr->y;
if(y1 < pr->y || y2 < pr->y) {
PyErr_SetString(PyExc_IndexError, "y subscript out of range");
return -1;
}
if (len != pr->bpp * (y2 - y1)) {
PyErr_SetString(PyExc_TypeError, "string is wrong length");
return -1;
}
gimp_pixel_rgn_set_col(pr, buf, x1, y1, y2 - y1);
} else {
PyErr_SetString(PyExc_IndexError,"invalid y subscript");
return -1;
}
} else if (PySlice_Check(x)) {
if (PySlice_GetIndices((PySliceObject *)x, pr->x + pr->w,
&x1, &x2, &xs) ||
x1 >= x2 || xs != 1) {
PyErr_SetString(PyExc_IndexError, "invalid x slice");
return -1;
}
if(x1 == 0)
x1 = pr->x;
if(x1 < pr->x || x2 < pr->x) {
PyErr_SetString(PyExc_IndexError, "x subscript out of range");
return -1;
}
if (PyInt_Check(y)) {
y1 = PyInt_AsSsize_t(y);
if (y1 < pr->y || y1 >= pr->y + pr->h) {
PyErr_SetString(PyExc_IndexError, "y subscript out of range");
return -1;
}
if (len != pr->bpp * (x2 - x1)) {
PyErr_SetString(PyExc_TypeError, "string is wrong length");
return -1;
}
gimp_pixel_rgn_set_row(pr, buf, x1, y1, x2 - x1);
} else if (PySlice_Check(y)) {
if (PySlice_GetIndices((PySliceObject *)y, pr->y + pr->h,
&y1, &y2, &ys) ||
y1 >= y2 || ys != 1) {
PyErr_SetString(PyExc_IndexError, "invalid y slice");
return -1;
}
if (y1 == 0)
y1 = pr->y;
if(y1 < pr->y || y2 < pr->y) {
PyErr_SetString(PyExc_IndexError, "y subscript out of range");
return -1;
}
if (len != pr->bpp * (x2 - x1) * (y2 - y1)) {
PyErr_SetString(PyExc_TypeError, "string is wrong length");
return -1;
}
gimp_pixel_rgn_set_rect(pr, buf, x1, y1, x2 - x1, y2 - y1);
} else {
PyErr_SetString(PyExc_IndexError,"invalid y subscript");
return -1;
}
} else {
PyErr_SetString(PyExc_TypeError, "invalid x subscript");
return -1;
}
return 0;
}
static void
blur (GimpDrawable *drawable)
{
gint i, j, k, channels;
gint x1, y1, x2, y2;
GimpPixelRgn rgn_in, rgn_out;
guchar output[4];
/* Gets upper left and lower right coordinates,
* and layers number in the image */
gimp_drawable_mask_bounds (drawable->drawable_id,
&x1, &y1,
&x2, &y2);
channels = gimp_drawable_bpp (drawable->drawable_id);
/* Initialises two PixelRgns, one to read original data,
* and the other to write output data. That second one will
* be merged at the end by the call to
* gimp_drawable_merge_shadow() */
gimp_pixel_rgn_init (&rgn_in,
drawable,
x1, y1,
x2 - x1, y2 - y1,
FALSE, FALSE);
gimp_pixel_rgn_init (&rgn_out,
drawable,
x1, y1,
x2 - x1, y2 - y1,
TRUE, TRUE);
for (i = x1; i < x2; i++)
{
for (j = y1; j < y2; j++)
{
guchar pixel[9][4];
/* Get nine pixels */
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[0],
MAX (i - 1, x1), MAX (j - 1, y1));
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[1],
MAX (i - 1, x1), j);
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[2],
MAX (i - 1, x1), MIN (j + 1, y2 - 1));
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[3],
i, MAX (j - 1, y1));
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[4],
i, j);
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[5],
i, MIN (j + 1, y2 - 1));
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[6],
MIN (i + 1, x2 - 1), MAX (j - 1, y1));
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[7],
MIN (i + 1, x2 - 1), j);
gimp_pixel_rgn_get_pixel (&rgn_in,
pixel[8],
MIN (i + 1, x2 - 1), MIN (j + 1, y2 - 1));
/* For each layer, compute the average of the
* nine */
for (k = 0; k < channels; k++)
{
int tmp, sum = 0;
for (tmp = 0; tmp < 9; tmp++)
sum += pixel[tmp][k];
output[k] = sum / 9;
}
gimp_pixel_rgn_set_pixel (&rgn_out,
output,
i, j);
}
if (i % 10 == 0)
gimp_progress_update ((gdouble) (i - x1) / (gdouble) (x2 - x1));
}
/* Update the modified region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
x1, y1,
x2 - x1, y2 - y1);
}
