cgma
Loop Class Reference

#include <Loop.hpp>

Inheritance diagram for Loop:
GroupingEntity TopologyEntity

List of all members.

Public Member Functions

 Loop ()
 Loop (LoopSM *OSMEPtr)
DagType dag_type () const
LoopType loop_type () const
CubitStatus get_angle_metric (double &angle_metric)
CubitStatus ordered_ref_edges (DLIList< RefEdge * > &ordered_edge_list)
CubitStatus ordered_co_edges (DLIList< CoEdge * > &ordered_coedge_list)
RefFaceget_ref_face_ptr ()
CoEdgeget_co_edge_ptr (RefEdge *ref_edge_ptr)
CubitBox bounding_box ()
CubitStatus tangents (RefVertex *vertex_ptr, CubitVector &first_vector, CubitVector &second_vector)
CubitBoolean validate ()
LoopSMget_loop_sm_ptr () const
CubitBoolean about_spatially_equal (DLIList< CoEdge * > &other_loop_coedges, CubitSense relative_sense, double tolerance_factor=1.0, CubitBoolean notify_refEntity=CUBIT_FALSE)

Private Member Functions

 Loop (const Loop &)
void operator= (const Loop &)

Detailed Description

Definition at line 37 of file Loop.hpp.


Constructor & Destructor Documentation

Definition at line 67 of file Loop.cpp.

{
}
Loop::Loop ( LoopSM OSMEPtr)

Definition at line 81 of file Loop.cpp.

{
   set_topology_bridge(OSMEPtr) ;
}
Loop::Loop ( const Loop ) [private]

Member Function Documentation

CubitBoolean Loop::about_spatially_equal ( DLIList< CoEdge * > &  other_loop_coedges,
CubitSense  relative_sense,
double  tolerance_factor = 1.0,
CubitBoolean  notify_refEntity = CUBIT_FALSE 
)

Definition at line 302 of file Loop.cpp.

{
  DLIList<CoEdge*> this_coedges(other_coedges.size());
  
    // Loops must have same number of coedges to match.
  this->ordered_co_edges( this_coedges );
  if (this_coedges.size() != other_coedges.size())
    return CUBIT_FALSE;
  
    // Want to compare coedges in order, so make sure we have
    // them in the correct order.
  if (relative_sense == CUBIT_REVERSED)
    this_coedges.reverse();
  
    // Try to match all coedges.  Begin with the first coedge
    // in this loop.  For each coedge in the other loop that 
    // it matches, check if all the other coedges match in the
    // correct order.
  int other_loop_index = 0;
  this_coedges.reset();
  other_coedges.reset();
  CoEdge* this_coedge = this_coedges.get_and_step();
  for (int i = other_coedges.size(); i--; )
  {
      // Loop until we find a matching CoEdge
    CoEdge* other_coedge = other_coedges.get_and_step();
    if (!this_coedge->about_spatially_equal( other_coedge,
                                             relative_sense,
                                             tolerance_factor,
                                             notify_refEntity ))
      continue;
    
      // Found a matching coedge.  Now try to match all the
      // others in the correct order.
    bool match = true;
    other_loop_index = other_coedges.get_index();
    for (int j = other_coedges.size() - 1; j-- && match; )
    {
      this_coedge = this_coedges.get_and_step();
      other_coedge = other_coedges.get_and_step();
      match = this_coedge->about_spatially_equal( other_coedge,
                                                  relative_sense,
                                                  tolerance_factor,
                                                  notify_refEntity );
    }
    
      // Matched all coedges, in order.  Done.
    if (match)
      return CUBIT_TRUE;
    
     // Try again, as perhaps the first coedge of this loop
     // also matches some other one in the second loop and
     // if we start with that one, the remaining coedges will
     // also match.
    this_coedges.reset();
    this_coedge = this_coedges.get_and_step();
    other_coedges.reset();
    other_coedges.step( other_loop_index );
  }
  
    // If here, loops didn't match.
  return CUBIT_FALSE;
}
DagType Loop::dag_type ( ) const [inline, virtual]

Implements TopologyEntity.

Definition at line 47 of file Loop.hpp.

{ return DagType::loop_type(); }
CubitStatus Loop::get_angle_metric ( double &  angle_metric)

Definition at line 107 of file Loop.cpp.

