GimpRGB
peek (gint x,
gint y)
{
static guchar data[4];
GimpRGB color;
gimp_pixel_rgn_get_pixel (&source_region, data, x, y);
color.r = (gdouble) (data[0]) / 255.0;
color.g = (gdouble) (data[1]) / 255.0;
color.b = (gdouble) (data[2]) / 255.0;
if (input_drawable->bpp == 4)
{
if (in_channels == 4)
color.a = (gdouble) (data[3]) / 255.0;
else
color.a = 1.0;
}
else
{
color.a = 1.0;
}
return color;
}
static GimpRGB
peek_box_image (gint image,
gint x,
gint y)
{
static guchar data[4];
GimpRGB color;
gimp_pixel_rgn_get_pixel (&box_regions[image], data, x, y);
color.r = (gdouble) (data[0]) / 255.0;
color.g = (gdouble) (data[1]) / 255.0;
color.b = (gdouble) (data[2]) / 255.0;
if (box_drawables[image]->bpp == 4)
{
if (gimp_drawable_has_alpha (box_drawables[image]->drawable_id))
color.a = (gdouble) (data[3]) / 255.0;
else
color.a = 1.0;
}
else
{
color.a = 1.0;
}
return color;
}
static guchar*
rgb_to_hsl (GimpDrawable *drawable,
LICEffectChannel effect_channel)
{
guchar *themap, data[4];
gint x, y;
GimpRGB color;
GimpHSL color_hsl;
gdouble val = 0.0;
glong maxc, index = 0;
GimpPixelRgn region;
GRand *gr;
gr = g_rand_new ();
maxc = drawable->width * drawable->height;
gimp_pixel_rgn_init (®ion, drawable, border_x, border_y,
border_w, border_h, FALSE, FALSE);
themap = g_new (guchar, maxc);
for (y = 0; y < region.h; y++)
{
for (x = 0; x < region.w; x++)
{
data[3] = 255;
gimp_pixel_rgn_get_pixel (®ion, data, x, y);
gimp_rgba_set_uchar (&color, data[0], data[1], data[2], data[3]);
gimp_rgb_to_hsl (&color, &color_hsl);
switch (effect_channel)
{
case LIC_HUE:
val = color_hsl.h * 255;
break;
case LIC_SATURATION:
val = color_hsl.s * 255;
break;
case LIC_BRIGHTNESS:
val = color_hsl.l * 255;
break;
}
/* add some random to avoid unstructured areas. */
val += g_rand_double_range (gr, -1.0, 1.0);
themap[index++] = (guchar) CLAMP0255 (RINT (val));
}
}
g_rand_free (gr);
return themap;
}
static void
peek (GimpPixelRgn *src_rgn,
gint x,
gint y,
GimpRGB *color)
{
static guchar data[4] = { 0, };
gimp_pixel_rgn_get_pixel (src_rgn, data, x, y);
gimp_rgba_set_uchar (color, data[0], data[1], data[2], data[3]);
}
guchar
sel_pixel_value (gint row,
gint col)
{
guchar ret;
if (col > sel_width || row > sel_height)
{
g_warning ("sel_pixel_value [%d,%d] out of bounds", col, row);
return 0;
}
gimp_pixel_rgn_get_pixel(&selection_rgn,&ret,col+sel_x1,row+sel_y1);
return ret;
}
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);
}
void * jpeg_highlighter_analyze(JOB_ARG *job)
{
int ii, jj, kk;
int row;
int col;
long long red_sum = 0;
long long green_sum = 0;
long long blue_sum = 0;
guchar max_pixel_color[4];
union
{
guchar pixel[4];
unsigned int value;
} stuff;
gint32 layer_id;
int temp = 0;
int unique_compressed_colors = 0;
int unique_original_colors = 0;
int *histogram;
max_pixel_color[0] = 0;
max_pixel_color[1] = 0;
max_pixel_color[2] = 0;
max_pixel_color[3] = 0;
histogram = (int*)malloc(sizeof(int)*255*255*255);
//
// GimpRunMode mode = GIMP_RUN_NONINTERACTIVE;
// PIXEL **temp_array;
GimpPixelRgn rgn_in;
printf("in analizer\n");
job->drawable->drawable_id = gimp_image_get_active_drawable(job->image_id);
layer_id = gimp_image_get_active_layer(job->image_id);
// printf("adding alpha channel\n");
// gimp_layer_add_alpha(layer_id);
//
//
//// if(! gimp_drawable_has_alpha (layer_id))
//// {
//// /* some filtermacros do not work with layer that do not have an alpha channel
//// * and cause gimp to fail on attempt to call gimp_pixel_rgn_init
//// * with both dirty and shadow flag set to TRUE
//// * in this situation GIMP displays the error message
//// * "expected tile ack and received: 5"
//// * and causes the called plug-in to exit immediate without success
//// * Therfore always add an alpha channel before calling a filtermacro.
//// */
//// gimp_layer_add_alpha(layer_id);
//// printf("adding alpha channel\n");
//// }
printf("zeroed array\n");
for(ii = 0; ii < 255*255*255; ii++)
{
histogram[ii] = 0;
}
gimp_pixel_rgn_init(&rgn_in, job->drawable, job->start_colum, job->start_row, job->image.width, job->image.height, FALSE, FALSE);
for (row = 0; row < job->image.height; row++)
{
for (col = 0; col < job->image.width; col++)
{
gimp_pixel_rgn_get_pixel (&rgn_in, stuff.pixel, col,row);
job->array_out[col][row].red = stuff.pixel[0];
job->array_out[col][row].green = stuff.pixel[1];
job->array_out[col][row].blue = stuff.pixel[2];
red_sum += stuff.pixel[0];
green_sum += stuff.pixel[1];
blue_sum += stuff.pixel[2];
stuff.pixel[3] = 0;
if(stuff.pixel[0] + stuff.pixel[1]+ stuff.pixel[2] > max_pixel_color[0] + max_pixel_color[1] + max_pixel_color[2] )
{
max_pixel_color[0] = stuff.pixel[0];
max_pixel_color[1] = stuff.pixel[1];
max_pixel_color[2] = stuff.pixel[2];
}
histogram[stuff.value]++;
}
if (row % 50 == 0)
{
gimp_progress_update ((gdouble) row / job->image.height);
}
}
for(ii = 0; ii < 255*255*255; ii++)
{
if(histogram[ii] != 0)
{
unique_compressed_colors++;
}
}
//doing the original
printf("zeroed array\n");
for(ii = 0; ii < 255*255*255; ii++)
{
histogram[ii] = 0;
}
for (row = 0; row < job->image.height; row++)
{
for (col = 0; col < job->image.width; col++)
{
stuff.pixel[0] = job->array_in[col][row].red;
stuff.pixel[1] = job->array_in[col][row].green;
stuff.pixel[2] = job->array_in[col][row].blue;
stuff.pixel[3] = 0;
histogram[stuff.value]++;
}
}
for(ii = 0; ii < 255*255*255; ii++)
{
if(histogram[ii] != 0)
{
unique_original_colors++;
}
}
free(histogram);
print_log("\nJpeg compression difference\n",temp);
print_log("unique colors in original image:%d\n",unique_original_colors);
print_log("unique colors in compressed image:%d\n",unique_compressed_colors);
print_log("ratio: %f\n",(double)unique_original_colors/unique_compressed_colors);
print_log("brightest compressed color %d %d %d\n",max_pixel_color[0], max_pixel_color[1], max_pixel_color[2]);
print_log("avg compressed color %f %f %f\n",(float)red_sum/(job->image.height*job->image.width), (float)green_sum/(job->image.height*job->image.width),(float)blue_sum/(job->image.height*job->image.width));
}
static PyObject *
pr_subscript(PyGimpPixelRgn *self, PyObject *key)
{
GimpPixelRgn *pr = &(self->pr);
PyObject *x, *y;
Py_ssize_t x1, y1, x2, y2, xs, ys;
PyObject *ret;
if (!PyTuple_Check(key) || PyTuple_Size(key) != 2) {
PyErr_SetString(PyExc_TypeError, "subscript must be a 2-tuple");
return NULL;
}
if (!PyArg_ParseTuple(key, "OO", &x, &y))
return NULL;
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 NULL;
}
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 NULL;
}
ret = PyString_FromStringAndSize(NULL, pr->bpp);
gimp_pixel_rgn_get_pixel(pr, (guchar*)PyString_AS_STRING(ret),
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 NULL;
}
if(y1 == 0)
y1 = pr->y;
if(y1 < pr->y || y2 < pr->y) {
PyErr_SetString(PyExc_IndexError, "y subscript out of range");
return NULL;
}
ret = PyString_FromStringAndSize(NULL, pr->bpp * (y2 - y1));
gimp_pixel_rgn_get_col(pr, (guchar*)PyString_AS_STRING(ret),
x1, y1, y2-y1);
}
else {
PyErr_SetString(PyExc_TypeError, "invalid y subscript");
return NULL;
}
} 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 NULL;
}
if (x1 == 0)
x1 = pr->x;
if(x1 < pr->x || x2 < pr->x) {
PyErr_SetString(PyExc_IndexError, "x subscript out of range");
return NULL;
}
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 NULL;
}
ret = PyString_FromStringAndSize(NULL, pr->bpp * (x2 - x1));
gimp_pixel_rgn_get_row(pr, (guchar*)PyString_AS_STRING(ret),
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 NULL;
}
if(y1 == 0)
y1 = pr->y;
if(y1 < pr->y || y2 < pr->y) {
PyErr_SetString(PyExc_IndexError, "y subscript out of range");
return NULL;
}
ret = PyString_FromStringAndSize(NULL,
pr->bpp * (x2 - x1) * (y2 - y1));
gimp_pixel_rgn_get_rect(pr, (guchar*)PyString_AS_STRING(ret),
x1, y1, x2 - x1, y2 - y1);
}
else {
PyErr_SetString(PyExc_TypeError, "invalid y subscript");
return NULL;
}
} else {
PyErr_SetString(PyExc_TypeError, "invalid x subscript");
return NULL;
}
return ret;
}
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);
}
