static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglRectangle boundary;
const Babl *format;
gfloat *dst_buf;
gint y;
boundary = gegl_operation_get_bounding_box (operation);
format = babl_format ("RGBA float");
dst_buf = g_new0 (gfloat, result->width * result->height * 4);
for (y = result->y; y < result->y + result->height; y++)
fractaltrace (input, &boundary, dst_buf, result, o, y, o->fractal, format);
gegl_buffer_set (output, result, 0, format, dst_buf, GEGL_AUTO_ROWSTRIDE);
g_free (dst_buf);
gegl_buffer_sample_cleanup (input);
return TRUE;
}
/* Compute the input rectangle required to compute the specified
* region of interest (roi).
*/
static GeglRectangle
get_required_for_output (GeglOperation *operation,
const gchar *input_pad,
const GeglRectangle *roi)
{
return gegl_operation_get_bounding_box (operation);
}
/* Perform the specified operation.
*/
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglRectangle boundary = gegl_operation_get_bounding_box (operation);
GeglRectangle eff_boundary = get_effective_area (operation);
const Babl *format = babl_format ("RaGaBaA float");
#ifdef DO_NOT_USE_BUFFER_SAMPLE
g_warning ("NOT USING BUFFER SAMPLE!");
#endif
apply_mirror (o->m_angle,
o->r_angle,
o->n_segs,
o->c_x * boundary.width,
o->c_y * boundary.height,
o->o_x * (eff_boundary.width - eff_boundary.x) + eff_boundary.x,
o->o_y * (eff_boundary.height - eff_boundary.y) + eff_boundary.y,
o->input_scale / 100,
o->clip,
o->warp,
format,
input,
&eff_boundary,
output,
&boundary,
result,
level);
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglRectangle boundary;
const Babl *format;
GeglSampler *sampler;
gfloat *dst_buf;
gint y;
boundary = gegl_operation_get_bounding_box (operation);
format = babl_format ("RGBA float");
dst_buf = g_new0 (gfloat, result->width * result->height * 4);
sampler = gegl_buffer_sampler_new_at_level (input, format, GEGL_SAMPLER_CUBIC, level);
for (y = result->y; y < result->y + result->height; y++)
fractaltrace (input, sampler, &boundary, dst_buf, result, o, y, o->fractal, format, level);
gegl_buffer_set (output, result, 0, format, dst_buf, GEGL_AUTO_ROWSTRIDE);
g_object_unref (sampler);
g_free (dst_buf);
gegl_buffer_sample_cleanup (input);
return TRUE;
}
/* Perform the specified operation.
*/
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglRectangle boundary = gegl_operation_get_bounding_box (operation);
const Babl *format = babl_format ("RaGaBaA float");
apply_whirl_pinch (o->whirl,
o->pinch,
o->radius,
boundary.width / 2.0,
boundary.height / 2.0,
format,
input,
&boundary,
output,
&boundary,
result,
level);
return TRUE;
}
/**
* gegl_graph_prepare:
* @path: The traversal path
*
* Prepare all nodes, initializing their output formats and have rects.
*/
void
gegl_graph_prepare (GeglGraphTraversal *path)
{
GList *list_iter = NULL;
for (list_iter = path->dfs_path; list_iter; list_iter = list_iter->next)
{
GeglNode *node = GEGL_NODE (list_iter->data);
GeglOperation *operation = node->operation;
g_mutex_lock (&node->mutex);
gegl_operation_prepare (operation);
node->have_rect = gegl_operation_get_bounding_box (operation);
node->valid_have_rect = TRUE;
if (node->cache)
{
gegl_buffer_set_extent (GEGL_BUFFER (node->cache),
&node->have_rect);
}
g_mutex_unlock (&node->mutex);
if (!g_hash_table_contains (path->contexts, node))
{
GeglOperationContext *context = gegl_operation_context_new (node->operation);
g_hash_table_insert (path->contexts,
node,
context);
}
}
}
/* Perform the specified operation.
*/
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglRectangle boundary = gegl_operation_get_bounding_box (operation);
Babl *format = babl_format ("RaGaBaA float");
apply_spread ((o->x_amount + 1) / 2,
(o->y_amount + 1) / 2,
boundary.width - 2 * o->x_amount,
boundary.height - 2 * o->y_amount,
format,
input,
output,
result);
return TRUE;
}
static GeglRectangle
get_bounding_box (GeglOperation *self)
{
GeglRectangle rect = { 0, 0, 0, 0 };
if (self->node->is_graph)
{
GeglOperation *operation;
operation = gegl_node_get_output_proxy (self->node, "output")->operation;
rect = gegl_operation_get_bounding_box (operation);
}
else
{
g_warning ("Operation '%s' has no get_bounding_box() method",
G_OBJECT_CLASS_NAME (G_OBJECT_GET_CLASS (self)));
}
return rect;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglChantO *o;
GeglRectangle boundary;
const Babl *format;
FractalType fractal_type;
gfloat *dst_buf;
gint y;
o = GEGL_CHANT_PROPERTIES (operation);
boundary = gegl_operation_get_bounding_box (operation);
fractal_type = FRACTAL_TYPE_MANDELBROT;
if (!strcmp (o->fractal, "mandelbrot"))
fractal_type = FRACTAL_TYPE_MANDELBROT;
else if (!strcmp(o->fractal, "julia"))
fractal_type = FRACTAL_TYPE_JULIA;
format = babl_format ("RGBA float");
dst_buf = g_new0 (gfloat, result->width * result->height * 4);
for (y = result->y; y < result->y + result->height; y++)
fractaltrace (input, &boundary, dst_buf, result, o, y, fractal_type, format);
gegl_buffer_set (output, result, 0, format, dst_buf, GEGL_AUTO_ROWSTRIDE);
g_free (dst_buf);
gegl_buffer_sample_cleanup (input);
return TRUE;
}
/* sets up the node's bounding box */
static void
gegl_have_visitor_visit_node (GeglVisitor *self,
GeglNode *node)
{
GeglOperation *operation;
glong time = gegl_ticks ();
GEGL_VISITOR_CLASS (gegl_have_visitor_parent_class)->visit_node (self, node);
if (!node)
return;
operation = node->operation;
g_mutex_lock (node->mutex);
node->have_rect = gegl_operation_get_bounding_box (operation);
GEGL_NOTE (GEGL_DEBUG_PROCESS,
"For \"%s\" have_rect = %d,%d %d×%d",
gegl_node_get_debug_name (node),
node->have_rect.x, node->have_rect.y, node->have_rect.width, node->have_rect.height);
g_mutex_unlock (node->mutex);
time = gegl_ticks () - time;
gegl_instrument ("process", gegl_node_get_operation (node), time);
gegl_instrument (gegl_node_get_operation (node), "defined-region", time);
}
static gboolean update (gpointer operation)
{
GeglRectangle bounds = gegl_operation_get_bounding_box (operation);
gegl_operation_invalidate (operation, &bounds, FALSE);
return TRUE;
}
static GeglRectangle
get_cached_region (GeglOperation *operation,
const GeglRectangle *roi)
{
return gegl_operation_get_bounding_box (operation);
}
