Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : CompositeCurve.cpp
3 : : //
4 : : // Purpose : Geometry defined as the joining of a chain of curves.
5 : : //
6 : : // Special Notes :
7 : : //
8 : : // Creator : Jason Kraftcheck
9 : : //
10 : : // Creation Date : 12/19/01
11 : : //-------------------------------------------------------------------------
12 : :
13 : : #include <math.h>
14 : :
15 : : #include "CompositeCurve.hpp"
16 : : #include "CompositeCoEdge.hpp"
17 : : #include "CompositeLoop.hpp"
18 : : #include "CompositePoint.hpp"
19 : : #include "VirtualQueryEngine.hpp"
20 : : #include "CompositeEngine.hpp"
21 : :
22 : : //#include "GfxDebug.hpp"
23 : : #include "GMem.hpp"
24 : :
25 : : //-------------------------------------------------------------------------
26 : : // Purpose : Constructor
27 : : //
28 : : // Special Notes :
29 : : //
30 : : // Creator : Jason Kraftcheck
31 : : //
32 : : // Creation Date : 12/19/01
33 : : //-------------------------------------------------------------------------
34 : 0 : CompositeCurve::CompositeCurve( Curve* curve )
35 : : : HadBridgeRemoved(0),
36 : : hiddenSet(0),
37 : : firstCoEdge(0),
38 : : startPoint(0),
39 : : endPoint(0),
40 : : startNext(0),
41 : : endNext(0),
42 : 0 : stitchNext(0)
43 : : {
44 [ # # ][ # # ]: 0 : compGeom = new CompositeGeom(1);
45 [ # # ]: 0 : compGeom->append( curve, CUBIT_FORWARD );
46 [ # # ][ # # ]: 0 : if( curve->owner() )
47 [ # # ][ # # ]: 0 : curve->owner()->swap_bridge( curve, this, false );
48 [ # # ]: 0 : curve->owner(this);
49 : 0 : }
50 : :
51 : 0 : CompositeCurve::CompositeCurve( CompositeGeom* geometry )
52 : : : HadBridgeRemoved(0),
53 : : compGeom( geometry ),
54 : : hiddenSet( 0 ),
55 : : firstCoEdge( 0 ),
56 : : startPoint( 0 ),
57 : : endPoint( 0 ),
58 : : startNext( 0 ),
59 : : endNext( 0 ),
60 : 0 : stitchNext(0)
61 : : {
62 [ # # ][ # # ]: 0 : for( int i = 0; i < compGeom->num_entities(); i++ )
63 : : {
64 [ # # ]: 0 : GeometryEntity* entity = compGeom->entity(i);
65 [ # # ][ # # ]: 0 : assert( !entity->owner() );
66 [ # # ]: 0 : entity->owner(this);
67 : : }
68 : 0 : }
69 : :
70 : : //-------------------------------------------------------------------------
71 : : // Purpose : Point-curve constructor
72 : : //
73 : : // Special Notes :
74 : : //
75 : : // Creator : Jason Kraftcheck
76 : : //
77 : : // Creation Date : 02/27/04
78 : : //-------------------------------------------------------------------------
79 : 0 : CompositeCurve::CompositeCurve( CompositePoint* point )
80 : : : HadBridgeRemoved(0),
81 : : hiddenSet(0),
82 : : firstCoEdge(0),
83 : : startPoint(0),
84 : : endPoint(0),
85 : : startNext(0),
86 : : endNext(0),
87 : 0 : stitchNext(0)
88 : : {
89 [ # # ][ # # ]: 0 : compGeom = new CompositeGeom(1);
90 : : //compGeom->append( point, CUBIT_FORWARD );
91 [ # # ]: 0 : start_point(point);
92 [ # # ]: 0 : end_point(point);
93 : 0 : }
94 : :
95 : :
96 [ # # ]: 0 : CompositeCurve::~CompositeCurve()
97 : : {
98 [ # # ]: 0 : while( firstCoEdge )
99 [ # # ]: 0 : remove( firstCoEdge );
100 : :
101 [ # # ][ # # ]: 0 : for( int i = 0; i < num_curves(); i++ )
102 [ # # ][ # # ]: 0 : if( get_curve(i)->owner() == this )
[ # # ]
103 [ # # ][ # # ]: 0 : get_curve(i)->owner(0);
104 : :
105 [ # # ]: 0 : start_point(0);
106 [ # # ]: 0 : end_point(0);
107 : :
108 [ # # ]: 0 : unstitch_all();
109 : :
110 [ # # ][ # # ]: 0 : delete hiddenSet;
111 [ # # ][ # # ]: 0 : delete compGeom;
112 : 0 : hiddenSet = (HiddenEntitySet*)0xbdbdbdbd;
113 : 0 : compGeom = (CompositeGeom*)0xbdbdbdbd;
114 [ # # ]: 0 : assert(!startNext);
115 [ # # ]: 0 : assert(!endNext);
116 [ # # ]: 0 : }
117 : :
118 : :
119 : 0 : CompositeCurve* CompositeCurve::next( const CompositePoint* around )
120 : : {
121 : 0 : return around == startPoint ? startNext :
122 [ # # ][ # # ]: 0 : around == endPoint ? endNext : 0;
123 : : }
124 : :
125 : 0 : CubitStatus CompositeCurve::start_point( CompositePoint* pt )
126 : : {
127 : 0 : return set_point( true, pt );
128 : : }
129 : :
130 : 0 : CubitStatus CompositeCurve::end_point( CompositePoint* pt )
131 : : {
132 : 0 : return set_point( false, pt );
133 : : }
134 : :
135 : 0 : CubitStatus CompositeCurve::set_point( bool start, CompositePoint* pt )
136 : : {
137 [ # # ]: 0 : CompositePoint*& my_point = start ? startPoint : endPoint;
138 [ # # ]: 0 : CompositeCurve*& next_crv = start ? startNext : endNext;
139 : :
140 [ # # ]: 0 : if( pt == my_point )
141 : 0 : return CUBIT_SUCCESS;
142 : :
143 [ # # ][ # # ]: 0 : if( my_point && startPoint != endPoint )
144 : : {
145 : 0 : CompositeCurve* prev = my_point->firstCurve;
146 [ # # ]: 0 : assert( prev != NULL );
147 : :
148 [ # # ]: 0 : if( prev == this )
149 : : {
150 : 0 : my_point->firstCurve = next_crv;
151 : : }
152 : : else
153 : : {
154 : 0 : CompositeCurve* curve = prev->next(my_point);
155 [ # # ]: 0 : while( curve != this )
156 : : {
157 : 0 : prev = curve;
158 : 0 : curve = prev->next(my_point);
159 : : }
160 : :
161 [ # # ]: 0 : if( prev->startPoint == my_point )
162 : : {
163 [ # # ]: 0 : assert(prev->startNext == this);
164 : 0 : prev->startNext = next_crv;
165 : : }
166 : :
167 [ # # ]: 0 : if( prev->endPoint == my_point )
168 : : {
169 [ # # ]: 0 : assert(prev->endNext == this);
170 : 0 : prev->endNext = next_crv;
171 : : }
172 : : }
173 : : }
174 : :
175 : 0 : my_point = pt;
176 [ # # ]: 0 : if (!pt)
177 : : {
178 : 0 : next_crv = 0;
179 : : }
180 [ # # ]: 0 : else if (startPoint == endPoint)
181 : : {
182 [ # # ]: 0 : next_crv = start ? endNext : startNext;
183 : : }
184 : : else
185 : : {
186 : 0 : next_crv = pt->firstCurve;
187 : 0 : pt->firstCurve = this;
188 : : }
189 : :
190 : 0 : return CUBIT_SUCCESS;
191 : : }
192 : :
193 : :
194 : 0 : CompositePoint* CompositeCurve::other_point( CompositePoint* pt )
195 : : {
196 : 0 : CompositePoint* sp = start_point();
197 : 0 : CompositePoint* ep = end_point();
198 [ # # ][ # # ]: 0 : return (pt == sp) ? ep : (pt == ep) ? sp : 0;
199 : : }
200 : :
201 : 0 : CompositeCurve* CompositeCurve::split( Curve* curve )
202 : : {
203 : 0 : int index = index_of( curve );
204 [ # # ][ # # ]: 0 : if( (index < 0) || (index == (num_curves()-1)) )
[ # # ]
205 : 0 : return 0;
206 : :
207 : 0 : CompositeGeom* new_geom = compGeom->split( index );
208 [ # # ]: 0 : if( !new_geom )
209 : 0 : return 0;
210 : :
211 [ # # ]: 0 : for( int i = 0; i < new_geom->num_entities(); i++ )
212 : 0 : new_geom->entity(i)->owner( 0 );
213 : :
214 [ # # ]: 0 : return new CompositeCurve( new_geom );
215 : : }
216 : :
217 : :
218 : 0 : CubitStatus CompositeCurve::combine( CompositeCurve* curve, bool prepend )
219 : : {
220 : : int start, stop;
221 [ # # ]: 0 : if ( prepend ) {
222 : 0 : start = 0;
223 : 0 : stop = curve->compGeom->num_entities();
224 : : } else {
225 : 0 : start = compGeom->num_entities();
226 : 0 : stop = start + curve->compGeom->num_entities();
227 : : }
228 : :
229 : 0 : compGeom->merge( *(curve->compGeom), prepend );
230 [ # # ]: 0 : if( curve->hiddenSet )
231 : 0 : hidden_entities().merge( curve->hiddenSet );
232 : :
233 [ # # ]: 0 : for( int i = start; i < stop; i++ )
234 : : {
235 : 0 : TopologyBridge* bridge = compGeom->entity(i);
236 [ # # ][ # # ]: 0 : assert( bridge->owner() == curve );
237 : 0 : bridge->owner(this);
238 : : }
239 : :
240 : 0 : return CUBIT_SUCCESS;
241 : : }
242 : :
243 : 0 : bool CompositeCurve::has_parent_composite_surface() const
244 : : {
245 : : CompositeCoEdge* coedge;
246 [ # # ]: 0 : for( coedge = first_coedge(); coedge; coedge = next_coedge(coedge) )
247 [ # # ]: 0 : if( coedge->get_loop() )
248 : 0 : return true;
249 : 0 : return false;
250 : : }
251 : :
252 : 0 : void CompositeCurve::reverse()
253 : : {
254 : 0 : compGeom->reverse();
255 : 0 : }
256 : :
257 : 0 : CompositePoint* CompositeCurve::common_point( CompositeCurve* curve )
258 : : {
259 : 0 : CompositePoint* result = 0;
260 : 0 : CompositePoint* this_sp = start_point();
261 : 0 : CompositePoint* this_ep = end_point();
262 : 0 : CompositePoint* othr_sp = curve->start_point();
263 : 0 : CompositePoint* othr_ep = curve->end_point();
264 : :
265 [ # # ][ # # ]: 0 : if( this_sp == othr_sp || this_sp == othr_ep )
266 : 0 : result = this_sp;
267 [ # # ][ # # ]: 0 : else if( this_ep == othr_sp || this_ep == othr_ep )
268 : 0 : result = this_ep;
269 : :
270 : 0 : return result;
271 : : }
272 : : /*
273 : : CompositeCoEdge* CompositeCurve::find_coedge( CompositeSurface* surface )
274 : : {
275 : : CoEdge* coedge = 0;
276 : : while( coedge = next_coedge( coedge ) )
277 : : if( coedge->get_loop() && coedge->get_loop()->get_surface() == surface )
278 : : break;
279 : : return coedge;
280 : : }
281 : : */
282 : 0 : CubitStatus CompositeCurve::add( CompositeCoEdge* coedge )
283 : : {
284 [ # # ]: 0 : if( coedge->myCurve )
285 : : {
286 : 0 : assert(0);
287 : : return CUBIT_FAILURE;
288 : : }
289 : :
290 : 0 : coedge->myCurve = this;
291 : 0 : coedge->nextOnCurve = firstCoEdge;
292 : 0 : firstCoEdge = coedge;
293 : :
294 : 0 : return CUBIT_SUCCESS;
295 : : }
296 : :
297 : 0 : CubitStatus CompositeCurve::remove( CompositeCoEdge* coedge )
298 : : {
299 [ # # ]: 0 : if( coedge->myCurve != this )
300 : 0 : return CUBIT_FAILURE;
301 : :
302 [ # # ]: 0 : if( coedge == firstCoEdge )
303 : : {
304 : 0 : firstCoEdge = coedge->nextOnCurve;
305 : : }
306 : : else
307 : : {
308 : 0 : CompositeCoEdge *prev = firstCoEdge,
309 : 0 : *next = firstCoEdge->nextOnCurve;
310 [ # # ]: 0 : while( next != coedge )
311 : : {
312 [ # # ]: 0 : assert(next != NULL);
313 : 0 : prev = next;
314 : 0 : next = next->nextOnCurve;
315 : : }
316 : :
317 : 0 : prev->nextOnCurve = next->nextOnCurve;
318 : : }
319 : :
320 : 0 : coedge->nextOnCurve = 0;
321 : 0 : coedge->myCurve = 0;
322 : 0 : return CUBIT_SUCCESS;
323 : : }
324 : :
325 : :
326 : 0 : CubitBox CompositeCurve::bounding_box() const
327 : 0 : { return compGeom->bounding_box(); }
328 : :
329 : 0 : double CompositeCurve::measure()
330 : 0 : { return compGeom->measure(); }
331 : :
332 : 0 : GeometryType CompositeCurve::geometry_type()
333 : : {
334 [ # # # ]: 0 : switch (num_curves()) {
335 : 0 : case 0 : return POINT_CURVE_TYPE;
336 : 0 : case 1 : return get_curve(0)->geometry_type();
337 : 0 : default : return UNDEFINED_CURVE_TYPE;
338 : : }
339 : : }
340 : :
341 : 0 : GeometryQueryEngine* CompositeCurve::get_geometry_query_engine() const
342 : 0 : { return VirtualQueryEngine::instance(); }
343 : :
344 : :
345 : 0 : double CompositeCurve::start_param()
346 : 0 : { return 0; }
347 : :
348 : 0 : double CompositeCurve::end_param()
349 : 0 : { return measure(); }
350 : :
351 : 0 : CubitBoolean CompositeCurve::get_param_range( double& lower, double& upper )
352 : : {
353 : 0 : lower = 0;
354 : 0 : upper = measure();
355 : 0 : return CUBIT_TRUE;
356 : : }
357 : :
358 : 0 : CubitBoolean CompositeCurve::is_periodic( double& period )
359 : : {
360 [ # # ]: 0 : if (geometry_type() == POINT_CURVE_TYPE)
361 : 0 : return CUBIT_FALSE;
362 : :
363 [ # # ][ # # ]: 0 : if( startPoint == endPoint && num_curves() > 0 )
[ # # ]
364 : : {
365 : 0 : period = measure();
366 : 0 : return CUBIT_TRUE;
367 : : }
368 : : else
369 : : {
370 : 0 : period = 0;
371 : 0 : return CUBIT_FALSE;
372 : : }
373 : : }
374 : :
375 : 0 : CubitStatus CompositeCurve::position_from_u( double u, CubitVector& position )
376 : : {
377 : : int index;
378 : : double ui;
379 : :
380 [ # # ][ # # ]: 0 : if (num_curves() == 0) // point curve
381 : 0 : return CUBIT_FAILURE;
382 : :
383 [ # # ][ # # ]: 0 : if( ! curve_param( u, ui, index ) || index < 0 )
[ # # ][ # # ]
384 : 0 : return CUBIT_FAILURE;
385 : :
386 [ # # ]: 0 : Curve* curve_ptr = get_curve( index );
387 [ # # ][ # # ]: 0 : return curve_ptr ? curve_ptr->position_from_u( ui, position ) : CUBIT_FAILURE;
388 : : }
389 : :
390 : 0 : double CompositeCurve::u_from_position( const CubitVector& position )
391 : : {
392 [ # # ]: 0 : if (num_curves() == 0) // point curve
393 : 0 : return 0.0;
394 : :
395 : 0 : int index = closest_curve(position );
396 : 0 : double param = get_curve( index )->u_from_position( position );
397 : 0 : return composite_param( index, param );
398 : : }
399 : :
400 : 0 : double CompositeCurve::u_from_arc_length( double param, double length )
401 : 0 : { return param + length; }
402 : 0 : double CompositeCurve::length_from_u( double u1, double u2 )
403 : 0 : { return u2 - u1; }
404 : :
405 : 0 : CubitStatus CompositeCurve::closest_point( const CubitVector& location,
406 : : CubitVector& closest,
407 : : CubitVector* tangent_ptr,
408 : : CubitVector* curvature_ptr,
409 : : double* param )
410 : : {
411 [ # # ]: 0 : if (num_curves() == 0) // point curve
412 : : {
413 [ # # ]: 0 : if (!startPoint)
414 : 0 : return CUBIT_FAILURE;
415 : :
416 [ # # ]: 0 : closest = startPoint->coordinates();
417 [ # # ]: 0 : if (tangent_ptr)
418 : 0 : tangent_ptr->set(0.0,0.0,0.0);
419 [ # # ]: 0 : if (curvature_ptr)
420 : 0 : curvature_ptr->set(0.0,0.0,0.0);
421 [ # # ]: 0 : if (param)
422 : 0 : *param = 0.0;
423 : : }
424 : :
425 [ # # ]: 0 : if( compGeom->num_entities() == 1 )
426 : : {
427 : 0 : CubitStatus result = get_curve(0)
428 : 0 : ->closest_point( location, closest, tangent_ptr, curvature_ptr, param );
429 : :
430 [ # # ][ # # ]: 0 : if( tangent_ptr && compGeom->sense(0) == CUBIT_REVERSED )
[ # # ]
431 : 0 : *tangent_ptr *= -1.0;
432 : :
433 [ # # ]: 0 : if( param )
434 : 0 : *param = composite_param( 0, *param );
435 : :
436 : 0 : return result;
437 : : }
438 : :
439 : 0 : int index = closest_curve( location, &closest );
440 : 0 : Curve* curve = get_curve( index );
441 [ # # ][ # # ]: 0 : if( tangent_ptr || curvature_ptr || param )
[ # # ]
442 : : {
443 : : curve->closest_point( location, closest, tangent_ptr,
444 : 0 : curvature_ptr, param );
445 [ # # ]: 0 : if( param )
446 : 0 : *param = composite_param( index, *param );
447 [ # # ][ # # ]: 0 : if( tangent_ptr && compGeom->sense(index) == CUBIT_REVERSED )
[ # # ]
448 : 0 : *tangent_ptr *= -1.0;
449 : : }
450 : :
451 : 0 : return CUBIT_SUCCESS;
452 : : }
453 : :
454 : :
455 : 0 : CubitStatus CompositeCurve::closest_point_trimmed(
456 : : const CubitVector& position,
457 : : CubitVector& closest )
458 : : {
459 [ # # ]: 0 : if (num_curves() == 0)
460 : 0 : return closest_point( position, closest );
461 : :
462 [ # # ]: 0 : if( compGeom->num_entities() == 1 )
463 : 0 : return get_curve(0)->closest_point_trimmed( position, closest );
464 : :
465 : 0 : closest_curve( position, &closest );
466 : 0 : return CUBIT_SUCCESS;
467 : : }
468 : :
469 : 0 : CubitBoolean CompositeCurve::is_position_on( const CubitVector& position )
470 : : {
471 : : // point curve
472 [ # # ]: 0 : if (num_curves() == 0)
473 : : {
474 : 0 : CompositePoint* point = start_point();
475 [ # # ][ # # ]: 0 : double lensqr = (position - point->coordinates()).length_squared();
476 : 0 : return lensqr <= (GEOMETRY_RESABS*GEOMETRY_RESABS);
477 : : }
478 : :
479 [ # # ]: 0 : if( compGeom->num_entities() == 1 )
480 : 0 : return get_curve(0)->is_position_on( position );
481 : :
482 : 0 : int index = closest_curve( position );
483 : 0 : return get_curve(index)->is_position_on( position );
484 : : }
485 : :
486 : 0 : CubitPointContainment CompositeCurve::point_containment( const CubitVector& point )
487 : : {
488 : : int index;
489 : :
490 [ # # ]: 0 : if (num_curves() == 0)
491 [ # # ]: 0 : return is_position_on(point) ? CUBIT_PNT_ON : CUBIT_PNT_OFF;
492 : :
493 [ # # ]: 0 : for( index = 0; index < compGeom->num_entities(); index++ )
494 : : {
495 [ # # ]: 0 : if( get_curve(index)->point_containment( point ) == CUBIT_PNT_ON )
496 : 0 : return CUBIT_PNT_ON;
497 : : }
498 : :
499 : 0 : return CUBIT_PNT_OFF; //not on any Curve
500 : : }
501 : :
502 : 0 : CubitStatus CompositeCurve::get_point_direction( CubitVector& origin,
503 : : CubitVector& direction )
504 : : {
505 [ # # ][ # # ]: 0 : if (num_curves() == 0) // point curve
506 : 0 : return CUBIT_FAILURE;
507 : :
508 [ # # ][ # # ]: 0 : if( compGeom->num_entities() == 1 )
509 [ # # ][ # # ]: 0 : return get_curve(0)->get_point_direction( origin, direction );
510 : :
511 [ # # ]: 0 : int count = compGeom->num_entities();
512 [ # # ][ # # ]: 0 : CubitVector* vect_list = new CubitVector[count];
[ # # ][ # # ]
513 : 0 : double RESABS_SQUARED = CUBIT_RESABS * CUBIT_RESABS;
514 [ # # ]: 0 : direction.set(0,0,0);
515 [ # # ]: 0 : for( int i = 0; i < count; i++ )
516 : : {
517 [ # # ][ # # ]: 0 : if( ! get_curve(i)->get_point_direction(origin,vect_list[i]) ||
[ # # ][ # # ]
[ # # ]
518 [ # # ]: 0 : (vect_list[i].length_squared() < RESABS_SQUARED) )
519 : : {
520 [ # # ]: 0 : delete [] vect_list;
521 : 0 : return CUBIT_FAILURE;
522 : : }
523 [ # # ][ # # ]: 0 : if( get_sense(i) == CUBIT_REVERSED )
524 [ # # ]: 0 : vect_list[i] *= -1;
525 [ # # ]: 0 : direction += vect_list[i];
526 : : }
527 : : //If we reach this point, then all of the underlying curves are linear.
528 : : //Next check if they are colinear.
529 [ # # ][ # # ]: 0 : if( direction.length_squared() < RESABS_SQUARED )
530 : : {
531 [ # # ]: 0 : delete [] vect_list;
532 : 0 : return CUBIT_FAILURE;
533 : : }
534 [ # # ]: 0 : CubitVector mean = ~direction;
535 [ # # ]: 0 : for( int j = 0; j < count; j++ )
536 : : {
537 [ # # ][ # # ]: 0 : if( fabs( 1 - (mean % ~vect_list[j]) ) > CUBIT_RESABS )
[ # # ]
538 : : {
539 [ # # ]: 0 : delete [] vect_list;
540 : 0 : return CUBIT_FAILURE;
541 : : }
542 : : }
543 : :
544 [ # # ]: 0 : delete [] vect_list;
545 [ # # ][ # # ]: 0 : get_curve(0)->get_point_direction(origin,direction);
546 [ # # ]: 0 : direction = mean;
547 : 0 : return CUBIT_SUCCESS;
548 : : }
549 : :
550 : 0 : CubitStatus CompositeCurve::get_interior_extrema(
551 : : DLIList<CubitVector*>& interior_points,
552 : : CubitSense& return_sense )
553 : : {
554 : 0 : return_sense = CUBIT_FORWARD;
555 [ # # ][ # # ]: 0 : if (num_curves() == 0) // point curve
556 : 0 : return CUBIT_SUCCESS;
557 : :
558 : : // Go through each curve in the composite
559 [ # # ]: 0 : DLIList<CubitVector*> curve_point_list;
560 [ # # ][ # # ]: 0 : for (int i = compGeom->num_entities() - 1; i >= 0; i--)
561 : : {
562 : : // Get the next curve's extrema
563 [ # # ]: 0 : Curve* cur_curve = get_curve(i);
564 [ # # ]: 0 : cur_curve->get_interior_extrema(curve_point_list,return_sense);
565 : : // See which order to put them into the return list
566 [ # # ][ # # ]: 0 : if (return_sense == get_sense(i))
567 : : {
568 [ # # ]: 0 : interior_points += curve_point_list;
569 : : }
570 : : else
571 : : {
572 [ # # ]: 0 : curve_point_list.last();
573 [ # # ][ # # ]: 0 : for (int j = curve_point_list.size(); j--; )
574 [ # # ][ # # ]: 0 : interior_points.append(curve_point_list.get_and_back());
575 : : }
576 : : // Unless this is the last curve, put in the point
577 : : // between this and the next curve
578 [ # # ]: 0 : if (i != 0)
579 : : {
580 [ # # ][ # # ]: 0 : CubitVector* endpoint = new CubitVector(0,0,0);
581 [ # # ][ # # ]: 0 : if (get_sense(i) == CUBIT_FORWARD)
582 [ # # ][ # # ]: 0 : cur_curve->position_from_u(cur_curve->end_param(), *endpoint);
583 : : else
584 [ # # ][ # # ]: 0 : cur_curve->position_from_u(cur_curve->end_param(), *endpoint);
585 [ # # ]: 0 : interior_points.append(endpoint);
586 : : }
587 : : // clean out the list for the next curve
588 [ # # ]: 0 : curve_point_list.clean_out();
589 : : }
590 : :
591 [ # # ]: 0 : return CUBIT_SUCCESS;
592 : : }
593 : :
594 : 0 : CubitStatus CompositeCurve::get_center_radius( CubitVector& c, double& r )
595 : : {
596 [ # # ]: 0 : if (num_curves() == 0) // point curve
597 : 0 : return CUBIT_FAILURE;
598 : :
599 [ # # ]: 0 : if (!get_curve(0)->get_center_radius(c,r) )
600 : 0 : return CUBIT_FAILURE;
601 : :
602 [ # # ]: 0 : for (int i = compGeom->num_entities() - 1; i > 0; i-- )
603 : : {
604 [ # # ]: 0 : CubitVector c2;
605 : : double r2;
606 [ # # ][ # # ]: 0 : if (!get_curve(i)->get_center_radius(c2,r2) ||
[ # # ][ # # ]
607 [ # # ][ # # ]: 0 : fabs(r - r2) > GEOMETRY_RESABS ||
608 [ # # ][ # # ]: 0 : (c2 - c).length_squared() > GEOMETRY_RESABS*GEOMETRY_RESABS)
[ # # ][ # # ]
609 : : {
610 : 0 : return CUBIT_FAILURE;
611 : : }
612 : : }
613 : 0 : return CUBIT_SUCCESS;
614 : : }
615 : :
616 : 0 : CubitBoolean CompositeCurve::G1_discontinuous( double param,
617 : : CubitVector* minus_tangent, CubitVector* plus_tangent )
618 : : {
619 [ # # ][ # # ]: 0 : if (num_curves() == 0) // point curve
620 : 0 : return CUBIT_FALSE;
621 : :
622 : 0 : const double half_resabs = CUBIT_RESABS / 2.0;
623 : : double curve_param;
624 : : int curve_index;
625 [ # # ]: 0 : CubitStatus s = this->curve_param( param, curve_param, curve_index );
626 [ # # ]: 0 : if( ! s )
627 : : {
628 [ # # ][ # # ]: 0 : PRINT_ERROR("Parameter %f out of range [%f,%f] in "
[ # # ][ # # ]
[ # # ]
629 [ # # ]: 0 : "CompositeCurve::G1_discontinous(..)\n",param,start_param(),end_param());
630 : 0 : return CUBIT_FALSE;
631 : : }
632 : :
633 [ # # ][ # # ]: 0 : CubitVector tan1, tan2, location, cp;
[ # # ][ # # ]
634 : 0 : CubitBoolean result = CUBIT_FALSE;
635 [ # # ][ # # ]: 0 : if( (curve_index > 0) &&
[ # # ]
636 [ # # ]: 0 : (fabs(compGeom->measure(curve_index-1) - param) < half_resabs) )
637 : : {
638 [ # # ][ # # ]: 0 : get_curve( curve_index )->position_from_u( curve_param, location );
639 [ # # ][ # # ]: 0 : get_curve( curve_index-1 )->closest_point( location, cp, &tan1 );
640 [ # # ][ # # ]: 0 : if( get_sense( curve_index-1 ) == CUBIT_REVERSED ) tan1 *= -1.0;
[ # # ]
641 [ # # ][ # # ]: 0 : get_curve( curve_index )->closest_point( location, cp, &tan2 );
642 [ # # ][ # # ]: 0 : if( get_sense( curve_index ) == CUBIT_REVERSED ) tan2 *= -1.0;
[ # # ]
643 [ # # ][ # # ]: 0 : double cross = (tan1 * tan2).length_squared();
644 [ # # ][ # # ]: 0 : double sum = (tan1 + tan2).length_squared();
645 [ # # ][ # # ]: 0 : double diff = (tan1 - tan2).length_squared();
646 [ # # ][ # # ]: 0 : if( (cross > CUBIT_RESABS) || (sum < diff) )
647 : : {
648 [ # # ][ # # ]: 0 : if( minus_tangent ) *minus_tangent = tan1;
649 [ # # ][ # # ]: 0 : if( plus_tangent ) *plus_tangent = tan2;
650 : 0 : result = CUBIT_TRUE;
651 : : }
652 : : else
653 : 0 : result = CUBIT_FALSE;
654 : :
655 : : }
656 [ # # ][ # # ]: 0 : else if( (curve_index < (compGeom->num_entities()-1)) &&
[ # # ][ # # ]
657 [ # # ]: 0 : (fabs(compGeom->measure(curve_index) - param) < half_resabs) )
658 : : {
659 [ # # ][ # # ]: 0 : get_curve( curve_index )->position_from_u( curve_param, location );
660 [ # # ][ # # ]: 0 : get_curve( curve_index )->closest_point( location, cp, &tan1 );
661 [ # # ][ # # ]: 0 : if( get_sense( curve_index ) == CUBIT_REVERSED ) tan1 *= -1.0;
[ # # ]
662 [ # # ][ # # ]: 0 : get_curve( curve_index+1 )->closest_point( location, cp, &tan2 );
663 [ # # ][ # # ]: 0 : if( get_sense( curve_index+1 ) == CUBIT_REVERSED ) tan2 *= -1.0;
[ # # ]
664 [ # # ][ # # ]: 0 : double cross = (tan1 * tan2).length_squared();
665 [ # # ][ # # ]: 0 : double sum = (tan1 + tan2).length_squared();
666 [ # # ][ # # ]: 0 : double diff = (tan1 - tan2).length_squared();
667 [ # # ][ # # ]: 0 : if( (cross > CUBIT_RESABS) || (sum < diff) )
668 : : {
669 [ # # ][ # # ]: 0 : if( minus_tangent ) *minus_tangent = tan1;
670 [ # # ][ # # ]: 0 : if( plus_tangent ) *plus_tangent = tan2;
671 : 0 : result = CUBIT_TRUE;
672 : : }
673 : : else
674 : 0 : result = CUBIT_FALSE;
675 : : }
676 [ # # ][ # # ]: 0 : else if( get_sense(curve_index) == CUBIT_FORWARD )
677 : : {
678 [ # # ]: 0 : result = get_curve( curve_index )
679 [ # # ]: 0 : ->G1_discontinuous( curve_param, minus_tangent, plus_tangent );
680 : : }
681 : : else
682 : : {
683 [ # # ]: 0 : result = get_curve( curve_index )
684 [ # # ]: 0 : ->G1_discontinuous( curve_param, plus_tangent, minus_tangent );
685 [ # # ]: 0 : if( result )
686 : : {
687 [ # # ][ # # ]: 0 : if( plus_tangent ) *plus_tangent *= -1.0;
688 [ # # ][ # # ]: 0 : if( minus_tangent) *minus_tangent *= -1.0;
689 : : }
690 : : }
691 : 0 : return result;
692 : : }
693 : :
694 : :
695 : 0 : int CompositeCurve::closest_curve( const CubitVector& location,
696 : : CubitVector *point )
697 : : {
698 : : double shortest_distance_sqr, current_distance_sqr;
699 [ # # ][ # # ]: 0 : CubitVector closest_point, current_point;
700 : : int closest_curve, current_curve;
701 : :
702 [ # # ]: 0 : closest_curve = compGeom->closest_box( location );
703 : :
704 [ # # ][ # # ]: 0 : get_curve( closest_curve )->closest_point_trimmed( location, closest_point );
705 [ # # ][ # # ]: 0 : shortest_distance_sqr = (location - closest_point).length_squared();
706 : :
707 [ # # ][ # # ]: 0 : while( ( current_curve = compGeom->next_box_within_dist( shortest_distance_sqr ) ) >= 0 )
708 : : {
709 [ # # ][ # # ]: 0 : get_curve( current_curve )->closest_point_trimmed( location, current_point );
710 [ # # ][ # # ]: 0 : current_distance_sqr = (location - current_point).length_squared();
711 [ # # ]: 0 : if( current_distance_sqr < shortest_distance_sqr )
712 : : {
713 : 0 : closest_curve = current_curve;
714 : 0 : shortest_distance_sqr = current_distance_sqr;
715 [ # # ]: 0 : closest_point = current_point;
716 : : }
717 : : }
718 : :
719 [ # # ][ # # ]: 0 : if( point ) *point = closest_point;
720 : 0 : return closest_curve;
721 : : }
722 : :
723 : :
724 : :
725 : : //-------------------------------------------------------------------------
726 : : // Purpose : Parameter Conversion
727 : : //
728 : : // Special Notes :
729 : : //
730 : : // Creator : Jason Kraftcheck
731 : : //
732 : : // Creation Date : 06/08/98
733 : : //-------------------------------------------------------------------------
734 : 0 : double CompositeCurve::composite_param( int index, double u ) const
735 : : {
736 [ # # ][ # # ]: 0 : if( (index < 0) || (index >= compGeom->num_entities()) ) return -1.0;
[ # # ][ # # ]
737 [ # # ]: 0 : Curve* curve_ptr = get_curve( index );
738 [ # # ]: 0 : double sum = lengthUntilI( index );
739 : :
740 : : double u_min, u_max;
741 [ # # ]: 0 : curve_ptr->get_param_range( u_min, u_max );
742 : :
743 [ # # ]: 0 : CubitSense sense = this->get_sense(index);
744 [ # # ]: 0 : double root_param = (sense == CUBIT_FORWARD) ? u_min : u_max;
745 : : double lfu = (root_param < u) ?
746 : 0 : curve_ptr->length_from_u( root_param, u ) :
747 [ # # ][ # # ]: 0 : curve_ptr->length_from_u( u, root_param );
[ # # ]
748 : 0 : return sum + fabs( lfu );
749 : : }
750 : :
751 : :
752 : 0 : CubitStatus CompositeCurve::curve_param( double uc, double& ui, int& index ) const
753 : : {
754 : 0 : double sum = 0.0, period;
755 [ # # ][ # # ]: 0 : if( const_cast<CompositeCurve*>(this)->is_periodic(period) )
756 [ # # ]: 0 : fixup_periodic_param( uc );
757 : :
758 [ # # ]: 0 : int max = compGeom->num_entities();
759 : 0 : int min = 0;
760 : 0 : index = max / 2;
761 [ # # ]: 0 : sum = lengthUntilI( max - 1);
762 [ # # ]: 0 : if( uc >= sum ) index = max - 1;
763 [ # # ]: 0 : else while( min != max )
764 : : {
765 [ # # ]: 0 : sum = lengthUntilI(index);
766 [ # # ]: 0 : if( sum > uc )
767 : 0 : max = index;
768 [ # # ][ # # ]: 0 : else if( lengthUntilI(index+1) > uc )
769 : 0 : break;
770 : : else
771 : 0 : min = index;
772 : :
773 : 0 : index = (min + max) / 2;
774 : : }
775 : :
776 [ # # ][ # # ]: 0 : if( index >= compGeom->num_entities() ) return CUBIT_FAILURE;
777 : :
778 : : double start_param, end_param;
779 [ # # ][ # # ]: 0 : get_curve(index)->get_param_range( start_param, end_param );
780 : :
781 : 0 : double arc_len = uc - sum;
782 [ # # ][ # # ]: 0 : if( get_sense(index) == CUBIT_REVERSED )
783 [ # # ][ # # ]: 0 : arc_len = get_curve(index)->measure() - arc_len;
784 : :
785 [ # # ][ # # ]: 0 : ui = get_curve(index)->u_from_arc_length( start_param, arc_len );
786 : 0 : return CUBIT_SUCCESS;
787 : : }
788 : :
789 : :
790 : :
791 : :
792 : : //-------------------------------------------------------------------------
793 : : // Purpose : Calculate the sum of the lengths of curves 0 to i-1.
794 : : //
795 : : // Special Notes :
796 : : //
797 : : // Creator : Jason Kraftcheck
798 : : //
799 : : // Creation Date : 06/09/98
800 : : //-------------------------------------------------------------------------
801 : 0 : double CompositeCurve::lengthUntilI( int i ) const
802 : : {
803 [ # # ][ # # ]: 0 : assert( i >= 0 && i < compGeom->num_entities() );
804 [ # # ]: 0 : return ( i == 0 ) ? 0.0 : compGeom->measure(i - 1);
805 : : }
806 : :
807 : : //-------------------------------------------------------------------------
808 : : // Purpose : TopologyBridge queries
809 : : //
810 : : // Special Notes :
811 : : //
812 : : // Creator : Jason Kraftcheck
813 : : //
814 : : // Creation Date : 03/04/02
815 : : //-------------------------------------------------------------------------
816 : 0 : void CompositeCurve::get_parents_virt( DLIList<TopologyBridge*>& list )
817 : : {
818 [ # # ]: 0 : for( CompositeCoEdge* coedge = firstCoEdge;
819 : : coedge != 0;
820 : : coedge = coedge->nextOnCurve )
821 [ # # ][ # # ]: 0 : if (!dynamic_cast<HiddenEntitySet*>(coedge->owner()))
[ # # ]
822 [ # # ]: 0 : list.append( coedge );
823 : :
824 [ # # ]: 0 : if (stitchNext)
825 : 0 : stitchNext->get_parents_virt(list);
826 : 0 : }
827 : 0 : void CompositeCurve::get_children_virt( DLIList<TopologyBridge*>& list )
828 : : {
829 : 0 : CompositePoint* sp = start_point();
830 : 0 : CompositePoint* ep = end_point();
831 : :
832 [ # # ]: 0 : if( sp )
833 [ # # ]: 0 : list.append( sp );
834 [ # # ][ # # ]: 0 : if( ep && ep != sp )
835 [ # # ]: 0 : list.append( ep );
836 : 0 : }
837 : :
838 : : //-------------------------------------------------------------------------
839 : : // Purpose : TBOwner methods
840 : : //
841 : : // Special Notes :
842 : : //
843 : : // Creator : Jason Kraftcheck
844 : : //
845 : : // Creation Date : 03/04/02
846 : : //-------------------------------------------------------------------------
847 : 0 : CubitStatus CompositeCurve::remove_bridge( TopologyBridge* bridge )
848 : : {
849 : 0 : int i = compGeom->index_of(bridge);
850 [ # # ]: 0 : if ( i >= 0 )
851 : : {
852 : 0 : bridge->owner(0);
853 [ # # ]: 0 : if ( !compGeom->remove(i,true) )
854 : 0 : return CUBIT_FAILURE;
855 : :
856 [ # # ]: 0 : if (compGeom->num_entities() == 0)
857 : 0 : CompositeEngine::instance().notify_deactivated(this);
858 : 0 : HadBridgeRemoved = 1;
859 : 0 : return CUBIT_SUCCESS;
860 : : }
861 : : else
862 : : {
863 [ # # ]: 0 : for (CompositeCurve* ptr = this; ptr->stitchNext; ptr = ptr->stitchNext)
864 : : {
865 [ # # ]: 0 : if (ptr->stitchNext == bridge)
866 : : {
867 : 0 : ptr->stitchNext = ((CompositeCurve*)bridge)->stitchNext;
868 : 0 : HadBridgeRemoved = 1;
869 : 0 : return CUBIT_SUCCESS;
870 : : }
871 : : }
872 : : }
873 : :
874 : 0 : return CUBIT_FAILURE;
875 : : }
876 : :
877 : 0 : Curve* CompositeCurve::remove_curve( int index )
878 : : {
879 : 0 : Curve* curve = get_curve(index);
880 [ # # ][ # # ]: 0 : if (!curve || !compGeom->remove(index,false) )
[ # # ]
881 : 0 : return 0;
882 : 0 : curve->owner(0);
883 : 0 : return curve;
884 : : }
885 : :
886 : :
887 : :
888 : 0 : CubitStatus CompositeCurve::swap_bridge( TopologyBridge* o,
889 : : TopologyBridge* n,
890 : : bool reversed )
891 : : {
892 : 0 : int i = compGeom->index_of(o);
893 [ # # ]: 0 : GeometryEntity* ge = dynamic_cast<GeometryEntity*>(n);
894 [ # # ][ # # ]: 0 : if( i >= 0 && ge != 0 )
895 : : {
896 : 0 : o->owner(0);
897 : 0 : n->owner(this);
898 [ # # ]: 0 : if ( ! compGeom->swap( i, ge ) )
899 : 0 : return CUBIT_FAILURE;
900 : :
901 [ # # ]: 0 : if (reversed)
902 : 0 : compGeom->reverse_sense(i);
903 : 0 : return CUBIT_SUCCESS;
904 : : }
905 : : else
906 : 0 : return CUBIT_FAILURE;
907 : : }
908 : 0 : CubitBoolean CompositeCurve::contains_bridge( TopologyBridge* bridge ) const
909 : : {
910 [ # # ]: 0 : if (!compGeom)
911 : 0 : return CUBIT_FALSE;
912 : :
913 : 0 : return (CubitBoolean)(compGeom->index_of(bridge) >= 0);
914 : : }
915 : :
916 : :
917 : : //-------------------------------------------------------------------------
918 : : // Purpose : Attach a CubitSimpleAttribute
919 : : //
920 : : // Special Notes :
921 : : //
922 : : // Creator : Jason Kraftcheck
923 : : //
924 : : // Creation Date : 03/10/98
925 : : //-------------------------------------------------------------------------
926 : 0 : void CompositeCurve::append_simple_attribute_virt(
927 : : const CubitSimpleAttrib& simple_attrib_ptr )
928 : : {
929 [ # # ]: 0 : if(compGeom)
930 : 0 : compGeom->add_attribute( simple_attrib_ptr );
931 : 0 : }
932 : :
933 : : //-------------------------------------------------------------------------
934 : : // Purpose : Remove an attached CubitSimpleAttrib
935 : : //
936 : : // Special Notes :
937 : : //
938 : : // Creator : Jason Kraftcheck
939 : : //
940 : : // Creation Date : 03/10/98
941 : : //-------------------------------------------------------------------------
942 : 0 : void CompositeCurve::remove_simple_attribute_virt(
943 : : const CubitSimpleAttrib& simple_attrib_ptr )
944 : : {
945 [ # # ]: 0 : if(compGeom)
946 : 0 : compGeom->rem_attribute( simple_attrib_ptr );
947 : 0 : }
948 : :
949 : :
950 : : //-------------------------------------------------------------------------
951 : : // Purpose : Remove an all attached CubitSimpleAttrib
952 : : //
953 : : // Special Notes :
954 : : //
955 : : // Creator : Greg Nielson
956 : : //
957 : : // Creation Date : 07/10/98
958 : : //-------------------------------------------------------------------------
959 : 0 : void CompositeCurve::remove_all_simple_attribute_virt()
960 : : {
961 [ # # ]: 0 : if(compGeom)
962 : 0 : compGeom->rem_all_attributes( );
963 : 0 : }
964 : :
965 : :
966 : : //-------------------------------------------------------------------------
967 : : // Purpose : Return the attached CubitSimpleAttribs.
968 : : //
969 : : // Special Notes :
970 : : //
971 : : // Creator : Jason Kraftcheck
972 : : //
973 : : // Creation Date : 03/10/98
974 : : //-------------------------------------------------------------------------
975 : 0 : CubitStatus CompositeCurve::get_simple_attribute(
976 : : DLIList<CubitSimpleAttrib>& attrib_list )
977 : : {
978 [ # # ]: 0 : if(!compGeom)
979 : 0 : return CUBIT_FAILURE;
980 : 0 : compGeom->get_attributes( attrib_list );
981 : 0 : return CUBIT_SUCCESS;
982 : : }
983 : :
984 : :
985 : :
986 : : //-------------------------------------------------------------------------
987 : : // Purpose : Get attribs by name
988 : : //
989 : : // Special Notes :
990 : : //
991 : : // Creator : Jason Kraftcheck
992 : : //
993 : : // Creation Date : 03/03/03
994 : : //-------------------------------------------------------------------------
995 : 0 : CubitStatus CompositeCurve::get_simple_attribute(
996 : : const CubitString& name, DLIList<CubitSimpleAttrib>& attrib_list )
997 : : {
998 [ # # ]: 0 : if(!compGeom)
999 : 0 : return CUBIT_FAILURE;
1000 : 0 : compGeom->get_attributes( name.c_str(), attrib_list );
1001 : 0 : return CUBIT_SUCCESS;
1002 : : }
1003 : :
1004 : 0 : void CompositeCurve::fixup_periodic_param( double& param ) const
1005 : : {
1006 [ # # ]: 0 : if(!compGeom)
1007 : 0 : return;
1008 : 0 : double period = compGeom->measure();
1009 [ # # ]: 0 : if( param < 0.0 )
1010 : 0 : param = period - param;
1011 [ # # ]: 0 : if( param >= period )
1012 : 0 : param = fmod( param, period );
1013 : : }
1014 : :
1015 : : //-------------------------------------------------------------------------
1016 : : // Purpose : Write attributes to underlying geometry entity
1017 : : //
1018 : : // Special Notes : Special case for point-curves
1019 : : //
1020 : : // Creator : Jason Kraftcheck
1021 : : //
1022 : : // Creation Date : 02/28/04
1023 : : //-------------------------------------------------------------------------
1024 : 0 : void CompositeCurve::write_attributes()
1025 : : {
1026 [ # # ]: 0 : if (num_curves()) // not a point-curve
1027 : : {
1028 : 0 : compGeom->write_attributes();
1029 : : }
1030 : : else
1031 : : {
1032 : 0 : CompositePoint* point = start_point();
1033 [ # # ]: 0 : assert(point == end_point());
1034 : 0 : compGeom->write_attributes(point);
1035 : : }
1036 : 0 : }
1037 : :
1038 : : //-------------------------------------------------------------------------
1039 : : // Purpose : Read attributes from underlying geometry
1040 : : //
1041 : : // Special Notes :
1042 : : //
1043 : : // Creator : Jason Kraftcheck
1044 : : //
1045 : : // Creation Date : 02/28/04
1046 : : //-------------------------------------------------------------------------
1047 : 0 : void CompositeCurve::read_attributes()
1048 : : {
1049 [ # # ]: 0 : if (num_curves()) // not a point-curve
1050 : : {
1051 : 0 : compGeom->read_attributes();
1052 : : }
1053 : : else
1054 : : {
1055 : 0 : CompositePoint* point = start_point();
1056 [ # # ]: 0 : assert(point == end_point());
1057 : 0 : compGeom->read_attributes(point);
1058 : : }
1059 : 0 : }
1060 : :
1061 : :
1062 : 0 : void CompositeCurve::get_hidden_points( DLIList<TBPoint*>& points )
1063 : : {
1064 [ # # ]: 0 : if( hiddenSet )
1065 : : {
1066 : 0 : hiddenSet->hidden_points( points );
1067 : : }
1068 : 0 : }
1069 : :
1070 : :
1071 : :
1072 : 0 : void CompositeCurve::print_debug_info( const char* prefix,
1073 : : bool brief ) const
1074 : : {
1075 [ # # ]: 0 : if( prefix == 0 ) prefix = "";
1076 : :
1077 [ # # ]: 0 : if ( brief )
1078 : : {
1079 : : #ifdef TOPOLOGY_BRIDGE_IDS
1080 : : PRINT_INFO("%sCompositeCurve %d : points (%d,%d) ", prefix, get_id(),
1081 : : startPoint ? startPoint->get_id() : -1, endPoint ? endPoint->get_id() : -1 );
1082 : : if ( num_curves() == 1 )
1083 : : PRINT_INFO(": %s %d\n", fix_type_name(typeid(*get_curve(0)).name()), get_curve(0)->get_id());
1084 : : else
1085 : : PRINT_INFO(": %d curves.\n", num_curves() );
1086 : : #else
1087 [ # # ][ # # ]: 0 : PRINT_INFO("%sCompositeCurve %p : points (%p,%p) ", prefix, (void*)this,
[ # # ]
1088 [ # # ]: 0 : (void*)startPoint, (void*)endPoint );
1089 [ # # ][ # # ]: 0 : if ( num_curves() == 1 )
1090 [ # # ][ # # ]: 0 : PRINT_INFO(": %s %p\n", fix_type_name(typeid(*get_curve(0)).name()), (void*)get_curve(0));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1091 : : else
1092 [ # # ][ # # ]: 0 : PRINT_INFO(": %d curves.\n", num_curves() );
[ # # ][ # # ]
[ # # ]
1093 : : #endif
1094 : 0 : return;
1095 : : }
1096 : :
1097 [ # # ]: 0 : char* new_prefix = new char[strlen(prefix)+3];
1098 : 0 : strcpy( new_prefix, prefix );
1099 : 0 : strcat( new_prefix, " ");
1100 : :
1101 : : #ifdef TOPOLOGY_BRIDGE_IDS
1102 : : PRINT_INFO("%sCompositeCurve %d\n", prefix, get_id() );
1103 : : #else
1104 [ # # ][ # # ]: 0 : PRINT_INFO("%sCompositeCurve %p\n", prefix, (void*)this );
[ # # ][ # # ]
1105 : : #endif
1106 [ # # ]: 0 : compGeom->print_debug_info( new_prefix );
1107 [ # # ][ # # ]: 0 : if( hiddenSet ) hiddenSet->print_debug_info( new_prefix );
1108 [ # # ][ # # ]: 0 : else PRINT_INFO("%s No Hidden Entities.\n", prefix );
[ # # ][ # # ]
1109 : :
1110 [ # # ]: 0 : CompositeCoEdge* coedge = first_coedge();
1111 [ # # ][ # # ]: 0 : DLIList<TopologyBridge*> loops(1), surface_list(1);
[ # # ]
1112 : :
1113 [ # # ]: 0 : while( coedge )
1114 : : {
1115 : 0 : TopologyBridge* surf_ptr = 0;
1116 [ # # ]: 0 : loops.clean_out();
1117 [ # # ]: 0 : surface_list.clean_out();
1118 [ # # ]: 0 : coedge->get_parents_virt(loops);
1119 [ # # ][ # # ]: 0 : if ( loops.size() == 1 )
1120 : : {
1121 [ # # ][ # # ]: 0 : loops.get()->get_parents_virt(surface_list);
1122 [ # # ][ # # ]: 0 : if( surface_list.size() == 1 )
1123 [ # # ]: 0 : surf_ptr = surface_list.get();
1124 : : }
1125 : :
1126 : : #ifdef TOPOLOGY_BRIDGE_IDS
1127 : : PRINT_INFO("%s %s on Surface %d\n", prefix,
1128 : : coedge->sense() == CUBIT_FORWARD ? "FORWARD" :
1129 : : coedge->sense() == CUBIT_REVERSED ? "REVERSE" : "UNKNOWN",
1130 : : surf_ptr->get_id() );
1131 : : #else
1132 [ # # ][ # # ]: 0 : PRINT_INFO("%s %s on Surface %p\n", prefix,
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1133 : : coedge->sense() == CUBIT_FORWARD ? "FORWARD" :
1134 : : coedge->sense() == CUBIT_REVERSED ? "REVERSE" : "UNKNOWN",
1135 [ # # ]: 0 : (void*)surf_ptr );
1136 : : #endif
1137 : :
1138 [ # # ][ # # ]: 0 : if (!coedge->get_loop())
1139 [ # # ]: 0 : coedge->print_debug_info( new_prefix, true );
1140 [ # # ]: 0 : coedge = next_coedge(coedge);
1141 : : }
1142 : :
1143 [ # # ][ # # ]: 0 : if ( !start_point() )
1144 [ # # ][ # # ]: 0 : PRINT_INFO("%s NULL START POINT\n", prefix );
[ # # ][ # # ]
1145 : : else
1146 [ # # ][ # # ]: 0 : start_point()->print_debug_info( new_prefix, true );
1147 : :
1148 [ # # ][ # # ]: 0 : if ( !end_point() )
1149 [ # # ][ # # ]: 0 : PRINT_INFO("%s NULL END POINT\n", prefix );
[ # # ][ # # ]
1150 [ # # ][ # # ]: 0 : else if ( end_point() == start_point() )
[ # # ]
1151 [ # # ][ # # ]: 0 : PRINT_INFO("%s end point SAME as start point\n", prefix );
[ # # ][ # # ]
1152 : : else
1153 [ # # ][ # # ]: 0 : end_point()->print_debug_info( new_prefix, true );
1154 : :
1155 [ # # ][ # # ]: 0 : delete [] new_prefix;
1156 : : }
1157 : :
1158 : :
1159 : : //-------------------------------------------------------------------------
1160 : : // Purpose : Update composite for change in sense of underlying curve
1161 : : //
1162 : : // Special Notes :
1163 : : //
1164 : : // Creator : Jason Kraftcheck
1165 : : //
1166 : : // Creation Date :
1167 : : //-------------------------------------------------------------------------
1168 : 0 : void CompositeCurve::notify_reversed( TopologyBridge* bridge )
1169 : : {
1170 : 0 : int index = compGeom->index_of(bridge);
1171 [ # # ]: 0 : if( index >= 0 )
1172 : 0 : compGeom->reverse_sense(index);
1173 : 0 : }
1174 : :
1175 : : //-------------------------------------------------------------------------
1176 : : // Purpose : Merge
1177 : : //
1178 : : // Special Notes :
1179 : : //
1180 : : // Creator : Jason Kraftcheck
1181 : : //
1182 : : // Creation Date : 12/02/02
1183 : : //-------------------------------------------------------------------------
1184 : 0 : CubitStatus CompositeCurve::stitch( CompositeCurve* dead )
1185 : : {
1186 : : // check to make sure end points are already stitched.
1187 : : bool reversed;
1188 : :
1189 [ # # ]: 0 : if( dead->start_point() == this->start_point() )
1190 : 0 : reversed = false;
1191 [ # # ]: 0 : else if( dead->end_point() == this->start_point() )
1192 : 0 : reversed = true;
1193 : : else
1194 : 0 : return CUBIT_FAILURE;
1195 : :
1196 [ # # ][ # # ]: 0 : if( ( reversed && (dead->start_point() != this->end_point())) ||
[ # # ][ # # ]
1197 [ # # ]: 0 : (!reversed && (dead->end_point() != this->end_point())) )
1198 : 0 : return CUBIT_FAILURE;
1199 : :
1200 : : // shouldn't be merging hidden curves
1201 [ # # ][ # # ]: 0 : if( dynamic_cast<CompositeCurve*>(this->owner()) ||
[ # # ]
1202 [ # # ][ # # ]: 0 : dynamic_cast<CompositeCurve*>(dead->owner()) )
1203 : : {
1204 : 0 : assert(0);
1205 : : return CUBIT_FAILURE;
1206 : : }
1207 : :
1208 : : // DAG / next level up should already be merged
1209 [ # # ]: 0 : if( dead->owner() != this->owner() )
1210 : : {
1211 : 0 : assert(0);
1212 : : return CUBIT_FAILURE;
1213 : : }
1214 : :
1215 : : // update owner
1216 [ # # ]: 0 : if( dead->owner() )
1217 : 0 : dead->owner()->notify_merged( dead, this );
1218 [ # # ]: 0 : assert( !dead->owner() );
1219 : 0 : dead->owner( this );
1220 : :
1221 : : // merge lists
1222 : 0 : CompositeCurve* end = dead;
1223 [ # # ]: 0 : while (end->stitchNext)
1224 : : {
1225 : 0 : end->stitchNext->owner( this );
1226 : 0 : end = end->stitchNext;
1227 : : }
1228 : 0 : end->stitchNext = stitchNext;
1229 : 0 : stitchNext = end;
1230 : :
1231 : 0 : return CUBIT_SUCCESS;
1232 : : }
1233 : :
1234 : : //-------------------------------------------------------------------------
1235 : : // Purpose : Get the visible curve of a set of stitched curves
1236 : : //
1237 : : // Special Notes :
1238 : : //
1239 : : // Creator : Jason Kraftcheck
1240 : : //
1241 : : // Creation Date : 12/02/02
1242 : : //-------------------------------------------------------------------------
1243 : 0 : CompositeCurve* CompositeCurve::primary_stitched_curve()
1244 : : {
1245 [ # # ]: 0 : CompositeCurve* result = dynamic_cast<CompositeCurve*>(owner());
1246 [ # # ]: 0 : return result ? result : this;
1247 : : }
1248 : :
1249 : : //-------------------------------------------------------------------------
1250 : : // Purpose : Is this curve stitched with any others
1251 : : //
1252 : : // Special Notes :
1253 : : //
1254 : : // Creator : Jason Kraftcheck
1255 : : //
1256 : : // Creation Date : 12/02/02
1257 : : //-------------------------------------------------------------------------
1258 : 0 : bool CompositeCurve::is_stitched()
1259 : : {
1260 [ # # ][ # # ]: 0 : return stitchNext || dynamic_cast<CompositeCurve*>(owner());
[ # # ]
1261 : : }
1262 : :
1263 : : //-------------------------------------------------------------------------
1264 : : // Purpose : Get list of stitched curves
1265 : : //
1266 : : // Special Notes :
1267 : : //
1268 : : // Creator : Jason Kraftcheck
1269 : : //
1270 : : // Creation Date : 12/16/02
1271 : : //-------------------------------------------------------------------------
1272 : 0 : void CompositeCurve::get_stitched( DLIList<CompositeCurve*>& list )
1273 : : {
1274 [ # # ][ # # ]: 0 : for (CompositeCurve* curve = primary_stitched_curve();
1275 : : curve; curve = curve->stitchNext)
1276 [ # # ]: 0 : list.append( curve );
1277 : 0 : }
1278 : :
1279 : : //-------------------------------------------------------------------------
1280 : : // Purpose : Remove all stitched curves
1281 : : //
1282 : : // Special Notes :
1283 : : //
1284 : : // Creator : Jason Kraftcheck
1285 : : //
1286 : : // Creation Date : 12/02/02
1287 : : //-------------------------------------------------------------------------
1288 : 0 : void CompositeCurve::unstitch_all()
1289 : : {
1290 : : // should only call on visible curve
1291 [ # # ]: 0 : assert (this == primary_stitched_curve());
1292 : :
1293 [ # # ]: 0 : while (stitchNext)
1294 : : {
1295 : 0 : stitchNext->owner(0);
1296 [ # # ]: 0 : if (owner())
1297 : 0 : owner()->notify_copied( stitchNext, this );
1298 : 0 : stitchNext = stitchNext->stitchNext;
1299 : : }
1300 : 0 : }
1301 : :
1302 : :
1303 : : //-------------------------------------------------------------------------
1304 : : // Purpose : Update for split in underlying curve
1305 : : //
1306 : : // Special Notes :
1307 : : //
1308 : : // Creator : Jason Kraftcheck
1309 : : //
1310 : : // Creation Date : 12/19/02
1311 : : //-------------------------------------------------------------------------
1312 : 0 : void CompositeCurve::notify_split( TopologyBridge* new_bridge,
1313 : : TopologyBridge* old_bridge )
1314 : : {
1315 [ # # ]: 0 : Curve* old_curve = dynamic_cast<Curve*>(old_bridge);
1316 [ # # ]: 0 : Curve* new_curve = dynamic_cast<Curve*>(new_bridge);
1317 [ # # ][ # # ]: 0 : assert( old_curve && new_curve && index_of(old_curve) >= 0 );
[ # # ][ # # ]
1318 : :
1319 : : // get start and end points
1320 [ # # ]: 0 : DLIList<TopologyBridge*> bridges;
1321 [ # # ][ # # ]: 0 : old_curve->get_children(bridges,true,old_curve->layer());
1322 [ # # ]: 0 : bridges.reset();
1323 [ # # ][ # # ]: 0 : TBPoint* old_start = dynamic_cast<TBPoint*>(bridges.get());
1324 [ # # ][ # # ]: 0 : TBPoint* old_end = dynamic_cast<TBPoint*>(bridges.next());
1325 [ # # ]: 0 : bridges.clean_out();
1326 [ # # ][ # # ]: 0 : new_curve->get_children(bridges,true,new_curve->layer());
1327 [ # # ][ # # ]: 0 : TBPoint* new_start = dynamic_cast<TBPoint*>(bridges.get());
1328 [ # # ][ # # ]: 0 : TBPoint* new_end = dynamic_cast<TBPoint*>(bridges.next());
1329 [ # # ]: 0 : bridges.clean_out();
1330 : :
1331 : :
1332 : : // find new point
1333 [ # # ][ # # ]: 0 : bool sp = (new_start == old_start || new_start == old_end);
1334 : : #ifndef NDEBUG
1335 [ # # ][ # # ]: 0 : bool ep = (new_end == old_start || new_end == old_end);
1336 [ # # ]: 0 : assert( ep != sp ); // one must be true and one must be false
1337 : : #endif
1338 [ # # ]: 0 : TBPoint* new_pt = sp ? new_start : new_end;
1339 : :
1340 : : // find relative sense of curves
1341 [ # # ]: 0 : int old_index = index_of(old_curve);
1342 : 0 : bool is_start = (old_start == new_pt);
1343 [ # # ]: 0 : bool is_forward = (get_sense(old_index) == CUBIT_FORWARD);
1344 : 0 : bool prepend = (is_start == is_forward);
1345 : 0 : is_start = (new_start == new_pt);
1346 [ # # ][ # # ]: 0 : assert( is_start || new_pt == new_end );
1347 : 0 : bool reversed = (is_start == prepend);
1348 : :
1349 [ # # ][ # # ]: 0 : CompositePoint* new_cpt = new CompositePoint(new_pt);
1350 : :
1351 [ # # ][ # # ]: 0 : hidden_entities().hide(new_cpt);
1352 : :
1353 [ # # ]: 0 : CubitSense new_sense = reversed ? CUBIT_REVERSED : CUBIT_FORWARD;
1354 : 0 : int insert_index = old_index;
1355 [ # # ]: 0 : if( !prepend ) insert_index++;
1356 [ # # ][ # # ]: 0 : if( ! compGeom->insert( insert_index, new_curve, new_sense ) )
1357 : : {
1358 : 0 : assert(0);
1359 : : delete new_cpt;
1360 : : return;
1361 : : }
1362 [ # # ]: 0 : new_curve->owner(this);
1363 : :
1364 [ # # ][ # # ]: 0 : DLIList<CoEdgeSM*> new_coedges, old_coedges;
[ # # ][ # # ]
[ # # ][ # # ]
1365 [ # # ]: 0 : bridges.clean_out();
1366 [ # # ]: 0 : new_curve->get_parents_virt( bridges );
1367 [ # # ][ # # ]: 0 : CAST_LIST( bridges, new_coedges, CoEdgeSM );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1368 [ # # ][ # # ]: 0 : assert(bridges.size() == new_coedges.size());
[ # # ]
1369 [ # # ]: 0 : bridges.clean_out();
1370 [ # # ]: 0 : old_curve->get_parents_virt( bridges );
1371 [ # # ][ # # ]: 0 : CAST_LIST( bridges, old_coedges, CoEdgeSM );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1372 [ # # ][ # # ]: 0 : assert(bridges.size() == old_coedges.size());
[ # # ]
1373 : :
1374 [ # # ][ # # ]: 0 : for( CompositeCoEdge* coedge = first_coedge();
[ # # ][ # # ]
[ # # ]
1375 : : coedge;
1376 : : coedge = next_coedge(coedge) )
1377 : : {
1378 : : // for each coedge of the old curve
1379 : : int i;
1380 : 0 : CoEdgeSM* old_coedge = 0;
1381 [ # # ][ # # ]: 0 : for( i = 0; i < coedge->num_coedges(); i++ )
1382 : : {
1383 [ # # ]: 0 : old_coedge = coedge->get_coedge(i);
1384 [ # # ][ # # ]: 0 : if( old_coedges.is_in_list(old_coedge) )
1385 : 0 : break;
1386 : : }
1387 [ # # ][ # # ]: 0 : assert(i < coedge->num_coedges() && old_coedge);
[ # # ]
1388 : :
1389 [ # # ]: 0 : bridges.clean_out();
1390 [ # # ]: 0 : old_coedge->get_parents_virt(bridges);
1391 [ # # ][ # # ]: 0 : assert(bridges.size() == 1);
1392 [ # # ][ # # ]: 0 : LoopSM* loopsm = dynamic_cast<LoopSM*>(bridges.get());
1393 [ # # ]: 0 : assert(0 != loopsm);
1394 : :
1395 [ # # ]: 0 : bridges.clean_out();
1396 [ # # ][ # # ]: 0 : loopsm->get_children(bridges, true, old_curve->layer());
1397 [ # # ]: 0 : bridges.move_to(old_coedge);
1398 [ # # ][ # # ]: 0 : assert(bridges.get() == old_coedge);
1399 : :
1400 : : // Determine if new_coedge (the one we are looking for)
1401 : : // should occur before or after old_coedge in the loop.
1402 : : // If new_curve is after old_curve (old_end == new_pt),
1403 : : // then the we want the coedge after old_coedge iff the
1404 : : // sense of old_coedge is forward, otherwise the one before.
1405 : : // Invert that if new_curve is before old_curve (old_start
1406 : : // == new_pt).
1407 [ # # ]: 0 : bool coe_reversed = (old_coedge->sense() == CUBIT_REVERSED);
1408 : 0 : bool curve_prepend = (old_start == new_pt);
1409 : 0 : bool previous = coe_reversed != curve_prepend;
1410 : : CoEdgeSM* new_coedge =
1411 [ # # ][ # # ]: 0 : dynamic_cast<CoEdgeSM*>(previous ? bridges.prev() : bridges.next());
[ # # ][ # # ]
1412 [ # # ][ # # ]: 0 : assert(new_coedges.is_in_list(new_coedge));
1413 : :
1414 [ # # ]: 0 : CubitStatus s = coedge->insert_coedge(insert_index, new_coedge);
1415 [ # # ]: 0 : assert(s);
1416 [ # # ]: 0 : if (CUBIT_SUCCESS != s) {
1417 [ # # ][ # # ]: 0 : PRINT_ERROR("Failed to insert a new coedge.\n");
[ # # ][ # # ]
1418 : 0 : return;
1419 : : }
1420 : 0 : }
1421 : : }
1422 : :
1423 : 0 : CubitStatus CompositeCurve::get_spline_params
1424 : : (
1425 : : bool &rational, // return true/false
1426 : : int °ree, // the degree of this spline
1427 : : DLIList<CubitVector> &cntrl_pts, // xyz position of controlpoints
1428 : : DLIList<double> &cntrl_pt_weights, // if rational, a weight for each cntrl point.
1429 : : DLIList<double> &knots, // There should be order+cntrl_pts.size()-2 knots
1430 : : bool &spline_is_reversed
1431 : : ) const
1432 : : {
1433 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine spline parameters for CompositeCurves.\n");
1434 : 0 : return CUBIT_FAILURE;
1435 : : }
1436 : :
1437 : 0 : CubitStatus CompositeCurve::get_ellipse_params
1438 : : (
1439 : : CubitVector ¢er_vec,
1440 : : CubitVector &normal,
1441 : : CubitVector &major_axis,
1442 : : double &radius_ratio
1443 : : ) const
1444 : : {
1445 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine ellipse parameters for CompositeCurves.\n");
1446 : 0 : return CUBIT_FAILURE;
1447 [ + - ][ + - ]: 6364 : }
1448 : :
1449 : : /*
1450 : : void CompositeCurve::draw( int color )
1451 : : {
1452 : : int num_pts;
1453 : : GMem gmem;
1454 : :
1455 : : if (!VirtualQueryEngine::instance()->get_graphics(this, num_pts, &gmem))
1456 : : return;
1457 : :
1458 : : GfxDebug::draw_polyline( gmem.point_list(),
1459 : : gmem.pointListCount,
1460 : : color );
1461 : : GfxDebug::flush();
1462 : : }
1463 : : */
|
