Branch data Line data Source code
1 : : #include "SubCurve.hpp"
2 : : #include "GMem.hpp"
3 : : #include "GeometryQueryEngine.hpp"
4 : :
5 : 0 : PartitionCurve* SubCurve::split( double param )
6 : : {
7 [ # # ]: 0 : if( startParam <= endParam )
8 : : {
9 [ # # ][ # # ]: 0 : if( (param <= startParam) || (param >= endParam) )
10 : 0 : return 0;
11 : : }
12 [ # # ][ # # ]: 0 : else if( (param >= startParam) || (param <= endParam) )
13 : 0 : return 0;
14 : :
15 [ # # ]: 0 : return new SubCurve( this, param );
16 : : }
17 : :
18 : 0 : CubitStatus SubCurve::combine( PartitionCurve* dead_curve )
19 : : {
20 [ # # ]: 0 : SubCurve* curve = dynamic_cast<SubCurve*>(dead_curve);
21 [ # # ][ # # ]: 0 : if( !curve || curve->real_curve() != this->real_curve() )
[ # # ]
22 : 0 : return CUBIT_FAILURE;
23 : :
24 : 0 : double dse = fabs(start_param() - dead_curve->end_param());
25 : 0 : double des = fabs(end_param() - dead_curve->start_param());
26 : :
27 [ # # ]: 0 : if( des <= dse )
28 : 0 : endParam = curve->endParam;
29 : : else
30 : 0 : startParam = curve->startParam;
31 : :
32 : 0 : return CUBIT_SUCCESS;
33 : : }
34 : :
35 : :
36 : :
37 : :
38 : 0 : SubCurve::SubCurve( Curve* curve_ptr )
39 : : {
40 [ # # ][ # # ]: 0 : assert( dynamic_cast<SubEntitySet*>(curve_ptr->owner()) == 0 );
[ # # ]
41 [ # # ][ # # ]: 0 : new SubEntitySet( curve_ptr, this );
42 : :
43 : :
44 [ # # ]: 0 : startParam = curve_ptr->start_param();
45 [ # # ]: 0 : endParam = curve_ptr->end_param();
46 : :
47 : : double period;
48 [ # # ]: 0 : if( fabs( startParam - endParam ) < CUBIT_RESABS )
49 : : {
50 [ # # ][ # # ]: 0 : if( ! curve_ptr->is_periodic( period ) )
51 : : {
52 : 0 : assert( 0 );
53 : : }
54 : 0 : endParam = startParam + period ;
55 : : }
56 : :
57 [ # # ][ # # ]: 0 : if( curve_ptr->bridge_sense() != this->bridge_sense() )
[ # # ]
58 [ # # ]: 0 : reverse_bridge_sense();
59 : 0 : }
60 : :
61 : 0 : SubCurve::SubCurve( SubCurve* split_from, double start )
62 : : {
63 [ # # ][ # # ]: 0 : split_from->sub_entity_set().add_partition( this, split_from );
[ # # ]
64 : :
65 : 0 : endParam = split_from->endParam;
66 : 0 : startParam = split_from->endParam = start;
67 : :
68 [ # # ][ # # ]: 0 : if( CUBIT_REVERSED == split_from->bridge_sense() )
69 [ # # ]: 0 : this->reverse_bridge_sense();
70 : 0 : }
71 : :
72 : 0 : SubCurve::~SubCurve()
73 : : {
74 [ # # ]: 0 : }
75 : :
76 : 0 : int SubCurve::num_partitions() const
77 : : {
78 [ # # ]: 0 : DLIList<TopologyBridge*> tmp;
79 [ # # ]: 0 : get_all_partitions( tmp );
80 [ # # ][ # # ]: 0 : return tmp.size();
81 : : }
82 : :
83 : 0 : void SubCurve::get_all_partitions( DLIList<TopologyBridge*>& curves ) const
84 : : {
85 : 0 : sub_entity_set().get_owners(curves);
86 : 0 : }
87 : :
88 : 0 : CubitBox SubCurve::bounding_box() const
89 : : {
90 : : /*
91 : : CubitVector start, end;
92 : : SubCurve* me = (SubCurve*)this;
93 : : me->position_from_u( me->start_param(), start );
94 : : me->position_from_u( me-> end_param(), end );
95 : : CubitBox box( start, end );
96 : :
97 : : DLIList<CubitVector*> extrema;
98 : : CubitSense sense;
99 : : me->get_interior_extrema( extrema, sense );
100 : : if( sense == CUBIT_REVERSED )
101 : : extrema.reverse();
102 : : while( extrema.size() )
103 : : {
104 : : CubitVector* v = extrema.pop();
105 : : box |= *v;
106 : : delete v;
107 : : }
108 : : */
109 [ # # ]: 0 : return dynamic_cast<Curve*>(partitioned_entity())->bounding_box();
110 : : }
111 : :
112 : 0 : double SubCurve::measure()
113 : : {
114 : 0 : return fabs(real_curve()->length_from_u( startParam, endParam ));
115 : : }
116 : :
117 : 0 : GeometryType SubCurve::geometry_type()
118 : : {
119 : 0 : return real_curve()->geometry_type();
120 : : }
121 : :
122 : 0 : CubitStatus SubCurve::closest_point( const CubitVector& from,
123 : : CubitVector& closest,
124 : : CubitVector* tangent,
125 : : CubitVector* curvature,
126 : : double* param )
127 : : {
128 : : double u;
129 : : CubitStatus result =
130 [ # # ][ # # ]: 0 : real_curve()->closest_point( from, closest, tangent, curvature, &u );
131 [ # # ]: 0 : if( param )
132 : 0 : *param = u;
133 : :
134 : : // Snap position to the ends of the SubCurve if
135 : : // necessary.
136 [ # # ]: 0 : if(result)
137 : : {
138 : : double lower, upper;
139 : : double period;
140 : :
141 : : // If curve is periodic we first need to see if our location
142 : : // can be mapped to the subcurve range just by adding or
143 : : // subtracting multiples of the period. If no then we
144 : : // will snap it to one of the ends.
145 [ # # ]: 0 : int is_per = is_periodic(period);
146 : :
147 : : // Get the param range of the SubCurve (will probably
148 : : // be different from that of the underlying real curve).
149 [ # # ]: 0 : get_ordered_param_range(lower, upper);
150 : :
151 : : // If we are past the low end...
152 [ # # ]: 0 : if(u < lower)
153 : : {
154 : : // Adjust for periodic curve.
155 [ # # ]: 0 : if(is_per)
156 : : {
157 : 0 : double tmp_u = u;
158 [ # # ]: 0 : while(tmp_u < upper + GEOMETRY_RESABS)
159 : : {
160 : 0 : tmp_u += period;
161 [ # # ][ # # ]: 0 : if(tmp_u > lower - GEOMETRY_RESABS &&
162 : 0 : tmp_u < upper + GEOMETRY_RESABS)
163 : : {
164 : 0 : u = tmp_u;
165 : : }
166 : : }
167 : : }
168 : : // If the value of u was not adjusted because
169 : : // of a periodic curve go ahead and snap to
170 : : // the lower bound.
171 [ # # ]: 0 : if(u < lower)
172 : : {
173 : 0 : u = lower;
174 : : }
175 : : // Update the position we will return.
176 [ # # ]: 0 : position_from_u(u, closest);
177 : : }
178 : : // If we are past the high end...
179 [ # # ]: 0 : else if(u > upper)
180 : : {
181 : : // Adjust for periodic curve.
182 [ # # ]: 0 : if(is_per)
183 : : {
184 : 0 : double tmp_u = u;
185 [ # # ]: 0 : while(tmp_u > upper - GEOMETRY_RESABS)
186 : : {
187 : 0 : tmp_u -= period;
188 [ # # ][ # # ]: 0 : if(tmp_u > lower - GEOMETRY_RESABS &&
189 : 0 : tmp_u < upper + GEOMETRY_RESABS)
190 : : {
191 : 0 : u = tmp_u;
192 : : }
193 : : }
194 : : }
195 : : // If the value of u was not adjusted because
196 : : // of a periodic curve go ahead and snap to
197 : : // the upper bound.
198 [ # # ]: 0 : if(u > upper)
199 : : {
200 : 0 : u = upper;
201 : : }
202 : : // Update the position we will return.
203 [ # # ]: 0 : position_from_u(u, closest);
204 : : }
205 : : }
206 : :
207 [ # # ][ # # ]: 0 : if( result && tangent )
208 : : {
209 [ # # ][ # # ]: 0 : CubitVector start, end;
210 [ # # ][ # # ]: 0 : if( !position_from_u( start_param(), start ) ||
[ # # ][ # # ]
[ # # ]
211 [ # # ][ # # ]: 0 : !position_from_u( end_param(), end ) )
212 : 0 : return CUBIT_FAILURE;
213 : :
214 [ # # ][ # # ]: 0 : double ds = (start - from).length_squared();
215 [ # # ][ # # ]: 0 : double de = (end - from).length_squared();
216 : 0 : const double rsq = GEOMETRY_RESABS * GEOMETRY_RESABS;
217 [ # # ][ # # ]: 0 : if( ds < rsq && G1_discontinuous( u, &end, &start ) )
[ # # ][ # # ]
218 [ # # ]: 0 : *tangent = start;
219 [ # # ][ # # ]: 0 : else if( de < rsq && G1_discontinuous( u, &end, &start ) )
[ # # ][ # # ]
220 [ # # ]: 0 : *tangent = end;
221 : : }
222 : :
223 : 0 : return result;
224 : : }
225 : :
226 : 0 : CubitPointContainment SubCurve::point_containment( const CubitVector& point )
227 : : {
228 : 0 : CubitPointContainment cpc = real_curve()->point_containment( point );
229 [ # # ][ # # ]: 0 : if( (cpc == CUBIT_PNT_INSIDE) || (cpc == CUBIT_PNT_ON) ||
[ # # ]
230 : : (cpc == CUBIT_PNT_BOUNDARY) )
231 : : {
232 [ # # ][ # # ]: 0 : double u = real_curve()->u_from_position( point );
233 : : double lower, upper;
234 [ # # ]: 0 : get_ordered_param_range( lower, upper );
235 [ # # ][ # # ]: 0 : if( u < lower || u > upper )
236 : 0 : cpc = CUBIT_PNT_OFF;
237 : : }
238 : :
239 [ # # ][ # # ]: 0 : if( (cpc == CUBIT_PNT_INSIDE) || (cpc == CUBIT_PNT_ON) )
240 : : {
241 [ # # ][ # # ]: 0 : CubitVector start, end;
242 [ # # ][ # # ]: 0 : position_from_u( start_param(), start );
243 [ # # ][ # # ]: 0 : position_from_u( end_param(), end );
244 [ # # ][ # # ]: 0 : if( (point-start).length_squared() < GEOMETRY_RESABS*GEOMETRY_RESABS ||
[ # # ][ # # ]
[ # # ]
[ # # # # ]
245 [ # # ][ # # ]: 0 : (point-end ).length_squared() < GEOMETRY_RESABS*GEOMETRY_RESABS )
[ # # ][ # # ]
246 : : {
247 : 0 : cpc = CUBIT_PNT_BOUNDARY;
248 : : }
249 : : }
250 : :
251 : 0 : return cpc;
252 : : }
253 : :
254 : 0 : CubitBoolean SubCurve::is_position_on( const CubitVector& position )
255 : : {
256 : 0 : return real_curve()->is_position_on( position );
257 : : }
258 : :
259 : 0 : CubitBoolean SubCurve::G1_discontinuous( double param,
260 : : CubitVector* minus_tan,
261 : : CubitVector* plus_tan )
262 : : {
263 : : double lower, upper;
264 [ # # ]: 0 : get_ordered_param_range( lower, upper );
265 [ # # ][ # # ]: 0 : if( param <= lower || param >= upper )
266 : 0 : return CUBIT_FALSE;
267 : :
268 [ # # ][ # # ]: 0 : CubitVector pos, start, end;
[ # # ]
269 [ # # ][ # # ]: 0 : if( !position_from_u( lower, start ) ||
[ # # ]
270 [ # # ][ # # ]: 0 : !position_from_u( upper, end ) ||
[ # # ]
271 [ # # ]: 0 : !position_from_u( param, pos ) )
272 : 0 : assert(0);
273 : :
274 [ # # ][ # # ]: 0 : double ds = (pos - start).length_squared();
275 [ # # ][ # # ]: 0 : double de = (pos - end ).length_squared();
276 : 0 : const double grs = GEOMETRY_RESABS * GEOMETRY_RESABS;
277 [ # # ][ # # ]: 0 : if( ds < grs || de < grs )
278 : 0 : return CUBIT_FALSE;
279 : :
280 [ # # ][ # # ]: 0 : return real_curve()->G1_discontinuous( param, minus_tan, plus_tan );
281 : : }
282 : :
283 : 0 : CubitStatus SubCurve::get_interior_extrema( DLIList<CubitVector*>& points,
284 : : CubitSense& sense )
285 : : {
286 [ # # ][ # # ]: 0 : assert( !points.size() );
287 : :
288 : : double lower, upper;
289 [ # # ]: 0 : get_ordered_param_range( lower, upper );
290 : :
291 [ # # ][ # # ]: 0 : CubitVector start, end;
292 [ # # ][ # # ]: 0 : if( ! real_curve()->position_from_u( lower, start ) ||
[ # # ][ # # ]
[ # # ]
293 [ # # ][ # # ]: 0 : ! real_curve()->position_from_u( upper, end ) )
294 : 0 : return CUBIT_FAILURE;
295 : :
296 [ # # ]: 0 : DLIList<CubitVector*> list;
297 [ # # ][ # # ]: 0 : if( ! real_curve()->get_interior_extrema( list, sense ) )
[ # # ]
298 : 0 : return CUBIT_FAILURE;
299 [ # # ][ # # ]: 0 : if( list.size() == 0 )
300 : 0 : return CUBIT_SUCCESS;
301 : :
302 [ # # ]: 0 : list.last();
303 [ # # ][ # # ]: 0 : double param = real_curve()->u_from_position( *list.get() );
[ # # ]
304 [ # # ][ # # ]: 0 : while( (param <= lower) || (param >= upper) )
305 : : {
306 [ # # ]: 0 : delete list.pop();
307 [ # # ][ # # ]: 0 : if( list.size() == 0 )
308 : 0 : return CUBIT_SUCCESS;
309 [ # # ]: 0 : list.last();
310 [ # # ][ # # ]: 0 : param = real_curve()->u_from_position( *list.get() );
[ # # ]
311 : : }
312 : :
313 [ # # ][ # # ]: 0 : double ds = (*list.get() - start).length_squared();
[ # # ]
314 [ # # ][ # # ]: 0 : double de = (*list.get() = end ).length_squared();
[ # # ]
315 : 0 : const double grs = GEOMETRY_RESABS * GEOMETRY_RESABS;
316 [ # # ][ # # ]: 0 : if( ds < grs || de < grs )
317 : : {
318 [ # # ]: 0 : delete list.pop();
319 [ # # ][ # # ]: 0 : if( list.size() == 0 )
320 : 0 : return CUBIT_SUCCESS;
321 [ # # ]: 0 : list.last();
322 [ # # ][ # # ]: 0 : param = real_curve()->u_from_position( *list.get() );
[ # # ]
323 : : }
324 : :
325 [ # # ][ # # ]: 0 : while( (param > lower) && (param < upper) )
326 : : {
327 [ # # ][ # # ]: 0 : points.append( list.pop() );
328 [ # # ][ # # ]: 0 : if( list.size() == 0 )
329 : 0 : break;
330 [ # # ]: 0 : list.last();
331 [ # # ][ # # ]: 0 : param = real_curve()->u_from_position( *list.get() );
[ # # ]
332 : : }
333 : :
334 [ # # ][ # # ]: 0 : while( list.size() )
335 [ # # ]: 0 : delete list.pop();
336 : :
337 [ # # ]: 0 : if( sense == CUBIT_FORWARD )
338 : 0 : sense = CUBIT_REVERSED;
339 [ # # ]: 0 : else if( sense == CUBIT_REVERSED )
340 : 0 : sense = CUBIT_FORWARD;
341 : :
342 [ # # ]: 0 : return CUBIT_SUCCESS;
343 : : }
344 : :
345 : 0 : CubitStatus SubCurve::get_center_radius( CubitVector& center, double& radius )
346 : 0 : { return real_curve()->get_center_radius(center,radius); }
347 : :
348 : :
349 : 0 : CubitBoolean SubCurve::get_param_range( double& lower, double& upper )
350 : : {
351 : 0 : lower = startParam;
352 : 0 : upper = endParam;
353 : 0 : return CUBIT_TRUE;
354 : : }
355 : :
356 : 0 : CubitBoolean SubCurve::get_ordered_param_range( double& lower, double& upper )
357 : : {
358 [ # # ]: 0 : if( startParam < endParam )
359 : : {
360 : 0 : lower = startParam;
361 : 0 : upper = endParam;
362 : : }
363 : : else
364 : : {
365 : 0 : lower = endParam;
366 : 0 : upper = startParam;
367 : : }
368 : 0 : return CUBIT_TRUE;
369 : : }
370 : :
371 : 0 : double SubCurve::start_param()
372 : 0 : { return startParam; }
373 : 0 : double SubCurve::end_param()
374 : 0 : { return endParam; }
375 : :
376 : 0 : CubitBoolean SubCurve::is_periodic( double& period )
377 : : {
378 : 0 : return real_curve()->is_periodic( period );
379 : : }
380 : :
381 : 0 : double SubCurve::length_from_u( double u1, double u2 )
382 : : {
383 : 0 : return real_curve()->length_from_u( u1, u2 );
384 : : }
385 : :
386 : 0 : double SubCurve::u_from_position( const CubitVector& p )
387 : : {
388 [ # # ][ # # ]: 0 : double result = real_curve()->u_from_position( p );
389 [ # # ]: 0 : fixup_periodic_param(result);
390 : 0 : return result;
391 : : }
392 : :
393 : 0 : CubitStatus SubCurve::position_from_u( double u, CubitVector& p )
394 : : {
395 : 0 : return real_curve()->position_from_u( u, p );
396 : : }
397 : :
398 : 0 : double SubCurve::u_from_arc_length( double root, double length )
399 : : {
400 : 0 : return real_curve()->u_from_arc_length( root, length );
401 : : }
402 : :
403 : 0 : void SubCurve::fixup_periodic_param( double& param ) const
404 : : {
405 : : double period;
406 [ # # ][ # # ]: 0 : if( ! real_curve()->is_periodic(period) )
[ # # ]
407 : 0 : return;
408 : :
409 [ # # ]: 0 : assert(period > GEOMETRY_RESABS);
410 : : double start, end;
411 [ # # ]: 0 : if ( startParam < endParam ) {
412 : 0 : start = startParam;
413 : 0 : end = endParam;
414 : : } else {
415 : 0 : start = endParam;
416 : 0 : end = startParam;
417 : : }
418 : :
419 [ # # ]: 0 : if( fabs( start-param ) < GEOMETRY_RESABS )
420 : 0 : param = start;
421 [ # # ]: 0 : if( fabs( end-param ) < GEOMETRY_RESABS )
422 : 0 : param = end;
423 : :
424 [ # # ]: 0 : while ( param > end )
425 : 0 : param -= period;
426 [ # # ]: 0 : while ( param < start )
427 : 0 : param += period;
428 : : }
429 : :
430 : 0 : CubitStatus SubCurve::get_graphics( GMem& result,
431 : : double angle_tolerance,
432 : : double distance_tolerance,
433 : : double max_edge_length )
434 : : {
435 [ # # ][ # # ]: 0 : if (POINT_CURVE_TYPE == this->geometry_type())
436 : : {
437 : 0 : result.pointListCount = 0;
438 : 0 : return CUBIT_SUCCESS;
439 : : }
440 : :
441 : : int i;
442 [ # # ][ # # ]: 0 : if( !real_curve()->get_geometry_query_engine()->
[ # # ]
443 [ # # ][ # # ]: 0 : get_graphics( real_curve(), &result, angle_tolerance, distance_tolerance, max_edge_length ) )
444 : 0 : return CUBIT_FAILURE;
445 : :
446 [ # # ]: 0 : if (0 == result.pointListCount)
447 : 0 : return CUBIT_FAILURE;
448 : :
449 : : double lo, hi, start_param, end_param;
450 [ # # ]: 0 : get_ordered_param_range( lo, hi );
451 [ # # ]: 0 : get_param_range(start_param, end_param);
452 [ # # ]: 0 : DLIList<double> param_list( result.pointListCount );
453 : :
454 : : // don't use first and last points -- this avoids projection
455 : : // close to a seam on a periodic curve. The projection can
456 : : // jump the seam and cause endpoints of the curve to incorrectly
457 : : // fall inside the parameter range causing extra segments to be drawn
458 [ # # ]: 0 : for( i = 1; i < result.pointListCount-1; i++ )
459 : : {
460 [ # # ]: 0 : CubitVector v( result.point_list()[i].x,
461 [ # # ]: 0 : result.point_list()[i].y,
462 [ # # ][ # # ]: 0 : result.point_list()[i].z );
463 [ # # ][ # # ]: 0 : double u = real_curve()->u_from_position( v );
464 [ # # ][ # # ]: 0 : if( (u >= lo) && (u <= hi) )
465 [ # # ]: 0 : param_list.append( u );
466 : : }
467 : :
468 [ # # ][ # # ]: 0 : CubitVector start_pt, end_pt;
469 [ # # ]: 0 : position_from_u( start_param, start_pt );
470 [ # # ]: 0 : position_from_u( end_param, end_pt );
471 : :
472 : 0 : bool append_start = true, append_end = true;
473 [ # # ][ # # ]: 0 : if( param_list.size() > 0 )
474 : : {
475 [ # # ][ # # ]: 0 : CubitVector first_pt, last_pt;
476 [ # # ]: 0 : param_list.last();
477 [ # # ][ # # ]: 0 : position_from_u( param_list.get(), last_pt );
478 [ # # ]: 0 : param_list.reset();
479 [ # # ][ # # ]: 0 : position_from_u( param_list.get(), first_pt );
480 : :
481 [ # # ][ # # ]: 0 : double d1 = (start_pt - first_pt).length_squared();
482 [ # # ][ # # ]: 0 : double d2 = (start_pt - last_pt ).length_squared();
483 [ # # ][ # # ]: 0 : double d4 = ( end_pt - first_pt).length_squared();
484 [ # # ][ # # ]: 0 : double d3 = ( end_pt - last_pt ).length_squared();
485 : 0 : double forward = d1 + d3;
486 : 0 : double reverse = d2 + d4;
487 [ # # ]: 0 : if( reverse < forward )
488 : : {
489 [ # # ]: 0 : CubitVector tmp( start_pt );
490 [ # # ]: 0 : start_pt = end_pt;
491 [ # # ]: 0 : end_pt = tmp;
492 : 0 : d1 = d2;
493 : 0 : d3 = d4;
494 : : }
495 : :
496 [ # # ]: 0 : if( d1 < (GEOMETRY_RESABS*GEOMETRY_RESABS) )
497 : 0 : append_start = false;
498 [ # # ]: 0 : if( d3 < (GEOMETRY_RESABS*GEOMETRY_RESABS) )
499 : 0 : append_end = false;
500 : : }
501 : :
502 : 0 : int index = 0;
503 [ # # ][ # # ]: 0 : result.allocate_polylines( param_list.size() + 1 );
504 : :
505 [ # # ]: 0 : if( append_start )
506 : : {
507 [ # # ][ # # ]: 0 : result.point_list()[index].x = (float)(start_pt.x());
508 [ # # ][ # # ]: 0 : result.point_list()[index].y = (float)(start_pt.y());
509 [ # # ][ # # ]: 0 : result.point_list()[index].z = (float)(start_pt.z());
510 : 0 : index++;
511 : : }
512 : :
513 [ # # ]: 0 : param_list.reset();
514 [ # # ]: 0 : CubitVector position;
515 [ # # ][ # # ]: 0 : for( i = param_list.size(); i--; )
516 : : {
517 [ # # ][ # # ]: 0 : position_from_u( param_list.get_and_step(), position );
518 [ # # ][ # # ]: 0 : result.point_list()[index].x = (float)(position.x());
519 [ # # ][ # # ]: 0 : result.point_list()[index].y = (float)(position.y());
520 [ # # ][ # # ]: 0 : result.point_list()[index].z = (float)(position.z());
521 : 0 : index++;
522 : : }
523 : :
524 [ # # ]: 0 : if( append_end )
525 : : {
526 [ # # ][ # # ]: 0 : result.point_list()[index].x = (float)(end_pt.x());
527 [ # # ][ # # ]: 0 : result.point_list()[index].y = (float)(end_pt.y());
528 [ # # ][ # # ]: 0 : result.point_list()[index].z = (float)(end_pt.z());
529 : 0 : index++;
530 : : }
531 : :
532 : 0 : result.pointListCount = index;
533 [ # # ]: 0 : return CUBIT_SUCCESS;
534 : : }
535 : :
536 : :
537 : 0 : void SubCurve::reverse_sense()
538 : : {
539 : 0 : reverse_point_order();
540 [ # # ]: 0 : if( owner() )
541 : 0 : owner()->notify_reversed(this);
542 : 0 : }
543 : :
544 : 0 : CubitStatus SubCurve::save( CubitSimpleAttrib& attrib )
545 : : {
546 [ # # ][ # # ]: 0 : int id = sub_entity_set().get_id(this);
547 [ # # ]: 0 : if( id <= 0 ) return CUBIT_FAILURE;
548 : :
549 [ # # ]: 0 : DLIList<int> end_points(4);
550 [ # # ]: 0 : get_save_topology(end_points);
551 : :
552 [ # # ][ # # ]: 0 : return sub_entity_set().save_geometry( id, 1, 0, 0, &end_points, 0, attrib );
[ # # ]
553 : : }
554 : :
555 : 0 : CubitStatus SubCurve::get_spline_params
556 : : (
557 : : bool &rational, // return true/false
558 : : int °ree, // the degree of this spline
559 : : DLIList<CubitVector> &cntrl_pts, // xyz position of controlpoints
560 : : DLIList<double> &cntrl_pt_weights, // if rational, a weight for each cntrl point.
561 : : DLIList<double> &knots, // There should be order+cntrl_pts.size()-2 knots
562 : : bool &spline_is_reversed
563 : : ) const
564 : : {
565 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine spline parameters for SubCurves.\n");
566 : 0 : return CUBIT_FAILURE;
567 : : }
568 : :
569 : 0 : CubitStatus SubCurve::get_ellipse_params
570 : : (
571 : : CubitVector ¢er_vec,
572 : : CubitVector &normal,
573 : : CubitVector &major_axis,
574 : : double &radius_ratio
575 : : ) const
576 : : {
577 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine ellipse parameters for SubCurves.\n");
578 : 0 : return CUBIT_FAILURE;
579 [ + - ][ + - ]: 6364 : }
|
