[an error occurred while processing this directive]

hugin_base/algorithms/basic/CalculateCPStatistics.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
#ifndef _BASICALGORITHMS_CALCULATECPSTSTISTICS_H
#define _BASICALGORITHMS_CALCULATECPSTSTISTICS_H

#include <hugin_shared.h>
#include <algorithm/PanoramaAlgorithm.h>



namespace HuginBase {


class IMPEX CalculateCPStatistics : public PanoramaAlgorithm
{

    protected:
        CalculateCPStatistics(PanoramaData& panorama, const int& imgNr=-1)
         : PanoramaAlgorithm(panorama), o_imageNumber(imgNr)
        {};
        
    public:
        virtual ~CalculateCPStatistics() {};
        
        
    public:
        virtual bool modifiesPanoramaData() const
            { return false; }
            
        virtual bool runAlgorithm() =0;
          
        
    public:
        virtual double getResultMin()
        {
            // [TODO] if(!hasRunSuccessfully()) DEBUG;
            return o_resultMin;
        }
        
        virtual double getResultMax()
        {
            // [TODO] if(!hasRunSuccessfully()) DEBUG;
            return o_resultMax;
        }
        
        virtual double getResultMean()
        {
            // [TODO] if(!hasRunSuccessfully()) DEBUG;
            return o_resultMean;
        }
    
        virtual double getResultVariance()
        {
            // [TODO] if(!hasRunSuccessfully()) DEBUG;
            return o_resultVar;
        }
        
    protected:
        int o_imageNumber;
        double o_resultMin, o_resultMax, o_resultMean, o_resultVar;
};
    
    
    
    
class IMPEX CalculateCPStatisticsError : public CalculateCPStatistics
{

    public:
        CalculateCPStatisticsError(PanoramaData& panorama, const int& imgNr=-1)
         : CalculateCPStatistics(panorama, imgNr)
        {};
        
        virtual ~CalculateCPStatisticsError() {};
          
        
    public:
        static void calcCtrlPntsErrorStats(const PanoramaData& pano,
                                           double & min, double & max, double & mean,
                                           double & var,
                                           const int& imgNr=-1);
        
        
    public:
        virtual bool runAlgorithm()
        {
            calcCtrlPntsErrorStats(o_panorama, 
                                   o_resultMin, o_resultMax, o_resultMean,
                                   o_resultVar,
                                   o_imageNumber);
            return true; // let's hope so.
        }
        
};


class CalculateCPStatisticsRadial : public CalculateCPStatistics
{
    
    public:
        CalculateCPStatisticsRadial(PanoramaData& panorama, const int& imgNr=-1)
         : CalculateCPStatistics(panorama, imgNr)
        {};
        
        virtual ~CalculateCPStatisticsRadial() {};
        
        
    public:
        static void calcCtrlPntsRadiStats(const PanoramaData& pano,
                                          double & min, double & max, double & mean, double & var,
                                          double & q10, double & q90, 
                                          const int& imgNr=-1);
        
        virtual double getResultPercentile10()
        {
            // [TODO] if(!hasRunSuccessfully()) DEBUG;
            return o_resultQ10;
        }
        
        virtual double getResultPercentile90()
        {
            // [TODO] if(!hasRunSuccessfully()) DEBUG;
            return o_resultQ90;
        }
        
        
    public:
        virtual bool runAlgorithm()
        {
                calcCtrlPntsRadiStats(o_panorama, 
                                      o_resultMin, o_resultMax, o_resultMean, o_resultVar,
                                      o_resultQ10, o_resultQ90,
                                      o_imageNumber);
                return true; // let's hope so.
        }
        
        
    protected:
        double o_resultQ10, o_resultQ90;
        
};

} //namespace
#endif //_H

---