[an error occurred while processing this directive]

hugin_base/panodata/Panorama.h

Go to the documentation of this file.

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

#include <hugin_shared.h>
#include <appbase/DocumentData.h>
#include <panodata/PanoramaData.h>


namespace HuginBase {
    
    
    
    
class IMPEX PanoramaMemento : public PanoramaDataMemento
{
        
        friend class Panorama;
        
    public:
        PanoramaMemento()
        : PanoramaDataMemento(), needsOptimization(false)
        {};
        
        PanoramaMemento(const PanoramaMemento & o);
        
        PanoramaMemento& operator=(const PanoramaMemento & o);
        
        virtual ~PanoramaMemento();
        
        
    protected:
        //  enum PTFileFormat { PTFILE_HUGIN, PTFILE_PTGUI, PTFILE_PTA };
        
        bool loadPTScript(std::istream & i, int & ptoVersion, const std::string & prefix = "");
    
        
    private:
        enum PTParseState {
            P_NONE,
            P_OUTPUT,
            P_MODIFIER,
            P_IMAGE,
            P_OPTIMIZE,
            P_CP
        };
        
        std::vector<SrcPanoImage *> images;
        
        CPVector ctrlPoints;
        
        PanoramaOptions options;
        
        OptimizeVector optvec;
        
        // indicates that changes have been made to
        // control points or lens parameters after the
        // last optimisation
        bool needsOptimization;
        
        void deleteAllImages();
};


    
class IMPEX Panorama : public ManagedPanoramaData, public AppBase::DocumentData
{
    
    public:

        Panorama();

        ~Panorama();
        
        
    // ====================== PanoramaData =========================================
        
        
        Panorama getSubset(const UIntSet & imgs) const;
        
        Panorama duplicate() const;
         
        PanoramaData* getNewSubset(const UIntSet& imgs) const
         {
             return new Panorama(this->getSubset(imgs));
         }
         
        PanoramaData* getNewCopy() const
         {
             return new Panorama(this->duplicate());
         }
        
        
    // -- Data Access --
        
    // = images =    
        
        std::size_t getNrOfImages() const
        {
            return state.images.size();
        };
        
        const SrcPanoImage & getImage(std::size_t nr) const
        {
            assert(nr < state.images.size());
            return *state.images[nr];
        };

        void setImage(std::size_t nr, SrcPanoImage img)
        {
            setSrcImage(nr, img);
        };
        
    //    unsigned int getImageNr(const PanoImage * image) const;
        
        unsigned int addImage(const SrcPanoImage &img);

        void mergePanorama(const Panorama &newPano);
        
//        int addImageAndLens(const std::string & filename);
        
        //    unsigned int addImage(const std::string & filename);
        
        void removeImage(unsigned int nr);
        
        void swapImages(unsigned int img1, unsigned int img2);
        
        SrcPanoImage getSrcImage(unsigned imgNr) const;
        
        void setSrcImage(unsigned int nr, const SrcPanoImage & img);
        
        void setImageFilename(unsigned int img, const std::string & fname);
        
        void setImageOptions(unsigned int i, const ImageOptions & opts);
        
        void activateImage(unsigned int imgNr, bool active=true);
        
        UIntSet getActiveImages() const;
        
        
    // = CPs =    
        
         std::size_t getNrOfCtrlPoints() const
        {
            return state.ctrlPoints.size();
        };
        
        const ControlPoint & getCtrlPoint(std::size_t nr) const
        {
            assert(nr < state.ctrlPoints.size());
            return state.ctrlPoints[nr];
        };
        
        const CPVector & getCtrlPoints() const
            { return state.ctrlPoints; };
        
        std::vector<unsigned int> getCtrlPointsForImage(unsigned int imgNr) const;
        
        void setCtrlPoints(const CPVector & points);
        
        unsigned int addCtrlPoint(const ControlPoint & point);
        
        void removeCtrlPoint(unsigned int pNr);

        void removeDuplicateCtrlPoints();
        
        void changeControlPoint(unsigned int pNr, const ControlPoint & point);
        
        //    unsigned int getCtrlPointNr(const ControlPoint * point) const;
        
        int getNextCPTypeLineNumber() const;
        
        void updateLineCtrlPoints();
        
        
        void updateCtrlPointErrors(const CPVector & controlPoints);
        
        void updateCtrlPointErrors(const UIntSet & imgs, const CPVector & cps);
        
        
    // = Variables =    
        
        VariableMapVector getVariables() const;

        const VariableMap getImageVariables(unsigned int imgNr) const;
        
        virtual void updateVariables(const VariableMapVector & vars);
        
        virtual void updateVariables(const UIntSet & imgs, const VariableMapVector & var);
        
