PartitionEngine.hpp

Go to the documentation of this file.

//-------------------------------------------------------------------------
// Filename      : PartitionEngine.hpp
//
// Purpose       : 
//
// Special Notes : 
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 04/23/02
//-------------------------------------------------------------------------

#ifndef PARTITION_ENGINE_HPP
#define PARTITION_ENGINE_HPP

#include "CubitDefines.h"
#include "VGDefines.h"
#include <map>
#include "IntermediateGeomEngine.hpp"
#include "DLIList.hpp"

class TopologyBridge;
class TBPoint;
class Curve;
class Surface;
class Lump;
class LoopSM;
class BodySM;

class SubSurface;
class SubCurve;
class SegmentedCurve;

class PartitionEntity;
class PartitionBody;
class PartitionLump;
class PartitionShell;
class PartitionCoSurf;
class PartitionSurface;
class PartitionCurve;
class PartitionPoint;
class PartitionLoop;
class PartitionCoEdge;
class PartPTCurve;

class PST_Point;
class SubEntitySet;
class FacetProjectTool;
class CubitSimpleAttrib;

class CubitPoint;
class CubitFacet;
class CubitPointData;
class CubitFacetData;
class CubitFacetEdgeData;
class Body;

class CubitVector;
class CubitTransformMatrix;
template <class X> class DLIList;

class PartitionEngine : public IntermediateGeomEngine
{

public:
  bool is_partition(TBOwner *bridge_owner);
  bool is_composite(TBOwner *bridge_owner);
  bool is_composite(TopologyBridge *bridge);
  virtual void remove_imprint_attributes_after_modify
                                ( DLIList<BodySM*> &old_sms,
                                DLIList<BodySM*> &new_sms ){};
  virtual void push_imprint_attributes_before_modify
                     ( DLIList<BodySM*> &body_sms ){};
  virtual void push_named_attributes_to_curves_and_points
                     ( DLIList<TopologyBridge*> &tb_list, const char *name_in ){};
  virtual void attribute_after_imprinting(DLIList<TopologyBridge*> &tb_list,
                                          DLIList<Body*> &old_bodies){};
  virtual void remove_attributes_from_unmodifed_virtual(DLIList<TopologyBridge*> &bridges){};



  virtual ~PartitionEngine();

  static PartitionEngine& instance();
  static void delete_instance();

  int level() const { return SUBCOMP_PARTITION_LAYER; }

  void notify_deactivated (PartitionBody* body);
  void notify_deactivated( PartitionLump* vol);
  void notify_deactivated (PartitionSurface* surface);
  void notify_deactivated (PartitionCurve* curve);
  void notify_deactivated (PartitionPoint* point);
  void add_to_deactivated_list(PartitionBody* body);
  void add_to_deactivated_list(PartitionLump* vol);
  void add_to_deactivated_list(PartitionSurface* sur);
  void add_to_deactivated_list(PartitionCurve* cur);
  void add_to_deactivated_list(PartitionPoint* pt);
  CubitStatus import_geometry( DLIList<TopologyBridge*>& imported_geometry );

  CubitStatus export_geometry( DLIList<TopologyBridge*>& geometry_to_save );

  TBPoint* insert_point( Curve* curve, double u );
  
  Curve* remove_point( PartitionPoint* point, 
                       PartitionCurve* dead_curves[2] = 0 );
  
  Surface* insert_curve( Surface* surface, 
                         DLIList<CubitVector*>& segment_points,
                         DLIList<Curve*>& new_curves,
                         const double *tolerance_length = NULL);
  
  CubitStatus insert_curve( DLIList<Surface*>& surfaces,
                            DLIList<CubitVector*>& polyline,
                            DLIList<Surface*>& new_surfaces,
                            DLIList<Curve*>& polyline_curves,
                            const double *tolerance_length = NULL,
                            DLIList<Surface*>* surfs_to_reverse = NULL);
  
  TBPoint* insert_point_curve( Surface* surf,
                             const CubitVector& position,
                             Surface *&partitioned_surf );

  Lump* insert_surface( Surface* surf_to_copy, Lump* lump );
  
  Surface* insert_surface( DLIList<CubitFacet*>& facets, Lump* lump );
  
  
  Surface* remove_curve( PartitionCurve* curve,
                         PartitionSurface* dead_surfs[2] = 0 );         
  
  Lump* remove_surface( PartitionSurface* surface );

  int layer() { return SUBCOMP_PARTITION_LAYER; }
  
  //static void destroy_facet( CubitFacetData* facet );
  
  CubitStatus add_to_id_map( SubEntitySet* set, int unique_id );

  CubitStatus remove_from_id_map( SubEntitySet* set, int unique_id );

  SubEntitySet* get_from_id_map( int unique_id );

  PartitionEntity* entity_from_id( int set_id, int geom_id, 
                                   SubEntitySet& default_set );
  
  
  CubitStatus destroy_surface( PartitionSurface* surface );
  
  CubitStatus destroy_lump( PartitionLump* lump );

  static void delete_facet( CubitFacet* );

  CubitStatus delete_solid_model_entities( PartitionBody* body,
                                           BodySM*& real_body );
  CubitStatus delete_solid_model_entities( PartitionSurface* surface,
                                           Surface*& real_surface );
  CubitStatus delete_solid_model_entities( PartitionCurve* curve,
                                           Curve*& real_curve );

  static void curves_from_surfaces( const DLIList<PartitionSurface*>& input_surfs,
                                    DLIList<PartitionCurve*>& output_curves );

