~centralelyon2010/inkscape/imagelinks2

/** @file

 * @brief Bucket fill drawing context, works by bitmap filling an area on a rendered version

 * of the current display and then tracing the result using potrace.

 */

/* Author:

 *   Lauris Kaplinski <lauris@kaplinski.com>

 *   bulia byak <buliabyak@users.sf.net>

 *   John Bintz <jcoswell@coswellproductions.org>

 *   Jon A. Cruz <jon@joncruz.org>

 *   Abhishek Sharma

 *

 * Copyright (C) 2006      Johan Engelen <johan@shouraizou.nl>

 * Copyright (C) 2000-2005 authors

 * Copyright (C) 2000-2001 Ximian, Inc.

 *

 * Released under GNU GPL, read the file 'COPYING' for more information

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <2geom/pathvector.h>

#include <gdk/gdkkeysyms.h>

#include <queue>

#include <deque>

#include <glibmm/i18n.h>

#include "color.h"

#include "context-fns.h"

#include "desktop.h"

#include "desktop-handles.h"

#include "desktop-style.h"

#include "display/cairo-utils.h"

#include "display/drawing-context.h"

#include "display/drawing-image.h"

#include "display/drawing-item.h"

#include "display/drawing.h"

#include "display/sp-canvas.h"

#include "document.h"

#include "flood-context.h"

#include "livarot/Path.h"

#include "livarot/Shape.h"

#include "macros.h"

#include "message-context.h"

#include "message-stack.h"

#include "object-edit.h"

#include "preferences.h"

#include "rubberband.h"

#include "selection.h"

#include "shape-editor.h"

#include "sp-defs.h"

#include "sp-item.h"

#include "splivarot.h"

#include "sp-metrics.h"

#include "sp-namedview.h"

#include "sp-object.h"

#include "sp-path.h"

#include "sp-rect.h"

#include "sp-root.h"

#include "svg/svg.h"

#include "trace/imagemap.h"

#include "trace/potrace/inkscape-potrace.h"

#include "trace/trace.h"

#include "xml/node-event-vector.h"

#include "xml/repr.h"

#include "pixmaps/cursor-paintbucket.xpm"

using Inkscape::DocumentUndo;

static void sp_flood_context_class_init(SPFloodContextClass *klass);

static void sp_flood_context_init(SPFloodContext *flood_context);

static void sp_flood_context_dispose(GObject *object);

static void sp_flood_context_setup(SPEventContext *ec);

static gint sp_flood_context_root_handler(SPEventContext *event_context, GdkEvent *event);

static gint sp_flood_context_item_handler(SPEventContext *event_context, SPItem *item, GdkEvent *event);

static void sp_flood_finish(SPFloodContext *rc);

static SPEventContextClass *parent_class;

GType sp_flood_context_get_type()

{

    static GType type = 0;

    if (!type) {

        GTypeInfo info = {

            sizeof(SPFloodContextClass),

            NULL, NULL,

            (GClassInitFunc) sp_flood_context_class_init,

            NULL, NULL,

            sizeof(SPFloodContext),

            4,

            (GInstanceInitFunc) sp_flood_context_init,

            NULL,    /* value_table */

        };

        type = g_type_register_static(SP_TYPE_EVENT_CONTEXT, "SPFloodContext", &info, (GTypeFlags) 0);

    }

    return type;

}

static void sp_flood_context_class_init(SPFloodContextClass *klass)

{

    GObjectClass *object_class = (GObjectClass *) klass;

    SPEventContextClass *event_context_class = (SPEventContextClass *) klass;

    parent_class = (SPEventContextClass *) g_type_class_peek_parent(klass);

    object_class->dispose = sp_flood_context_dispose;

    event_context_class->setup = sp_flood_context_setup;

    event_context_class->root_handler  = sp_flood_context_root_handler;

    event_context_class->item_handler  = sp_flood_context_item_handler;

}

static void sp_flood_context_init(SPFloodContext *flood_context)

{

    SPEventContext *event_context = SP_EVENT_CONTEXT(flood_context);

    event_context->cursor_shape = cursor_paintbucket_xpm;

    event_context->hot_x = 11;

    event_context->hot_y = 30;

    event_context->xp = 0;

    event_context->yp = 0;

    event_context->tolerance = 4;

    event_context->within_tolerance = false;

    event_context->item_to_select = NULL;

    flood_context->item = NULL;

    new (&flood_context->sel_changed_connection) sigc::connection();

}

