Normal and Tangent Computation

Functions
void	evaluate_normals ()
void	reduce_coordinates_to_all ()
void	print_features ()
	Dump out the 0- and 1-features in Tecplot format into files <name>f0.plt, <name>f1.plt, respectively. More...
void	reduce_normals_to_all (MPI_Op)
Vector_3	get_tangent (const Halfedge *h)

Detailed Description

Function Documentation

void evaluate_normals

(

)

Definition at line 208 of file RFC_Window_overlay.C.

References RFC_Window_overlay::_f_list_0, RFC_Window_overlay::_f_list_1, RFC_Pane_overlay::_f_n_index, RFC_Pane_overlay::_f_nrmls, RFC_Pane_overlay::_f_t_index, RFC_Pane_overlay::_f_tngts, RFC_Pane_overlay::_nrmls, RFC_Window_base::_pane_set, RFC_Window_overlay::acc, RFC_Pane_overlay::add_tangent(), Halfedge_overlay::destination(), free_vector(), HDS_accessor< _MP >::get_destination(), Overlay_primitives::get_face_normal(), HDS_accessor< _MP >::get_halfedge(), RFC_Pane_overlay::get_index(), HDS_accessor< _MP >::get_next_around_destination(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_pane(), RFC_Pane_overlay::hds(), i, iend, if(), Halfedge_overlay::is_border(), RFC_Window_overlay::is_feature_0(), RFC_Window_overlay::is_feature_1(), RFC_Pane_base::is_master(), j, k, MPI_SUM, RFC_Window_overlay::normalize(), RFC_Window_derived< RFC_Pane_overlay >::pane(), Vertex_overlay::point(), RFC_Window_overlay::reduce_normals_to_all(), RFC_assertion, scheme, swap(), and v.

Referenced by Overlay::overlay().

                                     {
  // First, evaluate normals for each pane
  Pane_set::iterator it, iend=_pane_set.end();
  for ( it=_pane_set.begin() ; it != iend; ++it) {
    if ( it->second->is_master())
      ((RFC_Pane_overlay*)it->second)->evaluate_normals();
  }

  // Second, perform reduction over all vertices
  reduce_normals_to_all( MPI_SUM);

  // Evaluate the one-sided normals for the halfedge edges incident 
  // on the features.
  for ( it=_pane_set.begin() ; it != iend; ++it) {
    RFC_Pane_overlay &pane = (RFC_Pane_overlay &)*it->second;
    free_vector( pane._f_nrmls); free_vector( pane._f_tngts);
    free_vector( pane._f_n_index); free_vector( pane._f_t_index);

    pane._f_n_index.resize( pane.hds().size_of_halfedges(), -1);
    pane._f_t_index.resize( pane.hds().size_of_halfedges(), -1);
  }

  Overlay_primitives      op;
  Point_2  one(1,0);
  // Loop throught the sharp halfedges in 1-features
  for ( Feature_list_1::iterator it = _f_list_1.begin(), iend=_f_list_1.end();
        it != iend; ++it) {
    for ( Feature_1::iterator j=it->begin(); j!=it->end(); ++j) {
      Halfedge *k = *j, *kopp=acc.get_opposite(k);
      do {
        if (!k->is_border() && acc.get_pane(k)->
            _f_n_index[acc.get_pane(k)->get_index(k)] == -1) {
          // First, compute the vector
          Vector_3 v = op.get_face_normal( k, one, scheme);
          Halfedge *h0 = k, *h = acc.get_next_around_destination(k);
          do {
            if ( is_feature_1( h)) break;
            RFC_assertion( !h->is_border());
            v += op.get_face_normal( h, one, scheme);
          } while ( (h=acc.get_next_around_destination(h)) != h0);

          // Second, insert the vector into the table
          normalize(v);
          swap( h, h0);
          do {
            RFC_Pane_overlay &pane = *acc.get_pane( h);
            if ( pane._f_nrmls.size() && v == pane._f_nrmls.back()) {
              pane._f_n_index[ pane.get_index( h)] = pane._f_nrmls.size()-1;
            }
            else {
              pane._f_n_index[ pane.get_index( h)] = pane._f_nrmls.size();
              pane._f_nrmls.push_back( v);
            }
          } while ( (h=acc.get_next_around_destination(h)) != h0);
        }
      } while ( (k=(k==kopp)?*j:kopp) != *j);
      
      // Compute the tangent
      Vector_3 tng = ( k->destination()->point() -
                        kopp->destination()->point());
      acc.get_pane( k)->add_tangent( k, tng);
      if ( !is_feature_0( acc.get_destination(k))) {
        Feature_1::iterator t = j; ++t;
        if ( t==it->end()) t = it->begin();
        Halfedge *h = acc.get_opposite(*t);
        acc.get_pane( h)->add_tangent( h, tng);
      }
      acc.get_pane( kopp)->add_tangent( kopp, tng);
      if ( !is_feature_0( acc.get_destination(kopp))) {
        Feature_1::iterator t = (j==it->begin()) ? it->end() : j; 
        Halfedge *h = *(--t);
        acc.get_pane( h)->add_tangent( h, tng);
      }
    }
  }

  // Loop through the vertices in 0-features
  for ( Feature_list_0::iterator it = _f_list_0.begin(), iend=_f_list_0.end();
        it != iend; ++it) {
    Halfedge *h = acc.get_halfedge(it->vertex());
    RFC_Pane_overlay &pane = *acc.get_pane( h);

    if ( !h->is_border() && pane._f_n_index[ pane.get_index( h)] == -1) {
      Halfedge *h0 = h;
      do {
        Vector_3 v = op.get_face_normal( h, one, scheme)+
          op.get_face_normal( acc.get_opposite(h), Point_2(0,0), scheme);
        normalize(v);

        if ( pane._f_nrmls.size() && v == pane._f_nrmls.back()) {
          pane._f_n_index[ pane.get_index( h)] = pane._f_nrmls.size()-1;
        }
        else {
          pane._f_n_index[ pane.get_index( h)] = pane._f_nrmls.size();
          pane._f_nrmls.push_back( v);
        }
      } while ( (h=acc.get_next_around_destination(h)) != h0);
    }
  }

  // Finally, normalize normals and tangents
  for ( it=_pane_set.begin() ; it != iend; ++it) {
    RFC_Pane_overlay &pane = (RFC_Pane_overlay &)*it->second;

    if ( pane.is_master()) {
      for ( int i=0, size = pane._nrmls.size(); i<size; ++i) 
        normalize( pane._nrmls[i]);
      for ( int i=0, size = pane._f_tngts.size(); i<size; ++i) 
        normalize( pane._f_tngts[i]);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Vector_3 get_tangent ( const Halfedge *  h )

inlineprotected

Definition at line 365 of file RFC_Window_overlay.h.

References Halfedge_overlay::destination(), Halfedge_overlay::origin(), and Vertex_overlay::point().

  { return h->destination()->point()-h->origin()->point(); }

Here is the call graph for this function:

void print_features

(

)

Dump out the 0- and 1-features in Tecplot format into files <name>f0.plt, <name>f1.plt, respectively.

The original mesh, vertex ranks, face angles, and edge angles are output into file <name>.plt.

Definition at line 55 of file RFC_Window_overlay_IO.C.

References acc, cimg_library::acos(), COM_allocate_array(), COM_call_function(), COM_delete_window(), COM_FLOAT, COM_free_buffer(), COM_get_attribute_handle_const(), COM_get_function_handle(), COM_get_panes(), COM_INTEGER, COM_LOAD_MODULE_STATIC_DYNAMIC, COM_new_attribute(), COM_new_window(), COM_UNLOAD_MODULE_STATIC_DYNAMIC, COM_use_attribute(), COM_window_init_done(), RFC_Pane_overlay::get_angle_defect(), RFC_Pane_overlay::get_cos_edge_angle(), 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_pane(), HDS_accessor< _MP >::get_primary(), RFC_Pane_overlay::hds(), HUGE_VALF, i, RFC_Pane_base::id(), iend, RFC_Pane_base::is_quadratic(), min(), Vertex_overlay::point(), RFC_assertion, s, RFC_Pane_base::size_of_nodes(), and v.

                                   {

  std::cout << "Writing feature info " << "..." << std::endl;

  // Construct a temporary window
  std::string wname_fea = name()+"_fea_temp";

  COM_new_window( wname_fea.c_str());
  COM_use_attribute( (wname_fea+".mesh").c_str(), (name()+".mesh").c_str());

  COM_new_attribute( (wname_fea+".frank").c_str(), 'n', COM_INTEGER, 1, "");
  COM_new_attribute( (wname_fea+".face_angle").c_str(), 'n', COM_FLOAT, 1, "");

  if ( verb > 1) {
    COM_new_attribute( (wname_fea+".turn_angle").c_str(), 'n', COM_FLOAT, 1, "");
    COM_new_attribute( (wname_fea+".angle_defect").c_str(), 'n', COM_FLOAT, 1, "");
  }

  Pane_set::iterator it=_pane_set.begin(), iend=_pane_set.end();
  for ( it=_pane_set.begin(); it != iend; ++it) {
    RFC_Pane_overlay &pane = (RFC_Pane_overlay &)*it->second;

    int *frank;
    COM_allocate_array( (wname_fea+".frank").c_str(), pane.id(), 
                        &(void*&)frank);

    float *face_angle=NULL, *turn_angle=NULL, *angle_defect=NULL;
    COM_allocate_array( (wname_fea+".face_angle").c_str(), pane.id(), 
                        &(void*&)face_angle);
    if ( verb>1) {
      COM_allocate_array( (wname_fea+".turn_angle").c_str(), pane.id(), 
                          &(void*&)turn_angle);
      COM_allocate_array( (wname_fea+".angle_defect").c_str(), pane.id(), 
                          &(void*&)angle_defect);
    }

    int s=pane.size_of_nodes();
    RFC_Pane_overlay::HDS::Vertex_iterator vit=pane.hds().vertices_begin(); 
    for ( int i=0; i<s; ++i, ++vit) if ( vit->halfedge()) {
      Vertex *v = acc.get_primary(&*vit);
      if ( is_feature_0( v)) {
        if ( _f0_ranks.find(v)==_f0_ranks.end()) {
          std::cout << "Found rank-0 vertex: " << v->point() << std::endl;
          frank[i] = 2; // 1;
        }
        else
          frank[i] = 2; // _f0_ranks[v]+1;
      }
      else
        frank[i] = is_on_feature(v);
        
      // Compute face angle
      face_angle[i] = 2.;
      Halfedge *h0=acc.get_halfedge(v), *h1=h0;

      if ( acc.get_destination( h0)==v) do {
        face_angle[i] = std::min( face_angle[i], 
                                  cos_face_angle( h1, acc.get_opposite(h1)));
      } while ( (h1=acc.get_next_around_destination(h1)) != h0);
      else { // v is an edge center for quadratic element
        RFC_assertion( pane.is_quadratic());
        face_angle[i] = cos_face_angle( h1, acc.get_opposite(h1));
      }

      face_angle[i] = acos( face_angle[i])*r2d;

      if ( verb>1) {
        if ( is_feature_0( v) && _f0_ranks[v]>2)
          turn_angle[i] = 180;
        else if ( acc.get_pane(v)->get_cos_edge_angle( v)==HUGE_VALF)
          turn_angle[i] = 0;
        else 
          turn_angle[i] = acos(acc.get_pane(v)->get_cos_edge_angle( v))*r2d;
        
        if ( acc.get_pane(v)->get_angle_defect(v)==HUGE_VALF)
          angle_defect[i] = 0.;
        else
          angle_defect[i] = acc.get_pane(v)->get_angle_defect(v)*r2d;
      }
    }
  }
   
  COM_window_init_done( wname_fea.c_str());

  // Load Rocout
  COM_LOAD_MODULE_STATIC_DYNAMIC( Rocout, "RFC_OUT");
  int hdl_write = COM_get_function_handle( "RFC_OUT.write_attribute");

  // Call Rocut with the window to write out the pane.
  int win_all = COM_get_attribute_handle_const( (wname_fea+".all").c_str());  

  string fname_pre = out_pre + name() + "_fea_";

  int npanes, *paneIDs;
  COM_get_panes( wname_fea.c_str(), &npanes, &paneIDs);

  for ( int i=0; i<npanes; ++i) {
    std::ostringstream ostr;

    ostr << fname_pre;
    ostr.fill('0'); ostr.width(5);
    ostr << paneIDs[i] << ".hdf";

    COM_call_function( hdl_write, ostr.str().c_str(), &win_all, 
                       wname_fea.c_str(), "000", NULL, NULL, &paneIDs[i]);
  }
  COM_free_buffer( &paneIDs);

  // Unload Rocout
  COM_UNLOAD_MODULE_STATIC_DYNAMIC( Rocout, "RFC_OUT");

  // Delete the temporary window
  COM_delete_window( wname_fea.c_str());
}

Here is the call graph for this function:

void reduce_coordinates_to_all

(

)

Reduces nodal coordinates from primary nodes to others

Definition at line 603 of file RFC_Window_overlay.C.

References RFC_Window_base::_pane_set, RFC_Window_overlay::acc, HDS_accessor< _MP >::get_primary(), RFC_Pane_overlay::hds(), i, iend, RFC_Window_derived< RFC_Pane_overlay >::pane(), Vertex_overlay::point(), s, RFC_Pane_base::size_of_nodes(), and v.

                                              {

  Pane_set::iterator it=_pane_set.begin(), iend=_pane_set.end();
  for ( it=_pane_set.begin(); it != iend; ++it) {
    RFC_Pane_overlay &pane = (RFC_Pane_overlay &)*it->second;

    int s=pane.size_of_nodes();
    RFC_Pane_overlay::HDS::Vertex_iterator vit=pane.hds().vertices_begin(); 
    for ( int i=0; i<s; ++i, ++vit) if ( vit->halfedge()) {
      Vertex *v = &*vit, *vpri = acc.get_primary(v);
      
      if ( v != vpri) const_cast<Point_3&>(v->point()) = vpri->point();
    }
  }
}

Here is the call graph for this function:

void reduce_normals_to_all ( MPI_Op  op )

protected

Reduces values for each node form all its instances to all instances.

Definition at line 582 of file RFC_Window_overlay.C.

References RFC_Window_base::_map_comm, RFC_Pane_overlay::_nrmls, RFC_Window_base::_pane_set, COM_DOUBLE, and RFC_Window_derived< RFC_Pane_overlay >::pane().

Referenced by RFC_Window_overlay::evaluate_normals().

                                                    {

  std::vector<void *> ptrs;
  // Loop through panes
  Pane_set::iterator pit=_pane_set.begin(), piend=_pane_set.end();
  for ( pit=_pane_set.begin(); pit != piend; ++pit) {
    RFC_Pane_overlay &pane=(RFC_Pane_overlay &)*pit->second;

    ptrs.push_back( &pane._nrmls[0]);
  }

  _map_comm.init( &ptrs[0], COM_DOUBLE, 3);
  _map_comm.begin_update_shared_nodes();
  _map_comm.reduce_on_shared_nodes( op);
  _map_comm.end_update_shared_nodes();
}

Here is the call graph for this function:

Here is the caller graph for this function: