Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : FacetSurface.cpp
3 : : //
4 : : // Purpose :
5 : : //
6 : : // Special Notes :
7 : : //
8 : : // Creator : David R. White
9 : : //
10 : : // Creation Date : 06/06/00
11 : : //
12 : : // Owner : David R. White
13 : : //-------------------------------------------------------------------------
14 : :
15 : : #include "SphereEvaluator.hpp"
16 : : #include "CubitMessage.hpp"
17 : : #include "CubitBox.hpp"
18 : : #include "CubitVector.hpp"
19 : :
20 : : // ********** END CUBIT INCLUDES **********
21 : :
22 : : // ********** BEGIN STATIC DECLARATIONS **********
23 : : // ********** END STATIC DECLARATIONS **********
24 : :
25 : : // ********** BEGIN PUBLIC FUNCTIONS **********
26 : :
27 : : //-------------------------------------------------------------------------
28 : : // Purpose : Compute and return the bounding box for this sphere.
29 : : //
30 : : // Special Notes :
31 : : //
32 : : //-------------------------------------------------------------------------
33 : 0 : CubitBox SphereEvaluator::bounding_box( void ) const
34 : : {
35 [ # # ]: 0 : CubitVector center = mTmatrix * mEvalData.center;
36 : :
37 [ # # ]: 0 : CubitVector min( center.x() - mEvalData.radius,
38 [ # # ]: 0 : center.y() - mEvalData.radius,
39 [ # # ][ # # ]: 0 : center.z() - mEvalData.radius );
40 [ # # ]: 0 : CubitVector max( center.x() + mEvalData.radius,
41 [ # # ]: 0 : center.y() + mEvalData.radius,
42 [ # # ][ # # ]: 0 : center.z() + mEvalData.radius );
43 : :
44 [ # # ]: 0 : CubitBox thebbox( min, max );
45 : :
46 : 0 : return thebbox;
47 : : }
48 : :
49 : : //-------------------------------------------------------------------------
50 : : // Purpose : This functions computes the point on the surface that is
51 : : // closest to the input location and then calculates the
52 : : // magnitudes of the principal curvatures at this (possibly,
53 : : // new) point on the surface.
54 : : //
55 : : // Special Notes :
56 : : //
57 : : //-------------------------------------------------------------------------
58 : 0 : CubitStatus SphereEvaluator::principal_curvatures(
59 : : CubitVector const& location,
60 : : double& curvature_1,
61 : : double& curvature_2,
62 : : CubitVector* closest_location )
63 : : {
64 : :
65 : 0 : curvature_1 = curvature_2 = 1.0 / mEvalData.radius;
66 : :
67 [ # # ]: 0 : if ( closest_location )
68 : : {
69 : 0 : closest_point( location, closest_location );
70 : : }
71 : 0 : return CUBIT_SUCCESS;
72 : : }
73 : :
74 : : //-------------------------------------------------------------------------
75 : : // Purpose : Computes the closest_point on the surface to the input
76 : : // location. Optionally, it also computes and returns
77 : : // the normal to the surface and the principal curvatures
78 : : // at closest_location.
79 : : //
80 : : //-------------------------------------------------------------------------
81 : 0 : CubitStatus SphereEvaluator::closest_point( CubitVector const& location,
82 : : CubitVector* closest_location,
83 : : CubitVector* unit_normal_ptr,
84 : : CubitVector* curvature1_ptr,
85 : : CubitVector* curvature2_ptr) const
86 : : {
87 [ # # ]: 0 : CubitTransformMatrix inverse_Tmatrix = mTmatrix;
88 [ # # ]: 0 : inverse_Tmatrix.inverse();
89 [ # # ]: 0 : CubitVector new_pt = inverse_Tmatrix * location;
90 : :
91 : : // ******************************************************
92 : : // If requested, compute the normal at the input point.
93 : : // ******************************************************
94 : :
95 [ # # ]: 0 : if ( unit_normal_ptr != NULL )
96 : : {
97 [ # # ]: 0 : CubitVector origin( 0.0, 0.0, 0.0 );
98 [ # # ]: 0 : CubitVector endpt = new_pt - mEvalData.center;
99 : :
100 [ # # ][ # # ]: 0 : origin = mTmatrix * origin;
101 [ # # ][ # # ]: 0 : endpt = mTmatrix * endpt;
102 : :
103 [ # # ][ # # ]: 0 : *unit_normal_ptr = endpt - origin;
104 [ # # ]: 0 : unit_normal_ptr->normalize();
105 : : }
106 : :
107 : : // *************************************************************
108 : : // If requested, compute the closest point to the input point.
109 : : // *************************************************************
110 : :
111 [ # # ]: 0 : if ( closest_location != NULL )
112 : : {
113 [ # # ][ # # ]: 0 : if ( location.within_tolerance( mEvalData.center, GEOMETRY_RESABS ) )
114 : : {
115 [ # # ]: 0 : closest_location->set( mEvalData.center.x() + mEvalData.radius,
116 : : mEvalData.center.y(),
117 [ # # ][ # # ]: 0 : mEvalData.center.z() );
[ # # ]
118 : : }
119 : : else
120 : : {
121 [ # # ]: 0 : CubitVector vec = new_pt - mEvalData.center;
122 [ # # ]: 0 : vec.normalize();
123 [ # # ][ # # ]: 0 : *closest_location = mEvalData.center + ( vec * mEvalData.radius );
[ # # ]
124 [ # # ][ # # ]: 0 : *closest_location = mTmatrix * (*closest_location);
125 : : }
126 : : }
127 : :
128 : : // ***********************************************************************
129 : : // If requested, compute the curvature directions.
130 : : // ***********************************************************************
131 : :
132 [ # # ][ # # ]: 0 : if ( curvature1_ptr &&
133 : : curvature2_ptr )
134 : : {
135 [ # # ][ # # ]: 0 : PRINT_ERROR("Sphere's do not current support curvature pointer requests.\n");
[ # # ][ # # ]
136 : 0 : return CUBIT_FAILURE;
137 : : }
138 : :
139 [ # # ]: 0 : return CUBIT_SUCCESS;
140 : : }
141 : :
142 : : //-------------------------------------------------------------------------
143 : : // Purpose : Given a UV parametric location, return the cooresponding
144 : : // XYZ location.
145 : : //-------------------------------------------------------------------------
146 : 0 : CubitVector SphereEvaluator::position_from_u_v( double u, double v ) const
147 : : {
148 : 0 : double two_pi = 2.0 * CUBIT_PI;
149 : :
150 [ # # ]: 0 : while ( u > two_pi ) u -= two_pi;
151 [ # # ]: 0 : while ( u < 0.0 ) u += two_pi;
152 : :
153 : 0 : double radius_modified = mEvalData.radius * sin ( v );
154 : 0 : double x = radius_modified * cos( u );
155 : 0 : double y = radius_modified * sin( u );
156 : 0 : double z = mEvalData.radius * cos( v );
157 : :
158 : 0 : CubitVector position( x, y, z );
159 [ # # ]: 0 : position = mTmatrix * position;
160 : :
161 : 0 : return position;
162 : : }
163 : :
164 : : //-------------------------------------------------------------------------
165 : : // Purpose : Project a given XYZ position to a surface and return
166 : : // the UV and XYZ locations on the surface.
167 : : //-------------------------------------------------------------------------
168 : 0 : CubitStatus SphereEvaluator::u_v_from_position
169 : : (
170 : : CubitVector const& location,
171 : : double& u,
172 : : double& v,
173 : : CubitVector* closest_location
174 : : ) const
175 : : {
176 [ # # ]: 0 : CubitTransformMatrix inverse_Tmatrix = mTmatrix;
177 [ # # ]: 0 : inverse_Tmatrix.inverse();
178 [ # # ]: 0 : CubitVector transformed_pt = inverse_Tmatrix * location;
179 : :
180 [ # # ]: 0 : CubitVector dir( transformed_pt );
181 [ # # ]: 0 : dir.normalize();
182 : :
183 [ # # ]: 0 : v = acos( dir.z() );
184 : :
185 [ # # ]: 0 : if ( v < GEOMETRY_RESABS )
186 : : {
187 : 0 : u = 0.0;
188 : : }
189 : : else
190 : : {
191 [ # # ][ # # ]: 0 : dir.set( dir.x(), dir.y(), 0.0 );
[ # # ]
192 [ # # ]: 0 : dir.normalize();
193 [ # # ]: 0 : u = acos( dir.x() );
194 : :
195 [ # # ][ # # ]: 0 : if ( dir.y() < 0.0 )
196 : : {
197 : 0 : u = 2*CUBIT_PI - u;
198 : : }
199 [ # # ]: 0 : while ( u < 0.0 ) u += 2*CUBIT_PI;
200 [ # # ]: 0 : while ( u >= 2*CUBIT_PI ) u -= 2*CUBIT_PI;
201 : : }
202 : :
203 [ # # ]: 0 : if ( closest_location )
204 [ # # ]: 0 : closest_point( location, closest_location );
205 [ # # ]: 0 : return CUBIT_SUCCESS;
206 : : }
207 : :
208 : : //-------------------------------------------------------------------------
209 : : // Purpose : returns a structure containing the parameters for this
210 : : // sphere (i.e. radius, center, etc.)
211 : : //
212 : : //-------------------------------------------------------------------------
213 : 0 : const CubitEvaluatorData* SphereEvaluator::evaluator_data( void ) const
214 : : {
215 : 0 : return &mEvalData;
216 : : }
217 : :
218 : : //-------------------------------------------------------------------------
219 : : // Purpose : return parametric extremes in the U direction
220 : : //
221 : : //-------------------------------------------------------------------------
222 : 0 : CubitBoolean SphereEvaluator::get_param_range_U
223 : : (
224 : : double& lower_bound,
225 : : double& upper_bound
226 : : ) const
227 : : {
228 : 0 : lower_bound = 0.0;
229 : 0 : upper_bound = 2.0*CUBIT_PI;
230 : 0 : return CUBIT_TRUE;
231 : : }
232 : :
233 : : //-------------------------------------------------------------------------
234 : : // Purpose : return parametric extremes in the V direction
235 : : //
236 : : //-------------------------------------------------------------------------
237 : 0 : CubitBoolean SphereEvaluator::get_param_range_V
238 : : (
239 : : double& lower_bound,
240 : : double& upper_bound
241 : : ) const
242 : : {
243 : 0 : lower_bound = 0;
244 : 0 : upper_bound = CUBIT_PI;
245 : 0 : return CUBIT_TRUE;
246 : : }
247 : :
248 : : // ********** END PUBLIC FUNCTIONS **********
249 : :
250 : : // ********** BEGIN PROTECTED FUNCTIONS **********
251 : : // ********** END PROTECTED FUNCTIONS **********
252 : :
253 : : // ********** BEGIN PRIVATE FUNCTIONS **********
254 : : // ********** END PRIVATE FUNCTIONS **********
255 : :
256 : : // ********** BEGIN HELPER CLASSES **********
257 : : // ********** END HELPER CLASSES **********
258 : :
259 : : // ********** BEGIN EXTERN FUNCTIONS **********
260 : : // ********** END EXTERN FUNCTIONS **********
261 : :
262 : : // ********** BEGIN STATIC FUNCTIONS **********
263 : : // ********** END STATIC FUNCTIONS **********
|