static void sp_flood_context_dispose(GObject *object)

{

    SPFloodContext *rc = SP_FLOOD_CONTEXT(object);

    SPEventContext *ec = SP_EVENT_CONTEXT(object);

    rc->sel_changed_connection.disconnect();

    rc->sel_changed_connection.~connection();

    delete ec->shape_editor;

    ec->shape_editor = NULL;

    /* fixme: This is necessary because we do not grab */

    if (rc->item) {

        sp_flood_finish(rc);

    }

    if (rc->_message_context) {

        delete rc->_message_context;

    }

    G_OBJECT_CLASS(parent_class)->dispose(object);

}

/**

\brief  Callback that processes the "changed" signal on the selection;

destroys old and creates new knotholder

*/

void sp_flood_context_selection_changed(Inkscape::Selection *selection, gpointer data)

{

    SPFloodContext *rc = SP_FLOOD_CONTEXT(data);

    SPEventContext *ec = SP_EVENT_CONTEXT(rc);

    ec->shape_editor->unset_item(SH_KNOTHOLDER);

    SPItem *item = selection->singleItem(); 

    ec->shape_editor->set_item(item, SH_KNOTHOLDER);

}

static void sp_flood_context_setup(SPEventContext *ec)

{

    SPFloodContext *rc = SP_FLOOD_CONTEXT(ec);

    if (((SPEventContextClass *) parent_class)->setup) {

        ((SPEventContextClass *) parent_class)->setup(ec);

    }

    ec->shape_editor = new ShapeEditor(ec->desktop);

    SPItem *item = sp_desktop_selection(ec->desktop)->singleItem();

    if (item) {

        ec->shape_editor->set_item(item, SH_KNOTHOLDER);

    }

    rc->sel_changed_connection.disconnect();

    rc->sel_changed_connection = sp_desktop_selection(ec->desktop)->connectChanged(

        sigc::bind(sigc::ptr_fun(&sp_flood_context_selection_changed), (gpointer)rc)

    );

    rc->_message_context = new Inkscape::MessageContext((ec->desktop)->messageStack());

    Inkscape::Preferences *prefs = Inkscape::Preferences::get();

    if (prefs->getBool("/tools/paintbucket/selcue")) {

        rc->enableSelectionCue();

    }

}

inline static guint32

compose_onto (guint32 px, guint32 bg)

{

    EXTRACT_ARGB32(px, ap,rp,gp,bp)

    EXTRACT_ARGB32(bg, ab,rb,gb,bb)

    guint32 ao,ro,bo,go;

    ao = 255*255 - (255-ap)*(255-bp);  ao = (ao + 127) / 255;

    ro = (255-ap)*rb + rp;             ro = (ro + 127) / 255;

    go = (255-ap)*gb + gp;             go = (go + 127) / 255;

    bo = (255-ap)*bb + bp;             bo = (bo + 127) / 255;

    ASSEMBLE_ARGB32(pxout, ao,ro,go,bo)

    return pxout;

}

/**

 * \brief Get the pointer to a pixel in a pixel buffer.

 * \param px The pixel buffer.

 * \param x The X coordinate.

 * \param y The Y coordinate.

 * \param stride The rowstride of the pixel buffer.

 */

inline guint32 get_pixel(guchar *px, int x, int y, int stride) {

    return *reinterpret_cast<guint32*>(px + y * stride + x * 4);

}

inline unsigned char * get_trace_pixel(guchar *trace_px, int x, int y, int width) {

    return trace_px + (x + y * width);

}

/**

 * \brief Generate the list of trace channel selection entries.

 */

GList * flood_channels_dropdown_items_list() {

    GList *glist = NULL;

    glist = g_list_append (glist, _("Visible Colors"));

    glist = g_list_append (glist, _("Red"));

    glist = g_list_append (glist, _("Green"));

    glist = g_list_append (glist, _("Blue"));

    glist = g_list_append (glist, _("Hue"));

    glist = g_list_append (glist, _("Saturation"));

    glist = g_list_append (glist, _("Lightness"));

    glist = g_list_append (glist, _("Alpha"));

    return glist;

}

