Feature-Detection Primitives

Functions
float	comp_angle_defect (Vertex *v)
	Compute the angle defect of a vertex. More...
float	cos_face_angle (Halfedge *h, Halfedge *hopp)
	Compute the cosine of the face angle (dihedral angle) at an edge. More...
float	cos_edge_angle (const Halfedge *h1, const Halfedge *h2)
	Compute the cosine of the edge angle at a vertex between two incident feature edges. More...
float	cos_edge_angle (const Feature_1 &f1, Feature_1::const_iterator it, bool isloop)
	Compute the cosine of the edge angle at a vertex in a given feature curve. More...
bool	is_strong_ad (Vertex *v)
	Determine whether a vertex is strong (either theta-strong or relatively strong) in angle defect. More...
bool	is_rstrong_ea (const Feature_1 &f1, Feature_1::const_iterator hprev, Feature_1::const_iterator hnext, float cos_ea, bool isloop)
	Determine whether a vertex is relatively strong in edge angle within a give feature. More...
template<class T >
T	squares (const T &t)
void	init_feature_parameters ()
	Read in the control file for feature detection. More...

Detailed Description

Function Documentation

float comp_angle_defect ( Vertex *  v )

protected

Compute the angle defect of a vertex.

The angle defect at v is defined as:

1. the difference between 2*pi and the sum of its angles in incident faces if v is not a border vertex;
2. the difference between pi and the sum of its angles in incident faces if v is a border vertex. When the angle defect was computed for a vertex for the first time, it is saved, and subsequent calls for the same vertex will return saved value.

Definition at line 224 of file RFC_Window_overlay_fea.C.

References NTS::abs(), acc, cimg_library::acos(), d, RFC_Pane_overlay::get_angle_defect(), HDS_accessor< _MP >::get_halfedge(), HDS_accessor< _MP >::get_next(), HDS_accessor< _MP >::get_next_around_destination(), HDS_accessor< _MP >::get_pane(), HUGE_VALF, HDS_accessor< _MP >::is_border(), and pi.

                                                {
  const float pi = 3.1415926535;

  // Precondition: d was initialized to HUGE_VALF
  float &t=acc.get_pane(v)->get_angle_defect(v), d=t;
  if ( d < HUGE_VALF) return d;
  
  float angle_sum = 0.;

  Halfedge *h = acc.get_halfedge( v), *h0=h;
  bool is_border = false;
  do {
    if ( !acc.is_border(h))
      angle_sum += acos( -cos_edge_angle( h, acc.get_next(h)));
    else 
      is_border = true;
  } while ( (h=acc.get_next_around_destination( h)) != h0);

  return t = abs((2-is_border)*pi - angle_sum);
}

Here is the call graph for this function:

float cos_edge_angle ( const Halfedge *  h1, const Halfedge *  h2  )

protected

Compute the cosine of the edge angle at a vertex between two incident feature edges.

Definition at line 163 of file RFC_Window_overlay_fea.C.

References acc, d, HDS_accessor< _MP >::get_destination(), HDS_accessor< _MP >::get_origin(), get_tangent(), max(), min(), and sqrt().

                                                        {
  Vector_3 v1 = get_tangent( h1);
  Vector_3 v2 = get_tangent( h2);

  float d=std::max( -1., std::min( (v1*v2)/sqrt((v1*v1)*(v2*v2)), 1.));
  if ( acc.get_destination( h1) == acc.get_destination( h2) ||
       acc.get_origin( h1) == acc.get_origin( h2))
    return -d;
  else
    return d;
}

Here is the call graph for this function:

float cos_edge_angle ( const Feature_1 &  f1, Feature_1::const_iterator  it, bool  isloop  )

protected

Compute the cosine of the edge angle at a vertex in a given feature curve.

It saves the solution by associating it with the vertex. When the routine is invoked on the same vertex next time, it will return the saved value if the vertex is not at the end of the feature curve.

Definition at line 181 of file RFC_Window_overlay_fea.C.

References acc, RFC_Pane_overlay::get_cos_edge_angle(), HDS_accessor< _MP >::get_destination(), HDS_accessor< _MP >::get_origin(), HDS_accessor< _MP >::get_pane(), HUGE_VALF, and v.

