Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : VirtualQueryEngine.cc
3 : : //
4 : : // Purpose : This file contains the implementation of the class
5 : : // VirtualQueryEngine.
6 : : //
7 : : // Special Notes : There are several functions in this class which are
8 : : // inhereted from GeometryQueryEngine that are not
9 : : // implemented or applicable in this class. These
10 : : // functions, if called, will print an error message
11 : : // and return the most appropriate error condition available.
12 : : //
13 : : // Creator : Jason Kraftcheck
14 : : //
15 : : // Creation Date : 08/01/97
16 : : //-------------------------------------------------------------------------
17 : :
18 : : // ********** BEGIN STANDARD INCLUDES **********
19 : : #include <assert.h>
20 : : // ********** END STANDARD INCLUDES **********
21 : :
22 : : // ********** BEGIN CUBIT INCLUDES **********
23 : :
24 : : #include "VirtualQueryEngine.hpp"
25 : : #include "CompositeTool.hpp"
26 : : #include "PartitionTool.hpp"
27 : : #include "CompositeEngine.hpp"
28 : : #include "PartitionEngine.hpp"
29 : : #include "GeometryUtil.hpp"
30 : :
31 : : #include "CubitDefines.h"
32 : : #include "GeometryDefines.h"
33 : : #include "CubitVector.hpp"
34 : :
35 : : #include "CastTo.hpp"
36 : : #include "GMem.hpp"
37 : :
38 : : #include "ModelQueryEngine.hpp"
39 : : #include "AppUtil.hpp"
40 : :
41 : : #include "Body.hpp"
42 : : #include "CoVolume.hpp"
43 : : #include "RefVolume.hpp"
44 : : #include "RefFace.hpp"
45 : : #include "Loop.hpp"
46 : : #include "CoEdge.hpp"
47 : : #include "RefEdge.hpp"
48 : : #include "Chain.hpp"
49 : : #include "CoVertex.hpp"
50 : : #include "RefVertex.hpp"
51 : : #include "RefEntityFactory.hpp"
52 : : #include "CoFace.hpp"
53 : :
54 : :
55 : : #include "CompositePoint.hpp"
56 : : #include "CompositeCurve.hpp"
57 : : #include "CompositeSurface.hpp"
58 : : #include "CompositeLump.hpp"
59 : : #include "CompositeBody.hpp"
60 : : #include "PartitionBody.hpp"
61 : : #include "PartitionLump.hpp"
62 : : #include "PartitionSurface.hpp"
63 : : #include "PartitionCurve.hpp"
64 : :
65 : :
66 : : #include "Shell.hpp"
67 : : #include "GeometryQueryTool.hpp"
68 : : #include "CubitPointData.hpp"
69 : : #include "CubitFacetData.hpp"
70 : : #include "CubitFacetEdgeData.hpp"
71 : :
72 : : #include "CACompositeVG.hpp"
73 : : #include "CAPartitionVG.hpp"
74 : : #include "CAVirtualVG.hpp"
75 : :
76 : : #include "HiddenEntitySet.hpp"
77 : : #include "SubEntitySet.hpp"
78 : :
79 : : // ********** END CUBIT INCLUDES **********
80 : :
81 : : // ********** BEGIN STATIC DECLARATIONS **********
82 : : VirtualQueryEngine* VirtualQueryEngine::instance_ = NULL;
83 : : //- A pointer to the single instance of this class
84 : :
85 : :
86 : : const int VirtualQueryEngine::VGE_MAJOR_VERSION = 10;
87 : : const int VirtualQueryEngine::VGE_MINOR_VERSION = 0;
88 : : const int VirtualQueryEngine::VGE_SUBMINOR_VERSION = 0;
89 : :
90 : : const double VirtualQueryEngine::param_epsilon_fraction = 1000000;
91 : : //- This value is used to determine epsilon for
92 : : //- compensating for rounding error in parameter
93 : : //- conversion between virtaul geometry and real
94 : : //- geometry.
95 : :
96 : : // ********** END STATIC DECLARATIONS **********
97 : :
98 : : // ********** BEGIN PUBLIC FUNCTIONS **********
99 : :
100 : : //-------------------------------------------------------------------------
101 : : // Purpose : Destructor
102 : : //
103 : : // Special Notes :
104 : : //
105 : : // Creator : Jason Kraftcheck
106 : : //
107 : : // Creation Date : 08/01/97
108 : : //-------------------------------------------------------------------------
109 : 0 : VirtualQueryEngine::~VirtualQueryEngine( )
110 : : {
111 : : // destroy_all_virtual_entities();
112 : : // if( virtual_entity_list_.size() )
113 : : // PRINT_WARNING("Not all virtual geometry has been removed. "
114 : : // "This is a bug (memory leak). Please report it.\n");
115 : : // assert( virtual_entity_list_.size() == 0 );
116 : :
117 [ # # ]: 0 : PartitionEngine::delete_instance();
118 [ # # ]: 0 : CompositeEngine::delete_instance();
119 : :
120 : 0 : instance_ = NULL;
121 [ # # ]: 0 : }
122 : :
123 : 0 : void VirtualQueryEngine::delete_instance()
124 : : {
125 [ # # ]: 0 : if( NULL != instance_ )
126 : : {
127 [ # # ]: 0 : delete instance_;
128 : 0 : instance_ = NULL;
129 : : }
130 : 0 : }
131 : :
132 : :
133 : : //-------------------------------------------------------------------------
134 : : // Purpose : Return a description of this ModelingEngine
135 : : //
136 : : // Special Notes :
137 : : //
138 : : // Creator : Jason Kraftcheck
139 : : //
140 : : // Creation Date : 08/01/97
141 : : //-------------------------------------------------------------------------
142 : 0 : int VirtualQueryEngine::get_major_version()
143 : : {
144 : 0 : return VGE_MAJOR_VERSION;
145 : : }
146 : :
147 : 0 : int VirtualQueryEngine::get_minor_version()
148 : : {
149 : 0 : return VGE_MINOR_VERSION;
150 : : }
151 : :
152 : 0 : int VirtualQueryEngine::get_subminor_version()
153 : : {
154 : 0 : return VGE_SUBMINOR_VERSION;
155 : : }
156 : :
157 : 0 : CubitString VirtualQueryEngine::get_engine_version_string()
158 : : {
159 : : CubitString return_this(
160 : 0 : "VirtualQueryEngine v1.2 by Jason Kraftcheck.\n" );
161 [ # # ][ # # ]: 0 : return_this += "I-CARVE Lab., University of Wisconsin - Madison, August 1, 1997.\n";
[ # # ]
162 [ # # ][ # # ]: 0 : return_this += "This ModelingEngine performs the necessary topological ";
[ # # ]
163 [ # # ][ # # ]: 0 : return_this += "operations for working with VirtualEntities, including ";
[ # # ]
164 [ # # ][ # # ]: 0 : return_this += "objects of type CompositeEntity, PartitionEntity, and ";
[ # # ]
165 [ # # ][ # # ]: 0 : return_this += "ParasiteEntity. ComposinteModelingEngine also ";
[ # # ]
166 [ # # ][ # # ]: 0 : return_this += "provides the interface for creating, destroying, and ";
[ # # ]
167 [ # # ][ # # ]: 0 : return_this += "modifying VirtualEntities.\n";
[ # # ]
168 : :
169 : 0 : return return_this;
170 : : }
171 : :
172 : 0 : CubitStatus VirtualQueryEngine::transform_vec_position(
173 : : CubitVector const& ,
174 : : BodySM *,
175 : : CubitVector & ) const
176 : : {
177 : 0 : return CUBIT_FAILURE;
178 : : }
179 : :
180 : : //This is only for partition surfaces!!!!!!!!!!!!!!!!!!
181 : 0 : CubitStatus VirtualQueryEngine::get_graphics( Surface* surf_ptr,
182 : : GMem *gmem,
183 : : std::vector<TopologyBridge*> &vertex_edge_to_point_vector,
184 : : std::vector<std::pair<TopologyBridge*, std::pair<int,int> > > &facet_edges_on_curves,
185 : : unsigned short normal_tol,
186 : : double dist_tol,
187 : : double max_edge_length ) const
188 : : {
189 [ # # ]: 0 : PartitionSurface* ps_ptr = CAST_TO(surf_ptr, PartitionSurface );
190 [ # # ]: 0 : if( ps_ptr != NULL )
191 : : {
192 : : return get_partition_surface_facetting( ps_ptr, gmem, &vertex_edge_to_point_vector, &facet_edges_on_curves,
193 : 0 : normal_tol, dist_tol, max_edge_length );
194 : : }
195 : :
196 [ # # ]: 0 : CompositeSurface* cs_ptr = CAST_TO(surf_ptr, CompositeSurface );
197 [ # # ]: 0 : if( cs_ptr != NULL )
198 : : {
199 : : return get_composite_surface_facetting( cs_ptr, gmem, &vertex_edge_to_point_vector, &facet_edges_on_curves,
200 : 0 : normal_tol, dist_tol, max_edge_length );
201 : : }
202 : : //PRINT_INFO("VirtualQueryEngine::get_graphics_facets"
203 : : // "( s%p, %p, %d, %f ) = CUBIT_FAILURE\n",
204 : : // surf_ptr, gmem, normal_tol, dist_tol);
205 : 0 : return CUBIT_FAILURE;
206 : : }
207 : :
208 : :
209 : :
210 : : //-------------------------------------------------------------------------
211 : : // Purpose : This function determines faceting information for use
212 : : // by HOOPS.
213 : : //
214 : : // Special Notes :
215 : : //
216 : : // Creator : Jason Kraftcheck
217 : : //
218 : : // Creation Date :
219 : : //-------------------------------------------------------------------------
220 : 0 : CubitStatus VirtualQueryEngine::get_graphics(
221 : : Surface* surf_ptr,
222 : : GMem* gMem,
223 : : unsigned short normal_tol,
224 : : double dist_tol,
225 : : double max_edge_length ) const
226 : : {
227 [ # # ]: 0 : CompositeSurface* cs_ptr = CAST_TO(surf_ptr, CompositeSurface );
228 [ # # ]: 0 : PartitionSurface* ps_ptr = CAST_TO(surf_ptr, PartitionSurface );
229 [ # # ]: 0 : if( cs_ptr != NULL )
230 : : {
231 : : return get_composite_surface_facetting( cs_ptr, gMem, NULL, NULL,
232 : 0 : normal_tol, dist_tol, max_edge_length );
233 : : }
234 [ # # ]: 0 : else if( ps_ptr != NULL )
235 : : {
236 : : return get_partition_surface_facetting( ps_ptr, gMem, NULL, NULL,
237 : 0 : normal_tol, dist_tol, max_edge_length );
238 : : }
239 : : else
240 : : {
241 [ # # ]: 0 : PRINT_INFO("VirtualQueryEngine::get_graphics_facets"
242 : : "( s%p, %p, %d, %f ) = CUBIT_FAILURE\n",
243 [ # # ]: 0 : (void*)surf_ptr, (void*)gMem, normal_tol, dist_tol);
244 : 0 : return CUBIT_FAILURE;
245 : : }
246 : : }
247 : :
248 : : //-----------------------------------------------------------------------
249 : : // Purpose : This function returns the necessary faceting information
250 : : // to display the curve.
251 : : //
252 : : // Special Notes :
253 : : //
254 : : // Creator : Jason Kraftcheck
255 : : //
256 : : // Creation Date : 10/10/97
257 : : //-----------------------------------------------------------------------
258 : 0 : CubitStatus VirtualQueryEngine::get_graphics( Curve* curve_ptr,
259 : : GMem* gMem,
260 : : double angle_tolerance,
261 : : double distance_tolerance,
262 : : double max_edge_length ) const
263 : : {
264 [ # # ]: 0 : CompositeCurve* ccurve = CAST_TO( curve_ptr, CompositeCurve );
265 [ # # ]: 0 : PartitionCurve* pcurve = CAST_TO( curve_ptr, PartitionCurve );
266 : :
267 : : CubitStatus result;
268 : :
269 [ # # ]: 0 : if( ccurve != NULL )
270 : : {
271 : : result = get_composite_curve_facetting( ccurve, gMem, angle_tolerance,
272 : 0 : distance_tolerance, max_edge_length );
273 : : }
274 [ # # ]: 0 : else if( pcurve != NULL )
275 : : {
276 : : result = get_partition_curve_facetting( pcurve, gMem, angle_tolerance,
277 : 0 : distance_tolerance, max_edge_length );
278 : : }
279 : : else
280 : : {
281 [ # # ]: 0 : PRINT_ERROR("Unknown curve type or NULL curve passed to "
282 [ # # ]: 0 : "VirtualQueryEngine::get_graphics_edges()\n");
283 : 0 : return CUBIT_FAILURE;
284 : : }
285 : :
286 : 0 : return result;
287 : : }
288 : :
289 : : // This is the template for an unimplemented version of this function.
290 : 0 : CubitStatus VirtualQueryEngine::get_isoparametric_points(Surface*,
291 : : int &nu, int &nv,
292 : : GMem*& ) const
293 : : {
294 : 0 : nu = nv = 0;
295 : 0 : return CUBIT_FAILURE;
296 : : }
297 : :
298 : : // This is the template for an unimplemented version of this function.
299 : 0 : CubitStatus VirtualQueryEngine::get_u_isoparametric_points(Surface*,
300 : : double , int& ,
301 : : GMem*& ) const
302 : : {
303 : 0 : return CUBIT_FAILURE;
304 : : }
305 : :
306 : : // This is the template for an unimplemented version of this function.
307 : 0 : CubitStatus VirtualQueryEngine::get_v_isoparametric_points(Surface*,
308 : : double , int& ,
309 : : GMem*&) const
310 : : {
311 : 0 : return CUBIT_FAILURE;
312 : : }
313 : :
314 : : //-----------------------------------------------------------------------
315 : : // Purpose : This function constructs the edge facetting information
316 : : // of a CompositeCurve for use by HOOPS.
317 : : //
318 : : // Special Notes :
319 : : //
320 : : // Creator : Jason Kraftcheck
321 : : //
322 : : // Creation Date : 10/10/97
323 : : //-----------------------------------------------------------------------
324 : 0 : CubitStatus VirtualQueryEngine::get_composite_curve_facetting(
325 : : CompositeCurve* ccurve_ptr,
326 : : GMem* gMem,
327 : : double angle_tolerance,
328 : : double distance_tolerance,
329 : : double max_edge_length ) const
330 : : {
331 : : // Just return if gMem is NULL
332 [ # # ]: 0 : if (gMem == NULL)
333 : : {
334 : 0 : return CUBIT_SUCCESS;
335 : : }
336 : :
337 [ # # ]: 0 : GMem current_gmem;
338 : 0 : int point_count = 0; //Current total of points returned
339 : : // from underlying edges
340 : :
341 : 0 : int next_index = 0; //index of next insert spot in passed GMem object.
342 : :
343 : : //Get points for each underlying curve
344 [ # # ]: 0 : current_gmem.clean_out();
345 [ # # ][ # # ]: 0 : for( int i = 0; i < ccurve_ptr->num_curves(); i++ )
346 : : {
347 : : // Get the next curve and its GME
348 [ # # ]: 0 : Curve* curve_ptr = ccurve_ptr->get_curve(i);
349 : : GeometryQueryEngine* GQE_ptr =
350 [ # # ]: 0 : curve_ptr->get_geometry_query_engine();
351 : :
352 : : // Get the GME to facet the curve
353 : : CubitStatus current_status =
354 : : GQE_ptr->get_graphics( curve_ptr, ¤t_gmem, angle_tolerance,
355 [ # # ]: 0 : distance_tolerance, max_edge_length );
356 [ # # ]: 0 : if( current_status == CUBIT_FAILURE )
357 : 0 : return CUBIT_FAILURE;
358 : :
359 : 0 : int this_point_count = current_gmem.pointListCount;
360 : :
361 : : // Make sure the passed in gmem is big enough
362 [ # # ]: 0 : gMem->allocate_more_polylines(this_point_count-1);
363 : : //assert( gMem->pts_size >= point_count );
364 : :
365 : : // If this isn't the first curve, we don't need to
366 : : // repeat one of the end nodes.
367 [ # # ]: 0 : if (point_count != 0)
368 : 0 : this_point_count--;
369 : : // Add to the total number of points so far
370 : 0 : point_count += this_point_count;
371 : :
372 : : //Copy points to passed GMem, in the correct order
373 : : //for the sense of the underlying edge wrt the
374 : : //composite.
375 [ # # ]: 0 : CubitSense sense = ccurve_ptr->get_sense( i );
376 : :
377 [ # # ]: 0 : if( sense == CUBIT_FORWARD )
378 : : {
379 [ # # ]: 0 : if (next_index == 0)
380 [ # # ]: 0 : for(int j = 0; j < point_count; j++)
381 : : {
382 [ # # ][ # # ]: 0 : gMem->point_list()[j] = current_gmem.point_list()[j];
383 : : }
384 : : else
385 : : // cur_gmem has one more point than we will access,
386 : : // so last index is point_count-next_index.
387 [ # # ]: 0 : for(int j = next_index; j < point_count; j++)
388 : : {
389 [ # # ][ # # ]: 0 : gMem->point_list()[j] = current_gmem.point_list()[j - next_index + 1];
390 : : }
391 : : }
392 : : else //( sense == CUBIT_REVERSED )
393 : : {
394 : : // All but the first curve will not use one of its points.
395 : : // This is taken into account by decrementing point_count
396 : : // earlier.
397 [ # # ]: 0 : for(int j = next_index; j < point_count; j++)
398 : : {
399 [ # # ][ # # ]: 0 : gMem->point_list()[j] = current_gmem.point_list()[point_count-j-1];
400 : : }
401 : : }
402 : 0 : next_index = point_count;
403 : 0 : gMem->pointListCount = point_count;
404 : : }
405 : :
406 : 0 : gMem->pointListCount = point_count;
407 [ # # ]: 0 : return CUBIT_SUCCESS;
408 : : }
409 : :
410 : : //-----------------------------------------------------------------------
411 : : // Purpose : This function constructs the edge facetting information
412 : : // of a PartitionCurve for use by HOOPS.
413 : : //
414 : : // Special Notes : It is currently not possible to split a face which
415 : : // has more than one loop (holes) because we cannot
416 : : // determine which partition the holes should lie on with
417 : : // the current implementation of ParasiteCurve.
418 : : //
419 : : // Creator : Jason Kraftcheck
420 : : //
421 : : // Creation Date : 10/10/97
422 : : //-----------------------------------------------------------------------
423 : 0 : CubitStatus VirtualQueryEngine::get_partition_curve_facetting(
424 : : PartitionCurve* pcurve_ptr,
425 : : GMem* gMem,
426 : : double angle_tolerance,
427 : : double distance_tolerance,
428 : : double max_edge_length ) const
429 : : {
430 [ # # ]: 0 : assert( gMem != NULL );
431 : : CubitStatus result = pcurve_ptr->get_graphics( *gMem, angle_tolerance,
432 : 0 : distance_tolerance, max_edge_length );
433 : 0 : return result;
434 : : }
435 : :
436 : :
437 : : //-------------------------------------------------------------------------
438 : : // Purpose : get Hoops facetting information for a CompositeSurface.
439 : : //
440 : : // Special Notes :
441 : : //
442 : : // Creator : Jason Kraftcheck
443 : : //
444 : : // Creation Date : 03/17/98
445 : : //-------------------------------------------------------------------------
446 : 0 : CubitStatus VirtualQueryEngine::get_composite_surface_facetting(
447 : : CompositeSurface* surf_ptr,
448 : : GMem* gMem,
449 : : std::vector<TopologyBridge*> *vertex_edge_to_point_vector,
450 : : std::vector<std::pair<TopologyBridge*, std::pair<int,int> > > *facet_edges_on_curves,
451 : : unsigned short normal_tol,
452 : : double dist_tol,
453 : : double longest_edge ) const
454 : : {
455 [ # # ]: 0 : if( gMem == NULL )
456 : 0 : return CUBIT_FAILURE;
457 : :
458 [ # # ]: 0 : if (surf_ptr->get_graphics(*gMem))
459 : : {
460 : : /*
461 : : if( vertex_edge_to_point_vector )
462 : : {
463 : : vertex_edge_to_point_vector->resize( gMem->pointListCount, NULL );
464 : : //get all the points on the surface
465 : : DLIList<TBPoint*> points;
466 : : surf_ptr->points( points );
467 : :
468 : : for( int i=points.size(); i--; )
469 : : {
470 : : TBPoint *tb_pt = points.get_and_step();
471 : : CompositePoint *comp_pt = CAST_TO( tb_pt, CompositePoint );
472 : :
473 : : if( comp_pt )
474 : : {
475 : : CubitPoint *facet_point = comp_pt->facet_point();
476 : : (*vertex_edge_to_point_vector)[facet_point->marked()] = comp_pt;
477 : : }
478 : : }
479 : : }
480 : :
481 : : if( facet_edges_on_curves )
482 : : {
483 : : DLIList<Curve*> tmp_curves;
484 : : surf_ptr->curves( tmp_curves );
485 : :
486 : : for( int i=tmp_curves.size(); i--; )
487 : : {
488 : : Curve *tmp_curve = tmp_curves.get_and_step();
489 : : CompositeCurve *comp_curve = CAST_TO( tmp_curve, CompositeCurve );
490 : :
491 : : if( comp_curve )
492 : : {
493 : : DLIList<CubitFacetEdgeData*> facet_edges;
494 : : comp_curve->get_facet_data( facet_edges );
495 : :
496 : : for( int j=facet_edges.size(); j--; )
497 : : {
498 : : CubitFacetEdge *facet_edge = facet_edges.get_and_step();
499 : :
500 : : facet_edges_on_curves->push_back( std::make_pair( tmp_curve,
501 : : std::make_pair( facet_edge->point(0)->marked(),
502 : : facet_edge->point(1)->marked() )));
503 : : }
504 : : }
505 : : }
506 : : }
507 : : */
508 : 0 : return CUBIT_SUCCESS;
509 : : }
510 : :
511 : :
512 : : // Get the underlying Surfaces
513 : : GeometryQueryEngine* gqe_ptr;
514 [ # # ][ # # ]: 0 : GMem *gMem_list = new GMem[ surf_ptr->num_surfs() ];
[ # # # # ]
515 : :
516 : 0 : int total_number_points = 0;
517 : 0 : int total_number_facets = 0;
518 : :
519 : : // Get the facets of each Surface
520 : : int i;
521 [ # # ]: 0 : for(i = 0; i < surf_ptr->num_surfs(); i++)
522 : : {
523 : 0 : Surface* surface_ptr = surf_ptr->get_surface(i);
524 : :
525 : 0 : gqe_ptr = surface_ptr->get_geometry_query_engine();
526 : :
527 : : gqe_ptr->get_graphics( surface_ptr, &(gMem_list[i]),
528 : 0 : normal_tol, dist_tol, longest_edge );
529 : :
530 : 0 : total_number_facets += gMem_list[i].fListCount;
531 : 0 : total_number_points += gMem_list[i].pointListCount;
532 : : }
533 : :
534 : 0 : int point_offset = 0;
535 : 0 : int face_offset = 0;
536 [ # # ]: 0 : gMem->replace_point_list(new GPoint[total_number_points],
537 : 0 : total_number_points, total_number_points);
538 [ # # ]: 0 : gMem->replace_facet_list(new int[total_number_facets],
539 : 0 : total_number_facets, total_number_facets);
540 : :
541 [ # # ]: 0 : for( i = 0; i < surf_ptr->num_surfs(); i++ )
542 : : {
543 : : int j;
544 [ # # ]: 0 : for( j = 0; j < gMem_list[i].pointListCount; j++ )
545 : : {
546 [ # # ]: 0 : assert((point_offset + j) < gMem->pointListCount );
547 : 0 : gMem->point_list()[j + point_offset].x = gMem_list[i].point_list()[j].x;
548 : 0 : gMem->point_list()[j + point_offset].y = gMem_list[i].point_list()[j].y;
549 : 0 : gMem->point_list()[j + point_offset].z = gMem_list[i].point_list()[j].z;
550 : : }
551 : :
552 : : int k;
553 [ # # ]: 0 : for( k = 0; k < gMem_list[i].fListCount;)
554 : : {
555 : 0 : int count = gMem_list[i].facet_list()[k];
556 [ # # ]: 0 : assert( k + count < gMem->fListCount );
557 : :
558 : 0 : gMem->facet_list()[k + face_offset] = count;
559 : 0 : k++;
560 [ # # ]: 0 : for( int l = 0; l < count; l++, k++ )
561 : : {
562 [ # # ]: 0 : assert( k + face_offset < gMem->fListCount );
563 [ # # ]: 0 : assert( k < gMem_list[i].fListCount );
564 : 0 : gMem->facet_list()[k + face_offset] = gMem_list[i].facet_list()[k]
565 : 0 : + point_offset;
566 : : }
567 : : }
568 : :
569 : 0 : point_offset += j;
570 : 0 : face_offset += k;
571 : : }
572 : :
573 : 0 : gMem->consolidate_points(10*GEOMETRY_RESABS);
574 : : // // Debug!!!
575 : : // int q;
576 : : // for (q = 0; q < bte_list.size(); q++)
577 : : // {
578 : : // PRINT_INFO("Printing Points for Surface %d.\n", q);
579 : : // int r;
580 : : // for (r = 0; r < gMem_list[q].pointListCount; r++)
581 : : // {
582 : : // PRINT_INFO("%g %g %g\n",
583 : : // gMem_list[q].point_list()[r].x,
584 : : // gMem_list[q].point_list()[r].y,
585 : : // gMem_list[q].point_list()[r].z);
586 : : // }
587 : : // PRINT_INFO("Printing FList for Surface %d.\n", q);
588 : : // for (r = 0; r < gMem_list[q].fListCount; r++)
589 : : // {
590 : : // PRINT_INFO("%d %s",
591 : : // gMem_list[q].facet_list()[r],
592 : : // r % 4 ? "" : "\n");
593 : : // }
594 : : // }
595 : : // PRINT_INFO("Composite points:\n");
596 : : // for (q = 0; q < gMem->pointListCount; q++)
597 : : // {
598 : : // PRINT_INFO("%g %g %g\n",
599 : : // gMem->point_list()[q].x,
600 : : // gMem->point_list()[q].y,
601 : : // gMem->point_list()[q].z);
602 : : // }
603 : : // PRINT_INFO("Composite facet list:\n");
604 : : // for (q = 0; q < gMem->fListCount; q++)
605 : : // {
606 : : // PRINT_INFO("%d %s",
607 : : // gMem->facet_list()[q],
608 : : // q % 4 ? "" : "\n");
609 : : // }
610 : :
611 [ # # ]: 0 : if( vertex_edge_to_point_vector )
612 : : {
613 [ # # ]: 0 : vertex_edge_to_point_vector->resize( gMem->pointListCount, NULL );
614 : : //get all the points on the surface
615 [ # # ]: 0 : DLIList<TBPoint*> points;
616 [ # # ]: 0 : surf_ptr->points( points );
617 : :
618 [ # # ][ # # ]: 0 : for( int i=points.size(); i--; )
619 : : {
620 [ # # ]: 0 : TBPoint *tb_pt = points.get_and_step();
621 [ # # ]: 0 : PartitionPoint *ppt = CAST_TO( tb_pt, PartitionPoint );
622 : :
623 [ # # ]: 0 : if( ppt )
624 : : {
625 [ # # ]: 0 : CubitPoint *facet_point = ppt->facet_point();
626 [ # # ][ # # ]: 0 : (*vertex_edge_to_point_vector)[facet_point->marked()] = ppt;
627 : : }
628 [ # # ]: 0 : }
629 : : }
630 : :
631 [ # # ]: 0 : if( facet_edges_on_curves )
632 : : {
633 [ # # ]: 0 : DLIList<Curve*> tmp_curves;
634 [ # # ]: 0 : surf_ptr->curves( tmp_curves );
635 : :
636 [ # # ][ # # ]: 0 : for( int i=tmp_curves.size(); i--; )
637 : : {
638 [ # # ]: 0 : Curve *tmp_curve = tmp_curves.get_and_step();
639 [ # # ]: 0 : PartitionCurve *pt_curve = CAST_TO( tmp_curve, PartitionCurve );
640 : :
641 [ # # ]: 0 : if( pt_curve )
642 : : {
643 [ # # ]: 0 : DLIList<CubitFacetEdgeData*> facet_edges;
644 [ # # ]: 0 : pt_curve->get_facet_data( facet_edges );
645 : :
646 [ # # ][ # # ]: 0 : for( int j=facet_edges.size(); j--; )
647 : : {
648 [ # # ]: 0 : CubitFacetEdge *facet_edge = facet_edges.get_and_step();
649 : :
650 : : facet_edges_on_curves->push_back( std::make_pair( tmp_curve,
651 [ # # ]: 0 : std::make_pair( facet_edge->point(0)->marked(),
652 [ # # ][ # # ]: 0 : facet_edge->point(1)->marked() )));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
653 : :
654 [ # # ]: 0 : }
655 : : }
656 [ # # ]: 0 : }
657 : : }
658 : :
659 [ # # ][ # # ]: 0 : delete [] gMem_list;
660 [ # # ]: 0 : return CUBIT_SUCCESS;
661 : : }
662 : :
663 : : //-------------------------------------------------------------------------
664 : : // Purpose : get hoops facets for a partition surface
665 : : //
666 : : // Special Notes :
667 : : //
668 : : // Creator : Jason Kraftcheck
669 : : //
670 : : // Creation Date : 06/18/98
671 : : //-------------------------------------------------------------------------
672 : 0 : CubitStatus VirtualQueryEngine::get_partition_surface_facetting(
673 : : PartitionSurface* surf_ptr,
674 : : GMem* gMem,
675 : : std::vector<TopologyBridge*> *vertex_edge_to_point_vector,
676 : : std::vector<std::pair<TopologyBridge*, std::pair<int,int> > > *facet_edges_on_curves,
677 : : unsigned short ,
678 : : double,
679 : : double ) const
680 : : {
681 : : int i, j;
682 : :
683 [ # # ]: 0 : DLIList<CubitFacetData*> surf_facets;
684 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> surf_points;
685 : :
686 : : // get surface facets
687 [ # # ]: 0 : surf_ptr->get_facet_data( surf_facets );
688 : :
689 : : // get list of points from list of facets
690 [ # # ][ # # ]: 0 : for( i = surf_facets.size(); i--; )
691 : : {
692 [ # # ]: 0 : CubitFacetData* facet = surf_facets.step_and_get();
693 [ # # ]: 0 : for( j = 0; j< 3; j++ )
694 [ # # ][ # # ]: 0 : facet->point(j)->marked(1);
695 : : }
696 [ # # ][ # # ]: 0 : for( i = surf_facets.size(); i--; )
697 : : {
698 [ # # ]: 0 : CubitFacetData* facet = surf_facets.step_and_get();
699 [ # # ]: 0 : for( j = 0; j< 3; j++ )
700 : : {
701 [ # # ][ # # ]: 0 : if( facet->point(j)->marked() )
[ # # ]
702 : : {
703 [ # # ][ # # ]: 0 : facet->point(j)->marked(0);
704 [ # # ][ # # ]: 0 : surf_points.append( facet->point(j) );
705 : : }
706 : : }
707 : : }
708 : :
709 [ # # ]: 0 : if( ! gMem ) return CUBIT_SUCCESS;
710 : :
711 : : // allocate storage for facet data
712 [ # # ][ # # ]: 0 : gMem->allocate_tri( surf_facets.size() );
713 [ # # ]: 0 : gMem->fListCount = surf_facets.size() * 4;
714 [ # # ]: 0 : gMem->pointListCount = surf_points.size();
715 : :
716 : : // put points in GMem and mark each point with
717 : : // its index in the array
718 [ # # ]: 0 : surf_points.reset();
719 [ # # ]: 0 : for( i = 0; i < gMem->pointListCount; i++ )
720 : : {
721 [ # # ]: 0 : GPoint* gpt = gMem->point_list() + i;
722 [ # # ]: 0 : CubitPoint* pt = surf_points.get_and_step();
723 [ # # ]: 0 : pt->marked(i);
724 [ # # ][ # # ]: 0 : gpt->x = (float)(pt->coordinates().x() );
725 [ # # ][ # # ]: 0 : gpt->y = (float)(pt->coordinates().y() );
726 [ # # ][ # # ]: 0 : gpt->z = (float)(pt->coordinates().z() );
727 : : }
728 : :
729 : : // put each facet in the GMem. retreive
730 : : // point indices from marks.
731 [ # # ]: 0 : surf_facets.reset();
732 [ # # ]: 0 : int* gfacet_ptr = gMem->facet_list();
733 [ # # ][ # # ]: 0 : for( i = 0; i < surf_facets.size(); i++ )
734 : : {
735 [ # # ]: 0 : CubitFacetData* facet = surf_facets.get_and_step();
736 : 0 : *gfacet_ptr = 3;
737 : 0 : gfacet_ptr++;
738 [ # # ]: 0 : for( j = 0; j < 3; j++ )
739 : : {
740 [ # # ][ # # ]: 0 : *gfacet_ptr = facet->point(j)->marked();
741 : 0 : gfacet_ptr++;
742 : : }
743 : : }
744 : :
745 [ # # ]: 0 : if( vertex_edge_to_point_vector )
746 : : {
747 [ # # ]: 0 : vertex_edge_to_point_vector->resize( gMem->pointListCount, NULL );
748 : : //get all the points on the surface
749 [ # # ]: 0 : DLIList<TBPoint*> points;
750 [ # # ]: 0 : surf_ptr->points( points );
751 : :
752 [ # # ][ # # ]: 0 : for( int i=points.size(); i--; )
753 : : {
754 [ # # ]: 0 : TBPoint *tb_pt = points.get_and_step();
755 [ # # ]: 0 : PartitionPoint *ppt = CAST_TO( tb_pt, PartitionPoint );
756 : :
757 [ # # ]: 0 : if( ppt )
758 : : {
759 [ # # ]: 0 : CubitPoint *facet_point = ppt->facet_point();
760 [ # # ][ # # ]: 0 : (*vertex_edge_to_point_vector)[facet_point->marked()] = ppt;
761 : : }
762 [ # # ]: 0 : }
763 : : }
764 : :
765 [ # # ]: 0 : if( facet_edges_on_curves )
766 : : {
767 [ # # ]: 0 : DLIList<Curve*> tmp_curves;
768 [ # # ]: 0 : surf_ptr->curves( tmp_curves );
769 : :
770 [ # # ][ # # ]: 0 : for( int i=tmp_curves.size(); i--; )
771 : : {
772 [ # # ]: 0 : Curve *tmp_curve = tmp_curves.get_and_step();
773 [ # # ]: 0 : PartitionCurve *pt_curve = CAST_TO( tmp_curve, PartitionCurve );
774 : :
775 [ # # ]: 0 : if( pt_curve )
776 : : {
777 [ # # ]: 0 : DLIList<CubitFacetEdgeData*> facet_edges;
778 [ # # ]: 0 : pt_curve->get_facet_data( facet_edges );
779 : :
780 [ # # ][ # # ]: 0 : for( int j=facet_edges.size(); j--; )
781 : : {
782 [ # # ]: 0 : CubitFacetEdge *facet_edge = facet_edges.get_and_step();
783 : :
784 : : facet_edges_on_curves->push_back( std::make_pair( tmp_curve,
785 [ # # ]: 0 : std::make_pair( facet_edge->point(0)->marked(),
786 [ # # ][ # # ]: 0 : facet_edge->point(1)->marked() )));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
787 : :
788 [ # # ]: 0 : }
789 : : }
790 [ # # ]: 0 : }
791 : : }
792 : :
793 : : // clear point marks
794 [ # # ][ # # ]: 0 : for( i = surf_points.size(); i--; )
795 [ # # ][ # # ]: 0 : surf_points.step_and_get()->marked(0);
796 : :
797 [ # # ]: 0 : return CUBIT_SUCCESS;
798 : : }
799 : :
800 : : // ********** END PUBLIC FUNCTIONS **********
801 : :
802 : : // ********** BEGIN PROTECTED FUNCTIONS **********
803 : :
804 : : //-------------------------------------------------------------------------
805 : : // Purpose : The constructor of the VirtualQueryEngine class.
806 : : //
807 : : // Special Notes :
808 : : //
809 : : // Creator : Wes Gill
810 : : //
811 : : // Creation Date : 10/5/01
812 : : //-------------------------------------------------------------------------
813 : :
814 : 1682 : VirtualQueryEngine::VirtualQueryEngine()
815 : : {
816 [ - + ]: 841 : assert( !instance_);
817 : : //Add the VirtualQueryEngine to the GeometryQueryTool's gqeList and
818 : : //set the VGE to the GQT's default engine.
819 : : //GeometryQueryTool::instance()->add_gqe(this);
820 : : //GeometryQueryTool::instance()->set_default_engine(this);
821 [ + - ]: 841 : CompositeEngine::instance();
822 [ + - ]: 841 : PartitionEngine::instance();
823 : 841 : }
824 : :
825 : :
826 : : //-------------------------------------------------------------------------
827 : : // Purpose : get child virtual geometry
828 : : //
829 : : // Special Notes :
830 : : //
831 : : // Creator : Jason Kraftcheck
832 : : //
833 : : // Creation Date : 08/11/98
834 : : //-------------------------------------------------------------------------
835 : 0 : void VirtualQueryEngine::get_VEs( TopologyEntity* te_ptr,
836 : : DLIList<TopologyBridge*>& ve_list,
837 : : CubitBoolean visible,
838 : : const CubitBoolean children_too)
839 : : {
840 [ # # ]: 0 : DLIList<TopologyBridge*> child_list;
841 [ # # ]: 0 : Body* body_ptr = CAST_TO( te_ptr, Body );
842 [ # # ]: 0 : CoVolume* covol_ptr = CAST_TO( te_ptr, CoVolume );
843 [ # # ]: 0 : RefVolume* vol_ptr = CAST_TO( te_ptr, RefVolume );
844 [ # # ]: 0 : Shell* shell_ptr = CAST_TO( te_ptr, Shell );
845 [ # # ]: 0 : CoFace* coface_ptr = CAST_TO( te_ptr, CoFace );
846 [ # # ]: 0 : RefFace* face_ptr = CAST_TO( te_ptr, RefFace );
847 [ # # ]: 0 : Loop* loop_ptr = CAST_TO( te_ptr, Loop );
848 [ # # ]: 0 : CoEdge* coedge_ptr = CAST_TO( te_ptr, CoEdge );
849 [ # # ]: 0 : RefEdge* edge_ptr = CAST_TO( te_ptr, RefEdge );
850 [ # # ]: 0 : Chain* chain_ptr = CAST_TO( te_ptr, Chain );
851 [ # # ]: 0 : CoVertex* covex_ptr = CAST_TO( te_ptr, CoVertex );
852 [ # # ]: 0 : RefVertex* vex_ptr = CAST_TO( te_ptr, RefVertex );
853 : :
854 [ # # ][ # # ]: 0 : if( (body_ptr != NULL) || (covol_ptr != NULL) )
855 : : {
856 [ # # ]: 0 : if (children_too) {
857 [ # # ]: 0 : DLIList<RefVolume*> vol_list;
858 [ # # ]: 0 : te_ptr->ref_volumes( vol_list );
859 [ # # ][ # # ]: 0 : for( int i = vol_list.size(); i > 0; i-- )
860 : : {
861 [ # # ]: 0 : child_list.clean_out();
862 [ # # ]: 0 : get_VEs( vol_list.get_and_step(), child_list, visible,
863 [ # # ]: 0 : children_too);
864 [ # # ]: 0 : ve_list.merge_unique( child_list );
865 [ # # ]: 0 : }
866 : 0 : }
867 : : }
868 [ # # ]: 0 : else if( vol_ptr != NULL )
869 : : {
870 [ # # ]: 0 : get_VEs( vol_ptr, ve_list, visible, children_too );
871 : : }
872 [ # # ][ # # ]: 0 : else if( (shell_ptr != NULL) || (coface_ptr != NULL) )
873 : : {
874 [ # # ]: 0 : if (children_too) {
875 [ # # ]: 0 : DLIList<RefFace*> face_list;
876 [ # # ]: 0 : te_ptr->ref_faces( face_list );
877 [ # # ][ # # ]: 0 : for( int i = face_list.size(); i> 0; i-- )
878 : : {
879 [ # # ]: 0 : child_list.clean_out();
880 [ # # ]: 0 : get_VEs( face_list.get_and_step(), child_list, visible,
881 [ # # ]: 0 : children_too);
882 [ # # ]: 0 : ve_list.merge_unique( child_list );
883 [ # # ]: 0 : }
884 : 0 : }
885 : : }
886 [ # # ]: 0 : else if( face_ptr != NULL )
887 : : {
888 [ # # ]: 0 : get_VEs( face_ptr, ve_list, visible, children_too );
889 : : }
890 [ # # ][ # # ]: 0 : else if( (loop_ptr != NULL) || (coedge_ptr != NULL) )
891 : : {
892 [ # # ]: 0 : if (children_too) {
893 [ # # ]: 0 : DLIList<RefEdge*> edge_list;
894 [ # # ]: 0 : te_ptr->ref_edges( edge_list );
895 [ # # ][ # # ]: 0 : for( int i = edge_list.size(); i > 0; i-- )
896 : : {
897 [ # # ]: 0 : child_list.clean_out();
898 [ # # ]: 0 : get_VEs( edge_list.get_and_step(), child_list, visible,
899 [ # # ]: 0 : children_too);
900 [ # # ]: 0 : ve_list.merge_unique( child_list );
901 [ # # ]: 0 : }
902 : 0 : }
903 : : }
904 [ # # ]: 0 : else if( edge_ptr != NULL )
905 : : {
906 [ # # ]: 0 : get_VEs( edge_ptr, ve_list, visible, children_too );
907 : : }
908 [ # # ][ # # ]: 0 : else if( (chain_ptr != NULL) || (covex_ptr != NULL ) )
909 : : {
910 [ # # ]: 0 : if (children_too) {
911 [ # # ]: 0 : DLIList<RefVertex*> vertex_list;
912 [ # # ]: 0 : te_ptr->ref_vertices( vertex_list );
913 [ # # ][ # # ]: 0 : for( int i = vertex_list.size(); i > 0; i-- )
914 : : {
915 [ # # ]: 0 : child_list.clean_out();
916 [ # # ]: 0 : get_VEs( vertex_list.get_and_step(), child_list, visible,
917 [ # # ]: 0 : children_too);
918 [ # # ]: 0 : ve_list.merge_unique( child_list );
919 [ # # ]: 0 : }
920 : 0 : }
921 : : }
922 [ # # ]: 0 : else if( vex_ptr != NULL )
923 : : {
924 [ # # ]: 0 : get_VEs( vex_ptr, ve_list, visible, children_too );
925 : : }
926 : : else
927 : : {
928 [ # # ][ # # ]: 0 : PRINT_ERROR("Unknown type of TopologyEntity passed to "
[ # # ]
929 : : "VirtualQueryEngine::get_VEs(..). Passed pointer"
930 [ # # ]: 0 : " may be stale.\n");
931 [ # # ]: 0 : }
932 : 0 : }
933 : :
934 : :
935 : 0 : void VirtualQueryEngine::get_VEs( RefVolume* volume_ptr,
936 : : DLIList<TopologyBridge*>& ve_list,
937 : : CubitBoolean visible,
938 : : const CubitBoolean children_too )
939 : : {
940 [ # # ]: 0 : DLIList<BasicTopologyEntity*> bte_list;
941 : : int i;
942 : :
943 [ # # ][ # # ]: 0 : DLIList<TopologyBridge*> tb_list;
[ # # ]
944 [ # # ][ # # ]: 0 : volume_ptr->bridge_manager()->get_bridge_list( tb_list );
945 : :
946 [ # # ][ # # ]: 0 : for( i = tb_list.size(); i--; )
947 : : {
948 [ # # ]: 0 : TopologyBridge* tb_ptr = tb_list.get_and_step();
949 [ # # ]: 0 : PartitionEntity* ve_ptr = dynamic_cast<PartitionEntity*>(tb_ptr);
950 [ # # ]: 0 : CompositeLump* ce_ptr = dynamic_cast<CompositeLump*>(tb_ptr);
951 [ # # ][ # # ]: 0 : if( ve_ptr || ce_ptr )
952 : : {
953 [ # # ]: 0 : ve_list.append( tb_ptr );
954 : : }
955 : : }
956 : :
957 [ # # ]: 0 : if (!children_too) return;
958 [ # # ][ # # ]: 0 : DLIList<TopologyBridge*> child_list;
[ # # ][ # # ]
959 : :
960 [ # # ][ # # ]: 0 : DLIList<RefFace*> face_list;
961 [ # # ]: 0 : volume_ptr->ref_faces( face_list );
962 [ # # ][ # # ]: 0 : DLIList<BasicTopologyEntity*> temp_face_list;
963 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT( face_list, temp_face_list );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
964 [ # # ]: 0 : bte_list.merge_unique( temp_face_list );
965 : : // bte_list.merge_unique( face_list );
966 [ # # ][ # # ]: 0 : for( i = bte_list.size();i > 0;i--)
967 : : {
968 [ # # ]: 0 : child_list.clean_out();
969 [ # # ][ # # ]: 0 : get_VEs( bte_list.get_and_step(), child_list, visible );
970 [ # # ]: 0 : ve_list.merge_unique( child_list );
971 : 0 : }
972 : : }
973 : :
974 : 0 : void VirtualQueryEngine::get_VEs( RefFace* face_ptr,
975 : : DLIList<TopologyBridge*>& ve_list,
976 : : CubitBoolean visible,
977 : : const CubitBoolean children_too )
978 : : {
979 [ # # ]: 0 : DLIList<BasicTopologyEntity*> bte_list;
980 [ # # ][ # # ]: 0 : DLIList<TopologyBridge*> tb_list;
[ # # ]
981 : : int i;
982 : :
983 [ # # ][ # # ]: 0 : face_ptr->bridge_manager()->get_bridge_list( tb_list );
984 [ # # ]: 0 : tb_list.reset();
985 : :
986 [ # # ][ # # ]: 0 : for( i = tb_list.size(); i--; )
987 : : {
988 : :
989 [ # # ]: 0 : TopologyBridge* ve_ptr = tb_list.get_and_step();
990 [ # # ][ # # ]: 0 : if( dynamic_cast<PartitionEntity*>(ve_ptr) ||
[ # # ]
991 [ # # ][ # # ]: 0 : dynamic_cast<CompositeSurface*>(ve_ptr) )
992 : : {
993 [ # # ]: 0 : ve_list.append( ve_ptr );
994 : : }
995 : : }
996 : :
997 : :
998 [ # # ]: 0 : if (!children_too) return;
999 : :
1000 [ # # ][ # # ]: 0 : DLIList<TopologyBridge*> child_list;
[ # # ][ # # ]
1001 [ # # ][ # # ]: 0 : DLIList<RefEdge*> edge_list;
1002 [ # # ]: 0 : face_ptr->ref_edges( edge_list );
1003 [ # # ][ # # ]: 0 : DLIList<BasicTopologyEntity*> temp_edge_list;
1004 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT( edge_list, temp_edge_list );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
1005 [ # # ]: 0 : bte_list.merge_unique( temp_edge_list );
1006 : :
1007 [ # # ][ # # ]: 0 : for( i = bte_list.size();i > 0;i--)
1008 : : {
1009 [ # # ]: 0 : child_list.clean_out();
1010 [ # # ][ # # ]: 0 : get_VEs( bte_list.get_and_step(), child_list, visible );
1011 [ # # ]: 0 : ve_list.merge_unique( child_list );
1012 : 0 : }
1013 : : }
1014 : :
1015 : 0 : void VirtualQueryEngine::get_VEs( RefEdge* edge_ptr,
1016 : : DLIList<TopologyBridge*>& ve_list,
1017 : : CubitBoolean visible,
1018 : : const CubitBoolean children_too )
1019 : : {
1020 [ # # ]: 0 : DLIList<BasicTopologyEntity*> bte_list;
1021 [ # # ][ # # ]: 0 : DLIList<TopologyBridge*> tb_list;
[ # # ]
1022 : : int i;
1023 : :
1024 [ # # ][ # # ]: 0 : edge_ptr->bridge_manager()->get_bridge_list( tb_list );
1025 [ # # ]: 0 : tb_list.reset();
1026 : :
1027 [ # # ][ # # ]: 0 : for( i = tb_list.size(); i--; )
1028 : : {
1029 : :
1030 [ # # ]: 0 : TopologyBridge* ve_ptr = tb_list.get_and_step();
1031 [ # # ][ # # ]: 0 : if( dynamic_cast<PartitionCurve*>(ve_ptr) ||
[ # # ]
1032 [ # # ][ # # ]: 0 : dynamic_cast<CompositeCurve*>(ve_ptr) )
1033 : : {
1034 [ # # ]: 0 : ve_list.append( ve_ptr );
1035 : : }
1036 : : }
1037 : :
1038 [ # # ]: 0 : if (!children_too) return;
1039 [ # # ][ # # ]: 0 : DLIList<TopologyBridge*> child_list;
[ # # ][ # # ]
1040 [ # # ][ # # ]: 0 : DLIList<RefVertex*> vex_list;
1041 [ # # ]: 0 : edge_ptr->ref_vertices( vex_list );
1042 [ # # ][ # # ]: 0 : DLIList<BasicTopologyEntity*> temp_vex_list;
1043 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT( vex_list, temp_vex_list );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
1044 [ # # ]: 0 : bte_list.merge_unique( temp_vex_list );
1045 : :
1046 [ # # ][ # # ]: 0 : for( i = bte_list.size();i > 0;i--)
1047 : : {
1048 [ # # ]: 0 : child_list.clean_out();
1049 [ # # ][ # # ]: 0 : get_VEs( bte_list.get_and_step(), child_list, visible );
1050 [ # # ]: 0 : ve_list.merge_unique( child_list );
1051 : 0 : }
1052 : : }
1053 : :
1054 : 0 : void VirtualQueryEngine::get_VEs( RefVertex* vex_ptr,
1055 : : DLIList<TopologyBridge*>& ve_list,
1056 : : CubitBoolean ,
1057 : : const CubitBoolean )
1058 : : {
1059 [ # # ]: 0 : DLIList<TopologyBridge*> tb_list;
1060 [ # # ][ # # ]: 0 : vex_ptr->bridge_manager()->get_bridge_list( tb_list );
1061 [ # # ]: 0 : tb_list.reset();
1062 [ # # ][ # # ]: 0 : for( int i = tb_list.size(); i--; )
1063 : : {
1064 [ # # ]: 0 : TopologyBridge* tb = tb_list.get_and_step();
1065 [ # # ][ # # ]: 0 : if( dynamic_cast<PartitionPoint*>(tb) ||
[ # # ]
1066 [ # # ][ # # ]: 0 : dynamic_cast<CompositePoint*>(tb) )
1067 [ # # ]: 0 : ve_list.append( tb );
1068 [ # # ]: 0 : }
1069 : 0 : }
1070 : :
1071 : :
1072 : : //-------------------------------------------------------------------------
1073 : : // Purpose : check if the entity is virtual or has virtual entities.
1074 : : //
1075 : : // Special Notes : all is_virtual entity, has_virtual = true
1076 : : // only body, refvolume, refface can be non-virtual but has
1077 : : // virtual.
1078 : : //
1079 : : // Creator : Jane Hu
1080 : : //
1081 : : // Creation Date : 10/01/04
1082 : : //-------------------------------------------------------------------------
1083 : 0 : CubitBoolean VirtualQueryEngine::has_virtual(TopologyEntity* te_ptr)
1084 : : {
1085 [ # # ]: 0 : if (te_ptr == NULL)
1086 : 0 : return CUBIT_FALSE;
1087 : :
1088 [ # # ]: 0 : if (is_virtual(te_ptr))
1089 : 0 : return CUBIT_TRUE;
1090 : :
1091 : : // check if children has partition or composite entities
1092 : : int i;
1093 [ # # ]: 0 : Body * body_ptr = CAST_TO (te_ptr, Body);
1094 [ # # ]: 0 : RefVolume * vol_ptr = CAST_TO (te_ptr, RefVolume);
1095 [ # # ]: 0 : RefFace * face_ptr = CAST_TO (te_ptr, RefFace);
1096 : 0 : CubitBoolean has_vir = CUBIT_FALSE;
1097 : :
1098 [ # # ]: 0 : if (body_ptr != NULL)
1099 : : {
1100 [ # # ]: 0 : DLIList<RefVolume*> vol_list;
1101 [ # # ]: 0 : te_ptr->ref_volumes(vol_list);
1102 [ # # ][ # # ]: 0 : for (i = vol_list.size(); i > 0; i--)
1103 : : {
1104 [ # # ][ # # ]: 0 : if (has_virtual(vol_list.get_and_step()))
[ # # ]
1105 : : {
1106 : 0 : has_vir = CUBIT_TRUE;
1107 : 0 : break;
1108 : : }
1109 [ # # ]: 0 : }
1110 : : }
1111 : :
1112 [ # # ]: 0 : if (vol_ptr != NULL)
1113 : : {
1114 [ # # ]: 0 : DLIList<RefFace*> face_list;
1115 [ # # ]: 0 : te_ptr->ref_faces(face_list);
1116 [ # # ][ # # ]: 0 : for (i = face_list.size(); i > 0; i --)
1117 : : {
1118 [ # # ][ # # ]: 0 : if (has_virtual(face_list.get_and_step()))
[ # # ]
1119 : : {
1120 : 0 : has_vir = CUBIT_TRUE;
1121 : 0 : break;
1122 : : }
1123 [ # # ]: 0 : }
1124 : : }
1125 : :
1126 [ # # ]: 0 : if (face_ptr != NULL)
1127 : : {
1128 [ # # ]: 0 : DLIList<RefEdge *> edge_list;
1129 [ # # ]: 0 : te_ptr->ref_edges(edge_list);
1130 [ # # ][ # # ]: 0 : for (i = edge_list.size(); i > 0; i --)
1131 : : {
1132 [ # # ][ # # ]: 0 : if (is_virtual(edge_list.get_and_step()))
[ # # ]
1133 : : {
1134 : 0 : has_vir = CUBIT_TRUE;
1135 : 0 : break;
1136 : : }
1137 [ # # ]: 0 : }
1138 : : }
1139 : :
1140 : 0 : return has_vir;
1141 : : }
1142 : :
1143 : 0 : CubitBoolean VirtualQueryEngine::is_virtual(TopologyEntity *entity,
1144 : : const CubitBoolean children_too)
1145 : : //Check if a TopologyEntity has any topologyBridge that is composite or
1146 : : //partition type.
1147 : : {
1148 [ # # ]: 0 : if ( entity == NULL )
1149 : 0 : return CUBIT_FALSE;
1150 : :
1151 [ # # ][ # # ]: 0 : if (CAST_TO(entity, Body) !=NULL)
[ # # ]
1152 : : {
1153 : : int i;
1154 [ # # ]: 0 : DLIList<TopologyBridge*> list;
1155 [ # # ][ # # ]: 0 : entity->bridge_manager()->get_bridge_list(list);
1156 : : TopologyBridge * tb;
1157 [ # # ][ # # ]: 0 : for (i = list.size(); i > 0; i--)
[ # # ][ # # ]
1158 : : {
1159 [ # # ]: 0 : tb = list.get_and_step();
1160 [ # # ][ # # ]: 0 : if (CAST_TO(tb, PartitionBody) != NULL ||
[ # # ][ # # ]
1161 [ # # ]: 0 : CAST_TO(tb, CompositeBody) != NULL)
1162 : 0 : return CUBIT_TRUE;
1163 : 0 : }
1164 : : }
1165 : :
1166 [ # # ]: 0 : DLIList<TopologyBridge*> ve_list;
1167 [ # # ]: 0 : get_VEs(entity, ve_list, CUBIT_TRUE, children_too);
1168 [ # # ][ # # ]: 0 : return (ve_list.size() ? CUBIT_TRUE : CUBIT_FALSE);
[ # # ]
1169 : : }
1170 : :
1171 : 0 : CubitBoolean VirtualQueryEngine::is_virtual(DLIList<Body*> &entity_list,
1172 : : const CubitBoolean children_too)
1173 : : {
1174 [ # # ]: 0 : if (!children_too) return CUBIT_FALSE;
1175 : :
1176 : : int i;
1177 [ # # ]: 0 : for (i = entity_list.size(); i > 0; i--)
1178 [ # # ]: 0 : if (is_virtual(entity_list.get_and_step(), children_too)) return CUBIT_TRUE;
1179 : 0 : return CUBIT_FALSE;
1180 : : }
1181 : :
1182 : 0 : CubitBoolean VirtualQueryEngine::is_virtual(DLIList<RefEntity*> &entity_list,
1183 : : const CubitBoolean children_too)
1184 : : {
1185 : : int i;
1186 [ # # ]: 0 : for (i = entity_list.size(); i > 0; i--) {
1187 : 0 : RefEntity *ref_entity = entity_list.get_and_step();
1188 [ # # ][ # # ]: 0 : if (is_virtual(CAST_TO(ref_entity, TopologyEntity), children_too)) return CUBIT_TRUE;
1189 : : }
1190 : :
1191 : 0 : return CUBIT_FALSE;
1192 : : }
1193 : :
1194 : 0 : CubitBoolean VirtualQueryEngine::is_partition( RefEntity *ref_entity )
1195 : : {
1196 [ # # ]: 0 : RefEdge *ref_edge = CAST_TO( ref_entity, RefEdge );
1197 : :
1198 [ # # ]: 0 : if( ref_edge )
1199 : : {
1200 : 0 : Curve *curve_ptr = ref_edge->get_curve_ptr();
1201 [ # # ]: 0 : PartitionCurve *part_curve = CAST_TO(curve_ptr, PartitionCurve);
1202 : :
1203 [ # # ]: 0 : if( part_curve )
1204 : 0 : return CUBIT_TRUE;
1205 : : }
1206 : :
1207 : 0 : return CUBIT_FALSE;
1208 : : }
1209 : :
1210 : 0 : CubitStatus VirtualQueryEngine::get_sister_partitions( RefEntity *ref_entity,
1211 : : DLIList<RefEntity*> &sisters)
1212 : : {
1213 [ # # ]: 0 : RefEdge *ref_edge = CAST_TO( ref_entity, RefEdge );
1214 : :
1215 [ # # ]: 0 : if( ref_edge )
1216 : : {
1217 : 0 : Curve *curve_ptr = ref_edge->get_curve_ptr();
1218 [ # # ]: 0 : PartitionCurve *part_curve = CAST_TO(curve_ptr, PartitionCurve);
1219 : :
1220 [ # # ]: 0 : if( part_curve )
1221 : : {
1222 [ # # ]: 0 : DLIList<TopologyBridge*> tb_list;
1223 [ # # ][ # # ]: 0 : part_curve->sub_entity_set().get_owners( tb_list );
1224 : :
1225 : : int k;
1226 [ # # ][ # # ]: 0 : for( k=tb_list.size(); k--; )
1227 : : {
1228 [ # # ]: 0 : TopologyBridge *tmp_bridge = tb_list.get_and_step();
1229 [ # # ]: 0 : TopologyEntity *te = tmp_bridge->topology_entity();
1230 [ # # ]: 0 : if( te )
1231 : : {
1232 [ # # ]: 0 : RefEntity *sister = CAST_TO(te, RefEntity );
1233 [ # # ]: 0 : if( sister )
1234 [ # # ]: 0 : sisters.append( sister );
1235 : : }
1236 [ # # ]: 0 : }
1237 : : }
1238 : : }
1239 : :
1240 : 0 : return CUBIT_SUCCESS;
1241 : : }
1242 : :
1243 : : //-------------------------------------------------------------------------
1244 : : // Purpose : Sort a DLList of RefEdges to be used in the construction
1245 : : // of a CompositeCurve.
1246 : : //
1247 : : // Special Notes : Sorted using topological information
1248 : : //
1249 : : // Creator : Jason Kraftcheck
1250 : : //
1251 : : // Creation Date : 08/04/97
1252 : : //-------------------------------------------------------------------------
1253 : 0 : CubitStatus VirtualQueryEngine::sort_edges(
1254 : : DLIList<RefEdge*>& edge_list ) const
1255 : : {
1256 [ # # ]: 0 : DLIList<RefEdge*> sorted_edge_list;
1257 : 0 : RefEdge *first, *current = NULL, *prev;
1258 : 0 : CubitStatus return_value = CUBIT_SUCCESS;
1259 : :
1260 [ # # ][ # # ]: 0 : if( edge_list.size( ) <= 0 )
1261 : : {
1262 : 0 : return CUBIT_FAILURE;
1263 : : }
1264 : :
1265 [ # # ][ # # ]: 0 : if( edge_list.size() == 1 )
1266 : : {
1267 : 0 : return CUBIT_SUCCESS;
1268 : : }
1269 : :
1270 : : //Note: this part badly needs some optimization. Given the array-based
1271 : : // implementation of the DLList class, this is a very inefficient
1272 : : // approach to sorting the edges. Look into a different seach
1273 : : // algorithm, and possible switching functions in DLList.
1274 : :
1275 : : //add first Curve
1276 [ # # ]: 0 : edge_list.reset( );
1277 [ # # ]: 0 : first = prev = edge_list.remove( );
1278 [ # # ]: 0 : sorted_edge_list.append( first );
1279 : :
1280 : : //sort the rest of the Curves
1281 : : int i;
1282 [ # # ][ # # ]: 0 : for( i = 0; i < edge_list.size( ); i++ ) //loop for each remaining RefEdge
1283 : : {
1284 [ # # ]: 0 : edge_list.reset( );
1285 : : //look through list for next RefEdge
1286 [ # # ][ # # ]: 0 : for( int j = 0; j < edge_list.size( ); j++ )
1287 : : {
1288 [ # # ]: 0 : current = edge_list.get( );
1289 [ # # ][ # # ]: 0 : if( prev->common_ref_vertex( current ) != NULL )
1290 : : {
1291 [ # # ]: 0 : edge_list.remove( );
1292 [ # # ]: 0 : sorted_edge_list.append( current );
1293 : 0 : i--; //edge_list.size() decreases with removal of edge
1294 : 0 : prev = current;
1295 : 0 : break;
1296 : : }
1297 [ # # ][ # # ]: 0 : else if( first->common_ref_vertex( current ) != NULL )
1298 : : {
1299 [ # # ]: 0 : edge_list.remove( );
1300 [ # # ]: 0 : sorted_edge_list.insert_first( current );
1301 : 0 : first = current;
1302 : 0 : i--; //edge_list.size() decreases with removal of edge
1303 : 0 : break;
1304 : : }
1305 : : else
1306 : : {
1307 [ # # ]: 0 : edge_list.step( );
1308 : : }
1309 : : }//end for(j)
1310 : : }//end for(i)
1311 : :
1312 : : //check if all the RefEdges got sorted
1313 [ # # ][ # # ]: 0 : if( edge_list.size( ) > 0 )
1314 : : {
1315 : 0 : return_value = CUBIT_FAILURE;
1316 : :
1317 : : //Sort the rest of the edges anyway, for use by
1318 : : //other functions than composite edge creation.
1319 : :
1320 [ # # ]: 0 : sort_edges( edge_list );
1321 [ # # ]: 0 : edge_list.reset( );
1322 [ # # ][ # # ]: 0 : for( i = 0; i < edge_list.size(); i++ )
1323 : : {
1324 [ # # ]: 0 : current = edge_list.get_and_step( );
1325 [ # # ]: 0 : sorted_edge_list.append( current );
1326 : : }
1327 : : }
1328 : : else
1329 : : {
1330 : 0 : return_value = CUBIT_SUCCESS;
1331 : : }
1332 : :
1333 [ # # ]: 0 : edge_list.clean_out( );
1334 [ # # ]: 0 : edge_list = sorted_edge_list;
1335 [ # # ]: 0 : edge_list.reset( );
1336 [ # # ]: 0 : return return_value;
1337 : : }
1338 : :
1339 : :
1340 : :
1341 : : // ********** BEGIN PRIVATE FUNCTIONS **********
1342 : :
1343 : : //-------------------------------------------------------------------------
1344 : : // Purpose: Display a default error message for certain inherited functions
1345 : : //-------------------------------------------------------------------------
1346 : 0 : void VirtualQueryEngine::default_error_message(
1347 : : const char callers_name[] ) const
1348 : : {
1349 [ # # ][ # # ]: 0 : PRINT_ERROR("A call was made to:\n");
1350 [ # # ][ # # ]: 0 : PRINT_ERROR("VirtualQueryEngine::");
1351 [ # # ][ # # ]: 0 : PRINT_ERROR("%s", callers_name);
1352 [ # # ][ # # ]: 0 : PRINT_ERROR("\n");
1353 [ # # ][ # # ]: 0 : PRINT_ERROR("Although this function is inhereted from GeometryQueryEngine\n");
1354 [ # # ][ # # ]: 0 : PRINT_ERROR("it is not applicable or implememtend in VirtualQueryEngine.\n");
1355 [ # # ][ # # ]: 0 : PRINT_ERROR("\nTHIS IS A BUG. This function should NEVER be called.\n");
1356 [ # # ][ # # ]: 0 : PRINT_ERROR("\nThis function exists only because it is pure virtual in\n");
1357 [ # # ][ # # ]: 0 : PRINT_ERROR("the abstract class GeometryQueryEngine, and must be\n");
1358 [ # # ][ # # ]: 0 : PRINT_ERROR("defined in VirtualQueryEngine for the class to be\n");
1359 [ # # ][ # # ]: 0 : PRINT_ERROR("instantiated.\n");
1360 : 0 : }
1361 : :
1362 : : // ********** END PRIVATE FUNCTIONS **********
1363 : :
1364 : : // ********** BEGIN HELPER CLASSES **********
1365 : : // ********** END HELPER CLASSES **********
1366 : :
1367 : : // ********** BEGIN EXTERN FUNCTIONS **********
1368 : : // ********** END EXTERN FUNCTIONS **********
1369 : :
1370 : : // ********** BEGIN STATIC FUNCTIONS **********
1371 : : // ********** END STATIC FUNCTIONS **********
1372 : :
1373 : :
1374 : :
1375 : : CubitStatus
1376 : 0 : VirtualQueryEngine::get_intersections( Curve* , Curve* ,
1377 : : DLIList<CubitVector>& /*intersection_list*/,
1378 : : CubitBoolean /*bounded*/,
1379 : : CubitBoolean /*closest*/ )
1380 : : {
1381 : 0 : return CUBIT_FAILURE;
1382 : : }
1383 : :
1384 : : CubitStatus
1385 : 0 : VirtualQueryEngine::get_intersections(Curve* curve, CubitVector &point1,
1386 : : CubitVector &point2,
1387 : : DLIList<CubitVector>& intersection_list,
1388 : : CubitBoolean bounded,
1389 : : CubitBoolean closest )
1390 : : {
1391 [ # # ]: 0 : DLIList<TopologyBridge*> curve_list;
1392 [ # # ]: 0 : get_underlying_curves( curve, curve_list );
1393 : : int i;
1394 [ # # ][ # # ]: 0 : for (i = 0; i < curve_list.size(); i++)
1395 : : {
1396 : : // Get the next curve and its GME
1397 [ # # ][ # # ]: 0 : Curve* curve_ptr = CAST_TO(curve_list.get_and_step(), Curve);
1398 : : GeometryQueryEngine* GQE_ptr =
1399 [ # # ]: 0 : curve_ptr->get_geometry_query_engine();
1400 : : GQE_ptr->get_intersections(curve_ptr, point1, point2, intersection_list,
1401 [ # # ]: 0 : bounded, closest);
1402 : : }
1403 [ # # ]: 0 : return CUBIT_SUCCESS;
1404 : : }
1405 : :
1406 : : CubitStatus
1407 : 0 : VirtualQueryEngine::get_intersections( Curve*, Surface*,
1408 : : DLIList<CubitVector>& /* intersection_list */,
1409 : : CubitBoolean /* bounded */)
1410 : : {
1411 : 0 : return CUBIT_FAILURE;
1412 : : }
1413 : :
1414 : 0 : int VirtualQueryEngine::curve_is_on_ignored_surface(Curve *curve_in, Surface *surf)
1415 : : {
1416 : 0 : int i, ret = 0;
1417 : :
1418 [ # # ]: 0 : CompositeSurface *cs = dynamic_cast<CompositeSurface*>(surf);
1419 [ # # ][ # # ]: 0 : if(cs && curve_in)
1420 : : {
1421 [ # # ]: 0 : DLIList<Surface*> ignored_surfs;
1422 [ # # ]: 0 : cs->get_ignored_surfs(ignored_surfs);
1423 [ # # ][ # # ]: 0 : for(i=ignored_surfs.size(); i>0 && !ret; i--)
[ # # ]
1424 : : {
1425 [ # # ]: 0 : Surface *surf = ignored_surfs.get_and_step();
1426 [ # # ]: 0 : DLIList<Curve*> crvs;
1427 [ # # ]: 0 : surf->curves(crvs);
1428 [ # # ][ # # ]: 0 : if(crvs.is_in_list(curve_in))
1429 : 0 : ret = 1;
1430 [ # # ][ # # ]: 0 : }
1431 : : }
1432 : :
1433 : 0 : return ret;
1434 : : }
1435 : :
1436 : : //-------------------------------------------------------------------------
1437 : : // Purpose : This function get underlying curves for virtual curves
1438 : : //
1439 : : // Special Notes :
1440 : : //
1441 : : // Creator : Jane Hu
1442 : : //
1443 : : // Creation Date :
1444 : : //-------------------------------------------------------------------------
1445 : 0 : CubitStatus VirtualQueryEngine::get_underlying_curves(Curve * curve_ptr,
1446 : : DLIList<TopologyBridge*>& curve_list)
1447 : : {
1448 [ # # ]: 0 : assert (curve_ptr);
1449 [ # # ]: 0 : CompositeCurve *comp_curve = CAST_TO(curve_ptr, CompositeCurve);
1450 [ # # ]: 0 : PartitionCurve *part_curve = CAST_TO(curve_ptr, PartitionCurve);
1451 [ # # ]: 0 : if ( comp_curve )
1452 : : {
1453 : : int i;
1454 [ # # ]: 0 : for (i = 0; i < comp_curve->num_curves(); i ++)
1455 : : {
1456 [ # # ]: 0 : part_curve = CAST_TO(comp_curve->get_curve(i), PartitionCurve);
1457 [ # # ]: 0 : if (!part_curve)
1458 : 0 : curve_list.append_unique(CAST_TO(comp_curve->get_curve(i),
1459 [ # # ]: 0 : TopologyBridge));
1460 : : else
1461 : : {
1462 [ # # ][ # # ]: 0 : if(dynamic_cast<Curve*>(part_curve->partitioned_entity()))
[ # # ]
1463 : : {
1464 : 0 : curve_list.append_unique(CAST_TO(part_curve->partitioned_entity(),
1465 [ # # ]: 0 : TopologyBridge));
1466 : : }
1467 : : }
1468 : : }
1469 : : }
1470 [ # # ]: 0 : else if ( part_curve )
1471 : 0 : curve_list.append(CAST_TO(part_curve->partitioned_entity(),
1472 [ # # ]: 0 : TopologyBridge));
1473 : 0 : return CUBIT_SUCCESS;
1474 : : }
1475 : :
1476 : 0 : CubitStatus VirtualQueryEngine::get_underlying_surfaces(Surface * surf_ptr,
1477 : : DLIList<TopologyBridge*>& surf_list)
1478 : : {
1479 [ # # ]: 0 : assert (surf_ptr);
1480 [ # # ]: 0 : CompositeSurface *comp_surf = CAST_TO(surf_ptr, CompositeSurface);
1481 [ # # ]: 0 : PartitionSurface *part_surf = CAST_TO(surf_ptr, PartitionSurface);
1482 [ # # ]: 0 : if ( comp_surf )
1483 : : {
1484 : : int i;
1485 [ # # ]: 0 : for (i = 0; i < comp_surf->num_surfs(); i ++)
1486 : : {
1487 [ # # ]: 0 : part_surf = CAST_TO(comp_surf->get_surface(i), PartitionSurface);
1488 [ # # ]: 0 : if (!part_surf)
1489 : 0 : surf_list.append_unique(CAST_TO(comp_surf->get_surface(i),
1490 [ # # ]: 0 : TopologyBridge));
1491 : : else
1492 : : {
1493 [ # # ][ # # ]: 0 : if(dynamic_cast<Surface*>(part_surf->partitioned_entity()))
[ # # ]
1494 : : {
1495 : 0 : surf_list.append_unique(CAST_TO(part_surf->partitioned_entity(),
1496 [ # # ]: 0 : TopologyBridge));
1497 : : }
1498 : : }
1499 : : }
1500 : : }
1501 [ # # ]: 0 : else if ( part_surf )
1502 : 0 : surf_list.append(CAST_TO(part_surf->partitioned_entity(),
1503 [ # # ]: 0 : TopologyBridge));
1504 : 0 : return CUBIT_SUCCESS;
1505 : : }
1506 : :
1507 : 0 : CubitStatus VirtualQueryEngine::get_underlying_bridges(TopologyBridge* bridge_ptr,
1508 : : DLIList<TopologyBridge*>& bridge_list)
1509 : : {
1510 [ # # ]: 0 : assert (bridge_ptr);
1511 [ # # ]: 0 : CompositeSurface *comp_surf = CAST_TO(bridge_ptr, CompositeSurface);
1512 [ # # ]: 0 : PartitionSurface *part_surf = CAST_TO(bridge_ptr, PartitionSurface);
1513 [ # # ]: 0 : CompositeCurve *comp_curve = CAST_TO(bridge_ptr, CompositeCurve);
1514 [ # # ]: 0 : PartitionCurve *part_curve = CAST_TO(bridge_ptr, PartitionCurve);
1515 [ # # ]: 0 : CompositePoint *comp_point = CAST_TO(bridge_ptr, CompositePoint);
1516 [ # # ]: 0 : PartitionPoint *part_point = CAST_TO(bridge_ptr, PartitionPoint);
1517 [ # # ]: 0 : PartitionBody *part_body = CAST_TO(bridge_ptr, PartitionBody);
1518 : :
1519 [ # # ]: 0 : if (part_body )
1520 : : {
1521 [ # # ]: 0 : bridge_list.append( part_body->partitioned_entity() );
1522 : : }
1523 [ # # ]: 0 : else if ( comp_surf )
1524 : : {
1525 : : int i;
1526 [ # # ]: 0 : for (i = 0; i < comp_surf->num_surfs(); i ++)
1527 : : {
1528 [ # # ]: 0 : part_surf = CAST_TO(comp_surf->get_surface(i), PartitionSurface);
1529 [ # # ]: 0 : if (!part_surf)
1530 : 0 : bridge_list.append_unique(CAST_TO(comp_surf->get_surface(i),
1531 [ # # ]: 0 : TopologyBridge));
1532 : : else
1533 : : {
1534 [ # # ][ # # ]: 0 : if(dynamic_cast<Surface*>(part_surf->partitioned_entity()))
[ # # ]
1535 : : {
1536 : 0 : bridge_list.append_unique(CAST_TO(part_surf->partitioned_entity(),
1537 [ # # ]: 0 : TopologyBridge));
1538 : : }
1539 : : }
1540 : : }
1541 : : }
1542 [ # # ]: 0 : else if ( part_surf )
1543 [ # # ]: 0 : bridge_list.append( part_surf->partitioned_entity() );
1544 [ # # ]: 0 : else if ( comp_curve )
1545 : : {
1546 : : int i;
1547 [ # # ]: 0 : for (i = 0; i < comp_curve->num_curves(); i ++)
1548 : : {
1549 [ # # ]: 0 : part_curve = CAST_TO(comp_curve->get_curve(i), PartitionCurve);
1550 [ # # ]: 0 : if (!part_curve)
1551 [ # # ]: 0 : bridge_list.append_unique(comp_curve->get_curve(i));
1552 : : else
1553 : : {
1554 [ # # ][ # # ]: 0 : if(dynamic_cast<Curve*>(part_curve->partitioned_entity()))
[ # # ]
1555 : : {
1556 [ # # ]: 0 : bridge_list.append_unique( part_curve->partitioned_entity() );
1557 : : }
1558 : : }
1559 : : }
1560 : : }
1561 [ # # ]: 0 : else if ( part_curve )
1562 [ # # ]: 0 : bridge_list.append( part_curve->partitioned_entity() );
1563 [ # # ]: 0 : else if ( part_point )
1564 : : {
1565 [ # # ]: 0 : TopologyBridge *tb_point = part_point->real_point();
1566 [ # # ]: 0 : if( tb_point )
1567 [ # # ]: 0 : bridge_list.append( tb_point );
1568 : : }
1569 [ # # ]: 0 : else if ( comp_point )
1570 : : {
1571 [ # # ]: 0 : TopologyBridge *tb_point = comp_point->get_point();
1572 [ # # ]: 0 : if( tb_point )
1573 [ # # ]: 0 : bridge_list.append( tb_point );
1574 : : }
1575 : :
1576 : 0 : return CUBIT_SUCCESS;
1577 : : }
1578 : :
1579 : : //================================================================================
1580 : : // Description: Find extrema position on an entity list
1581 : : // Author :
1582 : : // Date :
1583 : : //================================================================================
1584 : : CubitStatus
1585 : 0 : VirtualQueryEngine::entity_extrema( DLIList<GeometryEntity*> &,
1586 : : const CubitVector *,
1587 : : const CubitVector *,
1588 : : const CubitVector *,
1589 : : CubitVector &,
1590 : : GeometryEntity *& )
1591 : : {
1592 [ # # ][ # # ]: 0 : PRINT_ERROR("Entity extrema calculation not yet supported for virtual geometry.\n");
1593 : 0 : return CUBIT_FAILURE;
1594 : : }
1595 : :
1596 : : //================================================================================
1597 : : // Description: Find distance between two entities and closest positions.
1598 : : // Author :
1599 : : // Date :
1600 : : //================================================================================
1601 : : CubitStatus
1602 : 0 : VirtualQueryEngine::entity_entity_distance( GeometryEntity *ge1,
1603 : : GeometryEntity *ge2,
1604 : : CubitVector &p1, CubitVector &p2,
1605 : : double &distance )
1606 : : {
1607 [ # # ]: 0 : CompositeCurve *cc1 = dynamic_cast<CompositeCurve*>(ge1);
1608 [ # # ]: 0 : CompositeCurve *cc2 = dynamic_cast<CompositeCurve*>(ge2);
1609 [ # # ]: 0 : CompositeSurface *cs1 = dynamic_cast<CompositeSurface*>(ge1);
1610 [ # # ]: 0 : CompositeSurface *cs2 = dynamic_cast<CompositeSurface*>(ge2);
1611 : :
1612 [ # # ]: 0 : DLIList<GeometryEntity*> geometry_entities_1;
1613 [ # # ][ # # ]: 0 : DLIList<GeometryEntity*> geometry_entities_2;
1614 [ # # ][ # # ]: 0 : DLIList<GeometryQueryEngine*> gqes_1;
1615 [ # # ][ # # ]: 0 : DLIList<GeometryQueryEngine*> gqes_2;
1616 : :
1617 : : int i, j;
1618 : 0 : int still_ok = 1;
1619 : :
1620 [ # # ]: 0 : if(cc1)
1621 : : {
1622 [ # # ][ # # ]: 0 : for(i=cc1->num_curves()-1; i>-1 && still_ok; i--)
[ # # ]
1623 : : {
1624 [ # # ]: 0 : GeometryEntity *ge = cc1->get_curve(i);
1625 [ # # ][ # # ]: 0 : if(dynamic_cast<PartitionEntity*>(ge))
[ # # ]
1626 : 0 : still_ok = 0;
1627 [ # # ]: 0 : GeometryQueryEngine *gqe = ge->get_geometry_query_engine();
1628 [ # # ]: 0 : geometry_entities_1.append(ge);
1629 [ # # ]: 0 : gqes_1.append(gqe);
1630 : : }
1631 : : }
1632 [ # # ]: 0 : else if(cs1)
1633 : : {
1634 [ # # ][ # # ]: 0 : for(i=cs1->num_surfs()-1; i>-1 && still_ok; i--)
[ # # ]
1635 : : {
1636 [ # # ]: 0 : GeometryEntity *ge = cs1->get_surface(i);
1637 [ # # ][ # # ]: 0 : if(dynamic_cast<PartitionEntity*>(ge))
[ # # ]
1638 : 0 : still_ok = 0;
1639 [ # # ]: 0 : GeometryQueryEngine *gqe = ge->get_geometry_query_engine();
1640 [ # # ]: 0 : geometry_entities_1.append(ge);
1641 [ # # ]: 0 : gqes_1.append(gqe);
1642 : : }
1643 : : }
1644 : : else
1645 : : {
1646 [ # # ][ # # ]: 0 : if(dynamic_cast<PartitionEntity*>(ge1))
[ # # ]
1647 : 0 : still_ok = 0;
1648 [ # # ][ # # ]: 0 : else if(dynamic_cast<Curve*>(ge1) || dynamic_cast<Surface*>(ge1))
[ # # ][ # # ]
[ # # ]
1649 : : {
1650 [ # # ]: 0 : GeometryQueryEngine *gqe = ge1->get_geometry_query_engine();
1651 [ # # ]: 0 : geometry_entities_1.append(ge1);
1652 [ # # ]: 0 : gqes_1.append(gqe);
1653 : : }
1654 : : else
1655 : : {
1656 [ # # ][ # # ]: 0 : PRINT_ERROR("Entity-entity distance not yet supported for virtual geometry.\n");
[ # # ][ # # ]
1657 : 0 : return CUBIT_FAILURE;
1658 : : }
1659 : : }
1660 [ # # ]: 0 : if(cc2)
1661 : : {
1662 [ # # ][ # # ]: 0 : for(i=cc2->num_curves()-1; i>-1 && still_ok; i--)
[ # # ]
1663 : : {
1664 [ # # ]: 0 : GeometryEntity *ge = cc2->get_curve(i);
1665 [ # # ][ # # ]: 0 : if(dynamic_cast<PartitionEntity*>(ge))
[ # # ]
1666 : 0 : still_ok = 0;
1667 [ # # ]: 0 : GeometryQueryEngine *gqe = ge->get_geometry_query_engine();
1668 [ # # ]: 0 : geometry_entities_2.append(ge);
1669 [ # # ]: 0 : gqes_2.append(gqe);
1670 : : }
1671 : : }
1672 [ # # ]: 0 : else if(cs2)
1673 : : {
1674 [ # # ][ # # ]: 0 : for(i=cs2->num_surfs()-1; i>-1 && still_ok; i--)
[ # # ]
1675 : : {
1676 [ # # ]: 0 : GeometryEntity *ge = cs2->get_surface(i);
1677 [ # # ][ # # ]: 0 : if(dynamic_cast<PartitionEntity*>(ge))
[ # # ]
1678 : 0 : still_ok = 0;
1679 [ # # ]: 0 : GeometryQueryEngine *gqe = ge->get_geometry_query_engine();
1680 [ # # ]: 0 : geometry_entities_2.append(ge);
1681 [ # # ]: 0 : gqes_2.append(gqe);
1682 : : }
1683 : : }
1684 : : else
1685 : : {
1686 [ # # ][ # # ]: 0 : if(dynamic_cast<PartitionEntity*>(ge2))
[ # # ]
1687 : 0 : still_ok = 0;
1688 [ # # ][ # # ]: 0 : else if(dynamic_cast<Curve*>(ge2) || dynamic_cast<Surface*>(ge2))
[ # # ][ # # ]
[ # # ]
1689 : : {
1690 [ # # ]: 0 : GeometryQueryEngine *gqe = ge2->get_geometry_query_engine();
1691 [ # # ]: 0 : geometry_entities_2.append(ge2);
1692 [ # # ]: 0 : gqes_2.append(gqe);
1693 : : }
1694 : : else
1695 : : {
1696 [ # # ][ # # ]: 0 : PRINT_ERROR("Entity-entity distance not yet supported for virtual geometry.\n");
[ # # ][ # # ]
1697 : 0 : return CUBIT_FAILURE;
1698 : : }
1699 : : }
1700 : :
1701 [ # # ]: 0 : if(still_ok)
1702 : : {
1703 : 0 : double smallest_distance = CUBIT_DBL_MAX;
1704 [ # # ][ # # ]: 0 : for(i=geometry_entities_1.size(); i--;)
1705 : : {
1706 [ # # ]: 0 : GeometryEntity *ge1 = geometry_entities_1.get_and_step();
1707 [ # # ]: 0 : GeometryQueryEngine *gqe1 = gqes_1.get_and_step();
1708 [ # # ][ # # ]: 0 : for(j=geometry_entities_2.size(); j--;)
1709 : : {
1710 [ # # ]: 0 : GeometryEntity *ge2 = geometry_entities_2.get_and_step();
1711 : : //GeometryQueryEngine *gqe2 = gqes_2.get_and_step();
1712 : :
1713 [ # # ][ # # ]: 0 : CubitVector cur_pos1, cur_pos2;
1714 : : double cur_distance;
1715 : :
1716 [ # # ]: 0 : gqe1->entity_entity_distance(ge1, ge2, cur_pos1, cur_pos2, cur_distance);
1717 : :
1718 [ # # ]: 0 : if(cur_distance < smallest_distance)
1719 : : {
1720 : 0 : smallest_distance = cur_distance;
1721 : 0 : distance = cur_distance;
1722 [ # # ]: 0 : p1 = cur_pos1;
1723 [ # # ]: 0 : p2 = cur_pos2;
1724 : : }
1725 : : }
1726 : : }
1727 : : }
1728 : : else
1729 : : {
1730 [ # # ][ # # ]: 0 : PRINT_ERROR("Entity-entity distance not yet supported for virtual geometry.\n");
[ # # ][ # # ]
1731 : 0 : return CUBIT_FAILURE;
1732 : : }
1733 : :
1734 [ # # ]: 0 : return CUBIT_SUCCESS;
1735 : : }
1736 : :
1737 : : //-------------------------------------------------------------------------
1738 : : // Purpose : Remove all possible virtual geometry.
1739 : : //
1740 : : // Special Notes :
1741 : : //
1742 : : // Creator : Jason Kraftcheck
1743 : : //
1744 : : // Creation Date : 06/28/00
1745 : : //-------------------------------------------------------------------------
1746 : 0 : void VirtualQueryEngine::remove_virtual_geometry( RefEntity* entity_ptr,
1747 : : CubitBoolean all_children )
1748 : : {
1749 [ # # ][ # # ]: 0 : if ( Body* body_ptr = dynamic_cast<Body*>(entity_ptr) )
1750 : 0 : remove_virtual_geometry(body_ptr, all_children);
1751 [ # # ][ # # ]: 0 : else if( RefVolume* vol_ptr = dynamic_cast<RefVolume*>(entity_ptr) )
1752 : 0 : remove_virtual_geometry(vol_ptr, all_children);
1753 [ # # ][ # # ]: 0 : else if( RefFace* face_ptr = dynamic_cast<RefFace*>(entity_ptr) )
1754 : 0 : remove_virtual_geometry(face_ptr);
1755 : 0 : }
1756 : :
1757 : 0 : void VirtualQueryEngine::remove_virtual_geometry( Body* body_ptr,
1758 : : bool all_children )
1759 : : {
1760 : : int i;
1761 [ # # ][ # # ]: 0 : DLIList<RefVolume*> volumes, part_results;
[ # # ][ # # ]
1762 [ # # ]: 0 : body_ptr->ref_volumes(volumes);
1763 [ # # ][ # # ]: 0 : for ( i = volumes.size(); i--; ) {
1764 [ # # ]: 0 : RefVolume* vol = volumes.step_and_get();
1765 [ # # ][ # # ]: 0 : if ( ! dynamic_cast<PartitionLump*>(vol->get_lump_ptr()) )
[ # # ][ # # ]
1766 [ # # ]: 0 : volumes.change_to(0);
1767 : : }
1768 [ # # ]: 0 : volumes.remove_all_with_value(0);
1769 [ # # ][ # # ]: 0 : if ( volumes.size() )
1770 [ # # ][ # # ]: 0 : PartitionTool::instance()->unpartitionAll(volumes, part_results);
1771 : :
1772 [ # # ]: 0 : if ( !all_children )
1773 : 0 : return;
1774 : :
1775 [ # # ]: 0 : volumes.clean_out();
1776 [ # # ]: 0 : body_ptr->ref_volumes(volumes);
1777 [ # # ][ # # ]: 0 : for ( i = volumes.size(); i--; )
[ # # ][ # # ]
1778 [ # # ][ # # ]: 0 : remove_virtual_geometry( volumes.step_and_get(), true );
1779 : : }
1780 : :
1781 : 0 : void VirtualQueryEngine::remove_virtual_geometry( RefVolume* vol_ptr,
1782 : : bool all_children )
1783 : : {
1784 : : int i;
1785 [ # # ][ # # ]: 0 : DLIList<RefFace*> faces, part_results;
[ # # ][ # # ]
1786 : 0 : bool had_virtual_geometry = false;
1787 [ # # ]: 0 : vol_ptr->ref_faces( faces );
1788 [ # # ][ # # ]: 0 : for ( i = faces.size(); i--; )
1789 : : {
1790 [ # # ][ # # ]: 0 : if ( dynamic_cast<CompositeSurface*>(faces.step_and_get()->get_surface_ptr()) )
[ # # ][ # # ]
[ # # ]
1791 : : {
1792 [ # # ][ # # ]: 0 : CompositeTool::instance()->uncomposite(faces.get());
[ # # ]
1793 : 0 : had_virtual_geometry = true;
1794 : : }
1795 : : }
1796 : :
1797 [ # # ]: 0 : faces.clean_out();
1798 [ # # ]: 0 : vol_ptr->ref_faces( faces );
1799 [ # # ][ # # ]: 0 : for ( i = faces.size(); i--; )
1800 : : {
1801 [ # # ][ # # ]: 0 : if ( !dynamic_cast<PartitionSurface*>(faces.step_and_get()->get_surface_ptr()))
[ # # ][ # # ]
[ # # ]
1802 [ # # ]: 0 : faces.change_to(0);
1803 : : }
1804 [ # # ]: 0 : faces.remove_all_with_value(0);
1805 [ # # ][ # # ]: 0 : if ( faces.size() )
1806 : : {
1807 [ # # ][ # # ]: 0 : PartitionTool::instance()->unpartitionAll(faces, part_results);
1808 : 0 : had_virtual_geometry = true;
1809 : : }
1810 : :
1811 [ # # ]: 0 : if ( !all_children )
1812 : 0 : return;
1813 : :
1814 [ # # ]: 0 : faces.clean_out();
1815 [ # # ]: 0 : vol_ptr->ref_faces( faces );
1816 [ # # ][ # # ]: 0 : for ( i = faces.size(); i--; )
1817 [ # # ][ # # ]: 0 : remove_virtual_geometry( faces.step_and_get() );
1818 : :
1819 [ # # ]: 0 : if( had_virtual_geometry )
1820 [ # # ][ # # ]: 0 : AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOPOLOGY_MODIFIED, vol_ptr));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1821 : : }
1822 : :
1823 : 0 : void VirtualQueryEngine::remove_virtual_geometry( RefFace* face_ptr )
1824 : : {
1825 : : int i;
1826 [ # # ][ # # ]: 0 : DLIList<RefEdge*> edges, part_results;
[ # # ]
1827 [ # # ]: 0 : face_ptr->ref_edges( edges );
1828 [ # # ][ # # ]: 0 : for ( i = edges.size(); i--; ) {
1829 [ # # ][ # # ]: 0 : if ( dynamic_cast<CompositeCurve*>(edges.step_and_get()->get_curve_ptr()) )
[ # # ][ # # ]
[ # # ]
1830 [ # # ][ # # ]: 0 : CompositeTool::instance()->uncomposite(edges.get());
[ # # ]
1831 : : }
1832 : :
1833 [ # # ]: 0 : edges.clean_out();
1834 [ # # ]: 0 : face_ptr->ref_edges( edges );
1835 [ # # ][ # # ]: 0 : for ( i = edges.size(); i--; ) {
1836 [ # # ][ # # ]: 0 : if ( !dynamic_cast<PartitionCurve*>(edges.step_and_get()->get_curve_ptr()))
[ # # ][ # # ]
[ # # ]
1837 [ # # ]: 0 : edges.change_to(0);
1838 : : }
1839 [ # # ]: 0 : edges.remove_all_with_value(0);
1840 [ # # ][ # # ]: 0 : if ( edges.size() )
1841 [ # # ][ # # ]: 0 : PartitionTool::instance()->unpartitionAll(edges, part_results);
[ # # ]
1842 : 0 : }
1843 : :
1844 : :
1845 : :
1846 : :
1847 : 0 : CubitStatus VirtualQueryEngine::export_solid_model( DLIList<TopologyBridge*>& ,
1848 : : const char* ,
1849 : : Model_File_Type ,
1850 : : const CubitString &,
1851 : : ModelExportOptions & )
1852 : : {
1853 : 0 : return CUBIT_FAILURE;
1854 : : }
1855 : :
1856 : 0 : CubitStatus VirtualQueryEngine::save_temp_geom_file( DLIList<TopologyBridge*>& ,
1857 : : const char* ,
1858 : : const CubitString &,
1859 : : CubitString &,
1860 : : CubitString &)
1861 : : {
1862 : 0 : return CUBIT_FAILURE;
1863 : : }
1864 : :
1865 : 0 : CubitStatus VirtualQueryEngine::import_solid_model( const char* ,
1866 : : Model_File_Type,
1867 : : DLIList<TopologyBridge*>&,
1868 : : ModelImportOptions &import_options )
1869 : : {
1870 [ # # ][ # # ]: 0 : PRINT_INFO("VirtualQueryEngine::import_solid_model\n");
1871 : :
1872 : 0 : default_error_message( "import_solid_model()");
1873 : 0 : return CUBIT_FAILURE;
1874 : : }
1875 : :
1876 : 0 : void VirtualQueryEngine::delete_solid_model_entities(DLIList<BodySM*>& list) const
1877 : : {
1878 [ # # ]: 0 : for ( int i = list.size(); i--; )
1879 : 0 : delete_solid_model_entities( list.get_and_step() );
1880 : 0 : }
1881 : :
1882 : :
1883 : :
1884 : 0 : CubitStatus VirtualQueryEngine::delete_solid_model_entities(
1885 : : BodySM* bodysm ) const
1886 : : {
1887 [ # # ]: 0 : CompositeBody* compbod = dynamic_cast<CompositeBody*>(bodysm);
1888 [ # # ]: 0 : if (compbod)
1889 : : {
1890 [ # # ]: 0 : while (compbod->num_bodies())
1891 : : {
1892 : 0 : BodySM* dead_body = compbod->get_body( compbod->num_bodies() - 1 );
1893 : 0 : dead_body->get_geometry_query_engine()->delete_solid_model_entities( dead_body );
1894 : : }
1895 : :
1896 : 0 : CompositeEngine::instance().clean_out_deactivated_geometry();
1897 : 0 : return CUBIT_SUCCESS;
1898 : : }
1899 : :
1900 : :
1901 [ # # ]: 0 : PartitionBody* bod = dynamic_cast<PartitionBody*>(bodysm);
1902 [ # # ]: 0 : if ( !bod )
1903 : 0 : return CUBIT_FAILURE;
1904 : :
1905 : 0 : PartitionEngine::instance().delete_solid_model_entities( bod, bodysm );
1906 [ # # ]: 0 : if ( bodysm ) {
1907 : 0 : bodysm->get_geometry_query_engine()->delete_solid_model_entities(bodysm);
1908 : : }
1909 : 0 : return CUBIT_SUCCESS;
1910 : : }
1911 : :
1912 : 0 : CubitStatus VirtualQueryEngine::delete_solid_model_entities(
1913 : : Surface* surf_ptr ) const
1914 : : {
1915 [ # # ]: 0 : PartitionSurface* ps_ptr = dynamic_cast<PartitionSurface*>(surf_ptr);
1916 [ # # ]: 0 : CompositeSurface* cs_ptr = dynamic_cast<CompositeSurface*>(surf_ptr);
1917 : :
1918 [ # # ]: 0 : if (cs_ptr)
1919 : : {
1920 [ # # ]: 0 : while(cs_ptr->num_surfs())
1921 : : {
1922 : 0 : Surface* dead_surf = cs_ptr->get_surface(cs_ptr->num_surfs()-1);
1923 : 0 : dead_surf->get_geometry_query_engine()->delete_solid_model_entities(dead_surf);
1924 : : }
1925 : :
1926 : 0 : CompositeEngine::instance().clean_out_deactivated_geometry();
1927 : : }
1928 : :
1929 [ # # ]: 0 : else if( ps_ptr )
1930 : : {
1931 : 0 : PartitionEngine::instance().delete_solid_model_entities( ps_ptr, surf_ptr );
1932 [ # # ]: 0 : if ( surf_ptr )
1933 : 0 : surf_ptr->get_geometry_query_engine()->delete_solid_model_entities(surf_ptr);
1934 : : }
1935 : :
1936 : 0 : return CUBIT_SUCCESS;
1937 : : }
1938 : :
1939 : 0 : CubitStatus VirtualQueryEngine::delete_solid_model_entities(
1940 : : Curve* curve_ptr ) const
1941 : : {
1942 [ # # ]: 0 : CompositeCurve* cc_ptr = dynamic_cast<CompositeCurve*>(curve_ptr);
1943 [ # # ]: 0 : PartitionCurve* pc_ptr = dynamic_cast<PartitionCurve*>(curve_ptr);
1944 : :
1945 [ # # ]: 0 : if( cc_ptr )
1946 : : {
1947 [ # # ]: 0 : while(cc_ptr->num_curves())
1948 : : {
1949 : 0 : Curve* dead_curv = cc_ptr->get_curve(cc_ptr->num_curves()-1);
1950 : 0 : dead_curv->get_geometry_query_engine()->delete_solid_model_entities(dead_curv);
1951 : : }
1952 : :
1953 : 0 : CompositeEngine::instance().clean_out_deactivated_geometry();
1954 : : }
1955 [ # # ]: 0 : else if( pc_ptr )
1956 : : {
1957 : 0 : PartitionEngine::instance().delete_solid_model_entities( pc_ptr, curve_ptr );
1958 [ # # ]: 0 : if ( curve_ptr )
1959 : 0 : curve_ptr->get_geometry_query_engine()->delete_solid_model_entities(curve_ptr);
1960 : : }
1961 : :
1962 : 0 : return CUBIT_SUCCESS;
1963 : : }
1964 : :
1965 : 0 : CubitStatus VirtualQueryEngine::delete_solid_model_entities( TBPoint* ) const
1966 : : {
1967 : 0 : return CUBIT_FAILURE;
1968 : : }
1969 : :
1970 : 0 : CubitStatus VirtualQueryEngine::fire_ray( CubitVector &origin,
1971 : : CubitVector &direction,
1972 : : DLIList<TopologyBridge*> &at_entity_list,
1973 : : DLIList<double> &ray_params,
1974 : : int max_hits,
1975 : : double ray_radius,
1976 : : DLIList<TopologyBridge*> *hit_entity_list_ptr) const
1977 : : {
1978 : : // Note: for now assume we will only get curves or surfaces
1979 : :
1980 : : int i;
1981 : 0 : int prev_num_hits = ray_params.size();
1982 : 0 : GeometryQueryEngine *gqe = 0;
1983 : : TopologyBridge *bridge_ptr;
1984 : :
1985 : : // This is only needed because this function is "const"
1986 : 0 : VirtualQueryEngine *vqe = VirtualQueryEngine::instance();
1987 : :
1988 : 0 : at_entity_list.reset();
1989 [ # # ]: 0 : for( i=at_entity_list.size(); i--; )
1990 : : {
1991 : 0 : prev_num_hits = ray_params.size();
1992 : 0 : bridge_ptr = at_entity_list.get_and_step();
1993 : :
1994 : 0 : gqe = bridge_ptr->get_geometry_query_engine();
1995 [ # # ]: 0 : if( !gqe )
1996 : : {
1997 [ # # ][ # # ]: 0 : PRINT_ERROR( "Unable to find geometry engine associated with an entity!\n" );
1998 : 0 : return CUBIT_FAILURE;
1999 : : }
2000 : :
2001 [ # # ]: 0 : Curve *curve_ptr = CAST_TO( bridge_ptr, Curve );
2002 [ # # ]: 0 : if( curve_ptr )
2003 : : {
2004 [ # # ]: 0 : DLIList<TopologyBridge*> tb_curve_list;
2005 [ # # ]: 0 : vqe->get_underlying_curves( curve_ptr, tb_curve_list );
2006 : :
2007 [ # # ][ # # ]: 0 : if( tb_curve_list.size() > 0 )
2008 : : {
2009 [ # # ][ # # ]: 0 : gqe = tb_curve_list.get()->get_geometry_query_engine();
2010 : :
2011 : : gqe->fire_ray( origin, direction, tb_curve_list, ray_params, max_hits,
2012 [ # # ]: 0 : ray_radius, hit_entity_list_ptr );
2013 : :
2014 : : // If curve_ptr is a PartitionCurve, it could be smaller than the underlying curve.
2015 : : // This means we have to check to make sure any hit points lie inside the curve. Remove if they don't.
2016 [ # # ][ # # ]: 0 : if (CAST_TO(curve_ptr, PartitionCurve))
[ # # ]
2017 : : {
2018 : : // start iterating at the first new ray_param
2019 [ # # ]: 0 : ray_params.reset();
2020 [ # # ]: 0 : ray_params.step(prev_num_hits);
2021 [ # # ]: 0 : hit_entity_list_ptr->reset();
2022 [ # # ]: 0 : hit_entity_list_ptr->step(prev_num_hits);
2023 : :
2024 : : int j;
2025 [ # # ][ # # ]: 0 : for (j=prev_num_hits; j<ray_params.size(); j++)
2026 : : {
2027 : : CubitVector *loc_ptr;
2028 [ # # ]: 0 : double param = ray_params.get();
2029 : :
2030 [ # # ][ # # ]: 0 : loc_ptr = new CubitVector;
2031 [ # # ]: 0 : origin.next_point( direction, param, *loc_ptr );
2032 : :
2033 : 0 : CubitPointContainment containment = CUBIT_PNT_UNKNOWN;
2034 [ # # ]: 0 : containment = curve_ptr->point_containment(*loc_ptr);
2035 [ # # ][ # # ]: 0 : if ( (containment != CUBIT_PNT_ON) && (containment != CUBIT_PNT_BOUNDARY) )
2036 : : {
2037 : : //remove from the hit list
2038 [ # # ]: 0 : ray_params.remove();
2039 [ # # ]: 0 : hit_entity_list_ptr->remove();
2040 : : }
2041 : : else
2042 : : {
2043 [ # # ]: 0 : ray_params.step();
2044 [ # # ]: 0 : hit_entity_list_ptr->step();
2045 : : }
2046 : : }
2047 : : }
2048 : :
2049 [ # # ]: 0 : }
2050 : : }
2051 : :
2052 [ # # ]: 0 : Surface *surface_ptr = CAST_TO( bridge_ptr, Surface );
2053 [ # # ]: 0 : if( surface_ptr )
2054 : : {
2055 [ # # ]: 0 : DLIList<TopologyBridge*> tb_surface_list;
2056 [ # # ]: 0 : vqe->get_underlying_surfaces( surface_ptr, tb_surface_list );
2057 : :
2058 [ # # ][ # # ]: 0 : if( tb_surface_list.size() > 0 )
2059 : : {
2060 [ # # ][ # # ]: 0 : gqe = tb_surface_list.get()->get_geometry_query_engine();
2061 : :
2062 : : gqe->fire_ray( origin, direction, tb_surface_list, ray_params, max_hits,
2063 [ # # ]: 0 : ray_radius, hit_entity_list_ptr );
2064 : :
2065 : : // If surface_ptr is a PartitionSurface, it could be smaller than the underlying surface.
2066 : : // This means we have to check to make sure any hit points lie inside the surface. Remove if they don't.
2067 [ # # ][ # # ]: 0 : if (CAST_TO(surface_ptr, PartitionSurface))
[ # # ]
2068 : : {
2069 : : // start iterating at the first new ray_param
2070 [ # # ]: 0 : ray_params.reset();
2071 [ # # ]: 0 : ray_params.step(prev_num_hits);
2072 [ # # ]: 0 : hit_entity_list_ptr->reset();
2073 [ # # ]: 0 : hit_entity_list_ptr->step(prev_num_hits);
2074 : :
2075 : : int j;
2076 [ # # ][ # # ]: 0 : for (j=prev_num_hits; j<ray_params.size(); j++)
2077 : : {
2078 : : CubitVector *loc_ptr;
2079 [ # # ]: 0 : double param = ray_params.get();
2080 : :
2081 [ # # ][ # # ]: 0 : loc_ptr = new CubitVector;
2082 [ # # ]: 0 : origin.next_point( direction, param, *loc_ptr );
2083 : :
2084 : 0 : CubitPointContainment containment = CUBIT_PNT_UNKNOWN;
2085 [ # # ]: 0 : containment = surface_ptr->point_containment(*loc_ptr);
2086 [ # # ][ # # ]: 0 : if ( (containment != CUBIT_PNT_ON) && (containment != CUBIT_PNT_BOUNDARY) )
2087 : : {
2088 : : //remove from the hit list
2089 [ # # ]: 0 : ray_params.remove();
2090 [ # # ]: 0 : hit_entity_list_ptr->remove();
2091 : : }
2092 : : else
2093 : : {
2094 [ # # ]: 0 : ray_params.step();
2095 [ # # ]: 0 : hit_entity_list_ptr->step();
2096 : : }
2097 : : }
2098 : : }
2099 : :
2100 [ # # ]: 0 : }
2101 : : }
2102 : :
2103 : : }
2104 : :
2105 [ # # ][ # # ]: 0 : if( hit_entity_list_ptr && hit_entity_list_ptr->size() != ray_params.size() )
[ # # ]
2106 [ # # ][ # # ]: 0 : PRINT_WARNING( "Hit entity list size not equal to number of hits\n" );
2107 : :
2108 : : // Account for max hits
2109 [ # # ]: 0 : if( max_hits != 0 )
2110 : : {
2111 [ # # ]: 0 : if( ray_params.size() <= max_hits )
2112 : 0 : return CUBIT_SUCCESS;
2113 : :
2114 [ # # ]: 0 : for( i=ray_params.size()-max_hits; i--; )
2115 : : {
2116 : 0 : ray_params.last();
2117 : 0 : ray_params.remove();
2118 [ # # ]: 0 : if( hit_entity_list_ptr )
2119 : : {
2120 : 0 : hit_entity_list_ptr->last();
2121 : 0 : hit_entity_list_ptr->remove();
2122 : : }
2123 : : }
2124 : : }
2125 : :
2126 : 0 : return CUBIT_SUCCESS;
2127 : : }
2128 : :
2129 : 0 : double VirtualQueryEngine::get_sme_resabs_tolerance() const
2130 : : {
2131 : 0 : return GEOMETRY_RESABS;
2132 : : }
2133 : :
2134 : 0 : double VirtualQueryEngine::set_sme_resabs_tolerance( double )
2135 : : {
2136 [ # # ][ # # ]: 0 : PRINT_INFO("VirtualQueryEngine::set_sme_resabs_tolerance\n");
2137 : :
2138 : 0 : default_error_message( "set_sme_resabs_tolerance()");
2139 : 0 : return 0;
2140 : : }
2141 : :
2142 : 0 : CubitStatus VirtualQueryEngine::set_int_option( const char* , int )
2143 : : {
2144 [ # # ][ # # ]: 0 : PRINT_INFO("VirtualQueryEngine::set_int_option\n");
2145 : :
2146 : 0 : default_error_message( "set_int_option()");
2147 : 0 : return CUBIT_FAILURE;
2148 : : }
2149 : :
2150 : 0 : CubitStatus VirtualQueryEngine::set_dbl_option( const char* , double )
2151 : : {
2152 [ # # ][ # # ]: 0 : PRINT_INFO("VirtualQueryEngine::set_dbl_option\n");
2153 : :
2154 : 0 : default_error_message( "set_dbl_option()");
2155 : 0 : return CUBIT_FAILURE;
2156 : : }
2157 : :
2158 : 0 : CubitStatus VirtualQueryEngine::set_str_option( const char* , const char* )
2159 : : {
2160 [ # # ][ # # ]: 0 : PRINT_INFO("VirtualQueryEngine::set_str_option\n");
2161 : :
2162 : 0 : default_error_message( "set_str_option()");
2163 : 0 : return CUBIT_FAILURE;
2164 : : }
2165 : :
2166 : 841 : void VirtualQueryEngine::register_attributes()
2167 : : {
2168 : : CubitStatus result;
2169 : : result = CGMApp::instance()->attrib_manager()->register_attrib_type(
2170 : : CA_PARTITION_VG, "partition vg", "PARTITION_VG",
2171 : : CAPartitionVG_creator, CUBIT_FALSE,
2172 : : CUBIT_FALSE, CUBIT_TRUE, CUBIT_TRUE,
2173 : 841 : CUBIT_FALSE, CUBIT_FALSE);
2174 [ - + ]: 841 : if (CUBIT_SUCCESS != result) {
2175 [ # # ][ # # ]: 0 : PRINT_ERROR("Failed to register attribute type partition vg.\n");
2176 : 0 : return;
2177 : : }
2178 : :
2179 : : result = CGMApp::instance()->attrib_manager()->register_attrib_type(
2180 : : CA_COMPOSITE_VG, "composite vg", "COMPOSITE_VG",
2181 : : CACompositeVG_creator, CUBIT_FALSE,
2182 : : CUBIT_FALSE, CUBIT_TRUE, CUBIT_TRUE,
2183 : 841 : CUBIT_FALSE, CUBIT_FALSE);
2184 [ - + ]: 841 : if (CUBIT_SUCCESS != result) {
2185 [ # # ][ # # ]: 0 : PRINT_ERROR("Failed to register attribute type composite vg.\n");
2186 : 0 : return;
2187 : : }
2188 : :
2189 : : result = CGMApp::instance()->attrib_manager()->register_attrib_type(
2190 : : CA_VIRTUAL_VG, "virtual vg", "VIRTUAL_VG",
2191 : : CAVirtualVG_creator, CUBIT_FALSE,
2192 : : CUBIT_FALSE, CUBIT_TRUE, CUBIT_TRUE,
2193 : 841 : CUBIT_FALSE, CUBIT_FALSE);
2194 [ - + ]: 841 : if (CUBIT_SUCCESS != result) {
2195 [ # # ][ # # ]: 841 : PRINT_ERROR("Failed to register attribute type virtual vg.\n");
2196 : : }
2197 : : }
2198 : :
2199 : :
2200 : :
2201 : 0 : CubitStatus VirtualQueryEngine::translate( BodySM* body,
2202 : : const CubitVector& offset )
2203 : : {
2204 [ # # ][ # # ]: 0 : if (PartitionBody* part = dynamic_cast<PartitionBody*>(body))
2205 : 0 : return PartitionEngine::instance().translate( part, offset );
2206 [ # # ][ # # ]: 0 : else if(CompositeBody* comp = dynamic_cast<CompositeBody*>(body))
2207 : 0 : return CompositeEngine::instance().translate( comp, offset );
2208 : :
2209 [ # # ][ # # ]: 0 : PRINT_ERROR("Non-virtual entity in VGE::translate.\n");
2210 : 0 : return CUBIT_FAILURE;
2211 : : }
2212 : :
2213 : 0 : CubitStatus VirtualQueryEngine::rotate ( BodySM* body,
2214 : : const CubitVector& axis,
2215 : : double angle )
2216 : : {
2217 [ # # ][ # # ]: 0 : if (PartitionBody* part = dynamic_cast<PartitionBody*>(body))
2218 : 0 : return PartitionEngine::instance().rotate( part, axis, angle );
2219 [ # # ][ # # ]: 0 : else if(CompositeBody* comp = dynamic_cast<CompositeBody*>(body))
2220 : 0 : return CompositeEngine::instance().rotate( comp, axis, angle );
2221 : :
2222 [ # # ][ # # ]: 0 : PRINT_ERROR("Non-virtual entity in VGE::rotate.\n");
2223 : 0 : return CUBIT_FAILURE;
2224 : : }
2225 : :
2226 : 0 : CubitStatus VirtualQueryEngine::scale ( BodySM* body,
2227 : : double factor )
2228 : : {
2229 [ # # ]: 0 : return scale( body, CubitVector(factor,factor,factor) );
2230 : : }
2231 : :
2232 : 0 : CubitStatus VirtualQueryEngine::scale ( BodySM* body,
2233 : : const CubitVector& factors )
2234 : : {
2235 [ # # ][ # # ]: 0 : if (PartitionBody* part = dynamic_cast<PartitionBody*>(body))
2236 : 0 : return PartitionEngine::instance().scale( part, factors );
2237 [ # # ][ # # ]: 0 : else if(CompositeBody* comp = dynamic_cast<CompositeBody*>(body))
2238 : 0 : return CompositeEngine::instance().scale( comp, factors );
2239 : :
2240 [ # # ][ # # ]: 0 : PRINT_ERROR("Non-virtual entity in VGE::scale.\n");
2241 : 0 : return CUBIT_FAILURE;
2242 : : }
2243 : :
2244 : 0 : CubitStatus VirtualQueryEngine::reflect ( BodySM* body,
2245 : : const CubitVector& axis )
2246 : : {
2247 [ # # ][ # # ]: 0 : if (PartitionBody* part = dynamic_cast<PartitionBody*>(body))
2248 : 0 : return PartitionEngine::instance().reflect( part, axis );
2249 [ # # ][ # # ]: 0 : else if(CompositeBody* comp = dynamic_cast<CompositeBody*>(body))
2250 : 0 : return CompositeEngine::instance().reflect( comp, axis );
2251 : :
2252 [ # # ][ # # ]: 0 : PRINT_ERROR("Non-virtual entity in VGE::reflect.\n");
2253 : 0 : return CUBIT_FAILURE;
2254 : : }
2255 : :
2256 : 0 : CubitStatus VirtualQueryEngine::restore_transform( BodySM* body )
2257 : : {
2258 [ # # ][ # # ]: 0 : if (PartitionBody* part = dynamic_cast<PartitionBody*>(body))
2259 : 0 : return PartitionEngine::instance().restore_transform( part );
2260 [ # # ][ # # ]: 0 : else if(CompositeBody* comp = dynamic_cast<CompositeBody*>(body))
2261 : 0 : return CompositeEngine::instance().restore_transform( comp );
2262 : :
2263 [ # # ][ # # ]: 0 : PRINT_ERROR("Non-virtual entity in VGE::restore_transform.\n");
2264 : 0 : return CUBIT_FAILURE;
2265 : : }
2266 : :
2267 : 0 : CubitStatus VirtualQueryEngine::translate( GeometryEntity* ent,
2268 : : const CubitVector& offset )
2269 : : {
2270 [ # # ][ # # ]: 0 : if (PartitionEntity* part = dynamic_cast<PartitionEntity*>(ent))
2271 : 0 : return PartitionEngine::instance().translate( part, offset );
2272 [ # # ][ # # ]: 0 : else if(CompositeSurface* csurf = dynamic_cast<CompositeSurface*>(ent))
2273 : 0 : return CompositeEngine::instance().translate( csurf, offset );
2274 [ # # ][ # # ]: 0 : else if(CompositeCurve* ccurve = dynamic_cast<CompositeCurve*>(ent))
2275 : 0 : return CompositeEngine::instance().translate( ccurve, offset );
2276 : :
2277 [ # # ][ # # ]: 0 : PRINT_ERROR("Non-virtual entity in VGE::translate.\n");
2278 : 0 : return CUBIT_FAILURE;
2279 : : }
2280 : :
2281 : 0 : CubitStatus VirtualQueryEngine::rotate ( GeometryEntity* ent,
2282 : : const CubitVector& axis,
2283 : : double degrees )
2284 : : {
2285 [ # # ][ # # ]: 0 : if (PartitionEntity* part = dynamic_cast<PartitionEntity*>(ent))
2286 : 0 : return PartitionEngine::instance().rotate( part, axis, degrees );
2287 [ # # ][ # # ]: 0 : else if(CompositeSurface* csurf = dynamic_cast<CompositeSurface*>(ent))
2288 : 0 : return CompositeEngine::instance().rotate( csurf, axis, degrees );
2289 [ # # ][ # # ]: 0 : else if(CompositeCurve* ccurve = dynamic_cast<CompositeCurve*>(ent))
2290 : 0 : return CompositeEngine::instance().rotate( ccurve, axis, degrees );
2291 : :
2292 [ # # ][ # # ]: 0 : PRINT_ERROR("Non-virtual entity in VGE::rotate.\n");
2293 : 0 : return CUBIT_FAILURE;
2294 : : }
2295 : :
2296 : 0 : CubitStatus VirtualQueryEngine::scale ( GeometryEntity* ent,
2297 : : double factor )
2298 : : {
2299 [ # # ]: 0 : return scale( ent, CubitVector( factor, factor, factor ) );
2300 : : }
2301 : :
2302 : 0 : CubitStatus VirtualQueryEngine::scale ( GeometryEntity* ent,
2303 : : const CubitVector& factors )
2304 : : {
2305 [ # # ][ # # ]: 0 : if (PartitionEntity* part = dynamic_cast<PartitionEntity*>(ent))
2306 : 0 : return PartitionEngine::instance().scale( part, factors );
2307 [ # # ][ # # ]: 0 : else if(CompositeSurface* csurf = dynamic_cast<CompositeSurface*>(ent))
2308 : 0 : return CompositeEngine::instance().scale( csurf, factors );
2309 [ # # ][ # # ]: 0 : else if(CompositeCurve* ccurve = dynamic_cast<CompositeCurve*>(ent))
2310 : 0 : return CompositeEngine::instance().scale( ccurve, factors );
2311 : :
2312 [ # # ][ # # ]: 0 : PRINT_ERROR("Non-virtual entity in VGE::scale.\n");
2313 : 0 : return CUBIT_FAILURE;
2314 : : }
2315 : :
2316 : 0 : CubitStatus VirtualQueryEngine::reflect ( GeometryEntity* ent,
2317 : : const CubitVector& axis )
2318 : : {
2319 [ # # ][ # # ]: 0 : if (PartitionEntity* part = dynamic_cast<PartitionEntity*>(ent))
2320 : 0 : return PartitionEngine::instance().reflect( part, axis );
2321 [ # # ][ # # ]: 0 : else if(CompositeSurface* csurf = dynamic_cast<CompositeSurface*>(ent))
2322 : 0 : return CompositeEngine::instance().reflect( csurf, axis );
2323 [ # # ][ # # ]: 0 : else if(CompositeCurve* ccurve = dynamic_cast<CompositeCurve*>(ent))
2324 : 0 : return CompositeEngine::instance().reflect( ccurve, axis );
2325 : :
2326 [ # # ][ # # ]: 0 : PRINT_ERROR("Non-virtual entity in VGE::reflect.\n");
2327 : 0 : return CUBIT_FAILURE;
2328 : : }
2329 : :
2330 : : //Function should only be called on volumes of multi-volume bodies
2331 : 0 : CubitBoolean VirtualQueryEngine::volumes_overlap (Lump *lump1, Lump *lump2 ) const
2332 : : {
2333 [ # # ]: 0 : PartitionLump* partition_lump1 = dynamic_cast<PartitionLump*>(lump1);
2334 [ # # ]: 0 : PartitionLump* partition_lump2 = dynamic_cast<PartitionLump*>(lump2);
2335 : :
2336 : 0 : Lump *tmp_lump1 = lump1;
2337 [ # # ]: 0 : if( partition_lump1 )
2338 : 0 : tmp_lump1 = partition_lump1->real_lump();
2339 : :
2340 : 0 : Lump *tmp_lump2 = lump2;
2341 [ # # ]: 0 : if( partition_lump2 )
2342 : 0 : tmp_lump2 = partition_lump2->real_lump();
2343 : :
2344 : 0 : GeometryQueryEngine *gqe = tmp_lump1->get_geometry_query_engine();
2345 [ # # ]: 0 : if( gqe != tmp_lump2->get_geometry_query_engine() )
2346 : : {
2347 [ # # ]: 0 : PRINT_ERROR("Volumes must be of the same type (, SolidWorks, etc) to\n"
2348 [ # # ]: 0 : "find if they overlap.\n");
2349 : 0 : return CUBIT_FALSE;
2350 : : }
2351 : :
2352 : 0 : return gqe->volumes_overlap( tmp_lump1, tmp_lump2 );
2353 : : }
2354 : :
2355 : :
2356 : 0 : CubitBoolean VirtualQueryEngine::bodies_overlap (BodySM *body_ptr_1, BodySM *body_ptr_2 ) const
2357 : : {
2358 [ # # ]: 0 : PartitionBody* partition_body1 = dynamic_cast<PartitionBody*>(body_ptr_1);
2359 [ # # ]: 0 : PartitionBody* partition_body2 = dynamic_cast<PartitionBody*>(body_ptr_2);
2360 : :
2361 : 0 : BodySM *body1 = body_ptr_1;
2362 [ # # ]: 0 : if( partition_body1 )
2363 : 0 : body1 = partition_body1->real_body();
2364 : :
2365 : 0 : BodySM *body2 = body_ptr_2;
2366 [ # # ]: 0 : if( partition_body2 )
2367 : 0 : body2 = partition_body2->real_body();
2368 : :
2369 : 0 : GeometryQueryEngine *gqe = body1->get_geometry_query_engine();
2370 [ # # ]: 0 : if( gqe != body2->get_geometry_query_engine() )
2371 : : {
2372 [ # # ]: 0 : PRINT_ERROR("Volumes must be of the same type (, SolidWorks, etc) to\n"
2373 [ # # ]: 0 : "find if they overlap.\n");
2374 : 0 : return CUBIT_FALSE;
2375 : : }
2376 : :
2377 : 0 : return gqe->bodies_overlap( body1, body2 );
2378 : :
2379 : : }
2380 : :
2381 : 0 : TopologyBridge* VirtualQueryEngine::get_visible_entity_at_point(TopologyBridge* hidden_tb, CubitVector* point)
2382 : : {
2383 : : // Determine entity type; should only be Curve or TBPoint
2384 : :
2385 : : int j, k;
2386 : 0 : bool added_entity = false;
2387 : 0 : TopologyBridge* bridge_ptr = hidden_tb;
2388 : 0 : TopologyBridge* tb_owner = NULL;
2389 : 0 : bool hidden = CUBIT_TRUE;
2390 : :
2391 : 0 : TopologyBridge* visible_tb = NULL;
2392 : :
2393 [ # # ]: 0 : while (hidden)
2394 : : {
2395 [ # # ]: 0 : tb_owner = dynamic_cast<TopologyBridge*>(bridge_ptr->owner());
2396 [ # # ]: 0 : if( tb_owner )
2397 : : {
2398 [ # # ]: 0 : if( tb_owner->topology_entity() )
2399 : : {
2400 : 0 : visible_tb = tb_owner;
2401 : 0 : hidden = CUBIT_FALSE;
2402 : 0 : added_entity = true;
2403 : 0 : continue;
2404 : : }
2405 : : else
2406 : 0 : hidden = CUBIT_TRUE;
2407 : : }
2408 : : else
2409 : : {
2410 [ # # ]: 0 : if( bridge_ptr->topology_entity() )
2411 : : {
2412 : 0 : visible_tb = bridge_ptr;
2413 : 0 : hidden = CUBIT_FALSE;
2414 : 0 : added_entity = true;
2415 : 0 : continue;
2416 : : }
2417 : : else
2418 : : {
2419 : 0 : hidden = CUBIT_TRUE;
2420 : : }
2421 : : }
2422 : :
2423 : :
2424 : : TopologyBridge *tb_ptr;
2425 [ # # ]: 0 : if( tb_owner )
2426 : 0 : tb_ptr = tb_owner;
2427 : : else
2428 : 0 : tb_ptr = bridge_ptr;
2429 : :
2430 : 0 : TBOwner* tb_owner = tb_ptr->owner();
2431 [ # # ][ # # ]: 0 : if (CAST_TO(tb_owner, HiddenEntitySet)) // virtual geometry
[ # # ]
2432 : : {
2433 : 0 : TopologyBridge* parent = NULL;
2434 [ # # ][ # # ]: 0 : while (CAST_TO(tb_owner, HiddenEntitySet)) // virtual geometry
[ # # ]
2435 : : {
2436 [ # # ]: 0 : HiddenEntitySet* hidden_set_ptr = CAST_TO(tb_owner, HiddenEntitySet);
2437 [ # # ]: 0 : parent = dynamic_cast<TopologyBridge*>(hidden_set_ptr->owner());
2438 [ # # ]: 0 : if (parent)
2439 : 0 : tb_owner = parent->owner();
2440 : : }
2441 [ # # ]: 0 : if (parent)
2442 : : {
2443 : 0 : bridge_ptr = parent;
2444 : 0 : added_entity = true;
2445 : 0 : continue;
2446 : : }
2447 : : }
2448 [ # # ][ # # ]: 0 : else if (CAST_TO(tb_owner, SubEntitySet)) // partition geometry
[ # # ]
2449 : : {
2450 [ # # ]: 0 : SubEntitySet* sub_set_ptr = CAST_TO(tb_owner, SubEntitySet);
2451 : :
2452 [ # # ]: 0 : DLIList<TopologyBridge*> owner_list;
2453 [ # # ]: 0 : sub_set_ptr->get_owners(owner_list);
2454 [ # # ]: 0 : owner_list.reset();
2455 : : // need to traverse all the entities that make up the original geometry
2456 : : // if intersected a surface, and the surface is partitioned into mult surfaces,
2457 : : // which surface did we hit? Did we hit the curve in between? The vertices? gahhhh...
2458 [ # # ][ # # ]: 0 : for (j=0; j<owner_list.size(); j++)
2459 : : {
2460 [ # # ]: 0 : TopologyBridge* owner_partition = owner_list.get_and_step();
2461 : : //determine geometry type and call point_containment
2462 : :
2463 : 0 : CubitPointContainment containment = CUBIT_PNT_UNKNOWN;
2464 : :
2465 [ # # ][ # # ]: 0 : if (CAST_TO(owner_partition, Surface))
[ # # ]
2466 : : {
2467 [ # # ][ # # ]: 0 : containment = CAST_TO(owner_partition, Surface)->point_containment(*point);
2468 [ # # # # : 0 : switch (containment)
# ]
2469 : : {
2470 : : case CUBIT_PNT_OFF:
2471 : 0 : break;
2472 : : case CUBIT_PNT_ON:
2473 : 0 : bridge_ptr = owner_partition;
2474 : 0 : added_entity = true;
2475 : 0 : break;
2476 : : case CUBIT_PNT_UNKNOWN:
2477 : 0 : break;
2478 : : case CUBIT_PNT_BOUNDARY:
2479 : : {
2480 [ # # ][ # # ]: 0 : DLIList<TopologyBridge*> children, related_loops, related_coedges;
[ # # ][ # # ]
[ # # ]
2481 [ # # ][ # # ]: 0 : DLIList<TopologyBridge*> related_curves, temp;
[ # # ][ # # ]
2482 : :
2483 : : // Goal: get curves (incl. virtual ones)
2484 : : // Note: can't use ->curves() func b/c it won't grab the virtual curves
2485 : :
2486 : : // get all Loops, including virtual
2487 [ # # ]: 0 : owner_partition->get_children( related_loops, true );
2488 : :
2489 [ # # ]: 0 : related_loops.reset();
2490 : : int ii;
2491 : :
2492 : : // get all CoEdges
2493 [ # # ][ # # ]: 0 : for (ii = related_loops.size(); ii--;)
2494 : : {
2495 [ # # ]: 0 : temp.clean_out();
2496 [ # # ][ # # ]: 0 : related_loops.get_and_step()->get_children(temp, true);
2497 [ # # ]: 0 : related_coedges.merge_unique(temp);
2498 : : }
2499 : : // get all Curves
2500 [ # # ][ # # ]: 0 : for (ii = related_coedges.size(); ii--;)
2501 : : {
2502 [ # # ]: 0 : temp.clean_out();
2503 [ # # ][ # # ]: 0 : related_coedges.get_and_step()->get_children(temp, true);
2504 [ # # ]: 0 : related_curves.merge_unique(temp);
2505 : : }
2506 : :
2507 [ # # ][ # # ]: 0 : CAST_LIST(related_curves, children, TopologyBridge);
[ # # ][ # # ]
[ # # ][ # # ]
2508 [ # # ][ # # ]: 0 : for (k=0; k<children.size(); k++)
2509 : : {
2510 : : // CAST and do point_containment for each curve
2511 : 0 : containment = CUBIT_PNT_UNKNOWN;
2512 [ # # ]: 0 : TopologyBridge* partition_curve = children.get_and_step();
2513 [ # # ][ # # ]: 0 : containment = CAST_TO(partition_curve, Curve)->point_containment(*point);
2514 [ # # # # ]: 0 : switch (containment)
2515 : : {
2516 : : case CUBIT_PNT_OFF:
2517 : : case CUBIT_PNT_UNKNOWN:
2518 : 0 : break;
2519 : : case CUBIT_PNT_ON:
2520 : 0 : bridge_ptr = partition_curve;
2521 : 0 : added_entity = true;
2522 : 0 : break;
2523 : : case CUBIT_PNT_BOUNDARY:
2524 : : {
2525 : : // CAST and do point_containment for each vertex
2526 [ # # ]: 0 : children.clean_out();
2527 [ # # ]: 0 : partition_curve->get_children(children, true);
2528 : : int kk;
2529 [ # # ][ # # ]: 0 : for (kk=0; kk<children.size(); kk++)
2530 : : {
2531 [ # # ]: 0 : TopologyBridge* partition_vertex = children.get_and_step();
2532 : 0 : containment = CUBIT_PNT_UNKNOWN;
2533 [ # # ][ # # ]: 0 : CubitVector coords = CAST_TO(partition_vertex, TBPoint)->coordinates();
2534 [ # # ][ # # ]: 0 : if (coords.distance_between_squared(*point) < GEOMETRY_RESABS*GEOMETRY_RESABS)
2535 : : {
2536 : 0 : containment = CUBIT_PNT_ON;
2537 : 0 : bridge_ptr = partition_vertex;
2538 : 0 : added_entity = true;
2539 : 0 : break;
2540 : : }
2541 : : else
2542 : 0 : containment = CUBIT_PNT_OFF;
2543 : : }
2544 : : }
2545 : : }
2546 : :
2547 [ # # ]: 0 : if (added_entity)
2548 : 0 : break;
2549 : : }
2550 [ # # ]: 0 : break;
2551 : : }
2552 : : }
2553 [ # # ]: 0 : if (added_entity)
2554 : 0 : break;
2555 : : }
2556 [ # # ][ # # ]: 0 : else if (CAST_TO(owner_partition, Curve))
[ # # ]
2557 : : {
2558 : : // CAST and do point_containment for each curve
2559 : 0 : containment = CUBIT_PNT_UNKNOWN;
2560 [ # # ][ # # ]: 0 : containment = CAST_TO(owner_partition, Curve)->point_containment(*point);
2561 [ # # # # ]: 0 : switch (containment)
2562 : : {
2563 : : case CUBIT_PNT_OFF:
2564 : : case CUBIT_PNT_UNKNOWN:
2565 : 0 : break;
2566 : : case CUBIT_PNT_ON:
2567 : 0 : bridge_ptr = owner_partition;
2568 : 0 : added_entity = true;
2569 : 0 : break;
2570 : : case CUBIT_PNT_BOUNDARY:
2571 : : {
2572 : : // CAST and do point_containment for each vertex
2573 [ # # ]: 0 : DLIList<TopologyBridge*> children;
2574 [ # # ]: 0 : children.clean_out();
2575 [ # # ]: 0 : owner_partition->get_children(children, true);
2576 : : int kk;
2577 [ # # ][ # # ]: 0 : for (kk=0; kk<children.size(); kk++)
2578 : : {
2579 [ # # ]: 0 : TopologyBridge* partition_vertex = children.get_and_step();
2580 : 0 : containment = CUBIT_PNT_UNKNOWN;
2581 [ # # ][ # # ]: 0 : CubitVector coords = CAST_TO(partition_vertex, TBPoint)->coordinates();
2582 [ # # ][ # # ]: 0 : if (coords.distance_between_squared(*point) < GEOMETRY_RESABS*GEOMETRY_RESABS)
2583 : : {
2584 : 0 : containment = CUBIT_PNT_ON;
2585 : 0 : bridge_ptr = partition_vertex;
2586 : 0 : added_entity = true;
2587 : 0 : break;
2588 : : }
2589 : : else
2590 : 0 : containment = CUBIT_PNT_OFF;
2591 : : }
2592 [ # # ]: 0 : break;
2593 : : }
2594 : : }
2595 : :
2596 [ # # ]: 0 : if (added_entity)
2597 : 0 : break;
2598 : : }
2599 : :
2600 [ # # ][ # # ]: 0 : else if (CAST_TO(owner_partition, TBPoint))
[ # # ]
2601 : : {
2602 [ # # ][ # # ]: 0 : CubitVector coords = CAST_TO(owner_partition, TBPoint)->coordinates();
2603 [ # # ][ # # ]: 0 : if (coords.distance_between_squared(*point) < GEOMETRY_RESABS*GEOMETRY_RESABS)
2604 : : {
2605 : 0 : containment = CUBIT_PNT_ON;
2606 : 0 : bridge_ptr = owner_partition;
2607 : 0 : added_entity = true;
2608 : 0 : break;
2609 : : }
2610 : : else
2611 : 0 : containment = CUBIT_PNT_OFF;
2612 : : }
2613 : :
2614 : : else
2615 [ # # ][ # # ]: 0 : PRINT_WARNING("Hit unknown partition entity.\n");
[ # # ][ # # ]
2616 : :
2617 : :
2618 : : }
2619 [ # # ]: 0 : if (!added_entity)
2620 : : {
2621 : 0 : visible_tb = NULL;
2622 : 0 : hidden = CUBIT_FALSE;
2623 : : //break;
2624 [ # # ]: 0 : }
2625 : :
2626 : : }
2627 : :
2628 : :
2629 : : } //while
2630 : :
2631 : 0 : return visible_tb;
2632 : : }
2633 : :
2634 : :
2635 : 0 : CubitStatus VirtualQueryEngine::get_visible_entities( TopologyBridge *hidden_tb,
2636 : : DLIList<TopologyBridge*> &real_tbs )
2637 : : {
2638 : : int j;
2639 : 0 : TopologyBridge* bridge_ptr = NULL;
2640 : 0 : TopologyBridge* tb_owner = NULL;
2641 : :
2642 : 0 : TopologyBridge* visible_tb = NULL;
2643 : :
2644 [ # # ]: 0 : DLIList<TopologyBridge*> tbs_to_search;
2645 [ # # ]: 0 : tbs_to_search.append( hidden_tb );
2646 : :
2647 [ # # ][ # # ]: 0 : while(tbs_to_search.size())
2648 : : {
2649 [ # # ]: 0 : bridge_ptr = tbs_to_search.pop();
2650 : :
2651 [ # # ][ # # ]: 0 : tb_owner = dynamic_cast<TopologyBridge*>(bridge_ptr->owner());
2652 [ # # ]: 0 : if( tb_owner )
2653 : : {
2654 [ # # ][ # # ]: 0 : if( tb_owner->topology_entity() )
2655 : : {
2656 : 0 : visible_tb = tb_owner;
2657 [ # # ]: 0 : real_tbs.append( visible_tb );
2658 : 0 : continue;
2659 : : }
2660 : : }
2661 : : else
2662 : : {
2663 [ # # ][ # # ]: 0 : if( bridge_ptr->topology_entity() )
2664 : : {
2665 : 0 : visible_tb = bridge_ptr;
2666 [ # # ]: 0 : real_tbs.append( visible_tb );
2667 : 0 : continue;
2668 : : }
2669 : : }
2670 : :
2671 : :
2672 : : TopologyBridge *tb_ptr;
2673 [ # # ]: 0 : if( tb_owner )
2674 : 0 : tb_ptr = tb_owner;
2675 : : else
2676 : 0 : tb_ptr = bridge_ptr;
2677 : :
2678 [ # # ]: 0 : TBOwner* tb_owner = tb_ptr->owner();
2679 [ # # ][ # # ]: 0 : if (CAST_TO(tb_owner, HiddenEntitySet)) // it is a composite
[ # # ]
2680 : : {
2681 : 0 : TopologyBridge* parent = NULL;
2682 [ # # ][ # # ]: 0 : while (CAST_TO(tb_owner, HiddenEntitySet)) // virtual geometry
[ # # ]
2683 : : {
2684 [ # # ]: 0 : HiddenEntitySet* hidden_set_ptr = CAST_TO(tb_owner, HiddenEntitySet);
2685 [ # # ][ # # ]: 0 : parent = dynamic_cast<TopologyBridge*>(hidden_set_ptr->owner());
2686 [ # # ]: 0 : if (parent)
2687 [ # # ]: 0 : tb_owner = parent->owner();
2688 : : }
2689 [ # # ]: 0 : if (parent)
2690 : : {
2691 [ # # ]: 0 : tbs_to_search.append( parent );
2692 : 0 : continue;
2693 : : }
2694 : : }
2695 [ # # ][ # # ]: 0 : else if (CAST_TO(tb_owner, SubEntitySet)) // partition geometry
[ # # ]
2696 : : {
2697 [ # # ]: 0 : SubEntitySet* sub_set_ptr = CAST_TO(tb_owner, SubEntitySet);
2698 : :
2699 [ # # ]: 0 : DLIList<TopologyBridge*> owner_list;
2700 [ # # ]: 0 : sub_set_ptr->get_owners(owner_list);
2701 [ # # ]: 0 : owner_list.reset();
2702 : : // need to traverse all the entities that make up the original geometry
2703 : : // if intersected a surface, and the surface is partitioned into mult surfaces,
2704 : : // which surface did we hit? Did we hit the curve in between? The vertices? gahhhh...
2705 [ # # ][ # # ]: 0 : for (j=0; j<owner_list.size(); j++)
2706 : : {
2707 [ # # ]: 0 : TopologyBridge* owner_partition = owner_list.get_and_step();
2708 [ # # ]: 0 : tbs_to_search.append( owner_partition );
2709 [ # # ]: 0 : }
2710 : : }
2711 : : }
2712 : :
2713 [ # # ]: 0 : real_tbs.uniquify_ordered();
2714 : :
2715 [ # # ]: 0 : return CUBIT_SUCCESS;
2716 [ + - ][ + - ]: 6364 : }
|
