Applied patch #1501375

(bzr r1164)

3 files changed, 226 insertions, 14 deletions

diff --git a/src/trace/siox.cpp b/src/trace/siox.cpp
index 752a14460..b0632567c 100644
--- a/src/trace/siox.cpp
+++ b/src/trace/siox.cpp
@@ -655,9 +655,19 @@ const float Siox::CERTAIN_BACKGROUND_CONFIDENCE=0.0f;
  */
 Siox::Siox()
 {
+    sioxObserver = NULL;
     init();
 }
 
+/**
+ *  Construct a Siox engine
+ */
+Siox::Siox(SioxObserver *observer)
+{
+    init();
+    sioxObserver = observer;
+}
+
 
 /**
  *
@@ -704,6 +714,27 @@ void Siox::trace(char *fmt, ...)
 
 
 
+/**
+ * Progress reporting
+ */
+bool Siox::progressReport(float percentCompleted)
+{
+    if (!sioxObserver)
+        return true;
+
+    bool ret = sioxObserver->progress(percentCompleted);
+
+    if (!ret)
+      {
+      trace("User selected abort");
+      keepGoing = false;
+      }
+
+    return ret;
+}
+
+
+
 
 /**
  *  Extract the foreground of the original image, according
@@ -713,6 +744,7 @@ SioxImage Siox::extractForeground(const SioxImage &originalImage,
                                   unsigned int backgroundFillColor)
 {
     init();
+    keepGoing = true;
 
     SioxImage workImage = originalImage;
 
@@ -729,17 +761,28 @@ SioxImage Siox::extractForeground(const SioxImage &originalImage,
     //#### create color signatures
     std::vector<CLAB> knownBg;
     std::vector<CLAB> knownFg;
-    for (int x = 0 ; x < workImage.getWidth() ; x++)
-        for (int y = 0 ; y < workImage.getHeight() ; y++)
+    std::vector<CLAB> imageClab;
+    for (int y = 0 ; y < workImage.getHeight() ; y++)
+        for (int x = 0 ; x < workImage.getWidth() ; x++)
             {
             float cm = workImage.getConfidence(x, y);
             unsigned int pix = workImage.getPixel(x, y);
+            CLAB lab(pix);
+            imageClab.push_back(lab);
             if (cm <= BACKGROUND_CONFIDENCE)
-                knownBg.push_back(pix); //note: uses CLAB(rgb)
+                knownBg.push_back(lab); //note: uses CLAB(rgb)
             else if (cm >= FOREGROUND_CONFIDENCE)
-                knownFg.push_back(pix);
+                knownFg.push_back(lab);
             }
 
+    if (!progressReport(10.0))
+        {
+        error("User aborted");
+        workImage.setValid(false);
+        delete[] labelField;
+        return workImage;
+        }
+
     trace("knownBg:%d knownFg:%d", knownBg.size(), knownFg.size());
 
 
@@ -748,14 +791,25 @@ SioxImage Siox::extractForeground(const SioxImage &originalImage,
         {
         error("Could not create background signature");
         workImage.setValid(false);
+        delete[] labelField;
+        return workImage;
+        }
+
+    if (!progressReport(30.0))
+        {
+        error("User aborted");
+        workImage.setValid(false);
+        delete[] labelField;
         return workImage;
         }
+
+
     std::vector<CLAB> fgSignature ;
     if (!colorSignature(knownFg, fgSignature, 3))
         {
         error("Could not create foreground signature");
-        delete[] labelField;
         workImage.setValid(false);
+        delete[] labelField;
         return workImage;
         }
 
@@ -765,17 +819,41 @@ SioxImage Siox::extractForeground(const SioxImage &originalImage,
         {
         // segmentation impossible
         error("Signature size is < 1.  Segmentation is impossible");
+        workImage.setValid(false);
         delete[] labelField;
+        return workImage;
+        }
+
+    if (!progressReport(30.0))
+        {
+        error("User aborted");
         workImage.setValid(false);
+        delete[] labelField;
         return workImage;
         }
 
+
     // classify using color signatures,
     // classification cached in hashmap for drb and speedup purposes
     std::map<unsigned int, Tupel> hs;
+    
+    unsigned int progressResolution = pixelCount / 10;
 
     for (unsigned int i=0; i<pixelCount; i++)
         {
+        if (i % progressResolution == 0)
+            {
+            float progress = 
+                30.0 + 60.0 * (float)i / (float)progressResolution;
+            if (!progressReport(progress))
+                {
+                error("User aborted");
+                delete[] labelField;
+                workImage.setValid(false);
+                return workImage;
+                }
+            }
+
         if (cm[i] >= FOREGROUND_CONFIDENCE)
             {
             cm[i] = CERTAIN_FOREGROUND_CONFIDENCE;
@@ -795,7 +873,7 @@ SioxImage Siox::extractForeground(const SioxImage &originalImage,
                 }
             else
                 {
-                CLAB lab(image[i]);
+                CLAB lab = imageClab[i];
                 float minBg = sqrEuclidianDist(lab, bgSignature[0]);
                 int minIndex=0;
                 for (unsigned int j=1; j<bgSignature.size() ; j++)
@@ -846,8 +924,11 @@ SioxImage Siox::extractForeground(const SioxImage &originalImage,
             }
         }
 
+
+
     trace("### postProcessing");
 
+
     //## postprocessing
     smooth(cm, width, height, 0.33f, 0.33f, 0.33f); // average
     normalizeMatrix(cm, pixelCount);
@@ -871,7 +952,14 @@ SioxImage Siox::extractForeground(const SioxImage &originalImage,
     fillColorRegions();
     dilate(cm, width, height);
 
-    delete[] labelField;
+    if (!progressReport(100.0))
+        {
+        error("User aborted");
+        delete[] labelField;
+        workImage.setValid(false);
+        return workImage;
+        }
+
 
     //#### Yaay.  We are done.  Now clear everything but the background
     for (unsigned int y = 0 ; y < height ; y++)
@@ -884,7 +972,10 @@ SioxImage Siox::extractForeground(const SioxImage &originalImage,
                 }
             }
 
+    delete[] labelField;
+
     trace("### Done");
+    keepGoing = false;
     return workImage;
 }
 
diff --git a/src/trace/siox.h b/src/trace/siox.h
index ba85f0fa6..0dbf76a8e 100644
--- a/src/trace/siox.h
+++ b/src/trace/siox.h
@@ -341,6 +341,56 @@ private:
 
 
 
+//########################################################################
+//#  S I O X    O B S E R V E R
+//########################################################################
+class Siox;
+
+/**
+ *  This is a class for observing the progress of a Siox engine.  Overload
+ *  the methods in your subclass to get the desired behaviour.
+ */
+class SioxObserver
+{
+public:
+
+    /**
+     *  Constructor.  Context can point to anything, and is usually
+     *  used to point to a C++ object or C state object, to delegate
+     *  callback processing to something else.  Use NULL to ignore.
+     */
+    SioxObserver(void *contextArg) : context(NULL)
+        { context = contextArg; }
+
+    /**
+     *  Destructor
+     */
+    virtual ~SioxObserver()
+        { }
+
+    /**
+     *  Informs the observer how much has been completed.
+     *  Return false if the processing should be aborted.
+     */
+    virtual bool progress(float percentCompleted)
+        {
+        return true;
+        }
+
+    /**
+     *  Send an error string to the Observer.  Processing will
+     *  be halted.
+     */
+    virtual void error(const std::string &msg)
+        {
+        }
+
+protected:
+
+    void *context;
+
+};
+
 
 
 //########################################################################