/**

 * \brief Generate the list of autogap selection entries.

 */

GList * flood_autogap_dropdown_items_list() {

    GList *glist = NULL;

    glist = g_list_append (glist, (void*) C_("Flood autogap", "None"));

    glist = g_list_append (glist, (void*) C_("Flood autogap", "Small"));

    glist = g_list_append (glist, (void*) C_("Flood autogap", "Medium"));

    glist = g_list_append (glist, (void*) C_("Flood autogap", "Large"));

    return glist;

}

/**

 * \brief Compare a pixel in a pixel buffer with another pixel to determine if a point should be included in the fill operation.

 * \param check The pixel in the pixel buffer to check.

 * \param orig The original selected pixel to use as the fill target color.

 * \param merged_orig_pixel The original pixel merged with the background.

 * \param dtc The desktop background color.

 * \param threshold The fill threshold.

 * \param method The fill method to use as defined in PaintBucketChannels.

 */

static bool compare_pixels(guint32 check, guint32 orig, guint32 merged_orig_pixel, guint32 dtc, int threshold, PaintBucketChannels method)

{

    int diff = 0;

    float hsl_check[3] = {0,0,0}, hsl_orig[3] = {0,0,0};

    EXTRACT_ARGB32(check, ac,rc,gc,bc)

    EXTRACT_ARGB32(orig, ao,ro,go,bo)

    EXTRACT_ARGB32(dtc, ad,rd,gd,bd)

    EXTRACT_ARGB32(merged_orig_pixel, amop,rmop,gmop,bmop)

    if ((method == FLOOD_CHANNELS_H) ||

        (method == FLOOD_CHANNELS_S) ||

        (method == FLOOD_CHANNELS_L)) {

        double dac = ac;

        double dao = ao;

        sp_color_rgb_to_hsl_floatv(hsl_check, rc / dac, gc / dac, bc / dac);

        sp_color_rgb_to_hsl_floatv(hsl_orig, ro / dao, go / dao, bo / dao);

    }

    switch (method) {

        case FLOOD_CHANNELS_ALPHA:

            return abs(static_cast<int>(ac) - ao) <= threshold;

        case FLOOD_CHANNELS_R:

            return abs(static_cast<int>(ac ? unpremul_alpha(rc, ac) : 0) - (ao ? unpremul_alpha(ro, ao) : 0)) <= threshold;

        case FLOOD_CHANNELS_G:

            return abs(static_cast<int>(ac ? unpremul_alpha(gc, ac) : 0) - (ao ? unpremul_alpha(go, ao) : 0)) <= threshold;

        case FLOOD_CHANNELS_B:

            return abs(static_cast<int>(ac ? unpremul_alpha(bc, ac) : 0) - (ao ? unpremul_alpha(bo, ao) : 0)) <= threshold;

        case FLOOD_CHANNELS_RGB:

            guint32 amc, rmc, bmc, gmc;

            amc = 255*255 - (255-ac)*(255-ad); amc = (amc + 127) / 255;

            rmc = (255-ac)*rd + rc; rmc = (rmc + 127) / 255;

            gmc = (255-ac)*gd + gc; gmc = (gmc + 127) / 255;

            bmc = (255-ac)*bd + bc; bmc = (bmc + 127) / 255;

            diff += abs(static_cast<int>(amc ? unpremul_alpha(rmc, amc) : 0) - (amop ? unpremul_alpha(rmop, amop) : 0));

            diff += abs(static_cast<int>(amc ? unpremul_alpha(gmc, amc) : 0) - (amop ? unpremul_alpha(gmop, amop) : 0));

            diff += abs(static_cast<int>(amc ? unpremul_alpha(bmc, amc) : 0) - (amop ? unpremul_alpha(bmop, amop) : 0));

            return ((diff / 3) <= ((threshold * 3) / 4));

        case FLOOD_CHANNELS_H:

            return ((int)(fabs(hsl_check[0] - hsl_orig[0]) * 100.0) <= threshold);

        case FLOOD_CHANNELS_S:

            return ((int)(fabs(hsl_check[1] - hsl_orig[1]) * 100.0) <= threshold);

        case FLOOD_CHANNELS_L:

            return ((int)(fabs(hsl_check[2] - hsl_orig[2]) * 100.0) <= threshold);

    }

    return false;

}

