1975 lines
69 KiB
C
1975 lines
69 KiB
C
/* Warp --- image filter plug-in for PIKA
|
|
* Copyright (C) 1997 John P. Beale
|
|
* Much of the 'warp' is from the Displace plug-in: 1996 Stephen Robert Norris
|
|
* Much of the 'displace' code taken in turn from the pinch plug-in
|
|
* which is by 1996 Federico Mena Quintero
|
|
*
|
|
* 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/>.
|
|
*
|
|
* You can contact me (the warp author) at beale@best.com
|
|
* Please send me any patches or enhancements to this code.
|
|
* You can contact the original PIKA authors at pika@xcf.berkeley.edu
|
|
*
|
|
* --------------------------------------------------------------------
|
|
* Warp Program structure: after running the user interface and setting the
|
|
* parameters, warp generates a brand-new image (later to be deleted
|
|
* before the user ever sees it) which contains two grayscale layers,
|
|
* representing the X and Y gradients of the "control" image. For this
|
|
* purpose, all channels of the control image are summed for a scalar
|
|
* value at each pixel coordinate for the gradient operation.
|
|
*
|
|
* The X,Y components of the calculated gradient are then used to
|
|
* displace pixels from the source image into the destination
|
|
* image. The displacement vector is rotated a user-specified amount
|
|
* first. This displacement operation happens iteratively, generating
|
|
* a new displaced image from each prior image.
|
|
* -------------------------------------------------------------------
|
|
*
|
|
* Revision History:
|
|
* Version 0.37 12/19/98 Fixed Tooltips and freeing memory
|
|
* Version 0.36 11/9/97 Changed XY vector layers back to own image
|
|
* fixed 'undo' problem (hopefully)
|
|
*
|
|
* Version 0.35 11/3/97 Added vector-map, mag-map, grad-map to
|
|
* diff vector instead of separate operation
|
|
* further futzing with drawable updates
|
|
* starting adding tooltips
|
|
*
|
|
* Version 0.34 10/30/97 'Fixed' drawable update problem
|
|
* Added 16-bit resolution to differential map
|
|
* Added substep increments for finer control
|
|
*
|
|
* Version 0.33 10/26/97 Added 'angle increment' to user interface
|
|
*
|
|
* Version 0.32 10/25/97 Added magnitude control map (secondary control)
|
|
* Changed undo behavior to be one undo-step per warp call.
|
|
*
|
|
* Version 0.31 10/25/97 Fixed src/dest pixregions so program works
|
|
* with multiple-layer images. Still don't know
|
|
* exactly what I did to fix it :-/ Also, added 'color' option
|
|
* for border pixels to use the current selected foreground color.
|
|
*
|
|
* Version 0.3 10/20/97 Initial release for Pika 0.99.xx
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <libpika/pika.h>
|
|
#include <libpika/pikaui.h>
|
|
|
|
#include "libpika/stdplugins-intl.h"
|
|
|
|
|
|
/* Some useful macros */
|
|
|
|
#define PLUG_IN_PROC "plug-in-warp"
|
|
#define PLUG_IN_BINARY "warp"
|
|
#define PLUG_IN_ROLE "pika-warp"
|
|
#define ENTRY_WIDTH 75
|
|
#define MIN_ARGS 6 /* minimum number of arguments required */
|
|
|
|
enum
|
|
{
|
|
WRAP,
|
|
SMEAR,
|
|
BLACK,
|
|
COLOR
|
|
};
|
|
|
|
|
|
typedef struct _Warp Warp;
|
|
typedef struct _WarpClass WarpClass;
|
|
|
|
struct _Warp
|
|
{
|
|
PikaPlugIn parent_instance;
|
|
};
|
|
|
|
struct _WarpClass
|
|
{
|
|
PikaPlugInClass parent_class;
|
|
};
|
|
|
|
|
|
#define WARP_TYPE (warp_get_type ())
|
|
#define WARP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WARP_TYPE, Warp))
|
|
|
|
GType warp_get_type (void) G_GNUC_CONST;
|
|
|
|
static GList * warp_query_procedures (PikaPlugIn *plug_in);
|
|
static PikaProcedure * warp_create_procedure (PikaPlugIn *plug_in,
|
|
const gchar *name);
|
|
|
|
static PikaValueArray * warp_run (PikaProcedure *procedure,
|
|
PikaRunMode run_mode,
|
|
PikaImage *image,
|
|
gint n_drawables,
|
|
PikaDrawable **drawables,
|
|
PikaProcedureConfig *config,
|
|
gpointer run_data);
|
|
|
|
static void blur16 (PikaDrawable *drawable);
|
|
|
|
static void diff (PikaDrawable *drawable,
|
|
PikaProcedureConfig *config,
|
|
PikaDrawable **xl,
|
|
PikaDrawable **yl);
|
|
|
|
static void diff_prepare_row (GeglBuffer *buffer,
|
|
const Babl *format,
|
|
guchar *data,
|
|
gint x,
|
|
gint y,
|
|
gint w);
|
|
|
|
static void warp_one (PikaDrawable *draw,
|
|
PikaDrawable *newid,
|
|
PikaDrawable *map_x,
|
|
PikaDrawable *map_y,
|
|
PikaDrawable *mag_draw,
|
|
gboolean first_time,
|
|
gint step,
|
|
PikaProcedureConfig *config);
|
|
|
|
static void warp (PikaDrawable *drawable,
|
|
PikaProcedureConfig *config);
|
|
|
|
static gboolean warp_dialog (PikaDrawable *drawable,
|
|
PikaProcedureConfig *config);
|
|
static void warp_pixel (GeglBuffer *buffer,
|
|
const Babl *format,
|
|
gint width,
|
|
gint height,
|
|
gint x1,
|
|
gint y1,
|
|
gint x2,
|
|
gint y2,
|
|
gint x,
|
|
gint y,
|
|
guchar *pixel,
|
|
PikaProcedureConfig *config);
|
|
|
|
static gboolean warp_map_constrain (PikaImage *image,
|
|
PikaItem *item,
|
|
gpointer data);
|
|
static gdouble warp_map_mag_give_value (guchar *pt,
|
|
gint alpha,
|
|
gint bytes);
|
|
|
|
|
|
G_DEFINE_TYPE (Warp, warp, PIKA_TYPE_PLUG_IN)
|
|
|
|
PIKA_MAIN (WARP_TYPE)
|
|
DEFINE_STD_SET_I18N
|
|
|
|
|
|
static gint progress = 0; /* progress indicator bar */
|
|
static PikaRunMode run_mode; /* interactive, non-, etc. */
|
|
static guchar color_pixel[4] = {0, 0, 0, 255}; /* current fg color */
|
|
|
|
|
|
static void
|
|
warp_class_init (WarpClass *klass)
|
|
{
|
|
PikaPlugInClass *plug_in_class = PIKA_PLUG_IN_CLASS (klass);
|
|
|
|
plug_in_class->query_procedures = warp_query_procedures;
|
|
plug_in_class->create_procedure = warp_create_procedure;
|
|
plug_in_class->set_i18n = STD_SET_I18N;
|
|
}
|
|
|
|
static void
|
|
warp_init (Warp *warp)
|
|
{
|
|
}
|
|
|
|
static GList *
|
|
warp_query_procedures (PikaPlugIn *plug_in)
|
|
{
|
|
return g_list_append (NULL, g_strdup (PLUG_IN_PROC));
|
|
}
|
|
|
|
static PikaProcedure *
|
|
warp_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,
|
|
warp_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, _("_Warp..."));
|
|
pika_procedure_add_menu_path (procedure, "<Image>/Filters/Map");
|
|
|
|
pika_procedure_set_documentation (procedure,
|
|
_("Twist or smear image in many "
|
|
"different ways"),
|
|
"Smears an image along vector paths "
|
|
"calculated as the gradient of a "
|
|
"separate control matrix. The effect "
|
|
"can look like brushstrokes of acrylic "
|
|
"or watercolor paint, in some cases.",
|
|
name);
|
|
pika_procedure_set_attribution (procedure,
|
|
"John P. Beale",
|
|
"John P. Beale",
|
|
"1997");
|
|
|
|
PIKA_PROC_ARG_DOUBLE (procedure, "amount",
|
|
"Amount",
|
|
"Pixel displacement multiplier",
|
|
-G_MAXDOUBLE, G_MAXDOUBLE, 10.0,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DRAWABLE (procedure, "warp-map",
|
|
"Warp map",
|
|
"Displacement control map",
|
|
TRUE,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_INT (procedure, "iter",
|
|
"Iter",
|
|
"Iteration count",
|
|
1, 100, 5,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DOUBLE (procedure, "dither",
|
|
"Dither",
|
|
"Random dither amount",
|
|
0, 100, 0.0,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DOUBLE (procedure, "angle",
|
|
"Angle",
|
|
"Angle of gradient vector rotation",
|
|
0, 360, 90.0,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_INT (procedure, "wrap-type",
|
|
"Wrap type",
|
|
"Edge behavior: { WRAP (0), SMEAR (1), BLACK (2), "
|
|
"COLOR (3) }",
|
|
0, 3, WRAP,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DRAWABLE (procedure, "mag-map",
|
|
"Mag map",
|
|
"Magnitude control map",
|
|
TRUE,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_BOOLEAN (procedure, "mag-use",
|
|
"Mag use",
|
|
"Use magnitude map",
|
|
FALSE,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_INT (procedure, "substeps",
|
|
"Substeps",
|
|
"Substeps between image updates",
|
|
1, 100, 1,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DRAWABLE (procedure, "grad-map",
|
|
"Grad map",
|
|
"Gradient control map",
|
|
TRUE,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DOUBLE (procedure, "grad-scale",
|
|
"Grad scale",
|
|
"Scaling factor for gradient map (0=don't use)",
|
|
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DRAWABLE (procedure, "vector-map",
|
|
"Vector map",
|
|
"Fixed vector control map",
|
|
TRUE,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DOUBLE (procedure, "vector-scale",
|
|
"Vector scale",
|
|
"Scaling factor for fixed vector map (0=don't use)",
|
|
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DOUBLE (procedure, "vector-angle",
|
|
"Vector angle",
|
|
"Angle for fixed vector map",
|
|
0, 360, 0.0,
|
|
G_PARAM_READWRITE);
|
|
}
|
|
|
|
return procedure;
|
|
}
|
|
|
|
static PikaValueArray *
|
|
warp_run (PikaProcedure *procedure,
|
|
PikaRunMode _run_mode,
|
|
PikaImage *image,
|
|
gint n_drawables,
|
|
PikaDrawable **drawables,
|
|
PikaProcedureConfig *config,
|
|
gpointer run_data)
|
|
{
|
|
PikaDrawable *drawable;
|
|
PikaRGB color;
|
|
|
|
gegl_init (NULL, NULL);
|
|
|
|
if (n_drawables != 1)
|
|
{
|
|
GError *error = NULL;
|
|
|
|
g_set_error (&error, PIKA_PLUG_IN_ERROR, 0,
|
|
_("Procedure '%s' only works with one drawable."),
|
|
PLUG_IN_PROC);
|
|
|
|
return pika_procedure_new_return_values (procedure,
|
|
PIKA_PDB_CALLING_ERROR,
|
|
error);
|
|
}
|
|
else
|
|
{
|
|
drawable = drawables[0];
|
|
}
|
|
|
|
/* get currently selected foreground pixel color */
|
|
pika_context_get_foreground (&color);
|
|
pika_rgb_get_uchar (&color,
|
|
&color_pixel[0],
|
|
&color_pixel[1],
|
|
&color_pixel[2]);
|
|
|
|
run_mode = _run_mode;
|
|
|
|
if (run_mode == PIKA_RUN_INTERACTIVE && ! warp_dialog (drawable, config))
|
|
return pika_procedure_new_return_values (procedure,
|
|
PIKA_PDB_CANCEL,
|
|
NULL);
|
|
|
|
warp (drawable, config);
|
|
|
|
if (run_mode != PIKA_RUN_NONINTERACTIVE)
|
|
pika_displays_flush ();
|
|
|
|
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
|
|
}
|
|
|
|
static GtkWidget *
|
|
spin_button_new (GtkAdjustment **adjustment, /* return value */
|
|
gdouble value,
|
|
gdouble lower,
|
|
gdouble upper,
|
|
gdouble step_increment,
|
|
gdouble page_increment,
|
|
gdouble page_size,
|
|
gdouble climb_rate,
|
|
guint digits)
|
|
{
|
|
GtkWidget *spinbutton;
|
|
|
|
*adjustment = gtk_adjustment_new (value, lower, upper,
|
|
step_increment, page_increment, 0);
|
|
|
|
spinbutton = pika_spin_button_new (*adjustment,
|
|
climb_rate, digits);
|
|
|
|
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
|
|
|
|
return spinbutton;
|
|
}
|
|
|
|
static gboolean
|
|
warp_dialog (PikaDrawable *drawable,
|
|
PikaProcedureConfig *config)
|
|
{
|
|
GtkWidget *dlg;
|
|
GtkWidget *vbox;
|
|
GtkWidget *label;
|
|
GtkWidget *toggle;
|
|
GtkWidget *toggle_hbox;
|
|
GtkWidget *frame;
|
|
GtkWidget *grid;
|
|
GtkWidget *spinbutton;
|
|
GtkAdjustment *adj;
|
|
GtkWidget *combo;
|
|
GtkSizeGroup *label_group;
|
|
GtkSizeGroup *spin_group;
|
|
GSList *group = NULL;
|
|
gboolean run;
|
|
|
|
PikaDrawable *warp_map;
|
|
PikaDrawable *mag_map;
|
|
PikaDrawable *grad_map;
|
|
PikaDrawable *vector_map;
|
|
gdouble amount;
|
|
gdouble dither;
|
|
gdouble angle;
|
|
gdouble grad_scale;
|
|
gdouble vector_scale;
|
|
gdouble vector_angle;
|
|
gboolean use_mag;
|
|
gint substeps;
|
|
gint iter_count;
|
|
gint wrap_type;
|
|
|
|
gint32 warp_map_id;
|
|
gint32 mag_map_id;
|
|
gint32 grad_map_id;
|
|
gint32 vector_map_id;
|
|
|
|
pika_ui_init (PLUG_IN_BINARY);
|
|
|
|
g_object_get (config,
|
|
"amount", &amount,
|
|
"warp-map", &warp_map,
|
|
"iter", &iter_count,
|
|
"dither", &dither,
|
|
"angle", &angle,
|
|
"wrap-type", &wrap_type,
|
|
"mag-map", &mag_map,
|
|
"mag-use", &use_mag,
|
|
"substeps", &substeps,
|
|
"grad-map", &grad_map,
|
|
"grad-scale", &grad_scale,
|
|
"vector-map", &vector_map,
|
|
"vector-scale", &vector_scale,
|
|
"vector-angle", &vector_angle,
|
|
NULL);
|
|
warp_map_id = pika_item_get_id (PIKA_ITEM (warp_map));
|
|
mag_map_id = pika_item_get_id (PIKA_ITEM (mag_map));
|
|
grad_map_id = pika_item_get_id (PIKA_ITEM (grad_map));
|
|
vector_map_id = pika_item_get_id (PIKA_ITEM (vector_map));
|
|
g_clear_object (&warp_map);
|
|
g_clear_object (&mag_map);
|
|
g_clear_object (&grad_map);
|
|
g_clear_object (&vector_map);
|
|
|
|
dlg = pika_dialog_new (_("Warp"), PLUG_IN_ROLE,
|
|
NULL, 0,
|
|
pika_standard_help_func, PLUG_IN_PROC,
|
|
|
|
_("_Cancel"), GTK_RESPONSE_CANCEL,
|
|
_("_OK"), GTK_RESPONSE_OK,
|
|
|
|
NULL);
|
|
|
|
pika_dialog_set_alternative_button_order (GTK_DIALOG (dlg),
|
|
GTK_RESPONSE_OK,
|
|
GTK_RESPONSE_CANCEL,
|
|
-1);
|
|
|
|
pika_window_set_transient (GTK_WINDOW (dlg));
|
|
|
|
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
|
|
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
|
|
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))),
|
|
vbox, TRUE, TRUE, 0);
|
|
gtk_widget_show (vbox);
|
|
|
|
frame = pika_frame_new (_("Basic Options"));
|
|
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
|
|
gtk_widget_show (frame);
|
|
|
|
grid = gtk_grid_new ();
|
|
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
|
|
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
|
|
gtk_container_add (GTK_CONTAINER (frame), grid);
|
|
gtk_widget_show (grid);
|
|
|
|
spin_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
|
|
label_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
|
|
|
|
/* amount, iter */
|
|
spinbutton = spin_button_new (&adj, amount,
|
|
-1000, 1000, /* ??? */
|
|
1, 10, 0, 1, 2);
|
|
gtk_size_group_add_widget (spin_group, spinbutton);
|
|
g_object_unref (spin_group);
|
|
|
|
label = pika_grid_attach_aligned (GTK_GRID (grid), 0, 0,
|
|
_("Step size:"), 0.0, 0.5,
|
|
spinbutton, 1);
|
|
gtk_size_group_add_widget (label_group, label);
|
|
g_object_unref (label_group);
|
|
|
|
g_signal_connect (adj, "value-changed",
|
|
G_CALLBACK (pika_double_adjustment_update),
|
|
&amount);
|
|
|
|
spinbutton = spin_button_new (&adj, iter_count,
|
|
1, 100, 1, 5, 0, 1, 0);
|
|
gtk_size_group_add_widget (spin_group, spinbutton);
|
|
|
|
label = pika_grid_attach_aligned (GTK_GRID (grid), 0, 1,
|
|
_("Iterations:"), 0.0, 0.5,
|
|
spinbutton, 1);
|
|
gtk_size_group_add_widget (label_group, label);
|
|
|
|
g_signal_connect (adj, "value-changed",
|
|
G_CALLBACK (pika_int_adjustment_update),
|
|
&iter_count);
|
|
|
|
/* Displacement map menu */
|
|
label = gtk_label_new (_("Displacement map:"));
|
|
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
|
|
gtk_label_set_yalign (GTK_LABEL (label), 1.0);
|
|
gtk_widget_set_margin_start (label, 12);
|
|
gtk_grid_attach (GTK_GRID (grid), label, 2, 0, 1, 1);
|
|
// GTK_FILL, GTK_FILL, 0, 0);
|
|
gtk_widget_show (label);
|
|
|
|
combo = pika_drawable_combo_box_new (warp_map_constrain,
|
|
drawable,
|
|
NULL);
|
|
gtk_widget_set_margin_start (combo, 12);
|
|
pika_int_combo_box_connect (PIKA_INT_COMBO_BOX (combo),
|
|
warp_map_id,
|
|
G_CALLBACK (pika_int_combo_box_get_active),
|
|
&warp_map_id, NULL);
|
|
|
|
gtk_grid_attach (GTK_GRID (grid), combo, 2, 1, 1, 1);
|
|
// GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
|
|
gtk_widget_show (combo);
|
|
|
|
/* ======================================================================= */
|
|
|
|
/* Displacement Type */
|
|
label = gtk_label_new (_("On edges:"));
|
|
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
|
|
gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
|
|
// GTK_FILL, GTK_FILL, 0, 0);
|
|
gtk_widget_show (label);
|
|
|
|
toggle_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
|
|
gtk_grid_attach (GTK_GRID (grid), toggle_hbox, 1, 2, 2, 1);
|
|
// GTK_FILL, GTK_FILL, 0, 0);
|
|
gtk_widget_show (toggle_hbox);
|
|
|
|
toggle = gtk_radio_button_new_with_label (group, _("Wrap"));
|
|
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle));
|
|
gtk_box_pack_start (GTK_BOX (toggle_hbox), toggle, FALSE, FALSE, 0);
|
|
gtk_widget_show (toggle);
|
|
|
|
g_object_set_data (G_OBJECT (toggle), "pika-item-data",
|
|
GINT_TO_POINTER (WRAP));
|
|
|
|
g_signal_connect (toggle, "toggled",
|
|
G_CALLBACK (pika_radio_button_update),
|
|
&wrap_type);
|
|
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
|
|
wrap_type == WRAP);
|
|
|
|
toggle = gtk_radio_button_new_with_label (group, _("Smear"));
|
|
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle));
|
|
gtk_box_pack_start (GTK_BOX (toggle_hbox), toggle, FALSE, FALSE, 0);
|
|
gtk_widget_show (toggle);
|
|
|
|
g_object_set_data (G_OBJECT (toggle), "pika-item-data",
|
|
GINT_TO_POINTER (SMEAR));
|
|
|
|
g_signal_connect (toggle, "toggled",
|
|
G_CALLBACK (pika_radio_button_update),
|
|
&wrap_type);
|
|
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
|
|
wrap_type == SMEAR);
|
|
|
|
toggle = gtk_radio_button_new_with_label (group, _("Black"));
|
|
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle));
|
|
gtk_box_pack_start (GTK_BOX (toggle_hbox), toggle, FALSE, FALSE, 0);
|
|
gtk_widget_show (toggle);
|
|
|
|
g_object_set_data (G_OBJECT (toggle), "pika-item-data",
|
|
GINT_TO_POINTER (BLACK));
|
|
|
|
g_signal_connect (toggle, "toggled",
|
|
G_CALLBACK (pika_radio_button_update),
|
|
&wrap_type);
|
|
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
|
|
wrap_type == BLACK);
|
|
|
|
toggle = gtk_radio_button_new_with_label (group, _("Foreground color"));
|
|
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle));
|
|
gtk_box_pack_start (GTK_BOX (toggle_hbox), toggle, FALSE, FALSE, 0);
|
|
gtk_widget_show (toggle);
|
|
|
|
g_object_set_data (G_OBJECT (toggle), "pika-item-data",
|
|
GINT_TO_POINTER (COLOR));
|
|
|
|
g_signal_connect (toggle, "toggled",
|
|
G_CALLBACK (pika_radio_button_update),
|
|
&wrap_type);
|
|
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
|
|
wrap_type == COLOR);
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/* --------- The secondary grid -------------------------- */
|
|
|
|
frame = pika_frame_new (_("Advanced Options"));
|
|
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
|
|
gtk_widget_show (frame);
|
|
|
|
grid = gtk_grid_new ();
|
|
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
|
|
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
|
|
gtk_container_add (GTK_CONTAINER (frame), grid);
|
|
gtk_widget_show (grid);
|
|
|
|
spinbutton = spin_button_new (&adj, dither,
|
|
0, 100, 1, 10, 0, 1, 2);
|
|
gtk_size_group_add_widget (spin_group, spinbutton);
|
|
|
|
label = pika_grid_attach_aligned (GTK_GRID (grid), 0, 0,
|
|
_("Dither size:"), 0.0, 0.5,
|
|
spinbutton, 1);
|
|
gtk_size_group_add_widget (label_group, label);
|
|
|
|
g_signal_connect (adj, "value-changed",
|
|
G_CALLBACK (pika_double_adjustment_update),
|
|
&dither);
|
|
|
|
spinbutton = spin_button_new (&adj, angle,
|
|
0, 360, 1, 15, 0, 1, 1);
|
|
gtk_size_group_add_widget (spin_group, spinbutton);
|
|
|
|
label = pika_grid_attach_aligned (GTK_GRID (grid), 0, 1,
|
|
_("Rotation angle:"), 0.0, 0.5,
|
|
spinbutton, 1);
|
|
gtk_size_group_add_widget (label_group, label);
|
|
|
|
g_signal_connect (adj, "value-changed",
|
|
G_CALLBACK (pika_double_adjustment_update),
|
|
&angle);
|
|
|
|
spinbutton = spin_button_new (&adj, substeps,
|
|
1, 100, 1, 5, 0, 1, 0);
|
|
gtk_size_group_add_widget (spin_group, spinbutton);
|
|
|
|
label = pika_grid_attach_aligned (GTK_GRID (grid), 0, 2,
|
|
_("Substeps:"), 0.0, 0.5,
|
|
spinbutton, 1);
|
|
gtk_size_group_add_widget (label_group, label);
|
|
|
|
g_signal_connect (adj, "value-changed",
|
|
G_CALLBACK (pika_int_adjustment_update),
|
|
&substeps);
|
|
|
|
/* Magnitude map menu */
|
|
label = gtk_label_new (_("Magnitude map:"));
|
|
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
|
|
gtk_label_set_yalign (GTK_LABEL (label), 1.0);
|
|
gtk_widget_set_margin_start (label, 12);
|
|
gtk_grid_attach (GTK_GRID (grid), label, 2, 0, 1, 1);
|
|
// GTK_FILL, GTK_FILL, 0, 0);
|
|
gtk_widget_show (label);
|
|
|
|
combo = pika_drawable_combo_box_new (warp_map_constrain,
|
|
drawable,
|
|
NULL);
|
|
gtk_widget_set_margin_start (combo, 12);
|
|
pika_int_combo_box_connect (PIKA_INT_COMBO_BOX (combo),
|
|
mag_map_id,
|
|
G_CALLBACK (pika_int_combo_box_get_active),
|
|
&mag_map_id, NULL);
|
|
|
|
gtk_grid_attach (GTK_GRID (grid), combo, 2, 1, 1, 1);
|
|
// GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
|
|
gtk_widget_show (combo);
|
|
|
|
/* Magnitude Usage */
|
|
toggle_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
|
|
gtk_container_set_border_width (GTK_CONTAINER (toggle_hbox), 1);
|
|
gtk_grid_attach (GTK_GRID (grid), toggle_hbox, 2, 2, 1, 1);
|
|
// GTK_FILL, GTK_FILL, 0, 0);
|
|
gtk_widget_show (toggle_hbox);
|
|
|
|
toggle = gtk_check_button_new_with_label (_("Use magnitude map"));
|
|
gtk_widget_set_margin_start (toggle, 12);
|
|
gtk_box_pack_start (GTK_BOX (toggle_hbox), toggle, FALSE, FALSE, 0);
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), use_mag);
|
|
gtk_widget_show (toggle);
|
|
|
|
g_signal_connect (toggle, "toggled",
|
|
G_CALLBACK (pika_toggle_button_update),
|
|
&use_mag);
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/* --------- The "other" grid -------------------------- */
|
|
|
|
frame = pika_frame_new (_("More Advanced Options"));
|
|
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
|
|
gtk_widget_show (frame);
|
|
|
|
grid = gtk_grid_new ();
|
|
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
|
|
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
|
|
gtk_container_add (GTK_CONTAINER (frame), grid);
|
|
gtk_widget_show (grid);
|
|
|
|
spinbutton = spin_button_new (&adj, grad_scale,
|
|
-1000, 1000, /* ??? */
|
|
0.01, 0.1, 0, 1, 3);
|
|
gtk_size_group_add_widget (spin_group, spinbutton);
|
|
|
|
label = pika_grid_attach_aligned (GTK_GRID (grid), 0, 0,
|
|
_("Gradient scale:"), 0.0, 0.5,
|
|
spinbutton, 1);
|
|
gtk_size_group_add_widget (label_group, label);
|
|
|
|
g_signal_connect (adj, "value-changed",
|
|
G_CALLBACK (pika_double_adjustment_update),
|
|
&grad_scale);
|
|
|
|
/* --------- Gradient map menu ---------------- */
|
|
|
|
combo = pika_drawable_combo_box_new (warp_map_constrain,
|
|
drawable,
|
|
NULL);
|
|
gtk_widget_set_margin_start (combo, 12);
|
|
gtk_grid_attach (GTK_GRID (grid), combo, 2, 0, 1, 1);
|
|
// GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
|
|
gtk_widget_show (combo);
|
|
|
|
pika_int_combo_box_connect (PIKA_INT_COMBO_BOX (combo),
|
|
grad_map_id,
|
|
G_CALLBACK (pika_int_combo_box_get_active),
|
|
&grad_map_id, NULL);
|
|
|
|
pika_help_set_help_data (combo, _("Gradient map selection menu"), NULL);
|
|
|
|
/* ---------------------------------------------- */
|
|
|
|
spinbutton = spin_button_new (&adj, vector_scale,
|
|
-1000, 1000, /* ??? */
|
|
0.01, 0.1, 0, 1, 3);
|
|
gtk_size_group_add_widget (spin_group, spinbutton);
|
|
|
|
label = pika_grid_attach_aligned (GTK_GRID (grid), 0, 1,
|
|
_("Vector mag:"), 0.0, 0.5,
|
|
spinbutton, 1);
|
|
gtk_size_group_add_widget (label_group, label);
|
|
|
|
g_signal_connect (adj, "value-changed",
|
|
G_CALLBACK (pika_double_adjustment_update),
|
|
&vector_scale);
|
|
|
|
/* -------------------------------------------------------- */
|
|
|
|
spinbutton = spin_button_new (&adj, vector_angle,
|
|
0, 360, 1, 15, 0, 1, 1);
|
|
gtk_size_group_add_widget (spin_group, spinbutton);
|
|
|
|
label = pika_grid_attach_aligned (GTK_GRID (grid), 0, 2,
|
|
_("Angle:"), 0.0, 0.5,
|
|
spinbutton, 1);
|
|
gtk_size_group_add_widget (label_group, label);
|
|
|
|
g_signal_connect (adj, "value-changed",
|
|
G_CALLBACK (pika_double_adjustment_update),
|
|
&vector_angle);
|
|
|
|
/* --------- Vector map menu ---------------- */
|
|
combo = pika_drawable_combo_box_new (warp_map_constrain,
|
|
drawable,
|
|
NULL);
|
|
gtk_widget_set_margin_start (combo, 12);
|
|
gtk_grid_attach (GTK_GRID (grid), combo, 2, 1, 1, 1);
|
|
// GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
|
|
gtk_widget_show (combo);
|
|
|
|
pika_int_combo_box_connect (PIKA_INT_COMBO_BOX (combo),
|
|
vector_map_id,
|
|
G_CALLBACK (pika_int_combo_box_get_active),
|
|
&vector_map_id, NULL);
|
|
|
|
pika_help_set_help_data (combo,
|
|
_("Fixed-direction-vector map selection menu"),
|
|
NULL);
|
|
|
|
gtk_widget_show (dlg);
|
|
|
|
run = (pika_dialog_run (PIKA_DIALOG (dlg)) == GTK_RESPONSE_OK);
|
|
|
|
gtk_widget_destroy (dlg);
|
|
|
|
g_object_set (config,
|
|
"amount", amount,
|
|
"warp-map", pika_drawable_get_by_id (warp_map_id),
|
|
"iter", iter_count,
|
|
"dither", dither,
|
|
"angle", angle,
|
|
"wrap-type", wrap_type,
|
|
"mag-map", pika_drawable_get_by_id (mag_map_id),
|
|
"mag-use", use_mag,
|
|
"substeps", substeps,
|
|
"grad-map", pika_drawable_get_by_id (grad_map_id),
|
|
"grad-scale", grad_scale,
|
|
"vector-map", pika_drawable_get_by_id (vector_map_id),
|
|
"vector-scale", vector_scale,
|
|
"vector-angle", vector_angle,
|
|
NULL);
|
|
|
|
return run;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
static const Babl *
|
|
get_u8_format (PikaDrawable *drawable)
|
|
{
|
|
if (pika_drawable_is_rgb (drawable))
|
|
{
|
|
if (pika_drawable_has_alpha (drawable))
|
|
return babl_format ("R'G'B'A u8");
|
|
else
|
|
return babl_format ("R'G'B' u8");
|
|
}
|
|
else
|
|
{
|
|
if (pika_drawable_has_alpha (drawable))
|
|
return babl_format ("Y'A u8");
|
|
else
|
|
return babl_format ("Y' u8");
|
|
}
|
|
}
|
|
|
|
static void
|
|
blur16 (PikaDrawable *drawable)
|
|
{
|
|
/* blur a 2-or-more byte-per-pixel drawable,
|
|
* 1st 2 bytes interpreted as a 16-bit height field.
|
|
*/
|
|
GeglBuffer *src_buffer;
|
|
GeglBuffer *dest_buffer;
|
|
const Babl *format;
|
|
gint width, height;
|
|
gint src_bytes;
|
|
gint dest_bytes;
|
|
gint dest_bytes_inc;
|
|
gint offb, off1;
|
|
|
|
guchar *dest, *d; /* pointers to rows of X and Y diff. data */
|
|
guchar *prev_row, *pr;
|
|
guchar *cur_row, *cr;
|
|
guchar *next_row, *nr;
|
|
guchar *tmp;
|
|
gint row, col; /* relating to indexing into pixel row arrays */
|
|
gint x1, y1, x2, y2;
|
|
gdouble pval; /* average pixel value of pixel & neighbors */
|
|
|
|
/* --------------------------------------- */
|
|
|
|
if (! pika_drawable_mask_intersect (drawable,
|
|
&x1, &y1, &width, &height))
|
|
return;
|
|
|
|
x2 = x1 + width;
|
|
y2 = y1 + height;
|
|
|
|
width = pika_drawable_get_width (drawable); /* size of input drawable*/
|
|
height = pika_drawable_get_height (drawable);
|
|
|
|
format = get_u8_format (drawable);
|
|
|
|
/* bytes per pixel in SOURCE drawable, must be 2 or more */
|
|
src_bytes = babl_format_get_bytes_per_pixel (format);
|
|
|
|
dest_bytes = src_bytes; /* bytes per pixel in SOURCE drawable, >= 2 */
|
|
dest_bytes_inc = dest_bytes - 2; /* this is most likely zero, but I guess it's more conservative... */
|
|
|
|
/* allocate row buffers for source & dest. data */
|
|
|
|
prev_row = g_new (guchar, (x2 - x1 + 2) * src_bytes);
|
|
cur_row = g_new (guchar, (x2 - x1 + 2) * src_bytes);
|
|
next_row = g_new (guchar, (x2 - x1 + 2) * src_bytes);
|
|
dest = g_new (guchar, (x2 - x1) * src_bytes);
|
|
|
|
/* initialize the pixel regions (read from source, write into dest) */
|
|
src_buffer = pika_drawable_get_buffer (drawable);
|
|
dest_buffer = pika_drawable_get_shadow_buffer (drawable);
|
|
|
|
pr = prev_row + src_bytes; /* row arrays are prepared for indexing to -1 (!) */
|
|
cr = cur_row + src_bytes;
|
|
nr = next_row + src_bytes;
|
|
|
|
diff_prepare_row (src_buffer, format, pr, x1, y1, (x2 - x1));
|
|
diff_prepare_row (src_buffer, format, cr, x1, y1+1, (x2 - x1));
|
|
|
|
/* loop through the rows, applying the smoothing function */
|
|
for (row = y1; row < y2; row++)
|
|
{
|
|
/* prepare the next row */
|
|
diff_prepare_row (src_buffer, format, nr, x1, row + 1, (x2 - x1));
|
|
|
|
d = dest;
|
|
for (col = 0; col < (x2 - x1); col++) /* over columns of pixels */
|
|
{
|
|
offb = col*src_bytes; /* base of byte pointer offset */
|
|
off1 = offb+1; /* offset into row arrays */
|
|
|
|
pval = (256.0 * pr[offb - src_bytes] + pr[off1 - src_bytes] +
|
|
256.0 * pr[offb] + pr[off1] +
|
|
256.0 * pr[offb + src_bytes] + pr[off1 + src_bytes] +
|
|
256.0 * cr[offb - src_bytes] + cr[off1 - src_bytes] +
|
|
256.0 * cr[offb] + cr[off1] +
|
|
256.0 * cr[offb + src_bytes] + cr[off1 + src_bytes] +
|
|
256.0 * nr[offb - src_bytes] + nr[off1 - src_bytes] +
|
|
256.0 * nr[offb] + nr[off1] +
|
|
256.0 * nr[offb + src_bytes]) + nr[off1 + src_bytes];
|
|
|
|
pval /= 9.0; /* take the average */
|
|
*d++ = (guchar) (((gint) pval) >> 8); /* high-order byte */
|
|
*d++ = (guchar) (((gint) pval) % 256); /* low-order byte */
|
|
d += dest_bytes_inc; /* move data pointer on to next destination pixel */
|
|
}
|
|
|
|
/* store the dest */
|
|
gegl_buffer_set (dest_buffer, GEGL_RECTANGLE (x1, row, (x2 - x1), 1), 0,
|
|
format, dest,
|
|
GEGL_AUTO_ROWSTRIDE);
|
|
|
|
/* shuffle the row pointers */
|
|
tmp = pr;
|
|
pr = cr;
|
|
cr = nr;
|
|
nr = tmp;
|
|
|
|
if ((row % 8) == 0)
|
|
pika_progress_update ((double) row / (double) (y2 - y1));
|
|
}
|
|
|
|
g_object_unref (src_buffer);
|
|
g_object_unref (dest_buffer);
|
|
|
|
pika_progress_update (1.0);
|
|
|
|
pika_drawable_merge_shadow (drawable, TRUE);
|
|
pika_drawable_update (drawable, x1, y1, (x2 - x1), (y2 - y1));
|
|
|
|
g_free (prev_row); /* row buffers allocated at top of fn. */
|
|
g_free (cur_row);
|
|
g_free (next_row);
|
|
g_free (dest);
|
|
|
|
}
|
|
|
|
|
|
/* ====================================================================== */
|
|
/* Get one row of pixels from the PixelRegion and put them in 'data' */
|
|
|
|
static void
|
|
diff_prepare_row (GeglBuffer *buffer,
|
|
const Babl *format,
|
|
guchar *data,
|
|
gint x,
|
|
gint y,
|
|
gint w)
|
|
{
|
|
gint bpp = babl_format_get_bytes_per_pixel (format);
|
|
gint b;
|
|
|
|
/* y = CLAMP (y, 0, pixel_rgn->h - 1); FIXME? */
|
|
|
|
gegl_buffer_get (buffer, GEGL_RECTANGLE (x, y, w, 1), 1.0,
|
|
format, data,
|
|
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
|
|
|
|
/* Fill in edge pixels */
|
|
for (b = 0; b < bpp; b++)
|
|
{
|
|
data[b - (gint) bpp] = data[b];
|
|
data[w * bpp + b] = data[(w - 1) * bpp + b];
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* 'diff' combines the input drawables to prepare the two */
|
|
/* 16-bit (X,Y) vector displacement maps */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
static void
|
|
diff (PikaDrawable *drawable,
|
|
PikaProcedureConfig *config,
|
|
PikaDrawable **xl,
|
|
PikaDrawable **yl)
|
|
{
|
|
PikaDrawable *draw_xd;
|
|
PikaDrawable *draw_yd; /* vector disp. drawables */
|
|
PikaImage *image; /* image holding X and Y diff. arrays */
|
|
PikaImage *new_image; /* image holding X and Y diff. layers */
|
|
GList *selected_layers; /* currently selected layers */
|
|
PikaLayer *xlayer;
|
|
PikaLayer *ylayer; /* individual X and Y layer ID numbers */
|
|
GeglBuffer *src_buffer;
|
|
GeglBuffer *destx_buffer;
|
|
const Babl *destx_format;
|
|
GeglBuffer *desty_buffer;
|
|
const Babl *desty_format;
|
|
GeglBuffer *vec_buffer;
|
|
GeglBuffer *mag_buffer = NULL;
|
|
GeglBuffer *grad_buffer;
|
|
gint width, height;
|
|
const Babl *src_format;
|
|
gint src_bytes;
|
|
const Babl *mformat = NULL;
|
|
gint mbytes = 0;
|
|
const Babl *vformat = NULL;
|
|
gint vbytes = 0;
|
|
const Babl *gformat = NULL;
|
|
gint gbytes = 0; /* bytes-per-pixel of various source drawables */
|
|
const Babl *dest_format;
|
|
gint dest_bytes;
|
|
gint dest_bytes_inc;
|
|
gint do_gradmap = FALSE; /* whether to add in gradient of gradmap to final diff. map */
|
|
gint do_vecmap = FALSE; /* whether to add in a fixed vector scaled by the vector map */
|
|
gint do_magmap = FALSE; /* whether to multiply result by the magnitude map */
|
|
|
|
guchar *destx, *dx, *desty, *dy; /* pointers to rows of X and Y diff. data */
|
|
guchar *tmp;
|
|
guchar *prev_row, *pr;
|
|
guchar *cur_row, *cr;
|
|
guchar *next_row, *nr;
|
|
guchar *prev_row_g, *prg = NULL; /* pointers to gradient map data */
|
|
guchar *cur_row_g, *crg = NULL;
|
|
guchar *next_row_g, *nrg = NULL;
|
|
guchar *cur_row_v, *crv = NULL; /* pointers to vector map data */
|
|
guchar *cur_row_m, *crm = NULL; /* pointers to magnitude map data */
|
|
gint row, col, offb, off, bytes; /* relating to indexing into pixel row arrays */
|
|
gint x1, y1, x2, y2;
|
|
gint dvalx, dvaly; /* differential value at particular pixel */
|
|
gdouble tx, ty; /* temporary x,y differential value increments from gradmap, etc. */
|
|
gdouble rdx, rdy; /* x,y differential values: real #s */
|
|
gdouble rscalefac; /* scaling factor for x,y differential of 'curl' map */
|
|
gdouble gscalefac; /* scaling factor for x,y differential of 'gradient' map */
|
|
gdouble r, theta, dtheta; /* rectangular<-> spherical coordinate transform for vector rotation */
|
|
gdouble scale_vec_x, scale_vec_y; /* fixed vector X,Y component scaling factors */
|
|
|
|
PikaDrawable *mag_map;
|
|
PikaDrawable *grad_map;
|
|
PikaDrawable *vector_map;
|
|
gdouble angle;
|
|
gdouble grad_scale;
|
|
gdouble vector_scale;
|
|
gdouble vector_angle;
|
|
gboolean use_mag;
|
|
|
|
pika_ui_init (PLUG_IN_BINARY);
|
|
|
|
g_object_get (config,
|
|
"angle", &angle,
|
|
"mag-use", &use_mag,
|
|
"grad-scale", &grad_scale,
|
|
"vector-scale", &vector_scale,
|
|
"vector-angle", &vector_angle,
|
|
NULL);
|
|
|
|
/* ----------------------------------------------------------------------- */
|
|
|
|
if (grad_scale != 0.0)
|
|
do_gradmap = TRUE; /* add in gradient of gradmap if scale != 0.000 */
|
|
|
|
if (vector_scale != 0.0) /* add in gradient of vectormap if scale != 0.000 */
|
|
do_vecmap = TRUE;
|
|
|
|
do_magmap = (use_mag == TRUE); /* multiply by magnitude map if so requested */
|
|
|
|
/* Get the input area. This is the bounding box of the selection in
|
|
* the image (or the entire image if there is no selection). Only
|
|
* operating on the input area is simply an optimization. It doesn't
|
|
* need to be done for correct operation. (It simply makes it go
|
|
* faster, since fewer pixels need to be operated on).
|
|
*/
|
|
if (! pika_drawable_mask_intersect (drawable,
|
|
&x1, &y1, &width, &height))
|
|
return;
|
|
|
|
g_object_get (config,
|
|
"mag-map", &mag_map,
|
|
"grad-map", &grad_map,
|
|
"vector-map", &vector_map,
|
|
NULL);
|
|
|
|
x2 = x1 + width;
|
|
y2 = y1 + height;
|
|
|
|
/* Get the size of the input image. (This will/must be the same
|
|
* as the size of the output image.
|
|
*/
|
|
width = pika_drawable_get_width (drawable);
|
|
height = pika_drawable_get_height (drawable);
|
|
|
|
src_format = get_u8_format (drawable);
|
|
src_bytes = babl_format_get_bytes_per_pixel (src_format);
|
|
|
|
/* -- Add two layers: X and Y Displacement vectors -- */
|
|
/* -- I'm using a RGB drawable and using the first two bytes for a
|
|
16-bit pixel value. This is either clever, or a kluge,
|
|
depending on your point of view. */
|
|
|
|
image = pika_item_get_image (PIKA_ITEM (drawable));
|
|
selected_layers = pika_image_list_selected_layers (image);
|
|
|
|
/* create new image for X,Y diff */
|
|
new_image = pika_image_new (width, height, PIKA_RGB);
|
|
|
|
xlayer = pika_layer_new (new_image, "Warp_X_Vectors",
|
|
width, height,
|
|
PIKA_RGB_IMAGE,
|
|
100.0,
|
|
pika_image_get_default_new_layer_mode (new_image));
|
|
|
|
ylayer = pika_layer_new (new_image, "Warp_Y_Vectors",
|
|
width, height,
|
|
PIKA_RGB_IMAGE,
|
|
100.0,
|
|
pika_image_get_default_new_layer_mode (new_image));
|
|
|
|
draw_yd = PIKA_DRAWABLE (ylayer);
|
|
draw_xd = PIKA_DRAWABLE (xlayer);
|
|
|
|
pika_image_insert_layer (new_image, xlayer, NULL, 1);
|
|
pika_image_insert_layer (new_image, ylayer, NULL, 1);
|
|
pika_drawable_fill (PIKA_DRAWABLE (xlayer), PIKA_FILL_BACKGROUND);
|
|
pika_drawable_fill (PIKA_DRAWABLE (ylayer), PIKA_FILL_BACKGROUND);
|
|
pika_image_take_selected_layers (image, selected_layers);
|
|
|
|
dest_format = get_u8_format (draw_xd);
|
|
dest_bytes = babl_format_get_bytes_per_pixel (dest_format);
|
|
/* for a GRAYA drawable, I would expect this to be two bytes; any more would be excess */
|
|
dest_bytes_inc = dest_bytes - 2;
|
|
|
|
/* allocate row buffers for source & dest. data */
|
|
|
|
prev_row = g_new (guchar, (x2 - x1 + 2) * src_bytes);
|
|
cur_row = g_new (guchar, (x2 - x1 + 2) * src_bytes);
|
|
next_row = g_new (guchar, (x2 - x1 + 2) * src_bytes);
|
|
|
|
prev_row_g = g_new (guchar, (x2 - x1 + 2) * src_bytes);
|
|
cur_row_g = g_new (guchar, (x2 - x1 + 2) * src_bytes);
|
|
next_row_g = g_new (guchar, (x2 - x1 + 2) * src_bytes);
|
|
|
|
cur_row_v = g_new (guchar, (x2 - x1 + 2) * src_bytes); /* vector map */
|
|
cur_row_m = g_new (guchar, (x2 - x1 + 2) * src_bytes); /* magnitude map */
|
|
|
|
destx = g_new (guchar, (x2 - x1) * dest_bytes);
|
|
desty = g_new (guchar, (x2 - x1) * dest_bytes);
|
|
|
|
/* initialize the source and destination pixel regions */
|
|
|
|
/* 'curl' vector-rotation input */
|
|
src_buffer = pika_drawable_get_buffer (drawable);
|
|
|
|
/* destination: X diff output */
|
|
destx_buffer = pika_drawable_get_buffer (draw_xd);
|
|
destx_format = get_u8_format (draw_xd);
|
|
|
|
/* Y diff output */
|
|
desty_buffer = pika_drawable_get_buffer (draw_yd);
|
|
desty_format = get_u8_format (draw_yd);
|
|
|
|
pr = prev_row + src_bytes;
|
|
cr = cur_row + src_bytes;
|
|
nr = next_row + src_bytes;
|
|
|
|
diff_prepare_row (src_buffer, src_format, pr, x1, y1, (x2 - x1));
|
|
diff_prepare_row (src_buffer, src_format, cr, x1, y1+1, (x2 - x1));
|
|
|
|
/* fixed-vector (x,y) component scale factors */
|
|
scale_vec_x = (vector_scale *
|
|
cos ((90 - vector_angle) * G_PI / 180.0) * 256.0 / 10);
|
|
scale_vec_y = (vector_scale *
|
|
sin ((90 - vector_angle) * G_PI / 180.0) * 256.0 / 10);
|
|
|
|
if (do_vecmap)
|
|
{
|
|
/* bytes per pixel in SOURCE drawable */
|
|
vformat = get_u8_format (vector_map);
|
|
vbytes = babl_format_get_bytes_per_pixel (vformat);
|
|
|
|
/* fixed-vector scale-map */
|
|
vec_buffer = pika_drawable_get_buffer (vector_map);
|
|
|
|
crv = cur_row_v + vbytes;
|
|
diff_prepare_row (vec_buffer, vformat, crv, x1, y1, (x2 - x1));
|
|
}
|
|
|
|
if (do_gradmap)
|
|
{
|
|
gformat = get_u8_format (grad_map);
|
|
gbytes = babl_format_get_bytes_per_pixel (gformat);
|
|
|
|
/* fixed-vector scale-map */
|
|
grad_buffer = pika_drawable_get_buffer (grad_map);
|
|
|
|
prg = prev_row_g + gbytes;
|
|
crg = cur_row_g + gbytes;
|
|
nrg = next_row_g + gbytes;
|
|
diff_prepare_row (grad_buffer, gformat, prg, x1, y1 - 1, (x2 - x1));
|
|
diff_prepare_row (grad_buffer, gformat, crg, x1, y1, (x2 - x1));
|
|
}
|
|
|
|
if (do_magmap)
|
|
{
|
|
mformat = get_u8_format (mag_map);
|
|
mbytes = babl_format_get_bytes_per_pixel (mformat);
|
|
|
|
/* fixed-vector scale-map */
|
|
mag_buffer = pika_drawable_get_buffer (mag_map);
|
|
|
|
crm = cur_row_m + mbytes;
|
|
diff_prepare_row (mag_buffer, mformat, crm, x1, y1, (x2 - x1));
|
|
}
|
|
|
|
dtheta = angle * G_PI / 180.0;
|
|
/* note that '3' is rather arbitrary here. */
|
|
rscalefac = 256.0 / (3 * src_bytes);
|
|
/* scale factor for gradient map components */
|
|
gscalefac = grad_scale * 256.0 / (3 * gbytes);
|
|
|
|
/* loop through the rows, applying the differential convolution */
|
|
for (row = y1; row < y2; row++)
|
|
{
|
|
/* prepare the next row */
|
|
diff_prepare_row (src_buffer, src_format, nr, x1, row + 1, (x2 - x1));
|
|
|
|
if (do_magmap)
|
|
diff_prepare_row (mag_buffer, mformat, crm, x1, row + 1, (x2 - x1));
|
|
if (do_vecmap)
|
|
diff_prepare_row (vec_buffer, vformat, crv, x1, row + 1, (x2 - x1));
|
|
if (do_gradmap)
|
|
diff_prepare_row (grad_buffer, gformat, crg, x1, row + 1, (x2 - x1));
|
|
|
|
dx = destx;
|
|
dy = desty;
|
|
|
|
for (col = 0; col < (x2 - x1); col++) /* over columns of pixels */
|
|
{
|
|
rdx = 0.0;
|
|
rdy = 0.0;
|
|
ty = 0.0;
|
|
tx = 0.0;
|
|
|
|
offb = col * src_bytes; /* base of byte pointer offset */
|
|
for (bytes=0; bytes < src_bytes; bytes++) /* add all channels together */
|
|
{
|
|
off = offb+bytes; /* offset into row arrays */
|
|
rdx += ((gint) -pr[off - src_bytes] + (gint) pr[off + src_bytes] +
|
|
(gint) -2*cr[off - src_bytes] + (gint) 2*cr[off + src_bytes] +
|
|
(gint) -nr[off - src_bytes] + (gint) nr[off + src_bytes]);
|
|
|
|
rdy += ((gint) -pr[off - src_bytes] - (gint)2*pr[off] - (gint) pr[off + src_bytes] +
|
|
(gint) nr[off - src_bytes] + (gint)2*nr[off] + (gint) nr[off + src_bytes]);
|
|
}
|
|
|
|
rdx *= rscalefac; /* take average, then reduce. Assume max. rdx now 65535 */
|
|
rdy *= rscalefac; /* take average, then reduce */
|
|
|
|
theta = atan2(rdy,rdx); /* convert to polar, then back to rectang. coords */
|
|
r = sqrt(rdy*rdy + rdx*rdx);
|
|
theta += dtheta; /* rotate gradient vector by this angle (radians) */
|
|
rdx = r * cos(theta);
|
|
rdy = r * sin(theta);
|
|
|
|
if (do_gradmap)
|
|
{
|
|
offb = col*gbytes; /* base of byte pointer offset into pixel values (R,G,B,Alpha, etc.) */
|
|
for (bytes=0; bytes < src_bytes; bytes++) /* add all channels together */
|
|
{
|
|
off = offb+bytes; /* offset into row arrays */
|
|
tx += ((gint) -prg[off - gbytes] + (gint) prg[off + gbytes] +
|
|
(gint) -2*crg[off - gbytes] + (gint) 2*crg[off + gbytes] +
|
|
(gint) -nrg[off - gbytes] + (gint) nrg[off + gbytes]);
|
|
|
|
ty += ((gint) -prg[off - gbytes] - (gint)2*prg[off] - (gint) prg[off + gbytes] +
|
|
(gint) nrg[off - gbytes] + (gint)2*nrg[off] + (gint) nrg[off + gbytes]);
|
|
}
|
|
tx *= gscalefac;
|
|
ty *= gscalefac;
|
|
|
|
rdx += tx; /* add gradient component in to the other one */
|
|
rdy += ty;
|
|
|
|
} /* if (do_gradmap) */
|
|
|
|
if (do_vecmap)
|
|
{ /* add in fixed vector scaled by vec. map data */
|
|
tx = (gdouble) crv[col*vbytes]; /* use first byte only */
|
|
rdx += scale_vec_x * tx;
|
|
rdy += scale_vec_y * tx;
|
|
} /* if (do_vecmap) */
|
|
|
|
if (do_magmap)
|
|
{ /* multiply result by mag. map data */
|
|
tx = (gdouble) crm[col*mbytes];
|
|
rdx = (rdx * tx)/(255.0);
|
|
rdy = (rdy * tx)/(255.0);
|
|
} /* if do_magmap */
|
|
|
|
dvalx = rdx + (2<<14); /* take zero point to be 2^15, since this is two bytes */
|
|
dvaly = rdy + (2<<14);
|
|
|
|
if (dvalx < 0)
|
|
dvalx = 0;
|
|
|
|
if (dvalx > 65535)
|
|
dvalx = 65535;
|
|
|
|
*dx++ = (guchar) (dvalx >> 8); /* store high order byte in value channel */
|
|
*dx++ = (guchar) (dvalx % 256); /* store low order byte in alpha channel */
|
|
dx += dest_bytes_inc; /* move data pointer on to next destination pixel */
|
|
|
|
if (dvaly < 0)
|
|
dvaly = 0;
|
|
|
|
if (dvaly > 65535)
|
|
dvaly = 65535;
|
|
|
|
*dy++ = (guchar) (dvaly >> 8);
|
|
*dy++ = (guchar) (dvaly % 256);
|
|
dy += dest_bytes_inc;
|
|
|
|
} /* ------------------------------- for (col...) ---------------- */
|
|
|
|
/* store the dest */
|
|
gegl_buffer_set (destx_buffer,
|
|
GEGL_RECTANGLE (x1, row, (x2 - x1), 1), 0,
|
|
destx_format, destx,
|
|
GEGL_AUTO_ROWSTRIDE);
|
|
|
|
gegl_buffer_set (desty_buffer,
|
|
GEGL_RECTANGLE (x1, row, (x2 - x1), 1), 0,
|
|
desty_format, desty,
|
|
GEGL_AUTO_ROWSTRIDE);
|
|
|
|
/* swap around the pointers to row buffers */
|
|
tmp = pr;
|
|
pr = cr;
|
|
cr = nr;
|
|
nr = tmp;
|
|
|
|
if (do_gradmap)
|
|
{
|
|
tmp = prg;
|
|
prg = crg;
|
|
crg = nrg;
|
|
nrg = tmp;
|
|
}
|
|
|
|
if ((row % 8) == 0)
|
|
pika_progress_update ((gdouble) row / (gdouble) (y2 - y1));
|
|
|
|
} /* for (row..) */
|
|
|
|
pika_progress_update (1.0);
|
|
|
|
g_object_unref (src_buffer);
|
|
g_object_unref (destx_buffer);
|
|
g_object_unref (desty_buffer);
|
|
|
|
g_clear_object (&mag_map);
|
|
g_clear_object (&grad_map);
|
|
g_clear_object (&vector_map);
|
|
|
|
pika_drawable_update (draw_xd, x1, y1, (x2 - x1), (y2 - y1));
|
|
pika_drawable_update (draw_yd, x1, y1, (x2 - x1), (y2 - y1));
|
|
|
|
pika_displays_flush (); /* make sure layer is visible */
|
|
|
|
pika_progress_init (_("Smoothing X gradient"));
|
|
blur16 (draw_xd);
|
|
|
|
pika_progress_init (_("Smoothing Y gradient"));
|
|
blur16 (draw_yd);
|
|
|
|
g_free (prev_row); /* row buffers allocated at top of fn. */
|
|
g_free (cur_row);
|
|
g_free (next_row);
|
|
g_free (prev_row_g); /* row buffers allocated at top of fn. */
|
|
g_free (cur_row_g);
|
|
g_free (next_row_g);
|
|
g_free (cur_row_v);
|
|
g_free (cur_row_m);
|
|
|
|
g_free (destx);
|
|
g_free (desty);
|
|
|
|
*xl = PIKA_DRAWABLE (xlayer); /* pass back the X and Y layer ID numbers */
|
|
*yl = PIKA_DRAWABLE (ylayer);
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* The Warp displacement is done here. */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
static void
|
|
warp (PikaDrawable *orig_draw,
|
|
PikaProcedureConfig *config)
|
|
{
|
|
PikaDrawable *disp_map; /* Displacement map, ie, control array */
|
|
PikaDrawable *mag_draw; /* Magnitude multiplier factor map */
|
|
PikaDrawable *map_x = NULL;
|
|
PikaDrawable *map_y = NULL;
|
|
gboolean first_time = TRUE;
|
|
gint iter_count;
|
|
gint width;
|
|
gint height;
|
|
gint x1, y1, x2, y2;
|
|
PikaImage *image;
|
|
|
|
/* index var. over all "warp" Displacement iterations */
|
|
gint warp_iter;
|
|
|
|
/* calculate new X,Y Displacement image maps */
|
|
|
|
pika_progress_init (_("Finding XY gradient"));
|
|
|
|
/* Get selection area */
|
|
if (! pika_drawable_mask_intersect (orig_draw,
|
|
&x1, &y1, &width, &height))
|
|
return;
|
|
|
|
g_object_get (config,
|
|
"warp-map", &disp_map,
|
|
"mag-map", &mag_draw,
|
|
"iter", &iter_count,
|
|
NULL);
|
|
|
|
x2 = x1 + width;
|
|
y2 = y1 + height;
|
|
|
|
width = pika_drawable_get_width (orig_draw);
|
|
height = pika_drawable_get_height (orig_draw);
|
|
|
|
/* generate x,y differential images (arrays) */
|
|
diff (disp_map, config, &map_x, &map_y);
|
|
|
|
for (warp_iter = 0; warp_iter < iter_count; warp_iter++)
|
|
{
|
|
pika_progress_init_printf (_("Flow step %d"), warp_iter+1);
|
|
progress = 0;
|
|
|
|
warp_one (orig_draw, orig_draw,
|
|
map_x, map_y, mag_draw,
|
|
first_time, warp_iter, config);
|
|
|
|
pika_drawable_update (orig_draw,
|
|
x1, y1, (x2 - x1), (y2 - y1));
|
|
|
|
if (run_mode != PIKA_RUN_NONINTERACTIVE)
|
|
pika_displays_flush ();
|
|
|
|
first_time = FALSE;
|
|
}
|
|
|
|
image = pika_item_get_image (PIKA_ITEM (map_x));
|
|
|
|
pika_image_delete (image);
|
|
g_clear_object (&disp_map);
|
|
g_clear_object (&mag_draw);
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
static void
|
|
warp_one (PikaDrawable *draw,
|
|
PikaDrawable *new,
|
|
PikaDrawable *map_x,
|
|
PikaDrawable *map_y,
|
|
PikaDrawable *mag_draw,
|
|
gboolean first_time,
|
|
gint step,
|
|
PikaProcedureConfig *config)
|
|
{
|
|
GeglBuffer *src_buffer;
|
|
GeglBuffer *dest_buffer;
|
|
GeglBuffer *map_x_buffer;
|
|
GeglBuffer *map_y_buffer;
|
|
GeglBuffer *mag_buffer = NULL;
|
|
|
|
GeglBufferIterator *iter;
|
|
|
|
gint width;
|
|
gint height;
|
|
|
|
const Babl *src_format;
|
|
gint src_bytes;
|
|
const Babl *dest_format;
|
|
gint dest_bytes;
|
|
|
|
guchar pixel[4][4];
|
|
gint x1, y1, x2, y2;
|
|
gint x, y;
|
|
gint max_progress;
|
|
|
|
gdouble needx, needy;
|
|
gdouble xval=0; /* initialize to quiet compiler grumbles */
|
|
gdouble yval=0; /* interpolated vector displacement */
|
|
gdouble scalefac; /* multiplier for vector displacement scaling */
|
|
gdouble dscalefac; /* multiplier for incremental displacement vectors */
|
|
gint xi, yi;
|
|
gint substep; /* loop variable counting displacement vector substeps */
|
|
|
|
guchar values[4];
|
|
guint32 ivalues[4];
|
|
guchar val;
|
|
|
|
gint k;
|
|
|
|
gdouble dx, dy; /* X and Y Displacement, integer from GRAY map */
|
|
|
|
const Babl *map_x_format;
|
|
gint map_x_bytes;
|
|
const Babl *map_y_format;
|
|
gint map_y_bytes;
|
|
const Babl *mag_format;
|
|
gint mag_bytes = 1;
|
|
gboolean mag_alpha = FALSE;
|
|
|
|
GRand *gr;
|
|
|
|
gdouble amount;
|
|
gdouble dither;
|
|
gboolean use_mag;
|
|
gint substeps;
|
|
|
|
gr = g_rand_new (); /* Seed Pseudo Random Number Generator */
|
|
|
|
/* ================ Outer Loop calculation ================================ */
|
|
|
|
/* Get selection area */
|
|
|
|
if (! pika_drawable_mask_intersect (draw,
|
|
&x1, &y1, &width, &height))
|
|
return;
|
|
|
|
g_object_get (config,
|
|
"amount", &amount,
|
|
"dither", &dither,
|
|
"mag-use", &use_mag,
|
|
"substeps", &substeps,
|
|
NULL);
|
|
|
|
x2 = x1 + width;
|
|
y2 = y1 + height;
|
|
|
|
width = pika_drawable_get_width (draw);
|
|
height = pika_drawable_get_height (draw);
|
|
|
|
|
|
max_progress = (x2 - x1) * (y2 - y1);
|
|
|
|
|
|
/* --------- Register the (many) pixel regions ---------- */
|
|
|
|
src_buffer = pika_drawable_get_buffer (draw);
|
|
|
|
src_format = get_u8_format (draw);
|
|
src_bytes = babl_format_get_bytes_per_pixel (src_format);
|
|
|
|
iter = gegl_buffer_iterator_new (src_buffer,
|
|
GEGL_RECTANGLE (x1, y1, (x2 - x1), (y2 - y1)),
|
|
0, src_format,
|
|
GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 5);
|
|
|
|
|
|
dest_buffer = pika_drawable_get_shadow_buffer (new);
|
|
|
|
dest_format = get_u8_format (new);
|
|
dest_bytes = babl_format_get_bytes_per_pixel (dest_format);
|
|
|
|
gegl_buffer_iterator_add (iter, dest_buffer,
|
|
GEGL_RECTANGLE (x1, y1, (x2 - x1), (y2 - y1)),
|
|
0, dest_format,
|
|
GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE);
|
|
|
|
|
|
map_x_buffer = pika_drawable_get_buffer (map_x);
|
|
|
|
map_x_format = get_u8_format (map_x);
|
|
map_x_bytes = babl_format_get_bytes_per_pixel (map_x_format);
|
|
|
|
gegl_buffer_iterator_add (iter, map_x_buffer,
|
|
GEGL_RECTANGLE (x1, y1, (x2 - x1), (y2 - y1)),
|
|
0, map_x_format,
|
|
GEGL_ACCESS_READ, GEGL_ABYSS_NONE);
|
|
|
|
|
|
map_y_buffer = pika_drawable_get_buffer (map_y);
|
|
|
|
map_y_format = get_u8_format (map_y);
|
|
map_y_bytes = babl_format_get_bytes_per_pixel (map_y_format);
|
|
|
|
gegl_buffer_iterator_add (iter, map_y_buffer,
|
|
GEGL_RECTANGLE (x1, y1, (x2 - x1), (y2 - y1)),
|
|
0, map_y_format,
|
|
GEGL_ACCESS_READ, GEGL_ABYSS_NONE);
|
|
|
|
|
|
if (use_mag)
|
|
{
|
|
mag_buffer = pika_drawable_get_buffer (mag_draw);
|
|
|
|
mag_format = get_u8_format (mag_draw);
|
|
mag_bytes = babl_format_get_bytes_per_pixel (mag_format);
|
|
|
|
mag_alpha = pika_drawable_has_alpha (mag_draw);
|
|
|
|
gegl_buffer_iterator_add (iter, mag_buffer,
|
|
GEGL_RECTANGLE (x1, y1, (x2 - x1), (y2 - y1)),
|
|
0, mag_format,
|
|
GEGL_ACCESS_READ, GEGL_ABYSS_NONE);
|
|
}
|
|
|
|
/* substep displacement vector scale factor */
|
|
dscalefac = amount / (256 * 127.5 * substeps);
|
|
|
|
while (gegl_buffer_iterator_next (iter))
|
|
{
|
|
GeglRectangle roi = iter->items[1].roi;
|
|
guchar *srcrow = iter->items[0].data;
|
|
guchar *destrow = iter->items[1].data;
|
|
guchar *mxrow = iter->items[2].data;
|
|
guchar *myrow = iter->items[3].data;
|
|
guchar *mmagrow = NULL;
|
|
|
|
if (use_mag)
|
|
mmagrow = iter->items[4].data;
|
|
|
|
/* loop over destination pixels */
|
|
for (y = roi.y; y < (roi.y + roi.height); y++)
|
|
{
|
|
guchar *dest = destrow;
|
|
guchar *mx = mxrow;
|
|
guchar *my = myrow;
|
|
guchar *mmag = NULL;
|
|
|
|
if (use_mag == TRUE)
|
|
mmag = mmagrow;
|
|
|
|
for (x = roi.x; x < (roi.x + roi.width); x++)
|
|
{
|
|
/* ----- Find displacement vector (amnt_x, amnt_y) ------------ */
|
|
|
|
dx = dscalefac * ((256.0 * mx[0]) + mx[1] -32768); /* 16-bit values */
|
|
dy = dscalefac * ((256.0 * my[0]) + my[1] -32768);
|
|
|
|
if (use_mag)
|
|
{
|
|
scalefac = warp_map_mag_give_value (mmag,
|
|
mag_alpha,
|
|
mag_bytes) / 255.0;
|
|
dx *= scalefac;
|
|
dy *= scalefac;
|
|
}
|
|
|
|
if (dither != 0.0)
|
|
{ /* random dither is +/- dither pixels */
|
|
dx += g_rand_double_range (gr, -dither, dither);
|
|
dy += g_rand_double_range (gr, -dither, dither);
|
|
}
|
|
|
|
if (substeps != 1)
|
|
{ /* trace (substeps) iterations of displacement vector */
|
|
for (substep = 1; substep < substeps; substep++)
|
|
{
|
|
/* In this (substep) loop, (x,y) remain fixed. (dx,dy) vary each step. */
|
|
needx = x + dx;
|
|
needy = y + dy;
|
|
|
|
if (needx >= 0.0)
|
|
xi = (gint) needx;
|
|
else
|
|
xi = -((gint) -needx + 1);
|
|
|
|
if (needy >= 0.0)
|
|
yi = (gint) needy;
|
|
else
|
|
yi = -((gint) -needy + 1);
|
|
|
|
/* get 4 neighboring DX values from DiffX drawable for linear interpolation */
|
|
warp_pixel (map_x_buffer, map_x_format,
|
|
width, height,
|
|
x1, y1, x2, y2,
|
|
xi, yi,
|
|
pixel[0], config);
|
|
warp_pixel (map_x_buffer, map_x_format,
|
|
width, height,
|
|
x1, y1, x2, y2,
|
|
xi + 1, yi,
|
|
pixel[1], config);
|
|
warp_pixel (map_x_buffer, map_x_format,
|
|
width, height,
|
|
x1, y1, x2, y2,
|
|
xi, yi + 1,
|
|
pixel[2], config);
|
|
warp_pixel (map_x_buffer, map_x_format,
|
|
width, height,
|
|
x1, y1, x2, y2,
|
|
xi + 1, yi + 1,
|
|
pixel[3], config);
|
|
|
|
ivalues[0] = 256 * pixel[0][0] + pixel[0][1];
|
|
ivalues[1] = 256 * pixel[1][0] + pixel[1][1];
|
|
ivalues[2] = 256 * pixel[2][0] + pixel[2][1];
|
|
ivalues[3] = 256 * pixel[3][0] + pixel[3][1];
|
|
|
|
xval = pika_bilinear_32 (needx, needy, ivalues);
|
|
|
|
/* get 4 neighboring DY values from DiffY drawable for linear interpolation */
|
|
warp_pixel (map_y_buffer, map_y_format,
|
|
width, height,
|
|
x1, y1, x2, y2,
|
|
xi, yi,
|
|
pixel[0], config);
|
|
warp_pixel (map_y_buffer, map_y_format,
|
|
width, height,
|
|
x1, y1, x2, y2,
|
|
xi + 1, yi,
|
|
pixel[1], config);
|
|
warp_pixel (map_y_buffer, map_y_format,
|
|
width, height,
|
|
x1, y1, x2, y2,
|
|
xi, yi + 1,
|
|
pixel[2], config);
|
|
warp_pixel (map_y_buffer, map_y_format,
|
|
width, height,
|
|
x1, y1, x2, y2,
|
|
xi + 1, yi + 1,
|
|
pixel[3], config);
|
|
|
|
ivalues[0] = 256 * pixel[0][0] + pixel[0][1];
|
|
ivalues[1] = 256 * pixel[1][0] + pixel[1][1];
|
|
ivalues[2] = 256 * pixel[2][0] + pixel[2][1];
|
|
ivalues[3] = 256 * pixel[3][0] + pixel[3][1];
|
|
|
|
yval = pika_bilinear_32 (needx, needy, ivalues);
|
|
|
|
/* move displacement vector to this new value */
|
|
dx += dscalefac * (xval - 32768);
|
|
dy += dscalefac * (yval - 32768);
|
|
|
|
} /* for (substep) */
|
|
} /* if (substeps != 0) */
|
|
|
|
/* --------------------------------------------------------- */
|
|
|
|
needx = x + dx;
|
|
needy = y + dy;
|
|
|
|
mx += map_x_bytes; /* pointers into x,y displacement maps */
|
|
my += map_y_bytes;
|
|
|
|
if (use_mag == TRUE)
|
|
mmag += mag_bytes;
|
|
|
|
/* Calculations complete; now copy the proper pixel */
|
|
|
|
if (needx >= 0.0)
|
|
xi = (gint) needx;
|
|
else
|
|
xi = -((gint) -needx + 1);
|
|
|
|
if (needy >= 0.0)
|
|
yi = (gint) needy;
|
|
else
|
|
yi = -((gint) -needy + 1);
|
|
|
|
/* get 4 neighboring pixel values from source drawable
|
|
* for linear interpolation
|
|
*/
|
|
warp_pixel (src_buffer, src_format,
|
|
width, height,
|
|
x1, y1, x2, y2,
|
|
xi, yi,
|
|
pixel[0], config);
|
|
warp_pixel (src_buffer, src_format,
|
|
width, height,
|
|
x1, y1, x2, y2,
|
|
xi + 1, yi,
|
|
pixel[1], config);
|
|
warp_pixel (src_buffer, src_format,
|
|
width, height,
|
|
x1, y1, x2, y2,
|
|
xi, yi + 1,
|
|
pixel[2], config);
|
|
warp_pixel (src_buffer, src_format,
|
|
width, height,
|
|
x1, y1, x2, y2,
|
|
xi + 1, yi + 1,
|
|
pixel[3], config);
|
|
|
|
for (k = 0; k < dest_bytes; k++)
|
|
{
|
|
values[0] = pixel[0][k];
|
|
values[1] = pixel[1][k];
|
|
values[2] = pixel[2][k];
|
|
values[3] = pixel[3][k];
|
|
|
|
val = pika_bilinear_8 (needx, needy, values);
|
|
|
|
*dest++ = val;
|
|
}
|
|
}
|
|
|
|
/* srcrow += src_rgn.rowstride; */
|
|
srcrow += src_bytes * roi.width;
|
|
destrow += dest_bytes * roi.width;
|
|
mxrow += map_x_bytes * roi.width;
|
|
myrow += map_y_bytes * roi.width;
|
|
|
|
if (use_mag == TRUE)
|
|
mmagrow += mag_bytes * roi.width;
|
|
}
|
|
|
|
progress += (roi.width * roi.height);
|
|
pika_progress_update ((double) progress / (double) max_progress);
|
|
}
|
|
|
|
g_object_unref (src_buffer);
|
|
g_object_unref (dest_buffer);
|
|
g_object_unref (map_x_buffer);
|
|
g_object_unref (map_y_buffer);
|
|
|
|
if (use_mag == TRUE)
|
|
g_object_unref (mag_buffer);
|
|
|
|
pika_progress_update (1.0);
|
|
|
|
pika_drawable_merge_shadow (draw, first_time);
|
|
|
|
g_rand_free (gr);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
static gdouble
|
|
warp_map_mag_give_value (guchar *pt,
|
|
gint alpha,
|
|
gint bytes)
|
|
{
|
|
gdouble ret, val_alpha;
|
|
|
|
if (bytes >= 3)
|
|
ret = (pt[0] + pt[1] + pt[2])/3.0;
|
|
else
|
|
ret = (gdouble) *pt;
|
|
|
|
if (alpha)
|
|
{
|
|
val_alpha = pt[bytes - 1];
|
|
ret = (ret * val_alpha / 255.0);
|
|
};
|
|
|
|
return (ret);
|
|
}
|
|
|
|
|
|
static void
|
|
warp_pixel (GeglBuffer *buffer,
|
|
const Babl *format,
|
|
gint width,
|
|
gint height,
|
|
gint x1,
|
|
gint y1,
|
|
gint x2,
|
|
gint y2,
|
|
gint x,
|
|
gint y,
|
|
guchar *pixel,
|
|
PikaProcedureConfig *config)
|
|
{
|
|
static guchar empty_pixel[4] = { 0, 0, 0, 0 };
|
|
guchar *data;
|
|
gint wrap_type;
|
|
|
|
g_object_get (config,
|
|
"wrap-type", &wrap_type,
|
|
NULL);
|
|
|
|
/* Tile the image. */
|
|
if (wrap_type == WRAP)
|
|
{
|
|
if (x < 0)
|
|
x = width - (-x % width);
|
|
else
|
|
x %= width;
|
|
|
|
if (y < 0)
|
|
y = height - (-y % height);
|
|
else
|
|
y %= height;
|
|
}
|
|
/* Smear out the edges of the image by repeating pixels. */
|
|
else if (wrap_type == SMEAR)
|
|
{
|
|
if (x < 0)
|
|
x = 0;
|
|
else if (x > width - 1)
|
|
x = width - 1;
|
|
|
|
if (y < 0)
|
|
y = 0;
|
|
else if (y > height - 1)
|
|
y = height - 1;
|
|
}
|
|
|
|
if (x >= x1 && y >= y1 && x < x2 && y < y2)
|
|
{
|
|
gegl_buffer_sample (buffer, x, y, NULL, pixel, format,
|
|
GEGL_SAMPLER_NEAREST, GEGL_ABYSS_NONE);
|
|
}
|
|
else
|
|
{
|
|
gint bpp = babl_format_get_bytes_per_pixel (format);
|
|
gint b;
|
|
|
|
if (wrap_type == BLACK)
|
|
data = empty_pixel;
|
|
else
|
|
data = color_pixel; /* must have selected COLOR type */
|
|
|
|
for (b = 0; b < bpp; b++)
|
|
pixel[b] = data[b];
|
|
}
|
|
}
|
|
|
|
/* Warp interface functions */
|
|
|
|
static gboolean
|
|
warp_map_constrain (PikaImage *image,
|
|
PikaItem *item,
|
|
gpointer data)
|
|
{
|
|
PikaDrawable *d = data;
|
|
|
|
return (pika_drawable_get_width (PIKA_DRAWABLE (item)) == pika_drawable_get_width (d) &&
|
|
pika_drawable_get_height (PIKA_DRAWABLE (item)) == pika_drawable_get_height (d));
|
|
}
|
