vcgDeclarations.hpp

/* $Id$ */

#ifndef VCG_DECLARATIONS_HPP
#define VCG_DECLARATIONS_HPP

#include <vcg/simplex/vertex/base.h>
#include <vcg/simplex/vertex/component_ocf.h>
#include <vcg/simplex/edge/base.h>
#include <vcg/simplex/face/base.h>
#include <vcg/simplex/face/component_ocf.h>
#include <vcg/complex/used_types.h>
#include <vcg/complex/trimesh/base.h>
#include <vcg/complex/trimesh/allocate.h>
#include <vcg/complex/trimesh/append.h>
#include <vcg/math/shot.h>
#include <vcg/space/point3.h>
#include <vcg/math/matrix44.h>

#include "geom/t3d.hpp"
#include "fdetect/InterestFeature.hpp"
#include "fdetect/RealDescriptor.hpp"
#include "jmath/jblas.hpp"
#include "modeler/modelerException.hpp"

namespace jafar {
  namespace modeler {
    // Forward declarations needed for creating the used types
    class JfrVertex;
    class JfrEdge;
    class JfrFace;

    // Declaration of the semantic of the used types
    class JfrUsedTypes: public vcg::UsedTypes < vcg::Use<JfrVertex>::AsVertexType,
            vcg::Use<JfrEdge  >::AsEdgeType,
            vcg::Use<JfrFace  >::AsFaceType >{};


    // The Main Vertex Class
    // Most of the attributes are optional and must be enabled before use.
    // Each vertex needs 40 byte, on 32bit arch. and 44 byte on 64bit arch.
    
    class JfrVertex  : public vcg::Vertex< JfrUsedTypes,
             vcg::vertex::InfoOcf,           /*  4b */
             vcg::vertex::Coord3f,           /* 12b */
             vcg::vertex::BitFlags,          /*  4b */
             vcg::vertex::Normal3f,          /* 12b */
             vcg::vertex::Qualityf,          /*  4b */
             vcg::vertex::Color4b,           /*  4b */
             vcg::vertex::VFAdjOcf,          /*  0b */
             vcg::vertex::MarkOcf,           /*  0b */
             vcg::vertex::TexCoordfOcf,      /*  0b */
             vcg::vertex::CurvaturefOcf,     /*  0b */
             vcg::vertex::CurvatureDirfOcf,  /*  0b */
             vcg::vertex::RadiusfOcf         /*  0b */
             >{
    };


    // The Main Edge Class
    // Currently it does not contains anything.
    class JfrEdge : public vcg::Edge<JfrUsedTypes, vcg::edge::EVAdj> {
    public:
      inline JfrEdge(){};
      inline JfrEdge( JfrVertex * v0, JfrVertex * v1){ V(0)= v0 ; V(1)= v1;};
      static inline JfrEdge OrderedEdge(JfrVertex* v0,JfrVertex* v1){
  if(v0<v1) return JfrEdge(v0,v1);
  else return JfrEdge(v1,v0);
      }
    };
    
    // Each face needs 32 byte, on 32bit arch. and 48 byte on 64bit arch.
    class JfrFace    : public vcg::Face<  JfrUsedTypes,
            vcg::face::InfoOcf,              /* 4b */
            vcg::face::VertexRef,            /*12b */
            vcg::face::BitFlags,             /* 4b */
            vcg::face::Normal3f,             /*12b */
            vcg::face::QualityfOcf,          /* 0b */
            vcg::face::MarkOcf,              /* 0b */
            vcg::face::Color4bOcf,           /* 0b */
            vcg::face::FFAdjOcf,             /* 0b */
            vcg::face::VFAdjOcf,             /* 0b */
            vcg::face::WedgeTexCoordfOcf     /* 0b */
            > {};