enum {

  PIXEL_CHECKED = 1,

  PIXEL_QUEUED  = 2,

  PIXEL_PAINTABLE = 4,

  PIXEL_NOT_PAINTABLE = 8,

  PIXEL_COLORED = 16

};

static inline bool is_pixel_checked(unsigned char *t) { return (*t & PIXEL_CHECKED) == PIXEL_CHECKED; }

static inline bool is_pixel_queued(unsigned char *t) { return (*t & PIXEL_QUEUED) == PIXEL_QUEUED; }

static inline bool is_pixel_paintability_checked(unsigned char *t) {

  return !((*t & PIXEL_PAINTABLE) == 0) && ((*t & PIXEL_NOT_PAINTABLE) == 0);

}

static inline bool is_pixel_paintable(unsigned char *t) { return (*t & PIXEL_PAINTABLE) == PIXEL_PAINTABLE; }

static inline bool is_pixel_colored(unsigned char *t) { return (*t & PIXEL_COLORED) == PIXEL_COLORED; }

static inline void mark_pixel_checked(unsigned char *t) { *t |= PIXEL_CHECKED; }

static inline void mark_pixel_unchecked(unsigned char *t) { *t ^= PIXEL_CHECKED; }

static inline void mark_pixel_queued(unsigned char *t) { *t |= PIXEL_QUEUED; }

static inline void mark_pixel_paintable(unsigned char *t) { *t |= PIXEL_PAINTABLE; *t ^= PIXEL_NOT_PAINTABLE; }

static inline void mark_pixel_not_paintable(unsigned char *t) { *t |= PIXEL_NOT_PAINTABLE; *t ^= PIXEL_PAINTABLE; }

static inline void mark_pixel_colored(unsigned char *t) { *t |= PIXEL_COLORED; }

static inline void clear_pixel_paintability(unsigned char *t) { *t ^= PIXEL_PAINTABLE; *t ^= PIXEL_NOT_PAINTABLE; }

struct bitmap_coords_info {

    bool is_left;

    unsigned int x;

    unsigned int y;

    int y_limit;

    unsigned int width;

    unsigned int height;

    unsigned int stride;

    unsigned int threshold;

    unsigned int radius;

    PaintBucketChannels method;

    guint32 dtc;

    guint32 merged_orig_pixel;

    Geom::Rect bbox;

    Geom::Rect screen;

    unsigned int max_queue_size;

    unsigned int current_step;

};

/**

 * \brief Check if a pixel can be included in the fill.

 * \param px The rendered pixel buffer to check.

 * \param trace_t The pixel in the trace pixel buffer to check or mark.

 * \param x The X coordinate.

 * \param y The y coordinate.

 * \param orig_color The original selected pixel to use as the fill target color.

 * \param bci The bitmap_coords_info structure.

 */

inline static bool check_if_pixel_is_paintable(guchar *px, unsigned char *trace_t, int x, int y, guint32 orig_color, bitmap_coords_info bci) {

    if (is_pixel_paintability_checked(trace_t)) {

        return is_pixel_paintable(trace_t);

    } else {

        guint32 pixel = get_pixel(px, x, y, bci.stride);

        if (compare_pixels(pixel, orig_color, bci.merged_orig_pixel, bci.dtc, bci.threshold, bci.method)) {

            mark_pixel_paintable(trace_t);

            return true;

        } else {

            mark_pixel_not_paintable(trace_t);

            return false;

        }

    }

}

/**

 * \brief Perform the bitmap-to-vector tracing and place the traced path onto the document.

 * \param px The trace pixel buffer to trace to SVG.

 * \param desktop The desktop on which to place the final SVG path.

 * \param transform The transform to apply to the final SVG path.

 * \param union_with_selection If true, merge the final SVG path with the current selection.

 */

