Hugin

Revision: 4021
          http://hugin.svn.sourceforge.net/hugin/?rev=4021&view=rev
Author:   stativ
Date:     2009-07-10 14:33:29 +0000 (Fri, 10 Jul 2009)

Log Message:
-----------
changed threshold to be double, it's better for experimenting

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-07-10 14:27:20 UTC (rev 4020)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-07-10 14:33:29 UTC (rev 4021)
@@ -96,7 +96,7 @@
     uint16_t debugFlags = 0;
     EMoR response(0.0f);
     int verbosity = 0;
-    int thresholdLim = 128;
+    double thresholdLim = 128;
     response.resize(5);
     response[0] = -3.59f;
     response[1] = -0.93f;

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp	2009-07-10 14:27:20 UTC (rev 4020)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp	2009-07-10 14:33:29 UTC (rev 4021)
@@ -10,7 +10,7 @@
 using namespace vigra;
 using namespace std;
 
-vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const int threshold, uint16_t flags) {
+vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const double threshold, uint16_t flags) {
     vector<BImagePtr> retVal;
     for (unsigned int i=0; i < inputImages.size(); ++i) {
         if (flags & ONE_MASKED) {

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h	2009-07-10 14:27:20 UTC (rev 4020)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h	2009-07-10 14:33:29 UTC (rev 4021)
@@ -28,4 +28,4 @@
  *                             leave it in one image (where the pixel value is highest) white
  *              ONE_MASKED – make the pixel black only in one image where it's value is lowest
  */
-vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const int threshold, uint16_t flags);
+vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const double threshold, uint16_t flags);


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

Revision: 4024
          http://hugin.svn.sourceforge.net/hugin/?rev=4024&view=rev
Author:   stativ
Date:     2009-07-11 10:21:08 +0000 (Sat, 11 Jul 2009)

Log Message:
-----------
Normalize weights

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/support.h

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-07-10 17:49:27 UTC (rev 4023)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-07-11 10:21:08 UTC (rev 4024)
@@ -176,6 +176,8 @@
     std::vector<FImagePtr> Khan::createWeightMasks() {
         preprocessImages();
         
+        float maxWeight = 0;
+        
         cout << endl << "Running khan algorithm" << endl;
         // and we can run khan algorithm
         // khan iteration
@@ -287,12 +289,18 @@
                         // compute probability and set weight
                         //cout << "P=" << (float) wpqsKhsum/wpqssum << endl;
                         *wx *= (float) wpqsKhsum/wpqssum;
+                        if (maxWeight < *wx)
+                            maxWeight = *wx;
                         wpqsKhsum = wpqssum = 0;
                         
                     }
                 }
             }
         }
+        // normalize  weights
+        for (unsigned int i=0; i<weights.size(); ++i) {
+            transformImage(srcImageRange(*(weights[i])), destImage(*(weights[i])), NormalizeFunctor<float>(maxWeight, 255));
+        }
         return weights;
     }
 }

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/support.h	2009-07-10 17:49:27 UTC (rev 4023)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.h	2009-07-11 10:21:08 UTC (rev 4024)
@@ -78,6 +78,37 @@
         ComponentType offset;
 };
 
+/** Fuctor to normalize values
+ */
+template <class PixelType>
+class NormalizeFunctor {
+    public:
+        NormalizeFunctor(PixelType oldMaxValue, PixelType newMaxValue) : foo(newMaxValue/oldMaxValue) {}
+        
+        PixelType operator()(PixelType const &v) const {
+            return v*foo;
+        }
+    protected:
+        PixelType foo;
+};
+
+/** Fuctor to normalize values
+ * specialization for RGBValue
+ */
+template <class ComponentType>
+class NormalizeFunctor<RGBValue<ComponentType> > {
+    public:
+        NormalizeFunctor(RGBValue<ComponentType> oldMaxValue, RGBValue<ComponentType> newMaxValue) {
+            // TODO
+        }
+        
+        RGBValue<ComponentType> operator()(RGBValue<ComponentType> const &v) {
+            // TODO
+        }
+    protected:
+        RGBValue<ComponentType> foo;
+};
+
 /** Fixed size vector with scalar multiplication and element-wise substraction and addition
  */
 template <class T, int SIZE>


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

Revision: 4027
          http://hugin.svn.sourceforge.net/hugin/?rev=4027&view=rev
Author:   stativ
Date:     2009-07-11 12:04:56 +0000 (Sat, 11 Jul 2009)

Log Message:
-----------
Added constructor to the NormalizeFunctor which do not compute scale factor for every pixel.

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/support.h

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-07-11 10:25:21 UTC (rev 4026)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-07-11 12:04:56 UTC (rev 4027)
@@ -300,8 +300,9 @@
         
         if (verbosity > 1)
                 cout << "normalizing weights" << endl;
+        double factor = 255.0f/maxWeight;
         for (unsigned int i=0; i<weights.size(); ++i) {
-            transformImage(srcImageRange(*(weights[i])), destImage(*(weights[i])), NormalizeFunctor<float>(maxWeight, 255));
+            transformImage(srcImageRange(*(weights[i])), destImage(*(weights[i])), NormalizeFunctor<float>(factor));
         }
         return weights;
     }

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/support.h	2009-07-11 10:25:21 UTC (rev 4026)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.h	2009-07-11 12:04:56 UTC (rev 4027)
@@ -83,13 +83,14 @@
 template <class PixelType>
 class NormalizeFunctor {
     public:
-        NormalizeFunctor(PixelType oldMaxValue, PixelType newMaxValue) : foo(newMaxValue/oldMaxValue) {}
+        NormalizeFunctor(PixelType f) : factor(f) {}
+        NormalizeFunctor(PixelType oldMaxValue, PixelType newMaxValue) : factor(newMaxValue/oldMaxValue) {}
         
         PixelType operator()(PixelType const &v) const {
-            return v*foo;
+            return v*factor;
         }
     protected:
-        PixelType foo;
+        PixelType factor;
 };
 
 /** Fuctor to normalize values


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

Revision: 4029
          http://hugin.svn.sourceforge.net/hugin/?rev=4029&view=rev
Author:   stativ
Date:     2009-07-11 13:24:49 +0000 (Sat, 11 Jul 2009)

Log Message:
-----------
Added option which disables computing initial weights using hat function. I'm not sure if it's usefull though.

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h	2009-07-11 12:05:39 UTC (rev 4028)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h	2009-07-11 13:24:49 UTC (rev 4029)
@@ -23,9 +23,9 @@
     typedef boost::shared_ptr<vigra::FImage> FImagePtr;
 
     // constants for advanced modes
-    const uint16_t ADV_LOGARITHM  = 1;
-    const uint16_t ADV_GAMMA      = 2;
-    const uint16_t ADV_UNAVG   = 4;
+    const uint16_t ADV_LOGARITHM     = 1;
+    const uint16_t ADV_GAMMA         = 2;
+    const uint16_t ADV_NOINITWEIGHTS = 4;
     const uint16_t ADV_UNAVG2  = 8;
 
     // constants for debug modes

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-07-11 12:05:39 UTC (rev 4028)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-07-11 13:24:49 UTC (rev 4029)
@@ -45,6 +45,7 @@
          << "                                   cannot be combined with g" << endl
          << "                               g   use gamma 2.2 correction on input if input images are HDR," << endl
          << "                                   cannot be combined with l" << endl
+         << "                               n   do not compute initial weigths" << endl
          << "     -b BLOCKSIZE              image cache BLOCKSIZE in kilobytes; default: " <<
             (CachedFileImageDirector::v().getBlockSize() / 1024LL) << "KB" << endl
          << "     -m CACHESIZE              set image CACHESIZE in megabytes; default: " << 
@@ -147,6 +148,9 @@
                                     }
                                     flags += ADV_LOGARITHM;
                                     break;
+                                case 'n':
+                                    flags += ADV_NOINITWEIGHTS;
+                                    break;
                                 default:
                                     cerr<< "Error: unknown option" << endl;
                                     return 1;
@@ -225,6 +229,9 @@
                             }
                             flags += ADV_LOGARITHM;
                             break;
+                        case 'n':
+                            flags += ADV_NOINITWEIGHTS;
+                            break;
                         default:
                             cerr<< "Error: unknown option" << endl;
                             return 1;

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-07-11 12:05:39 UTC (rev 4028)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-07-11 13:24:49 UTC (rev 4029)
@@ -152,7 +152,15 @@
             }
             
             // generate initial weights using hat function
-            transformImage(srcImageRange(*pInputImg),destImage(*weight),hat);
+            if (flags & ADV_NOINITWEIGHTS) {
+                // convert image to grayscale (and take logarithm)
+                RGBToGrayAccessor<FRGBImage::PixelType> color2gray;
+                transformImage(srcImageRange(*pInputImg, color2gray), destImage(*weight), log(Arg1()+Param(1.0f)));
+            }
+            else {
+                transformImage(srcImageRange(*pInputImg),destImage(*weight),hat);
+            }
+            
             // convert from linear RGB to L*a*b //
             RGB2LabFunctor<float> RGB2Lab;
             FLabImagePtr LabImage(new FLabImage(imgInfo.size()));


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

Revision: 4031
          http://hugin.svn.sourceforge.net/hugin/?rev=4031&view=rev
Author:   stativ
Date:     2009-07-11 14:13:52 +0000 (Sat, 11 Jul 2009)

Log Message:
-----------
Some name changes

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h	2009-07-11 14:09:22 UTC (rev 4030)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h	2009-07-11 14:13:52 UTC (rev 4031)
@@ -26,11 +26,9 @@
     const uint16_t ADV_LOGARITHM     = 1;
     const uint16_t ADV_GAMMA         = 2;
     const uint16_t ADV_NOINITWEIGHTS = 4;
-    const uint16_t ADV_UNAVG2  = 8;
 
     // constants for debug modes
-    const uint16_t SAVE_WEIGHTS   = 1;
-    const uint16_t SAVE_PROBABILITIES = 2;
+    const uint16_t SAVE_INITWEIGHTS   = 1;
 
     class Deghosting
     {

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-07-11 14:09:22 UTC (rev 4030)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-07-11 14:13:52 UTC (rev 4031)
@@ -170,7 +170,7 @@
             weights.push_back(weight);
             
             // save weights for testing purposes
-            if (debugFlags & SAVE_WEIGHTS) {
+            if (debugFlags & SAVE_INITWEIGHTS) {
                 char tmpfn[100];
                 snprintf(tmpfn, 99, "init_weights_%d.tiff", i);
                 ImageExportInfo exWeights(tmpfn);


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

Revision: 4033
          http://hugin.svn.sourceforge.net/hugin/?rev=4033&view=rev
Author:   stativ
Date:     2009-07-12 07:04:00 +0000 (Sun, 12 Jul 2009)

Log Message:
-----------
Added possibility to call fuctor before applying threshold. I use it for changing contrast, because it yields better results then.

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h

Removed Paths:
-------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-07-11 17:37:06 UTC (rev 4032)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-07-12 07:04:00 UTC (rev 4033)
@@ -340,13 +340,14 @@
         }
     }
     
-    vector<BImagePtr> thresholded = threshold(weights, thresholdLim, 0);
+    vector<BImagePtr> thresholded = threshold(weights, thresholdLim, BrightnessContrastFunctor<FImage::PixelType>(1, contrast, 0, 255), 0);
     
     // save masks with treshold applied
     for (unsigned int i=0; i<weights.size(); ++i) {
         char tmpfn[100];
-        cout << hugin_utils::stripExtension(inputFiles[i]).c_str() << endl;
-        snprintf(tmpfn, 99, "%s_mask.tiff", hugin_utils::stripExtension(inputFiles[i]).c_str());
+        string fileName = hugin_utils::stripExtension(inputFiles[i]);
+        fileName = hugin_utils::stripPath(fileName);
+        snprintf(tmpfn, 99, "%s_mask.tiff", fileName.c_str());
         ImageExportInfo exWeights(tmpfn);
         exportImage(srcImageRange(*thresholded[i]), exWeights.setPixelType("UINT8"));
     }

Deleted: hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp	2009-07-11 17:37:06 UTC (rev 4032)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp	2009-07-12 07:04:00 UTC (rev 4033)
@@ -1,33 +0,0 @@
-
-#include "threshold.h"
-
-#include <vigra/transformimage.hxx>
-#include <vigra/imageinfo.hxx>
-
-// just for testing
-#include <vigra/inspectimage.hxx>
-
-using namespace vigra;
-using namespace std;
-
-vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const double threshold, uint16_t flags) {
-    vector<BImagePtr> retVal;
-    for (unsigned int i=0; i < inputImages.size(); ++i) {
-        if (flags & ONE_MASKED) {
-            // TODO
-            exit(0);
-        }
-        else if (flags & ONE_UNMASKED) {
-            // TODO
-            exit(0);
-        }
-        else {
-            // don't care about masking
-            BImagePtr tmpImg(new BImage(inputImages[i]->size()));
-            transformImage(srcImageRange(*(inputImages[i])), destImage(*tmpImg),
-                            Threshold<FImage::PixelType, BImage::PixelType>(threshold, 255, 0, 255));
-            retVal.push_back(tmpImg);
-        }
-    }
-    return retVal;
-}

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h	2009-07-11 17:37:06 UTC (rev 4032)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h	2009-07-12 07:04:00 UTC (rev 4033)
@@ -7,6 +7,7 @@
 
 #include <boost/shared_ptr.hpp>
 #include <vigra/stdimage.hxx>
+#include <vigra/transformimage.hxx>
 
 #include "deghosting.h"
 
@@ -28,4 +29,27 @@
  *                             leave it in one image (where the pixel value is highest) white
  *              ONE_MASKED – make the pixel black only in one image where it's value is lowest
  */
-vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const double threshold, uint16_t flags);
+template <class Functor>
+vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const double threshold, const Functor &f, uint16_t flags) {
+    vector<BImagePtr> retVal;
+    for (unsigned int i=0; i < inputImages.size(); ++i) {
+        if (flags & ONE_MASKED) {
+            // TODO
+            exit(0);
+        }
+        else if (flags & ONE_UNMASKED) {
+            // TODO
+            exit(0);
+        }
+        else {
+            // don't care about masking
+            BImagePtr tmpImg(new BImage(inputImages[i]->size()));
+            // preprocess image using functor f
+            transformImage(srcImageRange(*(inputImages[i])), destImage(*tmpImg), f);
+            transformImage(srcImageRange(*tmpImg), destImage(*tmpImg),
+                            Threshold<FImage::PixelType, BImage::PixelType>(threshold, 255, 0, 255));
+            retVal.push_back(tmpImg);
+        }
+    }
+    return retVal;
+}


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

Revision: 4037
          http://hugin.svn.sourceforge.net/hugin/?rev=4037&view=rev
Author:   stativ
Date:     2009-07-13 15:17:24 +0000 (Mon, 13 Jul 2009)

Log Message:
-----------
Finished more advanced threshold which doesn't leave holes in images

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/CMakeLists.txt
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/CMakeLists.txt
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/CMakeLists.txt	2009-07-13 00:42:47 UTC (rev 4036)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/CMakeLists.txt	2009-07-13 15:17:24 UTC (rev 4037)
@@ -1,6 +1,6 @@
 # various command line utilities
 
-add_executable(deghosting_mask deghosting_mask.cpp khan.cpp jbu.cpp support.cpp threshold.cpp)
+add_executable(deghosting_mask deghosting_mask.cpp khan.cpp support.cpp)
 target_link_libraries(deghosting_mask ${common_libs} ${image_libs})
 
 install(TARGETS deghosting_mask DESTINATION ${BINDIR})

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-07-13 00:42:47 UTC (rev 4036)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-07-13 15:17:24 UTC (rev 4037)
@@ -35,7 +35,8 @@
 static int iterations = 1;
 static double sigma = 30;
 static uint16_t flags = 0;
-static uint16_t otherFlags = 0;
+static uint16_t otherSaveFlags = 0;
+static uint16_t otherThresholdFlags = 0;
 static uint16_t debugFlags = 0;
 static EMoR response(0.0f);
 static int verbosity = 0;
@@ -64,6 +65,9 @@
             case 'n':
                 flags += ADV_NOINITWEIGHTS;
                 break;
+            case 't':
+                otherThresholdFlags += THRESHOLD_DONTCARE;
+                break;
             default:
                 cerr<< "Error: unknown option" << endl;
                 exit(1);
@@ -80,7 +84,7 @@
                 flags += SAVE_INITWEIGHTS;
                 break;
             case 'w':
-                otherFlags += SAVE_GENWEIGHTS;
+                otherSaveFlags += SAVE_GENWEIGHTS;
                 break;
             default:
                 cerr<< "Error: unknown option" << endl;
@@ -111,6 +115,7 @@
          << "                               g   use gamma 2.2 correction on input if input images are HDR," << endl
          << "                                   cannot be combined with l" << endl
          << "                               n   do not compute initial weigths" << endl
+         << "                               t   use simple threshold, may result in holes in images" << endl
          << "     -w, --save=SET            advanced save settings" << endl
          << "                               i   save initial weigths" << endl
          << "                               w   save generated weigths" << endl
@@ -331,23 +336,23 @@
     vector<FImagePtr> weights = deghoster->createWeightMasks();
     
     // save weights