    class JfrMesh : public vcg::tri::TriMesh< vcg::vertex::vector_ocf<JfrVertex>, 
                vcg::face::vector_ocf<JfrFace> > 
    { 
    public:
      typedef vcg::tri::TriMesh< vcg::vertex::vector_ocf<JfrVertex>, vcg::face::vector_ocf<JfrFace> >::ScalarType     ScalarType;
      typedef vcg::Shot<ScalarType> Shot;

      //features stuff
      unsigned int ftn;
      std::vector<fdetect_v2::InterestFeature<fdetect_v2::FloatDescriptor>* > features;
      JfrMesh::PerVertexAttributeHandle< std::vector<unsigned int> > origines_setter, origines_getter;
      JfrMesh::PerVertexAttributeHandle< unsigned int>  id_setter, id_getter;
      //shots stuff
      unsigned int sn;
      std::map<unsigned int, vcg::Shot<ScalarType> > shots;
      inline JfrMesh() : 
  vcg::tri::TriMesh < vcg::vertex::vector_ocf<JfrVertex>, vcg::face::vector_ocf<JfrFace> >(),
  ftn(0), sn(0)
      {
  using namespace fdetect_v2;
  origines_setter = vcg::tri::Allocator<JfrMesh>::AddPerVertexAttribute<std::vector<unsigned int> >  (*this,std::string("Origines")); 
  id_setter = vcg::tri::Allocator<JfrMesh>::AddPerVertexAttribute< unsigned int >  (*this,std::string("Id"));
  origines_getter = vcg::tri::Allocator<JfrMesh>::GetPerVertexAttribute<std::vector<unsigned int> >  (*this,std::string("Origines")); 
  id_getter = vcg::tri::Allocator<JfrMesh>::GetPerVertexAttribute< unsigned int >  (*this,std::string("Id"));

      };
      inline JfrMesh(JfrMesh& mesh) :
  ftn(mesh.ftn), sn(mesh.sn)
      {
  vcg::tri::Append<JfrMesh, JfrMesh>::Mesh(*this, mesh);

  using namespace fdetect_v2;
  origines_setter = vcg::tri::Allocator<JfrMesh>::AddPerVertexAttribute<std::vector<unsigned int> >  (*this,std::string("Origines")); 
  id_setter = vcg::tri::Allocator<JfrMesh>::AddPerVertexAttribute< unsigned int >  (*this,std::string("Id"));
  origines_getter = vcg::tri::Allocator<JfrMesh>::GetPerVertexAttribute<std::vector<unsigned int> >  (*this,std::string("Origines")); 
  id_getter = vcg::tri::Allocator<JfrMesh>::GetPerVertexAttribute< unsigned int >  (*this,std::string("Id"));
      };
    
      inline void addFeature(fdetect_v2::InterestFeature<fdetect_v2::FloatDescriptor>* ft)
      {
  features.push_back(ft);
  ++ftn;
      }
    
      inline void addShot(unsigned int id, 
        const geom::T3D* frame,
        int width, int height, 
        double u0, double v0, 
        double alphaU, double alphaV,
        double focal = 1.,
        double k1 = 0., double k2 = 0., double k3 = 0., double k4 = 0.)
      {
  std::map<unsigned int, vcg::Shot<ScalarType> >::iterator shit = shots.find(id);
  JFR_PRED_ERROR(shit == shots.end(),
           ModelerException,
           ModelerException::EXISTING_ID,
           "a shot with id "<< id << " was already defined")
    jblas::vec3 t = frame->getT();
  jblas::mat33 r = frame->getR();
  // extrinsic
  shots[id].Extrinsics.SetIdentity();
  // view point
  shots[id].Extrinsics.SetTra(vcg::Point3<ScalarType>((ScalarType)t[0],
                  (ScalarType)t[1],
                  (ScalarType)t[2]));
      
  // axis (i.e. rotation).
  vcg::Matrix44<ScalarType> rm;
  rm.SetIdentity();
  rm[0][0] = (ScalarType)r(0,0);
  rm[0][1] = (ScalarType)r(0,1);
  rm[0][2] = (ScalarType)r(0,2);
      
  rm[1][0] = (ScalarType)r(1,0);
  rm[1][1] = (ScalarType)r(1,1);
  rm[1][2] = (ScalarType)r(1,2);
      
  rm[2][0] = (ScalarType)r(2,0);
  rm[2][1] = (ScalarType)r(2,1);
  rm[2][2] = (ScalarType)r(2,2);
      
  shots[sn].Extrinsics.SetRot(rm);

  shots[id].Intrinsics.FocalMm        = (ScalarType)focal;
  shots[id].Intrinsics.PixelSizeMm[0] = (ScalarType)alphaU;
  shots[id].Intrinsics.PixelSizeMm[1] = (ScalarType)alphaV;
  shots[id].Intrinsics.CenterPx[0]    = (ScalarType)u0;
  shots[id].Intrinsics.CenterPx[1]    = (ScalarType)v0;
  shots[id].Intrinsics.ViewportPx[0]  = (ScalarType)width;
  shots[id].Intrinsics.ViewportPx[1]  = (ScalarType)height;
  shots[id].Intrinsics.k[0]           = (ScalarType)k1;
  shots[id].Intrinsics.k[1]           = (ScalarType)k2;
  shots[id].Intrinsics.k[2]           = (ScalarType)k3;
  shots[id].Intrinsics.k[3]           = (ScalarType)k4;
  ++sn;
      }
    };

  }
}

#endif