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 *roi,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
const Babl *format = gegl_operation_get_format (operation, "output");
gint components = babl_format_get_n_components (format);
gboolean has_alpha = babl_format_has_alpha (format);
gfloat *src_buff;
gfloat *dst_buff;
GeglRectangle rect;
gint x, y, ix, iy, b, idx;
rect = gegl_operation_get_required_for_output (operation, "input", roi);
src_buff = g_new (gfloat, rect.width * rect.height * components);
dst_buff = g_new0 (gfloat, roi->width * roi->height * components);
gegl_buffer_get (input, &rect, 1.0, format, src_buff,
GEGL_AUTO_ROWSTRIDE, o->border_behavior);
for (y = 0; y < roi->height; y++)
{
iy = y + 1;
for (x = 0; x < roi->width; x++)
{
ix = x + 1;
for (b = 0; b < 3; b++)
{
#define SRCPIX(X,Y,B) src_buff[((X) + (Y) * rect.width) * components + B]
gfloat window[9];
window[0] = SRCPIX(ix - 1, iy - 1, b);
window[1] = SRCPIX(ix, iy - 1, b);
window[2] = SRCPIX(ix + 1, iy - 1, b);
window[3] = SRCPIX(ix - 1, iy, b);
window[4] = SRCPIX(ix, iy, b);
window[5] = SRCPIX(ix + 1, iy, b);
window[6] = SRCPIX(ix - 1, iy + 1, b);
window[7] = SRCPIX(ix, iy + 1, b);
window[8] = SRCPIX(ix + 1, iy + 1, b);
idx = (x + y * roi->width) * components + b;
switch (o->algorithm)
{
default:
case GEGL_EDGE_SOBEL:
dst_buff[idx] = edge_sobel (window, o->amount);
break;
case GEGL_EDGE_PREWITT:
dst_buff[idx] = edge_prewitt (window, o->amount);
break;
case GEGL_EDGE_GRADIENT:
dst_buff[idx] = edge_gradient (window, o->amount);
break;
case GEGL_EDGE_ROBERTS:
dst_buff[idx] = edge_roberts (window, o->amount);
break;
case GEGL_EDGE_DIFFERENTIAL:
dst_buff[idx] = edge_differential (window, o->amount);
break;
case GEGL_EDGE_LAPLACE:
dst_buff[idx] = edge_laplace (window, o->amount);
break;
}
}
if (has_alpha)
dst_buff[idx + 1] = SRCPIX(ix, iy, 3);
}
#undef SRCPIX
}
gegl_buffer_set (output, roi, level, format, dst_buff, GEGL_AUTO_ROWSTRIDE);
g_free (src_buff);
g_free (dst_buff);
return TRUE;
}