  void clean_out_deactivated_geometry();
  
  CubitStatus translate( PartitionBody* ent, const CubitVector& delta );
  CubitStatus rotate( PartitionBody* ent, const CubitVector& axis, double degrees );
  CubitStatus scale( PartitionBody* ent, const CubitVector& factors );
  CubitStatus reflect( PartitionBody* ent, const CubitVector& axis );
  CubitStatus restore_transform( PartitionBody* ent );
  
  CubitStatus translate( PartitionEntity* ent, const CubitVector& delta );
  CubitStatus rotate( PartitionEntity* ent, const CubitVector& axis, double degrees );
  CubitStatus scale( PartitionEntity* ent, const CubitVector& factors );
  CubitStatus reflect( PartitionEntity* ent, const CubitVector& axis );

  CubitStatus notify_transform( TopologyBridge* bridge,
                                const CubitTransformMatrix& xform );
   
  void remove_attributes( DLIList<TopologyBridge*> &bridge_list );
    //remove Composite attributes off of topology bridges
  virtual void remove_modified(DLIList<Surface*> &all_surfs,
    DLIList<Curve*> &all_curves, DLIList<TBPoint*> &all_pts);
    
  void get_tbs_with_bridge_manager_as_owner( TopologyBridge *source_bridge, 
                                               DLIList<TopologyBridge*> &tbs );
private:

  CubitStatus notify_transform_internal( TopologyBridge* bridge,
                                const CubitTransformMatrix& xform );

  PartitionEngine();

  friend class PartitionLumpImprint;

  CubitStatus find_coedges( PartitionSurface* surface,
                            PartitionCurve* curve,
                            PartitionPoint* point,
                            PartitionCoEdge*& previous,
                            PartitionCoEdge*& next );
  
  PartitionCurve* next_curve_around_point( PartitionSurface *const surface,
                                           CubitFacetEdgeData *const edge,
                                           CubitPointData *const point,
                                           const bool backwards );
  

  CubitStatus remove_point_curve( PartitionPoint* point );
  
  PartitionPoint* insert_point_curve( PartitionSurface* surface,
                                      CubitPointData* point );
  CubitStatus insert_point_curve( PartitionSurface* surface,
                                  PartPTCurve* curve,
                                  bool update_topology = true );
                                  
  
  PartitionCurve* insert_point( PartitionCurve* curve, PartitionPoint* point );
  
  CubitStatus insert_curve( DLIList<PartitionSurface*>& surfaces,
                            DLIList<CubitVector*>& polyline,
                            DLIList<PartitionSurface*>& new_surfaces,
                            DLIList<PartitionCurve*>& polyline_curves,
                            const double *tolerance_length = NULL);

  PartitionSurface* insert_curve( PartitionSurface* surface, 
                                  SegmentedCurve* curve );
  
  SegmentedCurve* insert_curve( DLIList<CubitFacetEdgeData*>& facet_edges,
                                DLIList<CubitVector*>* curve_segments = 0 );
  
  CubitPointData* project_to_surface( PartitionSurface* surface,
                                      const CubitVector& position );
  
  CubitStatus project_to_surface( DLIList<CubitFacetData*>& facets,
                                  DLIList<CubitVector*>& polyline_in,
                                  DLIList<CubitFacetEdgeData*>& polyline_out,
                                  DLIList<CubitPointData*>& polyline_pts,
                                  const double *tolerance_length = NULL);
  
  PartitionLump* insert_surface( PartitionLump* lump, PartitionSurface* surf );
  
  
  PartitionBody* make_body( PartitionPoint* pt );
  PartitionBody* make_body( PartitionCurve* curve );
  PartitionBody* make_body( PartitionSurface* surf );
  PartitionBody* make_body( PartitionLump* lump );
  PartitionBody* make_body_internal( TopologyBridge* child_ptr );

  PartitionLump* replace_lump( Lump* lump );
  Lump* restore_lump( PartitionLump* lump );
  CubitStatus destroy_shell( PartitionShell* shell );


public: /* temporarily public for debugging */
  SubSurface* replace_surface( Surface* surface );
private:
  Surface* restore_surface( SubSurface* surface );

  SubCurve* replace_curve( Curve* curve );
  Curve* restore_curve( SubCurve* curve );
  
  PartitionPoint* replace_point( TBPoint* point );
  TBPoint* restore_point( PartitionPoint* point );
  
  PartitionSurface* split_surface( PartitionSurface* surface, 
                                   PartitionCoEdge* new_curve );
  
  PartitionLump* split_lump( PartitionShell* shell );
  
  PartitionShell* split_shell( PartitionShell* shell );
  
  void insert_nonmanifold_surfaces( DLIList<PartitionSurface*>& surfaces,
                             PartitionShell* shell1, PartitionShell* shell2);
  
  CubitStatus inside_shell( PartitionShell* const shell, 
                            PartitionSurface* const surf, 
                            bool& result );
  
  CubitStatus save_curves( SubEntitySet* curve_set );
  CubitStatus save_surfaces( SubEntitySet* surface_set );
  CubitStatus save_lumps( SubEntitySet* lump_set );
  
  CubitStatus restore_from_attrib( Curve* partitioned_curve );
  CubitStatus restore_from_attrib( Surface* partitioned_surface );
  CubitStatus restore_from_attrib( Lump* partitioned_lump );
  
  static PartitionEngine* instance_;

  std::map<int,SubEntitySet*> uniqueIdMap;

  DLIList<TopologyBridge*> deactivatedList;
};

#endif