-    if (otherFlags & SAVE_GENWEIGHTS) {
+    if (otherSaveFlags & SAVE_GENWEIGHTS) {
         for (unsigned int i=0; i<weights.size(); ++i) {
             char tmpfn[100];
-            snprintf(tmpfn, 99, "%s_%d.tiff", outputPrefix.c_str(), i);
+            snprintf(tmpfn, 99, "%s_%d.tif", outputPrefix.c_str(), i);
             ImageExportInfo exWeights(tmpfn);
             exportImage(srcImageRange(*weights[i]), exWeights.setPixelType("UINT8"));
         }
     }
     
-    vector<BImagePtr> thresholded = threshold(weights, thresholdLim, BrightnessContrastFunctor<FImage::PixelType>(1, contrast, 0, 255), 0);
+    vector<BImagePtr> thresholded = threshold(weights, thresholdLim, BrightnessContrastFunctor<FImage::PixelType>(1, contrast, 0, 255), otherThresholdFlags);
     
     // save masks with treshold applied
     for (unsigned int i=0; i<weights.size(); ++i) {
         char tmpfn[100];
         string fileName = hugin_utils::stripExtension(inputFiles[i]);
         fileName = hugin_utils::stripPath(fileName);
-        snprintf(tmpfn, 99, "%s_mask.tiff", fileName.c_str());
+        snprintf(tmpfn, 99, "%s_mask.tif", fileName.c_str());
         ImageExportInfo exWeights(tmpfn);
         exportImage(srcImageRange(*thresholded[i]), exWeights.setPixelType("UINT8"));
     }

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h	2009-07-13 00:42:47 UTC (rev 4036)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h	2009-07-13 15:17:24 UTC (rev 4037)
@@ -16,7 +16,6 @@
 using namespace deghosting;
 
 const uint16_t THRESHOLD_DONTCARE = 1;
-const uint16_t THRESHOLD_ONEMASKED = 2;
 
 /** Threshold function
  * used for creating alpha masks for images
@@ -32,6 +31,8 @@
 template <class Functor>
 vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const double threshold, const Functor &f, uint16_t flags) {
     vector<BImagePtr> retVal;
+    const uint8_t minValue = 0;
+    const uint8_t maxValue = 255;
     
     // don't care about masking
     if (flags & THRESHOLD_DONTCARE) {
@@ -45,53 +46,57 @@
         }
         return retVal;
     }
-
-    // OTHER THRESHOLD OPTIONS
     
     // arrays with iterators
     FImage::traverser siterators[inputImages.size()];
     BImage::traverser diterators[inputImages.size()];
     // iterator to the end
     FImage::traverser send = inputImages[0]->lowerRight();
-    // fill iterators array
+    // fill iterators and retVal
     for (unsigned int i=0; i < inputImages.size(); ++i) {
+        // fill retVal
+        BImagePtr tmpImg(new BImage(inputImages[i]->size()));
+        retVal.push_back(tmpImg);
+        // fill iterators
         siterators[i] = inputImages[i]->upperLeft();
+        diterators[i] = retVal[i]->upperLeft();
     }
     
-    // exactly one image masked
-    if (flags & THRESHOLD_ONEMASKED) {
-        
-    }
-    
-    // at least one image not masked
+    // leave pixels not masked in at least one image
     // this is DEFAULT
     // loop over row
     while (siterators[0].y != send.y) {
         // array with column iterators
         FImage::traverser siteratorsX[inputImages.size()];
+        BImage::traverser diteratorsX[inputImages.size()];
         for (unsigned int i=0; i < inputImages.size(); ++i) {
             siteratorsX[i] = siterators[i];
+            diteratorsX[i] = diterators[i];
         }
-        
         // now we can loop over the same pixels in all images at once
         while (siteratorsX[0].x != send.x) {
-            // image with smallest weight for the pixel
-            unsigned int smallestI = 0;
-            for (unsigned int i=0; inputImages.size(); ++i) {
-                // set pixel to black
-                if (*(siteratorsX[i]) < threshold) {
-                    // TODO
-                }
+            // image with highest weight for the pixel
+            unsigned int highestI = 0;
+            for (unsigned int i=0; i<inputImages.size(); ++i) {
+                // apply threshold
+                if (*(siteratorsX[i]) < threshold)
+                    *(diteratorsX[i]) = minValue;
+                else
+                    *(diteratorsX[i]) = maxValue;
+                // highest search
+                highestI = (*(siteratorsX[highestI]) > *(siteratorsX[i])) ? highestI : i;
             }
+            // set the highest one to maxValue;
+            *(diteratorsX[highestI]) = maxValue;
             
             // move all iterators by one pixel to the right
-            for (unsigned int i=0; inputImages.size(); ++i) {
-                ++siteratorsX[i];
+            for (unsigned int i=0; i<inputImages.size(); ++i) {
+                ++siteratorsX[i].x;
+                ++diteratorsX[i].x;
             }
         }
-        
         // move all iterators to the next row
-        for (unsigned int i=0; inputImages.size(); ++i) {
+        for (unsigned int i=0; i<inputImages.size(); ++i) {
             ++siterators[i].y;
             ++diterators[i].y;
         }


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

Revision: 4048
          http://hugin.svn.sourceforge.net/hugin/?rev=4048&view=rev
Author:   stativ
Date:     2009-07-17 12:35:59 +0000 (Fri, 17 Jul 2009)

Log Message:
-----------
Changed function preprocessImages() to preprocessImage which prepares only one image. I'll make use of it later.

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h	2009-07-17 09:01:43 UTC (rev 4047)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h	2009-07-17 12:35:59 UTC (rev 4048)
@@ -26,6 +26,7 @@
     const uint16_t ADV_LOGARITHM     = 1;
     const uint16_t ADV_GAMMA         = 2;
     const uint16_t ADV_NOINITWEIGHTS = 4;
+    const uint16_t ADV_ONLYP         = 8;
 
     // constants for debug modes
     const uint16_t SAVE_INITWEIGHTS   = 1;

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-07-17 09:01:43 UTC (rev 4047)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-07-17 12:35:59 UTC (rev 4048)
@@ -114,75 +114,76 @@
         }
     }
     
-    void Khan::preprocessImages() {
-        for (unsigned int i = 0; i < inputFiles.size(); i++) {
-            cout << "Loading image number " << i << endl;
-            // I should reimplement it without using VIGRA
-            ImageImportInfo imgInfo(inputFiles[i].c_str());
-            FRGBImage * pInputImg =  new FRGBImage(imgInfo.size());
-            BImage imgAlpha(imgInfo.size());
-            FImagePtr weight(new FImage(imgInfo.size()));
-            
-             // import alpha
-            importImageAlpha(imgInfo, destImage(*pInputImg),destImage(imgAlpha));
-            
-            // linearize RGB and convert it to L*a*b image
-            //linearizeRGB(inputFiles[i], pInputImg);
-            
-            // take logarithm or gamma correction if the input images are HDR
-            // I'm not sure if it's the right way how to
-            // find out if they are HDR
-            if ( (!strcmp(imgInfo.getFileType(),"TIFF") && strcmp(imgInfo.getPixelType(),"UINT8")) ||
-                  !strcmp(imgInfo.getFileType(),"EXR") ||
-                  !strcmp(imgInfo.getPixelType(),"FLOAT"))
-            {
-                // take logarithm
-                if (flags & ADV_LOGARITHM) {
-                    transformImage(srcImageRange(*pInputImg),destImage(*pInputImg),LogarithmFunctor<RGBValue<float> >(1.0));
-                }
-                // use gamma 2.2
-                else if (flags & ADV_GAMMA) {
-                    // GammaFunctor is only in vigra 1.6 GRRR
-                    // I have to use BrightnessContrastFunctor
-                    // TODO: change to the GammaFunctor in the future
-                    vigra::FindMinMax<float> minmax;
-                    vigra::inspectImage(srcImageRange(*pInputImg), minmax);
-                    transformImage(srcImageRange(*pInputImg),destImage(*pInputImg),BrightnessContrastFunctor<RGBValue<float> >(0.45,1.0,minmax.min, minmax.max));
-                }
+    void Khan::preprocessImage(unsigned int i, FImagePtr &weight, FLabImagePtr &LabImage) {
+        cout << "Loading image number " << i << endl;
+        ImageImportInfo imgInfo(inputFiles[i].c_str());
+        FRGBImage * pInputImg =  new FRGBImage(imgInfo.size());
+        BImage imgAlpha(imgInfo.size());
+        weight = FImagePtr(new FImage(imgInfo.size()));
+        
+        // import alpha
+        importImageAlpha(imgInfo, destImage(*pInputImg),destImage(imgAlpha));
+        
+        // linearize RGB and convert it to L*a*b image
+        //linearizeRGB(inputFiles[i], pInputImg);
+        
+        // take logarithm or gamma correction if the input images are HDR
+        // I'm not sure if it's the right way how to
+        // find out if they are HDR
+        if ( (!strcmp(imgInfo.getFileType(),"TIFF") && strcmp(imgInfo.getPixelType(),"UINT8")) ||
+                !strcmp(imgInfo.getFileType(),"EXR") ||
+                !strcmp(imgInfo.getPixelType(),"FLOAT"))
+        {
+            // take logarithm
+            if (flags & ADV_LOGARITHM) {
+                transformImage(srcImageRange(*pInputImg),destImage(*pInputImg),LogarithmFunctor<RGBValue<float> >(1.0));
             }
-            
-            // generate initial weights using hat function
-            if (flags & ADV_NOINITWEIGHTS) {
-                // convert image to grayscale (and take logarithm)
-                RGBToGrayAccessor<FRGBImage::PixelType> color2gray;
-                transformImage(srcImageRange(*pInputImg, color2gray), destImage(*weight), log(Arg1()+Param(1.0f)));
+            // use gamma 2.2
+            else if (flags & ADV_GAMMA) {
+                // GammaFunctor is only in vigra 1.6 GRRR
+                // I have to use BrightnessContrastFunctor
+                // TODO: change to the GammaFunctor in the future
+                vigra::FindMinMax<float> minmax;
+                vigra::inspectImage(srcImageRange(*pInputImg), minmax);
+                transformImage(srcImageRange(*pInputImg),destImage(*pInputImg),BrightnessContrastFunctor<RGBValue<float> >(0.45,1.0,minmax.min, minmax.max));
             }
-            else {
-                transformImage(srcImageRange(*pInputImg),destImage(*weight),hat);
-            }
-            
-            // convert from linear RGB to L*a*b //
-            RGB2LabFunctor<float> RGB2Lab;
-            FLabImagePtr LabImage(new FLabImage(imgInfo.size()));
-            transformImage(srcImageRange(*pInputImg), destImage(*LabImage), RGB2Lab);
-            
+        }
+        
+        // generate initial weights using hat function
+        if (flags & ADV_NOINITWEIGHTS) {
+            // convert image to grayscale (and take logarithm)
+            RGBToGrayAccessor<FRGBImage::PixelType> color2gray;
+            transformImage(srcImageRange(*pInputImg, color2gray), destImage(*weight), log(Arg1()+Param(1.0f)));
+        }
+        else {
+            transformImage(srcImageRange(*pInputImg),destImage(*weight),hat);
+        }
+        
+        // convert from linear RGB to L*a*b //
+        RGB2LabFunctor<float> RGB2Lab;
+        LabImage = FLabImagePtr(new FLabImage(imgInfo.size()));
+        transformImage(srcImageRange(*pInputImg), destImage(*LabImage), RGB2Lab);
+        
+        delete pInputImg;
+        pInputImg = 0;
+    }
+    
+    std::vector<FImagePtr> Khan::createWeightMasks() {
+        for (unsigned int i = 0; i < inputFiles.size(); i++) {
+            FImagePtr weight;
+            FLabImagePtr LabImage;
+            preprocessImage(i, weight, LabImage);
             LabImages.push_back(LabImage);
             weights.push_back(weight);
             
-            // save weights for testing purposes
+            // save init weights
             if (debugFlags & SAVE_INITWEIGHTS) {
                 char tmpfn[100];
                 snprintf(tmpfn, 99, "init_weights_%d.tiff", i);
                 ImageExportInfo exWeights(tmpfn);
                 exportImage(srcImageRange(*weight), exWeights.setPixelType("UINT8"));
             }
-            delete pInputImg;
-            pInputImg = 0;
         }
-    }
-    
-    std::vector<FImagePtr> Khan::createWeightMasks() {
-        preprocessImages();
         
         float maxWeight = 0;
         
@@ -311,6 +312,10 @@
         double factor = 255.0f/maxWeight;
         for (unsigned int i=0; i<weights.size(); ++i) {
             transformImage(srcImageRange(*(weights[i])), destImage(*(weights[i])), NormalizeFunctor<float>(factor));
+            // do this only if probabilities are requested
+            if (flags & ADV_ONLYP) {
+                // TODO
+            }
         }
         return weights;
     }

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-07-17 09:01:43 UTC (rev 4047)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-07-17 12:35:59 UTC (rev 4048)
@@ -91,12 +91,11 @@
              * Standard probability density function
              */
             inline double Kh(deghosting::AlgTinyVector< float, 3 > x);
-            /** function to preprocess input images
-             * This function loads images, linearizes them using EMoR,
-             * tranform them using logarithm or gamm if input images are HDR
-             * fills vector<FImagePtr> weights and vector<FLabImagePtr> LabImages
+            /** function to preprocess input image
+             * This function loads image, linearize it using EMoR (FIXME),
+             * tranform it using logarithm or gamma if input images are HDR
              */
-            void preprocessImages();
+            void preprocessImage(unsigned int i, FImagePtr &weight, FLabImagePtr &LabImage);
     };
 }
 


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

Revision: 4091
          http://hugin.svn.sourceforge.net/hugin/?rev=4091&view=rev
Author:   stativ
Date:     2009-07-23 12:10:11 +0000 (Thu, 23 Jul 2009)

Log Message:
-----------
I've finally found a way how to obtain better weights (it's so simple, why I've not got this idea before?)

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-07-23 05:22:55 UTC (rev 4090)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-07-23 12:10:11 UTC (rev 4091)
@@ -34,7 +34,7 @@
 // globals containing settings
 static int iterations = 1;
 static double sigma = 30;
-static uint16_t flags = 0;
+static uint16_t flags = ADV_ONLYP;
 static uint16_t otherSaveFlags = 0;
 static uint16_t otherThresholdFlags = 0;
 static uint16_t debugFlags = 0;
@@ -68,6 +68,9 @@
             case 't':
                 otherThresholdFlags += THRESHOLD_DONTCARE;
                 break;
+            case 'w':
+                flags -= ADV_ONLYP;
+                break;
             default:
                 cerr<< "Error: unknown option" << endl;
                 exit(1);
@@ -116,6 +119,7 @@
          << "                                   cannot be combined with l" << endl
          << "                               n   do not compute initial weigths" << endl
          << "                               t   use simple threshold, may result in holes in images" << endl
+         << "                               w   compute \"complete\" weights, not only probabilities" << endl
          << "     -w, --save=SET            advanced save settings" << endl
          << "                               i   save initial weigths" << endl
          << "                               w   save generated weigths" << endl

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-07-23 05:22:55 UTC (rev 4090)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-07-23 12:10:11 UTC (rev 4091)
@@ -205,7 +205,7 @@
             // loop through all images
             for (unsigned int i = 0; i < LabImages.size(); i++) {
                 if (verbosity > 1)
-                    cout << "processing image " << i << endl;
+                    cout << "processing image " << i+1 << endl;
                 
                 // vector storing pixel data
                 AlgTinyVector<float, 3> X;
@@ -297,7 +297,10 @@
                             cout << "computing new weight" << endl;
                         // compute probability and set weight
                         //cout << "P=" << (float) wpqsKhsum/wpqssum << endl;
-                        *wx *= (float) wpqsKhsum/wpqssum;
+                        if (flags & ADV_ONLYP)
+                            *wx = (float) wpqsKhsum/wpqssum;
+                        else
+                            *wx *= (float) wpqsKhsum/wpqssum;
                         if (maxWeight < *wx)
                             maxWeight = *wx;
                         wpqsKhsum = wpqssum = 0;
@@ -313,12 +316,12 @@
         for (unsigned int i=0; i<weights.size(); ++i) {
             transformImage(srcImageRange(*(weights[i])), destImage(*(weights[i])), NormalizeFunctor<float>(factor));
             // do this only if probabilities are requested
-            if (flags & ADV_ONLYP) {
+            /*if (flags & ADV_ONLYP) {
                 FImagePtr tmpInitWeight;
                 FLabImagePtr null;
                 preprocessImage(i, tmpInitWeight, null);
-                combineTwoImages(srcImageRange(*(weights[i])), srcImage(*tmpInitWeight), destImage(*(weights[i])), Arg1()/Arg2());
-            }
+                combineTwoImages(srcImageRange(*(weights[i])), srcImage(*tmpInitWeight), destImage(*(weights[i])), Arg1()/(Arg2()+Param(0.1)));
+            }*/
         }
         return weights;
     }


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

Revision: 4182
          http://hugin.svn.sourceforge.net/hugin/?rev=4182&view=rev
Author:   stativ
Date:     2009-08-07 09:07:40 +0000 (Fri, 07 Aug 2009)

Log Message:
-----------
Some first thoughts about scaling

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h	2009-08-06 23:06:08 UTC (rev 4181)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h	2009-08-07 09:07:40 UTC (rev 4182)
@@ -29,6 +29,7 @@
     const uint16_t ADV_GAMMA         = 2;
     const uint16_t ADV_NOINITWEIGHTS = 4;
     const uint16_t ADV_ONLYP         = 8;
+    const uint16_t ADV_MULTIRES      = 16;
 
     // constants for debug modes
     const uint16_t SAVE_INITWEIGHTS   = 1;

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-06 23:06:08 UTC (rev 4181)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-07 09:07:40 UTC (rev 4182)
@@ -15,6 +15,9 @@
 // for GammaFunctor
 #include <vigra/transformimage.hxx>
 
+// for resampleImage
+#include <vigra/resizeimage.hxx>
+
 #include <panotools/PanoToolsInterface.h>
 
 // for snprintf
@@ -187,6 +190,8 @@
         }
         
         float maxWeight = 0;
