Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : Curve.hpp
3 : : //
4 : : // Purpose :
5 : : //
6 : : // Special Notes :
7 : : //
8 : : // Creator : Xuechen Liu
9 : : //
10 : : // Creation Date : 08/02/96
11 : : //
12 : : // Owner : Malcolm J. Panthaki
13 : : //-------------------------------------------------------------------------
14 : :
15 : : #ifndef CURVE_HPP
16 : : #define CURVE_HPP
17 : :
18 : : // ********** BEGIN STANDARD INCLUDES **********
19 : : // ********** END STANDARD INCLUDES **********
20 : :
21 : : // ********** BEGIN CUBIT INCLUDES **********
22 : : #include "CubitDefines.h"
23 : : #include "RefEdge.hpp"
24 : :
25 : : #include "GeometryEntity.hpp"
26 : : // ********** END CUBIT INCLUDES **********
27 : :
28 : : // ********** BEGIN FORWARD DECLARATIONS **********
29 : : template <class X> class DLIList;
30 : : class FacetEvalTool;
31 : : class TBPoint;
32 : : // ********** END FORWARD DECLARATIONS **********
33 : :
34 : : // ********** BEGIN ENUM DEFINITIONS **********
35 : : // ********** END ENUM DEFINITIONS **********
36 : :
37 : : class CUBIT_GEOM_EXPORT Curve : public GeometryEntity
38 : : {
39 : : public :
40 : :
41 : : Curve();
42 : : //- The default constructor
43 : :
44 : : virtual ~Curve();
45 : : //- The destructor
46 : :
47 : : typedef TBPoint ChildType;
48 : :
49 : : virtual CubitSense relative_sense(Curve *other_curve);
50 : : //- given another curve, return whether the curves are "aligned" (CUBIT_FORWARD),
51 : : //- oppositely aligned (CUBIT_REVERSED), or inconclusive (CUBIT_UNKNOWN)
52 : :
53 : : virtual CubitStatus get_point_direction( CubitVector& origin,
54 : : CubitVector& direction );
55 : : //- Only valid for straight lines
56 : : //- Finds the underlying line's origin and direction unit vector
57 : : //- Returns CUBIT_FAILURE if curve is not a line
58 : :
59 : : virtual CubitStatus get_center_radius( CubitVector& center, double& radius ) = 0;
60 : : //- Only valid for arcs
61 : : //- Finds the underlying arc's center point and radius
62 : : //- Returns CUBIT_FAILURE if curve is not an arc
63 : :
64 : : virtual double length_from_u( double parameter1,
65 : : double parameter2 ) = 0;
66 : : //R double
67 : : //R- Returned length value
68 : : //I parameter1
69 : : //I- The first parameter value
70 : : //I parameter2
71 : : //I- The second parameter value
72 : : //- This function returns the arc length along the Curve starting from
73 : : //- the point represented by the parameter1 going to the point represented
74 : : //- by parameter2.
75 : : //-
76 : : //- The sign of the returned length value depends on the order of the parameters passed in.
77 : :
78 : : virtual double get_arc_length();
79 : : //R double
80 : : //R- Returned total length value
81 : : //- This function returns the arc length along the entire Curve
82 : :
83 : : virtual double get_arc_length( const CubitVector &point1,
84 : : const CubitVector &point2 );
85 : : //R double
86 : : //R- Returned length value
87 : : //I point1
88 : : //I- The first position value
89 : : //I point2
90 : : //I- The second position value
91 : : //- This function returns the arc length along the Curve starting from
92 : : //- the point1 going to point2
93 : : //- the length returned is always positive.
94 : :
95 : : virtual double get_arc_length( const CubitVector &point1,
96 : : const int which_end );
97 : : //R double
98 : : //R- Returned length value
99 : : //I point1
100 : : //I- The first position value
101 : : //I which_end
102 : : //I- 0 for start, 1 for end
103 : : //- This function returns the arc length along the Curve starting from
104 : : //- point1 going to either the start or the end
105 : : //- the length returned is always positive.
106 : :
107 : : virtual CubitVector center_point();
108 : : //R CubitVector
109 : : //R- center point on this edge
110 : : //- This function returns the center point on this edge, by
111 : : //- arc length
112 : :
113 : : virtual CubitStatus mid_point(const CubitVector &point1,
114 : : const CubitVector &point2,
115 : : CubitVector& mid_point );
116 : : //R CubitStatus
117 : : //I CubitVector, CubitVector
118 : : //I- points between which the mid_point is needed
119 : : //O CubitVector
120 : : //O- mid point on this edge
121 : : //- This function returns the mid point between two points on this
122 : : //-edge, by parameter
123 : :
124 : : virtual CubitStatus mid_point(CubitVector& mid_point);
125 : : //R CubitStatus
126 : : //O CubitVector
127 : : //O- mid point on this edge
128 : : //- This function returns the mid point on this edge, by parameter
129 : :
130 : : virtual CubitStatus position_from_fraction( const double fraction_along_curve,
131 : : CubitVector &output_position );
132 : : //R CubitStatus
133 : : //I fraction in parameter space along curve (1/3,2/3,4/5...)
134 : : //O- position where percent in parameter space lies.
135 : : //-This function takes the given fraction, finds the parameter value,
136 : : //-and calculates this position.
137 : :
138 : : virtual CubitBoolean is_periodic( double& period) = 0;
139 : : //R CubitBoolean
140 : : //R- CUBIT_TRUE/CUBIT_FALSE
141 : : //O period
142 : : //O- Returned period value
143 : : //- This function determines whether the underlying geometry of the
144 : : //- Curve is periodic or not. Returns CUBIT_TRUE if it is and
145 : : //- CUBIT_FALSE if it is not.
146 : : //-
147 : : //- If it is periodic, then it returns the period in the input
148 : : //- reference variable, "period". This value is set to 0.0 if
149 : : //- the Curve is not periodic.
150 : :
151 : : virtual CubitBoolean get_param_range( double& lower_bound,
152 : : double& upper_bound ) = 0;
153 : : //R CubitBoolean
154 : : //R- CUBIT_TRUE/CUBIT_FALSE
155 : : //O lower_bound
156 : : //O- The lower bound of the parametric range.
157 : : //O upper_bound
158 : : //O- The upper bound of the parametric range.
159 : : //- Returns the lower and upper parametric bounds of the
160 : : //- Curve, based on the extent of the its first underlying entity.
161 : : //- The boolean return value indicates whether the Curve is
162 : : //- parametrically defined or not -- returns CUBIT_TRUE if yes and
163 : : //- CUBIT_FALSE, otherwise. If the Curve is not parametrically
164 : : //- defined, the values of the upper and lower bounds are
165 : : //- undetermined.
166 : : //-
167 : : //- IMPORTANT NOTE:
168 : : //- Note that the lower bound is the parameter value of the start
169 : : //- location of the RefEdge that uses this Curve and the upper
170 : : //- bound is the parameter value of the end location of the RefEdge
171 : : //- that uses this Curve. This takes into account the sense of the
172 : : //- RefEdge with respect to the Curve (which could be REVERSED).
173 : : //- Hence, the numerical value of the lower parameter bound could be
174 : : //- greater than that of the upper parameter bound.
175 : :
176 : : virtual CubitStatus get_interior_extrema(DLIList<CubitVector*>& interior_points,
177 : : CubitSense& return_sense) = 0;
178 : : //- Finds the extrema along this RefEdge. An extremum is defined as
179 : : //- a local min or max in the direction of one of the primary axial directions.
180 : : //- O-interior_points: list of coordinates where the extrema occur.
181 : : //- O-return_sense: Whether the interior extrema are ordered in the
182 : : //- FORWARD or REVERSED direction of this RefEdge.
183 : : //-
184 : : //- ***IMPORTANT!!!***
185 : : //- This function dynamically allocates the CubitVectors appended to
186 : : //- interior_points. It is the responsibility of the calling code to
187 : : //- delete these CubitVectors (or in the case of RefEdge, to make sure
188 : : //- that *it's* calling code knows that it should delete the CubitVectors)!
189 : :
190 : : virtual CubitStatus closest_point( CubitVector const& location,
191 : : CubitVector& closest_location,
192 : : CubitVector* tangent_ptr = NULL,
193 : : CubitVector* curvature_ptr = NULL,
194 : : double *param = NULL) = 0;
195 : : //R void
196 : : //I location
197 : : //I- The point to which the closest point on the Curve is desired.
198 : : //O closest_location
199 : : //O- The point on the Curve, closest to the input location which
200 : : //O- might not be on the Curve. This is input as a reference
201 : : //O- so that the function can modify its contents.
202 : : //O tangent_ptr
203 : : //O- The tangent to the Curve (output as a unit vector) at the
204 : : //O- closest_location.
205 : : //O curvature_ptr
206 : : //O- The curvature of the Curve at the closest_location.
207 : : //- This function computes the point on the Curve closest to the input
208 : : //- location.
209 : : //-
210 : : //- If the tangent and/or curvature is required, then the calling code
211 : : //- is responsible for allocating space for the CubitVector(s) and
212 : : //- sending in the relevant non-NULL pointers. If either of these
213 : : //- pointers is NULL, the related quantity is not computed.
214 : : //-
215 : : //- Notes:
216 : : //- The tangent direction is always in the positive direction of the
217 : : //- *owning RefEdge*, regardless of the positive direction of the
218 : : //- underlying solid model entities, if any.
219 : :
220 : : virtual CubitStatus closest_point_trimmed( CubitVector const& from_pt,
221 : : CubitVector& result_pt );
222 : : //R CubitStatus
223 : : //R- CUBIT_SUCCESS/CUBIT_FAILURE
224 : : //I from_pt
225 : : //I- The position to evaluate wrt curve.
226 : : //I result_pt
227 : : //I- The resulting point on the curve.
228 : : //- This method finds the closest point to a BOUNDED curve.
229 : : //
230 : : // Added by Jason Kraftcheck, 07/17/98.
231 : : // See also: Curve::closest_point_trimmed(..).
232 : :
233 : : virtual CubitPointContainment point_containment( const CubitVector &point ) = 0;
234 : : //R CubitPointContainment - is the point on bounds of the curve?
235 : : //R- CUBIT_PNT_OFF, CUBIT_PNT_ON, CUBIT_PNT_UNKNOWN
236 : : //I CubitVector
237 : : //I- position to check, known to be on the Curve
238 : : // NOTE: POINT MUST LIE ON THE CURVE FOR THIS FUNCTION TO WORK PROPERLY.
239 : :
240 : : virtual double u_from_position (const CubitVector& input_position) = 0;
241 : : //R double
242 : : //R- The returned "u" parameter value in local parametric space
243 : : //I input_position
244 : : //I- The input position for which "u" is to be computed.
245 : : //- This function returns the coordinate of a point in the local
246 : : //- parametric (u) space that corresponds to the input position in
247 : : //- global (world) space. The input point is first moved to the
248 : : //- closest point on the Curve and the parameter value of that
249 : : //- point is determined.
250 : :
251 : : virtual CubitStatus position_from_u (double u_value,
252 : : CubitVector& output_position) = 0;
253 : : //R CubitStatus
254 : : //R- CUBIT_SUCCESS/FAILURE
255 : : //I u_value
256 : : //I- The input u parameter value
257 : : //O output_position
258 : : //O- The output position
259 : : //- This function returns the coordinates of a point in the global
260 : : //- (world) space that corresponds to the input parametric position
261 : : //- in the local space.
262 : : //-
263 : : //- If the input parameter value is not defined for the Curve, then
264 : : //- the input CubitVector is not modified and CUBIT_FAILURE is
265 : : //- returned. Otherwise, position is appropriately modified and
266 : : //- CUBIT_SUCCESS is returned.
267 : : //-
268 : : //- If the curve is periodic, the input u_value is first "normalized"
269 : : //- to the fundamental period of the Curve before its position
270 : : //- in global space is determined.
271 : :
272 : : virtual double u_from_arc_length ( double root_param,
273 : : double arc_length ) = 0;
274 : : //R double
275 : : //R- Returned parameter value
276 : : //I root_param
277 : : //I- The parameter value of the "root point"
278 : : //I arc_length
279 : : //I- A distance along the Curve
280 : : //- This function returns the parameter value of the point that is
281 : : //- "arc_length" away from the root point in the
282 : : //- positive sense direction of the owning RefEdge.
283 : : //-
284 : : //- A negative value for distance would force the search to go in the
285 : : //- negative (sense) direction of the RefEdge.
286 : : //-
287 : : //- NOTE:
288 : : //- The important assumption that is made in this routine is that
289 : : //- the end points of the RefEdge that owns this Curve are the same
290 : : //- as the end points of the first solid model entity in the list of
291 : : //- solid model entities associated with this Curve.
292 : :
293 : : virtual CubitBoolean is_position_on( const CubitVector &test_position ) = 0;
294 : : //R CubitBoolean
295 : : //R- CUBIT_TRUE/CUBIT_FALSE
296 : : //I CubitVector
297 : : //I- position, point where we want to test, whether or not it
298 : : //- is on the curve.
299 : :
300 : 0 : virtual GeometryType geometry_type()
301 : 0 : {return UNDEFINED_CURVE_TYPE;};
302 : : //R GeometryType (enum)
303 : : //R- The enumerated type of the geometric representation
304 : :
305 : : virtual double start_param() = 0;
306 : : //R double parameter
307 : : //R- start parameter of curve with respect to refEdge.
308 : :
309 : : virtual double end_param() = 0;
310 : : //R double parameter
311 : : //R- start parameter of curve with respect to refEdge.
312 : :
313 : : virtual CubitStatus point_from_arc_length( double root_param,
314 : : const double arc_length,
315 : : CubitVector &new_point);
316 : :
317 : : //R CubitStatus
318 : : //R- CUBIT_SUCCESS, CUBIT_FAILURE
319 : : //I- root_param-starting parameter for point on curve from which arc_length extends.
320 : : //O- new_point, from starting parameter by arc_lenth.
321 : :
322 : : virtual CubitStatus point_from_arc_length( const CubitVector &root_point,
323 : : double const arc_length,
324 : : CubitVector& new_point );
325 : : //R void
326 : : //R- pointer to void
327 : : //I- root_point-point from which arc_length extends.
328 : : //O- new_point, from root_point by arc_lenth.
329 : :
330 : : //========= Add Code by SRS of Cat, 3/3/99 2:34:50 PM =========
331 : 0 : virtual CubitBoolean is_tolerant(){ return CUBIT_FALSE; };
332 : : //- This function is overloaded in the Curve class only.
333 : : //- Tolerant edges can get created by the healer if the
334 : : //- edge cannot be healed.
335 : : //========= Code End by SRS of Cat, 3/3/99 2:34:50 PM =========
336 : :
337 : : virtual CubitBoolean G1_discontinuous( double u,
338 : : CubitVector* minus_tangent = NULL,
339 : : CubitVector* plus_tangent = NULL );
340 : : //R CubitBoolean
341 : : //R- CUBIT_TRUE/CUBIT_FALSE
342 : : //I u
343 : : //I- The parameter value on the curve to test at.
344 : : //O minus_tanget
345 : : //O- The tangent direction on the decreasing-parameter-value
346 : : //O- side of u. This vector, if passed, will only be changed
347 : : //O- when the return value is CUBIT_TRUE.
348 : : //O plus_tanget
349 : : //O- The tangent direction on the increasing-parameter-value
350 : : //O- side of u. This vector, if passed, will only be changed
351 : : //O- when the return value is CUBIT_TRUE.
352 : : //- Check for a G1 discontinuity in a curve. Derived classes should
353 : : //- override the function with a more exact implementation. The
354 : : //- default implementation provided in Curve is a simple numeric
355 : : //- approximation.
356 : :
357 : : //R CubitStatus
358 : : //O- true or false if spline is rational or not.
359 : : //O- the degree of this spline
360 : : //O- the control points
361 : : //O- If rational, weight for each control point
362 : : //O- the knots
363 : : //O- whether the underlying spline is reversed
364 : : virtual CubitStatus get_spline_params( bool &rational,
365 : : int °ree,
366 : : DLIList<CubitVector> &cntrl_pts,
367 : : DLIList<double> &cntrl_pt_weights,
368 : : DLIList<double> &knots, // There should be order+cntrl_pts.size()-2 knots
369 : : bool &spline_is_reversed
370 : : ) const = 0;
371 : :
372 : : //R CubitStatus
373 : : //O- center - ellipse center point
374 : : //O- normal - normal of the plane of the ellipse
375 : : //O- major_axis - major axis of the ellipse
376 : : //O- radius_ratio - ratio of the length of the major to minor axis.
377 : : virtual CubitStatus get_ellipse_params( CubitVector ¢er,
378 : : CubitVector &normal,
379 : : CubitVector &major_axis,
380 : : double &radius_ratio ) const = 0;
381 : :
382 : : protected:
383 : :
384 : : private:
385 : : };
386 : :
387 : :
388 : : // ********** BEGIN INLINE FUNCTIONS **********
389 : : inline
390 : 40667 : double Curve::get_arc_length()
391 : : {
392 : 40667 : return measure();
393 : : }
394 : :
395 : : inline
396 : 0 : double Curve::get_arc_length( const CubitVector &point1,
397 : : const CubitVector &point2 )
398 : : {
399 : 0 : double param1 = u_from_position(point1);
400 : 0 : double param2 = u_from_position(point2);
401 : 0 : return fabs(length_from_u(param1, param2));
402 : : }
403 : :
404 : : inline
405 : 0 : double Curve::get_arc_length( const CubitVector &point1,
406 : : const int which_end )
407 : : {
408 : 0 : double param1 = u_from_position(point1);
409 : : double param2;
410 [ # # ]: 0 : if (which_end == 0) param2 = start_param();
411 : 0 : else param2 = end_param();
412 : :
413 : 0 : return fabs(length_from_u(param1, param2));
414 : : }
415 : :
416 : : inline
417 : 1990 : CubitVector Curve::center_point()
418 : : {
419 : 1990 : double s_param = start_param();
420 : 1990 : double length = 0.5 * measure();
421 : 1990 : double param2 = u_from_arc_length(s_param, length);
422 : 1990 : CubitVector center;
423 : 1990 : position_from_u(param2, center);
424 : 1990 : return center;
425 : : }
426 : :
427 : : inline
428 : 0 : CubitStatus Curve::mid_point(CubitVector &midpoint)
429 : : {
430 : 0 : double param1 = 0.5 * (start_param() + end_param());
431 : :
432 : 0 : return position_from_u(param1, midpoint);
433 : : }
434 : :
435 : : inline
436 : 20443 : CubitStatus Curve::position_from_fraction( const double fraction_along_curve,
437 : : CubitVector &output_position )
438 : : {
439 : 20443 : CubitStatus result = CUBIT_FAILURE;
440 : 20443 : double param_1 = start_param() +
441 : 20443 : fraction_along_curve * (end_param() - start_param() );
442 : 20443 : result = position_from_u( param_1, output_position );
443 : 20443 : return result;
444 : : }
445 : :
446 : : inline
447 : 0 : CubitStatus Curve::mid_point(const CubitVector &point1,
448 : : const CubitVector &point2,
449 : : CubitVector& midpoint )
450 : : {
451 : 0 : double param1 = u_from_position(point1);
452 : 0 : double param2 = u_from_position(point2);
453 : 0 : param1 = 0.5 * (param1 + param2);
454 : 0 : return position_from_u(param1, midpoint);
455 : : }
456 : :
457 : : //R CubitStatus
458 : : //I CubitVector, CubitVector
459 : : //I- points between which the mid_point is needed
460 : : //O CubitVector
461 : : //O- mid point on this edge
462 : : //- This function returns the mid point between two points on this
463 : : //-edge, by parameter
464 : :
465 : :
466 : :
467 : : // ********** END INLINE FUNCTIONS **********
468 : :
469 : : // ********** BEGIN FRIEND FUNCTIONS **********
470 : : // ********** END FRIEND FUNCTIONS **********
471 : :
472 : : // ********** BEGIN EXTERN FUNCTIONS **********
473 : : // ********** END EXTERN FUNCTIONS **********
474 : :
475 : : #endif
476 : :
|
