GeometryQueryTool.hpp

Go to the documentation of this file.

#ifndef GEOMETRYQUERYTOOL_HPP
#define GEOMETRYQUERYTOOL_HPP

#include <stdio.h>
#include <typeinfo>
#include <list>
#include <set>

#include "GeometryDefines.h"
#include "DLIList.hpp"
#include "GeometryQueryEngine.hpp"
#include "IntermediateGeomEngine.hpp"
#include "CGMHistory.hpp"

class RefGroup;
class Body;
class BodySM;
class Lump;
class Shell;
class ShellSM;
class Loop;
class LoopSM;
class Chain;
class Surface;
class Curve;
class TopologyBridge;
class CoEdgeSM;

class GeometryEntity;

class RefGroup;

class TopologyEntity;
class TopologyBridge;

class RefEntity ;
class RefVolume ;
class RefFace ;
class RefEdge ;
class CoEdge;
class RefVertex ;

class SenseEntity;
class BasicTopologyEntity;
class RefVolume ;
class RefFace ;
class RefEdge ;
class RefVertex ;
class TBPoint;
class CubitEntity;
class CoEdgeSM;

class GeometryQueryEngine;

class CubitPlane ;
class CubitBox;
class CubitVector;
class CubitTransformMatrix;
class TBOwner;

#ifdef PROE
class RefPart;
class RefAssembly;
#endif

class CUBIT_GEOM_EXPORT GeometryQueryTool
{
public :

  friend class GeometryModifyTool;
   
  bool ige_is_composite(TBOwner *bridge_owner);
  bool ige_is_composite(TopologyBridge *bridge);
  bool ige_is_partition(TBOwner *bridge_owner);


  void ige_remove_modified(DLIList<Surface*> &all_surfs,
                                            DLIList<Curve*> &all_curves,
                                            DLIList<TBPoint*> &all_points);

  static GeometryQueryTool* instance( GeometryQueryEngine* gqePtr = NULL);
  ~GeometryQueryTool();

  static void delete_instance();
  
  double estimate_merge_tolerance(DLIList<RefVolume*> &vol_list,
                                                    bool accurate_in = false,
                                                    bool report_in = false,
                                                    double lo_val_in = -1.0, 
                                                    double hi_val_in = -1.0,
                                                    int num_calculations_in = 10,
                                                    bool return_calculations_in = false,
                                                    DLIList<double> *merge_tols = NULL,
                                                    DLIList<int> *num_proximities = NULL);

  void find_floating_volumes(DLIList<RefVolume*> &vol_list,
                             DLIList<RefVolume*> &floating_list);

  void find_nonmanifold_curves(DLIList<RefVolume*> &vol_list, DLIList<RefEdge*> &curve_list);

  void find_nonmanifold_vertices(DLIList<RefVolume*> &vol_list, DLIList<RefVertex*> &vertex_list);

  CubitStatus register_intermediate_engine( IntermediateGeomEngine* engine );
  void unregister_intermediate_engine( IntermediateGeomEngine* engine );

  void ige_remove_imprint_attributes_after_modify(DLIList<BodySM*> &old_sms,
                                              DLIList<BodySM*> &new_sms);
  void ige_push_imprint_attributes_before_modify
                                ( DLIList<BodySM*> &geom_list );
  void ige_push_named_attributes_to_curves_and_points
                                ( DLIList<TopologyBridge*> &tb_list, const char *name_in );
  void ige_export_geom( DLIList<TopologyBridge*> &geom_list );
  void ige_import_geom( DLIList<TopologyBridge*> &geom_list );
  void ige_remove_attributes( DLIList<TopologyBridge*> &geom_list );
  void ige_attribute_after_imprinting(DLIList<TopologyBridge*> &tb_list,
                                      DLIList<Body*> &old_bodies);
  void ige_remove_attributes_from_unmodifed_virtual(DLIList<TopologyBridge*> &bridges);
  
