PhotometricOptimizer.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
#ifndef _PHOTOMETRIC_OPTIMIZER_H_
#define _PHOTOMETRIC_OPTIMIZER_H_
 
#include <hugin_shared.h>
#include <algorithms/PanoramaAlgorithm.h>
#include <algorithms/optimizer/PTOptimizer.h>
 
#include <vector>
#include <panodata/PanoramaData.h>
#include <appbase/ProgressDisplay.h>
#include <vigra_ext/VignettingCorrection.h>
 
namespace HuginBase
{
    
    class IMPEX PhotometricOptimizer : public TimeConsumingPanoramaAlgorithm
    {
        
        public:
            typedef std::vector<vigra_ext::PointPairRGB> PointPairs;
        
            PhotometricOptimizer(PanoramaData& panorama, AppBase::ProgressDisplay* progressDisplay,
                                 const OptimizeVector& vars,
                                 const PointPairs& correspondences, const float imageStepSize)
                : TimeConsumingPanoramaAlgorithm(panorama, progressDisplay),
                  o_vars(vars), o_correspondences(correspondences), o_resultError(0.0), o_imageStepSize(imageStepSize)
            {};
        
            virtual ~PhotometricOptimizer() {};
    
            
        public:
            static void optimizePhotometric(PanoramaData& pano, const OptimizeVector& vars,
                                            const PointPairs& correspondences,
                                            const float imageStepSize,
                                            AppBase::ProgressDisplay* progress,
                                            double& error);
        
        protected:
            struct VarMapping
            {
                std::string type;
                std::set<unsigned> imgs;
            };
 
            struct OptimData
            {
                
                const PanoramaData& m_pano;
                std::vector<SrcPanoImage> m_imgs;
                std::vector<VarMapping> m_vars;
                std::vector<vigra_ext::PointPairRGB> m_data;
                double huberSigma;
                bool symmetricError;
 
                int m_maxIter;
                AppBase::ProgressDisplay* m_progress;
 
 
                OptimData(const PanoramaData& pano, const OptimizeVector& optvars,
                          const std::vector<vigra_ext::PointPairRGB>& data,
                          double mEstimatorSigma, bool symmetric,
                          int maxIter, AppBase::ProgressDisplay* progress);
 
                void ToX(double * x);
 
                void FromX(double * x);
                
            };
            
            static int photometricVis(double *p, double *x, int m, int n, int iter, double sqerror, void * data);
 
            static void photometricError(double* p, double* x, int m, int n, void* data);
 
 
        public:
            virtual bool modifiesPanoramaData() const
                { return true; }
            
            virtual bool runAlgorithm();
    
            
        public:
            double getResultError() const
            {
                // [TODO] if(!hasRunSuccessfully()) DEBUG;
                return o_resultError;
            }
                
            
        protected:
            const OptimizeVector& o_vars;
            const PointPairs& o_correspondences;
            const float o_imageStepSize;
            double o_resultError;
    };
 
 
 
 
    class IMPEX SmartPhotometricOptimizer : public PhotometricOptimizer, protected SmartOptimizerStub
    {
        public:
            enum PhotometricOptimizeMode {
                OPT_PHOTOMETRIC_LDR=0, 
                OPT_PHOTOMETRIC_LDR_WB, 
                OPT_PHOTOMETRIC_HDR, 
                OPT_PHOTOMETRIC_HDR_WB
            };
        
            SmartPhotometricOptimizer(PanoramaData& panorama, AppBase::ProgressDisplay* progressDisplay,
                                       const OptimizeVector& vars,
                                       const PointPairs& correspondences,
                                       const float imageStepSize,
                                       PhotometricOptimizeMode optMode)
                : PhotometricOptimizer(panorama, progressDisplay, vars, correspondences, imageStepSize), o_optMode(optMode)
            {};
            
            virtual ~SmartPhotometricOptimizer() {};
        
            
        public:
            static void smartOptimizePhotometric(PanoramaData & pano, PhotometricOptimizeMode mode,
                                                 const std::vector<vigra_ext::PointPairRGB> & correspondences,
                                                 const float imageStepSize,
                                                 AppBase::ProgressDisplay* progress,
                                                 double & error);
            
            virtual bool runAlgorithm();
 
            
        protected:
            PhotometricOptimizeMode o_optMode;
    };
 
    
    
} // namespace
 
 
#endif