gen.hpp

Go to the documentation of this file.

#ifndef GEN_HPP
#define GEN_HPP

#include <iostream>
#include <iomanip> // for setprecision
#include <limits> // for min/max values
#include <assert.h>
#include <math.h>
#include <time.h>
#include <vector>
#include <algorithm>
#include "moab/Core.hpp"
#include "moab/Range.hpp"
#include "moab/AdaptiveKDTree.hpp" // for merging verts
#include "moab/EntityHandle.hpp"
#include "moab/CartVect.hpp"

// SENSE CONVENTIONS
#define SENSE_FORWARD 1
#define SENSE_REVERSE -1
#define SENSE_UNKNOWN 0


// returns a moab interface
moab::Interface *MBI(); 

namespace gen {
  bool error( const bool error_has_occured, const std::string message="" );
  
  void moab_printer(moab::ErrorCode error_code);

  void print_vertex_cubit( const moab::EntityHandle vertex );

  void print_vertex_coords( const moab::EntityHandle vertex );

  void print_triangles( const moab::Range tris );

  void print_triangle( const moab::EntityHandle triangle, bool print_edges );

  void print_edge( const moab::EntityHandle edge );

  void print_vertex_count( const moab::EntityHandle input_meshset);

  void print_range( const moab::Range range );

  void print_range_of_edges( const moab::Range range );

  void print_arc_of_edges( const std::vector<moab::EntityHandle> arc_of_edges );

  void print_arcs( const std::vector < std::vector<moab::EntityHandle> > arcs );

  void print_loop( const std::vector<moab::EntityHandle> loop_of_verts );

moab::ErrorCode find_closest_vert( const moab::EntityHandle reference_vert,
                               const std::vector<moab::EntityHandle> arc_of_verts,
                               unsigned &position,
                               const double dist_limit );

  moab::ErrorCode find_closest_vert( const double tol,
                                 const moab::EntityHandle reference_vert,
                                 const std::vector<moab::EntityHandle> loop_of_verts,
                                 std::vector<unsigned> &positions, 
                                 std::vector<double>   &dists);
  /*  moab::ErrorCode find_closest_vert( const moab::EntityHandle reference_vert,
                                  const std::vector<std::vector<moab::EntityHandle> > loops_of_verts,
                                  unsigned int &loop, unsigned int &position, 
                                  double &min_dist);
  */
  // Merge the range of vertices. We do not merge by edges (more
  // stringent) because we do not want to miss corner vertices.

  moab::ErrorCode merge_vertices( moab::Range vertices /* in */, 
                              const  double tol       /* in */);
                              //bool &merge_vertices_again /* out */);

  moab::ErrorCode squared_dist_between_verts( const moab::EntityHandle v0, 
                                          const moab::EntityHandle v1, 
                                          double &d);

  double dist_between_verts( const moab::CartVect v0, const moab::CartVect v1 );
  moab::ErrorCode dist_between_verts( const moab::EntityHandle v0, const moab::EntityHandle v1,
                                  double &d );
  double dist_between_verts( double coords0[], double coords1[] );
  double dist_between_verts( moab::EntityHandle vert0, moab::EntityHandle vert1 );                             

  // Return the length of the curve defined by MBEDGEs or ordered MBVERTEXs.
  double length( std::vector<moab::EntityHandle> curve );

  // Given a vertex and vector of edges, return the number of edges adjacent to the vertex.
  unsigned int n_adj_edges( moab::EntityHandle vert, moab::Range edges );

// Return true if the edges share a vertex. Does not check for coincident edges.
  bool edges_adjacent( moab::EntityHandle edge0, moab::EntityHandle edge1 );

// get the direction unit vector from one vertex to another vertex
  //moab::ErrorCode get_direction( moab::EntityHandle from_vert, moab::EntityHandle to_vert, double dir[] );
  moab::ErrorCode get_direction( const moab::EntityHandle from_vert, const moab::EntityHandle to_vert,
                           moab::CartVect &dir ); 

// from http://www.topcoder.com/tc?module=Static&d1=tutorials&d2=geometry1
  double edge_point_dist( const moab::CartVect a, const moab::CartVect b, const moab::CartVect c );
  double edge_point_dist( const moab::EntityHandle endpt0, const moab::EntityHandle endpt1, 
                          const moab::EntityHandle pt );
  double edge_point_dist( const moab::EntityHandle edge, const moab::EntityHandle pt );

  moab::ErrorCode point_curve_min_dist( const std::vector<moab::EntityHandle> curve, 
                                    const moab::EntityHandle pt, double &min_dist,
                                    const double max_dist_along_curve );
  moab::ErrorCode point_curve_min_dist( const std::vector<moab::EntityHandle> curve, 
                                    const moab::EntityHandle pt, double &min_dist );

  double triangle_area( const moab::CartVect a, const moab::CartVect b, const moab::CartVect c);
  moab::ErrorCode triangle_area( const moab::EntityHandle conn[], double &area );
  moab::ErrorCode triangle_area( const moab::EntityHandle triangle, double &area );
  double triangle_area( moab::Range triangles );
  
  bool triangle_degenerate( const moab::EntityHandle triangle );
  bool triangle_degenerate( const moab::EntityHandle v0, const moab::EntityHandle v1, const moab::EntityHandle v2);