  //Using the source_bridge, finds all bridges that actually have a BridgeManager the owner.
  //This is for obtaining the real TopologyBridge when all you have is a  TopologyBridge 
  //that is Partition Entity.
  void get_tbs_with_bridge_manager_as_owner( TopologyBridge *source_bridge, 
                                             DLIList<TopologyBridge*> &tbs );

  //
  // Returns ref entities in a generic cubit entity list (overwrites list).
  // returns CUBIT_FAILURE if keyword is not a ref entity name, and
  // optionally prints error message
  //
  //CubitStatus cubit_entity_list( const char* keyword,
  //                               DLIList<CubitEntity*> &entity_list,
  //                               const CubitBoolean print_errors = CUBIT_TRUE);


  CubitStatus ref_entity_list( char const* keyword,
                               DLIList<RefEntity*> &entity_list,
                               const CubitBoolean print_errors = CUBIT_TRUE);

  CubitBox model_bounding_box();


  CubitBox bounding_box_of_bodies();


  void bodies (DLIList<Body*> &bodies);

  void ref_volumes (DLIList<RefVolume*> &ref_volumes);

  void ref_groups (DLIList<RefGroup*> &ref_groups);

  void ref_faces (DLIList<RefFace*> &ref_faces);

  void ref_edges (DLIList<RefEdge*> &ref_edges);

  void ref_vertices (DLIList<RefVertex*> &ref_vertices);

  void get_ordered_loops(RefFace* face, DLIList<Loop*> &loop_list);

#ifdef PROE
  void ref_parts (DLIList<RefPart*> &ref_parts);
  void ref_assemblies (DLIList<RefAssembly*> &ref_assemblies);
#endif //PROE


  int num_bodies() const;

  int num_ref_volumes() const;

  int num_ref_groups() const;

  int num_ref_faces() const;

  int num_ref_edges() const;

  int num_ref_vertices() const;

  RefEntity *get_ref_entity (const char *type, int id);

  RefEntity *get_ref_entity (const std::type_info& type, int id);

  Body *get_body ( int id );

  RefVolume *get_ref_volume ( int id );

  RefGroup *get_ref_group ( int id );

  RefFace *get_ref_face ( int id );

  RefEdge *get_ref_edge ( int id );

  RefVertex *get_ref_vertex ( int id );
  

  Body *get_first_body ();
  RefVolume *get_first_ref_volume ();
  RefGroup *get_first_ref_group ();
  RefFace *get_first_ref_face ();
  RefEdge *get_first_ref_edge ();
  RefVertex *get_first_ref_vertex ();

  Body *get_next_body ();
  RefVolume *get_next_ref_volume ();
  RefGroup *get_next_ref_group ();
  RefFace *get_next_ref_face ();
  RefEdge *get_next_ref_edge ();
  RefVertex *get_next_ref_vertex ();

  Body *get_last_body ();
  RefVolume *get_last_ref_volume ();
  RefGroup *get_last_ref_group ();
  RefFace *get_last_ref_face ();
  RefEdge *get_last_ref_edge ();
  RefVertex *get_last_ref_vertex ();
  
  
  CubitStatus get_free_ref_entities(DLIList<RefEntity*> &free_entities);

  void get_connected_free_ref_entities(
    RefEntity *entity,
    const int merge_option,
    DLIList<Body*> &body_list,
    DLIList<RefFace*> &ref_face_list,
    DLIList<RefEdge*> &ref_edge_list,
    DLIList<RefVertex*> &ref_vertex_list );

  void validate_geometry_database();

  CubitStatus save_temp_geom_files( DLIList<RefEntity*>& ref_entity_list,
                                  const char* filename,
                                  const CubitString &cubit_version,
                                  std::list<CubitString> &files_written,
                                  std::list<CubitString> &types_written);


  CubitStatus export_solid_model( DLIList<RefEntity*>& ref_entity_list,
                                  const char* filename,
                                  Model_File_Type filetype,
                                  int &num_ents_exported,
                                  const CubitString &cubit_version,
                                  ModelExportOptions &export_options );

