Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : SubSurface.cpp
3 : : //
4 : : // Purpose :
5 : : //
6 : : // Special Notes :
7 : : //
8 : : // Creator : Jason Kraftcheck
9 : : //
10 : : // Creation Date : 06/11/98
11 : : //-------------------------------------------------------------------------
12 : :
13 : : #include "SubSurface.hpp"
14 : : #include "PartitionEngine.hpp"
15 : : #include "PartitionLoop.hpp"
16 : : #include "PartitionCurve.hpp"
17 : : #include "VGLoopTool.hpp"
18 : : #include "CubitFacetData.hpp"
19 : :
20 : : #include "GMem.hpp"
21 : : #include "GeometryQueryTool.hpp"
22 : :
23 : : //-------------------------------------------------------------------------
24 : : // Purpose : Constructor
25 : : //
26 : : // Special Notes :
27 : : //
28 : : // Creator : Jason Kraftcheck
29 : : //
30 : : // Creation Date : 04/23/02
31 : : //-------------------------------------------------------------------------
32 : 0 : SubSurface::SubSurface( Surface* real_surf )
33 : : {
34 [ # # ][ # # ]: 0 : assert( dynamic_cast<SubEntitySet*>(real_surf->owner()) == 0 );
[ # # ]
35 [ # # ][ # # ]: 0 : new SubEntitySet( real_surf, this );
36 : :
37 : : // ensure that the sense is the same on both entities
38 : : //if( real_surf->bridge_sense() != this->bridge_sense() )
39 : : // reverse_bridge_sense();
40 : :
41 : 0 : geometry_sense = CUBIT_FORWARD;
42 : 0 : }
43 : :
44 : 0 : SubSurface::SubSurface( SubSurface* split_from )
45 : : {
46 [ # # ][ # # ]: 0 : split_from->sub_entity_set().add_partition( this );
47 : 0 : geometry_sense = CUBIT_FORWARD;
48 : 0 : }
49 : :
50 : 0 : PartitionSurface* SubSurface::copy()
51 : : {
52 [ # # ]: 0 : return new SubSurface(this);
53 : : }
54 : :
55 : : //-------------------------------------------------------------------------
56 : : // Purpose : Destructor
57 : : //
58 : : // Special Notes :
59 : : //
60 : : // Creator : Jason Kraftcheck
61 : : //
62 : : // Creation Date : 06/15/98
63 : : //-------------------------------------------------------------------------
64 : 0 : SubSurface::~SubSurface()
65 [ # # ]: 0 : { }
66 : :
67 : :
68 : :
69 : : //-------------------------------------------------------------------------
70 : : // Purpose : get bounding box
71 : : //
72 : : // Special Notes :
73 : : //
74 : : // Creator : Jason Kraftcheck
75 : : //
76 : : // Creation Date : 06/11/98
77 : : //-------------------------------------------------------------------------
78 : : //CubitBox SubSurface::bounding_box() const
79 : : // { return partitioned_surface()->bounding_box(); }
80 : :
81 : :
82 : : //-------------------------------------------------------------------------
83 : : // Purpose : Calculate surface area
84 : : //
85 : : // Special Notes :
86 : : //
87 : : // Creator : Jason Kraftcheck
88 : : //
89 : : // Creation Date : 06/11/98
90 : : //-------------------------------------------------------------------------
91 : 0 : double SubSurface::measure()
92 : : {
93 [ # # ]: 0 : if( ! sub_entity_set().has_multiple_sub_entities() )
94 : 0 : return partitioned_surface()->measure();
95 : : else
96 : 0 : return PartitionSurface::measure();
97 : : }
98 : :
99 : :
100 : 0 : GeometryType SubSurface::geometry_type()
101 : 0 : { return partitioned_surface()->geometry_type(); }
102 : :
103 : :
104 : 0 : CubitStatus SubSurface::get_point_normal( CubitVector& origin, CubitVector& normal )
105 : 0 : { return partitioned_surface()->get_point_normal( origin, normal ); }
106 : :
107 : :
108 : 0 : CubitStatus SubSurface::closest_point_uv_guess(
109 : : CubitVector const& location,
110 : : double &u, double &v,
111 : : CubitVector* closest_location,
112 : : CubitVector* unit_normal )
113 : : {
114 : 0 : CubitStatus ret = partitioned_surface()->
115 : 0 : closest_point_uv_guess(location, u, v, closest_location, unit_normal);
116 : :
117 [ # # ][ # # ]: 0 : if(unit_normal && geometry_sense == CUBIT_REVERSED)
118 [ # # ]: 0 : *unit_normal = -(*unit_normal);
119 : :
120 : 0 : return ret;
121 : : }
122 : :
123 : :
124 : : //-------------------------------------------------------------------------
125 : : // Purpose : Return the closest point on the surface.
126 : : //
127 : : // Special Notes :
128 : : //
129 : : // Creator : Jason Kraftcheck
130 : : //
131 : : // Creation Date : 06/11/98
132 : : //-------------------------------------------------------------------------
133 : 0 : CubitStatus SubSurface::closest_point( CubitVector const& a,
134 : : CubitVector* b,
135 : : CubitVector* c,
136 : : CubitVector* d,
137 : : CubitVector* e )
138 : : {
139 : 0 : CubitStatus ret = partitioned_surface()->closest_point( a, b, c, d, e );
140 : :
141 [ # # ][ # # ]: 0 : if(c && geometry_sense == CUBIT_REVERSED)
142 [ # # ]: 0 : *c = -(*c);
143 : :
144 : 0 : return ret;
145 : : }
146 : :
147 : : //-------------------------------------------------------------------------
148 : : // Purpose : closest point trimmed
149 : : //
150 : : // Special Notes :
151 : : //
152 : : // Creator : Jason Kraftcheck
153 : : //
154 : : // Creation Date : 03/28/03
155 : : //-------------------------------------------------------------------------
156 : 0 : void SubSurface::closest_point_trimmed( CubitVector from, CubitVector& result )
157 : : {
158 : 0 : PartitionCurve* curve = 0;
159 [ # # ][ # # ]: 0 : if ( point_containment( from, curve ) == CUBIT_PNT_INSIDE )
160 [ # # ][ # # ]: 0 : partitioned_surface()->closest_point( from, &result );
161 : : else
162 [ # # ]: 0 : curve->closest_point_trimmed( from, result );
163 : 0 : }
164 : :
165 : : //-------------------------------------------------------------------------
166 : : // Purpose : closest point trimmed
167 : : //
168 : : // Special Notes :
169 : : //
170 : : // Creator : Jason Kraftcheck
171 : : //
172 : : // Creation Date : 03/28/03
173 : : //-------------------------------------------------------------------------
174 : 0 : CubitStatus SubSurface::closest_point_along_vector( CubitVector& from_point,
175 : : CubitVector& along_vector,
176 : : CubitVector& point_on_surface)
177 : : {
178 : 0 : return partitioned_surface()->closest_point_along_vector( from_point, along_vector, point_on_surface );
179 : : }
180 : :
181 : :
182 : : //-------------------------------------------------------------------------
183 : : // Purpose : get the principal curvatues at a point
184 : : //
185 : : // Special Notes :
186 : : //
187 : : // Creator : Jason Kraftcheck
188 : : //
189 : : // Creation Date : 06/11/98
190 : : //-------------------------------------------------------------------------
191 : 0 : CubitStatus SubSurface::principal_curvatures( CubitVector const& a,
192 : : double& b, double& c,
193 : : CubitVector* d )
194 : 0 : { return partitioned_surface()->principal_curvatures(a,b,c,d); }
195 : :
196 : :
197 : : //-------------------------------------------------------------------------
198 : : // Purpose : return the position for a set of parameter values.
199 : : //
200 : : // Special Notes :
201 : : //
202 : : // Creator : Jason Kraftcheck
203 : : //
204 : : // Creation Date : 06/11/98
205 : : //-------------------------------------------------------------------------
206 : 0 : CubitVector SubSurface::position_from_u_v( double u, double v )
207 : 0 : { return partitioned_surface()->position_from_u_v( u, v ); }
208 : :
209 : : //-------------------------------------------------------------------------
210 : : // Purpose : return the u and v values at a position
211 : : //
212 : : // Special Notes :
213 : : //
214 : : // Creator : Jason Kraftcheck
215 : : //
216 : : // Creation Date : 06/11/98
217 : : //-------------------------------------------------------------------------
218 : 0 : CubitStatus SubSurface::u_v_from_position( CubitVector const& location,
219 : : double& u, double& v,
220 : : CubitVector* closest )
221 : 0 : { return partitioned_surface()->u_v_from_position(location,u,v,closest); }
222 : :
223 : : //-------------------------------------------------------------------------
224 : : // Purpose : Check if surface is periodic.
225 : : //
226 : : // Special Notes :
227 : : //
228 : : // Creator : Jason Kraftcheck
229 : : //
230 : : // Creation Date : 03/31/03
231 : : //-------------------------------------------------------------------------
232 : 0 : CubitBoolean SubSurface::is_periodic()
233 : : {
234 : 0 : double u_period = 0.0, v_period = 0.0;
235 [ # # ]: 0 : bool u_periodic = is_periodic_in_U(u_period);
236 [ # # ]: 0 : bool v_periodic = is_periodic_in_V(v_period);
237 [ # # ][ # # ]: 0 : if( !u_periodic && !v_periodic )
238 : 0 : return CUBIT_FALSE;
239 : :
240 [ # # ][ # # ]: 0 : if ( !next_loop(0) ) // sphere
241 : 0 : return CUBIT_TRUE;
242 : :
243 [ # # ]: 0 : if( u_period < 0.0 )
244 : 0 : u_period = -u_period;
245 [ # # ]: 0 : if( v_period < 0.0 )
246 : 0 : v_period = -v_period;
247 : :
248 : : // If a single step exceeds this delta of the parameter
249 : : // range, assume the step crossed the "international date
250 : : // line" of the parameterization. Could probably safely
251 : : // use a smaller value.
252 : 0 : double u_wrap = 0.75 * u_period;
253 : 0 : double v_wrap = 0.75 * v_period;
254 : :
255 : 0 : int num_periodic_loops = 0;
256 [ # # ]: 0 : std::vector<CubitVector> loop_polyline;
257 : 0 : PartitionLoop* loop = 0;
258 [ # # ][ # # ]: 0 : while( (loop = next_loop(loop) ) != NULL )
259 : : {
260 : : // Get a polyline representation of the loop
261 : : VGLoopTool<PartitionSurface,PartitionLoop,PartitionCoEdge,PartitionCurve,PartitionPoint>
262 [ # # ][ # # ]: 0 : ::get_loop_polyline( loop->first_coedge(), loop_polyline );
263 : :
264 [ # # ][ # # ]: 0 : if ( loop_polyline.size() < 2 )
265 : 0 : continue;
266 : :
267 : : // Sum steps (in parameter space) between points in polyline
268 [ # # ]: 0 : std::vector<CubitVector>::iterator itor = loop_polyline.begin(),
269 [ # # ]: 0 : end = loop_polyline.end();
270 : 0 : double u_sum = 0, v_sum = 0;
271 : : double u_prev, v_prev;
272 [ # # ][ # # ]: 0 : u_v_from_position( loop_polyline[loop_polyline.size()-1], u_prev, v_prev );
[ # # ]
273 [ # # ][ # # ]: 0 : for ( ; itor != end; ++itor )
[ # # ]
274 : : {
275 : : double u, v;
276 [ # # ][ # # ]: 0 : u_v_from_position( *itor, u, v );
277 : :
278 : 0 : double u_step = u - u_prev;
279 [ # # ]: 0 : if ( u_step > u_wrap )
280 : 0 : u_step = u_period - u_step;
281 [ # # ]: 0 : else if ( u_step < -u_wrap )
282 : 0 : u_step = -u_period - u_step;
283 : :
284 : 0 : double v_step = v - v_prev;
285 [ # # ]: 0 : if ( v_step > v_wrap )
286 : 0 : v_step = v_period - v_step;
287 [ # # ]: 0 : else if ( v_step < -v_wrap )
288 : 0 : v_step = -v_period - v_step;
289 : :
290 : 0 : u_sum += u_step;
291 : 0 : v_sum += v_step;
292 : 0 : u_prev = u;
293 : 0 : v_prev = v;
294 : : }
295 : :
296 : : // Sum should be either zero or +/-period if loop
297 : : // is non-periodic or periodic respectively.
298 [ # # ][ # # ]: 0 : if ( (u_periodic && fabs(u_sum) > 0.5*u_period) ||
[ # # ]
299 [ # # ]: 0 : (v_periodic && fabs(v_sum) > 0.5*v_period) )
300 : 0 : num_periodic_loops++;
301 : : }
302 : :
303 [ # # ]: 0 : return CubitBoolean(num_periodic_loops > 0);
304 : : }
305 : :
306 : :
307 : :
308 : :
309 : 0 : CubitBoolean SubSurface::is_periodic_in_U( double& period )
310 : 0 : { return partitioned_surface()->is_periodic_in_U(period); }
311 : 0 : CubitBoolean SubSurface::is_periodic_in_V( double& period )
312 : 0 : { return partitioned_surface()->is_periodic_in_V(period); }
313 : :
314 : : //-------------------------------------------------------------------------
315 : : // Purpose : check if the surface is singular in either parameter
316 : : //
317 : : // Special Notes :
318 : : //
319 : : // Creator : Jason Kraftcheck
320 : : //
321 : : // Creation Date : 06/11/98
322 : : //-------------------------------------------------------------------------
323 : 0 : CubitBoolean SubSurface::is_singular_in_U( double u_param )
324 : 0 : { return partitioned_surface()->is_singular_in_U(u_param); }
325 : 0 : CubitBoolean SubSurface::is_singular_in_V( double v_param )
326 : 0 : { return partitioned_surface()->is_singular_in_V(v_param); }
327 : :
328 : : //-------------------------------------------------------------------------
329 : : // Purpose : Check if the surface is closed along either parameter.
330 : : //
331 : : // Special Notes :
332 : : //
333 : : // Creator : Jason Kraftcheck
334 : : //
335 : : // Creation Date : 06/11/98
336 : : //-------------------------------------------------------------------------
337 : 0 : CubitBoolean SubSurface::is_closed_in_U()
338 : 0 : { return CUBIT_FALSE; }
339 : 0 : CubitBoolean SubSurface::is_closed_in_V()
340 : 0 : { return CUBIT_FALSE; }
341 : :
342 : : //-------------------------------------------------------------------------
343 : : // Purpose : Get uv derivitives
344 : : //
345 : : // Special Notes :
346 : : //
347 : : // Creator : Jason Kraftcheck
348 : : //
349 : : // Creation Date : 06/11/98
350 : : //-------------------------------------------------------------------------
351 : 0 : CubitStatus SubSurface::uv_derivitives( double u, double v,
352 : : CubitVector& du, CubitVector& dv )
353 : 0 : { return partitioned_surface()->uv_derivitives(u,v,du,dv); }
354 : :
355 : : //-------------------------------------------------------------------------
356 : : // Purpose : Check if surface is parameterized
357 : : //
358 : : // Special Notes :
359 : : //
360 : : // Creator : Jason Kraftcheck
361 : : //
362 : : // Creation Date : 06/11/98
363 : : //-------------------------------------------------------------------------
364 : 0 : CubitBoolean SubSurface::is_parametric()
365 : 0 : { return partitioned_surface()->is_parametric(); }
366 : :
367 : : //-------------------------------------------------------------------------
368 : : // Purpose : return the parameter ranges
369 : : //
370 : : // Special Notes :
371 : : //
372 : : // Creator : Jason Kraftcheck
373 : : //
374 : : // Creation Date : 06/11/98
375 : : //-------------------------------------------------------------------------
376 : 0 : CubitBoolean SubSurface::get_param_range_U( double& lower, double& upper )
377 : 0 : { return partitioned_surface()->get_param_range_U(lower,upper); }
378 : 0 : CubitBoolean SubSurface::get_param_range_V( double& lower, double& upper )
379 : 0 : { return partitioned_surface()->get_param_range_V(lower,upper); }
380 : :
381 : :
382 : : //-------------------------------------------------------------------------
383 : : // Purpose : Check if a position lies on this surface.
384 : : //
385 : : // Special Notes :
386 : : //
387 : : // Creator : Jason Kraftcheck
388 : : //
389 : : // Creation Date : 06/11/98
390 : : //-------------------------------------------------------------------------
391 : 0 : CubitBoolean SubSurface::is_position_on( CubitVector& position )
392 : 0 : { return partitioned_surface()->is_position_on( position ); }
393 : :
394 : :
395 : :
396 : 0 : CubitStatus SubSurface::combine( PartitionSurface* dead_surface )
397 : : {
398 [ # # ]: 0 : SubSurface* dead = dynamic_cast<SubSurface*>(dead_surface );
399 [ # # ]: 0 : if( !dead )
400 : : {
401 : 0 : assert(0);
402 : : return CUBIT_FAILURE;
403 : : }
404 : :
405 : 0 : return PartitionSurface::combine(dead_surface);
406 : : }
407 : :
408 : 0 : CubitSense SubSurface::get_geometry_sense()
409 : : {
410 : : /*
411 : : #ifdef ALPHA_TREADSWEEP
412 : : return geometry_sense;
413 : : #else
414 : : */
415 : 0 : return CUBIT_FORWARD;
416 : : /*
417 : : #endif
418 : : */
419 : : }
420 : :
421 : 0 : void SubSurface::reverse_sense()
422 : : {
423 [ # # ]: 0 : reverse_loops();
424 [ # # ][ # # ]: 0 : if( owner() )
425 [ # # ][ # # ]: 0 : owner()->notify_reversed(this);
426 : :
427 [ # # ]: 0 : if(geometry_sense == CUBIT_FORWARD)
428 : 0 : geometry_sense = CUBIT_REVERSED;
429 : : else
430 : 0 : geometry_sense = CUBIT_FORWARD;
431 : :
432 : : int j;
433 [ # # ]: 0 : DLIList<CubitFacetData*> surf_facets;
434 [ # # ]: 0 : this->get_facet_data( surf_facets );
435 [ # # ][ # # ]: 0 : for(j=surf_facets.size(); j--;)
436 [ # # ][ # # ]: 0 : surf_facets.get_and_step()->flip();
[ # # ]
437 : 0 : }
438 : :
439 : 0 : CubitStatus SubSurface::save( CubitSimpleAttrib& attrib )
440 : : {
441 [ # # ]: 0 : DLIList<int> curves;
442 [ # # ]: 0 : get_save_topology(curves);
443 [ # # ][ # # ]: 0 : int id = sub_entity_set().get_id(this);
444 [ # # ][ # # ]: 0 : return sub_entity_set().save_geometry( id, 2, 0, 0, &curves, 0, attrib );
[ # # ]
445 : : }
446 : :
447 : :
448 : 0 : CubitStatus SubSurface::evaluate( double u, double v,
449 : : CubitVector *position,
450 : : CubitVector *unit_normal,
451 : : CubitVector *curvature1,
452 : : CubitVector *curvature2 )
453 : : {
454 : 0 : CubitStatus ret = partitioned_surface()->evaluate(u, v, position, unit_normal, curvature1, curvature2 );
455 : :
456 [ # # ][ # # ]: 0 : if(unit_normal && geometry_sense == CUBIT_REVERSED)
457 [ # # ]: 0 : *unit_normal = -(*unit_normal);
458 : :
459 : 0 : return ret;
460 : : }
461 : :
462 : 0 : CubitStatus SubSurface::get_sphere_params
463 : : (
464 : : CubitVector ¢er,
465 : : double &radius
466 : : ) const
467 : : {
468 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine sphere parameters for a SubSurface.\n");
469 : 0 : return CUBIT_FAILURE;
470 : : }
471 : :
472 : 0 : CubitStatus SubSurface::get_cone_params
473 : : (
474 : : CubitVector ¢er,
475 : : CubitVector &normal,
476 : : CubitVector &major_axis,
477 : : double &radius_ratio,
478 : : double &sine_angle,
479 : : double &cos_angle
480 : : ) const
481 : : {
482 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine cone parameters for SubSurfaces.\n");
483 : 0 : return CUBIT_FAILURE;
484 : : }
485 : :
486 : 0 : CubitStatus SubSurface::get_torus_params
487 : : (
488 : : CubitVector ¢er,
489 : : CubitVector &normal,
490 : : double &major_radius,
491 : : double &minor_radius
492 : : ) const
493 : : {
494 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine torus parameters for SubSurface.\n");
495 : 0 : return CUBIT_FAILURE;
496 : : }
497 : :
498 : 0 : CubitStatus SubSurface::get_nurb_params
499 : : (
500 : : bool &rational,
501 : : int °ree_u,
502 : : int °ree_v,
503 : : int &num_cntrl_pts_u,
504 : : int &num_cntrl_pts_v,
505 : : DLIList<CubitVector> &cntrl_pts,
506 : : DLIList<double> &cntrl_pt_weights,
507 : : DLIList<double> &u_knots,
508 : : DLIList<double> &v_knots
509 : : ) const
510 : : {
511 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine nurbs parameters for SubSurface.\n");
512 : 0 : return CUBIT_FAILURE;
513 [ + - ][ + - ]: 6364 : }
|
