Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : CompositeSurface.cc
3 : : //
4 : : // Purpose : Implementation of the CompositeSurface class.
5 : : //
6 : : // Special Notes :
7 : : //
8 : : // Creator : Jason Kraftcheck
9 : : //
10 : : // Creation Date : 03/10/98
11 : : //
12 : : // Owner : Jason Kraftcheck
13 : : //-------------------------------------------------------------------------
14 : :
15 : : #include <assert.h>
16 : :
17 : : #include "VirtualQueryEngine.hpp"
18 : :
19 : : #include "Surface.hpp"
20 : :
21 : : #include "CompositeSurface.hpp"
22 : : #include "CompositeLoop.hpp"
23 : : #include "CompositeCurve.hpp"
24 : : #include "CompositePoint.hpp"
25 : : #include "CompositeShell.hpp"
26 : : #include "CompositeLump.hpp"
27 : :
28 : : #include "CompositeEngine.hpp"
29 : : #include "CompSurfFacets.hpp"
30 : : #include "GfxDebug.hpp"
31 : :
32 : : /*
33 : : #include "CpuTimer.hpp"
34 : : static double trimmed_time = 0.0;
35 : : static double contain_time = 0.0;
36 : : static double closest_time = 0.0;
37 : : static int total_calls = 0;
38 : : static int contain_trim_count = 0;
39 : : static int error_count = 0;
40 : : static CpuTimer timer;
41 : : */
42 : :
43 : 0 : CompositeSurface::CompositeSurface( Surface* surface )
44 [ # # ]: 0 : : HadBridgeRemoved(0), stitchPartner(0), firstCoSurf(0), firstLoop(0), hiddenSet(0), facetTool(0)
45 : : {
46 [ # # ]: 0 : assert( surface != NULL );
47 [ # # ][ # # ]: 0 : compGeom = new CompositeGeom(1);
48 [ # # ]: 0 : compGeom->append( surface, CUBIT_FORWARD );
49 [ # # ][ # # ]: 0 : if( surface->owner() )
50 [ # # ][ # # ]: 0 : surface->owner()->swap_bridge( surface, this, false );
51 [ # # ]: 0 : surface->owner(this);
52 : 0 : }
53 : :
54 : 0 : CompositeSurface::CompositeSurface( CompositeGeom* geometry )
55 : : : HadBridgeRemoved(0),
56 : : compGeom(geometry),
57 : : stitchPartner(0),
58 : : firstCoSurf(0),
59 : : firstLoop(0),
60 : : hiddenSet(0),
61 [ # # ]: 0 : facetTool(0)
62 : : {
63 [ # # ]: 0 : assert( geometry != NULL );
64 [ # # ][ # # ]: 0 : for( int i = 0; i < compGeom->num_entities(); i++ )
65 : : {
66 [ # # ]: 0 : GeometryEntity* entity = compGeom->entity(i);
67 [ # # ][ # # ]: 0 : assert( !entity->owner() );
68 [ # # ]: 0 : entity->owner(this);
69 : : }
70 : 0 : }
71 : :
72 : :
73 : :
74 : : //-------------------------------------------------------------------------
75 : : // Purpose : Desctructor
76 : : //
77 : : // Special Notes :
78 : : //
79 : : // Creator : Jason Kraftcheck
80 : : //
81 : : // Creation Date :
82 : : //-------------------------------------------------------------------------
83 [ # # ][ # # ]: 0 : CompositeSurface::~CompositeSurface()
84 : : {
85 [ # # ]: 0 : while( firstCoSurf )
86 : : {
87 : 0 : CompositeCoSurf* cosurf = firstCoSurf;
88 [ # # ]: 0 : remove( cosurf );
89 [ # # ][ # # ]: 0 : if( cosurf->get_shell() )
90 [ # # ][ # # ]: 0 : cosurf->get_shell()->remove( cosurf );
91 [ # # ][ # # ]: 0 : delete cosurf;
92 : : }
93 : :
94 [ # # ]: 0 : while( firstLoop )
95 [ # # ]: 0 : remove( firstLoop );
96 : :
97 [ # # ][ # # ]: 0 : for( int j = 0; j < num_surfs(); j++ )
98 [ # # ][ # # ]: 0 : if( get_surface(j)->owner() == this )
[ # # ]
99 [ # # ][ # # ]: 0 : get_surface(j)->owner(0);
100 : :
101 [ # # ]: 0 : if( stitchPartner )
102 : : {
103 : 0 : stitchPartner->stitchPartner = 0;
104 : 0 : stitchPartner = 0;
105 : : }
106 : :
107 [ # # ][ # # ]: 0 : delete hiddenSet;
108 [ # # ][ # # ]: 0 : delete compGeom;
109 [ # # ][ # # ]: 0 : delete facetTool;
110 : 0 : hiddenSet = (HiddenEntitySet*)0xbdbdbdbd;
111 : 0 : compGeom = (CompositeGeom*)0xbdbdbdbd;
112 [ # # ]: 0 : }
113 : :
114 : : //-------------------------------------------------------------------------
115 : : // Purpose : Add a CompositeLoop to child list
116 : : //
117 : : // Special Notes :
118 : : //
119 : : // Creator : Jason Kraftcheck
120 : : //
121 : : // Creation Date : 03/06/02
122 : : //-------------------------------------------------------------------------
123 : 0 : CubitStatus CompositeSurface::add( CompositeLoop* loop )
124 : : {
125 [ # # ]: 0 : if( loop->mySurface )
126 : : {
127 : 0 : assert(0);
128 : : return CUBIT_FAILURE;
129 : : }
130 : :
131 : 0 : loop->mySurface = this;
132 : 0 : loop->loopNext = firstLoop;
133 : 0 : firstLoop = loop;
134 : :
135 : 0 : return CUBIT_SUCCESS;
136 : : }
137 : :
138 : : //-------------------------------------------------------------------------
139 : : // Purpose : Remove a child loop
140 : : //
141 : : // Special Notes :
142 : : //
143 : : // Creator : Jason Kraftcheck
144 : : //
145 : : // Creation Date : 03/06/02
146 : : //-------------------------------------------------------------------------
147 : 0 : CubitStatus CompositeSurface::remove( CompositeLoop* loop )
148 : : {
149 [ # # ]: 0 : if( loop->mySurface != this )
150 : 0 : return CUBIT_FAILURE;
151 : :
152 [ # # ]: 0 : if( firstLoop == loop )
153 : : {
154 : 0 : firstLoop = loop->loopNext;
155 : : }
156 : : else
157 : : {
158 : 0 : CompositeLoop *prev = firstLoop,
159 : 0 : *next = firstLoop->loopNext;
160 : :
161 [ # # ]: 0 : while( next != loop )
162 : : {
163 [ # # ]: 0 : assert( next != NULL );
164 : 0 : prev = next;
165 : 0 : next = next->loopNext;
166 : : }
167 : :
168 : 0 : prev->loopNext = next->loopNext;
169 : : }
170 : :
171 : 0 : loop->loopNext = 0;
172 : 0 : loop->mySurface = 0;
173 : 0 : return CUBIT_SUCCESS;
174 : : }
175 : :
176 : : //-------------------------------------------------------------------------
177 : : // Purpose : Add a CoSurface to this Surface
178 : : //
179 : : // Special Notes :
180 : : //
181 : : // Creator : Jason Kraftcheck
182 : : //
183 : : // Creation Date : 08/07/02
184 : : //-------------------------------------------------------------------------
185 : 0 : CubitStatus CompositeSurface::add( CompositeCoSurf* cosurf )
186 : : {
187 [ # # ]: 0 : if( cosurf->mySurface )
188 : 0 : return CUBIT_FAILURE;
189 : :
190 : 0 : cosurf->mySurface = this;
191 : 0 : cosurf->surfaceNext = firstCoSurf;
192 : 0 : firstCoSurf = cosurf;
193 : 0 : return CUBIT_SUCCESS;
194 : : }
195 : :
196 : : //-------------------------------------------------------------------------
197 : : // Purpose : Remove a CoSurface
198 : : //
199 : : // Special Notes :
200 : : //
201 : : // Creator : Jason Kraftcheck
202 : : //
203 : : // Creation Date : 08/07/02
204 : : //-------------------------------------------------------------------------
205 : 0 : CubitStatus CompositeSurface::remove( CompositeCoSurf* cosurf )
206 : : {
207 [ # # ]: 0 : if( cosurf->mySurface != this )
208 : 0 : return CUBIT_FAILURE;
209 : :
210 [ # # ]: 0 : if( cosurf == firstCoSurf )
211 : 0 : firstCoSurf = cosurf->surfaceNext;
212 : : else
213 : : {
214 : 0 : CompositeCoSurf* prev = firstCoSurf;
215 [ # # ][ # # ]: 0 : while( prev && prev->surfaceNext != cosurf )
216 : 0 : prev = prev->surfaceNext;
217 [ # # ]: 0 : assert( prev != NULL );
218 : 0 : prev->surfaceNext = cosurf->surfaceNext;
219 : : }
220 : :
221 : 0 : cosurf->mySurface = 0;
222 : 0 : cosurf->surfaceNext = 0;
223 : 0 : return CUBIT_SUCCESS;
224 : : }
225 : :
226 : : //-------------------------------------------------------------------------
227 : : // Purpose : Get a CoSurface attaching this surface to the passed
228 : : // Shell or Lump
229 : : //
230 : : // Special Notes :
231 : : //
232 : : // Creator : Jason Kraftcheck
233 : : //
234 : : // Creation Date : 08/07/02
235 : : //-------------------------------------------------------------------------
236 : 0 : CompositeCoSurf* CompositeSurface::find_first( CompositeShell* shell ) const
237 : : {
238 : 0 : CompositeCoSurf* cos = firstCoSurf;
239 [ # # ][ # # ]: 0 : while( cos && cos->get_shell() != shell )
[ # # ]
240 : 0 : cos = cos->next_in_surface();
241 : 0 : return cos;
242 : : }
243 : 0 : CompositeCoSurf* CompositeSurface::find_first( CompositeLump* lump ) const
244 : : {
245 : 0 : CompositeCoSurf* cos = firstCoSurf;
246 [ # # ][ # # ]: 0 : while( cos && (!cos->get_shell() || cos->get_shell()->get_lump() != lump ) )
[ # # ][ # # ]
247 : 0 : cos = cos->next_in_surface();
248 : 0 : return cos;
249 : : }
250 : 0 : CompositeCoSurf* CompositeSurface::find_next( CompositeCoSurf* cosurf ) const
251 : : {
252 : 0 : CompositeCoSurf* cos = cosurf;
253 [ # # ][ # # ]: 0 : while( cos && cos->get_shell() != cosurf->get_shell() )
[ # # ]
254 : 0 : cos = cos->next_in_surface();
255 : 0 : return cos;
256 : : }
257 : :
258 : :
259 : : //-------------------------------------------------------------------------
260 : : // Purpose : Split this CompositeSurface into two.
261 : : //
262 : : // Special Notes :
263 : : //
264 : : // Creator : Jason Kraftcheck
265 : : //
266 : : // Creation Date : 03/06/02
267 : : //-------------------------------------------------------------------------
268 : 0 : CompositeSurface* CompositeSurface::split( VGArray<int>& indices_to_move )
269 : : {
270 : : int i;
271 : :
272 [ # # ]: 0 : for( i = 0; i < indices_to_move.size(); i++ )
273 [ # # ][ # # ]: 0 : if( indices_to_move[i] < 0 || indices_to_move[i] >= num_surfs() )
[ # # ]
274 : 0 : return 0;
275 : :
276 : 0 : CompositeGeom* new_geom = compGeom->split( indices_to_move );
277 [ # # ]: 0 : if( !new_geom )
278 : 0 : return 0;
279 : :
280 [ # # ]: 0 : for( i = 0; i < new_geom->num_entities(); i++ )
281 : 0 : new_geom->entity(i)->owner( 0 );
282 : :
283 [ # # ]: 0 : delete facetTool;
284 : 0 : facetTool = 0;
285 : :
286 [ # # ]: 0 : return new CompositeSurface( new_geom );
287 : : }
288 : :
289 : :
290 : : //-------------------------------------------------------------------------
291 : : // Purpose : Combine composite surfaces
292 : : //
293 : : // Special Notes :
294 : : //
295 : : // Creator : Jason Kraftcheck
296 : : //
297 : : // Creation Date : 03/06/02
298 : : //-------------------------------------------------------------------------
299 : 0 : CubitStatus CompositeSurface::combine( CompositeSurface* dead_surf )
300 : : {
301 : 0 : int old_size = compGeom->num_entities();
302 : :
303 : : // Merge the "surfaces_to_ignore" list.
304 : 0 : surfacesToIgnore.merge_unique(dead_surf->surfacesToIgnore);
305 : :
306 : 0 : compGeom->merge( *(dead_surf->compGeom) );
307 [ # # ]: 0 : if( dead_surf->hiddenSet != 0 )
308 : 0 : hidden_entities().merge( dead_surf->hiddenSet );
309 [ # # ]: 0 : for( int i = old_size; i < compGeom->num_entities(); i++ )
310 : : {
311 : 0 : TopologyBridge* bridge = compGeom->entity(i);
312 [ # # ][ # # ]: 0 : assert( bridge->owner() == dead_surf );
313 : 0 : bridge->owner( this );
314 : : }
315 : :
316 [ # # ]: 0 : delete facetTool;
317 : 0 : facetTool = 0;
318 : :
319 : 0 : return CUBIT_SUCCESS;
320 : : }
321 : :
322 : 0 : void CompositeSurface::get_ignored_surfs(DLIList<Surface*> &surfs)
323 : : {
324 : : int i;
325 : :
326 [ # # ]: 0 : if(surfacesToIgnore.size() > 0)
327 : : {
328 [ # # ]: 0 : for(i=0; i<num_surfs(); i++)
329 : : {
330 [ # # ]: 0 : Surface *srf = get_surface(i);
331 [ # # ][ # # ]: 0 : if(surfacesToIgnore.is_in_list(srf))
332 [ # # ]: 0 : surfs.append(srf);
333 : : }
334 : : }
335 : 0 : }
336 : :
337 : : //-------------------------------------------------------------------------
338 : : // Purpose : Return the bounding box
339 : : //
340 : : // Special Notes :
341 : : //
342 : : // Creator : Jason Kraftcheck
343 : : //
344 : : // Creation Date : 05/28/99
345 : : //-------------------------------------------------------------------------
346 : 0 : CubitBox CompositeSurface::bounding_box() const
347 : : {
348 : 0 : return compGeom->bounding_box();
349 : : }
350 : :
351 : : //-------------------------------------------------------------------------
352 : : // Purpose : TB Queries
353 : : //
354 : : // Special Notes :
355 : : //
356 : : // Creator : Jason Kraftcheck
357 : : //
358 : : // Creation Date : 03/06/02
359 : : //-------------------------------------------------------------------------
360 : 0 : void CompositeSurface::get_parents_virt( DLIList<TopologyBridge*>& list )
361 : : {
362 [ # # ][ # # ]: 0 : DLIList<TopologyBridge*> parents, parents2;
[ # # ]
363 [ # # ][ # # ]: 0 : for( int i = 0; i < num_surfs(); i++ )
364 : : {
365 [ # # ]: 0 : parents.clean_out();
366 [ # # ][ # # ]: 0 : get_surface(i)->get_parents( parents );
367 [ # # ]: 0 : parents.reset();
368 [ # # ][ # # ]: 0 : for ( int j = parents.size(); j--; )
369 : : {
370 [ # # ]: 0 : TopologyBridge* shell = parents.get_and_step();
371 [ # # ]: 0 : shell->get_parents( parents2 );
372 [ # # ][ # # ]: 0 : assert (parents2.size() == 1);
373 [ # # ][ # # ]: 0 : if (0 == dynamic_cast<CompositeLump*>(parents2.pop()->owner()))
[ # # ][ # # ]
[ # # ]
374 [ # # ]: 0 : list.append_unique( shell );
375 : : }
376 : : }
377 : :
378 : 0 : CompositeCoSurf* cosurf = 0;
379 [ # # ][ # # ]: 0 : while ((cosurf = next_co_surface( cosurf )))
380 [ # # ][ # # ]: 0 : list.append_unique( cosurf->get_shell() );
[ # # ]
381 : 0 : }
382 : 0 : void CompositeSurface::get_children_virt( DLIList<TopologyBridge*>& list )
383 : : {
384 [ # # ]: 0 : for( CompositeLoop* loop = firstLoop; loop; loop = loop->loopNext )
385 [ # # ]: 0 : list.append( loop );
386 : 0 : }
387 : :
388 : :
389 : : //-------------------------------------------------------------------------
390 : : // Purpose : Attach a CubitSimpleAttribute
391 : : //
392 : : // Special Notes :
393 : : //
394 : : // Creator : Jason Kraftcheck
395 : : //
396 : : // Creation Date : 03/10/98
397 : : //-------------------------------------------------------------------------
398 : 0 : void CompositeSurface::append_simple_attribute_virt(
399 : : const CubitSimpleAttrib& simple_attrib_ptr )
400 : : {
401 [ # # ]: 0 : if(compGeom)
402 : 0 : compGeom->add_attribute( simple_attrib_ptr );
403 : 0 : }
404 : :
405 : : //-------------------------------------------------------------------------
406 : : // Purpose : Remove an attached CubitSimpleAttrib
407 : : //
408 : : // Special Notes :
409 : : //
410 : : // Creator : Jason Kraftcheck
411 : : //
412 : : // Creation Date : 03/10/98
413 : : //-------------------------------------------------------------------------
414 : 0 : void CompositeSurface::remove_simple_attribute_virt(
415 : : const CubitSimpleAttrib& simple_attrib_ptr )
416 : : {
417 [ # # ]: 0 : if(compGeom)
418 : 0 : compGeom->rem_attribute( simple_attrib_ptr );
419 : 0 : }
420 : :
421 : :
422 : : //-------------------------------------------------------------------------
423 : : // Purpose : Remove an all attached CubitSimpleAttrib
424 : : //
425 : : // Special Notes :
426 : : //
427 : : // Creator : Greg Nielson
428 : : //
429 : : // Creation Date : 07/10/98
430 : : //-------------------------------------------------------------------------
431 : 0 : void CompositeSurface::remove_all_simple_attribute_virt()
432 : : {
433 [ # # ]: 0 : if(compGeom)
434 : 0 : compGeom->rem_all_attributes( );
435 : 0 : }
436 : :
437 : :
438 : : //-------------------------------------------------------------------------
439 : : // Purpose : Return the attached CubitSimpleAttribs.
440 : : //
441 : : // Special Notes :
442 : : //
443 : : // Creator : Jason Kraftcheck
444 : : //
445 : : // Creation Date : 03/10/98
446 : : //-------------------------------------------------------------------------
447 : 0 : CubitStatus CompositeSurface::get_simple_attribute(
448 : : DLIList<CubitSimpleAttrib>& attrib_list )
449 : : {
450 [ # # ]: 0 : if(!compGeom)
451 : 0 : return CUBIT_FAILURE;
452 : 0 : compGeom->get_attributes( attrib_list );
453 : 0 : return CUBIT_SUCCESS;
454 : : }
455 : 0 : CubitStatus CompositeSurface::get_simple_attribute(
456 : : const CubitString& name, DLIList<CubitSimpleAttrib>& attrib_list )
457 : : {
458 [ # # ]: 0 : if(!compGeom)
459 : 0 : return CUBIT_FAILURE;
460 : 0 : compGeom->get_attributes( name.c_str(), attrib_list );
461 : 0 : return CUBIT_SUCCESS;
462 : : }
463 : :
464 : :
465 : : //-------------------------------------------------------------------------
466 : : // Purpose : Methods from TBOwner
467 : : //
468 : : // Special Notes :
469 : : //
470 : : // Creator : Jason Kraftcheck
471 : : //
472 : : // Creation Date : 03/07/02
473 : : //-------------------------------------------------------------------------
474 : 0 : CubitStatus CompositeSurface::remove_bridge( TopologyBridge* bridge )
475 : : {
476 [ # # ]: 0 : if(!compGeom)
477 : 0 : return CUBIT_FAILURE;
478 : :
479 : 0 : int i = compGeom->index_of(bridge);
480 [ # # ]: 0 : if( i < 0 )
481 : 0 : return CUBIT_FAILURE;
482 : :
483 [ # # ]: 0 : delete facetTool;
484 : 0 : facetTool = 0;
485 : :
486 [ # # ]: 0 : assert( bridge->owner() == this );
487 : 0 : bridge->owner(0);
488 [ # # ]: 0 : if (!compGeom->remove(i, true))
489 : 0 : return CUBIT_FAILURE;
490 : :
491 [ # # ]: 0 : if (compGeom->num_entities() == 0)
492 : 0 : CompositeEngine::instance().notify_deactivated(this);
493 : 0 : HadBridgeRemoved = 1;
494 : 0 : return CUBIT_SUCCESS;
495 : : }
496 : :
497 : 0 : Surface* CompositeSurface::remove_surface( int index )
498 : : {
499 : 0 : Surface* result = get_surface(index);
500 [ # # ][ # # ]: 0 : if ( !result || !compGeom->remove(index,false) )
[ # # ]
501 : 0 : return 0;
502 : :
503 : 0 : result->owner(0);
504 : 0 : return result;
505 : : }
506 : :
507 : :
508 : :
509 : 0 : CubitStatus CompositeSurface::swap_bridge( TopologyBridge* o,
510 : : TopologyBridge* n,
511 : : bool reversed )
512 : : {
513 [ # # ]: 0 : if( n->owner() )
514 : 0 : return CUBIT_FAILURE;
515 : :
516 : 0 : int i = compGeom->index_of(o);
517 [ # # ]: 0 : GeometryEntity* ge = dynamic_cast<GeometryEntity*>(n);
518 [ # # ][ # # ]: 0 : if( i >= 0 && ge != 0 )
519 : : {
520 : 0 : o->owner(0);
521 : 0 : n->owner(this);
522 [ # # ]: 0 : if ( !compGeom->swap( i, ge ) )
523 : 0 : return CUBIT_FAILURE;
524 : :
525 [ # # ]: 0 : if (reversed)
526 : 0 : compGeom->reverse_sense(i);
527 : 0 : return CUBIT_SUCCESS;
528 : : }
529 : : else
530 : 0 : return CUBIT_FAILURE;
531 : : }
532 : 0 : CubitBoolean CompositeSurface::contains_bridge( TopologyBridge* bridge ) const
533 : : {
534 : 0 : return (CubitBoolean)(compGeom->index_of(bridge) >= 0);
535 : : }
536 : :
537 : :
538 : :
539 : :
540 : :
541 : : //-------------------------------------------------------------------------
542 : : // Purpose : Return a pointer to VirtualQueryEngine
543 : : //
544 : : // Special Notes :
545 : : //
546 : : // Creator : Jason Kraftcheck
547 : : //
548 : : // Creation Date : 03/10/98
549 : : //-------------------------------------------------------------------------
550 : 0 : GeometryQueryEngine* CompositeSurface::get_geometry_query_engine() const
551 : : {
552 : 0 : return VirtualQueryEngine::instance();
553 : : }
554 : :
555 : :
556 : : //-------------------------------------------------------------------------
557 : : // Purpose : Return the surface area.
558 : : //
559 : : // Special Notes :
560 : : //
561 : : // Creator : Jason Kraftcheck
562 : : //
563 : : // Creation Date : 03/10/98
564 : : //-------------------------------------------------------------------------
565 : 0 : double CompositeSurface::measure()
566 : : {
567 : 0 : return compGeom->measure();
568 : : }
569 : :
570 : :
571 : : //-------------------------------------------------------------------------
572 : : // Purpose : Find the closest point to the passed point.
573 : : //
574 : : // Special Notes :
575 : : //
576 : : // Creator : Jason Kraftcheck
577 : : //
578 : : // Creation Date : 03/10/98
579 : : //-------------------------------------------------------------------------
580 : 0 : void CompositeSurface::closest_point_trimmed( CubitVector from_point,
581 : : CubitVector& point_on_surf )
582 : : {
583 : 0 : int index = closest_underlying_surface( from_point );
584 [ # # ]: 0 : get_surface(index)->closest_point_trimmed( from_point, point_on_surf );
585 : 0 : }
586 : :
587 : :
588 : :
589 : 0 : CubitStatus CompositeSurface::get_point_normal( CubitVector& origin,
590 : : CubitVector& normal )
591 : : {
592 [ # # ]: 0 : int count = num_surfs();
593 [ # # ][ # # ]: 0 : CubitVector* vect_list = new CubitVector[count];
[ # # ][ # # ]
594 : 0 : double RESABS_SQUARED = CUBIT_RESABS * CUBIT_RESABS;
595 [ # # ]: 0 : normal.set(0.0,0.0,0.0);
596 : :
597 [ # # ]: 0 : if (count == 1)
598 : : {
599 [ # # ][ # # ]: 0 : return get_surface(0)->get_point_normal(origin,normal);
600 : : }
601 : :
602 [ # # ]: 0 : for( int i = 0; i < count; i++ )
603 : : {
604 [ # # ]: 0 : Surface* surf = get_surface(i);
605 [ # # ][ # # ]: 0 : if( surf->get_point_normal(origin,vect_list[i]) == CUBIT_FAILURE )
606 : : {
607 [ # # ]: 0 : delete [] vect_list;
608 : 0 : return CUBIT_FAILURE;
609 : : }
610 : :
611 [ # # ][ # # ]: 0 : if( compGeom->sense(i) == CUBIT_REVERSED )
612 [ # # ]: 0 : vect_list[i] *= -1.0;
613 [ # # ]: 0 : normal += vect_list[i];
614 : : }
615 : : //If we reach this point, then all of the underlying surfaces are planar.
616 : : //Next check if they are coplanar.
617 [ # # ][ # # ]: 0 : if( normal.length_squared() < RESABS_SQUARED )
618 : : {
619 [ # # ]: 0 : delete [] vect_list;
620 : 0 : return CUBIT_FAILURE;
621 : : }
622 [ # # ]: 0 : normal.normalize();
623 [ # # ]: 0 : for( int j = 0; j < count; j++ )
624 : : {
625 [ # # ][ # # ]: 0 : if( fabs( 1.0 - (normal % ~vect_list[j]) ) > CUBIT_RESABS )
[ # # ]
626 : : {
627 [ # # ]: 0 : delete [] vect_list;
628 : 0 : return CUBIT_FAILURE;
629 : : }
630 : : }
631 : :
632 [ # # ]: 0 : delete [] vect_list;
633 [ # # ]: 0 : CubitVector zero( 0.0, 0.0, 0.0 );
634 [ # # ]: 0 : closest_point( zero, &origin );
635 : 0 : return CUBIT_SUCCESS;
636 : : }
637 : :
638 : : // The CompositeSurface class has a variable
639 : : // "surfacesToIgnore" which specifies which surfaces
640 : : // within the composite should be ignored during evaluation.
641 : : // The "facetTool" variable has a corresponding list of flags
642 : : // and this function syncs the flags in the "facetTool" variable
643 : : // with those that are in the "surfacesToIgnore" variable.
644 : 0 : void CompositeSurface::update_facets_to_ignore()
645 : : {
646 [ # # ]: 0 : if(facetTool)
647 : : {
648 : : int i;
649 [ # # ]: 0 : DLIList<int> surfaces_to_ignore;
650 [ # # ]: 0 : int num_surfs_in_composite = num_surfs();
651 [ # # ]: 0 : for (i=0; i<num_surfs_in_composite; i++)
652 : : {
653 [ # # ]: 0 : Surface *cur_surf = get_surface(i);
654 [ # # ]: 0 : surfacesToIgnore.reset();
655 [ # # ][ # # ]: 0 : for(int j=surfacesToIgnore.size(); j--;)
656 : : {
657 [ # # ][ # # ]: 0 : if(cur_surf == surfacesToIgnore.get_and_step())
658 : : {
659 [ # # ]: 0 : surfaces_to_ignore.append( i );
660 : 0 : j=0;
661 : : }
662 : : }
663 : : }
664 : :
665 : : //do it all at once
666 [ # # ][ # # ]: 0 : facetTool->set_ignore_flag( surfaces_to_ignore, 1 );
667 : : }
668 : 0 : }
669 : :
670 : :
671 : : // This function tells the composite to ignore one of its
672 : : // surfaces during evaluation.
673 : 0 : void CompositeSurface::ignore_surface(int surface_id)
674 : : {
675 : 0 : update_facet_tool();
676 [ # # ]: 0 : if(facetTool)
677 : : {
678 : : int i;
679 : 0 : int num_surfs_in_composite = num_surfs();
680 [ # # ]: 0 : for (i=0; i<num_surfs_in_composite; i++)
681 : : {
682 [ # # ]: 0 : Surface *cur_surf = get_surface(i);
683 [ # # ][ # # ]: 0 : if(cur_surf->get_saved_id() == surface_id)
684 : : {
685 [ # # ]: 0 : surfacesToIgnore.append_unique(cur_surf);
686 : 0 : i = num_surfs_in_composite;
687 [ # # ]: 0 : update_facets_to_ignore();
688 : : }
689 : : }
690 : : }
691 : 0 : }
692 : :
693 : 0 : void CompositeSurface::ignore_surface(Surface *surf)
694 : : {
695 : 0 : update_facet_tool();
696 [ # # ]: 0 : if(facetTool)
697 : : {
698 : : int i;
699 : 0 : int num_surfs_in_composite = num_surfs();
700 [ # # ]: 0 : for (i=0; i<num_surfs_in_composite; i++)
701 : : {
702 [ # # ]: 0 : Surface *cur_surf = get_surface(i);
703 [ # # ]: 0 : if(cur_surf == surf)
704 : : {
705 [ # # ]: 0 : surfacesToIgnore.append_unique(cur_surf);
706 : 0 : i = num_surfs_in_composite;
707 [ # # ]: 0 : update_facets_to_ignore();
708 : : }
709 : : }
710 : : }
711 : 0 : }
712 : :
713 : : // This function tells the composite to unset the ignore
714 : : // flag for one of its surfaces.
715 : 0 : void CompositeSurface::unignore_surface(int surface_id)
716 : : {
717 : 0 : update_facet_tool();
718 [ # # ]: 0 : if(facetTool)
719 : : {
720 : : int i;
721 : 0 : int num_surfs_in_composite = num_surfs();
722 [ # # ]: 0 : for (i=0; i<num_surfs_in_composite; i++)
723 : : {
724 [ # # ]: 0 : Surface *cur_surf = get_surface(i);
725 [ # # ][ # # ]: 0 : if(cur_surf->get_saved_id() == surface_id)
726 : : {
727 [ # # ]: 0 : surfacesToIgnore.remove(cur_surf);
728 [ # # ]: 0 : update_facets_to_ignore();
729 : 0 : i = num_surfs_in_composite;
730 : : }
731 : : }
732 : : }
733 : 0 : }
734 : :
735 : 0 : void CompositeSurface::update_facet_tool()
736 : : {
737 [ # # ]: 0 : if( ! facetTool )
738 : : {
739 [ # # ][ # # ]: 0 : std::vector<Surface*> surf_vect(num_surfs());
740 [ # # ][ # # ]: 0 : for ( int i = 0; i < num_surfs(); i++ )
741 [ # # ][ # # ]: 0 : surf_vect[i] = get_surface(i);
742 [ # # ][ # # ]: 0 : facetTool = new CompSurfFacets();
743 [ # # ][ # # ]: 0 : if ( ! facetTool->setup( surf_vect ) )
744 : : {
745 [ # # ][ # # ]: 0 : delete facetTool;
746 : 0 : facetTool = 0;
747 : : }
748 : : else
749 : : {
750 : : // Make sure to update the facetTool to reflect
751 : : // any surfaces we think we need to ignore.
752 [ # # ]: 0 : update_facets_to_ignore();
753 [ # # ]: 0 : }
754 : : }
755 : 0 : }
756 : :
757 : 0 : CubitStatus CompositeSurface::closest_point_uv_guess(
758 : : CubitVector const& location,
759 : : double &u, double &v,
760 : : CubitVector* closest_location,
761 : : CubitVector* unit_normal )
762 : : {
763 [ # # ]: 0 : if ( num_surfs() == 1)
764 : 0 : return get_surface(0)->
765 : 0 : closest_point_uv_guess(location, u, v, closest_location, unit_normal);
766 : : else
767 : 0 : return closest_point(location, closest_location, unit_normal);
768 : : }
769 : :
770 : 0 : CubitStatus CompositeSurface::evaluate( double u, double v,
771 : : CubitVector *position,
772 : : CubitVector *normal,
773 : : CubitVector *curvature1,
774 : : CubitVector *curvature2 )
775 : : {
776 [ # # ][ # # ]: 0 : if( position || normal || (curvature1 && curvature2) )
[ # # ][ # # ]
777 : : {
778 [ # # ]: 0 : if ( num_surfs() == 1)
779 : 0 : return get_surface(0)->evaluate(u, v, position, normal, curvature1, curvature2 );
780 : : else
781 : 0 : return CUBIT_FAILURE;
782 : : }
783 : : else
784 : 0 : return CUBIT_FAILURE;
785 : : }
786 : :
787 : :
788 : :
789 : : /*
790 : : //-------------------------------------------------------------------------
791 : : // Purpose : Find the closest point to the passed point, on the surface.
792 : : //
793 : : // Special Notes :
794 : : //
795 : : // Creator : Jason Kraftcheck
796 : : //
797 : : // Creation Date : 03/10/98
798 : : //-------------------------------------------------------------------------
799 : : CubitStatus CompositeSurface::closest_point(
800 : : CubitVector const& location,
801 : : CubitVector* closest_location,
802 : : CubitVector* unit_normal,
803 : : CubitVector* curvature1,
804 : : CubitVector* curvature2 )
805 : : {
806 : : if ( num_surfs() == 1 )
807 : : return get_surface(0)->closest_point( location,
808 : : closest_location, unit_normal, curvature1, curvature2 );
809 : :
810 : : update_facet_tool();
811 : : if ( facetTool )
812 : : {
813 : : CubitVector facet_closest, surf_closest;
814 : : int index = facetTool->closest_index( location, &facet_closest );
815 : : CubitStatus result = get_surface(index)->closest_point( location,
816 : : &surf_closest, unit_normal, curvature1, curvature2 );
817 : :
818 : : if (!result)
819 : : return result;
820 : :
821 : : CubitVector facet_delta = facet_closest - location;
822 : : CubitVector surf_delta = surf_closest - location;
823 : : double facet_len = facet_delta.length();
824 : : double surf_len = surf_delta.length();
825 : :
826 : : if ( facet_len > CUBIT_RESABS && surf_len > CUBIT_RESABS )
827 : : {
828 : : facet_delta /= facet_len;
829 : : surf_delta /= surf_len;
830 : : const double cos_angle = facet_delta % surf_delta;
831 : : if (0.985 < cos_angle) // angle greater than about 10 degrees
832 : : {
833 : : result = get_surface(index)->closest_point( facet_closest,
834 : : &surf_closest, unit_normal, curvature1, curvature2 );
835 : :
836 : : if (!result)
837 : : return result;
838 : : }
839 : : }
840 : :
841 : : if (closest_location)
842 : : *closest_location = surf_closest;
843 : :
844 : : if (unit_normal && sense(index) == CUBIT_REVERSED)
845 : : *unit_normal = -*unit_normal;
846 : :
847 : : return result;
848 : : }
849 : :
850 : :
851 : : double shortest_dist_sqr, current_dist_sqr;
852 : : CubitVector closest_point, current_point;
853 : : int closest_surf, current_surf;
854 : :
855 : : //initialize CompositeEntity data structures
856 : : closest_surf = compGeom->closest_box( location );
857 : :
858 : : closest_trimmed( closest_surf, location, closest_point );
859 : : shortest_dist_sqr = (location - closest_point).length_squared();
860 : :
861 : : while( (current_surf = compGeom->next_box_within_dist( shortest_dist_sqr ) ) >= 0 )
862 : : {
863 : : closest_trimmed( current_surf, location, current_point );
864 : : current_dist_sqr = (location - current_point).length_squared();
865 : :
866 : : if( current_dist_sqr < shortest_dist_sqr )
867 : : {
868 : : closest_surf = current_surf;
869 : : closest_point = current_point;
870 : : shortest_dist_sqr = current_dist_sqr;
871 : : }
872 : : }
873 : :
874 : : if( closest_location ) *closest_location = closest_point;
875 : : if( unit_normal || curvature1 || curvature2 )
876 : : {
877 : : get_surface( closest_surf )->closest_point( closest_point, NULL,
878 : : unit_normal, curvature1, curvature2 );
879 : : if( unit_normal && compGeom->sense(closest_surf) == CUBIT_REVERSED )
880 : : *unit_normal *= -1;
881 : : }
882 : :
883 : : return CUBIT_SUCCESS;
884 : : }
885 : : */
886 : : //-------------------------------------------------------------------------
887 : : // Purpose : Find the closest point to the passed point, on the surface.
888 : : //
889 : : // Special Notes :
890 : : //
891 : : // Creator : Jason Kraftcheck
892 : : //
893 : : // Creation Date : 03/10/98
894 : : //-------------------------------------------------------------------------
895 : 0 : CubitStatus CompositeSurface::closest_point( CubitVector const& location,
896 : : CubitVector* closest_location,
897 : : CubitVector* unit_normal,
898 : : CubitVector* curvature1,
899 : : CubitVector* curvature2 )
900 : : {
901 [ # # ][ # # ]: 0 : if ( num_surfs() == 1 )
902 [ # # ]: 0 : return get_surface(0)->closest_point( location, closest_location,
903 : : unit_normal,
904 [ # # ]: 0 : curvature1, curvature2 );
905 : :
906 [ # # ]: 0 : update_facet_tool();
907 : :
908 [ # # ]: 0 : if ( facetTool )
909 : : {
910 : 0 : CubitStatus result = CUBIT_SUCCESS;
911 [ # # ]: 0 : CubitVector facet_closest;
912 : :
913 : : // look for multiple surfaces if normal is requested
914 [ # # ]: 0 : if (unit_normal)
915 : : {
916 [ # # ]: 0 : DLIList<int> index_list;
917 : : int num_found = facetTool->closest_index( location, index_list,
918 [ # # ]: 0 : &facet_closest );
919 : :
920 [ # # ]: 0 : CubitVector normal(0.0, 0.0, 0.0);
921 : : int i;
922 [ # # ]: 0 : for (i = 0; i < num_found; i++)
923 : : {
924 [ # # ]: 0 : int index = index_list[i];
925 [ # # ]: 0 : if(index > -1)
926 : : {
927 [ # # ]: 0 : Surface* surf = get_surface(index);
928 : :
929 : : result = surf->closest_point( facet_closest, closest_location,
930 [ # # ]: 0 : &normal, curvature1, curvature2 );
931 : :
932 [ # # ][ # # ]: 0 : if (get_sense(index) == CUBIT_REVERSED)
933 [ # # ][ # # ]: 0 : *unit_normal += (-normal);
934 : : else
935 [ # # ]: 0 : *unit_normal += normal;
936 : : }
937 : : }
938 [ # # ][ # # ]: 0 : unit_normal->normalize();
939 : : }
940 : : else
941 : : {
942 [ # # ]: 0 : int index = facetTool->closest_index( location, &facet_closest );
943 [ # # ]: 0 : if(index > -1)
944 : : {
945 [ # # ]: 0 : Surface* surf = get_surface(index);
946 : :
947 : : result = surf->closest_point( location, closest_location,
948 [ # # ]: 0 : unit_normal, curvature1, curvature2 );
949 : :
950 : : // if (unit_normal && get_sense(index) == CUBIT_REVERSED)
951 : : // *unit_normal = -*unit_normal;
952 : : }
953 : : else
954 : 0 : result = CUBIT_FAILURE;
955 : : }
956 : :
957 : 0 : return result;
958 : :
959 : : // this code is never accessed
960 : : Surface* surf = NULL;
961 : : int index = -1;
962 : : double u, v;
963 : : result = surf->u_v_from_position( facet_closest, u, v );
964 : : if (!result) return CUBIT_FAILURE;
965 : :
966 : : CubitVector surf_closest;
967 : : result = surf->closest_point_uv_guess( location, u, v, &surf_closest,
968 : : unit_normal );
969 : : if (!result) return CUBIT_FAILURE;
970 : :
971 : : if (unit_normal && get_sense(index) == CUBIT_REVERSED)
972 : : *unit_normal = -*unit_normal;
973 : :
974 : : if (curvature1 || curvature2)
975 : : {
976 : : result = surf->closest_point( surf_closest, 0, 0,
977 : : curvature1, curvature2 );
978 : : if (!result) return CUBIT_FAILURE;
979 : : }
980 : :
981 : : if(closest_location)
982 : : *closest_location = surf_closest;
983 : :
984 : : return CUBIT_SUCCESS;
985 : : }
986 : :
987 : : double shortest_dist_sqr, current_dist_sqr;
988 [ # # ][ # # ]: 0 : CubitVector closest_point, current_point;
989 : : int closest_surf, current_surf;
990 : :
991 : : //initialize CompositeEntity data structures
992 [ # # ]: 0 : closest_surf = compGeom->closest_box( location );
993 : :
994 [ # # ]: 0 : closest_trimmed( closest_surf, location, closest_point );
995 [ # # ][ # # ]: 0 : shortest_dist_sqr = (location - closest_point).length_squared();
996 : :
997 [ # # ][ # # ]: 0 : while( (current_surf = compGeom->next_box_within_dist( shortest_dist_sqr ) ) >= 0 )
998 : : {
999 [ # # ]: 0 : closest_trimmed( current_surf, location, current_point );
1000 [ # # ][ # # ]: 0 : current_dist_sqr = (location - current_point).length_squared();
1001 : :
1002 [ # # ]: 0 : if( current_dist_sqr < shortest_dist_sqr )
1003 : : {
1004 : 0 : closest_surf = current_surf;
1005 [ # # ]: 0 : closest_point = current_point;
1006 : 0 : shortest_dist_sqr = current_dist_sqr;
1007 : : }
1008 : : }
1009 : :
1010 [ # # ][ # # ]: 0 : if( closest_location ) *closest_location = closest_point;
1011 [ # # ][ # # ]: 0 : if( unit_normal || curvature1 || curvature2 )
[ # # ]
1012 : : {
1013 [ # # ]: 0 : get_surface( closest_surf )->closest_point( closest_point, NULL,
1014 [ # # ]: 0 : unit_normal, curvature1, curvature2 );
1015 [ # # ][ # # ]: 0 : if( unit_normal && compGeom->sense(closest_surf) == CUBIT_REVERSED )
[ # # ][ # # ]
1016 [ # # ]: 0 : *unit_normal *= -1;
1017 : : }
1018 : :
1019 : 0 : return CUBIT_SUCCESS;
1020 : : }
1021 : :
1022 : : //-------------------------------------------------------------------------
1023 : : // Purpose : Find closest underlying surface
1024 : : //
1025 : : // Special Notes :
1026 : : //
1027 : : // Creator : Jason Kraftcheck
1028 : : //
1029 : : // Creation Date : 02/18/03
1030 : : //-------------------------------------------------------------------------
1031 : 0 : int CompositeSurface::closest_underlying_surface( const CubitVector& pos )
1032 : : {
1033 [ # # ][ # # ]: 0 : if( num_surfs() == 1 )
1034 : 0 : return 0;
1035 : :
1036 [ # # ]: 0 : update_facet_tool();
1037 [ # # ]: 0 : if( facetTool )
1038 [ # # ]: 0 : return facetTool->closest_index( pos );
1039 : :
1040 : : double shortest_dist_sqr, current_dist_sqr;
1041 [ # # ]: 0 : CubitVector closest_point;
1042 : : int closest_surf, current_surf;
1043 : :
1044 : : //initialize CompositeEntity data structures
1045 [ # # ]: 0 : closest_surf = compGeom->closest_box( pos );
1046 : :
1047 [ # # ]: 0 : closest_trimmed( closest_surf, pos, closest_point );
1048 [ # # ][ # # ]: 0 : shortest_dist_sqr = (pos - closest_point).length_squared();
1049 : :
1050 [ # # ][ # # ]: 0 : while( (current_surf = compGeom->next_box_within_dist( shortest_dist_sqr ) ) >= 0 )
1051 : : {
1052 [ # # ]: 0 : closest_trimmed( current_surf, pos, closest_point );
1053 [ # # ][ # # ]: 0 : current_dist_sqr = (pos - closest_point).length_squared();
1054 : :
1055 [ # # ]: 0 : if( current_dist_sqr < shortest_dist_sqr )
1056 : : {
1057 : 0 : closest_surf = current_surf;
1058 : 0 : shortest_dist_sqr = current_dist_sqr;
1059 : : }
1060 : : }
1061 : :
1062 : 0 : return closest_surf;
1063 : : }
1064 : :
1065 : : //-------------------------------------------------------------------------
1066 : : // Purpose : Evaluate closest_point_trimmed un an underliying surface
1067 : : //
1068 : : // Special Notes : honors use_gme_cpt, and updates stats
1069 : : //
1070 : : // Creator : Jason Kraftcheck
1071 : : //
1072 : : // Creation Date : 11/10/99
1073 : : //-------------------------------------------------------------------------
1074 : 0 : void CompositeSurface::print_cpt_stats()
1075 : : {
1076 : : /*
1077 : : PRINT_INFO("Total Calls %10d\n", total_calls);
1078 : : PRINT_INFO("ClosestTrimmed %10.0f %10.5f\n", trimmed_time, trimmed_time / total_calls );
1079 : : PRINT_INFO("Closest %10.0f %10.5f\n", closest_time, closest_time / total_calls );
1080 : : PRINT_INFO("Containment %10.0f %10.5f\n", contain_time, contain_time / total_calls );
1081 : : double average_outside = (double)contain_trim_count / total_calls;
1082 : : PRINT_INFO("Outside Count %10d %10.5f\n", contain_trim_count, average_outside );
1083 : : double containment = contain_time +
1084 : : average_outside * trimmed_time +
1085 : : (1.0-average_outside) * closest_time;
1086 : : PRINT_INFO("Contain Est. %10.0f %10.5f\n", containment, containment / total_calls );
1087 : : PRINT_INFO("Error Count %10d %10.5f\n", error_count, (double)error_count / total_calls );
1088 : : */
1089 : 0 : }
1090 : 0 : void CompositeSurface::reset_cpt_stats()
1091 : : {
1092 : : /*
1093 : : trimmed_time = contain_time = closest_time = 0.0;
1094 : : total_calls = contain_trim_count = error_count = 0;
1095 : : */
1096 : 0 : }
1097 : 0 : CubitStatus CompositeSurface::closest_trimmed( int index,
1098 : : const CubitVector& position,
1099 : : CubitVector& result )
1100 : : {
1101 [ # # ]: 0 : get_surface(index)->closest_point_trimmed( position, result );
1102 : 0 : return CUBIT_SUCCESS;
1103 : : /*
1104 : : total_calls++;
1105 : : CubitVector close, copy(position);
1106 : : Surface* surf = get_surface(index);
1107 : :
1108 : : timer.cpu_secs();
1109 : : surf->closest_point_trimmed( position, result );
1110 : : trimmed_time += timer.cpu_secs();
1111 : :
1112 : : surf->closest_point( position, &close );
1113 : : closest_time += timer.cpu_secs();
1114 : :
1115 : : CubitPointContainment contain = surf->point_containment( copy );
1116 : : contain_time += timer.cpu_secs();
1117 : :
1118 : : if ( contain == CUBIT_PNT_OUTSIDE )
1119 : : contain_trim_count++;
1120 : : else if( (result - close).length_squared() > GEOMETRY_RESABS*GEOMETRY_RESABS)
1121 : : error_count++;
1122 : :
1123 : : return CUBIT_SUCCESS;
1124 : : */
1125 : : // if( use_gme_cpt )
1126 : : // {
1127 : : // get_surface( index )->closest_point_trimmed( position, result );
1128 : : // return CUBIT_SUCCESS;
1129 : : // }
1130 : : /*
1131 : : DLIList<TopologyBridge*> bridge_list;
1132 : : Surface* surf_ptr = get_surface(index);
1133 : : CubitVector surf_pt, normal, curve_pt;
1134 : : if( !surf_ptr->closest_point( position, &surf_pt, &normal ) )
1135 : : return CUBIT_FAILURE;
1136 : :
1137 : : CoEdgeSM *closest_coedge, *other_coedge = 0;
1138 : : cptInfo.setup(surf_ptr);
1139 : : cptInfo.closest_coedge( position, closest_coedge, other_coedge, curve_pt );
1140 : : if ( !closest_coedge )
1141 : : return CUBIT_FAILURE;
1142 : :
1143 : : CubitVector coe_normal, cross, tangent1, tangent2, junk;
1144 : : bool inside;
1145 : :
1146 : :
1147 : : if ( !other_coedge )
1148 : : {
1149 : : bridge_list.clean_out();
1150 : : closest_coedge->get_children_virt( bridge_list );
1151 : : Curve* curve_ptr = dynamic_cast<Curve*>(bridge_list.get());
1152 : : assert( !!curve_ptr );
1153 : : double u = curve_ptr->u_from_position( curve_pt );
1154 : :
1155 : : if( !curve_ptr->G1_discontinuous( u, &tangent1, &tangent2 ) )
1156 : : {
1157 : : curve_ptr->closest_point( curve_pt, junk, &tangent1 );
1158 : : bool inside = is_inside( tangent1, curve_pt, surf_pt, normal );
1159 : : result = inside ? surf_pt : curve_pt;
1160 : : return CUBIT_SUCCESS;
1161 : : }
1162 : :
1163 : : if( closest_coedge->sense() == CUBIT_REVERSED )
1164 : : {
1165 : : tangent1 = -tangent1;
1166 : : tangent2 = -tangent2;
1167 : : }
1168 : : }
1169 : : else
1170 : : {
1171 : : bridge_list.clean_out();
1172 : : closest_coedge->get_children_virt( bridge_list );
1173 : : Curve* curve1 = dynamic_cast<Curve*>(bridge_list.get());
1174 : : bridge_list.clean_out();
1175 : : other_coedge->get_children_virt( bridge_list );
1176 : : Curve* curve2 = dynamic_cast<Curve*>(bridge_list.get());
1177 : : assert(curve1 && curve2);
1178 : :
1179 : : curve1->closest_point( curve_pt, junk, &tangent1 );
1180 : : curve2->closest_point( curve_pt, junk, &tangent2 );
1181 : : if( closest_coedge->sense() == CUBIT_REVERSED ) tangent1 = -tangent1;
1182 : : if( other_coedge->sense() == CUBIT_REVERSED ) tangent2 = -tangent2;
1183 : : }
1184 : :
1185 : : surf_ptr->closest_point( curve_pt, 0, &coe_normal );
1186 : : cross = tangent1 * tangent2;
1187 : : bool inside1 = is_inside( tangent1, curve_pt, surf_pt, normal );
1188 : : bool inside2 = is_inside( tangent2, curve_pt, surf_pt, normal );
1189 : :
1190 : : if ( (cross % coe_normal) > 0.0 )
1191 : : inside = inside1 && inside2;
1192 : : else
1193 : : inside = inside1 || inside2;
1194 : :
1195 : : result = inside ? surf_pt : curve_pt;
1196 : : return CUBIT_SUCCESS;
1197 : : */
1198 : : }
1199 : : /*
1200 : : bool CompositeSurface::is_inside( const CubitVector& tangent,
1201 : : const CubitVector& curve_pt,
1202 : : const CubitVector& surf_pt,
1203 : : const CubitVector& normal )
1204 : : {
1205 : : CubitVector cross = tangent * ( surf_pt - curve_pt );
1206 : : return cross % normal >= 0.0;
1207 : : }
1208 : : */
1209 : :
1210 : :
1211 : : //-------------------------------------------------------------------------
1212 : : // Purpose : Get the magnitudes of the principal curvatures.
1213 : : //
1214 : : // Special Notes :
1215 : : //
1216 : : // Creator : Jason Kraftcheck
1217 : : //
1218 : : // Creation Date : 03/10/98
1219 : : //-------------------------------------------------------------------------
1220 : 0 : CubitStatus CompositeSurface::principal_curvatures(
1221 : : CubitVector const& location,
1222 : : double& curvature_1,
1223 : : double& curvature_2,
1224 : : CubitVector* closest_location )
1225 : : {
1226 [ # # ][ # # ]: 0 : if (num_surfs() == 1)
1227 [ # # ]: 0 : return get_surface(0)->
1228 [ # # ]: 0 : principal_curvatures(location, curvature_1, curvature_2, closest_location);
1229 : :
1230 [ # # ][ # # ]: 0 : CubitVector curvature1, curvature2;
1231 : : CubitStatus s = closest_point( location, closest_location, NULL,
1232 [ # # ]: 0 : &curvature1, &curvature2 );
1233 [ # # ]: 0 : if( s == CUBIT_FAILURE ) return CUBIT_FAILURE;
1234 : :
1235 [ # # ]: 0 : curvature_1 = curvature1.length();
1236 [ # # ]: 0 : curvature_2 = curvature2.length();
1237 : 0 : return CUBIT_SUCCESS;
1238 : : }
1239 : :
1240 : :
1241 : : //-------------------------------------------------------------------------
1242 : : // Purpose : Evaluate the parameter values to get a position on the
1243 : : // surface.
1244 : : //
1245 : : // Special Notes :
1246 : : //
1247 : : // Creator : Jason Kraftcheck
1248 : : //
1249 : : // Creation Date : 03/10/98
1250 : : //-------------------------------------------------------------------------
1251 : 0 : CubitVector CompositeSurface::position_from_u_v( double u, double v )
1252 : : {
1253 [ # # ][ # # ]: 0 : if (num_surfs() == 1)
1254 [ # # ][ # # ]: 0 : return get_surface(0)->position_from_u_v(u,v);
1255 : :
1256 [ # # ][ # # ]: 0 : PRINT_ERROR("CompositeSurface::position_from_u_v for non-paramtric surface.\n");
[ # # ][ # # ]
1257 [ # # ]: 0 : CubitVector nulvect( 0., 0., 0.);
1258 [ # # ]: 0 : return nulvect;
1259 : : }
1260 : :
1261 : :
1262 : : //-------------------------------------------------------------------------
1263 : : // Purpose : Determine values of u and v which evaluate to the passed
1264 : : // position on the surface.
1265 : : //
1266 : : // Special Notes :
1267 : : //
1268 : : // Creator : Jason Kraftcheck
1269 : : //
1270 : : // Creation Date : 03/10/98
1271 : : //-------------------------------------------------------------------------
1272 : 0 : CubitStatus CompositeSurface::u_v_from_position(
1273 : : CubitVector const& pos ,
1274 : : double& u,
1275 : : double& v,
1276 : : CubitVector* closest )
1277 : : {
1278 [ # # ]: 0 : if (num_surfs() == 1)
1279 : 0 : return get_surface(0)->u_v_from_position(pos, u, v, closest);
1280 : :
1281 [ # # ][ # # ]: 0 : PRINT_ERROR("CompositeSurface::u_v_from_position for non-paramtric surface.\n");
1282 : 0 : u = v = 0.0;
1283 : 0 : return CUBIT_FAILURE;
1284 : : }
1285 : :
1286 : :
1287 : : //-------------------------------------------------------------------------
1288 : : // Purpose : Is the prameterization of the surface periodic in nature?
1289 : : //
1290 : : // Special Notes : Always false, because the surface is not parametric.
1291 : : //
1292 : : // Creator : Jason Kraftcheck
1293 : : //
1294 : : // Creation Date : 03/10/98
1295 : : //-------------------------------------------------------------------------
1296 : 0 : CubitBoolean CompositeSurface::is_periodic()
1297 : : {
1298 [ # # ]: 0 : if (num_surfs() == 1)
1299 : 0 : return get_surface(0)->is_periodic();
1300 : :
1301 : 0 : return CUBIT_FALSE;
1302 : : }
1303 : :
1304 : : //-------------------------------------------------------------------------
1305 : : // Purpose : Is the prameterization of the surface periodic in nature?
1306 : : //
1307 : : // Special Notes : Always false, because the surface is not parametric.
1308 : : //
1309 : : // Creator : Jason Kraftcheck
1310 : : //
1311 : : // Creation Date : 03/10/98
1312 : : //-------------------------------------------------------------------------
1313 : 0 : CubitBoolean CompositeSurface::is_periodic_in_U( double& period )
1314 : : {
1315 [ # # ]: 0 : if (num_surfs() == 1)
1316 : 0 : return get_surface(0)->is_periodic_in_U(period);
1317 : :
1318 : 0 : period = 0.0;
1319 : 0 : return CUBIT_FALSE;
1320 : : }
1321 : 0 : CubitBoolean CompositeSurface::is_periodic_in_V( double& period )
1322 : : {
1323 [ # # ]: 0 : if (num_surfs() == 1)
1324 : 0 : return get_surface(0)->is_periodic_in_V(period);
1325 : :
1326 : 0 : period = 0.0;
1327 : 0 : return CUBIT_FALSE;
1328 : : }
1329 : :
1330 : : //-------------------------------------------------------------------------
1331 : : // Purpose : Is the parameterization singular at the passed parameter
1332 : : // value.
1333 : : //
1334 : : // Special Notes : Never: surface is not parametric.
1335 : : //
1336 : : // Creator : Jason Kraftcheck
1337 : : //
1338 : : // Creation Date : 03/10/98
1339 : : //-------------------------------------------------------------------------
1340 : 0 : CubitBoolean CompositeSurface::is_singular_in_U( double param )
1341 : : {
1342 [ # # ]: 0 : if (num_surfs() == 1)
1343 : 0 : return get_surface(0)->is_singular_in_U(param);
1344 : :
1345 : 0 : return CUBIT_FALSE;
1346 : : }
1347 : 0 : CubitBoolean CompositeSurface::is_singular_in_V( double param )
1348 : : {
1349 [ # # ]: 0 : if (num_surfs() == 1)
1350 : 0 : return get_surface(0)->is_singular_in_V(param);
1351 : :
1352 : 0 : return CUBIT_FALSE;
1353 : : }
1354 : :
1355 : :
1356 : : //-------------------------------------------------------------------------
1357 : : // Purpose : Is the surface closed along a param.
1358 : : //
1359 : : // Special Notes :
1360 : : //
1361 : : // Creator : Jason Kraftcheck
1362 : : //
1363 : : // Creation Date : 03/10/98
1364 : : //-------------------------------------------------------------------------
1365 : 0 : CubitBoolean CompositeSurface::is_closed_in_U()
1366 : : {
1367 [ # # ]: 0 : if (num_surfs() == 1)
1368 : 0 : return get_surface(0)->is_closed_in_U();
1369 : :
1370 : 0 : return CUBIT_FALSE;
1371 : : }
1372 : 0 : CubitBoolean CompositeSurface::is_closed_in_V()
1373 : : {
1374 [ # # ]: 0 : if (num_surfs() == 1)
1375 : 0 : return get_surface(0)->is_closed_in_V();
1376 : :
1377 : 0 : return CUBIT_FALSE;
1378 : : }
1379 : :
1380 : :
1381 : : //-------------------------------------------------------------------------
1382 : : // Purpose : Find u and v derivitives at the specified location.
1383 : : //
1384 : : // Special Notes :
1385 : : //
1386 : : // Creator : Jason Kraftcheck
1387 : : //
1388 : : // Creation Date : 03/10/98
1389 : : //-------------------------------------------------------------------------
1390 : 0 : CubitStatus CompositeSurface::uv_derivitives( double u,
1391 : : double v,
1392 : : CubitVector& du,
1393 : : CubitVector& dv )
1394 : : {
1395 [ # # ]: 0 : if (num_surfs() == 1)
1396 : 0 : return get_surface(0)->uv_derivitives(u, v, du, dv);
1397 : :
1398 [ # # ][ # # ]: 0 : PRINT_ERROR("CompositeSurface::uv_derivitives for non-paramtric surface.\n");
1399 : 0 : return CUBIT_FAILURE;
1400 : : }
1401 : :
1402 : :
1403 : : //-------------------------------------------------------------------------
1404 : : // Purpose : Is the surface parametric.
1405 : : //
1406 : : // Special Notes :
1407 : : //
1408 : : // Creator : Jason Kraftcheck
1409 : : //
1410 : : // Creation Date : 03/10/98
1411 : : //-------------------------------------------------------------------------
1412 : 0 : CubitBoolean CompositeSurface::is_parametric()
1413 : : {
1414 [ # # ]: 0 : if (num_surfs() == 1)
1415 : 0 : return get_surface(0)->is_parametric();
1416 : :
1417 : 0 : return CUBIT_FALSE;
1418 : : }
1419 : :
1420 : :
1421 : : //-------------------------------------------------------------------------
1422 : : // Purpose : Get the range of a parameter.
1423 : : //
1424 : : // Special Notes :
1425 : : //
1426 : : // Creator : Jason Kraftcheck
1427 : : //
1428 : : // Creation Date : 03/10/98
1429 : : //-------------------------------------------------------------------------
1430 : 0 : CubitBoolean CompositeSurface::get_param_range_U( double& lower,
1431 : : double& upper )
1432 : : {
1433 [ # # ]: 0 : if (num_surfs() == 1)
1434 : 0 : return get_surface(0)->get_param_range_U(lower, upper);
1435 : :
1436 : 0 : lower = upper = 0;
1437 : 0 : return CUBIT_FALSE;
1438 : : }
1439 : 0 : CubitBoolean CompositeSurface::get_param_range_V( double& lower,
1440 : : double& upper )
1441 : : {
1442 [ # # ]: 0 : if (num_surfs() == 1)
1443 : 0 : return get_surface(0)->get_param_range_V(lower, upper);
1444 : :
1445 : 0 : lower = upper = 0;
1446 : 0 : return CUBIT_FALSE;
1447 : : }
1448 : :
1449 : :
1450 : : //-------------------------------------------------------------------------
1451 : : // Purpose : Check if the passed position is on the surface.
1452 : : //
1453 : : // Special Notes :
1454 : : //
1455 : : // Creator : Jason Kraftcheck
1456 : : //
1457 : : // Creation Date : 03/10/98
1458 : : //-------------------------------------------------------------------------
1459 : 0 : CubitBoolean CompositeSurface::is_position_on(CubitVector& position)
1460 : : {
1461 [ # # ]: 0 : for( int i = 0; i < compGeom->num_entities(); i++ )
1462 : : {
1463 : 0 : Surface* surf = get_surface(i);
1464 [ # # ]: 0 : if( surf->is_position_on( position ) ) return CUBIT_TRUE;
1465 : : }
1466 : :
1467 : 0 : return CUBIT_FALSE;
1468 : : }
1469 : :
1470 : : //-------------------------------------------------------------------------
1471 : : // Purpose : Check if the passed position is outside, inside or
1472 : : // on the boundary of the surface.
1473 : : //
1474 : : // Special Notes :
1475 : : //
1476 : : // Creator : Steve Storm
1477 : : //
1478 : : // Creation Date : 12/01/00
1479 : : //-------------------------------------------------------------------------
1480 : 0 : CubitPointContainment CompositeSurface::point_containment( const CubitVector &point )
1481 : : {
1482 : 0 : bool boundary = false;
1483 [ # # ]: 0 : for( int i = 0; i < num_surfs(); i++ )
1484 : : {
1485 : 0 : CubitPointContainment cpc = get_surface(i)->point_containment( point );
1486 [ # # # # ]: 0 : switch( cpc )
1487 : : {
1488 : : case CUBIT_PNT_OUTSIDE:
1489 : : //case CUBIT_PNT_OFF:
1490 : 0 : break;
1491 : : case CUBIT_PNT_INSIDE:
1492 : : //case CUBIT_PNT_ON:
1493 : 0 : return cpc;
1494 : : case CUBIT_PNT_BOUNDARY:
1495 : 0 : boundary = true;
1496 : 0 : break;
1497 : : case CUBIT_PNT_UNKNOWN:
1498 : : default:
1499 : 0 : return CUBIT_PNT_UNKNOWN;
1500 : : }
1501 : : }
1502 : :
1503 [ # # ]: 0 : if( boundary )
1504 : 0 : return CUBIT_PNT_BOUNDARY;
1505 : : else
1506 : 0 : return CUBIT_PNT_OUTSIDE;
1507 : : }
1508 : : /*
1509 : : CubitPointContainment CompositeSurface::point_containment( CubitVector &point,
1510 : : double ,
1511 : : double )
1512 : : {
1513 : : return point_containment( point );
1514 : : }
1515 : : */
1516 : 0 : CubitPointContainment CompositeSurface::point_containment( double u,
1517 : : double v )
1518 : : {
1519 [ # # ]: 0 : if (num_surfs() == 1)
1520 : 0 : return get_surface(0)->point_containment(u,v);
1521 : : // Set this up when uv parameters are defined for composite surfaces.
1522 : 0 : return CUBIT_PNT_UNKNOWN;
1523 : : }
1524 : :
1525 : : //-------------------------------------------------------------------------
1526 : : // Purpose : Relative sense of Surface wrt geometry underneath.
1527 : : //
1528 : : // Special Notes :
1529 : : //
1530 : : // Creator : Jason Kraftcheck
1531 : : //
1532 : : // Creation Date : 03/10/98
1533 : : //-------------------------------------------------------------------------
1534 : 0 : CubitSense CompositeSurface::get_geometry_sense()
1535 : : {
1536 : 0 : return CUBIT_FORWARD;
1537 : : }
1538 : 0 : void CompositeSurface::reverse_sense()
1539 : : {
1540 : 0 : compGeom->reverse();
1541 : 0 : }
1542 : :
1543 : :
1544 : 0 : void CompositeSurface::get_curves( DLIList<CompositeCurve*>& result )
1545 : : {
1546 [ # # ]: 0 : for( CompositeLoop* loop = firstLoop; loop; loop = loop->loopNext )
1547 : : {
1548 : 0 : CompositeCoEdge* coedge = loop->first_coedge();
1549 [ # # ]: 0 : while( coedge )
1550 : : {
1551 [ # # ]: 0 : result.append_unique( coedge->get_curve() );
1552 : 0 : coedge = loop->next_coedge( coedge );
1553 : : }
1554 : : }
1555 : 0 : }
1556 : :
1557 : :
1558 : 0 : bool CompositeSurface::has_hidden_entities() const
1559 : : {
1560 [ # # ][ # # ]: 0 : return hiddenSet && !hiddenSet->is_empty();
1561 : : }
1562 : :
1563 : 0 : GeometryType CompositeSurface::geometry_type()
1564 : 0 : { return UNDEFINED_SURFACE_TYPE; }
1565 : :
1566 : 0 : void CompositeSurface::get_hidden_curves( DLIList<Curve*>& curves )
1567 : : {
1568 [ # # ]: 0 : if( hiddenSet )
1569 : 0 : hiddenSet->hidden_curves( curves );
1570 : 0 : }
1571 : :
1572 : 0 : void CompositeSurface::print_debug_info( const char* line_prefix,
1573 : : bool brief )
1574 : : {
1575 [ # # ]: 0 : if( line_prefix == 0 ) line_prefix = "";
1576 : 0 : CompositeLoop* loop = 0;
1577 : :
1578 [ # # ]: 0 : if( brief )
1579 : : {
1580 : 0 : int count = 0;
1581 [ # # ]: 0 : while ( (loop = next_loop(loop) ) != NULL )
1582 : 0 : count++;
1583 : : #ifdef TOPOLOGY_BRIDGE_IDS
1584 : : PRINT_INFO("%sCompositeSurface %d : %d loops ", line_prefix, get_id(), count );
1585 : : if ( num_surfs() == 1 )
1586 : : PRINT_INFO("%s %d\n", fix_type_name(typeid(*get_surface(0)).name()), get_surface(0)->get_id());
1587 : : else
1588 : : PRINT_INFO("%d surfaces.\n", num_surfs());
1589 : :
1590 : : #else
1591 [ # # ][ # # ]: 0 : PRINT_INFO("%sCompositeSurface %p : %d loops ", line_prefix, (void*)this, count );
1592 [ # # ]: 0 : if ( num_surfs() == 1 )
1593 [ # # ][ # # ]: 0 : PRINT_INFO("%s %d\n", fix_type_name(typeid(*get_surface(0)).name()), get_surface(0)->get_saved_id());
[ # # ]
1594 : : // PRINT_INFO("%s %p\n", fix_type_name(typeid(*get_surface(0)).name()), get_surface(0));
1595 : : else
1596 [ # # ][ # # ]: 0 : PRINT_INFO("%d surfaces.\n", num_surfs());
1597 : : #endif
1598 : 0 : return;
1599 : : }
1600 : :
1601 : 0 : char* new_prefix = new char[strlen(line_prefix)+3];
1602 : 0 : strcpy( new_prefix, line_prefix );
1603 : 0 : strcat( new_prefix, " " );
1604 : : #ifdef TOPOLOGY_BRIDGE_IDS
1605 : : PRINT_INFO("%sCompositeSurface %d\n", line_prefix, get_id() );
1606 : : #else
1607 [ # # ][ # # ]: 0 : PRINT_INFO("%sCompositeSurface %d\n", line_prefix, this->get_saved_id() );
1608 : : // PRINT_INFO("%sCompositeSurface %p\n", line_prefix, this );
1609 : : #endif
1610 : 0 : compGeom->print_debug_info( new_prefix );
1611 : :
1612 : : // Print out info about any surfaces we are ingoring
1613 : : // during evaluation.
1614 [ # # ]: 0 : if(surfacesToIgnore.size() > 0)
1615 : : {
1616 [ # # ][ # # ]: 0 : PRINT_INFO("%sSurfaces which are ignored:\n", new_prefix);
1617 [ # # ]: 0 : for(int k=surfacesToIgnore.size(); k--;)
1618 : : {
1619 [ # # ]: 0 : PRINT_INFO("%sSurface: %d\n",
1620 [ # # ]: 0 : new_prefix, surfacesToIgnore.get_and_step()->get_saved_id());
1621 : : }
1622 : : }
1623 [ # # ]: 0 : if( hiddenSet ) hiddenSet->print_debug_info( new_prefix );
1624 [ # # ][ # # ]: 0 : else PRINT_INFO("%s No Hidden Entities.\n", line_prefix );
1625 [ # # ]: 0 : while( (loop = next_loop(loop) ) != NULL )
1626 : 0 : loop->print_debug_info( new_prefix );
1627 [ # # ]: 0 : delete [] new_prefix;
1628 : :
1629 : 0 : update_facet_tool();
1630 [ # # ]: 0 : if ( facetTool )
1631 : : {
1632 : 0 : facetTool->debug_draw_facets();
1633 : : // bool* reversed = new bool[num_surfs()];
1634 : : // for (int i = 0; i < num_surfs(); i++ )
1635 : : // reversed[i] = get_sense(i) == CUBIT_REVERSED;
1636 : : // facetTool->consolidate_points(reversed, GEOMETRY_RESABS);
1637 : : // delete [] reversed;
1638 : : }
1639 : : }
1640 : :
1641 : : //-------------------------------------------------------------------------
1642 : : // Purpose : Get sense in Shell
1643 : : //
1644 : : // Special Notes :
1645 : : //
1646 : : // Creator : Jason Kraftcheck
1647 : : //
1648 : : // Creation Date : 08/27/02
1649 : : //-------------------------------------------------------------------------
1650 : 0 : CubitSense CompositeSurface::get_shell_sense( ShellSM* shellsm_ptr ) const
1651 : : {
1652 [ # # ]: 0 : CompositeShell* shell = dynamic_cast<CompositeShell*>(shellsm_ptr);
1653 [ # # ]: 0 : if( shell )
1654 [ # # ]: 0 : return shell->find_sense(this);
1655 : :
1656 [ # # ]: 0 : DLIList<TopologyBridge*> parents;
1657 [ # # ][ # # ]: 0 : for( int i = 0; i < num_surfs(); i++ )
1658 : : {
1659 [ # # ]: 0 : parents.clean_out();
1660 [ # # ][ # # ]: 0 : get_surface(i)->get_parents( parents );
1661 [ # # ][ # # ]: 0 : if( parents.is_in_list( shellsm_ptr ) )
1662 : : {
1663 [ # # ][ # # ]: 0 : CubitSense result = get_surface(i)->get_shell_sense(shellsm_ptr);
1664 [ # # ][ # # ]: 0 : if( get_sense(i) == CUBIT_REVERSED )
1665 : : {
1666 [ # # ]: 0 : if( result == CUBIT_FORWARD )
1667 : 0 : result = CUBIT_REVERSED;
1668 [ # # ]: 0 : else if( result == CUBIT_REVERSED )
1669 : 0 : result = CUBIT_FORWARD;
1670 : : }
1671 : 0 : return result;
1672 : : }
1673 : : }
1674 [ # # ]: 0 : return CUBIT_UNKNOWN;
1675 : : }
1676 : :
1677 : 0 : void CompositeSurface::notify_reversed( TopologyBridge* bridge )
1678 : : {
1679 : 0 : int index = compGeom->index_of(bridge);
1680 [ # # ]: 0 : if( index >= 0 )
1681 : 0 : compGeom->reverse_sense(index);
1682 : 0 : }
1683 : :
1684 : 0 : CubitStatus CompositeSurface::stitch( CompositeSurface* partner )
1685 : : {
1686 [ # # ][ # # ]: 0 : if( this == partner || this->stitchPartner || partner->stitchPartner )
[ # # ]
1687 : : {
1688 : 0 : assert(0);
1689 : : return CUBIT_FAILURE;
1690 : : }
1691 : :
1692 : 0 : this->stitchPartner = partner;
1693 : 0 : partner->stitchPartner = this;
1694 : 0 : return CUBIT_SUCCESS;
1695 : : }
1696 : :
1697 : 0 : CompositeSurface* CompositeSurface::unstitch()
1698 : : {
1699 : 0 : CompositeSurface* result = this->stitchPartner;
1700 [ # # ]: 0 : if( result )
1701 : 0 : this->stitchPartner = result->stitchPartner = 0;
1702 : 0 : return result;
1703 : : }
1704 : :
1705 : : //-------------------------------------------------------------------------
1706 : : // Purpose : Update for change in underlying topology
1707 : : //
1708 : : // Special Notes :
1709 : : //
1710 : : // Creator : Jason Kraftcheck
1711 : : //
1712 : : // Creation Date : 12/19/02
1713 : : //-------------------------------------------------------------------------
1714 : 0 : void CompositeSurface::notify_topology_modified( TopologyBridge* bridge )
1715 : : {
1716 [ # # ]: 0 : DLIList<CompositeCurve*> new_curves;
1717 [ # # ]: 0 : Surface* surf = dynamic_cast<Surface*>(bridge);
1718 [ # # ][ # # ]: 0 : assert( surf && index_of(surf) >= 0 );
[ # # ]
1719 [ # # ]: 0 : update_modified();
1720 [ # # ][ # # ]: 0 : update_modified( surf, new_curves );
1721 : :
1722 : : // for( int i = new_curves.size(); i--; )
1723 : : // if( !CompositeEngine::instance().restore_curve(new_curves.get_and_step()) )
1724 : : // assert(0);
1725 : 0 : }
1726 : :
1727 : 0 : void CompositeSurface::update_modified( Surface* surf,
1728 : : DLIList<CompositeCurve*>& new_curves )
1729 : : {
1730 : : int i;
1731 : : //int i = index_of(surf);
1732 : : //assert(i >= 0);
1733 : : //CubitSense rel_sense = get_sense(i);
1734 : :
1735 : : // find any new coedges in the surface
1736 [ # # ]: 0 : DLIList<TopologyBridge*> bridge_list;
1737 [ # # ][ # # ]: 0 : DLIList<LoopSM*> loops;
1738 [ # # ][ # # ]: 0 : DLIList<CoEdgeSM*> coedges;
1739 : :
1740 [ # # ]: 0 : surf->get_children_virt( bridge_list );
1741 [ # # ][ # # ]: 0 : CAST_LIST( bridge_list, loops, LoopSM );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1742 [ # # ][ # # ]: 0 : assert( bridge_list.size() == loops.size() );
[ # # ]
1743 [ # # ]: 0 : bridge_list.clean_out();
1744 : :
1745 [ # # ][ # # ]: 0 : for( i = loops.size(); i--; )
1746 : : {
1747 [ # # ][ # # ]: 0 : loops.get_and_step()->get_children_virt( bridge_list );
1748 [ # # ][ # # ]: 0 : while( bridge_list.size() )
1749 : : {
1750 [ # # ][ # # ]: 0 : CoEdgeSM* coedge = dynamic_cast<CoEdgeSM*>(bridge_list.pop());
1751 [ # # ]: 0 : assert(0 != coedge);
1752 [ # # ]: 0 : coedges.append(coedge);
1753 : : }
1754 : : }
1755 : :
1756 [ # # ][ # # ]: 0 : for( i = coedges.size(); i--; )
1757 : : {
1758 [ # # ]: 0 : CoEdgeSM* coedge = coedges.get_and_step();
1759 [ # # ]: 0 : bridge_list.clean_out();
1760 [ # # ]: 0 : coedge->get_children_virt( bridge_list );
1761 [ # # ][ # # ]: 0 : assert( bridge_list.size() == 1 );
1762 [ # # ][ # # ]: 0 : Curve* curve = dynamic_cast<Curve*>(bridge_list.get());
1763 [ # # ]: 0 : assert( 0 != curve );
1764 : :
1765 [ # # ][ # # ]: 0 : CompositeCoEdge* ccoedge = dynamic_cast<CompositeCoEdge*>(coedge->owner());
1766 [ # # ]: 0 : if (ccoedge)
1767 : : {
1768 : : // If replace-curve was already done for the curve
1769 : : // when processing the other surface, the composite
1770 : : // coedge will have been created already. Add it to
1771 : : // the hidden set.
1772 [ # # ][ # # ]: 0 : if( !ccoedge->owner() && ccoedge->get_curve()->owner() == &hidden_entities())
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1773 [ # # ][ # # ]: 0 : hidden_entities().hide( ccoedge );
1774 : :
1775 : : // If the coedge is a composite, the curve must be one
1776 : : // already as well. Done with this coedge.
1777 : 0 : continue;
1778 : : }
1779 : :
1780 : : // Replace curve with composite, and hide composite curve
1781 : : // and any new child points.
1782 [ # # ][ # # ]: 0 : CompositeCurve* ccurve = CompositeEngine::instance().replace_curve(curve);
1783 [ # # ]: 0 : assert(0 != ccurve);
1784 [ # # ]: 0 : new_curves.append(ccurve);
1785 [ # # ][ # # ]: 0 : hidden_entities().hide( ccurve );
1786 [ # # ]: 0 : CompositePoint* start = ccurve->start_point();
1787 [ # # ][ # # ]: 0 : if( ! start->owner() )
1788 [ # # ][ # # ]: 0 : hidden_entities().hide(start);
1789 [ # # ]: 0 : CompositePoint* end = ccurve->start_point();
1790 [ # # ][ # # ]: 0 : if( ! end->owner() )
1791 [ # # ][ # # ]: 0 : hidden_entities().hide(end);
1792 : :
1793 : : // CompositeCoEdge was created by replace_curve(..)
1794 : : // Add it to the HiddenEntitySet
1795 [ # # ][ # # ]: 0 : ccoedge = dynamic_cast<CompositeCoEdge*>(coedge->owner());
1796 [ # # ][ # # ]: 0 : assert(ccoedge && !ccoedge->owner());
[ # # ]
1797 [ # # ][ # # ]: 0 : hidden_entities().hide( ccoedge );
1798 [ # # ]: 0 : }
1799 : 0 : }
1800 : :
1801 : :
1802 : :
1803 : :
1804 : :
1805 : : //-------------------------------------------------------------------------
1806 : : // Purpose : Update for split in underlying surface
1807 : : //
1808 : : // Special Notes :
1809 : : //
1810 : : // Creator : Jason Kraftcheck
1811 : : //
1812 : : // Creation Date : 12/19/02
1813 : : //-------------------------------------------------------------------------
1814 : 0 : void CompositeSurface::notify_split( TopologyBridge* new_bridge,
1815 : : TopologyBridge* old_bridge )
1816 : : {
1817 [ # # ][ # # ]: 0 : assert(!new_bridge->owner());
1818 : :
1819 [ # # ]: 0 : Surface* old_surf = dynamic_cast<Surface*>(old_bridge);
1820 [ # # ]: 0 : Surface* new_surf = dynamic_cast<Surface*>(new_bridge);
1821 [ # # ][ # # ]: 0 : assert( old_surf && new_surf );
1822 [ # # ]: 0 : int old_surf_index = index_of(old_surf);
1823 [ # # ]: 0 : assert(old_surf_index >= 0);
1824 : :
1825 [ # # ][ # # ]: 0 : compGeom->append(new_surf, compGeom->sense(old_surf_index));
1826 [ # # ]: 0 : new_surf->owner(this);
1827 : :
1828 [ # # ]: 0 : DLIList<CompositeCurve*> new_curves;
1829 [ # # ]: 0 : update_modified();
1830 [ # # ]: 0 : update_modified( old_surf, new_curves );
1831 [ # # ][ # # ]: 0 : update_modified( new_surf, new_curves );
1832 : :
1833 : : // for( int i = new_curves.size(); i--; )
1834 : : // if( !CompositeEngine::instance().restore_curve(new_curves.get_and_step()) )
1835 : : // assert(0);
1836 : 0 : }
1837 : :
1838 : 0 : bool CompositeSurface::is_dead_coedge( CompositeCoEdge* coedge )
1839 : : {
1840 [ # # ]: 0 : if (coedge->num_coedges() > 0)
1841 : 0 : return false;
1842 : :
1843 : 0 : CompositeCurve* curve = coedge->get_curve();
1844 [ # # ]: 0 : if (!curve)
1845 : 0 : return true;
1846 : :
1847 [ # # ]: 0 : if (curve->num_curves() == 0) // point-curve
1848 : : {
1849 : 0 : CompositePoint* comp = curve->start_point();
1850 [ # # ]: 0 : assert(comp == curve->end_point());
1851 : 0 : return !(comp->get_point());
1852 : : }
1853 : :
1854 : 0 : return false;
1855 : : }
1856 : :
1857 : 0 : void CompositeSurface::update_modified( )
1858 : : {
1859 : : // search for dead CoEdge-Curve pairs
1860 [ # # ]: 0 : DLIList<CoEdgeSM*> coedge_list;
1861 [ # # ]: 0 : if ( hiddenSet )
1862 [ # # ]: 0 : hiddenSet->hidden_coedges( coedge_list );
1863 : :
1864 [ # # ][ # # ]: 0 : while (coedge_list.size())
1865 : : {
1866 [ # # ][ # # ]: 0 : CompositeCoEdge* coedge = dynamic_cast<CompositeCoEdge*>(coedge_list.pop());
1867 [ # # ][ # # ]: 0 : if ( is_dead_coedge(coedge) )
1868 [ # # ]: 0 : remove_dead_coedge(coedge);
1869 : : }
1870 : :
1871 [ # # ]: 0 : CompositeLoop* loop = next_loop();
1872 [ # # ]: 0 : while (loop)
1873 : : {
1874 [ # # ]: 0 : CompositeLoop* next = next_loop(loop);
1875 [ # # ]: 0 : CompositeCoEdge* coedge = loop->first_coedge();
1876 [ # # ][ # # ]: 0 : while (coedge && is_dead_coedge(coedge))
[ # # ][ # # ]
1877 : : {
1878 [ # # ]: 0 : remove_dead_coedge(coedge);
1879 [ # # ]: 0 : coedge = loop->first_coedge();
1880 : : }
1881 : :
1882 [ # # ]: 0 : if (coedge)
1883 : : {
1884 [ # # ]: 0 : coedge = coedge->next();
1885 [ # # ][ # # ]: 0 : while ( coedge != loop->first_coedge() )
1886 : : {
1887 [ # # ]: 0 : CompositeCoEdge* next_coe = coedge->next();
1888 [ # # ][ # # ]: 0 : if (is_dead_coedge(coedge))
1889 [ # # ]: 0 : remove_dead_coedge(coedge);
1890 : 0 : coedge = next_coe;
1891 : : }
1892 : : }
1893 : :
1894 [ # # ][ # # ]: 0 : if (loop->first_coedge() == NULL)
1895 : : {
1896 [ # # ]: 0 : remove(loop);
1897 [ # # ][ # # ]: 0 : delete loop;
1898 : : }
1899 : :
1900 : 0 : loop = next;
1901 [ # # ]: 0 : }
1902 : :
1903 : 0 : }
1904 : :
1905 : 0 : void CompositeSurface::remove_dead_coedge( CompositeCoEdge* coedge )
1906 : : {
1907 [ # # ]: 0 : assert(is_dead_coedge(coedge));
1908 : :
1909 : 0 : CompositeCurve* curve = coedge->get_curve();
1910 [ # # ]: 0 : assert(curve->num_curves() == 0);
1911 : 0 : curve->remove(coedge);
1912 [ # # ]: 0 : delete coedge;
1913 [ # # ]: 0 : if (curve->next_coedge(NULL))
1914 : 0 : return;
1915 : :
1916 : 0 : CompositePoint* start = curve->start_point();
1917 : 0 : CompositePoint* end = curve->end_point();
1918 : 0 : curve->start_point(0);
1919 : 0 : curve->end_point(0);
1920 [ # # ]: 0 : delete curve;
1921 : :
1922 [ # # ]: 0 : if ( start->next_curve(NULL) == NULL )
1923 : : {
1924 [ # # ]: 0 : if ( start->get_point() )
1925 : 0 : CompositeEngine::instance().restore_point_in_curve(start);
1926 : : else
1927 [ # # ]: 0 : delete start;
1928 : : }
1929 : :
1930 [ # # ][ # # ]: 0 : if ( end != start && end->next_curve(NULL) == NULL )
[ # # ]
1931 : : {
1932 [ # # ]: 0 : if ( end->get_point() )
1933 : 0 : CompositeEngine::instance().restore_point_in_curve(end);
1934 : : else
1935 [ # # ]: 0 : delete end;
1936 : : }
1937 : : }
1938 : :
1939 : : //-------------------------------------------------------------------------
1940 : : // Purpose : Get graphics from cached facet data
1941 : : //
1942 : : // Special Notes :
1943 : : //
1944 : : // Creator : Jason Kraftcheck
1945 : : //
1946 : : // Creation Date : 08/18/03
1947 : : //-------------------------------------------------------------------------
1948 : 0 : CubitStatus CompositeSurface::get_graphics( GMem& gmem )
1949 : : {
1950 [ # # ]: 0 : if (!facetTool)
1951 : 0 : update_facet_tool();
1952 : :
1953 [ # # ]: 0 : if (!facetTool)
1954 : 0 : return CUBIT_FAILURE;
1955 : :
1956 : 0 : facetTool->graphics( GEOMETRY_RESABS, gmem);
1957 : 0 : return CUBIT_SUCCESS;
1958 : : }
1959 : :
1960 : : //-------------------------------------------------------------------------
1961 : : // Purpose : Update for transform
1962 : : //
1963 : : // Special Notes :
1964 : : //
1965 : : // Creator : Jason Kraftcheck
1966 : : //
1967 : : // Creation Date : 10/17/03
1968 : : //-------------------------------------------------------------------------
1969 : 0 : void CompositeSurface::notify_transformed()
1970 : : {
1971 [ # # ]: 0 : if (facetTool)
1972 : : {
1973 [ # # ]: 0 : delete facetTool;
1974 : 0 : facetTool = 0;
1975 : : }
1976 : 0 : }
1977 : :
1978 : :
1979 : :
1980 : 0 : CubitStatus CompositeSurface::get_projected_distance_on_surface( CubitVector *pos1,
1981 : : CubitVector *pos2,
1982 : : double &distance )
1983 : : {
1984 [ # # ]: 0 : if ( num_surfs() == 1)
1985 : 0 : return get_surface(0)->get_projected_distance_on_surface( pos1, pos2, distance );
1986 : : else
1987 : 0 : return CUBIT_FAILURE;
1988 : : return CUBIT_FAILURE;
1989 : : }
1990 : 0 : CubitStatus CompositeSurface::get_sphere_params
1991 : : (
1992 : : CubitVector ¢er,
1993 : : double &radius
1994 : : ) const
1995 : : {
1996 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine sphere parameters for CompositeSurfaces.\n");
1997 : 0 : return CUBIT_FAILURE;
1998 : : }
1999 : :
2000 : 0 : CubitStatus CompositeSurface::get_cone_params
2001 : : (
2002 : : CubitVector ¢er,
2003 : : CubitVector &normal,
2004 : : CubitVector &major_axis,
2005 : : double &radius_ratio,
2006 : : double &sine_angle,
2007 : : double &cos_angle
2008 : : ) const
2009 : : {
2010 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine cone parameters for CompositeSurfaces.\n");
2011 : 0 : return CUBIT_FAILURE;
2012 : : }
2013 : :
2014 : 0 : CubitStatus CompositeSurface::get_torus_params
2015 : : (
2016 : : CubitVector ¢er,
2017 : : CubitVector &normal,
2018 : : double &major_radius,
2019 : : double &minor_radius
2020 : : ) const
2021 : : {
2022 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine torus parameters for CompositeSurface.\n");
2023 : 0 : return CUBIT_FAILURE;
2024 : : }
2025 : :
2026 : 0 : CubitStatus CompositeSurface::get_nurb_params
2027 : : (
2028 : : bool &rational,
2029 : : int °ree_u,
2030 : : int °ree_v,
2031 : : int &num_cntrl_pts_u,
2032 : : int &num_cntrl_pts_v,
2033 : : DLIList<CubitVector> &cntrl_pts,
2034 : : DLIList<double> &cntrl_pt_weights,
2035 : : DLIList<double> &u_knots,
2036 : : DLIList<double> &v_knots
2037 : : ) const
2038 : : {
2039 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine nurbs parameters for CompositeSurface.\n");
2040 : 0 : return CUBIT_FAILURE;
2041 : : }
2042 : :
2043 : :
2044 : 0 : CubitStatus CompositeSurface::closest_point_along_vector(CubitVector& from_point,
2045 : : CubitVector& along_vector,
2046 : : CubitVector& point_on_surface)
2047 : : {
2048 : 0 : int index = closest_underlying_surface( from_point );
2049 : 0 : CubitStatus status = get_surface(index)->closest_point_along_vector( from_point, along_vector, point_on_surface );
2050 : :
2051 [ # # ]: 0 : if( CUBIT_FAILURE == status )
2052 : : {
2053 : : //find the next closest surface and try it
2054 : 0 : double shortest_dist_sqr = CUBIT_DBL_MAX;
2055 : : double current_dist_sqr;
2056 [ # # ]: 0 : CubitVector closest_point;
2057 : 0 : int closest_surf = 0;
2058 : :
2059 [ # # ][ # # ]: 0 : for( int k=0; k<compGeom->num_entities(); k++ )
2060 : : {
2061 [ # # ]: 0 : if( k==index )
2062 : 0 : continue;
2063 : :
2064 [ # # ]: 0 : closest_trimmed( k, from_point, closest_point );
2065 [ # # ][ # # ]: 0 : current_dist_sqr = (from_point - closest_point).length_squared();
2066 : :
2067 [ # # ]: 0 : if( current_dist_sqr < shortest_dist_sqr )
2068 : : {
2069 : 0 : closest_surf = k;
2070 : 0 : shortest_dist_sqr = current_dist_sqr;
2071 : : }
2072 : : }
2073 [ # # ][ # # ]: 0 : status = get_surface(closest_surf)->closest_point_along_vector( from_point, along_vector, point_on_surface );
2074 : : }
2075 : :
2076 : :
2077 : 0 : return status;
2078 [ + - ][ + - ]: 6364 : }
|