static void do_trace(bitmap_coords_info bci, guchar *trace_px, SPDesktop *desktop, Geom::Affine transform, unsigned int min_x, unsigned int max_x, unsigned int min_y, unsigned int max_y, bool union_with_selection) {

    SPDocument *document = sp_desktop_document(desktop);

    unsigned char *trace_t;

    GrayMap *gray_map = GrayMapCreate((max_x - min_x + 1), (max_y - min_y + 1));

    unsigned int gray_map_y = 0;

    for (unsigned int y = min_y; y <= max_y; y++) {

        unsigned long *gray_map_t = gray_map->rows[gray_map_y];

        trace_t = get_trace_pixel(trace_px, min_x, y, bci.width);

        for (unsigned int x = min_x; x <= max_x; x++) {

            *gray_map_t = is_pixel_colored(trace_t) ? GRAYMAP_BLACK : GRAYMAP_WHITE;

            gray_map_t++;

            trace_t++;

        }

        gray_map_y++;

    }

    Inkscape::Trace::Potrace::PotraceTracingEngine pte;

    pte.keepGoing = 1;

    std::vector<Inkscape::Trace::TracingEngineResult> results = pte.traceGrayMap(gray_map);

    gray_map->destroy(gray_map);

    //XML Tree being used here directly while it shouldn't be...."

    Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();

    long totalNodeCount = 0L;

    Inkscape::Preferences *prefs = Inkscape::Preferences::get();

    double offset = prefs->getDouble("/tools/paintbucket/offset", 0.0);

    for (unsigned int i=0 ; i<results.size() ; i++) {

        Inkscape::Trace::TracingEngineResult result = results[i];

        totalNodeCount += result.getNodeCount();

        Inkscape::XML::Node *pathRepr = xml_doc->createElement("svg:path");

        /* Set style */

        sp_desktop_apply_style_tool (desktop, pathRepr, "/tools/paintbucket", false);

        Geom::PathVector pathv = sp_svg_read_pathv(result.getPathData().c_str());

        Path *path = new Path;

        path->LoadPathVector(pathv);

        if (offset != 0) {

            Shape *path_shape = new Shape();

            path->ConvertWithBackData(0.03);

            path->Fill(path_shape, 0);

            delete path;

            Shape *expanded_path_shape = new Shape();

            expanded_path_shape->ConvertToShape(path_shape, fill_nonZero);

            path_shape->MakeOffset(expanded_path_shape, offset * desktop->current_zoom(), join_round, 4);

            expanded_path_shape->ConvertToShape(path_shape, fill_positive);

            Path *expanded_path = new Path();

            expanded_path->Reset();

            expanded_path_shape->ConvertToForme(expanded_path);

            expanded_path->ConvertEvenLines(1.0);

            expanded_path->Simplify(1.0);

            delete path_shape;

            delete expanded_path_shape;

            gchar *str = expanded_path->svg_dump_path();

            if (str && *str) {

                pathRepr->setAttribute("d", str);

                g_free(str);

            } else {

                desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("<b>Too much inset</b>, the result is empty."));

                Inkscape::GC::release(pathRepr);

                g_free(str);

                return;

            }

            delete expanded_path;

        } else {

            gchar *str = path->svg_dump_path();

            delete path;

            pathRepr->setAttribute("d", str);

            g_free(str);

        }

        desktop->currentLayer()->addChild(pathRepr,NULL);

        SPObject *reprobj = document->getObjectByRepr(pathRepr);

        if (reprobj) {

            SP_ITEM(reprobj)->doWriteTransform(pathRepr, transform, NULL);

            // premultiply the item transform by the accumulated parent transform in the paste layer

            Geom::Affine local (SP_GROUP(desktop->currentLayer())->i2doc_affine());

            if (!local.isIdentity()) {

                gchar const *t_str = pathRepr->attribute("transform");

                Geom::Affine item_t (Geom::identity());

                if (t_str)

                    sp_svg_transform_read(t_str, &item_t);

                item_t *= local.inverse();

                // (we're dealing with unattached repr, so we write to its attr instead of using sp_item_set_transform)

                gchar *affinestr=sp_svg_transform_write(item_t);

                pathRepr->setAttribute("transform", affinestr);

                g_free(affinestr);

            }

            Inkscape::Selection *selection = sp_desktop_selection(desktop);

            pathRepr->setPosition(-1);

            if (union_with_selection) {

                desktop->messageStack()->flashF(Inkscape::WARNING_MESSAGE, ngettext("Area filled, path with <b>%d</b> node created and unioned with selection.","Area filled, path with <b>%d</b> nodes created and unioned with selection.",sp_nodes_in_path(SP_PATH(reprobj))), sp_nodes_in_path(SP_PATH(reprobj)));

                selection->add(reprobj);

                sp_selected_path_union_skip_undo(desktop);

            } else {

                desktop->messageStack()->flashF(Inkscape::WARNING_MESSAGE, ngettext("Area filled, path with <b>%d</b> node created.","Area filled, path with <b>%d</b> nodes created.",sp_nodes_in_path(SP_PATH(reprobj))), sp_nodes_in_path(SP_PATH(reprobj)));

                selection->set(reprobj);

            }

        }

        Inkscape::GC::release(pathRepr);

    }

}

/**

 * \brief The possible return states of perform_bitmap_scanline_check()

 */

enum ScanlineCheckResult {

    SCANLINE_CHECK_OK,

    SCANLINE_CHECK_ABORTED,

    SCANLINE_CHECK_BOUNDARY

};

/**

 * \brief Determine if the provided coordinates are within the pixel buffer limits.

 * \param x The X coordinate.

 * \param y The Y coordinate.

 * \param bci The bitmap_coords_info structure.

 */

inline static bool coords_in_range(unsigned int x, unsigned int y, bitmap_coords_info bci) {

    return (x < bci.width) &&

           (y < bci.height);

}

#define PAINT_DIRECTION_LEFT 1

#define PAINT_DIRECTION_RIGHT 2

#define PAINT_DIRECTION_UP 4

#define PAINT_DIRECTION_DOWN 8

#define PAINT_DIRECTION_ALL 15

/**

 * \brief Paint a pixel or a square (if autogap is enabled) on the trace pixel buffer

 * \param px The rendered pixel buffer to check.

 * \param trace_px The trace pixel buffer.

 * \param orig_color The original selected pixel to use as the fill target color.

 * \param bci The bitmap_coords_info structure.

 * \param original_point_trace_t The original pixel in the trace pixel buffer to check.

 */

inline static unsigned int paint_pixel(guchar *px, guchar *trace_px, guint32 orig_color, bitmap_coords_info bci, unsigned char *original_point_trace_t) {

    if (bci.radius == 0) {

        mark_pixel_colored(original_point_trace_t); 

        return PAINT_DIRECTION_ALL;

    } else {

        unsigned char *trace_t;

        bool can_paint_up = true;

        bool can_paint_down = true;

        bool can_paint_left = true;

        bool can_paint_right = true;

        for (unsigned int ty = bci.y - bci.radius; ty <= bci.y + bci.radius; ty++) {

            for (unsigned int tx = bci.x - bci.radius; tx <= bci.x + bci.radius; tx++) {

                if (coords_in_range(tx, ty, bci)) {

                    trace_t = get_trace_pixel(trace_px, tx, ty, bci.width);

                    if (!is_pixel_colored(trace_t)) {

                        if (check_if_pixel_is_paintable(px, trace_t, tx, ty, orig_color, bci)) {

                            mark_pixel_colored(trace_t); 

                        } else {

                            if (tx < bci.x) { can_paint_left = false; }

                            if (tx > bci.x) { can_paint_right = false; }

                            if (ty < bci.y) { can_paint_up = false; }

                            if (ty > bci.y) { can_paint_down = false; }

                        }

                    }

                }

            }

        }

        unsigned int paint_directions = 0;

        if (can_paint_left) { paint_directions += PAINT_DIRECTION_LEFT; }

        if (can_paint_right) { paint_directions += PAINT_DIRECTION_RIGHT; }

        if (can_paint_up) { paint_directions += PAINT_DIRECTION_UP; }

        if (can_paint_down) { paint_directions += PAINT_DIRECTION_DOWN; }

        return paint_directions;

    }

}

/**

 * \brief Push a point to be checked onto the bottom of the rendered pixel buffer check queue.

 * \param fill_queue The fill queue to add the point to.

 * \param max_queue_size The maximum size of the fill queue.

 * \param trace_t The trace pixel buffer pixel.

 * \param x The X coordinate.

 * \param y The Y coordinate.

 */

static void push_point_onto_queue(std::deque<Geom::Point> *fill_queue, unsigned int max_queue_size, unsigned char *trace_t, unsigned int x, unsigned int y) {