Panorama.h

Go to the documentation of this file.

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

// if this file is preprocessed for SWIG, we want to ignore
// all the header inclusions that follow:

#ifndef _HSI_IGNORE_SECTION

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


#endif // _HSI_IGNORE_SECTION

namespace HuginBase {
    
    
    
    
class IMPEX PanoramaMemento : public PanoramaDataMemento
{
        
        friend class Panorama;
        
    public:
        PanoramaMemento()
            : PanoramaDataMemento(), needsOptimization(false), optSwitch(0), optPhotoSwitch(0)
        {};
        
        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;
        int optSwitch;
        int optPhotoSwitch;

        // 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, const 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);

        void moveImage(size_t img1, size_t img2);
        
        SrcPanoImage getSrcImage(unsigned imgNr) const;
        
        void setSrcImage(unsigned int nr, const SrcPanoImage & img);
        
        void setImageFilename(unsigned int img, const std::string & fname);
        
        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;
        
        CPointVector getCtrlPointsVectorForImage(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
        
        virtual void updateWhiteBalance(double redFactor, double blueFactor);

    // = Optimise Vector =    
        const OptimizeVector & getOptimizeVector() const
            { return state.optvec; };

        void setOptimizeVector(const OptimizeVector & optvec);
        
        const int getOptimizerSwitch() const
            { return state.optSwitch;};
        void setOptimizerSwitch(const int newSwitch);

        const int getPhotometricOptimizerSwitch() const
            { return state.optPhotoSwitch; };
        void setPhotometricOptimizerSwitch(const int newSwitch);

    // = 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(bool convertPosMaskToNeg=false);
        void transferMask(MaskPolygon mask,unsigned int imgNr, const UIntSet targetImgs);
        void updateOptimizeVector();
        std::set<size_t> getRefImages();
        void checkRefOptStatus(bool& linkRefImgsYaw, bool& linkRefImgsPitch, bool& linkRefImgsRoll);

        // -- 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;
        }
        
        virtual void clearDirty()
        {
            AppBase::DocumentData::clearDirty();
            dirty = false;
        }
        
    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;
        
        //
        void centerCrop(unsigned int imgNr);
        vigra::Rect2D centerCropImage(unsigned int imgNr);
        void updateCropMode(unsigned int imgNr);

        std::string imgFilePrefix;

        bool dirty;

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

        bool m_forceImagesUpdate;

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




} // namespace




#endif // _PANORAMA_H

---