{
  Vertex *v;
  if ( !isloop) {
    if (it==f1.begin()) {
      v=acc.get_origin( *it);
      acc.get_pane(v)->get_cos_edge_angle( v) = HUGE_VALF;
      return -1;
    }
    else if ( it==f1.end()) {
      v=acc.get_destination( f1.back());
      acc.get_pane(v)->get_cos_edge_angle( v) = HUGE_VALF;
      return -1.;
    }
  }

  if ( it==f1.begin() || it==f1.end()) {
    v = acc.get_origin(f1.front());
    float &t = acc.get_pane(v)->get_cos_edge_angle( v);
    if ( t == HUGE_VALF)
      t = cos_edge_angle( f1.front(), f1.back());
    return t;
  }
  else {
    v = acc.get_origin( *it);
    float &t = acc.get_pane(v)->get_cos_edge_angle( v);
    if ( t == HUGE_VALF) {
      Feature_1::const_iterator ip=it; --ip;
      t = cos_edge_angle( *it, *ip);
    }
    return t;
  }
}

Here is the call graph for this function:

float cos_face_angle ( Halfedge *  h, Halfedge *  hopp  )

protected

Compute the cosine of the face angle (dihedral angle) at an edge.

When the face angle was computed the first time, it is saved and subsequent calls for the same edge will simply return the stored value. The face angle is defined to be pi if the edge is on the border.

Definition at line 139 of file RFC_Window_overlay_fea.C.

References acc, RFC_Pane_overlay::get_cos_face_angle(), Overlay_primitives::get_face_normal(), HDS_accessor< _MP >::get_pane(), HUGE_VALF, HDS_accessor< _MP >::is_border(), min(), p1, and sqrt().

                                                               {
  // Precondition: Face angles are initialized to HUGE_VALF.
  RFC_Pane_overlay *p1=acc.get_pane(h);
  float &t = p1->get_cos_face_angle(h);
  if ( t<HUGE_VALF) return t;
  
  if ( acc.is_border( h) || acc.is_border( hopp) )
    t = -1;
  else {
    Overlay_primitives        op;
    Vector_3 v1 = op.get_face_normal( h, Point_2(0.5,0));
    Vector_3 v2 = op.get_face_normal( hopp, Point_2(0.5,0));
    
    t=std::min(v1 * v2 / sqrt( (v1*v1) * (v2*v2)),1.);
    RFC_Pane_overlay *p2=acc.get_pane(hopp);
    if ( p1 != p2) p2->get_cos_face_angle( hopp) = t;
  }
  return t;
}

Here is the call graph for this function:

void init_feature_parameters ( )

private

Read in the control file for feature detection.

The control file should be named as <window name>="">.fc. It should contain five lines. The first three lines correspond to the parameters for face angle, angle defect, and edge angle, respectively. The fourth line controls filteration rules, including the minimum edge length for open-ended 1-features, whether to apply long-falseness checking with strong endedness, and whether whether to snap the feature onto the reference mesh. The last line controls verbose level. A sample control file (default) is:

0.76604444 0.98480775 3 0.98480775 1.3962634 0.314159265 3 0.17364818 0.96592583 3 6 1 0 0 1

For RSRM dataset, use the following control files: 0.5 0.6 3 0.17365 # cos(face_angle_ub) cos(face_angle_lb) face_angle_r cos(weak_end) 1.39626 0.314159 3 # angle_defect_ub angle_defect_lb angle_defect_r 0 0.5 3 # cos(turn_angle_ub) cos(turn_angle_lb) turn_angle_r 6 1 1 0 # min-length-of-ridge long-falseness-rule strong-ended-check snapping 1 # verbose level

If the control file is missing, then the default values (above) will be used. These default values should work for most cases. For some extreme cases, adjusting the signal-to-noise ratios (the last parameters of the first three lines) and the minimum edge (line 4) should suffice.

Definition at line 81 of file RFC_Window_overlay_fea.C.

References cos, and RFC_assertion.

