taylor.hpp

/* $Id: $ */
#ifndef MODELER_TAYLOR_HPP
#define MODELER_TAYLOR_HPP

#include "modeler/vcgDeclarations.hpp"
#include "fdetect/InterestFeature.hpp"
#include "fdetect/DetectionResult.hpp"
#include "gfm/MatchingResult.hpp"
#include "gfm/Matcher.hpp"
#include "image/Image.hpp"
#include "fdetect/Detector.hpp"
#include "localizer/planLocalizer.hpp"
#include "camera/cameraContainer.hpp"
#include "modeler/modeler.hpp"
#include "modeler/jfr_import_ply.h"
#include "modeler/jfr_io_mask.h"
namespace jafar {
  namespace modeler {
    class Taylor : public modeler::Modeler {

    private:
      typedef fdetect_v2::InterestFeature<fdetect_v2::FloatDescriptor> Feature;
      std::map<unsigned int, fdetect_v2::DetectionResult<Feature> > sequence_detect;
      typedef std::map<unsigned int, fdetect_v2::DetectionResult<Feature> >::iterator detections_iter;
      bool is_updatable;
      gfm_v2::MatchingResult<Feature> current_result;
      unsigned int first_new_vertex_id;
      unsigned int first_new_shot_id;
      std::vector<unsigned int> transient_vertices;
    public:
      Taylor(JfrMesh& _mesh, camera::CameraType _type, const jblas::vec& _params,
             fdetect_v2::Detector<Feature>* _detector, 
             gfm_v2::Matcher<Feature>* _matcher )  : 
        Modeler(_mesh, _type, _params, _detector, _matcher), 
        is_updatable(false), first_new_vertex_id(0), first_new_shot_id(0)
      {
        populate();
      }

      Taylor(JfrMesh& _mesh,
             fdetect_v2::Detector<Feature>* _detector, 
             gfm_v2::Matcher<Feature>* _matcher )  : 
        Modeler(_mesh, _detector, _matcher), is_updatable(false), first_new_vertex_id(0), first_new_shot_id(0)
      {
        populate();
      }

      Taylor(JfrMesh& _mesh, camera::CameraType _type, const jblas::vec& _params) : 
        Modeler(_mesh, _type, _params), is_updatable(false), first_new_vertex_id(0), first_new_shot_id(0)
      {
        populate();
      }

      Taylor(const std::string& ply_mesh_file, 
             camera::CameraType _type, const jblas::vec& _params) : 
        Modeler(ply_mesh_file, _type, _params), is_updatable(false), first_new_vertex_id(0), first_new_shot_id(0)
      {
        populate();
      }

      Taylor(JfrMesh& _mesh) : 
        Modeler(_mesh), is_updatable(false), first_new_vertex_id(0), first_new_shot_id(0)
      {
        populate();
      }

      Taylor(const std::string& ply_mesh_file) : 
        Modeler(ply_mesh_file), is_updatable(false), first_new_vertex_id(0), first_new_shot_id(0)
      {
        populate();
      }

      void setDetector(fdetect_v2::Detector<Feature>* _detector)
      {
        detector = _detector;
      }

      void setMatcher(gfm_v2::Matcher<Feature>* _matcher)
      {
        matcher = _matcher;
      }

      void retouch(const image::Image &rqst, geom::T3D* pose);
      void retouch(camera::CameraType type, const jblas::vec& intrinsics, 
                   geom::T3D* extrinsics, const image::Image &rqst);

      
      void update();


    private:
      void populate();

      int add(fdetect_v2::DetectionResult<Feature> &dr);
    };
  };
}

#endif