[an error occurred while processing this directive]

hugin_base/panodata/PanoImage.h

Go to the documentation of this file.

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

#include <hugin_config.h>

#include <iostream>
#include <vector>
#include <vigra/diff2d.hxx>
#include <hugin_math/hugin_math.h>


namespace HuginBase {

struct Keypoint
{
    Keypoint()
    { scale=0; orientation=0; laplacianSign=0; };

    hugin_utils::FDiff2D pos;
    std::vector<float> descriptor;
    double scale;
    double orientation;
    int laplacianSign;
};

struct ImageOptions {

    ImageOptions()
        : featherWidth(10),
          ignoreFrameWidth(0),
          morph(false),
          docrop(false),
          autoCenterCrop(true),
          m_vigCorrMode(VIGCORR_RADIAL|VIGCORR_DIV),
          responseType(0),
          active(true)
     { };

    
    unsigned int featherWidth;
    
    unsigned int ignoreFrameWidth;

    bool morph;

    // crop parameters
    bool docrop;
    bool autoCenterCrop;
    vigra::Rect2D cropRect;

    
    enum VignettingCorrMode { 
        VIGCORR_NONE = 0,      
        VIGCORR_RADIAL = 1,    
        VIGCORR_FLATFIELD = 2, 
        VIGCORR_DIV = 4        
    };
    
    int m_vigCorrMode;
    
    // coefficients for vignetting correction (even degrees: 0,2,4,6, ...)
    std::string m_flatfield;
    
    // the response type (Rt)
    int responseType;

    // is image active (displayed in preview and used for optimisation)
    bool active;
};



class PanoImage
{

    public:
        PanoImage();

        PanoImage(const std::string &filename, int width, int height, int lens);

//      PanoImage(const std::string & filename);
        
//      PanoImage(QDomNode & node);

        virtual ~PanoImage();
        
        
    public:
        virtual const char* isA() const
            { return "PanoImage"; };
        
        
    public:
        std::string getFilename() const
            { return filename; }

        void setFilename(const std::string& fn)
            { filename = fn; }

        const ImageOptions& getOptions() const
            { return options; }

        void setOptions(const ImageOptions & opt)
            { options = opt; }

        unsigned int getHeight() const
            { return height; }
        
        unsigned int getWidth() const
            { return width; }

        void setLensNr(const unsigned int& l)
            { lensNr = l; }
        
        unsigned int getLensNr() const
            { return lensNr; }

        void setSize(const vigra::Size2D& sz)
            { width =sz.x; height = sz.y; }

        void setFeatherWidth(const unsigned int& w)
            { options.featherWidth = w; }

        const std::vector<Keypoint> & getKeypoints() const
            { return m_keypoints; };

        void setKeypoints(const std::vector<Keypoint> & keypoints)
            { m_keypoints = keypoints; };

    private:
        // read image info (size, exif header)
    //  bool readImageInformation();
    //  bool imageRead;

        // image properties needed by Panorama tools.
        std::string filename;
        int height;
        int width;
        unsigned int lensNr; // the lens of this image
        ImageOptions options;
        std::vector<Keypoint> m_keypoints;
};


//typedef std::vector<PanoImage> ImageVector;


} // namespace
#endif // _H

---