Branch data Line data Source code
1 : : /**
2 : : * MOAB, a Mesh-Oriented datABase, is a software component for creating,
3 : : * storing and accessing finite element mesh data.
4 : : *
5 : : * Copyright 2004 Sandia Corporation. Under the terms of Contract
6 : : * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
7 : : * retains certain rights in this software.
8 : : *
9 : : * This library is free software; you can redistribute it and/or
10 : : * modify it under the terms of the GNU Lesser General Public
11 : : * License as published by the Free Software Foundation; either
12 : : * version 2.1 of the License, or (at your option) any later version.
13 : : *
14 : : */
15 : :
16 : : #include "moab/HalfFacetRep.hpp"
17 : : #include "Internals.hpp"
18 : : #include <iostream>
19 : : #include <assert.h>
20 : : #include <vector>
21 : : #include <map>
22 : : #include "MBTagConventions.hpp"
23 : : #include "moab/ScdInterface.hpp"
24 : : #ifdef MOAB_HAVE_MPI
25 : : #include "moab/ParallelComm.hpp"
26 : : #endif
27 : :
28 : : namespace moab
29 : : {
30 : :
31 : 724658 : inline EntityHandle CREATE_HALFFACET( const unsigned lid, const EntityID id )
32 : : {
33 [ + - ][ - + ]: 724658 : assert( id <= MB_END_ID && lid < 6 );
34 : 724658 : return ( ( (HFacet)lid ) << MB_ID_WIDTH ) | id;
35 : : }
36 : 19750212 : inline EntityID FID_FROM_HALFFACET( HFacet handle )
37 : : {
38 : 19750212 : return ( handle & MB_ID_MASK );
39 : : }
40 : 15612030 : inline int LID_FROM_HALFFACET( HFacet handle )
41 : : {
42 : 15612030 : return static_cast< int >( handle >> MB_ID_WIDTH );
43 : : }
44 : :
45 : 39 : HalfFacetRep::HalfFacetRep( Core* impl, ParallelComm* comm, moab::EntityHandle rset, bool filter_ghosts )
46 [ + - ][ + - ]: 39 : : thismeshtype( CURVE ), mb( impl ), pcomm( comm ), _rset( rset ), _filterghost( filter_ghosts )
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
47 : : {
48 [ - + ]: 39 : assert( NULL != impl );
49 : 39 : mInitAHFmaps = false;
50 : 39 : chk_mixed = false;
51 : 39 : is_mixed = false;
52 : 39 : }
53 : :
54 : 78 : HalfFacetRep::~HalfFacetRep() {}
55 : :
56 : 87 : MESHTYPE HalfFacetRep::get_mesh_type( int nverts, int nedges, int nfaces, int ncells )
57 : : {
58 : 87 : MESHTYPE mesh_type = CURVE;
59 : :
60 [ + - ][ + + ]: 87 : if( nverts && nedges && ( !nfaces ) && ( !ncells ) )
[ + + ][ + - ]
61 : 17 : mesh_type = CURVE;
62 [ + - ][ + + ]: 70 : else if( nverts && !nedges && nfaces && !ncells )
[ + + ][ + - ]
63 : 47 : mesh_type = SURFACE;
64 [ + - ][ + + ]: 23 : else if( nverts && nedges && nfaces && !ncells )
[ + - ][ - + ]
65 : 0 : mesh_type = SURFACE_MIXED;
66 [ + - ][ + + ]: 23 : else if( nverts && !nedges && !nfaces && ncells )
[ + - ][ + - ]
67 : 22 : mesh_type = VOLUME;
68 [ + - ][ + - ]: 1 : else if( nverts && nedges && !nfaces && ncells )
[ - + ][ # # ]
69 : 0 : mesh_type = VOLUME_MIXED_1;
70 [ + - ][ - + ]: 1 : else if( nverts && !nedges && nfaces && ncells )
[ # # ][ # # ]
71 : 0 : mesh_type = VOLUME_MIXED_2;
72 [ + - ][ + - ]: 1 : else if( nverts && nedges && nfaces && ncells )
[ + - ][ + - ]
73 : 1 : mesh_type = VOLUME_MIXED;
74 : :
75 : 87 : return mesh_type;
76 : : }
77 : :
78 : : const HalfFacetRep::adj_matrix HalfFacetRep::adjMatrix[7] = {
79 : : // Stores the adjacency matrix for each mesh type.
80 : : // CURVE
81 : : { { { 0, 1, 0, 0 }, { 1, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } } },
82 : :
83 : : // SURFACE
84 : : { { { 0, 0, 1, 0 }, { 0, 0, 0, 0 }, { 1, 0, 1, 0 }, { 0, 0, 0, 0 } } },
85 : :
86 : : // SURFACE_MIXED
87 : : { { { 0, 1, 1, 0 }, { 1, 1, 1, 0 }, { 1, 1, 1, 0 }, { 0, 0, 0, 0 } } },
88 : :
89 : : // VOLUME
90 : : { { { 0, 0, 0, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 1, 0, 0, 1 } } },
91 : :
92 : : // VOLUME_MIXED_1
93 : : { { { 0, 1, 0, 1 }, { 1, 1, 0, 1 }, { 0, 0, 0, 0 }, { 1, 1, 0, 1 } } },
94 : :
95 : : // VOLUME_MIXED_2
96 : : { { { 0, 0, 1, 1 }, { 0, 0, 0, 0 }, { 1, 0, 1, 1 }, { 1, 0, 1, 1 } } },
97 : :
98 : : // VOLUME_MIXED
99 : : { { { 0, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 } } }
100 : : };
101 : :
102 : 105164 : int HalfFacetRep::get_index_for_meshtype( MESHTYPE mesh_type )
103 : : {
104 : 105164 : int index = 0;
105 [ + + - + : 105164 : switch( mesh_type )
- - - - ]
106 : : {
107 : : case CURVE:
108 : 3986 : index = 0;
109 : 3986 : break;
110 : : case SURFACE:
111 : 34058 : index = 1;
112 : 34058 : break;
113 : : case SURFACE_MIXED:
114 : 0 : index = 2;
115 : 0 : break;
116 : : case VOLUME:
117 : 67120 : index = 3;
118 : 67120 : break;
119 : : case VOLUME_MIXED_1:
120 : 0 : index = 4;
121 : 0 : break;
122 : : case VOLUME_MIXED_2:
123 : 0 : index = 5;
124 : 0 : break;
125 : : case VOLUME_MIXED:
126 : 0 : index = 6;
127 : 0 : break;
128 : : }
129 : 105164 : return index;
130 : : }
131 : :
132 : 17 : bool HalfFacetRep::check_mixed_entity_type()
133 : : {
134 [ + - ]: 17 : if( !chk_mixed )
135 : : {
136 : 17 : chk_mixed = true;
137 : :
138 : : ErrorCode error;
139 [ + - ][ + - ]: 34 : Range felems, celems;
[ + - ]
140 : :
141 [ + - ][ - + ]: 17 : error = mb->get_entities_by_dimension( this->_rset, 2, felems );MB_CHK_ERR( error );
[ # # ][ # # ]
142 : :
143 [ + - ][ + + ]: 17 : if( felems.size() )
144 : : {
145 [ + - ][ + - ]: 16 : Range tris, quad, poly;
[ + - ][ + - ]
[ + - ]
146 [ + - ][ + - ]: 8 : tris = felems.subset_by_type( MBTRI );
147 [ + - ][ + - ]: 8 : quad = felems.subset_by_type( MBQUAD );
148 [ + - ][ + - ]: 8 : poly = felems.subset_by_type( MBPOLYGON );
149 [ + - ][ + + ]: 8 : if( ( tris.size() && quad.size() ) || ( tris.size() && poly.size() ) || ( quad.size() && poly.size() ) )
[ + - ][ + - ]
[ + - ][ + + ]
[ + - ][ + - ]
[ + - ][ + + ]
[ + - ][ - + ]
[ - + ]
150 : 0 : is_mixed = true;
151 [ + - ][ - + ]: 8 : if( poly.size() ) is_mixed = true;
152 : :
153 [ - + ][ + - ]: 16 : if( is_mixed ) return is_mixed;
154 : : }
155 : :
156 [ + - ][ - + ]: 17 : error = mb->get_entities_by_dimension( this->_rset, 3, celems );MB_CHK_ERR( error );
[ # # ][ # # ]
157 [ + - ][ + + ]: 17 : if( celems.size() )
158 : : {
159 [ + - ][ + - ]: 12 : Range tet, pyr, prism, hex, polyhed;
[ + - ][ + - ]
[ + - ]
160 [ + - ][ + - ]: 6 : tet = celems.subset_by_type( MBTET );
161 [ + - ][ + - ]: 6 : pyr = celems.subset_by_type( MBPYRAMID );
162 [ + - ][ + - ]: 6 : prism = celems.subset_by_type( MBPRISM );
163 [ + - ][ + - ]: 6 : hex = celems.subset_by_type( MBHEX );
164 [ + - ][ + - ]: 6 : polyhed = celems.subset_by_type( MBPOLYHEDRON );
165 [ + - ][ + - ]: 24 : if( ( tet.size() && pyr.size() ) || ( tet.size() && prism.size() ) || ( tet.size() && hex.size() ) ||
[ + - ][ + - ]
[ + + ][ + - ]
[ + - ][ + - ]
[ + + ][ + - ]
[ + - ][ + + ]
[ - + ]
166 [ + - ][ + - ]: 18 : ( tet.size() && polyhed.size() ) || ( pyr.size() && prism.size() ) || ( pyr.size() && hex.size() ) ||
[ + - ][ + - ]
[ - + ][ # # ]
[ # # ][ + - ]
[ - + ][ # # ]
[ # # ][ - + ]
167 [ + - ][ # # ]: 18 : ( pyr.size() && polyhed.size() ) || ( prism.size() && hex.size() ) ||
[ # # ][ + - ]
[ - + ][ # # ]
[ # # ][ - + ]
168 [ + + ][ + - ]: 18 : ( prism.size() && polyhed.size() ) || ( hex.size() && polyhed.size() ) )
[ # # ][ # # ]
[ + - ][ + + ]
[ + - ][ - + ]
169 : 0 : is_mixed = true;
170 : :
171 [ + - ][ - + ]: 12 : if( polyhed.size() ) is_mixed = true;
172 : : }
173 : :
174 : 17 : ScdInterface* scdi = NULL;
175 [ + - ][ - + ]: 17 : error = mb->query_interface( scdi );MB_CHK_ERR( error );
[ # # ][ # # ]
176 [ + - ]: 17 : if( scdi )
177 : : {
178 [ + - ]: 17 : Range boxes;
179 [ + - ][ - + ]: 17 : error = scdi->find_boxes( boxes );MB_CHK_ERR( error );
[ # # ][ # # ]
180 : :
181 [ + - ][ - + ]: 17 : if( !boxes.empty() ) is_mixed = true;
[ + - ][ + - ]
182 : 17 : }
183 : : }
184 : 17 : return is_mixed;
185 : : }
186 : :
187 : : /*******************************************************
188 : : * initialize *
189 : : ******************************************************/
190 : :
191 : 39 : ErrorCode HalfFacetRep::initialize()
192 : : {
193 : : ErrorCode error;
194 : :
195 [ + - ]: 39 : if( !mInitAHFmaps )
196 : : {
197 : 39 : mInitAHFmaps = true;
198 : : #ifdef MOAB_HAVE_MPI
199 [ + + ][ + + ]: 39 : if( pcomm && _filterghost )
200 : : {
201 [ + - ][ + - ]: 6 : moab::Range _averts, _aedgs, _afacs, _acels;
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
202 [ + - ][ - + ]: 3 : error = mb->get_entities_by_dimension( this->_rset, 0, _averts, true );MB_CHK_ERR( error );
[ # # ][ # # ]
203 [ + - ][ - + ]: 3 : error = mb->get_entities_by_dimension( this->_rset, 1, _aedgs, true );MB_CHK_ERR( error );
[ # # ][ # # ]
204 [ + - ][ - + ]: 3 : error = mb->get_entities_by_dimension( this->_rset, 2, _afacs, true );MB_CHK_ERR( error );
[ # # ][ # # ]
205 [ + - ][ - + ]: 3 : error = mb->get_entities_by_dimension( this->_rset, 3, _acels, true );MB_CHK_ERR( error );
[ # # ][ # # ]
206 : :
207 : : // filter based on parallel status
208 [ + - ][ - + ]: 3 : error = pcomm->filter_pstatus( _averts, PSTATUS_GHOST, PSTATUS_NOT, -1, &_verts );MB_CHK_ERR( error );
[ # # ][ # # ]
209 [ + - ][ - + ]: 3 : error = pcomm->filter_pstatus( _aedgs, PSTATUS_GHOST, PSTATUS_NOT, -1, &_edges );MB_CHK_ERR( error );
[ # # ][ # # ]
210 [ + - ][ - + ]: 3 : error = pcomm->filter_pstatus( _afacs, PSTATUS_GHOST, PSTATUS_NOT, -1, &_faces );MB_CHK_ERR( error );
[ # # ][ # # ]
211 [ + - ][ - + ]: 6 : error = pcomm->filter_pstatus( _acels, PSTATUS_GHOST, PSTATUS_NOT, -1, &_cells );MB_CHK_ERR( error );
[ # # ][ # # ]
[ + - ]
212 : : }
213 : : else
214 : : {
215 [ - + ][ # # ]: 36 : error = mb->get_entities_by_dimension( this->_rset, 0, _verts, true );MB_CHK_ERR( error );
216 [ - + ][ # # ]: 36 : error = mb->get_entities_by_dimension( this->_rset, 1, _edges, true );MB_CHK_ERR( error );
217 [ - + ][ # # ]: 36 : error = mb->get_entities_by_dimension( this->_rset, 2, _faces, true );MB_CHK_ERR( error );
218 [ - + ][ # # ]: 36 : error = mb->get_entities_by_dimension( this->_rset, 3, _cells, true );MB_CHK_ERR( error );
219 : : }
220 : : #else
221 : : error = mb->get_entities_by_dimension( this->_rset, 0, _verts, true );MB_CHK_ERR( error );
222 : : error = mb->get_entities_by_dimension( this->_rset, 1, _edges, true );MB_CHK_ERR( error );
223 : : error = mb->get_entities_by_dimension( this->_rset, 2, _faces, true );MB_CHK_ERR( error );
224 : : error = mb->get_entities_by_dimension( this->_rset, 3, _cells, true );MB_CHK_ERR( error );
225 : :
226 : : #endif
227 : :
228 : 39 : int nverts = _verts.size();
229 : 39 : int nedges = _edges.size();
230 : 39 : int nfaces = _faces.size();
231 : 39 : int ncells = _cells.size();
232 : :
233 : 39 : MESHTYPE mesh_type = get_mesh_type( nverts, nedges, nfaces, ncells );
234 : 39 : thismeshtype = mesh_type;
235 : :
236 : : // Initialize mesh type specific maps
237 [ + + ]: 39 : if( thismeshtype == CURVE )
238 : : {
239 [ - + ][ # # ]: 7 : error = init_curve();MB_CHK_ERR( error );
240 : : }
241 [ + + ]: 32 : else if( thismeshtype == SURFACE )
242 : : {
243 [ - + ][ # # ]: 25 : error = init_surface();MB_CHK_ERR( error );
244 : : }
245 [ - + ]: 7 : else if( thismeshtype == SURFACE_MIXED )
246 : : {
247 [ # # ][ # # ]: 0 : error = init_curve();MB_CHK_ERR( error );
248 [ # # ][ # # ]: 0 : error = init_surface();MB_CHK_ERR( error );
249 : : }
250 [ + + ]: 7 : else if( thismeshtype == VOLUME )
251 : : {
252 [ - + ][ # # ]: 6 : error = init_volume();MB_CHK_ERR( error );
253 : : }
254 [ - + ]: 1 : else if( thismeshtype == VOLUME_MIXED_1 )
255 : : {
256 [ # # ][ # # ]: 0 : error = init_curve();MB_CHK_ERR( error );
257 [ # # ][ # # ]: 0 : error = init_volume();MB_CHK_ERR( error );
258 : : }
259 [ - + ]: 1 : else if( thismeshtype == VOLUME_MIXED_2 )
260 : : {
261 [ # # ][ # # ]: 0 : error = init_surface();MB_CHK_ERR( error );
262 [ # # ][ # # ]: 0 : error = init_volume();MB_CHK_ERR( error );
263 : : }
264 [ + - ]: 1 : else if( thismeshtype == VOLUME_MIXED )
265 : : {
266 [ - + ][ # # ]: 1 : error = init_curve();MB_CHK_ERR( error );
267 [ - + ][ # # ]: 1 : error = init_surface();MB_CHK_ERR( error );
268 [ - + ][ # # ]: 39 : error = init_volume();MB_CHK_ERR( error );
269 : : }
270 : : }
271 : 39 : return MB_SUCCESS;
272 : : }
273 : :
274 : 1 : ErrorCode HalfFacetRep::deinitialize()
275 : : {
276 : 1 : return MB_SUCCESS;
277 : : }
278 : :
279 : 8 : ErrorCode HalfFacetRep::init_curve()
280 : : {
281 : : ErrorCode error;
282 : :
283 [ + - ][ + - ]: 8 : int nv = ID_FROM_HANDLE( *( _verts.end() - 1 ) );
[ + - ]
284 [ + - ][ + - ]: 8 : int ne = ID_FROM_HANDLE( *( _edges.end() - 1 ) );
[ + - ]
285 : :
286 [ + - ]: 8 : v2hv.resize( nv, 0 );
287 [ + - ]: 8 : sibhvs.resize( ne * 2, 0 );
288 : :
289 [ - + ][ # # ]: 8 : error = determine_sibling_halfverts( _verts, _edges );MB_CHK_ERR( error );
290 [ - + ][ # # ]: 8 : error = determine_incident_halfverts( _edges );MB_CHK_ERR( error );
291 : :
292 : 8 : return MB_SUCCESS;
293 : : }
294 : :
295 : 26 : ErrorCode HalfFacetRep::init_surface()
296 : : {
297 : : ErrorCode error;
298 [ + - ][ + - ]: 26 : EntityType ftype = mb->type_from_handle( *_faces.begin() );
299 : 26 : int nepf = lConnMap2D[ftype - 2].num_verts_in_face;
300 : :
301 [ + - ][ + - ]: 26 : int nv = ID_FROM_HANDLE( *( _verts.end() - 1 ) );
[ + - ]
302 [ + - ][ + - ]: 26 : int nf = ID_FROM_HANDLE( *( _faces.end() - 1 ) );
[ + - ]
303 : :
304 [ + - ]: 26 : v2he.resize( nv, 0 );
305 [ + - ]: 26 : sibhes.resize( nf * nepf, 0 );
306 : :
307 : : // Construct ahf maps
308 [ - + ][ # # ]: 26 : error = determine_sibling_halfedges( _faces );MB_CHK_ERR( error );
309 [ - + ][ # # ]: 26 : error = determine_incident_halfedges( _faces );MB_CHK_ERR( error );
310 : :
311 : : // Initialize queues for storing face and local id's during local search
312 [ + + ]: 5226 : for( int i = 0; i < MAXSIZE; i++ )
313 : : {
314 : 5200 : queue_fid[i] = 0;
315 : 5200 : queue_lid[i] = 0;
316 : 5200 : trackfaces[i] = 0;
317 : : }
318 : :
319 : 26 : return MB_SUCCESS;
320 : : }
321 : :
322 : 7 : ErrorCode HalfFacetRep::init_volume()
323 : : {
324 : : ErrorCode error;
325 : :
326 : : // Initialize std::map between cell-types and their index in lConnMap3D
327 [ + - ]: 7 : cell_index[MBTET] = 0;
328 [ + - ]: 7 : cell_index[MBPYRAMID] = 1;
329 [ + - ]: 7 : cell_index[MBPRISM] = 2;
330 [ + - ]: 7 : cell_index[MBHEX] = 3;
331 : :
332 [ + - ][ + - ]: 7 : int index = get_index_in_lmap( *_cells.begin() );
333 : 7 : int nfpc = lConnMap3D[index].num_faces_in_cell;
334 [ + - ][ + - ]: 7 : int nv = ID_FROM_HANDLE( *( _verts.end() - 1 ) );
[ + - ]
335 [ + - ][ + - ]: 7 : int nc = ID_FROM_HANDLE( *( _cells.end() - 1 ) );
[ + - ]
336 : : ;
337 : :
338 [ + - ]: 7 : v2hf.resize( nv, 0 );
339 [ + - ]: 7 : sibhfs.resize( nc * nfpc, 0 );
340 : :
341 : : // Construct the maps
342 [ - + ][ # # ]: 7 : error = determine_sibling_halffaces( _cells );MB_CHK_ERR( error );
343 [ - + ][ # # ]: 7 : error = determine_incident_halffaces( _cells );MB_CHK_ERR( error );
344 : :
345 : : // Initialize queues for storing face and local id's during local search
346 [ + + ]: 1407 : for( int i = 0; i < MAXSIZE; i++ )
347 : : {
348 : 1400 : Stkcells[i] = 0;
349 : 1400 : cellq[i] = 0;
350 : 1400 : trackcells[i] = 0;
351 : : }
352 : :
353 : 7 : return MB_SUCCESS;
354 : : }
355 : :
356 : : //////////////////////////////////////////////////
357 : 0 : ErrorCode HalfFacetRep::print_tags( int dim )
358 : : {
359 [ # # ]: 0 : if( dim == 1 )
360 : : {
361 [ # # ]: 0 : EntityHandle start_edge = *_edges.begin();
362 : 0 : std::cout << "start_edge = " << start_edge << std::endl;
363 : 0 : std::cout << "<SIBHVS_EID,SIBHVS_LVID>" << std::endl;
364 : :
365 [ # # ][ # # ]: 0 : for( Range::iterator i = _edges.begin(); i != _edges.end(); ++i )
[ # # ][ # # ]
[ # # ]
366 : : {
367 : : EntityHandle eid[2];
368 : : int lvid[2];
369 [ # # ][ # # ]: 0 : int eidx = ID_FROM_HANDLE( *i ) - 1;
370 [ # # ]: 0 : HFacet hf1 = sibhvs[2 * eidx];
371 [ # # ]: 0 : HFacet hf2 = sibhvs[2 * eidx + 1];
372 [ # # ]: 0 : eid[0] = fid_from_halfacet( hf1, MBEDGE );
373 [ # # ]: 0 : eid[1] = fid_from_halfacet( hf2, MBEDGE );
374 [ # # ]: 0 : lvid[0] = lid_from_halffacet( hf1 );
375 [ # # ]: 0 : lvid[1] = lid_from_halffacet( hf2 );
376 [ # # ][ # # ]: 0 : std::cout << "Entity = " << *i << " :: <" << eid[0] << "," << lvid[0] << ">"
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
377 [ # # ]: 0 : << " "
378 [ # # ][ # # ]: 0 : << "<" << eid[1] << "," << lvid[1] << ">" << std::endl;
[ # # ][ # # ]
[ # # ][ # # ]
379 : : }
380 : :
381 : 0 : std::cout << "<V2HV_EID, V2HV_LVID>" << std::endl;
382 : :
383 [ # # ][ # # ]: 0 : for( Range::iterator i = _verts.begin(); i != _verts.end(); ++i )
[ # # ][ # # ]
[ # # ]
384 : : {
385 [ # # ][ # # ]: 0 : int vidx = ID_FROM_HANDLE( *i ) - 1;
386 [ # # ]: 0 : HFacet hf = v2hv[vidx];
387 [ # # ]: 0 : EntityHandle eid = fid_from_halfacet( hf, MBEDGE );
388 [ # # ]: 0 : int lvid = lid_from_halffacet( hf );
389 [ # # ][ # # ]: 0 : std::cout << "Vertex = " << *i << " :: <" << eid << "," << lvid << ">" << std::endl;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
390 : : }
391 : : }
392 [ # # ]: 0 : else if( dim == 2 )
393 : : {
394 [ # # ][ # # ]: 0 : EntityType ftype = mb->type_from_handle( *_faces.begin() );
395 : 0 : int nepf = lConnMap2D[ftype - 2].num_verts_in_face;
396 [ # # ]: 0 : EntityHandle start_face = *_faces.begin();
397 : 0 : std::cout << "start_face = " << start_face << std::endl;
398 : 0 : std::cout << "<SIBHES_FID,SIBHES_LEID>" << std::endl;
399 : :
400 [ # # ][ # # ]: 0 : for( Range::iterator i = _faces.begin(); i != _faces.end(); ++i )
[ # # ][ # # ]
[ # # ]
401 : : {
402 [ # # ][ # # ]: 0 : int fidx = ID_FROM_HANDLE( *i ) - 1;
403 [ # # ][ # # ]: 0 : std::cout << "Entity = " << *i;
[ # # ]
404 [ # # ]: 0 : for( int j = 0; j < nepf; j++ )
405 : : {
406 [ # # ]: 0 : HFacet hf = sibhes[nepf * fidx + j];
407 [ # # ]: 0 : EntityHandle sib = fid_from_halfacet( hf, ftype );
408 [ # # ]: 0 : int lid = lid_from_halffacet( hf );
409 [ # # ][ # # ]: 0 : std::cout << " :: <" << sib << "," << lid << ">"
[ # # ][ # # ]
[ # # ]
410 [ # # ]: 0 : << " ";
411 : : }
412 [ # # ]: 0 : std::cout << std::endl;
413 : : }
414 : :
415 : 0 : std::cout << "<V2HE_FID, V2HE_LEID>" << std::endl;
416 : :
417 [ # # ][ # # ]: 0 : for( Range::iterator i = _verts.begin(); i != _verts.end(); ++i )
[ # # ][ # # ]
[ # # ]
418 : : {
419 [ # # ][ # # ]: 0 : int vidx = ID_FROM_HANDLE( *i ) - 1;
420 [ # # ]: 0 : HFacet hf = v2he[vidx];
421 [ # # ]: 0 : EntityHandle fid = fid_from_halfacet( hf, ftype );
422 [ # # ]: 0 : int lid = lid_from_halffacet( hf );
423 [ # # ][ # # ]: 0 : std::cout << "Vertex = " << *i << " :: <" << fid << "," << lid << ">" << std::endl;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
424 : : }
425 : : }
426 [ # # ]: 0 : else if( dim == 3 )
427 : : {
428 [ # # ][ # # ]: 0 : EntityType ctype = mb->type_from_handle( *_cells.begin() );
429 : :
430 [ # # ][ # # ]: 0 : int index = get_index_in_lmap( *_cells.begin() );
431 : 0 : int nfpc = lConnMap3D[index].num_faces_in_cell;
432 [ # # ]: 0 : EntityHandle start_cell = *_cells.begin();
433 : 0 : std::cout << "start_cell = " << start_cell << std::endl;
434 : 0 : std::cout << "<SIBHES_CID,SIBHES_LFID>" << std::endl;
435 : :
436 [ # # ][ # # ]: 0 : for( Range::iterator i = _cells.begin(); i != _cells.end(); ++i )
[ # # ][ # # ]
[ # # ]
437 : : {
438 [ # # ][ # # ]: 0 : int cidx = ID_FROM_HANDLE( *i ) - 1;
439 [ # # ][ # # ]: 0 : std::cout << "Entity = " << *i;
[ # # ]
440 [ # # ]: 0 : for( int j = 0; j < nfpc; j++ )
441 : : {
442 [ # # ]: 0 : HFacet hf = sibhfs[nfpc * cidx + j];
443 [ # # ]: 0 : EntityHandle sib = fid_from_halfacet( hf, ctype );
444 [ # # ]: 0 : int lid = lid_from_halffacet( hf );
445 [ # # ][ # # ]: 0 : std::cout << " :: <" << sib << "," << lid << ">"
[ # # ][ # # ]
[ # # ]
446 [ # # ]: 0 : << " ";
447 : : }
448 [ # # ]: 0 : std::cout << std::endl;
449 : : }
450 : :
451 : 0 : std::cout << "<V2HF_CID, V2HF_LFID>" << std::endl;
452 : : EntityHandle cid;
453 : : int lid;
454 : :
455 [ # # ][ # # ]: 0 : for( Range::iterator i = _verts.begin(); i != _verts.end(); ++i )
[ # # ][ # # ]
[ # # ]
456 : : {
457 [ # # ][ # # ]: 0 : int vidx = ID_FROM_HANDLE( *i ) - 1;
458 [ # # ]: 0 : HFacet hf = v2hf[vidx];
459 : :
460 [ # # ][ # # ]: 0 : if( hf == 0 && ( v2hfs.find( *i ) != v2hfs.end() ) )
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # #
# # # # ]
461 : : {
462 : : std::pair< std::multimap< EntityHandle, HFacet >::iterator,
463 : : std::multimap< EntityHandle, HFacet >::iterator >
464 [ # # ]: 0 : it_hfs;
465 [ # # ][ # # ]: 0 : it_hfs = v2hfs.equal_range( *i );
466 : :
467 [ # # ][ # # ]: 0 : for( std::multimap< EntityHandle, HFacet >::iterator it = it_hfs.first; it != it_hfs.second; ++it )
[ # # ]
468 : : {
469 [ # # ][ # # ]: 0 : cid = fid_from_halfacet( it->second, ctype );
470 [ # # ]: 0 : lid = lid_from_halffacet( hf );
471 : :
472 [ # # ][ # # ]: 0 : std::cout << "Vertex = " << *i << " :: <" << cid << "," << lid << ">" << std::endl;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
473 : : }
474 : : }
475 : : else
476 : : {
477 [ # # ]: 0 : cid = fid_from_halfacet( hf, ctype );
478 [ # # ]: 0 : lid = lid_from_halffacet( hf );
479 [ # # ][ # # ]: 0 : std::cout << "Vertex = " << *i << " :: <" << cid << "," << lid << ">" << std::endl;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
480 : : }
481 : : }
482 : : }
483 : 0 : return MB_SUCCESS;
484 : : }
485 : :
486 : : /**********************************************************
487 : : * User interface for adjacency functions *
488 : : ********************************************************/
489 : :
490 : 105164 : ErrorCode HalfFacetRep::get_adjacencies( const EntityHandle source_entity, const unsigned int target_dimension,
491 : : std::vector< EntityHandle >& target_entities )
492 : : {
493 : :
494 : : ErrorCode error;
495 : :
496 : 105164 : unsigned int source_dimension = mb->dimension_from_handle( source_entity );
497 [ - + ][ # # ]: 105164 : assert( ( source_dimension <= target_dimension ) || ( source_dimension > target_dimension ) );
498 : :
499 [ - + ]: 105164 : if( mInitAHFmaps == false )
500 : : {
501 [ # # ][ # # ]: 0 : error = initialize();MB_CHK_ERR( error );
502 : : }
503 : :
504 : 105164 : int mindex = get_index_for_meshtype( thismeshtype );
505 : 105164 : int adj_possible = adjMatrix[mindex].val[source_dimension][target_dimension];
506 : :
507 [ + - ]: 105164 : if( adj_possible )
508 : : {
509 [ + + ]: 105164 : if( source_dimension < target_dimension )
510 : : {
511 [ - + ][ # # ]: 45954 : error = get_up_adjacencies( source_entity, target_dimension, target_entities );MB_CHK_ERR( error );
512 : : }
513 [ + - ]: 59210 : else if( source_dimension == target_dimension )
514 : : {
515 [ - + ][ # # ]: 59210 : error = get_neighbor_adjacencies( source_entity, target_entities );MB_CHK_ERR( error );
516 : : }
517 : : else
518 : : {
519 [ # # ][ # # ]: 0 : error = get_down_adjacencies( source_entity, target_dimension, target_entities );MB_CHK_ERR( error );
520 : : }
521 : : }
522 : : else
523 : 0 : return MB_SUCCESS;
524 : :
525 : 105164 : return MB_SUCCESS;
526 : : }
527 : :
528 : 1146195 : ErrorCode HalfFacetRep::get_up_adjacencies( EntityHandle ent, int out_dim, std::vector< EntityHandle >& adjents,
529 : : std::vector< int >* lids )
530 : : {
531 : : ErrorCode error;
532 : 1146195 : int in_dim = mb->dimension_from_handle( ent );
533 [ + - ][ + - ]: 1146195 : assert( ( in_dim >= 0 && in_dim <= 2 ) && ( out_dim > in_dim ) );
[ - + ]
534 : :
535 [ + + ]: 1146195 : if( in_dim == 0 )
536 : : {
537 [ + + ]: 1145727 : if( out_dim == 1 )
538 : : {
539 [ - + ][ # # ]: 4088 : error = get_up_adjacencies_1d( ent, adjents, lids );MB_CHK_ERR( error );
540 : : }
541 [ + + ]: 1141639 : else if( out_dim == 2 )
542 : : {
543 [ - + ][ # # ]: 1114124 : error = get_up_adjacencies_vert_2d( ent, adjents );MB_CHK_ERR( error );
544 : : }
545 [ + - ]: 27515 : else if( out_dim == 3 )
546 : : {
547 [ - + ][ # # ]: 27515 : error = get_up_adjacencies_vert_3d( ent, adjents );MB_CHK_ERR( error );
548 : : }
549 : : }
550 : :
551 [ + + ][ + + ]: 638 : else if( ( in_dim == 1 ) && ( out_dim == 2 ) )
552 : : {
553 [ - + ][ # # ]: 170 : error = get_up_adjacencies_2d( ent, adjents, lids );MB_CHK_ERR( error );
554 : : }
555 [ + + ][ + - ]: 468 : else if( ( in_dim == 1 ) && ( out_dim == 3 ) )
556 : : {
557 [ - + ][ # # ]: 170 : error = get_up_adjacencies_edg_3d( ent, adjents, lids );MB_CHK_ERR( error );
558 : : }
559 [ + - ][ + - ]: 128 : else if( ( in_dim == 2 ) && ( out_dim == 3 ) )
560 : : {
561 [ - + ][ # # ]: 128 : error = get_up_adjacencies_face_3d( ent, adjents, lids );MB_CHK_ERR( error );
562 : : }
563 : 1146195 : return MB_SUCCESS;
564 : : }
565 : :
566 : 59540 : ErrorCode HalfFacetRep::get_neighbor_adjacencies( EntityHandle ent, std::vector< EntityHandle >& adjents )
567 : : {
568 : : ErrorCode error;
569 : 59540 : int in_dim = mb->dimension_from_handle( ent );
570 [ + - ][ - + ]: 59540 : assert( in_dim >= 1 && in_dim <= 3 );
571 : :
572 [ + + ]: 59540 : if( in_dim == 1 )
573 : : {
574 [ - + ][ # # ]: 2160 : error = get_neighbor_adjacencies_1d( ent, adjents );MB_CHK_ERR( error );
575 : : }
576 : :
577 [ + + ]: 57380 : else if( in_dim == 2 )
578 : : {
579 [ - + ][ # # ]: 17668 : error = get_neighbor_adjacencies_2d( ent, adjents );MB_CHK_ERR( error );
580 : : }
581 [ + - ]: 39712 : else if( in_dim == 3 )
582 : : {
583 [ - + ][ # # ]: 39712 : error = get_neighbor_adjacencies_3d( ent, adjents );MB_CHK_ERR( error );
584 : : }
585 : 59540 : return MB_SUCCESS;
586 : : }
587 : :
588 : 192 : ErrorCode HalfFacetRep::get_down_adjacencies( EntityHandle ent, int out_dim, std::vector< EntityHandle >& adjents )
589 : : {
590 : : ErrorCode error;
591 : 192 : int in_dim = mb->dimension_from_handle( ent );
592 [ + - ][ + - ]: 192 : assert( ( in_dim >= 2 && in_dim <= 3 ) && ( out_dim < in_dim ) );
[ - + ]
593 : :
594 [ + + ][ + - ]: 320 : if( ( in_dim == 2 ) && ( out_dim == 1 ) )
595 : : {
596 [ - + ][ # # ]: 128 : error = get_down_adjacencies_2d( ent, adjents );MB_CHK_ERR( error );
597 : : }
598 [ + - ][ + + ]: 96 : else if( ( in_dim == 3 ) && ( out_dim == 1 ) )
599 : : {
600 [ - + ][ # # ]: 32 : error = get_down_adjacencies_edg_3d( ent, adjents );MB_CHK_ERR( error );
601 : : }
602 [ + - ][ + - ]: 32 : else if( ( in_dim == 3 ) && ( out_dim == 2 ) )
603 : : {
604 [ - + ][ # # ]: 32 : error = get_down_adjacencies_face_3d( ent, adjents );MB_CHK_ERR( error );
605 : : }
606 : 192 : return MB_SUCCESS;
607 : : }
608 : :
609 : 48 : ErrorCode HalfFacetRep::count_subentities( Range& edges, Range& faces, Range& cells, int* nedges, int* nfaces )
610 : : {
611 : : ErrorCode error;
612 [ + + ][ + - ]: 48 : if( edges.size() && !faces.size() && !cells.size() )
[ + - ][ + + ]
613 : : {
614 : 10 : nedges[0] = edges.size();
615 : 10 : nfaces[0] = 0;
616 : : }
617 [ + + ][ + - ]: 38 : else if( faces.size() && !cells.size() )
[ + + ]
618 : : {
619 : 22 : nedges[0] = find_total_edges_2d( faces );
620 : 22 : nfaces[0] = 0;
621 : : }
622 [ + - ]: 16 : else if( cells.size() )
623 : : {
624 [ + - ][ - + ]: 16 : error = find_total_edges_faces_3d( cells, nedges, nfaces );MB_CHK_ERR( error );
[ # # ]
625 : : }
626 : 48 : return MB_SUCCESS;
627 : : }
628 : :
629 : : /********************************************************
630 : : * 1D: sibhvs, v2hv, incident and neighborhood queries *
631 : : *********************************************************/
632 : 8 : ErrorCode HalfFacetRep::determine_sibling_halfverts( Range& verts, Range& edges )
633 : : {
634 : : ErrorCode error;
635 : :
636 : : // Step 1: Create an index list storing the starting position for each vertex
637 [ + - ]: 8 : int nv = verts.size();
638 [ + - ]: 8 : std::vector< int > is_index( nv + 1 );
639 [ + + ]: 145 : for( int i = 0; i < nv + 1; i++ )
640 [ + - ]: 137 : is_index[i] = 0;
641 : :
642 [ + - ][ + - ]: 230 : for( Range::iterator eid = edges.begin(); eid != edges.end(); ++eid )
[ + - ][ + - ]
[ + + ]
643 : : {
644 : : const EntityHandle* conn;
645 : 222 : int num_conn = 0;
646 [ + - ][ + - ]: 222 : error = mb->get_connectivity( *eid, conn, num_conn, true );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
647 : :
648 [ + - ]: 222 : int index = verts.index( conn[0] );
649 [ + - ]: 222 : is_index[index + 1] += 1;
650 [ + - ]: 222 : index = verts.index( conn[1] );
651 [ + - ]: 222 : is_index[index + 1] += 1;
652 : : }
653 [ + - ]: 8 : is_index[0] = 0;
654 : :
655 [ + + ]: 137 : for( int i = 0; i < nv; i++ )
656 [ + - ][ + - ]: 129 : is_index[i + 1] = is_index[i] + is_index[i + 1];
[ + - ]
657 : :
658 : : // Step 2: Define two arrays v2hv_eid, v2hv_lvid storing every half-facet on a vertex
659 [ + - ][ + - ]: 16 : std::vector< EntityHandle > v2hv_map_eid( 2 * edges.size() );
660 [ + - ][ + - ]: 16 : std::vector< int > v2hv_map_lvid( 2 * edges.size() );
661 : :
662 [ + - ][ + - ]: 230 : for( Range::iterator eid = edges.begin(); eid != edges.end(); ++eid )
[ + - ][ + - ]
[ + + ]
663 : : {
664 : : const EntityHandle* conn;
665 : 222 : int num_conn = 0;
666 [ + - ][ + - ]: 222 : error = mb->get_connectivity( *eid, conn, num_conn, true );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
667 : :
668 [ + + ]: 666 : for( int j = 0; j < 2; j++ )
669 : : {
670 [ + - ]: 444 : int v = verts.index( conn[j] );
671 [ + - ][ + - ]: 444 : v2hv_map_eid[is_index[v]] = *eid;
[ + - ]
672 [ + - ][ + - ]: 444 : v2hv_map_lvid[is_index[v]] = j;
673 [ + - ]: 444 : is_index[v] += 1;
674 : : }
675 : : }
676 : :
677 [ + + ]: 129 : for( int i = nv - 2; i >= 0; i-- )
678 [ + - ][ + - ]: 121 : is_index[i + 1] = is_index[i];
679 [ + - ]: 8 : is_index[0] = 0;
680 : :
681 : : // Step 3: Fill up sibling half-verts map
682 [ + - ][ + - ]: 137 : for( Range::iterator vid = verts.begin(); vid != verts.end(); ++vid )
[ + - ][ + - ]
[ + + ]
683 : : {
684 [ + - ][ + - ]: 129 : int v = verts.index( *vid );
685 [ + - ]: 129 : int last = is_index[v + 1] - 1;
686 [ + - ][ + + ]: 129 : if( last > is_index[v] )
687 : : {
688 [ + - ]: 123 : EntityHandle prev_eid = v2hv_map_eid[last];
689 [ + - ]: 123 : int prev_lvid = v2hv_map_lvid[last];
690 : :
691 [ + - ][ + + ]: 561 : for( int i = is_index[v]; i <= last; i++ )
692 : : {
693 [ + - ]: 438 : EntityHandle cur_eid = v2hv_map_eid[i];
694 [ + - ]: 438 : int cur_lvid = v2hv_map_lvid[i];
695 : :
696 [ + - ]: 438 : int pidx = ID_FROM_HANDLE( prev_eid ) - 1;
697 [ + - ][ + - ]: 438 : sibhvs[2 * pidx + prev_lvid] = create_halffacet( cur_eid, cur_lvid );
698 : :
699 : 438 : prev_eid = cur_eid;
700 : 438 : prev_lvid = cur_lvid;
701 : : }
702 : : }
703 : : }
704 : :
705 : 16 : return MB_SUCCESS;
706 : : }
707 : :
708 : : ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
709 : 8 : ErrorCode HalfFacetRep::determine_incident_halfverts( Range& edges )
710 : : {
711 : : ErrorCode error;
712 : :
713 [ + - ][ + - ]: 230 : for( Range::iterator e_it = edges.begin(); e_it != edges.end(); ++e_it )
[ + - ][ + - ]
[ + + ]
714 : : {
715 [ + - ]: 222 : EntityHandle cur_eid = *e_it;
716 : : const EntityHandle* conn;
717 : 222 : int num_conn = 0;
718 [ + - ][ + - ]: 222 : error = mb->get_connectivity( *e_it, conn, num_conn, true );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
719 : :
720 [ + + ]: 666 : for( int i = 0; i < 2; ++i )
721 : : {
722 : 444 : EntityHandle v = conn[i];
723 [ + - ]: 444 : int vidx = ID_FROM_HANDLE( v ) - 1;
724 : :
725 [ + - ]: 444 : HFacet hf = v2hv[vidx];
726 [ + - ]: 444 : EntityHandle eid = fid_from_halfacet( hf, MBEDGE );
727 [ + + ][ + - ]: 444 : if( eid == 0 ) { v2hv[vidx] = create_halffacet( cur_eid, i ); }
[ + - ]
728 : : }
729 : : }
730 : :
731 : 8 : return MB_SUCCESS;
732 : : }
733 : : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
734 : 4472 : ErrorCode HalfFacetRep::get_up_adjacencies_1d( EntityHandle vid, std::vector< EntityHandle >& adjents,
735 : : std::vector< int >* lvids )
736 : : {
737 : 4472 : adjents.clear();
738 [ + - ]: 4472 : adjents.reserve( 20 );
739 : :
740 [ - + ][ # # ]: 4472 : if( lvids != NULL ) lvids->reserve( 20 );
741 : :
742 [ + - ]: 4472 : int vidx = ID_FROM_HANDLE( vid ) - 1;
743 [ + - ]: 4472 : HFacet hf = v2hv[vidx];
744 : :
745 [ + - ]: 4472 : EntityHandle start_eid = fid_from_halfacet( hf, MBEDGE );
746 [ + - ]: 4472 : int start_lid = lid_from_halffacet( hf );
747 : :
748 : 4472 : EntityHandle eid = start_eid;
749 : 4472 : int lid = start_lid;
750 : :
751 [ + - ]: 4472 : if( eid != 0 )
752 : : {
753 [ + - ]: 4472 : adjents.push_back( eid );
754 [ - + ][ # # ]: 4472 : if( lvids != NULL ) lvids->push_back( lid );
755 : :
756 [ + - ]: 14706 : while( eid != 0 )
757 : : {
758 [ + - ]: 10234 : int eidx = ID_FROM_HANDLE( eid ) - 1;
759 [ + - ]: 10234 : HFacet shf = sibhvs[2 * eidx + lid];
760 [ + - ]: 10234 : eid = fid_from_halfacet( shf, MBEDGE );
761 [ + - ]: 10234 : lid = lid_from_halffacet( shf );
762 : :
763 [ + + ][ + + ]: 10234 : if( ( !eid ) || ( eid == start_eid ) ) break;
764 : :
765 [ + - ]: 5762 : adjents.push_back( eid );
766 [ - + ][ # # ]: 5762 : if( lvids != NULL ) lvids->push_back( lid );
767 : : }
768 : : }
769 : :
770 : 4472 : return MB_SUCCESS;
771 : : }
772 : : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
773 : 2160 : ErrorCode HalfFacetRep::get_neighbor_adjacencies_1d( EntityHandle eid, std::vector< EntityHandle >& adjents )
774 : : {
775 : 2160 : adjents.clear();
776 [ + - ]: 2160 : adjents.reserve( 20 );
777 : :
778 : : EntityHandle sibhv_eid;
779 : : int sibhv_lid;
780 [ + - ]: 2160 : int eidx = ID_FROM_HANDLE( eid ) - 1;
781 : :
782 [ + + ]: 6480 : for( int lid = 0; lid < 2; ++lid )
783 : : {
784 [ + - ]: 4320 : HFacet shf = sibhvs[2 * eidx + lid];
785 [ + - ]: 4320 : sibhv_eid = fid_from_halfacet( shf, MBEDGE );
786 [ + - ]: 4320 : sibhv_lid = lid_from_halffacet( shf );
787 : :
788 [ + + ]: 4320 : if( sibhv_eid != 0 )
789 : : {
790 [ + - ]: 4302 : adjents.push_back( sibhv_eid );
791 : :
792 [ + - ]: 4302 : eidx = ID_FROM_HANDLE( sibhv_eid ) - 1;
793 [ + - ]: 4302 : HFacet nhf = sibhvs[2 * eidx + sibhv_lid];
794 [ + - ]: 4302 : EntityHandle hv_eid = fid_from_halfacet( nhf, MBEDGE );
795 [ + - ]: 4302 : int hv_lid = lid_from_halffacet( nhf );
796 : :
797 [ + - ]: 9542 : while( hv_eid != 0 )
798 : : {
799 [ + + ][ + - ]: 5240 : if( hv_eid != eid ) adjents.push_back( hv_eid );
800 : :
801 [ + - ]: 5240 : eidx = ID_FROM_HANDLE( hv_eid ) - 1;
802 [ + - ]: 5240 : HFacet hf = sibhvs[2 * eidx + hv_lid];
803 [ + - ]: 5240 : EntityHandle edge = fid_from_halfacet( hf, MBEDGE );
804 [ + + ]: 5240 : if( edge == sibhv_eid ) break;
805 : :
806 : 938 : hv_eid = edge;
807 [ + - ]: 938 : hv_lid = lid_from_halffacet( hf );
808 : : }
809 : : }
810 : : }
811 : :
812 : 2160 : return MB_SUCCESS;
813 : : }
814 : :
815 : : /*******************************************************
816 : : * 2D: sibhes, v2he, incident and neighborhood queries *
817 : : ********************************************************/
818 : : const HalfFacetRep::LocalMaps2D HalfFacetRep::lConnMap2D[2] = {
819 : : // Triangle
820 : : { 3, { 1, 2, 0 }, { 2, 0, 1 } },
821 : : // Quad
822 : : { 4, { 1, 2, 3, 0 }, { 3, 0, 1, 2 } }
823 : : };
824 : :
825 : : ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
826 : 26 : ErrorCode HalfFacetRep::determine_sibling_halfedges( Range& faces )
827 : : {
828 : : ErrorCode error;
829 [ + - ][ + - ]: 26 : EntityHandle start_face = *faces.begin();
830 [ + - ]: 26 : EntityType ftype = mb->type_from_handle( start_face );
831 [ + - ]: 26 : int nfaces = faces.size();
832 : 26 : int nepf = lConnMap2D[ftype - 2].num_verts_in_face;
833 : :
834 : : // Step 1: Create an index list storing the starting position for each vertex
835 [ + - ]: 26 : int nv = _verts.size();
836 [ + - ]: 26 : std::vector< int > is_index( nv + 1 );
837 [ + + ]: 8168 : for( int i = 0; i < nv + 1; i++ )
838 [ + - ]: 8142 : is_index[i] = 0;
839 : :
840 : : int index;
841 : :
842 [ + - ][ + - ]: 13298 : for( Range::iterator fid = faces.begin(); fid != faces.end(); ++fid )
[ + - ][ + - ]
[ + + ]
843 : : {
844 : : const EntityHandle* conn;
845 [ + - ][ + - ]: 13272 : error = mb->get_connectivity( *fid, conn, nepf, true );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
846 : :
847 [ + + ]: 55923 : for( int i = 0; i < nepf; i++ )
848 : : {
849 [ + - ]: 42651 : index = _verts.index( conn[i] );
850 [ + - ]: 42651 : is_index[index + 1] += 1;
851 : : }
852 : : }
853 [ + - ]: 26 : is_index[0] = 0;
854 : :
855 [ + + ]: 8142 : for( int i = 0; i < nv; i++ )
856 [ + - ][ + - ]: 8116 : is_index[i + 1] = is_index[i] + is_index[i + 1];
[ + - ]
857 : :
858 : : // Step 2: Define two arrays v2hv_eid, v2hv_lvid storing every half-facet on a vertex
859 [ + - ]: 52 : std::vector< EntityHandle > v2nv( nepf * nfaces );
860 [ + - ]: 52 : std::vector< EntityHandle > v2he_map_fid( nepf * nfaces );
861 [ + - ]: 52 : std::vector< int > v2he_map_leid( nepf * nfaces );
862 : :
863 [ + - ][ + - ]: 13298 : for( Range::iterator fid = faces.begin(); fid != faces.end(); ++fid )
[ + - ][ + - ]
[ + + ]
864 : : {
865 : : const EntityHandle* conn;
866 [ + - ][ + - ]: 13272 : error = mb->get_connectivity( *fid, conn, nepf, true );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
867 : :
868 [ + + ]: 55923 : for( int j = 0; j < nepf; j++ )
869 : : {
870 [ + - ]: 42651 : int v = _verts.index( conn[j] );
871 : 42651 : int nidx = lConnMap2D[ftype - 2].next[j];
872 [ + - ][ + - ]: 42651 : v2nv[is_index[v]] = conn[nidx];
873 [ + - ][ + - ]: 42651 : v2he_map_fid[is_index[v]] = *fid;
[ + - ]
874 [ + - ][ + - ]: 42651 : v2he_map_leid[is_index[v]] = j;
875 [ + - ]: 42651 : is_index[v] += 1;
876 : : }
877 : : }
878 : :
879 [ + + ]: 8116 : for( int i = nv - 2; i >= 0; i-- )
880 [ + - ][ + - ]: 8090 : is_index[i + 1] = is_index[i];
881 [ + - ]: 26 : is_index[0] = 0;
882 : :
883 : : // Step 3: Fill up sibling half-verts map
884 [ + - ][ + - ]: 13298 : for( Range::iterator fid = faces.begin(); fid != faces.end(); ++fid )
[ + - ][ + - ]
[ + + ]
885 : : {
886 : : const EntityHandle* conn;
887 [ + - ][ + - ]: 13272 : error = mb->get_connectivity( *fid, conn, nepf, true );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
888 : :
889 [ + - ][ + - ]: 13272 : int fidx = ID_FROM_HANDLE( *fid ) - 1;
890 [ + + ]: 55923 : for( int k = 0; k < nepf; k++ )
891 : : {
892 [ + - ]: 42651 : HFacet hf = sibhes[nepf * fidx + k];
893 [ + - ]: 42651 : EntityHandle sibfid = fid_from_halfacet( hf, ftype );
894 : :
895 [ + + ]: 42651 : if( sibfid != 0 ) continue;
896 : :
897 : 21319 : int nidx = lConnMap2D[ftype - 2].next[k];
898 [ + - ]: 21319 : int v = _verts.index( conn[k] );
899 [ + - ]: 21319 : int vn = _verts.index( conn[nidx] );
900 : :
901 [ + - ]: 21319 : EntityHandle first_fid = *fid;
902 : 21319 : int first_leid = k;
903 : :
904 [ + - ]: 21319 : EntityHandle prev_fid = *fid;
905 : 21319 : int prev_leid = k;
906 : :
907 [ + - ][ + - ]: 137712 : for( index = is_index[vn]; index <= is_index[vn + 1] - 1; index++ )
[ + + ]
908 : : {
909 [ + - ][ + + ]: 116393 : if( v2nv[index] == conn[k] )
910 : : {
911 [ + - ]: 21252 : EntityHandle cur_fid = v2he_map_fid[index];
912 [ + - ]: 21252 : int cur_leid = v2he_map_leid[index];
913 : :
914 [ + - ]: 21252 : int pidx = ID_FROM_HANDLE( prev_fid ) - 1;
915 [ + - ][ + - ]: 21252 : sibhes[nepf * pidx + prev_leid] = create_halffacet( cur_fid, cur_leid );
916 : :
917 : 21252 : prev_fid = cur_fid;
918 : 21252 : prev_leid = cur_leid;
919 : : }
920 : : }
921 : :
922 [ + - ][ + - ]: 137794 : for( index = is_index[v]; index <= is_index[v + 1] - 1; index++ )
[ + + ]
923 : : {
924 [ + - ][ + + ]: 116475 : if( ( v2nv[index] == conn[nidx] ) && ( v2he_map_fid[index] != *fid ) )
[ + - ][ + - ]
[ + + ][ + + ]
925 : : {
926 : :
927 [ + - ]: 80 : EntityHandle cur_fid = v2he_map_fid[index];
928 [ + - ]: 80 : int cur_leid = v2he_map_leid[index];
929 : :
930 [ + - ]: 80 : int pidx = ID_FROM_HANDLE( prev_fid ) - 1;
931 [ + - ][ + - ]: 80 : sibhes[nepf * pidx + prev_leid] = create_halffacet( cur_fid, cur_leid );
932 : :
933 : 80 : prev_fid = cur_fid;
934 : 80 : prev_leid = cur_leid;
935 : : }
936 : : }
937 : :
938 [ + + ]: 21319 : if( prev_fid != first_fid )
939 : : {
940 : :
941 [ + - ]: 21152 : int pidx = ID_FROM_HANDLE( prev_fid ) - 1;
942 [ + - ][ + - ]: 21152 : sibhes[nepf * pidx + prev_leid] = create_halffacet( first_fid, first_leid );
943 : : }
944 : : }
945 : : }
946 : :
947 : 52 : return MB_SUCCESS;
948 : : }
949 : : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
950 : 26 : ErrorCode HalfFacetRep::determine_incident_halfedges( Range& faces )
951 : : {
952 : : ErrorCode error;
953 [ + - ][ + - ]: 26 : EntityType ftype = mb->type_from_handle( *faces.begin() );
[ + - ]
954 : 26 : int nepf = lConnMap2D[ftype - 2].num_verts_in_face;
955 : :
956 [ + - ][ + - ]: 26 : std::vector< char > markEdges( nepf * faces.size(), 0 );
957 : :
958 [ + - ][ + - ]: 13298 : for( Range::iterator it = faces.begin(); it != faces.end(); ++it )
[ + - ][ + - ]
[ + + ]
959 : : {
960 [ + - ]: 13272 : EntityHandle fid = *it;
961 : : const EntityHandle* conn;
962 [ + - ][ - + ]: 13272 : error = mb->get_connectivity( fid, conn, nepf, true );MB_CHK_ERR( error );
[ # # ][ # # ]
963 : :
964 [ + + ]: 55923 : for( int i = 0; i < nepf; ++i )
965 : : {
966 : 42651 : EntityHandle v = conn[i];
967 [ + - ]: 42651 : int vidx = ID_FROM_HANDLE( v ) - 1;
968 [ + - ]: 42651 : HFacet hf = v2he[vidx];
969 : :
970 [ + + ][ - + ]: 42651 : if( hf == 0 && ( v2hes.empty() || ( v2hes.find( v ) == v2hes.end() ) ) )
[ # # ][ # # ]
[ # # ][ - + ]
[ - + ][ + +
# # # # ]
971 : : {
972 : : // This is the first time a half-facet is assigned to a vertex.
973 : 8116 : HFacet nwhf = 0;
974 [ + - ][ - + ]: 8116 : error = mark_halfedges( v, fid, i, faces, markEdges, nwhf );MB_CHK_ERR( error );
[ # # ][ # # ]
975 : :
976 [ + + ][ + - ]: 8116 : if( nwhf == 0 ) nwhf = create_halffacet( fid, i );
977 : :
978 [ + - ]: 8116 : v2he[vidx] = nwhf;
979 : : }
980 [ + - ][ + - ]: 34535 : else if( hf != 0 && !markEdges[nepf * faces.index( fid ) + i] )
[ + - ][ - + ]
[ - + ]
981 : : {
982 : : // This is the first time a non-manifold vertex is encountered. Copy the existing he
983 : : // in v2he[v] to the multimap.
984 [ # # ][ # # ]: 0 : v2hes.insert( std::pair< EntityHandle, HFacet >( v, hf ) );
985 : 0 : HFacet nwhf = 0;
986 [ # # ][ # # ]: 0 : error = mark_halfedges( v, fid, i, faces, markEdges, nwhf );MB_CHK_ERR( error );
[ # # ][ # # ]
987 : :
988 [ # # ][ # # ]: 0 : if( nwhf == 0 ) nwhf = create_halffacet( fid, i );
989 : :
990 [ # # ][ # # ]: 0 : v2hes.insert( std::pair< EntityHandle, HFacet >( v, nwhf ) );
991 [ # # ]: 0 : v2he[vidx] = 0;
992 : : }
993 [ - + ][ # # ]: 34535 : else if( hf == 0 && ( !v2hes.empty() ) && ( v2hes.find( v ) != v2hes.end() ) &&
[ # # ][ # # ]
[ # # ][ # # ]
[ - + ][ - + ]
[ - + # #
# # ]
994 [ # # ][ # # ]: 0 : !markEdges[nepf * faces.index( fid ) + i] )
995 : : {
996 : : // This is check if reached if the vertex is non-manifold and has encountered a
997 : : // half-facet to a new component.
998 : 0 : HFacet nwhf = 0;
999 [ # # ][ # # ]: 0 : error = mark_halfedges( v, fid, i, faces, markEdges, nwhf );MB_CHK_ERR( error );
[ # # ][ # # ]
1000 : :
1001 [ # # ][ # # ]: 0 : if( nwhf == 0 ) nwhf = create_halffacet( fid, i );
1002 : :
1003 [ # # ][ # # ]: 0 : v2hes.insert( std::pair< EntityHandle, HFacet >( v, nwhf ) );
1004 : : }
1005 : : }
1006 : : }
1007 : :
1008 : : // error = print_tags(2);
1009 : :
1010 : 26 : return MB_SUCCESS;
1011 : : }
1012 : :
1013 : : ///////////////////////////////////////////////////////////////////
1014 : 8116 : ErrorCode HalfFacetRep::mark_halfedges( EntityHandle vid, EntityHandle he_fid, int he_lid, Range& faces,
1015 : : std::vector< char >& markHEdgs, HFacet& bnd_hf )
1016 : : {
1017 : : ErrorCode error;
1018 [ + - ]: 8116 : EntityType ftype = mb->type_from_handle( he_fid );
1019 : 8116 : int nepf = lConnMap2D[ftype - 2].num_verts_in_face;
1020 : :
1021 : 8116 : int qsize = 0, count = -1;
1022 : 8116 : int num_qvals = 0;
1023 : :
1024 [ + - ][ - + ]: 8116 : error = gather_halfedges( vid, he_fid, he_lid, &qsize, &count );MB_CHK_ERR( error );
[ # # ][ # # ]
1025 : :
1026 [ + + ]: 67457 : while( num_qvals < qsize )
1027 : : {
1028 : 59341 : EntityHandle curfid = queue_fid[num_qvals];
1029 : 59341 : int curlid = queue_lid[num_qvals];
1030 : 59341 : num_qvals += 1;
1031 : :
1032 [ + - ]: 59341 : int fidx = ID_FROM_HANDLE( curfid ) - 1;
1033 : :
1034 : : const EntityHandle* conn;
1035 [ + - ][ - + ]: 59341 : error = mb->get_connectivity( curfid, conn, nepf, true );MB_CHK_ERR( error );
[ # # ][ # # ]
1036 : :
1037 [ + - ][ + - ]: 59341 : if( !markHEdgs[nepf * faces.index( curfid ) + curlid] && ( conn[curlid] == vid ) )
[ + + ][ + + ]
[ + + ]
1038 : : {
1039 [ + - ][ + - ]: 21604 : markHEdgs[nepf * faces.index( curfid ) + curlid] = 1;
1040 [ + - ]: 21604 : HFacet hf = sibhes[nepf * fidx + curlid];
1041 [ + - ]: 21604 : EntityHandle sibfid = fid_from_halfacet( hf, ftype );
1042 [ + + ][ + - ]: 21604 : if( sibfid == 0 ) bnd_hf = create_halffacet( curfid, curlid );
1043 : : }
1044 : :
1045 : 59341 : EntityHandle he2_fid = 0;
1046 : 59341 : int he2_lid = 0;
1047 [ + - ][ - + ]: 59341 : error = another_halfedge( vid, curfid, curlid, &he2_fid, &he2_lid );MB_CHK_ERR( error );
[ # # ][ # # ]
1048 : :
1049 [ + - ][ + - ]: 59341 : if( !markHEdgs[nepf * faces.index( curfid ) + he2_lid] && ( conn[he2_lid] == vid ) )
[ + + ][ + + ]
[ + + ]
1050 : : {
1051 [ + - ][ + - ]: 21047 : markHEdgs[nepf * faces.index( curfid ) + he2_lid] = 1;
1052 [ + - ]: 21047 : HFacet hf = sibhes[nepf * fidx + he2_lid];
1053 [ + - ]: 21047 : EntityHandle sibfid = fid_from_halfacet( hf, ftype );
1054 [ + + ][ + - ]: 21047 : if( sibfid == 0 ) bnd_hf = create_halffacet( he2_fid, he2_lid );
1055 : : }
1056 : :
1057 [ + - ]: 59341 : bool val = find_match_in_array( he2_fid, trackfaces, count );
1058 : :
1059 [ + + ]: 59341 : if( val ) continue;
1060 : :
1061 : 34535 : count += 1;
1062 : 34535 : trackfaces[count] = he2_fid;
1063 : :
1064 [ + - ][ - + ]: 34535 : error = get_up_adjacencies_2d( he2_fid, he2_lid, &qsize, &count );MB_CHK_ERR( error );
[ # # ][ # # ]
1065 : : }
1066 : :
1067 : : // Change the visited faces to false, also empty the queue
1068 [ + + ]: 75573 : for( int i = 0; i <= qsize; i++ )
1069 : : {
1070 : 67457 : queue_fid[i] = 0;
1071 : 67457 : queue_lid[i] = 0;
1072 : : }
1073 : :
1074 [ + + ]: 50767 : for( int i = 0; i <= count; i++ )
1075 : 42651 : trackfaces[i] = 0;
1076 : 8116 : return MB_SUCCESS;
1077 : : }
1078 : :
1079 : : ///////////////////////////////////////////////////////////////////
1080 : 1114188 : ErrorCode HalfFacetRep::get_up_adjacencies_vert_2d( EntityHandle vid, std::vector< EntityHandle >& adjents )
1081 : : {
1082 : : ErrorCode error;
1083 [ + - ][ + - ]: 1114188 : EntityType ftype = mb->type_from_handle( *_faces.begin() );
[ + - ]
1084 : :
1085 [ + - ]: 1114188 : int vidx = ID_FROM_HANDLE( vid ) - 1;
1086 [ + - ]: 1114188 : HFacet hf = v2he[vidx];
1087 : :
1088 [ + - ]: 1114188 : std::vector< EntityHandle > start_fids;
1089 [ + - ]: 2228376 : std::vector< int > start_lids;
1090 : :
1091 [ - + ][ # # ]: 1114188 : if( hf == 0 && ( v2hes.find( vid ) != v2hes.end() ) )
[ # # ][ # # ]
[ - + ][ - + ]
[ - + # #
# # ]
1092 : : {
1093 : : std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
1094 [ # # ]: 0 : it_hes;
1095 [ # # ]: 0 : it_hes = v2hes.equal_range( vid );
1096 : :
1097 [ # # ][ # # ]: 0 : for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
[ # # ]
1098 : : {
1099 [ # # ][ # # ]: 0 : start_fids.push_back( fid_from_halfacet( it->second, ftype ) );
[ # # ]
1100 [ # # ][ # # ]: 0 : start_lids.push_back( lid_from_halffacet( it->second ) );
[ # # ]
1101 : : }
1102 : : }
1103 [ + - ]: 1114188 : else if( hf != 0 )
1104 : : {
1105 [ + - ][ + - ]: 1114188 : start_fids.push_back( fid_from_halfacet( hf, ftype ) );
1106 [ + - ][ + - ]: 1114188 : start_lids.push_back( lid_from_halffacet( hf ) );
1107 : : }
1108 : :
1109 [ - + ]: 1114188 : if( start_fids.empty() ) return MB_SUCCESS;
1110 : :
1111 : 1114188 : int qsize = 0, count = -1;
1112 : 1114188 : int num_qvals = 0;
1113 : :
1114 [ + - ]: 1114188 : adjents.reserve( (int)start_fids.size() );
1115 : :
1116 [ + + ]: 2228376 : for( int i = 0; i < (int)start_fids.size(); i++ )
1117 : : {
1118 [ + - ][ + - ]: 1114188 : adjents.push_back( start_fids[i] );
1119 [ + - ][ + - ]: 1114188 : error = gather_halfedges( vid, start_fids[i], start_lids[i], &qsize, &count );MB_CHK_ERR( error );
[ + - ][ - + ]
[ # # ][ # # ]
1120 : : }
1121 : :
1122 [ + + ]: 9179057 : while( num_qvals < qsize )
1123 : : {
1124 : 8064869 : EntityHandle curfid = queue_fid[num_qvals];
1125 : 8064869 : int curlid = queue_lid[num_qvals];
1126 : 8064869 : num_qvals += 1;
1127 : :
1128 : 8064869 : EntityHandle he2_fid = 0;
1129 : 8064869 : int he2_lid = 0;
1130 [ + - ][ - + ]: 8064869 : error = another_halfedge( vid, curfid, curlid, &he2_fid, &he2_lid );MB_CHK_ERR( error );
[ # # ][ # # ]
1131 : :
1132 [ + - ]: 8064869 : bool val = find_match_in_array( he2_fid, trackfaces, count );
1133 : :
1134 [ + + ]: 8064869 : if( val ) continue;
1135 : :
1136 : 4720774 : count += 1;
1137 : 4720774 : trackfaces[count] = he2_fid;
1138 : :
1139 [ + - ][ - + ]: 4720774 : error = get_up_adjacencies_2d( he2_fid, he2_lid, &qsize, &count );MB_CHK_ERR( error );
[ # # ][ # # ]
1140 : :
1141 [ + - ]: 4720774 : adjents.push_back( he2_fid );
1142 : : }
1143 : :
1144 : : // Change the visited faces to false, also empty the queue
1145 [ + + ]: 10293245 : for( int i = 0; i <= qsize; i++ )
1146 : : {
1147 : 9179057 : queue_fid[i] = 0;
1148 : 9179057 : queue_lid[i] = 0;
1149 : : }
1150 : :
1151 [ + + ]: 6949150 : for( int i = 0; i <= count; i++ )
1152 : 5834962 : trackfaces[i] = 0;
1153 : :
1154 : 2228376 : return MB_SUCCESS;
1155 : : }
1156 : :
1157 : : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1158 : 170 : ErrorCode HalfFacetRep::get_up_adjacencies_2d( EntityHandle eid, std::vector< EntityHandle >& adjents,
1159 : : std::vector< int >* leids )
1160 : : {
1161 : :
1162 : : // Given an explicit edge eid, find the incident faces.
1163 : : ErrorCode error;
1164 : 170 : EntityHandle he_fid = 0;
1165 : 170 : int he_lid = 0;
1166 : :
1167 : : // Step 1: Given an explicit edge, find a corresponding half-edge from the surface mesh.
1168 [ + - ]: 170 : bool found = find_matching_halfedge( eid, &he_fid, &he_lid );
1169 : :
1170 : : // Step 2: If there is a corresponding half-edge, collect all sibling half-edges and store the
1171 : : // incident faces.
1172 [ + - ]: 170 : if( found )
1173 : : {
1174 [ + - ][ - + ]: 170 : error = get_up_adjacencies_2d( he_fid, he_lid, true, adjents, leids );MB_CHK_ERR( error );
[ # # ][ # # ]
1175 : : }
1176 : :
1177 : 170 : return MB_SUCCESS;
1178 : : }
1179 : :
1180 : : /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1181 : 87058 : ErrorCode HalfFacetRep::get_up_adjacencies_2d( EntityHandle fid, int leid, bool add_inent,
1182 : : std::vector< EntityHandle >& adj_ents, std::vector< int >* adj_leids,
1183 : : std::vector< int >* adj_orients )
1184 : : {
1185 : : // Given an implicit half-edge <fid, leid>, find the incident half-edges.
1186 : : ErrorCode error;
1187 : :
1188 [ + - ]: 87058 : EntityType ftype = mb->type_from_handle( fid );
1189 : 87058 : int nepf = lConnMap2D[ftype - 2].num_verts_in_face;
1190 : :
1191 [ - + ]: 87058 : if( !fid ) return MB_FAILURE;
1192 [ + - ]: 87058 : adj_ents.reserve( 20 );
1193 : :
1194 : 87058 : bool local_id = false;
1195 : 87058 : bool orient = false;
1196 [ + + ]: 87058 : if( adj_leids != NULL )
1197 : : {
1198 : 25926 : local_id = true;
1199 [ + - ]: 25926 : adj_leids->reserve( 20 );
1200 : : }
1201 [ + + ]: 87058 : if( adj_orients != NULL )
1202 : : {
1203 : 17179 : orient = true;
1204 [ + - ]: 17179 : adj_orients->reserve( 20 );
1205 : : }
1206 : :
1207 [ + + ]: 87058 : if( add_inent )
1208 : : {
1209 [ + - ]: 170 : adj_ents.push_back( fid );
1210 [ - + ][ # # ]: 170 : if( local_id ) adj_leids->push_back( leid );
1211 : : }
1212 : :
1213 : 87058 : EntityHandle fedge[2] = { 0, 0 };
1214 : :
1215 [ + + ]: 87058 : if( orient )
1216 : : {
1217 : : // get connectivity and match their directions
1218 : : const EntityHandle* fid_conn;
1219 [ + - ][ - + ]: 17179 : error = mb->get_connectivity( fid, fid_conn, nepf, true );MB_CHK_ERR( error );
[ # # ][ # # ]
1220 : :
1221 : 17179 : int nidx = lConnMap2D[ftype - 2].next[leid];
1222 : 17179 : fedge[0] = fid_conn[leid];
1223 : 17179 : fedge[1] = fid_conn[nidx];
1224 : : }
1225 : :
1226 [ + - ]: 87058 : int fidx = ID_FROM_HANDLE( fid ) - 1;
1227 [ + - ]: 87058 : HFacet hf = sibhes[nepf * fidx + leid];
1228 [ + - ]: 87058 : EntityHandle curfid = fid_from_halfacet( hf, ftype );
1229 [ + - ]: 87058 : int curlid = lid_from_halffacet( hf );
1230 : :
1231 [ + + ][ + + ]: 174022 : while( ( curfid != fid ) && ( curfid != 0 ) )
1232 : : { // Should not go into the loop when no sibling exists
1233 [ + - ]: 86964 : adj_ents.push_back( curfid );
1234 : :
1235 [ + + ][ + - ]: 86964 : if( local_id ) adj_leids->push_back( curlid );
1236 : :
1237 [ + + ]: 86964 : if( orient )
1238 : : {
1239 : : // get connectivity and match their directions
1240 : : const EntityHandle* conn;
1241 [ + - ][ - + ]: 17026 : error = mb->get_connectivity( curfid, conn, nepf, true );MB_CHK_ERR( error );
[ # # ][ # # ]
1242 : :
1243 : 17026 : int nidx = lConnMap2D[ftype - 2].next[curlid];
1244 : :
1245 [ + + ][ + - ]: 17026 : if( ( fedge[0] == conn[curlid] ) && ( fedge[1] == conn[nidx] ) )
1246 [ + - ]: 144 : adj_orients->push_back( 1 );
1247 [ + - ][ + - ]: 16882 : else if( ( fedge[1] == conn[curlid] ) && ( fedge[0] == conn[nidx] ) )
1248 [ + - ]: 17026 : adj_orients->push_back( 0 );
1249 : : }
1250 : :
1251 [ + - ]: 86964 : int cidx = ID_FROM_HANDLE( curfid ) - 1;
1252 [ + - ]: 86964 : hf = sibhes[nepf * cidx + curlid];
1253 [ + - ]: 86964 : curfid = fid_from_halfacet( hf, ftype );
1254 [ + - ]: 86964 : curlid = lid_from_halffacet( hf );
1255 : : }
1256 : :
1257 : 87058 : return MB_SUCCESS;
1258 : : }
1259 : :
1260 : : /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1261 : 7001062 : ErrorCode HalfFacetRep::get_up_adjacencies_2d( EntityHandle fid, int lid, int* qsize, int* count )
1262 : : {
1263 : 7001062 : EntityType ftype = mb->type_from_handle( fid );
1264 : 7001062 : int nepf = lConnMap2D[ftype - 2].num_verts_in_face;
1265 : :
1266 : 7001062 : int fidx = ID_FROM_HANDLE( fid ) - 1;
1267 : 7001062 : HFacet hf = sibhes[nepf * fidx + lid];
1268 : 7001062 : EntityHandle curfid = fid_from_halfacet( hf, ftype );
1269 : 7001062 : int curlid = lid_from_halffacet( hf );
1270 : :
1271 [ + + ]: 7001062 : if( curfid == 0 )
1272 : : {
1273 : 22842 : int index = 0;
1274 [ + - ]: 22842 : bool found_ent = find_match_in_array( fid, queue_fid, qsize[0] - 1, true, &index );
1275 : :
1276 [ + - ][ + - ]: 22842 : if( ( !found_ent ) || ( ( found_ent ) && ( queue_lid[index] != lid ) ) )
[ + + ]
1277 : : {
1278 : 11495 : queue_fid[qsize[0]] = fid;
1279 : 11495 : queue_lid[qsize[0]] = lid;
1280 : 22842 : qsize[0] += 1;
1281 : : }
1282 : : }
1283 : :
1284 [ + + ][ + + ]: 13983988 : while( ( curfid != fid ) && ( curfid != 0 ) )
1285 : : {
1286 : 6982926 : bool val = find_match_in_array( curfid, trackfaces, count[0] );
1287 : :
1288 [ + + ]: 6982926 : if( !val )
1289 : : {
1290 : 5870182 : queue_fid[qsize[0]] = curfid;
1291 : 5870182 : queue_lid[qsize[0]] = curlid;
1292 : 5870182 : qsize[0] += 1;
1293 : : }
1294 : :
1295 : 6982926 : int cidx = ID_FROM_HANDLE( curfid ) - 1;
1296 : 6982926 : hf = sibhes[nepf * cidx + curlid];
1297 : 6982926 : curfid = fid_from_halfacet( hf, ftype );
1298 : 6982926 : curlid = lid_from_halffacet( hf );
1299 : : }
1300 : :
1301 : 7001062 : return MB_SUCCESS;
1302 : : }
1303 : :
1304 : : /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1305 : 170 : bool HalfFacetRep::find_matching_halfedge( EntityHandle eid, EntityHandle* hefid, int* helid )
1306 : : {
1307 : : ErrorCode error;
1308 [ + - ][ + - ]: 170 : EntityType ftype = mb->type_from_handle( *_faces.begin() );
[ + - ]
1309 : :
1310 : : const EntityHandle* conn;
1311 : 170 : int num_conn = 0;
1312 [ + - ][ - + ]: 170 : error = mb->get_connectivity( eid, conn, num_conn, true );MB_CHK_ERR( error );
[ # # ][ # # ]
1313 : :
1314 : 170 : EntityHandle vid = conn[0];
1315 [ + - ]: 170 : int vidx = ID_FROM_HANDLE( conn[0] ) - 1;
1316 [ + - ]: 170 : HFacet hf = v2he[vidx];
1317 : :
1318 [ - + ]: 170 : if( hf == 0 )
1319 : : {
1320 [ # # ]: 0 : vidx = ID_FROM_HANDLE( conn[1] ) - 1;
1321 [ # # ]: 0 : hf = v2he[vidx];
1322 : :
1323 [ # # ]: 0 : if( hf == 0 ) // The edge is either a dangling edge or attached to two non-manifold
1324 : : // vertices
1325 : 0 : return MB_SUCCESS;
1326 : :
1327 : 0 : vid = conn[1];
1328 : : }
1329 : :
1330 [ + - ]: 170 : EntityHandle fid = fid_from_halfacet( hf, ftype );
1331 [ + - ]: 170 : int lid = lid_from_halffacet( hf );
1332 : :
1333 : 170 : bool found = false;
1334 : 170 : int qsize = 0, count = -1;
1335 : :
1336 [ + - ][ - + ]: 170 : error = gather_halfedges( vid, fid, lid, &qsize, &count );MB_CHK_ERR( error );
[ # # ][ # # ]
1337 : :
1338 [ + - ][ - + ]: 170 : found = collect_and_compare( vid, conn, &qsize, &count, hefid, helid );MB_CHK_ERR( error );
[ # # ][ # # ]
1339 : :
1340 : : // Change the visited faces to false
1341 [ + + ]: 2585 : for( int i = 0; i < qsize; i++ )
1342 : : {
1343 : 2415 : queue_fid[i] = 0;
1344 : 2415 : queue_lid[i] = 0;
1345 : : }
1346 : :
1347 [ + + ]: 1145 : for( int i = 0; i <= count; i++ )
1348 : 975 : trackfaces[i] = 0;
1349 : :
1350 : 170 : return found;
1351 : : }
1352 : : /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1353 : 1122474 : ErrorCode HalfFacetRep::gather_halfedges( EntityHandle vid, EntityHandle he_fid, int he_lid, int* qsize, int* count )
1354 : : {
1355 : : ErrorCode error;
1356 : 1122474 : EntityHandle he2_fid = 0;
1357 : 1122474 : int he2_lid = 0;
1358 : :
1359 [ + - ][ - + ]: 1122474 : error = another_halfedge( vid, he_fid, he_lid, &he2_fid, &he2_lid );MB_CHK_ERR( error );
[ # # ][ # # ]
1360 : :
1361 : 1122474 : queue_fid[*qsize] = he_fid;
1362 : 1122474 : queue_lid[*qsize] = he_lid;
1363 : 1122474 : *qsize += 1;
1364 : :
1365 : 1122474 : queue_fid[*qsize] = he2_fid;
1366 : 1122474 : queue_lid[*qsize] = he2_lid;
1367 : 1122474 : *qsize += 1;
1368 : :
1369 : 1122474 : *count += 1;
1370 : 1122474 : trackfaces[*count] = he_fid;
1371 : :
1372 [ + - ][ - + ]: 1122474 : error = get_up_adjacencies_2d( he_fid, he_lid, qsize, count );MB_CHK_ERR( error );
[ # # ][ # # ]
1373 [ + - ][ - + ]: 1122474 : error = get_up_adjacencies_2d( he2_fid, he2_lid, qsize, count );MB_CHK_ERR( error );
[ # # ][ # # ]
1374 : :
1375 : 1122474 : return MB_SUCCESS;
1376 : : }
1377 : :
1378 : : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1379 : 9247489 : ErrorCode HalfFacetRep::another_halfedge( EntityHandle vid, EntityHandle he_fid, int he_lid, EntityHandle* he2_fid,
1380 : : int* he2_lid )
1381 : : {
1382 : : ErrorCode error;
1383 [ + - ]: 9247489 : EntityType ftype = mb->type_from_handle( he_fid );
1384 : 9247489 : int nepf = lConnMap2D[ftype - 2].num_verts_in_face;
1385 : :
1386 : : const EntityHandle* conn;
1387 [ + - ][ - + ]: 9247489 : error = mb->get_connectivity( he_fid, conn, nepf, true );MB_CHK_ERR( error );
[ # # ][ # # ]
1388 : :
1389 : 9247489 : *he2_fid = he_fid;
1390 [ + + ]: 9247489 : if( conn[he_lid] == vid )
1391 : 5162599 : *he2_lid = lConnMap2D[ftype - 2].prev[he_lid];
1392 : : else
1393 : 4084890 : *he2_lid = lConnMap2D[ftype - 2].next[he_lid];
1394 : :
1395 : 9247489 : return MB_SUCCESS;
1396 : : }
1397 : :
1398 : : /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1399 : 170 : bool HalfFacetRep::collect_and_compare( const EntityHandle vid, const EntityHandle* edg_vert, int* qsize, int* count,
1400 : : EntityHandle* he_fid, int* he_lid )
1401 : : {
1402 : : ErrorCode error;
1403 [ + - ][ + - ]: 170 : EntityType ftype = mb->type_from_handle( *_faces.begin() );
[ + - ]
1404 : 170 : int nepf = lConnMap2D[ftype - 2].num_verts_in_face;
1405 : :
1406 : 170 : bool found = false;
1407 : 170 : int num_qvals = 0, counter = 0;
1408 : :
1409 [ + - ][ + - ]: 1454 : while( num_qvals < *qsize && counter < MAXSIZE )
1410 : : {
1411 : 1454 : EntityHandle curfid = queue_fid[num_qvals];
1412 : 1454 : int curlid = queue_lid[num_qvals];
1413 : 1454 : num_qvals += 1;
1414 : :
1415 : : const EntityHandle* conn;
1416 [ + - ][ - + ]: 1454 : error = mb->get_connectivity( curfid, conn, nepf, true );MB_CHK_ERR( error );
[ # # ][ # # ]
1417 : :
1418 : 1454 : int id = lConnMap2D[ftype - 2].next[curlid];
1419 [ + + ][ + + ]: 1454 : if( ( ( conn[curlid] == edg_vert[0] ) && ( conn[id] == edg_vert[1] ) ) ||
[ + + ]
1420 [ + - ]: 82 : ( ( conn[curlid] == edg_vert[1] ) && ( conn[id] == edg_vert[0] ) ) )
1421 : : {
1422 : 170 : *he_fid = curfid;
1423 : 170 : *he_lid = curlid;
1424 : 170 : found = true;
1425 : 170 : break;
1426 : : }
1427 : :
1428 [ + - ]: 1284 : bool val = find_match_in_array( curfid, trackfaces, count[0] );
1429 : :
1430 [ + + ]: 1284 : if( val ) continue;
1431 : :
1432 : 805 : count[0] += 1;
1433 : 805 : trackfaces[*count] = curfid;
1434 : :
1435 : : EntityHandle he2_fid;
1436 : : int he2_lid;
1437 [ + - ][ - + ]: 805 : error = another_halfedge( vid, curfid, curlid, &he2_fid, &he2_lid );MB_CHK_ERR( error );
[ # # ][ # # ]
1438 [ + - ][ - + ]: 805 : error = get_up_adjacencies_2d( he2_fid, he2_lid, qsize, count );MB_CHK_ERR( error );
[ # # ][ # # ]
1439 : :
1440 : 805 : counter += 1;
1441 : : }
1442 : 170 : return found;
1443 : : }
1444 : :
1445 : : ///////////////////////////////////////////////////////////////////////////////////////////////////
1446 : 17668 : ErrorCode HalfFacetRep::get_neighbor_adjacencies_2d( EntityHandle fid, std::vector< EntityHandle >& adjents )
1447 : : {
1448 : : ErrorCode error;
1449 : :
1450 [ + - ]: 17668 : if( fid != 0 )
1451 : : {
1452 : 17668 : EntityType ftype = mb->type_from_handle( fid );
1453 : 17668 : int nepf = lConnMap2D[ftype - 2].num_verts_in_face;
1454 : :
1455 [ + + ]: 78630 : for( int lid = 0; lid < nepf; ++lid )
1456 : : {
1457 [ - + ][ # # ]: 60962 : error = get_up_adjacencies_2d( fid, lid, false, adjents );MB_CHK_ERR( error );
1458 : : }
1459 : : }
1460 : :
1461 : 17668 : return MB_SUCCESS;
1462 : : }
1463 : :
1464 : : /////////////////////////////////////////////////////////////////////////////////////////////////
1465 : 128 : ErrorCode HalfFacetRep::get_down_adjacencies_2d( EntityHandle fid, std::vector< EntityHandle >& adjents )
1466 : : {
1467 : : // Returns explicit edges, if any, of the face
1468 : : ErrorCode error;
1469 [ + - ]: 128 : adjents.reserve( 10 );
1470 [ + - ]: 128 : EntityType ftype = mb->type_from_handle( fid );
1471 : 128 : int nepf = lConnMap2D[ftype - 2].num_verts_in_face;
1472 : :
1473 : : const EntityHandle* conn;
1474 [ + - ][ - + ]: 128 : error = mb->get_connectivity( fid, conn, nepf, true );MB_CHK_ERR( error );
[ # # ][ # # ]
1475 : :
1476 [ + - ]: 128 : std::vector< EntityHandle > temp;
1477 : :
1478 : : // Loop over 2 vertices
1479 [ + + ]: 384 : for( int i = 0; i < 2; i++ )
1480 : : {
1481 : : // Choose the two adjacent vertices for a triangle, and two opposite vertices for a quad
1482 : : int l;
1483 [ - + ]: 256 : if( ftype == MBTRI )
1484 : 0 : l = i;
1485 : : else
1486 : 256 : l = 2 * i;
1487 : :
1488 : : // Get the current, next and prev vertices
1489 : 256 : int nidx = lConnMap2D[ftype - 2].next[l];
1490 : 256 : int pidx = lConnMap2D[ftype - 2].prev[l];
1491 : 256 : EntityHandle v = conn[l];
1492 : 256 : EntityHandle vnext = conn[nidx];
1493 : 256 : EntityHandle vprev = conn[pidx];
1494 : :
1495 : : // Get incident edges on v
1496 [ + - ][ - + ]: 256 : error = get_up_adjacencies_1d( v, temp );MB_CHK_ERR( error );
[ # # ][ # # ]
1497 : :
1498 : : // Loop over the incident edges and check if its end vertices match those in the face
1499 [ + + ]: 1496 : for( int k = 0; k < (int)temp.size(); k++ )
1500 : : {
1501 : : const EntityHandle* econn;
1502 : 1240 : int num_conn = 0;
1503 [ + - ][ + - ]: 1240 : error = mb->get_connectivity( temp[k], econn, num_conn, true );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
1504 : :
1505 [ + + ][ + + ]: 1240 : if( ( econn[0] == v && econn[1] == vnext ) || ( econn[0] == v && econn[1] == vprev ) ||
[ + + ][ + + ]
[ + + ]
1506 [ - + ][ + + ]: 994 : ( econn[0] == vnext && econn[1] == v ) || ( econn[0] == vprev && econn[1] == v ) )
[ + - ]
1507 : : {
1508 : 512 : bool found = false;
1509 [ + + ]: 1280 : for( int j = 0; j < (int)adjents.size(); j++ )
1510 : : {
1511 [ + - ][ + - ]: 768 : if( adjents[j] == temp[k] )
[ - + ]
1512 : : {
1513 : 0 : found = true;
1514 : 0 : break;
1515 : : }
1516 : : }
1517 [ + - ][ + - ]: 512 : if( !found ) adjents.push_back( temp[k] );
[ + - ]
1518 : : }
1519 : : }
1520 : : }
1521 : :
1522 : 128 : return MB_SUCCESS;
1523 : : }
1524 : :
1525 : : ////////////////////////////////////////////////////////////////////////////////////////////////
1526 : 22 : int HalfFacetRep::find_total_edges_2d( Range& faces )
1527 : : {
1528 : : ErrorCode error;
1529 [ + - ][ + - ]: 22 : EntityType ftype = mb->type_from_handle( *faces.begin() );
[ + - ]
1530 : 22 : int nepf = lConnMap2D[ftype - 2].num_verts_in_face;
1531 [ + - ]: 22 : int nfaces = faces.size();
1532 : :
1533 : 22 : int total_edges = nepf * nfaces;
1534 : :
1535 [ + - ]: 22 : std::vector< int > trackF( total_edges, 0 );
1536 [ + - ]: 44 : std::vector< EntityHandle > adj_fids;
1537 [ + - ]: 44 : std::vector< int > adj_lids;
1538 : :
1539 [ + - ][ + - ]: 5566 : for( Range::iterator f = faces.begin(); f != faces.end(); ++f )
[ + - ][ + - ]
[ + + ]
1540 : : {
1541 [ + + ]: 22723 : for( int l = 0; l < nepf; l++ )
1542 : : {
1543 : :
1544 : 17179 : adj_fids.clear();
1545 : 17179 : adj_lids.clear();
1546 : :
1547 [ + - ][ + - ]: 17179 : int id = nepf * ( faces.index( *f ) ) + l;
1548 [ + - ][ + + ]: 17179 : if( !trackF[id] )
1549 : : {
1550 [ + - ][ + - ]: 8747 : error = get_up_adjacencies_2d( *f, l, false, adj_fids, &adj_lids );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
1551 : :
1552 : 8747 : total_edges -= adj_fids.size();
1553 : :
1554 [ + + ]: 17179 : for( int i = 0; i < (int)adj_fids.size(); i++ )
1555 [ + - ][ + - ]: 8432 : trackF[nepf * ( faces.index( adj_fids[i] ) ) + adj_lids[i]] = 1;
[ + - ][ + - ]
1556 : : };
1557 : : };
1558 : : };
1559 : :
1560 : 44 : return total_edges;
1561 : : }
1562 : :
1563 : 0 : ErrorCode HalfFacetRep::get_face_edges( EntityHandle fid, std::vector< EntityHandle >& edges )
1564 : : {
1565 : : ErrorCode error;
1566 : 0 : edges.clear();
1567 : :
1568 [ # # ]: 0 : EntityType ftype = mb->type_from_handle( fid );
1569 : 0 : int nepf = lConnMap2D[ftype - 2].num_verts_in_face;
1570 : :
1571 [ # # ]: 0 : std::vector< EntityHandle > conn;
1572 [ # # ][ # # ]: 0 : error = mb->get_connectivity( &fid, 1, conn );MB_CHK_ERR( error );
[ # # ][ # # ]
1573 : :
1574 [ # # ]: 0 : for( int i = 0; i < nepf; i++ )
1575 : : {
1576 [ # # ]: 0 : EntityHandle v0 = conn[i];
1577 [ # # ]: 0 : EntityHandle v1 = conn[lConnMap2D[ftype - 2].next[i]];
1578 : :
1579 [ # # ][ # # ]: 0 : std::vector< EntityHandle > e0, e1, ecom;
[ # # ][ # # ]
[ # # ]
1580 [ # # ][ # # ]: 0 : error = get_up_adjacencies_1d( v0, e0 );MB_CHK_ERR( error );
[ # # ][ # # ]
1581 [ # # ][ # # ]: 0 : error = get_up_adjacencies_1d( v1, e1 );MB_CHK_ERR( error );
[ # # ][ # # ]
1582 : :
1583 [ # # ]: 0 : std::sort( e0.begin(), e0.end() );
1584 [ # # ]: 0 : std::sort( e1.begin(), e1.end() );
1585 [ # # ][ # # ]: 0 : std::set_intersection( e0.begin(), e0.end(), e1.begin(), e1.end(), std::back_inserter( ecom ) );
1586 [ # # ][ # # ]: 0 : assert( ecom.size() == 1 || ecom.size() == 0 );
1587 [ # # ]: 0 : if( ecom.size() == 0 )
1588 [ # # ]: 0 : edges.push_back( 0 );
1589 : : else
1590 [ # # ][ # # ]: 0 : edges.push_back( ecom[0] );
[ # # ]
1591 : 0 : }
1592 : :
1593 : 0 : return MB_SUCCESS;
1594 : : }
1595 : :
1596 : : /*******************************************************
1597 : : * 3D: sibhfs, v2hf, incident and neighborhood queries *
1598 : : ********************************************************/
1599 : :
1600 : 607591 : int HalfFacetRep::get_index_in_lmap( EntityHandle cid )
1601 : : {
1602 [ + - ]: 607591 : EntityType type = mb->type_from_handle( cid );
1603 [ + - ][ + - ]: 607591 : int index = cell_index.find( type )->second;
1604 : 607591 : return index;
1605 : : }
1606 : :
1607 : : const HalfFacetRep::LocalMaps3D HalfFacetRep::lConnMap3D[4] = {
1608 : : // Tet
1609 : : { 4,
1610 : : 6,
1611 : : 4,
1612 : : { 3, 3, 3, 3 },
1613 : : { { 0, 1, 3 }, { 1, 2, 3 }, { 2, 0, 3 }, { 0, 2, 1 } },
1614 : : { 3, 3, 3, 3 },
1615 : : { { 0, 2, 3 }, { 0, 1, 3 }, { 1, 2, 3 }, { 0, 1, 2 } },
1616 : : { { 0, 1 }, { 1, 2 }, { 2, 0 }, { 0, 3 }, { 1, 3 }, { 2, 3 } },
1617 : : { { 3, 0 }, { 3, 1 }, { 3, 2 }, { 0, 2 }, { 0, 1 }, { 1, 2 } },
1618 : : { { 0, 4, 3 }, { 1, 5, 4 }, { 2, 3, 5 }, { 2, 1, 0 } },
1619 : : { { -1, 0, 2, 3 }, { 0, -1, 1, 4 }, { 2, 1, -1, 5 }, { 3, 4, 5, -1 } },
1620 : : { 3, 0, 1, 2 },
1621 : : { 0, 1 },
1622 : : { { 3, 1, 2, 3 }, { 2, 2, 3 }, { 1, 3 } } },
1623 : :
1624 : : // Pyramid: Note: In MOAB pyramid follows the CGNS convention. Look up src/MBCNArrays.hpp
1625 : : { 5,
1626 : : 8,
1627 : : 5,
1628 : : { 4, 3, 3, 3, 3 },
1629 : : { { 0, 3, 2, 1 }, { 0, 1, 4 }, { 1, 2, 4 }, { 2, 3, 4 }, { 3, 0, 4 } },
1630 : : { 3, 3, 3, 3, 4 },
1631 : : { { 0, 1, 4 }, { 0, 1, 2 }, { 0, 2, 3 }, { 0, 3, 4 }, { 1, 2, 3, 4 } },
1632 : : { { 0, 1 }, { 1, 2 }, { 2, 3 }, { 3, 0 }, { 0, 4 }, { 1, 4 }, { 2, 4 }, { 3, 4 } },
1633 : : { { 0, 1 }, { 0, 2 }, { 0, 3 }, { 0, 4 }, { 1, 4 }, { 1, 2 }, { 2, 3 }, { 3, 4 } },
1634 : : { { 3, 2, 1, 0 }, { 0, 5, 4 }, { 1, 6, 5 }, { 2, 7, 6 }, { 3, 4, 7 } },
1635 : : { { -1, 0, -1, 3, 4 }, { 0, -1, 1, -1, 5 }, { -1, 1, -1, 2, 6 }, { 3, -1, 2, -1, 7 }, { 4, 5, 6, 7, -1 } },
1636 : : { 3, 4, 2, 0 },
1637 : : { 0, 4 },
1638 : : { { 4, 0, 1, 2, 3 }, { 2, 1, 3 }, { 2, 1, 3 } } },
1639 : :
1640 : : // Prism
1641 : : { 6,
1642 : : 9,
1643 : : 5,
1644 : : { 4, 4, 4, 3, 3 },
1645 : : { { 0, 1, 4, 3 }, { 1, 2, 5, 4 }, { 0, 3, 5, 2 }, { 0, 2, 1 }, { 3, 4, 5 } },
1646 : : { 3, 3, 3, 3, 3, 3 },
1647 : : { { 0, 2, 3 }, { 0, 1, 3 }, { 1, 2, 3 }, { 0, 2, 4 }, { 0, 1, 4 }, { 1, 4, 2 } },
1648 : : { { 0, 1 }, { 1, 2 }, { 2, 0 }, { 0, 3 }, { 1, 4 }, { 2, 5 }, { 3, 4 }, { 4, 5 }, { 5, 3 } },
1649 : : { { 0, 3 }, { 1, 3 }, { 2, 3 }, { 0, 2 }, { 0, 1 }, { 1, 2 }, { 0, 4 }, { 1, 4 }, { 2, 4 } },
1650 : : { { 0, 4, 6, 3 }, { 1, 5, 7, 4 }, { 2, 3, 8, 5 }, { 2, 1, 0 }, { 6, 7, 8 } },
1651 : : { { -1, 0, 2, 3, -1, -1 },
1652 : : { 0, -1, 1, -1, 4, -1 },
1653 : : { 2, 1, -1, -1, -1, 5 },
1654 : : { 3, -1, -1, -1, 6, 8 },
1655 : : { -1, 4, -1, 6, -1, 7 },
1656 : : { -1, -1, 5, 8, 7, -1 } },
1657 : : { 4, 0, 5, 4, 1 },
1658 : : { 0, 5 },
1659 : : { { 3, 1, 2, 3 }, { 3, 2, 4, 3 }, { 2, 3, 1 }, { 1, 2 } } },
1660 : :
1661 : : // Hex
1662 : : { 8,
1663 : : 12,
1664 : : 6,
1665 : : { 4, 4, 4, 4, 4, 4 },
1666 : : { { 0, 1, 5, 4 }, { 1, 2, 6, 5 }, { 2, 3, 7, 6 }, { 3, 0, 4, 7 }, { 0, 3, 2, 1 }, { 4, 5, 6, 7 } },
1667 : : { 3, 3, 3, 3, 3, 3, 3, 3 },
1668 : : { { 0, 3, 4 }, { 0, 1, 4 }, { 1, 2, 4 }, { 2, 3, 4 }, { 0, 3, 5 }, { 0, 1, 5 }, { 1, 2, 5 }, { 2, 3, 5 } },
1669 : : { { 0, 1 },
1670 : : { 1, 2 },
1671 : : { 2, 3 },
1672 : : { 3, 0 },
1673 : : { 0, 4 },
1674 : : { 1, 5 },
1675 : : { 2, 6 },
1676 : : { 3, 7 },
1677 : : { 4, 5 },
1678 : : { 5, 6 },
1679 : : { 6, 7 },
1680 : : { 7, 4 } },
1681 : : { { 0, 4 },
1682 : : { 1, 4 },
1683 : : { 2, 4 },
1684 : : { 3, 4 },
1685 : : { 0, 3 },
1686 : : { 0, 1 },
1687 : : { 1, 2 },
1688 : : { 2, 3 },
1689 : : { 0, 5 },
1690 : : { 1, 5 },
1691 : : { 2, 5 },
1692 : : { 3, 5 } },
1693 : : { { 0, 5, 8, 4 }, { 1, 6, 9, 5 }, { 2, 7, 10, 6 }, { 3, 4, 11, 7 }, { 3, 2, 1, 0 }, { 8, 9, 10, 11 } },
1694 : : { { -1, 0, -1, 3, 4, -1, -1, -1 },
1695 : : { 0, -1, 1, -1, -1, 5, -1, -1 },
1696 : : { -1, 1, -1, 2, -1, -1, 6, -1 },
1697 : : { 3, -1, 2, -1, -1, -1, -1, 7 },
1698 : : { 4, -1, -1, -1, -1, 8, -1, 11 },
1699 : : { -1, 5, -1, -1, 8, -1, 9, -1 },
1700 : : { -1, -1, 6, -1, -1, 9, -1, 10 },
1701 : : { -1, -1, -1, 7, 11, -1, 10, -1 } },
1702 : : { 4, 0, 2, 5, 7 },
1703 : : { 0, 6 },
1704 : : { { 3, 1, 3, 4 }, { 3, 1, 3, 6 }, { 3, 1, 4, 6 }, { 3, 3, 6, 4 } } }
1705 : : };
1706 : :
1707 : : //////////////////////////////////////////////////////////////////////////////////
1708 : 7 : ErrorCode HalfFacetRep::determine_sibling_halffaces( Range& cells )
1709 : : {
1710 : : ErrorCode error;
1711 [ + - ][ + - ]: 7 : EntityHandle start_cell = *cells.begin();
1712 [ + - ]: 7 : EntityType ctype = mb->type_from_handle( start_cell );
1713 [ + - ]: 7 : int index = get_index_in_lmap( start_cell );
1714 : 7 : int nvpc = lConnMap3D[index].num_verts_in_cell;
1715 : 7 : int nfpc = lConnMap3D[index].num_faces_in_cell;
1716 : :
1717 : : // Step 1: Create an index list storing the starting position for each vertex
1718 [ + - ]: 7 : int nv = _verts.size();
1719 [ + - ]: 7 : std::vector< int > is_index( nv + 1 );
1720 [ + + ]: 149 : for( int i = 0; i < nv + 1; i++ )
1721 [ + - ]: 142 : is_index[i] = 0;
1722 : :
1723 : : int vindex;
1724 : :
1725 [ + - ][ + - ]: 57 : for( Range::iterator cid = cells.begin(); cid != cells.end(); ++cid )
[ + - ][ + - ]
[ + + ]
1726 : : {
1727 : : const EntityHandle* conn;
1728 [ + - ][ + - ]: 50 : error = mb->get_connectivity( *cid, conn, nvpc, true );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
1729 : :
1730 [ + + ]: 332 : for( int i = 0; i < nfpc; ++i )
1731 : : {
1732 : 282 : int nvF = lConnMap3D[index].hf2v_num[i];
1733 : 282 : EntityHandle v = 0;
1734 [ + + ]: 1374 : for( int k = 0; k < nvF; k++ )
1735 : : {
1736 : 1092 : int id = lConnMap3D[index].hf2v[i][k];
1737 [ + + ]: 1092 : if( v <= conn[id] ) v = conn[id];
1738 : : }
1739 [ + - ]: 282 : vindex = _verts.index( v );
1740 [ + - ]: 282 : is_index[vindex + 1] += 1;
1741 : : }
1742 : : }
1743 [ + - ]: 7 : is_index[0] = 0;
1744 : :
1745 [ + + ]: 142 : for( int i = 0; i < nv; i++ )
1746 [ + - ][ + - ]: 135 : is_index[i + 1] = is_index[i] + is_index[i + 1];
[ + - ]
1747 : :
1748 : : // Step 2: Define four arrays v2hv_eid, v2hv_lvid storing every half-facet on a vertex
1749 [ + - ][ + - ]: 14 : std::vector< EntityHandle > v2oe_v1( is_index[nv] );
1750 [ + - ][ + - ]: 14 : std::vector< EntityHandle > v2oe_v2( is_index[nv] );
1751 [ + - ][ + - ]: 14 : std::vector< EntityHandle > v2hf_map_cid( is_index[nv] );
1752 [ + - ][ + - ]: 14 : std::vector< int > v2hf_map_lfid( is_index[nv] );
1753 : :
1754 [ + - ][ + - ]: 57 : for( Range::iterator cid = cells.begin(); cid != cells.end(); ++cid )
[ + - ][ + - ]
[ + + ]
1755 : : {
1756 : : const EntityHandle* conn;
1757 [ + - ][ + - ]: 50 : error = mb->get_connectivity( *cid, conn, nvpc, true );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
1758 : :
1759 [ + + ]: 332 : for( int i = 0; i < nfpc; i++ )
1760 : : {
1761 : 282 : int nvF = lConnMap3D[index].hf2v_num[i];
1762 [ + - ]: 282 : std::vector< EntityHandle > vs( nvF );
1763 : 282 : EntityHandle vmax = 0;
1764 : 282 : int lv = -1;
1765 [ + + ]: 1374 : for( int k = 0; k < nvF; k++ )
1766 : : {
1767 : 1092 : int id = lConnMap3D[index].hf2v[i][k];
1768 [ + - ]: 1092 : vs[k] = conn[id];
1769 [ + + ]: 1092 : if( vmax <= conn[id] )
1770 : : {
1771 : 789 : vmax = conn[id];
1772 : 789 : lv = k;
1773 : : }
1774 : : }
1775 : :
1776 : 282 : int nidx = lConnMap2D[nvF - 3].next[lv];
1777 : 282 : int pidx = lConnMap2D[nvF - 3].prev[lv];
1778 : :
1779 [ + - ]: 282 : int v = _verts.index( vmax );
1780 [ + - ][ + - ]: 282 : v2oe_v1[is_index[v]] = vs[nidx];
[ + - ]
1781 [ + - ][ + - ]: 282 : v2oe_v2[is_index[v]] = vs[pidx];
[ + - ]
1782 [ + - ][ + - ]: 282 : v2hf_map_cid[is_index[v]] = *cid;
[ + - ]
1783 [ + - ][ + - ]: 282 : v2hf_map_lfid[is_index[v]] = i;
1784 [ + - ]: 282 : is_index[v] += 1;
1785 : 282 : }
1786 : : }
1787 : :
1788 [ + + ]: 135 : for( int i = nv - 2; i >= 0; i-- )
1789 [ + - ][ + - ]: 128 : is_index[i + 1] = is_index[i];
1790 [ + - ]: 7 : is_index[0] = 0;
1791 : :
1792 : : // Step 3: Fill up sibling half-verts map
1793 [ + - ][ + - ]: 57 : for( Range::iterator cid = cells.begin(); cid != cells.end(); ++cid )
[ + - ][ + - ]
[ + + ]
1794 : : {
1795 : : const EntityHandle* conn;
1796 [ + - ][ + - ]: 50 : error = mb->get_connectivity( *cid, conn, nvpc, true );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
1797 : :
1798 [ + - ][ + - ]: 50 : int cidx = ID_FROM_HANDLE( *cid ) - 1;
1799 [ + + ]: 332 : for( int i = 0; i < nfpc; i++ )
1800 : : {
1801 [ + - ]: 282 : HFacet hf = sibhfs[nfpc * cidx + i];
1802 [ + - ]: 282 : EntityHandle sibcid = fid_from_halfacet( hf, ctype );
1803 : :
1804 [ + + ]: 282 : if( sibcid != 0 ) continue;
1805 : :
1806 : 202 : int nvF = lConnMap3D[index].hf2v_num[i];
1807 [ + - ]: 202 : std::vector< EntityHandle > vs( nvF );
1808 : 202 : EntityHandle vmax = 0;
1809 : 202 : int lv = -1;
1810 [ + + ]: 982 : for( int k = 0; k < nvF; k++ )
1811 : : {
1812 : 780 : int id = lConnMap3D[index].hf2v[i][k];
1813 [ + - ]: 780 : vs[k] = conn[id];
1814 [ + + ]: 780 : if( vmax <= conn[id] )
1815 : : {
1816 : 561 : vmax = conn[id];
1817 : 561 : lv = k;
1818 : : }
1819 : : }
1820 [ - + ][ # # ]: 202 : if( lv < 0 ) MB_SET_ERR( MB_FAILURE, "did not find local vertex " );
[ # # ][ # # ]
[ # # ][ # # ]
1821 : 202 : int nidx = lConnMap2D[nvF - 3].next[lv];
1822 : 202 : int pidx = lConnMap2D[nvF - 3].prev[lv];
1823 : :
1824 [ + - ]: 202 : int v = _verts.index( vmax );
1825 [ + - ]: 202 : EntityHandle v1 = vs[pidx];
1826 [ + - ]: 202 : EntityHandle v2 = vs[nidx];
1827 : :
1828 [ + - ][ + - ]: 1010 : for( int ind = is_index[v]; ind <= is_index[v + 1] - 1; ind++ )
[ + + ][ + - ]
1829 : : {
1830 [ + - ][ + + ]: 808 : if( ( v2oe_v1[ind] == v1 ) && ( v2oe_v2[ind] == v2 ) )
[ + - ][ + + ]
[ + + ]
1831 : : {
1832 : : // Map to opposite hf
1833 [ + - ]: 80 : EntityHandle cur_cid = v2hf_map_cid[ind];
1834 [ + - ]: 80 : int cur_lfid = v2hf_map_lfid[ind];
1835 : :
1836 [ + - ][ + - ]: 80 : sibhfs[nfpc * cidx + i] = create_halffacet( cur_cid, cur_lfid );
1837 : :
1838 [ + - ]: 80 : int scidx = ID_FROM_HANDLE( cur_cid ) - 1;
1839 [ + - ][ + - ]: 80 : sibhfs[nfpc * scidx + cur_lfid] = create_halffacet( *cid, i );
[ + - ]
1840 : : }
1841 : : }
1842 : 202 : }
1843 : : }
1844 : :
1845 : 14 : return MB_SUCCESS;
1846 : : }
1847 : :
1848 : 7 : ErrorCode HalfFacetRep::determine_incident_halffaces( Range& cells )
1849 : : {
1850 : : ErrorCode error;
1851 [ + - ][ + - ]: 7 : int index = get_index_in_lmap( *cells.begin() );
[ + - ]
1852 : 7 : int nvpc = lConnMap3D[index].num_verts_in_cell;
1853 : :
1854 [ + - ]: 7 : std::multimap< EntityHandle, EntityHandle > comps;
1855 : : HFacet nwhf;
1856 : :
1857 [ + - ][ + - ]: 57 : for( Range::iterator cid = cells.begin(); cid != cells.end(); ++cid )
[ + - ][ + - ]
[ + + ]
1858 : : {
1859 [ + - ]: 50 : EntityHandle cell = *cid;
1860 : : const EntityHandle* conn;
1861 [ + - ][ + - ]: 50 : error = mb->get_connectivity( *cid, conn, nvpc, true );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
1862 : :
1863 [ + + ]: 414 : for( int i = 0; i < nvpc; ++i )
1864 : : {
1865 : 364 : EntityHandle v = conn[i];
1866 [ + - ]: 364 : int vidx = ID_FROM_HANDLE( v ) - 1;
1867 [ + - ]: 364 : HFacet hf = v2hf[vidx];
1868 : :
1869 [ + - ]: 364 : bool found = find_cell_in_component( v, cell, comps );
1870 : :
1871 [ + + ][ + - ]: 364 : if( hf == 0 && !found && ( v2hfs.empty() || ( v2hfs.find( v ) == v2hfs.end() ) ) )
[ - + ][ # # ]
[ # # ][ # # ]
[ - + ][ - + ]
[ + + # #
# # ]
1872 : : {
1873 : 135 : nwhf = 0;
1874 [ + - ][ - + ]: 135 : error = add_cells_of_single_component( v, cell, lConnMap3D[index].v2hf[i][0], comps, nwhf );MB_CHK_ERR( error );
[ # # ][ # # ]
1875 : :
1876 [ + - ]: 135 : v2hf[vidx] = nwhf;
1877 : : }
1878 [ + - ][ - + ]: 229 : else if( hf != 0 && !found )
1879 : : {
1880 : 0 : nwhf = 0;
1881 [ # # ][ # # ]: 0 : error = add_cells_of_single_component( v, cell, lConnMap3D[index].v2hf[i][0], comps, nwhf );MB_CHK_ERR( error );
[ # # ][ # # ]
1882 : :
1883 [ # # ][ # # ]: 0 : v2hfs.insert( std::pair< EntityHandle, HFacet >( v, hf ) );
1884 [ # # ][ # # ]: 0 : v2hfs.insert( std::pair< EntityHandle, HFacet >( v, nwhf ) );
1885 [ # # ]: 0 : v2hf[vidx] = 0;
1886 : : }
1887 [ - + ][ # # ]: 229 : else if( hf == 0 && !found && ( !v2hfs.empty() ) && ( v2hfs.find( v ) != v2hfs.end() ) )
[ # # ][ # # ]
[ # # ][ # # ]
[ - + ][ - + ]
[ - + # #
# # ]
1888 : : {
1889 : 0 : nwhf = 0;
1890 [ # # ][ # # ]: 0 : error = add_cells_of_single_component( v, cell, lConnMap3D[index].v2hf[i][0], comps, nwhf );MB_CHK_ERR( error );
[ # # ][ # # ]
1891 [ # # ][ # # ]: 0 : v2hfs.insert( std::pair< EntityHandle, HFacet >( v, nwhf ) );
1892 : : }
1893 : : }
1894 : : }
1895 : :
1896 : : // error = print_tags(3);
1897 : :
1898 : 7 : return MB_SUCCESS;
1899 : : }
1900 : :
1901 : 0 : ErrorCode HalfFacetRep::determine_border_vertices( Range& cells, Tag isborder )
1902 : : {
1903 : : ErrorCode error;
1904 [ # # ][ # # ]: 0 : EntityHandle start_cell = *cells.begin();
1905 [ # # ][ # # ]: 0 : EntityType ctype = mb->type_from_handle( *cells.begin() );
[ # # ]
1906 [ # # ]: 0 : int index = get_index_in_lmap( start_cell );
1907 : 0 : int nvpc = lConnMap3D[index].num_verts_in_cell;
1908 : 0 : int nfpc = lConnMap3D[index].num_faces_in_cell;
1909 : :
1910 : 0 : int val = 1;
1911 : :
1912 [ # # ][ # # ]: 0 : for( Range::iterator t = cells.begin(); t != cells.end(); ++t )
[ # # ][ # # ]
[ # # ]
1913 : : {
1914 : :
1915 : : const EntityHandle* conn;
1916 [ # # ][ # # ]: 0 : error = mb->get_connectivity( *t, conn, nvpc, true );MB_CHK_ERR( error );
[ # # ][ # # ]
[ # # ]
1917 : :
1918 [ # # ][ # # ]: 0 : int cidx = ID_FROM_HANDLE( *t ) - 1;
1919 [ # # ]: 0 : for( int i = 0; i < nfpc; ++i )
1920 : : {
1921 [ # # ]: 0 : HFacet hf = sibhfs[nfpc * cidx + i];
1922 [ # # ]: 0 : EntityHandle sib_cid = fid_from_halfacet( hf, ctype );
1923 : :
1924 [ # # ]: 0 : if( sib_cid == 0 )
1925 : : {
1926 : 0 : int nvF = lConnMap3D[index].hf2v_num[i];
1927 : :
1928 [ # # ]: 0 : for( int j = 0; j < nvF; ++j )
1929 : : {
1930 : 0 : int ind = lConnMap3D[index].hf2v[i][j];
1931 [ # # ][ # # ]: 0 : error = mb->tag_set_data( isborder, &conn[ind], 1, &val );MB_CHK_ERR( error );
[ # # ][ # # ]
1932 : : }
1933 : : }
1934 : : }
1935 : : }
1936 : :
1937 : 0 : return MB_SUCCESS;
1938 : : }
1939 : :
1940 : : /////////////////////////////////////////////////////////////////////////
1941 : 135 : ErrorCode HalfFacetRep::add_cells_of_single_component( EntityHandle vid, EntityHandle curcid, int curlid,
1942 : : std::multimap< EntityHandle, EntityHandle >& comps, HFacet& hf )
1943 : : {
1944 : : ErrorCode error;
1945 [ + - ]: 135 : EntityType ctype = mb->type_from_handle( curcid );
1946 [ + - ]: 135 : int index = get_index_in_lmap( curcid );
1947 : 135 : int nvpc = lConnMap3D[index].num_verts_in_cell;
1948 : 135 : int nfpc = lConnMap3D[index].num_faces_in_cell;
1949 : :
1950 : 135 : int Stksize = 0, count = -1;
1951 : 135 : Stkcells[0] = curcid;
1952 : :
1953 [ + - ]: 135 : hf = create_halffacet( curcid, curlid );
1954 : :
1955 : : EntityHandle cur_cid;
1956 [ + + ]: 582 : while( Stksize >= 0 )
1957 : : {
1958 : 447 : cur_cid = Stkcells[Stksize];
1959 : 447 : Stksize -= 1;
1960 : :
1961 [ + - ]: 447 : bool found = find_match_in_array( cur_cid, trackcells, count );
1962 [ + + ]: 447 : if( !found )
1963 : : {
1964 : 364 : count += 1;
1965 : 364 : trackcells[count] = cur_cid;
1966 : :
1967 : : // Add the current cell
1968 [ + - ][ + - ]: 364 : comps.insert( std::pair< EntityHandle, EntityHandle >( vid, cur_cid ) );
1969 : : }
1970 : :
1971 : : // Connectivity of the cell
1972 : : const EntityHandle* conn;
1973 [ + - ][ - + ]: 447 : error = mb->get_connectivity( cur_cid, conn, nvpc, true );MB_CHK_ERR( error );
[ # # ][ # # ]
1974 : :
1975 : : // Local id of vid in the cell and the half-faces incident on it
1976 : 447 : int lv = -1;
1977 [ + - ]: 2012 : for( int i = 0; i < nvpc; ++i )
1978 : : {
1979 [ + + ]: 2012 : if( conn[i] == vid )
1980 : : {
1981 : 447 : lv = i;
1982 : 447 : break;
1983 : : }
1984 : : }
1985 [ - + ][ # # ]: 447 : if( lv < 0 ) MB_SET_ERR( MB_FAILURE, "did not find local vertex " );
[ # # ][ # # ]
[ # # ][ # # ]
1986 : 447 : int nhf_thisv = lConnMap3D[index].v2hf_num[lv];
1987 [ + - ]: 447 : int cidx = ID_FROM_HANDLE( cur_cid ) - 1;
1988 : :
1989 : : // Add new cells into the stack
1990 : : EntityHandle ngb;
1991 : : HFacet hf_ngb;
1992 [ + + ]: 1788 : for( int i = 0; i < nhf_thisv; ++i )
1993 : : {
1994 : 1341 : int ind = lConnMap3D[index].v2hf[lv][i];
1995 [ + - ]: 1341 : hf_ngb = sibhfs[nfpc * cidx + ind];
1996 [ + - ]: 1341 : ngb = fid_from_halfacet( hf_ngb, ctype );
1997 : :
1998 [ + + ]: 1341 : if( ngb )
1999 : : {
2000 [ + - ]: 835 : bool found_ent = find_match_in_array( ngb, trackcells, count );
2001 : :
2002 [ + + ]: 835 : if( !found_ent )
2003 : : {
2004 : 312 : Stksize += 1;
2005 : 835 : Stkcells[Stksize] = ngb;
2006 : : }
2007 : : }
2008 : : else
2009 [ + - ]: 506 : hf = create_halffacet( cur_cid, ind );
2010 : : }
2011 : : }
2012 : :
2013 : : // Change the visited faces to false
2014 [ - + ]: 135 : for( int i = 0; i < Stksize; i++ )
2015 : 0 : Stkcells[i] = 0;
2016 : :
2017 [ + + ]: 499 : for( int i = 0; i <= count; i++ )
2018 : 364 : trackcells[i] = 0;
2019 : :
2020 : 135 : return MB_SUCCESS;
2021 : : }
2022 : :
2023 : 364 : bool HalfFacetRep::find_cell_in_component( EntityHandle vid, EntityHandle cell,
2024 : : std::multimap< EntityHandle, EntityHandle >& comps )
2025 : : {
2026 : 364 : bool found = false;
2027 : :
2028 [ + + ]: 364 : if( comps.empty() ) return found;
2029 : :
2030 : : std::pair< std::multimap< EntityHandle, EntityHandle >::iterator,
2031 : : std::multimap< EntityHandle, EntityHandle >::iterator >
2032 [ + - ]: 357 : rit;
2033 : :
2034 [ + - ]: 357 : rit = comps.equal_range( vid );
2035 : :
2036 [ + - ][ + - ]: 889 : for( std::multimap< EntityHandle, EntityHandle >::iterator it = rit.first; it != rit.second; ++it )
[ + + ]
2037 : : {
2038 [ + - ][ + + ]: 761 : if( it->second == cell )
2039 : : {
2040 : 229 : found = true;
2041 : 229 : break;
2042 : : }
2043 : : }
2044 : :
2045 : 364 : return found;
2046 : : }
2047 : :
2048 : : ////////////////////////////////////////////////////////////////////////
2049 : 27515 : ErrorCode HalfFacetRep::get_up_adjacencies_vert_3d( EntityHandle vid, std::vector< EntityHandle >& adjents )
2050 : : {
2051 : : ErrorCode error;
2052 [ + - ]: 27515 : adjents.reserve( 20 );
2053 [ + - ][ + - ]: 27515 : EntityType ctype = mb->type_from_handle( *_cells.begin() );
[ + - ]
2054 : :
2055 : : // Obtain a half-face/s incident on v
2056 [ + - ]: 27515 : int vidx = ID_FROM_HANDLE( vid ) - 1;
2057 [ + - ]: 27515 : HFacet hf = v2hf[vidx];
2058 : :
2059 [ + - ]: 27515 : std::vector< EntityHandle > start_cells;
2060 [ - + ][ # # ]: 27515 : if( hf == 0 && ( v2hfs.find( vid ) != v2hfs.end() ) ) // Vertex is non-manifold
[ # # ][ # # ]
[ - + ][ - + ]
[ - + # #
# # ]
2061 : : {
2062 : : std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
2063 [ # # ]: 0 : it_hes;
2064 [ # # ]: 0 : it_hes = v2hfs.equal_range( vid );
2065 : :
2066 [ # # ][ # # ]: 0 : for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
[ # # ]
2067 : : {
2068 [ # # ][ # # ]: 0 : start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
[ # # ]
2069 : : }
2070 : : }
2071 [ + - ]: 27515 : else if( hf != 0 )
2072 [ + - ][ + - ]: 27515 : start_cells.push_back( fid_from_halfacet( hf, ctype ) );
2073 : :
2074 [ - + ]: 27515 : if( start_cells.empty() ) return MB_SUCCESS;
2075 : :
2076 [ + - ][ + - ]: 27515 : int index = get_index_in_lmap( start_cells[0] );
2077 : 27515 : int nvpc = lConnMap3D[index].num_verts_in_cell;
2078 : 27515 : int nfpc = lConnMap3D[index].num_faces_in_cell;
2079 : :
2080 [ + + ]: 55030 : for( int i = 0; i < (int)start_cells.size(); i++ )
2081 [ + - ]: 27515 : cellq[i] = start_cells[i];
2082 : :
2083 : 27515 : int qsize = start_cells.size();
2084 : : EntityHandle cur_cid;
2085 : 27515 : int num_qvals = 0;
2086 : :
2087 [ + + ]: 265851 : while( num_qvals < qsize )
2088 : : {
2089 : 238336 : cur_cid = cellq[num_qvals];
2090 : 238336 : num_qvals += 1;
2091 : :
2092 : : // Add the current cell to output adj vector
2093 [ + - ]: 238336 : adjents.push_back( cur_cid );
2094 : :
2095 : : // Connectivity of the cell
2096 : : const EntityHandle* conn;
2097 [ + - ][ - + ]: 238336 : error = mb->get_connectivity( cur_cid, conn, nvpc, true );MB_CHK_ERR( error );
[ # # ][ # # ]
2098 : :
2099 : : // Local id of vid in the cell and the half-faces incident on it
2100 : 238336 : int lv = -1;
2101 [ + - ]: 913792 : for( int i = 0; i < nvpc; ++i )
2102 : : {
2103 [ + + ]: 913792 : if( conn[i] == vid )
2104 : : {
2105 : 238336 : lv = i;
2106 : 238336 : break;
2107 : : }
2108 : : };
2109 [ - + ][ # # ]: 238336 : if( lv < 0 ) MB_SET_ERR( MB_FAILURE, "did not find local vertex " );
[ # # ][ # # ]
[ # # ][ # # ]
2110 : : // Number of local half-faces incident on the current vertex
2111 : 238336 : int nhf_thisv = lConnMap3D[index].v2hf_num[lv];
2112 [ + - ]: 238336 : int cidx = ID_FROM_HANDLE( cur_cid ) - 1;
2113 : :
2114 : : // Add new cells into the stack
2115 : : EntityHandle ngb;
2116 [ + + ]: 953344 : for( int i = 0; i < nhf_thisv; ++i )
2117 : : {
2118 : 715008 : int ind = lConnMap3D[index].v2hf[lv][i];
2119 [ + - ]: 715008 : hf = sibhfs[nfpc * cidx + ind];
2120 [ + - ]: 715008 : ngb = fid_from_halfacet( hf, ctype );
2121 : :
2122 [ + + ]: 715008 : if( ngb )
2123 : : {
2124 [ + - ]: 679872 : bool found_ent = find_match_in_array( ngb, cellq, qsize - 1 );
2125 : :
2126 [ + + ]: 679872 : if( !found_ent )
2127 : : {
2128 : 210821 : cellq[qsize] = ngb;
2129 : 679872 : qsize += 1;
2130 : : }
2131 : : }
2132 : : }
2133 : : }
2134 : :
2135 : : // Change the visited faces to false
2136 [ + + ]: 265851 : for( int i = 0; i < qsize; i++ )
2137 : 238336 : cellq[i] = 0;
2138 : :
2139 : 27515 : return MB_SUCCESS;
2140 : : }
2141 : :
2142 : 170 : ErrorCode HalfFacetRep::get_up_adjacencies_edg_3d( EntityHandle eid, std::vector< EntityHandle >& adjents,
2143 : : std::vector< int >* leids )
2144 : : {
2145 : : ErrorCode error;
2146 [ + - ][ + - ]: 170 : EntityType ctype = mb->type_from_handle( *_cells.begin() );
[ + - ]
2147 [ + - ][ + - ]: 170 : EntityHandle start_cell = *_cells.begin();
2148 [ + - ]: 170 : int index = get_index_in_lmap( start_cell );
2149 : 170 : int nvpc = lConnMap3D[index].num_verts_in_cell;
2150 : 170 : int nfpc = lConnMap3D[index].num_faces_in_cell;
2151 : :
2152 [ + - ]: 170 : adjents.reserve( 20 );
2153 [ - + ][ # # ]: 170 : if( leids != NULL ) leids->reserve( 20 );
2154 : :
2155 : : // Find the edge vertices
2156 : : const EntityHandle* econn;
2157 : 170 : int num_conn = 0;
2158 [ + - ][ - + ]: 170 : error = mb->get_connectivity( eid, econn, num_conn, true );MB_CHK_ERR( error );
[ # # ][ # # ]
2159 : :
2160 : 170 : EntityHandle v_start = econn[0], v_end = econn[1];
2161 [ + - ]: 170 : int v1idx = ID_FROM_HANDLE( v_start ) - 1;
2162 [ + - ]: 170 : int v2idx = ID_FROM_HANDLE( v_end ) - 1;
2163 : :
2164 : : // Find an half-facets incident to each end vertex of the edge
2165 [ + - ]: 170 : std::vector< EntityHandle > start_cells;
2166 [ + - ]: 170 : HFacet hf1 = v2hf[v1idx];
2167 [ + - ]: 170 : HFacet hf2 = v2hf[v2idx];
2168 : :
2169 [ - + ][ # # ]: 170 : if( hf1 == 0 && !v2hfs.empty() )
[ - + ]
2170 : : {
2171 : : std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
2172 [ # # ]: 0 : it_hes;
2173 [ # # ]: 0 : it_hes = v2hfs.equal_range( v_start );
2174 : :
2175 [ # # ][ # # ]: 0 : for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
[ # # ]
2176 : : {
2177 [ # # ][ # # ]: 0 : start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
[ # # ]
2178 : : }
2179 : : }
2180 [ + - ]: 170 : else if( hf1 != 0 )
2181 : : {
2182 [ + - ][ + - ]: 170 : start_cells.push_back( fid_from_halfacet( hf1, ctype ) );
2183 : : }
2184 : :
2185 [ - + ][ # # ]: 170 : if( hf2 == 0 && !v2hfs.empty() )
[ - + ]
2186 : : {
2187 : : std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
2188 [ # # ]: 0 : it_hes;
2189 [ # # ]: 0 : it_hes = v2hfs.equal_range( v_end );
2190 : :
2191 [ # # ][ # # ]: 0 : for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
[ # # ]
2192 : : {
2193 [ # # ][ # # ]: 0 : start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
[ # # ]
2194 : : }
2195 : : }
2196 [ + - ]: 170 : else if( hf2 != 0 )
2197 : : {
2198 [ + - ][ + - ]: 170 : start_cells.push_back( fid_from_halfacet( hf2, ctype ) );
2199 : : }
2200 : :
2201 [ - + ]: 170 : if( start_cells.empty() ) return MB_SUCCESS;
2202 : :
2203 [ + - ]: 170 : std::sort( start_cells.begin(), start_cells.end() );
2204 [ + - ]: 170 : std::vector< EntityHandle >::iterator last = std::unique( start_cells.begin(), start_cells.end() );
2205 [ + - ]: 170 : start_cells.erase( last, start_cells.end() );
2206 : :
2207 [ + + ]: 488 : for( int i = 0; i < (int)start_cells.size(); i++ )
2208 [ + - ]: 318 : cellq[i] = start_cells[i];
2209 : :
2210 : 170 : int qsize = start_cells.size();
2211 : 170 : int num_qvals = 0;
2212 : :
2213 [ + + ]: 998 : while( num_qvals < qsize )
2214 : : {
2215 : 828 : EntityHandle cell_id = cellq[num_qvals];
2216 : 828 : num_qvals += 1;
2217 : :
2218 : : const EntityHandle* conn;
2219 [ + - ][ - + ]: 828 : error = mb->get_connectivity( cell_id, conn, nvpc, true );MB_CHK_ERR( error );
[ # # ][ # # ]
2220 : :
2221 : 828 : int lv0 = -1, lv1 = -1, lv = -1;
2222 : :
2223 : : // locate v_origin in poped out tet, check if v_end is in
2224 [ + + ]: 7452 : for( int i = 0; i < nvpc; i++ )
2225 : : {
2226 [ + + ]: 6624 : if( v_start == conn[i] )
2227 : : {
2228 : 596 : lv0 = i;
2229 : 596 : lv = lv0;
2230 : : }
2231 [ + + ]: 6028 : else if( v_end == conn[i] )
2232 : : {
2233 : 616 : lv1 = i;
2234 : 616 : lv = lv1;
2235 : : }
2236 : : }
2237 : :
2238 [ + + ][ + + ]: 828 : if( ( lv0 >= 0 ) && ( lv1 >= 0 ) )
2239 : : {
2240 [ + - ]: 384 : adjents.push_back( cell_id );
2241 [ - + ][ # # ]: 384 : if( leids != NULL ) leids->push_back( lConnMap3D[index].lookup_leids[lv0][lv1] );
2242 : : }
2243 : :
2244 : : // push back new found unchecked incident tets of v_start
2245 [ + - ]: 828 : int cidx = ID_FROM_HANDLE( cell_id ) - 1;
2246 [ - + ][ # # ]: 828 : if( lv < 0 ) MB_SET_ERR( MB_FAILURE, "did not find local vertex " );
[ # # ][ # # ]
[ # # ][ # # ]
2247 : 828 : int nhf_thisv = lConnMap3D[index].v2hf_num[lv];
2248 : :
2249 [ + + ]: 3312 : for( int i = 0; i < nhf_thisv; i++ )
2250 : : {
2251 : 2484 : int ind = lConnMap3D[index].v2hf[lv][i];
2252 [ + - ]: 2484 : HFacet hf = sibhfs[nfpc * cidx + ind];
2253 [ + - ]: 2484 : EntityHandle ngb = fid_from_halfacet( hf, ctype );
2254 : :
2255 [ + + ]: 2484 : if( ngb )
2256 : : {
2257 [ + - ]: 1842 : bool found_ent = find_match_in_array( ngb, &cellq[0], qsize - 1 );
2258 : :
2259 [ + + ]: 1842 : if( !found_ent )
2260 : : {
2261 : 510 : cellq[qsize] = ngb;
2262 : 1842 : qsize += 1;
2263 : : }
2264 : : }
2265 : : }
2266 : : }
2267 : :
2268 [ + + ]: 998 : for( int i = 0; i < qsize; i++ )
2269 : 828 : cellq[i] = 0;
2270 : :
2271 : 170 : return MB_SUCCESS;
2272 : : }
2273 : :
2274 : 55039 : ErrorCode HalfFacetRep::get_up_adjacencies_edg_3d( EntityHandle cid, int leid, std::vector< EntityHandle >& adjents,
2275 : : std::vector< int >* leids, std::vector< int >* adj_orients )
2276 : : {
2277 : : ErrorCode error;
2278 [ + - ]: 55039 : EntityType ctype = mb->type_from_handle( cid );
2279 [ + - ]: 55039 : int index = get_index_in_lmap( cid );
2280 : 55039 : int nvpc = lConnMap3D[index].num_verts_in_cell;
2281 : 55039 : int nfpc = lConnMap3D[index].num_faces_in_cell;
2282 : 55039 : adjents.clear();
2283 [ + - ]: 55039 : adjents.reserve( 20 );
2284 : :
2285 [ + - ]: 55039 : if( leids != NULL )
2286 : : {
2287 : 55039 : leids->clear();
2288 [ + - ]: 55039 : leids->reserve( 20 );
2289 : : }
2290 [ + + ]: 55039 : if( adj_orients != NULL )
2291 : : {
2292 : 42930 : adj_orients->clear();
2293 [ + - ]: 42930 : adj_orients->reserve( 20 );
2294 : : }
2295 : :
2296 : : const EntityHandle* econn;
2297 [ + - ][ - + ]: 55039 : error = mb->get_connectivity( cid, econn, nvpc, true );MB_CHK_ERR( error );
[ # # ][ # # ]
2298 : :
2299 : : // Get the end vertices of the edge <cid,leid>
2300 : 55039 : int id = lConnMap3D[index].e2v[leid][0];
2301 : 55039 : EntityHandle v_start = econn[id];
2302 : 55039 : id = lConnMap3D[index].e2v[leid][1];
2303 : 55039 : EntityHandle v_end = econn[id];
2304 : :
2305 [ + - ]: 55039 : int v1idx = ID_FROM_HANDLE( v_start ) - 1;
2306 [ + - ]: 55039 : int v2idx = ID_FROM_HANDLE( v_end ) - 1;
2307 : :
2308 : : // Find an half-facets incident to each end vertex of the edge
2309 [ + - ]: 55039 : std::vector< EntityHandle > start_cells;
2310 [ + - ]: 55039 : HFacet hf1 = v2hf[v1idx];
2311 [ + - ]: 55039 : HFacet hf2 = v2hf[v2idx];
2312 : :
2313 [ - + ][ # # ]: 55039 : if( hf1 == 0 && !v2hfs.empty() )
[ - + ]
2314 : : {
2315 : : std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
2316 [ # # ]: 0 : it_hes;
2317 [ # # ]: 0 : it_hes = v2hfs.equal_range( v_start );
2318 : :
2319 [ # # ][ # # ]: 0 : for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
[ # # ]
2320 : : {
2321 [ # # ][ # # ]: 0 : start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
[ # # ]
2322 : : }
2323 : : }
2324 [ + - ]: 55039 : else if( hf1 != 0 )
2325 : : {
2326 [ + - ][ + - ]: 55039 : start_cells.push_back( fid_from_halfacet( hf1, ctype ) );
2327 : : }
2328 : :
2329 [ - + ][ # # ]: 55039 : if( hf2 == 0 && !v2hfs.empty() )
[ - + ]
2330 : : {
2331 : : std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
2332 [ # # ]: 0 : it_hes;
2333 [ # # ]: 0 : it_hes = v2hfs.equal_range( v_end );
2334 : :
2335 [ # # ][ # # ]: 0 : for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
[ # # ]
2336 : : {
2337 [ # # ][ # # ]: 0 : start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
[ # # ]
2338 : : }
2339 : : }
2340 [ + - ]: 55039 : else if( hf2 != 0 )
2341 : : {
2342 [ + - ][ + - ]: 55039 : start_cells.push_back( fid_from_halfacet( hf2, ctype ) );
2343 : : }
2344 : :
2345 [ - + ]: 55039 : if( start_cells.empty() ) return MB_SUCCESS;
2346 : :
2347 [ + - ]: 55039 : std::sort( start_cells.begin(), start_cells.end() );
2348 [ + - ]: 55039 : std::vector< EntityHandle >::iterator last = std::unique( start_cells.begin(), start_cells.end() );
2349 [ + - ]: 55039 : start_cells.erase( last, start_cells.end() );
2350 : :
2351 [ + + ]: 154269 : for( int i = 0; i < (int)start_cells.size(); i++ )
2352 [ + - ]: 99230 : cellq[i] = start_cells[i];
2353 : :
2354 : 55039 : int qsize = start_cells.size();
2355 : 55039 : int num_qvals = 0;
2356 : :
2357 [ + + ]: 923209 : while( num_qvals < qsize )
2358 : : {
2359 : 868170 : EntityHandle cell_id = cellq[num_qvals];
2360 : 868170 : num_qvals += 1;
2361 : :
2362 : : const EntityHandle* conn;
2363 [ + - ][ - + ]: 868170 : error = mb->get_connectivity( cell_id, conn, nvpc, true );MB_CHK_ERR( error );
[ # # ][ # # ]
2364 : :
2365 : 868170 : int lv0 = -1, lv1 = -1, lv = -1;
2366 : :
2367 : : // locate v_origin in poped out tet, check if v_end is in
2368 [ + + ]: 5616434 : for( int i = 0; i < nvpc; i++ )
2369 : : {
2370 [ + + ]: 4748264 : if( v_start == conn[i] )
2371 : : {
2372 : 509974 : lv0 = i;
2373 : 509974 : lv = lv0;
2374 : : }
2375 [ + + ]: 4238290 : else if( v_end == conn[i] )
2376 : : {
2377 : 572086 : lv1 = i;
2378 : 572086 : lv = lv1;
2379 : : }
2380 : : }
2381 : :
2382 [ + + ][ + + ]: 868170 : if( ( lv0 >= 0 ) && ( lv1 >= 0 ) )
2383 : : {
2384 [ + - ]: 213890 : adjents.push_back( cell_id );
2385 [ + - ][ + - ]: 213890 : if( leids != NULL ) leids->push_back( lConnMap3D[index].lookup_leids[lv0][lv1] );
2386 : :
2387 [ + + ]: 213890 : if( adj_orients != NULL )
2388 : : {
2389 : 170960 : int cur_leid = lConnMap3D[index].lookup_leids[lv0][lv1];
2390 : 170960 : int id1 = lConnMap3D[index].e2v[cur_leid][0];
2391 : 170960 : int id2 = lConnMap3D[index].e2v[cur_leid][1];
2392 [ + + ][ + - ]: 170960 : if( ( v_start == conn[id1] ) && ( v_end == conn[id2] ) )
2393 [ + - ]: 114658 : adj_orients->push_back( 1 );
2394 [ + - ][ + - ]: 56302 : else if( ( v_start == conn[id2] ) && ( v_end == conn[id1] ) )
2395 [ + - ]: 213890 : adj_orients->push_back( 0 );
2396 : : }
2397 : : }
2398 [ - + ][ # # ]: 868170 : if( lv < 0 ) MB_SET_ERR( MB_FAILURE, "did not find local vertex " );
[ # # ][ # # ]
[ # # ][ # # ]
2399 : : // push back new found unchecked incident tets of v_start
2400 [ + - ]: 868170 : int cidx = ID_FROM_HANDLE( cell_id ) - 1;
2401 : 868170 : int nhf_thisv = lConnMap3D[index].v2hf_num[lv];
2402 : :
2403 [ + + ]: 3472680 : for( int i = 0; i < nhf_thisv; i++ )
2404 : : {
2405 : 2604510 : int ind = lConnMap3D[index].v2hf[lv][i];
2406 [ + - ]: 2604510 : HFacet hf = sibhfs[nfpc * cidx + ind];
2407 [ + - ]: 2604510 : EntityHandle ngb = fid_from_halfacet( hf, ctype );
2408 : :
2409 [ + + ]: 2604510 : if( ngb )
2410 : : {
2411 [ + - ]: 2492050 : bool found_ent = find_match_in_array( ngb, &cellq[0], qsize - 1 );
2412 : :
2413 [ + + ]: 2492050 : if( !found_ent )
2414 : : {
2415 : 768940 : cellq[qsize] = ngb;
2416 : 2492050 : qsize += 1;
2417 : : }
2418 : : }
2419 : : }
2420 : : }
2421 : :
2422 [ + + ]: 923209 : for( int i = 0; i < qsize; i++ )
2423 : 868170 : cellq[i] = 0;
2424 : :
2425 : 55039 : return MB_SUCCESS;
2426 : : }
2427 : :
2428 : 0 : ErrorCode HalfFacetRep::get_up_adjacencies_edg_3d_comp( EntityHandle cid, int leid,
2429 : : std::vector< EntityHandle >& adjents, std::vector< int >* leids,
2430 : : std::vector< int >* adj_orients )
2431 : : {
2432 : : ErrorCode error;
2433 [ # # ]: 0 : EntityType ctype = mb->type_from_handle( cid );
2434 [ # # ]: 0 : int index = get_index_in_lmap( cid );
2435 : 0 : int nvpc = lConnMap3D[index].num_verts_in_cell;
2436 : 0 : int nfpc = lConnMap3D[index].num_faces_in_cell;
2437 : 0 : adjents.clear();
2438 [ # # ]: 0 : adjents.reserve( 20 );
2439 : :
2440 [ # # ]: 0 : if( leids != NULL )
2441 : : {
2442 : 0 : leids->clear();
2443 [ # # ]: 0 : leids->reserve( 20 );
2444 : : }
2445 [ # # ]: 0 : if( adj_orients != NULL )
2446 : : {
2447 : 0 : adj_orients->clear();
2448 [ # # ]: 0 : adj_orients->reserve( 20 );
2449 : : }
2450 : :
2451 : : const EntityHandle* econn;
2452 [ # # ][ # # ]: 0 : error = mb->get_connectivity( cid, econn, nvpc );MB_CHK_ERR( error );
[ # # ][ # # ]
2453 : :
2454 : : // Get the end vertices of the edge <cid,leid>
2455 : 0 : int id = lConnMap3D[index].e2v[leid][0];
2456 : 0 : EntityHandle v_start = econn[id];
2457 : 0 : id = lConnMap3D[index].e2v[leid][1];
2458 : 0 : EntityHandle v_end = econn[id];
2459 : :
2460 [ # # ]: 0 : int v1idx = ID_FROM_HANDLE( v_start ) - 1;
2461 [ # # ]: 0 : int v2idx = ID_FROM_HANDLE( v_end ) - 1;
2462 : :
2463 : : // Find an half-facets incident to each end vertex of the edge
2464 [ # # ]: 0 : std::vector< EntityHandle > start_cells;
2465 [ # # ]: 0 : HFacet hf1 = v2hf[v1idx];
2466 [ # # ]: 0 : HFacet hf2 = v2hf[v2idx];
2467 : :
2468 [ # # ][ # # ]: 0 : if( ( hf1 == 0 ) && ( v2hfs.find( v_start ) != v2hfs.end() ) && ( hf2 == 0 ) &&
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # #
# # ]
2469 [ # # ][ # # ]: 0 : ( v2hfs.find( v_end ) != v2hfs.end() ) )
[ # # ][ # # ]
[ # # # # ]
2470 : : {
2471 : : std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
2472 [ # # ]: 0 : it_hes;
2473 [ # # ]: 0 : it_hes = v2hfs.equal_range( v_start );
2474 : :
2475 [ # # ][ # # ]: 0 : for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
[ # # ]
2476 : : {
2477 [ # # ][ # # ]: 0 : start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
[ # # ]
2478 : : }
2479 : : }
2480 : : else
2481 : 0 : return MB_SUCCESS;
2482 : :
2483 [ # # ]: 0 : if( start_cells.empty() ) return MB_SUCCESS;
2484 : :
2485 : : // std::sort(start_cells.begin(), start_cells.end());
2486 : : // std::vector<EntityHandle>::iterator last = std::unique(start_cells.begin(),
2487 : : // start_cells.end()); start_cells.erase(last, start_cells.end());
2488 : :
2489 [ # # ]: 0 : for( int c = 0; c < (int)start_cells.size(); c++ )
2490 : : {
2491 [ # # ]: 0 : cellq[0] = start_cells[c];
2492 : :
2493 : 0 : int qsize = 1;
2494 : 0 : int num_qvals = 0;
2495 : :
2496 [ # # ]: 0 : while( num_qvals < qsize )
2497 : : {
2498 : 0 : EntityHandle cell_id = cellq[num_qvals];
2499 : 0 : num_qvals += 1;
2500 : :
2501 : : const EntityHandle* conn;
2502 [ # # ][ # # ]: 0 : error = mb->get_connectivity( cell_id, conn, nvpc );MB_CHK_ERR( error );
[ # # ][ # # ]
2503 : :
2504 : 0 : int lv0 = -1, lv1 = -1, lv = -1;
2505 : :
2506 : : // locate v_origin in poped out tet, check if v_end is in
2507 [ # # ]: 0 : for( int i = 0; i < nvpc; i++ )
2508 : : {
2509 [ # # ]: 0 : if( v_start == conn[i] )
2510 : : {
2511 : 0 : lv0 = i;
2512 : 0 : lv = lv0;
2513 : : }
2514 [ # # ]: 0 : else if( v_end == conn[i] )
2515 : : {
2516 : 0 : lv1 = i;
2517 : 0 : lv = lv1;
2518 : : }
2519 : : }
2520 : :
2521 [ # # ][ # # ]: 0 : if( ( lv0 >= 0 ) && ( lv1 >= 0 ) )
2522 : : {
2523 [ # # ]: 0 : adjents.push_back( cell_id );
2524 [ # # ][ # # ]: 0 : if( leids != NULL ) leids->push_back( lConnMap3D[index].lookup_leids[lv0][lv1] );
2525 : :
2526 [ # # ]: 0 : if( adj_orients != NULL )
2527 : : {
2528 : 0 : int cur_leid = lConnMap3D[index].lookup_leids[lv0][lv1];
2529 : 0 : int id1 = lConnMap3D[index].e2v[cur_leid][0];
2530 : 0 : int id2 = lConnMap3D[index].e2v[cur_leid][1];
2531 [ # # ][ # # ]: 0 : if( ( v_start == conn[id1] ) && ( v_end == conn[id2] ) )
2532 [ # # ]: 0 : adj_orients->push_back( 1 );
2533 [ # # ][ # # ]: 0 : else if( ( v_start == conn[id2] ) && ( v_end == conn[id1] ) )
2534 [ # # ]: 0 : adj_orients->push_back( 0 );
2535 : : }
2536 : :
2537 [ # # ]: 0 : for( int i = 0; i < qsize; i++ )
2538 : 0 : cellq[i] = 0;
2539 : :
2540 : 0 : break;
2541 : : }
2542 : :
2543 : : // push back new found unchecked incident tets of v_start
2544 [ # # ]: 0 : int cidx = ID_FROM_HANDLE( cell_id ) - 1;
2545 : 0 : int nhf_thisv = lConnMap3D[index].v2hf_num[lv];
2546 : :
2547 [ # # ]: 0 : for( int i = 0; i < nhf_thisv; i++ )
2548 : : {
2549 : 0 : int ind = lConnMap3D[index].v2hf[lv][i];
2550 [ # # ]: 0 : HFacet hf = sibhfs[nfpc * cidx + ind];
2551 [ # # ]: 0 : EntityHandle ngb = fid_from_halfacet( hf, ctype );
2552 : :
2553 [ # # ]: 0 : if( ngb )
2554 : : {
2555 [ # # ]: 0 : bool found_ent = find_match_in_array( ngb, &cellq[0], qsize - 1 );
2556 : :
2557 [ # # ]: 0 : if( !found_ent )
2558 : : {
2559 : 0 : cellq[qsize] = ngb;
2560 : 0 : qsize += 1;
2561 : : }
2562 : : }
2563 : : }
2564 : : }
2565 : :
2566 [ # # ]: 0 : for( int i = 0; i < qsize; i++ )
2567 : 0 : cellq[i] = 0;
2568 : : }
2569 : :
2570 : 0 : return MB_SUCCESS;
2571 : : }
2572 : :
2573 : 128 : ErrorCode HalfFacetRep::get_up_adjacencies_face_3d( EntityHandle fid, std::vector< EntityHandle >& adjents,
2574 : : std::vector< int >* lfids )
2575 : : {
2576 : : ErrorCode error;
2577 : :
2578 : 128 : EntityHandle cid = 0;
2579 : 128 : int lid = 0;
2580 [ + - ]: 128 : bool found = find_matching_halfface( fid, &cid, &lid );
2581 : :
2582 [ + - ]: 128 : if( found )
2583 : : {
2584 [ + - ][ - + ]: 128 : error = get_up_adjacencies_face_3d( cid, lid, adjents, lfids );MB_CHK_ERR( error );
[ # # ][ # # ]
2585 : : }
2586 : :
2587 : 128 : return MB_SUCCESS;
2588 : : }
2589 : :
2590 : 27628 : ErrorCode HalfFacetRep::get_up_adjacencies_face_3d( EntityHandle cid, int lfid, std::vector< EntityHandle >& adjents,
2591 : : std::vector< int >* lfids )
2592 : : {
2593 : :
2594 [ + - ][ + - ]: 27628 : EntityHandle start_cell = *_cells.begin();
2595 [ + - ]: 27628 : EntityType ctype = mb->type_from_handle( start_cell );
2596 [ + - ]: 27628 : int index = get_index_in_lmap( start_cell );
2597 : 27628 : int nfpc = lConnMap3D[index].num_faces_in_cell;
2598 : :
2599 [ + - ]: 27628 : adjents.reserve( 4 );
2600 [ + - ]: 27628 : adjents.push_back( cid );
2601 : :
2602 [ + + ]: 27628 : if( lfids != NULL )
2603 : : {
2604 [ + - ]: 27500 : lfids->reserve( 4 );
2605 [ + - ]: 27500 : lfids->push_back( lfid );
2606 : : }
2607 : :
2608 [ + - ]: 27628 : int cidx = ID_FROM_HANDLE( cid ) - 1;
2609 [ + - ]: 27628 : HFacet hf = sibhfs[nfpc * cidx + lfid];
2610 [ + - ]: 27628 : EntityHandle sibcid = fid_from_halfacet( hf, ctype );
2611 [ + - ]: 27628 : int siblid = lid_from_halffacet( hf );
2612 : :
2613 [ + + ]: 27628 : if( sibcid != 0 )
2614 : : {
2615 [ + - ]: 23836 : adjents.push_back( sibcid );
2616 [ + + ][ + - ]: 23836 : if( lfids != NULL ) lfids->push_back( siblid );
2617 : : }
2618 : :
2619 : 27628 : return MB_SUCCESS;
2620 : : }
2621 : :
2622 : 0 : bool HalfFacetRep::find_matching_implicit_edge_in_cell( EntityHandle eid, std::vector< EntityHandle >& cid,
2623 : : std::vector< int >& leid )
2624 : : {
2625 : : ErrorCode error;
2626 [ # # ][ # # ]: 0 : EntityType ctype = mb->type_from_handle( *_cells.begin() );
[ # # ]
2627 [ # # ][ # # ]: 0 : EntityHandle start_cell = *_cells.begin();
2628 [ # # ]: 0 : int index = get_index_in_lmap( start_cell );
2629 : 0 : int nvpc = lConnMap3D[index].num_verts_in_cell;
2630 : 0 : int nfpc = lConnMap3D[index].num_faces_in_cell;
2631 : :
2632 : : // Find the edge vertices
2633 : : const EntityHandle* econn;
2634 : 0 : int num_conn = 0;
2635 [ # # ][ # # ]: 0 : error = mb->get_connectivity( eid, econn, num_conn, true );MB_CHK_ERR( error );
[ # # ][ # # ]
2636 : :
2637 : 0 : EntityHandle v_start = econn[0], v_end = econn[1];
2638 [ # # ]: 0 : int v1idx = ID_FROM_HANDLE( v_start ) - 1;
2639 [ # # ]: 0 : int v2idx = ID_FROM_HANDLE( v_end ) - 1;
2640 : :
2641 : : // Find an incident cell to v_start
2642 [ # # ]: 0 : std::vector< EntityHandle > start_cells;
2643 [ # # ]: 0 : HFacet hf1 = v2hf[v1idx];
2644 [ # # ]: 0 : HFacet hf2 = v2hf[v2idx];
2645 : :
2646 : 0 : int ncomps1 = 0, ncomps2 = 0, ncomp;
2647 [ # # ][ # # ]: 0 : if( hf1 == 0 && !v2hfs.empty() )
[ # # ]
2648 : : {
2649 : : std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
2650 [ # # ]: 0 : it_hes;
2651 [ # # ]: 0 : it_hes = v2hfs.equal_range( v_start );
2652 : :
2653 [ # # ][ # # ]: 0 : for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
[ # # ]
2654 : : {
2655 [ # # ][ # # ]: 0 : start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
[ # # ]
2656 : 0 : ncomps1 += 1;
2657 : : }
2658 : : }
2659 [ # # ]: 0 : else if( hf1 != 0 )
2660 : : {
2661 [ # # ][ # # ]: 0 : start_cells.push_back( fid_from_halfacet( hf1, ctype ) );
2662 : 0 : ncomps1 += 1;
2663 : : }
2664 : :
2665 [ # # ][ # # ]: 0 : if( hf2 == 0 && !v2hfs.empty() )
[ # # ]
2666 : : {
2667 : : std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
2668 [ # # ]: 0 : it_hes;
2669 [ # # ]: 0 : it_hes = v2hfs.equal_range( v_end );
2670 : :
2671 [ # # ][ # # ]: 0 : for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
[ # # ]
2672 : : {
2673 [ # # ][ # # ]: 0 : start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
[ # # ]
2674 : 0 : ncomps2 += 1;
2675 : : }
2676 : : }
2677 [ # # ]: 0 : else if( hf2 != 0 )
2678 : : {
2679 [ # # ][ # # ]: 0 : start_cells.push_back( fid_from_halfacet( hf2, ctype ) );
2680 : 0 : ncomps2 += 1;
2681 : : }
2682 : :
2683 [ # # ]: 0 : ncomp = std::min( ncomps1, ncomps2 );
2684 : :
2685 : 0 : bool found = false;
2686 [ # # ]: 0 : if( start_cells.empty() ) return found;
2687 : :
2688 [ # # ]: 0 : for( int i = 0; i < (int)start_cells.size(); i++ )
2689 [ # # ]: 0 : cellq[i] = start_cells[i];
2690 : :
2691 : 0 : int qsize = start_cells.size();
2692 : 0 : int num_qvals = 0;
2693 : :
2694 [ # # ]: 0 : while( num_qvals < qsize )
2695 : : {
2696 : 0 : EntityHandle cell_id = cellq[num_qvals];
2697 : 0 : num_qvals += 1;
2698 : :
2699 : : const EntityHandle* conn;
2700 [ # # ][ # # ]: 0 : error = mb->get_connectivity( cell_id, conn, nvpc, true );MB_CHK_ERR( error );
[ # # ][ # # ]
2701 : :
2702 : 0 : int lv0 = -1, lv1 = -1, lv = -1;
2703 : :
2704 : : // locate v_origin in poped out tet, check if v_end is in
2705 [ # # ]: 0 : for( int i = 0; i < nvpc; i++ )
2706 : : {
2707 [ # # ]: 0 : if( v_start == conn[i] )
2708 : : {
2709 : 0 : lv0 = i;
2710 : 0 : lv = lv0;
2711 : : }
2712 [ # # ]: 0 : else if( v_end == conn[i] )
2713 : : {
2714 : 0 : lv1 = i;
2715 : 0 : lv = lv1;
2716 : : }
2717 : : }
2718 : :
2719 [ # # ][ # # ]: 0 : if( ( lv0 >= 0 ) && ( lv1 >= 0 ) )
2720 : : {
2721 : 0 : found = true;
2722 [ # # ]: 0 : cid.push_back( cell_id );
2723 [ # # ]: 0 : leid.push_back( lConnMap3D[index].lookup_leids[lv0][lv1] );
2724 : :
2725 [ # # ]: 0 : if( (int)cid.size() == ncomp ) break;
2726 : : }
2727 : :
2728 : : // push back new found unchecked incident tets of v_start
2729 [ # # ]: 0 : int cidx = ID_FROM_HANDLE( cell_id ) - 1;
2730 : 0 : int nhf_thisv = lConnMap3D[index].v2hf_num[lv];
2731 [ # # ][ # # ]: 0 : if( lv < 0 ) MB_SET_ERR( MB_FAILURE, "did not find local vertex " );
[ # # ][ # # ]
[ # # ][ # # ]
2732 [ # # ]: 0 : for( int i = 0; i < nhf_thisv; i++ )
2733 : : {
2734 : 0 : int ind = lConnMap3D[index].v2hf[lv][i];
2735 [ # # ]: 0 : HFacet hf = sibhfs[nfpc * cidx + ind];
2736 [ # # ]: 0 : EntityHandle ngb = fid_from_halfacet( hf, ctype );
2737 : :
2738 [ # # ]: 0 : if( ngb )
2739 : : {
2740 [ # # ]: 0 : bool found_ent = find_match_in_array( ngb, &cellq[0], qsize - 1 );
2741 : :
2742 [ # # ]: 0 : if( !found_ent )
2743 : : {
2744 : 0 : cellq[qsize] = ngb;
2745 : 0 : qsize += 1;
2746 : : }
2747 : : }
2748 : : }
2749 : : }
2750 : :
2751 [ # # ]: 0 : for( int i = 0; i < qsize; i++ )
2752 : 0 : cellq[i] = 0;
2753 : :
2754 : 0 : return found;
2755 : : }
2756 : :
2757 : 128 : bool HalfFacetRep::find_matching_halfface( EntityHandle fid, EntityHandle* cid, int* lid )
2758 : : {
2759 : : ErrorCode error;
2760 [ + - ][ + - ]: 128 : EntityHandle start_cell = *_cells.begin();
2761 [ + - ]: 128 : EntityType ctype = mb->type_from_handle( start_cell );
2762 [ + - ]: 128 : int index = get_index_in_lmap( start_cell );
2763 : 128 : int nvpc = lConnMap3D[index].num_verts_in_cell;
2764 : 128 : int nfpc = lConnMap3D[index].num_faces_in_cell;
2765 [ + - ]: 128 : EntityType ftype = mb->type_from_handle( fid );
2766 : 128 : int nvF = lConnMap2D[ftype - 2].num_verts_in_face;
2767 : :
2768 : : const EntityHandle* fid_verts;
2769 [ + - ][ - + ]: 128 : error = mb->get_connectivity( fid, fid_verts, nvF, true );MB_CHK_ERR( error );
[ # # ][ # # ]
2770 : :
2771 [ + - ]: 128 : std::vector< EntityHandle > start_cells;
2772 : 128 : int vidx, locfv0 = -1;
2773 : 128 : HFacet hf = 0;
2774 : :
2775 [ + - ]: 128 : for( int i = 0; i < nvF; i++ )
2776 : : {
2777 [ + - ]: 128 : vidx = ID_FROM_HANDLE( fid_verts[i] ) - 1;
2778 [ + - ]: 128 : hf = v2hf[vidx];
2779 [ + - ]: 128 : if( hf != 0 )
2780 : : {
2781 [ + - ][ + - ]: 128 : start_cells.push_back( fid_from_halfacet( hf, ctype ) );
2782 : 128 : locfv0 = i;
2783 : 128 : break;
2784 : : }
2785 [ # # ][ # # ]: 0 : else if( hf == 0 && v2hfs.find( fid_verts[i] ) != v2hfs.end() )
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # #
# # ]
2786 : : {
2787 : : std::pair< std::multimap< EntityHandle, HFacet >::iterator,
2788 : : std::multimap< EntityHandle, HFacet >::iterator >
2789 [ # # ]: 0 : it_hfs;
2790 [ # # ]: 0 : it_hfs = v2hfs.equal_range( fid_verts[i] );
2791 : :
2792 [ # # ][ # # ]: 0 : for( std::multimap< EntityHandle, HFacet >::iterator it = it_hfs.first; it != it_hfs.second; ++it )
[ # # ]
2793 : : {
2794 [ # # ][ # # ]: 0 : start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
[ # # ]
2795 : : }
2796 : 0 : locfv0 = i;
2797 : 0 : break;
2798 : : }
2799 : : }
2800 : :
2801 [ - + ]: 128 : if( start_cells.empty() ) return false;
2802 : :
2803 : : EntityHandle cur_cid;
2804 : 128 : bool found = false;
2805 : :
2806 : 128 : int Stksize = 0, count = -1;
2807 : :
2808 [ + + ]: 256 : for( int i = 0; i < (int)start_cells.size(); i++ )
2809 [ + - ]: 128 : Stkcells[i] = start_cells[i];
2810 : :
2811 : 128 : Stksize = start_cells.size() - 1;
2812 : :
2813 [ + - ]: 270 : while( Stksize >= 0 )
2814 : : {
2815 : 270 : cur_cid = Stkcells[Stksize];
2816 : 270 : Stksize -= 1;
2817 : 270 : count += 1;
2818 : 270 : trackcells[count] = cur_cid;
2819 : :
2820 : : const EntityHandle* conn;
2821 [ + - ][ - + ]: 270 : error = mb->get_connectivity( cur_cid, conn, nvpc, true );MB_CHK_ERR( error );
[ # # ][ # # ]
2822 : :
2823 : 270 : int lv[4] = { -1, -1, -1, -1 };
2824 : 270 : int cnt = 0;
2825 [ + + ]: 2430 : for( int i = 0; i < nvpc; i++ )
2826 : : {
2827 [ + + ]: 10800 : for( int j = 0; j < nvF; j++ )
2828 [ + + ]: 8640 : if( conn[i] == fid_verts[j] )
2829 : : {
2830 : 751 : lv[j] = i;
2831 : 751 : cnt += 1;
2832 : : }
2833 : : }
2834 [ + + ]: 270 : if( cnt == nvF ) // All face verts are part of the cell
2835 : : {
2836 : 128 : found = true;
2837 : 128 : int nhf_thisv = lConnMap3D[index].v2hf_num[lv[locfv0]];
2838 : 128 : int lfid = -1;
2839 [ + - ]: 276 : for( int i = 0; i < nhf_thisv; ++i )
2840 : : {
2841 : 276 : lfid = lConnMap3D[index].v2hf[lv[locfv0]][i];
2842 : 276 : int lcnt = 0;
2843 [ + + ]: 1380 : for( int j = 0; j < nvF; ++j )
2844 : : {
2845 [ + + ]: 5520 : for( int k = 0; k < nvF; ++k )
2846 : : {
2847 [ + + ]: 4416 : if( lv[k] == lConnMap3D[index].hf2v[lfid][j] ) lcnt += 1;
2848 : : }
2849 : : }
2850 [ + + ]: 276 : if( lcnt == nvF ) break;
2851 : : }
2852 : 128 : cid[0] = cur_cid;
2853 : 128 : lid[0] = lfid;
2854 : :
2855 : 128 : break;
2856 : : }
2857 : : else
2858 : : {
2859 : : // Add other cells that are incident on fid_verts[0]
2860 [ + - ][ - + ]: 142 : if( locfv0 < 0 || lv[locfv0] < 0 ) MB_SET_ERR( MB_FAILURE, "did not find local vertex " );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2861 : 142 : int nhf_thisv = lConnMap3D[index].v2hf_num[lv[locfv0]];
2862 [ + - ]: 142 : int cidx = ID_FROM_HANDLE( cur_cid ) - 1;
2863 : :
2864 : : // Add new cells into the stack
2865 : : EntityHandle ngb;
2866 [ + + ]: 568 : for( int i = 0; i < nhf_thisv; ++i )
2867 : : {
2868 : 426 : int ind = lConnMap3D[index].v2hf[lv[locfv0]][i];
2869 [ + - ]: 426 : hf = sibhfs[nfpc * cidx + ind];
2870 [ + - ]: 426 : ngb = fid_from_halfacet( hf, ctype );
2871 : :
2872 [ + + ]: 426 : if( ngb )
2873 : : {
2874 : :
2875 [ + - ]: 343 : bool found_ent = find_match_in_array( ngb, trackcells, count );
2876 : :
2877 [ + + ]: 343 : if( !found_ent )
2878 : : {
2879 : 271 : Stksize += 1;
2880 : 343 : Stkcells[Stksize] = ngb;
2881 : : }
2882 : : }
2883 : : }
2884 : : }
2885 : : }
2886 : :
2887 : : // Change the visited faces to false
2888 [ + + ]: 182 : for( int i = 0; i < Stksize; i++ )
2889 : 54 : Stkcells[i] = 0;
2890 : :
2891 [ + + ]: 398 : for( int i = 0; i <= count; i++ )
2892 : 270 : trackcells[i] = 0;
2893 : :
2894 : 128 : return found;
2895 : : }
2896 : :
2897 : : ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2898 : 39712 : ErrorCode HalfFacetRep::get_neighbor_adjacencies_3d( EntityHandle cid, std::vector< EntityHandle >& adjents )
2899 : : {
2900 : 39712 : adjents.reserve( 20 );
2901 : 39712 : EntityType ctype = mb->type_from_handle( cid );
2902 : 39712 : int index = get_index_in_lmap( cid );
2903 : 39712 : int nfpc = lConnMap3D[index].num_faces_in_cell;
2904 : 39712 : int cidx = ID_FROM_HANDLE( cid ) - 1;
2905 : :
2906 [ + - ]: 39712 : if( cid != 0 )
2907 : : {
2908 [ + + ]: 238304 : for( int lfid = 0; lfid < nfpc; ++lfid )
2909 : : {
2910 [ + - ]: 198592 : HFacet hf = sibhfs[nfpc * cidx + lfid];
2911 [ + - ]: 198592 : EntityHandle sibcid = fid_from_halfacet( hf, ctype );
2912 [ + + ][ + - ]: 198592 : if( sibcid != 0 ) adjents.push_back( sibcid );
2913 : : }
2914 : : }
2915 : :
2916 : 39712 : return MB_SUCCESS;
2917 : : }
2918 : :
2919 : : /////////////////////////////////////////////////////////////////////////////////////////////////
2920 : 32 : ErrorCode HalfFacetRep::get_down_adjacencies_edg_3d( EntityHandle cid, std::vector< EntityHandle >& adjents )
2921 : : {
2922 : : // TODO: Try intersection without using std templates
2923 : : // Returns explicit edges, if any, of the face
2924 : : ErrorCode error;
2925 [ + - ]: 32 : adjents.reserve( 20 );
2926 [ + - ]: 32 : int index = get_index_in_lmap( cid );
2927 : 32 : int nvpc = lConnMap3D[index].num_verts_in_cell;
2928 : :
2929 : : const EntityHandle* conn;
2930 [ + - ][ - + ]: 32 : error = mb->get_connectivity( cid, conn, nvpc, true );MB_CHK_ERR( error );
[ # # ][ # # ]
2931 : :
2932 : : // Gather all the incident edges on each vertex of the face
2933 : 32 : int ns = lConnMap3D[index].search_everts[0];
2934 [ + - ]: 32 : std::vector< EntityHandle > temp;
2935 [ + + ]: 160 : for( int i = 0; i < ns; i++ )
2936 : : {
2937 : 128 : temp.clear();
2938 : 128 : int lv0 = lConnMap3D[index].search_everts[i + 1];
2939 [ + - ][ - + ]: 128 : error = get_up_adjacencies_1d( conn[lv0], temp );MB_CHK_ERR( error );
[ # # ][ # # ]
2940 : :
2941 : 128 : int nle = lConnMap3D[index].v2le[i][0];
2942 : 128 : int count = 0;
2943 [ + - ]: 554 : for( int j = 0; j < (int)temp.size(); j++ )
2944 : : {
2945 : : const EntityHandle* econn;
2946 : 554 : int nvpe = 0;
2947 [ + - ][ + - ]: 554 : error = mb->get_connectivity( temp[j], econn, nvpe, true );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
2948 : :
2949 [ + + ]: 2216 : for( int k = 0; k < nle; k++ )
2950 : : {
2951 : 1662 : int lv1 = lConnMap3D[index].v2le[i][k + 1];
2952 [ + + ][ + + ]: 1662 : if( ( ( econn[0] == conn[lv0] ) && ( econn[1] == conn[lv1] ) ) ||
[ + + ]
2953 [ + + ]: 912 : ( ( econn[1] == conn[lv0] ) && ( econn[0] == conn[lv1] ) ) )
2954 : : {
2955 [ + - ][ + - ]: 384 : adjents.push_back( temp[j] );
2956 : 384 : count += 1;
2957 : : }
2958 : : }
2959 [ + + ]: 554 : if( count == nle ) break;
2960 : : }
2961 : : }
2962 : 32 : return MB_SUCCESS;
2963 : : }
2964 : :
2965 : 32 : ErrorCode HalfFacetRep::get_down_adjacencies_face_3d( EntityHandle cid, std::vector< EntityHandle >& adjents )
2966 : : {
2967 : : // Returns explicit face, if any of the cell
2968 : : ErrorCode error;
2969 [ + - ]: 32 : adjents.reserve( 10 );
2970 [ + - ]: 32 : int index = get_index_in_lmap( cid );
2971 : 32 : int nvpc = lConnMap3D[index].num_verts_in_cell;
2972 : 32 : int nfpc = lConnMap3D[index].num_faces_in_cell;
2973 : :
2974 : : // Get the connectivity of the input cell
2975 : : const EntityHandle* conn;
2976 [ + - ][ - + ]: 32 : error = mb->get_connectivity( cid, conn, nvpc, true );MB_CHK_ERR( error );
[ # # ][ # # ]
2977 : :
2978 : : // Collect all the half-faces of the cell
2979 : : EntityHandle half_faces[6][4];
2980 [ + + ]: 224 : for( int i = 0; i < nfpc; i++ )
2981 : : {
2982 : 192 : int nvf = lConnMap3D[index].hf2v_num[i];
2983 [ + + ]: 960 : for( int j = 0; j < nvf; j++ )
2984 : : {
2985 : 768 : int ind = lConnMap3D[index].hf2v[i][j];
2986 : 768 : half_faces[i][j] = conn[ind];
2987 : : }
2988 : : }
2989 : :
2990 : : // Add two vertices for which the upward adjacencies are computed
2991 : : int search_verts[2];
2992 : 32 : search_verts[0] = lConnMap3D[index].search_fverts[0];
2993 : 32 : search_verts[1] = lConnMap3D[index].search_fverts[1];
2994 : :
2995 [ + - ]: 32 : std::vector< EntityHandle > temp;
2996 [ + - ]: 32 : temp.reserve( 20 );
2997 [ + + ]: 96 : for( int i = 0; i < 2; i++ )
2998 : : {
2999 : : // Get the incident faces on the local vertex
3000 : 64 : int lv = search_verts[i];
3001 : 64 : temp.clear();
3002 [ + - ][ - + ]: 64 : error = get_up_adjacencies_vert_2d( conn[lv], temp );MB_CHK_ERR( error );
[ # # ][ # # ]
3003 : :
3004 [ - + ]: 64 : if( temp.size() == 0 ) continue;
3005 : :
3006 : : // Get the half-faces incident on the local vertex and match it with the obtained faces
3007 : 64 : int nhfthisv = lConnMap3D[index].v2hf_num[lv];
3008 [ + + ]: 596 : for( int k = 0; k < (int)temp.size(); k++ )
3009 : : {
3010 : : const EntityHandle* fid_verts;
3011 : 532 : int fsize = 0;
3012 [ + - ][ + - ]: 532 : error = mb->get_connectivity( temp[k], fid_verts, fsize, true );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
3013 : :
3014 [ + + ]: 2128 : for( int j = 0; j < nhfthisv; j++ )
3015 : : {
3016 : : // Collect all the vertices of this half-face
3017 : 1596 : int idx = lConnMap3D[index].v2hf[lv][j];
3018 : 1596 : int nvF = lConnMap3D[index].hf2v_num[idx];
3019 : :
3020 [ - + ]: 1596 : if( fsize != nvF ) continue;
3021 : :
3022 : : int direct, offset;
3023 [ + - ]: 1596 : bool they_match = CN::ConnectivityMatch( &half_faces[idx][0], &fid_verts[0], nvF, direct, offset );
3024 : :
3025 [ + + ]: 1596 : if( they_match )
3026 : : {
3027 : 192 : bool found = false;
3028 [ + + ]: 672 : for( int p = 0; p < (int)adjents.size(); p++ )
3029 : : {
3030 [ + - ][ + - ]: 480 : if( adjents[p] == temp[k] )
[ - + ]
3031 : : {
3032 : 0 : found = true;
3033 : 0 : break;
3034 : : }
3035 : : }
3036 [ + - ][ + - ]: 1596 : if( !found ) adjents.push_back( temp[k] );
[ + - ]
3037 : : }
3038 : : }
3039 : : }
3040 : : }
3041 : :
3042 : 32 : return MB_SUCCESS;
3043 : : }
3044 : : ////////////////////////////////////////////////////////////////////////////////
3045 : 16 : ErrorCode HalfFacetRep::find_total_edges_faces_3d( Range cells, int* nedges, int* nfaces )
3046 : : {
3047 : : ErrorCode error;
3048 [ + - ][ + - ]: 16 : int index = get_index_in_lmap( *cells.begin() );
[ + - ]
3049 : 16 : int nepc = lConnMap3D[index].num_edges_in_cell;
3050 : 16 : int nfpc = lConnMap3D[index].num_faces_in_cell;
3051 [ + - ]: 16 : int ncells = cells.size();
3052 : 16 : int total_edges = nepc * ncells;
3053 : 16 : int total_faces = nfpc * ncells;
3054 : :
3055 [ + - ]: 16 : std::vector< int > trackE( total_edges, 0 );
3056 [ + - ]: 32 : std::vector< int > trackF( total_faces, 0 );
3057 : :
3058 [ + - ][ + - ]: 32 : std::vector< EntityHandle > inc_cids, sib_cids;
3059 [ + - ][ + - ]: 32 : std::vector< int > inc_leids, sib_lfids;
3060 : :
3061 [ + - ][ + - ]: 4786 : for( Range::iterator it = cells.begin(); it != cells.end(); ++it )
[ + - ][ + - ]
[ + + ]
3062 : : {
3063 : : // Count edges
3064 [ + + ]: 47700 : for( int i = 0; i < nepc; i++ )
3065 : : {
3066 : 42930 : inc_cids.clear();
3067 : 42930 : inc_leids.clear();
3068 : :
3069 [ + - ][ + - ]: 42930 : int id = nepc * ( cells.index( *it ) ) + i;
3070 [ + - ][ + + ]: 42930 : if( !trackE[id] )
3071 : : {
3072 [ + - ][ + - ]: 12109 : error = get_up_adjacencies_edg_3d( *it, i, inc_cids, &inc_leids );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
3073 : :
3074 : 12109 : total_edges -= inc_cids.size() - 1;
3075 [ + + ]: 55039 : for( int j = 0; j < (int)inc_cids.size(); j++ )
3076 [ + - ][ + - ]: 42930 : trackE[nepc * ( cells.index( inc_cids[j] ) ) + inc_leids[j]] = 1;
[ + - ][ + - ]
3077 : : }
3078 : : }
3079 : :
3080 : : // Count faces
3081 [ + + ]: 28620 : for( int i = 0; i < nfpc; i++ )
3082 : : {
3083 : 23850 : sib_cids.clear();
3084 : 23850 : sib_lfids.clear();
3085 : :
3086 [ + - ][ + - ]: 23850 : int id = nfpc * ( cells.index( *it ) ) + i;
3087 [ + - ][ + + ]: 23850 : if( !trackF[id] )
3088 : : {
3089 [ + - ][ + - ]: 13030 : error = get_up_adjacencies_face_3d( *it, i, sib_cids, &sib_lfids );MB_CHK_ERR( error );
[ - + ][ # # ]
[ # # ]
3090 : :
3091 [ + + ]: 13030 : if( sib_cids.size() == 1 ) continue;
3092 : :
3093 : 10820 : total_faces -= sib_cids.size() - 1;
3094 [ + - ][ + - ]: 10820 : trackF[nfpc * ( cells.index( sib_cids[1] ) ) + sib_lfids[1]] = 1;
[ + - ][ + - ]
3095 : : }
3096 : : }
3097 : : }
3098 : :
3099 : 16 : nedges[0] = total_edges;
3100 : 16 : nfaces[0] = total_faces;
3101 : :
3102 : 32 : return MB_SUCCESS;
3103 : : }
3104 : :
3105 : 18306651 : bool HalfFacetRep::find_match_in_array( EntityHandle ent, EntityHandle* ent_list, int count, bool get_index,
3106 : : int* index )
3107 : : {
3108 : 18306651 : bool found = false;
3109 [ + + ]: 89251768 : for( int i = 0; i <= count; i++ )
3110 : : {
3111 [ + + ]: 77644254 : if( ent == ent_list[i] )
3112 : : {
3113 : 6699137 : found = true;
3114 [ + + ]: 6699137 : if( get_index ) *index = i;
3115 : 6699137 : break;
3116 : : }
3117 : : }
3118 : :
3119 : 18306651 : return found;
3120 : : }
3121 : :
3122 : 0 : ErrorCode HalfFacetRep::get_half_facet_in_comp( EntityHandle cid, int leid, std::vector< EntityHandle >& ents,
3123 : : std::vector< int >& lids, std::vector< int >& lfids )
3124 : : {
3125 : : ErrorCode error;
3126 : 0 : ents.clear();
3127 : 0 : lids.clear();
3128 [ # # ]: 0 : EntityType ctype = mb->type_from_handle( cid );
3129 [ # # ][ # # ]: 0 : int index = get_index_in_lmap( *_cells.begin() );
[ # # ]
3130 : 0 : int nfpc = lConnMap3D[index].num_faces_in_cell;
3131 : 0 : int nvpc = lConnMap3D[index].num_verts_in_cell;
3132 : :
3133 : : // Get all incident cells
3134 [ # # ]: 0 : std::vector< EntityHandle > adjents;
3135 [ # # ]: 0 : std::vector< int > adjlids;
3136 [ # # ][ # # ]: 0 : error = get_up_adjacencies_edg_3d( cid, leid, adjents, &adjlids );MB_CHK_ERR( error );
[ # # ][ # # ]
3137 : :
3138 : : // Get the end vertices of the edge <cid,leid>
3139 : : const EntityHandle* econn;
3140 [ # # ][ # # ]: 0 : error = mb->get_connectivity( cid, econn, nvpc, true );MB_CHK_ERR( error );
[ # # ][ # # ]
3141 : 0 : int id = lConnMap3D[index].e2v[leid][0];
3142 : 0 : EntityHandle vstart = econn[id];
3143 : 0 : id = lConnMap3D[index].e2v[leid][1];
3144 : 0 : EntityHandle vend = econn[id];
3145 : :
3146 [ # # ]: 0 : std::vector< int > mark( adjents.size(), 0 );
3147 : 0 : int count = 0;
3148 : :
3149 [ # # ]: 0 : for( int k = 0; k < (int)adjents.size(); k++ )
3150 : : {
3151 : :
3152 [ # # ][ # # ]: 0 : if( mark[k] != 0 ) continue;
3153 : :
3154 : 0 : count += 1;
3155 [ # # ]: 0 : mark[k] = count;
3156 : :
3157 : : // Loop over each half-face incident on this local edge
3158 [ # # ]: 0 : for( int i = 0; i < 2; i++ )
3159 : : {
3160 [ # # ]: 0 : EntityHandle cur_cell = adjents[k];
3161 [ # # ]: 0 : int cur_leid = adjlids[k];
3162 : :
3163 : 0 : int lface = i;
3164 : :
3165 : : while( true )
3166 : : {
3167 [ # # ]: 0 : int cidx = ID_FROM_HANDLE( cur_cell ) - 1;
3168 : 0 : int lfid = lConnMap3D[index].e2hf[cur_leid][lface];
3169 : :
3170 [ # # ]: 0 : HFacet hf = sibhfs[nfpc * cidx + lfid];
3171 [ # # ]: 0 : cur_cell = fid_from_halfacet( hf, ctype );
3172 [ # # ]: 0 : lfid = lid_from_halffacet( hf );
3173 : :
3174 : : // Check if loop reached starting cell or a boundary
3175 [ # # ][ # # ]: 0 : if( ( cur_cell == adjents[k] ) || ( cur_cell == 0 ) ) break;
[ # # ][ # # ]
3176 : :
3177 : : const EntityHandle* sib_conn;
3178 [ # # ][ # # ]: 0 : error = mb->get_connectivity( cur_cell, sib_conn, nvpc, true );MB_CHK_ERR( error );
[ # # ][ # # ]
3179 : :
3180 : : // Find the local edge id wrt to sibhf
3181 : 0 : int nv_curF = lConnMap3D[index].hf2v_num[lfid];
3182 : 0 : int lv0 = -1, lv1 = -1, idx = -1;
3183 [ # # ]: 0 : for( int j = 0; j < nv_curF; j++ )
3184 : : {
3185 : 0 : idx = lConnMap3D[index].hf2v[lfid][j];
3186 [ # # ]: 0 : if( vstart == sib_conn[idx] ) lv0 = idx;
3187 [ # # ]: 0 : if( vend == sib_conn[idx] ) lv1 = idx;
3188 : : }
3189 : :
3190 [ # # ][ # # ]: 0 : assert( ( lv0 >= 0 ) && ( lv1 >= 0 ) );
3191 : 0 : cur_leid = lConnMap3D[index].lookup_leids[lv0][lv1];
3192 : :
3193 : 0 : int chk_lfid = lConnMap3D[index].e2hf[cur_leid][0];
3194 : :
3195 [ # # ]: 0 : if( lfid == chk_lfid )
3196 : 0 : lface = 1;
3197 : : else
3198 : 0 : lface = 0;
3199 : :
3200 [ # # ][ # # ]: 0 : int ind = std::find( adjents.begin(), adjents.end(), cur_cell ) - adjents.begin();
3201 [ # # ]: 0 : mark[ind] = count;
3202 : : }
3203 : :
3204 : : // Loop back
3205 [ # # ]: 0 : if( cur_cell != 0 ) break;
3206 : 0 : }
3207 : : }
3208 : :
3209 : : // Loop over again to find cells on the boundary
3210 [ # # ]: 0 : for( int c = 0; c < count; c++ )
3211 : : {
3212 [ # # ]: 0 : for( int i = 0; i < (int)adjents.size(); i++ )
3213 : : {
3214 [ # # ][ # # ]: 0 : if( mark[i] == c + 1 )
3215 : : {
3216 [ # # ][ # # ]: 0 : int cidx = ID_FROM_HANDLE( adjents[i] ) - 1;
3217 [ # # ]: 0 : for( int j = 0; j < nfpc; j++ )
3218 : : {
3219 [ # # ]: 0 : HFacet hf = sibhfs[nfpc * cidx + j];
3220 [ # # ]: 0 : EntityHandle cell = fid_from_halfacet( hf, ctype );
3221 [ # # ]: 0 : if( cell == 0 )
3222 : : {
3223 [ # # ][ # # ]: 0 : ents.push_back( adjents[i] );
3224 [ # # ][ # # ]: 0 : lids.push_back( adjlids[i] );
3225 [ # # ]: 0 : lfids.push_back( j );
3226 : 0 : break;
3227 : : }
3228 : : }
3229 : : }
3230 : : }
3231 : : }
3232 : :
3233 : 0 : return MB_SUCCESS;
3234 : : }
3235 : :
3236 : : ///////////////////////////////////////////////////////////////////////////////////////////
3237 : 48 : ErrorCode HalfFacetRep::resize_hf_maps( EntityHandle start_vert, int nverts, EntityHandle start_edge, int nedges,
3238 : : EntityHandle start_face, int nfaces, EntityHandle start_cell, int ncells )
3239 : : {
3240 : 48 : int nwsz = 0, insz = 0;
3241 [ + + ]: 48 : if( nedges )
3242 : : {
3243 [ + - ][ + - ]: 10 : if( ID_FROM_HANDLE( ( *( _edges.end() - 1 ) + 1 ) ) != ID_FROM_HANDLE( start_edge ) )
[ + - ][ + - ]
[ - + ]
3244 [ # # ][ # # ]: 0 : nwsz = ( ID_FROM_HANDLE( start_edge ) - ID_FROM_HANDLE( *_edges.end() ) + nedges ) * 2;
3245 : : else
3246 : 10 : nwsz = nedges * 2;
3247 : 10 : insz = sibhvs.size();
3248 [ + - ]: 10 : sibhvs.resize( insz + nwsz, 0 );
3249 : :
3250 [ - + ]: 10 : if( v2hv.empty() )
3251 : : {
3252 [ # # ]: 0 : if( ( !v2he.empty() ) )
3253 : 0 : insz = v2he.size();
3254 [ # # ]: 0 : else if( ( !v2hf.empty() ) )
3255 : 0 : insz = v2hf.size();
3256 : : else
3257 [ # # ][ # # ]: 0 : MB_SET_ERR( MB_FAILURE, "Trying to resize ahf maps for a mesh with no edges, faces and cells" );
[ # # ][ # # ]
[ # # ]
3258 : : }
3259 : : else
3260 : 10 : insz = v2hv.size();
3261 : :
3262 [ + - ][ + - ]: 10 : if( ID_FROM_HANDLE( *( _verts.end() - 1 ) + 1 ) != ID_FROM_HANDLE( start_vert ) )
[ + - ][ + - ]
[ - + ]
3263 [ # # ][ # # ]: 0 : nwsz = ID_FROM_HANDLE( start_vert ) - ID_FROM_HANDLE( *_verts.end() ) + nverts;
3264 : : else
3265 : 10 : nwsz = nverts;
3266 [ + - ]: 10 : v2hv.resize( insz + nwsz, 0 );
3267 : : }
3268 : :
3269 [ + + ]: 48 : if( nfaces )
3270 : : {
3271 [ + - ][ + - ]: 22 : EntityType ftype = mb->type_from_handle( *_faces.begin() );
3272 : 22 : int nepf = lConnMap2D[ftype - 2].num_verts_in_face;
3273 : :
3274 [ + - ][ + - ]: 22 : if( ID_FROM_HANDLE( ( *( _faces.end() - 1 ) + 1 ) ) != ID_FROM_HANDLE( start_face ) )
[ + - ][ + - ]
[ - + ]
3275 [ # # ][ # # ]: 0 : nwsz = ( ID_FROM_HANDLE( start_face ) - ID_FROM_HANDLE( *_faces.end() ) + nfaces ) * nepf;
3276 : : else
3277 : 22 : nwsz = nfaces * nepf;
3278 : 22 : insz = sibhes.size();
3279 [ + - ]: 22 : sibhes.resize( insz + nwsz, 0 );
3280 : :
3281 [ + - ][ + - ]: 22 : if( ID_FROM_HANDLE( *( _verts.end() - 1 ) + 1 ) != ID_FROM_HANDLE( start_vert ) )
[ + - ][ + - ]
[ - + ]
3282 [ # # ][ # # ]: 0 : nwsz = ID_FROM_HANDLE( start_vert ) - ID_FROM_HANDLE( *_verts.end() ) + nverts;
3283 : : else
3284 : 22 : nwsz = nverts;
3285 : 22 : insz = v2he.size();
3286 [ + - ]: 22 : v2he.resize( insz + nwsz, 0 );
3287 : : }
3288 : :
3289 [ + + ]: 48 : if( ncells )
3290 : : {
3291 [ + - ][ + - ]: 16 : int index = get_index_in_lmap( *_cells.begin() );
3292 : 16 : int nfpc = lConnMap3D[index].num_faces_in_cell;
3293 : :
3294 [ + - ][ + - ]: 16 : if( ID_FROM_HANDLE( ( *( _cells.end() - 1 ) + 1 ) ) != ID_FROM_HANDLE( start_cell ) )
[ + - ][ + - ]
[ - + ]
3295 [ # # ][ # # ]: 0 : nwsz = ( ID_FROM_HANDLE( start_cell ) - ID_FROM_HANDLE( *_cells.end() ) + ncells ) * nfpc;
3296 : : else
3297 : 16 : nwsz = ncells * nfpc;
3298 : 16 : insz = sibhfs.size();
3299 [ + - ]: 16 : sibhfs.resize( insz + nwsz, 0 );
3300 : :
3301 [ + - ][ + - ]: 16 : if( ID_FROM_HANDLE( *( _verts.end() - 1 ) + 1 ) != ID_FROM_HANDLE( start_vert ) )
[ + - ][ + - ]
[ - + ]
3302 [ # # ][ # # ]: 0 : nwsz = ID_FROM_HANDLE( start_vert ) - ID_FROM_HANDLE( *_verts.end() ) + nverts;
3303 : : else
3304 : 16 : nwsz = nverts;
3305 : 16 : insz = v2hf.size();
3306 [ + - ]: 16 : v2hf.resize( insz + nwsz, 0 );
3307 : : }
3308 : :
3309 : 48 : return MB_SUCCESS;
3310 : : }
3311 : :
3312 : 0 : bool HalfFacetRep::check_nonmanifold_vertices( EntityType type, EntityHandle vid )
3313 : : {
3314 : 0 : bool status = false;
3315 [ # # ][ # # ]: 0 : if( type == MBTRI || type == MBQUAD )
3316 : : {
3317 : 0 : HFacet hf = v2he[ID_FROM_HANDLE( vid ) - 1];
3318 [ # # ][ # # ]: 0 : if( hf == 0 && ( v2hes.find( vid ) != v2hes.end() ) ) status = true;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
[ # # # # ]
3319 : : }
3320 [ # # ][ # # ]: 0 : else if( type == MBTET || type == MBHEX )
3321 : : {
3322 : 0 : HFacet hf = v2hf[ID_FROM_HANDLE( vid ) - 1];
3323 [ # # ][ # # ]: 0 : if( hf == 0 && ( v2hfs.find( vid ) != v2hfs.end() ) ) status = true;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
[ # # # # ]
3324 : : }
3325 : : else
3326 [ # # ][ # # ]: 0 : MB_SET_ERR( MB_FAILURE, "Requesting non-manifold vertex checks for either (1) 1D mesh or "
[ # # ][ # # ]
[ # # ]
3327 : : "(2) not-implemented entity types" );
3328 : :
3329 : 0 : return status;
3330 : : }
3331 : :
3332 : 89543 : ErrorCode HalfFacetRep::get_sibling_map( EntityType type, EntityHandle ent, EntityHandle* sib_entids, int* sib_lids,
3333 : : int num_halffacets )
3334 : : {
3335 : :
3336 [ + + ]: 89543 : if( type == MBEDGE )
3337 : : {
3338 [ - + ][ # # ]: 4537 : if( num_halffacets != 2 ) MB_SET_ERR( MB_FAILURE, "Incorrect number of halfvertices." );
[ # # ][ # # ]
[ # # ][ # # ]
3339 : :
3340 : 4537 : int eidx = ID_FROM_HANDLE( ent ) - 1;
3341 [ + + ]: 13611 : for( int i = 0; i < 2; i++ )
3342 : : {
3343 : 9074 : HFacet hf = sibhvs[2 * eidx + i];
3344 : 9074 : sib_entids[i] = fid_from_halfacet( hf, MBEDGE );
3345 : 9074 : sib_lids[i] = lid_from_halffacet( hf );
3346 : : }
3347 : : }
3348 [ + + ][ + + ]: 85006 : else if( type == MBTRI || type == MBQUAD )
3349 : : {
3350 : 40556 : int nepf = lConnMap2D[type - 2].num_verts_in_face;
3351 : :
3352 [ - + ][ # # ]: 40556 : if( num_halffacets != nepf ) MB_SET_ERR( MB_FAILURE, "Incorrect number of halfedges." );
[ # # ][ # # ]
[ # # ][ # # ]
3353 : :
3354 : 40556 : int fidx = ID_FROM_HANDLE( ent ) - 1;
3355 [ + + ]: 170601 : for( int i = 0; i < nepf; i++ )
3356 : : {
3357 : 130045 : HFacet hf = sibhes[nepf * fidx + i];
3358 : 130045 : sib_entids[i] = fid_from_halfacet( hf, type );
3359 : 130045 : sib_lids[i] = lid_from_halffacet( hf );
3360 : 40556 : }
3361 : : }
3362 : : else
3363 : : {
3364 [ + - ][ + - ]: 44450 : int idx = get_index_in_lmap( *_cells.begin() );
3365 : 44450 : int nfpc = lConnMap3D[idx].num_faces_in_cell;
3366 : :
3367 [ - + ][ # # ]: 44450 : if( num_halffacets != nfpc ) MB_SET_ERR( MB_FAILURE, "Incorrect number of halffaces." );
[ # # ][ # # ]
[ # # ][ # # ]
3368 : :
3369 : 44450 : int cidx = ID_FROM_HANDLE( ent ) - 1;
3370 [ + + ]: 266700 : for( int i = 0; i < nfpc; i++ )
3371 : : {
3372 : 222250 : HFacet hf = sibhfs[nfpc * cidx + i];
3373 : 222250 : sib_entids[i] = fid_from_halfacet( hf, type );
3374 : 222250 : sib_lids[i] = lid_from_halffacet( hf );
3375 : : }
3376 : : }
3377 : 89543 : return MB_SUCCESS;
3378 : : }
3379 : :
3380 : 127222 : ErrorCode HalfFacetRep::get_sibling_map( EntityType type, EntityHandle ent, int lid, EntityHandle& sib_entid,
3381 : : int& sib_lid )
3382 : : {
3383 : :
3384 [ - + ]: 127222 : if( type == MBEDGE )
3385 : : {
3386 : 0 : int eidx = ID_FROM_HANDLE( ent ) - 1;
3387 : 0 : HFacet hf = sibhvs[2 * eidx + lid];
3388 : 0 : sib_entid = fid_from_halfacet( hf, MBEDGE );
3389 : 0 : sib_lid = lid_from_halffacet( hf );
3390 : : }
3391 [ + + ][ + + ]: 127222 : else if( type == MBTRI || type == MBQUAD )
3392 : : {
3393 : 39342 : int nepf = lConnMap2D[type - 2].num_verts_in_face;
3394 : 39342 : int fidx = ID_FROM_HANDLE( ent ) - 1;
3395 : 39342 : HFacet hf = sibhes[nepf * fidx + lid];
3396 : 39342 : sib_entid = fid_from_halfacet( hf, type );
3397 : 39342 : sib_lid = lid_from_halffacet( hf );
3398 : : }
3399 : : else
3400 : : {
3401 [ + - ][ + - ]: 87880 : int idx = get_index_in_lmap( *_cells.begin() );
3402 : 87880 : int nfpc = lConnMap3D[idx].num_faces_in_cell;
3403 : 87880 : int cidx = ID_FROM_HANDLE( ent ) - 1;
3404 : 87880 : HFacet hf = sibhfs[nfpc * cidx + lid];
3405 : 87880 : sib_entid = fid_from_halfacet( hf, type );
3406 : 87880 : sib_lid = lid_from_halffacet( hf );
3407 : : }
3408 : 127222 : return MB_SUCCESS;
3409 : : }
3410 : :
3411 : 78374 : ErrorCode HalfFacetRep::set_sibling_map( EntityType type, EntityHandle ent, EntityHandle* set_entids, int* set_lids,
3412 : : int num_halffacets )
3413 : : {
3414 : :
3415 [ + + ]: 78374 : if( type == MBEDGE )
3416 : : {
3417 [ - + ][ # # ]: 3682 : if( num_halffacets != 2 ) MB_SET_ERR( MB_FAILURE, "Incorrect number of halfvertices" );
[ # # ][ # # ]
[ # # ][ # # ]
3418 : :
3419 : 3682 : int eidx = ID_FROM_HANDLE( ent ) - 1;
3420 [ + + ]: 11046 : for( int i = 0; i < 2; i++ )
3421 : : {
3422 : 7364 : sibhvs[2 * eidx + i] = create_halffacet( set_entids[i], set_lids[i] );
3423 : : }
3424 : : }
3425 [ + + ][ + + ]: 74692 : else if( type == MBTRI || type == MBQUAD )
3426 : : {
3427 : 35012 : int nepf = lConnMap2D[type - 2].num_verts_in_face;
3428 [ - + ][ # # ]: 35012 : if( num_halffacets != nepf ) MB_SET_ERR( MB_FAILURE, "Incorrect number of halfedges." );
[ # # ][ # # ]
[ # # ][ # # ]
3429 : :
3430 : 35012 : int fidx = ID_FROM_HANDLE( ent ) - 1;
3431 [ + + ]: 147878 : for( int i = 0; i < nepf; i++ )
3432 : : {
3433 : 112866 : sibhes[nepf * fidx + i] = create_halffacet( set_entids[i], set_lids[i] );
3434 : 35012 : }
3435 : : }
3436 : : else
3437 : : {
3438 [ + - ][ + - ]: 39680 : int idx = get_index_in_lmap( *_cells.begin() );
3439 : 39680 : int nfpc = lConnMap3D[idx].num_faces_in_cell;
3440 [ - + ][ # # ]: 39680 : if( num_halffacets != nfpc ) MB_SET_ERR( MB_FAILURE, "Incorrect number of halffaces." );
[ # # ][ # # ]
[ # # ][ # # ]
3441 : :
3442 : 39680 : int cidx = ID_FROM_HANDLE( ent ) - 1;
3443 [ + + ]: 238080 : for( int i = 0; i < nfpc; i++ )
3444 : : {
3445 : 198400 : sibhfs[nfpc * cidx + i] = create_halffacet( set_entids[i], set_lids[i] );
3446 : : }
3447 : : }
3448 : :
3449 : 78374 : return MB_SUCCESS;
3450 : : }
3451 : :
3452 : 302630 : ErrorCode HalfFacetRep::set_sibling_map( EntityType type, EntityHandle ent, int lid, EntityHandle& set_entid,
3453 : : int& set_lid )
3454 : : {
3455 : :
3456 [ + + ]: 302630 : if( type == MBEDGE )
3457 : : {
3458 : 2270 : int eidx = ID_FROM_HANDLE( ent ) - 1;
3459 : 2270 : sibhvs[2 * eidx + lid] = create_halffacet( set_entid, set_lid );
3460 : : }
3461 [ + + ][ + + ]: 300360 : else if( type == MBTRI || type == MBQUAD )
3462 : : {
3463 : 111480 : int nepf = lConnMap2D[type - 2].num_verts_in_face;
3464 : 111480 : int fidx = ID_FROM_HANDLE( ent ) - 1;
3465 : 111480 : sibhes[nepf * fidx + lid] = create_halffacet( set_entid, set_lid );
3466 : : }
3467 : : else
3468 : : {
3469 [ + - ][ + - ]: 188880 : int idx = get_index_in_lmap( *_cells.begin() );
3470 : 188880 : int nfpc = lConnMap3D[idx].num_faces_in_cell;
3471 : 188880 : int cidx = ID_FROM_HANDLE( ent ) - 1;
3472 : 188880 : sibhfs[nfpc * cidx + lid] = create_halffacet( set_entid, set_lid );
3473 : : }
3474 : :
3475 : 302630 : return MB_SUCCESS;
3476 : : }
3477 : :
3478 : 186607 : ErrorCode HalfFacetRep::get_incident_map( EntityType type, EntityHandle vid, std::vector< EntityHandle >& inci_entid,
3479 : : std::vector< int >& inci_lid )
3480 : : {
3481 : 186607 : inci_entid.clear();
3482 : 186607 : inci_lid.clear();
3483 : :
3484 [ + + ]: 186607 : if( type == MBEDGE )
3485 : : {
3486 : 1996 : HFacet hf = v2hv[ID_FROM_HANDLE( vid ) - 1];
3487 [ + - ]: 1996 : inci_entid.push_back( fid_from_halfacet( hf, type ) );
3488 [ + - ]: 1996 : inci_lid.push_back( lid_from_halffacet( hf ) );
3489 : : }
3490 [ + + ][ + + ]: 184611 : else if( type == MBTRI || type == MBQUAD )
3491 : : {
3492 : 33381 : HFacet hf = v2he[ID_FROM_HANDLE( vid ) - 1];
3493 [ + + ][ + - ]: 33381 : if( hf == 0 && ( v2hes.find( vid ) != v2hes.end() ) )
[ + - ][ - + ]
[ + + ][ + + ]
[ - + # #
# # ]
3494 : : {
3495 : : std::pair< std::multimap< EntityHandle, HFacet >::iterator,
3496 : : std::multimap< EntityHandle, HFacet >::iterator >
3497 [ # # ]: 0 : it_hes;
3498 [ # # ]: 0 : it_hes = v2hes.equal_range( vid );
3499 : :
3500 [ # # ][ # # ]: 0 : for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
[ # # ]
3501 : : {
3502 [ # # ][ # # ]: 0 : inci_entid.push_back( fid_from_halfacet( it->second, type ) );
[ # # ]
3503 [ # # ][ # # ]: 0 : inci_lid.push_back( lid_from_halffacet( it->second ) );
[ # # ]
3504 : : }
3505 : : }
3506 [ + + ]: 33381 : else if( hf != 0 )
3507 : : {
3508 [ + - ]: 14622 : inci_entid.push_back( fid_from_halfacet( hf, type ) );
3509 [ + - ]: 14622 : inci_lid.push_back( lid_from_halffacet( hf ) );
3510 : : }
3511 [ + - ][ + - ]: 18759 : else if( hf == 0 && ( v2hes.find( vid ) == v2hes.end() ) )
[ + - ][ + - ]
[ + - ][ + - ]
[ + - # #
# # ]
3512 : : {
3513 [ + - ]: 18759 : inci_entid.push_back( fid_from_halfacet( hf, type ) );
3514 [ + - ]: 18759 : inci_lid.push_back( lid_from_halffacet( hf ) );
3515 : 33381 : }
3516 : : }
3517 : : else
3518 : : {
3519 : 151230 : HFacet hf = v2hf[ID_FROM_HANDLE( vid ) - 1];
3520 [ + + ][ + - ]: 151230 : if( hf == 0 && ( v2hfs.find( vid ) != v2hfs.end() ) )
[ + - ][ - + ]
[ + + ][ + + ]
[ - + # #
# # ]
3521 : : {
3522 : : std::pair< std::multimap< EntityHandle, HFacet >::iterator,
3523 : : std::multimap< EntityHandle, HFacet >::iterator >
3524 [ # # ]: 0 : it_hes;
3525 [ # # ]: 0 : it_hes = v2hfs.equal_range( vid );
3526 : :
3527 [ # # ][ # # ]: 0 : for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
[ # # ]
3528 : : {
3529 [ # # ][ # # ]: 0 : inci_entid.push_back( fid_from_halfacet( it->second, type ) );
[ # # ]
3530 [ # # ][ # # ]: 0 : inci_lid.push_back( lid_from_halffacet( it->second ) );
[ # # ]
3531 : : }
3532 : : }
3533 [ + + ]: 151230 : else if( hf != 0 )
3534 : : {
3535 [ + - ]: 127655 : inci_entid.push_back( fid_from_halfacet( hf, type ) );
3536 [ + - ]: 127655 : inci_lid.push_back( lid_from_halffacet( hf ) );
3537 : : }
3538 [ + - ][ + - ]: 23575 : else if( hf == 0 && ( v2hfs.find( vid ) == v2hfs.end() ) )
[ + - ][ + - ]
[ + - ][ + - ]
[ + - # #
# # ]
3539 : : {
3540 [ + - ]: 23575 : inci_entid.push_back( fid_from_halfacet( hf, type ) );
3541 [ + - ]: 23575 : inci_lid.push_back( lid_from_halffacet( hf ) );
3542 : : }
3543 : : }
3544 : :
3545 : 186607 : return MB_SUCCESS;
3546 : : }
3547 : :
3548 : 51426 : ErrorCode HalfFacetRep::set_incident_map( EntityType type, EntityHandle vid, std::vector< EntityHandle >& set_entid,
3549 : : std::vector< int >& set_lid )
3550 : : {
3551 [ + + ]: 51426 : if( type == MBEDGE ) { v2hv[ID_FROM_HANDLE( vid ) - 1] = create_halffacet( set_entid[0], set_lid[0] ); }
3552 [ + + ][ + + ]: 49430 : else if( type == MBTRI || type == MBQUAD )
3553 : : {
3554 [ + - ]: 21990 : if( set_entid.size() == 1 )
3555 : 21990 : v2he[ID_FROM_HANDLE( vid ) - 1] = create_halffacet( set_entid[0], set_lid[0] );
3556 : : else
3557 : : {
3558 : 0 : HFacet hf = 0;
3559 [ # # ]: 0 : for( int i = 0; i < (int)set_entid.size(); i++ )
3560 : : {
3561 [ # # ][ # # ]: 0 : hf = create_halffacet( set_entid[i], set_lid[i] );
[ # # ]
3562 [ # # ][ # # ]: 0 : v2hes.insert( std::pair< EntityHandle, HFacet >( vid, hf ) );
3563 : : }
3564 : 21990 : }
3565 : : }
3566 : : else
3567 : : {
3568 [ + - ]: 27440 : if( set_entid.size() == 1 )
3569 : 27440 : v2hf[ID_FROM_HANDLE( vid ) - 1] = create_halffacet( set_entid[0], set_lid[0] );
3570 : : else
3571 : : {
3572 [ # # ][ # # ]: 0 : HFacet hf = v2hf[ID_FROM_HANDLE( vid ) - 1];
3573 [ # # ][ # # ]: 0 : if( hf != 0 ) { v2hf[ID_FROM_HANDLE( vid ) - 1] = 0; }
[ # # ]
3574 [ # # ]: 0 : for( int i = 0; i < (int)set_entid.size(); i++ )
3575 : : {
3576 [ # # ][ # # ]: 0 : hf = create_halffacet( set_entid[i], set_lid[i] );
[ # # ]
3577 [ # # ][ # # ]: 0 : v2hfs.insert( std::pair< EntityHandle, HFacet >( vid, hf ) );
3578 : : }
3579 : : }
3580 : : }
3581 : :
3582 : 51426 : return MB_SUCCESS;
3583 : : }
3584 : :
3585 : 17 : ErrorCode HalfFacetRep::get_entity_ranges( Range& verts, Range& edges, Range& faces, Range& cells )
3586 : : {
3587 : 17 : verts = _verts;
3588 : 17 : edges = _edges;
3589 : 17 : faces = _faces;
3590 : 17 : cells = _cells;
3591 : 17 : return MB_SUCCESS;
3592 : : }
3593 : :
3594 : 48 : ErrorCode HalfFacetRep::update_entity_ranges( EntityHandle fileset )
3595 : : {
3596 : : ErrorCode error;
3597 : :
3598 [ - + ][ # # ]: 48 : error = mb->get_entities_by_dimension( fileset, 0, _verts, true );MB_CHK_ERR( error );
3599 : :
3600 [ - + ][ # # ]: 48 : error = mb->get_entities_by_dimension( fileset, 1, _edges, true );MB_CHK_ERR( error );
3601 : :
3602 [ - + ][ # # ]: 48 : error = mb->get_entities_by_dimension( fileset, 2, _faces, true );MB_CHK_ERR( error );
3603 : :
3604 [ - + ][ # # ]: 48 : error = mb->get_entities_by_dimension( fileset, 3, _cells, true );MB_CHK_ERR( error );
3605 : :
3606 : 48 : return MB_SUCCESS;
3607 : : }
3608 : :
3609 : 0 : void HalfFacetRep::get_memory_use( unsigned long long& entity_total, unsigned long long& memory_total )
3610 : : {
3611 : 0 : entity_total = memory_total = 0;
3612 : : // 1D
3613 [ # # ]: 0 : if( !v2hv.empty() ) entity_total += v2hv.capacity() * sizeof( HFacet ) + sizeof( v2hv );
3614 [ # # ]: 0 : if( !sibhvs.empty() ) entity_total += sibhvs.capacity() * sizeof( HFacet ) + sizeof( sibhvs );
3615 : :
3616 : : // 2D
3617 [ # # ]: 0 : if( !v2he.empty() ) entity_total += v2he.capacity() * sizeof( HFacet ) + sizeof( v2he );
3618 [ # # ]: 0 : if( !sibhes.empty() ) entity_total += sibhes.capacity() * sizeof( HFacet ) + sizeof( sibhes );
3619 : :
3620 : : // 3D
3621 [ # # ]: 0 : if( !v2hf.empty() ) entity_total += v2hf.capacity() * sizeof( HFacet ) + sizeof( v2hf );
3622 [ # # ]: 0 : if( !sibhfs.empty() ) entity_total += sibhfs.capacity() * sizeof( HFacet ) + sizeof( sibhfs );
3623 : :
3624 : 0 : memory_total = entity_total;
3625 : 0 : }
3626 : :
3627 : 724658 : HFacet HalfFacetRep::create_halffacet( EntityHandle handle, int lid )
3628 : : {
3629 : 724658 : EntityID fid = ID_FROM_HANDLE( handle );
3630 : 724658 : return CREATE_HALFFACET( lid, fid );
3631 : : }
3632 : :
3633 : 19750212 : EntityHandle HalfFacetRep::fid_from_halfacet( const HFacet facet, EntityType type )
3634 : : {
3635 [ + - ]: 19750212 : EntityID id = FID_FROM_HALFFACET( facet );
3636 : 19750212 : EntityHandle handle = 0;
3637 [ + + ]: 19750212 : if( id == 0 ) return handle;
3638 : :
3639 [ + - ][ - + ]: 19182554 : ErrorCode error = mb->handle_from_id( type, id, handle );MB_CHK_ERR( error );
[ # # ][ # # ]
3640 : 19750212 : return handle;
3641 : : }
3642 : :
3643 : 15999460 : int HalfFacetRep::lid_from_halffacet( const HFacet facet )
3644 : : {
3645 [ + + ]: 15999460 : if( facet == 0 )
3646 : 387430 : return 0;
3647 : : else
3648 : 15612030 : return LID_FROM_HALFFACET( facet );
3649 : : }
3650 : :
3651 [ + - ][ + - ]: 16 : } // namespace moab
|
