Manipulation of Strong Curves

Functions
bool	check_false_strong_1 (Feature_1 &)
	Determine whether a curve is false strong. More...
void	subdiv_feature_curve (const Feature_1 &f1, Feature_list_1 &new_flist, int &dropped)
	Subdivide a feature curve by splitting it at 0-features. More...
void	merge_features_1 (Vertex *v, Feature_1 &f1, Feature_1 &f2)
	Merge two feature curves into one at vertex v. More...
void	remove_feature_1 (Feature_1 &f)
	Remove a false strong curve. More...

Detailed Description

Function Documentation

bool check_false_strong_1 ( Feature_1 &  f1 )

protected

Determine whether a curve is false strong.

Definition at line 330 of file RFC_Window_overlay_fea.C.

References acc, HDS_accessor< _MP >::get_destination(), HDS_accessor< _MP >::get_halfedge(), HDS_accessor< _MP >::get_next_around_destination(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_origin(), HDS_accessor< _MP >::get_pane(), RFC_Pane_overlay::unset_strong_edge(), and v.

                                                       {
  if ( cos_face_angle( f1.front(),NULL)==-1) return false;

  Vertex *src = acc.get_origin(f1.front());
  Vertex *dst = acc.get_destination( f1.back());

  // is a loop or strong at both ends
  if ( src == dst || is_on_feature( src) && is_on_feature( dst)
       && (!_f0_ranks.empty() || is_feature_0(src) || is_feature_0(dst)) || 
       cos_face_angle(f1.front(),NULL)<0 && cos_face_angle(f1.back(),NULL)<0)
    return false;

  // Is it weak ended? If so, pop out the weak edges
  if ( _strong_ended) {
    if ( !f1.empty())  for (;;) {
      Halfedge *h=f1.front(), *hopp=acc.get_opposite(h);

      if ( is_on_feature( src) || cos_face_angle( h, hopp) <= _cos_uf || is_strong_ad( src))
        break;
      else {
        acc.get_pane(h)->unset_strong_edge(h);
        acc.get_pane( hopp)->unset_strong_edge( hopp);
        f1.pop_front();
      }
      if ( !f1.empty()) 
        src = acc.get_origin( f1.front());
      else
        return true;
    }

    if ( !f1.empty())  for (;;) {
      Halfedge *h=f1.back();
      Halfedge *hopp=acc.get_opposite(h);

      if ( is_on_feature( dst) || cos_face_angle( h, hopp) <= _cos_uf 
           || is_strong_ad( src))
        break;
      else {
        acc.get_pane(h)->unset_strong_edge(h);
        acc.get_pane( hopp)->unset_strong_edge( hopp);
        f1.pop_back();
      }
      if ( !f1.empty()) 
        dst = acc.get_destination( f1.back());
      else
        return true;
    }
  }

  // is it too short?
  if ( _min_1f_len) {
    int c = !(is_strong_ad( src) || is_feature_0( src)) + 
            !(is_strong_ad( dst) || is_feature_0( dst));
    if ( int(f1.size()) <= c*_min_1f_len)
      return true;
  }

  // is it too close to another features?
  if ( _long_falseness_check) {
    if ( _f_list_1.empty() || 
         (is_strong_ad( src) || is_feature_0( src)) &&
         (is_strong_ad( dst) || is_feature_0( dst)))
      return false;
    for ( Feature_1::const_iterator it=++f1.begin(); it!=f1.end(); ++it) {
      Vertex *v = acc.get_origin( *it);
      Halfedge *h0 = acc.get_halfedge( v), *h1=h0;
      // Loop through incident edges of v
      do {
        if ( is_on_feature( acc.get_origin( h1))) { v=NULL; break; }
      } while ( (h1=acc.get_next_around_destination(h1))!=h0);
      if (v==NULL) continue;
      else return false;
    }
    return true;
  }
  return false;
}

Here is the call graph for this function:

void merge_features_1 ( Vertex *  v, Feature_1 &  f1, Feature_1 &  f2  )

protected

Merge two feature curves into one at vertex v.

After the operation, f1 becomes the union of f1 and f2, and f2 becomes empty.

Definition at line 297 of file RFC_Window_overlay_fea.C.

References acc, HDS_accessor< _MP >::get_destination(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_origin(), and RFC_assertion.

                                                                            {
  RFC_assertion( !f1.empty() && f1!=f2);
  if ( f2.empty()) return;

  Vertex *dst, *src;
  
  if ( (dst=acc.get_destination( f1.back())) == 
       acc.get_origin( f2.front()) && v==dst)
    f1.splice( f1.end(), f2);
  else if ( (src=acc.get_origin( f1.front())) == 
            acc.get_destination( f2.back()) && v==src) {
    f2.splice( f2.end(), f1);
    f1.swap( f2);
  }
  else if ( dst == acc.get_destination( f2.back()) && v==dst) {
    while ( !f2.empty()) {
      f1.push_back( acc.get_opposite( f2.back()));
      f2.pop_back();
    }
  }
  else {
    RFC_assertion( src == acc.get_origin( f2.front()) && v==src);
    while ( !f2.empty()) {
      f1.push_front( acc.get_opposite( f2.front()));
      f2.pop_front();
    }
  }
  RFC_assertion( f2.empty());
}

Here is the call graph for this function:

void remove_feature_1

(

Feature_1 &

f

)

Remove a false strong curve.

Definition at line 527 of file RFC_Window_overlay_fea.C.

References RFC_Pane_overlay::_f_n_index, acc, RFC_Pane_overlay::get_index(), HDS_accessor< _MP >::get_next_around_destination(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_pane(), iend, k, and RFC_assertion.

                                                  {
  
  for ( Feature_1::iterator it=f.begin(), iend=f.end(); it != iend; ++it) {
    unset_strong_edge( *it);  unset_strong_edge( acc.get_opposite( *it));
  }

  for ( Feature_1::iterator it=f.begin(), iend=f.end(); it != iend; ++it) {
    Halfedge *k = *it, *kopp = acc.get_opposite( k);
    RFC_assertion( !acc.get_pane(k)->_f_n_index.empty());
    do {
      Halfedge *h0 = k, *h = h0;
      do {
        RFC_assertion( !is_feature_1( h));
        RFC_Pane_overlay &pane = *acc.get_pane( h);
        pane._f_n_index[ pane.get_index( h)] = -1;
      } while ( (h=acc.get_next_around_destination(h)) != h0);
    } while ( (k=(k==kopp)?*it:kopp) != *it);
  }
}

Here is the call graph for this function:

void subdiv_feature_curve ( const Feature_1 &  f1, Feature_list_1 &  new_flist, int &  dropped  )

protected

Subdivide a feature curve by splitting it at 0-features.

Some false strong edges may be filtered out during this step.

Definition at line 412 of file RFC_Window_overlay_fea.C.

References acc, d, HDS_accessor< _MP >::get_destination(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_origin(), HDS_accessor< _MP >::get_pane(), i, max(), min(), RFC_assertion, RFC_Pane_overlay::unset_strong_edge(), and v.

                                                               {
  
  // We loop through all vertices in the curve to locate the 0-features
  list< Feature_1::const_iterator>  divs;
  Vertex *src = acc.get_origin(f1.front());
  Vertex *trg = acc.get_destination( f1.back());
  bool isloop = (src==trg);

  // A 1-feature is dangling if one of its end point is a terminus
  bool isdangling = !isloop && 
    (_f0_ranks.find( src) == _f0_ranks.end() || 
     _f0_ranks.find( trg) == _f0_ranks.end());

  float cos_min_fa_before=1, cos_min_fa_after=1;
  Feature_1::const_iterator f1end = f1.end(), hfirst = f1end, hlast=f1end;

  for (Feature_1::const_iterator hprev=f1.begin(),hi=++f1.begin(),hnext=hi;
       hi!=f1end; hprev=hi,hi=hnext) {
    ++hnext;
    Vertex *v = acc.get_origin(*hi);
    if ( is_feature_0( v)) { RFC_assertion( hi==f1.begin()); continue; }

    float cos_ea = cos_edge_angle( f1, hi, isloop);
    if ( cos_ea <= _cos_ue || 
         is_rstrong_ea( f1, hprev, hnext, cos_ea, isloop)) { 
      divs.push_back( hi); 
      // When breaking loops, mark breakpoints as corners
      set_feature_0( acc.get_origin( *hi));
    }
    else if ( isdangling) {
      // Mark transitions between strong and week edges for danging 1-features
      // as 0-feature
      float dpre = cos_face_angle( *hprev, acc.get_opposite( *hprev));
      float d = cos_face_angle( *hi, acc.get_opposite( *hi));

      if ( hfirst == f1end && dpre < cos_min_fa_before)
        cos_min_fa_before = dpre;

      if ( std::min( dpre,d) <= _cos_weakend && 
           std::max( dpre,d) > _cos_weakend ) {
        if ( hfirst == f1end) hfirst = hi;
        hlast = hi; cos_min_fa_after = 1.;
      }

      if ( d < cos_min_fa_before) cos_min_fa_after = d;
    }
  }

  if ( isdangling && divs.empty() ) {
    if ( hfirst!=f1end && cos_min_fa_before>_cos_weakend &&
         _f0_ranks.find( src) == _f0_ranks.end() ) 
    { divs.push_back( hfirst); set_feature_0( acc.get_origin( *hfirst)); }

    if ( hlast!=f1end && hlast!=hfirst && cos_min_fa_after>_cos_weakend &&
         _f0_ranks.find( trg) == _f0_ranks.end()) 
    { divs.push_back( hlast); set_feature_0( acc.get_origin( *hlast)); }
  }

  if ( isloop) {
    // Finally, we process end vertices
    Feature_1::const_iterator hi = f1.begin();
    float cos_ea = cos_edge_angle( f1, hi, isloop);
    if ( cos_ea <= _cos_ue || 
         is_rstrong_ea( f1,f1end,++f1.begin(),cos_ea,isloop)) {
      // When breaking loops, mark breakpoints as corners
      divs.push_back( f1end); set_feature_0( acc.get_origin( *hi));
    }
  }
  else
    divs.push_back( f1end);
  
  // Now subdivide the curve into sub-curves
  Feature_list_1   subcur;
  if ( divs.size()==0)
    subcur.push_back( f1);
  else {
    subcur.push_back( Feature_1( f1.begin(),divs.front()));
    list< Feature_1::const_iterator>::const_iterator dit=divs.begin();
    for ( list< Feature_1::const_iterator>::const_iterator 
            dinext=dit; ++dinext != divs.end(); dit=dinext)
      subcur.push_back( Feature_1( *dit, *dinext));
    
    if ( isloop) {
      Feature_1 &newf=subcur.front();
      newf.insert( newf.begin(), *dit, f1end);
    }
  }
  
  // Check the sub-curves to filter out false-strongness.
  for (Feature_list_1::iterator sit=subcur.begin();sit!=subcur.end();++sit) {
    if ( check_false_strong_1( *sit)) {
      for ( Feature_1::const_iterator i=sit->begin(); i!=sit->end(); ++i) {
        acc.get_pane(*i)->unset_strong_edge(*i); ++dropped;
        Halfedge *hopp=acc.get_opposite(*i);
        acc.get_pane( hopp)->unset_strong_edge( hopp);
      }
    }
    else {
      // Set all vertices on-feature
      set_on_feature( acc.get_origin( sit->front()));
      for ( Feature_1::const_iterator i=sit->begin(); i!=sit->end(); ++i)
        set_on_feature( acc.get_destination( *i));
      
      Vertex *src = acc.get_origin(sit->front());
      Vertex *dst = acc.get_destination(sit->back());
      
      if ( src!=dst) {  set_feature_0( src); set_feature_0( dst); }
      new_flist.push_back( Feature_1()); new_flist.back().swap(*sit);
    }
  }
}

Here is the call graph for this function: