Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : CompositeGeom.cpp
3 : : //
4 : : // Purpose : Object used by CompositeSurface and CompositeCurve
5 : : // to manage underlying entities.
6 : : //
7 : : // Special Notes :
8 : : //
9 : : // Creator : Jason Kraftcheck
10 : : //
11 : : // Creation Date : 12/19/01
12 : : //-------------------------------------------------------------------------
13 : :
14 : : #include "VGDefines.h"
15 : : #include "GeometryEntity.hpp"
16 : : #include "CompositeGeom.hpp"
17 : : #include "CompositeAttrib.hpp"
18 : : #include "DLIList.hpp"
19 : : #include "CubitMessage.hpp"
20 : :
21 : : // used to print debug info:
22 : : #include "Lump.hpp"
23 : : #include "Surface.hpp"
24 : : #include "Curve.hpp"
25 : : #include "Point.hpp"
26 : :
27 : : const char* const COMPOSITE_DATA_ATTRIB_NAME = "COMPOSITE_ATTRIB";
28 : :
29 : :
30 : : //-------------------------------------------------------------------------
31 : : // Purpose : Constructor
32 : : //
33 : : // Special Notes :
34 : : //
35 : : // Creator : Jason Kraftcheck
36 : : //
37 : : // Creation Date : 12/19/01
38 : : //-------------------------------------------------------------------------
39 : 0 : CompositeGeom::CompositeGeom( int size )
40 : : : entityList(size),
41 : : currentIndex(0),
42 : : firstIndex(-1),
43 : : needToUpdateBbox( true ),
44 : : needToUpdateMeasure( true ),
45 : 0 : listHead(0)
46 : : {
47 : : // initialization above both allocated space for size
48 : : // entities, and set the current count in the list to
49 : : // size. We want the initial memory, but need to set
50 : : // the count back to zero.
51 [ # # ]: 0 : entityList.size(0);
52 : 0 : }
53 : :
54 : : //-------------------------------------------------------------------------
55 : : // Purpose : Destructor
56 : : //
57 : : // Special Notes :
58 : : //
59 : : // Creator : Jason Kraftcheck
60 : : //
61 : : // Creation Date : 12/19/01
62 : : //-------------------------------------------------------------------------
63 : 0 : CompositeGeom::~CompositeGeom()
64 : : {
65 [ # # ]: 0 : while(listHead)
66 : : {
67 : 0 : CompositeAttrib* dead = listHead;
68 : 0 : listHead = listHead->next;
69 [ # # ][ # # ]: 0 : delete dead;
70 : : }
71 : 0 : }
72 : :
73 : : //-------------------------------------------------------------------------
74 : : // Purpose : Find the index of an entity
75 : : //
76 : : // Special Notes :
77 : : //
78 : : // Creator : Jason Kraftcheck
79 : : //
80 : : // Creation Date : 12/19/01
81 : : //-------------------------------------------------------------------------
82 : 0 : int CompositeGeom::index_of( TopologyBridge* ptr ) const
83 : : {
84 : : int i;
85 [ # # ]: 0 : for( i = entityList.size() - 1; i >= 0; i-- )
86 [ # # ]: 0 : if( entityList[i].entity == ptr )
87 : 0 : break;
88 : :
89 : 0 : return i;
90 : : }
91 : :
92 : : //-------------------------------------------------------------------------
93 : : // Purpose : Insert an entry
94 : : //
95 : : // Special Notes :
96 : : //
97 : : // Creator : Jason Kraftcheck
98 : : //
99 : : // Creation Date : 12/19/01
100 : : //-------------------------------------------------------------------------
101 : 0 : CubitStatus CompositeGeom::insert( int index, GeometryEntity* geom_ptr,
102 : : CubitSense sense )
103 : : {
104 [ # # ]: 0 : if( index < 0 )
105 : : {
106 [ # # ]: 0 : assert( index >= 0 );
107 : 0 : index = 0;
108 : : }
109 [ # # ][ # # ]: 0 : else if( index > entityList.size() )
110 : : {
111 [ # # ][ # # ]: 0 : assert( index <= entityList.size() );
112 [ # # ]: 0 : index = entityList.size();
113 : : }
114 : :
115 [ # # ]: 0 : CompositeEntry ent;
116 : 0 : ent.entity = geom_ptr;
117 : 0 : ent.sense = sense;
118 : 0 : ent.dist_sqr = ent.measure = 0.;
119 : :
120 : : //force 0th surface to be one that has the composite attrib on it.
121 [ # # ][ # # ]: 0 : DLIList<CubitSimpleAttrib> list;
122 [ # # ][ # # ]: 0 : geom_ptr->get_simple_attribute(COMPOSITE_DATA_ATTRIB_NAME,list);
[ # # ]
123 [ # # ][ # # ]: 0 : if( list.size() )
124 : 0 : index = 0;
125 : :
126 [ # # ]: 0 : entityList.insert( ent, index );
127 : :
128 [ # # ]: 0 : update_cached_data();
129 : :
130 [ # # ]: 0 : return CUBIT_SUCCESS;
131 : : }
132 : :
133 : : //-------------------------------------------------------------------------
134 : : // Purpose : Remove an entry
135 : : //
136 : : // Special Notes :
137 : : //
138 : : // Creator : Jason Kraftcheck
139 : : //
140 : : // Creation Date : 12/19/01
141 : : //-------------------------------------------------------------------------
142 : 0 : CubitStatus CompositeGeom::remove( int index, bool dead )
143 : : {
144 [ # # ][ # # ]: 0 : if( (index < 0) || (index >= entityList.size()) )
[ # # ]
145 : : {
146 [ # # ][ # # ]: 0 : assert( index >= 0 && index < entityList.size() );
147 : 0 : return CUBIT_FAILURE;
148 : : }
149 : :
150 [ # # ]: 0 : if (!dead)
151 : 0 : clean_up_attribs(entityList[index].entity);
152 : :
153 : 0 : entityList.remove( index );
154 : 0 : update_cached_data();
155 : :
156 : 0 : return CUBIT_SUCCESS;
157 : : }
158 : :
159 : : //-------------------------------------------------------------------------
160 : : // Purpose : Split this composite into two, where all entries
161 : : // before the passed index remain in this entity and all
162 : : // entries after the index become part of a new composite.
163 : : //
164 : : // Special Notes : The entry at the specified index remains in this.
165 : : //
166 : : // Creator : Jason Kraftcheck
167 : : //
168 : : // Creation Date : 12/19/01
169 : : //-------------------------------------------------------------------------
170 : 0 : CompositeGeom* CompositeGeom::split( int index )
171 : : {
172 : : int i;
173 [ # # ][ # # ]: 0 : if( (index < 0) || (index >= entityList.size()) )
[ # # ]
174 : : {
175 [ # # ][ # # ]: 0 : assert( index >= 0 && index < entityList.size() );
176 : 0 : return 0;
177 : : }
178 : :
179 : : // find EntityName attribute
180 : 0 : CompositeAttrib* name_attrib = listHead;
181 [ # # ][ # # ]: 0 : while (name_attrib && name_attrib->name() != "ENTITY_NAME")
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # # ]
182 : 0 : name_attrib = name_attrib->next;
183 : :
184 : 0 : int first = index + 1;
185 [ # # ]: 0 : CompositeGeom* new_geom = new CompositeGeom( entityList.size() - first );
186 : :
187 [ # # ]: 0 : for( i = first; i < entityList.size(); i++ )
188 : 0 : new_geom->append( entityList[i].entity, entityList[i].sense );
189 : :
190 : 0 : entityList.size( first );
191 : 0 : update_cached_data();
192 : :
193 : : // copy entityname attrib to new entity
194 [ # # ]: 0 : if ( name_attrib )
195 : : {
196 [ # # ]: 0 : assert(!new_geom->listHead);
197 [ # # ]: 0 : new_geom->listHead = new CompositeAttrib(*name_attrib);
198 : : }
199 : :
200 : 0 : return new_geom;
201 : : }
202 : 0 : CompositeGeom* CompositeGeom::split( VGArray<int>& index_array )
203 : : {
204 : : int i, j;
205 : :
206 [ # # ]: 0 : if( index_array.size() == 0 )
207 : 0 : return 0;
208 : :
209 [ # # ]: 0 : for( i = 0; i < index_array.size(); i++ )
210 [ # # ][ # # ]: 0 : if( index_array[i] < 0 || index_array[i] >= entityList.size() )
[ # # ]
211 : : {
212 : 0 : assert(0);
213 : : return 0;
214 : : }
215 : :
216 : :
217 : : // find EntityName attribute
218 : 0 : CompositeAttrib* name_attrib = listHead;
219 [ # # ][ # # ]: 0 : while (name_attrib && name_attrib->name() != "ENTITY_NAME")
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # # ]
220 : 0 : name_attrib = name_attrib->next;
221 : :
222 [ # # ]: 0 : CompositeGeom* new_geom = new CompositeGeom( index_array.size() );
223 [ # # ]: 0 : for( i = 0; i < index_array.size(); i++ )
224 : : {
225 : 0 : int index = index_array[i];
226 [ # # ]: 0 : assert( entityList[index].entity != NULL );
227 : 0 : new_geom->append( entityList[index].entity, entityList[index].sense );
228 : 0 : entityList[index].entity = 0;
229 : : }
230 : :
231 [ # # ][ # # ]: 0 : for( i = 0; i < entityList.size() && entityList[i].entity; i++ );
[ # # ]
232 [ # # ]: 0 : for( j = i + 1; j < entityList.size(); j++ )
233 : : {
234 [ # # ]: 0 : if( entityList[j].entity )
235 : : {
236 : 0 : entityList[i].entity = entityList[j].entity;
237 : 0 : entityList[i].sense = entityList[j].sense;
238 : 0 : entityList[j].entity = 0;
239 : 0 : i++;
240 : : }
241 : : }
242 : 0 : entityList.size( i );
243 : :
244 : : // copy entityname attrib to new entity
245 [ # # ]: 0 : if ( name_attrib )
246 : : {
247 [ # # ]: 0 : assert(!new_geom->listHead);
248 [ # # ]: 0 : new_geom->listHead = new CompositeAttrib(*name_attrib);
249 : : }
250 : :
251 : 0 : update_cached_data();
252 : 0 : return new_geom;
253 : : }
254 : :
255 : : //-------------------------------------------------------------------------
256 : : // Purpose : change geometry entity
257 : : //
258 : : // Special Notes :
259 : : //
260 : : // Creator : Jason Kraftcheck
261 : : //
262 : : // Creation Date : 01/11/02
263 : : //-------------------------------------------------------------------------
264 : 0 : CubitStatus CompositeGeom::swap( int index, GeometryEntity* new_geom )
265 : : {
266 [ # # ][ # # ]: 0 : if( (index < 0) || (index >= entityList.size()) )
[ # # ]
267 : : {
268 [ # # ][ # # ]: 0 : assert( index >= 0 && index < entityList.size() );
269 : 0 : return CUBIT_FAILURE;
270 : : }
271 : :
272 : 0 : entityList[index].entity = new_geom;
273 : 0 : update_cached_data();
274 : 0 : return CUBIT_SUCCESS;
275 : : }
276 : :
277 : : //-------------------------------------------------------------------------
278 : : // Purpose : Return union of bounding boxes of all entities.
279 : : //
280 : : // Special Notes :
281 : : //
282 : : // Creator : Jason Kraftcheck
283 : : //
284 : : // Creation Date : 12/19/01
285 : : //-------------------------------------------------------------------------
286 : 0 : CubitBox CompositeGeom::bounding_box()
287 : : {
288 [ # # ][ # # ]: 0 : if( entityList.size() == 0 )
289 : : {
290 [ # # ]: 0 : return CubitBox();
291 : : }
292 : :
293 [ # # ]: 0 : if( needToUpdateBbox )
294 [ # # ]: 0 : update_data_bbox();
295 : :
296 [ # # ][ # # ]: 0 : CubitBox box( entityList[0].bbox );
297 [ # # ][ # # ]: 0 : for( int i = 1; i < entityList.size(); i++ )
298 [ # # ][ # # ]: 0 : box |= entityList[i].bbox;
299 [ # # ][ # # ]: 0 : return box;
300 : : }
301 : :
302 : : //-------------------------------------------------------------------------
303 : : // Purpose : Return sum of measure() for all entities.
304 : : //
305 : : // Special Notes :
306 : : //
307 : : // Creator : Jason Kraftcheck
308 : : //
309 : : // Creation Date : 12/19/01
310 : : //-------------------------------------------------------------------------
311 : 0 : double CompositeGeom::measure()
312 : : {
313 [ # # ]: 0 : if( entityList.size() == 0 )
314 : 0 : return 0.0;
315 : :
316 [ # # ]: 0 : if( needToUpdateMeasure )
317 : 0 : update_data_measure();
318 : :
319 : 0 : return entityList[entityList.size()-1].measure;
320 : : }
321 : :
322 : : //-------------------------------------------------------------------------
323 : : // Purpose : Update cached data for each entity
324 : : //
325 : : // Special Notes :
326 : : //
327 : : // Creator : Jason Kraftcheck
328 : : //
329 : : // Creation Date : 12/19/01
330 : : //-------------------------------------------------------------------------
331 : 0 : void CompositeGeom::update_data_measure()
332 : : {
333 : 0 : needToUpdateMeasure = false;
334 : 0 : double sum = 0.0;
335 [ # # ]: 0 : for( int i = 0; i < entityList.size(); i++ )
336 : : {
337 : 0 : sum += entityList[i].entity->measure();
338 : 0 : entityList[i].measure = sum;
339 : : }
340 : 0 : }
341 : :
342 : : //-------------------------------------------------------------------------
343 : : // Purpose : Update cached data for each entity
344 : : //
345 : : // Special Notes :
346 : : //
347 : : // Creator : Jason Kraftcheck
348 : : //
349 : : // Creation Date : 12/19/01
350 : : //-------------------------------------------------------------------------
351 : 0 : void CompositeGeom::update_data_bbox()
352 : : {
353 : 0 : needToUpdateBbox = false;
354 [ # # ]: 0 : for( int i = 0; i < entityList.size(); i++ )
355 : : {
356 [ # # ][ # # ]: 0 : entityList[i].bbox = entityList[i].entity->bounding_box();
357 : : }
358 : 0 : }
359 : :
360 : : //-------------------------------------------------------------------------
361 : : // Purpose : Setup search based on distance between passed position
362 : : // and the bounding box of each entity, and return the
363 : : // index of the entity with the bounding box closest to
364 : : // the passed position.
365 : : //
366 : : // Special Notes :
367 : : //
368 : : // Creator : Jason Kraftcheck
369 : : //
370 : : // Creation Date : 12/19/01
371 : : //-------------------------------------------------------------------------
372 : 0 : int CompositeGeom::closest_box( const CubitVector& position )
373 : : {
374 [ # # ]: 0 : if( entityList.size() <= 0 ) return -1;
375 : :
376 [ # # ]: 0 : if( needToUpdateBbox ) update_data_bbox();
377 : :
378 : 0 : int min_index = 0;
379 : 0 : double min_dist = entityList[0].dist_sqr
380 : 0 : = entityList[0].bbox.distance_squared( position );
381 : :
382 [ # # ]: 0 : for( int i = 1; i < entityList.size(); i++ )
383 : : {
384 : 0 : CompositeEntry& ent = entityList[i];
385 : 0 : double dist_sqr = ent.dist_sqr = ent.bbox.distance_squared( position );
386 [ # # ]: 0 : if( dist_sqr < min_dist )
387 : 0 : min_index = i;
388 : : }
389 : :
390 : 0 : firstIndex = -1;
391 : 0 : currentIndex = min_index;
392 : 0 : return currentIndex;
393 : : }
394 : :
395 : : //-------------------------------------------------------------------------
396 : : // Purpose : Interate through entities with bounding boxes
397 : : // within the specified distance (squared) from the
398 : : // position passed to closest_box().
399 : : //
400 : : // Special Notes : -1 is returned ONCE to indicate the end of the list.
401 : : // Behavior is undefined if closest_box() has never been
402 : : // called.
403 : : //
404 : : // Creator : Jason Kraftcheck
405 : : //
406 : : // Creation Date : 12/19/01
407 : : //-------------------------------------------------------------------------
408 : 0 : int CompositeGeom::next_box_within_dist( double dist_squared )
409 : : {
410 [ # # ]: 0 : if( entityList.size() > 0 )
411 : : {
412 [ # # ]: 0 : if( firstIndex < 0 )
413 : : {
414 : 0 : firstIndex = currentIndex;
415 : : }
416 [ # # ]: 0 : else if( firstIndex == currentIndex )
417 : : {
418 : 0 : return -1;
419 : : }
420 : :
421 [ # # ]: 0 : while( (currentIndex = (currentIndex + 1) % entityList.size())
422 : 0 : != firstIndex )
423 : : {
424 [ # # ]: 0 : if( entityList[currentIndex].dist_sqr < dist_squared )
425 : : {
426 : 0 : return currentIndex;
427 : : }
428 : : }
429 : : }
430 : :
431 : 0 : return -1;
432 : : }
433 : :
434 : : //-------------------------------------------------------------------------
435 : : // Purpose : Reverse sense of composite
436 : : //
437 : : // Special Notes :
438 : : //
439 : : // Creator : Jason Kraftcheck
440 : : //
441 : : // Creation Date :
442 : : //-------------------------------------------------------------------------
443 : 0 : CubitStatus CompositeGeom::reverse()
444 : : {
445 : 0 : reverse_order();
446 : 0 : reverse_rel_senses();
447 : 0 : return CUBIT_SUCCESS;
448 : : }
449 : 0 : CubitStatus CompositeGeom::reverse_order()
450 : : {
451 : 0 : int i, half = entityList.size() / 2;
452 [ # # ]: 0 : for( i = 0; i < half; i++ )
453 : : {
454 : 0 : int j = entityList.size() - (i+1);
455 : 0 : GeometryEntity* temp_entity = entityList[i].entity;
456 : 0 : entityList[i].entity = entityList[j].entity;
457 : 0 : entityList[j].entity = temp_entity;
458 : 0 : CubitSense temp_sense = entityList[i].sense;
459 : 0 : entityList[i].sense = entityList[j].sense;
460 : 0 : entityList[j].sense = temp_sense;
461 : : }
462 : 0 : update_cached_data();
463 : 0 : return CUBIT_SUCCESS;
464 : : }
465 : 0 : CubitStatus CompositeGeom::reverse_rel_senses()
466 : : {
467 [ # # ]: 0 : for( int i = 0; i < entityList.size(); i++ )
468 : : {
469 : 0 : entityList[i].sense =
470 : 0 : entityList[i].sense == CUBIT_FORWARD ? CUBIT_REVERSED :
471 : 0 : entityList[i].sense == CUBIT_REVERSED ? CUBIT_FORWARD :
472 [ # # # # ]: 0 : CUBIT_UNKNOWN;
473 : : }
474 : :
475 : 0 : return CUBIT_SUCCESS;
476 : : }
477 : :
478 : :
479 : : //-------------------------------------------------------------------------
480 : : // Purpose : Combine
481 : : //
482 : : // Special Notes :
483 : : //
484 : : // Creator : Jason Kraftcheck
485 : : //
486 : : // Creation Date : 03/04/02
487 : : //-------------------------------------------------------------------------
488 : 0 : CubitStatus CompositeGeom::merge( CompositeGeom& dead, bool prepend )
489 : : {
490 : : int i;
491 : :
492 [ # # ]: 0 : if (entityList.size() == 1)
493 : : {
494 [ # # ]: 0 : DLIList<CubitSimpleAttrib> list;
495 [ # # ][ # # ]: 0 : entityList[0].entity->get_simple_attribute(list);
496 [ # # ]: 0 : list.reset();
497 [ # # ][ # # ]: 0 : for (i = list.size(); i--; )
498 : : {
499 [ # # ][ # # ]: 0 : const CubitSimpleAttrib csa = list.get_and_step();
500 [ # # ][ # # ]: 0 : if (csa.character_type() != COMPOSITE_DATA_ATTRIB_NAME)
[ # # ][ # # ]
[ # # ][ # # ]
501 [ # # ][ # # ]: 0 : listHead = new CompositeAttrib(csa, listHead);
502 [ # # ][ # # ]: 0 : }
503 : : }
504 : :
505 : : // find EntityName attribute
506 : 0 : CompositeAttrib* this_name = listHead;
507 [ # # ][ # # ]: 0 : while (this_name && this_name->name() != "ENTITY_NAME")
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # # ]
508 : 0 : this_name = this_name->next;
509 : :
510 : : // merge entity name attributes
511 : 0 : CompositeAttrib* dead_name = dead.listHead;
512 [ # # ]: 0 : if (dead_name)
513 : : {
514 [ # # ][ # # ]: 0 : if (dead_name->name() == "ENTITY_NAME")
[ # # ]
515 : : {
516 : 0 : dead_name = dead.listHead;
517 : 0 : dead.listHead = dead_name->next;
518 : 0 : dead_name->next = 0;
519 : : }
520 : : else
521 : : {
522 [ # # ][ # # ]: 0 : while(dead_name->next && dead_name->next->name() != "ENTITY_NAME")
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # # ]
523 : 0 : dead_name = dead_name->next;
524 [ # # ]: 0 : if(dead_name->next)
525 : : {
526 : 0 : CompositeAttrib* prev = dead_name;
527 : 0 : prev->next = dead_name = dead_name->next;
528 : 0 : dead_name->next = 0;
529 : : }
530 : : }
531 : : }
532 : :
533 : :
534 : : int insert ;
535 [ # # ]: 0 : if ( prepend )
536 : : {
537 : 0 : insert = 0;
538 : 0 : entityList.size_end( entityList.size() + dead.entityList.size() );
539 : : }
540 : : else
541 : : {
542 : 0 : insert = entityList.size();
543 : 0 : entityList.size( entityList.size() + dead.entityList.size() );
544 : : }
545 : :
546 [ # # ]: 0 : for( i = 0; i < dead.entityList.size(); i++ )
547 : : {
548 : 0 : entityList[insert].entity = dead.entityList[i].entity;
549 : 0 : entityList[insert].sense = dead.entityList[i].sense;
550 : 0 : insert++;
551 : : }
552 : :
553 : 0 : dead.entityList.size(0);
554 : 0 : update_cached_data();
555 : :
556 : 0 : return CUBIT_SUCCESS;
557 : : }
558 : :
559 : :
560 : : //-------------------------------------------------------------------------
561 : : // Purpose : Store an attribute
562 : : //
563 : : // Special Notes :
564 : : //
565 : : // Creator : Jason Kraftcheck
566 : : //
567 : : // Creation Date : 06/18/02
568 : : //-------------------------------------------------------------------------
569 : 0 : void CompositeGeom::add_attribute( const CubitSimpleAttrib& csa )
570 : : {
571 [ # # ]: 0 : if (entityList.size() == 1)
572 : 0 : entityList[0].entity->append_simple_attribute_virt(csa);
573 : : else
574 [ # # ]: 0 : listHead = new CompositeAttrib( csa, listHead );
575 : 0 : }
576 : :
577 : : //-------------------------------------------------------------------------
578 : : // Purpose : Remove an attribute
579 : : //
580 : : // Special Notes :
581 : : //
582 : : // Creator : Jason Kraftcheck
583 : : //
584 : : // Creation Date : 06/18/02
585 : : //-------------------------------------------------------------------------
586 : 0 : void CompositeGeom::rem_attribute( const CubitSimpleAttrib& csa )
587 : : {
588 [ # # ][ # # ]: 0 : while (listHead && listHead->equals(csa))
[ # # ]
589 : : {
590 : 0 : CompositeAttrib* dead = listHead;
591 : 0 : listHead = dead->next;
592 [ # # ]: 0 : delete dead;
593 : : }
594 : :
595 [ # # ]: 0 : if (listHead)
596 : : {
597 : 0 : CompositeAttrib* attrib = listHead;
598 [ # # ]: 0 : while (attrib->next)
599 : : {
600 [ # # ]: 0 : if(attrib->next->equals(csa))
601 : : {
602 : 0 : CompositeAttrib* dead = attrib->next;
603 : 0 : attrib->next = dead->next;
604 [ # # ]: 0 : delete dead;
605 : : }
606 : : else
607 : : {
608 : 0 : attrib = attrib->next;
609 : : }
610 : : }
611 : : }
612 : :
613 [ # # ]: 0 : if (entityList.size() == 1)
614 : 0 : entityList[0].entity->remove_simple_attribute_virt(csa);
615 : 0 : }
616 : :
617 : : //-------------------------------------------------------------------------
618 : : // Purpose : Remove all attributes
619 : : //
620 : : // Special Notes :
621 : : //
622 : : // Creator : Jason Kraftcheck
623 : : //
624 : : // Creation Date : 06/18/02
625 : : //-------------------------------------------------------------------------
626 : 0 : void CompositeGeom::rem_all_attributes()
627 : : {
628 [ # # ]: 0 : while(listHead)
629 : : {
630 : 0 : CompositeAttrib* dead = listHead;
631 : 0 : listHead = listHead->next;
632 [ # # ]: 0 : delete dead;
633 : : }
634 : :
635 [ # # ]: 0 : if (entityList.size() == 1)
636 : 0 : entityList[0].entity->remove_all_simple_attribute_virt();
637 : 0 : }
638 : :
639 : :
640 : : //-------------------------------------------------------------------------
641 : : // Purpose : Get all attributes
642 : : //
643 : : // Special Notes :
644 : : //
645 : : // Creator : Jason Kraftcheck
646 : : //
647 : : // Creation Date : 06/18/02
648 : : //-------------------------------------------------------------------------
649 : 0 : void CompositeGeom::get_attributes( DLIList<CubitSimpleAttrib>& list )
650 : : {
651 : : // special case: single-entity 'composite'
652 [ # # ]: 0 : if (entityList.size() == 1)
653 : : {
654 : 0 : TopologyBridge* entity = entityList[0].entity;
655 : 0 : entity->get_simple_attribute(list);
656 : :
657 : : // handle 8.1 attribs on single-entity 'composites'
658 [ # # ]: 0 : for (int i = list.size(); i--; )
659 : : {
660 : 0 : const CubitSimpleAttrib& attrib = list.step_and_get();
661 [ # # ][ # # ]: 0 : if (attrib.character_type() == COMPOSITE_DATA_ATTRIB_NAME &&
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # #
# # ]
662 [ # # ][ # # ]: 0 : attrib.int_data_list()[0] == 1)
663 : : {
664 [ # # ]: 0 : entity->remove_simple_attribute_virt(attrib);
665 [ # # ]: 0 : CubitSimpleAttrib newattrib = attrib;
666 [ # # ][ # # ]: 0 : newattrib.string_data_list().erase(newattrib.string_data_list().begin());
[ # # ][ # # ]
667 [ # # ][ # # ]: 0 : newattrib.int_data_list().erase(newattrib.int_data_list().begin());
[ # # ][ # # ]
668 [ # # ][ # # ]: 0 : entity->append_simple_attribute_virt(newattrib);
669 : : }
670 : : }
671 : : }
672 : :
673 : :
674 [ # # ]: 0 : for (CompositeAttrib* ptr = listHead; ptr; ptr = ptr->next)
675 [ # # ]: 0 : list.append(ptr->csa());
676 : 0 : }
677 : :
678 : : //-------------------------------------------------------------------------
679 : : // Purpose : Get named attributes
680 : : //
681 : : // Special Notes :
682 : : //
683 : : // Creator : Jason Kraftcheck
684 : : //
685 : : // Creation Date : 03/03/03
686 : : //-------------------------------------------------------------------------
687 : 0 : void CompositeGeom::get_attributes( const char* name,
688 : : DLIList<CubitSimpleAttrib>& list )
689 : : {
690 [ # # ]: 0 : if (entityList.size() == 1)
691 : : {
692 : : // handle 8.1 attribs on single-entity 'composites'
693 : 0 : list.clean_out();
694 [ # # ]: 0 : entityList[0].entity->get_simple_attribute(COMPOSITE_DATA_ATTRIB_NAME,list);
695 [ # # ]: 0 : while (list.size())
696 : : {
697 [ # # ]: 0 : CubitSimpleAttrib attrib = list.pop();
698 [ # # ][ # # ]: 0 : if (attrib.int_data_list()[0] == 1)
[ # # ]
699 : : {
700 [ # # ][ # # ]: 0 : entityList[0].entity->remove_simple_attribute_virt(attrib);
701 [ # # ][ # # ]: 0 : std::vector<CubitString> s(attrib.string_data_list().begin()+1, attrib.string_data_list().end());
[ # # ][ # # ]
[ # # ][ # # ]
702 [ # # ][ # # ]: 0 : std::vector<int> i(attrib.int_data_list().begin()+1, attrib.int_data_list().end());
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
703 [ # # ][ # # ]: 0 : CubitSimpleAttrib new_attrib(&s, &attrib.double_data_list(), &i);
[ # # ]
704 [ # # ][ # # ]: 0 : entityList[0].entity->append_simple_attribute_virt(new_attrib);
[ # # ]
705 : : }
706 [ # # ]: 0 : }
707 : :
708 [ # # ]: 0 : entityList[0].entity->get_simple_attribute(name, list);
709 : : }
710 : :
711 [ # # ]: 0 : for (CompositeAttrib* ptr = listHead; ptr; ptr = ptr->next)
712 [ # # ][ # # ]: 0 : if (ptr->name() == name)
[ # # ]
713 [ # # ]: 0 : list.append(ptr->csa());
714 : 0 : }
715 : :
716 : : //-------------------------------------------------------------------------
717 : : // Purpose : Write info about object for debugging
718 : : //
719 : : // Special Notes :
720 : : //
721 : : // Creator : Jason Kraftcheck
722 : : //
723 : : // Creation Date :
724 : : //-------------------------------------------------------------------------
725 : 0 : void CompositeGeom::print_debug_info( const char* line_prefix )
726 : : {
727 [ # # ]: 0 : if( needToUpdateBbox )
728 : 0 : update_data_bbox();
729 [ # # ]: 0 : if( needToUpdateMeasure )
730 : 0 : update_data_measure();
731 [ # # ]: 0 : if( line_prefix == 0 )
732 : 0 : line_prefix = "";
733 : :
734 [ # # ][ # # ]: 0 : PRINT_INFO("%sCompositeGeom @ %p : \n", line_prefix, (void*)this );
735 [ # # ]: 0 : for( int i = 0; i < entityList.size(); i++ )
736 : : {
737 : 0 : GeometryEntity* ptr = entityList[i].entity;
738 : : #ifdef TOPOLOGY_BRIDGE_IDS
739 : : PRINT_INFO("%s %15s %d %7s\n", line_prefix,
740 : : ptr ? fix_type_name(typeid(*ptr).name()) : "GeometryEntity",
741 : : ptr ? ptr->get_id() : 0,
742 : : entityList[i].sense == CUBIT_FORWARD ? "Forward" :
743 : : entityList[i].sense == CUBIT_REVERSED ? "Reverse" :
744 : : "Unknown");
745 : : #else
746 : : /*
747 : : PRINT_INFO("%s %15s %p %7s\n", line_prefix,
748 : : ptr ? fix_type_name(typeid(*ptr).name()) : "GeometryEntity",
749 : : ptr,
750 : : entityList[i].sense == CUBIT_FORWARD ? "Forward" :
751 : : entityList[i].sense == CUBIT_REVERSED ? "Reverse" :
752 : : "Unknown");
753 : : */
754 [ # # ][ # # ]: 0 : PRINT_INFO("%s %15s %d %7s\n", line_prefix,
[ # # ][ # # ]
[ # # ][ # # ]
755 : : ptr ? fix_type_name(typeid(*ptr).name()) : "GeometryEntity",
756 : : ptr ? ptr->get_saved_id() : 0,
757 : : entityList[i].sense == CUBIT_FORWARD ? "Forward" :
758 : : entityList[i].sense == CUBIT_REVERSED ? "Reverse" :
759 [ # # ]: 0 : "Unknown");
760 : :
761 : : #endif
762 : : }
763 : 0 : }
764 : :
765 : : //-------------------------------------------------------------------------
766 : : // Purpose : Reverse geometric sense of composite
767 : : //
768 : : // Special Notes :
769 : : //
770 : : // Creator : Jason Kraftcheck
771 : : //
772 : : // Creation Date :
773 : : //-------------------------------------------------------------------------
774 : 0 : void CompositeGeom::reverse_sense( int index )
775 : : {
776 [ # # ]: 0 : assert(index < entityList.size() );
777 : 0 : CubitSense old = entityList[index].sense;
778 : 0 : entityList[index].sense = (old == CUBIT_REVERSED) ? CUBIT_FORWARD : CUBIT_REVERSED;
779 : 0 : }
780 : :
781 : : //-------------------------------------------------------------------------
782 : : // Purpose : Read and remove attributes from underlying entities
783 : : //
784 : : // Special Notes :
785 : : //
786 : : // Creator : Jason Kraftcheck
787 : : //
788 : : // Creation Date : 06/30/03
789 : : //-------------------------------------------------------------------------
790 : 0 : void CompositeGeom::read_attributes( GeometryEntity* geom_ptr )
791 : : {
792 [ # # ]: 0 : DLIList<CubitSimpleAttrib> list;
793 : : int i;
794 : :
795 : : // remove any attributes from previous read
796 [ # # ]: 0 : rem_all_attributes();
797 : :
798 [ # # ]: 0 : if (geom_ptr)
799 : : {
800 : : // Special case for point-curves (no real curves to write
801 : : // attirbutes to.) Write to passed entity instead.
802 [ # # ][ # # ]: 0 : assert(entityList.size() == 0);
803 [ # # ][ # # ]: 0 : geom_ptr->get_simple_attribute(COMPOSITE_DATA_ATTRIB_NAME,list);
[ # # ]
804 : :
805 [ # # ]: 0 : list.reset();
806 [ # # ][ # # ]: 0 : for (i = list.size(); i--; )
807 : : {
808 [ # # ]: 0 : const CubitSimpleAttrib& attrib = list.get_and_step();
809 [ # # ][ # # ]: 0 : assert(attrib.int_data_list().size());
[ # # ]
810 [ # # ][ # # ]: 0 : if (attrib.int_data_list()[0] == entityList.size())
[ # # ][ # # ]
811 : : {
812 [ # # ]: 0 : geom_ptr->remove_simple_attribute_virt(attrib);
813 [ # # ]: 0 : CubitSimpleAttrib c = attrib;
814 [ # # ][ # # ]: 0 : c.int_data_list().erase(c.int_data_list().begin());
[ # # ][ # # ]
815 [ # # ][ # # ]: 0 : c.string_data_list().erase(c.string_data_list().begin());
[ # # ][ # # ]
816 [ # # ][ # # ]: 0 : listHead = new CompositeAttrib(c,listHead);
[ # # ]
817 : : }
818 : : }
819 : :
820 : 0 : return;
821 : : }
822 : :
823 [ # # ][ # # ]: 0 : for (i = 0; i < entityList.size(); i++)
[ # # ][ # # ]
824 : : {
825 [ # # ]: 0 : list.clean_out();
826 [ # # ][ # # ]: 0 : entityList[i].entity->get_simple_attribute(COMPOSITE_DATA_ATTRIB_NAME,list);
[ # # ][ # # ]
827 : :
828 [ # # ]: 0 : list.reset();
829 [ # # ][ # # ]: 0 : for (int j = list.size(); j--; )
830 : : {
831 [ # # ]: 0 : const CubitSimpleAttrib& attrib = list.get_and_step();
832 [ # # ][ # # ]: 0 : assert(attrib.int_data_list().size());
[ # # ]
833 [ # # ][ # # ]: 0 : if (attrib.int_data_list()[0] == entityList.size())
[ # # ][ # # ]
834 : : {
835 : : // Take the attributes off of the current entity and put them on the first entity
836 : : // in this list. I believe this is ok to do because the attributes should apply to
837 : : // the whole composite surface and not just the underlying entity they are on
838 : : // (the one exception to this might be UNIQUE_ID but I haven't seen any problems
839 : : // with this yet). The reason for doing this is that there is some code (I believe
840 : : // in uncomposite() that assumes any attributes will be on the first entity
841 : : // in the list. Previous code actually moved the entity to the beginning
842 : : // of the list but this reordering of the list does not fly with composite
843 : : // curves because there is code depending on the curves in the list being
844 : : // ordered so that they connect end to end in a contiguous manner (the
845 : : // faceting code, for one, relies on this). BWC 1/7/07.
846 [ # # ][ # # ]: 0 : entityList[i].entity->remove_simple_attribute_virt(attrib);
847 [ # # ][ # # ]: 0 : entityList[0].entity->append_simple_attribute_virt(attrib);
848 : :
849 [ # # ]: 0 : CubitSimpleAttrib c = attrib;
850 [ # # ][ # # ]: 0 : c.int_data_list().erase(c.int_data_list().begin());
[ # # ][ # # ]
851 [ # # ][ # # ]: 0 : c.string_data_list().erase(c.string_data_list().begin());
[ # # ][ # # ]
852 : :
853 [ # # ]: 0 : if( NULL == listHead )
854 [ # # ][ # # ]: 0 : listHead = new CompositeAttrib(c,listHead);
855 : : else //this assures that we are not adding duplicate attribs
856 : : {
857 : 0 : bool is_duplicate = false;
858 : :
859 : 0 : CompositeAttrib* curr_attrib = listHead;
860 : :
861 [ # # ]: 0 : while( curr_attrib )
862 : : {
863 [ # # ][ # # ]: 0 : if( curr_attrib->equals( c ) )
864 : : {
865 : 0 : is_duplicate = true;
866 : 0 : break;
867 : : }
868 : 0 : curr_attrib = curr_attrib->next;
869 : : }
870 : :
871 [ # # ]: 0 : if( false == is_duplicate )
872 [ # # ][ # # ]: 0 : listHead = new CompositeAttrib(c,listHead);
873 [ # # ]: 0 : }
874 : : }
875 : : }
876 : 0 : }
877 : : }
878 : :
879 : : //-------------------------------------------------------------------------
880 : : // Purpose : Save attributes on first underlying entity
881 : : //
882 : : // Special Notes :
883 : : //
884 : : // Creator : Jason Kraftcheck
885 : : //
886 : : // Creation Date : 06/30/03
887 : : //-------------------------------------------------------------------------
888 : 0 : void CompositeGeom::write_attributes( GeometryEntity* geom_ptr )
889 : : {
890 [ # # ]: 0 : DLIList<CubitSimpleAttrib> list;
891 : :
892 [ # # ]: 0 : if (geom_ptr)
893 : : {
894 : : // Special case for point-curves (no real curves to write
895 : : // attirbutes to.) Write to passed entity instead.
896 [ # # ][ # # ]: 0 : assert(entityList.size() == 0);
897 : :
898 : : // clean up any attributes from the previous write
899 [ # # ][ # # ]: 0 : geom_ptr->get_simple_attribute(COMPOSITE_DATA_ATTRIB_NAME,list);
[ # # ]
900 [ # # ][ # # ]: 0 : while (list.size())
901 : : {
902 [ # # ]: 0 : CubitSimpleAttrib csa = list.pop();
903 [ # # ]: 0 : geom_ptr->remove_simple_attribute_virt(csa);
904 [ # # ]: 0 : }
905 : : }
906 : : else
907 : : {
908 [ # # ]: 0 : geom_ptr = entityList[0].entity;
909 : :
910 : : // clean up any attributes from the previous write
911 [ # # ][ # # ]: 0 : for (int i = 0; i < entityList.size(); i++)
912 : : {
913 [ # # ][ # # ]: 0 : entityList[i].entity->get_simple_attribute(COMPOSITE_DATA_ATTRIB_NAME,list);
[ # # ][ # # ]
914 [ # # ][ # # ]: 0 : while (list.size())
915 : : {
916 [ # # ]: 0 : CubitSimpleAttrib csa = list.pop();
917 [ # # ][ # # ]: 0 : entityList[i].entity->remove_simple_attribute_virt(csa);
918 [ # # ]: 0 : }
919 : : }
920 : : }
921 : :
922 : :
923 [ # # ][ # # ]: 0 : CubitString name = COMPOSITE_DATA_ATTRIB_NAME;
924 [ # # ]: 0 : int count = entityList.size();
925 [ # # ][ # # ]: 0 : CubitSimpleAttrib attrib;
926 : :
927 [ # # ]: 0 : for (CompositeAttrib* ptr = listHead; ptr; ptr = ptr->next)
928 : : {
929 [ # # ][ # # ]: 0 : attrib.string_data_list().push_back(name);
930 [ # # ][ # # ]: 0 : attrib.int_data_list().push_back(count);
931 : :
932 [ # # ]: 0 : ptr->append_to_csa(attrib);
933 : :
934 : : //append the name attribute on all the rest of the entities too. This
935 : : //is so that if a one gets split, the results each get the name as well:
936 : : //jack --> jack and jack@A
937 [ # # ][ # # ]: 0 : if( ptr->name() == "ENTITY_NAME" )
[ # # ][ # # ]
[ # # ]
938 : : {
939 [ # # ][ # # ]: 0 : for( int k=1; k<entityList.size(); k++ )
940 [ # # ][ # # ]: 0 : entityList[k].entity->append_simple_attribute_virt( attrib );
941 : : }
942 : :
943 [ # # ]: 0 : geom_ptr->append_simple_attribute_virt(attrib);
944 : :
945 [ # # ][ # # ]: 0 : attrib.string_data_list().clear();
946 [ # # ][ # # ]: 0 : attrib.int_data_list().clear();
947 [ # # ][ # # ]: 0 : attrib.double_data_list().clear();
948 [ # # ]: 0 : }
949 : 0 : }
950 : :
951 : : //-------------------------------------------------------------------------
952 : : // Purpose : Clean out composite attributes.
953 : : //
954 : : // Special Notes :
955 : : //
956 : : // Creator : Jason Kraftcheck
957 : : //
958 : : // Creation Date : 07/01/03
959 : : //-------------------------------------------------------------------------
960 : 0 : void CompositeGeom::clean_up_attribs( GeometryEntity* ent )
961 : : {
962 [ # # ]: 0 : DLIList<CubitSimpleAttrib> list;
963 [ # # ][ # # ]: 0 : ent->get_simple_attribute(COMPOSITE_DATA_ATTRIB_NAME,list);
[ # # ]
964 [ # # ][ # # ]: 0 : while (list.size())
965 : : {
966 [ # # ]: 0 : CubitSimpleAttrib csa = list.pop();
967 [ # # ]: 0 : ent->remove_simple_attribute_virt(csa);
968 [ # # ][ # # ]: 0 : }
969 [ + - ][ + - ]: 6364 : }
|
