Point_set.h

Go to the documentation of this file.

/*
**    Mesh Converter
**    Copyright (C) 2008 Damien Rohmer
**
**    This program is free software: you can redistribute it and/or modify
**    it under the terms of the GNU General Public License as published by
**    the Free Software Foundation, either version 3 of the License, or
**    (at your option) any later version.
**
**   This program is distributed in the hope that it will be useful,
**    but WITHOUT ANY WARRANTY; without even the implied warranty of
**    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**    GNU General Public License for more details.
**
**    You should have received a copy of the GNU General Public License
**    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/



/*
** Point_set.h
** 
** Made by damien
** Login   <damien@ortie>
** 
** Started on  Tue Apr 15 20:06:40 2008 damien
** Last update Tue Apr 15 20:06:40 2008 damien
*/

#ifndef         POINT_SET_H_
# define        POINT_SET_H_


#include <stdlib.h>
#include <iostream>
#include <cmath>
#include <string>
#include <errno.h>
#include <stdio.h>

#include <tinyXml/tinyxml.h>
#include <tinyXml/tinystr.h>

#include <V_3D.h>
#include <Matrix.h>

#include <vector>
using namespace std;



class Point_set
{
 public:

  //************************************************//
  //************************************************//
  //CONSTRUCTORS
  //************************************************//
  //************************************************//


  Point_set();

  Point_set(const Point_set &);
  ~Point_set();
  
  int destroy();


  //************************************************//
  //************************************************//
  //SIZE INFORMATIONS
  //************************************************//
  //************************************************//


  int get_vertex_number() const;


  int size() const;


  int resize(int N_vertex);



  //************************************************//
  //************************************************//
  //GET VERTEX
  //************************************************//
  //************************************************//
  
  double& get_vertex(int k_vertex,int k_dim);
  double  get_vertex(int k_vertex,int k_dim) const;
  const double* get_vertex_p(int k_vertex);
  V_3D get_vertex(int k_vertex) const;
  V_3D get_vertex_v3d(int k_vertex) const;



  //SET VERTEX
  //************************************************//

  
  int set_vertex(int k_vertex,double x,double y,double z);
  int set_vertex(int k_vertex,int k_dim,double value);
  int set_vertex(int k_vertex,V_3D v);
  int set_vertex(const std::vector <double>& to_set);
  int set_vertex(int k_vertex,double* v);
  int set_vertex(int k_vertex,int dim,double *v);
  int set_vertex(const Point_set& p);


  //ADD VERTEX
  //************************************************//


  int add_vertex(double x,double y,double z);
  int add_vertex(const V_3D& v);
  int add_vertex(const std::vector <double>& to_add);
  int add_vertex(const std::vector <V_3D>& to_add);
  int add_vertex(const double* v);
  int add_vertex(int dim,double *v);
  int add_vertex(const Point_set& p);


  //ADD/DELETE UNIQUE
  //************************************************//

  //return -1 if not found
  int add_unique(double x,double y,double z,double epsilon);
  int add_unique(const V_3D& v,double epsilon);
  int add_unique(const double* v,double epsilon);

  int exist(const V_3D& v) const;
  int exist(const V_3D& v,double epsilon) const;
  int exist(double x,double y,double z) const;
  int exist(double x,double y,double z,double epsilon) const;

  int eliminate(int k_index);
  int eliminate(const std::vector <int>& k_index);
  int eliminate(const std::vector <double>& k_index);
  int eliminate(double x,double y,double z);
  int eliminate(double x,double y,double z,double epsilon);
  int eliminate(const V_3D& x,double epsilon);
  int eliminate(const V_3D& x);
  int eliminate(const double* x,double epsilon);
  int eliminate(const double* x);


  //TRANSFORMATIONS
  //************************************************//

  int matrix_transform(const Matrix& M);


  int rotate(const V_3D& n,double angle);
  int rotate(double n_x,double n_y,double n_z,double angle);
  int rotate(const double *n,double angle);

  int rotate_centered(const V_3D& n,double angle);
  int rotate_centered(double n_x,double n_y,double n_z,double angle);
  int rotate_centered(const double *n,double angle);

  int rotate(const V_3D& n,double angle,const V_3D& center);
  int rotate(double n_x,double n_y,double n_z,double angle,const V_3D& center);
  int rotate(const double *n,double angle,const V_3D& center);




  int translate(double t_x,double t_y,double t_z);
  int translate(const double *t);
  int translate(const V_3D& t);

  int scale(double s_x,double s_y,double s_z);
  int scale(const double *s);
  int scale(const V_3D& s);
  int scale(double s);

  int scale_centered(double s_x,double s_y,double s_z);
  int scale_centered(const double *s);
  int scale_centered(const V_3D& s);
  int scale_centered(double s);



  

