static void prepare (GeglOperation *operation) { GeglOperationAreaFilter *area = GEGL_OPERATION_AREA_FILTER (operation); area->left = area->right = area->top = area->bottom = GEGL_CHANT_PROPERTIES (operation)->radius; gegl_operation_set_format (operation, "output", babl_format ("RGBA float")); }
static void prepare (GeglOperation *operation) { GeglOperationAreaFilter *area = GEGL_OPERATION_AREA_FILTER (operation); GeglProperties *o = GEGL_PROPERTIES (operation); const Babl *in_format = gegl_operation_get_source_format (operation, "input"); const Babl *format = babl_format ("RGB float"); area->left = area->right = area->top = area->bottom = o->radius; o->user_data = g_renew (gint, o->user_data, o->radius + 1); init_neighborhood_outline (o->neighborhood, o->radius, o->user_data); if (in_format) { if (babl_format_has_alpha (in_format)) format = babl_format ("RGBA float"); } gegl_operation_set_format (operation, "input", format); gegl_operation_set_format (operation, "output", format); }
static void prepare (GeglOperation *operation) { GeglOperationAreaFilter *area = GEGL_OPERATION_AREA_FILTER (operation); area->right = area->bottom = 1; gegl_operation_set_format (operation, "output", babl_format ("RGB float")); }
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* buf; 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; buf = g_new0 (gfloat, src_rect.width * src_rect.height * 4); gegl_buffer_get (input, &src_rect, 1.0, babl_format ("RGBA float"), buf, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); dot(buf, roi, o); gegl_buffer_set (output, roi, 0, babl_format ("RGBA float"), buf, GEGL_AUTO_ROWSTRIDE); g_free (buf); return TRUE; }
static gboolean cl_process (GeglOperation *operation, GeglBuffer *input, GeglBuffer *output, const GeglRectangle *result) { const Babl *in_format = gegl_operation_get_format (operation, "input"); const Babl *out_format = gegl_operation_get_format (operation, "output"); gint err; gint j; cl_int cl_err; GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation); GeglChantO *o = GEGL_CHANT_PROPERTIES (operation); GeglBufferClIterator *i = gegl_buffer_cl_iterator_new (output, result, out_format, GEGL_CL_BUFFER_WRITE, GEGL_ABYSS_NONE); gint read = gegl_buffer_cl_iterator_add_2 (i, input, result, in_format, GEGL_CL_BUFFER_READ, op_area->left, op_area->right, op_area->top, op_area->bottom, GEGL_ABYSS_NONE); while (gegl_buffer_cl_iterator_next (i, &err)) { if (err) return FALSE; for (j=0; j < i->n; j++) { cl_err = cl_bilateral_filter(i->tex[read][j], i->tex[0][j], i->size[0][j], &i->roi[0][j], ceil(o->blur_radius), o->edge_preservation); if (cl_err != CL_SUCCESS) { g_warning("[OpenCL] Error in gegl:bilateral-filter: %s", gegl_cl_errstring(cl_err)); return FALSE; } } } return TRUE; }
static gboolean cl_process (GeglOperation *operation, GeglBuffer *input, GeglBuffer *output, const GeglRectangle *result) { const Babl *in_format = gegl_operation_get_format (operation, "input"); const Babl *out_format = gegl_operation_get_format (operation, "output"); gint err; gint j; cl_int cl_err; GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation); GeglBufferClIterator *i = gegl_buffer_cl_iterator_new (output, result, out_format, GEGL_CL_BUFFER_WRITE, GEGL_ABYSS_NONE); gint read = gegl_buffer_cl_iterator_add_2 (i, input, result, in_format, GEGL_CL_BUFFER_READ, op_area->left, op_area->right, op_area->top, op_area->bottom, GEGL_ABYSS_NONE); gint aux = gegl_buffer_cl_iterator_add_2 (i, NULL, result, in_format, GEGL_CL_BUFFER_AUX, op_area->left, op_area->right, op_area->top, op_area->bottom, GEGL_ABYSS_NONE); while (gegl_buffer_cl_iterator_next (i, &err)) { if (err) return FALSE; for (j=0; j < i->n; j++) { cl_err = cl_edge_laplace(i->tex[read][j], i->tex[aux][j], i->tex[0][j], &i->roi[read][j], &i->roi[0][j], LAPLACE_RADIUS); if (cl_err != CL_SUCCESS) { g_warning("[OpenCL] Error in gegl:edge-laplace: %s", gegl_cl_errstring(cl_err)); return FALSE; } } } return TRUE; }
static void prepare_cl (GeglOperation *operation) { GeglOperationAreaFilter* op_area = GEGL_OPERATION_AREA_FILTER (operation); GeglChantO* o = GEGL_CHANT_PROPERTIES (operation); gdouble theta = o->angle * G_PI / 180.0; gdouble offset_x = fabs(o->length * cos(theta)); gdouble offset_y = fabs(o->length * sin(theta)); op_area->left = op_area->right = (gint)ceil(0.5 * offset_x); op_area->top = op_area->bottom = (gint)ceil(0.5 * offset_y); GeglNode * self; GeglPad *pad; Babl * format=babl_format ("RaGaBaA float"); self=gegl_operation_get_source_node(operation,"input"); while(self) { if(strcmp(gegl_node_get_operation(self),"gimp:tilemanager-source")==0) { format=gegl_operation_get_format(self->operation,"output"); break; } self=gegl_operation_get_source_node(self->operation,"input"); } gegl_operation_set_format (operation, "output", format); }
static void prepare (GeglOperation *operation) { GeglProperties *o = GEGL_PROPERTIES (operation); GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation); const Babl *format; if (o->direction == GEGL_ORIENTATION_HORIZONTAL) { op_area->left = o->shift; op_area->right = o->shift; op_area->top = 0; op_area->bottom = 0; } else if (o->direction == GEGL_ORIENTATION_VERTICAL) { op_area->top = o->shift; op_area->bottom = o->shift; op_area->left = 0; op_area->right = 0; } format = gegl_operation_get_source_format (operation, "input"); gegl_operation_set_format (operation, "input", format); gegl_operation_set_format (operation, "output", format); }
static void prepare (GeglOperation *operation) { GeglChantO *o; GeglOperationAreaFilter *op_area; op_area = GEGL_OPERATION_AREA_FILTER (operation); o = GEGL_CHANT_PROPERTIES (operation); if (o->chant_data) { g_hash_table_destroy (o->chant_data); o->chant_data = NULL; } op_area->left = o->strength; op_area->right = o->strength; op_area->top = o->strength; op_area->bottom = o->strength; gegl_operation_set_format (operation, "input", babl_format ("RGBA float")); gegl_operation_set_format (operation, "output", babl_format ("RGBA float")); }
static GeglRectangle get_bounding_box (GeglOperation *operation) { GeglOperationAreaFilter *area = GEGL_OPERATION_AREA_FILTER (operation); GeglRectangle result = { 0, }; GeglRectangle *in_rect; in_rect = gegl_operation_source_get_bounding_box (operation,"input"); if (!in_rect) return result; if (gegl_rectangle_is_infinite_plane (in_rect)) return *in_rect; result = *in_rect; if (result.width != 0 && result.height != 0) { result.x-= area->left; result.y-= area->top; result.width += area->left + area->right; result.height += area->top + area->bottom; } return result; }
static gboolean process (GeglOperation *operation, GeglBuffer *input, GeglBuffer *output, const GeglRectangle *result, gint level) { GeglChantO *o = GEGL_CHANT_PROPERTIES (operation); GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation); GeglRectangle rect; gfloat *src_buf; gfloat *dst_buf; gchar *type; gint alpha; gint x; gint floats_per_pixel; /*blur-map or emboss*/ if (o->filter && !strcmp (o->filter, "blur-map")) { type = "RGBA float"; floats_per_pixel = 4; alpha = 1; } else { type = "Y float"; floats_per_pixel = 1; alpha = 0; } rect.x = result->x - op_area->left; rect.width = result->width + op_area->left + op_area->right; rect.y = result->y - op_area->top; rect.height = result->height + op_area->top + op_area->bottom; src_buf = g_new0 (gfloat, rect.width * rect.height * floats_per_pixel); dst_buf = g_new0 (gfloat, rect.width * rect.height * floats_per_pixel); gegl_buffer_get (input, &rect, 1.0, babl_format (type), src_buf, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); /*do for every row*/ for (x = 0; x < rect.height; x++) emboss (src_buf, &rect, dst_buf, &rect, x, type, floats_per_pixel, alpha, DEG_TO_RAD (o->azimuth), DEG_TO_RAD (o->elevation), o->depth); gegl_buffer_set (output, &rect, 0, babl_format (type), dst_buf, GEGL_AUTO_ROWSTRIDE); g_free (src_buf); g_free (dst_buf); return TRUE; }
static void prepare (GeglOperation *operation) { GeglOperationAreaFilter *area = GEGL_OPERATION_AREA_FILTER (operation); //GeglChantO *o = GEGL_CHANT_PROPERTIES (operation); area->left = area->right = area->top = area->bottom = LAPLACE_RADIUS; gegl_operation_set_format (operation, "input", babl_format ("RGBA float")); gegl_operation_set_format (operation, "output", babl_format ("RGBA float")); }
static gboolean cl_process (GeglOperation *operation, GeglBuffer *input, GeglBuffer *output, const GeglRectangle *result) { const Babl *in_format = gegl_operation_get_format (operation, "input"); const Babl *out_format = gegl_operation_get_format (operation, "output"); gint err; GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation); GeglChantO *o = GEGL_CHANT_PROPERTIES (operation); GeglBufferClIterator *i = gegl_buffer_cl_iterator_new (output, result, out_format, GEGL_CL_BUFFER_WRITE); gint read = gegl_buffer_cl_iterator_add_2 (i, input, result, in_format, GEGL_CL_BUFFER_READ, op_area->left, op_area->right, op_area->top, op_area->bottom, GEGL_ABYSS_NONE); gint aux = gegl_buffer_cl_iterator_add_2 (i, NULL, result, in_format, GEGL_CL_BUFFER_AUX, 0, 0, op_area->top, op_area->bottom, GEGL_ABYSS_NONE); while (gegl_buffer_cl_iterator_next (i, &err)) { if (err) return FALSE; err = cl_box_max(i->tex[read], i->tex[aux], i->tex[0], i->size[0], &i->roi[0], ceil (o->radius)); if (err) return FALSE; } return TRUE; }
static gboolean cl_process (GeglOperation *operation, GeglBuffer *input, GeglBuffer *output, const GeglRectangle *result) { const Babl *in_format = gegl_operation_get_format (operation, "input"); const Babl *out_format = gegl_operation_get_format (operation, "output"); gint err = 0; GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation); GeglProperties *o = GEGL_PROPERTIES (operation); GeglBufferClIterator *i = gegl_buffer_cl_iterator_new (output, result, out_format, GEGL_CL_BUFFER_WRITE); gint read = gegl_buffer_cl_iterator_add_2 (i, input, result, in_format, GEGL_CL_BUFFER_READ, op_area->left, op_area->right, op_area->top, op_area->bottom, GEGL_ABYSS_CLAMP); gint aux = gegl_buffer_cl_iterator_add_aux (i, result, in_format, 0, 0, op_area->top, op_area->bottom); while (gegl_buffer_cl_iterator_next (i, &err) && !err) { err = cl_box_blur (i->tex[read], i->tex[aux], i->tex[0], i->size[0], &i->roi[0], o->radius); if (err) { gegl_buffer_cl_iterator_stop (i); break; } } return !err; }
static void prepare (GeglOperation *operation) { GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation); op_area->left = op_area->right = op_area->top = op_area->bottom = HALF_WINDOW; gegl_operation_set_format (operation, "output", babl_format ("RGBA float")); }
static void prepare (GeglOperation *operation) { GeglOperationAreaFilter *area = GEGL_OPERATION_AREA_FILTER (operation); GeglProperties *o = GEGL_PROPERTIES (operation); const Babl *format = babl_format ("R'G'B'A float"); area->left = area->right = area->top = area->bottom = o->iterations; gegl_operation_set_format (operation, "input", format); gegl_operation_set_format (operation, "output", format); }
static gboolean process (GeglOperation *operation, GeglBuffer *input, GeglBuffer *output, const GeglRectangle *result) { GeglChantO *o = GEGL_CHANT_PROPERTIES (operation); GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation); Babl *format = babl_format ("RGBA float"); GeglRectangle rect; GeglRectangle boundary = get_effective_area (operation); gint x, y; gfloat *dst_buf, *src_buf; rect.x = CLAMP (result->x - op_area->left, boundary.x, boundary.x + boundary.width); rect.width = CLAMP (result->width + op_area->left + op_area->right, 0, boundary.width); rect.y = CLAMP (result->y - op_area->top, boundary.y, boundary.y + boundary.width); rect.height = CLAMP (result->height + op_area->top + op_area->bottom, 0, boundary.height); dst_buf = g_new0 (gfloat, result->height * result->width * 4); src_buf = g_new0 (gfloat, rect.height * rect.width * 4); gegl_buffer_get (input, 1.0, result, format, dst_buf, GEGL_AUTO_ROWSTRIDE); gegl_buffer_get (input, 1.0, &rect, format, src_buf, GEGL_AUTO_ROWSTRIDE); if (o->horizontal) { for (y = result->y; y < result->y + result->height; y++) if ((o->even && (y % 2 == 0)) || (!o->even && (y % 2 != 0))) deinterlace_horizontal (src_buf, dst_buf, result, &rect, &boundary, o->even ? 0 : 1, y, o->size); } else { for (x = result->x; x < result->x + result->width; x++) if ((o->even && (x % 2 == 0)) || (!o->even && (x % 2 != 0))) deinterlace_vertical (src_buf, dst_buf, result, &rect, &boundary, o->even ? 0 : 1, x, o->size); } gegl_buffer_set (output, result, format, dst_buf, GEGL_AUTO_ROWSTRIDE); g_free (src_buf); g_free (dst_buf); return TRUE; }
static void prepare (GeglOperation *operation) { GeglOperationAreaFilter *area = GEGL_OPERATION_AREA_FILTER (operation); GeglProperties *o = GEGL_PROPERTIES (operation); area->left = area->right = ceil (fabs (o->glow_radius)) +1; area->top = area->bottom = ceil (fabs (o->glow_radius)) +1; gegl_operation_set_format (operation, "input", babl_format ("RGBA float")); gegl_operation_set_format (operation, "output", babl_format ("RGBA float")); }
static void prepare (GeglOperation *operation) { GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation); GeglProperties *o = GEGL_PROPERTIES (operation); op_area->left = o->amplitude; op_area->right = o->amplitude; op_area->top = o->amplitude; op_area->bottom = o->amplitude; gegl_operation_set_format (operation, "input", babl_format ("RGBA float")); gegl_operation_set_format (operation, "output", babl_format ("RGBA float")); }
static GeglRectangle get_invalidated_by_change (GeglOperation *operation, const gchar *input_pad, const GeglRectangle *input_region) { GeglOperationAreaFilter *area = GEGL_OPERATION_AREA_FILTER (operation); GeglRectangle retval; retval.x = input_region->x - area->left; retval.y = input_region->y - area->top; retval.width = input_region->width + area->left + area->right; retval.height = input_region->height + area->top + area->bottom; return retval; }
static void prepare (GeglOperation *operation) { GeglChantO *o = GEGL_CHANT_PROPERTIES (operation); GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation); op_area->left = op_area->right = op_area->top = op_area->bottom = 3; if (o->filter && !strcmp(o->filter, "blur-map")) gegl_operation_set_format (operation, "output", babl_format ("RGBA float")); else gegl_operation_set_format (operation, "output", babl_format ("Y float")); }
static gboolean cl_process (GeglOperation *operation, GeglBuffer *input, GeglBuffer *output, const GeglRectangle *result, gboolean has_alpha) { const Babl *in_format = babl_format ("RGBA float"); const Babl *out_format = babl_format ("RGBA float"); gint err; GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation); GeglChantO *o = GEGL_CHANT_PROPERTIES (operation); GeglBufferClIterator *i = gegl_buffer_cl_iterator_new (output, result, out_format, GEGL_CL_BUFFER_WRITE); gint read = gegl_buffer_cl_iterator_add_2 (i, input, result, in_format, GEGL_CL_BUFFER_READ, op_area->left, op_area->right, op_area->top, op_area->bottom, GEGL_ABYSS_NONE); while (gegl_buffer_cl_iterator_next (i, &err)) { if (err) return FALSE; err = cl_edge_sobel(i->tex[read], i->tex[0], i->size[0], &i->roi[0], o->horizontal, o->vertical, o->keep_signal, has_alpha); if (err) return FALSE; } return TRUE; }
static void prepare (GeglOperation *operation) { GeglChantO *o; GeglOperationAreaFilter *op_area; op_area = GEGL_OPERATION_AREA_FILTER (operation); o = GEGL_CHANT_PROPERTIES (operation); op_area->left = op_area->right = op_area->top = op_area->bottom = o->radius; gegl_operation_set_format (operation, "input", babl_format ("RaGaBaA float")); gegl_operation_set_format (operation, "output", babl_format ("RaGaBaA float")); }
static void prepare (GeglOperation *operation) { GeglOperationAreaFilter *area = GEGL_OPERATION_AREA_FILTER (operation); //GeglChantO *o = GEGL_CHANT_PROPERTIES (operation); const Babl *source_format = gegl_operation_get_source_format (operation, "input"); area->left = area->right = area->top = area->bottom = SOBEL_RADIUS; gegl_operation_set_format (operation, "input", babl_format ("RGBA float")); if (source_format && !babl_format_has_alpha (source_format)) gegl_operation_set_format (operation, "output", babl_format ("RGB float")); else gegl_operation_set_format (operation, "output", babl_format ("RGBA float")); }
static void prepare (GeglOperation *operation) { GeglOperationAreaFilter* op_area = GEGL_OPERATION_AREA_FILTER (operation); GeglChantO* o = GEGL_CHANT_PROPERTIES (operation); gdouble theta = o->angle * G_PI / 180.0; gdouble offset_x = fabs(o->length * cos(theta)); gdouble offset_y = fabs(o->length * sin(theta)); op_area->left = op_area->right = (gint)ceil(0.5 * offset_x); op_area->top = op_area->bottom = (gint)ceil(0.5 * offset_y); gegl_operation_set_format (operation, "output", babl_format ("RaGaBaA float")); }
static void prepare (GeglOperation *operation) { GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation); GeglProperties *o = GEGL_PROPERTIES (operation); GeglRectangle *whole_region; gdouble angle = o->angle * G_PI / 180.0; while (angle < 0.0) angle += 2 * G_PI; whole_region = gegl_operation_source_get_bounding_box (operation, "input"); if (whole_region != NULL) { gdouble center_x = gegl_coordinate_relative_to_pixel (o->center_x, whole_region->width); gdouble center_y = gegl_coordinate_relative_to_pixel (o->center_y, whole_region->height); gdouble maxr_x = MAX (fabs (center_x - whole_region->x), fabs (center_x - whole_region->x - whole_region->width)); gdouble maxr_y = MAX (fabs (center_y - whole_region->y), fabs (center_y - whole_region->y - whole_region->height)); if (angle >= G_PI) angle = G_PI; op_area->left = op_area->right = ceil (maxr_y * sin (angle / 2.0)) + 1; op_area->top = op_area->bottom = ceil (maxr_x * sin (angle / 2.0)) + 1; } else { op_area->left = op_area->right = op_area->top = op_area->bottom = 0; } gegl_operation_set_format (operation, "input", babl_format ("RaGaBaA float")); gegl_operation_set_format (operation, "output", babl_format ("RaGaBaA float")); }
static void prepare (GeglOperation *operation) { #define max(A,B) ((A) > (B) ? (A) : (B)) GeglOperationAreaFilter *area = GEGL_OPERATION_AREA_FILTER (operation); GeglChantO *o = GEGL_CHANT_PROPERTIES (operation); gfloat fir_radius_x = fir_calc_convolve_matrix_length (o->std_dev_x) / 2; gfloat fir_radius_y = fir_calc_convolve_matrix_length (o->std_dev_y) / 2; gfloat iir_radius_x = o->std_dev_x * RADIUS_SCALE; gfloat iir_radius_y = o->std_dev_y * RADIUS_SCALE; /* XXX: these should be calculated exactly considering o->filter, but we just * make sure there is enough space */ area->left = area->right = ceil ( max (fir_radius_x, iir_radius_x)); area->top = area->bottom = ceil ( max (fir_radius_y, iir_radius_y)); gegl_operation_set_format (operation, "output", babl_format ("RaGaBaA float")); #undef max }
static void prepare (GeglOperation *operation) { GeglChantO *o = GEGL_CHANT_PROPERTIES (operation); GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation); gint tmp; /* * Calculate the needed extension for the ROI * MAX (o->tile_size + * g_rand_double_range (gr, 0, o->tile_size / 4.0) - * o->tile_size / 8.0) * o->tile_saturation) */ tmp = ceil ((9 * o->tile_size / 8.0) * o->tile_saturation); op_area->left = op_area->right = op_area->top = op_area->bottom = tmp; gegl_operation_set_format (operation, "input", babl_format ("RGBA float")); gegl_operation_set_format (operation, "output", babl_format ("RGBA float")); }
static void prepare (GeglOperation *operation) { const Babl *input_format = gegl_operation_get_source_format (operation, "input"); const Babl *format; GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation); if (input_format == NULL || babl_format_has_alpha (input_format)) format = babl_format ("R'G'B'A float"); else format = babl_format ("R'G'B' float"); gegl_operation_set_format (operation, "input", format); gegl_operation_set_format (operation, "output", format); op_area->left = op_area->right = op_area->top = op_area->bottom = 1; }
static void prepare (GeglOperation *operation) { GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation); GeglChantO *o = GEGL_CHANT_PROPERTIES (operation); if (o->orientation == GEGL_ORIENTATION_HORIZONTAL) { op_area->left = op_area->right = 0; op_area->top = op_area->bottom = o->size + 1; } else { op_area->left = op_area->right = o->size + 1; op_area->top = op_area->bottom = 0; } gegl_operation_set_format (operation, "input", babl_format ("RGBA float")); gegl_operation_set_format (operation, "output", babl_format ("RGBA float")); }