[an error occurred while processing this directive]

hugin_base/panodata/ImageVariableTranslate.h

Go to the documentation of this file.

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

namespace HuginBase
{
/* We define stuff to use the PTO codes i image_variables.h
 */
class IMPEX PTOVariableConverterNoOp
{
public:
    inline static bool checkApplicability(const std::string name)
    {
        return false;
    }
    
    template <class T>
    inline static double getValueFromVariable(
                                        const std::string name,
                                        const ImageVariable<T> & var
                                      )
    {
        return 0;
    }
    
    template <class T>
    inline static void setValueFromVariable(
                                        const std::string name,
                                        ImageVariable<T> & var,
                                        const double value
                                    )
    {
    }
    
    template <class T>
    inline static void addToVariableMap(
                            const ImageVariable<T> & var,
                            VariableMap & map
                                )
    {
    }
};

template <char code1, char code2 = '\0', char code3 = '\0', class T = double>
class IMPEX PTOVariableConverterSingle
{
public:
    inline static bool checkApplicability(const std::string name)
    {
        static const char code[] = {code1, code2, code3, '\0'};
        return ((std::string)code) == name;
    }
    
    inline static double getValueFromVariable(const std::string name, const ImageVariable<T> & var)
    {
        return var.getData();
    }
    
    inline static void setValueFromVariable(const std::string name, ImageVariable<T> & var, const double value)
    {
        var.setData((T)value);
    }
    
    inline static void addToVariableMap(const ImageVariable<T> & var, VariableMap & map)
    {
        static const char code[] = {code1, code2, code3, '\0'};
        map.insert(std::make_pair(code, Variable(code, (double)var.getData())));
    }
};


template <char base_code, class T = double, size_t size = 4>
class IMPEX PTOVariableConverterVectorChar
{
public:
    inline static bool checkApplicability(const std::string name)
    {
        return name.size() == 2 && name[0] == base_code && name[1] >= 'a' && name[1] < 'a' + char(size);
    }
    
    inline static double getValueFromVariable(const std::string name, const ImageVariable<std::vector<T> > & var)
    {
        return var.getData()[name[1]-'a'];
    }
    
    inline static void setValueFromVariable(const std::string name, ImageVariable<std::vector<T> > & var, const double value)
    {
        std::vector<T> temp = var.getData();
        temp[name[1]-'a'] = value;
        var.setData(temp);
    }
    
    inline static void addToVariableMap(const ImageVariable<std::vector<T> > & var, VariableMap & map)
    {
        char s[3] = {base_code, 'a', '\0'};
        for (size_t index = 0; index < size; index++, s[1]++)
        {
            map.insert(std::make_pair(s, Variable(s, (double)var.getData()[index])));
        }
    }
};

template <class T = double, size_t size = 3>
class IMPEX PTOVariableConverterVector
{
public:
    inline static bool checkApplicability(const std::string name)
    {
        return name[0] >= 'a' && name[0] < 'a' + char(size);
    }
    
    inline static double getValueFromVariable(const std::string name, const ImageVariable<std::vector<T> > & var)
    {
        return var.getData()[name[0]-'a'];
    }
    
    inline static void setValueFromVariable(const std::string name, ImageVariable<std::vector<T> > & var, const double value)
    {
        std::vector<T> temp = var.getData();
        temp[name[0]-'a'] = value;
        var.setData(temp);
    }
    
    inline static void addToVariableMap(const ImageVariable<std::vector<T> > & var, VariableMap & map)
    {
        char s[] = "a";
        for (size_t index = 0; index < size; index++, s[0]++)
        {
            map.insert(std::make_pair(s, Variable(s, (double)var.getData()[index])));
        }
    }
};

template <char code_x1, char code_y1, char code_x2 = '\0', char code_y2 = '\0'>
class IMPEX PTOVariableConverterFDiff2D
{
public:
    inline static bool checkApplicability(const std::string name)
    {
        static const char code_x[] = {code_x1, code_x2, '\0'};
        static const char code_y[] = {code_y1, code_y2, '\0'};
        return name == (std::string) code_x || name == (std::string) code_y;
    }
    
    inline static double getValueFromVariable(const std::string name, const ImageVariable<hugin_utils::FDiff2D> & var)
    {
        static const char code_x[] = {code_x1, code_x2, '\0'};
        return name == (std::string) code_x ? var.getData().x : var.getData().y;
    }
    
    inline static void setValueFromVariable(const std::string name, ImageVariable<hugin_utils::FDiff2D> & var, const double value)
    {
        hugin_utils::FDiff2D temp = var.getData();
        static const char code_x[] = {code_x1, code_x2, '\0'};
        (name == (std::string)code_x ? temp.x : temp.y) = value;
        var.setData(temp);
    }
    
