LCOV - code coverage report
Current view: top level - geom/virtual/cgm - PartitionCurve.hpp (source / functions) Hit Total Coverage
Test: coverage_sk.info Lines: 0 13 0.0 %
Date: 2020-06-30 00:58:45 Functions: 0 7 0.0 %
Branches: 0 12 0.0 %

           Branch data     Line data    Source code
       1                 :            : //-------------------------------------------------------------------------
       2                 :            : // Filename      : PartitionCurve-new.hpp
       3                 :            : //
       4                 :            : // Purpose       : 
       5                 :            : //
       6                 :            : // Special Notes : 
       7                 :            : //
       8                 :            : // Creator       : Jason Kraftcheck
       9                 :            : //
      10                 :            : // Creation Date : 04/10/02
      11                 :            : //-------------------------------------------------------------------------
      12                 :            : #ifndef PARTITION_CURVE_HPP
      13                 :            : #define PARTITION_CURVE_HPP
      14                 :            : 
      15                 :            : #include "Curve.hpp"
      16                 :            : #include "PartitionPoint.hpp"
      17                 :            : #include "PartitionCoEdge.hpp"
      18                 :            : 
      19                 :            : class PartitionPoint;
      20                 :            : class PartitionSurface;
      21                 :            : class GMem;
      22                 :            : class CubitFacetEdgeData;
      23                 :            : 
      24                 :            : class PartitionCurve : public Curve, public PartitionEntity
      25                 :            : {
      26                 :            : 
      27                 :            : public:
      28                 :            : 
      29                 :            :   virtual PartitionCurve* split( double param ) = 0;
      30                 :            :   
      31                 :            :   virtual CubitStatus combine( PartitionCurve* dead_curve ) = 0;
      32                 :            : 
      33                 :            :   virtual ~PartitionCurve();
      34                 :            : 
      35                 :          0 :   PartitionPoint* start_point() const
      36                 :          0 :     { return startPoint; }
      37                 :            :   
      38                 :          0 :   PartitionPoint* end_point() const
      39                 :          0 :     { return endPoint; }
      40                 :            :   
      41                 :          0 :   PartitionPoint* other_point( const PartitionPoint* pt ) const
      42 [ #  # ][ #  # ]:          0 :     { return pt == startPoint ? endPoint : pt == endPoint ? startPoint : 0; }
      43                 :            :     
      44                 :            :   int num_coedges() const;
      45                 :            :   
      46                 :          0 :   PartitionCoEdge* next_coedge( const PartitionCoEdge* prev = 0 ) const
      47 [ #  # ][ #  # ]:          0 :     { return !prev ? firstCoEdge : prev->myCurve == this ? prev->curveNext : 0; }
      48                 :            :   
      49                 :            :   CubitStatus add( PartitionCoEdge* coedge );
      50                 :            :   CubitStatus remove( PartitionCoEdge* coedge );
      51                 :            :   void remove_all_coedges();
      52                 :            :   
      53                 :            :   CubitStatus start_point( PartitionPoint* point );
      54                 :            :   CubitStatus end_point  ( PartitionPoint* point );
      55                 :            :   
      56                 :            :   virtual CubitStatus get_graphics( GMem& result,
      57                 :            :                                     double angle_tolerance=0,
      58                 :            :                                     double distance_tolerance=0,
      59                 :            :                                     double max_edge_length=0) = 0; 
      60                 :            :   
      61                 :          0 :   PartitionCurve* next_curve( const PartitionPoint* about_this ) const
      62                 :          0 :     { return about_this == startPoint ? startNext :
      63 [ #  # ][ #  # ]:          0 :              about_this ==   endPoint ?   endNext : 0; }
      64                 :            :   
      65                 :            :   bool is_nonmanifold( const PartitionSurface* in_this_surf ) const;
      66                 :            :   bool is_in_surface( const PartitionSurface* surf, 
      67                 :            :                       bool manifold_only = false ) const;
      68                 :            :   
      69                 :            :   CubitStatus move_to_geometry( CubitVector& position );
      70                 :            :   CubitStatus move_to_geometry( CubitPoint* facetPoint );
      71                 :            :   
      72                 :            :   void append_simple_attribute_virt( const CubitSimpleAttrib& );
      73                 :            :   void remove_simple_attribute_virt( const CubitSimpleAttrib& );
      74                 :            :   void remove_all_simple_attribute_virt();
      75                 :            :   CubitStatus get_simple_attribute( DLIList<CubitSimpleAttrib>& );
      76                 :            :   CubitStatus get_simple_attribute( const CubitString& name,
      77                 :            :                                     DLIList<CubitSimpleAttrib>& );
      78                 :            : 
      79                 :            :   void get_parents_virt( DLIList<TopologyBridge*>& );
      80                 :            :   void get_children_virt( DLIList<TopologyBridge*>& );
      81                 :          0 :   int layer() const { return sub_entity_set().get_owner_layer(); }
      82                 :            :   GeometryQueryEngine* get_geometry_query_engine() const;
      83                 :            : 
      84                 :            :                 
      85                 :            :   virtual void print_debug_info( const char* prefix = 0,
      86                 :            :                                  bool print_subentity_set = true ) const;
      87                 :            :   
      88                 :            : 
      89                 :            :   void get_facet_data( DLIList<CubitFacetEdgeData*>& result_list ) const;
      90                 :            :   void set_facet_data( const DLIList<CubitFacetEdgeData*>& new_list );
      91                 :          0 :   bool has_facet_data() const { return facetEdges.size() > 0; }
      92                 :            :   void remove_facet_data();
      93                 :            :   void replace_facet(CubitFacetEdgeData* dead_facet,
      94                 :            :                      DLIList<CubitFacetEdgeData*> &new_facets);
      95                 :            :   virtual void notify_split( FacetEntity* old_entity, FacetEntity* new_entity );
      96                 :            :   CubitStatus fix_facet_data( PartitionCurve* new_curve );
      97                 :            :   void remove_dead_facet( CubitFacetEdgeData* edge );
      98                 :            :     //- update facet data for curve partition operation
      99                 :            :     //- must be called after end points have been updated.
     100                 :            :     
     101                 :            :   void do_facet_cleanup();
     102                 :            :     //- remove small edges, etc.
     103                 :            :  
     104                 :            :   void draw_facets(int color);
     105                 :            :   
     106                 :            :   virtual void transform( const CubitTransformMatrix& );
     107                 :            : 
     108                 :            : protected:
     109                 :            : 
     110                 :            :   PartitionCurve( );
     111                 :            :   
     112                 :            :   CubitStatus get_save_topology( DLIList<int>& points );
     113                 :            :   
     114                 :            :   void reverse_point_order();
     115                 :            : 
     116                 :            : private:
     117                 :            : 
     118                 :            :   DLIList<CubitFacetEdgeData*> facetEdges;
     119                 :            : 
     120                 :            :   CubitStatus remove_start_point();
     121                 :            :   CubitStatus remove_end_point();
     122                 :            :   CubitStatus remove_from_point( PartitionPoint* point, PartitionCurve* next );
     123                 :            : 
     124                 :            :   PartitionCoEdge* firstCoEdge;
     125                 :            :   
     126                 :            :   PartitionPoint *startPoint, *endPoint;
     127                 :            :   PartitionCurve *startNext, *endNext;
     128                 :            : };
     129                 :            : 
     130                 :            : #endif
     131                 :            : 
     132                 :            :   
     133                 :            :   

Generated by: LCOV version 1.11