  moab::ErrorCode triangle_normals( const moab::Range triangles, std::vector<moab::CartVect> &normals );
  moab::ErrorCode triangle_normal( const moab::EntityHandle triangle, moab::CartVect &normal );
  moab::ErrorCode triangle_normal( const moab::EntityHandle v0, const moab::EntityHandle v1,
                               const moab::EntityHandle v2, moab::CartVect &normal );
  moab::ErrorCode triangle_normal( const moab::CartVect v0, const moab::CartVect v1, 
                               const moab::CartVect v2, moab::CartVect &normal ); 

  // Distance between a point and line. The line is defined by two verts.
  // We are using a line and not a line segment!
  // http://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html
  moab::ErrorCode line_point_dist( const moab::EntityHandle line_pt1, const moab::EntityHandle line_pt2,
                               const moab::EntityHandle pt0, double &dist );

  // Project the point onto the line. Not the line segment! 
  // Change the coordinates of the pt0 to the projection.
  moab::ErrorCode point_line_projection( const moab::EntityHandle line_pt1,     
                                     const moab::EntityHandle line_pt2,             
                                     const moab::EntityHandle pt0 );

  // Do not change the coords of pt0. Instead return the projected coords.              
  moab::ErrorCode point_line_projection( const moab::EntityHandle line_pt1,     
                                     const moab::EntityHandle line_pt2,             
                                     const moab::EntityHandle pt0,              
                                     moab::CartVect &projected_coords,
                                     double &parameter );  
  // Get the distance of pt0 from line_pt1 if pt0 is projected. No coords are
  // changed in MOAB.
  moab::ErrorCode point_line_projection( const moab::EntityHandle line_pt1,
                                     const moab::EntityHandle line_pt2,
                                     const moab::EntityHandle pt0,
                                     double &dist_along_edge  );
  
  moab::ErrorCode ear_clip_polygon( std::vector<moab::EntityHandle> polygon_of_verts,
                                    const moab::CartVect plane_normal_vector, moab::Range &new_tris );

  int geom_id_by_handle( const moab::EntityHandle set);

  moab::ErrorCode save_normals( moab::Range tris, moab::Tag normal_tag );

  moab::ErrorCode flip(const moab::EntityHandle tri, const moab::EntityHandle vert0, 
                   const moab::EntityHandle vert2, const moab::EntityHandle surf_set);


  moab::ErrorCode ordered_verts_from_ordered_edges( const std::vector<moab::EntityHandle> ordered_edges,
                                                std::vector<moab::EntityHandle> &ordered_verts );
  moab::ErrorCode dist_between_arcs( bool debug,
                         const std::vector<moab::EntityHandle> arc0,
                         const std::vector<moab::EntityHandle> arc1,
                         double &dist );

  // skin edges are a vector of two vertex handles
    // Hold edges in an array of handles.
  struct edge {
    moab::EntityHandle e, v0, v1;
  };
  int compare_edge(const void *a, const void *b);
  moab::ErrorCode find_skin( moab::Range tris, const int dim,                     
                         // std::vector<std::vector<moab::EntityHandle> > &skin_edges,    
                         moab::Range &skin_edges,                         
                         const bool );
  //moab::ErrorCode find_skin( const moab::Range tris, const int dim, moab::Range &skin_edges, const bool );
  moab::ErrorCode measure( const moab::EntityHandle set, const moab::Tag geom_tag, double &size, bool debug, bool verbose );

  // Given a curve and surface set, get the relative sense.
  // From CGMA/builds/dbg/include/CubitDefines, CUBIT_UNKNOWN=-1, CUBIT_FORWARD=0, CUBIT_REVERSED=1
  moab::ErrorCode get_curve_surf_sense( const moab::EntityHandle surf_set, const moab::EntityHandle curve_set,
                                    int &sense, bool debug = false );

  moab::ErrorCode surface_sense( moab::EntityHandle volume, int num_surfaces,const moab::EntityHandle* surfaces,int* senses_out );
  moab::ErrorCode surface_sense( moab::EntityHandle volume, moab::EntityHandle surface, int& sense_out );

  moab::Tag get_tag( const char* name, int size, moab::TagType store,moab::DataType type, const void* def_value, bool create_if_missing);

  moab::ErrorCode delete_surface( moab::EntityHandle surf, moab::Tag geom_tag, moab::Range tris, int id, bool debug, bool verbose);

  moab::ErrorCode remove_surf_sense_data(moab::EntityHandle del_surf, bool debug);

  moab::ErrorCode combine_merged_curve_senses( std::vector<moab::EntityHandle> &curves, moab::Tag merge_tag, bool debug = false) ;

  moab::ErrorCode get_sealing_mesh_tags( double &facet_tol,
                             double &sme_resabs_tol,
                             moab::Tag &geom_tag, 
                             moab::Tag &id_tag, 
                             moab::Tag &normal_tag, 
                             moab::Tag &merge_tag, 
                             moab::Tag &faceting_tol_tag, 
                             moab::Tag &geometry_resabs_tag, 
                             moab::Tag &size_tag, 
                             moab::Tag &orig_curve_tag);

  moab::ErrorCode get_geometry_meshsets( moab::Range geometry_sets[], moab::Tag geom_tag, bool verbose = false);

  moab::ErrorCode check_for_geometry_sets(moab::Tag geom_tag, bool verbose);

}

#endif