Classes
class	RFC_Window_overlay::Feature_0

struct	RFC_Window_overlay::Feature_1

Typedefs
typedef std::list< Feature_0 >	Feature_list_0

typedef std::list< Feature_1 >	Feature_list_1

Functions
void	detect_features ()
	The main entry of feature detection. More...

bool	snap_on_features () const

Feature_list_0 &	flist_0 ()

Feature_list_1 &	flist_1 ()

const Feature_list_0 &	flist_0 () const

const Feature_list_1 &	flist_1 () const

Detailed Description

Typedef Documentation

typedef std::list< Feature_0> Feature_list_0

Definition at line 394 of file RFC_Window_overlay.h.

typedef std::list< Feature_1> Feature_list_1

Definition at line 395 of file RFC_Window_overlay.h.

Function Documentation

void detect_features ( )

The main entry of feature detection.

Definition at line 728 of file RFC_Window_overlay_fea.C.

References RFC_Pane_overlay::_ad_0, RFC_Pane_overlay::_ea_0, RFC_Pane_overlay::_fd_1, RFC_Pane_overlay::_hds, RFC_Pane_overlay::_is_f_0, RFC_Pane_overlay::_is_f_1, RFC_Pane_overlay::_is_on_f, acc, cimg_library::acos(), cos, d, for(), free_vector(), HDS_accessor< _MP >::get_destination(), HDS_accessor< _MP >::get_next_around_origin(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_origin(), HDS_accessor< _MP >::get_pane(), get_tangent(), get_wtime(), RFC_Pane_overlay::hds(), HUGE_VALF, i, RFC_Pane_base::id(), iend, RFC_Pane_overlay::init_angle_defect(), RFC_Pane_overlay::init_edge_angle(), RFC_Pane_overlay::init_face_angle(), HDS_accessor< _MP >::mark(), HDS_accessor< _MP >::marked(), max(), min(), Vertex_overlay::point(), s, RFC_Pane_overlay::set_strong_edge(), and sqrt().

Referenced by Overlay::overlay().

                                     {
   int size_edges=0, dropped=0;
 
   // Initializing data arrays.
   Pane_set::iterator it=_pane_set.begin(), iend=_pane_set.end();
   for ( ; it != iend; ++it) {
     RFC_Pane_overlay &pane = (RFC_Pane_overlay &)*it->second;
     int num_hedgs=pane._hds.size_of_halfedges();
     int num_verts=pane._hds.size_of_vertices();
     size_edges+=num_hedgs/2;
 
     pane.init_face_angle(); pane.init_angle_defect(); pane.init_edge_angle();
     pane._is_f_1.clear(); pane._is_f_1.resize( num_hedgs, false);
     pane._is_f_0.clear(); pane._is_f_0.resize( num_verts, false);
     pane._is_on_f.clear(); pane._is_on_f.resize( num_verts, false);
   }
   std::vector< pair<float, Halfedge*> > tstrong_edges, rstrong_edges;   
   tstrong_edges.reserve(size_edges/10);
   rstrong_edges.reserve(size_edges/10);
 
   float t0=get_wtime(), totaltime=0; 
   // loop through all panes and primary halfedges in each pane
   for ( it=_pane_set.begin(); it != iend; ++it) {
     RFC_Pane_overlay &pane = (RFC_Pane_overlay &)*it->second;
     
     // Detect theta-strong edges
     for ( RFC_Pane_overlay::HDS::Halfedge_iterator 
             hit=pane.hds().halfedges_begin(), hend=pane.hds().halfedges_end(); 
           hit!=hend; ++ ++hit) {
       Halfedge *h = &*hit, *hopp = acc.get_opposite(h);
       if ( pane.id() <= acc.get_pane(hopp)->id()) {
         // Determine whether the edge is theta-strong
         float d = cos_face_angle( h, hopp);
         
         if ( d < _cos_uf) tstrong_edges.push_back( make_pair(d,h));
       }
     }
   }
   float t1=get_wtime(); totaltime+=t1-t0;
   if ( verb >= 3) {
     std::cout << "\tIdentified " << tstrong_edges.size() 
               << " theta-strong edges with Theta=" << acos( _cos_uf)*r2d
               << " in " << t1-t0 << " sec." << std::endl;
     t0=get_wtime(); 
   }
 
   sort(tstrong_edges.begin(),tstrong_edges.end());
   t1=get_wtime();  totaltime+=t1-t0;
   if ( verb >= 3) {
     std::cout << "\tSorted theta-strong edges in " 
               << t1-t0 << " sec." << std::endl;
   }
   
   vector<std::pair<float,Halfedge*> > iedges; iedges.reserve(16);
   _f_list_1.clear();
 
   // Sort the strong edges into strong curves
   unmark_alledges(); 
   float min_fa_r=HUGE_VALF;
   t0=get_wtime(); 
   for ( vector< pair<float,Halfedge*> >::iterator
           it=tstrong_edges.begin(),iend=tstrong_edges.end(); it!=iend; ++it){
     Halfedge *h=it->second;
     if ( acc.marked( h)) continue;
     Halfedge *hopp=acc.get_opposite( h);
 
     // Create a new list
     Feature_1 f1;
     f1.push_back( h);
 
     // Mark the edge and its opposite
     acc.get_pane(h)->set_strong_edge(h);  acc.mark( h); 
     acc.get_pane(hopp)->set_strong_edge(hopp); acc.mark( hopp);
 
     Vertex *src=acc.get_origin( f1.front());
     Vertex *dst=acc.get_destination(f1.back());
 
     // Traverse forwards and backwards along the curve, and append an 
     // r-strong edge to the curve until we reach a non-strong curve.
     for (int c=0; c<2; ++c) {
       for (;;) {
         Halfedge *h = ((c==0)?f1.back():f1.front());
         if ( src == dst || c==0&&is_on_feature(dst) || c&&is_on_feature(src))
           break;
         
         // Get the unmarked 1-feature with mimimum angle
         iedges.clear();
         Halfedge *h0=acc.get_opposite(h);
         float d0=cos_face_angle( h, h0);
         pair<float, Halfedge*> t0(d0,(c==0)?h0:h);
         pair<float, Halfedge*> cos_max(HUGE_VALF,NULL);
         
         Halfedge *h1=acc.get_next_around_origin(t0.second);
         do {
           Halfedge *h1o=acc.get_opposite(h1);
           float d = cos_face_angle(h1, h1o);
           pair<float, Halfedge*> t(d,h1);
           iedges.push_back( t);
 
           if ( t < cos_max) cos_max = t;
         } while ( (h1=acc.get_next_around_origin(h1)) != t0.second);
 
         bool is_strong=true;
         const Vector_3 v1=get_tangent( t0.second);
         if ( cos_max.first>_cos_uf && iedges.size()>1) {
           for ( int i=0,s=iedges.size(); i<s; ++i) {
             const Vector_3 v2=get_tangent( iedges[i].second);
             const Real t = std::max(-v1*v2/sqrt((v1*v1)*(v2*v2)),0.);
             iedges[i].first = acos(iedges[i].first)*t;
           }
           sort(iedges.rbegin(),iedges.rend());
           cos_max = iedges[0];
           if ( cos(cos_max.first)>_cos_lf) break;
 
           is_strong = cos_max.first >= iedges[1].first*_rf ||
             is_on_feature( acc.get_destination(cos_max.second)) ||
             is_strong_ad( acc.get_destination(cos_max.second));
           min_fa_r=std::min(min_fa_r,cos_max.first/iedges[1].first);
         }
         const Vector_3 v2=get_tangent( cos_max.second);
         float a = -v1*v2/sqrt((v1*v1)*(v2*v2));
         if ( a<_cos_ue || a<cos_face_angle(cos_max.second,NULL)) break;
         
         rstrong_edges.push_back(make_pair(cos_face_angle(cos_max.second,0),
                                           cos_max.second));
         
         h = cos_max.second;
         if ( acc.marked( h)) break;
         Halfedge *hopp = acc.get_opposite( h);
 
         acc.mark( h);    acc.get_pane(h)->set_strong_edge( h);
         acc.mark( hopp); acc.get_pane(hopp)->set_strong_edge( hopp);
         if (c==0) {
           f1.push_back( h); 
           dst = acc.get_destination( h); 
         }
         else {
           f1.push_front( hopp);
           src = acc.get_origin( hopp);
         }
         if ( !is_strong) break;
       }
     }
 
     Feature_list_1 flist;
     subdiv_feature_curve( f1, flist, dropped);
     _f_list_1.splice( _f_list_1.end(), flist);
   }
 
   t1=get_wtime();  totaltime+=t1-t0;
   if ( verb >= 3) {
     std::cout << "\tIdentified " << rstrong_edges.size()
               << " r-strong edges with r=" << _rf 
               << " in " << t1-t0 << " sec." << std::endl;
     sort(rstrong_edges.begin(), rstrong_edges.end());
     dump_strong_edges( tstrong_edges, rstrong_edges);
     t0=get_wtime();
   }
 
   identify_features_0();
 
   totaltime+=t1-t0;
   if ( verb >= 1) {
     std::cout << "\tFound " << _f_list_1.size() << " ridges and " 
               << _f_list_0.size() << " corners and dropped "
               << dropped << " false-strong edges.\n"
               << "\tDone in " << totaltime << " sec." << std::endl;
 #ifndef DEBUG
     if ( verb >= 2)
 #endif
       print_features();
   }
   
   // Compute the bounding boxes of the 1-features
   for ( Feature_list_1::iterator it=_f_list_1.begin();
         it != _f_list_1.end(); ++it) {
     it->bbox += Bbox_3(acc.get_origin( it->front())->point());
     for (Feature_1::iterator hi=it->begin(), hiend=it->end(); hi!=hiend; ++hi){
       it->bbox += Bbox_3(acc.get_destination( *hi)->point());
     }
   }
 
   // Finalization
   unmark_alledges();
 
   free_vector( tstrong_edges); rstrong_edges.clear();
   for ( it=_pane_set.begin(); it != _pane_set.end(); ++it) {
     RFC_Pane_overlay &pane = (RFC_Pane_overlay &)*it->second;
 
     free_vector( pane._fd_1);
     free_vector( pane._ad_0);
     free_vector( pane._ea_0);
   }
 }