C++ DLIList::next方法代码示例

void CubitUtil::list_entity_ids( const char *pre_string, 
                                 const DLIList<CubitEntity*> &entity_list, 
                                 int width, const char *post_string,
                                 int sort, int unique,
                                 int tab, const char *sep_string,
                                 const char *post_string_none )
{
  DLIList <int> id_list( entity_list.size() );
  for ( int i=0; i<entity_list.size(); i++ ) 
    id_list.append( entity_list.next(i)->id() );

  list_entity_ids( pre_string, id_list, width, post_string, sort,
                   unique, tab, sep_string, post_string_none );
}

CubitStatus LoopParamTool::check_selfintersecting_coincident_edges(DLIList<DLIList<CubitPoint *>*> 
                                                                   &loops_bounding_points)
{
    //This function checks each line segment against every other line segment
    //to see if they intersect or overlap.  Each line will be described
    //by the following equations:
    //
    // Pa = P1 + ua( P2 - P1 )
    // Pb = P3 + ub( P4 - P3 )
    //
    //Setting the Pa equal to Pb and solving for ua and ub you will get two
    //equation.  Both will have the common denominator:
    //
    // denom = ( (uv4.y() - uv3.y()) * (uv2.x() - uv1.x() ) -
    //         (uv4.x() - uv3.x()) * (uv2.y() - uv1.y() ) )
    //
    //And the numerators will be:
    //
    // numer_a = ( (uv4.x() - uv3.x()) * (uv1.y() - uv3.y() ) -
    //          (uv4.y() - uv3.y()) * (uv1.x() - uv3.x() ) )
    //      
    // numer_b = ( (uv2.x() - uv1.x()) * (uv1.y() - uv3.y() ) -
    //           (uv2.y() - uv1.y()) * (uv1.x() - uv3.x() ) )
    //
    //ua and ub then become:
    //
    // ua = numer_a / denom
    // ub = numer_b / denom
    //
    //If the lines are parallel then denom will be zero.  If they are
    //also coincedent then the numerators will also be zero.  For the
    //segments to intersect ua and ub need to both be between 0
    //and 1.
  
  int ii, jj, kk, ll;
  
  for ( ii = 0; ii < loops_bounding_points.size(); ii++ )
  {
    DLIList<CubitPoint*>* sub_loops_bounding_points1 = loops_bounding_points.next(ii);
    for( jj = 0; jj < sub_loops_bounding_points1->size(); jj++ )
    {
      CubitPoint* start_point1 = sub_loops_bounding_points1->next(jj);
      CubitPoint* end_point1 = NULL;
      if ( jj == sub_loops_bounding_points1->size()-1 )
         end_point1 = sub_loops_bounding_points1->next(0);
      else
         end_point1 = sub_loops_bounding_points1->next(jj+1);
      CubitVector uv1 = start_point1->coordinates();
      CubitVector uv2 = end_point1->coordinates();

        //Start with the current loop in the list.  The previous
        //lists have already been checked against this list.
      for ( kk = ii; kk < loops_bounding_points.size(); kk++ )
      {
        DLIList<CubitPoint*>* sub_loops_bounding_points2 = loops_bounding_points.next(kk);
        for ( ll = 0; ll < sub_loops_bounding_points2->size(); ll++ )
        {
          CubitPoint* start_point2 = sub_loops_bounding_points2->next(ll);
          CubitPoint* end_point2 = NULL;
          if ( ll == sub_loops_bounding_points2->size()-1 )
            end_point2 = sub_loops_bounding_points2->next(0);
          else
            end_point2 = sub_loops_bounding_points2->next(ll+1);
          CubitVector uv3 = start_point2->coordinates();
          CubitVector uv4 = end_point2->coordinates();

          if ( start_point1 == end_point2 || start_point1== start_point2 ||
               end_point1 == start_point2 || end_point1 == end_point2 )
            continue;
          
          if ( (uv1 == uv3) && (uv2 == uv4) )
            continue;
          
          double denom = ( (uv4.y() - uv3.y()) * (uv2.x() - uv1.x() ) -
                           (uv4.x() - uv3.x()) * (uv2.y() - uv1.y() ) );
          
          double numer_a = ( (uv4.x() - uv3.x()) * (uv1.y() - uv3.y() ) -
                             (uv4.y() - uv3.y()) * (uv1.x() - uv3.x() ) );
          
          double numer_b = ( (uv2.x() - uv1.x()) * (uv1.y() - uv3.y() ) -
                             (uv2.y() - uv1.y()) * (uv1.x() - uv3.x() ) );
          
          if( denom < CUBIT_RESABS && denom > -CUBIT_RESABS )
          {
              //The lines are parallel.  Check the numerators to
              //see if they are coincident.
            if( numer_a < CUBIT_RESABS && numer_a > -CUBIT_RESABS &&
                numer_b < CUBIT_RESABS && numer_b > -CUBIT_RESABS )
            {
                //The lines are coincident.  Now see if the segments
                //over lap.
              double ua;
              double ub;
              if( (uv2.x() - uv1.x()) < CUBIT_RESABS &&
                  (uv2.x() - uv1.x()) > -CUBIT_RESABS )
              {
		if( (uv2.y() - uv1.y() < CUBIT_RESABS &&
		     uv2.y() - uv1.y() > -CUBIT_RESABS)){
			PRINT_ERROR("Can't mesh due to zero-length edge.\n");
			return CUBIT_FAILURE;
//.........这里部分代码省略.........

CubitStatus Faceter::get_curve_facets( RefEdge* curve, DLIList<CubitPoint*>& segments ) const
{
//const double COS_ANGLE_TOL =  0.965925826289068312213715; // cos(15)
  const double COS_ANGLE_TOL =  0.984807753012208020315654; // cos(10)
//const double COS_ANGLE_TOL =  0.996194698091745545198705; // cos(5)
  GMem curve_graphics;
  const double dist_tol = GEOMETRY_RESABS;
  const double dist_tol_sqr = dist_tol*dist_tol;
  Curve* curve_ptr = curve->get_curve_ptr();
  curve_ptr->get_geometry_query_engine()->get_graphics( curve_ptr, &curve_graphics );
  
  GPoint* gp = curve_graphics.point_list();
  CubitPoint* last = (CubitPoint*) new FaceterPointData( gp->x, gp->y, gp->z );
  ((FaceterPointData*)last)->owner(dynamic_cast<RefEntity*>(curve));
  CubitVector lastv = last->coordinates();
  segments.append( last );
  GPoint* end = gp + curve_graphics.pointListCount - 1;
  
  for( gp++; gp < end; gp++ )
  {
    CubitVector pos(  gp->x, gp->y, gp->z );
    CubitVector step1 = (pos - lastv);
    double len1 = step1.length();
    if( len1 < dist_tol ) continue;
    
    GPoint* np = gp + 1;
    CubitVector next( np->x, np->y, np->z );
    CubitVector step2 = next - pos;
    double len2 = step2.length();
    if( len2 < dist_tol ) continue;
    
    double cosine = (step1 % step2) / (len1 * len2);
    if( cosine > COS_ANGLE_TOL ) continue;
    
    last = new FaceterPointData( pos );
    ((FaceterPointData*)last)->owner(dynamic_cast<RefEntity*>(curve));
    segments.append( last );
    lastv = last->coordinates();
  }
  
  CubitVector last_pos( gp->x, gp->y, gp->z );
  segments.last();
  while( (last_pos - (segments.get()->coordinates())).length_squared() < dist_tol_sqr )
  {
    delete segments.pop();
    segments.last();
  }
  CubitPoint *tmp_point = (CubitPoint*) new FaceterPointData( last_pos );
  segments.append( tmp_point );
  ((FaceterPointData*)tmp_point)->owner( dynamic_cast<RefEntity*>(curve) );
    
  // Now check if the segment list is reversed wrt the curve direction.
  segments.reset();
  double u1, u2;
  if( segments.size() > 2 )
  {
    u1 = curve->u_from_position( (segments.next(1)->coordinates()) );
    u2 = curve->u_from_position( (segments.next(2)->coordinates()) );    
  }
  else
  {
    u1 = curve->u_from_position( (segments.get()->coordinates() ) );
    u2 = curve->u_from_position( (segments.next()->coordinates()) );
  }
  if( (u2 < u1) && (curve->start_param() <= curve->end_param()) )
    segments.reverse();

    //Make sure we don't have duplicate points.
  int jj;
  CubitVector curr, prev;
  for ( jj = segments.size(); jj > 0; jj-- )
  {
    prev = segments.prev()->coordinates();
    curr = segments.get_and_step()->coordinates();
    if ( prev.about_equal(curr) )
    {
      PRINT_DEBUG_129("Points on curve %d within tolerance...\n", curve->id());
      segments.back();
      delete segments.remove();
    }
  }
  return CUBIT_SUCCESS;
}

CubitStatus LoopParamTool::transform_loopspoints_to_uv( DLIList<DLIList<CubitPoint *>*> &loops_point_list)
                                                         
{
  int ii, jj;
  CubitStatus ret_value = CUBIT_SUCCESS;
  DLIList<CubitPoint *> *sub_loops_point_list;
  CubitPoint *point_ptr;
  CubitVector xyz_location, uv_location, point_coordinates;
  
    // transform the points on the best fit plane
  ret_value = transform_to_bestfit_plane( loops_point_list);
  
    /*printf("\n after transform to best fit plane\n");
      for( ii = 0; ii < loops_point_list.size(); ii++)
      {
      sub_loops_point_list = loops_point_list.get_and_step();
      for ( jj = 0; jj < sub_loops_point_list->size(); jj++)
      {
      point_ptr = sub_loops_point_list->get_and_step();
      point_coordinates = point_ptr->coordinates();
      printf(" %f %f %f \n",point_coordinates.x(),point_coordinates.y(),point_coordinates.z());
      }
      }*/

    //transform to u-v
  for ( ii = 0; ii < loops_point_list.size(); ii++)
  {
    sub_loops_point_list = loops_point_list.get_and_step();
	  
    for ( jj = 0; jj < sub_loops_point_list->size(); jj++ )
    {
      point_ptr = sub_loops_point_list->get_and_step();
      xyz_location = point_ptr->coordinates();
      ret_value = transform_to_uv_local( xyz_location, uv_location );
      point_ptr->set(uv_location);
		  
    } 
  }

  if ( check_selfintersecting_coincident_edges(loops_point_list) != CUBIT_SUCCESS )
  {
    //PRINT_ERROR("Self interesections in parameter space found.\n");
    ret_value = CUBIT_FAILURE;
  }
  else
    ret_value = CUBIT_SUCCESS;
  
 
    // if the self-intersecting and coincident edges are not there then return CUBIT_SUCCESS
    // else restore the points to their original positions and return CUBIT_FAILURE
  return ret_value;
    //don't do the rest for now...
  if ( ret_value == CUBIT_SUCCESS )
    return CUBIT_SUCCESS;
  else
  {
    ToolData *td;
    for ( ii = 0; ii < loops_point_list.size(); ii++ )
    {
      sub_loops_point_list = loops_point_list.next(ii);
      for ( jj = 0; jj < sub_loops_point_list->size(); jj++)
      {
        point_ptr = sub_loops_point_list->next(jj);
        td = point_ptr->get_TD(&TDVector::is_td_vector);
        TDVector *td_pos = CAST_TO(td, TDVector);
        CubitVector orig_xyz_location = td_pos->get_vector();
        point_ptr->set(orig_xyz_location);
        point_coordinates = point_ptr->coordinates();
      }
    }
    return CUBIT_FAILURE;
  }
}