        virtual void updateVariables(unsigned int imgNr, const VariableMap & var);
        
        virtual void updateVariable(unsigned int imgNr, const Variable &var);
        
        virtual void UpdateFocalLength(UIntSet imgs, double newFocalLength);
        virtual void UpdateCropFactor(UIntSet imgs, double newCropFactor);
        /* Link image variable functions. Used to group image variables which
         * should share the same value. The initial value is the one kept by
         * the image with number sourceImgNr.
         */
#define image_variable( name, type, default_value ) \
        virtual void linkImageVariable##name(unsigned int sourceImgNr, unsigned int destImgNr);
#include "image_variables.h"
#undef image_variable

        /* Unlink image variable functions. Makes a image variable independant
         * of the other images.
         */
#define image_variable( name, type, default_value ) \
        virtual void unlinkImageVariable##name(unsigned int imgNr);
#include "image_variables.h"
#undef image_variable
        
    // = Optimise Vector =    
        const OptimizeVector & getOptimizeVector() const
            { return state.optvec; };

        void setOptimizeVector(const OptimizeVector & optvec);
        
    // = Panorama options =    

        const PanoramaOptions & getOptions() const
            { return state.options; };

        void setOptions(const PanoramaOptions & opt);
        

        
    // -- script interface --
            
        void parseOptimizerScript(std::istream & i,
                                  const UIntSet & imgs,
                                  VariableMapVector & imgVars,
                                  CPVector & ctrlPoints) const;
            
        void printPanoramaScript(std::ostream & o,
                                 const OptimizeVector & optvars,
                                 const PanoramaOptions & options,
                                 const UIntSet & imgs,
                                 bool forPTOptimizer,
                                 const std::string & stripPrefix="") const;
        
        void printStitcherScript(std::ostream & o,
                                 const PanoramaOptions & target,
                                 const UIntSet & imgs) const;

        
        
    //=========== ManagedPanoramaData ==============================================



    // -- Observing --
        
        void addObserver(PanoramaObserver *o);
        
        bool removeObserver(PanoramaObserver *observer);
        
        void clearObservers();
        
        void changeFinished(bool keepDirty);
        
        void changeFinished()
            { changeFinished(false); }
        
        void imageChanged(unsigned int imgNr);

        void updateMasksForImage(unsigned int imgNr, MaskPolygonVector newMasks);
        void updateMasks();
        
        
        // -- Memento interface --
        
        virtual PanoramaDataMemento* getNewMemento() const;
        
        virtual bool setMementoToCopyOf(const PanoramaDataMemento* const memento);
        
        PanoramaMemento getMemento() const
            { return state; }
        
        void setMemento(const PanoramaMemento& memento);
        
        
    // -- Optimization Status --
        
        bool needsOptimization()
            { return state.needsOptimization; };

        void markAsOptimized(bool optimized=true)
            { state.needsOptimization = !optimized; };
        


    //=========== Document Data ====================================================

    public:
        ReadWriteError readData(std::istream& dataInput, std::string documentType = "");
        
        ReadWriteError writeData(std::ostream& dataOutput, std::string documentType = "");

        bool isDirty() const
        {
            if (dirty != AppBase::DocumentData::isDirty())
                DEBUG_WARN("modification status mismatch.");
                
            return dirty;
        }
        
        void clearDirty()
        {
            AppBase::DocumentData::clearDirty();
            
            dirty = false;
            changeFinished(true);
        }
        
    protected:
        void setDirty(const bool& dirty = true)
        { 
            AppBase::DocumentData::setDirty(dirty);
            
            this->dirty = dirty;
        }
        
        
    // == additional methods for documents ==
        
    public:
        void setFilePrefix(std::string prefix)
            { imgFilePrefix = prefix; }
        
    protected:
        std::string getFilePrefix() const
            { return imgFilePrefix; }
        
    //=========== Internal methods =================================================
        
    public:
        void reset();
        
    protected:
        void adjustVarLinks();


    //    void notifyImageAdded(unsigned int imgNr);

    //    void notifyImageRemoved(unsigned int imgNr);

    //    void notifyImageChanged(unsigned int imgNr);

        

    private:

        // data
//        enum ProcessType { NO_PROCESS, OPTIMIZER, STITCHER };

        // to run stitcher & optimizer
//        ProcessType currentProcess;
//        std::string optimizerExe;
//        std::string stitcherExe;
//        std::string PTScriptFile;
        
        //
        std::string imgFilePrefix;

        bool dirty;

        PanoramaMemento state;
        std::set<PanoramaObserver *> observers;
        UIntSet changedImages;

        bool m_forceImagesUpdate;

        std::set<std::string> m_ptoptimizerVarNames;
};




} // namespace




#endif // _PANORAMA_H

---