Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : FacetCurve.cpp
3 : : //
4 : : // Purpose :
5 : : //
6 : : // Special Notes :
7 : : //
8 : : // Creator : Steven J. Owen
9 : : //
10 : : // Creation Date : 07/14/00
11 : : //
12 : : // Owner : Steven J. Owen
13 : : //-------------------------------------------------------------------------
14 : :
15 : : // ********** BEGIN STANDARD INCLUDES **********
16 : :
17 : : // ********** END STANDARD INCLUDES **********
18 : :
19 : : // ********** BEGIN CUBIT INCLUDES **********
20 : :
21 : : #include "CastTo.hpp"
22 : : #include "CubitVector.hpp"
23 : : #include "CubitBox.hpp"
24 : : #include "GeometryDefines.h"
25 : : #include "FacetCurve.hpp"
26 : : #include "FacetAttrib.hpp"
27 : : #include "FacetEvalTool.hpp"
28 : : #include "CurveFacetEvalTool.hpp"
29 : : #include "GeometryQueryEngine.hpp"
30 : : #include "FacetQueryEngine.hpp"
31 : : #include "CoEdgeSM.hpp"
32 : : #include "CubitPoint.hpp"
33 : :
34 : : #include "FacetBody.hpp"
35 : : #include "FacetLump.hpp"
36 : : #include "FacetShell.hpp"
37 : : #include "FacetSurface.hpp"
38 : : #include "FacetLoop.hpp"
39 : : #include "FacetCoEdge.hpp"
40 : : #include "FacetPoint.hpp"
41 : :
42 : : // ********** END CUBIT INCLUDES **********
43 : :
44 : : // ********** BEGIN FORWARD DECLARATIONS **********
45 : : // ********** END FORWARD DECLARATIONS **********
46 : :
47 : : // ********** BEGIN STATIC DECLARATIONS **********
48 : : // ********** END STATIC DECLARATIONS **********
49 : :
50 : : // ********** BEGIN PUBLIC FUNCTIONS **********
51 : :
52 : : //-------------------------------------------------------------------------
53 : : // Purpose : The default constructor
54 : : //
55 : : // Special Notes :
56 : : //
57 : : // Creator: : Steve Owen
58 : : //
59 : : // Creation Date : 07/14/00
60 : : //-------------------------------------------------------------------------
61 : 594 : FacetCurve::FacetCurve(CurveFacetEvalTool *curve_facet_tool,
62 : : TBPoint *start_ptr, TBPoint *end_ptr,
63 : : DLIList<CoEdgeSM*> &coedge_list )
64 [ + - ][ + - ]: 594 : : sense_(CUBIT_FORWARD)
65 : : {
66 : : static int counter = 0;
67 : 594 : myId = counter++;
68 : : // Calculate a bounding box if there isn't one already
69 : 594 : curveFacetEvalTool = curve_facet_tool;
70 : 594 : myStartPoint = start_ptr;
71 : 594 : myEndPoint = end_ptr;
72 [ + - ]: 594 : myCoEdges += coedge_list;
73 : 594 : periodic = start_ptr == end_ptr;
74 : 594 : }
75 : :
76 : : //-------------------------------------------------------------------------
77 : : // Purpose : Another constructor
78 : : //
79 : : // Special Notes : Implemented for save/restore
80 : : //
81 : : // Creator: : Corey Ernst
82 : : //
83 : : // Creation Date : 02/03/03
84 : : //-------------------------------------------------------------------------
85 : 264 : FacetCurve::FacetCurve(CurveFacetEvalTool *curve_facet_tool,
86 : : TBPoint *start_ptr, TBPoint *end_ptr,
87 [ + - ][ + - ]: 264 : CubitSense sense )
88 : : {
89 : : static int counter = 0;
90 : 264 : myId = counter++;
91 : : // Calculate a bounding box if there isn't one already
92 : 264 : curveFacetEvalTool = curve_facet_tool;
93 : 264 : myStartPoint = start_ptr;
94 : 264 : myEndPoint = end_ptr;
95 : 264 : periodic = start_ptr == end_ptr;
96 : 264 : sense_ = sense;
97 : 264 : }
98 : : //-------------------------------------------------------------------------
99 : : // Purpose : The destructor.
100 : : //
101 : : // Special Notes :
102 : : //
103 : : // Creator : Steve Owen
104 : : //
105 : : // Creation Date : 07/14/00
106 : : //-------------------------------------------------------------------------
107 [ # # ][ # # ]: 0 : FacetCurve::~FacetCurve()
108 : : {
109 [ # # ]: 0 : if(this->curveFacetEvalTool)
110 [ # # ][ # # ]: 0 : delete this->curveFacetEvalTool;
111 : :
112 [ # # ]: 0 : }
113 : :
114 : : //-------------------------------------------------------------------------
115 : : // Purpose : The purpose of this function is to append a
116 : : // attribute to the GE. The name is attached to the
117 : : // underlying solid model entity this one points to.
118 : : //
119 : : //
120 : : // Special Notes :
121 : : //
122 : : // Creator : Steve Owen
123 : : //
124 : : // Creation Date : 07/14/00
125 : : //-------------------------------------------------------------------------
126 : 704 : void FacetCurve::append_simple_attribute_virt(const CubitSimpleAttrib &csa)
127 : 704 : { attribSet.append_attribute(csa); }
128 : :
129 : : //-------------------------------------------------------------------------
130 : : // Purpose : The purpose of this function is to remove a simple
131 : : // attribute attached to this geometry entity. The name is
132 : : // removed from the underlying BODY this points to.
133 : : //
134 : : // Special Notes :
135 : : //
136 : : // Creator : Steve Owen
137 : : //
138 : : // Creation Date : 07/14/00
139 : : //-------------------------------------------------------------------------
140 : 4664 : void FacetCurve::remove_simple_attribute_virt(const CubitSimpleAttrib &csa)
141 : 4664 : { attribSet.remove_attribute(csa); }
142 : :
143 : : //-------------------------------------------------------------------------
144 : : // Purpose : The purpose of this function is to remove all simple
145 : : // attributes attached to this geometry entity. Also
146 : : // removes lingering GTC attributes.
147 : : //
148 : : //
149 : : // Special Notes :
150 : : //
151 : : // Creator : Steve Owen
152 : : //
153 : : // Creation Date : 07/14/00
154 : : //-------------------------------------------------------------------------
155 : 1518 : void FacetCurve::remove_all_simple_attribute_virt()
156 : 1518 : { attribSet.remove_all_attributes(); }
157 : :
158 : : //-------------------------------------------------------------------------
159 : : // Purpose : The purpose of this function is to get the
160 : : // attributes attached to this geometry entity. The name is
161 : : // attached to the underlying BODY this points to.
162 : : //
163 : : // Special Notes :
164 : : //
165 : : // Creator : Steve Owen
166 : : //
167 : : // Creation Date : 07/14/00
168 : : //-------------------------------------------------------------------------
169 : 814 : CubitStatus FacetCurve::get_simple_attribute(DLIList<CubitSimpleAttrib>&
170 : : csa_list)
171 : 814 : { return attribSet.get_attributes(csa_list); }
172 : :
173 : 5456 : CubitStatus FacetCurve::get_simple_attribute( const CubitString& name,
174 : : DLIList<CubitSimpleAttrib>& csa_list)
175 : 5456 : { return attribSet.get_attributes( name, csa_list ); }
176 : :
177 : :
178 : 462 : CubitStatus FacetCurve::save_attribs( FILE *file_ptr )
179 : 462 : { return attribSet.save_attributes(file_ptr); }
180 : :
181 : 264 : CubitStatus FacetCurve::restore_attribs( FILE *file_ptr, unsigned int endian )
182 : 264 : { return attribSet.restore_attributes(file_ptr, endian); }
183 : :
184 : :
185 : :
186 : : //-------------------------------------------------------------------------
187 : : // Purpose : Get geometry modeling engine: FacetQueryEngine
188 : : //
189 : : // Special Notes :
190 : : //
191 : : // Creator : Steve Owen
192 : : //
193 : : // Creation Date : 07/14/00
194 : : //-------------------------------------------------------------------------
195 : 0 : GeometryQueryEngine* FacetCurve::get_geometry_query_engine() const
196 : : {
197 : 0 : return FacetQueryEngine::instance();
198 : : }
199 : :
200 : : //-------------------------------------------------------------------------
201 : : // Purpose : Get the bounding box of the object.
202 : : //
203 : : // Special Notes :
204 : : //
205 : : // Creator : Steve Owen
206 : : //
207 : : // Creation Date : 10/23/96
208 : : //-------------------------------------------------------------------------
209 : 539 : CubitBox FacetCurve::bounding_box() const
210 : : {
211 : 539 : return curveFacetEvalTool->bounding_box();
212 : : }
213 : :
214 : :
215 : : //-------------------------------------------------------------------------
216 : : // Purpose : Return the length of the curve.
217 : : //
218 : : // Special Notes :
219 : : //
220 : : // Creator : Steve Owen
221 : : //
222 : : // Creation Date : 07/14/00
223 : : //-------------------------------------------------------------------------
224 : 1078 : double FacetCurve::measure()
225 : : {
226 : 1078 : return curveFacetEvalTool->length();
227 : : }
228 : :
229 : : //-------------------------------------------------------------------------
230 : : // Purpose : Return the arc length along the Curve starting from
231 : : // the point represented by the parameter1 going to the
232 : : // point represented by parameter2.
233 : : //
234 : : // Special Notes : Parameter1 and parameter2 are with respect to the EDGE.
235 : : //
236 : : // Creator : Steve Owen
237 : : //
238 : : // Creation Date : 07/14/00
239 : : //-------------------------------------------------------------------------
240 : 0 : double FacetCurve::length_from_u( double parameter1, double parameter2 )
241 : : {
242 : :
243 : : //Don't perform the periodic adjustment so that
244 : : // this function will satisfy the properties of
245 : : // the function as defined in RefEdge.hpp.
246 : : // Also, take the fabs of the arc length for the same reason.
247 : : //if( periodic )
248 : : //{
249 : : // adjust_periodic_parameter( parameter1 );
250 : : // adjust_periodic_parameter( parameter2 );
251 : : //}
252 : 0 : return curveFacetEvalTool->length_from_u( parameter1, parameter2 );
253 : : }
254 : :
255 : : //-------------------------------------------------------------------------
256 : : // Purpose : Returns CUBIT_TRUE and the associated period value. Not
257 : : // implemented yet
258 : : //
259 : : // Special Notes :
260 : : //
261 : : // Creator : Steve Owen
262 : : //
263 : : // Creation Date : 07/14/00
264 : : //-------------------------------------------------------------------------
265 : 6820 : CubitBoolean FacetCurve::is_periodic(double& period)
266 : : {
267 [ - + ]: 6820 : if( periodic )
268 : : {
269 : 0 : period = 1.0;
270 : 0 : return CUBIT_TRUE;
271 : : }
272 : 6820 : return CUBIT_FALSE;
273 : : }
274 : :
275 : : //------------------------------------------------------------------
276 : : // Purpose: Returns CUBIT_TRUE and the associated parametric values,
277 : : // if the facet curve associated with the first EDGE is
278 : : // parametric.
279 : : // Otherwise returns CUBIT_FALSE and the values of
280 : : // the lower and upper parametric bounds are undetermined.
281 : : // NOT IMPLEMENTED YET
282 : : //
283 : : // Creator : Steve Owen
284 : : //
285 : : // Creation Date : 07/14/00
286 : : //-------------------------------------------------------------------
287 : 24882 : CubitBoolean FacetCurve::get_param_range( double& lower_bound,
288 : : double& upper_bound )
289 : : {
290 : 24882 : lower_bound = 0.0;
291 : 24882 : upper_bound = 1.0;
292 : 24882 : return CUBIT_TRUE;
293 : : }
294 : :
295 : : //------------------------------------------------------------------
296 : : // Purpose: Finds the extrema along this Curve.
297 : : //
298 : : // Special Notes : It is the responsibility of the
299 : : // calling code to delete the CubitVectors added to
300 : : // interior_points!
301 : : //
302 : : // Creator : Jason Kraftcheck
303 : : //
304 : : // Creation Date : 05/29/01
305 : : //-------------------------------------------------------------------
306 : 0 : CubitStatus FacetCurve::get_interior_extrema(
307 : : DLIList<CubitVector*>& interior_points,
308 : : CubitSense& return_sense )
309 : : {
310 : : // Need curveFacetEvalTool to get point list
311 [ # # ]: 0 : if( ! curveFacetEvalTool )
312 : 0 : return CUBIT_FAILURE;
313 : :
314 : : // Get list of points defining this curve
315 [ # # ]: 0 : DLIList<CubitPoint*> point_list;
316 [ # # ]: 0 : get_points( point_list );
317 : :
318 : : // If there are only 2 points, then the curve is a line and there
319 : : // are no interior extrema
320 [ # # ][ # # ]: 0 : if( point_list.size() < 3 )
321 : 0 : return CUBIT_SUCCESS;
322 : :
323 : : // Return sense is whatever the sense of this curve is.
324 : 0 : return_sense = sense_;
325 : :
326 : : // Get a vector between the first two points
327 [ # # ]: 0 : point_list.reset();
328 [ # # ][ # # ]: 0 : CubitVector prev_pt = point_list.get_and_step()->coordinates();
329 [ # # ][ # # ]: 0 : CubitVector curr_pt = point_list.get_and_step()->coordinates();
330 [ # # ]: 0 : CubitVector prev_vct = curr_pt - prev_pt;
331 [ # # ]: 0 : CubitVector next_vct;
332 : :
333 [ # # ][ # # ]: 0 : for( int i = point_list.size(); i > 2; i-- )
334 : : {
335 : : // Get a vector between the next two points
336 [ # # ][ # # ]: 0 : next_vct = point_list.get()->coordinates() - curr_pt;
[ # # ][ # # ]
337 : :
338 : : // In Curve::get_interior_extrema, the extrema seem to
339 : : // be evaluated with respect to the principle axes, so do
340 : : // the same here. The extrema are points at which the
341 : : // derivitive in the specified direction (principle axis)
342 : : // is zero. So look for a sign change in the slope across
343 : : // a point wrt each principle direction.
344 [ # # ][ # # ]: 0 : if( (prev_vct.x() * next_vct.x() < 0.) || // x extrema
[ # # ][ # # ]
345 [ # # ][ # # ]: 0 : (prev_vct.y() * next_vct.y() < 0.) || // y extrema
[ # # ][ # # ]
346 [ # # ][ # # ]: 0 : (prev_vct.z() * next_vct.z() < 0.) ) // z extrema
347 [ # # ][ # # ]: 0 : interior_points.append( new CubitVector( curr_pt ) );
[ # # ]
348 : :
349 : : // Advance to next point.
350 [ # # ]: 0 : prev_vct = next_vct;
351 [ # # ][ # # ]: 0 : curr_pt = point_list.get_and_step()->coordinates();
[ # # ]
352 : : }
353 : :
354 [ # # ]: 0 : return CUBIT_SUCCESS;
355 : : }
356 : :
357 : : //-------------------------------------------------------------------------
358 : : // Purpose : This function computes the point on the curve closest
359 : : // to the input location. Optionally, it can also compute
360 : : // the tangent and curvature on the Curve at the point on
361 : : // on the Curve closest to the input location.
362 : : //
363 : : // Special Notes : The tangent direction is always in the positive direction of the
364 : : // owning RefEdge, regardless of the positive direction of the
365 : : // underlying solid model entities.
366 : : //
367 : : // If the calling code needs the tangent and/or the curvature,
368 : : // it is responsible for allocating the memory for these
369 : : // CubitVector(s) and sending in the relevant non-NULL
370 : : // pointers to this routine.
371 : : //
372 : : // Creator : Steve Owen
373 : : //
374 : : // Creation Date : 07/14/00
375 : : //-------------------------------------------------------------------------
376 : 3740 : CubitStatus FacetCurve::closest_point(
377 : : CubitVector const& location,
378 : : CubitVector& closest_location,
379 : : CubitVector* tangent_ptr,
380 : : CubitVector* curvature_ptr,
381 : : double* param)
382 : : {
383 : : // Only the closest point is required
384 [ + + ][ + - ]: 3740 : if (tangent_ptr == NULL && curvature_ptr == NULL)
385 : : {
386 [ + - ]: 3410 : CubitVector temp = location;
387 : : curveFacetEvalTool->closest_point( temp,
388 [ + - ]: 3410 : closest_location, NULL, NULL, param );
389 : : }
390 : :
391 : : // The closest point and the tangent are required
392 [ + - ][ + - ]: 330 : else if (tangent_ptr != NULL && curvature_ptr == NULL)
393 : : {
394 [ + - ]: 330 : CubitVector temp = location;
395 [ + - ]: 330 : curveFacetEvalTool->closest_point( temp, closest_location, tangent_ptr, NULL, param );
396 : : }
397 : :
398 : : // Everything is required
399 : : // NOTE: If the curvature is required but not the tangent, the tangent,
400 : : // too, will be computed.
401 : : else
402 : : {
403 [ # # ]: 0 : CubitVector temp = location;
404 [ # # ]: 0 : curveFacetEvalTool->closest_point( temp, closest_location, tangent_ptr, curvature_ptr, param );
405 : : }
406 : :
407 [ + + ]: 3740 : if (tangent_ptr != NULL)
408 : : {
409 [ - + ]: 330 : if (sense_ == CUBIT_REVERSED)
410 [ # # ]: 0 : *tangent_ptr = -(*tangent_ptr);
411 : : }
412 : :
413 : : // Set the curvature, if necessary
414 [ - + ]: 3740 : if (curvature_ptr != NULL)
415 : : {
416 : : // get the sense wrt the curve, consists of 2 sense values
417 [ # # ]: 0 : if (sense_ == CUBIT_REVERSED)
418 [ # # ]: 0 : *curvature_ptr = -(*curvature_ptr);
419 : : }
420 : :
421 [ + + ]: 3740 : if (param != NULL)
422 : : {
423 : 3410 : adjust_periodic_parameter(*param);
424 : : }
425 : :
426 : 3740 : return CUBIT_SUCCESS;
427 : : }
428 : :
429 : :
430 : : //------------------------------------------------------------------
431 : : // Purpose: This function returns the coordinate of a point in the local
432 : : // parametric (u) space that corresponds to the input position
433 : : // in global (world) space. The input point is first moved to
434 : : // the closest point on the Curve and the parameter value of
435 : : // that point is determined.
436 : : //
437 : : // Creator : Steve Owen
438 : : //
439 : : // Creation Date : 07/14/00
440 : : //-------------------------------------------------------------------
441 : 10802 : CubitStatus FacetCurve::position_from_u (double u_value,
442 : : CubitVector& output_position)
443 : : {
444 : :
445 : 10802 : CubitStatus status = CUBIT_SUCCESS;
446 : :
447 : : // Get the parameter range of this Curve
448 : : double lower_bound, upper_bound;
449 [ + - ]: 10802 : this->get_param_range( lower_bound, upper_bound );
450 : 10802 : double param_interval = upper_bound - lower_bound;
451 : :
452 : : // Make sure the requested u_value is either within the range or, if
453 : : // the Curve is periodic, then reduce the input value down to the
454 : : // fundamental range
455 [ + - ][ - + ]: 10802 : if (u_value > upper_bound || u_value < lower_bound)
456 : : {
457 [ # # ]: 0 : adjust_periodic_parameter(u_value);
458 : : }
459 : :
460 : : // Now that we have a "valid" parameter value, get its global location
461 : : // on the Curve
462 : :
463 : : // Now we assume that the u_value is with respect to the
464 : : // EDGE, we must switch it according the the EDGE->curve sense.
465 : :
466 [ - + ]: 10802 : if (sense_ == CUBIT_REVERSED)
467 : : {
468 : 0 : u_value = -(u_value);
469 : : }
470 : : //now the u_value is with respect to curve so we are safe in
471 : : //passing this parameter for evaluation on the curve.
472 : :
473 : 10802 : double fraction = (u_value - lower_bound) / param_interval;
474 [ + - ]: 10802 : status = curveFacetEvalTool->position_from_fraction( fraction, output_position );
475 : :
476 : 10802 : return status;
477 : : }
478 : :
479 : : //-------------------------------------------------------------------------
480 : : // Purpose : This function returns the coordinate of a point in the local
481 : : // parametric (u) space that corresponds to the input position
482 : : // in global (world) space. The input point is first moved to
483 : : // the closest point on the Curve and the parameter value of
484 : : // that point is determined.
485 : : //
486 : : // Special Notes :
487 : : //
488 : : // Creator : Malcolm J. Panthaki
489 : : //
490 : : // Creation Date : 2/25/97
491 : : //-------------------------------------------------------------------------
492 : 0 : double FacetCurve::u_from_position (const CubitVector& input_position)
493 : : {
494 : : // Get the closest point on the Curve to the input position
495 [ # # ]: 0 : CubitVector closest_point;
496 : : double u_val;
497 : : this->closest_point(input_position, closest_point,
498 [ # # ]: 0 : NULL, NULL, &u_val);
499 : : // closest_point already makes adjustments for sense and periodicity
500 : :
501 : 0 : return u_val;
502 : : }
503 : :
504 : : //------------------------------------------------------------------
505 : : // Purpose: This function returns the parameter value of the point
506 : : // that is "arc_length" away from the root point, in the
507 : : // positive sense direction of the owning RefEdge.
508 : : //
509 : : // Special Notes :
510 : : // If arc_length is negative, the new point (whose parameter value
511 : : // is being computed) is in the negative sense direction (along
512 : : // the RefEdge) from the root point (whose parameter value is
513 : : // root_param).
514 : : //
515 : : // If the curve is not periodic and the new point, "arc_length"
516 : : // away from the root point in the appropriate direction, goes
517 : : // beyond the end point of the first EDGE, that end point is used
518 : : // to generate the returned parameter value.
519 : : //
520 : : // If the curve is periodic and the new point, "arc_length" away
521 : : // from the root point in the appropriate direction, goes beyond
522 : : // the end point of the first EDGE, wrap around is done. After
523 : : // wrap around, the point is treated as with other curves
524 : : //
525 : : // NOTE:
526 : : // The important assumption that is made in this routine is that
527 : : // the end points of the RefEdge that owns this Curve are the
528 : : // same as the end points of the first EDGE in the list of EDGEs
529 : : // associated with this Curve.
530 : : //
531 : : // Assume that the parameter root_param is with respect to the
532 : : // RefEdge as well as arc_length. Before calling the "curve",
533 : : // we need to get them with respect to the curve.
534 : : //
535 : : // Creator : Malcolm J. Panthaki
536 : : //
537 : : // Creation Date : 2/28/97
538 : : //------------------------------------------------------------------
539 : 264 : double FacetCurve::u_from_arc_length ( double root_param,
540 : : double arc_length )
541 : : {
542 : :
543 [ - + ]: 264 : if (!curveFacetEvalTool)
544 : : {
545 [ # # ][ # # ]: 0 : PRINT_ERROR("curve facet evaluation tool not defined in FacetCurve::u_from_arc_length\n");
546 : 0 : return 0.0;
547 : : }
548 : 264 : return curveFacetEvalTool->u_from_arc_length( root_param, arc_length );
549 : :
550 : : }
551 : :
552 : : //-------------------------------------------------------------------------
553 : : // Purpose : This function tests the passed in position to see if
554 : : // is on the underlying curve.
555 : : //
556 : : // Special Notes :
557 : : //
558 : : // Creator : Steve Owen
559 : : //
560 : : // Creation Date : 07/14/00
561 : : //-------------------------------------------------------------------------
562 : 0 : CubitBoolean FacetCurve::is_position_on( const CubitVector &test_position )
563 : : {
564 [ # # ]: 0 : CubitVector new_point;
565 [ # # ]: 0 : CubitStatus stat = closest_point(test_position, new_point, NULL,NULL,NULL);
566 : :
567 [ # # ]: 0 : if ( !stat )
568 : 0 : return CUBIT_FALSE;
569 [ # # ]: 0 : CubitVector result_vec = test_position - new_point;
570 [ # # ][ # # ]: 0 : if ( result_vec.length_squared() < GEOMETRY_RESABS )
571 : 0 : return CUBIT_TRUE;
572 : 0 : return CUBIT_FALSE;
573 : : }
574 : :
575 : : //-------------------------------------------------------------------------
576 : : // Purpose : This function returns the type of underlying curve.
577 : : //
578 : : // Special Notes : It checks to see if *any* of the curves associated
579 : : // with the EDGEs in the list of EDGEs of this Curve is of
580 : : // a particular type and returns the appropriate value
581 : : // of the enum, CurveType.
582 : : //
583 : : // Creator : Steve Owen
584 : : //
585 : : // Creation Date : 07/14/00
586 : : //-------------------------------------------------------------------------
587 : 352 : GeometryType FacetCurve::geometry_type()
588 : : {
589 : 352 : return SEGMENTED_CURVE_TYPE;
590 : : }
591 : :
592 : : //-------------------------------------------------------------------------
593 : : // Purpose : Return direction of point on curve
594 : : //
595 : : // Special Notes : not currently implemented
596 : : //
597 : : // Creator : Steve Owen
598 : : //
599 : : // Creation Date : 07/14/00
600 : : //-------------------------------------------------------------------------
601 : 0 : CubitStatus FacetCurve::get_point_direction( CubitVector& point,
602 : : CubitVector& direction )
603 : : {
604 : 0 : point = point;
605 : 0 : direction = direction;
606 [ # # ][ # # ]: 0 : PRINT_DEBUG_122("FacetCurve::get_point_direction currently not implemented.\n");
[ # # ]
607 : 0 : return CUBIT_FAILURE;
608 : : }
609 : :
610 : : //-------------------------------------------------------------------------
611 : : // Purpose : Return the center and radius of an arc
612 : : //
613 : : // Special Notes : not currently implemented
614 : : //
615 : : // Creator : Steve Owen
616 : : //
617 : : // Creation Date : 07/14/00
618 : : //-------------------------------------------------------------------------
619 : 0 : CubitStatus FacetCurve::get_center_radius( CubitVector& /* center */,
620 : : double& /* radius */ )
621 : : {
622 [ # # ][ # # ]: 0 : PRINT_DEBUG_122("FacetCurve::get_center_radius currently not implemented.\n");
[ # # ]
623 : 0 : return CUBIT_FAILURE;
624 : : }
625 : :
626 : : //-------------------------------------------------------------------------
627 : : // Purpose : This function returns the start parameter.
628 : : //
629 : : // Special Notes : The start param is with respect to the ref_edge.
630 : : //
631 : : // Creator : Steve Owen
632 : : //
633 : : // Creation Date : 07/14/00
634 : : //-------------------------------------------------------------------------
635 : 7084 : double FacetCurve::start_param()
636 : : {
637 : 7084 : double start = 0.0, end = 0.0;
638 : :
639 [ + - ]: 7084 : get_param_range( start, end );
640 : 7084 : return start;
641 : : }
642 : :
643 : : //-------------------------------------------------------------------------
644 : : // Purpose : This function returns the end parameter.
645 : : //
646 : : // Special Notes : The end param is with respect to the ref_edge.
647 : : //
648 : : // Creator : Steve Owen
649 : : //
650 : : // Creation Date : 07/14/00
651 : : //-------------------------------------------------------------------------
652 : 3410 : double FacetCurve::end_param()
653 : : {
654 : 3410 : double start = 0.0, end = 0.0;
655 : :
656 [ + - ]: 3410 : get_param_range( start, end );
657 : 3410 : return end;
658 : : }
659 : :
660 : : /*
661 : : void FacetCurve::bodysms(DLIList<BodySM*> &bodies)
662 : : {
663 : : int ii;
664 : : for ( ii = myCoEdges.size(); ii > 0; ii-- )
665 : : {
666 : : myCoEdges.get_and_step()->bodysms(bodies);
667 : : }
668 : : }
669 : :
670 : : void FacetCurve::lumps(DLIList<Lump*> &lumps)
671 : : {
672 : : int ii;
673 : : for ( ii = myCoEdges.size(); ii > 0; ii-- )
674 : : {
675 : : myCoEdges.get_and_step()->lumps(lumps);
676 : : }
677 : : }
678 : :
679 : : void FacetCurve::shellsms(DLIList<ShellSM*> &shellsms)
680 : : {
681 : : int ii;
682 : : for ( ii = myCoEdges.size(); ii > 0; ii-- )
683 : : {
684 : : myCoEdges.get_and_step()->shellsms(shellsms);
685 : : }
686 : : }
687 : :
688 : : void FacetCurve::surfaces(DLIList<Surface*> &surfaces)
689 : : {
690 : : int ii;
691 : : for ( ii = myCoEdges.size(); ii > 0; ii-- )
692 : : {
693 : : myCoEdges.get_and_step()->surfaces(surfaces);
694 : : }
695 : : }
696 : :
697 : : void FacetCurve::loopsms(DLIList<LoopSM*> &loopsms)
698 : : {
699 : : int ii;
700 : : for ( ii = myCoEdges.size(); ii > 0; ii-- )
701 : : {
702 : : myCoEdges.get_and_step()->loopsms(loopsms);
703 : : }
704 : : }
705 : :
706 : :
707 : : void FacetCurve::coedgesms(DLIList<CoEdgeSM*> &coedgesms)
708 : : {
709 : : int ii;
710 : : for ( ii = myCoEdges.size(); ii > 0; ii-- )
711 : : {
712 : : coedgesms.append_unique( myCoEdges.get_and_step() );
713 : : }
714 : : }
715 : :
716 : : void FacetCurve::curves(DLIList<Curve*> &curves)
717 : : {
718 : : curves.append_unique( this );
719 : : }
720 : :
721 : : void FacetCurve::points(DLIList<TBPoint*> &points)
722 : : {
723 : : points.append_unique( myStartPoint );
724 : : points.append_unique( myEndPoint );
725 : : }
726 : : */
727 : :
728 : :
729 : 374 : void FacetCurve::get_parents_virt( DLIList<TopologyBridge*>& parents )
730 [ + - ][ + + ]: 1122 : { CAST_LIST_TO_PARENT( myCoEdges, parents ); }
731 : 2266 : void FacetCurve::get_children_virt( DLIList<TopologyBridge*>& children )
732 : : {
733 [ + - ]: 2266 : children.append( myStartPoint );
734 [ + + ]: 2266 : if( myStartPoint != myEndPoint )
735 [ + - ]: 2200 : children.append( myEndPoint );
736 : 2266 : }
737 : :
738 : :
739 : :
740 : :
741 : : //-------------------------------------------------------------------------
742 : : // Purpose : Check for G1 discontinuity
743 : : //
744 : : // Special Notes : not implemented
745 : : //
746 : : // Creator : Steve Owen
747 : : //
748 : : // Creation Date : 07/14/00
749 : : //-------------------------------------------------------------------------
750 : 0 : CubitBoolean FacetCurve::G1_discontinuous(
751 : : double param, CubitVector* mtan, CubitVector* ptan )
752 : : {
753 [ # # ]: 0 : DLIList<CubitPoint*> point_list;
754 [ # # ]: 0 : curveFacetEvalTool->get_points( point_list );
755 [ # # ]: 0 : CubitVector position;
756 [ # # ]: 0 : position_from_u( param, position );
757 [ # # ]: 0 : point_list.reset();
758 [ # # ]: 0 : CubitPoint* prev = point_list.get_and_step();
759 [ # # ][ # # ]: 0 : for( int i = point_list.size(); i > 2; i--)
760 : : {
761 [ # # ]: 0 : CubitPoint* point = point_list.get_and_step();
762 [ # # ][ # # ]: 0 : if( (point->coordinates() - position).length_squared() <
[ # # ][ # # ]
763 : : (GEOMETRY_RESABS*GEOMETRY_RESABS) )
764 : : {
765 [ # # ]: 0 : if( mtan )
766 : : {
767 [ # # ][ # # ]: 0 : *mtan = point->coordinates() - prev->coordinates();
[ # # ][ # # ]
768 : : }
769 [ # # ]: 0 : if( ptan )
770 : : {
771 [ # # ][ # # ]: 0 : *ptan = point_list.get()->coordinates() - point->coordinates();
[ # # ][ # # ]
[ # # ]
772 : : }
773 : 0 : return CUBIT_TRUE;
774 : : }
775 : : }
776 [ # # ]: 0 : return CUBIT_FALSE;
777 : : }
778 : :
779 : : //-------------------------------------------------------------------------
780 : : // Purpose : retreive the facet edge list for this curve
781 : : //
782 : : // Special Notes :
783 : : //
784 : : // Creator : Steve J. Owen
785 : : //
786 : : // Creation Date : 12/10/00
787 : : //-------------------------------------------------------------------------
788 : 924 : void FacetCurve::get_facets(DLIList<CubitFacetEdge*>& facet_list)
789 : : {
790 [ + - ]: 924 : if (curveFacetEvalTool)
791 : : {
792 : 924 : curveFacetEvalTool->get_facets(facet_list);
793 : : }
794 : : else
795 : : {
796 [ # # ][ # # ]: 0 : PRINT_ERROR("curve facet evaluation tool not defined for FacetCurve\n");
797 : : }
798 : 924 : }
799 : :
800 : : //-------------------------------------------------------------------------
801 : : // Purpose : retreive the facet point list for this curve
802 : : //
803 : : // Special Notes :
804 : : //
805 : : // Creator : Steve J. Owen
806 : : //
807 : : // Creation Date : 12/10/00
808 : : //-------------------------------------------------------------------------
809 : 0 : void FacetCurve::get_points(DLIList<CubitPoint*>& point_list)
810 : : {
811 [ # # ]: 0 : if (curveFacetEvalTool)
812 : : {
813 : 0 : curveFacetEvalTool->get_points(point_list);
814 : : }
815 : : else
816 : : {
817 [ # # ][ # # ]: 0 : PRINT_ERROR("curve facet evaluation tool not defined for FacetCurve\n");
818 : : }
819 : 0 : }
820 : :
821 : : //-------------------------------------------------------------------------
822 : : // Purpose : set the facetLength in the CurveFacetEvalTool
823 : : //
824 : : // Special Notes :
825 : : //
826 : : // Creator : Steve J. Owen
827 : : //
828 : : // Creation Date : 03/19/02
829 : : //-------------------------------------------------------------------------
830 : 0 : void FacetCurve::reset_length()
831 : : {
832 [ # # ]: 0 : if (curveFacetEvalTool)
833 : : {
834 : 0 : curveFacetEvalTool->set_length();
835 : : }
836 : : else
837 : : {
838 [ # # ][ # # ]: 0 : PRINT_ERROR("curve facet evaluation tool not defined for FacetCurve\n");
839 : : }
840 : 0 : }
841 : :
842 : :
843 : 0 : void FacetCurve::get_lumps( DLIList<FacetLump*>& result_list )
844 : : {
845 [ # # ]: 0 : DLIList<FacetShell*> shell_list;
846 [ # # ]: 0 : get_shells( shell_list );
847 [ # # ]: 0 : shell_list.reset();
848 [ # # ][ # # ]: 0 : for ( int i = shell_list.size(); i--; )
849 : : {
850 [ # # ]: 0 : FacetShell* shell = shell_list.get_and_step();
851 [ # # ]: 0 : shell->get_lumps( result_list );
852 [ # # ][ # # ]: 0 : FacetLump* lump = dynamic_cast<FacetLump*>(shell->get_lump());
853 [ # # ]: 0 : if (lump)
854 [ # # ]: 0 : result_list.append_unique(lump);
855 [ # # ]: 0 : }
856 : 0 : }
857 : :
858 : 0 : void FacetCurve::get_shells( DLIList<FacetShell*>& result_list )
859 : : {
860 [ # # ]: 0 : DLIList<FacetSurface*> surface_list;
861 [ # # ][ # # ]: 0 : DLIList<FacetShell*> temp_list;
862 [ # # ]: 0 : get_surfaces( surface_list );
863 [ # # ]: 0 : surface_list.reset();
864 [ # # ][ # # ]: 0 : for ( int i = surface_list.size(); i--; )
865 : : {
866 [ # # ]: 0 : FacetSurface* surface = surface_list.get_and_step();
867 [ # # ]: 0 : temp_list.clean_out();
868 [ # # ]: 0 : surface->get_shells( temp_list );
869 [ # # ]: 0 : result_list.merge_unique( temp_list );
870 [ # # ]: 0 : }
871 : 0 : }
872 : :
873 : 0 : void FacetCurve::get_surfaces( DLIList<FacetSurface*>& result_list )
874 : : {
875 [ # # ]: 0 : DLIList<FacetLoop*> loop_list;
876 [ # # ]: 0 : get_loops( loop_list );
877 [ # # ]: 0 : loop_list.reset();
878 [ # # ][ # # ]: 0 : for ( int i = loop_list.size(); i--; )
879 : : {
880 [ # # ]: 0 : FacetLoop* loop = loop_list.get_and_step();
881 [ # # ][ # # ]: 0 : FacetSurface* surface = dynamic_cast<FacetSurface*>(loop->get_surface());
882 [ # # ]: 0 : if (surface)
883 [ # # ]: 0 : result_list.append_unique(surface);
884 [ # # ]: 0 : }
885 : 0 : }
886 : :
887 : 0 : void FacetCurve::get_loops( DLIList<FacetLoop*>& result_list )
888 : : {
889 [ # # ]: 0 : DLIList<FacetCoEdge*> coedge_list;
890 [ # # ]: 0 : get_coedges( coedge_list );
891 [ # # ]: 0 : coedge_list.reset();
892 [ # # ][ # # ]: 0 : for ( int i = coedge_list.size(); i--; )
893 : : {
894 [ # # ]: 0 : FacetCoEdge* coedge = coedge_list.get_and_step();
895 [ # # ][ # # ]: 0 : FacetLoop* loop = dynamic_cast<FacetLoop*>(coedge->get_loop());
896 [ # # ]: 0 : if (loop)
897 [ # # ]: 0 : result_list.append_unique(loop);
898 [ # # ]: 0 : }
899 : 0 : }
900 : :
901 : 264 : void FacetCurve::get_coedges( DLIList<FacetCoEdge*>& result_list )
902 : : {
903 : 264 : myCoEdges.reset();
904 [ + + ]: 792 : for ( int i = 0; i < myCoEdges.size(); i++ )
905 [ + - ][ - + ]: 528 : if ( FacetCoEdge* coedge = dynamic_cast<FacetCoEdge*>(myCoEdges.next(i)) )
[ + - ]
906 [ + - ]: 528 : result_list.append(coedge);
907 : 264 : }
908 : :
909 : 462 : void FacetCurve::get_points( DLIList<FacetPoint*>& result_list )
910 : : {
911 : : FacetPoint* point;
912 [ - + ][ + - ]: 462 : if ( (point = dynamic_cast<FacetPoint*>(myStartPoint)) )
913 [ + - ]: 462 : result_list.append( point );
914 [ + + ][ - + ]: 462 : if ( (myStartPoint != myEndPoint) &&
[ + - ][ + + ]
915 : : (point = dynamic_cast<FacetPoint*>(myEndPoint)) )
916 [ + - ]: 396 : result_list.append( point );
917 : 462 : }
918 : :
919 : :
920 : : // ********** END PUBLIC FUNCTIONS **********
921 : :
922 : : // ********** BEGIN PROTECTED FUNCTIONS **********
923 : : // ********** END PROTECTED FUNCTIONS **********
924 : :
925 : : // ********** BEGIN PRIVATE FUNCTIONS **********
926 : :
927 : :
928 : : //----------------------------------------------------------------
929 : : // Adjusts the input parameter so that it falls within the
930 : : // parameter range of this Curve, if possible. Necessary for
931 : : // periodic curves.
932 : : //----------------------------------------------------------------
933 : 3410 : void FacetCurve::adjust_periodic_parameter(double& param)
934 : : {
935 : : // Adjustment only legal if this is a periodic curve.
936 : : double period;
937 [ + - ][ - + ]: 3410 : if ( this->is_periodic(period) && (fabs(period) > CUBIT_RESABS))
[ # # ][ - + ]
938 : : {
939 : : double upper_bound, lower_bound;
940 [ # # ]: 0 : this->get_param_range( lower_bound, upper_bound );
941 [ # # ]: 0 : assert((upper_bound - lower_bound) > CUBIT_RESABS * 100);
942 : :
943 : 0 : lower_bound -= CUBIT_RESABS;
944 : 0 : upper_bound += CUBIT_RESABS;
945 : :
946 : : // Make sure period is positive
947 [ # # ]: 0 : if (period < 0.)
948 : 0 : period = -period;
949 : :
950 : : // Move the parameter above the low param
951 [ # # ]: 0 : while (param < lower_bound)
952 : 0 : param += period;
953 : : // Move the parameter below the high param
954 [ # # ]: 0 : while (param > upper_bound)
955 : 0 : param -= period;
956 : : }
957 : 3410 : }
958 : 0 : CubitPointContainment FacetCurve::point_containment( const CubitVector &/*point*/ )
959 : : {
960 : 0 : return CUBIT_PNT_UNKNOWN;
961 : : }
962 : 0 : CubitPointContainment FacetCurve::point_containment( double /*u_param*/,
963 : : double /*v_param*/ )
964 : : {
965 : 0 : return CUBIT_PNT_UNKNOWN;
966 : : }
967 : 0 : CubitPointContainment FacetCurve::point_containment( CubitVector &/*point*/,
968 : : double /*u_param*/,
969 : : double /*v_param*/ )
970 : : {
971 : 0 : return CUBIT_PNT_UNKNOWN;
972 : : }
973 : :
974 : : //-------------------------------------------------------------------------
975 : : // Purpose : Tear down topology
976 : : //
977 : : // Special Notes :
978 : : //
979 : : // Creator : Jason Kraftcheck
980 : : //
981 : : // Creation Date : 09/29/03
982 : : //-------------------------------------------------------------------------
983 : 0 : CubitStatus FacetCurve::disconnect_coedge( FacetCoEdge* coedge )
984 : : {
985 [ # # ][ # # ]: 0 : if (!myCoEdges.move_to(coedge))
986 : 0 : return CUBIT_FAILURE;
987 : 0 : myCoEdges.remove();
988 : :
989 [ # # ]: 0 : assert(coedge->curve() == this);
990 : 0 : coedge->remove_curve();
991 : :
992 : 0 : return CUBIT_SUCCESS;
993 : : }
994 : :
995 : 0 : CubitStatus FacetCurve::get_spline_params
996 : : (
997 : : bool &rational, // return true/false
998 : : int °ree, // the degree of this spline
999 : : DLIList<CubitVector> &cntrl_pts, // xyz position of controlpoints
1000 : : DLIList<double> &cntrl_pt_weights, // if rational, a weight for each cntrl point.
1001 : : DLIList<double> &knots, // There should be order+cntrl_pts.size()-2 knots
1002 : : bool &spline_is_reversed
1003 : : ) const
1004 : : {
1005 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine spline parameters for FacetCurves.\n");
1006 : 0 : return CUBIT_FAILURE;
1007 : : }
1008 : :
1009 : 0 : CubitStatus FacetCurve::get_ellipse_params
1010 : : (
1011 : : CubitVector ¢er_vec,
1012 : : CubitVector &normal,
1013 : : CubitVector &major_axis,
1014 : : double &radius_ratio
1015 : : ) const
1016 : : {
1017 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine ellipse parameters for FacetCurves.\n");
1018 : 0 : return CUBIT_FAILURE;
1019 [ + - ][ + - ]: 6540 : }
1020 : :
1021 : : // ********** END PRIVATE FUNCTIONS **********
1022 : :
1023 : : // ********** BEGIN HELPER CLASSES **********
1024 : : // ********** END HELPER CLASSES **********
1025 : :
1026 : : // ********** BEGIN EXTERN FUNCTIONS **********
1027 : : // ********** END EXTERN FUNCTIONS **********
1028 : :
1029 : : // ********** BEGIN STATIC FUNCTIONS **********
1030 : : // ********** END STATIC FUNCTIONS **********
|
