GeometryHealerTool.hpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// Filename      : GeometryHealerTool.hpp
//
// Purpose       : Define the healer interface for all solid modeling engines.
//
// Special Notes : This is a singleton pattern class for the healer functions.
//
// Creator       : Tyronne Lim (CAT)
//
// Creation Date : 7/21/03
//
// Owner         : 
//-----------------------------------------------------------------------------

#ifndef _GEOMETRYHEALERTOOL_HPP
#define _GEOMETRYHEALERTOOL_HPP

// *** BEGIN INCLUDES *** //

#include "CubitDefines.h"
#include "DLIList.hpp"
#include "CGMGeomConfigure.h"

// *** END INCLUDES *** //

// *** BEGIN FORWARD DECLARATIONS *** //

class GeometryHealerEngine;

class TopologyBridge;
class TopologyEntity;

class RefEntity;
class RefFace;
class RefEdge;

class Body;
// *** END FORWARD DECLARATIONS *** //

class CUBIT_GEOM_EXPORT GeometryHealerTool
{
   public:

      // singleton pattern class instance interface
      static GeometryHealerTool* instance( GeometryHealerEngine* GHEPtr = NULL );

      static void delete_instance() 
      {
        if (instance_)
        {
          delete instance_;
          instance_ = NULL;
        }
      };

      // destructor
      ~GeometryHealerTool();

      // *** BEGIN ENGINE OPERATIONS *** //

      // set the default healer engine
//      void set_default_engine( GeometryHealerEngine *ghe_ptr );

      void add_ghe( GeometryHealerEngine *ghe_ptr );

      // remove a healer engine from the list
//      CubitStatus remove_ghe( GeometryHealerEngine *ghe_ptr );

      // get the list of healer engines
//      void get_ghe_list( DLIList<GeometryHealerEngine*> &ghe_list );

   private:
      // returns the healer engine of an entity
      GeometryHealerEngine* get_engine( TopologyBridge *tb_ptr ) const;
      GeometryHealerEngine* get_engine( TopologyEntity *te_ptr ) const;

      // determines if entities belong to the same engine
      CubitBoolean same_healer_engine( DLIList<RefEntity*> &ref_entity_list,
                                             CubitBoolean check_children ) const;
      CubitBoolean same_healer_engine( DLIList<TopologyEntity*> &topo_list ) const;

      // *** END ENGINE OPERATIONS *** //

      // *** BEGIN HEALER FUNCTIONS *** //
   public:
      CubitStatus auto_heal_bodies( DLIList<Body*> &body_list, 
                                    DLIList<Body*> &new_body_list,
                                    DLIList<TopologyEntity*> &bad_geometry,
                                    CubitBoolean rebuild = CUBIT_FALSE, 
                                    CubitBoolean keep_old = CUBIT_FALSE,
                                    CubitBoolean make_tolerant = CUBIT_FALSE,
                                    FILE* logfile_ptr = NULL );

      CubitStatus heal_bodies( DLIList<Body*> &body_list, 
                               DLIList<Body*> &new_body_list,
                               DLIList<TopologyEntity*> &bad_geometry,
                               CubitBoolean rebuild = CUBIT_FALSE,
                               CubitBoolean keep_old = CUBIT_FALSE,
                               CubitBoolean make_tolerant = CUBIT_FALSE,
                               FILE* logfile_ptr = NULL );

      CubitStatus analyze_badgeom( DLIList<Body*> &body_list, 
                                   DLIList<TopologyEntity*> &bad_geometry,
                                   FILE* logfile = NULL );

      CubitStatus get_badgeom( DLIList<Body*> &body_list, 
                               DLIList<TopologyEntity*> &bad_geometry );

      CubitStatus get_tcurves( DLIList<Body*> &body_list,
                               DLIList<RefEdge*> &t_curves );

      CubitStatus heal_incremental( DLIList<Body*> &body_list, 
                                    DLIList<Body*> &new_bodies,
                                    DLIList<TopologyEntity*> &bad_geometry,
                                    double simplify_tol = CUBIT_DBL_MAX,
                                    double stitch_min_tol = CUBIT_DBL_MAX,
                                    double stitch_max_tol = CUBIT_DBL_MAX,
                                    double geombuild_tol = CUBIT_DBL_MAX,
                                    double analytic_tol = CUBIT_DBL_MAX,
                                    double isospline_tol = CUBIT_DBL_MAX,
                                    double reblend_classify_tol = CUBIT_DBL_MAX,
                                    double reblend_tol = CUBIT_DBL_MAX,
                                    CubitBoolean keep_old = CUBIT_FALSE,
                                    CubitBoolean make_tolerant = CUBIT_FALSE,
                                    FILE* logfile_ptr = NULL);

      void list_incremental();

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






      double get_default_simplify_tol();
      void set_default_simplify_tol( double tol );
      double get_default_stitch_min_tol();
      void set_default_stitch_min_tol( double tol );
      double get_default_stitch_max_tol();
      void set_default_stitch_max_tol( double tol );
      double get_default_geombuild_tol();
      void set_default_geombuild_tol( double tol );
      double get_default_analytic_tol();
      void set_default_analytic_tol( double tol );
      double get_default_isospline_tol();
      void set_default_isospline_tol( double tol );
      double get_default_reblend_classify_tol();
      void set_default_reblend_classify_tol( double tol );
      double get_default_reblend_tol();
      void set_default_reblend_tol( double tol );
      void reset_default_tolerances();
      void list_default_tolerances();

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



