/users/wolffm/guskov/Source/AlgoGuskov.hh

Go to the documentation of this file.

#ifndef DEF_ALGOGUSKOV
#define DEF_ALGOGUSKOV

#include <math.h>
#include <complex>
#include <vector>


#include "Common.hh"
#include "Tile.hh"


class AlgoGuskov
{

private:

  /*
  OriginalMesh orig_mesh;
  OriginalMesh base_mesh;
  
  OpenMesh::VPropHandleT< unsigned int >  vprop_tile;       // region a laquelle le noeud apartient (0 = aucune)
  OpenMesh::VPropHandleT< double >        vprop_distance;   // plus court distance du noeud au seed le plus proche
  OpenMesh::VPropHandleT< int >           vprop_heappos;
*/

  //int get_triangle_index(const OriginalMesh& mesh, const Vertex& v, const OriginalMesh::FaceHandle& face) const;


//  OriginalMesh::Point planar_mapping(const OriginalMesh& base_mesh, const Vertex& v1, const OriginalMesh::FaceHandle& face, const OriginalMesh::Point &s) const;

//  OriginalMesh::Point planar_mapping(const OriginalMesh& base_mesh, const Vertex& bv1, const Vertex& bv2, const Vertex& bv3, const OriginalMesh::Point &s) const;


  std::vector<OriginalMesh::Normal> get_face_normal(OriginalMesh& result_mesh, OriginalMesh::VertexHandle v);


  
  // ###################################################################################################
  // paramètres de l'algorithme
  // ###################################################################################################

  // ################################################
  // Chartification
  
  double max_normal_error;

  vector<Vertex> seed_list;

  // ################################################
  // Parameterization

  double delta_cubic_spline[2];

  // ################################################
  // Remeshing

  unsigned int resampling_level;

  unsigned int mapping_parameter_h;

  
  // ###################################################################################################
  // fonctions d'aide pour la chartification
  // ###################################################################################################



  bool condition_EB(vector<Tile*> &tiles, Vertex &v, OriginalMesh &m) ;

  bool condition_NZ(vector<Tile*> &tiles, Vertex &v, OriginalMesh &m) ;

  bool condition_MB(vector<Tile*> &tiles, Vertex &v, OriginalMesh &m) ;

  bool condition_MN(vector<Tile*> &tiles, Vertex &v, OriginalMesh &m); 

  bool check_normal_error(vector<Tile*>& tiles, Vertex &v, OriginalMesh &m, OpenMesh::VPropHandleT< unsigned int > &vprop_tile);





  // ###################################################################################################
  // fonctions d'aide pour le "Resampling"
  // ###################################################################################################



  double calculate_cubic_spline(const double r) const;

  double metric_space_dist(OriginalMesh::Point const & s, OriginalMesh::Point const & b1, OriginalMesh::Point const & b2, OriginalMesh::Point const & b3) const;


  OriginalMesh::Point blending(OriginalMesh& m, const vector<Tile*>& tiles, const OriginalMesh& base_mesh, const OriginalMesh::Point s, const OriginalMesh::FaceHandle base_face1, const OriginalMesh::FaceHandle second_base_face);

  
  bool triangle_in_D(const OriginalMesh& m, const unsigned int tile_id, const Vertex vertices[3], vector<Tile*> tiles) const;
  


  // ###################################################################################################
  // fonctions d'aide pour l'optimisation
  // ###################################################################################################




  void optimize_vertex_find_region_interior(OriginalMesh& om, const OriginalMesh& bm, Tile& cur_tile, const OpenMesh::VPropHandleT< double >& vprop_distance, vector<OriginalMesh::Point>& ret_region, Vertex& boundary_start_vertex);
  

  void optimize_vertex_region(OriginalMesh& om, OriginalMesh& bm, vector<Tile*>& tiles);

  //void optimize_edge_region(OriginalMesh om, BaseMesh bm, Edge e);

  

public:

  AlgoGuskov()
  {
    max_normal_error = 0.5;
    delta_cubic_spline[0] = 0.4;
    delta_cubic_spline[1] = 0.75;
    resampling_level = 2;
    mapping_parameter_h = 1;
  }



  void set_max_normal_error(double error)
  { max_normal_error = error; }

  double get_max_normal_error() const
  { return max_normal_error;  }

  void set_cubic_spline_delta(unsigned int which_delta, double value)
  {
    if(which_delta < 2)
      delta_cubic_spline[which_delta] = value;
  }

  double get_cubic_spline_delta(unsigned int which_delta) const
  {
    return (which_delta < 2) ? delta_cubic_spline[which_delta] : 0.0;
  }

  void set_resampling_level(unsigned int level)
  {
    resampling_level = level;
  }

  unsigned int get_resampling_level() const
  {
    return resampling_level;
  }

  void set_mapping_parameter_h(unsigned int h)
  {
    if(h < 2)
      mapping_parameter_h = h;
  }
  
  unsigned int get_mapping_parameter_h() const
  {
    return mapping_parameter_h;
  }


  void init_mesh(OriginalMesh& m);


  std::vector<Seed> create_seeds(const unsigned int n, const OriginalMesh& m);


  void run_chartification(OriginalMesh& m, vector<Seed>& seed_list, vector<Tile*>& tiles );


  void create_base_mesh(OriginalMesh& m, vector<Tile*>& tiles, OriginalMesh& base_mesh);

  
  void initial_parameterization(OriginalMesh  &orig_mesh, OriginalMesh const &base_mesh, vector<Tile*> const &tiles);


  void run_resampling(OriginalMesh& m, vector<Tile*>& tiles, OriginalMesh& base_mesh, OriginalMesh& result_mesh);
};





#endif

---