MeshManager.h

Go to the documentation of this file.

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

#include "panodata/Panorama.h"

#include "MeshRemapper.h"

class MeshRemapper;
class VisualizationState;

class MeshManager
{
public:
    MeshManager(HuginBase::Panorama *pano, VisualizationState *visualization_state);
    virtual ~MeshManager();

    void CheckUpdate();
    
    void CleanMeshes();
    void RenderMesh(unsigned int image_number) const;
    unsigned int GetDisplayList(unsigned int image_number) const;
    
    void SetLayoutMode(bool state);
    bool GetLayoutMode() const;
    void SetLayoutScale(double scale);

    class MeshInfo
    {
    public:
        MeshInfo(HuginBase::Panorama * m_pano, HuginBase::SrcPanoImage * image,
                 VisualizationState * visualization_state, bool layout_mode_on);
        MeshInfo(const MeshInfo & source);
        virtual ~MeshInfo();
        void CallList() const;
        void Update();
        unsigned int display_list_number;
        void SetScaleFactor(double scale);
        void SetSrcImage(HuginBase::SrcPanoImage * image) {this->image = *image;}

        class Coord3D
        {
            public:
                Coord3D() {}
                explicit Coord3D(hugin_utils::FDiff2D & coord) {x = coord.x; y = coord.y; z = 0;}
                double x,y,z;
        };

        class MeshCoords3D {
        public:
            MeshCoords3D() {}
            explicit MeshCoords3D(const MeshRemapper::Coords & coords);
            double tex_coords[2][2][2];
            double vertex_coords[2][2][3];
        };

        
    protected:

        virtual void BeforeCompile() {}
        virtual void Transform() {}
        virtual void AfterCompile() {}
    
        HuginBase::SrcPanoImage image;
        HuginBase::Panorama *m_pano;
        double scale_factor;
        VisualizationState *m_visualization_state;
        MeshRemapper * remap;
        void CompileList();
        bool layout_mode_on;
    };

    class PreviewMeshInfo : public MeshInfo
    {
    public:
        PreviewMeshInfo(HuginBase::Panorama * m_pano, HuginBase::SrcPanoImage * image,
                 VisualizationState * visualization_state, bool layout_mode_on) : MeshInfo(m_pano, image, visualization_state, layout_mode_on) {
            Update();
        }
        PreviewMeshInfo(const PreviewMeshInfo & source) : MeshInfo((MeshInfo)source) {
            Update();
        }

        static MeshCoords3D GetMeshCoords3D(MeshRemapper::Coords &coords, VisualizationState * state) {return MeshCoords3D(coords);}
        static Coord3D GetCoord3D(hugin_utils::FDiff2D & coord, VisualizationState * state) {return Coord3D(coord);}

    };

    class PanosphereOverviewMeshInfo : public MeshInfo
    {
    public:
        PanosphereOverviewMeshInfo(HuginBase::Panorama * m_pano, HuginBase::SrcPanoImage * image,
                 VisualizationState * visualization_state, bool layout_mode_on)
            : MeshInfo(m_pano, image, visualization_state, layout_mode_on) {
                scale_factor *= scale_diff;
                Update();
            }

        PanosphereOverviewMeshInfo(const PanosphereOverviewMeshInfo & source)
            : MeshInfo((MeshInfo) source) {
                Update();
            }

        static void Convert(double &x, double &y, double &z, double th, double ph, double r);

        static MeshCoords3D GetMeshCoords3D(MeshRemapper::Coords &coords, VisualizationState * state);
        static Coord3D GetCoord3D(hugin_utils::FDiff2D &coord, VisualizationState * state);

        static const double scale_diff;

    protected:

        void BeforeCompile();
        void Transform();
        void AfterCompile();

        double yaw,pitch;

    };

    class PlaneOverviewMeshInfo : public MeshInfo
    {
    public:
        PlaneOverviewMeshInfo(HuginBase::Panorama * m_pano, HuginBase::SrcPanoImage * image,
                 VisualizationState * visualization_state, bool layout_mode_on)
            : MeshInfo(m_pano, image, visualization_state, layout_mode_on) {
                Update();
            }

        PlaneOverviewMeshInfo(const PlaneOverviewMeshInfo & source)
            : MeshInfo((MeshInfo) source) {
                Update();
            }

        const static double scale;
        static MeshCoords3D GetMeshCoords3D(MeshRemapper::Coords &coords, VisualizationState * state);
        static Coord3D GetCoord3D(hugin_utils::FDiff2D &coord, VisualizationState * state);

    };
    
    virtual MeshInfo::MeshCoords3D GetMeshCoords3D(MeshRemapper::Coords &coords) = 0;
    virtual MeshInfo::Coord3D GetCoord3D(hugin_utils::FDiff2D &) = 0;
    

    virtual MeshInfo * ObtainMeshInfo(HuginBase::SrcPanoImage *, bool layout_mode_on) = 0;

protected:


    HuginBase::Panorama  * m_pano;
    VisualizationState * visualization_state;

    
    std::vector<MeshInfo*> meshes;
    bool layout_mode_on;
};


class PanosphereOverviewMeshManager : public MeshManager
{
public:
    PanosphereOverviewMeshManager(HuginBase::Panorama *pano, VisualizationState *visualization_state) : MeshManager(pano, visualization_state) {}
    MeshInfo::MeshCoords3D GetMeshCoords3D(MeshRemapper::Coords &coords) {return MeshManager::PanosphereOverviewMeshInfo::GetMeshCoords3D(coords, visualization_state);}
    MeshInfo::Coord3D GetCoord3D(hugin_utils::FDiff2D &coord) {return MeshManager::PanosphereOverviewMeshInfo::GetCoord3D(coord,visualization_state);}

    MeshInfo * ObtainMeshInfo(HuginBase::SrcPanoImage *, bool layout_mode_on);
};

class PlaneOverviewMeshManager : public MeshManager
{
public:
    PlaneOverviewMeshManager(HuginBase::Panorama *pano, VisualizationState *visualization_state) : MeshManager(pano, visualization_state) {}
    MeshInfo::MeshCoords3D GetMeshCoords3D(MeshRemapper::Coords &coords) {return MeshManager::PlaneOverviewMeshInfo::GetMeshCoords3D(coords, visualization_state);}
    MeshInfo::Coord3D GetCoord3D(hugin_utils::FDiff2D &coord) {return MeshManager::PlaneOverviewMeshInfo::GetCoord3D(coord,visualization_state);}

    MeshInfo * ObtainMeshInfo(HuginBase::SrcPanoImage *, bool layout_mode_on);

};

class PreviewMeshManager : public MeshManager
{
public:
    PreviewMeshManager(HuginBase::Panorama *pano, VisualizationState *visualization_state) : MeshManager(pano, visualization_state) {}
    MeshInfo::MeshCoords3D GetMeshCoords3D(MeshRemapper::Coords &coords) {return MeshManager::PreviewMeshInfo::GetMeshCoords3D(coords, visualization_state);}
    MeshInfo::Coord3D GetCoord3D(hugin_utils::FDiff2D &coord) {return MeshManager::PreviewMeshInfo::GetCoord3D(coord,visualization_state);}

    MeshInfo * ObtainMeshInfo(HuginBase::SrcPanoImage *, bool layout_mode_on);

};


#endif