PanoramaData.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
#ifndef _PANORAMA_H
#define _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 <vector>
#include <set>
#include <iostream>
 
#include <hugin_math/Matrix3.h>
#include <panodata/PanoramaVariable.h>
#include <panodata/SrcPanoImage.h>
#include <panodata/ControlPoint.h>
#include <panodata/Lens.h>
#include <panodata/PanoramaOptions.h>
 
#endif // _HSI_IGNORE_SECTION
 
namespace HuginBase {
 
typedef std::set<unsigned int> UIntSet;
 
typedef std::vector<unsigned int> UIntVector;
 
typedef std::vector<UIntSet> UIntSetVector;
 
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;
    
    virtual PanoramaData* getUnlinkedSubset(UIntSetVector& imageGroups) 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, const 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 void moveImage(size_t img1, size_t 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 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;
 
    virtual void updateWhiteBalance(double redFactor, double blueFactor) =0;
    
// = Optimise Vector =    
 
    virtual const OptimizeVector & getOptimizeVector() const =0;
 
    virtual void setOptimizeVector(const OptimizeVector & optvec) =0;
 
 
    virtual const int getOptimizerSwitch() const =0;
    virtual void setOptimizerSwitch(const int newSwitch) =0;
 
    virtual const int getPhotometricOptimizerSwitch() const =0;
    virtual void setPhotometricOptimizerSwitch(const int newSwitch) =0;
 
// = Panorama options =    
 
    virtual const PanoramaOptions & getOptions() const =0;
 
    virtual void setOptions(const PanoramaOptions & opt) =0;
    
 
    
// -- script interface --
 
    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;
    virtual void updateMasksForImage(unsigned int imgNr, MaskPolygonVector newMasks)=0;
    virtual void updateMasks(bool convertPosMaskToNeg=false)=0;
    virtual void transferMask(MaskPolygon mask,unsigned int imgNr, const UIntSet& targetImgs)=0;
    virtual void updateOptimizeVector()=0;
    virtual std::set<size_t> getRefImages()=0;
    virtual void checkRefOptStatus(bool& linkRefImgsYaw, bool& linkRefImgsPitch, bool& linkRefImgsRoll)=0;
 
};
 
 
 
class PanoramaObserver
{
    public:
        
        virtual ~PanoramaObserver() {};
        
        virtual void panoramaChanged(Panorama &pano) =0;
        
        virtual void panoramaImagesChanged(Panorama& pano,
                                           const UIntSet& changed) =0;
        
        
};
 
 
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 clearDirty() =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