  CubitStatus export_solid_model(DLIList<RefEntity*>& ref_entity_list,
                 char*& p_buffer,
                 int& n_buffer_size,
                 bool b_export_buffer);

  CubitStatus import_solid_model(const char* file_name,
                                 Model_File_Type file_type,
                                 ModelImportOptions &import_options,
                 DLIList<RefEntity*> *imported_entities = NULL );


    // import entities in a solid model buffer
  CubitStatus import_solid_model(DLIList<RefEntity*> *imported_entities,
                 const char* pBuffer,
                 const int n_buffer_size);


  CubitStatus fire_ray( CubitVector &origin,
                        CubitVector &direction,
                        DLIList<RefEntity*> &at_entity_list,
                        DLIList<double> &ray_params,
                        int max_hits = 0,
                        double ray_radius = 0.0,
                        DLIList<RefEntity*> *hit_entity_list_ptr = 0 );


  CubitStatus fire_ray( CubitVector &origin,
                        CubitVector &direction,
                        DLIList<TopologyEntity*> &at_entity_list,
                        DLIList<double> &ray_params,
                        int max_hits = 0,
                        double ray_radius = 0.0,
                        DLIList<TopologyEntity*> *hit_entity_list_ptr = 0 );
  
  static void geom_debug( DLIList<TopologyEntity*> );

  static void set_facet_bbox( CubitBoolean pass_flag )
      {useFacetBBox = pass_flag;}

  static CubitBoolean get_facet_bbox()
      {return useFacetBBox;}

  CubitString get_engine_version_string();

  CubitStatus set_export_allint_version(int version);

  int get_allint_version();

  CubitStatus list_engine_versions(CubitString &versions);

  double get_sme_resabs_tolerance();

  double set_sme_resabs_tolerance( double new_resabs );

  CubitStatus set_sme_int_option( const char* opt_name, int val );
  CubitStatus set_sme_dbl_option( const char* opt_name, double val );
  CubitStatus set_sme_str_option( const char* opt_name, const char* val );


  Body* make_Body(BodySM *bodysm_ptr) const;
  RefFace* make_RefFace(Surface* surface_ptr ) const;
  RefEdge* make_RefEdge(Curve* curve_ptr) const;
  RefVertex* make_RefVertex(TBPoint* point_ptr) const;

  static CubitSense relative_sense( Surface* surface1, Surface* surface2 );

  RefFace* make_free_RefFace(Surface *surface_ptr, bool is_free_surface) const;
  RefEdge* make_free_RefEdge(Curve *curve_ptr ) const;
  RefVertex* make_free_RefVertex(TBPoint *point_ptr) const;


  void delete_Body( DLIList<Body*>& body_list );


  CubitStatus delete_Body( Body* body_ptr );


  CubitStatus delete_single_Body( Body* body_ptr );

  CubitStatus delete_RefEntity( RefEntity* ref_entity_ptr );
  
  CubitStatus delete_RefFace( RefFace* ref_face_ptr );

  CubitStatus delete_RefEdge( RefEdge* ref_edge_ptr );

  CubitStatus delete_RefVertex( RefVertex* ref_vertex_ptr );

  void cleanout_deactivated_geometry();
  void cleanout_temporary_geometry ();
  
  void delete_geometry();

  
  CubitStatus interpolate_along_surface( CubitVector *vector_1,
                                         CubitVector *vector_2,
                                         DLIList<CubitVector*> &vector_list,
                                         RefFace* ref_face_ptr,
                                         int number_points ) const;

  CubitBoolean about_spatially_equal (const CubitVector& Vec1,
                                      const CubitVector& Vec2,
                                      double tolerance_factor = 1.0);

  CubitBoolean about_spatially_equal (RefVertex* refVertex1,
                                      RefVertex* refVertex2,
                                      double tolerance_factor = 1.0);

  double geometric_angle(RefEdge* ref_edge_1,
                         RefEdge* ref_edge_2,
                         RefFace* ref_face );

  double geometric_angle(CoEdge* co_edge_1,
                         CoEdge* co_edge_2 );

