[an error occurred while processing this directive]

hugin_base/panodata/PanoramaVariable.h

Go to the documentation of this file.

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


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

#include <hugin_utils/stl_utils.h>


namespace HuginBase {

class IMPEX Variable
{
    public:
        Variable(const std::string & name, double val = 0.0)
            : name(name), value(val)
        {};
        
        virtual ~Variable()
        {};
        

        virtual std::ostream & print(std::ostream & o) const;

        
        const std::string & getName() const
            { return name; }
        
        void setValue(double v)
            { value = v; }
        
        double getValue() const
            { return value; }

    protected:
        std::string name;
        double value;
};



// a linked variable (which contains the link target explicitly
class IMPEX LinkedVariable : public Variable
{
    
    public:
        LinkedVariable(const std::string & name, double val = 0.0, int link=-1)
        : Variable(name, val), m_link(link)
        {}

        bool isLinked() const
        { return m_link >= 0; }
        
        int getLink()  const
        { return m_link; }
        
        void setLink(int link)
        { m_link = link; }

    protected:
        int m_link;
};



class IMPEX LensVariable : public Variable
{
    public:
        LensVariable(const std::string & name, double value, bool link=false)
            : Variable(name, value), linked(link)
        {};
        
        virtual ~LensVariable()
            {};
        
        
        virtual std::ostream& printLink(std::ostream & o, unsigned int link) const;

        
        bool isLinked() const
            { return linked; }
        void setLinked(bool l=true)
            { linked = l; }
        
    private:
        bool linked;
    
};




struct PrintVar : public std::unary_function<Variable, void>
{
    PrintVar(std::ostream & o)
        : os(o)
    {};
    
    void operator()(Variable x) const
        { x.print(os) << " "; };
    
    std::ostream& os;
};


typedef std::map<std::string,Variable> VariableMap;

IMPEX void fillVariableMap(VariableMap & vars);

IMPEX void printVariableMap(std::ostream & o, const VariableMap & vars);

typedef std::vector<VariableMap> VariableMapVector;


typedef std::map<std::string,LensVariable> LensVarMap;

IMPEX void fillLensVarMap(LensVarMap & vars);


typedef std::vector<std::set<std::string> > OptimizeVector;


} // namespace
#endif // _H

---