[an error occurred while processing this directive]

hugin_base/panodata/PanoramaData.h

Go to the documentation of this file.

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

#include <hugin_shared.h>
#include <vector>
#include <set>
#include <iostream>

#include <hugin_math/Matrix3.h>
//#include <panodata/PanoImage.h>
#include <panodata/PanoramaVariable.h>
#include <panodata/SrcPanoImage.h>
#include <panodata/ControlPoint.h>
#include <panodata/Lens.h>
#include <panodata/PanoramaOptions.h>



namespace HuginBase {

typedef std::set<unsigned int> UIntSet;

typedef std::vector<unsigned int> UIntVector;


class IMPEX PanoramaData
{
    
public:
    
    virtual ~PanoramaData() {};
    
    
    /* get a subset of the panorama
    *
    *  This returns a panorama that contains only the images specified by \imgs
    *  Useful for operations on a subset of the panorama
    */
//  virtual Panorama getSubset(const UIntSet& imgs) const;
    
    /* duplicate the panorama
    *
    *  returns a copy of the pano state, except for the listeners.
    */
//  virtual Panorama duplicate() const;
    
    virtual PanoramaData* getNewSubset(const UIntSet& imgs) const =0;
    
    virtual PanoramaData* getNewCopy() const =0;
    
    
// -- Data Access --
    
// = images =    
    
    virtual std::size_t getNrOfImages() const =0;
    
    virtual const SrcPanoImage& getImage(std::size_t nr) const =0;

    virtual void setImage(std::size_t nr, SrcPanoImage img) =0;
    
//    virtual unsigned int getImageNr(const PanoImage * image) const =0;
    
    virtual unsigned int addImage(const SrcPanoImage& img) =0;
    
//    virtual int addImageAndLens(const std::string & filename) =0;
    
//  virtual unsigned int addImage(const std::string & filename) =0;
    
    virtual void removeImage(unsigned int nr) =0;
    
    virtual void swapImages(unsigned int img1, unsigned int img2) =0;
    
    virtual SrcPanoImage getSrcImage(unsigned imgNr) const =0;
    
    virtual void setSrcImage(unsigned int nr, const SrcPanoImage & img) =0;
    
    virtual void setImageFilename(unsigned int img, const std::string & fname) =0;
    
    virtual void setImageOptions(unsigned int i, const ImageOptions & opts) =0;
    
    virtual  void activateImage(unsigned int imgNr, bool active=true) =0;
    
    virtual  UIntSet getActiveImages() const =0;
    
        /* 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) =0;
#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) =0;
#include "image_variables.h"
#undef image_variable    
    
    
// = CPs =    
    
    virtual  std::size_t getNrOfCtrlPoints() const =0;
    
    virtual const ControlPoint & getCtrlPoint(std::size_t nr) const =0;
    
    virtual const CPVector & getCtrlPoints() const =0;
    
    virtual std::vector<unsigned int> getCtrlPointsForImage(unsigned int imgNr) const =0;
    
    virtual void setCtrlPoints(const CPVector & points) =0;
    
    virtual unsigned int addCtrlPoint(const ControlPoint & point) =0;
    
    virtual void removeCtrlPoint(unsigned int pNr) =0;
    
    virtual void removeDuplicateCtrlPoints() =0;

    virtual void changeControlPoint(unsigned int pNr, const ControlPoint & point) =0;
    
//  virtual unsigned int getCtrlPointNr(const ControlPoint * point) const =0;
    
    virtual int getNextCPTypeLineNumber() const =0;
    
    virtual void updateLineCtrlPoints() =0;
    
    
    virtual void updateCtrlPointErrors(const CPVector & controlPoints) =0;
    
    virtual void updateCtrlPointErrors(const UIntSet & imgs, const CPVector & cps) =0;
    
// = Variables =    
/*   TODO most of this section needs fixing. The image variables are now stored
 *        in SrcPanoImage objects, the PanoramaData object should just duplicate
 *        the changes across all images sharing variables.
 *        We also need access to the links of the variables.
 *        At some point, this functions should be removed. Do not create new
 *        code using them. Instead, use getSrcImage.
 */
    virtual VariableMapVector getVariables() const =0;

    virtual const VariableMap getImageVariables(unsigned int imgNr) const =0;
    
    virtual void updateVariables(const VariableMapVector & vars) =0;
    
    virtual void updateVariables(const UIntSet & imgs, const VariableMapVector & var) =0;
    
    virtual void updateVariables(unsigned int imgNr, const VariableMap & var) =0;
    
    virtual void updateVariable(unsigned int imgNr, const Variable &var) =0;

    
// = Optimise Vector =    

    virtual const OptimizeVector & getOptimizeVector() const =0;

    virtual void setOptimizeVector(const OptimizeVector & optvec) =0;

    
// = Panorama options =    

    virtual const PanoramaOptions & getOptions() const =0;

    virtual void setOptions(const PanoramaOptions & opt) =0;
    

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

};



class PanoramaObserver
{
    public:
        
        virtual ~PanoramaObserver() {};
        
        virtual void panoramaChanged(PanoramaData &pano) =0;
        
        virtual void panoramaImagesChanged(PanoramaData& pano,
                                           const UIntSet& changed) =0;
        
    //  virtual void panoramaImageAdded(PanoramaData &pano, unsigned int imgNr)
    //        { DEBUG_WARN("DEFAULT handler method"); };
        
    //  virtual void panoramaImageRemoved(PanoramaData &pano, unsigned int imgNr)
    //        { DEBUG_WARN("DEFAULT handler method"); };
        
    //  virtual void panoramaImageChanged(PanoramaData &pano, unsigned int imgNr)
    //        { DEBUG_TRACE(""); };
        
};


class IMPEX PanoramaDataMemento
{
    protected: 
        PanoramaDataMemento() {};
    
    public:
        virtual ~PanoramaDataMemento() {};
};


class IMPEX ManagedPanoramaData : public PanoramaData
{
    public:
        
        virtual ~ManagedPanoramaData() {};
        
        
        // -- Observing --
        
    public:
        virtual void addObserver(PanoramaObserver *o) =0;
        
        virtual bool removeObserver(PanoramaObserver *observer) =0;
        
        virtual void clearObservers() =0;
        
        virtual void changeFinished() =0;
        
        virtual void imageChanged(unsigned int imgNr) =0;
        
        
        // -- Memento interface --
        
    public:
        virtual PanoramaDataMemento* getNewMemento() const =0;
        
        virtual bool setMementoToCopyOf(const PanoramaDataMemento* const memento) =0;
        
        
        // -- Optimization Status --
        
    public:
        virtual bool needsOptimization() =0;
        
        virtual void markAsOptimized(bool optimized=true) =0;
        
};


} // namespace




#endif // _PANORAMA_H

---