      CubitBoolean get_cleanatt_flg();
      void set_cleanatt_flg( CubitBoolean flg );


      int get_show_method(); // 0-none, 1-highlight, 2-draw
      void set_show_method( int method );


      CubitBoolean get_show_summary_flg();
      void set_show_summary_flg( CubitBoolean flg );


      CubitBoolean get_show_details_flg();
      void set_show_details_flg( CubitBoolean flg );


      CubitBoolean get_show_on_heal_flg();
      void set_show_on_heal_flg( CubitBoolean flg );


      CubitBoolean get_check_vol_on_heal_flg();
      void set_check_vol_on_heal_flg( CubitBoolean flg );
      double get_vol_on_heal_limit();
      void set_vol_on_heal_limit( double limit );


      CubitBoolean get_check_surf_on_heal_flg();
      void set_check_surf_on_heal_flg( CubitBoolean flg );
      double get_surf_on_heal_limit();
      void set_surf_on_heal_limit( double limit );
      

      CubitBoolean get_check_curve_on_heal_flg();
      void set_check_curve_on_heal_flg( CubitBoolean flg );
      double get_curve_on_heal_limit();
      void set_curve_on_heal_limit( double limit );
      

      CubitBoolean get_show_bad_vertices_flg();
      void set_show_bad_vertices_flg( CubitBoolean flg );
      CubitBoolean get_show_bad_curves_flg();
      void set_show_bad_curves_flg( CubitBoolean flg );
      CubitBoolean get_show_bad_coedges_flg();
      void set_show_bad_coedges_flg( CubitBoolean flg );
      CubitBoolean get_show_bad_loops_flg();
      void set_show_bad_loops_flg( CubitBoolean flg );
      CubitBoolean get_show_bad_surfaces_flg();
      void set_show_bad_surfaces_flg( CubitBoolean flg );
      CubitBoolean get_show_bad_shells_flg();
      void set_show_bad_shells_flg( CubitBoolean flg );
      CubitBoolean get_show_bad_volumes_flg();
      void set_show_bad_volumes_flg( CubitBoolean flg );
      CubitBoolean get_show_bad_bodies_flg();
      void set_show_bad_bodies_flg( CubitBoolean flg );

      void list_onshow_flgs();
      
      // Functions for controlling incremental healing
      CubitBoolean get_inc_preprocess_flg();
      void set_inc_preprocess_flg( CubitBoolean flg );
      CubitBoolean get_inc_simplify_flg();
      void set_inc_simplify_flg( CubitBoolean flg );
      CubitBoolean get_inc_stitch_flg();
      void set_inc_stitch_flg( CubitBoolean flg );
      CubitBoolean get_inc_geombuild_flg();
      void set_inc_geombuild_flg( CubitBoolean flg );
      CubitBoolean get_inc_analytic_flg();
      void set_inc_analytic_flg( CubitBoolean flg );
      CubitBoolean get_inc_isospline_flg();
      void set_inc_isospline_flg( CubitBoolean flg );
      CubitBoolean get_inc_reblend_flg();
      void set_inc_reblend_flg( CubitBoolean flg );
      CubitBoolean get_inc_sharpedge_flg();
      void set_inc_sharpedge_flg( CubitBoolean flg );
      CubitBoolean get_inc_genericspline_flg();
      void set_inc_genericspline_flg( CubitBoolean flg );
      CubitBoolean get_inc_wrapup_flg();
      void set_inc_wrapup_flg( CubitBoolean flg );
      CubitBoolean get_inc_postprocess_flg();
      void set_inc_postprocess_flg( CubitBoolean flg );


      CubitStatus force_simplify_to_plane( DLIList<RefFace*> &ref_face_list, DLIList<Body*>& new_body_list, 
                                           CubitBoolean keep = CUBIT_FALSE );
      CubitStatus force_simplify_to_cylinder( DLIList<RefFace*> &ref_face_list, DLIList<Body*>& new_body_list, 
                                              CubitBoolean keep = CUBIT_FALSE );
      CubitStatus force_simplify_to_cone( DLIList<RefFace*> &ref_face_list, DLIList<Body*>& new_body_list, 
                                          CubitBoolean keep = CUBIT_FALSE );
      CubitStatus force_simplify_to_sphere( DLIList<RefFace*> &ref_face_list, DLIList<Body*>& new_body_list, 
                                            CubitBoolean keep = CUBIT_FALSE );
      CubitStatus force_simplify_to_torus( DLIList<RefFace*> &ref_face_list, DLIList<Body*>& new_body_list, 
                                           CubitBoolean keep = CUBIT_FALSE );

      // *** END HEALER FUNCTIONS *** //

   protected:

      // constructor
      GeometryHealerTool( GeometryHealerEngine *GHEPtr );

   private:

      // singleton pattern class instance interface
      static GeometryHealerTool* instance_;

      // list of healer engines
      DLIList<GeometryHealerEngine*> gheList;
};

#endif