Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : CompositeCoEdge.cpp
3 : : //
4 : : // Purpose : Combined set of CoEdgeSMs
5 : : //
6 : : // Special Notes :
7 : : //
8 : : // Creator : Jason Kraftcheck
9 : : //
10 : : // Creation Date : 01/11/02
11 : : //-------------------------------------------------------------------------
12 : :
13 : : #include "CompositeCoEdge.hpp"
14 : : #include "CompositeCurve.hpp"
15 : : #include "CompositeLoop.hpp"
16 : : #include "CompositeEngine.hpp"
17 : : #include "VirtualQueryEngine.hpp"
18 : :
19 : : // for printing debug info
20 : : #include "RefEdge.hpp"
21 : :
22 : : //-------------------------------------------------------------------------
23 : : // Purpose : Constructor
24 : : //
25 : : // Special Notes :
26 : : //
27 : : // Creator : Jason Kraftcheck
28 : : //
29 : : // Creation Date : 01/11/02
30 : : //-------------------------------------------------------------------------
31 : 0 : CompositeCoEdge::CompositeCoEdge( CoEdgeSM* coedge )
32 : : : myLoop(0),
33 : : nextCoedge(0),
34 : : prevCoedge(0),
35 : : myCurve(0),
36 [ # # ]: 0 : nextOnCurve(0)
37 : : {
38 [ # # ]: 0 : mySense = coedge->sense();
39 [ # # ]: 0 : coedgeSet.push( coedge );
40 [ # # ][ # # ]: 0 : if( coedge->owner() )
41 [ # # ][ # # ]: 0 : coedge->owner()->swap_bridge( coedge, this, false );
42 [ # # ]: 0 : coedge->owner(this);
43 : 0 : }
44 : :
45 : 0 : CompositeCoEdge::CompositeCoEdge( CompositeCurve* point_curve )
46 : : : mySense(CUBIT_FORWARD),
47 : : myLoop(0),
48 : : nextCoedge(0),
49 : : prevCoedge(0),
50 : : myCurve(0),
51 [ # # ]: 0 : nextOnCurve(0)
52 : : {
53 [ # # ][ # # ]: 0 : assert(point_curve->num_curves() == 0);
54 [ # # ]: 0 : CubitStatus stat = point_curve->add(this);
55 [ # # ]: 0 : assert(stat);
56 [ # # ]: 0 : if (CUBIT_SUCCESS != stat) {
57 [ # # ][ # # ]: 0 : PRINT_ERROR("Failed to add a coedge to point curve.\n");
[ # # ][ # # ]
58 : : }
59 : 0 : }
60 : :
61 : 0 : CompositeCoEdge::CompositeCoEdge()
62 : : : mySense(CUBIT_UNKNOWN),
63 : : myLoop(0),
64 : : nextCoedge( 0 ),
65 : : prevCoedge( 0 ),
66 : : myCurve(0),
67 [ # # ]: 0 : nextOnCurve(0)
68 : 0 : {}
69 : :
70 : : //-------------------------------------------------------------------------
71 : : // Purpose : Destructor
72 : : //
73 : : // Special Notes :
74 : : //
75 : : // Creator : Jason Kraftcheck
76 : : //
77 : : // Creation Date : 01/11/02
78 : : //-------------------------------------------------------------------------
79 [ # # ][ # # ]: 0 : CompositeCoEdge::~CompositeCoEdge()
80 : : {
81 [ # # ]: 0 : if( myLoop )
82 [ # # ]: 0 : myLoop->remove(this);
83 [ # # ]: 0 : if( myCurve )
84 [ # # ]: 0 : myCurve->remove(this);
85 : :
86 [ # # ][ # # ]: 0 : assert( !prevCoedge && !nextCoedge && !nextOnCurve );
[ # # ]
87 : :
88 [ # # ][ # # ]: 0 : for( int i = 0; i < coedgeSet.size(); i++ )
89 [ # # ][ # # ]: 0 : if( coedgeSet[i]->owner() == this )
[ # # ]
90 [ # # ][ # # ]: 0 : coedgeSet[i]->owner(0);
91 [ # # ]: 0 : }
92 : : /*
93 : : //-------------------------------------------------------------------------
94 : : // Purpose : Add an underlying coedge
95 : : //
96 : : // Special Notes :
97 : : //
98 : : // Creator : Jason Kraftcheck
99 : : //
100 : : // Creation Date : 01/11/02
101 : : //-------------------------------------------------------------------------
102 : : CubitStatus CompositeCoEdge::append( CoEdgeSM* coedge_ptr )
103 : : {
104 : : if( index_of( coedge_ptr ) >= 0 || coedge_ptr->owner() )
105 : : return CUBIT_FAILURE;
106 : :
107 : : coedge_ptr->owner( this );
108 : : coedgeSet.push( coedge_ptr );
109 : :
110 : : return CUBIT_SUCCESS;
111 : : }
112 : : */
113 : :
114 : : //-------------------------------------------------------------------------
115 : : // Purpose : find the index of the coedge that owns the passed curve
116 : : //
117 : : // Special Notes : returns -1 if not found
118 : : //
119 : : // Creator : Jason Kraftcheck
120 : : //
121 : : // Creation Date : 01/11/02
122 : : //-------------------------------------------------------------------------
123 : 0 : int CompositeCoEdge::index_of( Curve* ptr ) const
124 : : {
125 : : int i;
126 [ # # ]: 0 : DLIList<TopologyBridge*> curve_list;
127 : 0 : TopologyBridge* curve = ptr;
128 [ # # ][ # # ]: 0 : for( i = coedgeSet.size() - 1; i > 0; i-- )
129 : : {
130 [ # # ]: 0 : curve_list.clean_out();
131 [ # # ][ # # ]: 0 : coedgeSet[i]->get_children( curve_list );
132 [ # # ][ # # ]: 0 : if( curve_list.is_in_list( curve ) )
133 : 0 : break;
134 : : }
135 [ # # ]: 0 : return i;
136 : : }
137 : :
138 : : //-------------------------------------------------------------------------
139 : : // Purpose : Split this CompositeCoEdge into two at the specified index
140 : : //
141 : : // Special Notes : new/other gets CoEdge at the passed index
142 : : //
143 : : // Creator : Jason Kraftcheck
144 : : //
145 : : // Creation Date : 01/11/02
146 : : //-------------------------------------------------------------------------
147 : 0 : CompositeCoEdge* CompositeCoEdge::split( int index )
148 : : {
149 [ # # ][ # # ]: 0 : if( index < 0 || index >= coedgeSet.size() )
[ # # ]
150 : 0 : return 0;
151 : :
152 : 0 : ++index;
153 [ # # ]: 0 : CompositeCoEdge* new_cce = new CompositeCoEdge();
154 : 0 : new_cce->mySense = mySense;
155 : :
156 : 0 : int new_cce_count = coedgeSet.size() - index;
157 : 0 : new_cce->coedgeSet.size( new_cce_count );
158 : :
159 [ # # ]: 0 : for( int i = 0; i < new_cce_count; i++ )
160 : : {
161 : 0 : new_cce->coedgeSet[i] = coedgeSet[i+index];
162 [ # # ]: 0 : new_cce->coedgeSet[i]->owner( new_cce );
163 : : }
164 : 0 : coedgeSet.size( index );
165 : :
166 [ # # ]: 0 : if( myLoop )
167 : : {
168 : : CubitStatus s;
169 [ # # ]: 0 : if( mySense == CUBIT_FORWARD )
170 : 0 : s = myLoop->insert_after( new_cce, this );
171 : : else
172 : 0 : s = myLoop->insert_before( new_cce, this );
173 [ # # ]: 0 : assert( s );
174 [ # # ]: 0 : if (CUBIT_SUCCESS != s) {
175 [ # # ][ # # ]: 0 : PRINT_ERROR("Failed to insert a child coedge.\n");
176 : 0 : return NULL;
177 : : }
178 : : }
179 : :
180 : 0 : new_cce->mySense = mySense;
181 : :
182 : 0 : return new_cce;
183 : : }
184 : :
185 : 0 : CubitStatus CompositeCoEdge::combine( CompositeCoEdge* dead, bool prepend )
186 : : {
187 : : int insert;
188 [ # # ]: 0 : if ( prepend )
189 : : {
190 : 0 : insert = 0;
191 : 0 : coedgeSet.size_end( coedgeSet.size() + dead->coedgeSet.size() );
192 : : }
193 : : else
194 : : {
195 : 0 : insert = coedgeSet.size();
196 : 0 : coedgeSet.size( coedgeSet.size() + dead->coedgeSet.size() );
197 : : }
198 : :
199 [ # # ]: 0 : for( int i = 0; i < dead->coedgeSet.size(); i++ )
200 : : {
201 : 0 : CoEdgeSM* coedge = dead->coedgeSet[i];
202 [ # # ][ # # ]: 0 : assert( coedge->owner() == dead );
203 : 0 : coedge->owner(this);
204 : 0 : coedgeSet[insert++] = coedge;
205 : : }
206 : 0 : dead->coedgeSet.size(0);
207 : 0 : return CUBIT_SUCCESS;
208 : : }
209 : :
210 : : /*
211 : : //-------------------------------------------------------------------------
212 : : // Purpose : dequeue underlying coedge
213 : : //
214 : : // Special Notes :
215 : : //
216 : : // Creator : Jason Kraftcheck
217 : : //
218 : : // Creation Date : 01/11/02
219 : : //-------------------------------------------------------------------------
220 : : CoEdgeSM* CompositeCoEdge::remove_first()
221 : : {
222 : : CoEdgeSM* result = 0;
223 : : if( coedgeSet.size() > 0 )
224 : : {
225 : : result = coedgeSet[0];
226 : : coedgeSet.remove(0);
227 : : }
228 : : return result;
229 : : }
230 : :
231 : : //-------------------------------------------------------------------------
232 : : // Purpose : pop underlying coedge
233 : : //
234 : : // Special Notes :
235 : : //
236 : : // Creator : Jason Kraftcheck
237 : : //
238 : : // Creation Date : 01/11/02
239 : : //-------------------------------------------------------------------------
240 : : CoEdgeSM* CompositeCoEdge::remove_last()
241 : : {
242 : : CoEdgeSM* result = 0;
243 : : if( coedgeSet.size() > 0 )
244 : : {
245 : : result = coedgeSet.pop()
246 : : result->owner(0);
247 : : }
248 : : return result;
249 : : }
250 : : */
251 : : //-------------------------------------------------------------------------
252 : : // Purpose : get parents (pure virtual in TopologyBridge)
253 : : //
254 : : // Special Notes :
255 : : //
256 : : // Creator : Jason Kraftcheck
257 : : //
258 : : // Creation Date : 01/11/02
259 : : //-------------------------------------------------------------------------
260 : 0 : void CompositeCoEdge::get_parents_virt( DLIList<TopologyBridge*>& parents )
261 : : {
262 : 0 : LoopSM* result = get_parent_loop();
263 [ # # ]: 0 : if( result )
264 : : {
265 [ # # ]: 0 : parents.append( result );
266 : : }
267 : 0 : }
268 : :
269 : : //-------------------------------------------------------------------------
270 : : // Purpose : get children (pure virtual in TopologyBridge)
271 : : //
272 : : // Special Notes :
273 : : //
274 : : // Creator : Jason Kraftcheck
275 : : //
276 : : // Creation Date : 01/11/02
277 : : //-------------------------------------------------------------------------
278 : 0 : void CompositeCoEdge::get_children_virt( DLIList<TopologyBridge*>& children )
279 : : {
280 [ # # ]: 0 : if( myCurve )
281 : : {
282 [ # # ]: 0 : children.append( myCurve->primary_stitched_curve() );
283 : : }
284 : : /*
285 : : else if( num_coedges() )
286 : : {
287 : : DLIList<TopologyBridge*> coedge_children;
288 : : coedge(0)->get_children( coedge_children );
289 : : assert( coedge_children.size() == 1 );
290 : : children.append( coedge_children.get() );
291 : : }
292 : : */
293 : 0 : }
294 : :
295 : : /*
296 : : //-------------------------------------------------------------------------
297 : : // Purpose : Set child curve
298 : : //
299 : : // Special Notes : If curve is composite, update curve link to this
300 : : //
301 : : // Creator : Jason Kraftcheck
302 : : //
303 : : // Creation Date : 01/11/02
304 : : //-------------------------------------------------------------------------
305 : : void CompositeCoEdge::curve( CompositeCurve* curve_ptr )
306 : : {
307 : : if( myCurve )
308 : : {
309 : : myCurve->remove(this);
310 : : assert( !myCurve );
311 : : }
312 : :
313 : : if( curve_ptr )
314 : : {
315 : : curve_ptr->add(this);
316 : : assert( myCurve == curve_ptr );
317 : : }
318 : : }
319 : :
320 : : //-------------------------------------------------------------------------
321 : : // Purpose : set loop pointer
322 : : //
323 : : // Special Notes : if loop is composite, add this to loop instead
324 : : //
325 : : // Creator : Jason Kraftcheck
326 : : //
327 : : // Creation Date : 01/11/02
328 : : //-------------------------------------------------------------------------
329 : : void CompositeCoEdge::loop( CompositeLoop* loop_ptr )
330 : : {
331 : : if( myLoop )
332 : : myLoop->remove( this );
333 : :
334 : : if( loop_ptr )
335 : : loop_ptr->insert_before( loop_ptr->first_coedge(), this );
336 : :
337 : : myLoop = loop_ptr;
338 : : }
339 : : */
340 : : //-------------------------------------------------------------------------
341 : : // Purpose : Get parent loop no higher than composite level
342 : : //
343 : : // Special Notes :
344 : : //
345 : : // Creator : Jason Kraftcheck
346 : : //
347 : : // Creation Date : 03/05/02
348 : : //-------------------------------------------------------------------------
349 : 0 : LoopSM* CompositeCoEdge::get_parent_loop()
350 : : {
351 : 0 : LoopSM* result = get_loop();
352 : :
353 [ # # ][ # # ]: 0 : if( !result && num_coedges() )
[ # # ]
354 : : {
355 [ # # ]: 0 : DLIList<TopologyBridge*> parents(1);
356 [ # # ][ # # ]: 0 : get_coedge(0)->get_parents_virt( parents );
357 [ # # ][ # # ]: 0 : assert( parents.size() == 1 );
358 [ # # ][ # # ]: 0 : result = dynamic_cast<LoopSM*>(parents.get());
[ # # ]
359 : : }
360 : :
361 : 0 : return result;
362 : : }
363 : :
364 : : //-------------------------------------------------------------------------
365 : : // Purpose : remove an underlying bridge
366 : : //
367 : : // Special Notes : pure virtual in TBOwner
368 : : //
369 : : // Creator : Jason Kraftcheck
370 : : //
371 : : // Creation Date : 01/11/02
372 : : //-------------------------------------------------------------------------
373 : 0 : CubitStatus CompositeCoEdge::remove_bridge( TopologyBridge* bridge )
374 : : {
375 : : int index;
376 [ # # ]: 0 : for( index = coedgeSet.size() - 1; index >= 0; index-- )
377 [ # # ]: 0 : if( coedgeSet[index] == bridge )
378 : 0 : break;
379 [ # # ]: 0 : if( index < 0 )
380 : 0 : return CUBIT_FAILURE;
381 : :
382 : 0 : coedgeSet.remove( index );
383 : 0 : bridge->owner(0);
384 : : /*
385 : : if ( coedgeSet.size() > 0 )
386 : : return CUBIT_SUCCESS;
387 : :
388 : : if ( get_curve() )
389 : : get_curve()->remove(this);
390 : :
391 : : if ( get_loop() )
392 : : {
393 : : CompositeLoop* loop = get_loop();
394 : : loop->remove(this);
395 : : if ( loop->first_coedge() == 0 )
396 : : delete loop;
397 : : }
398 : :
399 : : delete this;
400 : : */
401 : 0 : return CUBIT_SUCCESS;
402 : : }
403 : :
404 : : //-------------------------------------------------------------------------
405 : : // Purpose : exchange one underlying coedge for another
406 : : //
407 : : // Special Notes : pure virtual in TBOwner
408 : : //
409 : : // Creator : Jason Kraftcheck
410 : : //
411 : : // Creation Date : 01/11/02
412 : : //-------------------------------------------------------------------------
413 : 0 : CubitStatus CompositeCoEdge::swap_bridge( TopologyBridge* old_tb,
414 : : TopologyBridge* new_tb,
415 : : bool )
416 : : {
417 [ # # ]: 0 : CoEdgeSM* old_coedge = dynamic_cast<CoEdgeSM*>(old_tb);
418 [ # # ]: 0 : CoEdgeSM* new_coedge = dynamic_cast<CoEdgeSM*>(new_tb);
419 : :
420 : 0 : int index = index_of( old_coedge );
421 [ # # ][ # # ]: 0 : if( index < 0 || !new_coedge || index_of(new_coedge) >= 0 )
[ # # ][ # # ]
422 : 0 : return CUBIT_FAILURE;
423 : :
424 : 0 : coedgeSet[index] = new_coedge;
425 : :
426 : 0 : old_tb->owner(0);
427 [ # # ]: 0 : if( new_tb->owner() )
428 : 0 : new_tb->owner()->remove_bridge( new_tb );
429 : 0 : new_tb->owner(this);
430 : :
431 : 0 : return CUBIT_SUCCESS;
432 : : }
433 : :
434 : : //-------------------------------------------------------------------------
435 : : // Purpose : see if we are the owner of the passed TB
436 : : //
437 : : // Special Notes : pure virtual in TBOwner
438 : : //
439 : : // Creator : Jason Kraftcheck
440 : : //
441 : : // Creation Date : 01/11/02
442 : : //-------------------------------------------------------------------------
443 : 0 : CubitBoolean CompositeCoEdge::contains_bridge( TopologyBridge* bridge ) const
444 : : {
445 [ # # ]: 0 : CompositeCoEdge* coedge = dynamic_cast<CompositeCoEdge*>(bridge);
446 [ # # ]: 0 : return (index_of(coedge) < 0) ? CUBIT_FALSE : CUBIT_TRUE;
447 : : }
448 : :
449 : 0 : void CompositeCoEdge::notify_reversed( TopologyBridge* )
450 : 0 : {}
451 : :
452 : :
453 : : //-------------------------------------------------------------------------
454 : : // Purpose : Get CompositeEngine
455 : : //
456 : : // Special Notes :
457 : : //
458 : : // Creator : Jason Kraftcheck
459 : : //
460 : : // Creation Date : 01/11/02
461 : : //-------------------------------------------------------------------------
462 : 0 : GeometryQueryEngine* CompositeCoEdge::get_geometry_query_engine() const
463 : 0 : { return VirtualQueryEngine::instance(); }
464 : :
465 : : //-------------------------------------------------------------------------
466 : : // Purpose : Attribute functions
467 : : //
468 : : // Special Notes :
469 : : //
470 : : // Creator : Jason Kraftcheck
471 : : //
472 : : // Creation Date : 01/11/02
473 : : //-------------------------------------------------------------------------
474 : 0 : void CompositeCoEdge::append_simple_attribute_virt( const CubitSimpleAttrib& )
475 : 0 : { }
476 : 0 : void CompositeCoEdge::remove_simple_attribute_virt( const CubitSimpleAttrib& )
477 : 0 : { }
478 : 0 : void CompositeCoEdge::remove_all_simple_attribute_virt()
479 : 0 : { }
480 : 0 : CubitStatus CompositeCoEdge::get_simple_attribute( DLIList<CubitSimpleAttrib>& )
481 : 0 : { return CUBIT_FAILURE; }
482 : 0 : CubitStatus CompositeCoEdge::get_simple_attribute( const CubitString& ,
483 : : DLIList<CubitSimpleAttrib>& )
484 : 0 : { return CUBIT_FAILURE; }
485 : :
486 : :
487 : :
488 : :
489 : 0 : void CompositeCoEdge::reverse()
490 : : {
491 [ # # # ]: 0 : switch( mySense ) {
492 : : case CUBIT_FORWARD:
493 : 0 : mySense = CUBIT_REVERSED;
494 : 0 : break;
495 : : case CUBIT_REVERSED:
496 : 0 : mySense = CUBIT_FORWARD;
497 : 0 : break;
498 : : default:
499 : 0 : mySense = CUBIT_UNKNOWN;
500 : : }
501 : :
502 : 0 : int half = coedgeSet.size() / 2;
503 [ # # ]: 0 : for( int i = 0; i < half; i++ )
504 : : {
505 : 0 : int j = coedgeSet.size() - i - 1;
506 : 0 : CoEdgeSM* tmp = coedgeSet[i];
507 : 0 : coedgeSet[i] = coedgeSet[j];
508 : 0 : coedgeSet[j] = tmp;
509 : : }
510 : :
511 : 0 : }
512 : :
513 : : //-------------------------------------------------------------------------
514 : : // Purpose : Get start and end points reversed if sense is reversed
515 : : //
516 : : // Special Notes :
517 : : //
518 : : // Creator : Jason Kraftcheck
519 : : //
520 : : // Creation Date : 03/17/02
521 : : //-------------------------------------------------------------------------
522 : 0 : CompositePoint* CompositeCoEdge::start_point()
523 : : {
524 : 0 : return mySense == CUBIT_FORWARD
525 : 0 : ? myCurve->start_point()
526 [ # # ]: 0 : : myCurve->end_point();
527 : : }
528 : 0 : CompositePoint* CompositeCoEdge::end_point()
529 : : {
530 : 0 : return mySense == CUBIT_FORWARD
531 : 0 : ? myCurve->end_point()
532 [ # # ]: 0 : : myCurve->start_point();
533 : : }
534 : :
535 : :
536 : 0 : CubitStatus CompositeCoEdge::remove_coedge( int index )
537 : : {
538 [ # # ][ # # ]: 0 : if( index < 0 || index >= coedgeSet.size() )
[ # # ]
539 : 0 : return CUBIT_FAILURE;
540 : :
541 : 0 : coedgeSet[index]->owner(0);
542 : 0 : coedgeSet.remove( index );
543 : :
544 : 0 : return CUBIT_SUCCESS;
545 : : }
546 : :
547 : :
548 : 0 : CubitStatus CompositeCoEdge::insert_coedge( int index, CoEdgeSM* coedge )
549 : : {
550 [ # # ][ # # ]: 0 : if( index < 0 || index > coedgeSet.size() )
[ # # ]
551 : 0 : return CUBIT_FAILURE;
552 : :
553 : 0 : coedgeSet.insert(coedge, index);
554 : 0 : coedge->owner(this);
555 : 0 : return CUBIT_SUCCESS;
556 : : }
557 : :
558 : 0 : void CompositeCoEdge::print_debug_info( const char* prefix, bool brief )
559 : : {
560 [ # # ]: 0 : if( prefix == 0 ) prefix = "";
561 : :
562 : 0 : const char* sense = mySense == CUBIT_FORWARD ? "Forward" :
563 [ # # ][ # # ]: 0 : mySense == CUBIT_REVERSED ? "Reverse" : "UNKNOWN";
564 : :
565 [ # # ][ # # ]: 0 : PRINT_INFO("%sCompCoEdge %p %s ", prefix, (void*)this, sense );
566 [ # # ]: 0 : if ( num_coedges() == 1 )
567 [ # # ][ # # ]: 0 : PRINT_INFO("%s %p ", fix_type_name(typeid(*get_coedge(0)).name()),
568 [ # # ]: 0 : (void*)get_coedge(0));
569 : : else
570 [ # # ][ # # ]: 0 : PRINT_INFO("%d coedges ", num_coedges() );
571 : :
572 [ # # ]: 0 : if( !myCurve )
573 [ # # ][ # # ]: 0 : PRINT_INFO("NULL CURVE\n");
574 [ # # ]: 0 : else if( brief )
575 : : #ifdef TOPOLOGY_BRIDGE_IDS
576 : : PRINT_INFO("curve %d\n", myCurve->get_id() );
577 : : #else
578 [ # # ][ # # ]: 0 : PRINT_INFO("curve %p\n", (void*)myCurve );
579 : : #endif
580 : : else
581 [ # # ][ # # ]: 0 : { PRINT_INFO("\n "); myCurve->print_debug_info(prefix, true); }
582 : :
583 : : /*
584 : : if( coedgeSet.size() == 0 )
585 : : PRINT_INFO(" No CoEdgeSMs!\n");
586 : : else if( coedgeSet.size() == 1 )
587 : : PRINT_INFO(" CoEdgeSM=%p\n", coedgeSet[0] );
588 : : else
589 : : {
590 : : PRINT_INFO("\n");
591 : : for( int i = 0; i < coedgeSet.size(); i++ )
592 : : PRINT_INFO("%s CoEdgeSM[%d] = %p\n", prefix, i, coedgeSet[i] );
593 : : }
594 : : */
595 [ + - ][ + - ]: 6364 : }
|
