Hugin

Revision: 3271
          http://hugin.svn.sourceforge.net/hugin/?rev=3271&view=rev
Author:   fmannan
Date:     2008-08-05 13:18:53 +0000 (Tue, 05 Aug 2008)

Log Message:
-----------
+added missing CMakeLists files

Added Paths:
-----------
    hugin/branches/gsoc2008_masking/src/maskeditor/core/CMakeLists.txt
    hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/CMakeLists.txt

Added: hugin/branches/gsoc2008_masking/src/maskeditor/core/CMakeLists.txt
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/core/CMakeLists.txt	                        (rev 0)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/core/CMakeLists.txt	2008-08-05 13:18:53 UTC (rev 3271)
@@ -0,0 +1,20 @@
+
+	# sources
+	set(maskeditor_CORE_SOURCES
+				BrushStroke.h
+				MaskPoly.h
+				MaskMgr.h MaskMgr.cpp
+				MaskFileMgr.h MaskFileMgr.cpp
+				PTOFileMgr.h PTOFileMgr.cpp 
+				MaskEdCommand.h MaskEdCommand.cpp
+				IMaskEdMemento.h IMaskEdMemento.cpp
+				ISegmentation.h
+				Pixel.h Pixel.cpp)
+	
+	IF (${HUGIN_SHARED_LIBS})
+  	add_library(maskeditor_core SHARED ${maskeditor_CORE_SOURCES})
+  	set_target_properties(maskeditor_core PROPERTIES VERSION ${HUGIN_LIB_VERSION})
+  	install(TARGETS maskeditor_core DESTINATION ${LIBDIR})
+	ELSE (${HUGIN_SHARED_LIBS})
+  	add_library(maskeditor_core STATIC ${maskeditor_CORE_SOURCES})
+	ENDIF (${HUGIN_SHARED_LIBS})

Added: hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/CMakeLists.txt
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/CMakeLists.txt	                        (rev 0)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/CMakeLists.txt	2008-08-05 13:18:53 UTC (rev 3271)
@@ -0,0 +1,29 @@
+
+	# sources
+	set(maskeditor_SEGMENTATION_SOURCES
+				polyed_basic/PolyEd_Basic.h polyed_basic/PolyEd_Basic.cpp
+				polyed_basic/PolyEdBasicMemento.h polyed_basic/PolyEdBasicMemento.cpp
+				lazysnapping/LazySnapping.h lazysnapping/LazySnapping.cpp
+				lazysnapping/LazySnappingMemento.h lazysnapping/LazySnappingMemento.cpp
+				lazysnapping/maxflow/graph.cpp
+				lazysnapping/maxflow/maxflow.cpp
+				#lazysnapping/kmeans/KMeans.hpp
+				lazysnapping/watershed.cxx
+				lazysnapping/KMlocal/KCtree.cpp
+				lazysnapping/KMlocal/KCutil.cpp
+				lazysnapping/KMlocal/KM_ANN.cpp
+				lazysnapping/KMlocal/KMcenters.cpp
+				lazysnapping/KMlocal/KMdata.cpp
+				lazysnapping/KMlocal/KMeans.cpp
+				lazysnapping/KMlocal/KMfilterCenters.cpp
+				lazysnapping/KMlocal/KMlocal.cpp
+				lazysnapping/KMlocal/KMrand.cpp
+				lazysnapping/KMlocal/KMterm.cpp)
+	
+	IF (${HUGIN_SHARED_LIBS})
+  	add_library(maskeditor_segmentation SHARED ${maskeditor_SEGMENTATION_SOURCES})
+  	set_target_properties(maskeditor_segmentation PROPERTIES VERSION ${HUGIN_LIB_VERSION})
+  	install(TARGETS maskeditor_segmentation DESTINATION ${LIBDIR})
+	ELSE (${HUGIN_SHARED_LIBS})
+  	add_library(maskeditor_segmentation STATIC ${maskeditor_SEGMENTATION_SOURCES})
+	ENDIF (${HUGIN_SHARED_LIBS})


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 3565
          http://hugin.svn.sourceforge.net/hugin/?rev=3565&view=rev
Author:   fmannan
Date:     2008-11-29 17:46:45 +0000 (Sat, 29 Nov 2008)

Log Message:
-----------
+some changes to binary mask
+mask is stored as <imgname>_mask.tif

Modified Paths:
--------------
    hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskFileMgr.cpp
    hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskFileMgr.h
    hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskMgr.cpp
    hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskMgr.h
    hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdMainFrame.cpp
    hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.cpp
    hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/polyed_basic/PolyEd_Basic.cpp

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskFileMgr.cpp
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskFileMgr.cpp	2008-11-26 01:59:01 UTC (rev 3564)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskFileMgr.cpp	2008-11-29 17:46:45 UTC (rev 3565)
@@ -86,6 +86,23 @@
     }
 }
 
+void MaskFileMgr::saveFile(const std::string &filename, const std::vector<std::string> &imgfiles)
+{
+    if(filename.empty())
+        throw;
+    try {
+        ofstream fout(filename.c_str());
+        fout << "# remapped images" << endl;
+        for(vector<string>::const_iterator it = imgfiles.begin(); it != imgfiles.end(); it++) 
+        {
+            string imgfile = hugin_utils::stripPath(*it);
+            fout << "ri " << imgfile << endl;
+        }
+    }catch(exception &e) {
+        throw e;
+    }
+}
+
 vector<string> MaskFileMgr::getImgFiles()
 {
     return m_imgfiles;

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskFileMgr.h
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskFileMgr.h	2008-11-26 01:59:01 UTC (rev 3564)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskFileMgr.h	2008-11-29 17:46:45 UTC (rev 3565)
@@ -45,7 +45,7 @@
     static MaskFileMgr* getInstance();
 
     void loadFile(std::string filename);
-
+    void saveFile(const std::string &filename, const std::vector<std::string>& imgfiles);
     std::string getPTOFile();
     std::vector<std::string> getImgFiles();
     int getImgFileCount();

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskMgr.cpp
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskMgr.cpp	2008-11-26 01:59:01 UTC (rev 3564)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskMgr.cpp	2008-11-29 17:46:45 UTC (rev 3565)
@@ -29,9 +29,11 @@
 #include "MaskMgr.h"
 #include "MaskFileMgr.h"
 #include <wx/wx.h>
+#include "hugin_utils/utils.h"
 
 using namespace std;
 using namespace vigra;
+using namespace hugin_utils;
 using HuginBase::ImageCache;
 
 MaskMgr* MaskMgr::m_instance = 0;
@@ -172,6 +174,11 @@
     loadImage(MaskFileMgr::getInstance()->getImgFiles());
 }
 
