Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : CompSurfFacets.cpp
3 : : //
4 : : // Purpose : Encapsulate facet date used to speed up composite surfaces
5 : : //
6 : : // Special Notes :
7 : : //
8 : : // Creator : Jason Kraftcheck
9 : : //
10 : : // Creation Date : 03/20/03
11 : : //-------------------------------------------------------------------------
12 : :
13 : : #include "CompSurfFacets.hpp"
14 : : #include "Surface.hpp"
15 : : #include "GeometryQueryEngine.hpp"
16 : : #include "GMem.hpp"
17 : : #include "OctTree.hpp"
18 : : #include "GfxDebug.hpp"
19 : :
20 : : #include "CubitFacetData.hpp"
21 : : #include "CubitFacetEdgeData.hpp"
22 : : #include "CubitPointData.hpp"
23 : : #include "FacetEvalTool.hpp"
24 : : #include "FacetDataUtil.hpp"
25 : : #include "DLIList.hpp"
26 : :
27 : :
28 [ # # ][ # # ]: 0 : CompSurfFacets::CompSurfFacets()
[ # # ][ # # ]
29 : : {
30 : 0 : pointsConsolidated = false;
31 : 0 : facetEvalTool = NULL;
32 : 0 : }
33 : :
34 [ # # ][ # # ]: 0 : CompSurfFacets::~CompSurfFacets()
[ # # ][ # # ]
35 : : {
36 : : //delete the facetEvalTool...deletes the facets also
37 [ # # ]: 0 : if (facetEvalTool)
38 [ # # ][ # # ]: 0 : delete facetEvalTool;
39 : 0 : facetEvalTool = NULL;
40 : :
41 : : //delete the facets not in the tool
42 [ # # ]: 0 : FacetDataUtil::delete_facets( facetsToIgnore );
43 : 0 : }
44 : :
45 : 0 : CubitStatus CompSurfFacets::setup( const SurfPtrList& surface_data )
46 : : {
47 [ # # ]: 0 : GMem gmem;
48 [ # # ][ # # ]: 0 : DLIList<CubitFacet*> facet_list;
49 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> point_list;
50 : :
51 [ # # ][ # # ]: 0 : ignoreFlags.resize(surface_data.size());
52 : :
53 [ # # ][ # # ]: 0 : for ( unsigned int index = 0; index < surface_data.size(); index++ )
54 : : {
55 [ # # ]: 0 : Surface* surface = surface_data[index];
56 [ # # ]: 0 : ignoreFlags[index] = 0;
57 : :
58 [ # # ]: 0 : CubitStatus result = surface->get_geometry_query_engine()
59 [ # # ]: 0 : ->get_graphics( surface, &gmem, 5);
60 [ # # ]: 0 : if ( !result )
61 : 0 : return CUBIT_FAILURE;
62 : :
63 : : //make the points
64 [ # # ]: 0 : DLIList<CubitPoint*> tmp_points;
65 [ # # ]: 0 : GPoint* g_itor = gmem.point_list();
66 : 0 : GPoint* g_end = g_itor + gmem.pointListCount;
67 [ # # ]: 0 : for ( ; g_itor != g_end; ++g_itor )
68 : : {
69 : : CubitPoint *new_point_ptr =
70 [ # # ][ # # ]: 0 : new CubitPointData(g_itor->x, g_itor->y, g_itor->z);
71 [ # # ]: 0 : tmp_points.append( new_point_ptr );
72 : : }
73 : :
74 : : //make the facets
75 [ # # ]: 0 : int* f_itor = gmem.facet_list();
76 : 0 : int* f_end = f_itor + gmem.fListCount;
77 : 0 : int num_facets = 0;
78 : :
79 [ # # ]: 0 : while ( f_itor != f_end )
80 : : {
81 : 0 : int count = *f_itor++;
82 [ # # ]: 0 : assert( count == 3 );
83 : :
84 : : CubitPoint *facet_points[3];
85 : :
86 [ # # ]: 0 : for (int i=0; i<count; i++ )
87 : : {
88 : 0 : int index2 = *f_itor++;
89 [ # # ]: 0 : facet_points[i] = tmp_points[index2];
90 : : }
91 : :
92 : : //skip degenerate facets
93 [ # # ][ # # ]: 0 : if( facet_points[0] == facet_points[1] ||
94 [ # # ]: 0 : facet_points[0] == facet_points[2] ||
95 : 0 : facet_points[1] == facet_points[2] )
96 : 0 : continue;
97 : :
98 : : CubitFacet *facet = (CubitFacet*) new CubitFacetData(
99 [ # # ][ # # ]: 0 : facet_points[0], facet_points[1], facet_points[2] );
100 : :
101 [ # # ]: 0 : facet_list.append( facet );
102 [ # # ]: 0 : allFacets.append( facet );
103 : :
104 [ # # ][ # # ]: 0 : facetToSurfaceMap.insert( std::map<CubitFacet*, int>::value_type( facet, index ) );
105 : 0 : num_facets++;
106 : : }
107 [ # # ]: 0 : point_list += tmp_points;
108 [ # # ]: 0 : numFacetsPerSurface.append( num_facets );
109 [ # # ]: 0 : }
110 : :
111 : : //create a FacetEvalTool with the points and facets
112 [ # # ][ # # ]: 0 : facetEvalTool = new FacetEvalTool();
113 [ # # ][ # # ]: 0 : if ( CUBIT_SUCCESS != facetEvalTool->initialize( facet_list, point_list, -1, 0.707106 ) )
114 : 0 : return CUBIT_FAILURE;
115 : :
116 : 0 : pointsConsolidated = false;
117 [ # # ]: 0 : return CUBIT_SUCCESS;
118 : : }
119 : :
120 : 0 : void CompSurfFacets::set_ignore_flag(DLIList<int> &indicies, int flag)
121 : : {
122 [ # # ][ # # ]: 0 : if( indicies.size() == 0 )
123 : 0 : return;
124 : :
125 [ # # ]: 0 : DLIList<CubitFacet*> facets_to_use;
126 [ # # ]: 0 : facetsToIgnore.clean_out();
127 : :
128 : 0 : int where_to_start = 0;
129 : : int i;
130 [ # # ]: 0 : int num_ignore_flags = (int)ignoreFlags.size();
131 [ # # ]: 0 : assert(num_ignore_flags >= 0);
132 [ # # ]: 0 : for( i = 0; i < num_ignore_flags; i++ )
133 : : {
134 [ # # ]: 0 : ignoreFlags[i] = 0;
135 : :
136 : : //should we ignore this one?
137 : : int j;
138 [ # # ]: 0 : if( flag == 1 )
139 : : {
140 [ # # ][ # # ]: 0 : for( j=indicies.size(); j--; )
141 : : {
142 [ # # ][ # # ]: 0 : if( indicies.get_and_step() == i )
143 [ # # ]: 0 : ignoreFlags[i] = 1;
144 : : }
145 : : }
146 : :
147 [ # # ]: 0 : int num_facets = numFacetsPerSurface[i];
148 : :
149 : : //put the ignored ones in a list to prevent memory leak
150 [ # # ]: 0 : for( j=where_to_start; j<where_to_start+num_facets; j++ )
151 : : {
152 [ # # ][ # # ]: 0 : if( ignoreFlags[i] == 0 )
153 [ # # ][ # # ]: 0 : facets_to_use.append( allFacets[j] );
154 : : else
155 [ # # ][ # # ]: 0 : facetsToIgnore.append( allFacets[j] );
156 : : }
157 : :
158 [ # # ]: 0 : where_to_start += numFacetsPerSurface[i];
159 : : }
160 : :
161 : : //give these facets to the tool
162 [ # # ]: 0 : facetEvalTool->replace_facets( facets_to_use );
163 : :
164 : : //now reset the bounding box on the
165 [ # # ][ # # ]: 0 : facetEvalTool->reset_bounding_box();
166 : :
167 : : }
168 : :
169 : 0 : int CompSurfFacets::get_ignore_flag(int index)
170 : : {
171 : 0 : return ignoreFlags[index];
172 : : }
173 : :
174 : 0 : int CompSurfFacets::closest_index( const CubitVector& pos,
175 : : CubitVector* closest_pos ) const
176 : : {
177 [ # # ]: 0 : CubitFacet *closest_facet = facetEvalTool->closest_facet( pos );
178 : :
179 [ # # ]: 0 : std::map<CubitFacet*, int>::const_iterator my_iter;
180 [ # # ]: 0 : my_iter = facetToSurfaceMap.find( closest_facet );
181 : :
182 : 0 : int closest_index = -1;
183 : :
184 [ # # ][ # # ]: 0 : if( my_iter != facetToSurfaceMap.end() )
[ # # ]
185 [ # # ]: 0 : closest_index = my_iter->second;
186 : :
187 [ # # ]: 0 : if( closest_pos )
188 : : {
189 : : CubitPoint *pt1, *pt2;
190 [ # # ]: 0 : closest_facet->closest_point_trimmed( pos, *closest_pos, pt1, pt2 );
191 : : }
192 : :
193 : 0 : return closest_index;
194 : : }
195 : :
196 : 0 : int CompSurfFacets::closest_index( const CubitVector& pos,
197 : : DLIList<int>& index_list,
198 : : CubitVector* closest_pos )
199 : : {
200 : : //facets must be consolidated before calling this function
201 : : //if not, you won't know if a position is on multiple
202 : : //surfaces (on seam between 2 surfaces)
203 [ # # ]: 0 : if (!pointsConsolidated)
204 : : {
205 [ # # ]: 0 : consolidate_points(GEOMETRY_RESABS);
206 : 0 : pointsConsolidated = true;
207 : : }
208 : :
209 [ # # ]: 0 : CubitFacet *closest_facet = facetEvalTool->closest_facet( pos );
210 : :
211 [ # # ]: 0 : std::map<CubitFacet*, int>::const_iterator iter;
212 [ # # ][ # # ]: 0 : iter = facetToSurfaceMap.find( closest_facet );
213 : :
214 : 0 : int closest_index = -1;
215 : :
216 [ # # ][ # # ]: 0 : if( iter != facetToSurfaceMap.end() )
[ # # ][ # # ]
217 [ # # ]: 0 : closest_index = iter->second;
218 : :
219 [ # # ]: 0 : index_list.append( closest_index );
220 : :
221 [ # # ]: 0 : CubitVector tmp_closest_pos;
222 : : CubitPoint *pt1, *pt2;
223 [ # # ]: 0 : closest_facet->closest_point_trimmed( pos, tmp_closest_pos, pt1, pt2 );
224 : :
225 [ # # ]: 0 : if( closest_pos )
226 [ # # ]: 0 : *closest_pos = tmp_closest_pos;
227 : :
228 : 0 : double tol_sq = GEOMETRY_RESABS*GEOMETRY_RESABS;
229 [ # # ]: 0 : double dist_sq = pos.distance_between_squared( tmp_closest_pos );
230 : :
231 : : //if the closest distance is less than resabs, there could be more facets
232 : : //less then resabs away too....find them
233 [ # # ]: 0 : if( dist_sq < tol_sq )
234 : : {
235 : : //examine neighboring facets
236 : : CubitPoint *point0, *point1, *point2;
237 [ # # ]: 0 : closest_facet->points( point0, point1, point2 );
238 : :
239 [ # # ]: 0 : DLIList<CubitFacet*> neighbor_facets;
240 [ # # ]: 0 : point0->tris( neighbor_facets );
241 [ # # ]: 0 : point1->tris( neighbor_facets );
242 [ # # ]: 0 : point2->tris( neighbor_facets );
243 : :
244 [ # # ]: 0 : neighbor_facets.uniquify_unordered();
245 : :
246 : : int k;
247 [ # # ][ # # ]: 0 : for( k=neighbor_facets.size(); k--; )
248 : : {
249 [ # # ]: 0 : CubitFacet *tmp_facet = neighbor_facets.get_and_step();
250 [ # # ]: 0 : tmp_facet->closest_point_trimmed( pos, tmp_closest_pos, pt1, pt2 );
251 : :
252 [ # # ]: 0 : dist_sq = pos.distance_between_squared( tmp_closest_pos );
253 [ # # ]: 0 : if( dist_sq < tol_sq )
254 : : {
255 [ # # ][ # # ]: 0 : iter = facetToSurfaceMap.find( tmp_facet );
256 [ # # ][ # # ]: 0 : if( iter != facetToSurfaceMap.end() )
[ # # ][ # # ]
257 [ # # ][ # # ]: 0 : index_list.append( iter->second );
258 : : }
259 [ # # ]: 0 : }
260 : : }
261 : :
262 [ # # ]: 0 : index_list.uniquify_unordered();
263 : :
264 [ # # ]: 0 : return index_list.size();
265 : : }
266 : :
267 : 0 : void CompSurfFacets::debug_draw_facets() const
268 : : {
269 : : int i;
270 [ # # ]: 0 : for( i=0; i<allFacets.size(); i++ )
271 : 0 : allFacets[i]->debug_draw( 4 );
272 : :
273 : 0 : GfxDebug::flush();
274 : 0 : }
275 : :
276 : 0 : void CompSurfFacets::consolidate_points( double tolerance )
277 : : {
278 [ # # ]: 0 : DLIList<CubitFacet*> facet_list;
279 [ # # ]: 0 : facetEvalTool->get_facets( facet_list );
280 : :
281 : : //group the points by surface
282 [ # # ][ # # ]: 0 : DLIList< DLIList<CubitFacet*>* > list_of_lists;
283 : : int i;
284 [ # # ]: 0 : numFacetsPerSurface.reset();
285 : 0 : int index_into_facet_array = 0;
286 [ # # ][ # # ]: 0 : for( i=0; i<numFacetsPerSurface.size(); i++ )
287 : : {
288 [ # # ]: 0 : int num_facets = numFacetsPerSurface.get_and_step();
289 : :
290 [ # # ][ # # ]: 0 : if( ignoreFlags[i] == 0 )
291 : : {
292 [ # # ][ # # ]: 0 : DLIList<CubitFacet*>* tmp_facet_list = new DLIList<CubitFacet*>;
293 : : int k;
294 [ # # ]: 0 : for(k=0; k<num_facets; k++ )
295 [ # # ][ # # ]: 0 : tmp_facet_list->append( allFacets[index_into_facet_array+k] );
296 [ # # ]: 0 : list_of_lists.append( tmp_facet_list );
297 : : }
298 : 0 : index_into_facet_array += num_facets;
299 : : }
300 : :
301 : : int num_points_merged, num_edges_merged;
302 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> unmerged_points;
303 : : FacetDataUtil::merge_coincident_vertices( list_of_lists, tolerance,
304 : : num_points_merged, num_edges_merged,
305 [ # # ]: 0 : unmerged_points );
306 : :
307 : : //replace facets so points list get updates
308 [ # # ]: 0 : facetEvalTool->replace_facets( facet_list );
309 : :
310 : : //clean up
311 [ # # ][ # # ]: 0 : for( i=list_of_lists.size(); i--; )
312 [ # # ][ # # ]: 0 : delete list_of_lists.get_and_step();
[ # # ]
313 : :
314 [ # # ]: 0 : pointsConsolidated = true;
315 : 0 : }
316 : :
317 : : class CubitVectOctTreeEval {
318 : : public:
319 : : static inline const CubitVector& coordinates(CubitVector* p)
320 : : { return *p; };
321 : : };
322 : :
323 : 0 : void CompSurfFacets::graphics( double tolerance, GMem& gmem )
324 : : {
325 [ # # ]: 0 : if (!pointsConsolidated)
326 : : {
327 [ # # ]: 0 : consolidate_points(tolerance);
328 : 0 : pointsConsolidated = true;
329 : : }
330 : :
331 [ # # ]: 0 : DLIList<CubitPoint*> point_list;
332 [ # # ][ # # ]: 0 : DLIList<CubitFacet*> facet_list;
333 [ # # ]: 0 : facetEvalTool->get_points( point_list );
334 [ # # ]: 0 : facetEvalTool->get_facets( facet_list );
335 [ # # ]: 0 : point_list.reset();
336 [ # # ]: 0 : facet_list.reset();
337 : :
338 : : //mark all the points to -1
339 : : int i;
340 [ # # ][ # # ]: 0 : for( i=point_list.size(); i--; )
341 [ # # ][ # # ]: 0 : point_list.get_and_step()->marked(-1);
342 : :
343 [ # # ][ # # ]: 0 : gmem.allocate_tri( facet_list.size() );
344 : :
345 [ # # ]: 0 : int* f_itor = gmem.facet_list();
346 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> tmp_points;
347 : 0 : int index = 0;
348 : :
349 [ # # ][ # # ]: 0 : for( i=facet_list.size(); i--; )
350 : : {
351 [ # # ]: 0 : CubitFacet *tmp_facet = facet_list.get_and_step();
352 : : CubitPoint *p0, *p1, *p2;
353 [ # # ]: 0 : tmp_facet->points(p0, p1, p2 );
354 : :
355 : 0 : *(f_itor++) = 3;
356 : :
357 [ # # ][ # # ]: 0 : if( p0->marked() == -1 )
358 : : {
359 [ # # ]: 0 : tmp_points.append( p0 );
360 [ # # ]: 0 : p0->marked( index );
361 : 0 : index++;
362 : : }
363 [ # # ]: 0 : *(f_itor++) = p0->marked();
364 : :
365 [ # # ][ # # ]: 0 : if( p1->marked() == -1 )
366 : : {
367 [ # # ]: 0 : tmp_points.append( p1 );
368 [ # # ]: 0 : p1->marked( index );
369 : 0 : index++;
370 : : }
371 [ # # ]: 0 : *(f_itor++) = p1->marked();
372 : :
373 [ # # ][ # # ]: 0 : if( p2->marked() == -1 )
374 : : {
375 [ # # ]: 0 : tmp_points.append( p2 );
376 [ # # ]: 0 : p2->marked( index );
377 : 0 : index++;
378 : : }
379 [ # # ]: 0 : *(f_itor++) = p2->marked();
380 : : }
381 : :
382 : :
383 [ # # ]: 0 : GPoint* g_itor = gmem.point_list();
384 [ # # ][ # # ]: 0 : for( i=tmp_points.size(); i--; )
385 : : {
386 [ # # ]: 0 : CubitPoint *tmp_point = tmp_points.get_and_step();
387 [ # # ]: 0 : g_itor->x = (float)tmp_point->x();
388 [ # # ]: 0 : g_itor->y = (float)tmp_point->y();
389 [ # # ]: 0 : g_itor->z = (float)tmp_point->z();
390 : 0 : g_itor++;
391 : : }
392 : :
393 [ # # ]: 0 : gmem.fListCount = (facet_list.size() * 4);
394 [ # # ][ # # ]: 0 : gmem.pointListCount = tmp_points.size();
395 [ + - ][ + - ]: 6364 : }
396 : :
|