  double surface_angle( RefFace *ref_face_1, RefFace *ref_face_2,
                        RefEdge *ref_edge = NULL,
                        RefVolume *ref_volume = NULL,
                        double frac = 0.5);


  CubitStatus get_intersections( RefEdge* ref_edge1,
                                 CubitVector& point1,
                                 CubitVector& point2,
                                 DLIList<CubitVector>& intersection_list,
                                 CubitBoolean bounded = CUBIT_FALSE,
                                 CubitBoolean closest = CUBIT_FALSE);
 

  CubitStatus get_intersections( RefEdge* ref_edge1, RefEdge* ref_edge2,
                                 DLIList<CubitVector>& intersection_list,
                                 CubitBoolean bounded = CUBIT_FALSE,
                                 CubitBoolean closest = CUBIT_FALSE );


  CubitStatus get_intersections( RefEdge* ref_edge, RefFace* ref_face,
                                 DLIList<CubitVector>& intersection_list,
                                 CubitBoolean bounded = CUBIT_FALSE );

  CubitStatus get_intersections( RefEdge* ref_edge, CubitPlane plane,
                                 DLIList<CubitVector>& intersection_list,
                                 CubitBoolean bounded = CUBIT_FALSE,
                                 double extended_percent = 0.0);



  CubitStatus entity_extrema( RefEntity *ref_entity_ptr,
                              const CubitVector *dir1,
                              const CubitVector *dir2,
                              const CubitVector *dir3,
                              CubitVector &extrema,
                              RefEntity *&extrema_entity_ptr );


  CubitStatus entity_extrema( DLIList<RefEntity*> &ref_entity_list,
                              const CubitVector *dir1,
                              const CubitVector *dir2,
                              const CubitVector *dir3,
                              CubitVector &extrema,
                              RefEntity *&extrema_entity_ptr );


  CubitStatus entity_entity_distance( GeometryEntity *ge1,
                                      GeometryEntity *ge2,
                                      CubitVector &pos1, CubitVector &pos2,
                                      double &distance );


  CubitStatus entity_entity_distance( RefEntity *ref_entity_ptr1,
                                      RefEntity *ref_entity_ptr2,
                                      CubitVector &pos1, CubitVector &pos2,
                                      double &distance );


  static void reset_geometry_factor();
  
  static void set_geometry_factor( double fac );

  static double get_geometry_factor();

  static void set_merge_test_bbox(CubitBoolean tof);

  static CubitBoolean get_merge_test_bbox();

  static void set_merge_test_internal(int tof);
  static int get_merge_test_internal();
  static void set_sliver_curve_cleanup_tolerance( double tol );
  static void set_sliver_surface_cleanup_tolerance( double tol );
  static double get_sliver_curve_cleanup_tolerance(); 
  static double get_sliver_surface_cleanup_tolerance(); 

  static void initialize_settings();

  static CubitStatus import_actuate( DLIList<RefEntity*> &entity_list );

  CubitBoolean same_query_engine(DLIList<TopologyEntity*> &topo_list) const;


  GeometryQueryEngine* common_query_engine(
    DLIList<TopologyEntity*>& topology_list,
    DLIList<TopologyBridge*>& engine_bridges,
    CubitBoolean allow_default_engine
    = CUBIT_FALSE ) const;

  CubitBoolean does_geom_contain_query_engine(DLIList<TopologyEntity*> &topo_list,
                                              GeometryQueryEngine *engine) const;

  CubitBoolean does_geom_contain_query_engine(DLIList<RefEntity*> &ref_entity_list,
                                              GeometryQueryEngine *engine,
                                              CubitBoolean children_too = CUBIT_FALSE) const;

  TopologyEntity* entity_from_bridge( TopologyBridge* bridge_ptr ) const;

  void add_gqe(GeometryQueryEngine *gqe_ptr);

  CubitStatus remove_gqe(GeometryQueryEngine *gqe_ptr);

  void get_gqe_list(DLIList<GeometryQueryEngine*> &gqe_list);

  GeometryQueryEngine *get_gqe();

  CubitStatus set_default_gqe(GeometryQueryEngine* gqe);

  bool contains_intermediate_geometry(RefEntity*) const;
  bool contains_intermediate_geometry(DLIList<RefEntity*>& ref_entitylist) const;
  bool is_intermediate_geometry(RefEntity*) const;
  bool is_intermediate_geometry(TopologyBridge*) const;

  CubitStatus destroy_dead_entity( TopologyEntity* topo_ent, bool top = true ) const;

  CubitStatus translate( DLIList<Body*> &bodies,
                         const CubitVector& delta,
                         DLIList<Body*> *bodies_translated = NULL,
                         bool check_to_transform = true,
                         bool preview = false );

  CubitStatus translate( DLIList<BasicTopologyEntity*> &btes,
                         const CubitVector& delta,
                         DLIList<BasicTopologyEntity*> *btes_translated = NULL,
                         bool check_to_transform = true,
                         bool preview = false );

  void translate( DLIList<RefEntity*> &entities_to_transform,
          double x, double y, double z,
          bool check_before_transforming,
          DLIList<RefEntity*> &entities_transformed,
          bool preview = false );

  CubitStatus rotate( DLIList<Body*> &bodies,
                      const CubitVector& axis,
                      double degrees,
                      DLIList<Body*> *bodies_rotated = NULL,
                      bool check_to_transform = true,
                      bool preview = false );

  CubitStatus rotate( DLIList<Body*> &bodies,
                      const CubitVector& point,
                      const CubitVector& normal,
                      double degrees,
                      DLIList<Body*> *bodies_rotated = NULL,
                      bool check_to_transform = true,
                      bool preview = false);

  CubitStatus rotate( DLIList<RefEntity*> &entities_to_transform,  
                      const CubitVector& point,
                      const CubitVector& normal,
                      double degrees,
                      bool check_to_transform, 
                      DLIList<RefEntity*> &entities_transformed,
                      bool preview = false);

  CubitStatus rotate( DLIList<BasicTopologyEntity*> &btes,
                      const CubitVector& axis, 
                      double degrees,
                      DLIList<BasicTopologyEntity*> *btes_rotated = NULL,
                      bool check_to_transform = true,
                      bool preview = false);

  CubitStatus rotate( DLIList<BasicTopologyEntity*> &btes,
                      const CubitVector& point,
                      const CubitVector& normal,
                      double degrees,
                      DLIList<BasicTopologyEntity*> *btes_rotated = NULL,
                      bool check_to_transform = true,
                      bool preview = false);

  CubitStatus scale( Body* entity,const CubitVector& point, double factor, bool check_to_transform = true, bool preview = false);

  CubitStatus scale( Body* entity,const CubitVector& point, const CubitVector& factors, bool check_to_transform = true, bool preview = false);

  CubitStatus scale( BasicTopologyEntity* entity,const CubitVector& point, double factor, bool check_to_transform = true, bool preview = false);

  CubitStatus scale( BasicTopologyEntity* entity,const CubitVector& point, const CubitVector& factors,bool check_to_transform = true,
                     bool preview = false);

  void scale( DLIList<RefEntity*> &entities_to_transform, 
              const CubitVector& point,
              double scale_x, double scale_y, double scale_z, 
              bool check_to_transform, 
              DLIList<RefEntity*> &entities_scaled,
              bool preview = false);

  CubitStatus reflect( DLIList<Body*> &bodies,
                       const CubitVector& point,
                       const CubitVector& axis,
                       DLIList<Body*> *bodies_reflected = NULL,
                       bool preview = false );

  CubitStatus reflect( DLIList<BasicTopologyEntity*> &btes,
                       const CubitVector& point,
                       const CubitVector& axis,
                       DLIList<BasicTopologyEntity*> *btes_reflected = NULL,
                       bool check_to_transform = true,
                       bool preview = false);

  void reflect( DLIList<RefEntity*> &entities_to_transform,
                            const CubitVector& point,
                            const CubitVector& axis,
                            bool check_before_transforming,
                            DLIList<RefEntity*> &entities_transformed,
                            bool preview = false);