+void MaskMgr::saveMaskProject(const string &filename)
+{
+    MaskFileMgr::getInstance()->saveFile(filename, m_imgfiles);
+}
+
 void MaskMgr::reload()
 {
     if(m_loadtype == LOADFILE) {
@@ -206,10 +213,15 @@
 {
     int i = 0;
     wxBitmap *mask = 0;
+    string pathprefix = prefix;//, filename;
     for(std::vector<ISegmentation*>::iterator it = m_segmentation.begin(); it != m_segmentation.end(); it++, i++)
     {
         stringstream ss;
-        ss << prefix << "_" << i << "." << fileExt;
+        //pathprefix = getPathPrefix(m_imgfiles[i]);
+        //filename = stripExtension(stripPath(m_imgfiles[i]));
+        pathprefix = stripExtension(m_imgfiles[i]);
+        //ss << prefix << "_" << i << "." << fileExt;
+        ss << pathprefix << "_mask." << fileExt;
         vigra::ImageExportInfo exi( ss.str().c_str() ); 
 
         mask = (*it)->getMaskBitmap();

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskMgr.h
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskMgr.h	2008-11-26 01:59:01 UTC (rev 3564)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/core/MaskMgr.h	2008-11-29 17:46:45 UTC (rev 3565)
@@ -33,11 +33,11 @@
 {
     std::vector<std::string>    m_imgfiles;
     std::vector<ISegmentation*> m_segmentation; //each image will have its own instance
-    std::vector<std::string> m_segmentation_options; //this should be done dynamically
+    std::vector<std::string> m_segmentation_options; //this should be set dynamically
     typedef std::vector<std::pair<vigra::BRGBImage*, vigra::BImage*> > tImgAlphaPair;
     tImgAlphaPair m_imgs_alpha;
     
-    enum tLoadType { LOADFILE, LOADMEM };
+    enum tLoadType { LOADFILE, LOADMEM }; //an image can be loaded from file or from cache
     tLoadType                m_loadtype;
     int                      m_segmentation_index;
     static MaskMgr          *m_instance;
@@ -65,6 +65,9 @@
     void loadImage(const std::vector<std::string> &filesv);
     void loadImage(const std::string &filename);
     void loadMaskProject(const std::string &filename);
+    
+    void saveMaskProject(const std::string &filename);
+
     void reload();  //reloads all images
 
     std::vector<std::string> getImages();

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdMainFrame.cpp
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdMainFrame.cpp	2008-11-26 01:59:01 UTC (rev 3564)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdMainFrame.cpp	2008-11-29 17:46:45 UTC (rev 3565)
@@ -171,13 +171,14 @@
 void MaskEdMainFrame::OnSaveMask(wxCommandEvent &event)
 {
     //wxString filter = wxT("JPEG files (*.jpg;*.jpeg)|*.jpg;*.JPG;*.jpeg;*.JPEG|tiff files (*.tif)|*.tif|All files (*.*)|*.*");
-    wxFileDialog dialog(this, wxT("Save Mask: Enter prefix"), wxEmptyString,
-        wxEmptyString, wxEmptyString, wxSAVE);
-    if(dialog.ShowModal() == wxID_OK)
-    {
+    //wxFileDialog dialog(this, wxT("Save Mask: Enter prefix"), wxEmptyString,
+    //    wxEmptyString, wxEmptyString, /*wxSAVE*/wxFD_CHANGE_DIR);
+    //if(dialog.ShowModal() == wxID_OK)
+    //{
         //m_MaskEdClientWnd->saveMask(0, dialog.GetPath());
-        MaskMgr::getInstance()->saveMask(string(dialog.GetPath().mb_str()));
-    }
+        //MaskMgr::getInstance()->saveMask(string(dialog.GetPath().mb_str()));
+        MaskMgr::getInstance()->saveMask("");
+    //}
 
 }
 

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.cpp
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.cpp	2008-11-26 01:59:01 UTC (rev 3564)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.cpp	2008-11-29 17:46:45 UTC (rev 3565)
@@ -31,6 +31,7 @@
 
 #define INF     1000000
 using namespace std;
+using namespace vigra;
 using HuginBase::ImageCache;
 
 #define SAFE_DELETE(x) { if(x) delete x; x = 0; }
@@ -122,24 +123,35 @@
     
     fout.close();
 }
-
+struct BinaryMask
+{
+    vigra::BImage::value_type operator()(const vigra::BImage::value_type &p) const
+    {
+        return p > 0 ? 255 : 0; //((p.red() + p.green() + p.blue())/3) > 0 ? 255 : 0;
+    }
+};
 void LazySnapping::init(vigra::BImage *mask)
 {
     if(m_width > 0 && m_height > 0)
     {
-        if(!mask)
+        if(!mask) {
             m_mask = new wxBitmap(m_width, m_height, 1);
-        else {
+            wxMemoryDC dc(*m_mask);
+            dc.SetBackground(*wxWHITE_BRUSH);
+            dc.Clear();
+        } else {
             assert(mask->width() == m_width && mask->height() == m_height);
-            m_mask = new wxBitmap((const char*)mask->data(), mask->width(), mask->height());
+            vigra::BImage binmask(mask->width(), mask->height());
+            vigra::transformImage(srcImageRange(*mask), destImage(binmask), BinaryMask());
+            m_mask = new wxBitmap((const char*)binmask.data(), binmask.width(), binmask.height());
         }
         /*SAFE_DELETE(m_tmp_bmp);
         m_tmp_bmp = new wxBitmap(m_width, m_height, 1);*/
         preprocess();
         buildGraph();
-        wxMemoryDC dc(*m_mask);
+        /*wxMemoryDC dc(*m_mask);
         dc.SetBackground(*wxWHITE_BRUSH);
-        dc.Clear();
+        dc.Clear();*/
     }
 }
 

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/polyed_basic/PolyEd_Basic.cpp
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/polyed_basic/PolyEd_Basic.cpp	2008-11-26 01:59:01 UTC (rev 3564)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/polyed_basic/PolyEd_Basic.cpp	2008-11-29 17:46:45 UTC (rev 3565)
@@ -25,8 +25,10 @@
 #include "PolyEd_Basic.h"
 #include "PolyEdBasicMemento.h"
 #include <wx/wx.h>
+#include "vigra/transformimage.hxx"
 
 using namespace std;
+using namespace vigra;
 using HuginBase::ImageCache;
 
 struct PixelCoordToWxPoint
@@ -72,20 +74,29 @@
     
 }
 
+struct BinaryMask
+{
+    vigra::BImage::value_type operator()(const vigra::BImage::value_type &p) const
+    {
+        return p > 0 ? 255 : 0; //((p.red() + p.green() + p.blue())/3) > 0 ? 255 : 0;
+    }
+};
+
 void PolyEd_Basic::init(vigra::BImage *mask)
 {
     if(m_width > 0 && m_height > 0)
     {
         if(!mask) {
             m_mask = new wxBitmap(m_width, m_height, 1);
+            wxMemoryDC dc(*m_mask);
+            dc.SetBackground(*wxWHITE_BRUSH);
+            dc.Clear();
         } else {
             assert(mask->width() == m_width && mask->height() == m_height);
-            m_mask = new wxBitmap((const char*)mask->data(), mask->width(), mask->height());
-            //FIX:the mask that is passed is not a true alpha mask
+            vigra::BImage binmask(mask->width(), mask->height());
+            vigra::transformImage(srcImageRange(*mask), destImage(binmask), BinaryMask());
+            m_mask = new wxBitmap((const char*)binmask.data(), binmask.width(), binmask.height());
         }
-        wxMemoryDC dc(*m_mask);
-        dc.SetBackground(*wxWHITE_BRUSH);
-        dc.Clear();
     }
 }
 


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 3578
          http://hugin.svn.sourceforge.net/hugin/?rev=3578&view=rev
Author:   fmannan
Date:     2009-01-04 00:23:24 +0000 (Sun, 04 Jan 2009)

Log Message:
-----------
GUI update:
+ Images are centered
+ Checkerboard pattern at the back
+ Added base code for retrieving mask contour

Modified Paths:
--------------
    hugin/branches/gsoc2008_masking/src/maskeditor/core/ISegmentation.h
    hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdClientWnd.cpp
    hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.cpp
    hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.h
    hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.cpp
    hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.h
    hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/polyed_basic/PolyEd_Basic.cpp
    hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/polyed_basic/PolyEd_Basic.h

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/core/ISegmentation.h
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/core/ISegmentation.h	2009-01-03 15:47:09 UTC (rev 3577)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/core/ISegmentation.h	2009-01-04 00:23:24 UTC (rev 3578)
@@ -61,7 +61,7 @@
     virtual void setImage(const std::string &imgId, const vigra::BRGBImage* img, vigra::BImage *mask = 0) = 0;
     virtual wxMask* getMask() const = 0;
     virtual wxBitmap* getMaskBitmap() const = 0;
-    virtual std::vector<wxPoint> getOutline() const = 0;
+    virtual std::vector<std::vector<wxPoint> > getMaskContours() const = 0;
 };
 
 #endif

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdClientWnd.cpp
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdClientWnd.cpp	2009-01-03 15:47:09 UTC (rev 3577)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdClientWnd.cpp	2009-01-04 00:23:24 UTC (rev 3578)
@@ -44,7 +44,7 @@
     m_MaskEdEditWnd = new MaskEdEditWnd(this, wxID_ANY, wxDefaultPosition, wxSize(size.GetWidth(), size.GetHeight()*0.75));
     m_MaskEdPreviewWnd = new MaskEdPreviewWnd(this, wxID_ANY, wxDefaultPosition, wxSize(size.GetWidth(), size.GetHeight()*0.25));
     
-    SetMinimumPaneSize(20);
+    SetMinimumPaneSize(size.GetHeight() * 0.25);
     //SetSashPosition(size.GetHeight() * 0.75);
     m_MaskEdEditWnd->Show();
     m_MaskEdPreviewWnd->Show();

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.cpp
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.cpp	2009-01-03 15:47:09 UTC (rev 3577)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.cpp	2009-01-04 00:23:24 UTC (rev 3578)
@@ -41,7 +41,7 @@
     EVT_RIGHT_UP(MaskEdEditWnd::OnRightMouseButtonUp)
     EVT_MOTION(MaskEdEditWnd::OnMotion)
     EVT_PAINT(MaskEdEditWnd::OnPaint)
-    EVT_ERASE_BACKGROUND(MaskEdEditWnd::OnEraseBackground)
+    //EVT_ERASE_BACKGROUND(MaskEdEditWnd::OnEraseBackground)
     EVT_SIZE(MaskEdEditWnd::OnSize)
 END_EVENT_TABLE()
 
@@ -84,6 +84,9 @@
     SetScrollbars( 1, 1, m_max_width, m_max_height);
 }
 
+///
+/// All the images are rendered onto the display bitmap
+///
 void MaskEdEditWnd::createDisplayBitmap()
 {
     if(m_display_bmp) 
@@ -91,10 +94,10 @@
     m_display_bmp = 0;
    
     wxSize sz = GetClientSize();
-    int width = std::max(sz.GetWidth(), m_max_width);
-    int height = std::max(sz.GetHeight(), m_max_height);
+    int width = m_max_width;//std::max(sz.GetWidth(), m_max_width);
+    int height = m_max_height;//std::max(sz.GetHeight(), m_max_height);
     if(width > 0 && height > 0)
-        m_display_bmp = new wxBitmap(2 * width, 2 * height);
+        m_display_bmp = new wxBitmap(width, height);
 }
 
 
@@ -103,11 +106,26 @@
     m_edmode = edmode;
 }
 
+/////////////////////////////////////////////////////////////////////////////////////////
+/// Image Loading
+/// --------------
+/// \brief Loading images is basically storing the image filenames which is used for 
+/// retrieving the desired image from the ImageCache. If the image was not loaded before
+/// then the ImageCache will load it from the filesystem otherwise it will just retrieve
+/// it from memory.
+/////////////////////////////////////////////////////////////////////////////////////////
+
 //void MaskEdEditWnd::loadImage(const wxString &filename)
 //{
 //    loadImage(string(filename.mb_str()));
 //}
 
+/////////////////////////////////////////////////////////////////////////////////////////
+/// loadImage
+/// ---------
+/// Retrieves an image from the image cache using the filename, extracts the starting
+/// position and stores it as wxImage (without mask) and wxBitmap (with mask).
+/////////////////////////////////////////////////////////////////////////////////////////
 void MaskEdEditWnd::loadImage(const string &filename)
 {
     if(filename == "")
@@ -148,7 +166,7 @@
 void MaskEdEditWnd::loadImage(const vector<string> &filesv)
 {
     init();
-    //remove_copy_if(filesv.begin(), filesv.end(), back_insert_iterator<vector<string> >(m_imgfiles), );
+  
     copy(filesv.begin(), filesv.end(), back_insert_iterator<vector<string> >(m_imgfiles));
     //creates local cache of images
     for(vector<string>::const_iterator it = filesv.begin(); it != filesv.end(); it++)
@@ -196,13 +214,30 @@
     rect.SetBottomRight(br);
 }
 
+void MaskEdEditWnd::Draw(wxDC &dc)
+{
+    //dc.SetUserScale(m_scale, m_scale);
+    if(m_display_bmp) {
+        //center the bitmap
+        wxSize sz = GetClientSize();
+        int x, y;
+        x = (sz.GetWidth() - m_display_bmp_scaled->GetWidth())/2;
+        y = (sz.GetHeight() - m_display_bmp_scaled->GetHeight())/2;
+        x = x > 0 ? x : 0;
+        y = y > 0 ? y : 0;
+        m_origin_x = x;
+        m_origin_y = y;
+        // draw the bitmap
+        dc.DrawBitmap(*m_display_bmp_scaled, m_origin_x, m_origin_y);
+    }
+}
 void MaskEdEditWnd::OnEraseBackground(wxEraseEvent &event)
 {
     if(m_display_bmp) {
         wxClientDC dc(this);
         DoPrepareDC(dc);
-        dc.SetUserScale(m_scale, m_scale);
-        dc.DrawBitmap(*m_display_bmp,0, 0);
+        //dc.SetUserScale(m_scale, m_scale);
+        Draw(dc);
     } else
         event.Skip();
 }
@@ -216,11 +251,23 @@
     wxMemoryDC dc(*m_display_bmp);
     int i = m_bimgs.size() - 1;
     int lastDrawn = -1;
-    if(clear) {
-        dc.SetBackground(*wxWHITE_BRUSH);
-        dc.Clear();
+    
+    //draw checker board pattern on the bitmap
+    dc.SetPen(*wxTRANSPARENT_PEN);
+    
+    int stepSize = 8;
+    for(int i = 0; i < m_display_bmp->GetWidth(); i+=stepSize) {
+        for(int j = 0; j < m_display_bmp->GetHeight(); j+=stepSize) {
+            if((i/stepSize+j/stepSize)&1)
+                 dc.SetBrush(*wxGREY_BRUSH);
+            else
+                dc.SetBrush(*wxLIGHT_GREY_BRUSH);
+            dc.DrawRectangle(i, j, stepSize, stepSize);
+        }
     }
-    //dc.SetUserScale(m_scale, m_scale);
+    // draw the bitmaps
+    dc.SetPen(wxNullPen);
+    dc.SetBrush(wxNullBrush);
     for(vector<wxBitmap*>::reverse_iterator it = m_bimgs.rbegin(); it != m_bimgs.rend(); it++, i--)
     {
         if(!m_selected[i]) continue;
@@ -238,17 +285,24 @@
         }
         lastDrawn = i;
     }
+    wxImage img = m_display_bmp->ConvertToImage();
+    m_display_bmp_scaled = new wxBitmap(img.Scale(img.GetWidth() * m_scale, img.GetHeight() * m_scale));
 }
 
 void MaskEdEditWnd::OnSize(wxSizeEvent &event)
 {
     wxSize sz = event.GetSize();
     if(m_display_bmp) {
-        if(m_display_bmp->GetWidth() < sz.GetWidth() 
+        /*if(m_display_bmp->GetWidth() < sz.GetWidth() 
             || m_display_bmp->GetHeight() < sz.GetHeight()) {
             createDisplayBitmap();
             updateDisplayBitmap();
-        }
+        }*/
+        //wxClientDC dc(this);
+        //DoPrepareDC(dc);
+        ////dc.SetUserScale(m_scale, m_scale);
+        //Draw(dc);
+        Refresh();
     }
 }
 
@@ -256,9 +310,12 @@
 {
     wxPaintDC dc(this);
     DoPrepareDC(dc);
-    dc.SetUserScale(m_scale, m_scale);
-    if(m_display_bmp)
-        dc.DrawBitmap(*m_display_bmp, 0, 0);
+    //dc.SetUserScale(m_scale, m_scale);
+    
+    // for fast display, draw onto m_display_bmp and then draw m_display_bmp
+    if(m_display_bmp) { 
+        Draw(dc);
+    }
     //int x,y;
     //x = 0;//GetScrollPos(wxSB_HORIZONTAL);
     //y = 0;//GetScrollPos(wxSB_VERTICAL);
@@ -303,14 +360,14 @@
         wxPoint *pts = new wxPoint[m_poly.size()];
         dc.SetPen(*wxRED);
         dc.SetBrush(*wxTRANSPARENT_BRUSH);
-        //copy(m_poly.pt.begin(), m_poly.pt.end(), pts);
+        
         int i = 0;
         for(vector<PixelCoord>::iterator it = m_poly.begin(); it != m_poly.end(); it++,i++)
         {
-            pts[i].x = it->x /* m_scale - x*/ + m_pos[m_active].x;
-            pts[i].y = it->y /* m_scale - y*/ + m_pos[m_active].y;
-            int offset = POLY_DRAW_VWIDTH/2;
-            if(m_poly.isMouseOver(*it))
+            pts[i].x = it->x * m_scale + m_pos[m_active].x + m_origin_x;
+            pts[i].y = it->y * m_scale + m_pos[m_active].y + m_origin_y;
+            int offset = POLY_DRAW_VWIDTH/2; //width of the rectangle denoting the point
+            if(m_poly.isMouseOver(*it)) //enlarge the rectangle denoting point for easier selection
                 offset *= 2;
             dc.DrawRectangle(pts[i].x - offset, pts[i].y - offset,
                 offset * 2, offset * 2);
@@ -374,7 +431,7 @@
             int x, y;
             x = GetScrollPos(wxSB_HORIZONTAL);
             y = GetScrollPos(wxSB_VERTICAL);
-            wxPoint pos = event.GetPosition()+wxPoint(x,y)-m_pos[m_active];
+            wxPoint pos = event.GetPosition()+wxPoint(x,y)-m_pos[m_active]-wxPoint(m_origin_x, m_origin_y);
             //m_poly.add(PixelCoord(pos.x/m_scale, pos.y/m_scale));
             m_MaskEdCmdHist.addCommand(new PolyVertexAddCmd(&m_poly, pos.x/m_scale, pos.y/m_scale));
         } else {
@@ -419,7 +476,7 @@
     x = GetScrollPos(wxSB_HORIZONTAL);
     y = GetScrollPos(wxSB_VERTICAL);
     
-    wxPoint newPt = event.GetPosition() + wxPoint(x, y) - m_pos[m_active];
+    wxPoint newPt = event.GetPosition() + wxPoint(x, y) - m_pos[m_active] - wxPoint(m_origin_x, m_origin_y);
     newPt.x /= m_scale;
     newPt.y /= m_scale;
 
@@ -430,8 +487,8 @@
         if(m_edmode == ME_BSTROKE) {
             if(m_brushstroke.pt.size() > 0) {
                 wxClientDC dc(this);
-                DoPrepareDC(dc);
-                dc.SetUserScale(m_scale, m_scale);
+                //DoPrepareDC(dc);
+                //dc.SetUserScale(m_scale, m_scale);
                 wxPen oldpen = dc.GetPen();
                 wxPen *pen;
 
@@ -441,8 +498,8 @@
                     pen = new wxPen(*wxBLUE, 1);
                 dc.SetPen(*pen);
                 wxPoint lastPt(m_brushstroke.pt.back().x, m_brushstroke.pt.back().y);
-                //dc.DrawLine(lastPt - wxPoint(x, y) + m_pos[m_active], event.GetPosition());
-                dc.DrawLine(lastPt, newPt);
+                dc.DrawLine(wxPoint(lastPt.x * m_scale, lastPt.y * m_scale) - wxPoint(x, y) + m_pos[m_active] + wxPoint(m_origin_x, m_origin_y), 
+                    event.GetPosition());
                 dc.SetPen(oldpen);
             }
             m_brushstroke.pt.push_back(PixelCoord(newPt.x, newPt.y));
@@ -463,17 +520,12 @@
     }
 }
 
-//void MaskEdEditWnd::reloadImages()
-//{
-//    m_bimgs.clear();
-//    for(vector<string>::iterator it = m_imgfiles.begin(); it != m_imgfiles.end(); it++)
-//        loadImage(*it);
-//}   
-
 void MaskEdEditWnd::zoom(float scale, wxRect region)
 {
     m_scale = scale;
-    //reloadImages();
+    
+    wxImage tmpImg = m_display_bmp->ConvertToImage();
+    m_display_bmp_scaled = new wxBitmap(tmpImg.Scale(m_display_bmp->GetWidth() * m_scale, m_display_bmp->GetHeight()*m_scale, wxIMAGE_QUALITY_HIGH));
     SetScrollbars( 1, 1, m_max_width*m_scale, m_max_height*m_scale);
     Refresh();
 }
@@ -517,7 +569,6 @@
     updateMask(m_active);
     updateDisplayBitmap(true);
     Refresh();
-    //reloadImages();
 }
 
 void MaskEdEditWnd::redo()
@@ -526,7 +577,6 @@
     updateMask(m_active);
     updateDisplayBitmap(true);
     Refresh();
-    //reloadImages();
 }
 
 void MaskEdEditWnd::updateMask(int nimgId)
@@ -536,6 +586,18 @@
     img.SetMaskFromImage(mask->ConvertToImage(), 0, 0, 0);
     delete m_bimgs[nimgId];
     m_bimgs[nimgId] = new wxBitmap(img);
+    // draw mask contour
+    vector<vector<wxPoint> > contours = MaskMgr::getInstance()->getSegmentation(m_imgfiles[nimgId])->getMaskContours();
+    if(contours.size() > 0) {
+        wxMemoryDC dc(*m_bimgs[nimgId]);
+        dc.SetPen(*wxRED_PEN);
+        for(vector<vector<wxPoint> >::iterator i = contours.begin(); i != contours.end(); i++) {
+            for(vector<wxPoint>::iterator j =  i->begin(); j != i->end(); j++) {
+                dc.DrawPoint(*j);
+            }
+        }
+        dc.SetPen(wxNullPen);
+    }
     updateDisplayBitmap(true);
 }
 

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.h
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.h	2009-01-03 15:47:09 UTC (rev 3577)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.h	2009-01-04 00:23:24 UTC (rev 3578)
@@ -35,7 +35,10 @@
 
 class MaskEdEditWnd : public wxScrolledWindow
 {
-    wxBitmap                *m_display_bmp;
+    wxBitmap                *m_display_bmp;      // used as back-buffer
+    wxBitmap                *m_display_bmp_scaled; //scaled version that is actually displayed
+    int                      m_origin_x;         // x origin of the scaled bitmap
+    int                      m_origin_y;         // y origin of the scaled bitmap
     std::vector<wxImage*>    m_wximgs;
     std::vector<wxBitmap*>   m_bimgs;            //local cache
     std::vector<std::string> m_imgfiles;
@@ -73,6 +76,8 @@
     void loadImage(const std::vector<std::string> &filesv);
     //void reloadImages();
 
+    void Draw(wxDC &dc);
+
     void updateMask(int imdId);
     void updateMask(std::string &imgId);
 

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.cpp
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.cpp	2009-01-03 15:47:09 UTC (rev 3577)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.cpp	2009-01-04 00:23:24 UTC (rev 3578)
@@ -162,7 +162,7 @@
     m_height = 0;
     m_depth = 0;
     m_cnodes = 0;
-    m_outline.clear();
+//    m_outline.clear();
     SAFE_DELETE_ARRAY(m_nodes);
     SAFE_DELETE(m_graph);
     SAFE_DELETE_ARRAY(m_data);
@@ -590,11 +590,88 @@
     return m_mask;
 }
 
