static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglBufferIterator *iter;
GeglBuffer *dest1;
GeglBuffer *dest2;
gdouble diff;
gdouble ramp_down;
gdouble ramp_up;
gdouble mult;
grey_blur_buffer (input, o->sharpness, o->mask_radius, &dest1, &dest2);
compute_ramp (dest1, dest2, result,
o->black, o->white, TRUE,
&ramp_down, &ramp_up);
iter = gegl_buffer_iterator_new (dest1, result, 0,
babl_format ("Y float"),
GEGL_ACCESS_READ,
GEGL_ABYSS_NONE);
gegl_buffer_iterator_add (iter, dest2, result, 0,
babl_format ("Y float"),
GEGL_ACCESS_READ,
GEGL_ABYSS_NONE);
gegl_buffer_iterator_add (iter, output, result, 0,
babl_format ("Y float"),
GEGL_ACCESS_WRITE,
GEGL_ABYSS_NONE);
while (gegl_buffer_iterator_next (iter))
{
gint n_pixels = iter->length;
gfloat *ptr1 = iter->data[0];
gfloat *ptr2 = iter->data[1];
gfloat *out_pixel = iter->data[2];
while (n_pixels--)
{
diff = *ptr1 / *ptr2;
if (diff < THRESHOLD)
{
if (ramp_down == 0.0)
*out_pixel = 0.0;
else
{
mult = (ramp_down - MIN (ramp_down,
(THRESHOLD - diff))) / ramp_down;
*out_pixel = *ptr1 * mult;
}
}
else
{
if (ramp_up == 0.0)
mult = 1.0;
else
mult = MIN (ramp_up,
(diff - THRESHOLD)) / ramp_up;
*out_pixel = mult + *ptr1 - mult * *ptr1;
}
ptr1++;
ptr2++;
out_pixel++;
}
}
g_object_unref (dest1);
g_object_unref (dest2);
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglOperationAreaFilter *area = GEGL_OPERATION_AREA_FILTER (operation);
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglBuffer *dest, *dest_tmp;
GeglRectangle working_region;
GeglRectangle *whole_region;
GeglBufferIterator *iter;
whole_region = gegl_operation_source_get_bounding_box (operation, "input");
working_region.x = result->x - area->left;
working_region.width = result->width + area->left + area->right;
working_region.y = result->y - area->top;
working_region.height = result->height + area->top + area->bottom;
gegl_rectangle_intersect (&working_region, &working_region, whole_region);
dest_tmp = gegl_buffer_new (&working_region, babl_format ("Y' float"));
iter = gegl_buffer_iterator_new (dest_tmp, &working_region, 0, babl_format ("Y' float"),
GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE);
gegl_buffer_iterator_add (iter, input, &working_region, 0, babl_format ("Y' float"),
GEGL_ACCESS_READ, GEGL_ABYSS_NONE);
while (gegl_buffer_iterator_next (iter))
{
gint i;
gfloat *data_out = iter->data[0];
gfloat *data_in = iter->data[1];
for (i = 0; i < iter->length; i++)
{
/* compute sigmoidal transfer */
gfloat val = *data_in;
val = 1.0 / (1.0 + exp (-(SIGMOIDAL_BASE + (o->sharpness * SIGMOIDAL_RANGE)) * (val - 0.5)));
val = val * o->brightness;
*data_out = CLAMP (val, 0.0, 1.0);
data_out +=1;
data_in +=1;
}
}
dest = grey_blur_buffer (dest_tmp, o->glow_radius, result);
iter = gegl_buffer_iterator_new (output, result, 0, babl_format ("RGBA float"),
GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE);
gegl_buffer_iterator_add (iter, input, result, 0, babl_format ("RGBA float"),
GEGL_ACCESS_READ, GEGL_ABYSS_NONE);
gegl_buffer_iterator_add (iter, dest, result, 0, babl_format ("Y' float"),
GEGL_ACCESS_READ, GEGL_ABYSS_NONE);
while (gegl_buffer_iterator_next (iter))
{
gint i;
gfloat *data_out = iter->data[0];
gfloat *data_in = iter->data[1];
gfloat *data_blur = iter->data[2];
for (i = 0; i < iter->length; i++)
{
gint c;
for (c = 0; c < 3; c++)
{
gfloat tmp = (1.0 - data_in[c]) * (1.0 - *data_blur);
data_out[c] = CLAMP (1.0 - tmp, 0.0, 1.0);
}
data_out[3] = data_in[3];
data_out += 4;
data_in += 4;
data_blur+= 1;
}
}
g_object_unref (dest);
g_object_unref (dest_tmp);
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglBufferIterator *iter;
GeglBuffer *dest1;
GeglBuffer *dest2;
GeglSampler *sampler1;
GeglSampler *sampler2;
gdouble ramp;
gint x;
gint y;
gfloat tot_pixels = result->width * result->height;
gfloat pixels = 0;
grey_blur_buffer (input, o->mask_radius, &dest1, &dest2);
sampler1 = gegl_buffer_sampler_new_at_level (dest1,
babl_format ("Y' float"),
GEGL_SAMPLER_LINEAR,
level);
sampler2 = gegl_buffer_sampler_new_at_level (dest2,
babl_format ("Y' float"),
GEGL_SAMPLER_LINEAR,
level);
ramp = compute_ramp (sampler1, sampler2, result, o->pct_black);
iter = gegl_buffer_iterator_new (output, result, 0,
babl_format ("Y'CbCrA float"),
GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE);
gegl_buffer_iterator_add (iter, input, result, 0,
babl_format ("Y'CbCrA float"),
GEGL_ACCESS_READ, GEGL_ABYSS_NONE);
gegl_operation_progress (operation, 0.0, "");
while (gegl_buffer_iterator_next (iter))
{
gfloat *out_pixel = iter->data[0];
gfloat *in_pixel = iter->data[1];
for (y = iter->roi[0].y; y < iter->roi[0].y + iter->roi[0].height; ++y)
{
for (x = iter->roi[0].x; x < iter->roi[0].x + iter->roi[0].width; ++x)
{
gfloat pixel1;
gfloat pixel2;
gdouble mult = 0.0;
gdouble diff;
gegl_sampler_get (sampler1, x, y,
NULL, &pixel1,
GEGL_ABYSS_NONE);
gegl_sampler_get (sampler2, x, y,
NULL, &pixel2,
GEGL_ABYSS_NONE);
if (pixel2 != 0)
{
diff = (gdouble) pixel1 / (gdouble) pixel2;
if (diff < THRESHOLD)
{
if (GEGL_FLOAT_EQUAL (ramp, 0.0))
mult = 0.0;
else
mult = (ramp - MIN (ramp, (THRESHOLD - diff))) / ramp;
}
else
mult = 1.0;
}
out_pixel[0] = CLAMP (pixel1 * mult, 0.0, 1.0);
out_pixel[1] = in_pixel[1];
out_pixel[2] = in_pixel[2];
out_pixel[3] = in_pixel[3];
out_pixel += 4;
in_pixel += 4;
}
pixels += iter->roi[0].width;
gegl_operation_progress (operation, pixels / tot_pixels, "");
}
}
gegl_operation_progress (operation, 1.0, "");
g_object_unref (sampler1);
g_object_unref (sampler2);
g_object_unref (dest1);
g_object_unref (dest2);
return TRUE;
}