  CubitStatus restore_transform( Body* body );


  CubitBoolean volumes_overlap( RefVolume *volume_1, RefVolume *volume_2);


  CubitBoolean bodies_overlap( Body *body_ptr_1, Body *body_ptr_2 );

  CubitStatus construct_refentities(DLIList<TopologyBridge*> &topology_bridges,
                                    DLIList<RefEntity*> *imported_entities = NULL);

  static CubitBoolean trackMergedAwayEnts;
  static CubitBoolean importingSolidModel;

  //Before calling import_solid_model, normally we want to clear out the 
  //map in CAUniqueId, but not when we are importing a cub file.
  static CubitBoolean clearUidMapBeforeImport; 

  //variable defining scope of merge...if true, 
  //merge entities you are importing with any entity (i.e.
  //entities already in the cubit session), otherwise 
  //only merge entities that are importing with other entities 
  //that are importing 
  static CubitBoolean mergeGloballyOnImport;

  static DLIList<int> uidsOfImportingEnts;
  static int entitiesMergedAway; 

  CGMHistory& history();

  CubitStatus get_graphics( Body *body, 
                            GMem *g_mem,
                            std::vector<RefFace*> &face_to_facet_vector,
                            std::vector<RefEntity*> &facet_point_ownership_vector,
                            std::vector<std::pair<RefEntity*, std::pair<int,int> > > &facetedges_on_refedges,
                            unsigned short normal_tolerance, 
                            double distance_tolerance, 
                            double max_edge_length );

  CubitStatus get_graphics( RefFace *ref_face,
                            GMem *gmem,
                            std::vector<RefEntity*> &facet_point_ownership_vector,
                            std::vector<std::pair< RefEntity*, std::pair<int,int> > > &facetedges_on_refedges,
                            unsigned short normal_tolerance = 15, 
                            double distance_tolerance = 0.0, 
                            double max_edge_length = 0.0 );

  CubitStatus get_point_containment( DLIList<Body*> &body_list,
                                     DLIList<CubitVector> &point_list,
                                     double tolerance,
                                     bool allow_pts_in_multiple_bodies,
                                     std::vector< std::pair<Body*, std::vector<int> > > &body_to_pt_indices );

protected :

  GeometryQueryTool(GeometryQueryEngine* GQEPtr);
private :

  CubitBoolean okay_to_transform( Body* body ) const;
  CubitBoolean okay_to_transform( BasicTopologyEntity* bte ) const;
  void notify_observers_of_transform(RefEntity* ref_entity,  const CubitTransformMatrix *transform = NULL ) const;
  void notify_observers_of_transform(DLIList<RefEntity*> &ref_ents,
                                     const CubitTransformMatrix *xform = NULL) const;

  CubitStatus notify_intermediate_of_transform( TopologyEntity* bte,
                                             const CubitTransformMatrix& xform
                                             ) const;

  Shell* make_Shell(ShellSM *shellsm_ptr, bool& shell_modified ) const;
  RefVolume* make_RefVolume( Lump* lump_ptr, bool& vol_modified ) const;

  CubitStatus make_merged_RefFace( Surface* surface_ptr ) const;
    // Helper function for make_RefFace(Surface*)
    // For a merged RefFace, check if the passed surface topology
    // is still compatible.  If so, remerge any unmerged child
    // entities and return CUBIT_SUCCESS.  If not, return CUBIT_FAILURE.

  RefEntity *check_mergeable_refentity(GeometryEntity *bridge) const;
    // check for mergeable ref entity, indicated by a merge attribute on the
    // bridge

  CoEdgeSM *find_merged_coedgesm( Surface* on_this_surface,
                                  CoEdgeSM* merged_with_this ) const;
    // check for mergeable sense entity, which is a child of the entity pointed
    // to by a merge attribute on bridge, which corresponds to re_ptr

  
  void get_merged_away_free_entities( DLIList<RefEntity*> &ref_ents,
                                      DLIList<TopologyBridge*> &free_ents );


