Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : RefEdge.cpp
3 : : //
4 : : // Purpose : This file contains the implementation of the class
5 : : // RefEdge.
6 : : //
7 : : // Special Notes :
8 : : //
9 : : // Creator : Xuechen Liu
10 : : //
11 : : // Creation Date : 07/11/96
12 : : //
13 : : // Owner : Malcolm J. Panthaki
14 : : //-------------------------------------------------------------------------
15 : :
16 : : // ********** BEGIN STANDARD INCLUDES **********
17 : : #include <assert.h>
18 : : // ********** END STANDARD INCLUDES **********
19 : :
20 : : // ********** BEGIN CUBIT INCLUDES **********
21 : : #include "CubitDefines.h"
22 : :
23 : : #include "RefVolume.hpp"
24 : : #include "RefFace.hpp"
25 : : #include "RefEdge.hpp"
26 : : #include "RefVertex.hpp"
27 : : #include "Chain.hpp"
28 : :
29 : : #include "Curve.hpp"
30 : : #include "CoEdge.hpp"
31 : : #include "Loop.hpp"
32 : :
33 : : #include "RefEntityFactory.hpp"
34 : : #include "GeometryQueryTool.hpp"
35 : :
36 : : #include "CastTo.hpp"
37 : : #include "DLIList.hpp"
38 : :
39 : : #include "CubitAttrib.hpp"
40 : : #include "CubitUtil.hpp"
41 : : #include "ModelQueryEngine.hpp"
42 : :
43 : : #include "ToolData.hpp"
44 : : #include "CpuTimer.hpp"
45 : :
46 : : bool RefEdge::mSuppressEdgeLengthWarning = false;
47 : :
48 : : //-------------------------------------------------------------------------
49 : : // Purpose : Constructor with a pointer to a Curve
50 : : //
51 : : // Special Notes :
52 : : //
53 : : // Creator : Xuechen Liu
54 : : //
55 : : // Creation Date : 07/11/96
56 : : //-------------------------------------------------------------------------
57 : 70502 : RefEdge::RefEdge(Curve* curvePtr)
58 : : {
59 : : // Set the GeometryEntity pointer
60 [ + - ]: 35251 : if (curvePtr != NULL)
61 : : {
62 [ + - ]: 35251 : set_geometry_entity_ptr(curvePtr) ;
63 : : }
64 : : else
65 : : {
66 [ # # ][ # # ]: 0 : PRINT_ERROR("In the RefEdge(Curve*) constructor\n");
[ # # ][ # # ]
67 [ # # ][ # # ]: 0 : PRINT_ERROR(" Input Curve pointer is NULL\n");
[ # # ][ # # ]
68 : 0 : assert(CUBIT_FALSE);
69 : : }
70 : :
71 : : // Initialize the member data
72 [ + - ]: 35251 : initialize();
73 : 35251 : }
74 : :
75 : : //-------------------------------------------------------------------------
76 : : // Purpose : The destructor.
77 : : //
78 : : // Special Notes :
79 : : //
80 : : // Creator : Raikanta Sahu
81 : : //
82 : : // Creation Date : 10/22/96
83 : : //-------------------------------------------------------------------------
84 : 65589 : RefEdge::~RefEdge()
85 : : {
86 [ - + ]: 43726 : }
87 : :
88 : : //-------------------------------------------------------------------------
89 : : // Purpose : Return a pointer to the curve associated with a edge.
90 : : //
91 : : // Special Notes :
92 : : //
93 : : // Creator : Xuechen Liu
94 : : //
95 : : // Creation Date : 08/02/96
96 : : //-------------------------------------------------------------------------
97 : 185252 : Curve* RefEdge::get_curve_ptr()
98 : : {
99 : 185252 : return STATIC_CAST_TO(get_geometry_entity_ptr(), Curve) ;
100 : : }
101 : :
102 : 0 : const Curve* RefEdge::get_curve_ptr() const
103 : : {
104 : 0 : return STATIC_CAST_TO(get_geometry_entity_ptr(), Curve) ;
105 : : }
106 : :
107 : : //-------------------------------------------------------------------------
108 : : // Purpose : Get Chain associated with this RefEdge
109 : : //
110 : : // Special Notes :
111 : : //
112 : : // Creator : Jason Kraftcheck
113 : : //
114 : : // Creation Date : 07/22/03
115 : : //-------------------------------------------------------------------------
116 : 117680 : Chain* RefEdge::get_chain_ptr()
117 : : {
118 : 117680 : GroupingEntity* gpe_ptr = get_first_grouping_entity_ptr();
119 [ + + - + ]: 200029 : if ( !gpe_ptr || // no chain
[ + + ]
120 : 82349 : gpe_ptr->next() ) // multiple chains
121 : : {
122 : 35331 : return 0;
123 : : }
124 : :
125 : 82349 : return static_cast<Chain*>(gpe_ptr);
126 : : }
127 : :
128 : 0 : CubitStatus RefEdge::get_point_direction( CubitVector& origin, CubitVector& direction )
129 : : {
130 : 0 : Curve* curve_ptr = get_curve_ptr();
131 : :
132 [ # # ]: 0 : if( curve_ptr != NULL )
133 : : {
134 : :
135 [ # # ]: 0 : if( curve_ptr->geometry_type() != STRAIGHT_CURVE_TYPE )
136 : 0 : return CUBIT_FAILURE;
137 : :
138 [ # # ]: 0 : if( curve_ptr->get_point_direction( origin, direction ) == CUBIT_FAILURE )
139 : : {
140 [ # # ]: 0 : origin = start_coordinates();
141 [ # # ][ # # ]: 0 : direction = end_coordinates() - origin;
142 : 0 : direction.normalize();
143 : : }
144 : : }
145 : : else
146 : : {
147 [ # # ][ # # ]: 0 : PRINT_WARNING("In RefEdge::get_point_direction\n"
[ # # ][ # # ]
148 : : " %s (curve %d) is not associated with a valid\n"
149 : : " underlying geometric Curve\n",
150 [ # # ]: 0 : entity_name().c_str(), id()) ;
151 : 0 : return CUBIT_FAILURE ;
152 : : }
153 : :
154 [ # # ]: 0 : if (curve_ptr->bridge_sense() == CUBIT_REVERSED)
155 [ # # ]: 0 : direction = -direction;
156 : :
157 : 0 : return CUBIT_SUCCESS;
158 : :
159 : : }
160 : :
161 : 0 : CubitStatus RefEdge::get_center_radius( CubitVector& center, double& radius )
162 : : {
163 : 0 : Curve* curve_ptr = get_curve_ptr();
164 : :
165 [ # # ]: 0 : if( curve_ptr != NULL )
166 : : {
167 : :
168 [ # # # # ]: 0 : if( curve_ptr->geometry_type() != ARC_CURVE_TYPE &&
[ # # ]
169 : 0 : curve_ptr->geometry_type() != ELLIPSE_CURVE_TYPE )
170 : 0 : return CUBIT_FAILURE;
171 : :
172 [ # # ]: 0 : if( curve_ptr->get_center_radius( center, radius ) == CUBIT_FAILURE )
173 : 0 : return CUBIT_FAILURE;
174 : : }
175 : : else
176 : : {
177 [ # # ][ # # ]: 0 : PRINT_WARNING("In RefEdge::get_center_radius\n"
[ # # ][ # # ]
178 : : " %s (curve %d) is not associated with a valid\n"
179 : : " underlying geoemtric Curve\n",
180 [ # # ]: 0 : entity_name().c_str(), id()) ;
181 : 0 : return CUBIT_FAILURE ;
182 : : }
183 : :
184 : 0 : return CUBIT_SUCCESS;
185 : : }
186 : :
187 : : //-------------------------------------------------------------------------
188 : : // Purpose : Finds the closest point on the RefEdge to the input
189 : : // point and modifies the coordinate values of the input
190 : : // point to be those of the closest point.
191 : : //
192 : : // Special Notes :
193 : : //
194 : : // Creator : Malcolm J. Panthaki
195 : : //
196 : : // Creation Date : 2/25/97
197 : : //-------------------------------------------------------------------------
198 : 0 : void RefEdge::move_to_curve( CubitVector& vector )
199 : : {
200 : : // Get the Curve associated with this RefEdge
201 [ # # ]: 0 : Curve* curvePtr = this->get_curve_ptr();
202 : :
203 : : // Move the point to the Curve (the following call modifes the values
204 : : // of the input "vector", if necessary)
205 [ # # ]: 0 : CubitVector closest_point;
206 [ # # ]: 0 : curvePtr->closest_point_trimmed(vector, closest_point);
207 [ # # ]: 0 : vector.set( closest_point.x(),
208 [ # # ]: 0 : closest_point.y(),
209 [ # # ][ # # ]: 0 : closest_point.z() );
210 : 0 : }
211 : :
212 : 0 : CubitStatus RefEdge::get_interior_extrema(DLIList<CubitVector*>& interior_points,
213 : : CubitSense& return_sense) const
214 : : {
215 : : CubitStatus result;
216 : :
217 : : // Cast away the constness of the Curve
218 : 0 : Curve* curve = const_cast<Curve*>(get_curve_ptr());
219 : 0 : result = curve->get_interior_extrema(interior_points, return_sense);
220 [ # # ]: 0 : if (curve->bridge_sense() == CUBIT_REVERSED)
221 : 0 : return_sense = CubitUtil::opposite_sense(return_sense);
222 : 0 : return result;
223 : : }
224 : :
225 : 19994 : CubitStatus RefEdge::closest_point( CubitVector const& location,
226 : : CubitVector& closest_location,
227 : : CubitVector* tangent_ptr,
228 : : CubitVector* curvature_ptr)
229 : : {
230 : 19994 : Curve *curve_ptr = get_curve_ptr();
231 : : CubitStatus result = curve_ptr->closest_point(location, closest_location,
232 : 19994 : tangent_ptr, curvature_ptr);
233 [ + + ][ - + ]: 19994 : if (tangent_ptr && curve_ptr->bridge_sense() == CUBIT_REVERSED)
[ - + ]
234 [ # # ]: 0 : *tangent_ptr = -(*tangent_ptr);
235 : :
236 : 19994 : return result;
237 : : }
238 : :
239 : 20403 : CubitStatus RefEdge::closest_point_trimmed( CubitVector const& location,
240 : : CubitVector& closest_location)
241 : : {
242 : 20403 : Curve *curve_ptr = get_curve_ptr();
243 : 20403 : return curve_ptr->closest_point_trimmed(location, closest_location);
244 : : }
245 : :
246 : 0 : CubitPointContainment RefEdge::point_containment( const CubitVector &point )
247 : : {
248 : 0 : Curve *curve_ptr = get_curve_ptr();
249 : 0 : return curve_ptr->point_containment(point);
250 : : }
251 : :
252 : :
253 : : //-------------------------------------------------------------------------
254 : : // Purpose : These functions return the start and end global coordinate
255 : : // locations of the RefEdge.
256 : : //
257 : : // Special Notes :
258 : : // These coordinates remain consistent throughout the life of the
259 : : // RefEdge, regardless of the fact that the actual start and
260 : : // end RefVerex'es may change (e.g., after a merge operation).
261 : : //
262 : : // Creator : Malcolm J. Panthaki
263 : : //
264 : : // Creation Date : 07/03/97
265 : : //-------------------------------------------------------------------------
266 : 0 : CubitVector RefEdge::start_coordinates()
267 : : {
268 : 0 : return this->start_vertex()->coordinates();
269 : : }
270 : :
271 : 0 : CubitVector RefEdge::end_coordinates()
272 : : {
273 : 0 : return this->end_vertex()->coordinates();
274 : : }
275 : :
276 : 1728 : void RefEdge::tangent ( const CubitVector &point, CubitVector& tangent_vec )
277 : : {
278 : : // Get the tangent at the point closest to "point" on the RefEdge.
279 : : // The tangent is always pointing in the positive direction of the
280 : : // RefEdge
281 [ + - ]: 1728 : Curve* curve_ptr = this->get_curve_ptr();
282 [ + - ]: 1728 : CubitVector closest_point;
283 [ + - ]: 1728 : curve_ptr->closest_point( point, closest_point, &tangent_vec );
284 [ + - ][ - + ]: 1728 : if (curve_ptr->bridge_sense() == CUBIT_REVERSED)
285 [ # # ][ # # ]: 0 : tangent_vec = -tangent_vec;
286 : 1728 : }
287 : : //-------------------------------------------------------------------------
288 : : // Purpose : Get the correct tangent with respect to
289 : : // the ref_face_ptr.
290 : : // Special Note : This tangent function is not the safest method for getting
291 : : // : the tangent on a surface. In face if there could be
292 : : // another direction, this function could fail...(assert).
293 : : // This function assumes that there is only 1 co-edge per
294 : : // this ref_face for this REfEdge.
295 : : //
296 : : // Creator : David White
297 : : //
298 : : // Creation Date : 03/15/97
299 : : //-------------------------------------------------------------------------
300 : 0 : CubitStatus RefEdge::tangent( const CubitVector &point,
301 : : CubitVector& tangent_vec,
302 : : RefFace *ref_face_ptr )
303 : : {
304 : : //Get the tangent for this edge.
305 [ # # ]: 0 : tangent( point, tangent_vec );
306 : :
307 : : //Now allign the tangent with the face.
308 : : //For this function we assume that there must only be one
309 : : //co edge for this ref_edge.
310 [ # # ]: 0 : DLIList<CoEdge*> co_edge_list;
311 [ # # ]: 0 : get_co_edges( co_edge_list, ref_face_ptr );
312 : :
313 [ # # ][ # # ]: 0 : if( co_edge_list.size() != 1 )
314 : : {
315 [ # # ][ # # ]: 0 : PRINT_ERROR( "Ambiguous case in tangent calculation.\n" );
[ # # ][ # # ]
316 : 0 : return CUBIT_FAILURE;
317 : : }
318 : : // assert( co_edge_list.size() == 1 );
319 : :
320 [ # # ][ # # ]: 0 : if ( co_edge_list.get()->get_sense() == CUBIT_REVERSED )
[ # # ]
321 [ # # ][ # # ]: 0 : tangent_vec = -tangent_vec;
322 [ # # ]: 0 : return CUBIT_SUCCESS;
323 : : }
324 : :
325 : : //-------------------------------------------------------------------------
326 : : // Purpose : Get the correct tangent with respect to
327 : : // the ref_face_ptr and the next_ref_edge
328 : : // Special Note : For this function next_ref_edge must follow RefEdge.
329 : : // : This tangent function is the safest method for getting
330 : : // : the tangent on a surface. The others are less restrictive
331 : : // : about the tangents direction... (forward, reverse)
332 : : //
333 : : // Creator : David White
334 : : //
335 : : // Creation Date : 03/15/97
336 : : //-------------------------------------------------------------------------
337 : 0 : CubitStatus RefEdge::tangent( const CubitVector &point,
338 : : CubitVector& tangent_vec,
339 : : RefEdge *next_ref_edge,
340 : : RefFace *ref_face_ptr )
341 : : {
342 : 0 : CoEdge *co_edge_this = NULL;
343 : 0 : CoEdge *co_edge_next = NULL;
344 : : //First get the two coedges that corrispond to
345 : : //this ref_edge an the next one, with reference to
346 : : //the ref_face_ptr.
347 : : CubitStatus status = get_two_co_edges( next_ref_edge,
348 : : ref_face_ptr,
349 : : co_edge_this,
350 [ # # ]: 0 : co_edge_next );
351 [ # # ]: 0 : if (status == CUBIT_FAILURE )
352 : 0 : return status;
353 : :
354 [ # # ]: 0 : assert(co_edge_this != NULL );
355 [ # # ]: 0 : assert(co_edge_next != NULL );
356 : :
357 : : //Now get the tangent from this curve.
358 [ # # ]: 0 : tangent ( point, tangent_vec );
359 : :
360 : : //with the go_edge data we have, we can get the tangent
361 : : //going in the right direction...
362 [ # # ][ # # ]: 0 : if ( co_edge_this->get_sense() == CUBIT_REVERSED )
363 [ # # ][ # # ]: 0 : tangent_vec = -tangent_vec;
364 : 0 : return CUBIT_SUCCESS;
365 : : }
366 : :
367 : 40667 : double RefEdge::get_arc_length ()
368 : : {
369 : : // Get the Curve associated with this RefEdge
370 : 40667 : Curve* curve_ptr = get_curve_ptr();
371 : :
372 [ - + ]: 40667 : assert(curve_ptr != NULL);
373 : :
374 : : // Get the length
375 : 40667 : return curve_ptr->get_arc_length();
376 : : }
377 : :
378 : 0 : double RefEdge::get_arc_length ( const CubitVector &point1,
379 : : const CubitVector &point2 )
380 : : {
381 : : // Get the Curve associated with this RefEdge
382 : 0 : Curve* curve_ptr = get_curve_ptr();
383 : :
384 [ # # ]: 0 : assert(curve_ptr != NULL);
385 : :
386 : : // Get the length between the 2 points
387 : 0 : return curve_ptr->get_arc_length(point1, point2);
388 : : }
389 : :
390 : 0 : double RefEdge::get_arc_length ( const CubitVector &point1,
391 : : int which_end )
392 : : {
393 : 0 : Curve* curve_ptr = get_curve_ptr();
394 : :
395 [ # # ]: 0 : assert (curve_ptr != NULL);
396 : :
397 [ # # ]: 0 : if (curve_ptr->bridge_sense() == CUBIT_REVERSED)
398 : 0 : which_end = 1 - which_end;
399 : :
400 : 0 : return curve_ptr->get_arc_length(point1, which_end);
401 : : }
402 : :
403 : 0 : double RefEdge::get_chord_length()
404 : : {
405 [ # # ][ # # ]: 0 : CubitVector start_pos(start_vertex()->coordinates());
406 [ # # ][ # # ]: 0 : CubitVector end_pos(start_vertex()->coordinates());
407 [ # # ][ # # ]: 0 : double distance = (start_pos - end_pos).length();
408 : 0 : return distance;
409 : : }
410 : :
411 : :
412 : : //-------------------------------------------------------------------------
413 : : // Purpose : Return the "actual" center point (the midpoint along
414 : : // the arc length) of the RefEdge.
415 : : //
416 : : // Special Notes :
417 : : //
418 : : // Creator : Malcolm Panthaki
419 : : //
420 : : // Creation Date : 2/27/97
421 : : //-------------------------------------------------------------------------
422 : 550 : CubitVector RefEdge::center_point()
423 : : {
424 : : // Get the parameter range of the RefEdge
425 : 550 : Curve* curve_ptr = get_curve_ptr();
426 : :
427 [ - + ]: 550 : assert (curve_ptr != NULL);
428 : :
429 : 550 : return curve_ptr->center_point();
430 : : }
431 : :
432 : 0 : CubitStatus RefEdge::mid_point ( const CubitVector &point1,
433 : : const CubitVector &point2,
434 : : CubitVector& mid_point )
435 : : {
436 : : // Get the Curve associated with this RefEdge
437 : 0 : Curve* curve_ptr = get_curve_ptr();
438 : :
439 [ # # ]: 0 : assert(curve_ptr != NULL);
440 : :
441 : : // Get the global location of parameter3
442 : 0 : return curve_ptr->mid_point(point1, point2, mid_point);
443 : :
444 : : }
445 : :
446 : 0 : CubitStatus RefEdge::mid_point ( CubitVector& mid_point )
447 : : {
448 : : // Get the Curve associated with this RefEdge
449 : 0 : Curve* curve_ptr = get_curve_ptr();
450 : :
451 [ # # ]: 0 : assert(curve_ptr != NULL);
452 : :
453 : : // Get the global location of parameter3
454 : 0 : return curve_ptr->mid_point(mid_point);
455 : :
456 : : }
457 : 20443 : CubitStatus RefEdge::position_from_fraction( double fraction_along_curve,
458 : : CubitVector& output_position )
459 : : {
460 : :
461 : : //Get the Curve of this RefEdge.
462 : 20443 : Curve* curve_ptr = this->get_curve_ptr();
463 : :
464 [ + - ][ - + ]: 20443 : assert( fraction_along_curve < 1.0000001 && fraction_along_curve > -0.0000001 );
465 : : //Now get the postion from this fraction value.
466 : :
467 [ - + ]: 20443 : if (curve_ptr->bridge_sense() == CUBIT_REVERSED)
468 : 0 : fraction_along_curve = 1.0 - fraction_along_curve;
469 : :
470 : : CubitStatus result = curve_ptr->position_from_fraction( fraction_along_curve,
471 : 20443 : output_position );
472 : 20443 : return result;
473 : : }
474 : :
475 : : //-------------------------------------------------------------------------
476 : : // Purpose : Get the parameter value of the start of the RefEdge.
477 : : //
478 : : // Special Notes :
479 : : //
480 : : // Creator : Malcolm J. Panthaki
481 : : //
482 : : // Creation Date : 2/27/97
483 : : //-------------------------------------------------------------------------
484 : 17512 : double RefEdge::start_param()
485 : : {
486 : : // Get the Curve associated with this RefEdge
487 : 17512 : Curve* curve_ptr = get_curve_ptr();
488 : :
489 [ - + ]: 17512 : assert(curve_ptr != NULL);
490 : :
491 [ - + ]: 17512 : if (curve_ptr->bridge_sense() == CUBIT_REVERSED)
492 : 0 : return -(curve_ptr->end_param());
493 : : else
494 : 17512 : return curve_ptr->start_param();
495 : : }
496 : :
497 : : //-------------------------------------------------------------------------
498 : : // Purpose : Get the parameter value of the end of the RefEdge.
499 : : //
500 : : // Special Notes :
501 : : //
502 : : // Creator : Malcolm J. Panthaki
503 : : //
504 : : // Creation Date : 2/27/97
505 : : //-------------------------------------------------------------------------
506 : 1771 : double RefEdge::end_param()
507 : : {
508 : : // Get the Curve associated with this RefEdge
509 : 1771 : Curve* curve_ptr = get_curve_ptr();
510 : :
511 [ - + ]: 1771 : assert(curve_ptr != NULL);
512 : :
513 [ - + ]: 1771 : if (curve_ptr->bridge_sense() == CUBIT_REVERSED)
514 : 0 : return -(curve_ptr->start_param());
515 : : else
516 : 1771 : return curve_ptr->end_param();
517 : : }
518 : :
519 : 3004 : CubitBoolean RefEdge::get_param_range( double& start_param, double& end_param )
520 : : {
521 : : // Get the Curve of this RefEdge
522 : 3004 : Curve* curvePtr = this->get_curve_ptr();
523 : :
524 : : // Now get the parameter values of the start and end locations
525 : : // of this RefEdge
526 : 3004 : CubitBoolean result = curvePtr->get_param_range( start_param, end_param );
527 : :
528 [ - + ]: 3004 : if (curvePtr->bridge_sense() == CUBIT_REVERSED)
529 : : {
530 : 0 : double tmp_start_param = start_param;
531 : 0 : start_param = -end_param;
532 : 0 : end_param = -tmp_start_param;
533 : : }
534 : :
535 : 3004 : return result;
536 : : }
537 : :
538 : 0 : double RefEdge::u_from_position (const CubitVector& input_position)
539 : : {
540 : : // Get the Curve of this RefEdge
541 : 0 : Curve* curvePtr = this->get_curve_ptr();
542 : :
543 : : // Now get the parameter values of the start and end locations
544 : : // of this RefEdge
545 : 0 : double param = curvePtr->u_from_position(input_position);
546 [ # # ]: 0 : if (curvePtr->bridge_sense() == CUBIT_REVERSED)
547 : 0 : param = -param;
548 : :
549 : 0 : return param;
550 : : }
551 : :
552 : 25138 : CubitStatus RefEdge::position_from_u (double u_value,
553 : : CubitVector& output_position)
554 : : {
555 : : // Get the Curve of this RefEdge
556 : 25138 : Curve* curvePtr = this->get_curve_ptr();
557 : :
558 [ - + ]: 25138 : if (curvePtr->bridge_sense() == CUBIT_REVERSED)
559 : 0 : u_value = -u_value;
560 : :
561 : : // Now get the parameter values of the start and end locations
562 : : // of this RefEdge
563 : 25138 : return curvePtr->position_from_u(u_value, output_position);
564 : : }
565 : :
566 : 0 : double RefEdge::u_from_arc_length ( double root_param, double arc_length )
567 : : {
568 : : // Get the Curve of this RefEdge
569 : 0 : Curve* curvePtr = this->get_curve_ptr();
570 : :
571 [ # # ]: 0 : if (curvePtr->bridge_sense() == CUBIT_REVERSED)
572 : 0 : return -(curvePtr->u_from_arc_length(-root_param, -arc_length));
573 : : else
574 : 0 : return curvePtr->u_from_arc_length(root_param, arc_length);
575 : : }
576 : :
577 : 0 : double RefEdge::fraction_from_arc_length(RefVertex *root_vertex,
578 : : double length)
579 : : {
580 [ # # ][ # # ]: 0 : if (root_vertex != start_vertex() && root_vertex != end_vertex())
[ # # ]
581 : 0 : return -1.0;
582 : :
583 [ # # ][ # # ]: 0 : if (geometry_type() == POINT_CURVE_TYPE || get_arc_length() < GEOMETRY_RESABS)
[ # # ]
584 : 0 : return 0.0;
585 : :
586 [ # # ]: 0 : if (length >= get_arc_length())
587 : 0 : return 1.0;
588 : :
589 [ # # ]: 0 : if (root_vertex == start_vertex())
590 : 0 : return length/get_arc_length();
591 : :
592 : : else
593 : 0 : return 1-length/get_arc_length();
594 : : }
595 : :
596 : 0 : CubitStatus RefEdge::point_from_arc_length ( const CubitVector& root_point,
597 : : double arc_length,
598 : : CubitVector& new_point )
599 : : {
600 : : // Get the Curve of this RefEdge
601 : 0 : Curve* curvePtr = this->get_curve_ptr();
602 : :
603 [ # # ]: 0 : if (curvePtr->bridge_sense() == CUBIT_REVERSED)
604 : 0 : arc_length = -arc_length;
605 : :
606 : : // Now get the parameter values of the start and end locations
607 : : // of this RefEdge
608 : : return curvePtr->point_from_arc_length (root_point, arc_length,
609 : 0 : new_point );
610 : : }
611 : :
612 : 0 : CubitStatus RefEdge::point_from_arc_length ( double root_param,
613 : : double arc_length,
614 : : CubitVector& new_point )
615 : : {
616 : : // Get the Curve of this RefEdge
617 : 0 : Curve* curvePtr = this->get_curve_ptr();
618 : :
619 [ # # ]: 0 : if (curvePtr->bridge_sense() == CUBIT_REVERSED)
620 : 0 : arc_length = -arc_length;
621 : :
622 : : // Now get the parameter values of the start and end locations
623 : : // of this RefEdge
624 : : return curvePtr->point_from_arc_length (root_param, arc_length,
625 : 0 : new_point );
626 : : }
627 : :
628 : 0 : double RefEdge::length_from_u( double parameter1,
629 : : double parameter2 )
630 : : {
631 : : // Get the Curve of this RefEdge
632 : 0 : Curve* curvePtr = this->get_curve_ptr();
633 : :
634 [ # # ]: 0 : if (curvePtr->bridge_sense() == CUBIT_REVERSED)
635 : 0 : return -(curvePtr->length_from_u(-parameter1, -parameter2));
636 : : else
637 : 0 : return curvePtr->length_from_u(parameter1, parameter2);
638 : : }
639 : :
640 : 0 : CubitBoolean RefEdge::is_periodic( )
641 : : {
642 : : double temp_val;
643 [ # # ]: 0 : return this->is_periodic(temp_val);
644 : : }
645 : :
646 : 0 : CubitBoolean RefEdge::is_periodic( double& period)
647 : : {
648 : : // Get the Curve of this RefEdge
649 : 0 : Curve* curvePtr = this->get_curve_ptr();
650 : :
651 : : // Now get the parameter values of the start and end locations
652 : : // of this RefEdge
653 : 0 : CubitBoolean periodic = curvePtr->is_periodic(period);
654 : :
655 [ # # ]: 0 : if (curvePtr->bridge_sense() == CUBIT_REVERSED)
656 : 0 : period = -period;
657 : :
658 : 0 : return periodic;
659 : : }
660 : :
661 : : //-------------------------------------------------------------------------
662 : : // Purpose : Get parent CoEdges
663 : : //
664 : : // Special Notes :
665 : : //
666 : : // Creator : Jason Kraftcheck
667 : : //
668 : : // Creation Date : 07/29/03
669 : : //-------------------------------------------------------------------------
670 : 104 : CubitStatus RefEdge::get_co_edges( DLIList<CoEdge*>& co_edges_found_list,
671 : : RefFace *input_ref_face_ptr )
672 : : {
673 [ + + ]: 396 : for (SenseEntity* coedge_ptr = get_first_sense_entity_ptr();
674 : : coedge_ptr;
675 : : coedge_ptr = coedge_ptr->next_on_bte())
676 : : {
677 [ + - + + ]: 584 : if (!input_ref_face_ptr ||
[ + + ]
678 : 292 : coedge_ptr->get_parent_basic_topology_entity_ptr() == input_ref_face_ptr)
679 : : {
680 [ - + ][ + - ]: 104 : co_edges_found_list.append (dynamic_cast<CoEdge*>(coedge_ptr));
681 : : }
682 : : }
683 : :
684 : 104 : return CUBIT_SUCCESS;
685 : : }
686 : :
687 : 0 : double RefEdge::angle_between( RefEdge *other_edge_ptr,
688 : : RefFace *face_ptr )
689 : : {
690 [ # # ]: 0 : DLIList<DLIList<RefEdge*> > ref_edge_loop;
691 [ # # ][ # # ]: 0 : CubitVector vertex_vector, normal_vector;
692 [ # # ][ # # ]: 0 : CubitVector left_vector, right_vector;
693 : :
694 : : // Loop through face's loops.
695 [ # # ]: 0 : face_ptr->ref_edge_loops( ref_edge_loop );
696 : 0 : double return_val = CUBIT_DBL_MAX;
697 : :
698 [ # # ][ # # ]: 0 : for( int i = 0; i<ref_edge_loop.size(); i++ )
699 : : {
700 : : // Look for this edge in the list.
701 [ # # ]: 0 : DLIList<RefEdge*>& ref_edge_list = ref_edge_loop[i];
702 [ # # ][ # # ]: 0 : if( !ref_edge_list.move_to( this ) )
703 : 0 : continue;
704 : : // Look for other_edge in the list.
705 [ # # ][ # # ]: 0 : if( !ref_edge_list.move_to( other_edge_ptr ) )
706 : : {
707 [ # # ][ # # ]: 0 : PRINT_ERROR("Attempted to get angle between two "
[ # # ]
708 [ # # ]: 0 : "RefEdges not on the same Loop.\n");
709 : 0 : return 0.;
710 : : }
711 : :
712 : : // If other_edge is before this edge in the loop . . .
713 [ # # ][ # # ]: 0 : if( ref_edge_list.next() == this )
714 : : { // (other = left, this = right)
715 : : // Get the vector of the the common vertex.
716 [ # # ][ # # ]: 0 : vertex_vector =
717 [ # # ]: 0 : other_edge_ptr->common_ref_vertex(this, face_ptr)->coordinates();
718 : : // Get the normal vector of the face.
719 [ # # ][ # # ]: 0 : normal_vector = face_ptr->normal_at( vertex_vector );
720 : : // Get the vectors of both edges.
721 : : other_edge_ptr->tangent( vertex_vector, left_vector,
722 [ # # ]: 0 : this, face_ptr );
723 : : this->tangent( vertex_vector, right_vector,
724 [ # # ][ # # ]: 0 : ref_edge_list.next(2), face_ptr);
725 : : }
726 : :
727 : : // If this edge is before other_edge in the loop . . .
728 [ # # ][ # # ]: 0 : else if( ref_edge_list.prev() == this )
729 : : { // (this = left, other = right)
730 : : // Get the vector of the the common vertex.
731 [ # # ][ # # ]: 0 : vertex_vector =
732 [ # # ]: 0 : common_ref_vertex(other_edge_ptr,face_ptr)->coordinates();
733 : : // Get the normal vector of the face.
734 [ # # ][ # # ]: 0 : normal_vector = face_ptr->normal_at( vertex_vector );
735 : : // Get the vectors of both edges.
736 : : this->tangent( vertex_vector, left_vector,
737 [ # # ]: 0 : other_edge_ptr, face_ptr);
738 : : other_edge_ptr->tangent( vertex_vector, right_vector,
739 [ # # ][ # # ]: 0 : ref_edge_list.next(), face_ptr );
740 : : }
741 : :
742 : : // Otherwise, error.
743 : : else
744 : : {
745 [ # # ][ # # ]: 0 : PRINT_ERROR("Attempted to get angle between two "
[ # # ]
746 [ # # ]: 0 : "non-consecutive edges.\n");
747 : 0 : return 0.;
748 : : }
749 : :
750 : : // Return the angle between the vectors.
751 [ # # ][ # # ]: 0 : return_val = normal_vector.vector_angle( right_vector, -left_vector );
752 : 0 : break;
753 : : }
754 : : // If this far, then error.
755 [ # # ]: 0 : if (CUBIT_DBL_MAX == return_val) {
756 [ # # ][ # # ]: 0 : PRINT_ERROR("Attempted to get angle between two edges "
[ # # ]
757 [ # # ]: 0 : "where one is not found on the given face.\n");
758 : 0 : return_val = 0.0;
759 : : }
760 [ # # ]: 0 : return return_val;
761 : : }
762 : :
763 : 132761 : int RefEdge::dimension() const
764 : : {
765 : 132761 : return 1;
766 : : }
767 : :
768 : 5416 : double RefEdge::measure()
769 : : {
770 : 5416 : return get_arc_length();
771 : : }
772 : :
773 : 0 : CubitString RefEdge::measure_label()
774 : : {
775 : 0 : return "length";
776 : : }
777 : :
778 : 0 : int RefEdge::num_of_common_ref_face( RefEdge *other_edge )
779 : : {
780 [ # # ][ # # ]: 0 : DLIList<RefFace*> ref_faces, ref_faces_for_other_edge;
[ # # ]
781 [ # # ]: 0 : this->ref_faces(ref_faces);
782 [ # # ]: 0 : other_edge->ref_faces(ref_faces_for_other_edge);
783 : :
784 : : int i, j;
785 : 0 : int num = 0;
786 [ # # ][ # # ]: 0 : for (i = 0; i < ref_faces.size(); i++)
787 : : {
788 [ # # ]: 0 : RefFace * ref_face = ref_faces.get_and_step();
789 [ # # ][ # # ]: 0 : for (j = 0; j < ref_faces_for_other_edge.size(); j++)
790 [ # # ][ # # ]: 0 : if (ref_face == ref_faces_for_other_edge.get_and_step())
791 : 0 : num++;
792 : : }
793 : :
794 [ # # ]: 0 : return num;
795 : : }
796 : :
797 : : // Get one common RefFace between two edges.
798 : 0 : RefFace *RefEdge::common_ref_face( RefEdge *other_edge )
799 : : {
800 [ # # ][ # # ]: 0 : DLIList<RefFace*> ref_faces, ref_faces_for_other_edge;
[ # # ]
801 [ # # ]: 0 : this->ref_faces(ref_faces);
802 [ # # ]: 0 : other_edge->ref_faces(ref_faces_for_other_edge);
803 : :
804 : : int i, j;
805 [ # # ][ # # ]: 0 : for (i = 0; i < ref_faces.size(); i++)
806 : : {
807 [ # # ]: 0 : RefFace * ref_face = ref_faces.get_and_step();
808 [ # # ][ # # ]: 0 : for (j = 0; j < ref_faces_for_other_edge.size(); j++)
809 [ # # ][ # # ]: 0 : if (ref_face == ref_faces_for_other_edge.get_and_step())
810 : 0 : return ref_face;
811 : : }
812 : :
813 [ # # ]: 0 : return NULL;
814 : : }
815 : :
816 : 0 : int RefEdge::common_ref_faces ( RefEdge* input_edge, DLIList<RefFace*> &common_face_list )
817 : : {
818 : 0 : int nedges = 0;
819 [ # # ][ # # ]: 0 : DLIList<RefFace*> ref_faces, ref_faces_for_other_edge;
[ # # ]
820 [ # # ]: 0 : this->ref_faces(ref_faces);
821 [ # # ]: 0 : input_edge->ref_faces(ref_faces_for_other_edge);
822 : :
823 : : int i, j;
824 [ # # ][ # # ]: 0 : for (i = 0; i < ref_faces.size(); i++)
825 : : {
826 [ # # ]: 0 : RefFace * ref_face = ref_faces.get_and_step();
827 [ # # ][ # # ]: 0 : for (j = 0; j < ref_faces_for_other_edge.size(); j++)
828 [ # # ][ # # ]: 0 : if (ref_face == ref_faces_for_other_edge.get_and_step())
829 : : {
830 [ # # ]: 0 : common_face_list.append(ref_face);
831 : 0 : nedges++;
832 : : }
833 : : }
834 : :
835 [ # # ]: 0 : return nedges;
836 : : }
837 : :
838 : 0 : RefVertex *RefEdge::common_ref_vertex( RefEdge *other_edge )
839 : : {
840 : 0 : RefVertex *this_start = start_vertex();
841 : 0 : RefVertex *this_end = end_vertex();
842 : 0 : RefVertex *other_start = other_edge->start_vertex();
843 : 0 : RefVertex *other_end = other_edge->end_vertex();
844 : :
845 [ # # ][ # # ]: 0 : if ( this_start == other_start || this_start == other_end )
846 : : {
847 : 0 : return this_start;
848 : : }
849 [ # # ][ # # ]: 0 : else if ( this_end == other_start || this_end == other_end )
850 : : {
851 : 0 : return this_end;
852 : : }
853 : : else
854 : : {
855 : 0 : return NULL;
856 : : }
857 : : }
858 : 0 : CubitBoolean RefEdge::common_vertices( RefEdge *other_edge,
859 : : DLIList<RefVertex*> &common_verts)
860 : : {
861 : 0 : CubitBoolean result = CUBIT_FALSE;
862 [ # # ]: 0 : RefVertex *this_start = start_vertex();
863 [ # # ]: 0 : RefVertex *this_end = end_vertex();
864 [ # # ]: 0 : RefVertex *other_start = other_edge->start_vertex();
865 [ # # ]: 0 : RefVertex *other_end = other_edge->end_vertex();
866 : :
867 [ # # ][ # # ]: 0 : if ( this_start == other_start || this_start == other_end )
868 : : {
869 [ # # ]: 0 : common_verts.append(this_start);
870 : 0 : result = CUBIT_TRUE;
871 : : }
872 [ # # ][ # # ]: 0 : if ( this_end == other_start || this_end == other_end )
873 : : {
874 [ # # ]: 0 : common_verts.append(this_end);
875 : 0 : result = CUBIT_TRUE;
876 : : }
877 : :
878 : 0 : return result;
879 : : }
880 : : //-------------------------------------------------------------------------
881 : : // Purpose : Return a pointer to the ref_vertex that is common
882 : : // between the two ref edges and is in the correct order
883 : : // going with respect to the face.
884 : : //
885 : : // Creator : David White
886 : : //
887 : : // Creation Date : 03/15/97
888 : : //-------------------------------------------------------------------------
889 : :
890 : 0 : RefVertex *RefEdge::common_ref_vertex( RefEdge *next_ref_edge,
891 : : RefFace *ref_face_ptr )
892 : : {
893 : 0 : CoEdge *co_edge_this = NULL;
894 : 0 : CoEdge *co_edge_next = NULL;
895 : :
896 : : //First get the two coedges that corrispond to
897 : : //this ref_edge an the next one, with reference to
898 : : //the ref_face_ptr.
899 : : CubitStatus status = get_two_co_edges( next_ref_edge,
900 : : ref_face_ptr,
901 : : co_edge_this,
902 [ # # ]: 0 : co_edge_next );
903 [ # # ]: 0 : if (status == CUBIT_FAILURE )
904 : 0 : return NULL;
905 [ # # ]: 0 : assert(co_edge_this != NULL );
906 [ # # ]: 0 : assert(co_edge_next != NULL );
907 : : RefVertex *common_vertex;
908 : :
909 : : //Now according to the sense get the vertex at the
910 : : //end of this edge (start if reversed).
911 [ # # ][ # # ]: 0 : if ( co_edge_this->get_sense() == CUBIT_FORWARD )
912 [ # # ]: 0 : common_vertex = end_vertex();
913 : : else
914 [ # # ]: 0 : common_vertex = start_vertex();
915 : :
916 : : //Lets just do a sanitiy check...
917 [ # # ][ # # ]: 0 : if (common_vertex == NULL ||
[ # # ]
918 [ # # ]: 0 : !next_ref_edge->is_directly_related( common_vertex )) {
919 : :
920 : : // let's check for bad sense, then print warning and return
921 : : // correct vertex
922 [ # # ]: 0 : common_vertex = other_vertex(common_vertex);
923 [ # # ][ # # ]: 0 : if (common_vertex != NULL &&
[ # # ]
924 [ # # ]: 0 : next_ref_edge->is_directly_related( common_vertex )) {
925 : :
926 [ # # ][ # # ]: 0 : PRINT_ERROR(" bad sense between curve %d and surface %d; please"
[ # # ][ # # ]
[ # # ]
927 [ # # ]: 0 : " report this.\n", id(), ref_face_ptr->id());
928 : : }
929 : : else {
930 [ # # ][ # # ]: 0 : PRINT_ERROR("unable to find common vertex (curves %d, %d)",
[ # # ][ # # ]
[ # # ]
931 [ # # ]: 0 : this->id(), next_ref_edge->id());
932 : : assert(CUBIT_TRUE);
933 : 0 : return (RefVertex*)NULL;
934 : : }
935 : : }
936 : : //Hurray, Success...
937 : 0 : return common_vertex;
938 : : }
939 : :
940 : 0 : RefEdge* RefEdge::get_other_curve(RefVertex* common_vertex,
941 : : RefFace* ref_face_ptr)
942 : : {
943 [ # # ]: 0 : DLIList<RefEdge*> curves;
944 [ # # ]: 0 : ref_face_ptr->ref_edges(curves);
945 [ # # ][ # # ]: 0 : for(int ii = curves.size(); ii>0; ii--)
946 : : {
947 [ # # ]: 0 : RefEdge* temp_edge = curves.get_and_step();
948 [ # # ][ # # ]: 0 : if((temp_edge->is_directly_related(common_vertex)) &&
[ # # ][ # # ]
949 : : (this != temp_edge))
950 : 0 : return temp_edge;
951 : : }
952 [ # # ]: 0 : return NULL;
953 : : }
954 : :
955 : :
956 : : //-------------------------------------------------------------------------
957 : : // Purpose : Returns the co_edge that corresponds to 'this' ref_edge
958 : : // and the one that corresponds to next_ref_edge, with
959 : : // respect to the ref_face_ptr.
960 : : // Special Notes : next_ref_edge must follow 'this' ref_edge in a Loop
961 : : // on the ref_face_ptr, this is assumed so the function
962 : : // will assert if this is not done...
963 : : //
964 : : // Creator : David White
965 : : //
966 : : // Creation Date : 03/15/97
967 : : //-------------------------------------------------------------------------
968 : 0 : CubitStatus RefEdge::get_two_co_edges( RefEdge *next_ref_edge,
969 : : RefFace *ref_face_ptr,
970 : : CoEdge *&co_edge_this,
971 : : CoEdge *&co_edge_next )
972 : : {
973 [ # # ]: 0 : DLIList<Loop*> loop_list;
974 : : Loop *loop_ptr;
975 : : CubitStatus status;
976 [ # # ][ # # ]: 0 : DLIList<CoEdge*> co_edge_list;
977 : :
978 : : //First get the loops for this ref_face;
979 [ # # ]: 0 : ref_face_ptr->loops( loop_list );
980 : : //Now we want to find the coedge list that
981 : : //has 'this' refedge followed by the next one
982 [ # # ][ # # ]: 0 : assert( loop_list.size() != 0 );
983 : :
984 [ # # ][ # # ]: 0 : for ( int i = loop_list.size(); i--; )
985 : : {
986 : : // get the ordered co-edges of this loop
987 [ # # ]: 0 : loop_ptr = loop_list.get_and_step();
988 [ # # ]: 0 : co_edge_list.clean_out();
989 [ # # ]: 0 : status = loop_ptr->ordered_co_edges( co_edge_list );
990 : :
991 : : //Now find the coedges corresponding to this ref_edge
992 : : // and the next ref_edge.
993 [ # # ]: 0 : if ( status == CUBIT_SUCCESS ) {
994 [ # # ][ # # ]: 0 : for ( int j = co_edge_list.size(); j--; )
995 : : {
996 : : // candidates
997 [ # # ]: 0 : co_edge_this = co_edge_list.get_and_step();
998 [ # # ]: 0 : co_edge_next = co_edge_list.get();
999 : :
1000 : : // really correspond to this and next edge?
1001 [ # # ][ # # ]: 0 : if ( co_edge_this->get_ref_edge_ptr() == this &&
[ # # ][ # # ]
1002 [ # # ]: 0 : co_edge_next->get_ref_edge_ptr() == next_ref_edge )
1003 : : {
1004 : 0 : return CUBIT_SUCCESS;
1005 : : }
1006 : : }
1007 : : }
1008 : : }
1009 : 0 : co_edge_this = co_edge_next = NULL;
1010 [ # # ][ # # ]: 0 : PRINT_ERROR("in RefEdge::get_two_co_edges.\n"
[ # # ]
1011 : : "Couldn't find CoEdgeList with this edge\n"
1012 [ # # ]: 0 : "and the next edge passed in.\n");
1013 [ # # ]: 0 : return CUBIT_FAILURE;
1014 : : }
1015 : :
1016 : :
1017 : 0 : RefVertex *RefEdge::other_vertex( RefVertex *vertex )
1018 : : {
1019 [ # # ]: 0 : if ( vertex == start_vertex() )
1020 : : {
1021 : 0 : return end_vertex();
1022 : : }
1023 [ # # ]: 0 : else if ( vertex == end_vertex() )
1024 : : {
1025 : 0 : return start_vertex();
1026 : : }
1027 : : else
1028 : : {
1029 : 0 : return NULL;
1030 : : }
1031 : : }
1032 : :
1033 : 0 : RefFace *RefEdge::other_face(RefFace *not_face, RefVolume *ref_volume)
1034 : : {
1035 : : //- return the (an) other face sharing this edge, which also borders
1036 : : //- ref_volume if non-NULL
1037 [ # # ]: 0 : DLIList<RefFace*> temp_faces;
1038 [ # # ]: 0 : ref_faces(temp_faces);
1039 : : int i;
1040 [ # # ][ # # ]: 0 : for (i = temp_faces.size(); i > 0; i--) {
1041 [ # # ]: 0 : RefFace *other_face = temp_faces.get_and_step();
1042 [ # # ][ # # ]: 0 : if (other_face != not_face &&
[ # # ]
1043 [ # # ][ # # ]: 0 : (!ref_volume || other_face->is_directly_related(ref_volume)))
1044 : 0 : return other_face;
1045 : : }
1046 : :
1047 [ # # ]: 0 : return NULL;
1048 : : }
1049 : :
1050 : :
1051 : 20403 : CubitStatus RefEdge::relative_sense( RefEdge *ref_edge_ptr_2,
1052 : : double tolerance_factor,
1053 : : CubitSense *sense,
1054 : : CubitBoolean &spatially_equal,
1055 : : CubitBoolean force_merge)
1056 : : {
1057 : : // It is assumed that the endpoints have been determined to be
1058 : : // spatially equal before this function is called.
1059 : :
1060 : : // Algorithm: Get a point from 'this' (the 1/3 point). See if it
1061 : : // lies on the second RefEdge also, within tolerance. If so,
1062 : : // spatially_equal is set to true. Next, compare the normal directions
1063 : : // at the common point. If they point the same direction (dot product
1064 : : // of tangents is > 0), sense is forward. Else, sense is reversed. If
1065 : : // the tangent dot product is between -.5 and .5, a warning is printed.
1066 : :
1067 : 20403 : const double ONE_THIRD = 1.0/3.0;
1068 [ + - ]: 20403 : if (sense)
1069 : 20403 : *sense = CUBIT_FORWARD;
1070 : : CubitStatus result;
1071 : :
1072 : : // Find the point 1/3 along *this*
1073 [ + - ][ + - ]: 20403 : CubitVector test_point_1, test_point_2;
1074 : : result = this->position_from_fraction( ONE_THIRD,
1075 [ + - ]: 20403 : test_point_1);
1076 [ - + ]: 20403 : if ( result != CUBIT_SUCCESS )
1077 : : {
1078 [ # # ][ # # ]: 0 : PRINT_ERROR("Error in RefEdge::compare(refedges).\n"
[ # # ]
1079 [ # # ]: 0 : "Can't find position 1/3 along curve.\n");
1080 : 0 : return CUBIT_FAILURE;
1081 : : }
1082 : :
1083 : : // See if the 1/3 point on *this* lies on the other curve
1084 [ + - ][ + + ]: 20403 : if ( ref_edge_ptr_2->closest_point_trimmed(test_point_1, test_point_2)
1085 : : != CUBIT_SUCCESS )
1086 : : {
1087 : 1723 : return CUBIT_FAILURE;
1088 : : }
1089 [ + - ][ + + ]: 18680 : if ( GeometryQueryTool::instance()->
1090 [ + - ]: 18680 : about_spatially_equal(test_point_1, test_point_2,tolerance_factor ))
1091 : : {
1092 : 917 : spatially_equal = CUBIT_TRUE;
1093 : : }
1094 [ + - ]: 17763 : else if ( !force_merge )
1095 : : {
1096 : 17763 : return CUBIT_FAILURE;
1097 : : }
1098 : :
1099 : : // Now find the sense
1100 [ + - ]: 917 : if (sense)
1101 : : {
1102 [ + - ][ + - ]: 917 : CubitVector tangent_1, tangent_2;
1103 : : result = this->closest_point(test_point_2,
1104 : : test_point_1,
1105 [ + - ]: 917 : &tangent_1);
1106 [ + - ]: 917 : if (result == CUBIT_SUCCESS)
1107 : : result = ref_edge_ptr_2->closest_point(test_point_1,
1108 : : test_point_2,
1109 [ + - ]: 917 : &tangent_2);
1110 [ - + ]: 917 : if ( result != CUBIT_SUCCESS )
1111 : : {
1112 [ # # ][ # # ]: 0 : PRINT_ERROR("Error in RefEdge::relative_sense(refedges).\n"
[ # # ]
1113 [ # # ]: 0 : "Can't find Curve tangents.\n");
1114 : 0 : return CUBIT_FAILURE;
1115 : : }
1116 : :
1117 : : // Find the sense
1118 : :
1119 : : //If one of the curves is zero-length, it will have a zero
1120 : : //tangent vector.
1121 [ + - ][ + - ]: 917 : double len_product = tangent_1.length() * tangent_2.length();
1122 [ + - ]: 917 : if( len_product > CUBIT_DBL_MIN )
1123 : : {
1124 : :
1125 [ + - ]: 917 : double dot_product = (tangent_1 % tangent_2) / len_product;
1126 [ + + ]: 917 : if (dot_product < 0)
1127 : 917 : *sense = CUBIT_REVERSED;
1128 : : //if (dot_product > -.5 && dot_product < .5)
1129 : : // tangent_warning = CUBIT_TRUE;
1130 : : }
1131 : : else
1132 : : {
1133 : : //If one of the tangents is zero-length, one of the curves had
1134 : : //better be as well.
1135 [ # # ][ # # ]: 917 : assert( (measure() * ref_edge_ptr_2->measure()) < CUBIT_RESABS );
[ # # ]
1136 : : }
1137 : : }
1138 : 20403 : return CUBIT_SUCCESS;
1139 : : }
1140 : :
1141 : : //-------------------------------------------------------------------------
1142 : : // Purpose : Spatially compare two RefEdges. Does not go down to EDGE
1143 : : // level. It does it at the ref_edge level so the parameter
1144 : : // values are consistant.
1145 : : //
1146 : : // Special Notes :
1147 : : //
1148 : : // Creator : David White
1149 : : //
1150 : : // Creation Date : 04/07/97
1151 : : //-------------------------------------------------------------------------
1152 : 20425 : CubitBoolean RefEdge::about_spatially_equal(
1153 : : RefEdge* ref_edge_ptr_2,
1154 : : double tol_factor,
1155 : : CubitSense* sensePtr,
1156 : : CubitBoolean notify_refEntity )
1157 : :
1158 : : {
1159 [ + + ]: 20425 : if( this == ref_edge_ptr_2)
1160 : : {
1161 [ + - ]: 418 : if (sensePtr)
1162 : 418 : *sensePtr = CUBIT_FORWARD;
1163 [ + - ]: 418 : if (notify_refEntity)
1164 [ + - ]: 418 : remove_compare_data();
1165 : 418 : return CUBIT_TRUE;
1166 : : }
1167 : :
1168 : 20007 : CubitBoolean spatially_equal = CUBIT_FALSE;
1169 : 20007 : CubitSense rel_sense = CUBIT_FORWARD;
1170 : 20007 : CubitStatus stat = CUBIT_SUCCESS;
1171 : : stat = relative_sense( ref_edge_ptr_2, tol_factor,
1172 [ + - ]: 20007 : &rel_sense, spatially_equal);
1173 : :
1174 [ + + ][ - + ]: 20007 : if (stat != CUBIT_SUCCESS || !spatially_equal)
1175 : : {
1176 : 19486 : return CUBIT_FALSE;
1177 : : }
1178 : :
1179 [ + - ]: 521 : if (sensePtr)
1180 : 521 : *sensePtr = rel_sense;
1181 : :
1182 : : //compare the start and end vertices to be spatially equal.
1183 [ + - ]: 521 : RefVertex* this_start = start_vertex();
1184 [ + - ]: 521 : RefVertex* this_end = end_vertex();
1185 [ + - ]: 521 : RefVertex* edge2_start = ref_edge_ptr_2->start_vertex();
1186 [ + - ]: 521 : RefVertex* edge2_end = ref_edge_ptr_2->end_vertex();
1187 : :
1188 : : // Swap vertices to simplify things later.
1189 [ + + ]: 521 : if (rel_sense == CUBIT_REVERSED)
1190 [ + - ]: 86 : std::swap(edge2_start, edge2_end);
1191 : :
1192 : : //compare vertex locations unless force_merge is true.
1193 : : // closed curve case
1194 [ + + ][ - + ]: 521 : if (this_start == this_end || edge2_start == edge2_end)
1195 : : {
1196 [ + - ][ - + ]: 80 : if ((this_start != this_end) ||
1197 [ + - ][ - + ]: 80 : (edge2_start != edge2_end) ||
1198 [ + - ]: 40 : !this_start->about_spatially_equal(edge2_start, tol_factor, CUBIT_FALSE))
1199 : 0 : return CUBIT_FALSE;
1200 : : }
1201 : : else
1202 : : {
1203 [ + - ][ - + ]: 962 : if ((this_start == edge2_end) ||
1204 [ + - ]: 481 : (this_end == edge2_start) ||
1205 [ + - ][ + - ]: 1443 : !this_start->about_spatially_equal(edge2_start, tol_factor, CUBIT_FALSE) ||
[ - + ]
1206 [ + - ]: 481 : !this_end->about_spatially_equal(edge2_end, tol_factor, CUBIT_FALSE))
1207 : 0 : return CUBIT_FALSE;
1208 : : }
1209 : :
1210 : : //Now if they match report it.
1211 : : //Do vertices explicitly here rather than in
1212 : : //RefVertex::about_spatially_equal(..) because we don't call
1213 : : //RefVertex::about_spatially_equal(..) if force_merge is true.
1214 [ + - ]: 521 : if (notify_refEntity)
1215 : : {
1216 [ + - ][ + - ]: 521 : this->comparison_found(ref_edge_ptr_2);
1217 [ + + ]: 521 : if (this_start != edge2_start)
1218 [ + - ][ + - ]: 481 : this_start->comparison_found(edge2_start);
1219 : : else
1220 [ + - ]: 40 : this_start->remove_compare_data();
1221 [ + + ]: 521 : if (this_end != edge2_end)
1222 [ + - ][ + - ]: 481 : this_end->comparison_found(edge2_end);
1223 : : else
1224 [ + - ]: 521 : this_end->remove_compare_data();
1225 : : }
1226 : :
1227 : 20425 : return CUBIT_TRUE;
1228 : : }
1229 : :
1230 : 0 : int RefEdge::validate()
1231 : : {
1232 : : //- This function determines whether the entity is valid.
1233 : : //- Several types of checks can be done,
1234 : 0 : int error = 0;
1235 : :
1236 : : // Perform general RefEntity checks (measure > 0)
1237 : 0 : error += RefEntity::validate();
1238 : :
1239 : : // Pass through to curve and add in its validation
1240 : 0 : Curve *curve = get_curve_ptr();
1241 : :
1242 : : // check curve ptr
1243 [ # # ]: 0 : if (curve != NULL) {
1244 : : // Check underlying curve
1245 [ # # ]: 0 : DLIList <TopologyEntity*> bad_entities;
1246 [ # # ][ # # ]: 0 : error += curve->validate(entity_name(),bad_entities);
[ # # ][ # # ]
1247 : : } else {
1248 [ # # ][ # # ]: 0 : PRINT_WARNING("\tWARNING: Null underlying curve for %s, (%s %d)\n",
[ # # ][ # # ]
1249 [ # # ]: 0 : entity_name().c_str(), class_name(), id());
1250 : 0 : error++;
1251 : : }
1252 : 0 : return error;
1253 : : }
1254 : :
1255 : : // ********** END PUBLIC FUNCTIONS **********
1256 : :
1257 : : // ********** BEGIN PROTECTED FUNCTIONS **********
1258 : : // ********** END PROTECTED FUNCTIONS **********
1259 : :
1260 : : // ********** BEGIN PRIVATE FUNCTIONS **********
1261 : :
1262 : : //-------------------------------------------------------------------------
1263 : : // Purpose : Initializes the member data of the RefEdge
1264 : : //
1265 : : // Special Notes :
1266 : : //
1267 : : // Creator : Malcolm J. Panthaki
1268 : : //
1269 : : // Creation Date : 10/07/96
1270 : : //-------------------------------------------------------------------------
1271 : 35251 : void RefEdge::initialize()
1272 : : {
1273 : : // Initialize some member data
1274 : 35251 : refEdgeClone = 0;
1275 : 35251 : markedFlag = CUBIT_FALSE;
1276 : :
1277 : : // Make sure the arc length is not zero if there are start and end
1278 : : // RefVertex'es already assigned to this RefEdge
1279 [ - + ]: 35251 : if ( get_arc_length() < CUBIT_DBL_MIN )
1280 : : {
1281 [ # # ][ # # ]: 0 : if ( start_vertex() && end_vertex() )
[ # # ]
1282 : : {
1283 [ # # ][ # # ]: 0 : CubitVector start_pt = start_vertex()->coordinates();
1284 [ # # ][ # # ]: 0 : CubitVector end_pt = end_vertex()->coordinates();
1285 [ # # ][ # # ]: 0 : PRINT_WARNING ( "(RefEdge::initialize): Edge has zero arclength.\n"
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1286 : : " Start vertex location is (%9.2f, %9.2f, %9.2f ).\n"
1287 : : " End vertex location is (%9.2f, %9.2f, %9.2f ).\n",
1288 : : start_pt.x(), start_pt.y(), start_pt.z(),
1289 [ # # ]: 0 : end_pt.x(), end_pt.y(), end_pt.z() );
1290 : : }
1291 [ # # ]: 0 : else if (!mSuppressEdgeLengthWarning)
1292 : : {
1293 [ # # ]: 0 : PRINT_WARNING( "Edge found with zero arclength\n"
1294 [ # # ]: 0 : " For cones, this may be normal.\n");
1295 : : }
1296 : :
1297 : : }
1298 : :
1299 : : // Set the Entity ID for this new RefEdge
1300 : 35251 : GeometryEntity* geom_ptr = get_geometry_entity_ptr();
1301 : 35251 : int saved_id = geom_ptr->get_saved_id();
1302 [ - + ][ # # ]: 35251 : if ( !saved_id || RefEntityFactory::instance()->get_ref_edge(saved_id) )
[ + - ]
1303 : : {
1304 : 35251 : saved_id = RefEntityFactory::instance()->next_ref_edge_id();
1305 : 35251 : geom_ptr->set_saved_id(saved_id);
1306 : : }
1307 : 35251 : entityId = saved_id;
1308 : :
1309 : : // read and initialize attributes
1310 : 35251 : auto_read_cubit_attrib();
1311 : 35251 : auto_actuate_cubit_attrib();
1312 : :
1313 : : // Assign a default entity name
1314 : 35251 : assign_default_name();
1315 : 35251 : }
1316 : :
1317 : : //-------------------------------------------------------------------------
1318 : : // Purpose : Return a pointer to the start RefVertex of this RefEdge.
1319 : : //
1320 : : // Special Notes : The assumption is that there is only 1 Chain associated
1321 : : // with each RefEdge. Also, the RefVertex associated with
1322 : : // the first CoVertex in this Chain is the start RefVertex
1323 : : // of this RefEdge and the RefVertex associated with the
1324 : : // last CoVertex in this Chain is the end RefVertex of this
1325 : : // RefEdge.
1326 : : //
1327 : : // Creator : Malcolm J. Panthaki
1328 : : //
1329 : : // Creation Date : 10/21/96
1330 : : //-------------------------------------------------------------------------
1331 : 20432 : RefVertex* RefEdge::start_vertex()
1332 : : {
1333 : : // Get the first (and only) Chain associated with this RefEdge.
1334 : 20432 : Chain* chain_ptr = this->get_chain_ptr();
1335 : :
1336 : : // Ask the Chain for its first RefVertex
1337 [ + + ]: 20432 : if (chain_ptr == NULL)
1338 : : {
1339 : 40 : return NULL;
1340 : : }
1341 : :
1342 : : else
1343 : : {
1344 : 20392 : return chain_ptr->start_vertex();
1345 : : }
1346 : : }
1347 : :
1348 : : //-------------------------------------------------------------------------
1349 : : // Purpose : Return a pointer to the end RefVertex of this RefEdge.
1350 : : //
1351 : : // Special Notes : The assumption is that there is only 1 Chain associated
1352 : : // with each RefEdge. Also, the RefVertex associated with
1353 : : // the first CoVertex in this Chain is the start RefVertex
1354 : : // of this RefEdge and the RefVertex associated with the
1355 : : // last CoVertex in this Chain is the end RefVertex of this
1356 : : // RefEdge.
1357 : : //
1358 : : // Creator : Malcolm J. Panthaki
1359 : : //
1360 : : // Creation Date : 10/21/96
1361 : : //-------------------------------------------------------------------------
1362 : 20410 : RefVertex* RefEdge::end_vertex()
1363 : : {
1364 : : // Get the first (and only) Chain associated with this RefEdge.
1365 : 20410 : Chain* chain_ptr = get_chain_ptr();
1366 : :
1367 : : // Ask the Chain for its end (last) RefVertex
1368 [ + + ]: 20410 : if (chain_ptr == NULL)
1369 : : {
1370 : 40 : return NULL;
1371 : : }
1372 : :
1373 : : else
1374 : : {
1375 : 20370 : return chain_ptr->end_vertex();
1376 : : }
1377 : : }
1378 : :
1379 : 0 : void RefEdge::reverse_topology()
1380 : : {
1381 [ # # ]: 0 : Chain* chain_ptr = get_chain_ptr();
1382 [ # # ]: 0 : chain_ptr->reverse_direction();
1383 : :
1384 : : // switch co_edge senses
1385 [ # # ]: 0 : DLIList<SenseEntity*> co_edge_list;
1386 [ # # ]: 0 : get_sense_entity_list(co_edge_list);
1387 [ # # ][ # # ]: 0 : for ( int i = co_edge_list.size(); i--; )
1388 [ # # ][ # # ]: 0 : co_edge_list.get_and_step()->reverse_sense();
[ # # ]
1389 : 0 : }
1390 : :
1391 : 104 : CubitSense RefEdge::sense( RefFace *face )
1392 : : {
1393 [ + - ]: 104 : DLIList<CoEdge*> co_edge_list;
1394 [ + - ]: 104 : get_co_edges(co_edge_list, face);
1395 : : CoEdge *coedge;
1396 : 104 : CubitSense my_sense = CUBIT_UNKNOWN;
1397 [ + - ][ + + ]: 208 : for ( int i = co_edge_list.size(); i--; ) {
1398 [ + - ]: 104 : coedge = co_edge_list.get_and_step();
1399 [ + - ][ + + ]: 104 : if(coedge->get_sense() == CUBIT_FORWARD)
1400 : : {
1401 [ - + ]: 11 : if (my_sense == CUBIT_REVERSED)
1402 : 0 : return CUBIT_UNKNOWN;
1403 : 11 : my_sense = CUBIT_FORWARD;
1404 : : }
1405 : : else
1406 : : {
1407 [ - + ]: 93 : if (my_sense == CUBIT_FORWARD)
1408 : 0 : return CUBIT_UNKNOWN;
1409 : 93 : my_sense = CUBIT_REVERSED;
1410 : : }
1411 : : }
1412 [ + - ]: 104 : return my_sense;
1413 : : }
1414 : :
1415 : 0 : CubitBoolean RefEdge::is_tolerant()
1416 : : {
1417 : 0 : Curve* curve_ptr = get_curve_ptr();
1418 [ # # ]: 0 : if (curve_ptr == NULL) {
1419 [ # # ][ # # ]: 0 : PRINT_WARNING("\tWARNING: Null underlying curve for %s, (%s %d)\n",
[ # # ][ # # ]
1420 [ # # ]: 0 : entity_name().c_str(), class_name(), id());
1421 : 0 : return CUBIT_FALSE;
1422 : : }
1423 : :
1424 : 0 : return curve_ptr->is_tolerant();
1425 : : }
1426 : :
1427 : 0 : CubitVector RefEdge::curve_center()
1428 : : {
1429 [ # # ][ # # ]: 0 : CubitVector p1 = start_vertex()->coordinates();
1430 [ # # ][ # # ]: 0 : CubitVector p2 = end_vertex()->coordinates();
1431 [ # # ][ # # ]: 0 : if ( start_vertex() == end_vertex() )
[ # # ]
1432 : : {
1433 [ # # ]: 0 : mid_point(p2);
1434 : : }
1435 [ # # ]: 0 : p1 += p2;
1436 [ # # ]: 0 : p1 /= 2.0;
1437 : 0 : return p1;
1438 : : }
1439 : :
1440 : 5832 : CubitStatus RefEdge::get_graphics( GMem& polyline, double angle_tolerance,
1441 : : double distance_tolerance,
1442 : : double max_edge_length )
1443 : : {
1444 : 5832 : Curve* curve_ptr = get_curve_ptr();
1445 [ - + ]: 5832 : if (!curve_ptr)
1446 : : {
1447 [ # # ][ # # ]: 0 : PRINT_ERROR("RefEdge %d is invalid -- no attached Curve.\n",id());
1448 : 0 : return CUBIT_FAILURE;
1449 : : }
1450 : :
1451 : 5832 : return curve_ptr->get_geometry_query_engine()->get_graphics(curve_ptr,
1452 : 5832 : &polyline, angle_tolerance, distance_tolerance, max_edge_length );
1453 : : }
1454 : :
1455 : : //-------------------------------------------------------------------------
1456 : : // Purpose : Reverse RefEdge sense relative to Curve(s)
1457 : : //
1458 : : // Special Notes :
1459 : : //
1460 : : // Creator : Jason Kraftcheck
1461 : : //
1462 : : // Creation Date : 10/14/03
1463 : : //-------------------------------------------------------------------------
1464 : 0 : void RefEdge::reverse_tangent()
1465 : : {
1466 : 0 : bridge_manager()->reverse_bridge_senses();
1467 : 0 : reverse_topology();
1468 : 0 : }
1469 : :
1470 : 0 : void RefEdge::suppress_edge_length_warning(bool flag)
1471 : : {
1472 : 0 : mSuppressEdgeLengthWarning = flag;
1473 : 0 : }
1474 : :
1475 : 0 : CubitStatus RefEdge::evaluate_exterior_angle(double *exterior_angle)
1476 : : {
1477 : : //- Get the center point of this curve
1478 [ # # ]: 0 : CubitVector center = this->center_point();
1479 [ # # ][ # # ]: 0 : CubitVector surf_norm[2];
1480 [ # # ]: 0 : CubitVector tangent;
1481 : 0 : RefFace* ref_face = NULL;
1482 : 0 : RefEdge* next_curve = NULL;
1483 : :
1484 : : int i, j, k;
1485 : :
1486 : : //- Get surfaces on this curve
1487 [ # # ]: 0 : DLIList<RefFace*> surf_list;
1488 [ # # ]: 0 : this->ref_faces(surf_list);
1489 [ # # ][ # # ]: 0 : if(surf_list.size() == 2)
1490 : : {
1491 [ # # ][ # # ]: 0 : for( i = 0; i < surf_list.size(); i++)
1492 : : {
1493 [ # # ]: 0 : RefFace* this_surf = surf_list.get_and_step();
1494 [ # # ][ # # ]: 0 : surf_norm[i] = this_surf->normal_at(center);
1495 [ # # ]: 0 : if( i == 1)
1496 : : {
1497 : : //- Get the referance surface and curve to get exterior angle
1498 : 0 : ref_face = this_surf;
1499 [ # # ]: 0 : DLIList<DLIList<RefEdge*> > loop_lists;
1500 [ # # ]: 0 : ref_face->ref_edge_loops(loop_lists);
1501 [ # # ][ # # ]: 0 : for( j = 0; j < loop_lists.size(); j++ )
1502 : : {
1503 [ # # ]: 0 : DLIList<RefEdge*>& current_list = loop_lists[j];
1504 [ # # ][ # # ]: 0 : for( k = 0; k < current_list.size(); k++ )
1505 : : {
1506 [ # # ]: 0 : RefEdge* current_curve = current_list.get_and_step();
1507 [ # # ]: 0 : if( current_curve == this )
1508 : : {
1509 [ # # ]: 0 : next_curve = current_list.get();
1510 : 0 : break;
1511 : : }
1512 : : }
1513 [ # # ]: 0 : if(next_curve != NULL)
1514 : 0 : break;
1515 [ # # ]: 0 : }
1516 : : }
1517 : : }
1518 : : }
1519 : : else
1520 : : {
1521 : 0 : *exterior_angle = 0.0;
1522 [ # # ][ # # ]: 0 : PRINT_ERROR("There aren't 2 surfaces on curve %d. Can't compute angle.\n", this->id());
[ # # ][ # # ]
[ # # ]
1523 : 0 : return CUBIT_FAILURE;
1524 : : }
1525 : :
1526 [ # # ]: 0 : this->tangent(center, tangent, next_curve, ref_face);
1527 : :
1528 : : //Find the angle from normal 1 to normal 0.
1529 [ # # ]: 0 : double rad_angle = tangent.vector_angle_quick(surf_norm[1], surf_norm[0]); //angle in radians
1530 : 0 : double angle = rad_angle * (180.0 / 3.14159); //angle in degrees
1531 : :
1532 : : //Now convert to the exterior angle between the two surfaces.
1533 : 0 : angle += 180.0;
1534 [ # # ]: 0 : if( angle > 360.0 )
1535 : 0 : angle -= 360.0;
1536 : :
1537 : : //- Return the exterior angle for this curve in degrees.
1538 : 0 : *exterior_angle = angle;
1539 [ # # ]: 0 : return CUBIT_SUCCESS;
1540 : : }
1541 : :
1542 : 924 : void RefEdge::get_parent_ref_entities(DLIList<RefEntity*>& entity_list)
1543 : : {
1544 : :
1545 : : // First get the type of RefEntity that is a child of "this" one
1546 [ + - ]: 924 : DagType parent_type = get_parent_ref_entity_type();;
1547 : :
1548 [ + - ]: 924 : DLIList<TopologyEntity*> tempList ;
1549 : :
1550 : : CubitStatus result = ModelQueryEngine::instance()->
1551 [ + - ][ + - ]: 924 : query_model( *this, parent_type, tempList );
1552 [ - + ]: 924 : if (result == CUBIT_FAILURE)
1553 : : {
1554 [ # # ][ # # ]: 0 : PRINT_ERROR("In RefEntity::get_parent_ref_entities\n");
[ # # ][ # # ]
1555 [ # # ][ # # ]: 0 : PRINT_ERROR(" Query failed for unknown reason.\n");
[ # # ][ # # ]
1556 : 924 : return;
1557 : : }
1558 : :
1559 [ + - ]: 924 : entity_list.clean_out();
1560 [ + - ][ + + ]: 2752 : for(int i=0; i<tempList.size(); i++)
[ + - ][ + - ]
1561 : : {
1562 [ + - ][ + - ]: 1828 : entity_list.append(static_cast<ParentType*>(tempList[i]));
[ + - ]
1563 : 924 : }
1564 [ + - ][ + - ]: 6540 : }
|