-vector<wxPoint> LazySnapping::getOutline() const
+void LazySnapping::floodFill(int x, int y, unsigned char *mask, int val, int fill_val) const
 {
-    return m_outline;
+    //if not valid
+    if(y < 0 || y >= m_height || x < 0 || x >= m_width || mask[y * m_width + x] != val)
+        return;
+    mask[y * m_width + x] = fill_val;
+    floodFill(x - 1, y, mask, val, fill_val);
+    floodFill(x, y + 1, mask, val, fill_val);
+    floodFill(x + 1, y + 1, mask, val, fill_val);
+    floodFill(x, y - 1, mask, val, fill_val);
 }
 
+void LazySnapping::traceContour(int x, int y, unsigned char *mask, int contour_val, vector<wxPoint> &contour) const
+{
+    // directions (dx, dy) or (col, row)
+    int dir[8][2] = { {0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1},
+                      {-1, 0}, {-1, -1}};
+    int dir_map[8] = {7, 7, 1, 1, 3, 3, 5, 5}; //mapping of incoming and outgoing direction
+    int in_dir, out_dir;
+    int startx = x;
+    int starty = y;
+    int cx, cy;
+    int i;
+    cx = x;
+    cy = y;
+    in_dir = 2; //initially coming from the left
+    do {
+        contour.push_back(wxPoint(cx, cy));
+        // determine next point on the boundary
+        for(i = 0; i < 8; i++) {
+            out_dir = (i + dir_map[in_dir]) % 8;
+            if(cx + dir[out_dir][0] >= 0 && cx + dir[out_dir][0] < m_width &&
+                cy + dir[out_dir][1] >= 0 && cy + dir[out_dir][1] < m_height &&
+                mask[(cy + dir[out_dir][1]) * m_width + cx + dir[out_dir][0]] == contour_val) {
+                mask[(cy + dir[out_dir][1]) * m_width + cx + dir[out_dir][0]] = 129;
+                cx += dir[out_dir][0];
+                cy += dir[out_dir][1];
+                in_dir = out_dir;
+                break;
+            }
+        }
+    } while(!(cx == startx && cy == starty));
+}
+
+vector<vector<wxPoint> > LazySnapping::getMaskContours() const
+{
+    ///\brief find all the closed black regions
+    vector<vector<wxPoint> > contours;
+#if 0
+    // create a working copy of m_mask 
+    unsigned char *mask = new unsigned char [m_width * m_height];
+    // fetch the bitmap data...there's no better way other than converting into wxImage
+    // and then retrieving the data from a single channel
+    wxImage img = m_mask->ConvertToImage();
+    img.SaveFile(wxT("J:\\hugin-devel\\test\\testimages\\lowres\\mask0.tif"));
+    unsigned char *mask_tmp = new unsigned char[ m_width * m_height * 3];
+    memcpy(mask_tmp, img.GetData(), sizeof(unsigned char) * m_width * m_height * 3);
+    for(int i = 0; i < m_height; i++) {
+        for(int j = 0; j < m_width; j++) {
+            mask[i * m_width + j] = mask_tmp[(i * m_width + j)];
+        }
+    }
+    delete [] mask_tmp;
+    //find an edge which hasn't been traversed yet
+    for(int i = 0; i < m_height; i++) {
+        for(int j = 0; j < m_width; j++) {
+            if(mask[i * m_width + j] == 0) {
+                floodFill(j, i, mask, mask[i * m_width + j], 128);
+                vector<wxPoint> contour;
+                traceContour(j, i, mask, 128, contour);
+                contours.push_back(contour);
+            }
+        }
+    }
+    
+    //wxBitmap bmp((char*)mask, m_width, m_height);
+    //bmp.SaveFile(wxT("J:\\hugin-devel\\test\\testimages\\lowres\\mask1.bmp"), wxBITMAP_TYPE_BMP);
+    delete [] mask;
+#endif
+    return contours;
+}
+
 wxBitmap* LazySnapping::getImage() const
 {
     return new wxBitmap((const char*)m_data, m_width, m_height, m_depth);

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.h
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.h	2009-01-03 15:47:09 UTC (rev 3577)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.h	2009-01-04 00:23:24 UTC (rev 3578)
@@ -33,7 +33,7 @@
 
 const double SIGMA = 2.0f;
 const double LAMBDA = 50.0f;
-const int    NCLUSTERS = 64;
+const int    NCLUSTERS = 16;
 const int    CLUSTERCOORDDIM = 5; // 3:RGB, 5:RGB + (r,c)
 
 class LazySnappingMemento;
@@ -48,11 +48,11 @@
     //wxBitmap *m_tmp_bmp;         //used for drawing lines and getting all pixel from it
     //HuginBase::ImageCache::ImageCacheRGB8Ptr m_img;
     unsigned char *m_data;
-    std::vector<wxPoint> m_outline;
+    //std::vector<wxPoint> m_outline;
     int m_width, m_height, m_depth;
     Graph::node_id *m_nodes;
     Graph          *m_graph;
-    int             m_cnodes;       //number of nodes it can be no. of pixels or nodes after preprocessing
+    int             m_cnodes;       //number of nodes. It can be no. of pixels or nodes after preprocessing
     double          m_lambda, m_sigma;
     captype         m_K;
 
@@ -150,6 +150,9 @@
     PixelColor getPixelValue(int p) const;
     PixelColor getPixelValue(int r, int c) const;
     PixelColor getPixelValue(PixelCoord pt) const;
+
+    void traceContour(int x, int y, unsigned char *mask, int contour_val, std::vector<wxPoint> &contour) const;
+    void floodFill(int x, int y, unsigned char *mask, int val, int fill_val) const;
 public:
     LazySnapping();    
     LazySnapping(const std::string &filename);
@@ -174,6 +177,6 @@
     wxMask* getMask() const;
     wxBitmap* getMaskBitmap() const;
     wxBitmap* getImage() const;                 //get working image
-    std::vector<wxPoint> getOutline() const;
+    std::vector<std::vector<wxPoint> > getMaskContours() const;
 };
 #endif

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/polyed_basic/PolyEd_Basic.cpp
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/polyed_basic/PolyEd_Basic.cpp	2009-01-03 15:47:09 UTC (rev 3577)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/polyed_basic/PolyEd_Basic.cpp	2009-01-04 00:23:24 UTC (rev 3578)
@@ -173,9 +173,9 @@
     return m_mask;
 }
 
