908 lines
31 KiB
C
908 lines
31 KiB
C
/* Page Curl 0.9 --- image filter plug-in for PIKA
|
|
* Copyright (C) 1996 Federico Mena Quintero
|
|
* Ported to Pika 1.0 1998 by Simon Budig <Simon.Budig@unix-ag.org>
|
|
*
|
|
* You can contact me at quartic@polloux.fciencias.unam.mx
|
|
* You can contact the original PIKA authors at pika@xcf.berkeley.edu
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Ported to the 0.99.x architecture by Simon Budig, Simon.Budig@unix-ag.org
|
|
* Ported to the 3.0 plug-in API by Michael Natterer <mitch@gimp.org>
|
|
*/
|
|
|
|
/*
|
|
* Version History
|
|
* 0.5: (1996) Version for Pika 0.54 by Federico Mena Quintero
|
|
* 0.6: (Feb '98) First Version for Pika 0.99.x, very buggy.
|
|
* 0.8: (Mar '98) First "stable" version
|
|
* 0.9: (May '98)
|
|
* - Added support for Gradients. It is now possible to map
|
|
* a gradient to the back of the curl.
|
|
* - This implies a changed PDB-Interface: New "mode" parameter.
|
|
* - Pagecurl now returns the ID of the new layer.
|
|
* - Exchanged the meaning of FG/BG Color, because mostly the FG
|
|
* color is darker.
|
|
* 1.0: (July '04)
|
|
* - Code cleanup, added reverse gradient option.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <libpika/pika.h>
|
|
#include <libpika/pikaui.h>
|
|
|
|
#include "libpika/stdplugins-intl.h"
|
|
|
|
|
|
#define PLUG_IN_PROC "plug-in-pagecurl"
|
|
#define PLUG_IN_BINARY "pagecurl"
|
|
#define PLUG_IN_ROLE "pika-pagecurl"
|
|
#define PLUG_IN_VERSION "July 2004, 1.0"
|
|
#define NGRADSAMPLES 256
|
|
|
|
|
|
typedef enum
|
|
{
|
|
CURL_COLORS_FG_BG,
|
|
CURL_COLORS_GRADIENT,
|
|
CURL_COLORS_GRADIENT_REVERSE,
|
|
CURL_COLORS_LAST = CURL_COLORS_GRADIENT_REVERSE
|
|
} CurlColors;
|
|
|
|
typedef enum
|
|
{
|
|
CURL_ORIENTATION_VERTICAL,
|
|
CURL_ORIENTATION_HORIZONTAL,
|
|
CURL_ORIENTATION_LAST = CURL_ORIENTATION_HORIZONTAL
|
|
} CurlOrientation;
|
|
|
|
typedef enum
|
|
{
|
|
CURL_EDGE_LOWER_RIGHT = 1,
|
|
CURL_EDGE_LOWER_LEFT = 2,
|
|
CURL_EDGE_UPPER_LEFT = 3,
|
|
CURL_EDGE_UPPER_RIGHT = 4,
|
|
CURL_EDGE_FIRST = CURL_EDGE_LOWER_RIGHT,
|
|
CURL_EDGE_LAST = CURL_EDGE_UPPER_RIGHT
|
|
} CurlEdge;
|
|
|
|
|
|
#define CURL_EDGE_LEFT(e) ((e) == CURL_EDGE_LOWER_LEFT || \
|
|
(e) == CURL_EDGE_UPPER_LEFT)
|
|
#define CURL_EDGE_RIGHT(e) ((e) == CURL_EDGE_LOWER_RIGHT || \
|
|
(e) == CURL_EDGE_UPPER_RIGHT)
|
|
#define CURL_EDGE_LOWER(e) ((e) == CURL_EDGE_LOWER_RIGHT || \
|
|
(e) == CURL_EDGE_LOWER_LEFT)
|
|
#define CURL_EDGE_UPPER(e) ((e) == CURL_EDGE_UPPER_LEFT || \
|
|
(e) == CURL_EDGE_UPPER_RIGHT)
|
|
|
|
|
|
typedef struct _Pagecurl Pagecurl;
|
|
typedef struct _PagecurlClass PagecurlClass;
|
|
|
|
struct _Pagecurl
|
|
{
|
|
PikaPlugIn parent_instance;
|
|
};
|
|
|
|
struct _PagecurlClass
|
|
{
|
|
PikaPlugInClass parent_class;
|
|
};
|
|
|
|
|
|
#define PAGECURL_TYPE (pagecurl_get_type ())
|
|
#define PAGECURL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PAGECURL_TYPE, Pagecurl))
|
|
|
|
GType pagecurl_get_type (void) G_GNUC_CONST;
|
|
|
|
static GList * pagecurl_query_procedures (PikaPlugIn *plug_in);
|
|
static PikaProcedure * pagecurl_create_procedure (PikaPlugIn *plug_in,
|
|
const gchar *name);
|
|
|
|
static PikaValueArray * pagecurl_run (PikaProcedure *procedure,
|
|
PikaRunMode run_mode,
|
|
PikaImage *image,
|
|
gint n_drawables,
|
|
PikaDrawable **drawables,
|
|
PikaProcedureConfig *config,
|
|
gpointer run_data);
|
|
|
|
static gboolean dialog (PikaProcedure *procedure,
|
|
PikaProcedureConfig *config);
|
|
|
|
static void init_calculation (PikaDrawable *drawable,
|
|
PikaProcedureConfig *config);
|
|
static PikaLayer * do_curl_effect (PikaDrawable *drawable,
|
|
PikaProcedureConfig *config);
|
|
static void clear_curled_region (PikaDrawable *drawable,
|
|
PikaProcedureConfig *config);
|
|
static PikaLayer * page_curl (PikaDrawable *drawable,
|
|
PikaProcedureConfig *config);
|
|
static PikaRGB * get_gradient_samples (PikaDrawable *drawable,
|
|
gboolean reverse);
|
|
|
|
|
|
G_DEFINE_TYPE (Pagecurl, pagecurl, PIKA_TYPE_PLUG_IN)
|
|
|
|
PIKA_MAIN (PAGECURL_TYPE)
|
|
DEFINE_STD_SET_I18N
|
|
|
|
|
|
/* Image parameters */
|
|
|
|
static PikaImage *image = NULL;
|
|
|
|
static gint sel_x, sel_y;
|
|
static gint true_sel_width, true_sel_height;
|
|
static gint sel_width, sel_height;
|
|
static gint drawable_position;
|
|
|
|
/* Center and radius of circle */
|
|
|
|
static PikaVector2 center;
|
|
static double radius;
|
|
|
|
/* Useful points to keep around */
|
|
|
|
static PikaVector2 left_tangent;
|
|
static PikaVector2 right_tangent;
|
|
|
|
/* Slopes --- these are *not* in the usual geometric sense! */
|
|
|
|
static gdouble diagl_slope;
|
|
static gdouble diagr_slope;
|
|
static gdouble diagb_slope;
|
|
static gdouble diagm_slope;
|
|
|
|
/* User-configured parameters */
|
|
|
|
static PikaRGB fg_color;
|
|
static PikaRGB bg_color;
|
|
|
|
|
|
static void
|
|
pagecurl_class_init (PagecurlClass *klass)
|
|
{
|
|
PikaPlugInClass *plug_in_class = PIKA_PLUG_IN_CLASS (klass);
|
|
|
|
plug_in_class->query_procedures = pagecurl_query_procedures;
|
|
plug_in_class->create_procedure = pagecurl_create_procedure;
|
|
plug_in_class->set_i18n = STD_SET_I18N;
|
|
}
|
|
|
|
static void
|
|
pagecurl_init (Pagecurl *pagecurl)
|
|
{
|
|
}
|
|
|
|
static GList *
|
|
pagecurl_query_procedures (PikaPlugIn *plug_in)
|
|
{
|
|
return g_list_append (NULL, g_strdup (PLUG_IN_PROC));
|
|
}
|
|
|
|
static PikaProcedure *
|
|
pagecurl_create_procedure (PikaPlugIn *plug_in,
|
|
const gchar *name)
|
|
{
|
|
PikaProcedure *procedure = NULL;
|
|
|
|
if (! strcmp (name, PLUG_IN_PROC))
|
|
{
|
|
procedure = pika_image_procedure_new (plug_in, name,
|
|
PIKA_PDB_PROC_TYPE_PLUGIN,
|
|
pagecurl_run, NULL, NULL);
|
|
|
|
pika_procedure_set_image_types (procedure, "RGB*, GRAY*");
|
|
pika_procedure_set_sensitivity_mask (procedure,
|
|
PIKA_PROCEDURE_SENSITIVE_DRAWABLE);
|
|
|
|
pika_procedure_set_menu_label (procedure, _("_Pagecurl..."));
|
|
pika_procedure_add_menu_path (procedure, "<Image>/Filters/Distorts");
|
|
|
|
pika_procedure_set_documentation (procedure,
|
|
_("Curl up one of the image corners"),
|
|
"This plug-in creates a pagecurl-effect.",
|
|
name);
|
|
pika_procedure_set_attribution (procedure,
|
|
"Federico Mena Quintero and Simon Budig",
|
|
"Federico Mena Quintero and Simon Budig",
|
|
PLUG_IN_VERSION);
|
|
|
|
PIKA_PROC_ARG_CHOICE (procedure, "colors",
|
|
_("Colors"), NULL,
|
|
pika_choice_new_with_values ("fg-bg", CURL_COLORS_FG_BG, _("Foreground / background colors"), NULL,
|
|
"current-gradient", CURL_COLORS_GRADIENT, _("Current gradient"), NULL,
|
|
"current-gradient-reversed", CURL_COLORS_GRADIENT_REVERSE, _("Current gradient (reversed)"), NULL,
|
|
NULL),
|
|
"fg-bg",
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_CHOICE (procedure, "edge",
|
|
_("Locatio_n"),
|
|
_("Corner which is curled"),
|
|
pika_choice_new_with_values ("upper-left", CURL_EDGE_UPPER_LEFT, _("Upper left"), NULL,
|
|
"upper-right", CURL_EDGE_UPPER_RIGHT, _("Upper right"), NULL,
|
|
"lower-left", CURL_EDGE_LOWER_LEFT, _("Lower left"), NULL,
|
|
"lower-right", CURL_EDGE_LOWER_RIGHT, _("Lower right"), NULL,
|
|
NULL),
|
|
"lower-right",
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_CHOICE (procedure, "orientation",
|
|
_("Or_ientation"), NULL,
|
|
pika_choice_new_with_values ("vertical", CURL_ORIENTATION_VERTICAL, _("Vertical"), NULL,
|
|
"horizontal", CURL_ORIENTATION_HORIZONTAL, _("Horizontal"), NULL,
|
|
NULL),
|
|
"vertical",
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_BOOLEAN (procedure, "shade",
|
|
_("Sh_ade"),
|
|
_("Shade the region under the curl"),
|
|
TRUE,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DOUBLE (procedure, "opacity",
|
|
_("Opaci_ty"),
|
|
_("Opacity"),
|
|
0.0, 1.0, 0.0,
|
|
PIKA_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_VAL_LAYER (procedure, "curl-layer",
|
|
"Curl layer",
|
|
"The new layer with the curl.",
|
|
FALSE,
|
|
G_PARAM_READWRITE);
|
|
}
|
|
|
|
return procedure;
|
|
}
|
|
|
|
static PikaValueArray *
|
|
pagecurl_run (PikaProcedure *procedure,
|
|
PikaRunMode run_mode,
|
|
PikaImage *_image,
|
|
gint n_drawables,
|
|
PikaDrawable **drawables,
|
|
PikaProcedureConfig *config,
|
|
gpointer run_data)
|
|
{
|
|
PikaDrawable *drawable;
|
|
PikaValueArray *return_vals = NULL;
|
|
|
|
gegl_init (NULL, NULL);
|
|
|
|
image = _image;
|
|
|
|
if (n_drawables != 1)
|
|
{
|
|
GError *error = NULL;
|
|
|
|
g_set_error (&error, PIKA_PLUG_IN_ERROR, 0,
|
|
_("Procedure '%s' only works with one drawable."),
|
|
pika_procedure_get_name (procedure));
|
|
|
|
return pika_procedure_new_return_values (procedure,
|
|
PIKA_PDB_CALLING_ERROR,
|
|
error);
|
|
}
|
|
else
|
|
{
|
|
drawable = drawables[0];
|
|
}
|
|
|
|
if (! pika_drawable_mask_intersect (drawable, &sel_x, &sel_y,
|
|
&true_sel_width, &true_sel_height))
|
|
{
|
|
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS,
|
|
NULL);
|
|
}
|
|
|
|
if (! (pika_drawable_is_rgb (drawable) ||
|
|
pika_drawable_is_gray (drawable)))
|
|
{
|
|
/* Sorry - no indexed/noalpha images */
|
|
return pika_procedure_new_return_values (procedure,
|
|
PIKA_PDB_EXECUTION_ERROR,
|
|
NULL);
|
|
}
|
|
|
|
if (run_mode == PIKA_RUN_INTERACTIVE && ! dialog (procedure, config))
|
|
return pika_procedure_new_return_values (procedure,
|
|
PIKA_PDB_CANCEL,
|
|
NULL);
|
|
|
|
return_vals = pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS,
|
|
NULL);
|
|
|
|
PIKA_VALUES_SET_LAYER (return_vals, 1, page_curl (drawable, config));
|
|
|
|
if (run_mode != PIKA_RUN_NONINTERACTIVE)
|
|
pika_displays_flush ();
|
|
|
|
return return_vals;
|
|
}
|
|
|
|
/*****************************************************
|
|
* Functions to locate the current point in the curl.
|
|
* The following functions assume an curl in the
|
|
* lower right corner.
|
|
* diagb crosses the two tangential points from the
|
|
* circle with diagl and diagr.
|
|
*
|
|
* +------------------------------------------------+
|
|
* | __-- /|
|
|
* | __-- _/ |
|
|
* | __-- / |
|
|
* | __-- _/ |
|
|
* | __-- / |
|
|
* | __--____ _/ |
|
|
* | __----~~ \ _/ |
|
|
* | __-- | _/ |
|
|
* | diagl __-- _/| _/diagr |
|
|
* | __-- diagm_/ |/ |
|
|
* | __-- /___/ |
|
|
* +-------------------------+----------------------+
|
|
*/
|
|
|
|
static inline gboolean
|
|
left_of_diagl (gdouble x,
|
|
gdouble y)
|
|
{
|
|
return (x < (sel_width + (y - sel_height) * diagl_slope));
|
|
}
|
|
|
|
static inline gboolean
|
|
right_of_diagr (gdouble x,
|
|
gdouble y)
|
|
{
|
|
return (x > (sel_width + (y - sel_height) * diagr_slope));
|
|
}
|
|
|
|
static inline gboolean
|
|
below_diagb (gdouble x,
|
|
gdouble y)
|
|
{
|
|
return (y < (right_tangent.y + (x - right_tangent.x) * diagb_slope));
|
|
}
|
|
|
|
static inline gboolean
|
|
right_of_diagm (gdouble x,
|
|
gdouble y)
|
|
{
|
|
return (x > (sel_width + (y - sel_height) * diagm_slope));
|
|
}
|
|
|
|
static inline gboolean
|
|
inside_circle (gdouble x,
|
|
gdouble y)
|
|
{
|
|
x -= center.x;
|
|
y -= center.y;
|
|
|
|
return x * x + y * y <= radius * radius;
|
|
}
|
|
|
|
|
|
/********************************************************************/
|
|
/* dialog callbacks */
|
|
/********************************************************************/
|
|
|
|
static void
|
|
curl_pixbuf_update (PikaProcedureConfig *config,
|
|
const GParamSpec *pspec,
|
|
GtkWidget *curl_image)
|
|
{
|
|
GdkPixbuf *pixbuf;
|
|
gint index;
|
|
gchar *resource;
|
|
CurlEdge edge;
|
|
CurlOrientation orientation;
|
|
|
|
edge = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "edge");
|
|
switch (edge)
|
|
{
|
|
case CURL_EDGE_LOWER_RIGHT: index = 0; break;
|
|
case CURL_EDGE_LOWER_LEFT: index = 1; break;
|
|
case CURL_EDGE_UPPER_RIGHT: index = 2; break;
|
|
case CURL_EDGE_UPPER_LEFT: index = 3; break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
orientation = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "orientation");
|
|
index += orientation * 4;
|
|
|
|
resource = g_strdup_printf ("/technology.heckin/pagecurl-icons/curl%c.png",
|
|
'0' + index);
|
|
pixbuf = gdk_pixbuf_new_from_resource (resource, NULL);
|
|
g_free (resource);
|
|
|
|
gtk_image_set_from_pixbuf (GTK_IMAGE (curl_image), pixbuf);
|
|
g_object_unref (pixbuf);
|
|
}
|
|
|
|
static gboolean
|
|
dialog (PikaProcedure *procedure,
|
|
PikaProcedureConfig *config)
|
|
{
|
|
/* Missing options: Color-dialogs? / own curl layer ? / transparency
|
|
to original drawable / Warp-curl (unsupported yet) */
|
|
GtkWidget *dialog;
|
|
GtkWidget *curl_image;
|
|
gboolean run;
|
|
|
|
pika_ui_init (PLUG_IN_BINARY);
|
|
|
|
dialog = pika_procedure_dialog_new (procedure,
|
|
PIKA_PROCEDURE_CONFIG (config),
|
|
_("Pagecurl Effect"));
|
|
|
|
pika_procedure_dialog_get_spin_scale (PIKA_PROCEDURE_DIALOG (dialog), "opacity", 100.0);
|
|
pika_procedure_dialog_fill (PIKA_PROCEDURE_DIALOG (dialog),
|
|
"edge", "orientation", "shade", "colors", "opacity", NULL);
|
|
|
|
curl_image = gtk_image_new ();
|
|
|
|
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
|
|
curl_image, FALSE, FALSE, 0);
|
|
gtk_widget_show (curl_image);
|
|
|
|
g_signal_connect (config, "notify",
|
|
G_CALLBACK (curl_pixbuf_update),
|
|
curl_image);
|
|
curl_pixbuf_update (config, NULL, curl_image);
|
|
|
|
run = pika_procedure_dialog_run (PIKA_PROCEDURE_DIALOG (dialog));
|
|
|
|
gtk_widget_destroy (dialog);
|
|
|
|
return run;
|
|
}
|
|
|
|
static void
|
|
init_calculation (PikaDrawable *drawable,
|
|
PikaProcedureConfig *config)
|
|
{
|
|
gdouble k;
|
|
gdouble alpha, beta;
|
|
gdouble angle;
|
|
PikaVector2 v1, v2;
|
|
GList *layers;
|
|
CurlOrientation orientation;
|
|
|
|
orientation = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "orientation");
|
|
|
|
pika_layer_add_alpha (PIKA_LAYER (drawable));
|
|
|
|
/* Image parameters */
|
|
|
|
/* Determine Position of original Layer in the Layer stack. */
|
|
layers = pika_image_list_layers (image);
|
|
drawable_position = g_list_index (layers, drawable);
|
|
g_list_free (layers);
|
|
|
|
switch (orientation)
|
|
{
|
|
case CURL_ORIENTATION_VERTICAL:
|
|
sel_width = true_sel_width;
|
|
sel_height = true_sel_height;
|
|
break;
|
|
|
|
case CURL_ORIENTATION_HORIZONTAL:
|
|
sel_width = true_sel_height;
|
|
sel_height = true_sel_width;
|
|
break;
|
|
}
|
|
|
|
/* Circle parameters */
|
|
|
|
alpha = atan ((double) sel_height / sel_width);
|
|
beta = alpha / 2.0;
|
|
k = sel_width / ((G_PI + alpha) * sin (beta) + cos (beta));
|
|
pika_vector2_set (¢er, k * cos (beta), k * sin (beta));
|
|
radius = center.y;
|
|
|
|
/* left_tangent */
|
|
|
|
pika_vector2_set (&left_tangent, radius * -sin (alpha), radius * cos (alpha));
|
|
pika_vector2_add (&left_tangent, &left_tangent, ¢er);
|
|
|
|
/* right_tangent */
|
|
|
|
pika_vector2_sub (&v1, &left_tangent, ¢er);
|
|
pika_vector2_set (&v2, sel_width - center.x, sel_height - center.y);
|
|
angle = -2.0 * acos (pika_vector2_inner_product (&v1, &v2) /
|
|
(pika_vector2_length (&v1) *
|
|
pika_vector2_length (&v2)));
|
|
pika_vector2_set (&right_tangent,
|
|
v1.x * cos (angle) + v1.y * -sin (angle),
|
|
v1.x * sin (angle) + v1.y * cos (angle));
|
|
pika_vector2_add (&right_tangent, &right_tangent, ¢er);
|
|
|
|
/* Slopes */
|
|
|
|
diagl_slope = (double) sel_width / sel_height;
|
|
diagr_slope = (sel_width - right_tangent.x) / (sel_height - right_tangent.y);
|
|
diagb_slope = ((right_tangent.y - left_tangent.y) /
|
|
(right_tangent.x - left_tangent.x));
|
|
diagm_slope = (sel_width - center.x) / sel_height;
|
|
|
|
/* Colors */
|
|
|
|
pika_context_get_foreground (&fg_color);
|
|
pika_context_get_background (&bg_color);
|
|
}
|
|
|
|
static PikaLayer *
|
|
do_curl_effect (PikaDrawable *drawable,
|
|
PikaProcedureConfig *config)
|
|
{
|
|
gint x = 0;
|
|
gint y = 0;
|
|
gboolean color_image;
|
|
gint x1, y1;
|
|
guint progress, max_progress;
|
|
gdouble intensity, alpha;
|
|
PikaVector2 v, dl, dr;
|
|
gdouble dl_mag, dr_mag, angle, factor;
|
|
GeglBuffer *curl_buffer;
|
|
PikaLayer *curl_layer;
|
|
PikaRGB *grad_samples = NULL;
|
|
gint width, height, n_ch;
|
|
GeglRectangle *roi;
|
|
GeglBufferIterator *iter;
|
|
const Babl *format;
|
|
CurlOrientation orientation;
|
|
CurlColors colors;
|
|
CurlEdge edge;
|
|
gboolean shade;
|
|
gdouble opacity;
|
|
|
|
orientation = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "orientation");
|
|
colors = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "colors");
|
|
edge = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "edge");
|
|
|
|
g_object_get (config,
|
|
"shade", &shade,
|
|
"opacity", &opacity,
|
|
NULL);
|
|
|
|
color_image = pika_drawable_is_rgb (drawable);
|
|
|
|
curl_layer = pika_layer_new (image,
|
|
_("Curl Layer"),
|
|
true_sel_width,
|
|
true_sel_height,
|
|
color_image ?
|
|
PIKA_RGBA_IMAGE : PIKA_GRAYA_IMAGE,
|
|
100,
|
|
pika_image_get_default_new_layer_mode (image));
|
|
|
|
pika_image_insert_layer (image, curl_layer,
|
|
PIKA_LAYER (pika_item_get_parent (PIKA_ITEM (drawable))),
|
|
drawable_position);
|
|
pika_drawable_fill (PIKA_DRAWABLE (curl_layer), PIKA_FILL_TRANSPARENT);
|
|
|
|
pika_drawable_get_offsets (drawable, &x1, &y1);
|
|
pika_layer_set_offsets (curl_layer, sel_x + x1, sel_y + y1);
|
|
|
|
curl_buffer = pika_drawable_get_shadow_buffer (PIKA_DRAWABLE (curl_layer));
|
|
|
|
width = gegl_buffer_get_width (curl_buffer);
|
|
height = gegl_buffer_get_height (curl_buffer);
|
|
format = babl_format ("R'G'B'A float");
|
|
n_ch = babl_format_get_n_components (format);
|
|
|
|
iter = gegl_buffer_iterator_new (curl_buffer,
|
|
GEGL_RECTANGLE (0, 0, width, height), 0,
|
|
format,
|
|
GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 1);
|
|
|
|
/* Init shade_under */
|
|
pika_vector2_set (&dl, -sel_width, -sel_height);
|
|
dl_mag = pika_vector2_length (&dl);
|
|
pika_vector2_set (&dr,
|
|
-(sel_width - right_tangent.x),
|
|
-(sel_height - right_tangent.y));
|
|
dr_mag = pika_vector2_length (&dr);
|
|
alpha = acos (pika_vector2_inner_product (&dl, &dr) / (dl_mag * dr_mag));
|
|
|
|
/* Gradient Samples */
|
|
switch (colors)
|
|
{
|
|
case CURL_COLORS_FG_BG:
|
|
break;
|
|
case CURL_COLORS_GRADIENT:
|
|
grad_samples = get_gradient_samples (PIKA_DRAWABLE (curl_layer), FALSE);
|
|
break;
|
|
case CURL_COLORS_GRADIENT_REVERSE:
|
|
grad_samples = get_gradient_samples (PIKA_DRAWABLE (curl_layer), TRUE);
|
|
break;
|
|
}
|
|
|
|
max_progress = 2 * sel_width * sel_height;
|
|
progress = 0;
|
|
|
|
/* Main loop */
|
|
while (gegl_buffer_iterator_next (iter))
|
|
{
|
|
gfloat *dest;
|
|
|
|
roi = &iter->items[0].roi;
|
|
dest = (gfloat *) iter->items[0].data;
|
|
|
|
for (y1 = roi->y; y1 < roi->y + roi->height; y1++)
|
|
{
|
|
PikaRGB color;
|
|
|
|
for (x1 = roi->x; x1 < roi->x + roi->width; x1++)
|
|
{
|
|
/* Map coordinates to get the curl correct... */
|
|
switch (orientation)
|
|
{
|
|
case CURL_ORIENTATION_VERTICAL:
|
|
x = CURL_EDGE_RIGHT (edge) ? x1 : sel_width - 1 - x1;
|
|
y = CURL_EDGE_UPPER (edge) ? y1 : sel_height - 1 - y1;
|
|
break;
|
|
|
|
case CURL_ORIENTATION_HORIZONTAL:
|
|
x = CURL_EDGE_LOWER (edge) ? y1 : sel_width - 1 - y1;
|
|
y = CURL_EDGE_LEFT (edge) ? x1 : sel_height - 1 - x1;
|
|
break;
|
|
}
|
|
|
|
if (left_of_diagl (x, y))
|
|
{ /* uncurled region: transparent black */
|
|
pika_rgba_set (&color, 0, 0, 0, 0);
|
|
}
|
|
else if (right_of_diagr (x, y) ||
|
|
(right_of_diagm (x, y) &&
|
|
below_diagb (x, y) &&
|
|
!inside_circle (x, y)))
|
|
{
|
|
/* curled region: transparent black */
|
|
pika_rgba_set (&color, 0, 0, 0, 0);
|
|
}
|
|
else
|
|
{
|
|
v.x = -(sel_width - x);
|
|
v.y = -(sel_height - y);
|
|
angle = acos (pika_vector2_inner_product (&v, &dl) /
|
|
(pika_vector2_length (&v) * dl_mag));
|
|
|
|
if (inside_circle (x, y) || below_diagb (x, y))
|
|
{
|
|
/* Below the curl. */
|
|
factor = angle / alpha;
|
|
pika_rgba_set (&color, 0, 0, 0, shade ? factor : 0);
|
|
}
|
|
else
|
|
{
|
|
PikaRGB *gradrgb;
|
|
|
|
/* On the curl */
|
|
switch (colors)
|
|
{
|
|
case CURL_COLORS_FG_BG:
|
|
intensity = pow (sin (G_PI * angle / alpha), 1.5);
|
|
pika_rgba_set (&color,
|
|
intensity * bg_color.r + (1.0 - intensity) * fg_color.r,
|
|
intensity * bg_color.g + (1.0 - intensity) * fg_color.g,
|
|
intensity * bg_color.b + (1.0 - intensity) * fg_color.b,
|
|
(1.0 - intensity * (1.0 - opacity)));
|
|
break;
|
|
|
|
case CURL_COLORS_GRADIENT:
|
|
case CURL_COLORS_GRADIENT_REVERSE:
|
|
/* Calculate position in Gradient */
|
|
intensity = (angle/alpha) + sin (G_PI*2 * angle/alpha) * 0.075;
|
|
|
|
gradrgb = grad_samples + ((guint) (intensity * NGRADSAMPLES));
|
|
|
|
/* Check boundaries */
|
|
intensity = CLAMP (intensity, 0.0, 1.0);
|
|
color = *gradrgb;
|
|
color.a = gradrgb->a * (1.0 - intensity * (1.0 - opacity));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
dest[0] = color.r;
|
|
dest[1] = color.g;
|
|
dest[2] = color.b;
|
|
dest[3] = color.a;
|
|
|
|
dest += n_ch;
|
|
}
|
|
}
|
|
progress += roi->width * roi->height;
|
|
pika_progress_update ((double) progress / (double) max_progress);
|
|
}
|
|
|
|
pika_progress_update (0.5);
|
|
gegl_buffer_flush (curl_buffer);
|
|
pika_drawable_merge_shadow (PIKA_DRAWABLE (curl_layer), FALSE);
|
|
pika_drawable_update (PIKA_DRAWABLE (curl_layer), 0, 0, width, height);
|
|
|
|
g_free (grad_samples);
|
|
|
|
return curl_layer;
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
static void
|
|
clear_curled_region (PikaDrawable *drawable,
|
|
PikaProcedureConfig *config)
|
|
{
|
|
gint x = 0;
|
|
gint y = 0;
|
|
guint x1, y1;
|
|
gfloat *dest, *src;
|
|
guint progress, max_progress;
|
|
GeglBuffer *buf;
|
|
GeglBuffer *shadow_buf;
|
|
GeglRectangle *roi;
|
|
GeglBufferIterator *iter;
|
|
const Babl *format;
|
|
gint width, height, bpp, n_ch;
|
|
gint buf_index;
|
|
CurlOrientation orientation;
|
|
CurlEdge edge;
|
|
|
|
orientation = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "orientation");
|
|
edge = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "edge");
|
|
|
|
max_progress = 2 * sel_width * sel_height;
|
|
progress = max_progress / 2;
|
|
|
|
buf = pika_drawable_get_buffer (drawable);
|
|
shadow_buf = pika_drawable_get_shadow_buffer (drawable);
|
|
width = gegl_buffer_get_width (buf);
|
|
height = gegl_buffer_get_height (buf);
|
|
|
|
format = babl_format ("R'G'B'A float");
|
|
bpp = babl_format_get_bytes_per_pixel (format);
|
|
n_ch = babl_format_get_n_components (format);
|
|
|
|
iter = gegl_buffer_iterator_new (shadow_buf,
|
|
GEGL_RECTANGLE (0, 0, width, height), 0,
|
|
format,
|
|
GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 2);
|
|
buf_index = gegl_buffer_iterator_add (iter, buf, NULL, 0,
|
|
format,
|
|
GEGL_ACCESS_READ, GEGL_ABYSS_NONE);
|
|
|
|
while (gegl_buffer_iterator_next (iter))
|
|
{
|
|
roi = &iter->items[0].roi;
|
|
dest = iter->items[0].data;
|
|
src = iter->items[buf_index].data;
|
|
|
|
memcpy (dest, src, roi->width * roi->height * bpp);
|
|
|
|
for (y1 = roi->y; y1 < roi->y + roi->height; y1++)
|
|
{
|
|
for (x1 = roi->x; x1 < roi->x + roi->width; x1++)
|
|
{
|
|
/* Map coordinates to get the curl correct... */
|
|
switch (orientation)
|
|
{
|
|
case CURL_ORIENTATION_VERTICAL:
|
|
x = (CURL_EDGE_RIGHT (edge) ?
|
|
x1 - sel_x : sel_width - 1 - (x1 - sel_x));
|
|
y = (CURL_EDGE_UPPER (edge) ?
|
|
y1 - sel_y : sel_height - 1 - (y1 - sel_y));
|
|
break;
|
|
|
|
case CURL_ORIENTATION_HORIZONTAL:
|
|
x = (CURL_EDGE_LOWER (edge) ?
|
|
y1 - sel_y : sel_width - 1 - (y1 - sel_y));
|
|
y = (CURL_EDGE_LEFT (edge) ?
|
|
x1 - sel_x : sel_height - 1 - (x1 - sel_x));
|
|
break;
|
|
}
|
|
|
|
if (right_of_diagr (x, y) ||
|
|
(right_of_diagm (x, y) &&
|
|
below_diagb (x, y) &&
|
|
!inside_circle (x, y)))
|
|
{
|
|
/* Right of the curl: Alpha = 0 */
|
|
dest[0] = src[0];
|
|
dest[1] = src[1];
|
|
dest[2] = src[2];
|
|
dest[3] = 0.0;
|
|
}
|
|
|
|
dest += n_ch;
|
|
src += n_ch;
|
|
}
|
|
}
|
|
|
|
progress += roi->width * roi->height;
|
|
pika_progress_update ((double) progress / (double) max_progress);
|
|
}
|
|
|
|
pika_progress_update (1.0);
|
|
gegl_buffer_flush (shadow_buf);
|
|
pika_drawable_merge_shadow (drawable, TRUE);
|
|
pika_drawable_update (drawable,
|
|
sel_x, sel_y,
|
|
true_sel_width, true_sel_height);
|
|
}
|
|
|
|
static PikaLayer *
|
|
page_curl (PikaDrawable *drawable,
|
|
PikaProcedureConfig *config)
|
|
{
|
|
PikaLayer *curl_layer;
|
|
|
|
pika_image_undo_group_start (image);
|
|
|
|
pika_progress_init (_("Page Curl"));
|
|
|
|
init_calculation (drawable, config);
|
|
|
|
curl_layer = do_curl_effect (drawable, config);
|
|
|
|
clear_curled_region (drawable, config);
|
|
|
|
pika_image_undo_group_end (image);
|
|
|
|
return curl_layer;
|
|
}
|
|
|
|
/*
|
|
Returns NGRADSAMPLES samples of active gradient.
|
|
Each sample has (pika_drawable_get_bpp (drawable)) bytes.
|
|
"ripped" from gradmap.c.
|
|
*/
|
|
static PikaRGB *
|
|
get_gradient_samples (PikaDrawable *drawable,
|
|
gboolean reverse)
|
|
{
|
|
PikaGradient *gradient;
|
|
|
|
gint n_d_samples;
|
|
gdouble *d_samples = NULL;
|
|
PikaRGB *rgba;
|
|
gint i;
|
|
|
|
gradient = pika_context_get_gradient ();
|
|
|
|
pika_gradient_get_uniform_samples (gradient, NGRADSAMPLES, reverse,
|
|
&n_d_samples, &d_samples);
|
|
|
|
rgba = g_new0 (PikaRGB, NGRADSAMPLES);
|
|
for (i = 0; i < NGRADSAMPLES; i++)
|
|
{
|
|
pika_rgba_set (rgba + i,
|
|
d_samples[i*4 + 0],
|
|
d_samples[i*4 + 1],
|
|
d_samples[i*4 + 2],
|
|
d_samples[i*4 + 3]);
|
|
}
|
|
|
|
return rgba;
|
|
}
|
