#include <Overlay.h>

Collaboration diagram for Overlay:

Public Types
typedef Overlay	Self

typedef HDS_overlay	HDS

typedef RFC_Window_overlay::Vertex	Vertex

typedef RFC_Window_overlay::Halfedge	Halfedge

typedef RFC_Window_overlay::Facet	Facet

typedef std::pair< const Halfedge , const Halfedge >	Parent_pair

typedef std::list< const INode * >	INode_const_list

typedef std::vector< const INode * >	Subface

typedef std::list< Subface >	Subface_list

typedef RFC_Window_overlay::Feature_0	Feature_0

typedef RFC_Window_overlay::Feature_1	Feature_1

typedef RFC_Window_overlay::Feature_list_0	Feature_list_0

typedef RFC_Window_overlay::Feature_list_1	Feature_list_1

Public Member Functions
	Overlay (const COM::Window w1, const COM::Window w2, const char *pre)

	~Overlay ()

int	overlay ()

void	set_tolerance (double tol)

RFC_Window_overlay *	get_rfc_window (const COM::Window *w)

const RFC_Window_overlay *	get_rfc_window (const COM::Window *w) const

RFC_Window_overlay *	get_blue_window ()

RFC_Window_overlay *	get_green_window ()

const RFC_Window_overlay *	get_blue_window () const

const RFC_Window_overlay *	get_green_window () const

void	get_inodes_of_face (const Facet *f, INode_const_list &nodes)

Halfedge *	get_parent_face (const Subface &sf, int color)

bool	subdivide (const INode_const_list &face, INode_const_list::const_iterator last_checked, Subface_list &sub_faces, int color, int depth=0) const

Point_2	get_nat_coor (const INode &i, const Generic_element &e, const Halfedge *h, int color) const

void	export_windows (RFC_Window_base , RFC_Window_base )
	Export the subdivisions to the two given windows. More...

void	write_inodes_tec (std::ostream &os, const char *color)

void	write_inodes_vec (std::ostream &os)

void	write_overlay_tec (std::ostream &, const COM::Window *)

void	write_overlay_off (std::ostream &, const COM::Window *)

Protected Member Functions
INode *	overlay_init ()

void	get_green_parent (const Vertex v, const Halfedge b, Halfedge *o, Parent_type t, Point_2 *nc)

void	insert_node_in_blue_edge (INode &x, Halfedge *b)

void	intersect_blue_with_green ()

void	sort_on_green_edges ()

void	associate_green_vertices ()

void	insert_node_in_green_edge (INode *v, int tag)

void	project_adjacent_green_vertices (const INode , Halfedge )
	Helper for associate_green_vertices(). More...

bool	verify_inode (const INode *i)

Host_face	get_edge_parent (const INode &i0, const INode &i1, const int color) const

Parent_pair	get_edge_pair_parents (const INode &i0, const INode &i1, const int color) const

bool	intersect_link (const INode x, const Halfedge b, const Halfedge g0, const Parent_type t0, Halfedge g1, const Parent_type t1, Real start, Real cb, Real cg, Halfedge *g, Parent_type t, int tryindex=0)

bool	intersect_link_helper (const Halfedge b, Halfedge g2, Real start, Real cb, Real cg, Halfedge *g, Parent_type t, bool found, int snapcode, const Vertex anchor, bool panic)

bool	intersect_link_helper2 (Real cb, Real cg, Halfedge *g, Parent_type t)

bool	contains (const Halfedge e1, const Parent_type t1, const Halfedge e2, const Parent_type t2) const

void	match_features_0 ()

INode *	project_next_vertex (Halfedge , Halfedge )

int	count_edges (const Halfedge *e) const

Protected Attributes
RFC_Window_overlay *	B

RFC_Window_overlay *	G

std::list< INode * >	inodes

Overlay_primitives	op

HDS_accessor< Tag_true >	acc

bool	is_opposite

bool	verbose

bool	verbose2

std::string	out_pre

Real	eps_e

Real	eps_p

Private Member Functions
void	set_subnode_id (INode *i, int color, int pane_id, int l_id)

int	get_subnode_id (const INode *i, int color, int pane_id) const

int	get_subnode_copies (const INode *i, int color) const

void	convert_nat_coordinates (const INode i, Halfedge h, int color, int pane_id, int &lid, RFC_Pane_overlay::Edge_ID &eid, Point_2 &nc) const

void	number_a_subnode (INode *i, int color, std::map< int, std::pair< int, int > > &cnts)

void	count_subnodes (INode *i, int color, std::map< int, std::pair< int, int > > &cnts)

void	number_subnodes ()

void	number_subfaces ()

void	insert_edge_into_queue (Halfedge h, INode v, std::queue< Halfedge * > &q, std::queue< Halfedge * > &q_rdg, std::queue< Halfedge * > &q_crn)

bool	is_queue_empty (std::queue< Halfedge * > &q, std::queue< Halfedge * > &q_rdg, std::queue< Halfedge * > &q_crn)

Real	sq_length (const Halfedge &h) const

const INode *	get_next_inode (const INode v1, const INode v2, int) const

std::pair< const INode , const Halfedge >	get_next_inode_ccw (const INode v0, const INode v1, int color) const

std::pair< const INode , const Halfedge >	get_next_inode_cw (const INode v0, const INode v1, int color) const

bool	logical_xor (bool a, bool b) const

Private Attributes
std::vector< Node_ID >	_subnode_ids_b

std::vector< Node_ID >	_subnode_ids_g

std::vector< char >	_subnode_copies_b

std::vector< char >	_subnode_copies_g

std::map< int, std::map< int, int > >	_subnode_imap_b

std::map< int, std::map< int, int > >	_subnode_imap_g

Detailed Description

Definition at line 55 of file Overlay.h.

Member Typedef Documentation

typedef RFC_Window_overlay::Facet Facet

Definition at line 61 of file Overlay.h.

typedef RFC_Window_overlay::Feature_0 Feature_0

Definition at line 66 of file Overlay.h.

typedef RFC_Window_overlay::Feature_1 Feature_1

Definition at line 67 of file Overlay.h.

typedef RFC_Window_overlay::Feature_list_0 Feature_list_0

Definition at line 68 of file Overlay.h.

typedef RFC_Window_overlay::Feature_list_1 Feature_list_1

Definition at line 69 of file Overlay.h.

typedef RFC_Window_overlay::Halfedge Halfedge

Definition at line 60 of file Overlay.h.

typedef HDS_overlay HDS

Definition at line 58 of file Overlay.h.

typedef std::list< const INode *> INode_const_list

Definition at line 63 of file Overlay.h.

typedef std::pair< const Halfedge*, const Halfedge*> Parent_pair

Definition at line 62 of file Overlay.h.

typedef Overlay Self

Definition at line 57 of file Overlay.h.

typedef std::vector< const INode*> Subface

Definition at line 64 of file Overlay.h.

typedef std::list< Subface > Subface_list

Definition at line 65 of file Overlay.h.

typedef RFC_Window_overlay::Vertex Vertex

Definition at line 59 of file Overlay.h.

Constructor & Destructor Documentation

RFC_BEGIN_NAME_SPACE Overlay	(	const COM::Window *	w1,
		const COM::Window *	w2,
		const char *	pre
	)

Definition at line 46 of file Overlay.C.

References B, BLUE, G, GREEN, out_pre, and verbose2.

   : op(1.e-9, 1.e-6, 1.e-2), is_opposite(true), 
     verbose(true), verbose2(false), out_pre(pre?pre:""),
     eps_e( 1.e-2), eps_p(1.e-6) {
   B = new RFC_Window_overlay( const_cast<COM::Window*>(w1), BLUE,  
                               out_pre.c_str());
   G = new RFC_Window_overlay( const_cast<COM::Window*>(w2), GREEN, 
                               out_pre.c_str());
 
 #if DEBUG
   verbose2 = true;
 #endif
 }

~Overlay ( )

Definition at line 61 of file Overlay.C.

References B, and G.

                   {
   delete G;
   delete B; 
 }

Member Function Documentation

void associate_green_vertices ( )

protected

Definition at line 898 of file Overlay.C.

