static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglRectangle compute;
if (o->blur_radius >= 1.0 && gegl_cl_is_accelerated ())
if (cl_process (operation, input, output, result))
return TRUE;
compute = gegl_operation_get_required_for_output (operation, "input",result);
if (o->blur_radius < 1.0)
{
gegl_buffer_copy (input, result, output, result);
}
else
{
bilateral_filter (input, &compute, output, result, o->blur_radius, o->edge_preservation);
}
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglBuffer *temp_in;
GeglRectangle compute;
if (gegl_cl_is_accelerated ())
if (cl_process (operation, input, output, result))
return TRUE;
compute = gegl_operation_get_required_for_output (
operation, "input", result);
if (o->radius < 1.0)
{
output = g_object_ref (input);
}
else
{
temp_in = gegl_buffer_create_sub_buffer (input, &compute);
snn_mean (temp_in, output, result, o->radius, o->pairs);
g_object_unref (temp_in);
}
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
gfloat red = o->red;
gfloat green = o->green;
gfloat blue = o->blue;
gfloat *in_buf;
gfloat *out_buf;
if (gegl_cl_is_accelerated ())
if (cl_process (operation, input, output, result))
return TRUE;
if ((result->width > 0) && (result->height > 0))
{
gint num_pixels = result->width * result->height;
gint i;
gfloat *in_pixel, *out_pixel;
in_buf = g_new (gfloat, 4 * num_pixels);
out_buf = g_new (gfloat, 2 * num_pixels);
gegl_buffer_get (input, result, 1.0, babl_format ("RGBA float"), in_buf, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
in_pixel = in_buf;
out_pixel = out_buf;
for (i = 0; i < num_pixels; ++i)
{
out_pixel[0] = in_pixel[0] * red + in_pixel[1] * green + in_pixel[2] * blue;
out_pixel[1] = in_pixel[3];
in_pixel += 4;
out_pixel += 2;
}
gegl_buffer_set (output, result, 0, babl_format ("YA float"), out_buf,
GEGL_AUTO_ROWSTRIDE);
g_free (in_buf);
g_free (out_buf);
}
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *out_buf,
const GeglRectangle *roi,
gint level)
{
GeglBufferIterator *iter;
const Babl *out_format = gegl_operation_get_format (operation,
"output");
if (gegl_operation_use_opencl (operation))
{
GeglBufferClIterator *cl_iter;
gboolean err;
GEGL_NOTE (GEGL_DEBUG_OPENCL, "GEGL_OPERATION_POINT_RENDER: %s",
GEGL_OPERATION_GET_CLASS (operation)->name);
cl_iter = gegl_buffer_cl_iterator_new (out_buf, roi, out_format,
GEGL_CL_BUFFER_WRITE);
while (gegl_buffer_cl_iterator_next (cl_iter, &err) && !err)
{
err = cl_process (operation, cl_iter->tex[0], cl_iter->roi);
if (err)
{
gegl_buffer_cl_iterator_stop (cl_iter);
break;
}
}
if (err)
GEGL_NOTE (GEGL_DEBUG_OPENCL, "Error: %s",
GEGL_OPERATION_GET_CLASS (operation)->name);
else
return TRUE;
}
iter = gegl_buffer_iterator_new (out_buf, roi, level, out_format,
GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE);
while (gegl_buffer_iterator_next (iter))
c_process (operation, iter->data[0], &iter->roi[0]);
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
gint i, j;
gfloat *buf1, *buf2, *buf3;
if (gegl_operation_use_opencl (operation))
if (cl_process (operation, input, output, result))
return TRUE;
buf1 = g_new (gfloat, SQR (CHUNK_SIZE + LAPLACE_RADIUS * 2) * 4);
buf2 = g_new (gfloat, SQR (CHUNK_SIZE + LAPLACE_RADIUS * 2) * 4);
buf3 = g_new (gfloat, SQR (CHUNK_SIZE) * 4);
for (j = 0; (j-1) * CHUNK_SIZE < result->height; j++)
for (i = 0; (i-1) * CHUNK_SIZE < result->width; i++)
{
GeglRectangle chunked_result;
GeglRectangle compute;
chunked_result = *GEGL_RECTANGLE (result->x + i * CHUNK_SIZE,
result->y + j * CHUNK_SIZE,
CHUNK_SIZE, CHUNK_SIZE);
gegl_rectangle_intersect (&chunked_result, &chunked_result, result);
if (chunked_result.width < 1 || chunked_result.height < 1)
continue;
compute = gegl_operation_get_required_for_output (operation,
"input",
&chunked_result);
edge_laplace (input, &compute, output, &chunked_result,
buf1, buf2, buf3);
}
g_free (buf1);
g_free (buf2);
g_free (buf3);
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglRectangle compute;
if (gegl_cl_is_accelerated ())
if (cl_process (operation, input, output, result))
return TRUE;
compute = gegl_operation_get_required_for_output (operation, "input", result);
edge_laplace (input, &compute, output, result);
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglRectangle input_rect = gegl_operation_get_required_for_output (operation, "input", result);
if (gegl_cl_is_accelerated ())
if (cl_process (operation, input, output, result))
return TRUE;
hor_min ( input, &input_rect, output, result, o->radius);
ver_min (output, result, output, result, o->radius);
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglRectangle compute;
gboolean has_alpha;
compute = gegl_operation_get_required_for_output (operation, "input", result);
has_alpha = babl_format_has_alpha (gegl_operation_get_format (operation, "output"));
if (gegl_operation_use_opencl (operation))
if (cl_process (operation, input, output, result, has_alpha))
return TRUE;
edge_sobel (input, &compute, output, result, o->horizontal, o->vertical, o->keep_signal, has_alpha);
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglRectangle rect;
GeglRectangle tmprect;
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglBuffer *temp;
GeglOperationAreaFilter *op_area;
op_area = GEGL_OPERATION_AREA_FILTER (operation);
if (gegl_operation_use_opencl (operation))
if (cl_process (operation, input, output, result))
return TRUE;
rect = *result;
tmprect = *result;
rect.x -= op_area->left * 2;
rect.y -= op_area->top * 2;
rect.width += (op_area->left + op_area->right) * 2;
rect.height += (op_area->top + op_area->bottom) * 2;
/* very tricky: enlarge temp buffer to avoid seams in second pass */
tmprect.y -= o->radius;
tmprect.height += o->radius * 2;
temp = gegl_buffer_new (&tmprect,
babl_format ("RaGaBaA float"));
/* doing second pass in separate gegl op may be significantly faster */
hor_blur (input, &rect, temp, &tmprect, o->radius);
ver_blur (temp, &rect, output, result, o->radius);
g_object_unref (temp);
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *roi,
gint level)
{
GeglRectangle src_rect;
GeglRectangle *whole_region;
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglOperationAreaFilter *op_area;
op_area = GEGL_OPERATION_AREA_FILTER (operation);
whole_region = gegl_operation_source_get_bounding_box (operation, "input");
if (gegl_operation_use_opencl (operation))
if (cl_process (operation, input, output, roi))
return TRUE;
if (o->size_x * o->size_y < SQR (ALLOC_THRESHOLD_SIZE))
{
gfloat background_color[4];
gfloat *input_buf = g_new (gfloat,
(CHUNK_SIZE + o->size_x * 2) *
(CHUNK_SIZE + o->size_y * 2) * 4);
gfloat *output_buf = g_new (gfloat, SQR (CHUNK_SIZE) * 4);
gint i, j;
gegl_color_get_pixel (o->background, babl_format("RaGaBaA float"),
background_color);
for (j = 0; (j-1) * CHUNK_SIZE < roi->height; j++)
for (i = 0; (i-1) * CHUNK_SIZE < roi->width; i++)
{
GeglRectangle chunked_result;
GeglRectangle chunked_sizes;
chunked_result = *GEGL_RECTANGLE (roi->x + i * CHUNK_SIZE,
roi->y + j * CHUNK_SIZE,
CHUNK_SIZE, CHUNK_SIZE);
gegl_rectangle_intersect (&chunked_result, &chunked_result, roi);
if (chunked_result.width < 1 || chunked_result.height < 1)
continue;
src_rect = chunked_result;
src_rect.x -= op_area->left;
src_rect.y -= op_area->top;
src_rect.width += op_area->left + op_area->right;
src_rect.height += op_area->top + op_area->bottom;
gegl_buffer_get (input, &src_rect, 1.0, babl_format ("RaGaBaA float"),
input_buf, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_CLAMP);
gegl_rectangle_copy (&chunked_sizes, &chunked_result);
chunked_sizes.x = 0;
chunked_sizes.y = 0;
set_rectangle (output_buf, &chunked_sizes, &chunked_sizes,
chunked_result.width, background_color,
GEGL_PIXELIZE_NORM_INFINITY);
pixelize (input_buf, output_buf, &chunked_result, &src_rect,
whole_region, o);
gegl_buffer_set (output, &chunked_result, 0,
babl_format ("RaGaBaA float"),
output_buf, GEGL_AUTO_ROWSTRIDE);
}
g_free (input_buf);
g_free (output_buf);
}
else
{
gegl_buffer_set_color (output, roi, o->background);
pixelize_noalloc (input, output, roi, whole_region, o);
}
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
gfloat min[3], max[3], diff[3];
GeglBufferIterator *gi;
GeglProperties *o;
gint c;
if (gegl_cl_is_accelerated ())
if (cl_process (operation, input, output, result))
return TRUE;
o = GEGL_PROPERTIES (operation);
buffer_get_min_max (input, min, max);
if (o->keep_colors)
reduce_min_max_global (min, max);
for (c = 0; c < 3; c++)
{
diff[c] = max[c] - min[c];
/* Avoid a divide by zero error if the image is a solid color */
if (diff[c] < 1e-3)
{
min[c] = 0.0;
diff[c] = 1.0;
}
}
gi = gegl_buffer_iterator_new (input, result, 0, babl_format ("RGBA float"),
GEGL_ACCESS_READ, GEGL_ABYSS_NONE);
gegl_buffer_iterator_add (gi, output, result, 0, babl_format ("RGBA float"),
GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE);
while (gegl_buffer_iterator_next (gi))
{
gfloat *in = gi->data[0];
gfloat *out = gi->data[1];
gint o;
for (o = 0; o < gi->length; o++)
{
for (c = 0; c < 3; c++)
out[c] = (in[c] - min[c]) / diff[c];
out[3] = in[3];
in += 4;
out += 4;
}
}
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *roi,
gint level)
{
GeglRectangle src_rect;
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglOperationAreaFilter *op_area;
gfloat* in_buf;
gfloat* out_buf;
gfloat* out_pixel;
gint x,y;
gdouble theta = o->angle * G_PI / 180.0;
gdouble offset_x = o->length * cos(theta);
gdouble offset_y = o->length * sin(theta);
gint num_steps = (gint)ceil(o->length) + 1;
gfloat inv_num_steps = 1.0f / num_steps;
op_area = GEGL_OPERATION_AREA_FILTER (operation);
src_rect = *roi;
src_rect.x -= op_area->left;
src_rect.y -= op_area->top;
src_rect.width += op_area->left + op_area->right;
src_rect.height += op_area->top + op_area->bottom;
if (gegl_cl_is_accelerated ())
if (cl_process (operation, input, output, roi, &src_rect))
return TRUE;
in_buf = g_new (gfloat, src_rect.width * src_rect.height * 4);
out_buf = g_new0 (gfloat, roi->width * roi->height * 4);
out_pixel = out_buf;
gegl_buffer_get (input, &src_rect, 1.0, babl_format ("RaGaBaA float"), in_buf, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
for (y=0; y<roi->height; ++y)
{
for (x=0; x<roi->width; ++x)
{
gint step;
gint c;
gint px = x+roi->x;
gint py = y+roi->y;
gfloat sum[4] = {0,0,0,0};
for (step=0; step<num_steps; ++step)
{
gdouble t = num_steps == 1 ? 0.0 : step / (gdouble)(num_steps-1) - 0.5;
/* get the interpolated pixel position for this step */
gdouble xx = px + t*offset_x;
gdouble yy = py + t*offset_y;
gint ix = (gint)floor(xx);
gint iy = (gint)floor(yy);
gdouble dx = xx - floor(xx);
gdouble dy = yy - floor(yy);
/* do bilinear interpolation to get a nice smooth result */
gfloat *pix0, *pix1, *pix2, *pix3;
gfloat mixy0[4];
gfloat mixy1[4];
pix0 = get_pixel_color(in_buf, &src_rect, ix, iy);
pix1 = get_pixel_color(in_buf, &src_rect, ix+1, iy);
pix2 = get_pixel_color(in_buf, &src_rect, ix, iy+1);
pix3 = get_pixel_color(in_buf, &src_rect, ix+1, iy+1);
for (c=0; c<4; ++c)
{
mixy0[c] = dy*(pix2[c] - pix0[c]) + pix0[c];
mixy1[c] = dy*(pix3[c] - pix1[c]) + pix1[c];
sum[c] += dx*(mixy1[c] - mixy0[c]) + mixy0[c];
}
}
for (c=0; c<4; ++c)
*out_pixel++ = sum[c] * inv_num_steps;
}
}
gegl_buffer_set (output, roi, 0, babl_format ("RaGaBaA float"), out_buf, GEGL_AUTO_ROWSTRIDE);
g_free (in_buf);
g_free (out_buf);
return TRUE;
}