  CubitStatus straightline_intersections( RefEdge* ref_edge1,
                                 CubitVector & origin2,
                                 CubitVector & dir2,
                                 DLIList<CubitVector>& intersection_list,
                                 CubitBoolean bounded = CUBIT_FALSE,
                                 CubitBoolean closest = CUBIT_FALSE);

  static GeometryQueryTool* instance_;

  static CubitBoolean useFacetBBox;

  DLIList<GeometryQueryEngine*> gqeList;

  struct IGEComp : public std::binary_function<IntermediateGeomEngine*,
                                              IntermediateGeomEngine*,
                                              bool> {
    bool operator() ( const IntermediateGeomEngine* ptr1,
                      const IntermediateGeomEngine* ptr2 ) const
      { return ptr1->level() < ptr2->level(); }
  };
  typedef std::set<IntermediateGeomEngine*,IGEComp> IGESet;
  IGESet igeSet;

  GeometryQueryEngine *default_gqe;

  static double curveSliverCleanUpTolerance;

  static double surfaceSliverCleanUpTolerance;

  static double geometryToleranceFactor;

  static CubitBoolean bboxMergeTest;

  static int internalSurfaceMergeTest; 

  int maxPersistentBodyId;
  int maxPersistentRefVolumeId;
  int maxPersistentRefGroupId;
  int maxPersistentRefFaceId;
  int maxPersistentRefEdgeId;
  int maxPersistentRefVertexId;

  CGMHistory mHistory;
};

inline void GeometryQueryTool::reset_geometry_factor()
{
  geometryToleranceFactor = DEFAULT_GEOM_FACTOR;
}

inline void GeometryQueryTool::set_geometry_factor( double factor )
{
  if ( factor < .0099999999999 )
    return;
  else
    geometryToleranceFactor = factor;
}
inline double GeometryQueryTool::get_geometry_factor()
{
  return geometryToleranceFactor;
}

inline void GeometryQueryTool::set_sliver_surface_cleanup_tolerance( double tol )
{
  surfaceSliverCleanUpTolerance = tol;
}

inline void GeometryQueryTool::set_sliver_curve_cleanup_tolerance( double tol )
{
  curveSliverCleanUpTolerance = tol;
}

inline double GeometryQueryTool::get_sliver_curve_cleanup_tolerance()
{
  return curveSliverCleanUpTolerance; 
}

inline double GeometryQueryTool::get_sliver_surface_cleanup_tolerance()
{
  return surfaceSliverCleanUpTolerance; 
}

inline CubitBoolean GeometryQueryTool::get_merge_test_bbox()
{return bboxMergeTest;}
inline int GeometryQueryTool::get_merge_test_internal()
{return internalSurfaceMergeTest;}
inline void GeometryQueryTool::set_merge_test_bbox(CubitBoolean tof)
{bboxMergeTest = tof;}
inline void GeometryQueryTool::set_merge_test_internal(int tof)
{internalSurfaceMergeTest = tof;}

inline void GeometryQueryTool::add_gqe(GeometryQueryEngine *gqe_ptr)
{
  assert(gqe_ptr != 0);
  if (!gqeList.move_to(gqe_ptr)) gqeList.append(gqe_ptr);
}
inline CubitStatus GeometryQueryTool::remove_gqe(GeometryQueryEngine *gqe_ptr)
{
  assert(gqe_ptr != 0);
  CubitStatus status = CUBIT_FAILURE;
  if (gqeList.move_to(gqe_ptr)) {
    gqeList.remove();
    status = CUBIT_SUCCESS;
  }
  return status;
}

inline void GeometryQueryTool::get_gqe_list(DLIList<GeometryQueryEngine*> &gqe_list)
{
  gqe_list += gqeList;
}
inline GeometryQueryEngine *GeometryQueryTool::get_gqe()
{
  GeometryQueryEngine *gqe = NULL;
  if (gqeList.size()) {
    gqeList.reset();
    gqe = gqeList.get();
  }
  return gqe;
}

#endif