[an error occurred while processing this directive]

hugin_base/panotools/PanoToolsInterface.h

Go to the documentation of this file.

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

#include <hugin_shared.h>
#include <hugin_config.h>

#include <iostream>
#include <string>
#include <set>

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


// libpano includes ------------------------------------------------------------

#ifdef _WIN32
// include windows.h with sensible defines, otherwise
// panotools might include with its stupid, commonly
// named macros all over the place.
#define _STLP_VERBOSE_AUTO_LINK
//#define _USE_MATH_DEFINES
#define NOMINMAX
#define VC_EXTRALEAN
#include <windows.h>
#undef DIFFERENCE
#undef min
#undef max
#undef MIN
#undef MAX
#endif


extern "C" {
#ifdef __INTEL__
#define __INTELMEMO__
#undef __INTEL__
#endif

#include <pano13/panorama.h>
#include <pano13/filter.h>

#ifdef __INTELMEMO__
#define __INTEL__
#undef __INTELMEMO__
#endif

#include <pano13/filter.h>

// somehow these are still set after panorama.h has been included
#undef DIFFERENCE
#undef min
#undef max
#undef MIN
#undef MAX

}

//------------------------------------------------------------------------------


namespace vigra { class Diff2D; }
namespace HuginBase { class PanoramaData; }



namespace HuginBase { namespace PTools {


class IMPEX Transform
{
        
    public:
        Transform()
          : m_initialized(false), m_srcTX(0), m_srcTY(0),
            m_destTX(0), m_destTY(0)
        {
            // initialize pointer
            m_srcImage.data = NULL;
            m_dstImage.data = NULL;
        }

        ~Transform();
        
    private:
        // private, no copy constructor for the pt structures yet.
        Transform(const Transform &);
        Transform & operator=(const Transform &);

        
    public:
        void createTransform(const vigra::Diff2D & srcSize,
                             VariableMap srcVars,
                             Lens::LensProjectionFormat srcProj,
                             const vigra::Diff2D &destSize,
                             PanoramaOptions::ProjectionFormat destProj,
                             const std::vector<double> & destProjParam,
                             double destHFOV,
                             const vigra::Diff2D & origSrcSize);

        void createTransform(const PanoramaData& pano, unsigned int imgNr,
                             const PanoramaOptions & dest,
                             vigra::Diff2D srcSize=vigra::Diff2D(0,0));

        void createTransform(const SrcPanoImage & src, const PanoramaOptions & dest);

        void createInvTransform(const vigra::Diff2D & srcSize,
                                VariableMap srcVars,
                                Lens::LensProjectionFormat srcProj,
                                const vigra::Diff2D & destSize,
                                PanoramaOptions::ProjectionFormat destProj,
                                const std::vector<double> & destProjParam,
                                double destHFOV,
                                const vigra::Diff2D & origSrcSize);

        void createInvTransform(const PanoramaData& pano, unsigned int imgNr,
                                const PanoramaOptions & dest,
                                vigra::Diff2D srcSize=vigra::Diff2D(0,0));

        void createInvTransform(const SrcPanoImage & src, const PanoramaOptions & dest);

        bool transform(double & x_dest, double & y_dest,
                       double x_src, double y_src) const;

        bool transform(hugin_utils::FDiff2D& dest, const hugin_utils::FDiff2D & src) const;

        bool transformImgCoord(double & x_dest, double & y_dest,
                               double x_src, double y_src) const;

        bool transformImgCoordPartial(double & x_dest, double & y_dest, double x_src, double y_src) const;

        bool transformImgCoord(hugin_utils::FDiff2D& dest, const hugin_utils::FDiff2D & src) const
            { return transformImgCoord(dest.x, dest.y, src.x, src.y); }


        bool emitGLSL(std::ostringstream& oss) const;
        
    private:
        // update internal PT data structs.
        void updatePTData(const vigra::Diff2D &srcSize,
                          const VariableMap & srcVars,
                          Lens::LensProjectionFormat & srcProj,
                          const vigra::Diff2D & destSize,
                          PanoramaOptions::ProjectionFormat & destProj,
                          const std::vector<double> & destProjParam,
                          double destHFOV);

        
    private:
        bool m_initialized;

        Image m_srcImage;
        Image m_dstImage;
        struct MakeParams       m_mp;
        struct fDesc    m_stack[15];

        // used to convert from screen to cartesian coordinates
        double m_srcTX, m_srcTY;
        double m_destTX, m_destTY;
        
};



class AlignInfoWrap
{
    public:
        AlignInfoWrap();
        
        ~AlignInfoWrap();
        
        
    public:
        bool setInfo(const PanoramaData& pano);
        
        void setGlobal();
        
        VariableMapVector getVariables() const;
        
        CPVector getCtrlPoints() const;
        
        //    std::map<int,int> m_ctrlPointMap;
        //    CPVector m_controlPoints;
        
    protected:
            AlignInfo gl;
};





void setDestImage(Image & image, vigra::Diff2D size, unsigned char * imageData,
                  const PanoramaOptions::ProjectionFormat & format,
                  const std::vector<double> & projParams,
                  double destHFOV);

void setFullImage(Image & image, vigra::Diff2D size, unsigned char * imageData,
                  const VariableMap & vars,
                  const Lens::LensProjectionFormat format,
                  bool correctDistortions);

void createAdjustPrefs(aPrefs  & p, TrformStr & transf);

void setAdjustSrcImg(TrformStr & trf, aPrefs & ap,
                     int width, int height, unsigned char * imageData,
                     const VariableMap & vars,
                     const Lens::LensProjectionFormat format,
                     bool correctDistortions);


void setAdjustDestImg(TrformStr & trf, aPrefs & ap,
                      int width, int height, unsigned char * imageData,
                      const PanoramaOptions & opts);


void createAdjustTrform(TrformStr & trf);

void freeTrform(TrformStr & trf);

void freeImage(Image &img);


void setOptVars(optVars & opt, const std::set<std::string> & optvars);

VariableMapVector GetAlignInfoVariables(const AlignInfo & gl);

CPVector GetAlignInfoCtrlPoints(const AlignInfo & gl);



}} // namespace

#endif // _H

---