-vector<wxPoint> PolyEd_Basic::getOutline() const
+vector<vector<wxPoint> > PolyEd_Basic::getMaskContours() const
 {
-    vector<wxPoint> outline;
+    vector<vector<wxPoint> > outline;
     return outline;
 }
 

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/polyed_basic/PolyEd_Basic.h
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/polyed_basic/PolyEd_Basic.h	2009-01-03 15:47:09 UTC (rev 3577)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/polyed_basic/PolyEd_Basic.h	2009-01-04 00:23:24 UTC (rev 3578)
@@ -56,7 +56,7 @@
     void setImage(const std::string &imgId, const vigra::BRGBImage* img, vigra::BImage *mask = 0);
     wxMask* getMask() const;
     wxBitmap* getMaskBitmap() const;
-    std::vector<wxPoint> getOutline() const;
+    std::vector<std::vector<wxPoint> > getMaskContours() const;
 };
 
 #endif


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 3581
          http://hugin.svn.sourceforge.net/hugin/?rev=3581&view=rev
Author:   fmannan
Date:     2009-01-11 21:18:26 +0000 (Sun, 11 Jan 2009)

Log Message:
-----------
+Added Contour Tracing code
+Added show/hide contour option in the GUI

Modified Paths:
--------------
    hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdClientWnd.cpp
    hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdClientWnd.h
    hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.cpp
    hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.h
    hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdMainFrame.cpp
    hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdMainFrame.h
    hugin/branches/gsoc2008_masking/src/maskeditor/gui/xrc/data/Thumbs.db
    hugin/branches/gsoc2008_masking/src/maskeditor/gui/xrc/main_toolbar.xrc
    hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.cpp
    hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.h
    hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnappingMemento.cpp
    hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnappingMemento.h