  //FURTHER
  //************************************************//

  double get_closest_distance(double x,double y,double z,int *index) const;
  double get_closest_distance(const double* x,int *index) const;
  double get_closest_distance(const V_3D& x,int *index) const;

  double get_further_distance(double x,double y,double z,int *index) const;
  double get_further_distance(const double* x,int *index) const;
  double get_further_distance(const V_3D& x,int *index) const;

  double distance_to_index(double x,double y,double z,int index) const;
  double distance_to_index(const double* x,int index) const;
  double distance_to_index(const V_3D& x,int index) const;


  std::vector <int> N_closest(const V_3D& center,int N_closest) const;
  std::vector <int> N_closest(double x,double y,double z,int N_closest) const;
  std::vector <int> N_closest(double *x,int N_closest) const;

  V_3D get_closest_vertex(const V_3D& center) const;
  V_3D get_closest_vertex(double x,double y,double z) const;
  V_3D get_closest_vertex(const double *x) const;
  
  //GEOMETRY
  //************************************************//

  std::vector <int> inside_circle(const V_3D& center,double radius) const;
  std::vector <int> inside_circle(double x,double y,double z,double radius) const;

  std::vector <int> outside_circle(const V_3D& center,double radius) const;
  std::vector <int> outside_circle(double x,double y,double z,double radius) const;

  std::vector <int> inside_box(const V_3D& p1,const V_3D& p2) const;
  std::vector <int> outside_box(const V_3D& p1,const V_3D& p2) const;

  std::vector <int> inside_tetrahedra(const V_3D& p1,const V_3D& p2,const V_3D& p3,const V_3D& p4) const;
  std::vector <int> outside_tetrahedra(const V_3D& p1,const V_3D& p2,const V_3D& p3,const V_3D& p4) const;

  std::vector <int> in_half_space(const V_3D& n,const V_3D& x0) const;

  std::vector <int> inside_rectangle(const V_3D& p1,const V_3D& p2) const;
  std::vector <int> outside_rectangle(const V_3D& p1,const V_3D& p2) const;
  
  std::vector <int> other_index(const std::vector <int>& index) const;



  //POINTERS
  //************************************************//

  const double *get_vertex() const;
  std::vector <double> get_vertex_vector() const;



  //CUT
  //************************************************//
  int keep_index(int k_start,int k_end);
  int delete_index(int k_start,int k_end);




  //SIZE
  //************************************************//

  V_3D get_middle_point() const;
  V_3D get_min_point() const;
  V_3D get_max_point() const;
  V_3D get_size_set() const;

  //center the point set
  int center_point_set();

  //set max size to 1
  int unitize_size();




  //************************************************//
  //************************************************//
  //INPUT/OUTPUT
  //************************************************// 
  //************************************************//


  int load_off_file(const char* filename);
  int load_off_file(const std::string& filename);
  int load_obj_file(const char* filename);
  int load_obj_file(const std::string& filename); 

  int load_collada_file(const char* filename);
  int load_collada_file(const std::string& filename);

  int load_collada_file(const std::string& filename,const std::string& name);

  int load_collada_file(const char* filename,const char* name);

  int write_off_type(const char* filename) const;
  int write_off_type(const std::string& filename) const;
  int write_obj_type(const char* filename) const;
  int write_obj_type(const std::string& filename) const;



  int load_g_file(const char* filename);
  int load_g_file(const std::string& filename);
  int write_g_type(const char* filename) const;
  int write_g_type(const std::string& filename) const;

  


  int export_visible_off(const char* filename,double s_cube_size) const;
  int export_visible_off(const std::string& filename,double s_cube_size) const;



  //OPERATORS
  //************************************************//

  double& operator[](int index);
  double  operator[](int index) const;
  V_3D    operator()(int index) const;
  double  operator()(int k_index,int k_dim) const;
  double& operator()(int k_index,int k_dim) ;

  const Point_set& operator=(const Point_set&);
  
  friend Point_set operator+(const Point_set&, V_3D T);
  friend Point_set operator+(const V_3D& T,const Point_set&);
  friend Point_set operator-(const Point_set&, V_3D T);
  friend Point_set operator-(const V_3D& T,const Point_set&);
  friend Point_set operator*(const Matrix& M,const Point_set&);
  friend bool operator==(const Point_set&, const Point_set& );
  friend bool operator!=(const Point_set&, const Point_set& );
  friend ostream& operator << (ostream& flux,const Point_set& );
  
  
 private:


  int load_collada_mesh_vertices(TiXmlNode* geometry_node,const std::string& filename);
  std::vector <double> load_collada_float_array(TiXmlNode *mesh_source,const std::string& filename);


  std::vector <double> vertex;

};

#endif      /* !POINT_SET_H_ */