{
    // If the OSME knows its angle metric (some modelers cache
    // some data along these lines), return that value
  LoopSM* loop_sm = get_loop_sm_ptr();
  if (loop_sm && loop_sm->get_angle_metric(angle_metric))
    return CUBIT_SUCCESS;
  
    // First, get the list of coedges
  DLIList<CoEdge*> coedges;
  ordered_co_edges(coedges); 
  
    // Now build a polygon approximation of the curves in the loop.
    // The polygon is a straight-line approximation to and is
    // topologically equivalent to the loop. At any given point,
    // the polygon may be far from the actual loop, however.
    //  - samitch
  
    // If there are no coedges, this is an empty loop
  if (coedges.size() == 0)
  {
    angle_metric = 0;
    return CUBIT_FAILURE;
  }

  //catch hardpoint case
  if( coedges.size() == 1 && coedges[0]->ref_edge()->geometry_type() == POINT_CURVE_TYPE )
  {
    angle_metric = 2.0;
    return CUBIT_SUCCESS;  
  }
  
    // Loop through each coedge
  int i, j;
  DLIList<CubitVector*> polygon_points;
  DLIList<CubitVector*> interior_points;
  CoEdge* cur_coedge = NULL;
  coedges.reset();
  for (i = coedges.size(); i--; )
  {
      // Get the first point on this curve
    cur_coedge = coedges.get_and_step();
    RefEdge* cur_refedge = cur_coedge->get_ref_edge_ptr();
    polygon_points.append(new CubitVector
                          (cur_coedge->get_sense() == CUBIT_FORWARD ?
                           cur_refedge->start_vertex()->coordinates() :
                           cur_refedge->end_vertex()->coordinates()));
    
      // Get the interior points for approximation
    CubitSense return_sense = cur_coedge->get_sense();
    interior_points.clean_out();
    cur_refedge->get_interior_extrema(interior_points, return_sense);
      // Now put the points into the polygon.
      // We don't need to re-allocate any CubitVectors because we are just
      // copying pointers to dynamically allocated CubitVectors.
    if (cur_coedge->get_sense() == return_sense)
    {
      interior_points.reset();
      for (j = interior_points.size(); j--; )
        polygon_points.append(interior_points.get_and_step());
    }
    else
    {
      interior_points.last();
      for (j = interior_points.size(); j--; )
        polygon_points.append(interior_points.get_and_back());
    }
  }
  
    // Now that we have all of the points, compute and sum up
    // the internal angles on the polygon approximation.
  double angle, angle_sum = 0;
  RefFace* surface = cur_coedge->get_ref_face();
  CubitVector *point[3], t[2], normal;
  point[0] = polygon_points.get_and_step();
  point[1] = polygon_points.get_and_step();
  t[0] = *point[1] - *point[0];
  for (i = polygon_points.size(); i--; )
  {
      // Determine proper internal surface angle at point[1]
    point[2] = polygon_points.get_and_step();
    normal = surface->normal_at(*point[1]);
    t[1] = *point[1] - *point[2] ;
    angle = normal.vector_angle(t[1], t[0]);
    
      // Add up the total
    angle_sum += angle;
    
      // Iterate
    point[1] = point[2];
    t[0] = -t[1];
  }
  angle_metric = angle_sum / CUBIT_PI - polygon_points.size();
  
    // Clean up dynamically allocated vectors
  for (i = polygon_points.size(); i>0; i--) 
    delete polygon_points.get_and_step();
  
  return CUBIT_SUCCESS;
}
CoEdge* Loop::get_co_edge_ptr ( RefEdge ref_edge_ptr)

Definition at line 288 of file Loop.cpp.

{
  return dynamic_cast<LoopSM*>(bridge_manager()->topology_bridge());
}

Definition at line 274 of file Loop.cpp.

Definition at line 86 of file Loop.cpp.

{
    LoopSM* loop_sm = get_loop_sm_ptr();
    if (loop_sm)
    {
        return loop_sm->loop_type();
    }
    assert(0);
    return LOOP_TYPE_UNKNOWN;
}
void Loop::operator= ( const Loop ) [private]
CubitStatus Loop::ordered_co_edges ( DLIList< CoEdge * > &  ordered_coedge_list)

Definition at line 250 of file Loop.cpp.

{
  CubitStatus status = CUBIT_SUCCESS;
  
  DLIList<SenseEntity*> sense_entity_list;
  
  status = this->get_sense_entity_list(sense_entity_list);
  if ( status == CUBIT_FAILURE )
  {
    PRINT_ERROR("In Loop::ordered_co_edges\n"
                "       Problem getting the CoEdges of this Loop.\n");
    return CUBIT_FAILURE;
  }
  
    // Cast the SenseEntity list to a CoEdge list
  DLIList<CoEdge*> co_edge_list(sense_entity_list.size());
  CAST_LIST( sense_entity_list, co_edge_list , CoEdge);
  
  ordered_coedge_list += co_edge_list;
  return CUBIT_SUCCESS;
}
CubitStatus Loop::ordered_ref_edges ( DLIList< RefEdge * > &  ordered_edge_list)

Definition at line 217 of file Loop.cpp.

{
  CubitStatus status = CUBIT_SUCCESS;

  DLIList<SenseEntity*> sense_entity_list;

  status = this->get_sense_entity_list(sense_entity_list);
  if ( status == CUBIT_FAILURE )
  {
    PRINT_ERROR("In Loop::ordered_ref_edges\n");
    PRINT_ERROR("       Problem getting the CoEdges of this Loop.\n");
    return CUBIT_FAILURE;
  }
  
    //Get the ref_edges associated with each co_edge.
  for ( int ii = sense_entity_list.size(); ii > 0; ii-- )
  {
    SenseEntity* se_ptr = sense_entity_list.get_and_step();
    BasicTopologyEntity* bte_ptr = se_ptr->get_basic_topology_entity_ptr();
    ordered_edge_list.append( dynamic_cast<RefEdge*>(bte_ptr) );
  }

  return CUBIT_SUCCESS;
}
CubitStatus Loop::tangents ( RefVertex vertex_ptr,
CubitVector first_vector,
CubitVector second_vector 
)

The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines