Adding upstream version 1.2.2.upstream/1.2.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 584 insertions, 0 deletions

diff --git a/src/trace/trace.cpp b/src/trace/trace.cpp
new file mode 100644
index 0000000..802f497
--- /dev/null
+++ b/src/trace/trace.cpp
@@ -0,0 +1,584 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * A generic interface for plugging different
+ *  autotracers into Inkscape.
+ *
+ * Authors:
+ *   Bob Jamison <rjamison@earthlink.net>
+ *   Jon A. Cruz <jon@joncruz.org>
+ *   Abhishek Sharma
+ *
+ * Copyright (C) 2004-2006 Bob Jamison
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "trace/potrace/inkscape-potrace.h"
+
+#include <limits>
+
+#include <glibmm/i18n.h>
+#include <gtkmm/main.h>
+
+#include <2geom/transforms.h>
+
+#include "desktop.h"
+#include "document.h"
+#include "document-undo.h"
+#include "inkscape.h"
+#include "message-stack.h"
+#include "selection.h"
+
+#include "display/cairo-utils.h"
+#include "display/drawing.h"
+#include "display/drawing-shape.h"
+
+#include "object/sp-item.h"
+#include "object/sp-shape.h"
+#include "object/sp-image.h"
+
+#include "ui/icon-names.h"
+
+#include "xml/repr.h"
+#include "xml/attribute-record.h"
+
+#include "siox.h"
+
+namespace Inkscape {
+namespace Trace {
+
+SPImage *Tracer::getSelectedSPImage()
+{
+
+    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+    if (!desktop)
+        {
+        g_warning("Trace: No active desktop");
+        return nullptr;
+        }
+
+    Inkscape::MessageStack *msgStack = desktop->getMessageStack();
+
+    Inkscape::Selection *sel = desktop->getSelection();
+    if (!sel)
+        {
+        char *msg = _("Select an <b>image</b> to trace");
+        msgStack->flash(Inkscape::ERROR_MESSAGE, msg);
+        //g_warning(msg);
+        return nullptr;
+        }
+
+    if (sioxEnabled)
+        {
+        SPImage *img = nullptr;
+        auto list = sel->items();
+        std::vector<SPItem *> items;
+        sioxShapes.clear();
+
+        /*
+           First, things are selected top-to-bottom, so we need to invert
+           them as bottom-to-top so that we can discover the image and any
+           SPItems above it
+        */
+        for (auto i=list.begin() ; list.end()!=i ; ++i)
+            {
+            if (!SP_IS_ITEM(*i))
+                {
+                continue;
+                }
+            SPItem *item = *i;
+            items.insert(items.begin(), item);
+            }
+        std::vector<SPItem *>::iterator iter;
+        for (iter = items.begin() ; iter!= items.end() ; ++iter)
+            {
+            SPItem *item = *iter;
+            if (SP_IS_IMAGE(item))
+                {
+                if (img) //we want only one
+                    {
+                    char *msg = _("Select only one <b>image</b> to trace");
+                    msgStack->flash(Inkscape::ERROR_MESSAGE, msg);
+                    return nullptr;
+                    }
+                img = SP_IMAGE(item);
+                }
+            else // if (img) //# items -after- the image in tree (above it in Z)
+                {
+                if (SP_IS_SHAPE(item))
+                    {
+                    SPShape *shape = SP_SHAPE(item);
+                    sioxShapes.push_back(shape);
+                    }
+                }
+            }
+
+        if (!img || sioxShapes.size() < 1)
+            {
+            char *msg = _("Select one image and one or more shapes above it");
+            msgStack->flash(Inkscape::ERROR_MESSAGE, msg);
+            return nullptr;
+            }
+        return img;
+        }
+    else
+        //### SIOX not enabled.  We want exactly one image selected
+        {
+        SPItem *item = sel->singleItem();
+        if (!item)
+            {
+            char *msg = _("Select an <b>image</b> to trace");  //same as above
+            msgStack->flash(Inkscape::ERROR_MESSAGE, msg);
+            //g_warning(msg);
+            return nullptr;
+            }
+
+        if (!SP_IS_IMAGE(item))
+            {
+            char *msg = _("Select an <b>image</b> to trace");
+            msgStack->flash(Inkscape::ERROR_MESSAGE, msg);
+            //g_warning(msg);
+            return nullptr;
+            }
+
+        SPImage *img = SP_IMAGE(item);
+
+        return img;
+        }
+
+}
+
+
+
+typedef org::siox::SioxImage SioxImage;
+typedef org::siox::SioxObserver SioxObserver;
+typedef org::siox::Siox Siox;
+
+
+class TraceSioxObserver : public SioxObserver
+{
+public:
+
+    /**
+     *
+     */
+    TraceSioxObserver (void *contextArg) :
+                     SioxObserver(contextArg)
+        {}
+
+    /**
+     *
+     */
+    ~TraceSioxObserver () override
+        = default;
+
+    /**
+     *  Informs the observer how much has been completed.
+     *  Return false if the processing should be aborted.
+     */
+    bool progress(float /*percentCompleted*/) override
+        {
+        //Tracer *tracer = (Tracer *)context;
+        //## Allow the GUI to update
+        Gtk::Main::iteration(false); //at least once, non-blocking
+        while( Gtk::Main::events_pending() )
+            Gtk::Main::iteration();
+        return true;
+        }
+
+    /**
+     *  Send an error string to the Observer.  Processing will
+     *  be halted.
+     */
+    void error(const std::string &/*msg*/) override
+        {
+        //Tracer *tracer = (Tracer *)context;
+        }
+
+
+};
+
+
+
+
+
+Glib::RefPtr<Gdk::Pixbuf> Tracer::sioxProcessImage(SPImage *img, Glib::RefPtr<Gdk::Pixbuf>origPixbuf)
+{
+    if (!sioxEnabled)
+        return origPixbuf;
+
+    if (origPixbuf == lastOrigPixbuf)
+        return lastSioxPixbuf;
+
+    //g_message("siox: start");
+
+    SioxImage simage(origPixbuf->gobj());
+
+    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+    if (!desktop)
+        {
+        g_warning("%s", _("Trace: No active desktop"));
+        return Glib::RefPtr<Gdk::Pixbuf>(nullptr);
+        }
+
+    Inkscape::MessageStack *msgStack = desktop->getMessageStack();
+
+    Inkscape::Selection *sel = desktop->getSelection();
+    if (!sel)
+        {
+        char *msg = _("Select an <b>image</b> to trace");
+        msgStack->flash(Inkscape::ERROR_MESSAGE, msg);
+        //g_warning(msg);
+        return Glib::RefPtr<Gdk::Pixbuf>(nullptr);
+        }
+
+    Inkscape::DrawingItem *aImg = img->get_arenaitem(desktop->dkey);
+    //g_message("img: %d %d %d %d\n", aImg->bbox.x0, aImg->bbox.y0,
+    //                                aImg->bbox.x1, aImg->bbox.y1);
+
+    double width  = aImg->geometricBounds()->width();
+    double height = aImg->geometricBounds()->height();
+
+    double iwidth  = simage.getWidth();
+    double iheight = simage.getHeight();
+
+    double iwscale = width  / iwidth;
+    double ihscale = height / iheight;
+
+    std::vector<Inkscape::DrawingItem *> arenaItems;
+    std::vector<SPShape *>::iterator iter;
+    for (iter = sioxShapes.begin() ; iter!=sioxShapes.end() ; ++iter)
+        {
+        SPItem *item = *iter;
+        Inkscape::DrawingItem *aItem = item->get_arenaitem(desktop->dkey);
+        arenaItems.push_back(aItem);
+        }
+
+    //g_message("%d arena items\n", arenaItems.size());
+
+    //g_message("siox: start selection");
+
+    for (int row=0 ; row<iheight ; row++)
+        {
+        double ypos = aImg->geometricBounds()->top() + ihscale * (double) row;
+        for (int col=0 ; col<simage.getWidth() ; col++)
+            {
+            //Get absolute X,Y position
+            double xpos = aImg->geometricBounds()->left() + iwscale * (double)col;
+            Geom::Point point(xpos, ypos);
+            point *= aImg->transform();
+            //point *= imgMat;
+            //point = desktop->doc2dt(point);
+            //g_message("x:%f    y:%f\n", point[0], point[1]);
+            bool weHaveAHit = false;
+            std::vector<Inkscape::DrawingItem *>::iterator aIter;
+            for (aIter = arenaItems.begin() ; aIter!=arenaItems.end() ; ++aIter)
+                {
+                Inkscape::DrawingItem *arenaItem = *aIter;
+                arenaItem->drawing().update();
+                if (arenaItem->pick(point, 1.0f, 1))
+                    {
+                    weHaveAHit = true;
+                    break;
+                    }
+                }
+
+            if (weHaveAHit)
+                {
+                //g_message("hit!\n");
+                simage.setConfidence(col, row,
+                        Siox::UNKNOWN_REGION_CONFIDENCE);
+                }
+            else
+                {
+                //g_message("miss!\n");
+                simage.setConfidence(col, row,
+                        Siox::CERTAIN_BACKGROUND_CONFIDENCE);
+                }
+            }
+        }
+
+    //g_message("siox: selection done");
+
+    //## ok we have our pixel buf
+    TraceSioxObserver observer(this);
+    Siox sengine(&observer);
+    SioxImage result = sengine.extractForeground(simage, 0xffffff);
+    if (!result.isValid())
+        {
+        g_warning("%s", _("Invalid SIOX result"));
+        return Glib::RefPtr<Gdk::Pixbuf>(nullptr);
+        }
+
+    //result.writePPM("siox2.ppm");
+
+    Glib::RefPtr<Gdk::Pixbuf> newPixbuf = Glib::wrap(result.getGdkPixbuf());
+
+    //g_message("siox: done");
+
+    lastSioxPixbuf = newPixbuf;
+
+    return newPixbuf;
+}
+
+
+Glib::RefPtr<Gdk::Pixbuf> Tracer::getSelectedImage()
+{
+
+
+    SPImage *img = getSelectedSPImage();
+    if (!img)
+        return Glib::RefPtr<Gdk::Pixbuf>(nullptr);
+
+    if (!img->pixbuf)
+        return Glib::RefPtr<Gdk::Pixbuf>(nullptr);
+
+    GdkPixbuf *raw_pb = img->pixbuf->getPixbufRaw(false);
+    GdkPixbuf *trace_pb = gdk_pixbuf_copy(raw_pb);
+    if (img->pixbuf->pixelFormat() == Inkscape::Pixbuf::PF_CAIRO) {
+        convert_pixels_argb32_to_pixbuf(
+            gdk_pixbuf_get_pixels(trace_pb),
+            gdk_pixbuf_get_width(trace_pb),
+            gdk_pixbuf_get_height(trace_pb),
+            gdk_pixbuf_get_rowstride(trace_pb));
+    }
+
+    Glib::RefPtr<Gdk::Pixbuf> pixbuf = Glib::wrap(trace_pb, false);
+
+    if (sioxEnabled)
+        {
+        Glib::RefPtr<Gdk::Pixbuf> sioxPixbuf =
+             sioxProcessImage(img, pixbuf);
+        if (!sioxPixbuf)
+            {
+            return pixbuf;
+            }
+        else
+            {
+            return sioxPixbuf;
+            }
+        }
+    else
+        {
+        return pixbuf;
+        }
+
+}
+
+
+
+//#########################################################################
+//#  T R A C E
+//#########################################################################
+
+void Tracer::enableSiox(bool enable)
+{
+    sioxEnabled = enable;
+}
+
+
+void Tracer::traceThread()
+{
+    //## Remember. NEVER leave this method without setting
+    //## engine back to NULL
+
+    //## Prepare our kill flag.  We will watch this later to
+    //## see if the main thread wants us to stop
+    keepGoing = true;
+
+    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+    if (!desktop)
+        {
+        g_warning("Trace: No active desktop\n");
+        return;
+        }
+
+    Inkscape::MessageStack *msgStack = desktop->getMessageStack();
+
+    Inkscape::Selection *selection = desktop->getSelection();
+
+    if (!SP_ACTIVE_DOCUMENT)
+        {
+        char *msg = _("Trace: No active document");
+        msgStack->flash(Inkscape::ERROR_MESSAGE, msg);
+        //g_warning(msg);
+        engine = nullptr;
+        return;
+        }
+    SPDocument *doc = SP_ACTIVE_DOCUMENT;
+    doc->ensureUpToDate();
+
+
+    SPImage *img = getSelectedSPImage();
+    if (!img)
+        {
+        engine = nullptr;
+        return;
+        }
+
+    GdkPixbuf *trace_pb = gdk_pixbuf_copy(img->pixbuf->getPixbufRaw(false));
+    if (img->pixbuf->pixelFormat() == Inkscape::Pixbuf::PF_CAIRO) {
+        convert_pixels_argb32_to_pixbuf(
+            gdk_pixbuf_get_pixels(trace_pb),
+            gdk_pixbuf_get_width(trace_pb),
+            gdk_pixbuf_get_height(trace_pb),
+            gdk_pixbuf_get_rowstride(trace_pb));
+    }
+
+    Glib::RefPtr<Gdk::Pixbuf> pixbuf = Glib::wrap(trace_pb, false);
+
+    pixbuf = sioxProcessImage(img, pixbuf);
+
+    if (!pixbuf)
+        {
+        char *msg = _("Trace: Image has no bitmap data");
+        msgStack->flash(Inkscape::ERROR_MESSAGE, msg);
+        //g_warning(msg);
+        engine = nullptr;
+        return;
+        }
+
+    msgStack->flash(Inkscape::NORMAL_MESSAGE, _("Trace: Starting trace..."));
+    desktop->updateCanvasNow();
+
+    std::vector<TracingEngineResult> results =
+                engine->trace(pixbuf);
+    //printf("nrPaths:%d\n", results.size());
+    int nrPaths = results.size();
+
+    //### Check if we should stop
+    if (!keepGoing || nrPaths<1)
+        {
+        engine = nullptr;
+        return;
+        }
+
+    //### Get pointers to the <image> and its parent
+    //XML Tree being used directly here while it shouldn't be.
+    Inkscape::XML::Node *imgRepr   = img->getRepr();
+    Inkscape::XML::Node *par       = imgRepr->parent();
+
+    //### Get some information for the new transform()
+    double x = imgRepr->getAttributeDouble("x", 0.0);
+    double y = imgRepr->getAttributeDouble("y", 0.0);
+    double width = imgRepr->getAttributeDouble("width", 0.0);
+    double height = imgRepr->getAttributeDouble("height", 0.0);
+
+    double iwidth  = (double)pixbuf->get_width();
+    double iheight = (double)pixbuf->get_height();
+
+    double iwscale = width  / iwidth;
+    double ihscale = height / iheight;
+
+    Geom::Translate trans(x, y);
+    Geom::Scale scal(iwscale, ihscale);
+
+    //# Convolve scale, translation, and the original transform
+    Geom::Affine tf(scal * trans);
+    tf *= img->transform;
+
+
+    //#OK.  Now let's start making new nodes
+
+    Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
+    Inkscape::XML::Node *groupRepr = nullptr;
+
+    //# if more than 1, make a <g>roup of <path>s
+    if (nrPaths > 1)
+        {
+        groupRepr = xml_doc->createElement("svg:g");
+        par->addChild(groupRepr, imgRepr);
+        }
+
+    long totalNodeCount = 0L;
+
+    for (auto result : results)
+        {
+        totalNodeCount += result.getNodeCount();
+
+        Inkscape::XML::Node *pathRepr = xml_doc->createElement("svg:path");
+        pathRepr->setAttributeOrRemoveIfEmpty("style", result.getStyle());
+        pathRepr->setAttributeOrRemoveIfEmpty("d",     result.getPathData());
+
+        if (nrPaths > 1)
+            groupRepr->addChild(pathRepr, nullptr);
+        else
+            par->addChild(pathRepr, imgRepr);
+
+        //### Apply the transform from the image to the new shape
+        SPObject *reprobj = doc->getObjectByRepr(pathRepr);
+        if (reprobj)
+            {
+            SPItem *newItem = SP_ITEM(reprobj);
+            newItem->doWriteTransform(tf);
+            }
+        if (nrPaths == 1)
+            {
+            selection->clear();
+            selection->add(pathRepr);
+            }
+        Inkscape::GC::release(pathRepr);
+        }
+
+    // If we have a group, then focus on, then forget it
+    if (nrPaths > 1)
+        {
+        selection->clear();
+        selection->add(groupRepr);
+        Inkscape::GC::release(groupRepr);
+        }
+
+    //## inform the document, so we can undo
+    DocumentUndo::done(doc, _("Trace bitmap"), INKSCAPE_ICON("bitmap-trace"));
+
+    engine = nullptr;
+
+    char *msg = g_strdup_printf(_("Trace: Done. %ld nodes created"), totalNodeCount);
+    msgStack->flash(Inkscape::NORMAL_MESSAGE, msg);
+    g_free(msg);
+
+}
+
+
+
+
+
+void Tracer::trace(TracingEngine *theEngine)
+{
+    //Check if we are already running
+    if (engine)
+        return;
+
+    engine = theEngine;
+
+    traceThread();
+}
+
+
+
+
+
+void Tracer::abort()
+{
+
+    //## Inform Trace's working thread
+    keepGoing = false;
+
+    if (engine)
+        {
+        engine->abort();
+        }
+
+}
+
+
+
+} // namespace Trace
+
+} // namespace Inkscape
+
+
+//#########################################################################
+//# E N D   O F   F I L E
+//#########################################################################
+