[an error occurred while processing this directive]

hugin_base/algorithm/PanoramaAlgorithm.h

Go to the documentation of this file.

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

#include <hugin_shared.h>
#include <appbase/ProgressDisplay.h>


namespace HuginBase {
    
    class PanoramaData;

    
    class IMPEX PanoramaAlgorithm
    {

    protected:
        PanoramaAlgorithm(PanoramaData& panorama)
            : o_panorama(panorama), o_successful(false)
            { };

    public:
        virtual ~PanoramaAlgorithm() {};
        

    public:
        virtual bool modifiesPanoramaData() const =0;
        
        virtual bool hasRunSuccessfully()
        {
            return o_successful;
        }
        
        virtual void run()
        {
            o_successful = runAlgorithm();
        }
        
#if 0

        template<class AlgorithmClass>
        AlgorithmClass& runMe()
        {
            AlgorithmClass& THIS = static_cast<AlgorithmClass&>(*this);
            THIS.run();
            return THIS;
        }
#endif
        
        virtual bool runAlgorithm() =0; 
        
        /*
         * Here is the informal interface guidelines that you should follow when
         * you subclass from this class:
         *
         *  1. You should provide [ SomeType getSomeResult() ] methods if there 
         *   is any result from the algorithm.
         *
         *  2. For complicated algorithms, you can have [ MyErrorEnum getError() ]
         *   that returns error.
         *
         *  3. You can optionaly implement your algorithm as
         *   [ static SomeType executeMyAlgorithm(PanoramaData& panorama, all parameters) ].
         *
         */
        
    protected:
        PanoramaData& o_panorama;
        bool o_successful;
        
    };



    class IMPEX TimeConsumingPanoramaAlgorithm : public PanoramaAlgorithm
    {
        
    protected:
        TimeConsumingPanoramaAlgorithm(PanoramaData& panorama, AppBase::ProgressDisplay* progressDisplay = NULL)
            : PanoramaAlgorithm(panorama),
              m_progressDisplay(progressDisplay), m_wasCancelled(false)
        { };
        
    public:
        virtual ~TimeConsumingPanoramaAlgorithm() {};
        
        
    public:
        /*
         * Please follow the same guideline as the PanoramaAlgorithm class, but with:
         *
         *  3. should now be 
         *   [ static SomeType executeMyAlgorithm(PanoramaData& panorama, ProgressDisplay* progressDisplay, all parameters) ]
         *   instead.
         *
         */
        
        
    // -- access to the ProgressDisplay --        
        
    protected:
        virtual AppBase::ProgressDisplay* getProgressDisplay() const
            { return m_progressDisplay; };
        
        virtual bool hasProgressDisplay() const
            { return getProgressDisplay() != NULL; };
        
        
    // -- cancelling process --
        
    public:
        virtual bool wasCancelled() const
            { return m_wasCancelled; };
        
    protected:
        virtual void cancelAlgorithm()
        {
            m_wasCancelled = true;
            algorithmCancelled();
        }
    
        virtual void algorithmCancelled() {};
        
        
    // -- private variables --
        
    private:
        AppBase::ProgressDisplay* m_progressDisplay;
        bool m_wasCancelled;
        
    };
    

}; // namespace
#endif // _H

---