AlderconeStudio/PIKApp
AlderconeStudio
/
PIKApp
0
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 1 Wiki Activity
PIKApp/app/tools/pikaiscissorstool.c

2193 lines
70 KiB
C
Raw Permalink Normal View History

Initial checkin of Pika from heckimp
2023-09-26 00:35:21 +02:00
/* PIKA - Photo and Image Kooker Application
* a rebranding of The GNU Image Manipulation Program (created with heckimp)
* A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
*
* Original copyright, applying to most contents (license remains unchanged):
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* 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/>.
*/
/* This tool is based on a paper from SIGGRAPH '95:
* "Intelligent Scissors for Image Composition", Eric N. Mortensen and
* William A. Barrett, Brigham Young University.
*
* thanks to Professor D. Forsyth for prompting us to implement this tool. */
/* Personal note: Dr. Barrett, one of the authors of the paper written above
* is not only one of the most brilliant people I have ever met, he is an
* incredible professor who genuinely cares about his students and wants them
* to learn as much as they can about the topic.
*
* I didn't even notice I was taking a class from the person who wrote the
* paper until halfway through the semester.
* -- Rockwalrus
*/
/* The history of this implementation is lonog and varied. It was
* originally done by Spencer and Peter, and worked fine in the 0.54
* (motif only) release of PIKA. Later revisions (0.99.something
* until about 1.1.4) completely changed the algorithm used, until it
* bore little resemblance to the one described in the paper above.
* The 0.54 version of the algorithm was then forwards ported to 1.1.4
* by Austin Donnelly.
*/
/* Livewire boundary implementation done by Laramie Leavitt */
#include "config.h"
#include <stdlib.h>
#include <gegl.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include "libpikamath/pikamath.h"
#include "libpikawidgets/pikawidgets.h"
#include "tools-types.h"
#include "gegl/pika-gegl-utils.h"
#include "core/pikachannel.h"
#include "core/pikachannel-select.h"
#include "core/pikaimage.h"
#include "core/pikapickable.h"
#include "core/pikascanconvert.h"
#include "core/pikatempbuf.h"
#include "core/pikatoolinfo.h"
#include "widgets/pikahelp-ids.h"
#include "widgets/pikawidgets-utils.h"
#include "display/pikacanvasitem.h"
#include "display/pikadisplay.h"
#include "pikaiscissorsoptions.h"
#include "pikaiscissorstool.h"
#include "pikatilehandleriscissors.h"
#include "pikatoolcontrol.h"
#include "pika-intl.h"
/* defines */
#define GRADIENT_SEARCH 32 /* how far to look when snapping to an edge */
#define EXTEND_BY 0.2 /* proportion to expand cost map by */
#define FIXED 5 /* additional fixed size to expand cost map */
#define COST_WIDTH 2 /* number of bytes for each pixel in cost map */
/* weight to give between gradient (_G) and direction (_D) */
#define OMEGA_D 0.2
#define OMEGA_G 0.8
/* sentinel to mark seed point in ?cost? map */
#define SEED_POINT 9
/* Functional defines */
#define PIXEL_COST(x) ((x) >> 8)
#define PIXEL_DIR(x) ((x) & 0x000000ff)
struct _ISegment
{
gint x1, y1;
gint x2, y2;
GPtrArray *points;
};
struct _ICurve
{
GQueue *segments;
gboolean first_point;
gboolean closed;
};
/* local function prototypes */
static void pika_iscissors_tool_finalize (GObject *object);
static void pika_iscissors_tool_control (PikaTool *tool,
PikaToolAction action,
PikaDisplay *display);
static void pika_iscissors_tool_button_press (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaButtonPressType press_type,
PikaDisplay *display);
static void pika_iscissors_tool_button_release (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaButtonReleaseType release_type,
PikaDisplay *display);
static void pika_iscissors_tool_motion (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaDisplay *display);
static void pika_iscissors_tool_oper_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
gboolean proximity,
PikaDisplay *display);
static void pika_iscissors_tool_cursor_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
PikaDisplay *display);
static gboolean pika_iscissors_tool_key_press (PikaTool *tool,
GdkEventKey *kevent,
PikaDisplay *display);
static const gchar * pika_iscissors_tool_can_undo (PikaTool *tool,
PikaDisplay *display);
static const gchar * pika_iscissors_tool_can_redo (PikaTool *tool,
PikaDisplay *display);
static gboolean pika_iscissors_tool_undo (PikaTool *tool,
PikaDisplay *display);
static gboolean pika_iscissors_tool_redo (PikaTool *tool,
PikaDisplay *display);
static void pika_iscissors_tool_draw (PikaDrawTool *draw_tool);
static void pika_iscissors_tool_push_undo (PikaIscissorsTool *iscissors);
static void pika_iscissors_tool_pop_undo (PikaIscissorsTool *iscissors);
static void pika_iscissors_tool_free_redo (PikaIscissorsTool *iscissors);
static void pika_iscissors_tool_halt (PikaIscissorsTool *iscissors,
PikaDisplay *display);
static void pika_iscissors_tool_commit (PikaIscissorsTool *iscissors,
PikaDisplay *display);
static void iscissors_convert (PikaIscissorsTool *iscissors,
PikaDisplay *display);
static GeglBuffer * gradient_map_new (PikaPickable *pickable);
static void find_optimal_path (GeglBuffer *gradient_map,
PikaTempBuf *dp_buf,
gint x1,
gint y1,
gint x2,
gint y2,
gint xs,
gint ys);
static void find_max_gradient (PikaIscissorsTool *iscissors,
PikaPickable *pickable,
gint *x,
gint *y);
static void calculate_segment (PikaIscissorsTool *iscissors,
ISegment *segment);
static PikaCanvasItem * iscissors_draw_segment (PikaDrawTool *draw_tool,
ISegment *segment);
static gint mouse_over_vertex (PikaIscissorsTool *iscissors,
gdouble x,
gdouble y);
static gboolean clicked_on_vertex (PikaIscissorsTool *iscissors,
gdouble x,
gdouble y);
static GList * mouse_over_segment (PikaIscissorsTool *iscissors,
gdouble x,
gdouble y);
static gboolean clicked_on_segment (PikaIscissorsTool *iscissors,
gdouble x,
gdouble y);
static GPtrArray * plot_pixels (PikaTempBuf *dp_buf,
gint x1,
gint y1,
gint xs,
gint ys,
gint xe,
gint ye);
static ISegment * isegment_new (gint x1,
gint y1,
gint x2,
gint y2);
static ISegment * isegment_copy (ISegment *segment);
static void isegment_free (ISegment *segment);
static ICurve * icurve_new (void);
static ICurve * icurve_copy (ICurve *curve);
static void icurve_clear (ICurve *curve);
static void icurve_free (ICurve *curve);
static ISegment * icurve_append_segment (ICurve *curve,
gint x1,
gint y1,
gint x2,
gint y2);
static ISegment * icurve_insert_segment (ICurve *curve,
GList *sibling,
gint x1,
gint y1,
gint x2,
gint y2);
static void icurve_delete_segment (ICurve *curve,
ISegment *segment);
static void icurve_close (ICurve *curve);
static PikaScanConvert *
icurve_create_scan_convert (ICurve *curve);
/* static variables */
/* where to move on a given link direction */
static const gint move[8][2] =
{
{ 1, 0 },
{ 0, 1 },
{ -1, 1 },
{ 1, 1 },
{ -1, 0 },
{ 0, -1 },
{ 1, -1 },
{ -1, -1 },
};
/* IE:
* '---+---+---`
* | 7 | 5 | 6 |
* +---+---+---+
* | 4 | | 0 |
* +---+---+---+
* | 2 | 1 | 3 |
* `---+---+---'
*/
static gfloat distance_weights[GRADIENT_SEARCH * GRADIENT_SEARCH];
static gint diagonal_weight[256];
static gint direction_value[256][4];
G_DEFINE_TYPE (PikaIscissorsTool, pika_iscissors_tool,
PIKA_TYPE_SELECTION_TOOL)
#define parent_class pika_iscissors_tool_parent_class
void
pika_iscissors_tool_register (PikaToolRegisterCallback callback,
gpointer data)
{
(* callback) (PIKA_TYPE_ISCISSORS_TOOL,
PIKA_TYPE_ISCISSORS_OPTIONS,
pika_iscissors_options_gui,
0,
"pika-iscissors-tool",
_("Scissors Select"),
_("Scissors Select Tool: Select shapes using intelligent edge-fitting"),
N_("Intelligent _Scissors"),
"I",
NULL, PIKA_HELP_TOOL_ISCISSORS,
PIKA_ICON_TOOL_ISCISSORS,
data);
}
static void
pika_iscissors_tool_class_init (PikaIscissorsToolClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
PikaToolClass *tool_class = PIKA_TOOL_CLASS (klass);
PikaDrawToolClass *draw_tool_class = PIKA_DRAW_TOOL_CLASS (klass);
gint i, j;
gint radius;
object_class->finalize = pika_iscissors_tool_finalize;
tool_class->control = pika_iscissors_tool_control;
tool_class->button_press = pika_iscissors_tool_button_press;
tool_class->button_release = pika_iscissors_tool_button_release;
tool_class->motion = pika_iscissors_tool_motion;
tool_class->key_press = pika_iscissors_tool_key_press;
tool_class->oper_update = pika_iscissors_tool_oper_update;
tool_class->cursor_update = pika_iscissors_tool_cursor_update;
tool_class->can_undo = pika_iscissors_tool_can_undo;
tool_class->can_redo = pika_iscissors_tool_can_redo;
tool_class->undo = pika_iscissors_tool_undo;
tool_class->redo = pika_iscissors_tool_redo;
draw_tool_class->draw = pika_iscissors_tool_draw;
for (i = 0; i < 256; i++)
{
/* The diagonal weight array */
diagonal_weight[i] = (int) (i * G_SQRT2);
/* The direction value array */
direction_value[i][0] = (127 - abs (127 - i)) * 2;
direction_value[i][1] = abs (127 - i) * 2;
direction_value[i][2] = abs (191 - i) * 2;
direction_value[i][3] = abs (63 - i) * 2;
}
/* set the 256th index of the direction_values to the highest cost */
direction_value[255][0] = 255;
direction_value[255][1] = 255;
direction_value[255][2] = 255;
direction_value[255][3] = 255;
/* compute the distance weights */
radius = GRADIENT_SEARCH >> 1;
for (i = 0; i < GRADIENT_SEARCH; i++)
for (j = 0; j < GRADIENT_SEARCH; j++)
distance_weights[i * GRADIENT_SEARCH + j] =
1.0 / (1 + sqrt (SQR (i - radius) + SQR (j - radius)));
}
static void
pika_iscissors_tool_init (PikaIscissorsTool *iscissors)
{
PikaTool *tool = PIKA_TOOL (iscissors);
pika_tool_control_set_scroll_lock (tool->control, TRUE);
pika_tool_control_set_snap_to (tool->control, FALSE);
pika_tool_control_set_preserve (tool->control, FALSE);
pika_tool_control_set_dirty_mask (tool->control,
PIKA_DIRTY_IMAGE_SIZE |
PIKA_DIRTY_ACTIVE_DRAWABLE);
pika_tool_control_set_tool_cursor (tool->control,
PIKA_TOOL_CURSOR_ISCISSORS);
iscissors->op = ISCISSORS_OP_NONE;
iscissors->curve = icurve_new ();
iscissors->state = NO_ACTION;
}
static void
pika_iscissors_tool_finalize (GObject *object)
{
PikaIscissorsTool *iscissors = PIKA_ISCISSORS_TOOL (object);
icurve_free (iscissors->curve);
iscissors->curve = NULL;
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
pika_iscissors_tool_control (PikaTool *tool,
PikaToolAction action,
PikaDisplay *display)
{
PikaIscissorsTool *iscissors = PIKA_ISCISSORS_TOOL (tool);
switch (action)
{
case PIKA_TOOL_ACTION_PAUSE:
case PIKA_TOOL_ACTION_RESUME:
break;
case PIKA_TOOL_ACTION_HALT:
pika_iscissors_tool_halt (iscissors, display);
break;
case PIKA_TOOL_ACTION_COMMIT:
pika_iscissors_tool_commit (iscissors, display);
break;
}
PIKA_TOOL_CLASS (parent_class)->control (tool, action, display);
}
static void
pika_iscissors_tool_button_press (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaButtonPressType press_type,
PikaDisplay *display)
{
PikaIscissorsTool *iscissors = PIKA_ISCISSORS_TOOL (tool);
PikaIscissorsOptions *options = PIKA_ISCISSORS_TOOL_GET_OPTIONS (tool);
PikaImage *image = pika_display_get_image (display);
ISegment *segment;
iscissors->x = RINT (coords->x);
iscissors->y = RINT (coords->y);
/* If the tool was being used in another image...reset it */
if (display != tool->display)
pika_tool_control (tool, PIKA_TOOL_ACTION_HALT, display);
pika_tool_control_activate (tool->control);
tool->display = display;
pika_draw_tool_pause (PIKA_DRAW_TOOL (tool));
switch (iscissors->state)
{
case NO_ACTION:
iscissors->state = SEED_PLACEMENT;
if (! (state & pika_get_extend_selection_mask ()))
find_max_gradient (iscissors, PIKA_PICKABLE (image),
&iscissors->x, &iscissors->y);
iscissors->x = CLAMP (iscissors->x, 0, pika_image_get_width (image) - 1);
iscissors->y = CLAMP (iscissors->y, 0, pika_image_get_height (image) - 1);
pika_iscissors_tool_push_undo (iscissors);
segment = icurve_append_segment (iscissors->curve,
iscissors->x,
iscissors->y,
iscissors->x,
iscissors->y);
/* Initialize the draw tool only on starting the tool */
pika_draw_tool_start (PIKA_DRAW_TOOL (tool), display);
break;
default:
/* Check if the mouse click occurred on a vertex or the curve itself */
if (clicked_on_vertex (iscissors, coords->x, coords->y))
{
iscissors->state = SEED_ADJUSTMENT;
/* recalculate both segments */
if (iscissors->segment1)
{
iscissors->segment1->x1 = iscissors->x;
iscissors->segment1->y1 = iscissors->y;
if (options->interactive)
calculate_segment (iscissors, iscissors->segment1);
}
if (iscissors->segment2)
{
iscissors->segment2->x2 = iscissors->x;
iscissors->segment2->y2 = iscissors->y;
if (options->interactive)
calculate_segment (iscissors, iscissors->segment2);
}
}
/* If the iscissors is closed, check if the click was inside */
else if (iscissors->curve->closed && iscissors->mask &&
pika_pickable_get_opacity_at (PIKA_PICKABLE (iscissors->mask),
iscissors->x,
iscissors->y))
{
pika_tool_control (tool, PIKA_TOOL_ACTION_COMMIT, display);
}
else if (! iscissors->curve->closed)
{
/* if we're not closed, we're adding a new point */
ISegment *last = g_queue_peek_tail (iscissors->curve->segments);
iscissors->state = SEED_PLACEMENT;
pika_iscissors_tool_push_undo (iscissors);
if (last->x1 == last->x2 &&
last->y1 == last->y2)
{
last->x2 = iscissors->x;
last->y2 = iscissors->y;
if (options->interactive)
calculate_segment (iscissors, last);
}
else
{
segment = icurve_append_segment (iscissors->curve,
last->x2,
last->y2,
iscissors->x,
iscissors->y);
if (options->interactive)
calculate_segment (iscissors, segment);
}
}
break;
}
pika_draw_tool_resume (PIKA_DRAW_TOOL (tool));
}
static void
iscissors_convert (PikaIscissorsTool *iscissors,
PikaDisplay *display)
{
PikaSelectionOptions *options = PIKA_SELECTION_TOOL_GET_OPTIONS (iscissors);
PikaImage *image = pika_display_get_image (display);
PikaScanConvert *sc;
sc = icurve_create_scan_convert (iscissors->curve);
if (iscissors->mask)
g_object_unref (iscissors->mask);
iscissors->mask = pika_channel_new_mask (image,
pika_image_get_width (image),
pika_image_get_height (image));
pika_scan_convert_render (sc,
pika_drawable_get_buffer (PIKA_DRAWABLE (iscissors->mask)),
0, 0, options->antialias);
pika_scan_convert_free (sc);
}
static void
pika_iscissors_tool_button_release (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaButtonReleaseType release_type,
PikaDisplay *display)
{
PikaIscissorsTool *iscissors = PIKA_ISCISSORS_TOOL (tool);
PikaIscissorsOptions *options = PIKA_ISCISSORS_TOOL_GET_OPTIONS (tool);
pika_tool_control_halt (tool->control);
/* Make sure X didn't skip the button release event -- as it's known
* to do
*/
if (iscissors->state == WAITING)
return;
pika_draw_tool_pause (PIKA_DRAW_TOOL (tool));
if (release_type != PIKA_BUTTON_RELEASE_CANCEL)
{
/* Progress to the next stage of intelligent selection */
switch (iscissors->state)
{
case SEED_PLACEMENT:
/* Add a new segment */
if (! iscissors->curve->first_point)
{
/* Determine if we're connecting to the first point */
ISegment *segment = g_queue_peek_head (iscissors->curve->segments);
if (pika_draw_tool_on_handle (PIKA_DRAW_TOOL (tool), display,
iscissors->x, iscissors->y,
PIKA_HANDLE_CIRCLE,
segment->x1, segment->y1,
PIKA_TOOL_HANDLE_SIZE_CIRCLE,
PIKA_TOOL_HANDLE_SIZE_CIRCLE,
PIKA_HANDLE_ANCHOR_CENTER))
{
iscissors->x = segment->x1;
iscissors->y = segment->y1;
icurve_close (iscissors->curve);
if (! options->interactive)
{
segment = g_queue_peek_tail (iscissors->curve->segments);
calculate_segment (iscissors, segment);
}
pika_iscissors_tool_free_redo (iscissors);
}
else
{
segment = g_queue_peek_tail (iscissors->curve->segments);
if (segment->x1 != segment->x2 ||
segment->y1 != segment->y2)
{
if (! options->interactive)
calculate_segment (iscissors, segment);
pika_iscissors_tool_free_redo (iscissors);
}
else
{
pika_iscissors_tool_pop_undo (iscissors);
}
}
}
else /* this was our first point */
{
iscissors->curve->first_point = FALSE;
pika_iscissors_tool_free_redo (iscissors);
}
break;
case SEED_ADJUSTMENT:
if (state & pika_get_modify_selection_mask ())
{
if (iscissors->segment1 && iscissors->segment2)
{
icurve_delete_segment (iscissors->curve,
iscissors->segment2);
calculate_segment (iscissors, iscissors->segment1);
}
}
else
{
/* recalculate both segments */
if (iscissors->segment1)
{
if (! options->interactive)
calculate_segment (iscissors, iscissors->segment1);
}
if (iscissors->segment2)
{
if (! options->interactive)
calculate_segment (iscissors, iscissors->segment2);
}
}
pika_iscissors_tool_free_redo (iscissors);
break;
default:
break;
}
}
else
{
switch (iscissors->state)
{
case SEED_PLACEMENT:
case SEED_ADJUSTMENT:
pika_iscissors_tool_pop_undo (iscissors);
break;
default:
break;
}
}
if (iscissors->curve->first_point)
iscissors->state = NO_ACTION;
else
iscissors->state = WAITING;
pika_draw_tool_resume (PIKA_DRAW_TOOL (tool));
/* convert the curves into a region */
if (iscissors->curve->closed)
iscissors_convert (iscissors, display);
}
static void
pika_iscissors_tool_motion (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaDisplay *display)
{
PikaIscissorsTool *iscissors = PIKA_ISCISSORS_TOOL (tool);
PikaIscissorsOptions *options = PIKA_ISCISSORS_TOOL_GET_OPTIONS (tool);
PikaImage *image = pika_display_get_image (display);
ISegment *segment;
if (iscissors->state == NO_ACTION)
return;
pika_draw_tool_pause (PIKA_DRAW_TOOL (tool));
iscissors->x = RINT (coords->x);
iscissors->y = RINT (coords->y);
/* Hold the shift key down to disable the auto-edge snap feature */
if (! (state & pika_get_extend_selection_mask ()))
find_max_gradient (iscissors, PIKA_PICKABLE (image),
&iscissors->x, &iscissors->y);
iscissors->x = CLAMP (iscissors->x, 0, pika_image_get_width (image) - 1);
iscissors->y = CLAMP (iscissors->y, 0, pika_image_get_height (image) - 1);
switch (iscissors->state)
{
case SEED_PLACEMENT:
segment = g_queue_peek_tail (iscissors->curve->segments);
segment->x2 = iscissors->x;
segment->y2 = iscissors->y;
if (iscissors->curve->first_point)
{
segment->x1 = segment->x2;
segment->y1 = segment->y2;
}
else
{
if (options->interactive)
calculate_segment (iscissors, segment);
}
break;
case SEED_ADJUSTMENT:
if (iscissors->segment1)
{
iscissors->segment1->x1 = iscissors->x;
iscissors->segment1->y1 = iscissors->y;
if (options->interactive)
calculate_segment (iscissors, iscissors->segment1);
}
if (iscissors->segment2)
{
iscissors->segment2->x2 = iscissors->x;
iscissors->segment2->y2 = iscissors->y;
if (options->interactive)
calculate_segment (iscissors, iscissors->segment2);
}
break;
default:
break;
}
pika_draw_tool_resume (PIKA_DRAW_TOOL (tool));
}
static void
pika_iscissors_tool_draw (PikaDrawTool *draw_tool)
{
PikaIscissorsTool *iscissors = PIKA_ISCISSORS_TOOL (draw_tool);
PikaIscissorsOptions *options = PIKA_ISCISSORS_TOOL_GET_OPTIONS (draw_tool);
PikaCanvasItem *item;
GList *list;
/* First, render all segments and lines */
if (! iscissors->curve->first_point)
{
for (list = g_queue_peek_head_link (iscissors->curve->segments);
list;
list = g_list_next (list))
{
ISegment *segment = list->data;
/* plot the segment */
item = iscissors_draw_segment (draw_tool, segment);
/* if this segment is currently being added or adjusted */
if ((iscissors->state == SEED_PLACEMENT &&
! list->next)
||
(iscissors->state == SEED_ADJUSTMENT &&
(segment == iscissors->segment1 ||
segment == iscissors->segment2)))
{
if (! options->interactive)
item = pika_draw_tool_add_line (draw_tool,
segment->x1, segment->y1,
segment->x2, segment->y2);
if (item)
pika_canvas_item_set_highlight (item, TRUE);
}
}
}
/* Then, render the handles on top of the segments */
for (list = g_queue_peek_head_link (iscissors->curve->segments);
list;
list = g_list_next (list))
{
ISegment *segment = list->data;
if (! iscissors->curve->first_point)
{
gboolean adjustment = (iscissors->state == SEED_ADJUSTMENT &&
segment == iscissors->segment1);
item = pika_draw_tool_add_handle (draw_tool,
adjustment ?
PIKA_HANDLE_CROSS :
PIKA_HANDLE_FILLED_CIRCLE,
segment->x1,
segment->y1,
PIKA_TOOL_HANDLE_SIZE_CIRCLE,
PIKA_TOOL_HANDLE_SIZE_CIRCLE,
PIKA_HANDLE_ANCHOR_CENTER);
if (adjustment)
pika_canvas_item_set_highlight (item, TRUE);
}
/* Draw the last point if the curve is not closed */
if (! list->next && ! iscissors->curve->closed)
{
gboolean placement = (iscissors->state == SEED_PLACEMENT);
item = pika_draw_tool_add_handle (draw_tool,
placement ?
PIKA_HANDLE_CROSS :
PIKA_HANDLE_FILLED_CIRCLE,
segment->x2,
segment->y2,
PIKA_TOOL_HANDLE_SIZE_CIRCLE,
PIKA_TOOL_HANDLE_SIZE_CIRCLE,
PIKA_HANDLE_ANCHOR_CENTER);
if (placement)
pika_canvas_item_set_highlight (item, TRUE);
}
}
}
static PikaCanvasItem *
iscissors_draw_segment (PikaDrawTool *draw_tool,
ISegment *segment)
{
PikaCanvasItem *item;
PikaVector2 *points;
gpointer *point;
gint i, len;
if (! segment->points)
return NULL;
len = segment->points->len;
points = g_new (PikaVector2, len);
for (i = 0, point = segment->points->pdata; i < len; i++, point++)
{
guint32 coords = GPOINTER_TO_INT (*point);
points[i].x = (coords & 0x0000ffff);
points[i].y = (coords >> 16);
}
item = pika_draw_tool_add_lines (draw_tool, points, len, NULL, FALSE);
g_free (points);
return item;
}
static void
pika_iscissors_tool_oper_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
gboolean proximity,
PikaDisplay *display)
{
PikaIscissorsTool *iscissors = PIKA_ISCISSORS_TOOL (tool);
PIKA_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity,
display);
/* parent sets a message in the status bar, but it will be replaced here */
if (mouse_over_vertex (iscissors, coords->x, coords->y) > 1)
{
GdkModifierType snap_mask = pika_get_extend_selection_mask ();
GdkModifierType remove_mask = pika_get_modify_selection_mask ();
if (state & remove_mask)
{
pika_tool_replace_status (tool, display,
_("Click to remove this point"));
iscissors->op = ISCISSORS_OP_REMOVE_POINT;
}
else
{
gchar *status =
pika_suggest_modifiers (_("Click-Drag to move this point"),
(snap_mask | remove_mask) & ~state,
_("%s: disable auto-snap"),
_("%s: remove this point"),
NULL);
pika_tool_replace_status (tool, display, "%s", status);
g_free (status);
iscissors->op = ISCISSORS_OP_MOVE_POINT;
}
}
else if (mouse_over_segment (iscissors, coords->x, coords->y))
{
ISegment *segment = g_queue_peek_head (iscissors->curve->segments);
if (pika_draw_tool_on_handle (PIKA_DRAW_TOOL (tool), display,
RINT (coords->x), RINT (coords->y),
PIKA_HANDLE_CIRCLE,
segment->x1, segment->y1,
PIKA_TOOL_HANDLE_SIZE_CIRCLE,
PIKA_TOOL_HANDLE_SIZE_CIRCLE,
PIKA_HANDLE_ANCHOR_CENTER))
{
pika_tool_replace_status (tool, display,
_("Click to close the curve"));
iscissors->op = ISCISSORS_OP_CONNECT;
}
else
{
pika_tool_replace_status (tool, display,
_("Click to add a point on this segment"));
iscissors->op = ISCISSORS_OP_ADD_POINT;
}
}
else if (iscissors->curve->closed && iscissors->mask)
{
if (pika_pickable_get_opacity_at (PIKA_PICKABLE (iscissors->mask),
RINT (coords->x),
RINT (coords->y)))
{
if (proximity)
{
pika_tool_replace_status (tool, display,
_("Click or press Enter to convert to"
" a selection"));
}
iscissors->op = ISCISSORS_OP_SELECT;
}
else
{
if (proximity)
{
pika_tool_replace_status (tool, display,
_("Press Enter to convert to a"
" selection"));
}
iscissors->op = ISCISSORS_OP_IMPOSSIBLE;
}
}
else
{
switch (iscissors->state)
{
case WAITING:
if (proximity)
{
GdkModifierType snap_mask = pika_get_extend_selection_mask ();
gchar *status;
status = pika_suggest_modifiers (_("Click or Click-Drag to add a"
" point"),
snap_mask & ~state,
_("%s: disable auto-snap"),
NULL, NULL);
pika_tool_replace_status (tool, display, "%s", status);
g_free (status);
}
iscissors->op = ISCISSORS_OP_ADD_POINT;
break;
default:
/* if NO_ACTION, keep parent's status bar message (selection tool) */
iscissors->op = ISCISSORS_OP_NONE;
break;
}
}
}
static void
pika_iscissors_tool_cursor_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
PikaDisplay *display)
{
PikaIscissorsTool *iscissors = PIKA_ISCISSORS_TOOL (tool);
PikaCursorModifier modifier = PIKA_CURSOR_MODIFIER_NONE;
switch (iscissors->op)
{
case ISCISSORS_OP_SELECT:
{
PikaSelectionOptions *options;
options = PIKA_SELECTION_TOOL_GET_OPTIONS (tool);
/* Do not overwrite the modifiers for add, subtract, intersect */
if (options->operation == PIKA_CHANNEL_OP_REPLACE)
{
modifier = PIKA_CURSOR_MODIFIER_SELECT;
}
}
break;
case ISCISSORS_OP_MOVE_POINT:
modifier = PIKA_CURSOR_MODIFIER_MOVE;
break;
case ISCISSORS_OP_ADD_POINT:
modifier = PIKA_CURSOR_MODIFIER_PLUS;
break;
case ISCISSORS_OP_REMOVE_POINT:
modifier = PIKA_CURSOR_MODIFIER_MINUS;
break;
case ISCISSORS_OP_CONNECT:
modifier = PIKA_CURSOR_MODIFIER_JOIN;
break;
case ISCISSORS_OP_IMPOSSIBLE:
modifier = PIKA_CURSOR_MODIFIER_BAD;
break;
default:
break;
}
if (modifier != PIKA_CURSOR_MODIFIER_NONE)
{
pika_tool_set_cursor (tool, display,
PIKA_CURSOR_MOUSE,
PIKA_TOOL_CURSOR_ISCISSORS,
modifier);
}
else
{
PIKA_TOOL_CLASS (parent_class)->cursor_update (tool, coords,
state, display);
}
}
static gboolean
pika_iscissors_tool_key_press (PikaTool *tool,
GdkEventKey *kevent,
PikaDisplay *display)
{
PikaIscissorsTool *iscissors = PIKA_ISCISSORS_TOOL (tool);
if (display != tool->display)
return FALSE;
switch (kevent->keyval)
{
case GDK_KEY_BackSpace:
if (! iscissors->curve->closed &&
g_queue_peek_tail (iscissors->curve->segments))
{
ISegment *segment = g_queue_peek_tail (iscissors->curve->segments);
if (g_queue_get_length (iscissors->curve->segments) > 1)
{
pika_draw_tool_pause (PIKA_DRAW_TOOL (tool));
pika_iscissors_tool_push_undo (iscissors);
icurve_delete_segment (iscissors->curve, segment);
pika_iscissors_tool_free_redo (iscissors);
pika_draw_tool_resume (PIKA_DRAW_TOOL (tool));
}
else if (segment->x2 != segment->x1 || segment->y2 != segment->y1)
{
pika_draw_tool_pause (PIKA_DRAW_TOOL (tool));
pika_iscissors_tool_push_undo (iscissors);
segment->x2 = segment->x1;
segment->y2 = segment->y1;
g_ptr_array_remove_range (segment->points,
0, segment->points->len);
pika_iscissors_tool_free_redo (iscissors);
pika_draw_tool_resume (PIKA_DRAW_TOOL (tool));
}
else
{
pika_tool_control (tool, PIKA_TOOL_ACTION_HALT, display);
}
return TRUE;
}
return FALSE;
case GDK_KEY_Return:
case GDK_KEY_KP_Enter:
case GDK_KEY_ISO_Enter:
if (iscissors->curve->closed && iscissors->mask)
{
pika_tool_control (tool, PIKA_TOOL_ACTION_COMMIT, display);
return TRUE;
}
return FALSE;
case GDK_KEY_Escape:
pika_tool_control (tool, PIKA_TOOL_ACTION_HALT, display);
return TRUE;
default:
return FALSE;
}
}
static const gchar *
pika_iscissors_tool_can_undo (PikaTool *tool,
PikaDisplay *display)
{
PikaIscissorsTool *iscissors = PIKA_ISCISSORS_TOOL (tool);
if (! iscissors->undo_stack)
return NULL;
return _("Modify Scissors Curve");
}
static const gchar *
pika_iscissors_tool_can_redo (PikaTool *tool,
PikaDisplay *display)
{
PikaIscissorsTool *iscissors = PIKA_ISCISSORS_TOOL (tool);
if (! iscissors->redo_stack)
return NULL;
return _("Modify Scissors Curve");
}
static gboolean
pika_iscissors_tool_undo (PikaTool *tool,
PikaDisplay *display)
{
PikaIscissorsTool *iscissors = PIKA_ISCISSORS_TOOL (tool);
pika_draw_tool_pause (PIKA_DRAW_TOOL (tool));
iscissors->redo_stack = g_list_prepend (iscissors->redo_stack,
iscissors->curve);
iscissors->curve = iscissors->undo_stack->data;
iscissors->undo_stack = g_list_remove (iscissors->undo_stack,
iscissors->curve);
if (! iscissors->undo_stack)
{
iscissors->state = NO_ACTION;
pika_draw_tool_stop (PIKA_DRAW_TOOL (tool));
}
pika_draw_tool_resume (PIKA_DRAW_TOOL (tool));
return TRUE;
}
static gboolean
pika_iscissors_tool_redo (PikaTool *tool,
PikaDisplay *display)
{
PikaIscissorsTool *iscissors = PIKA_ISCISSORS_TOOL (tool);
pika_draw_tool_pause (PIKA_DRAW_TOOL (tool));
if (! iscissors->undo_stack)
{
iscissors->state = WAITING;
pika_draw_tool_start (PIKA_DRAW_TOOL (tool), display);
}
iscissors->undo_stack = g_list_prepend (iscissors->undo_stack,
iscissors->curve);
iscissors->curve = iscissors->redo_stack->data;
iscissors->redo_stack = g_list_remove (iscissors->redo_stack,
iscissors->curve);
pika_draw_tool_resume (PIKA_DRAW_TOOL (tool));
return TRUE;
}
static void
pika_iscissors_tool_push_undo (PikaIscissorsTool *iscissors)
{
iscissors->undo_stack = g_list_prepend (iscissors->undo_stack,
icurve_copy (iscissors->curve));
}
static void
pika_iscissors_tool_pop_undo (PikaIscissorsTool *iscissors)
{
icurve_free (iscissors->curve);
iscissors->curve = iscissors->undo_stack->data;
iscissors->undo_stack = g_list_remove (iscissors->undo_stack,
iscissors->curve);
if (! iscissors->undo_stack)
{
iscissors->state = NO_ACTION;
pika_draw_tool_stop (PIKA_DRAW_TOOL (iscissors));
}
}
static void
pika_iscissors_tool_free_redo (PikaIscissorsTool *iscissors)
{
g_list_free_full (iscissors->redo_stack,
(GDestroyNotify) icurve_free);
iscissors->redo_stack = NULL;
/* update the undo actions / menu items */
pika_image_flush (pika_display_get_image (PIKA_TOOL (iscissors)->display));
}
static void
pika_iscissors_tool_halt (PikaIscissorsTool *iscissors,
PikaDisplay *display)
{
icurve_clear (iscissors->curve);
iscissors->segment1 = NULL;
iscissors->segment2 = NULL;
iscissors->state = NO_ACTION;
if (iscissors->undo_stack)
{
g_list_free_full (iscissors->undo_stack, (GDestroyNotify) icurve_free);
iscissors->undo_stack = NULL;
}
if (iscissors->redo_stack)
{
g_list_free_full (iscissors->redo_stack, (GDestroyNotify) icurve_free);
iscissors->redo_stack = NULL;
}
g_clear_object (&iscissors->gradient_map);
g_clear_object (&iscissors->mask);
}
static void
pika_iscissors_tool_commit (PikaIscissorsTool *iscissors,
PikaDisplay *display)
{
PikaTool *tool = PIKA_TOOL (iscissors);
PikaSelectionOptions *options = PIKA_SELECTION_TOOL_GET_OPTIONS (tool);
PikaImage *image = pika_display_get_image (display);
if (! iscissors->curve->closed)
{
ISegment *first = g_queue_peek_head (iscissors->curve->segments);
ISegment *last = g_queue_peek_tail (iscissors->curve->segments);
if (first && last && first != last)
{
ISegment *segment;
segment = icurve_append_segment (iscissors->curve,
last->x2,
last->y2,
first->x1,
first->y1);
icurve_close (iscissors->curve);
calculate_segment (iscissors, segment);
iscissors_convert (iscissors, display);
}
}
if (iscissors->curve->closed && iscissors->mask)
{
pika_channel_select_channel (pika_image_get_mask (image),
pika_tool_get_undo_desc (tool),
iscissors->mask,
0, 0,
options->operation,
options->feather,
options->feather_radius,
options->feather_radius);
pika_image_flush (image);
}
}
/* XXX need some scan-conversion routines from somewhere. maybe. ? */
static gint
mouse_over_vertex (PikaIscissorsTool *iscissors,
gdouble x,
gdouble y)
{
GList *list;
gint segments_found = 0;
/* traverse through the list, returning non-zero if the current cursor
* position is on an existing curve vertex. Set the segment1 and segment2
* variables to the two segments containing the vertex in question
*/
iscissors->segment1 = iscissors->segment2 = NULL;
for (list = g_queue_peek_head_link (iscissors->curve->segments);
list;
list = g_list_next (list))
{
ISegment *segment = list->data;
if (pika_draw_tool_on_handle (PIKA_DRAW_TOOL (iscissors),
PIKA_TOOL (iscissors)->display,
x, y,
PIKA_HANDLE_CIRCLE,
segment->x1, segment->y1,
PIKA_TOOL_HANDLE_SIZE_CIRCLE,
PIKA_TOOL_HANDLE_SIZE_CIRCLE,
PIKA_HANDLE_ANCHOR_CENTER))
{
iscissors->segment1 = segment;
if (segments_found++)
return segments_found;
}
else if (pika_draw_tool_on_handle (PIKA_DRAW_TOOL (iscissors),
PIKA_TOOL (iscissors)->display,
x, y,
PIKA_HANDLE_CIRCLE,
segment->x2, segment->y2,
PIKA_TOOL_HANDLE_SIZE_CIRCLE,
PIKA_TOOL_HANDLE_SIZE_CIRCLE,
PIKA_HANDLE_ANCHOR_CENTER))
{
iscissors->segment2 = segment;
if (segments_found++)
return segments_found;
}
}
return segments_found;
}
static gboolean
clicked_on_vertex (PikaIscissorsTool *iscissors,
gdouble x,
gdouble y)
{
gint segments_found = mouse_over_vertex (iscissors, x, y);
if (segments_found > 1)
{
pika_iscissors_tool_push_undo (iscissors);
return TRUE;
}
/* if only one segment was found, the segments are unconnected, and
* the user only wants to move either the first or last point
* disallow this for now.
*/
if (segments_found == 1)
return FALSE;
return clicked_on_segment (iscissors, x, y);
}
static GList *
mouse_over_segment (PikaIscissorsTool *iscissors,
gdouble x,
gdouble y)
{
GList *list;
/* traverse through the list, returning the curve segment's list element
* if the current cursor position is on a curve...
*/
for (list = g_queue_peek_head_link (iscissors->curve->segments);
list;
list = g_list_next (list))
{
ISegment *segment = list->data;
gpointer *pt;
gint len;
if (! segment->points)
continue;
pt = segment->points->pdata;
len = segment->points->len;
while (len--)
{
guint32 coords = GPOINTER_TO_INT (*pt);
gint tx, ty;
pt++;
tx = coords & 0x0000ffff;
ty = coords >> 16;
/* Is the specified point close enough to the segment? */
if (pika_draw_tool_calc_distance_square (PIKA_DRAW_TOOL (iscissors),
PIKA_TOOL (iscissors)->display,
tx, ty,
x, y) < SQR (PIKA_TOOL_HANDLE_SIZE_CIRCLE / 2))
{
return list;
}
}
}
return NULL;
}
static gboolean
clicked_on_segment (PikaIscissorsTool *iscissors,
gdouble x,
gdouble y)
{
GList *list = mouse_over_segment (iscissors, x, y);
/* traverse through the list, getting back the curve segment's list
* element if the current cursor position is on a segment...
* If this occurs, replace the segment with two new segments,
* separated by a new vertex.
*/
if (list)
{
ISegment *segment = list->data;
ISegment *new_segment;
pika_iscissors_tool_push_undo (iscissors);
new_segment = icurve_insert_segment (iscissors->curve,
list,
iscissors->x,
iscissors->y,
segment->x2,
segment->y2);
iscissors->segment1 = new_segment;
iscissors->segment2 = segment;
return TRUE;
}
return FALSE;
}
static void
calculate_segment (PikaIscissorsTool *iscissors,
ISegment *segment)
{
PikaDisplay *display = PIKA_TOOL (iscissors)->display;
PikaPickable *pickable = PIKA_PICKABLE (pika_display_get_image (display));
gint width;
gint height;
gint xs, ys, xe, ye;
gint x1, y1, x2, y2;
gint ewidth, eheight;
/* Initialise the gradient map buffer for this pickable if we don't
* already have one.
*/
if (! iscissors->gradient_map)
iscissors->gradient_map = gradient_map_new (pickable);
width = gegl_buffer_get_width (iscissors->gradient_map);
height = gegl_buffer_get_height (iscissors->gradient_map);
/* Calculate the lowest cost path from one vertex to the next as specified
* by the parameter "segment".
* Here are the steps:
* 1) Calculate the appropriate working area for this operation
* 2) Allocate a temp buf for the dynamic programming array
* 3) Run the dynamic programming algorithm to find the optimal path
* 4) Translate the optimal path into pixels in the isegment data
* structure.
*/
/* Get the bounding box */
xs = CLAMP (segment->x1, 0, width - 1);
ys = CLAMP (segment->y1, 0, height - 1);
xe = CLAMP (segment->x2, 0, width - 1);
ye = CLAMP (segment->y2, 0, height - 1);
x1 = MIN (xs, xe);
y1 = MIN (ys, ye);
x2 = MAX (xs, xe) + 1; /* +1 because if xe = 199 & xs = 0, x2 - x1, width = 200 */
y2 = MAX (ys, ye) + 1;
/* expand the boundaries past the ending points by
* some percentage of width and height. This serves the following purpose:
* It gives the algorithm more area to search so better solutions
* are found. This is particularly helpful in finding "bumps" which
* fall outside the bounding box represented by the start and end
* coordinates of the "segment".
*/
ewidth = (x2 - x1) * EXTEND_BY + FIXED;
eheight = (y2 - y1) * EXTEND_BY + FIXED;
if (xe >= xs)
x2 += CLAMP (ewidth, 0, width - x2);
else
x1 -= CLAMP (ewidth, 0, x1);
if (ye >= ys)
y2 += CLAMP (eheight, 0, height - y2);
else
y1 -= CLAMP (eheight, 0, y1);
/* blow away any previous points list we might have */
if (segment->points)
{
g_ptr_array_free (segment->points, TRUE);
segment->points = NULL;
}
if ((x2 - x1) && (y2 - y1))
{
/* If the bounding box has width and height... */
PikaTempBuf *dp_buf; /* dynamic programming buffer */
gint dp_width = (x2 - x1);
gint dp_height = (y2 - y1);
dp_buf = pika_temp_buf_new (dp_width, dp_height,
babl_format ("Y u32"));
/* find the optimal path of pixels from (x1, y1) to (x2, y2) */
find_optimal_path (iscissors->gradient_map, dp_buf,
x1, y1, x2, y2, xs, ys);
/* get a list of the pixels in the optimal path */
segment->points = plot_pixels (dp_buf, x1, y1, xs, ys, xe, ye);
pika_temp_buf_unref (dp_buf);
}
else if ((x2 - x1) == 0)
{
/* If the bounding box has no width */
/* plot a vertical line */
gint y = ys;
gint dir = (ys > ye) ? -1 : 1;
segment->points = g_ptr_array_new ();
while (y != ye)
{
g_ptr_array_add (segment->points, GINT_TO_POINTER ((y << 16) + xs));
y += dir;
}
}
else if ((y2 - y1) == 0)
{
/* If the bounding box has no height */
/* plot a horizontal line */
gint x = xs;
gint dir = (xs > xe) ? -1 : 1;
segment->points = g_ptr_array_new ();
while (x != xe)
{
g_ptr_array_add (segment->points, GINT_TO_POINTER ((ys << 16) + x));
x += dir;
}
}
}
/* badly need to get a replacement - this is _way_ too expensive */
static gboolean
gradient_map_value (GeglSampler *map_sampler,
const GeglRectangle *map_extent,
gint x,
gint y,
guint8 *grad,
guint8 *dir)
{
if (x >= map_extent->x &&
y >= map_extent->y &&
x < map_extent->width &&
y < map_extent->height)
{
guint8 sample[2];
gegl_sampler_get (map_sampler, x, y, NULL, sample, GEGL_ABYSS_NONE);
*grad = sample[0];
*dir = sample[1];
return TRUE;
}
return FALSE;
}
static gint
calculate_link (GeglSampler *map_sampler,
const GeglRectangle *map_extent,
gint x,
gint y,
guint32 pixel,
gint link)
{
gint value = 0;
guint8 grad1, dir1, grad2, dir2;
if (! gradient_map_value (map_sampler, map_extent, x, y, &grad1, &dir1))
{
grad1 = 0;
dir1 = 255;
}
/* Convert the gradient into a cost: large gradients are good, and
* so have low cost. */
grad1 = 255 - grad1;
/* calculate the contribution of the gradient magnitude */
if (link > 1)
value += diagonal_weight[grad1] * OMEGA_G;
else
value += grad1 * OMEGA_G;
/* calculate the contribution of the gradient direction */
x += (gint8)(pixel & 0xff);
y += (gint8)((pixel & 0xff00) >> 8);
if (! gradient_map_value (map_sampler, map_extent, x, y, &grad2, &dir2))
{
grad2 = 0;
dir2 = 255;
}
value +=
(direction_value[dir1][link] + direction_value[dir2][link]) * OMEGA_D;
return value;
}
static GPtrArray *
plot_pixels (PikaTempBuf *dp_buf,
gint x1,
gint y1,
gint xs,
gint ys,
gint xe,
gint ye)
{
gint x, y;
guint32 coords;
gint link;
gint width = pika_temp_buf_get_width (dp_buf);
guint *data;
GPtrArray *list;
/* Start the data pointer at the correct location */
data = (guint *) pika_temp_buf_get_data (dp_buf) + (ye - y1) * width + (xe - x1);
x = xe;
y = ye;
list = g_ptr_array_new ();
while (TRUE)
{
coords = (y << 16) + x;
g_ptr_array_add (list, GINT_TO_POINTER (coords));
link = PIXEL_DIR (*data);
if (link == SEED_POINT)
return list;
x += move[link][0];
y += move[link][1];
data += move[link][1] * width + move[link][0];
}
/* won't get here */
return NULL;
}
#define PACK(x, y) ((((y) & 0xff) << 8) | ((x) & 0xff))
#define OFFSET(pixel) ((gint8)((pixel) & 0xff) + \
((gint8)(((pixel) & 0xff00) >> 8)) * \
pika_temp_buf_get_width (dp_buf))
static void
find_optimal_path (GeglBuffer *gradient_map,
PikaTempBuf *dp_buf,
gint x1,
gint y1,
gint x2,
gint y2,
gint xs,
gint ys)
{
GeglSampler *map_sampler;
const GeglRectangle *map_extent;
gint i, j, k;
gint x, y;
gint link;
gint linkdir;
gint dirx, diry;
gint min_cost;
gint new_cost;
gint offset;
gint cum_cost[8];
gint link_cost[8];
gint pixel_cost[8];
guint32 pixel[8];
guint32 *data;
guint32 *d;
gint dp_buf_width = pika_temp_buf_get_width (dp_buf);
gint dp_buf_height = pika_temp_buf_get_height (dp_buf);
/* initialize the gradient map sampler and extent */
map_sampler = gegl_buffer_sampler_new (gradient_map,
gegl_buffer_get_format (gradient_map),
GEGL_SAMPLER_NEAREST);
map_extent = gegl_buffer_get_extent (gradient_map);
/* initialize the dynamic programming buffer */
data = (guint32 *) pika_temp_buf_data_clear (dp_buf);
/* what directions are we filling the array in according to? */
dirx = (xs - x1 == 0) ? 1 : -1;
diry = (ys - y1 == 0) ? 1 : -1;
linkdir = (dirx * diry);
y = ys;
for (i = 0; i < dp_buf_height; i++)
{
x = xs;
d = data + (y-y1) * dp_buf_width + (x-x1);
for (j = 0; j < dp_buf_width; j++)
{
min_cost = G_MAXINT;
/* pixel[] array encodes how to get to a neighbour, if possible.
* 0 means no connection (eg edge).
* Rest packed as bottom two bytes: y offset then x offset.
* Initially, we assume we can't get anywhere.
*/
for (k = 0; k < 8; k++)
pixel[k] = 0;
/* Find the valid neighboring pixels */
/* the previous pixel */
if (j)
pixel[((dirx == 1) ? 4 : 0)] = PACK (-dirx, 0);
/* the previous row of pixels */
if (i)
{
pixel[((diry == 1) ? 5 : 1)] = PACK (0, -diry);
link = (linkdir == 1) ? 3 : 2;
if (j)
pixel[((diry == 1) ? (link + 4) : link)] = PACK (-dirx, -diry);
link = (linkdir == 1) ? 2 : 3;
if (j != dp_buf_width - 1)
pixel[((diry == 1) ? (link + 4) : link)] = PACK (dirx, -diry);
}
/* find the minimum cost of going through each neighbor to reach the
* seed point...
*/
link = -1;
for (k = 0; k < 8; k ++)
if (pixel[k])
{
link_cost[k] = calculate_link (map_sampler, map_extent,
xs + j*dirx, ys + i*diry,
pixel [k],
((k > 3) ? k - 4 : k));
offset = OFFSET (pixel [k]);
pixel_cost[k] = PIXEL_COST (d[offset]);
cum_cost[k] = pixel_cost[k] + link_cost[k];
if (cum_cost[k] < min_cost)
{
min_cost = cum_cost[k];
link = k;
}
}
/* If anything can be done... */
if (link >= 0)
{
/* set the cumulative cost of this pixel and the new direction
*/
*d = (cum_cost[link] << 8) + link;
/* possibly change the links from the other pixels to this pixel...
* these changes occur if a neighboring pixel will receive a lower
* cumulative cost by going through this pixel.
*/
for (k = 0; k < 8; k ++)
if (pixel[k] && k != link)
{
/* if the cumulative cost at the neighbor is greater than
* the cost through the link to the current pixel, change the
* neighbor's link to point to the current pixel.
*/
new_cost = link_cost[k] + cum_cost[link];
if (pixel_cost[k] > new_cost)
{
/* reverse the link direction /--------------------\ */
offset = OFFSET (pixel[k]);
d[offset] = (new_cost << 8) + ((k > 3) ? k - 4 : k + 4);
}
}
}
/* Set the seed point */
else if (!i && !j)
{
*d = SEED_POINT;
}
/* increment the data pointer and the x counter */
d += dirx;
x += dirx;
}
/* increment the y counter */
y += diry;
}
g_object_unref (map_sampler);
}
static GeglBuffer *
gradient_map_new (PikaPickable *pickable)
{
GeglBuffer *buffer;
GeglTileHandler *handler;
buffer = pika_pickable_get_buffer (pickable);
buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0,
gegl_buffer_get_width (buffer),
gegl_buffer_get_height (buffer)),
babl_format_n (babl_type ("u8"), 2));
handler = pika_tile_handler_iscissors_new (pickable);
pika_tile_handler_validate_assign (PIKA_TILE_HANDLER_VALIDATE (handler),
buffer);
pika_tile_handler_validate_invalidate (PIKA_TILE_HANDLER_VALIDATE (handler),
GEGL_RECTANGLE (0, 0,
gegl_buffer_get_width (buffer),
gegl_buffer_get_height (buffer)));
g_object_unref (handler);
return buffer;
}
static void
find_max_gradient (PikaIscissorsTool *iscissors,
PikaPickable *pickable,
gint *x,
gint *y)
{
GeglBufferIterator *iter;
GeglRectangle *roi;
gint width;
gint height;
gint radius;
gint cx, cy;
gint x1, y1, x2, y2;
gfloat max_gradient;
/* Initialise the gradient map buffer for this pickable if we don't
* already have one.
*/
if (! iscissors->gradient_map)
iscissors->gradient_map = gradient_map_new (pickable);
width = gegl_buffer_get_width (iscissors->gradient_map);
height = gegl_buffer_get_height (iscissors->gradient_map);
radius = GRADIENT_SEARCH >> 1;
/* calculate the extent of the search */
cx = CLAMP (*x, 0, width);
cy = CLAMP (*y, 0, height);
x1 = CLAMP (cx - radius, 0, width);
y1 = CLAMP (cy - radius, 0, height);
x2 = CLAMP (cx + radius, 0, width);
y2 = CLAMP (cy + radius, 0, height);
/* calculate the factor to multiply the distance from the cursor by */
max_gradient = 0;
*x = cx;
*y = cy;
iter = gegl_buffer_iterator_new (iscissors->gradient_map,
GEGL_RECTANGLE (x1, y1, x2 - x1, y2 - y1),
0, NULL,
GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 1);
roi = &iter->items[0].roi;
while (gegl_buffer_iterator_next (iter))
{
guint8 *data = iter->items[0].data;
gint endx = roi->x + roi->width;
gint endy = roi->y + roi->height;
gint i, j;
for (i = roi->y; i < endy; i++)
{
const guint8 *gradient = data + 2 * roi->width * (i - roi->y);
for (j = roi->x; j < endx; j++)
{
gfloat g = *gradient;
gradient += COST_WIDTH;
g *= distance_weights [(i - y1) * GRADIENT_SEARCH + (j - x1)];
if (g > max_gradient)
{
max_gradient = g;
*x = j;
*y = i;
}
}
}
}
}
static ISegment *
isegment_new (gint x1,
gint y1,
gint x2,
gint y2)
{
ISegment *segment = g_slice_new0 (ISegment);
segment->x1 = x1;
segment->y1 = y1;
segment->x2 = x2;
segment->y2 = y2;
return segment;
}
static ISegment *
isegment_copy (ISegment *segment)
{
ISegment *copy = isegment_new (segment->x1,
segment->y1,
segment->x2,
segment->y2);
if (segment->points)
{
gint i;
copy->points = g_ptr_array_sized_new (segment->points->len);
for (i = 0; i < segment->points->len; i++)
{
gpointer value = g_ptr_array_index (segment->points, i);
g_ptr_array_add (copy->points, value);
}
}
return copy;
}
static void
isegment_free (ISegment *segment)
{
if (segment->points)
g_ptr_array_free (segment->points, TRUE);
g_slice_free (ISegment, segment);
}
static ICurve *
icurve_new (void)
{
ICurve *curve = g_slice_new0 (ICurve);
curve->segments = g_queue_new ();
curve->first_point = TRUE;
return curve;
}
static ICurve *
icurve_copy (ICurve *curve)
{
ICurve *copy = icurve_new ();
GList *link;
for (link = g_queue_peek_head_link (curve->segments);
link;
link = g_list_next (link))
{
g_queue_push_tail (copy->segments, isegment_copy (link->data));
}
copy->first_point = curve->first_point;
copy->closed = curve->closed;
return copy;
}
static void
icurve_clear (ICurve *curve)
{
while (! g_queue_is_empty (curve->segments))
isegment_free (g_queue_pop_head (curve->segments));
curve->first_point = TRUE;
curve->closed = FALSE;
}
static void
icurve_free (ICurve *curve)
{
g_queue_free_full (curve->segments, (GDestroyNotify) isegment_free);
g_slice_free (ICurve, curve);
}
static ISegment *
icurve_append_segment (ICurve *curve,
gint x1,
gint y1,
gint x2,
gint y2)
{
ISegment *segment = isegment_new (x1, y1, x2, y2);
g_queue_push_tail (curve->segments, segment);
return segment;
}
static ISegment *
icurve_insert_segment (ICurve *curve,
GList *sibling,
gint x1,
gint y1,
gint x2,
gint y2)
{
ISegment *segment = sibling->data;
ISegment *new_segment;
new_segment = isegment_new (x1, y1, x2, y2);
segment->x2 = x1;
segment->y2 = y1;
g_queue_insert_after (curve->segments, sibling, new_segment);
return new_segment;
}
static void
icurve_delete_segment (ICurve *curve,
ISegment *segment)
{
GList *link = g_queue_find (curve->segments, segment);
ISegment *next_segment = NULL;
if (link->next)
next_segment = link->next->data;
else if (curve->closed)
next_segment = g_queue_peek_head (curve->segments);
if (next_segment)
{
next_segment->x1 = segment->x1;
next_segment->y1 = segment->y1;
}
g_queue_remove (curve->segments, segment);
isegment_free (segment);
}
static void
icurve_close (ICurve *curve)
{
ISegment *first = g_queue_peek_head (curve->segments);
ISegment *last = g_queue_peek_tail (curve->segments);
last->x2 = first->x1;
last->y2 = first->y1;
curve->closed = TRUE;
}
static PikaScanConvert *
icurve_create_scan_convert (ICurve *curve)
{
PikaScanConvert *sc;
GList *list;
PikaVector2 *points;
guint n_total_points = 0;
sc = pika_scan_convert_new ();
for (list = g_queue_peek_tail_link (curve->segments);
list;
list = g_list_previous (list))
{
ISegment *segment = list->data;
n_total_points += segment->points->len;
}
points = g_new (PikaVector2, n_total_points);
n_total_points = 0;
/* go over the segments in reverse order, adding the points we have */
for (list = g_queue_peek_tail_link (curve->segments);
list;
list = g_list_previous (list))
{
ISegment *segment = list->data;
guint n_points;
gint i;
n_points = segment->points->len;
for (i = 0; i < n_points; i++)
{
guint32 packed = GPOINTER_TO_INT (g_ptr_array_index (segment->points,
i));
points[n_total_points + i].x = packed & 0x0000ffff;
points[n_total_points + i].y = packed >> 16;
}
n_total_points += n_points;
}
pika_scan_convert_add_polyline (sc, n_total_points, points, TRUE);
g_free (points);
return sc;
}