References acc, B, In_place_list_n< T, managed >::begin(), COM_assertion, In_place_list_n< T, managed >::empty(), In_place_list_n< T, managed >::end(), HDS_accessor< _MP >::get_halfedge(), HDS_accessor< _MP >::get_inode(), HDS_accessor< _MP >::get_inode_list(), HDS_accessor< _MP >::get_next(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_origin(), GREEN, i, HDS_accessor< _MP >::is_border(), RFC_Window_derived< _Pane >::panes(), PARENT_FACE, INode::parent_type(), project_adjacent_green_vertices(), In_place_list_n< T, managed >::rbegin(), In_place_list_n< T, managed >::rend(), and v.

Referenced by overlay().

                            {
   std::vector<RFC_Pane_overlay*>   ps;
   B->panes( ps); // Process all the panes including extension panes.
 
   // Loop through all panes of B
   for (std::vector<RFC_Pane_overlay*>::iterator 
          pit=ps.begin(); pit!=ps.end(); ++pit) {
     // Loop through the core faces of each pane.
     for ( HDS::Facet_iterator fit=(*pit)->hds().facets_begin(); 
           fit!=(*pit)->hds().facets_end(); ++fit) {
 
       Halfedge *b = acc.get_halfedge( &*fit);
       COM_assertion( !acc.is_border(b));
       Halfedge *h=b;
 
       do {
         INode *i=acc.get_inode( acc.get_origin(h));
         if ( i && i->parent_type( GREEN)!=PARENT_FACE) 
           project_adjacent_green_vertices( i, b);
         
         INode_list &il = acc.get_inode_list( h);
 
         if ( ! il.empty()) {
           // Loop through the intersections on the edges
           INode_list::iterator v = il.begin(), vend = il.end();
           for ( ; v != vend; ++v) project_adjacent_green_vertices( &*v, b);
         }
         else {
           INode_list &ilr = acc.get_inode_list( acc.get_opposite(h));
           if ( !ilr.empty()) {
             INode_list::reverse_iterator vr=ilr.rbegin(),vrend=ilr.rend();
             for ( ; vr!=vrend; ++vr) project_adjacent_green_vertices(&*vr,b);
           }
         }
         // Increment the iterator
       } while ( (h = acc.get_next(h)) != b);
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool contains	(	const Halfedge *	e1,
		const Parent_type	t1,
		const Halfedge *	e2,
		const Parent_type	t2
	)		const

protected

Definition at line 1488 of file Overlay.C.

References acc, HDS_accessor< _MP >::get_destination(), HDS_accessor< _MP >::get_facet(), HDS_accessor< _MP >::get_next(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_origin(), PARENT_EDGE, PARENT_FACE, PARENT_VERTEX, RFC_assertion, and RFC_precondition.

Referenced by get_edge_parent(), get_next_inode(), get_parent_face(), insert_node_in_blue_edge(), intersect_link(), intersect_link_helper(), project_adjacent_green_vertices(), and verify_inode().

                                                                    {
   RFC_precondition( e1!=NULL);
   if ( e2 == NULL) return false;
 
   switch ( t1) {
   case PARENT_FACE: {
     const Facet *f1=acc.get_facet(e1);
     RFC_assertion( f1!=NULL);
     switch( t2) {
     case PARENT_FACE: {
       RFC_assertion( acc.get_facet(e2));
       return f1 == acc.get_facet(e2);
     }
     case PARENT_EDGE: {
       return f1 == acc.get_facet(e2) || 
         f1 == acc.get_facet( acc.get_opposite(e2));
     }
     case PARENT_VERTEX: {
       // Is true if any edge have acc.get_origin(e2) as an endpoint.
       const Vertex *v2=acc.get_origin(e2);
       const Halfedge *h = e1;
       do {
         if ( acc.get_destination(h) == v2) return true;
       } while ( ( h = acc.get_next(h)) != e1);
       break;
     }
     default:
       RFC_assertion( false);
       break;
     }
     break;
   }
   case PARENT_EDGE:
     if ( t2 == PARENT_EDGE)
       return ( e1 == e2 || e1 == acc.get_opposite(e2));
     else if ( t2 == PARENT_VERTEX) {
       const Vertex *v2=acc.get_origin(e2);
       return acc.get_origin(e1) == v2 || acc.get_destination(e1) == v2;
     }
     break;
   case PARENT_VERTEX:
     return t2 == PARENT_VERTEX && acc.get_origin(e1) == acc.get_origin(e2);
   default:
     RFC_assertion( false);
     break;
   }
   return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void convert_nat_coordinates	(	const INode *	i,
		Halfedge *	h,
		int	color,
		int	pane_id,
		int &	lid,
		RFC_Pane_overlay::Edge_ID &	eid,
		Point_2 &	nc
	)		const

private

Retrieve the local id within a given pane for a given subnode.

See Also: set_subnode_id

Definition at line 123 of file Overlay_IO.C.

References acc, B, RFC_Pane_base::base(), BLUE, Halfedge_overlay::destination(), RFC_Pane_base::Edge_ID::edge_id, RFC_Pane_base::Edge_ID::face_id, Halfedge_overlay::facet(), G, RFC_Pane_overlay::get_lid(), RFC_Pane_base::get_lvid(), HDS_accessor< _MP >::get_pane(), get_subnode_id(), INode::halfedge(), INode::nat_coor(), Halfedge_overlay::next(), RFC_Pane_base::normalize_nat_coor(), Halfedge_overlay::origin(), PARENT_FACE, INode::parent_type(), PARENT_VERTEX, RFC_assertion, and RFC_assertion_code.

Referenced by number_subfaces().

                                                      {
   lid = get_subnode_id( i, color, pane_id);
   i->nat_coor( color, nc);
 
   // ==== Determine eid
   RFC_Pane_overlay &pane = *acc.get_pane(h);
   eid.face_id = pane.get_lid( h->facet());
 
   // Determine eid.edge_id
   Element_node_enumerator ene( pane.base(), eid.face_id);
   Halfedge *b = i->halfedge( color);
 
   if ( b->facet() != h->facet()) {
     RFC_assertion( i->parent_type(color) != PARENT_FACE);
     RFC_Window_overlay &win = color==BLUE? *B : *G;
     RFC_assertion_code( int count=0); 
     // Find the local node id of b->origin() in the host pane of h
     while ( !win.is_same_node( b->origin(), h->destination())) {
       h = h->next(); RFC_assertion( ++count <= 4);
     }
     if ( i->parent_type(color) == PARENT_VERTEX)
       eid.edge_id = pane.get_lvid( ene, pane.get_lid( h->destination()));
     else {
       eid.edge_id = pane.get_lvid( ene, pane.get_lid( h->origin()));
       nc = Point_2( 1-nc[0], 0);
     }
   }
   else {
     eid.edge_id = pane.get_lvid( ene, pane.get_lid( b->origin()));
     
     if ( i->parent_type(color) == PARENT_FACE) {
       pane.normalize_nat_coor( eid.edge_id, ene.size_of_edges(), nc);
       eid.edge_id = 0;
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int count_edges ( const Halfedge * e ) const

inlineprotected

Definition at line 224 of file Overlay.h.

References i, and Halfedge_overlay::next().

Referenced by insert_node_in_blue_edge(), and number_subfaces().

                                             {
     int i=0;
     const Halfedge *h=e;
     do { ++i; } while ( (h=h->next())!= e);
     return i;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void count_subnodes	(	INode *	i,
		int	color,
		std::map< int, std::pair< int, int > > &	cnts
	)

private

Definition at line 212 of file Overlay_IO.C.

References acc, HDS_accessor< _MP >::get_next_around_origin(), HDS_accessor< _MP >::get_pane(), Vertex_overlay::halfedge(), INode::halfedge(), RFC_Pane_base::id(), Halfedge_overlay::is_border(), Halfedge_overlay::origin(), INode::parent_type(), and PARENT_VERTEX.

Referenced by number_subnodes().

                                                      {
   if  ( i->parent_type( color) == PARENT_VERTEX) {
     Halfedge   *h = i->halfedge( color);
     Halfedge *h0 = h;
     int  last_id = -1;
     std::set<int>   panes;
     bool first_iter = true;
     do {
       int  pane_id = acc.get_pane(h)->id();
       if ( !first_iter && (pane_id==last_id||panes.find(pane_id)!=panes.end()))
         continue;
       ++(cnts[ pane_id].second);
       panes.insert(last_id=pane_id);
 
       // Optimization assuming the halfedge structure is normalized
       if ( first_iter && !h->origin()->halfedge()->is_border()) break;
       first_iter = false;
     } while ( (h=acc.get_next_around_origin(h)) != h0);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void export_windows	(	RFC_Window_base *	bw,
		RFC_Window_base *	gw
	)

Export the subdivisions to the two given windows.

Definition at line 455 of file Overlay_IO.C.

References B, RFC_Window_base::export_window(), and G.

                                                           {
   // Copy data from RFC_Window_overlay into RFC_Window_base.
   B->export_window( bw);
   G->export_window( gw);
 }

Here is the call graph for this function:

RFC_Window_overlay* get_blue_window ( )

inline

Definition at line 88 of file Overlay.h.

References B.

88 { return B; }

Overlay::B

RFC_Window_overlay * B

Definition: Overlay.h:280

const RFC_Window_overlay* get_blue_window ( ) const

inline

Definition at line 90 of file Overlay.h.

References B.

90 { return B; }

Overlay::B

RFC_Window_overlay * B

Definition: Overlay.h:280

Overlay::Parent_pair get_edge_pair_parents	(	const INode &	i0,
		const INode &	i1,
		const int	color
	)		const

protected

Definition at line 1464 of file Overlay.C.

References acc, get_edge_parent(), HDS_accessor< _MP >::get_opposite(), Host_face::halfedge(), HDS_accessor< _MP >::is_border(), PARENT_EDGE, PARENT_FACE, Host_face::parent_type(), and RFC_assertion.

                                               {
   Host_face f = get_edge_parent( i0, i1, color);
   Halfedge *g = f.halfedge(); 
   RFC_assertion( !acc.is_border(g));
 
   // There are two cases for f:
   // 1. g is not a border edge and the parent type is PARENT_FACE
   // 2. g is not a border edge and the parent type is PARENT_EDGE
 
   switch ( f.parent_type()) {
   case PARENT_FACE:
     return std::make_pair( g, g);
   case PARENT_EDGE:
     return std::make_pair( g, acc.get_opposite(g));
   default:
     RFC_assertion( false);
     return std::make_pair( (Halfedge*)NULL, (Halfedge*)NULL);
   }
 }

Here is the call graph for this function:

Host_face get_edge_parent	(	const INode &	i0,
		const INode &	i1,
		const int	color
	)		const

protected

Definition at line 1393 of file Overlay.C.

References acc, contains(), HDS_accessor< _MP >::get_destination(), HDS_accessor< _MP >::get_next_around_origin(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_origin(), INode::halfedge(), HDS_accessor< _MP >::is_border(), INode::nat_coor(), PARENT_EDGE, PARENT_FACE, PARENT_NONE, INode::parent_type(), PARENT_VERTEX, and RFC_assertion.

Referenced by get_edge_pair_parents(), get_next_inode(), get_next_inode_ccw(), get_next_inode_cw(), get_parent_face(), and intersect_blue_with_green().

                                           {
   Halfedge *h0 = i0.halfedge( color);
   Halfedge *h1 = i1.halfedge( color);
   
   Parent_type t0 = i0.parent_type( color);
   Parent_type t1 = i1.parent_type( color);
   
   if ( t1 == PARENT_FACE) {
     if ( !acc.is_border( h1) && contains( h1, PARENT_FACE, h0, t0))
       return Host_face( h1, PARENT_FACE);
     else 
       return Host_face( NULL, PARENT_NONE);
   }
   
   switch ( t0) {
   case PARENT_VERTEX: {
     Halfedge *h = h0;
     // First check whether they lie on the same edge
     do {
       if ( t1 == PARENT_EDGE && (h == h1 || acc.get_opposite(h) == h1) ||
            t1 == PARENT_VERTEX && acc.get_destination(h)==acc.get_origin(h1)) {
         return Host_face( h, PARENT_EDGE);
       }
       RFC_assertion( t1 != PARENT_VERTEX || 
                      acc.get_origin(h0) != acc.get_origin(h1));
     } while ( (h=acc.get_next_around_origin(h)) != h0);
     // If not, check whether they lie on the same face
     do {
       if ( !acc.is_border( h) && contains(h, PARENT_FACE, h1, t1)) 
         return Host_face( h, PARENT_FACE);
     } while ( (h=acc.get_next_around_origin(h)) != h0);
     break;
   }
   case PARENT_EDGE: {
     Halfedge *hopp=acc.get_opposite(h0);
     if ( t1 == PARENT_EDGE && ( h0 == h1 || hopp == h1)) {
       Real nc0=i0.nat_coor( color)[0], nc1=i1.nat_coor( color)[0];
       if ( h0 == h1 && nc0<nc1 || hopp == h1 && 1.-nc0<nc1)
         return Host_face( h0, PARENT_EDGE);
       else 
         return Host_face( hopp, PARENT_EDGE);
     }
     if ( t1 == PARENT_VERTEX) {
       if (acc.get_destination(h0) == acc.get_origin(h1))
         return Host_face( h0, PARENT_EDGE);
       else if (acc.get_origin(h0) == acc.get_origin(h1))
         return Host_face( hopp, PARENT_EDGE);
     }
     if ( ! acc.is_border(h0) && contains( h0, PARENT_FACE, h1, t1))
       return Host_face( h0, PARENT_FACE);
     if ( ! acc.is_border(hopp) && contains( hopp, PARENT_FACE, h1, t1))
       return Host_face( hopp, PARENT_FACE);
     break;
   }
   case PARENT_FACE: {
     RFC_assertion( ! acc.is_border(h0));
     if ( contains(h0, PARENT_FACE, h1, t1)) 
       return Host_face(h0, PARENT_FACE);
     break;
   }
   default:
     RFC_assertion( false);
     break;
   }
   return Host_face( NULL, PARENT_NONE);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void get_green_parent	(	const Vertex *	v,
		const Halfedge *	b,
		Halfedge **	o,
		Parent_type *	t,
		Point_2 *	nc
	)

protected

Definition at line 101 of file Overlay_init.C.

Referenced by overlay_init().

 {
   const Point_3 &p = acc.get_pane(v)->get_point(v);
   Real  sq_dist = 1.e30;
   Vertex *w = NULL;
 
   //=================================================================
   // Locate the closest green vertex
   //=================================================================
   std::vector<RFC_Pane_overlay*>   ps;
   G->panes( ps);
   // Loop through all the panes of G
   for ( std::vector<RFC_Pane_overlay*>::iterator 
           pit=ps.begin(); pit != ps.end(); ++pit) {
     RFC_Pane_overlay &pane = **pit;
     // loop through all the green vertices that are complete
     for ( HDS::Vertex_iterator vit=pane.hds().vertices_begin(); 
           vit!=pane.hds().vertices_end(); ++vit) 
       if ( vit->halfedge() && vit->halfedge()->destination() == &*vit) {
         // if the distance is closer than previous ones, save it
         Real sq_d = ( p- acc.get_pane(&*vit)->get_point(&*vit)).squared_norm();
         if ( sq_d < sq_dist) { sq_dist = sq_d;  w = &*vit; }
       }
   }
 
   if ( w == NULL) return; 
 
   RFC_assertion( acc.is_primary( w)); // Because we start from smaller ids.
   // Let h be a nonborder incident halfedge of w
   Halfedge *h = acc.get_halfedge( w);
   h = !acc.is_border( h) ? acc.get_next( h) : acc.get_opposite( h);
 
   // We perform breadth-first search starting from h
   std::queue< Halfedge*> q;
   std::list< Halfedge*>  hlist;
 
   q.push( h);
   // Mark the halfedges in the same face as h
   Halfedge *h0 = h;
   do { RFC_assertion( !acc.marked(h)); acc.mark( h); hlist.push_back( h); } 
   while ( (h=acc.get_next(h)) != h0);
 
   Vector_3 vec(0.,0.,0.);
   while ( !q.empty()) {
     h = q.front(); q.pop();
     
     *t_out = PARENT_NONE; *h_out=h;
     if ( op.project_onto_element( p, h_out, t_out, vec, nc, eps_e) &&
          std::abs(acc.get_normal(b)* acc.get_normal(h)) >= 0.6)
       break;
 
     // Insert the incident faces of h into the queue
     h0 = h;
     do {
       Halfedge *hopp=acc.get_opposite(h);
       if ( !acc.is_border(hopp) && ! acc.marked( hopp)) {
         Halfedge *h1 = hopp;
         q.push( h1);
         do { 
           acc.mark(h1); hlist.push_back( h1); 
         } while ((h1=acc.get_next(h1))!=hopp);
       }
     } while ( (h=acc.get_next(h)) != h0);
   }
   // Unmark the halfedges
   while ( !hlist.empty()) 
   { acc.unmark( hlist.front()); hlist.pop_front(); }
 
   // If v is too far from p_out, return NULL.
   vec = op.get_point( *h_out, *nc) - p;
   if ( vec * vec > sq_length( **h_out) + sq_length( *acc.get_halfedge(v)))  {
     *h_out = NULL; *t_out = PARENT_NONE;
   }
   else {
     // Determine whether the two surfaces are facing each other
     is_opposite = ( acc.get_pane(b)->get_normal( b, v) * 
                     op.get_face_normal( *h_out, *nc)) < 0;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

RFC_Window_overlay* get_green_window ( )

inline

Definition at line 89 of file Overlay.h.

References G.

89 { return G; }

Overlay::G

RFC_Window_overlay * G

Definition: Overlay.h:281

const RFC_Window_overlay* get_green_window ( ) const

inline

Definition at line 91 of file Overlay.h.

References G.

91 { return G; }

Overlay::G

RFC_Window_overlay * G

Definition: Overlay.h:281

void get_inodes_of_face	(	const Facet *	f,
		INode_const_list &	nodes
	)

Definition at line 1922 of file Overlay.C.

References acc, In_place_list_n< T, managed >::begin(), In_place_list_n< T, managed >::empty(), In_place_list_n< T, managed >::end(), HDS_accessor< _MP >::get_halfedge(), HDS_accessor< _MP >::get_inode(), HDS_accessor< _MP >::get_inode_list(), HDS_accessor< _MP >::get_next(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_origin(), i, Halfedge_overlay::is_border(), HDS_accessor< _MP >::is_border(), In_place_list_n< T, managed >::rbegin(), In_place_list_n< T, managed >::rend(), and v.

Referenced by number_subfaces(), write_overlay_off(), and write_overlay_tec().

                                                       {
   const Halfedge *b = acc.get_halfedge(f);
   if ( acc.is_border(b)) {
     // Make sure the opposite of b is a border edge
     while ( !acc.get_opposite(b)->is_border()) b=acc.get_next(b); 
   }
   const Halfedge *h=b;
   do {
     const INode *i=acc.get_inode( acc.get_origin(h));
     if ( i) nodes.push_back( i);
     
     const INode_list &il = acc.get_inode_list( h);
     
     if ( ! il.empty()) {
       // Loop through the intersections on the edges
       INode_list::const_iterator v = il.begin(), vend = il.end();
       for ( ; v != vend; ++v) nodes.push_back( &*v);
     }
     else {
       const INode_list &ilr = acc.get_inode_list( acc.get_opposite(h));
       if ( !ilr.empty()) {
         INode_list::const_reverse_iterator vr=ilr.rbegin(),vrend=ilr.rend();
         for ( ; vr!=vrend; ++vr) nodes.push_back(&*vr);
       }
     }
     
     // Increment the iterator
   } while ( (h = acc.get_next(h)) != b);
 
   return;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Point_2 get_nat_coor	(	const INode &	i,
		const Generic_element &	e,
		const Halfedge *	h,
		int	color
	)		const

Definition at line 1854 of file Overlay.C.

References acc, Halfedge_overlay::facet(), HDS_accessor< _MP >::get_next(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_origin(), INode::halfedge(), HDS_accessor< _MP >::is_border(), INode::nat_coor(), Halfedge_overlay::next(), PARENT_EDGE, INode::parent_type(), PARENT_VERTEX, Halfedge_overlay::prev(), RFC_assertion, and v.

Referenced by insert_node_in_blue_edge(), and number_subfaces().

                                                            {
   const Halfedge *hi = i.halfedge( color);
   Point_2 nc; i.nat_coor( color, nc);
 
   if ( hi->facet() != h->facet()) {
     switch ( i.parent_type( color)) {
     case PARENT_VERTEX: {
       const Vertex *v =  acc.get_origin( hi);
       hi = h;
       while ( acc.get_origin( hi) != v) 
       { hi = acc.get_next( hi); RFC_assertion( hi != h); }
       break;
     }
     case PARENT_EDGE: {
       const Halfedge *hj = acc.get_opposite( hi);
       if ( hj->facet() == h->facet()) {
         hi = hj; nc = Point_2( 1.-nc[0], 0.); break;
       }
       // Otherwise, it is in an extension edge and we treat it as a face.
     }
     default: {
       RFC_assertion( acc.is_border( hi));
 
       // In the extension region
       while ( acc.get_opposite( hi) != h)
       { hi = acc.get_next(hi); RFC_assertion( hi != i.halfedge(color)); }
       
       return Point_2(1.-get_nat_coor(i, Generic_element(4), hi, color)[0],0.);
     }
     }
   }
 
   switch( e.size_of_edges()) {
   case 3: {
     if ( hi == h)
       return nc;
     else if ( hi == h->prev()) {
       return Point_2( nc[1], 1.-nc[0]-nc[1]);
     }
     else {
       RFC_assertion( hi == h->next());
       return Point_2( 1.-nc[0]-nc[1], nc[0]);
     }
   }
   case 4: {
     if ( hi == h)
       return nc;
     else if ( hi == h->prev()) {
       return Point_2( nc[1], 1-nc[0]);
     }
     else if ( hi == h->next()) {
       return Point_2( 1-nc[1], nc[0]);
     }
     else {
       RFC_assertion( hi == h->next()->next());
       return Point_2( 1-nc[0], 1-nc[1]);
     }
   }
   default: {
     RFC_assertion( false);
   }
   }
   return Point_2(0,0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const INode * get_next_inode	(	const INode *	v1,
		const INode *	v2,
		int	color
	)		const

private

Definition at line 1728 of file Overlay.C.

References acc, contains(), get_edge_parent(), get_next_inode_ccw(), get_next_inode_cw(), Host_face::halfedge(), HDS_accessor< _MP >::is_border(), is_opposite, PARENT_FACE, and Host_face::parent_type().

Referenced by subdivide().

                                                                           {
   // First, find the blue face that contain both inodes.
   std::pair<const INode*,const Halfedge*> b, g;
 
   b = get_next_inode_ccw( v0, v1, color);
   if ( !is_opposite)
     g = get_next_inode_ccw( v0, v1, !color);
   else
     g = get_next_inode_cw( v0, v1, !color);
 
   if ( g.first==NULL) return b.first;
   if ( b.first!=NULL) {
     const Host_face bf = get_edge_parent( *v1, *b.first, !color);
   
     if ( !acc.is_border( g.second) && 
          contains( g.second, PARENT_FACE, bf.halfedge(), bf.parent_type()))
       // If the blue one is contained in the green face, return the blue one
       return b.first;
   }
 
   return g.first;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair< const INode , const Overlay::Halfedge > get_next_inode_ccw	(	const INode *	v0,
		const INode *	v1,
		int	color
	)		const

private

Definition at line 1585 of file Overlay.C.

References acc, In_place_list_n< T, managed >::back(), In_place_list_n< T, managed >::empty(), Halfedge_overlay::facet(), In_place_list_n< T, managed >::front(), HDS_accessor< _MP >::get_destination(), get_edge_parent(), HDS_accessor< _MP >::get_inode(), HDS_accessor< _MP >::get_inode_list(), HDS_accessor< _MP >::get_next_around_origin(), HDS_accessor< _MP >::get_opposite(), Host_face::halfedge(), INode::halfedge(), In_place_list_n_base< T, n >::next_link, PARENT_EDGE, PARENT_FACE, Host_face::parent_type(), INode::parent_type(), PARENT_VERTEX, In_place_list_n_base< T, n >::prev_link, and RFC_assertion.

Referenced by get_next_inode().

 {
   INode *v2=NULL;
   switch( v1->parent_type( color)) {
   case PARENT_FACE:
     // Rule 1: When making turns, it must be at an edge/vertex.
     return std::pair<const INode *, const Halfedge*>(NULL,NULL);
   case PARENT_EDGE: {
     Host_face hf = get_edge_parent( *v0, *v1, color);
     if ( hf.parent_type() == PARENT_EDGE) {
       // Rule 2: No three vertices on the same edge can be in the same subface.
       return  std::pair<const INode *, const Halfedge*>(NULL,NULL);
     }
     else {
       RFC_assertion( hf.parent_type() == PARENT_FACE);
       // next inode is the next one along the edge
       Halfedge *h = v1->halfedge( color);
       if ( h->facet() != hf.halfedge()->facet()) {
         h = acc.get_opposite( h);
         RFC_assertion( h->facet() == hf.halfedge()->facet());
       }
       
       INode_list &il = acc.get_inode_list( h);
       if ( !il.empty()) {
         if ( v1 == &il.back()) 
           v2 = acc.get_inode(acc.get_destination( h));
         else
           v2 = v1->next_link[color];
       }
       else {
         INode_list &ilr = acc.get_inode_list( acc.get_opposite(h));
         RFC_assertion( !ilr.empty());
         if ( v1 == &ilr.front())
           v2 = acc.get_inode(acc.get_destination( h));
         else
           v2 = v1->prev_link[color];
       }
       RFC_assertion( v2);
       return std::pair<const INode*, const Halfedge*>(v2, h);
     }
   }
   case PARENT_VERTEX: {
     Host_face hf = get_edge_parent( *v0, *v1, color);
     
     Halfedge *h = v1->halfedge(color);
     while ( h->facet() != hf.halfedge()->facet()) {
       h = acc.get_next_around_origin( h); 
       RFC_assertion( h != v1->halfedge(color));
     }
     
     INode_list &il = acc.get_inode_list( h);
     if ( !il.empty())
       v2 = &il.front();
     else {
       INode_list &ilr = acc.get_inode_list( acc.get_opposite(h));
       if ( !ilr.empty())
         v2 = &ilr.back();
       else
         v2 = acc.get_inode( acc.get_destination( h));
     }
     RFC_assertion( v2);
     return std::pair<const INode*, const Halfedge*>(v2, h);
   }
   default:
     RFC_assertion( false);
     return std::pair<const INode *, const Halfedge*>(NULL,NULL);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair< const INode , const Overlay::Halfedge > get_next_inode_cw	(	const INode *	v0,
		const INode *	v1,
		int	color
	)		const

private

Definition at line 1655 of file Overlay.C.

References acc, In_place_list_n< T, managed >::back(), In_place_list_n< T, managed >::empty(), Halfedge_overlay::facet(), In_place_list_n< T, managed >::front(), get_edge_parent(), HDS_accessor< _MP >::get_inode(), HDS_accessor< _MP >::get_inode_list(), HDS_accessor< _MP >::get_next_around_origin(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_origin(), Host_face::halfedge(), INode::halfedge(), j, In_place_list_n_base< T, n >::next_link, PARENT_EDGE, PARENT_FACE, Host_face::parent_type(), INode::parent_type(), PARENT_VERTEX, Halfedge_overlay::prev(), In_place_list_n_base< T, n >::prev_link, and RFC_assertion.

Referenced by get_next_inode().

 {
   INode *v2=NULL;
   switch( v1->parent_type( color)) {
   case PARENT_FACE:
     // Rule 1: When making turns, it must be at an edge/vertex.
     return std::pair<const INode *, const Halfedge*>(NULL,NULL);
   case PARENT_EDGE: {
     Host_face hf = get_edge_parent( *v0, *v1, color);
     if ( hf.parent_type() == PARENT_EDGE) {
       // Rule 2: No three vertices on the same edge can be in the same subface.
       return  std::pair<const INode *, const Halfedge*>(NULL,NULL);
     }
     else {
       RFC_assertion( hf.parent_type() == PARENT_FACE);
       // next inode is the next one along the edge
       Halfedge *h = v1->halfedge( color);
       if ( h->facet() != hf.halfedge()->facet()) {
         h = acc.get_opposite( h);
         RFC_assertion( h->facet() == hf.halfedge()->facet());
       }
       
       INode_list &il = acc.get_inode_list( h);
       if ( !il.empty()) {
         if ( v1 == &il.front()) 
           v2 = acc.get_inode(acc.get_origin( h));
         else
           v2 = v1->prev_link[color],h->prev();
       }
       else {
         INode_list &ilr = acc.get_inode_list( acc.get_opposite(h));
         RFC_assertion( !ilr.empty());
         if ( v1 == &ilr.back())
           v2 = acc.get_inode(acc.get_origin( h));
         else
           v2 = v1->next_link[color],h->prev();
       }
       return std::pair<const INode*, const Halfedge*>(v2, h);
     }
   }
   case PARENT_VERTEX: {
     Host_face hf = get_edge_parent( *v0, *v1, color);
 
     Halfedge *h = v1->halfedge(color);
     Halfedge *j = ( (hf.parent_type() == PARENT_EDGE) ?
                     acc.get_opposite(hf.halfedge()) : hf.halfedge());
 
     while ( h->facet() != j->facet()) {
       h = acc.get_next_around_origin( h); 
       RFC_assertion( h != v1->halfedge(color));
     }
     h = h->prev();
     
     INode *v2;
     INode_list &il = acc.get_inode_list( h);
     if ( !il.empty())
       v2 = &il.back();
     else {
       INode_list &ilr = acc.get_inode_list( acc.get_opposite(h));
       if ( !ilr.empty())
         v2 = &ilr.front();
       else
         v2 = acc.get_inode( acc.get_origin( h));
     }
     return std::pair<const INode*, const Halfedge*>(v2, h);
   }
   default:
     RFC_assertion( false);
     return std::pair<const INode *, const Halfedge*>(NULL,NULL);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Overlay::Halfedge * get_parent_face	(	const Subface &	sf,
		int	color
	)

Definition at line 1841 of file Overlay.C.

References acc, contains(), get_edge_parent(), HDS_accessor< _MP >::get_opposite(), PARENT_FACE, and RFC_assertion.

Referenced by number_subfaces().

                                                       {
   RFC_assertion( sf.size()>0);
 
   Host_face f = get_edge_parent( *sf[0], *sf[1], color);
   if ( !f.halfedge()->is_border() && 
        contains( f.halfedge(), PARENT_FACE, 
                  sf[2]->halfedge(color), sf[2]->parent_type(color)))
     return f.halfedge();
   else
     return acc.get_opposite(f.halfedge());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

RFC_Window_overlay* get_rfc_window ( const COM::Window * w )

inline

Definition at line 84 of file Overlay.h.

References B, RFC_Window_base::base(), and G.

85 { return ( B->base() == w) ? B : G; }

Overlay::G

RFC_Window_overlay * G

Definition: Overlay.h:281

RFC_Window_base::base

const COM::Window * base() const

Get a reference to the base COM::Window object.

Definition: RFC_Window_base.h:557

Overlay::B

RFC_Window_overlay * B

Definition: Overlay.h:280

Here is the call graph for this function:

const RFC_Window_overlay* get_rfc_window ( const COM::Window * w ) const

inline

Definition at line 86 of file Overlay.h.

References B, RFC_Window_base::base(), and G.

87 { return ( B->base() == w) ? B : G; }

Overlay::G

RFC_Window_overlay * G

Definition: Overlay.h:281

RFC_Window_base::base

const COM::Window * base() const

Get a reference to the base COM::Window object.

Definition: RFC_Window_base.h:557

Overlay::B

RFC_Window_overlay * B

Definition: Overlay.h:280

Here is the call graph for this function:

int get_subnode_copies	(	const INode *	i,
		int	color
	)		const

private

Retrieve the number of copies for a given subnode.

Definition at line 107 of file Overlay_IO.C.

References _subnode_copies_b, _subnode_copies_g, BLUE, GREEN, INode::id(), and RFC_assertion.

                                                      {
   if ( color==BLUE) {
     int global_id = i->id();
     return _subnode_copies_b[ global_id];
   }
   else { 
     RFC_assertion( color == GREEN);
     int global_id = i->id();
     return _subnode_copies_g[ global_id];
   }
 }

Here is the call graph for this function:

int get_subnode_id	(	const INode *	i,
		int	color,
		int	pane_id
	)		const

private

Retrieve the local id within a given pane for a given subnode.

See Also: set_subnode_id

Definition at line 83 of file Overlay_IO.C.

References _subnode_ids_b, _subnode_ids_g, _subnode_imap_b, _subnode_imap_g, BLUE, GREEN, INode::id(), Node_ID::node_id, Node_ID::pane_id, and RFC_assertion.

Referenced by convert_nat_coordinates().

                                                               {
   if ( color==BLUE) {
     int global_id = i->id();
     const Node_ID &vid = _subnode_ids_b[ global_id];
 
     if ( vid.pane_id == pane_id) 
       return vid.node_id;
     else
       return _subnode_imap_b.find( global_id)->second.find( pane_id)->second;
   }
   else { RFC_assertion( color == GREEN);
     int global_id = i->id();
     const Node_ID &vid = _subnode_ids_g[ global_id];
 
     if ( vid.pane_id == pane_id)
       return vid.node_id;
     else
       return _subnode_imap_g.find( global_id)->second.find( pane_id)->second;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void insert_edge_into_queue	(	Halfedge *	h,
		INode *	v,
		std::queue< Halfedge * > &	q,
		std::queue< Halfedge * > &	q_rdg,
		std::queue< Halfedge * > &	q_crn
	)

private

Definition at line 486 of file Overlay.C.

References acc, Halfedge_overlay::destination(), HDS_accessor< _MP >::get_opposite(), GREEN, INode::halfedge(), HDS_accessor< _MP >::is_border(), HDS_accessor< _MP >::is_feature_0(), HDS_accessor< _MP >::is_feature_1(), HDS_accessor< _MP >::is_on_feature(), HDS_accessor< _MP >::mark(), HDS_accessor< _MP >::marked(), Halfedge_overlay::origin(), PARENT_EDGE, INode::parent_type(), and PARENT_VERTEX.

Referenced by intersect_blue_with_green().

                                                       {
   // If the edge or its opposite has been marked, then skip.
   if ( acc.marked( h)) return;
 
   // First, determine feature rank of origin and destination vertices.
   int frank_org = acc.is_on_feature( h->origin());
   if ( frank_org) frank_org += acc.is_feature_0( ( h->origin()));
 
   if ( frank_org != 2) { // Consider feature type of green parent.
     Parent_type pt = v->parent_type(GREEN);
     Halfedge *g = v->halfedge(GREEN);
     if ( pt == PARENT_VERTEX) {
       Vertex *gv;
       if ( acc.is_feature_0( gv=g->origin()))
         frank_org = 2; // If mapped onto a corner, consider vertex as corner
       else if ( frank_org == 0 && acc.is_on_feature( gv))
         frank_org = 1;
     }
     else if ( frank_org==0 && pt==PARENT_EDGE && acc.is_feature_1( g)) {
       frank_org = 1; // Ridge vertex
     }
   }
 
   int frank_dst = 0;
   if ( frank_org) { // Determine type of destination vertex
     frank_dst = acc.is_on_feature( ( h->destination()));
     if ( frank_dst) frank_dst += acc.is_feature_0( h->destination());
   }
 
   Halfedge *hopp = acc.get_opposite(h);
   acc.mark( h);
   if ( frank_org == 0 || frank_org < frank_dst || acc.is_border(hopp) ||
        frank_dst != 2 && !acc.is_border(hopp) && acc.marked( hopp)) { 
     // If push edge into main queue, then mark both the edge and its opposite
     q.push( h); acc.mark( hopp); 
   }
   else if ( frank_org == 2 && !acc.is_border(hopp) && acc.marked( hopp)) {
     // If I am a corner and the other edge is candidate, move into main queue
     q.push( hopp);
   }
   else if ( frank_org == 1) {
     // Otherwise, if frank_org is ridge, then push into ridge queue
     q_rdg.push( h);
   }
   else {
     // Otherwise frank_org is corner, don't push it.
     q_crn.push(h);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void insert_node_in_blue_edge	(	INode &	x,
		Halfedge *	b
	)

protected

Definition at line 187 of file Overlay.C.

Referenced by intersect_blue_with_green(), match_features_0(), and project_next_vertex().

                                                   {
   Halfedge *b = x.halfedge( BLUE);
   Halfedge *g = x.halfedge( GREEN); RFC_assertion( !acc.is_border(g));
 
   // Step 1, verify that x is not at a green vertex that already has
   //    an inode associated with. If so, merge the two inodes by making
   //    its blue parent the intersection of the two blue edges/vertices,
   //    and delete the old one.
   if ( x.parent_type( GREEN) == PARENT_VERTEX) {
     INode *i = acc.get_inode( acc.get_origin( g));
     if (i) {
       if ( i->parent_type( BLUE) == PARENT_VERTEX) {
         std::cerr << "ERROR: One-to-many mapping at green vertex "
                   << acc.get_pane(g)->get_index(g->origin())+1 
                   << " of pane " << acc.get_pane(g)->id() 
                   << " at " << g->origin()->point() 
                   << ".\n It is projected onto from blue vertices \n\t"
                   << acc.get_pane(b)->get_index(b->origin())+1 << " of pane " 
                   << acc.get_pane(b)->id() << " at " << b->origin()->point() << " and\n\t";
         b = i->halfedge(BLUE);
         std::cerr << acc.get_pane(b)->get_index(b->origin())+1 
                   << " of pane " << acc.get_pane(b)->id() 
                   << " at " << b->origin()->point() << std::endl;
         RFC_assertion(i->parent_type( BLUE) != PARENT_VERTEX); abort();
       }
       if ( !contains( i->halfedge( BLUE), i->parent_type( BLUE), 
                       b, PARENT_VERTEX)) {
         b = acc.get_next( b);
         RFC_assertion( contains( i->halfedge( BLUE), i->parent_type( BLUE), 
                                  b, PARENT_VERTEX));
       }
       x.set_parent( b, Point_2(0,0), BLUE);
     }
   }
 
   if ( x.parent_type( BLUE) == PARENT_VERTEX) {
     // Step 2a, assign blue parent
     INode *i = acc.get_inode( acc.get_origin( b));
     if ( i != NULL) {
       if ( !contains( i->halfedge( GREEN), i->parent_type( GREEN),
                       g, x.parent_type( GREEN))) {
         // Otherwise, we must correct the green parent of i by computing 
         // the intersection of the two computed parents
         if ( x.parent_type( GREEN) == PARENT_FACE) {
           Parent_type pg = i->parent_type(GREEN);
 
           bool found=false;
           if ( pg ==PARENT_FACE) {
             // Find the intersection of the two faces
             Halfedge *h = g; RFC_assertion( !acc.is_border(h));
             do {
               if ( contains( i->halfedge( GREEN), pg, h, PARENT_EDGE)) { 
                 // the edge is the intersection of the two
                 Point_2 nc = get_nat_coor( x, Generic_element(count_edges(g)),
                                            h, GREEN);
                 RFC_assertion( nc[0]>0 && nc[0]<1 && nc[1]>0 && nc[1]<0.5);
                 x.set_parent( g, Point_2(nc[0],0), GREEN);
 
                 found = true; 
                 break; 
               }
             } while ( (h=acc.get_next( h)) != g);
           }
 
           if ( !found) {
             // Search for the common vertex 
             Halfedge *h = g;
             do {
               if ( contains( i->halfedge( GREEN), pg,  h, PARENT_VERTEX)) {
                 g = h; x.set_parent( g, Point_2(0,0), GREEN); 
                 
                 found = true; 
                 break; 
               }
             } while ( (h=acc.get_next( h)) != g);
             RFC_assertion( found);
           }
         }
         else { // green parent of x is not a face.
           if ( x.parent_type(GREEN)==PARENT_EDGE &&
                x.parent_type( GREEN) == i->parent_type( GREEN) &&
                !contains( i->halfedge( GREEN), i->parent_type( GREEN),
                           g, PARENT_VERTEX)) {
             g = acc.get_next( g);
             RFC_assertion(contains(i->halfedge( GREEN), i->parent_type( GREEN),
                                    g, PARENT_VERTEX));
           }
           RFC_assertion( acc.get_inode(acc.get_origin(g))==NULL ||
                          acc.get_inode(acc.get_origin(g))->parent_type(BLUE)
                          == PARENT_EDGE);
 
           x.set_parent( g, Point_2(0,0), GREEN);
 
           if ( !contains( i->halfedge( GREEN), i->parent_type( GREEN),
                           g, x.parent_type( GREEN))) {
             std::cerr << "ERROR: One-to-many mapping at blue vertex "
                       << acc.get_pane(b)->get_index(b->origin())+1 
                       << " of pane " << acc.get_pane(b)->id() 
                       << " at " << b->origin()->point() 
                       << ". It projects onto \n\tgreen vertex "
                       << acc.get_pane(g)->get_index(g->origin())+1 << " of pane " 
                       << acc.get_pane(g)->id() << " at " << g->origin()->point() 
                       << " and\n\tgreen ";
             switch (i->parent_type(GREEN)) {
             case PARENT_VERTEX: std::cerr << "vertex"; break;
             case PARENT_EDGE: std::cerr << "edge"; break;
             case PARENT_FACE: std::cerr << "face incident on"; break;
             default: ;
             }
             g = i->halfedge(GREEN);
             std::cerr << " (" 
                       << acc.get_pane(g)->get_index(g->origin())+1 << ","
                       << acc.get_pane(g)->get_index(g->destination())+1
                       << ") of pane " << acc.get_pane(g)->id() << " at (" 
                       << g->origin()->point() << "," 
                       << g->destination()->point() << ")." << std::endl;
 
             RFC_assertion( contains( i->halfedge( GREEN), i->parent_type( GREEN),
                                      g, x.parent_type( GREEN))); abort();
           }
         }
       }
       delete i; i=NULL;
     }
     acc.set_inode( acc.get_origin( b), &x);
 
     // Step 3a
     // Delete the inconsistent inodes on adjacent edges of b
     Halfedge *h = b;
     do {
       INode_list &il = acc.get_inode_list( h);
       if ( !il.empty()) {
         // Throw away the false intersection points.
         while ( ! il.empty()) {
           INode *i=&il.front();
           
           if ( contains( i->halfedge( GREEN), i->parent_type( GREEN), 
                          g, x.parent_type( GREEN))) {
             il.pop_front();
             delete i; i=NULL;
           }
           else
             break;
         }
       }
       else {
         INode_list &ilr = acc.get_inode_list( acc.get_opposite(h));
         // Throw away the false intersection points.
         while ( ! ilr.empty()) {
           INode *i=&ilr.back();
           
           if ( contains( i->halfedge( GREEN), i->parent_type( GREEN), 
                          g, x.parent_type( GREEN))) {
             ilr.pop_back();
             delete i; i=NULL;
           }
           else
             break;
         }
       }
     } while ( ( h = acc.get_next_around_origin( h)) != b);
   }
   else {
     // If x is on a blue edge, remove the inconsistent ones
     RFC_assertion( x.parent_type( BLUE) == PARENT_EDGE && b1==b);
 
     // Step 3b
     INode_list &il = acc.get_inode_list( b);
     // Throw away the false intersection points.
     while ( !il.empty()) {
       INode *i=&il.back();
       if ( i->nat_coor(BLUE)[0] >= x.nat_coor(BLUE)[0]) {
         std::cerr << "WARNING: Intersections are out-of-order on blue edge ("
                   << acc.get_pane(b)->get_index(b->origin())+1 << ","
                   << acc.get_pane(b)->get_index(b->destination())+1
                   << ") on pane " << acc.get_pane(b)->id() << " at ("
                   << b->origin()->point() << "," << b->destination()->point()
                   << ").\n\tPrevious intersection was " 
                   << i->nat_coor(BLUE)[0]
                   << " but current one is at " << x.nat_coor(BLUE)[0] 
                   << " and green parameterization is "
                   << x.nat_coor(GREEN)[0]  << "." << std::endl;
 
         RFC_assertion( std::abs(i->nat_coor(0)[0] - x.nat_coor(0)[0]) < 0.1);
         RFC_assertion( i->parent_type( GREEN) != PARENT_VERTEX);
 
         if ( !contains( i->halfedge( GREEN), i->parent_type( GREEN),
                         g, PARENT_VERTEX) &&
              !contains( i->halfedge( GREEN), i->parent_type( GREEN),
                         g->next(), PARENT_VERTEX)) {
           std::cerr << "Cannot be continued. Stopping..." << std::endl;
           abort();
         }
         
         // Otherwise, we must correct the green parent of i by computing 
         // the intersection of the two computed parents
         if ( !contains( i->halfedge( GREEN), i->parent_type( GREEN),
                         g, PARENT_VERTEX))
           g = acc.get_next( g);
         
         x.set_parent( g, Point_2(0,0), GREEN);
 
         { // Determine the blue parameterization of x based on closest point 
           // of the green vertex on the blue edge.
           Vector_3 t = b->destination()->point()-b->origin()->point();
           Real c = (g->origin()->point()-b->origin()->point())*t / (t*t);
           
           // If snapped onto a blue vertex, then call recursively.
           if ( c>=1-eps_e) {
             x.set_parent( b->next(), Point_2(0,0), BLUE);
             insert_node_in_blue_edge( x, x.halfedge(BLUE)); return;
           }
           else if ( c<=eps_e) {
             x.set_parent( b, Point_2(0,0), BLUE); 
             insert_node_in_blue_edge( x, x.halfedge(BLUE)); return;
           }
 
           // Otherwise, pop the neighbor vertex.
           x.set_parent( b, Point_2(c,0), BLUE);
         }
       }
       
       if ( contains( i->halfedge( GREEN), i->parent_type( GREEN), 
                      g, x.parent_type( GREEN))) {
         il.pop_back();
         delete i; i=NULL;
       }
       else
         break;
     }
     il.push_back( x);
   }
 
   // If x is a vertex and b is border, change to a nonborder edge.
   if ( x.parent_type(BLUE) == PARENT_VERTEX && acc.is_border( b)) {
     b = acc.get_next_around_origin(b);
     x.set_parent( b, Point_2(0,0), BLUE);
   }
 
   // If the green parent of x is a vertex, associate x with the green vertex.
   if ( x.parent_type(GREEN) == PARENT_VERTEX) {
     RFC_assertion(g==x.halfedge(GREEN));    
     acc.set_inode( acc.get_origin(g), &x);
   }
 
   // Output some debugging information.
   static int count=0, countmax=10;
   if ( verbose && count<countmax) {
     if ( x.parent_type(BLUE) == PARENT_VERTEX) {
       b = x.halfedge(BLUE);
       double dist = ( b->origin()->point() -
                       op.get_point( x.halfedge(GREEN), x.nat_coor(GREEN))).squared_norm();
 
       if ( dist > 0.1*(b->destination()->point()-
                        b->origin()->point()).squared_norm()) {
         if ( count == 0) std::cout << std::endl;
         std::cout << "WARNING: Distance from blue vertex " 
                   << acc.get_pane(b)->get_index(b->origin())+1 
                   << " of pane " << acc.get_pane(b)->id() 
                   << " at " << b->origin()->point() 
                   << " to green mesh is relatively large: " << std::sqrt(dist) << std::endl;
 
         if ( count++==0) {
           std::cout << "Note: Only " << countmax << " such warnings " 
                     << " will be printed." << std::endl;
         }
       }
     }
     else if ( x.parent_type(GREEN) == PARENT_VERTEX) {
       g = x.halfedge( GREEN);
       double dist = ( g->origin()->point() -
                       op.get_point( x.halfedge(BLUE), x.nat_coor(BLUE))).squared_norm();
       
       if ( dist > 0.1*( g->destination()->point()-
                         g->origin()->point()).squared_norm()) {
 
         if ( count == 0) std::cout << std::endl;
         std::cout << "WARNING: Distance from green vertex " 
                   << acc.get_pane(g)->get_index(g->origin())+1 
                   << " of pane " << acc.get_pane(g)->id() 
                   << " at " << g->origin()->point() 
                   << " to blue mesh is relatively large: " << std::sqrt(dist) << std::endl;
 
         if ( count++==0) {
           std::cout << "NOTE: Only " << countmax << " such warnings" 
                     << " will be printed." << std::endl;
         }
       }
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void insert_node_in_green_edge	(	INode *	v,
		int	tag
	)

protected

Definition at line 856 of file Overlay.C.

References acc, HDS_accessor< _MP >::get_buffered_inode(), HDS_accessor< _MP >::get_inode(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_origin(), GREEN, INode::halfedge(), HDS_accessor< _MP >::is_border(), INode::nat_coor(), In_place_list_n_base< T, n >::next_link, PARENT_EDGE, PARENT_FACE, INode::parent_type(), PARENT_VERTEX, In_place_list_n_base< T, n >::prev_link, RFC_assertion, HDS_accessor< _MP >::set_buffered_inode(), INode::set_parent(), v, x, and y.

Referenced by sort_on_green_edges().

                                               {
   switch ( v->parent_type( GREEN)) {
   case PARENT_VERTEX: {
     RFC_assertion(acc.get_inode(acc.get_origin(v->halfedge( GREEN)))==v);
     return;
   }
   case PARENT_EDGE: {
     Halfedge *g = v->halfedge( GREEN), *gopp=acc.get_opposite(g);
     if ( !acc.is_border(gopp) && g>gopp) {
       g = gopp;
       v->set_parent( gopp, Point_2( 1.-v->nat_coor(GREEN)[0],0.), GREEN);
     }
     INode *y = acc.get_buffered_inode( g, tag);
     
     if ( y ) {
       INode *x = v;
 
       if ( y->nat_coor(GREEN)[0] > x->nat_coor(GREEN)[0]) {
         RFC_assertion(x->next_link[GREEN] == NULL || x->next_link[GREEN] == y);
         RFC_assertion(y->prev_link[GREEN] == NULL || y->prev_link[GREEN] == x);
         x->next_link[GREEN] = y; y->prev_link[GREEN] = x;
       }
       else {
         RFC_assertion(x->prev_link[GREEN] == NULL || x->prev_link[GREEN] == y);
         RFC_assertion(y->next_link[GREEN] == NULL || y->next_link[GREEN] == x);
         x->prev_link[GREEN] = y; y->next_link[GREEN] = x;
       }
     }
     // Otherwise, store the node
     else
       acc.set_buffered_inode( g, tag, v);
   }
   case PARENT_FACE:
     return;
   default:
     RFC_assertion(false);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void intersect_blue_with_green ( )

protected

Definition at line 572 of file Overlay.C.

Referenced by overlay().

                             {
   // Precondition: None of the blue halfedges is marked.
   std::queue<Halfedge*>   q, q_rdg, q_crn;
 
 for ( int ncomp=1; ;++ncomp) { // Top loop over connected components.
   INode *seed = overlay_init();
   if ( seed==NULL) return; // If all halfedges are marked, then stop.
   RFC_assertion( seed->parent_type( BLUE) == PARENT_VERTEX);
   Halfedge *b = seed->halfedge( BLUE), *h=b;
   
   if ( verbose) {
     if ( ncomp>1) 
       std::cout << "There appear to be multiple connected components "
                 << "in the input mesh.\n\tWorking on component " 
                 << ncomp << std::endl;
     else
       std::cout << "\nThe input meshes have " 
                 << ( is_opposite ? "opposite orientations" : 
                      "the same orientation") << std::endl;
     
     std::cout << "Starting with seed vertex " 
               << acc.get_pane(b)->get_index(b->origin())+1 
               << " in pane " << acc.get_pane(b)->id() << " of blue mesh at "
               << b->origin()->point() << std::endl;
   }
 
   // Embed the seed into the blue vertex, (and the green vertex if its
   //       green parent is a vertex.)
   insert_node_in_blue_edge( *seed, seed->halfedge(BLUE));
   do {
     insert_edge_into_queue( h, seed, q, q_rdg, q_crn);
   } while ( (h = acc.get_next_around_origin(h)) != b);
 
   while ( !is_queue_empty( q, q_rdg, q_crn)) {
     Halfedge *b = q.front(); q.pop();
     Halfedge *bopp=acc.get_opposite(b);
 
     INode_list &il = acc.get_inode_list( b);
     INode *x = acc.get_inode( acc.get_origin(b));
     Vertex *dst = acc.get_destination(b);
     INode *idst= acc.get_inode( dst);
     
     bool is_feature = acc.get_pane(b)->is_feature_1( b);
     bool is_border = acc.is_border(b) || acc.is_border( acc.get_opposite(b));
     bool is_dst_feature = is_feature || acc.is_on_feature( dst);
     bool is_dst_border = is_border || acc.is_border( dst);
 
     // This is to snap open-ends of features.
     const Real tol_snap_fea = 0.2, tol_snap_border = 2./3.;
     Real  cb=0, cg;
 
     for (;;) {
       if (x->parent_type( BLUE)==PARENT_VERTEX &&
           acc.get_origin(x->halfedge( BLUE))==dst ||
           idst && get_edge_parent(*x,*idst,GREEN)!=Host_face(NULL,PARENT_NONE))
         break; // The last two inodes on the edge are adjacent
 
       Halfedge   *g1, *g0, *g2;
       Parent_type t1, t0, t2;
 
       if ( il.empty()) {
         INode *iorg = acc.get_inode( acc.get_origin(b));
         g1 = iorg->halfedge( GREEN); t1 = iorg->parent_type( GREEN);
         g0 = NULL; t0 = PARENT_NONE;
       }
       else {
         INode_list::iterator it=--il.end();
         g1 = it->halfedge( GREEN); t1 = it->parent_type( GREEN);
         if ( it==il.begin()) {
           INode *iorg = acc.get_inode( acc.get_origin(b));
           g0 = iorg->halfedge( GREEN); t0 = iorg->parent_type( GREEN);
         }
         else {
           --it; g0 = it->halfedge( GREEN); t0 = it->parent_type( GREEN);
         }
       }
 
       // Compute the intersection of b with the edges in the link
       //    of <g1,t1> but not in the star of <g0, t0>.
       Real start = cb;
       intersect_link( x, b, g0, t0, g1, t1, start, &cb, &cg, &g2, &t2);
       
       // If current edge is a ridge edge, then attempt to snap it onto ridge.
       if ( is_feature && cb < 1 && cb > 0) {
         op.snap_blue_ridge_edge( b, g2, &cb, &cg, &t2, 
                                  is_border ? tol_snap_border : tol_snap_fea);
       }
       else if ( !is_feature && cb < 1 && 
                 ( is_dst_feature && cb>1-tol_snap_fea && 
                   (t2 == PARENT_VERTEX && acc.is_on_feature(g2->origin()) ||
                    t2 == PARENT_EDGE && acc.is_feature_1(g2)) ||
                   is_dst_feature && cb>1-tol_snap_border &&
                   (t2 == PARENT_VERTEX && acc.is_border(g2->origin()) ||
                    t2 == PARENT_EDGE && acc.is_border(g2)))) {
         // Enforce snapping vertex onto feature/border
         cb = 1 + tol_snap_fea; 
         t2 = PARENT_EDGE;
       }
 
       Point_2 nc(cg,0.);
       RFC_assertion( t2 != PARENT_NONE);
       if ( cb > 1) { // If intersects beyond the end point, do projection.
         RFC_assertion( t2 != PARENT_VERTEX);
         bool onto=op.project_onto_element( dst->point(),&g2,&t2,
                                            Vector_3(0,0,0), &nc, eps_e, 0.2);
         RFC_assertion( onto);
       }
 
       if ( is_dst_feature && t2 != PARENT_VERTEX && cb>=1) {
         op.snap_blue_ridge_vertex( dst, &g2, &t2, &nc, is_dst_border ?
                                    tol_snap_border : tol_snap_fea);
       }
 
       // Create an inode for the intersection point.
       x = new INode();
       if ( cb < 1)
         x->set_parent( b, Point_2( cb, 0), BLUE);
       else
         x->set_parent( bopp, Point_2(0,0), BLUE);
 
       if ( nc[0] == 1.) {
         nc[0] = 0;
         g2 = !acc.is_border( g2) ? g2->next() : acc.get_opposite(g2);
       }
 
       static int count=0, countmax = 10;
       if ( verbose && count < countmax) {
         if ( acc.is_border( dst) && cb>=1 && acc.get_inode( dst)==NULL && 
              !( t2 == PARENT_EDGE && acc.is_border(acc.get_opposite(g2)) ||
                 t2 == PARENT_VERTEX && acc.is_border(g2->origin()))) {
           if ( count == 0) std::cerr << std::endl;
           std::cerr << "WARNING: Blue border vertex " << b->destination()->point()
                     << " is not matched with green boundary" << std::endl;
           ++count;
         }
         else if ( is_border && cb>0 && cb<1 && 
                   !( t2 == PARENT_EDGE && acc.is_border(acc.get_opposite(g2)) ||
                      t2 == PARENT_VERTEX && acc.is_border(g2->origin()))) {
 
           if ( count == 0) std::cerr << std::endl;
           std::cerr << "WARNING: Blue border edge " << b->origin()->point() 
                     << b->destination()->point()
                     << " is not matched with green boundary " << std::endl;
           ++count;
         }
 
         if ( is_dst_feature && cb>=1 && acc.get_inode( dst)==NULL && 
              !( t2 == PARENT_EDGE && acc.get_pane(g2)->is_feature_1(g2) ||
                 t2 == PARENT_VERTEX && acc.is_on_feature(g2->origin()))) {
           std::cerr << "WARNING: Blue ridge vertex " << b->destination()->point()
                     << " is not matched with green ridge. cb is " << cb
                     << " and nc is " << nc << std::endl;
           ++count;
         }
         else if ( is_feature && cb<1 && 
                   !( t2 == PARENT_EDGE && acc.get_pane(g2)->is_feature_1(g2) ||
                      t2 == PARENT_VERTEX && acc.is_on_feature(g2->origin()))) {
           std::cerr << "WARNING: Blue ridge edge " << b->origin()->point() 
                     << b->destination()->point()
                     << " is not matched with green ridge. cb is " << cb
                     << " and nc is " << nc << std::endl;
           ++count;
         }
       }
 
       x->set_parent( g2, nc, GREEN);
       
       insert_node_in_blue_edge( *x, b);
     }
 
     // Copy inode from border edge into neighbor edge
     if ( acc.is_border( b) && !il.empty()) {
       INode_list &ilr = acc.get_inode_list( bopp);
 
       while ( !il.empty()) {
         INode &i =  il.front(); il.pop_front();
         ilr.push_front( i); 
         i.set_parent( bopp, Point_2(1-i.nat_coor(BLUE)[0],0), BLUE);
       }
     }
 
     // Push unvisited incident halfedges of b->destination() into q.
     Halfedge *h;  h = acc.get_next(b);
 
     do {
       // Push the edge into queue and mark it as nonzero.
       insert_edge_into_queue( h, x, q, q_rdg, q_crn);
     } while ( ( h = acc.get_next_around_origin( h)) != bopp);
   }
  } // end for
 
   // Unmark all the halfedges of B
   B->unmark_alledges();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool intersect_link	(	const INode *	x,
		const Halfedge *	b,
		const Halfedge *	g0,
		const Parent_type	t0,
		Halfedge *	g1,
		const Parent_type	t1,
		Real	start,
		Real *	cb,
		Real *	cg,
		Halfedge **	g,
		Parent_type *	t,
		int	tryindex = `0`
	)

protected

Definition at line 1251 of file Overlay.C.

References acc, contains(), Halfedge_overlay::destination(), RFC_Pane_overlay::get_index(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_origin(), HDS_accessor< _MP >::get_pane(), HDS_accessor< _MP >::get_prev(), RFC_Pane_base::id(), intersect_link_helper(), intersect_link_helper2(), Halfedge_overlay::is_border(), HDS_accessor< _MP >::is_border(), HDS_accessor< _MP >::is_feature_1(), Halfedge_overlay::next(), Halfedge_overlay::origin(), PARENT_EDGE, PARENT_FACE, PARENT_VERTEX, Vertex_overlay::point(), Halfedge_overlay::prev(), RFC_assertion, and v.

Referenced by intersect_blue_with_green().

                                              {
 
   bool found = false, is_feature = acc.is_feature_1(b);
   bool is_border= acc.is_border(b) || acc.is_border(acc.get_opposite(b));
   *cb = *cg = HUGE_VAL;
   *g = NULL;
 
   switch ( t1) {
   case PARENT_FACE: {
     RFC_assertion( !g1->is_border());
     // Loop through the edges of the face
     Halfedge *g2 = g1;
     do {
       int snapcode = is_feature ? 4 : 0;
 
       if ( intersect_link_helper( b, g2, start, cb, cg, g, t, &found, 
                                   snapcode, NULL, trytime)) {
         if ( found) return true;
         else return intersect_link_helper2( cb, cg, g, t);
       }
     } while ( ( g2 = g2->next()) != g1);
 
     break;
   }
   case PARENT_EDGE: {
     Halfedge *g1_0=g1;  
 
     // if g1 intersects b from left to right
     do {
       if ( g1->is_border() || contains( g1, PARENT_FACE, g0, t0)) continue;
       Halfedge *g2 = g1->next();
       
       do {
         int snapcode = 0;
         if (is_feature) {
           snapcode = 4;
           if ( is_border && acc.is_border( acc.get_opposite(g1)) || 
                !is_border && acc.is_feature_1( g1)) {
             if ( g2->prev()==g1) snapcode += 1;
             else if (g2->next()==g1) snapcode += 2;
           }
         }
 
         if ( intersect_link_helper( b, g2, start, cb, cg, g, t, &found, 
                                     snapcode, NULL, trytime)) {
           if ( found) return true;
           else return intersect_link_helper2( cb, cg, g, t);
         }
       } while ( ( g2 = g2->next()) != g1);
     } while ( ( g1 = acc.get_opposite(g1)) != g1_0);
 
     break;
   }
   case PARENT_VERTEX: {
     Halfedge *g1_0=g1, *g1_1; 
     Vertex   *v = acc.get_origin(g1);
 
     do {
       g1_1 = acc.get_prev(g1);
       if ( g1->is_border() || contains( g1, PARENT_FACE, g0, t0)) continue;
       Halfedge *g2 = g1->next();
       do {
         int snapcode = 0;
         if (is_feature) {
           snapcode = 4;
 
           if ( is_border &&  acc.is_border( acc.get_opposite(g2->prev())) ||
                !is_border && acc.is_feature_1( g2->prev()) &&
                contains(g2->prev(), PARENT_EDGE, g1, PARENT_VERTEX)) 
             snapcode += 1;
           if (  is_border &&  acc.is_border( acc.get_opposite(g2->next())) ||
                !is_border && acc.is_feature_1( g2->next()) &&
                 contains(g2->next(), PARENT_EDGE, g1, PARENT_VERTEX))
             snapcode += 2;
         }
 
         if ( intersect_link_helper( b, g2, start, cb, cg, g, t, &found, 
                                     snapcode, v, trytime))  {
           if ( found) return true;
           else return intersect_link_helper2( cb, cg, g, t);
         }
       } while ( ( g2 = g2->next()) != g1_1);
     } while ( ( g1 = acc.get_opposite(g1_1)) != g1_0);
 
     break;
   }
   default:
     RFC_assertion( false);
     break;
   }
 
   if (found) return true;   
   if ( *cb < HUGE_VAL) return intersect_link_helper2( cb, cg, g, t);
 
   if ( trytime==0) {
     // Print out error messages
     std::cerr << "WARNING: Encountered inconsistency when intersecting blue edge ("
               << acc.get_pane(b)->get_index(b->origin())+1 << ","
               << acc.get_pane(b)->get_index(b->destination())+1 << ") in pane "
               << acc.get_pane(b)->id() << " at \n\t("
               << b->origin()->point() << "), (" << b->destination()->point()
               << ") \nwith the link of the ";
     if ( t1 == PARENT_FACE)   std::cerr << "green face incident on";
     if ( t1 == PARENT_EDGE)   std::cerr << "green";
     if ( t1 == PARENT_VERTEX) std::cerr << "source vertex of green";
     std::cerr << " halfedge (" << acc.get_pane(g1)->get_index(g1->origin())+1 
               << ","  << acc.get_pane(g1)->get_index(g1->destination())+1 
               << ") in pane " << acc.get_pane(g1)->id() << " at \n\t("
               << g1->origin()->point() << "), (" 
               << g1->destination()->point() << ")." << std::endl;
 
     // One more try with print info
     intersect_link( x, b, g0, t0, g1, t1, start, cb, cg, g, t, 1);
 
     if ( *cb < HUGE_VAL) {
       std::cerr << "WARNING: Input meshes appear to have severe normal mismatch." << std::endl;
       std::cerr << "WARNING: Trying to continue with relaxed normal matching.\n\n"      << std::endl;
     }
     else {
       // Continue with projecting onto face
       *cb = HUGE_VAL; *cg = HUGE_VAL; *t = PARENT_FACE;
       if ( *g == NULL || t1==PARENT_VERTEX) *g = g1;
       std::cerr << "WARNING: Could not find edge intersection." << std::endl;
       std::cerr << "WARNING: Trying to recover with point projection.\n\n" << std::endl;
     }
   }
 
   return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool intersect_link_helper	(	const Halfedge *	b,
		Halfedge *	g2,
		Real	start,
		Real *	cb,
		Real *	cg,
		Halfedge **	g,
		Parent_type *	t,
		bool *	found,
		int	snapcode,
		const Vertex *	anchor,
		bool	panic
	)

protected

Definition at line 1058 of file Overlay.C.

References NTS::abs(), acc, contains(), Halfedge_overlay::destination(), do_intersect(), eps_e, eps_p, Halfedge_overlay::facet(), HDS_accessor< _MP >::get_destination(), HDS_accessor< _MP >::get_next(), HDS_accessor< _MP >::get_origin(), Overlay_primitives::intersect(), Halfedge_overlay::is_border(), is_opposite, Halfedge_overlay::next(), Overlay_primitives::normalmatch(), op, Halfedge_overlay::origin(), PARENT_EDGE, PARENT_FACE, PARENT_VERTEX, Vertex_overlay::point(), Halfedge_overlay::prev(), RFC_assertion, and verbose.

Referenced by intersect_link().

                                                          {
   RFC_assertion( !g2->is_border());
 
   Real tcb, tcg;     // Parameterization of intersection on b and g2
   Real orient_match; // To what degree [0..1] b and g2 are counterclockwise
   Real normal_match; // To what degree [0..1] the intersection have same normal
 
   // Tolerance for normal matching
   const Real tol_nm_large = 0.6, tol_nm_small=0.3; // about 50 and 80 degrees
   const Real tol_nm = panic ? tol_nm_small : tol_nm_large;
   const Real tol_proj=0.5, tol_snap=0.2;
 
   bool do_intersect = op.intersect( b, g2, start, &tcb, &tcg, &orient_match,
                                     &normal_match, is_opposite, eps_e);
   do_intersect &= (normal_match >= tol_nm);
 
   if ( verbose && panic) {
     std::cerr << "INFO: Intersection with green edge (" 
               << g2->origin()->point() << "," << g2->destination()->point()
               << ") is at bparam=" << tcb << ", gparam=" << tcg << std::endl;
     
     if ( tcb<HUGE_VAL) {
       std::cerr << "\t inner product of normals equal to " 
                 << normal_match << std::endl;
 
       if ( normal_match<tol_nm_large) {
         std::cerr << "WARNING: Intersection was rejected due to normal mismatch under tolerance " 
                   << tol_nm_large << std::endl;
         
         if ( normal_match > tol_nm_small) {
           std::cerr << "WARNING: Trying with reduced normal-matching tolerance of " 
                     << tol_nm_small << std::endl;
         }
       }
     }
   }
 
   if ( do_intersect && tcb == 0) {
     // Inconsistency detected. It has backfired!
     // Or we need to snap to feature edge if nothing else works.
     *cb = 0.; *g = g2; *cg = tcg; *found=false;
     *t = ( tcg==0 || tcg==1) ? PARENT_VERTEX : PARENT_EDGE;
 
     return true;
   }
 
   if ( (tcb*eps_e > 1.) || orient_match < -eps_p || 
        normal_match < tol_nm || tcb<0.) {
     if ( *cb == HUGE_VAL) *g = g2; // Keep a record of the last intersection.
 
     // Do not treat it as fatal inconsistency because this might
     // happen at locations with large curvature and trying to repair it
     // can fail the algorithm. Instead, we simply ignore this intersection.
     return false;
   }
 
   if ( verbose && snapcode == 7 && tcg > tol_snap && tcg < 1-tol_snap ) {
     std::cerr << "WARNING: Blue edge (" << b->origin()->point() 
               << ", " << b->destination()->point()
               << " appears to walk over a green corner "
               << g2->prev()->origin()->point()
               << " in an ambiguous way. This may cause overlay to failure. " 
               << std::endl;
   }
 
   if ( do_intersect) {
     bool case1;
     if ( ( case1 = tcg == 1. || snapcode==6 || snapcode==7 && 
            op.normalmatch(b, g2->next()) > op.normalmatch( b, g2->prev())) || 
          tcg == 0. || snapcode==5 || snapcode==7 && 
          op.normalmatch(b, g2->next()) < op.normalmatch( b, g2->prev()) || 
          ( case1 = *found && tcg>0.5 && 
            contains( *g, *t, acc.get_next(g2), PARENT_VERTEX)) ||
          *found && tcg<0.5 && contains( *g, *t, g2, PARENT_VERTEX)) { 
       *g = case1 ? acc.get_next(g2) : g2; *t = PARENT_VERTEX; *cg = 0.; 
       if ( *found && *cb >1 && *cb < 1+tol_proj || tcb == 1) *cb = 1;
       else if ( !*found || tcb < *cb) *cb = tcb;
 
       *found = true;
     }
     else if ( !*found || !snapcode && tcb < *cb ||
               snapcode && std::abs(0.5-tcg)>std::abs(0.5-*cg)) 
     { *g = g2; *t = PARENT_EDGE; *cg = tcg; *cb = tcb; *found = true; }
   }
   else if ( tcg >=0. && tcg <= 1.) {
     RFC_assertion( tcb > 1.); // Otherwise, they would have intersected.   
 
     bool case1;
     if ( ( case1 = tcg == 1. || snapcode==6 || snapcode==7 && 
            op.normalmatch(b, g2->next()) > op.normalmatch( b, g2->prev())) || 
          tcg == 0. || snapcode==5 || snapcode==7 && 
          op.normalmatch(b, g2->next()) < op.normalmatch( b, g2->prev()) || 
          *found && *t != PARENT_VERTEX && g2->facet()!=(*g)->facet() &&
          ( ( case1 = tcg>0.5 && contains( *g, *t, acc.get_next(g2), PARENT_VERTEX)) ||
            tcg<0.5 && contains( *g, *t, g2, PARENT_VERTEX))) {
 
       if ( *found && *cb <= 1) 
       { *g = case1 ? g2->next() : g2; *t = PARENT_VERTEX; *cg = 0.; *cb = 1; }
       else if ( case1) { 
         *g = g2->next(); *cg = 0;
         *t = (acc.get_destination( *g) == anchor) ? PARENT_EDGE : PARENT_FACE; 
 
         if ( !*found || tcb < *cb) *cb = tcb; 
       }
       else {
         *g = g2->prev(); *cg = 1.; 
         *t = (acc.get_origin( *g) == anchor) ? PARENT_EDGE : PARENT_FACE; 
 
         if ( !*found || tcb < *cb) *cb = tcb; 
       }
 
       *found = true;
     }
     else if ( !*found || !snapcode && tcb < *cb ||
               snapcode && std::abs(0.5-tcg)>std::abs(0.5-*cg))
     { *cg = tcg; *g = g2; *t = PARENT_FACE; *cb = tcb; *found = true; }
   }
   else if ( !*found && tcb>=0) {
     bool case1;
     if ( *cb > 0 && *cb < HUGE_VAL && 
          *t != PARENT_VERTEX && g2->facet() != (*g)->facet() &&
          ( ( case1 = tcg>0.5 && contains( *g, *t, acc.get_next(g2), PARENT_VERTEX)) ||
            tcg<0.5 && contains( *g, *t, g2, PARENT_VERTEX))) {
 
       if ( tcb > 1 && *cb >1) {
         *g = case1 ? g2->next() : g2->prev(); *t = PARENT_EDGE; *cg = case1 ? 0. : 1.; 
         if ( tcb < *cb) *cb = tcb; 
       }
       else {
         *g = case1 ? acc.get_next(g2) : g2; *t = PARENT_VERTEX; *cg = 0.; 
         if ( tcb ==1 || tcb >1 && tcb < 1+tol_proj && *cb < 1 || 
              tcb<=1 && *cb > 1 && *cb < 1+tol_proj)
           *cb = 1;
         else if ( tcb < *cb) *cb = tcb;
       }
     }
     else if ( *cb == HUGE_VAL || 
               *cg < tcg && tcg < 0 || *cg > tcg && tcg > 1) {
       // NOTE: cg is not used outside intersect_link if *cb>1, but we
       //       need to keep the value of tcg for later comparisons 
       if (  tcg <0 && tcb>1 && acc.get_origin( g2->prev()) == anchor)
       { *g = g2->prev(); *t = PARENT_EDGE; }
       else if ( tcg>1 && tcb>1 && acc.get_destination( g2->next()) == anchor) 
       { *g = g2->next(); *t = PARENT_EDGE; }
       else
       { *g = g2; *t = PARENT_FACE; }
       
       *cb = tcb; *cg = tcg;
     }
   }
 
   return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool intersect_link_helper2	(	Real *	cb,
		Real *	cg,
		Halfedge **	g,
		Parent_type *	t
	)

protected

Definition at line 1223 of file Overlay.C.

References acc, HDS_accessor< _MP >::get_next(), PARENT_EDGE, and PARENT_VERTEX.

Referenced by intersect_link().

                                         {
   if ( *cb > 1.) {
     if ( *cg>1) { *cg = 1; } else if ( *cg <0) { *cg = 0.; }
     return true; // Preserve the parent-type.
   }
   else {
     // Otherwise, there is an inconsistency. 
     if ( *cb <=0.) *cb = 0.;
 
     if ( *cg > 0. && *cg < 1.){ *t = PARENT_EDGE; }
     else if ( *cg >= 1.)
     { *g = acc.get_next(*g); *t = PARENT_VERTEX; *cg = 0.; }
     else if ( *cg <= 0.) 
     { *t = PARENT_VERTEX; *cg = 0.; }
     return false;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_queue_empty	(	std::queue< Halfedge * > &	q,
		std::queue< Halfedge * > &	q_rdg,
		std::queue< Halfedge * > &	q_crn
	)

private

Definition at line 546 of file Overlay.C.

References acc, HDS_accessor< _MP >::get_opposite(), i, HDS_accessor< _MP >::mark(), and HDS_accessor< _MP >::marked().

Referenced by intersect_blue_with_green().

                                                {
   if ( !q.empty()) return false;
 
   for ( int i=0; i<2; ++i) {
     std::queue<Halfedge*>   &qbuf = (i==0) ? q_rdg : q_crn;
     while ( !qbuf.empty()) {
       Halfedge *h = qbuf.front(); qbuf.pop();
       Halfedge *hopp = acc.get_opposite(h);
       if ( !acc.marked( hopp)) {
         q.push( h); acc.mark( acc.get_opposite(h));
         return false;
       }
     }
   }
 
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool logical_xor	(	bool	a,
		bool	b
	)		const

inlineprivate

Definition at line 277 of file Overlay.h.

Referenced by project_adjacent_green_vertices().

277 { return a&&!b || !a&&b; }

Here is the caller graph for this function:

void match_features_0 ( )

protected

Definition at line 51 of file Overlay_0d.C.

Referenced by overlay().

                    {
  
   const Real w2e_ratio = 1;
   const Real d2e_ratio_sq = 1;
   
   std::list<Feature_0>  &bf0 = B->flist_0();
   std::list<Feature_0>  &gf0 = G->flist_0();
   
   std::vector< Point_3_ref> gf0_1;
   gf0_1.reserve( gf0.size());
   for ( std::list<Feature_0>::iterator it=gf0.begin(); it!=gf0.end(); ++it)
     gf0_1.push_back( Point_3_ref( it->point(), it->vertex()));
 
   // Create a 3-dimensional KD-tree for the 0-features of green mesh
   KD_tree kdtree(3); kdtree.build( gf0_1);
 
   int dropped=0;
   // Query every 0-feature of the blue mesh in the KD-tree to find
   //      whether there is a unique corresponding one in the other mesh.
   for ( std::list<Feature_0>::iterator
           it=bf0.begin(), iend=bf0.end(); it != iend; ++it) {
     Vertex *v = it->vertex();
     // Find the corresponding green feature of *it in the KD-tree
     const Point_3 &p = v->point();
 
     // Compute the tolerance.
     Real tol=HUGE_VAL;
     Halfedge *b=acc.get_halfedge(v), *b0=b;
     do {
       Real t = sq_length( *b);
       if ( t<tol) tol=t;
     } while ( (b=acc.get_next_around_destination( b))!=b0);
     tol = std::sqrt( tol);
 
     const Vector_3 vtol(tol*w2e_ratio, tol*w2e_ratio, tol*w2e_ratio);
     KD_tree::Box box( p-vtol, p+vtol, 3);
 
     std::vector< Point_3_ref>  outList; outList.reserve(2);
     kdtree.search( std::back_inserter( outList), box);
 
     // Find the closest corner in the list
     Real dist_min = HUGE_VAL;
     int k=-1;
 
     for ( int i=0, n = outList.size(); i<n; ++i) {
       Real d=(p-reinterpret_cast<const Point_3&>(outList[i])).squared_norm();
       if ( d <= dist_min) {
         dist_min = d; k=i;
       }
     }
 
     if ( dist_min<HUGE_VAL) {
       Halfedge *g = acc.get_halfedge( outList[k].vertex());
       if ( acc.is_border(g)) g = acc.get_opposite(g);
       else g = acc.get_next(g);
 
       Real s=tol*tol;
       Halfedge *h=g, *h0=h;
       do {
         Real t = sq_length( *h);
         if ( t<s) s=t;
       } while ( (h=acc.get_next_around_origin( h))!=h0);
 
       if ( dist_min < s*d2e_ratio_sq) {
         if ( verbose2) {
           std::cout << "Matched\t blue vertex " 
                     << acc.get_pane(b)->get_index(b->origin())+1 
                     << " in pane " << acc.get_pane(b)->id() << " at " << p
                     << "\n  with\t green vertex " 
                     << acc.get_pane(g)->get_index(g->origin())+1 
                     << " in pane " << acc.get_pane(g)->id() << " at " 
                     << g->origin()->point() << std::endl;
         }
 
         Halfedge *b = acc.get_halfedge( v);
         if ( acc.is_border(b)) b = acc.get_opposite(b);
         else b = acc.get_next(b);
         
         // Create an inode for the o-feature
         INode *x = new INode();
         x->set_parent( b, Point_2(0,0), BLUE);
         x->set_parent( g, Point_2(0,0), GREEN);
 
         if ( B->snap_on_features()) {
           // Update the coordinates for the blue point
           Point_3 &pnt = const_cast<Point_3&>( acc.get_origin(b)->point());
           pnt = acc.get_origin( g)->point();
         }
 
         insert_node_in_blue_edge( *x, b);
         continue;
       }
     }
 
     if ( verbose) {
       std::cout << "\nRocface Warning: Dropping blue corner vertex " 
                 << acc.get_pane(b)->get_index(b->origin())+1 
                 << " in pane " << acc.get_pane(b)->id() 
                 << " at " << p << std::endl;
     }
 
     // Remove the false blue 0-feature
     it = --B->remove_feature_0( it);
     ++dropped;
   }
 
   if ( verbose && dropped) {
     std::cout << "Dropped " << dropped << " corners in \"" << B->name() 
               << "\" after feature matching" << std::endl;
   }
 
   dropped=0;
   // Remove the false green 0-features
   for ( std::list<Feature_0>::iterator
           it=gf0.begin(), iend=gf0.end(); it != iend; ++it) {
     Vertex *v = it->vertex();
     if ( acc.get_inode( v) == NULL) {
 
       if ( verbose) {
         std::cout << "\nRocface Warning: Dropping green corner vertex " 
                   << acc.get_pane(v)->get_index(v)+1 
                   << " in pane " << acc.get_pane(v)->id() 
                   << " at " << v->point() << std::endl;
       }
       
       // Unmark the 0-features in the green window
       it = --G->remove_feature_0( it);
       ++dropped;
     }
   }
 
   if ( verbose && dropped) {
     std::cout << "Dropped " << dropped << " corners in \"" << G->name() 
               << "\" after feature matching" << std::endl;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void number_a_subnode	(	INode *	i,
		int	color,
		std::map< int, std::pair< int, int > > &	cnts
	)

private

Definition at line 165 of file Overlay_IO.C.

References acc, HDS_accessor< _MP >::get_next_around_origin(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_pane(), Vertex_overlay::halfedge(), INode::halfedge(), RFC_Pane_base::id(), Halfedge_overlay::is_border(), Halfedge_overlay::origin(), PARENT_EDGE, PARENT_FACE, INode::parent_type(), PARENT_VERTEX, RFC_assertion, and set_subnode_id().

Referenced by number_subnodes().

                                                        {
   Parent_type t = i->parent_type( color);
   Halfedge   *h = i->halfedge( color);
 
   switch ( t) {
   case PARENT_FACE: {
     int  pane_id = acc.get_pane(h)->id();
     set_subnode_id( i, color, pane_id, ++(cnts[ pane_id].second));
     break;
   }
   case PARENT_EDGE: {
     Halfedge *h0 = h;
     int  last_id = -1;
     do {
       int  pane_id = acc.get_pane(h)->id();
       if ( pane_id == last_id) continue;
       set_subnode_id( i, color, pane_id, ++(cnts[ pane_id].second));
       last_id = pane_id;
     } while ( (h=acc.get_opposite(h)) != h0);
     break;
   }
   default: {
     RFC_assertion( t == PARENT_VERTEX);
 
     Halfedge *h0 = h;
     int  last_id = -1;
     std::set<int>   panes;
     bool first_iter = true;
     do {
       int  pane_id = acc.get_pane(h)->id();
       if ( !first_iter && (pane_id==last_id||panes.find(pane_id)!=panes.end()))
         continue;
       set_subnode_id( i, color, pane_id, ++(cnts[ pane_id].first));
       panes.insert(last_id=pane_id);
 
       // Optimization assuming the halfedge structure is normalized
       if ( first_iter && !h->origin()->halfedge()->is_border()) break;
       first_iter = false;
     } while ( (h=acc.get_next_around_origin(h)) != h0);
     break;
   }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void number_subfaces ( )

private

Definition at line 281 of file Overlay_IO.C.

References acc, RFC_Pane_overlay::allocate_subfaces(), B, BLUE, COM_assertion_msg, convert_nat_coordinates(), count_edges(), Halfedge_overlay::facet(), G, RFC_Pane_overlay::get_index(), get_inodes_of_face(), RFC_Pane_overlay::get_lid(), get_nat_coor(), HDS_accessor< _MP >::get_pane(), get_parent_face(), GREEN, RFC_Pane_overlay::hds(), i, RFC_Pane_base::id(), RFC_Pane_overlay::insert_subface(), k, n, RFC_Window_derived< _Pane >::panes(), pi, RFC_assertion, RFC_assertion_code, s, subdivide(), and Triangulation::triangulate().

Referenced by overlay().

                   {
   std::vector<RFC_Pane_overlay*>   b_ps, g_ps;
   B->panes( b_ps);  G->panes( g_ps);
 
   typedef std::map< int, std::vector< int> > Subface_counts;
   Subface_counts cnts_b, cnts_g;
 
   std::vector<RFC_Pane_overlay*>::iterator pi;
   for ( pi=b_ps.begin(); pi!=b_ps.end(); ++pi)
     cnts_b[(*pi)->id()].resize( (*pi)->size_of_faces(), 0);
   for ( pi=g_ps.begin(); pi!=g_ps.end(); ++pi)
     cnts_g[(*pi)->id()].resize( (*pi)->size_of_faces(), 0);
 
   // First, count the number of S-faces by looping through all the blue faces
   for ( pi=b_ps.begin(); pi!=b_ps.end(); ++pi) {
     RFC_Pane_overlay *pane_b = *pi;
     Subface_counts::iterator cnts_it_b = cnts_b.find(pane_b->id());
     Subface_counts::iterator cnts_it_g = cnts_g.begin();
 
     for ( HDS::Facet_iterator fi=pane_b->hds().facets_begin(); 
           fi!=pane_b->hds().facets_end(); ++fi) {
       // Construct a list of nodes for the blue face
       INode_const_list nodes;
       get_inodes_of_face( &*fi, nodes);
       RFC_assertion( nodes.size() > 2);
 
       Subface_list   sub_faces;
       // subdivide the face
       bool ret = subdivide( nodes, ++nodes.begin(), sub_faces, BLUE);
       if ( ret) {
         std::cerr << "ERROR: Got error code " << ret 
                   << " when subdividing face "
                   << fi - pane_b->hds().facets_begin() + 1
                   << " with node " 
                   << pane_b->get_index( fi->halfedge()->origin())+1
                   << " in pane " << pane_b->id() << std::endl;
 
         sub_faces.clear();
         subdivide( nodes, ++nodes.begin(), sub_faces, BLUE);
         RFC_assertion(!ret); abort();
       }
       if (sub_faces.empty()) {
         std::cerr << "ERROR: Error in enumerating subface in face "
                   << fi - pane_b->hds().facets_begin() + 1
                   << " in pane " << pane_b->id() << std::endl;
         RFC_assertion(!sub_faces.empty()); abort();
       }
       
       // Count the subfaces in the blue face
       for (Subface_list::iterator 
              si=sub_faces.begin(), send=sub_faces.end(); si != send; ++si) {
         int num_tris = si->size()-2;
         Halfedge *s = get_parent_face( *si, GREEN);
         RFC_Pane_overlay *pane_g = acc.get_pane(s);
         if ( cnts_it_g->first != pane_g->id()) 
           cnts_it_g=cnts_g.find(pane_g->id());
 
         cnts_it_b->second[pane_b->get_index(&*fi)] += num_tris;
         cnts_it_g->second[pane_g->get_index(s->facet())] += num_tris;
       }
     }
   }
 
   // Allocate space for subfaces and convert counts into offsets.
   for ( pi=b_ps.begin(); pi!=b_ps.end(); ++pi) {
     std::vector< int> &cnts = cnts_b[ (*pi)->id()];
     (*pi)->allocate_subfaces( cnts);
     if ( cnts.empty()) continue;
     // Convert counts into offsets
     int t1=cnts[0];
     cnts[0] = 0;
     for ( int i=1, n=cnts.size(); i<n; ++i) {
       int t2 = cnts[i];
       cnts[i] = cnts[i-1] + t1;
       t1 = t2;
     }
   }
 
   for ( pi=g_ps.begin(); pi!=g_ps.end(); ++pi) {
     std::vector< int> &cnts = cnts_g[ (*pi)->id()];
     (*pi)->allocate_subfaces( cnts);
     if ( cnts.empty()) continue;
     // Convert counts into offsets
     int t1=cnts[0];
     cnts[0] = 0;
     for ( int i=1, n=cnts.size(); i<n; ++i) {
       int t2 = cnts[i];
       cnts[i] = cnts[i-1] + t1;
       t1 = t2;
     }
   }
 
   Subface_counts &offsets_b=cnts_b, &offsets_g=cnts_g;
 
   // Third, we fill up the arrays for face-list and etc.
   for ( pi=b_ps.begin(); pi!=b_ps.end(); ++pi) {
     RFC_Pane_overlay *pane_b = *pi;
     const int pane_id_b = pane_b->id();
 
     Subface_counts::iterator offsets_it_b = offsets_b.find(pane_b->id());
     Subface_counts::iterator offsets_it_g = offsets_g.begin();
 
     for ( HDS::Facet_iterator fi=(*pi)->hds().facets_begin(); 
           fi!=(*pi)->hds().facets_end(); ++fi) {
 
       // Construct a list of nodes for the blue face
       INode_const_list nodes;
       get_inodes_of_face( &*fi, nodes);
       RFC_assertion( nodes.size() > 2);
 
       Subface_list   sub_faces;
       // subdivide the face
       RFC_assertion_code( bool ret = )
         subdivide( nodes, ++nodes.begin(), sub_faces, BLUE);
       RFC_assertion( !ret);
       
       Halfedge         *b = fi->halfedge();
       Generic_element  e_b( count_edges(b));
       
       // output the subfaces of the blue face
       for (Subface_list::iterator 
              si=sub_faces.begin(), send=sub_faces.end(); si != send; ++si) {
         int n = si->size(), num_tris = n-2;
 
         Halfedge        *g = get_parent_face( *si, GREEN);
         Generic_element  e_g( count_edges(g));
 
         std::vector< Point_2>   pnts_b( n), pnts_g( n);
         for ( int k=0; k<n; ++k) {
           pnts_b[k] = get_nat_coor( *(*si)[k], e_b, b, BLUE);
           pnts_g[k] = get_nat_coor( *(*si)[k], e_g, g, GREEN);
         }
 
         std::vector< Three_tuple<int> > tris( num_tris);
         Triangulation triangulation;
         // Triangulate the sub-face in both B and G.
         triangulation.triangulate( &pnts_b[0], n, &tris);
 
         RFC_Pane_overlay *pane_g = acc.get_pane(g);
         const int pane_id_g = pane_g->id();
         // Insert the triangles into the blue and green panes
         for ( int k=0; k<num_tris; ++k) {
           int      lids_b[3], lids_g[3];
           RFC_Pane_overlay::Edge_ID  eids_b[3], eids_g[3];
           Point_2 ncs_b[3], ncs_g[3];
 
           for ( int i=0; i<3; ++i) {
             COM_assertion_msg( (*si)[tris[k][i]], "Empty intersection.");
 
             convert_nat_coordinates( (*si)[tris[k][i]], b, BLUE, pane_id_b,
                                      lids_b[i], eids_b[i], ncs_b[i]);
             convert_nat_coordinates( (*si)[tris[k][i]], g, GREEN, pane_id_g,
                                      lids_g[i], eids_g[i], ncs_g[i]);
           }
 
           if ( offsets_it_g->first != pane_g->id()) 
             offsets_it_g=offsets_g.find(pane_g->id());
 
           int idx_b = offsets_it_b->second[pane_b->get_index(&*fi)]++;
           int idx_g = offsets_it_g->second[pane_g->get_index(g->facet())]++;
 
           pane_b->insert_subface(idx_b, pane_b->get_lid( b->facet()), 
                                  lids_b, eids_b, ncs_b,
                                  pane_id_g, idx_g+1, lids_g);
           pane_g->insert_subface(idx_g, pane_g->get_lid( g->facet()), 
                                  lids_g, eids_g, ncs_g, 
                                  pane_id_b, idx_b+1, lids_b);
         }
       }
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void number_subnodes ( )

private

Definition at line 236 of file Overlay_IO.C.

References _subnode_copies_b, _subnode_copies_g, _subnode_ids_b, _subnode_ids_g, B, BLUE, count_subnodes(), G, GREEN, i, inodes, n, number_a_subnode(), RFC_Window_derived< _Pane >::panes(), and pi.

Referenced by overlay().

                   {
   std::vector<RFC_Pane_overlay*>   b_ps, g_ps;
   B->panes( b_ps);  G->panes( g_ps);
   
   // Maps from pane ids to the number of S-vertices processed
   std::map< int, std::pair<int,int> >   b_vertex_counts;
   std::map< int, std::pair<int,int> >   g_vertex_counts;
 
   std::vector<RFC_Pane_overlay*>::iterator pi;
   for ( pi=b_ps.begin(); pi!=b_ps.end(); ++pi)
     b_vertex_counts[(*pi)->id()] = std::make_pair(0,0);
   for ( pi=g_ps.begin(); pi!=g_ps.end(); ++pi)
     g_vertex_counts[(*pi)->id()] = std::make_pair(0,0);
 
   // Loop through the S-vertices
   // First, count the number of subvertices host at vertices
   for ( std::list< INode*>::const_iterator 
           it=inodes.begin(); it!=inodes.end(); ++it) {
     count_subnodes( *it, BLUE, b_vertex_counts);
     count_subnodes( *it, GREEN, g_vertex_counts);
   }
 
   // Second, assign IDs for subnodes
   int n=inodes.size();
   _subnode_ids_b.resize( n, Node_ID( 0,-1));
   _subnode_ids_g.resize( n, Node_ID( 0,-1));
   _subnode_copies_b.resize( n, 0);
   _subnode_copies_g.resize( n, 0);
   int i=0;
   for ( std::list< INode*>::const_iterator 
           it=inodes.begin(); it!=inodes.end(); ++it,++i) {
     (*it)->set_id( i);
     number_a_subnode( *it, BLUE, b_vertex_counts);
     number_a_subnode( *it, GREEN, g_vertex_counts);
   }
   
   // Allocate space for subnodes.
   for ( pi=b_ps.begin(); pi!=b_ps.end(); ++pi)
     (*pi)->allocate_subnodes( b_vertex_counts[(*pi)->id()].second);
   for ( pi=g_ps.begin(); pi!=g_ps.end(); ++pi)
     (*pi)->allocate_subnodes( g_vertex_counts[(*pi)->id()].second);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int overlay ( )

Definition at line 73 of file Overlay.C.

References associate_green_vertices(), B, RFC_Window_overlay::create_overlay_data(), RFC_Window_overlay::delete_overlay_data(), RFC_Window_overlay::detect_features(), Bbox_3::do_match(), RFC_Window_overlay::evaluate_normals(), G, RFC_Window_base::get_bounding_box(), get_wtime(), inodes, intersect_blue_with_green(), match_features_0(), min(), RFC_Window_base::name(), number_subfaces(), number_subnodes(), RFC_Window_base::size_of_faces(), RFC_Window_base::size_of_nodes(), sort_on_green_edges(), verbose, x, Bbox_3::xmax(), Bbox_3::xmin(), Bbox_3::ymax(), Bbox_3::ymin(), Bbox_3::zmax(), and Bbox_3::zmin().

                      {
   Bbox_3 bbox=B->get_bounding_box(), gbox = G->get_bounding_box();
 
   std::cout << "\tMesh " << B->name() << ": " 
             << B->size_of_nodes() << " vertices, "
             << B->size_of_faces() << " faces, with bounding box "
             << bbox << "\n\tMesh " << G->name() << ": "
             << G->size_of_nodes() << " vertices, "
             << G->size_of_faces() << " faces, with bounding box "
             << gbox << std::endl;
 
   double tol_high = 3.e-1, tol_low=1.e-1;
  
   // First, check whether the scales of the two bounding boxes are
   // the same by comparing the total lengths of bounding boxes and 
   // the individual dimensions.
   double bl = (bbox.xmax()-bbox.xmin()) + 
     (bbox.ymax()-bbox.ymin()) + (bbox.zmax()-bbox.zmin());
   double gl = (gbox.xmax()-gbox.xmin()) + 
     (gbox.ymax()-gbox.ymin()) + (gbox.zmax()-gbox.zmin());
 
   if ( bl>gl*(1+tol_high) || gl>bl*(1+tol_high) || 
        !bbox.do_match( gbox, std::min(bl,gl)*tol_high)) {
     std::cerr << "ERROR: The bounding boxes differ by more than "
               << tol_high*100 << "%. Please check the geometries. Stopping..." 
               << std::endl;
     abort();
   }
 
   // If the bounding boxes do not match at all sides within a fraction 
   // of the longest dimension, then stop the code. 
   // the difference between the two boxes is smaller than a fraction (eps)
   // of the largest dimension of the two boxes.
   if ( !bbox.do_match( gbox, std::min(bl,gl)*tol_low)) {
     std::cerr << "WARNING: The bounding boxes differ by more than "
               << tol_low*100 << "% but less than "
               << tol_high*100 << "%. Continuing anyway." << std::endl;
   }
 
   double t0 = get_wtime();
 
   // Create helper data in two input meshes.
   B->create_overlay_data();
   G->create_overlay_data();
 
   // Detect the 0-features of the two meshes.
   std::cerr << "Detecting features in " << B->name() << "..." << std::endl;
   B->detect_features();
 
   std::cerr << "Detecting features in " << G->name() << "..." << std::endl;
   G->detect_features();
 
   match_features_0();
 
   // Evaluate normals for the nodes.
   B->evaluate_normals();
   G->evaluate_normals();
 
   std::cout << "Performing mesh overlay..." << std::flush;
   // Step 1: Project the blue vertices onto G and
   // compute the intersection points of blue edges with green
   //  edges, and insert the intersections into the blue edges on the fly.
   intersect_blue_with_green();
   std::cout << "..." << std::flush;
 
   // Step 2: Sort the intersection points corresponding to each green 
   //   edge and insert them into green edges (in linear time).
   sort_on_green_edges();
   std::cout << "..." << std::flush;
 
   // Step 3: Compute the projection of the green vertices on B.
   associate_green_vertices();
   std::cout << "..." << std::flush;
   
   if ( verbose) {
     std::cout << "\n\tLocated " << inodes.size() 
               << " edge intersections.\n\tDone in " 
               << get_wtime()-t0 << " sec.\n"
               << "Exporting the subdivision..." << std::flush;
     t0 = get_wtime();
   }
   
   // Finally, assign local ids to the subnodes within panes and 
   number_subnodes();
 
   // subdivide the faces and assign local ids to these subfaces,and
   // create the nodal and face lists for the panes.
   number_subfaces();
 
   // Now, clean up the overlay data
   // Destroy helper data in the input windows
   B->delete_overlay_data(); G->delete_overlay_data();
   while ( !inodes.empty()) {
     INode* x = inodes.front(); inodes.pop_front();
     delete x; 
   }
 
   std::cout << "Done";
   if ( verbose) {
     std::cout << " in " << get_wtime()-t0 << " sec.";
   }
   std::cout << std::endl;
   return 0;
 }

Here is the call graph for this function:

RFC_BEGIN_NAME_SPACE INode * overlay_init ( )

protected

Definition at line 48 of file Overlay_init.C.

References acc, B, BLUE, RFC_Window_overlay::get_an_unmarked_halfedge(), get_green_parent(), HDS_accessor< _MP >::get_pane(), RFC_Pane_overlay::get_point(), GREEN, HDS_accessor< _MP >::is_border(), Halfedge_overlay::next(), Halfedge_overlay::origin(), PARENT_EDGE, PARENT_FACE, PARENT_NONE, PARENT_VERTEX, RFC_assertion, INode::set_parent(), v, verbose2, and x.

Referenced by intersect_blue_with_green().

                              {
   INode *v=NULL;
 
   // get an unmarked halfedge from the blue mesh and take its origin as x.
   Halfedge *b=B->get_an_unmarked_halfedge(), *g;
   if ( b==NULL) return NULL;
 
   Vertex *x = b->origin();   RFC_assertion( !acc.is_border(x));
 
   // locate the green parent of x.
   Parent_type t;
   Point_2    nc;
   get_green_parent( x, b, &g, &t, &nc);
   RFC_assertion ( t != PARENT_NONE && g != NULL);
 
   // create a new inode for x
   v = new INode();
   v->set_parent( b, Point_2(0,0), BLUE);
   v->set_parent( g, nc, GREEN);
 
   if ( verbose2) {
     std::cout << "\nFound a seed at blue vertex (" 
               << acc.get_pane(x)->get_point(x) << ") \nin green ";
     const RFC_Pane_overlay *gpane=acc.get_pane(g);
     switch ( t) {
     case PARENT_VERTEX:
       std::cout << "vertex (" << gpane->get_point( g->origin()) << ")\n";
       break;
     case PARENT_EDGE:
       std::cout << "edge (" << gpane->get_point( g->origin()) << "), (" 
                 << gpane->get_point( g->destination()) << ")\n";
       break;
     case PARENT_FACE: {
       std::cout << "face ";
       Halfedge *gt = g;
       do {
         std::cout << "\t(" << gpane->get_point( gt->origin()) << "), ";
       } while ( (gt = gt->next()) != g);
       std::cout << std::endl;
       break;
     }
     default:
       RFC_assertion( false);
     }
     std::cout << std::endl;
   }
 
   return v;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void project_adjacent_green_vertices	(	const INode *	i,
		Halfedge *	b
	)

protected

Helper for associate_green_vertices().

Definition at line 940 of file Overlay.C.

Referenced by associate_green_vertices().

                                                               {
   std::queue< INode*> q;
 
   // From every known subnode, projects its adjacent green vertices
   // onto blue faces and creates new subnodes for the green vertices.
   do {
     Halfedge *g = i->halfedge(GREEN), *gopp, *g0=g;
     Parent_type igp = i->parent_type( GREEN);
     // Loop through all the incident halfedges.
     do {
       gopp = acc.get_opposite( g);
       Vertex_overlay *dst = acc.get_destination(g);
       
       INode_list &il = acc.get_inode_list( g);
       INode_list &ilr = acc.get_inode_list( gopp);
 
       // If there is any subnode between i and dst, skip the edge.
       if ( igp == PARENT_VERTEX) {
         if (!il.empty() || !ilr.empty())
           continue;
       }
       else if ( igp == PARENT_EDGE) {
         INode *j;
         if ( !il.empty()) {
           if ( &il.back() != i) continue;
           j = ( il.size() > 1 ? i->prev_link[GREEN] : 
                 acc.get_inode( acc.get_origin( g)));
         }
         else {
           if ( &ilr.front() != i) continue;
           j = ( ilr.size() > 1 ? i->next_link[GREEN] : 
                 acc.get_inode( acc.get_origin( g)));
         }
         if ( j && contains( b, PARENT_FACE, 
                             j->halfedge( BLUE), j->parent_type( BLUE)))
           continue;
       }
 
       // If dst has already been projected, skip the edge.
       INode *x=NULL;
       if ( (x=acc.get_inode( dst)) != NULL) {
         RFC_assertion( x->parent_type( BLUE) != PARENT_FACE ||
                        contains( x->halfedge(BLUE), PARENT_FACE,
                                  i->halfedge(BLUE), i->parent_type(BLUE)));
         continue;
       }
 
       // Determine whether the vertex projects onto the blue face, and if so,
       // create a new subnode at it and insert the subnode into the queue.
       Halfedge *b1 = b; Parent_type t=PARENT_FACE; 
       Point_2 nc;
       const RFC_Pane_overlay *gpane = acc.get_pane(g);
       Vector_3 v1 = gpane->get_normal( g, g->destination());
       if (op.project_onto_element( g->destination()->point(), 
                                    &b1, &t, v1, &nc, eps_p)) {
         Vector_3 v2 = op.get_face_normal( b1, nc); 
         if (v2 != Vector_3(0,0,0)) v2 = v2 / std::sqrt( v2*v2);
 
         if ( logical_xor( is_opposite, v1 * v2 < 0.15)) continue;
         RFC_assertion( nc[0] != 0. && nc[1] != 0.);
 
         x = new INode();
           
         x->set_parent( b1, nc, BLUE);
         x->set_parent( gopp, Point_2(0,0), GREEN);
         // Check whether consistency rules are satisfied
         if ( verify_inode( x)) {
           inodes.push_back( x);
           acc.set_inode( dst, x);
           q.push( x);
         }
         else
           delete x;
       }
       RFC_assertion( igp != PARENT_FACE); // Must have been projected.
     } while ( ( g = ( igp==PARENT_VERTEX ? acc.get_next(gopp) : gopp)) != g0);
     if ( !q.empty()) { i = q.front(); q.pop(); } else i = NULL;
   } while (i);
        
 }

Here is the call graph for this function:

Here is the caller graph for this function:

RFC_BEGIN_NAME_SPACE INode * project_next_vertex	(	Halfedge *	b,
		Halfedge *	g
	)

protected

Definition at line 33 of file Overlay_1d.C.

References acc, B, BLUE, Halfedge_overlay::destination(), eps_e, RFC_Pane_overlay::get_normal(), HDS_accessor< _MP >::get_pane(), RFC_Pane_overlay::get_tangent(), GREEN, insert_node_in_blue_edge(), op, Halfedge_overlay::origin(), Vertex_overlay::point(), Overlay_primitives::project_blue_feature(), Overlay_primitives::project_green_feature(), s, HDS_accessor< _MP >::set_parent(), RFC_Window_overlay::snap_on_features(), and x.

                                                {
   const RFC_Pane_overlay *gpane = acc.get_pane(g);
   const Vertex *borg = b->origin(), *bdst = b->destination();
   const Vertex *gorg = g->origin(), *gdst = g->destination();
 
   double eps_e;
 
   if ( B->snap_on_features()) eps_e = 5.e-3; // Increase the threshold for RSRM
   else eps_e = Overlay::eps_e;
 
   Real s = op.project_green_feature( gpane->get_normal( g, gdst), 
                                      gpane->get_tangent( g, gdst),
                                      borg->point(), bdst->point(), 
                                      gdst->point(), eps_e);
   INode *x = new INode();
   if ( s < 1) {
     if ( s < 0) s = 0; // Adjust the origin of the blue edge.
     acc.set_parent( x, b, Point_2( s,0), BLUE);
     acc.set_parent( x, g, Point_2( 1,0), GREEN);
   }
   else if ( s>= 1) {
     // The blue parent is bdst, so we locate a non-border 
     // blue halfedge originated from b.
     acc.set_parent( x, b, Point_2( 1,0), BLUE);
     // Project green vertex onto blue edge
     Real t;
     if ( s > 1) {
       // Project the blue vertex onto the green halfedge
       t=op.project_blue_feature( gpane->get_normal(g, gorg), 
                                  gpane->get_normal(g, gdst),
                                  gpane->get_tangent(g, gorg),
                                  gpane->get_tangent(g, gdst),
                                  gorg->point(), gdst->point(),
                                  bdst->point(), eps_e);
       if ( t>1) t=1;
     }
     else
       t = 1;
     acc.set_parent( x, g, Point_2(t,0), GREEN);
 
     if ( B->snap_on_features()) {
       // Update the coordinates for the blue point
       Point_3 &pnt = const_cast<Point_3&>(bdst->point());
       pnt = gorg->point()+t*(gdst->point()-gorg->point());
     }
   }
   
   // Insert the new edge into the blue edge.
   insert_node_in_blue_edge( *x, b); 
 
   return x;
 }

Here is the call graph for this function:

RFC_BEGIN_NAME_SPACE void set_subnode_id	(	INode *	i,
		int	color,
		int	pane_id,
		int	l_id
	)

private

Insert the local id within a pane for a given subnode into the global-to-local-mapping. The mapping is composed of two data structures, _subnode_ids storing one id for every subnode, and _subnode_imap, which stores a mapping from pane_id to local_id for the subnodes present in more than one panes.

See Also: get_subnode_id

Definition at line 45 of file Overlay_IO.C.

References _subnode_copies_b, _subnode_copies_g, _subnode_ids_b, _subnode_ids_g, _subnode_imap_b, _subnode_imap_g, BLUE, GREEN, INode::id(), Node_ID::node_id, Node_ID::pane_id, and RFC_assertion.

Referenced by number_a_subnode().

                                                             {
   if ( color==BLUE) {
     int global_id = i->id();
     Node_ID &vid = _subnode_ids_b[ global_id];
     if ( vid.node_id < 0) { // Uninitialized
       vid = Node_ID( pane_id, l_id);
       _subnode_copies_b[global_id] = 1;
     }
     else {
       _subnode_imap_b[global_id][ vid.pane_id] = vid.node_id;
       std::map<int,int> &imap=_subnode_imap_b[global_id];
       RFC_assertion( imap.find(pane_id) == imap.end());
       imap[ pane_id] = l_id;
       ++_subnode_copies_b[global_id];
     }
   }
   else { 
     RFC_assertion( color==GREEN);
     int global_id = i->id();
     Node_ID &vid = _subnode_ids_g[ global_id];
     if ( vid.node_id < 0) { // Uninitialized
       vid = Node_ID( pane_id, l_id);
       _subnode_copies_g[global_id] = 1;
     }
     else {
       _subnode_imap_g[global_id][ vid.pane_id] = vid.node_id;
       std::map<int,int> &imap=_subnode_imap_g[global_id];
       RFC_assertion( imap.find(pane_id) == imap.end());
       imap[ pane_id] = l_id;
       ++_subnode_copies_g[global_id];
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void set_tolerance ( double tol )

Definition at line 66 of file Overlay.C.

References COM_assertion_msg, eps_e, and max().

                                        {
   COM_assertion_msg( tol<=0.2, "Tolerance too large");
 
   eps_e = std::max(tol, 1.e-3); // Set snap tolerance.
 }

Here is the call graph for this function:

void sort_on_green_edges ( )

protected

Definition at line 771 of file Overlay.C.

References acc, B, In_place_list_n< T, managed >::begin(), In_place_list_n< T, managed >::empty(), empty(), In_place_list_n< T, managed >::end(), HDS_accessor< _MP >::get_halfedge(), HDS_accessor< _MP >::get_inode(), HDS_accessor< _MP >::get_inode_list(), HDS_accessor< _MP >::get_next(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_origin(), GREEN, INode::halfedge(), i, inodes, insert_node_in_green_edge(), HDS_accessor< _MP >::is_primary(), j, In_place_list_n_base< T, n >::next_link, RFC_Window_derived< _Pane >::panes(), PARENT_EDGE, INode::parent_type(), In_place_list_n_base< T, n >::prev_link, In_place_list_n< T, managed >::push_back(), In_place_list_n< T, managed >::rbegin(), In_place_list_n< T, managed >::rend(), RFC_assertion, and v.

Referenced by overlay().

                       {
   std::vector<RFC_Pane_overlay*>   ps;
   B->panes( ps);
 
   inodes.clear();
   // Loop through all the panes of B to insert the inodes into a list
   for ( std::vector<RFC_Pane_overlay*>::iterator 
           pit=ps.begin(); pit!=ps.end(); ++pit){
     // Loop through the vertices.
     for ( HDS::Vertex_iterator vit=(*pit)->hds().vertices_begin(); 
           vit!=(*pit)->hds().vertices_end(); ++vit) 
       if ( vit->halfedge() && vit->halfedge()->destination() == &*vit 
            && acc.is_primary( &*vit)) {
         INode *i = acc.get_inode( &*vit); RFC_assertion( i);
         i->prev_link[GREEN]=i->next_link[GREEN]=NULL;
         inodes.push_back( i);
       }
 
     for ( HDS::Halfedge_iterator hit=(*pit)->hds().halfedges_begin(); 
           hit!=(*pit)->hds().halfedges_end(); ++hit) {
       INode_list &il = acc.get_inode_list( &*hit);
       for ( INode_list::iterator it=il.begin(); it!=il.end(); ++it) {
         INode *i = &*it; RFC_assertion( i);
         i->prev_link[GREEN]=i->next_link[GREEN]=NULL;
         inodes.push_back( i);
       }
     }
   }
 
   int count = 1;
   // Loop through all the panes of B
   for ( std::vector<RFC_Pane_overlay*>::iterator 
           pit=ps.begin(); pit!=ps.end(); ++pit) {
     // Loop through the real faces of each pane.
     for ( HDS::Facet_iterator fit=(*pit)->hds().facets_begin(); 
           fit!=(*pit)->hds().facets_end(); ++fit, ++count) {
       // if ( !acc.is_master( &*fit)) continue;
       Halfedge *b = acc.get_halfedge( &*fit), *h=b;
       do {
         INode *i=acc.get_inode( acc.get_origin(h));
         if ( i) insert_node_in_green_edge( i, count);
         
         INode_list &il = acc.get_inode_list( h);
         if ( !il.empty()) {
           RFC_assertion(acc.get_inode_list(acc.get_opposite(h)).empty());
           // Loop through the intersections on the edges
           INode_list::iterator v = il.begin(), vend = il.end();
           for ( ; v != vend; ++v) 
             insert_node_in_green_edge( &*v, count);
         }
         else {
           INode_list &ilr = acc.get_inode_list( acc.get_opposite(h));
           if ( !ilr.empty()) {
             INode_list::reverse_iterator vr=ilr.rbegin(),vrend=ilr.rend();
             for ( ; vr != vrend; ++vr) 
               insert_node_in_green_edge(&*vr, count);
           }
         }
         // Increment the iterator
       } while ( (h = acc.get_next(h)) != b);
     }
   }
   
   // Loop through all the inodes
   for (std::list<INode*>::iterator it=inodes.begin(); it!=inodes.end(); ++it) {
     INode *i=*it;
     if ( i->parent_type( GREEN) == PARENT_EDGE) {
       INode_list &il = acc.get_inode_list( i->halfedge(GREEN));
       if ( il.empty()) {
         while ( i->prev_link[GREEN]) { i = i->prev_link[GREEN]; }
 
         for (;;) {
           INode *j = i->next_link[GREEN];
           il.push_back(*i);
           if ( j) i=j; else break;
         }
       }
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Real sq_length ( const Halfedge & h ) const

private

Definition at line 178 of file Overlay.C.

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

Referenced by get_green_parent(), and match_features_0().

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

Here is the call graph for this function:

Here is the caller graph for this function:

bool subdivide	(	const INode_const_list &	face,
		INode_const_list::const_iterator	last_checked,
		Subface_list &	sub_faces,
		int	color,
		int	depth = `0`
	)		const

Definition at line 1759 of file Overlay.C.

References get_next_inode(), i, iend, RFC_assertion, and RFC_assertion_code.

Referenced by number_subfaces(), write_overlay_off(), and write_overlay_tec().

                                                 {
   if ( face.size() < 3) return true; // Do nothing
   RFC_assertion( last_checked != face.begin() && last_checked != face.end() && depth < 1000);
 
   INode_const_list::const_iterator it=last_checked, iend=face.end(),inext;
   const INode *v0 = *(--last_checked), *v1 = *it, *v2;
   // v0 and v1 are the last pair of adjacent nodes that are known belonging
   // to the sub-face of previous nodes in the node list.
 
   for ( RFC_assertion_code(unsigned int c=0);;RFC_assertion(++c<face.size())) {
     inext = it; ++inext; // Equivalent to inext = it + 1;
     if ( inext == iend) { // All nodes in the list are processed.
       if ( face.front() == get_next_inode( v0, v1, color)) {
         // Insert a new item in the sub-face list.
         sub_faces.push_back( std::vector< const INode*>());
         std::vector< const INode*> &vec = sub_faces.back();
         vec.reserve( face.size());
         vec.insert( vec.end(),face.begin(), face.end());
         return false;
       }
       return true; 
     }
     else {
       v2 = get_next_inode( v0, v1, color);
       if ( !v2) { 
         INode_const_list sub2( it, face.end());
         subdivide( sub2, ++sub2.begin(), sub_faces, color, depth+1);
         return true;
       }
       v0 = v1; v1 = v2;
       if ( v2 != *inext) break; // the face is split at v2
       
       it = inext;
     }
   }
 
   // The sub-face is a proper subset of given face. We split it into two parts.
   // Create a binary tree structure for the nodes.
   typedef std::map< const INode *, INode_const_list::const_iterator> IMap;
   IMap  imap;
   for ( INode_const_list::const_iterator i = face.begin(); i!=iend; ++i)
     imap.insert( std::make_pair( *i, i));
 
   IMap::const_iterator mit;
   // Create two sub lists
   std::list< const INode *> sub1, sub2;
   sub1.insert( sub1.end(), face.begin(), inext);
 
   // Find the end of the chain that cuts the face
   for ( RFC_assertion_code( int count=0);;RFC_assertion(++count<100)) {
     if ( (mit=imap.find( v1)) == imap.end()) {
       sub1.push_back( v1);
       sub2.push_front( v1);
       v2 = get_next_inode( v0, v1, color);
       if (v2) { v0=v1; v1 = v2; } else break;
     }
     else {
       break;
     }
   }
 
   bool ret1=true, ret2=true;
   // Cut the face along the inodes (*mit->second,sub2.front,...,sub2.end(),*it)
   INode_const_list::const_iterator sub_it1 = --sub1.end();
   if (v2 && mit->second != face.begin())
   { sub1.insert( sub1.end(), mit->second, iend); ++sub_it1; }
   if (v2) ret1 = subdivide( sub1, sub_it1, sub_faces, color, depth+1); 
   sub1.clear();
 
   if ( v2) sub2.push_front( *mit->second);
   if ( v2 && mit->second != face.begin())
   { sub2.insert(sub2.end(),it,mit->second); }
   else
   { sub2.insert(sub2.end(),it,iend); }
   ret2 = subdivide( sub2, ++sub2.begin(), sub_faces, color, depth+1);
   return ret1 || ret2;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool verify_inode ( const INode * i )

protected

Definition at line 1022 of file Overlay.C.

References acc, In_place_list_n< T, managed >::back(), BLUE, contains(), In_place_list_n< T, managed >::empty(), In_place_list_n< T, managed >::front(), HDS_accessor< _MP >::get_destination(), HDS_accessor< _MP >::get_inode(), HDS_accessor< _MP >::get_inode_list(), HDS_accessor< _MP >::get_next(), HDS_accessor< _MP >::get_opposite(), HDS_accessor< _MP >::get_origin(), GREEN, INode::halfedge(), i, j, In_place_list_n_base< T, n >::next_link, PARENT_FACE, INode::parent_type(), In_place_list_n_base< T, n >::prev_link, RFC_precondition, and In_place_list_n< T, managed >::size().

Referenced by project_adjacent_green_vertices().

                               {
   RFC_precondition( i->parent_type(BLUE) == PARENT_FACE);
 
   Halfedge *g = i->halfedge(GREEN), *gopp, *g0=g;
   // Loop through all the incident halfedges.
   do {
     gopp = acc.get_opposite( g);
     
     INode_list &il = acc.get_inode_list( g);
     INode_list &ilr = acc.get_inode_list( gopp);
     
     // If there is any subnode between i and dst, skip the edge.
     INode *j;
     if ( !il.empty()) {
       if ( &il.back() != i) continue;
       j = ( il.size() > 1 ? i->prev_link[GREEN] : 
             acc.get_inode( acc.get_origin( g)));
     }
     else if ( !ilr.empty()) {
       if ( &ilr.front() != i) continue;
       j = ( ilr.size() > 1 ? i->next_link[GREEN] : 
             acc.get_inode( acc.get_origin( g)));
     }
     else 
       j = acc.get_inode( acc.get_destination(g));
 
     if ( j && !contains( i->halfedge( BLUE), PARENT_FACE, 
                          j->halfedge( BLUE), j->parent_type( BLUE)))
       return false;
   } while ( ( g = acc.get_next(gopp)) != g0);
 
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void write_inodes_tec	(	std::ostream &	os,
		const char *	color
	)

Definition at line 1541 of file Overlay.C.

References BLUE, Overlay_primitives::get_point(), GREEN, INode::halfedge(), i, iend, inodes, min(), n, INode::nat_coor(), op, and set_ascii_mode().

                                                     {
   set_ascii_mode(os);
   
   int n=0;
   std::list<INode*>::iterator it = inodes.begin(), iend = inodes.end();
   for ( ; it != iend; ++it,++n) {
     if ( n%50==0) {
       os << "GEOMETRY T=LINE3D";
       if ( color) os << " C=" << color;
       os << " LT=0.2" << std::endl;
       os << std::min(int(inodes.size()-n),int(50)) << std::endl;
     }
     INode *i = *it;
     os << 2 << ' ' << op.get_point( i->halfedge(BLUE), i->nat_coor( BLUE))
        << ' ' << op.get_point( i->halfedge(GREEN), i->nat_coor( GREEN))
        << std::endl;
   }
 }

Here is the call graph for this function:

void write_inodes_vec ( std::ostream & os )

Definition at line 1561 of file Overlay.C.

References BLUE, Overlay_primitives::get_point(), GREEN, INode::halfedge(), i, iend, inodes, n, INode::nat_coor(), op, and set_ascii_mode().

                                   {
   set_ascii_mode(os);  
 
   int n = inodes.size();
 
   os << "VECT\n";
   os << n << ' ' << n*2 << ' ' << 0 << '\n';
 
   int i;
   // Print the number of vertices in each inode
   for ( i=n; i>0; --i) os << 2 << '\n';
   for ( i=n; i>0; --i) os << 0 << '\n';
 
   // Print the coordinates of each node
   std::list<INode*>::iterator it = inodes.begin(), iend = inodes.end();
   for ( ; it != iend; ++it) {
     INode *i = *it;
     os << op.get_point( i->halfedge(BLUE), i->nat_coor( BLUE))
        << ' ' << op.get_point( i->halfedge(GREEN), i->nat_coor( GREEN))
        << std::endl;
   }
 }

Here is the call graph for this function:

void write_overlay_off	(	std::ostream &	os,
		const COM::Window *	w
	)

Definition at line 2006 of file Overlay.C.

References B, RFC_Window_base::base(), BLUE, G, get_inodes_of_face(), Overlay_primitives::get_point(), GREEN, i, inodes, op, RFC_Window_derived< _Pane >::panes(), RFC_assertion, RFC_assertion_code, set_ascii_mode(), subdivide(), and verbose.

                                                               {
   int color = (w==B->base()) ? BLUE : GREEN;
   os << "OFF" << std::endl;
   set_ascii_mode(os);
 
   // Loop through all the original blue faces
   std::vector<RFC_Pane_overlay*>   ps;
   if ( color==GREEN) G->panes( ps); else B->panes( ps);
 
   int nfaces = 0;
 
   // Loop through all the panes of the window to count the number of faces
   for (std::vector<RFC_Pane_overlay*>::iterator 
          pit=ps.begin(); pit != ps.end(); ++pit) {
     // Loop through the faces of each pane.
     for ( HDS::Facet_iterator fit=(*pit)->hds().facets_begin(); 
           fit!=(*pit)->hds().facets_end(); ++fit) {
 
       // Construct a list of nodes for the blue face
       INode_const_list nodes;
       get_inodes_of_face( &*fit, nodes);
       if ( nodes.size() <= 2) continue;
 
       Subface_list   sub_faces;
       // subdivide the face
       RFC_assertion_code( bool ret = )
         subdivide( nodes, ++nodes.begin(), sub_faces, color);
       RFC_assertion( !ret);
       
       // output the subfaces of the blue face
       nfaces += sub_faces.size();
     }
   }
 
   os << inodes.size() << ' ' << nfaces << " 0" << std::endl;
 
   // Assign ids for the vertices
   int id=0;
   std::map< const void*, int>   ids;
   for ( std::list< INode*>::const_iterator
           i = inodes.begin(); i != inodes.end(); ++i) {
     os << op.get_point( (*i)->halfedge( color), 
                         (*i)->nat_coor( color)) 
        << std::endl;
     ids[*i] = id++;
   }
 
   // Loop through all the original blue faces
   for (std::vector<RFC_Pane_overlay*>::iterator 
          pit=ps.begin(); pit != ps.end(); ++pit) {
     // Loop through the faces of each pane.
     for ( HDS::Facet_iterator fit=(*pit)->hds().facets_begin(); 
           fit!=(*pit)->hds().facets_end(); ++fit) {
 
       // Construct a list of nodes for the blue face
       INode_const_list nodes;
       get_inodes_of_face( &*fit, nodes);
       if ( nodes.size() <= 2) continue;
 
       Subface_list   sub_faces;
       // subdivide the face
       RFC_assertion_code( bool ret = )
         subdivide( nodes, ++nodes.begin(), sub_faces, color);
       RFC_assertion( !ret);
       
       // output the subfaces of the blue face
       Subface_list::iterator sfit = sub_faces.begin(), sfend=sub_faces.end();
 
       for ( ; sfit != sfend; ++sfit) {
         // Loop through the points in the sub face
         os << sfit->size();
         for ( Subface_list::value_type::iterator
                 vit=sfit->begin(); vit!=sfit->end(); ++vit) {
           os << " " << ids[*vit];
         }
         os << std::endl;
       } 
     }
   }
 
   if ( verbose)
     std::cout << "\tTotal number of sub-faces in the overlay is " 
               << nfaces << std::endl;
 }

Here is the call graph for this function:

void write_overlay_tec	(	std::ostream &	os,
		const COM::Window *	w
	)

Definition at line 1956 of file Overlay.C.

References B, RFC_Window_base::base(), BLUE, G, get_inodes_of_face(), Overlay_primitives::get_point(), GREEN, op, RFC_Window_derived< _Pane >::panes(), RFC_assertion, RFC_assertion_code, subdivide(), and verbose.

                                                               {
   int color = (w==B->base()) ? BLUE : GREEN;
   int num_faces=0;
   // Loop through all the original blue faces
   std::vector<RFC_Pane_overlay*>   ps;
   if ( color==GREEN) G->panes( ps); else B->panes( ps);
   // Loop through all the panes of G
   for (std::vector<RFC_Pane_overlay*>::iterator 
          pit=ps.begin(); pit != ps.end(); ++pit) {
     // Loop through the faces of each pane.
     for ( HDS::Facet_iterator fit=(*pit)->hds().facets_begin(); 
           fit!=(*pit)->hds().facets_end(); ++fit) {
 
       // Construct a list of nodes for the blue face
       INode_const_list nodes;
       get_inodes_of_face( &*fit, nodes);
       if ( nodes.size() <= 2) continue;
 
       Subface_list   sub_faces;
       // subdivide the face
       RFC_assertion_code( bool ret = )
         subdivide( nodes, ++nodes.begin(), sub_faces, color);
       RFC_assertion( !ret);
       
       // output the subfaces of the blue face
       num_faces += sub_faces.size();
       Subface_list::iterator sfit = sub_faces.begin(), sfend=sub_faces.end();
       os << "GEOMETRY T=LINE3D C=BLACK"
          << " LT=0.15\n" << sub_faces.size() << std::endl;
       for ( ; sfit != sfend; ++sfit) {
         // Loop through the points in the sub face
         os << sfit->size()+1 << " ";
         for ( Subface_list::value_type::iterator
                 vit=sfit->begin(); vit!=sfit->end(); ++vit) {
           os << op.get_point( (*vit)->halfedge( color), 
                               (*vit)->nat_coor( color))
              << std::endl;
         }
         os << op.get_point( (*sfit->begin())->halfedge( color), 
                             (*sfit->begin())->nat_coor( color))
            << std::endl;
       } 
     }
   }
   if ( verbose)
     std::cout << "\tTotal number of sub-faces in the overlay is " 
               << num_faces << std::endl;
 }