+        const int width = weights[0]->width();
+        const int height = weights[0]->height();
         
         cout << endl << "Running khan algorithm" << endl;
         // and we can run khan algorithm
@@ -197,6 +202,35 @@
             // copy weights from previous iteration
             if (verbosity > 1)
                 cout << "copying weights from previous iteration" << endl;
+            
+            // scale weights to the requied size
+            if (flags & ADV_MULTIRES) {
+                // it would be better to use resampleImage, but it seems to be present only in VIGRA 1.6
+                // so let's use some of the resizeImageINTERPOLATION() functions
+                
+                // compute width TODO
+                int resized_width = width / ( iterations/(i+1) );
+                //compute height TODO
+                int resized_height = height / ( iterations/(i+1) );
+                // it's not worthy to scale to less than 100px per side
+                if (resized_width > 100 && resized_height > 100) {
+                    // create destination image of desired size
+                    FImage resizedWeight(Size2D(resized_width,resized_height));
+                } else if (width >= 100 && height >= 100) {
+                    // resize it to the smallest value (ie 100px for the shorter side)
+                    if (width >= height) {
+                        FImage resizedWeight(Size2D(100*width/height, 100));
+                    } else {
+                        FImage resizedWeight(Size2D(100, 100*height/width));
+                    }
+                } else {
+                    // don't scale at all
+                }
+                
+                // No interpolation – only for testing TODO
+                //resizeImageNoInterpolation(srcImageRange());
+            }
+            
             std::vector<FImagePtr> prevWeights;
             for (unsigned int i = 0; i < weights.size(); i++) {
                 FImagePtr tmp(new FImage(*weights[i]));


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

Revision: 4183
          http://hugin.svn.sourceforge.net/hugin/?rev=4183&view=rev
Author:   stativ
Date:     2009-08-07 11:12:37 +0000 (Fri, 07 Aug 2009)

Log Message:
-----------
Some more work on scaling. Please don't enable it yet, it doesn't scale input images and thus crashes.

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-08-07 09:07:40 UTC (rev 4182)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-08-07 11:12:37 UTC (rev 4183)
@@ -35,6 +35,7 @@
 static int iterations = 1;
 static double sigma = 30;
 static uint16_t flags = ADV_ONLYP;
+//static uint16_t flags = ADV_ONLYP + ADV_MULTIRES;
 static uint16_t otherSaveFlags = 0;
 static uint16_t otherThresholdFlags = 0;
 static uint16_t debugFlags = 0;

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-07 09:07:40 UTC (rev 4182)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-07 11:12:37 UTC (rev 4183)
@@ -190,6 +190,7 @@
         }
         
         float maxWeight = 0;
+        // image size
         const int width = weights[0]->width();
         const int height = weights[0]->height();
         
@@ -203,40 +204,50 @@
             if (verbosity > 1)
                 cout << "copying weights from previous iteration" << endl;
             