Added Paths:
-----------
    hugin/branches/gsoc2008_masking/src/maskeditor/gui/xrc/data/contour_region.png

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdClientWnd.cpp
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdClientWnd.cpp	2009-01-09 02:49:55 UTC (rev 3580)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdClientWnd.cpp	2009-01-11 21:18:26 UTC (rev 3581)
@@ -124,6 +124,11 @@
     m_MaskEdEditWnd->toggleShowOverlappedRect();
 }
 
+void MaskEdClientWnd::toggleShowContour()
+{
+    m_MaskEdEditWnd->toggleShowContour();
+}
+
 void MaskEdClientWnd::undo()
 {
     m_MaskEdEditWnd->undo();

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdClientWnd.h
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdClientWnd.h	2009-01-09 02:49:55 UTC (rev 3580)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdClientWnd.h	2009-01-11 21:18:26 UTC (rev 3581)
@@ -56,6 +56,7 @@
     wxString getFile() const;
     void setEditMode(MaskEdEditMode_t edmode);
     void toggleShowOverlappedRect();
+    void toggleShowContour();
 
     void undo();
     void redo();

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.cpp
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.cpp	2009-01-09 02:49:55 UTC (rev 3580)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.cpp	2009-01-11 21:18:26 UTC (rev 3581)
@@ -563,6 +563,13 @@
     Refresh();
 }
 
+void MaskEdEditWnd::toggleShowContour()
+{
+    m_bShowContour = m_bShowContour ? false : true;
+    updateMask(m_active);
+    Refresh();
+}
+
 void MaskEdEditWnd::undo()
 {
     m_MaskEdCmdHist.undo();
@@ -581,22 +588,41 @@
 
 void MaskEdEditWnd::updateMask(int nimgId)
 {
-    wxBitmap *mask = MaskMgr::getInstance()->getSegmentation(m_imgfiles[nimgId])->getMaskBitmap();
-    wxImage img = *m_wximgs[nimgId];
-    img.SetMaskFromImage(mask->ConvertToImage(), 0, 0, 0);
+    static unsigned char bInv = 0;
+    wxImage img = *m_wximgs[nimgId];
     delete m_bimgs[nimgId];
-    m_bimgs[nimgId] = new wxBitmap(img);
-    // draw mask contour
-    vector<vector<wxPoint> > contours = MaskMgr::getInstance()->getSegmentation(m_imgfiles[nimgId])->getMaskContours();
-    if(contours.size() > 0) {
-        wxMemoryDC dc(*m_bimgs[nimgId]);
-        dc.SetPen(*wxRED_PEN);
-        for(vector<vector<wxPoint> >::iterator i = contours.begin(); i != contours.end(); i++) {
-            for(vector<wxPoint>::iterator j =  i->begin(); j != i->end(); j++) {
-                dc.DrawPoint(*j);
+    if(!m_bShowContour) {
+        wxBitmap *mask = MaskMgr::getInstance()->getSegmentation(m_imgfiles[nimgId])->getMaskBitmap();
+        img.SetMaskFromImage(mask->ConvertToImage(), 0, 0, 0);
+        m_bimgs[nimgId] = new wxBitmap(img);
+    } else {
+        m_bimgs[nimgId] = new wxBitmap(img);
+        // draw mask contour
+        vector<vector<wxPoint> > contours = MaskMgr::getInstance()->getSegmentation(m_imgfiles[nimgId])->getMaskContours();
+        if(contours.size() > 0) {
+            wxMemoryDC dc(*m_bimgs[nimgId]);
+            wxPen pen;
+            /*if(bInv)
+                pen = wxPen(wxColor(128, 128, 128),2, wxSHORT_DASH);
+            else 
+                pen = wxPen(wxColor(128, 128, 128),2, wxDOT_DASH);*/
+            /*wxDash dash[2][3] = {{2,1,2}, {1,2,1}};
+            pen.SetDashes(3, dash[bInv]);*/
+            pen = wxPen(wxColor(255, 0, 0),2, wxSOLID);
+            bInv = !bInv;
+            dc.SetPen(pen);
+            
+            for(vector<vector<wxPoint> >::iterator i = contours.begin(); i != contours.end(); i++) {
+                vector<wxPoint>::iterator j =  i->begin();
+                wxPoint pt = *j;
+                for(j++; j != i->end(); j++) {
+                    //dc.DrawPoint(*j);
+                    dc.DrawLine(pt, *j);
+                    pt = *j;
+                }
             }
+            dc.SetPen(wxNullPen);
         }
-        dc.SetPen(wxNullPen);
     }
     updateDisplayBitmap(true);
 }

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.h
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.h	2009-01-09 02:49:55 UTC (rev 3580)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdEditWnd.h	2009-01-11 21:18:26 UTC (rev 3581)
@@ -56,6 +56,7 @@
     float                   m_scale;
     int                     m_edmode;           //editing mode
     bool                    m_bShowOverlappedRect;
+    bool                    m_bShowContour;     
 
     AppBase::CommandHistory<AppBase::Command<std::string> >   m_MaskEdCmdHist;
 
@@ -89,6 +90,7 @@
     
     void setEditMode(MaskEdEditMode_t edmode);
     void toggleShowOverlappedRect();
+    void toggleShowContour();
     void undo();
     void redo();
 

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdMainFrame.cpp
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdMainFrame.cpp	2009-01-09 02:49:55 UTC (rev 3580)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdMainFrame.cpp	2009-01-11 21:18:26 UTC (rev 3581)
@@ -64,6 +64,7 @@
     EVT_BUTTON(XRCID("action_set_roi"), MaskEdMainFrame::OnSetROI)
     EVT_MENU(XRCID("action_show_overlap"), MaskEdMainFrame::OnShowOverlap)
     EVT_BUTTON(XRCID("action_show_overlap"), MaskEdMainFrame::OnShowOverlap)
+    EVT_BUTTON(XRCID("action_show_contour"), MaskEdMainFrame::OnShowContour)
     EVT_COMBOBOX(XRCID("m_comboSegChoice"), MaskEdMainFrame::OnSegSelUpdate)
     //EVT_SIZE(MaskEdMainFrame::OnSize)
 END_EVENT_TABLE()
@@ -261,6 +262,11 @@
     m_MaskEdClientWnd->toggleShowOverlappedRect();
 }
 
+void MaskEdMainFrame::OnShowContour(wxCommandEvent &event)
+{
+    m_MaskEdClientWnd->toggleShowContour();
+}
+
 void MaskEdMainFrame::OnSegSelUpdate(wxCommandEvent &event)
 {
     wxWindow *pWnd = GetToolBar();

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdMainFrame.h
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdMainFrame.h	2009-01-09 02:49:55 UTC (rev 3580)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/gui/MaskEdMainFrame.h	2009-01-11 21:18:26 UTC (rev 3581)
@@ -58,6 +58,7 @@
     void OnZoomOut(wxCommandEvent& event);
     void OnSetROI(wxCommandEvent& event);
     void OnShowOverlap(wxCommandEvent& event);
+    void OnShowContour(wxCommandEvent& event);
     void OnSegSelUpdate(wxCommandEvent& event);
 
     void OnSize(wxSizeEvent& event);

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/gui/xrc/data/Thumbs.db
===================================================================
(Binary files differ)

Added: hugin/branches/gsoc2008_masking/src/maskeditor/gui/xrc/data/contour_region.png
===================================================================
(Binary files differ)


Property changes on: hugin/branches/gsoc2008_masking/src/maskeditor/gui/xrc/data/contour_region.png
___________________________________________________________________
Added: svn:mime-type
   + application/octet-stream

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/gui/xrc/main_toolbar.xrc
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/gui/xrc/main_toolbar.xrc	2009-01-09 02:49:55 UTC (rev 3580)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/gui/xrc/main_toolbar.xrc	2009-01-11 21:18:26 UTC (rev 3581)
@@ -69,6 +69,12 @@
         <longhelp></longhelp>
         <bitmap>data/rectoverlap.png</bitmap>
       </object>
+      <object class="tool" name="action_show_contour">
+        <label>tool</label>
+        <tooltip>Show contour of the selected region</tooltip>
+        <longhelp></longhelp>
+        <bitmap>data/contour_region.png</bitmap>
+      </object>
       <object class="separator" />
       <object class="wxComboBox" name="m_comboSegChoice">
         <style>wxCB_DROPDOWN|wxCB_READONLY</style>

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.cpp
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.cpp	2009-01-09 02:49:55 UTC (rev 3580)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.cpp	2009-01-11 21:18:26 UTC (rev 3581)
@@ -60,14 +60,14 @@
  * LazySnapping Implementation
  */
 LazySnapping::LazySnapping() 
-: m_mask(0), m_data(0), m_nodes(0), m_graph(0), m_lambda(LAMBDA), m_sigma(SIGMA),
+: m_mask(0), m_mask_data(0), m_data(0), m_nodes(0), m_graph(0), m_lambda(LAMBDA), m_sigma(SIGMA),
 m_nclusters(NCLUSTERS), m_K(-1), m_width(0), m_height(0), m_depth(0), m_cnodes(0),
 m_memento(0)
 {
     m_name = "LazySnapping";
 }
 LazySnapping::LazySnapping(const string &filename) 
-: m_mask(0), m_data(0), m_nodes(0), m_graph(0), m_lambda(LAMBDA), m_sigma(SIGMA),
+: m_mask(0), m_mask_data(0), m_data(0), m_nodes(0), m_graph(0), m_lambda(LAMBDA), m_sigma(SIGMA),
 m_nclusters(NCLUSTERS), m_K(-1), m_width(0), m_height(0), m_depth(0), m_cnodes(0),
 m_memento(0)
 {
@@ -76,7 +76,7 @@
 }
 
 LazySnapping::LazySnapping(const string &imgId, const vigra::BRGBImage *img, vigra::BImage *mask)
-: m_mask(0), m_data(0), m_nodes(0), m_graph(0), m_lambda(LAMBDA), m_sigma(SIGMA),
+: m_mask(0), m_mask_data(0), m_data(0), m_nodes(0), m_graph(0), m_lambda(LAMBDA), m_sigma(SIGMA),
 m_nclusters(NCLUSTERS), m_K(-1), m_width(0), m_height(0), m_depth(0), m_cnodes(0),
 m_memento(0)
 {
@@ -93,17 +93,17 @@
 {
     if(m_mask)
         delete m_mask;
+    if(m_mask_data)
+        delete m_mask_data;
     m_mask = ((LazySnappingMemento*)memento)->m_mask;
+    m_mask_data = ((LazySnappingMemento*)memento)->m_mask_data;
     m_width = ((LazySnappingMemento*)memento)->m_width;
     m_height = ((LazySnappingMemento*)memento)->m_height;
-    //int n = ((LazySnappingMemento*)memento)->m_nseeds;
-    //while(n > 0)
-    //    m_seeds.e
 }
 
 IMaskEdMemento* LazySnapping::createMemento()
 {
-    m_memento = new LazySnappingMemento(m_mask, m_width, m_height, 
+    m_memento = new LazySnappingMemento(m_mask, m_mask_data, m_width, m_height, 
         m_seeds.size(), m_fgnd_seeds.size(), m_bkgnd_seeds.size(),
         m_fgnd_clusters.size(), m_bkgnd_clusters.size());
     return m_memento;
@@ -136,6 +136,8 @@
     {
         if(!mask) {
             m_mask = new wxBitmap(m_width, m_height, 1);
+            m_mask_data = new unsigned char[m_width * m_height];
+            memset(m_mask_data, 0xff, m_width * m_height);
             wxMemoryDC dc(*m_mask);
             dc.SetBackground(*wxWHITE_BRUSH);
             dc.Clear();
@@ -143,6 +145,7 @@
             assert(mask->width() == m_width && mask->height() == m_height);
             vigra::BImage binmask(mask->width(), mask->height());
             vigra::transformImage(srcImageRange(*mask), destImage(binmask), BinaryMask());
+            memcpy(m_mask_data, (unsigned char*) binmask.data(), binmask.width() * binmask.height());
             m_mask = new wxBitmap((const char*)binmask.data(), binmask.width(), binmask.height());
         }
         /*SAFE_DELETE(m_tmp_bmp);
@@ -516,9 +519,11 @@
     if(label == FGND) {
         dc.SetPen(*wxBLACK);
         dc.SetBrush(*wxBLACK);
+        m_mask_data[getIndex(r, c)] = 0;
     }else {
         dc.SetPen(*wxWHITE);
         dc.SetBrush(*wxWHITE);
+        m_mask_data[getIndex(r, c)] = 255;
     }
     dc.DrawPoint(c, r);
     //dc.DrawCircle(c, r, 5);
@@ -597,9 +602,13 @@
         return;
     mask[y * m_width + x] = fill_val;
     floodFill(x - 1, y, mask, val, fill_val);
+    floodFill(x - 1, y + 1, mask, val, fill_val);
     floodFill(x, y + 1, mask, val, fill_val);
     floodFill(x + 1, y + 1, mask, val, fill_val);
-    floodFill(x, y - 1, mask, val, fill_val);
+    floodFill(x + 1, y, mask, val, fill_val);
+    floodFill(x + 1, y - 1, mask, val, fill_val);
+    floodFill(x , y - 1, mask, val, fill_val);
+    floodFill(x - 1, y - 1, mask, val, fill_val);
 }
 
 void LazySnapping::traceContour(int x, int y, unsigned char *mask, int contour_val, vector<wxPoint> &contour) const
@@ -609,6 +618,8 @@
                       {-1, 0}, {-1, -1}};
     int dir_map[8] = {7, 7, 1, 1, 3, 3, 5, 5}; //mapping of incoming and outgoing direction
     int in_dir, out_dir;
+    vector<int> direction;
+    int back_index = 0;
     int startx = x;
     int starty = y;
     int cx, cy;
@@ -617,7 +628,10 @@
     cy = y;
     in_dir = 2; //initially coming from the left
     do {
-        contour.push_back(wxPoint(cx, cy));
+        if(back_index == 0) {
+            contour.push_back(wxPoint(cx, cy));
+            direction.push_back(in_dir);
+        }
         // determine next point on the boundary
         for(i = 0; i < 8; i++) {
             out_dir = (i + dir_map[in_dir]) % 8;
@@ -628,9 +642,26 @@
                 cx += dir[out_dir][0];
                 cy += dir[out_dir][1];
                 in_dir = out_dir;
+                back_index = 0;
                 break;
             }
         }
+        if(i == 8) { // next point was not found
+            /*contour.pop_back();
+            direction.pop_back();
+            wxPoint pt = contour.back();
+            cx = pt.x;
+            cy = pt.y;
+            in_dir = direction.back();
+            contour.pop_back();
+            direction.pop_back();*/
+            back_index++;
+            if(back_index >= contour.size()) break;
+            wxPoint pt = contour[contour.size() - back_index - 1];
+            cx = pt.x;
+            cy = pt.y;
+            in_dir = direction[direction.size() - back_index - 1];
+        }
     } while(!(cx == startx && cy == starty));
 }
 
@@ -638,21 +669,22 @@
 {
     ///\brief find all the closed black regions
     vector<vector<wxPoint> > contours;
-#if 0
+
     // create a working copy of m_mask 
     unsigned char *mask = new unsigned char [m_width * m_height];
+    memcpy(mask, m_mask_data, m_width * m_height);
     // fetch the bitmap data...there's no better way other than converting into wxImage
     // and then retrieving the data from a single channel
-    wxImage img = m_mask->ConvertToImage();
-    img.SaveFile(wxT("J:\\hugin-devel\\test\\testimages\\lowres\\mask0.tif"));
-    unsigned char *mask_tmp = new unsigned char[ m_width * m_height * 3];
-    memcpy(mask_tmp, img.GetData(), sizeof(unsigned char) * m_width * m_height * 3);
-    for(int i = 0; i < m_height; i++) {
+    //wxImage img = m_mask->ConvertToImage();
+    //img.SaveFile(wxT("J:\\hugin-devel\\test\\testimages\\lowres\\mask0.tif"));
+    //unsigned char *mask_tmp = new unsigned char[ m_width * m_height * 3];
+    //memcpy(mask_tmp, img.GetData(), sizeof(unsigned char) * m_width * m_height * 3);
+    /*for(int i = 0; i < m_height; i++) {
         for(int j = 0; j < m_width; j++) {
             mask[i * m_width + j] = mask_tmp[(i * m_width + j)];
         }
-    }
-    delete [] mask_tmp;
+    }*/
+    //delete [] mask_tmp;
     //find an edge which hasn't been traversed yet
     for(int i = 0; i < m_height; i++) {
         for(int j = 0; j < m_width; j++) {
@@ -661,14 +693,27 @@
                 vector<wxPoint> contour;
                 traceContour(j, i, mask, 128, contour);
                 contours.push_back(contour);
+            } else if(j > 0 && mask[i * m_width + j - 1] == 128 && mask[i * m_width + j] == 255) { //hole
+                vector<wxPoint> contour;
+                traceContour(j-1, i, mask, 128, contour);
+                contours.push_back(contour);
             }
         }
     }
     
-    //wxBitmap bmp((char*)mask, m_width, m_height);
+    //wxBitmap bmp((char*)m_mask_data, m_width, m_height, 1);
     //bmp.SaveFile(wxT("J:\\hugin-devel\\test\\testimages\\lowres\\mask1.bmp"), wxBITMAP_TYPE_BMP);
-    delete [] mask;
-#endif
+    FILE *fout = fopen("J:\\hugin-devel\\test\\testimages\\lowres\\mask1.pgm", "w");
+    fprintf(fout,"P2\n%d %d\n255\n", m_width, m_height);
+    for(int i = 0; i < m_height; i++) {
+        for(int j = 0; j < m_width; j++) {
+            fprintf(fout, "%d ", mask[i * m_width + j]);
+        }
+        fprintf(fout,"\n");
+    }
+    //delete [] mask;
+    //delete [] mask_tmp;
+
     return contours;
 }
 

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.h
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.h	2009-01-09 02:49:55 UTC (rev 3580)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnapping.h	2009-01-11 21:18:26 UTC (rev 3581)
@@ -33,7 +33,7 @@
 
 const double SIGMA = 2.0f;
 const double LAMBDA = 50.0f;
-const int    NCLUSTERS = 16;
+const int    NCLUSTERS = 64;
 const int    CLUSTERCOORDDIM = 5; // 3:RGB, 5:RGB + (r,c)
 
 class LazySnappingMemento;
@@ -45,9 +45,10 @@
     typedef float captype;
 
     wxBitmap *m_mask;
+    unsigned char *m_mask_data;    // raw pixels
     //wxBitmap *m_tmp_bmp;         //used for drawing lines and getting all pixel from it
     //HuginBase::ImageCache::ImageCacheRGB8Ptr m_img;
-    unsigned char *m_data;
+    unsigned char *m_data;         // input image
     //std::vector<wxPoint> m_outline;
     int m_width, m_height, m_depth;
     Graph::node_id *m_nodes;

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnappingMemento.cpp
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnappingMemento.cpp	2009-01-09 02:49:55 UTC (rev 3580)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnappingMemento.cpp	2009-01-11 21:18:26 UTC (rev 3581)
@@ -28,10 +28,10 @@
 
 using namespace std;
 
-LazySnappingMemento::LazySnappingMemento(wxBitmap *mask, int width, int height, int prev_nseeds, 
+LazySnappingMemento::LazySnappingMemento(wxBitmap *mask, unsigned char *mask_data, int width, int height, int prev_nseeds, 
                                          int fgnd_nseeds, int bkgnd_nseeds,  
                                          int fgnd_cluster_size, int bkgnd_cluster_size)
-: m_mask(mask), m_width(width), m_height(height), m_nseeds(prev_nseeds),
+: m_mask(mask), m_mask_data(mask_data), m_width(width), m_height(height), m_nseeds(prev_nseeds),
 m_fgnd_nseeds(fgnd_nseeds), m_bkgnd_nseeds(m_bkgnd_nseeds),
 m_fgnd_cluster_size(fgnd_cluster_size), m_bkgnd_cluster_size(bkgnd_cluster_size)
 {}

Modified: hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnappingMemento.h
===================================================================
--- hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnappingMemento.h	2009-01-09 02:49:55 UTC (rev 3580)
+++ hugin/branches/gsoc2008_masking/src/maskeditor/segmentation/lazysnapping/LazySnappingMemento.h	2009-01-11 21:18:26 UTC (rev 3581)
@@ -32,6 +32,7 @@
 class LazySnappingMemento : public IMaskEdMemento
 {
     wxBitmap *m_mask;
+    unsigned char *m_mask_data;
     int m_width, m_height, m_depth;
     std::vector<PixelCoord> m_seeds;
     int m_nseeds;        //previous number of seeds of type label
@@ -41,7 +42,7 @@
 
     friend class LazySnapping;
 public:
-    LazySnappingMemento(wxBitmap *mask, int width, int height, int prev_nseeds, int m_fgnd_nseeds, int m_bkgnd_nseeds, int fgnd_cluster_size, int bkgnd_cluster_size);
+    LazySnappingMemento(wxBitmap *mask, unsigned char *mask_data, int width, int height, int prev_nseeds, int m_fgnd_nseeds, int m_bkgnd_nseeds, int fgnd_cluster_size, int bkgnd_cluster_size);
     ~LazySnappingMemento();
 
     void setSeeds(const std::vector<PixelCoord> &seeds, int label);


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.