@@ -385,6 +435,11 @@ public:
     Siox();
 
     /**
+     *  Construct a Siox engine.  Use null to ignore
+     */
+    Siox(SioxObserver *observer);
+
+    /**
      *
      */
     virtual ~Siox();
@@ -401,6 +456,18 @@ public:
 
 private:
 
+    SioxObserver *sioxObserver;
+
+    /**
+     * Progress reporting
+     */
+    bool progressReport(float percentCompleted);
+
+    /**
+     * Flag this as false during processing to abort
+     */
+    bool keepGoing;
+
     /**
      * Our signature limits
      */
diff --git a/src/trace/trace.cpp b/src/trace/trace.cpp
index 408f5c5c3..8e3126501 100644
--- a/src/trace/trace.cpp
+++ b/src/trace/trace.cpp
@@ -19,6 +19,7 @@
 #include <desktop-handles.h>
 #include <document.h>
 #include <message-stack.h>
+#include <gtkmm.h>
 #include <glibmm/i18n.h>
 #include <selection.h>
 #include <xml/repr.h>
@@ -57,7 +58,7 @@ Tracer::getSelectedSPImage()
     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
     if (!desktop)
         {
-        g_warning("Trace: No active desktop\n");
+        g_warning("Trace: No active desktop");
         return NULL;
         }
 
@@ -155,8 +156,61 @@ Tracer::getSelectedSPImage()
 
 
 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)
+        {}
+
+    /**
+     *
+     */
+    virtual ~TraceSioxObserver ()
+        { }
+
+    /**
+     *  Informs the observer how much has been completed.
+     *  Return false if the processing should be aborted.
+     */
+    virtual bool progress(float percentCompleted)
+        {
+        //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.
+     */
+    virtual void error(const std::string &msg)
+        {
+        //Tracer *tracer = (Tracer *)context;
+        }
+
+
+};
+
+
+
+
+
+/**
+ * Process a GdkPixbuf, according to which areas have been
+ * obscured in the GUI.
+ */
 GdkPixbuf *
 Tracer::sioxProcessImage(SPImage *img, GdkPixbuf *origPixbuf)
 {
@@ -213,8 +267,8 @@ Tracer::sioxProcessImage(SPImage *img, GdkPixbuf *origPixbuf)
         }
     //g_message("%d arena items\n", arenaItems.size());
 
-    PackedPixelMap *dumpMap = PackedPixelMapCreate(
-                    simage.getWidth(), simage.getHeight());
+    //PackedPixelMap *dumpMap = PackedPixelMapCreate(
+    //                simage.getWidth(), simage.getHeight());
 
     for (int row=0 ; row<simage.getHeight() ; row++)
         {
@@ -246,14 +300,14 @@ Tracer::sioxProcessImage(SPImage *img, GdkPixbuf *origPixbuf)
             if (weHaveAHit)
                 {
                 //g_message("hit!\n");
-                dumpMap->setPixelLong(dumpMap, col, row, 0L);
+                //dumpMap->setPixelLong(dumpMap, col, row, 0L);
                 simage.setConfidence(col, row, 
                         Siox::UNKNOWN_REGION_CONFIDENCE);
                 }
             else
                 {
-                dumpMap->setPixelLong(dumpMap, col, row,
-                        simage.getPixel(col, row));
+                //dumpMap->setPixelLong(dumpMap, col, row,
+                //        simage.getPixel(col, row));
                 simage.setConfidence(col, row,
                         Siox::CERTAIN_BACKGROUND_CONFIDENCE);
                 }
@@ -261,7 +315,7 @@ Tracer::sioxProcessImage(SPImage *img, GdkPixbuf *origPixbuf)
         }
 
     //dumpMap->writePPM(dumpMap, "siox1.ppm");
-    dumpMap->destroy(dumpMap);
+    //dumpMap->destroy(dumpMap);
 
     //## ok we have our pixel buf
     org::siox::Siox sengine;