Referenced by RFC_Window_overlay::RFC_Window_overlay().

                                            {
  std::string fname = string(name())+".fc";
  std::ifstream f(fname.c_str());

  if ( f) {
    std::string buf;
    std::cout << "Reading in parameters from file " << fname 
              << "..." << std::flush;
    f >> _cos_uf >> _cos_lf >> _rf >> _cos_weakend; getline(f, buf);
    f >> _ud >> _ld >> _rd; getline(f, buf);
    f >> _cos_ue >> _cos_le >> _re; getline(f, buf);
    f >> _min_1f_len >> _long_falseness_check 
      >> _strong_ended >> _snap_on_features; getline(f, buf);
    f >> verb; getline(f, buf);

    RFC_assertion( _cos_uf>=0 && _cos_uf<=1 && _cos_lf<=1 && _cos_lf>=_cos_uf);
    RFC_assertion( _rf==0 || _rf >=1);
    RFC_assertion( _ud>=0 && _ud<=180/r2d && _ld>=0 && _ld <= _ud);
    RFC_assertion( _rd==0 || _rd>=1);
    RFC_assertion( _cos_ue>=0 && _cos_ue<=1 && _cos_le<=1 && _cos_le>=_cos_ue);
    RFC_assertion( _re==0 || _re >=1);
    RFC_assertion( _min_1f_len >=1);
    std::cout << "Done" << std::endl;
  }
  else {
    // Use default parameters and write the parameters into the file
    _cos_uf=cos(50/r2d); _cos_lf=cos(15/r2d); _rf=3;  _cos_weakend = _cos_lf;
    _ud=60/r2d;          _ld=18/r2d;          _rd=3;
    _cos_ue=cos(60/r2d); _cos_le=cos(30/r2d); _re=3;
    _min_1f_len=6; _long_falseness_check = true;
    _strong_ended = true; _snap_on_features = false;
    verb=1;
  }

  if ( verb) {
    std::cout << "Using the following threshold to detect features in "
              << name() << ":\n\n";
    
    std::cout << _cos_uf << ' ' << _cos_lf << ' ' << _rf << ' ' << _cos_weakend
              << " # cos(face_angle_ub) cos(face_angle_lb) face_angle_r cos(weak_end)" << std::endl
              << _ud << ' ' << _ld << ' ' << _rd
              << " # angle_defect_ub angle_defect_lb angle_defect_r" << std::endl
              << _cos_ue << ' ' << _cos_le << ' ' << _re
              << " # cos(turn_angle_ub) cos(turn_angle_lb) turn_angle_r" << std::endl
              << _min_1f_len << ' ' <<_long_falseness_check << ' '
              << _strong_ended << ' ' << _snap_on_features 
              << " # min-length-of-ridge long-falseness-rule "
              << " strong-ended-check snapping" << std::endl
              << verb << " # verbose level" << std::endl;
  }
}

Here is the caller graph for this function:

bool is_rstrong_ea ( const Feature_1 &  f1, Feature_1::const_iterator  hprev, Feature_1::const_iterator  hnext, float  cos_ea, bool  isloop  )

protected

Determine whether a vertex is relatively strong in edge angle within a give feature.

Definition at line 278 of file RFC_Window_overlay_fea.C.

References cimg_library::acos(), and min().

                                                              {
  if ( cos_ea > _cos_le) return false;
  float cos_max = std::min( cos_edge_angle( f1, hprev, isloop),
                            cos_edge_angle( f1, hnext, isloop));
  return acos(cos_ea) >= _re*acos(cos_max);
}

Here is the call graph for this function:

bool is_strong_ad ( Vertex *  v )

protected

Determine whether a vertex is strong (either theta-strong or relatively strong) in angle defect.

Definition at line 253 of file RFC_Window_overlay_fea.C.

References acc, d, HDS_accessor< _MP >::get_halfedge(), HDS_accessor< _MP >::get_next_around_destination(), HDS_accessor< _MP >::get_origin(), and max().

                                           {
  // Determine whether the edge is theta-strong
  float d = comp_angle_defect( v);
  if ( d >= _ud) { 
    return true;
  }
  else if ( d >= _ld) {
    float max_ad=0;
    Halfedge *h0 = acc.get_halfedge( v), *h1=h0;
    // Loop through incident edges of v
    do {
      float a = comp_angle_defect( acc.get_origin(h1));
      max_ad = std::max( max_ad, a);
    } while ( (h1=acc.get_next_around_destination(h1))!=h0);
    
    if ( d >= _rd*max_ad)
      return true;
  }
  return false;
}

Here is the call graph for this function:

T squares

(

const T &

t

)

Definition at line 246 of file RFC_Window_overlay_fea.C.

{ return t*t; }