    inline static void addToVariableMap(const ImageVariable<hugin_utils::FDiff2D> & var, VariableMap & map)
    {
        static const char s_x[] = {code_x1, code_x2, '\0'};
        static const char s_y[] = {code_y1, code_y2, '\0'};
        map.insert(std::make_pair(s_x, Variable(s_x, var.getData().x)));
        map.insert(std::make_pair(s_y, Variable(s_y, var.getData().y)));
    }
};

// Now we can define a type to use for every PanoramaVariable.
// We should make sure that any given code is only applicable to one of these.

typedef PTOVariableConverterNoOp PTOVariableConverterForFilename;
typedef PTOVariableConverterNoOp PTOVariableConverterForSize;
//typedef PTOVariableConverterSingle<'f','\0', '\0', SrcPanoImage::Projection> PTOVariableConverterForProjection;
typedef PTOVariableConverterNoOp PTOVariableConverterForProjection;
typedef PTOVariableConverterSingle<'v'> PTOVariableConverterForHFOV;

typedef PTOVariableConverterNoOp PTOVariableConverterForResponseType;
typedef PTOVariableConverterVectorChar<'R', float, 5> PTOVariableConverterForEMoRParams;
typedef PTOVariableConverterSingle<'E', 'e', 'v'> PTOVariableConverterForExposureValue;
typedef PTOVariableConverterNoOp PTOVariableConverterForGamma ;
typedef PTOVariableConverterSingle<'E', 'r'>  PTOVariableConverterForWhiteBalanceRed;
typedef PTOVariableConverterSingle<'E', 'b'>  PTOVariableConverterForWhiteBalanceBlue;

typedef PTOVariableConverterSingle<'r'> PTOVariableConverterForRoll;
typedef PTOVariableConverterSingle<'p'> PTOVariableConverterForPitch;
typedef PTOVariableConverterSingle<'y'> PTOVariableConverterForYaw;

typedef PTOVariableConverterSingle<'T','r','X'> PTOVariableConverterForX;
typedef PTOVariableConverterSingle<'T','r','Y'> PTOVariableConverterForY;
typedef PTOVariableConverterSingle<'T','r','Z'> PTOVariableConverterForZ;

typedef PTOVariableConverterSingle<'j'> PTOVariableConverterForStack;

typedef PTOVariableConverterVector<double, 3> PTOVariableConverterForRadialDistortion;
typedef PTOVariableConverterNoOp PTOVariableConverterForRadialDistortionRed;
typedef PTOVariableConverterNoOp PTOVariableConverterForRadialDistortionBlue;
typedef PTOVariableConverterFDiff2D<'d', 'e'> PTOVariableConverterForRadialDistortionCenterShift;
typedef PTOVariableConverterFDiff2D<'g', 't'> PTOVariableConverterForShear;

typedef PTOVariableConverterNoOp PTOVariableConverterForCropMode;
typedef PTOVariableConverterNoOp PTOVariableConverterForCropRect;
typedef PTOVariableConverterNoOp PTOVariableConverterForAutoCenterCrop;

typedef PTOVariableConverterNoOp PTOVariableConverterForFlatfieldFilename;
//typedef PTOVariableConverterSingle<'V', 'm', '\0', int> PTOVariableConverterForVigCorrMode;
typedef PTOVariableConverterNoOp PTOVariableConverterForVigCorrMode;
typedef PTOVariableConverterVectorChar<'V', double, 4> PTOVariableConverterForRadialVigCorrCoeff;
typedef PTOVariableConverterFDiff2D<'V','V', 'x','y'> PTOVariableConverterForRadialVigCorrCenterShift;

typedef PTOVariableConverterNoOp PTOVariableConverterForExifModel;
typedef PTOVariableConverterNoOp PTOVariableConverterForExifMake;
typedef PTOVariableConverterNoOp PTOVariableConverterForExifCropFactor;
typedef PTOVariableConverterNoOp PTOVariableConverterForExifFocalLength;
typedef PTOVariableConverterNoOp PTOVariableConverterForExifOrientation;
typedef PTOVariableConverterNoOp PTOVariableConverterForExifAperture;
typedef PTOVariableConverterNoOp PTOVariableConverterForExifISO;
typedef PTOVariableConverterNoOp PTOVariableConverterForExifDistance;
typedef PTOVariableConverterNoOp PTOVariableConverterForExifFocalLength35;
typedef PTOVariableConverterNoOp PTOVariableConverterForExifExposureTime;
typedef PTOVariableConverterNoOp PTOVariableConverterForExifDate;

typedef PTOVariableConverterNoOp PTOVariableConverterForFeatherWidth;
typedef PTOVariableConverterNoOp PTOVariableConverterForMasks;
typedef PTOVariableConverterNoOp PTOVariableConverterForActiveMasks;
typedef PTOVariableConverterNoOp PTOVariableConverterForMorph;
typedef PTOVariableConverterNoOp PTOVariableConverterForActive;
typedef PTOVariableConverterNoOp PTOVariableConverterForLensNr;
}

#endif

---