-            // scale weights to the requied size
-            if (flags & ADV_MULTIRES) {
-                // it would be better to use resampleImage, but it seems to be present only in VIGRA 1.6
-                // so let's use some of the resizeImageINTERPOLATION() functions
-                
-                // compute width TODO
-                int resized_width = width / ( iterations/(i+1) );
-                //compute height TODO
-                int resized_height = height / ( iterations/(i+1) );
-                // it's not worthy to scale to less than 100px per side
-                if (resized_width > 100 && resized_height > 100) {
-                    // create destination image of desired size
-                    FImage resizedWeight(Size2D(resized_width,resized_height));
-                } else if (width >= 100 && height >= 100) {
-                    // resize it to the smallest value (ie 100px for the shorter side)
-                    if (width >= height) {
-                        FImage resizedWeight(Size2D(100*width/height, 100));
+            std::vector<FImagePtr> prevWeights;
+            for (unsigned int i = 0; i < weights.size(); i++) {
+                // scale weights to the requied size
+                if (flags & ADV_MULTIRES) {
+                    // it would be better to use resampleImage, but it seems to be present only in VIGRA 1.6
+                    // so let's use some of the resizeImageINTERPOLATION() functions
+                    
+                    // compute width TODO
+                    int resized_width = width / ( iterations/(it+1) );
+                    //compute height TODO
+                    int resized_height = height / ( iterations/(it+1) );
+                    // destination image
+                    FImage resizedWeight;
+                    // it's not worthy to scale to less than 100px per side
+                    if (resized_width > 100 && resized_height > 100) {
+                        // DEBUG
+                        cout << "resizing " << iterations/(it+1) << "x to: " << resized_width << " x " << resized_height << endl;
+                        // create destination image of desired size
+                        resizedWeight = FImage(Size2D(resized_width,resized_height));
+                    } else if (width >= 100 && height >= 100) {
+                        // resize it to the smallest value (ie 100px for the shorter side)
+                        if (width >= height) {
+                            resizedWeight = FImage(Size2D(100*width/height, 100));
+                        } else {
+                            resizedWeight = FImage(Size2D(100, 100*height/width));
+                        }
                     } else {
-                        FImage resizedWeight(Size2D(100, 100*height/width));
+                        // don't scale at all
+                        // just copy weights as if no scaling seting was applied
+                        goto DONTSCALE;
                     }
+                    
+                    // No interpolation – only for testing TODO
+                    resizeImageNoInterpolation(srcImageRange(*weights[i]), destImageRange(resizedWeight));
+                    
+                    FImagePtr tmp(new FImage(resizedWeight));
+                    prevWeights.push_back(tmp);
                 } else {
-                    // don't scale at all
+                    DONTSCALE:
+                    FImagePtr tmp(new FImage(*weights[i]));
+                    prevWeights.push_back(tmp);
                 }
-                
-                // No interpolation – only for testing TODO
-                //resizeImageNoInterpolation(srcImageRange());
             }
             
-            std::vector<FImagePtr> prevWeights;
-            for (unsigned int i = 0; i < weights.size(); i++) {
-                FImagePtr tmp(new FImage(*weights[i]));
-                prevWeights.push_back(tmp);
-            }
-            
             // loop through all images
             for (unsigned int i = 0; i < LabImages.size(); i++) {
                 if (verbosity > 1)
@@ -247,9 +258,6 @@
                 // sums for eq. 6
                 double wpqssum = 0;
                 double wpqsKhsum = 0;
-                // image size
-                int width = LabImages[i]->width();
-                int height = LabImages[i]->height();
 
                 // iterator to the upper left corner
                 FLabImage::traverser sy = LabImages[i]->upperLeft();


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

Revision: 4194
          http://hugin.svn.sourceforge.net/hugin/?rev=4194&view=rev
Author:   stativ
Date:     2009-08-11 15:19:31 +0000 (Tue, 11 Aug 2009)

Log Message:
-----------
Finally fixed scaling images.

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-08-09 15:11:30 UTC (rev 4193)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-08-11 15:19:31 UTC (rev 4194)
@@ -34,8 +34,8 @@
 // globals containing settings
 static int iterations = 1;
 static double sigma = 30;
-static uint16_t flags = ADV_ONLYP;
-//static uint16_t flags = ADV_ONLYP + ADV_MULTIRES;
+//static uint16_t flags = ADV_ONLYP;
+static uint16_t flags = ADV_ONLYP + ADV_MULTIRES;
 static uint16_t otherSaveFlags = 0;
 static uint16_t otherThresholdFlags = 0;
 static uint16_t debugFlags = 0;
@@ -63,6 +63,9 @@
                 }
                 flags += ADV_LOGARITHM;
                 break;
+            case 'm':
+                flags -= ADV_MULTIRES;
+                break;
             case 'n':
                 flags += ADV_NOINITWEIGHTS;
                 break;
@@ -118,6 +121,7 @@
          << "                                   cannot be combined with g" << endl
          << "                               g   use gamma 2.2 correction on input if input images are HDR," << endl
          << "                                   cannot be combined with l" << endl
+         << "                               m   do not scale image, NOTE: slows down process" << endl
          << "                               n   do not compute initial weigths" << endl
          << "                               t   use simple threshold, may result in holes in images" << endl
          << "                               w   compute \"complete\" weights, not only probabilities" << endl

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-09 15:11:30 UTC (rev 4193)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-11 15:19:31 UTC (rev 4194)
@@ -191,8 +191,8 @@
         
         float maxWeight = 0;
         // image size
-        const int width = weights[0]->width();
-        const int height = weights[0]->height();
+        const int origWidth = weights[0]->width();
+        const int origHeight = weights[0]->height();
         
         // if we doing scaling, we have to backup L*a*b images of original size
         std::vector<FLabImagePtr> backupLab;
@@ -221,27 +221,25 @@
                     // so let's use some of the resizeImageINTERPOLATION() functions
                     
                     // compute width
-                    int resized_width = width / ( iterations/(it+1) );
+                    int resized_width = origWidth / ( iterations/(it+1) );
                     //compute height
-                    int resized_height = height / ( iterations/(it+1) );
+                    int resized_height = origHeight / ( iterations/(it+1) );
                     // destination images
                     FImage resizedWeight;
                     FLabImage resizedLab;
                     // it's not worthy to scale to less than 100px per side
                     if (resized_width > 100 && resized_height > 100) {
-                        // DEBUG
-                        cout << "resizing " << iterations/(it+1) << "x to: " << resized_width << " x " << resized_height << endl;
                         // create destination image of desired size
                         resizedWeight = FImage(Size2D(resized_width,resized_height));
                         resizedLab = FLabImage(Size2D(resized_width,resized_height));
-                    } else if (width >= 100 && height >= 100) {
+                    } else if (origWidth >= 100 && origHeight >= 100) {
                         // resize it to the smallest value (ie 100px for the shorter side)
-                        if (width >= height) {
-                            resizedWeight = FImage(Size2D(100*width/height, 100));
-                            resizedLab = FLabImage(Size2D(100*width/height, 100));
+                        if (origWidth >= origHeight) {
+                            resizedWeight = FImage(Size2D(100*origWidth/origHeight, 100));
+                            resizedLab = FLabImage(Size2D(100*origWidth/origHeight, 100));
                         } else {
-                            resizedWeight = FImage(Size2D(100, 100*height/width));
-                            resizedLab = FLabImage(Size2D(100, 100*height/width));
+                            resizedWeight = FImage(Size2D(100, 100*origHeight/origWidth));
+                            resizedLab = FLabImage(Size2D(100, 100*origHeight/origWidth));
                         }
                     } else {
                         // don't scale at all
@@ -256,6 +254,7 @@
                     FImagePtr tmp(new FImage(resizedWeight));
                     prevWeights.push_back(tmp);
                     LabImages[i] = FLabImagePtr(new FLabImage(resizedLab));
+                    weights[i] = FImagePtr(new FImage(resizedWeight));
                 } else {
                     DONTSCALE:
                     FImagePtr tmp(new FImage(*weights[i]));
@@ -273,6 +272,9 @@
                 // sums for eq. 6
                 double wpqssum = 0;
                 double wpqsKhsum = 0;
+                // image size
+                const int width = LabImages[i]->width();
+                const int height = LabImages[i]->height();
 
                 // iterator to the upper left corner
                 FLabImage::traverser sy = LabImages[i]->upperLeft();


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

Revision: 4198
          http://hugin.svn.sourceforge.net/hugin/?rev=4198&view=rev
Author:   stativ
Date:     2009-08-12 14:02:22 +0000 (Wed, 12 Aug 2009)

Log Message:
-----------
Remove some unnecessary includes.

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/support.h

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-08-11 21:17:19 UTC (rev 4197)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-08-12 14:02:22 UTC (rev 4198)
@@ -7,6 +7,8 @@
 #include <hugin_version.h>
 // for stripExtension
 #include <hugin_utils/utils.h>
+// for exportImage
+#include <vigra_ext/impexalpha.hxx>
 
 #include "deghosting.h"
 #include "support.h"

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/support.h	2009-08-11 21:17:19 UTC (rev 4197)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.h	2009-08-12 14:02:22 UTC (rev 4198)
@@ -1,46 +1,16 @@
-/** @file support.h
- *
- *  @author Jing Jin
- *  ported to the current interface by Lukas Jirkovsky
- *
- *  This program is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- *  This software is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public
- *  License along with this software; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- */
 
 #ifndef SUPPORT_H_
 #define SUPPORT_H_
 
-#include <vector>
-#include <boost/shared_ptr.hpp>
-
 #include "deghosting.h"
 
-#include <vigra/error.hxx>
 #include <vigra/functorexpression.hxx>
-#include <vigra/transformimage.hxx>
+// used in hugin_hdrmerge
+// FIXME: move it to the hugin_hdrmerge
 #include <vigra/combineimages.hxx>
-#include <vigra/resizeimage.hxx>
 
-#include <vigra_ext/impexalpha.hxx>
-#include <vigra_ext/utils.h>
-
-#include <iostream>
-
 namespace deghosting {
 
-using namespace std;
 using namespace vigra;
 using namespace vigra::functor;
 


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

Revision: 4200
          http://hugin.svn.sourceforge.net/hugin/?rev=4200&view=rev
Author:   stativ
Date:     2009-08-12 14:18:38 +0000 (Wed, 12 Aug 2009)

Log Message:
-----------
Adding some comments.

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-12 14:04:53 UTC (rev 4199)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-12 14:18:38 UTC (rev 4200)
@@ -1,16 +1,20 @@
 
 #include "khan.h"
 #include <vigra/impex.hxx>
+// for importImageAlpha, it's not really necessary
 #include <vigra_ext/impexalpha.hxx>
 
 // for EMoR
 #include <photometric/ResponseTransform.h>
-
-// neded for zeroNegative()
+// neded for zeroNegative(), used in response transformation
 #include <vigra_ext/ImageTransforms.h>
+// panotools format of image, needed for response transformation
+#include <panotools/PanoToolsInterface.h>
 
+#ifdef ATAN_KH
 // neded for atan and abs
 #include <cmath>
+#endif
 
 // for GammaFunctor
 #include <vigra/transformimage.hxx>
@@ -18,8 +22,6 @@
 // for resampleImage
 #include <vigra/resizeimage.hxx>
 
-#include <panotools/PanoToolsInterface.h>
-
 // for snprintf
 #include <cstdio>
 using std::snprintf;

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-08-12 14:04:53 UTC (rev 4199)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-08-12 14:18:38 UTC (rev 4200)
@@ -3,17 +3,15 @@
 #define KHAN_H_
 
 #include "deghosting.h"
-// for AlgTinyVector
+// for AlgTinyVector, NormalizeFunctor and LogarithmFunctor
 #include "support.h"
 
-#include <vigra/rgbvalue.hxx>
-
 // needed for RGB2Lab
 #include <vigra/imageinfo.hxx>
 #include <vigra/transformimage.hxx>
 #include <vigra/colorconversions.hxx>
 
-// for hat function
+// for RGBvalue used in hat function
 #include <vigra/rgbvalue.hxx>
 
 // needed for Kh()


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

Revision: 4236
          http://hugin.svn.sourceforge.net/hugin/?rev=4236&view=rev
Author:   stativ
Date:     2009-08-17 10:08:16 +0000 (Mon, 17 Aug 2009)

Log Message:
-----------
Added some exceptions.

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h	2009-08-17 03:19:23 UTC (rev 4235)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h	2009-08-17 10:08:16 UTC (rev 4236)
@@ -8,6 +8,7 @@
 #ifndef DEGHOSTING_H_
 #define DEGHOSTING_H_
 
+#include <exception>
 #include <vector>
 #include <string>
 #include <stdint.h>
@@ -19,6 +20,23 @@
 #define DEGHOSTING_CACHE_IMAGES
 
 namespace deghosting {
+    
+    /** exception called when image dimensions differ
+     */
+    class BadDimensions : public std::exception {
+        public:
+            BadDimensions() : std::exception() {};
+            const char * what() { return "Input images must have the same dimensions"; }
+    };
+    
+    /** exception called when there are no input images
+     */
+    class NoImages : public std::exception {
+        public:
+            NoImages() : std::exception() {};
+            const char * what() { return "You must specify images"; }
+    };
+    
     typedef boost::shared_ptr<vigra::BImage> BImagePtr;
     typedef boost::shared_ptr<vigra::FImage> FImagePtr;
     // type for camera response
@@ -47,7 +65,7 @@
         /** load images for processing
          * @param inputFiles images to be processed
          */
-        virtual void loadImages(std::vector<std::string>& inputFiles) {}
+        virtual void loadImages(std::vector<std::string>& inputFiles) throw(NoImages, BadDimensions) {}
         
         /** set advanced flags
          * Allows to change behavior of used algorithm

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-17 03:19:23 UTC (rev 4235)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-17 10:08:16 UTC (rev 4236)
@@ -44,7 +44,17 @@
         denom = 1/PIPOW;
     }
 
-    void Khan::loadImages(std::vector<std::string>& newInputFiles) {
+    void Khan::loadImages(std::vector<std::string>& newInputFiles) throw(NoImages, BadDimensions) {
+        if (newInputFiles.empty())
+            throw NoImages();
+        const ImageImportInfo firstInfo = ImageImportInfo(newInputFiles[0].c_str());
+        const int width = firstInfo.width();
+        const int height = firstInfo.height();
+        for (unsigned int i = 0; i< newInputFiles.size(); i++) {
+            ImageImportInfo tmpInfo = ImageImportInfo(newInputFiles[i].c_str());
+            if ((width != tmpInfo.width()) || (height != tmpInfo.height()))
+                throw BadDimensions();
+        }
         inputFiles = newInputFiles;
     }
 

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-08-17 03:19:23 UTC (rev 4235)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-08-17 10:08:16 UTC (rev 4236)
@@ -46,7 +46,7 @@
         public:
             Khan(std::vector< std::string >& inputFiles, const uint16_t flags, const uint16_t debugFlags, int iterations, int verbosity);
             std::vector<FImagePtr> createWeightMasks();
-            void loadImages(std::vector<std::string>& inputFiles);
+            void loadImages(std::vector<std::string>& inputFiles) throw(NoImages, BadDimensions);
             void setFlags(const uint16_t flagslags);
             void setDebugFlags(const uint16_t debugFlags);
             void setIterationNum(const int iterations);


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

Revision: 4245
          http://hugin.svn.sourceforge.net/hugin/?rev=4245&view=rev
Author:   stativ
Date:     2009-08-19 12:15:33 +0000 (Wed, 19 Aug 2009)

Log Message:
-----------
Moved contrast change out from the threshold function.

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-08-18 15:43:12 UTC (rev 4244)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-08-19 12:15:33 UTC (rev 4245)
@@ -358,8 +358,13 @@
             }
         }
         
-        vector<BImagePtr> thresholded = threshold(weights, thresholdLim, BrightnessContrastFunctor<FImage::PixelType>(1, contrast, 0, 255), otherThresholdFlags);
+        // apply contrast functor
+        for (unsigned int i=0; i < weights.size(); ++i) {
+            transformImage(srcImageRange(*(weights[i])), destImage(*(weights[i])), BrightnessContrastFunctor<FImage::PixelType>(1, contrast, 0, 255));
+        }
         
+        vector<BImagePtr> thresholded = threshold(weights, thresholdLim, otherThresholdFlags);
+        
         // save masks with treshold applied
         for (unsigned int i=0; i<weights.size(); ++i) {
             char tmpfn[100];

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h	2009-08-18 15:43:12 UTC (rev 4244)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h	2009-08-19 12:15:33 UTC (rev 4245)
@@ -15,6 +15,7 @@
 using namespace vigra;
 using namespace deghosting;
 
+const uint16_t ONE_UNMASKED       = 0;
 const uint16_t THRESHOLD_DONTCARE = 1;
 
 /** Threshold function
@@ -23,13 +24,11 @@
  * @param const int threshold all pixels above this thresshold are set to 255, others to 0
  * @param const uint16_t flags flags for setting the behavior
  *          possible values are:
- *              0 – applies only threshold
+ *              THRESHOLD_DONTCARE – applies only simple threshold
  *              ONE_UNMASKED – if pixel should be black in all images after applying threshold
- *                             leave it in one image (where the pixel value is highest) white
- *              ONE_MASKED – make the pixel black only in one image where it's value is lowest
+ *                             leave it in one image (where the pixel value is highest) white, default
  */
-template <class Functor>
-vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const double threshold, const Functor &f, uint16_t flags) {
+vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const double threshold, const uint16_t flags) {
     vector<BImagePtr> retVal;
     const uint8_t minValue = 0;
     const uint8_t maxValue = 255;
@@ -38,8 +37,6 @@
     if (flags & THRESHOLD_DONTCARE) {
         for (unsigned int i=0; i < inputImages.size(); ++i) {
             BImagePtr tmpImg(new BImage(inputImages[i]->size()));
-            // preprocess image using functor f
-            transformImage(srcImageRange(*(inputImages[i])), destImage(*tmpImg), f);
             transformImage(srcImageRange(*tmpImg), destImage(*tmpImg),
                             Threshold<FImage::PixelType, BImage::PixelType>(threshold, 255, 0, 255));
             retVal.push_back(tmpImg);


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

Revision: 4260
          http://hugin.svn.sourceforge.net/hugin/?rev=4260&view=rev
Author:   stativ
Date:     2009-08-22 15:14:33 +0000 (Sat, 22 Aug 2009)

Log Message:
-----------
Comment out the linearizeRGB function.

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-22 08:07:01 UTC (rev 4259)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-22 15:14:33 UTC (rev 4260)
@@ -4,12 +4,12 @@
 // for importImageAlpha, it's not really necessary
 #include <vigra_ext/impexalpha.hxx>
 
-// for EMoR
+/*// for EMoR
 #include <photometric/ResponseTransform.h>
 // neded for zeroNegative(), used in response transformation
 #include <vigra_ext/ImageTransforms.h>
 // panotools format of image, needed for response transformation
-#include <panotools/PanoToolsInterface.h>
+#include <panotools/PanoToolsInterface.h>*/
 
 #ifdef ATAN_KH
 // neded for atan and abs
@@ -72,7 +72,7 @@
         #endif
     }
     
-    void Khan::linearizeRGB(std::string inputFile,FRGBImage *pInputImg) {
+    /*void Khan::linearizeRGB(std::string inputFile,FRGBImage *pInputImg) {
         HuginBase::SrcPanoImage panoImg(inputFile);
         panoImg.setResponseType(HuginBase::SrcPanoImage::RESPONSE_EMOR);
         panoImg.setEMoRParams(response);
@@ -98,7 +98,7 @@
                 *dx = vigra_ext::zeroNegative(invResponse(*sx, hugin_utils::FDiff2D(x, y)));
             }
         }
-    }
+    }*/
     
     void Khan::preprocessImage(unsigned int i, FImagePtr &weight, FLabImagePtr &LabImage) {
         cout << "Loading image " << inputFiles[i] << endl;

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-08-22 08:07:01 UTC (rev 4259)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-08-22 15:14:33 UTC (rev 4260)
@@ -69,7 +69,7 @@
              * @param inputFile filename of image to be transformed
              * @param *pInputImg FRGBImage to be transformed
              */
-            void linearizeRGB(std::string, FRGBImage* pInputImg);
+            //void linearizeRGB(std::string, FRGBImage* pInputImg);
             /** kernel function
              * Standard probability density function
              */


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

Revision: 4273
          http://hugin.svn.sourceforge.net/hugin/?rev=4273&view=rev
Author:   stativ
Date:     2009-08-25 08:59:50 +0000 (Tue, 25 Aug 2009)

Log Message:
-----------
Small rearanging of code.

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-25 07:46:16 UTC (rev 4272)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-25 08:59:50 UTC (rev 4273)
@@ -98,7 +98,7 @@
         return 1.0 - t; 
     }
     
-    double Khan::Kh(deghosting::AlgTinyVector< float, 3 > x) {
+    float Khan::Kh(deghosting::AlgTinyVector< float, 3 > x) {
         #ifdef ATAN_KH
             // good choice for sigma for this function is around 600
             return std::atan(-(x*x)+sigma)/PI + 0.5;

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-08-25 07:46:16 UTC (rev 4272)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-08-25 08:59:50 UTC (rev 4273)
@@ -36,11 +36,10 @@
 {
     #ifdef DEGHOSTING_CACHE_IMAGES
         typedef CachedFileImage<AlgTinyVector<float, 3> > FLabImage;
-        typedef boost::shared_ptr<FLabImage> FLabImagePtr;
     #else
         typedef BasicImage<AlgTinyVector<float, 3> > FLabImage;
-        typedef boost::shared_ptr<FLabImage> FLabImagePtr;
     #endif
+    typedef boost::shared_ptr<FLabImage> FLabImagePtr;
     
     class Khan : public Deghosting
     {
@@ -81,7 +80,7 @@
             /** kernel function
              * Standard probability density function
              */
-            inline double Kh(deghosting::AlgTinyVector< float, 3 > x);
+            inline float Kh(deghosting::AlgTinyVector< float, 3 > x);
             
             /** function to preprocess input image
              * This function loads image, linearize it using EMoR (FIXME),


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

Revision: 4274
          http://hugin.svn.sourceforge.net/hugin/?rev=4274&view=rev
Author:   stativ
Date:     2009-08-25 09:13:18 +0000 (Tue, 25 Aug 2009)

Log Message:
-----------
Remove hat function and use functor instead.

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h
    hugin/branches/gsoc2009_deghosting/src/deghosting/support.h

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-25 08:59:50 UTC (rev 4273)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-25 09:13:18 UTC (rev 4274)
@@ -87,16 +87,6 @@
     void Khan::setSigma(double newSigma) {
         sigma = newSigma;
     }
-
-    float Khan::hat(RGBValue<float> pixel) {
-        double value = (pixel[0]+pixel[1]+pixel[2])/3;
-        double t = (value/127.5 -1);
-        t *= t; // ^2
-        t *= t; // ^4
-        t *= t; // ^8
-        t *= t; // ^16
-        return 1.0 - t; 
-    }
     
     float Khan::Kh(deghosting::AlgTinyVector< float, 3 > x) {
         #ifdef ATAN_KH
@@ -174,7 +164,7 @@
             transformImage(srcImageRange(*pInputImg, color2gray), destImage(*weight), log(Arg1()+Param(1.0f)));
         }
         else {
-            transformImage(srcImageRange(*pInputImg),destImage(*weight),Khan::hat);
+            transformImage(srcImageRange(*pInputImg),destImage(*weight),HatFunctor<RGBValue<float> >());
         }
         
         // convert from linear RGB to L*a*b //

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-08-25 08:59:50 UTC (rev 4273)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-08-25 09:13:18 UTC (rev 4274)
@@ -61,11 +61,6 @@
             std::vector<FLabImagePtr> LabImages;
             std::vector<FImagePtr> weights;
             
-            /** hat function
-             * used for creating initial weights
-             */
-            static inline float hat(RGBValue<float> pixel);
-            
             /** set sigma
              * sets sigma for gaussian weigting function
              */

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/support.h	2009-08-25 08:59:50 UTC (rev 4273)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.h	2009-08-25 09:13:18 UTC (rev 4274)
@@ -48,6 +48,44 @@
         ComponentType offset;
 };
 
+/** Functor to apply mexican hat function
+ * returns very small values for input near to 0 or 255
+ */
+template <class PixelType>
+class HatFunctor {
+    public:
+        HatFunctor() {}
+        
+        PixelType operator()(PixelType v) const {
+            PixelType t = (v/127.5 -1);
+            t *= t; // ^2
+            t *= t; // ^4
+            t *= t; // ^8
+            t *= t; // ^16
+            return 1.0 - t; 
+        }
+};
+
+/** Functor to apply mexican hat function
+ * returns very small values for input near to 0 or 255
+ * specialization for RGBValue
+ */
+template <class ComponentType>
+class HatFunctor<RGBValue<ComponentType> > {
+    public:
+        HatFunctor() {}
+        
+        ComponentType operator()(RGBValue<ComponentType> v) const {
+            double value = (v[0]+v[1]+v[2])/3;
+            ComponentType t = (value/127.5 -1);
+            t *= t; // ^2
+            t *= t; // ^4
+            t *= t; // ^8
+            t *= t; // ^16
+            return 1.0 - t; 
+        }
+};
+
 /** Fuctor to normalize values
  */
 template <class PixelType>


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

Revision: 4275
          http://hugin.svn.sourceforge.net/hugin/?rev=4275&view=rev
Author:   stativ
Date:     2009-08-25 09:34:17 +0000 (Tue, 25 Aug 2009)

Log Message:
-----------
Some more work on adding possibility to handle grayscale images.

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-25 09:13:18 UTC (rev 4274)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-08-25 09:34:17 UTC (rev 4275)
@@ -126,9 +126,10 @@
         }
     }*/
     
+    template <class PixelType>
     void Khan::preprocessImage(unsigned int i, FImagePtr &weight, FLabImagePtr &LabImage) {
         ImageImportInfo imgInfo(inputFiles[i]);
-        FRGBImage * pInputImg =  new FRGBImage(imgInfo.size());
+        BasicImage<PixelType> * pInputImg =  new BasicImage<PixelType>(imgInfo.size());
         BImage imgAlpha(imgInfo.size());
         weight = FImagePtr(new FImage(imgInfo.size()));
         
@@ -150,10 +151,10 @@
                 // TODO: change to the GammaFunctor in the future
                 vigra::FindMinMax<float> minmax;
                 vigra::inspectImage(srcImageRange(*pInputImg), minmax);
-                transformImage(srcImageRange(*pInputImg),destImage(*pInputImg),BrightnessContrastFunctor<RGBValue<float> >(0.45,1.0,minmax.min, minmax.max));
+                transformImage(srcImageRange(*pInputImg),destImage(*pInputImg),BrightnessContrastFunctor<PixelType>(0.45,1.0,minmax.min, minmax.max));
             } else {
                 // take logarithm
-                transformImage(srcImageRange(*pInputImg),destImage(*pInputImg),LogarithmFunctor<RGBValue<float> >(1.0));
+                transformImage(srcImageRange(*pInputImg),destImage(*pInputImg),LogarithmFunctor<PixelType>(1.0));
             }
         }
         
@@ -164,7 +165,7 @@
             transformImage(srcImageRange(*pInputImg, color2gray), destImage(*weight), log(Arg1()+Param(1.0f)));
         }
         else {
-            transformImage(srcImageRange(*pInputImg),destImage(*weight),HatFunctor<RGBValue<float> >());
+            transformImage(srcImageRange(*pInputImg),destImage(*weight),HatFunctor<PixelType>());
         }
         
         // convert from linear RGB to L*a*b //
@@ -180,7 +181,7 @@
         for (unsigned int i = 0; i < inputFiles.size(); i++) {
             FImagePtr weight;
             FLabImagePtr LabImage;
-            preprocessImage(i, weight, LabImage);
+            preprocessImage<RGBValue<float> >(i, weight, LabImage);
             LabImages.push_back(LabImage);
             weights.push_back(weight);
             

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-08-25 09:13:18 UTC (rev 4274)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-08-25 09:34:17 UTC (rev 4275)
@@ -81,6 +81,7 @@
              * This function loads image, linearize it using EMoR (FIXME),
              * tranform it using logarithm or gamma if input images are HDR
              */
+            template <class PixelType>
             void preprocessImage(unsigned int i, FImagePtr &weight, FLabImagePtr &LabImage);
     };
 }


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

Revision: 4322
          http://hugin.svn.sourceforge.net/hugin/?rev=4322&view=rev
Author:   stativ
Date:     2009-09-05 10:06:26 +0000 (Sat, 05 Sep 2009)

Log Message:
-----------
Delete jbu.{h,cpp}, it's no longer used and may cause legal problems

Removed Paths:
-------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.h

Deleted: hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.cpp	2009-09-04 11:03:25 UTC (rev 4321)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.cpp	2009-09-05 10:06:26 UTC (rev 4322)
@@ -1,200 +0,0 @@
-// -*- c-basic-offset: 4 -*-
-
-/** @file jbu.cpp
- *
- *  @brief Implementation of joint bilateral upsampling
- *
- *  @author Jing Jin <jingidy@...>
- *
- *  $Id: jbu.cpp 2510 2007-10-28 22:24:11Z dangelo $
- *
- *  This program is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- *  This software is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public
- *  License along with this software; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- */
- 
-#include <cmath>
-
-#include "khan.h"
-#include "jbu.h"
-
-
-using namespace std;
-using namespace hugin_utils;
-using namespace vigra;
-using namespace vigra::functor;
-
-//extern int g_verbose;
-static int g_verbose = 1;
-
-/** given n layers of source images and n layers of references, upscales all
- *  source images with respect to their individual references
- *  destImgs is ptr to an empty vector to be filled in
- */
-void jointBilateralUpsampling(vector<FImagePtr> *sources, 
-                                vector<FImagePtr> *refs,
-                                vector<FImagePtr> *destImgs, int num_neighbors)
-{
-    int num_layers = sources->size();
-    bool destEmpty = destImgs->size() == 0;
-    for(int i = 0; i < num_layers; i++) {
-        FImagePtr tmp = jbuImage(sources->at(i), refs->at(i), num_neighbors);
-        if(!destEmpty)
-            destImgs->at(i) = tmp;
-        else
-            destImgs->push_back(tmp);
-    }
-}
-
-
-/** upsamples a given source image to the size of the given reference 
- *  creates the resulting FImagePtr and returns it
- */
-FImagePtr jbuImage(FImagePtr source, FImagePtr refIm, int num_neighbors)
-{        
-    int width = refIm->width();
-    int height = refIm->height();
-    int s_width = source->width();
-    int s_height = source->height();
-    float scale = s_width / width;
-        
-    FImagePtr dest = FImagePtr(new FImage(width, height));
-    float sigma = 0.5;
-    int mu = 0;
-    
-    for(int y = 0; y < height; y++) {
-        float *refPixLoc = (float *)(refIm->data()) + y * width;
-        
-        if(g_verbose > 2)
-            cout << "y: " << y << "\n"
-                << "\trefPixLoc: " << hex << refPixLoc << endl;
-        
-        for(int x = 0; x < width; x++) {
-            float refPix = *(refPixLoc + x);
-            
-            float total_val = 0;
-            float normalizing_factor = 0;
-            
-            //prevent black areas fro all rgausses being 0
-            float norgauss = 0; 
-            float norgauss_normalize = 0;
-            
-            //find coords in source
-            float o_x = x * scale;
-            float o_y = y * scale;
-            
-            if(g_verbose > 2)
-                cout << "x: " << x << "\n"
-                << "\trefPixLoc+x: " << hex << refPixLoc + x << "\n"
-                << "\to_x: " << o_x << "\n"
-                << "\to_y: " << o_y << endl;
-                
-            //for each neighbor for the source
-            for(int j = -num_neighbors; j <= num_neighbors; j++) {
-                int r_y = (int)round(o_y + j);
-                r_y = (r_y > 0 ? (r_y < s_height ? r_y : s_height-1) : 0);
-                float *srcPixLoc = (float *)source->data() + r_y * s_width;
-                //corresponding reference pixel
-                float *neighborPixLoc = (float *)refIm->data() + 
-                                            (int) (r_y * scale * width);
-                
-                if(g_verbose > 3)
-                    cout << "\tj: " << j << "\n"
-                    << "\t\tr_y: " << r_y << "\n"
-                    << "\t\tsrcPixLoc: " << hex << srcPixLoc << "\n"
-                    << "\t\tneighborPixLoc: " << hex << neighborPixLoc << endl;
-                                
-                for(int i = -num_neighbors; i <= num_neighbors; i++) {
-                    //find coords in source
-                    int r_x = (int)round(o_x + i);
-                    r_x = (r_x > 0 ? (r_x < s_width ? r_x : s_width-1) : 0);
-                    float srcPix = *(srcPixLoc + r_x);
-                    //in ref img
-                    neighborPixLoc += int(r_x * scale);
-                    float neighborPix = *neighborPixLoc;
-                    
-                    if(g_verbose > 3)
-                        cout << "\ti: " << i << "\n"
-                        << "\t\tr_x: " << r_x << "\n"
-                        << "\t\tsrcPixLoc+r_x: " << hex << srcPixLoc + r_x << "\n"
-                        << "\t\tsrcPix: " << srcPix << "\n"
-                        << "\t\tneighborPixLoc: " << hex << neighborPixLoc << "\n"
-                        << " \t\tneighborPix: " << neighborPix << endl;
-                    
-                    //gauss dist to center
-                    float sgauss = simpleGauss(dist(o_x, o_y, r_x, r_y),
-                                                sigma, mu);
-                    //gauss radiance diff to center in ref
-                    float rgauss = simpleGauss(abs(refPix - neighborPix),
-                                                sigma, mu);
-                    
-                    //multiply gausses by value in source and add to total val
-                    norgauss = srcPix * sgauss;
-                    norgauss_normalize += sgauss;
-                    float totalgauss = sgauss * rgauss;
-                    normalizing_factor += totalgauss;
-                    total_val += srcPix * totalgauss;
-                    
-                    if(g_verbose > 3)
-                        cout << "\t\tsgauss: " << sgauss << "\n"
-                                << "\t\trgauss: " << rgauss << "\n"
-                                << "\t\ttotalgauss+srcPix: " << totalgauss + 
-                                                                srcPix << endl;
-                    
-                } //end for i
-            }//end for j
-            
-            //normalize and store
-            
-            if(g_verbose > 2)
-                cout << "\tnormalizing_factor: " << normalizing_factor << "\n"
-                        << "\ttotal_val(before): " << total_val << endl;
-
-            if(total_val) {
-                total_val /= normalizing_factor;
-                *((float *)dest->data() + y * width + x) = total_val;
-            }
-            else {
-                total_val = norgauss/norgauss_normalize;
-            }
-            
-            if(g_verbose > 3)
-                cout << "\ttotal_val(after): " << total_val << "\n"
-                        << "stored in: " << hex << dest->data() + 
-                                                y * width + x << endl; 
-        }//end for x
-    }//end for y
-        
-    return dest; 
-}
-
-/** given 2 floating point pixel locations, computes the distance */
-float dist(float x1, float y1, float x2, float y2)
-{
-    return sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2));
-}
-
-/** gaussian applied to a single variable */
-float simpleGauss(float x, float sigma, float mu)
-{
-    if(sigma == 0) {
-        cerr << "simpleGauss: sigma must be non-zero" << endl;
-        exit(1);
-    }
-    float pi = 3.1415926;
-    float x_p = x - mu;
-    float exponent = std::exp(x_p * x_p / (-2 * sigma * sigma));
-    exponent /= sqrt(2 * pi) * sigma;
-    return exponent;
-}

Deleted: hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.h	2009-09-04 11:03:25 UTC (rev 4321)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.h	2009-09-05 10:06:26 UTC (rev 4322)
@@ -1,56 +0,0 @@
-// -*- c-basic-offset: 4 -*-
-
-/** @file jbu.h
- *
- *  @author Jing Jin <jingidy@...>
- *
- *  $Id: jbu.h 2510 2007-10-28 22:24:11Z dangelo $
- *
- *  This program is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- *  This software is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public
- *  License along with this software; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- */
- 
-
-#include <vigra/error.hxx>
-#include <hugin_utils/utils.h>
-#include <vigra_ext/impexalpha.hxx>
-
-#include <boost/shared_ptr.hpp>
-
-// define the types of images we will use.
-// use float for RGB
-typedef vigra::FRGBImage ImageType;
-// use byte for original grey value in source image
-typedef vigra::BImage WeightImageType;
-
-// smart pointers to the images.
-typedef boost::shared_ptr<ImageType> ImagePtr;
-typedef boost::shared_ptr<vigra::FImage> FImagePtr;
-typedef boost::shared_ptr<vigra::BImage> BImagePtr;
-
-/** upsamples multiple images given vector to store results in */
-void jointBilateralUpsampling(std::vector<FImagePtr> *sources, 
-                                std::vector<FImagePtr> *refs,
-                                std::vector<FImagePtr> *destImgs, 
-                                int num_neighbors);
-
-/** upsamples a single image and returns the FImagePtr to the result */
-FImagePtr jbuImage(FImagePtr source, FImagePtr refIm, int num_neighbors);
-
-/** given 2 floating point pixel locations, computes the distance */
-float dist(float x1, float y1, float x2, float y2);
-
-/** gaussian applied to a single variable */
-float simpleGauss(float x, float sigma, float mu);


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

Revision: 4324
          http://hugin.svn.sourceforge.net/hugin/?rev=4324&view=rev
Author:   stativ
Date:     2009-09-05 10:17:03 +0000 (Sat, 05 Sep 2009)

Log Message:
-----------
Added license headers

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/CMakeLists.txt
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h
    hugin/branches/gsoc2009_deghosting/src/deghosting/support.h
    hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/CMakeLists.txt
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/CMakeLists.txt	2009-09-05 10:15:18 UTC (rev 4323)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/CMakeLists.txt	2009-09-05 10:17:03 UTC (rev 4324)
@@ -1,4 +1,3 @@
-# various command line utilities
 
 add_executable(deghosting_mask deghosting_mask.cpp deghosting.cpp khan.cpp)
 target_link_libraries(deghosting_mask ${common_libs} ${image_libs})

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.cpp	2009-09-05 10:15:18 UTC (rev 4323)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.cpp	2009-09-05 10:17:03 UTC (rev 4324)
@@ -1,4 +1,23 @@
 
+/**
+ * Implementation of basic routines for deghosting algorithms
+ * Copyright (C) 2009  Lukáš Jirkovský <l.jirkovsky@...>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ *Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
 #include "deghosting.h"
 
 using namespace vigra;

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h	2009-09-05 10:15:18 UTC (rev 4323)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h	2009-09-05 10:17:03 UTC (rev 4324)
@@ -1,9 +1,22 @@
-/*
- * deghosting.h
+
+/**
+ * Header file for base class for deghosting algorithms
+ * Copyright (C) 2009  Lukáš Jirkovský <l.jirkovsky@...>
  *
- *  Created on: May 23, 2009
- *      Author: Lukas "stativ" Jirkovsky
- */
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ *Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
 
 #ifndef DEGHOSTING_H_
 #define DEGHOSTING_H_

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-09-05 10:15:18 UTC (rev 4323)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-09-05 10:17:03 UTC (rev 4324)
@@ -1,4 +1,23 @@
 
+/**
+ * Tool for creating b/w alpha masks to eliminate ghosting artifacts
+ * Copyright (C) 2009  Lukáš Jirkovský <l.jirkovsky@...>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ *Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
 #include <iostream>
 #include <string>
 #include <cstring>

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-09-05 10:15:18 UTC (rev 4323)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp	2009-09-05 10:17:03 UTC (rev 4324)
@@ -1,4 +1,23 @@
 
+/**
+ * Implementation of Khan's deghosting algorithm
+ * Copyright (C) 2009  Lukáš Jirkovský <l.jirkovsky@...>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ *Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
 #include "khan.h"
 #include <vigra/impex.hxx>
 // for importImageAlpha, it's not really necessary

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-09-05 10:15:18 UTC (rev 4323)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-09-05 10:17:03 UTC (rev 4324)
@@ -1,4 +1,23 @@
 
+/**
+ * Header file for Khan's deghosting algorithm
+ * Copyright (C) 2009  Lukáš Jirkovský <l.jirkovsky@...>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ *Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
 #ifndef KHAN_H_
 #define KHAN_H_
 

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/support.h	2009-09-05 10:15:18 UTC (rev 4323)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.h	2009-09-05 10:17:03 UTC (rev 4324)
@@ -1,4 +1,23 @@
 
+/**
+ * Support code for use in deghosting implementation
+ * Copyright (C) 2009  Lukáš Jirkovský <l.jirkovsky@...>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ *Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
 #ifndef SUPPORT_H_
 #define SUPPORT_H_
 

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h	2009-09-05 10:15:18 UTC (rev 4323)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h	2009-09-05 10:17:03 UTC (rev 4324)
@@ -1,6 +1,22 @@
+
 /**
- * thresshold
- */
+ * Advanced threshold
+ * Copyright (C) 2009  Lukáš Jirkovský <l.jirkovsky@...>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ *Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
 
 #include <vector>
 #include <stdint.h>


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

Revision: 4400
          http://hugin.svn.sourceforge.net/hugin/?rev=4400&view=rev
Author:   stativ
Date:     2009-09-13 14:08:01 +0000 (Sun, 13 Sep 2009)

Log Message:
-----------
Partial implementation of NumericTraits for AlgTinyVector

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h
    hugin/branches/gsoc2009_deghosting/src/deghosting/support.h

Added Paths:
-----------
    hugin/branches/gsoc2009_deghosting/src/deghosting/algtinyvector.h

Added: hugin/branches/gsoc2009_deghosting/src/deghosting/algtinyvector.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/algtinyvector.h	                        (rev 0)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/algtinyvector.h	2009-09-13 14:08:01 UTC (rev 4400)
@@ -0,0 +1,139 @@
+
+#include <vigra/tinyvector.hxx>
+#include <vigra/numerictraits.hxx>
+
+namespace vigra {
+
+/** Fixed size vector with scalar multiplication and element-wise substraction and addition
+ */
+template <class T, int SIZE>
+class AlgTinyVector
+{
+    public:
+        AlgTinyVector(const AlgTinyVector<T,SIZE> t) {
+            for (unsigned int i = 0; i < SIZE; ++i) {
+                content[i] = t[i];
+            }
+        }
+        
+        const T operator[](int i) const {
+            return content[i];
+        }
+        
+        T& operator[](int i) {
+            return content[i];
+        }
+        
+        const T operator*(const AlgTinyVector<T,SIZE> & t) const {
+            T retVal = 0;
+            for (unsigned int i = 0; i < SIZE; ++i) {
+                retVal += t[i] * content[i];
+            }
+            return retVal;
+        }
+        
+        const AlgTinyVector operator*(const int t) const {
+            AlgTinyVector<T,SIZE> retVal;
+            for (unsigned int i = 0; i < SIZE; ++i) {
+                retVal[i] = t * content[i];
+            }
+            return retVal;
+        }
+        
+        const AlgTinyVector operator/(const int t) const {
+            AlgTinyVector<T,SIZE> retVal;
+            for (unsigned int i = 0; i < SIZE; ++i) {
+                retVal[i] = content[i] / t;
+            }
+            return retVal;
+        }
+        
+        const AlgTinyVector operator-(const AlgTinyVector<T,SIZE> & t) const {
+            AlgTinyVector<T,SIZE> retVal;
+            for (unsigned int i = 0; i < SIZE; ++i) {
+                retVal[i] = t[i] - content[i];
+            }
+            return retVal;
+        }
+        
+        const AlgTinyVector operator+(const AlgTinyVector<T,SIZE> & t) const {
+            AlgTinyVector<T,SIZE> retVal;
+            for (unsigned int i = 0; i < SIZE; ++i) {
+                retVal[i] = t[i] + content[i];
+            }
+            return retVal;
+        }        
+        
+        AlgTinyVector & operator=(const AlgTinyVector<T,SIZE> & t) {
+            if (this == &t)
+                return *this;
+            for (unsigned int i = 0; i < SIZE; ++i) {
+                content[i] = t[i];
+            }
+            return *this;
+        }
+        
+        AlgTinyVector & operator=(const TinyVector<T,SIZE> & t) {
+            for (unsigned int i = 0; i < SIZE; ++i) {
+                content[i] = t[i];
+            }
+            return *this;
+        }
+        
+    private:
+        T content[SIZE];
+};
+
+template <class T, int SIZE>
+struct NumericTraits<AlgTinyVector<T, SIZE> >
+{
+    typedef AlgTinyVector<T, SIZE> Type;
+    typedef AlgTinyVector<typename NumericTraits<T>::Promote, SIZE> Promote;
+    typedef AlgTinyVector<typename NumericTraits<T>::RealPromote, SIZE> RealPromote;
+    typedef AlgTinyVector<typename NumericTraits<T>::ComplexPromote, SIZE> ComplexPromote;
+    typedef T ValueType;
+
+    typedef typename NumericTraits<T>::isIntegral isIntegral;
+    typedef VigraFalseType isScalar;
+    typedef typename NumericTraits<T>::isSigned isSigned;
+    typedef VigraFalseType isOrdered;
+    typedef VigraFalseType isComplex;
+
+    static AlgTinyVector<T, SIZE> zero() {
+        return AlgTinyVector<T, SIZE>(NumericTraits<T>::zero());
+    }
+    static AlgTinyVector<T, SIZE> one() {
+        return AlgTinyVector<T, SIZE>(NumericTraits<T>::one());
+    }
+    static AlgTinyVector<T, SIZE> nonZero() {
+        return AlgTinyVector<T, SIZE>(NumericTraits<T>::nonZero());
+    }
+
+    static Promote toPromote(const AlgTinyVector<T,SIZE> & v)
+    {
+        return Promote(v);
+    }
+
+    static RealPromote toRealPromote(const AlgTinyVector<T,SIZE> & v)
+    {
+        return RealPromote(v);
+    }
+
+    /*static AlgTinyVector<T, SIZE>
+    fromPromote(AlgTinyVector<typename NumericTraits<T>::Promote> const & v)
+    {
+        AlgTinyVector<T, SIZE> res;
+        return res;
+    }
+
+    static TinyVector<T, SIZE>
+    fromRealPromote(AlgTinyVector<typename NumericTraits<T>::RealPromote> const & v)
+    {
+        TinyVector<T, SIZE> res(detail::dontInit());
+        typedef typename detail::LoopType<SIZE>::type ltype;
+        ltype::fromRealPromote(res.begin(), v.begin());
+        return res;
+    }*/
+};
+
+}
\ No newline at end of file

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-09-13 07:47:16 UTC (rev 4399)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-09-13 14:08:01 UTC (rev 4400)
@@ -24,6 +24,7 @@
 #include "deghosting.h"
 // for AlgTinyVector, NormalizeFunctor and LogarithmFunctor
 #include "support.h"
+#include "algtinyvector.h"
 
 // needed for RGB2Lab
 #include <vigra/imageinfo.hxx>

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/support.h	2009-09-13 07:47:16 UTC (rev 4399)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.h	2009-09-13 14:08:01 UTC (rev 4400)
@@ -137,80 +137,6 @@
         RGBValue<ComponentType> foo;
 };
 
-/** Fixed size vector with scalar multiplication and element-wise substraction and addition
- */
-template <class T, int SIZE>
-class AlgTinyVector
-{
-    public:
-        const T operator[](int i) const {
-            return content[i];
-        }
-        
-        T& operator[](int i) {
-            return content[i];
-        }
-        
-        const T operator*(const AlgTinyVector<T,SIZE> t) const {
-            T retVal = 0;
-            for (unsigned int i = 0; i < SIZE; ++i) {
-                retVal += t[i] * content[i];
-            }
-            return retVal;
-        }
-        
-        const AlgTinyVector operator*(const int t) const {
-            AlgTinyVector<T,SIZE> retVal;
-            for (unsigned int i = 0; i < SIZE; ++i) {
-                retVal[i] = t * content[i];
-            }
-            return retVal;
-        }
-        
-        const AlgTinyVector operator/(const int t) const {
-            AlgTinyVector<T,SIZE> retVal;
-            for (unsigned int i = 0; i < SIZE; ++i) {
-                retVal[i] = content[i] / t;
-            }
-            return retVal;
-        }
-        
-        const AlgTinyVector operator-(const AlgTinyVector<T,SIZE> t) const {
-            AlgTinyVector<T,SIZE> retVal;
-            for (unsigned int i = 0; i < SIZE; ++i) {
-                retVal[i] = t[i] - content[i];
-            }
-            return retVal;
-        }
-        
-        const AlgTinyVector operator+(const AlgTinyVector<T,SIZE> t) const {
-            AlgTinyVector<T,SIZE> retVal;
-            for (unsigned int i = 0; i < SIZE; ++i) {
-                retVal[i] = t[i] + content[i];
-            }
-            return retVal;
-        }        
-        
-        AlgTinyVector & operator=(const AlgTinyVector<T,SIZE> & t) {
-            if (this == &t)
-                return *this;
-            for (unsigned int i = 0; i < SIZE; ++i) {
-                content[i] = t[i];
-            }
-            return *this;
-        }
-        
-        AlgTinyVector & operator=(const TinyVector<T,SIZE> & t) {
-            for (unsigned int i = 0; i < SIZE; ++i) {
-                content[i] = t[i];
-            }
-            return *this;
-        }
-        
-    private:
-        T content[SIZE];
-};
-
 }  // namespace deghosting
 
 #endif /* SUPPORT_H_ */


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

Revision: 4419
          http://hugin.svn.sourceforge.net/hugin/?rev=4419&view=rev
Author:   stativ
Date:     2009-09-14 12:23:13 +0000 (Mon, 14 Sep 2009)

Log Message:
-----------
Support for gray input is almost finished (ie. code is here, but it's not yet used).

I had to remove ADV_NOINITWEIGHTS (it wasn't wery usefull though).

Modified Paths:
--------------
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h
    hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
    hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h	2009-09-14 11:50:56 UTC (rev 4418)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h	2009-09-14 12:23:13 UTC (rev 4419)
@@ -58,9 +58,8 @@
 
     // constants for advanced modes
     const uint16_t ADV_GAMMA         = 1;
-    const uint16_t ADV_NOINITWEIGHTS = 2;
-    const uint16_t ADV_ONLYP         = 4;
-    const uint16_t ADV_MULTIRES      = 8;
+    const uint16_t ADV_ONLYP         = 2;
+    const uint16_t ADV_MULTIRES      = 4;
 
     // constants for debug modes
     const uint16_t SAVE_INITWEIGHTS   = 1;

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-09-14 11:50:56 UTC (rev 4418)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp	2009-09-14 12:23:13 UTC (rev 4419)
@@ -75,9 +75,6 @@
             case 'm':
                 flags -= ADV_MULTIRES;
                 break;
-            case 'n':
-                flags += ADV_NOINITWEIGHTS;
-                break;
             case 't':
                 otherThresholdFlags += THRESHOLD_DONTCARE;
                 break;
@@ -128,7 +125,6 @@
          << "     -a, --advanced=SET        advanced settings. Possible options are:" << endl
          << "                               g   use gamma 2.2 correction instead of logarithm if input images are HDR" << endl
          << "                               m   do not scale image, NOTE: slows down process" << endl
-         << "                               n   do not compute initial weigths" << endl
          << "                               t   use simple threshold, may result in holes in images" << endl
          << "                               w   compute \"complete\" weights, not only probabilities" << endl
          << "     -w, --save=SET            advanced save settings" << endl
@@ -347,6 +343,7 @@
         // FIXME
         // handle gray input correctly
         Khan<RGBValue<float> > khanDeghoster(inputFiles, flags, debugFlags, iterations, sigma, verbosity);
+        //Khan<float> khanDeghoster(inputFiles, flags, debugFlags, iterations, sigma, verbosity);
         
         deghoster = &khanDeghoster;
         deghoster->setCameraResponse(response);

Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h
===================================================================
--- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-09-14 11:50:56 UTC (rev 4418)
+++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h	2009-09-14 12:23:13 UTC (rev 4419)
@@ -261,12 +261,11 @@
     // load image and convert it to grayscale
     template <class PixelType>
     void Khan<PixelType>::importRGBImage(ImageImportInfo & info, BasicImage<PixelType> * img, VigraTrueType) {
-        cout << "Converting to grayscale" << endl;
         // FIXME: I guess this is not optimal, but it works
         RGBToGrayAccessor<FRGBImage::PixelType> color2gray;
         FRGBImage tmpImg(info.size());
         importImage(info, destImage(tmpImg));
-        copyImage(srcImageRange(tmpImg, color2gray), destImage(*img));
+        transformImage(srcImageRange(tmpImg, color2gray), destImage(*img), log(Arg1()+Param(1.0f)));
     }
     
     // only load image
@@ -313,15 +312,8 @@
             }
         }
         
-        // generate initial weights using hat function
-        if (flags & ADV_NOINITWEIGHTS) {
-            // convert image to grayscale (and take logarithm)
-            RGBToGrayAccessor<FRGBImage::PixelType> color2gray;
-            transformImage(srcImageRange(*pInputImg, color2gray), destImage(*weight), log(Arg1()+Param(1.0f)));
-        }
-        else {
-            transformImage(srcImageRange(*pInputImg),destImage(*weight),HatFunctor<PixelType>());
-        }
+        // generate initial weights
+        transformImage(srcImageRange(*pInputImg),destImage(*weight),HatFunctor<PixelType>());
         
         convertImage(pInputImg, LabImage, srcIsScalar());
         
@@ -426,7 +418,7 @@
                     cout << "processing image " << i+1 << endl;
                 
                 // vector storing pixel data
-                AlgTinyVector<float, 3> X;
+                ProcessImagePixelType X;
                 // sums for eq. 6
                 double wpqssum = 0;
                 double wpqsKhsum = 0;


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