viewsManager.hpp

/* $Id$ */

#ifndef _VIEWS_MANAGER_HPP
#define _VIEWS_MANAGER_HPP

#include "geom/t3d.hpp"
#include "geom/t3dPointTools.hpp"
#include "geom/Declarations.hpp"
#include "camera/cameraContainer.hpp"
#include "bundler/view.hpp"
#include "jmath/jblas.hpp"
#include "jmath/linearLeastSquares.hpp"

namespace jafar {

  namespace bundler {
    
    class ViewsManager {
      private:
      std::string m_camCalibFile;
      jafar::camera::CameraType m_camType;
      jafar::camera::CameraContainer m_camContainer;
      int startImageIndex;
      std::map<int, geom::T3D*> m_toOriginReferences;
      std::vector<jafar::bundler::View*> views;
      jblas::mat pixMatrix; 
      jblas::mat posMatrix;
      jblas::mat dirMatrix;
      jblas::mat a;
      jblas::vec b;
      jmath::LinearLeastSquares lls;
      jblas::vec3 center;
      double error;
      int first, last, step;
      void setCameraModel();
      
      protected:
      View* viewFromImage(const int& _imgIndex, 
                          const jblas::vec2& _pixel);
      View* viewFromData(const int& _imgIndex, 
                         const jblas::vec2& _pixel,
                         const jblas::vec3& _position,
                         const jblas::vec3& _direction);

      public:
      ViewsManager();

      ViewsManager(const std::string& camCalibFile,
                   const jafar::camera::CameraType& camType = jafar::camera::MONO) :
        m_camCalibFile(camCalibFile),
        m_camType(camType)
      {
        m_camContainer.setType(camType);
        setCameraModel();
      }

      ViewsManager(const std::string& camCalibFile,
                   const jafar::camera::CameraType& camType,
                   const std::map<int, geom::T3D*>& toOriginReferences) :
        m_camCalibFile(camCalibFile),
        m_camType(camType),
        m_toOriginReferences(toOriginReferences) 
      {
        m_camContainer.setType(camType);
        setCameraModel();
      }

      ~ViewsManager();
      void setCamera(const camera::CameraType& camType,
                     const std::string& camCalibFile);
      void setToOrigineReferences (const std::map<int, geom::T3D*>& toOriginReferences);
      std::string camCalibFile() const;
      std::vector<jafar::bundler::View*> viewsList();
      void loadViews(std::list<jblas::vec2> _pixelList, 
                     std::list<int> _indexList);        
      void printViews();
      void clearViews();
      void insertNewView(const int& _imgIndex, 
                         const jblas::vec2& _pixel,
                         const jblas::vec3& _position = jblas::zero_vec(3),
                         const jblas::vec3& _direction = jblas::zero_vec(3),
                         const jblas::vec2& _size = jblas::zero_vec(2));
      void solve();
      jblas::vec3 solution() const;
      //      void insertToOriginReference(const int& _index);
      void insertToOriginReference(const int& index, 
                                   geom::T3D* sensorToOrigin);
      std::map<int, geom::T3D *> toOriginReferences() const;
      geom::T3D* refByIndex(const int& index) const;
      double selectRay();
      void computeReprojectionError();
      double reprojectionError();
    };

  }//namespace bundler

}//namespace jafar

#endif