mixer.hpp

/* $Id: $ */
#ifndef MODELER_MIXER_HPP
#define MODELER_MIXER_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"

#include <vcg/complex/trimesh/autoalign_4pcs.h>

namespace jafar {
  namespace modeler {
    class Mixer : public modeler::Modeler {
    public:
      typedef fdetect_v2::InterestFeature<fdetect_v2::FloatDescriptor> Feature;
    private:
      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;
      vcg::tri::FourPCS<JfrMesh> icp;
      JfrMesh m_model;
    public:
      Mixer(JfrMesh& _mesh, camera::CameraType _type, const jblas::vec& _params,
             fdetect_v2::Detector<Feature>* _detector, 
             gfm_v2::Matcher<Feature>* _matcher )  : 
        Modeler(_type, _params, _detector, _matcher), m_model(_mesh),
        is_updatable(false), first_new_vertex_id(0), first_new_shot_id(0)
      { 
        JFR_POSTCOND(m_model.vn > 0, "model mesh is empty") 
      }

      Mixer(JfrMesh& _mesh,
             fdetect_v2::Detector<Feature>* _detector, 
             gfm_v2::Matcher<Feature>* _matcher )  : 
        Modeler(_detector, _matcher), m_model(_mesh),
        is_updatable(false), first_new_vertex_id(0), first_new_shot_id(0)
      { 
        JFR_POSTCOND(m_model.vn > 0, "model mesh is empty") 
      }

      Mixer(JfrMesh& _mesh, camera::CameraType _type, const jblas::vec& _params) : 
        Modeler(_type, _params), m_model(_mesh),
        is_updatable(false), first_new_vertex_id(0), first_new_shot_id(0)
      { 
        JFR_POSTCOND(m_model.vn > 0, "model mesh is empty") 
      }

      Mixer(const std::string& ply_mesh_file, 
             camera::CameraType _type, const jblas::vec& _params) : 
        Modeler(_type, _params),
        is_updatable(false), first_new_vertex_id(0), first_new_shot_id(0)
      {
        int mask = 0;
        if(vcg::tri::io::JfrImporterPLY<JfrMesh>::Open(m_model, ply_mesh_file.c_str(), mask) != 0)
          JFR_ERROR(ModelerException,
                    ModelerException::FILE_READING_ERROR,
                    "Error reading ply file "<<ply_mesh_file)
        JFR_POSTCOND(m_model.vn > 0, "model mesh is empty") 
      }

      Mixer(JfrMesh& _mesh) : 
        Modeler(), m_model(_mesh),
        is_updatable(false), first_new_vertex_id(0), first_new_shot_id(0)
      {
        JFR_POSTCOND(m_model.vn > 0, "model mesh is empty") 
      }

      Mixer(const std::string& ply_mesh_file) : 
        Modeler(), is_updatable(false), first_new_vertex_id(0), first_new_shot_id(0)
      {
        int mask = 0;
        if(vcg::tri::io::JfrImporterPLY<JfrMesh>::Open(m_model, ply_mesh_file.c_str(), mask) != 0)
          JFR_ERROR(ModelerException,
                    ModelerException::FILE_READING_ERROR,
                    "Error reading ply file "<<ply_mesh_file)
        JFR_POSTCOND(m_model.vn > 0, "model mesh is empty") 
      }

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

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

#endif