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 : : #include "CubitSimpleAttrib.hpp"
15 : : #include "CubitVector.hpp"
16 : : #include "GeometryDefines.h"
17 : : #include "FacetSurface.hpp"
18 : : #include "RefFace.hpp"
19 : : #include "FacetQueryEngine.hpp"
20 : : #include "FacetAttrib.hpp"
21 : :
22 : : #include "CubitUtil.hpp"
23 : : #include "CastTo.hpp"
24 : : #include "RefVolume.hpp"
25 : : #include "GeometryQueryEngine.hpp"
26 : : #include "DLIList.hpp"
27 : : #include "FacetEvalTool.hpp"
28 : : #include "ShellSM.hpp"
29 : : #include "Lump.hpp"
30 : : #include "LoopSM.hpp"
31 : : #include "CubitPointData.hpp"
32 : : #include "CubitFacetData.hpp"
33 : : #include "CubitFacetEdge.hpp"
34 : : #include "FacetBody.hpp"
35 : : #include "FacetLump.hpp"
36 : : #include "FacetShell.hpp"
37 : : #include "FacetLoop.hpp"
38 : : #include "FacetCoEdge.hpp"
39 : : #include "FacetCurve.hpp"
40 : : #include "FacetPoint.hpp"
41 : : #include "CubitEvaluator.hpp"
42 : : #include "SphereEvaluator.hpp"
43 : : #include "CylinderEvaluator.hpp"
44 : :
45 : : #include <map>
46 : : #include "GfxDebug.hpp"
47 : : // ********** END CUBIT INCLUDES **********
48 : :
49 : : // ********** BEGIN STATIC DECLARATIONS **********
50 : : // ********** END STATIC DECLARATIONS **********
51 : :
52 : : // ********** BEGIN PUBLIC FUNCTIONS **********
53 : : //-------------------------------------------------------------------------
54 : : // Purpose : The constructor with a pointer to the FacetEvalTool.
55 : : //
56 : : // Special Notes :
57 : : //
58 : : //-------------------------------------------------------------------------
59 : 341 : FacetSurface::FacetSurface(FacetEvalTool *facet_tool,
60 : : DLIList<ShellSM*> &shellsms,
61 [ + - ][ + - ]: 341 : DLIList<LoopSM*> &loopsms)
[ + - ]
62 : : {
63 : : // Calculate a bounding box if there isn't one already
64 : 341 : facetEvalTool = facet_tool;
65 : : //sense_ = CUBIT_FORWARD;
66 [ + - ]: 341 : myShells += shellsms;
67 [ + - ]: 341 : myLoops += loopsms;
68 : 341 : myShellSense = CUBIT_UNKNOWN;
69 : 341 : myEvaluator = NULL;
70 : 341 : }
71 : :
72 : : //-------------------------------------------------------------------------
73 : : // Purpose : The constructor with a pointer to the FacetEvalTool.
74 : : //
75 : : // Special Notes : Used for save/restore
76 : : //
77 : : //-------------------------------------------------------------------------
78 : 0 : FacetSurface::FacetSurface( const SphereEvaluatorData *sphere_data,
79 : : FacetEvalTool *facet_tool,
80 : : DLIList<ShellSM*> &shellsms,
81 [ # # ][ # # ]: 0 : DLIList<LoopSM*> &loopsms )
[ # # ]
82 : : {
83 : 0 : facetEvalTool = facet_tool;
84 : : //sense_ = CUBIT_FORWARD;
85 [ # # ]: 0 : myShells += shellsms;
86 [ # # ]: 0 : myLoops += loopsms;
87 : 0 : myShellSense = CUBIT_UNKNOWN;
88 : :
89 [ # # ][ # # ]: 0 : myEvaluator = new SphereEvaluator( sphere_data );
90 : 0 : }
91 : : //-------------------------------------------------------------------------
92 : : // Purpose : The constructor with a pointer to the FacetEvalTool.
93 : : //
94 : : // Special Notes : Used for save/restore
95 : : //
96 : : //-------------------------------------------------------------------------
97 : 0 : FacetSurface::FacetSurface( const CylinderEvaluatorData *cylinder_data,
98 : : FacetEvalTool *facet_tool,
99 : : DLIList<ShellSM*> &shellsms,
100 [ # # ][ # # ]: 0 : DLIList<LoopSM*> &loopsms )
[ # # ]
101 : : {
102 : 0 : facetEvalTool = facet_tool;
103 : : //sense_ = CUBIT_FORWARD;
104 [ # # ]: 0 : myShells += shellsms;
105 [ # # ]: 0 : myLoops += loopsms;
106 : 0 : myShellSense = CUBIT_UNKNOWN;
107 : :
108 [ # # ][ # # ]: 0 : myEvaluator = new CylinderEvaluator( cylinder_data );
109 : 0 : }
110 : :
111 : : //-------------------------------------------------------------------------
112 : : // Purpose : The constructor with a pointer to the FacetEvalTool.
113 : : //
114 : : // Special Notes : Used for save/restore
115 : : //
116 : : //-------------------------------------------------------------------------
117 : 132 : FacetSurface::FacetSurface(FacetEvalTool *facet_tool,
118 : : CubitSense sense,
119 : : CubitSense shell_sense0,
120 : : CubitBoolean use_facets,
121 [ + - ][ + - ]: 132 : DLIList<LoopSM*> &loopsms)
[ + - ]
122 : : {
123 : : // Calculate a bounding box if there isn't one already
124 : 132 : facetEvalTool = facet_tool;
125 : : //sense_ = CUBIT_FORWARD;
126 [ + - ]: 132 : myLoops += loopsms;
127 : 132 : myShellSense = shell_sense0;
128 : 132 : myEvaluator = NULL;
129 : 132 : }
130 : : //-------------------------------------------------------------------------
131 : : // Purpose : The default destructor.
132 : : //
133 : : // Special Notes :
134 : : //
135 : : //-------------------------------------------------------------------------
136 [ # # ][ # # ]: 0 : FacetSurface::~FacetSurface()
[ # # ]
137 : : {
138 [ # # ]: 0 : if ( facetEvalTool )
139 : : {
140 [ # # ][ # # ]: 0 : delete facetEvalTool;
141 : : }
142 [ # # ]: 0 : if ( myEvaluator )
143 : : {
144 [ # # ][ # # ]: 0 : delete myEvaluator;
145 : : }
146 [ # # ]: 0 : }
147 : :
148 : :
149 : : //-------------------------------------------------------------------------
150 : : // Purpose : get the interpolation order of the FacetEvalTool
151 : : //
152 : : // Special Notes :
153 : : //
154 : : //-------------------------------------------------------------------------
155 : 0 : int FacetSurface::interp_order()
156 : : {
157 [ # # ]: 0 : assert(facetEvalTool != NULL);
158 : :
159 : 0 : return facetEvalTool->interp_order();
160 : : }
161 : :
162 : : //-------------------------------------------------------------------------
163 : : // Purpose : get the min dot of the FacetEvalTool
164 : : //
165 : : // Special Notes :
166 : : //
167 : : //-------------------------------------------------------------------------
168 : 0 : double FacetSurface::min_dot()
169 : : {
170 [ # # ]: 0 : assert(facetEvalTool != NULL);
171 : :
172 : 0 : return facetEvalTool->get_min_dot();
173 : : }
174 : :
175 : : //-------------------------------------------------------------------------
176 : : // Purpose : The purpose of this function is to append a
177 : : // attribute to the GE. The name is attached to the
178 : : // underlying solid model entity this one points to.
179 : : //
180 : : //
181 : : // Special Notes :
182 : : //
183 : : //-------------------------------------------------------------------------
184 : 242 : void FacetSurface::append_simple_attribute_virt(const CubitSimpleAttrib &csa)
185 : 242 : { attribSet.append_attribute(csa); }
186 : :
187 : : //-------------------------------------------------------------------------
188 : : // Purpose : The purpose of this function is to remove a simple
189 : : // attribute attached to this geometry entity. The name is
190 : : // removed from the underlying BODY this points to.
191 : : //
192 : : // Special Notes :
193 : : //
194 : : //-------------------------------------------------------------------------
195 : 2024 : void FacetSurface::remove_simple_attribute_virt(const CubitSimpleAttrib &csa)
196 : 2024 : { attribSet.remove_attribute( csa ); }
197 : :
198 : : //-------------------------------------------------------------------------
199 : : // Purpose : The purpose of this function is to remove all simple
200 : : // attributes attached to this geometry entity. Also
201 : : // removes lingering GTC attributes.
202 : : //
203 : : //
204 : : // Special Notes :
205 : : //
206 : : //-------------------------------------------------------------------------
207 : 770 : void FacetSurface::remove_all_simple_attribute_virt()
208 : 770 : { attribSet.remove_all_attributes(); }
209 : :
210 : : //-------------------------------------------------------------------------
211 : : // Purpose : The purpose of this function is to get the
212 : : // attributes attached to this geometry entity. The name is
213 : : // attached to the underlying BODY this points to.
214 : : //
215 : : // Special Notes :
216 : : //
217 : : //-------------------------------------------------------------------------
218 : 462 : CubitStatus FacetSurface::get_simple_attribute(DLIList<CubitSimpleAttrib>&
219 : : csa_list)
220 : 462 : { return attribSet.get_attributes(csa_list); }
221 : 2486 : CubitStatus FacetSurface::get_simple_attribute(const CubitString& name,
222 : : DLIList<CubitSimpleAttrib>& csa_list )
223 : 2486 : { return attribSet.get_attributes( name, csa_list ); }
224 : :
225 : 275 : CubitStatus FacetSurface::save_attribs( FILE *file_ptr )
226 : 275 : { return attribSet.save_attributes(file_ptr); }
227 : :
228 : 132 : CubitStatus FacetSurface::restore_attribs( FILE *file_ptr, unsigned int endian )
229 : 132 : { return attribSet.restore_attributes( file_ptr, endian ); }
230 : :
231 : :
232 : : //-------------------------------------------------------------------------
233 : : // Purpose : Get geometry modeling engine: FacetQueryEngine
234 : : //
235 : : // Special Notes :
236 : : //
237 : : //-------------------------------------------------------------------------
238 : : GeometryQueryEngine*
239 : 0 : FacetSurface::get_geometry_query_engine() const
240 : : {
241 : 0 : return FacetQueryEngine::instance();
242 : : }
243 : :
244 : : //-------------------------------------------------------------------------
245 : : // Purpose : Get the bounding box of the object.
246 : : //
247 : : // Special Notes :
248 : : //
249 : : //-------------------------------------------------------------------------
250 : 2233 : CubitBox FacetSurface::bounding_box() const
251 : : {
252 [ - + ]: 2233 : if ( myEvaluator )
253 : 0 : return myEvaluator->bounding_box();
254 : : else
255 : 2233 : return facetEvalTool->bounding_box();
256 : : }
257 : :
258 : :
259 : 0 : CubitStatus FacetSurface::get_point_normal( CubitVector& location,
260 : : CubitVector& normal )
261 : : {
262 : 0 : return closest_point( location, NULL, &normal );
263 : : }
264 : :
265 : 0 : CubitStatus FacetSurface::closest_point_uv_guess(
266 : : CubitVector const& location,
267 : : double& , double& ,
268 : : CubitVector* closest_location,
269 : : CubitVector* unit_normal )
270 : : {
271 : : // don't use u and v guesses
272 : 0 : return closest_point(location, closest_location, unit_normal);
273 : : }
274 : :
275 : :
276 : : //-------------------------------------------------------------------------
277 : : // Purpose : Computes the closest_point on the surface to the input
278 : : // location. Optionally, it also computes and returns
279 : : // the normal to the surface and the principal curvatures
280 : : // at closest_location.
281 : : //
282 : : //-------------------------------------------------------------------------
283 : 2167 : CubitStatus FacetSurface::closest_point( CubitVector const& location,
284 : : CubitVector* closest_location,
285 : : CubitVector* unit_normal_ptr,
286 : : CubitVector* curvature1_ptr,
287 : : CubitVector* curvature2_ptr)
288 : : {
289 : 2167 : CubitStatus rv = CUBIT_SUCCESS;
290 [ - + ]: 2167 : if ( myEvaluator )
291 : : return myEvaluator->closest_point( location,
292 : : closest_location,
293 : : unit_normal_ptr,
294 : : curvature1_ptr,
295 : 0 : curvature2_ptr );
296 : :
297 : : // Only need to compute the closest location
298 [ + + ][ + - ]: 2167 : if (unit_normal_ptr == NULL &&
299 [ + - ]: 1243 : curvature1_ptr == NULL &&
300 : : curvature2_ptr == NULL)
301 : : {
302 [ + - ]: 1243 : CubitVector temp = location;
303 : : rv=facetEvalTool->closest_point( temp,
304 [ + - ]: 1243 : closest_location, NULL );
305 [ - + ]: 1243 : if(!rv){
306 : 0 : return rv;
307 : 1243 : }
308 : : }
309 : :
310 : : // Need to compute the closest location and the normal, but not the
311 : : // curvatures
312 [ + - ][ + - ]: 924 : else if ( (unit_normal_ptr != NULL) &&
313 [ + - ]: 924 : (curvature1_ptr == NULL && curvature2_ptr == NULL) )
314 : : {
315 [ + - ]: 924 : CubitVector temp = location;
316 [ + - ]: 924 : rv =facetEvalTool->closest_point( temp, closest_location, unit_normal_ptr);
317 [ - + ]: 924 : if(!rv){
318 : 0 : return rv;
319 : 924 : }
320 : : // if ( get_relative_surface_sense() == CUBIT_REVERSED )
321 : : // {
322 : : // *unit_normal_ptr = -1.0*(*unit_normal_ptr);
323 : : // }
324 : : }
325 : : else
326 : : {
327 [ # # ][ # # ]: 0 : PRINT_ERROR("Faceted geometry currently doesn't support curvature requests.\n");
328 : 0 : return CUBIT_FAILURE;
329 : : }
330 : :
331 : 2167 : return CUBIT_SUCCESS;
332 : : }
333 : :
334 : :
335 : :
336 : 0 : CubitStatus FacetSurface::closest_point_along_vector(CubitVector& from_point,
337 : : CubitVector& along_vector,
338 : : CubitVector& point_on_surface)
339 : : {
340 [ # # ]: 0 : CubitVector other_point = from_point+along_vector;
341 [ # # ]: 0 : DLIList<CubitVector*> intersection_list;
342 [ # # ][ # # ]: 0 : facetEvalTool->get_intersections( from_point, other_point, intersection_list );
[ # # ]
343 : :
344 [ # # ][ # # ]: 0 : if( intersection_list.size() == 0 )
345 : 0 : return CUBIT_FAILURE;
346 : :
347 [ # # ][ # # ]: 0 : if( intersection_list.size() == 1 )
348 : : {
349 [ # # ][ # # ]: 0 : point_on_surface = *intersection_list.get();
350 [ # # ]: 0 : delete intersection_list.get();
351 : 0 : return CUBIT_SUCCESS;
352 : : }
353 : :
354 : : //get the closest intersection
355 : 0 : double closest_dist_sq = CUBIT_DBL_MAX;
356 [ # # ][ # # ]: 0 : for( int k=intersection_list.size(); k--; )
357 : : {
358 [ # # ]: 0 : CubitVector *int_pt = intersection_list.get_and_step();
359 : :
360 [ # # ]: 0 : double tmp_dist_sq = from_point.distance_between_squared( *int_pt );
361 : :
362 [ # # ]: 0 : if( tmp_dist_sq < closest_dist_sq )
363 : : {
364 [ # # ]: 0 : point_on_surface = *int_pt;
365 : 0 : closest_dist_sq = tmp_dist_sq;
366 : : }
367 : :
368 : 0 : delete int_pt;
369 : : }
370 : :
371 [ # # ]: 0 : return CUBIT_SUCCESS;
372 : : }
373 : :
374 : :
375 : :
376 : : //-------------------------------------------------------------------------
377 : : // Purpose : Computes the closest_point on the trimmed surface to the
378 : : // input location.
379 : : //
380 : : // Special Notes :
381 : : //-------------------------------------------------------------------------
382 : 11 : void FacetSurface::closest_point_trimmed( CubitVector from_point,
383 : : CubitVector& point_on_surface)
384 : : {
385 : : CubitBoolean on_surf;
386 : : facetEvalTool->closest_point_trimmed( from_point, &point_on_surface,
387 [ + - ]: 11 : on_surf);
388 : 11 : return;
389 : : }
390 : :
391 : : //-------------------------------------------------------------------------
392 : : // Purpose : This functions computes the point on the surface that is
393 : : // closest to the input location and then calculates the
394 : : // magnitudes of the principal curvatures at this (possibly,
395 : : // new) point on the surface. Specifying the RefVolume for
396 : : // reference is optional.
397 : : //
398 : : // Special Notes :
399 : : //
400 : : //-------------------------------------------------------------------------
401 : 0 : CubitStatus FacetSurface::principal_curvatures(
402 : : CubitVector const& location,
403 : : double& curvature_1,
404 : : double& curvature_2,
405 : : CubitVector* closest_location )
406 : : {
407 [ # # ]: 0 : if ( myEvaluator )
408 : : {
409 : : return myEvaluator->principal_curvatures( location,
410 : : curvature_1,
411 : : curvature_2,
412 : 0 : closest_location );
413 : : }
414 : :
415 [ # # ][ # # ]: 0 : PRINT_ERROR("Faceted geometry currently does not support curvature requests.\n");
416 : 0 : return CUBIT_FAILURE;
417 : : }
418 : :
419 : :
420 : :
421 : 0 : CubitStatus FacetSurface::evaluate( double u, double v,
422 : : CubitVector *position,
423 : : CubitVector *normal,
424 : : CubitVector *curvature1,
425 : : CubitVector *curvature2 )
426 : : {
427 : 0 : return CUBIT_FAILURE;
428 : : }
429 : :
430 : :
431 : : //-------------------------------------------------------------------------
432 : : // Purpose : Given values of the two parameters, get the position.
433 : : //
434 : : // Special Notes :
435 : : //
436 : : //-------------------------------------------------------------------------
437 : 0 : CubitVector FacetSurface::position_from_u_v (double u, double v)
438 : : {
439 [ # # ]: 0 : if ( myEvaluator )
440 : 0 : return myEvaluator->position_from_u_v( u, v );
441 : :
442 [ # # ][ # # ]: 0 : PRINT_ERROR("Faceted geometry currently does not support u-v parameterization.\n");
443 : 0 : return CubitVector (0,0,0);
444 : : }
445 : :
446 : : //-------------------------------------------------------------------------
447 : : // Purpose : This function returns the {u, v} coordinates of the point
448 : : // on the Surface closest to the input point (specified in
449 : : // global space). The closest_location is also returned.
450 : : //
451 : : // Special Notes :
452 : : //
453 : : //-------------------------------------------------------------------------
454 : 0 : CubitStatus FacetSurface::u_v_from_position( CubitVector const& location,
455 : : double& u,
456 : : double& v,
457 : : CubitVector* closest_location )
458 : : {
459 [ # # ]: 0 : if ( myEvaluator )
460 : 0 : return myEvaluator->u_v_from_position( location, u, v, closest_location );
461 : :
462 [ # # ][ # # ]: 0 : PRINT_ERROR("Faceted geometry currently does not support u-v parameterization.\n");
463 : 0 : return CUBIT_FAILURE;
464 : : }
465 : :
466 : : //-------------------------------------------------------------------------
467 : : // Purpose : Determines whether the Facet surface is periodic. Not
468 : : // available yet.
469 : : //
470 : : //
471 : : //-------------------------------------------------------------------------
472 : 0 : CubitBoolean FacetSurface::is_periodic()
473 : : {
474 [ # # ]: 0 : if ( myEvaluator )
475 : 0 : return myEvaluator->is_periodic();
476 : :
477 : : //I'm sure we can do something later to calculate this. But for now...
478 : : //PRINT_ERROR("FacetSurface::is_periodic not implemented yet\n");
479 : 0 : return CUBIT_FALSE;
480 : :
481 : : }
482 : :
483 : : //-------------------------------------------------------------------------
484 : : // Purpose : Determines if the face is periodic in the given parameter
485 : : // direction. Not available yet.
486 : : //
487 : : //-------------------------------------------------------------------------
488 : 0 : CubitBoolean FacetSurface::is_periodic_in_U( double& period )
489 : : {
490 [ # # ]: 0 : if ( myEvaluator )
491 : 0 : return myEvaluator->is_periodic_in_U( period );
492 : :
493 : : //PRINT_ERROR("FacetSurface::is_periodic_in_U not implemented yet\n");
494 : 0 : return CUBIT_FALSE;
495 : : }
496 : :
497 : : //-------------------------------------------------------------------------
498 : : // Purpose : Determines if the face is periodic in the given parameter
499 : : // direction. Not available yet.
500 : : //
501 : : //
502 : : //-------------------------------------------------------------------------
503 : 0 : CubitBoolean FacetSurface::is_periodic_in_V( double& period )
504 : : {
505 [ # # ]: 0 : if ( myEvaluator )
506 : 0 : return myEvaluator->is_periodic_in_V( period );
507 : :
508 : : //PRINT_ERROR("FacetSurface::is_periodic_in_V not implemented yet\n");
509 : 0 : return CUBIT_FALSE;
510 : : }
511 : :
512 : : //-------------------------------------------------------------------------
513 : : // Purpose : Determines if the face is singular in the given parameter
514 : : // direction. Not available yet.
515 : : //
516 : : //-------------------------------------------------------------------------
517 : 0 : CubitBoolean FacetSurface::is_singular_in_U( double )
518 : : {
519 [ # # ]: 0 : if ( myEvaluator )
520 : 0 : return myEvaluator->is_singular_in_U();
521 : :
522 : : //PRINT_ERROR("FacetSurface::is_singular_in_U not implemented yet\n");
523 : 0 : return CUBIT_FALSE;
524 : : }
525 : :
526 : : //-------------------------------------------------------------------------
527 : : // Purpose : Determines if the face is singular in the given parameter
528 : : // direction. Not available yet.
529 : : //-------------------------------------------------------------------------
530 : 0 : CubitBoolean FacetSurface::is_singular_in_V( double )
531 : : {
532 [ # # ]: 0 : if ( myEvaluator )
533 : 0 : return myEvaluator->is_singular_in_V();
534 : :
535 : : //PRINT_ERROR("FacetSurface::is_singular_in_V not implemented yet\n");
536 : 0 : return CUBIT_FALSE;
537 : : }
538 : :
539 : : //-------------------------------------------------------------------------
540 : : // Purpose : Determines if the face is closed in the U parameter.
541 : : //
542 : : //-------------------------------------------------------------------------
543 : 0 : CubitBoolean FacetSurface::is_closed_in_U()
544 : : {
545 [ # # ]: 0 : if ( myEvaluator )
546 : 0 : return myEvaluator->is_closed_in_U();
547 : :
548 : : //PRINT_ERROR("FacetSurface::is_closed_in_U not implemented yet\n");
549 : 0 : return CUBIT_FALSE;
550 : : }
551 : :
552 : : //-------------------------------------------------------------------------
553 : : // Purpose : Determines if the face is closed in the V parameter.
554 : : //-------------------------------------------------------------------------
555 : 0 : CubitBoolean FacetSurface::is_closed_in_V()
556 : : {
557 [ # # ]: 0 : if ( myEvaluator )
558 : 0 : return myEvaluator->is_closed_in_V();
559 : :
560 : : //PRINT_ERROR("FacetSurface::is_closed_in_V not implemented yet\n");
561 : 0 : return CUBIT_FALSE;
562 : : }
563 : :
564 : : //-------------------------------------------------------------------------
565 : : // Purpose : Calculates the derivitives at a given parameter location.
566 : : //
567 : : //-------------------------------------------------------------------------
568 : 0 : CubitStatus FacetSurface::uv_derivitives( double ,
569 : : double ,
570 : : CubitVector &,
571 : : CubitVector & )
572 : : {
573 [ # # ][ # # ]: 0 : PRINT_ERROR("Derivitives on a surface not supported on faceted geometry yet.\n");
574 : 0 : return CUBIT_FAILURE;
575 : : }
576 : :
577 : : //-------------------------------------------------------------------------
578 : : // Purpose : Determines whether the surface is parametrically defined.
579 : : // Hopefully later this will be available.
580 : : //
581 : : //-------------------------------------------------------------------------
582 : 858 : CubitBoolean FacetSurface::is_parametric()
583 : : {
584 [ - + ]: 858 : if ( myEvaluator )
585 : : {
586 : 0 : return myEvaluator->is_parametric();
587 : : }
588 : :
589 : : //PRINT_ERROR("FacetSurface::is_parametric not implemented\n");
590 : 858 : return CUBIT_FALSE;
591 : : }
592 : :
593 : : //-------------------------------------------------------------------------
594 : : // Purpose : Returns the lower and upper parametric bounds of the
595 : : // surface in U, if it is parametric. Otherwise, it returns
596 : : // CUBIT_FALSE and zeroes for the upper and lower parametric
597 : : // bounds.
598 : : //
599 : : // Creator : Malcolm J. Panthaki
600 : : //
601 : : // Creation Date : 12/17/96
602 : : //-------------------------------------------------------------------------
603 : 0 : CubitBoolean FacetSurface::get_param_range_U( double& lower_bound,
604 : : double& upper_bound )
605 : : {
606 [ # # ]: 0 : if ( myEvaluator )
607 : 0 : return myEvaluator->get_param_range_U( lower_bound, upper_bound );
608 : :
609 : 0 : lower_bound = 0.0;
610 : 0 : upper_bound = 1.0;
611 : : //PRINT_ERROR("FacetSurface::get_param_range_U not implemented\n");
612 : 0 : return CUBIT_FALSE;
613 : : }
614 : :
615 : : //-------------------------------------------------------------------------
616 : : // Purpose : Returns the lower and upper parametric bounds of the
617 : : // surface in V, if it is parametric. Otherwise, it returns
618 : : // CUBIT_FALSE and zeroes for the upper and lower parametric
619 : : // bounds.
620 : : //
621 : : //-------------------------------------------------------------------------
622 : 0 : CubitBoolean FacetSurface::get_param_range_V( double& lower_bound,
623 : : double& upper_bound )
624 : : {
625 [ # # ]: 0 : if ( myEvaluator )
626 : 0 : return myEvaluator->get_param_range_V( lower_bound, upper_bound );
627 : :
628 : 0 : lower_bound = 0.0;
629 : 0 : upper_bound = 1.0;
630 : : //PRINT_ERROR("FacetSurface::get_param_range_V not implemented\n");
631 : 0 : return CUBIT_FALSE;
632 : : }
633 : :
634 : : //-------------------------------------------------------------------------
635 : : // Purpose : Returns a surface type ID
636 : : //
637 : : //-------------------------------------------------------------------------
638 : 880 : GeometryType FacetSurface::geometry_type()
639 : : {
640 [ + - ]: 880 : if ( is_flat() )
641 : : {
642 : 880 : return PLANE_SURFACE_TYPE;
643 : : }
644 [ # # ]: 0 : else if ( is_spherical() )
645 : : {
646 : 0 : return SPHERE_SURFACE_TYPE;
647 : : }
648 [ # # ]: 0 : else if ( is_conical() )
649 : : {
650 : 0 : return CONE_SURFACE_TYPE;
651 : : }
652 : : else
653 : : {
654 : 0 : return FACET_SURFACE_TYPE;
655 : : }
656 : : }
657 : :
658 : : //-------------------------------------------------------------------------
659 : : // Purpose : Returns the area of the Surface
660 : : //
661 : : //-------------------------------------------------------------------------
662 : 0 : double FacetSurface::measure()
663 : : {
664 : 0 : return facetEvalTool->area();
665 : : }
666 : :
667 : : //-------------------------------------------------------------------------
668 : : // Purpose : Updates the (cached) area of the Surface so that if
669 : : // measure() is called, the correct value is returned.
670 : : //-------------------------------------------------------------------------
671 : 66 : void FacetSurface::update_measurement()
672 : : {
673 : 66 : facetEvalTool->calculate_area();
674 : 66 : }
675 : :
676 : : //-------------------------------------------------------------------------
677 : : // Purpose : Returns whether the facet surface is completely flat
678 : : //
679 : : //-------------------------------------------------------------------------
680 : 880 : CubitBoolean FacetSurface::is_flat()
681 : : {
682 [ + - ]: 880 : return (facetEvalTool->is_flat() == 1) ? CUBIT_TRUE : CUBIT_FALSE;
683 : : }
684 : :
685 : : //-------------------------------------------------------------------------
686 : : // Purpose : Returns whether the facet surface is spherical
687 : : //
688 : : //-------------------------------------------------------------------------
689 : 0 : CubitBoolean FacetSurface::is_spherical()
690 : : {
691 [ # # ][ # # ]: 0 : if ( myEvaluator && myEvaluator->ask_type() == SPHERE_SURFACE_TYPE )
[ # # ]
692 : : {
693 : 0 : return CUBIT_TRUE;
694 : : }
695 : 0 : return CUBIT_FALSE;
696 : : }
697 : :
698 : : //-------------------------------------------------------------------------
699 : : // Purpose : Returns whether the facet surface is spherical
700 : : //
701 : : //-------------------------------------------------------------------------
702 : 0 : CubitBoolean FacetSurface::is_conical()
703 : : {
704 [ # # ][ # # ]: 0 : if ( myEvaluator && myEvaluator->ask_type() == CONE_SURFACE_TYPE )
[ # # ]
705 : : {
706 : 0 : return CUBIT_TRUE;
707 : : }
708 : 0 : return CUBIT_FALSE;
709 : : }
710 : :
711 : 0 : const CubitEvaluatorData *FacetSurface::evaluator_data( void )
712 : : {
713 [ # # ]: 0 : if ( myEvaluator )
714 : : {
715 : 0 : return myEvaluator->evaluator_data();
716 : : }
717 : 0 : return NULL;
718 : : }
719 : :
720 : : //-------------------------------------------------------------------------
721 : : // Purpose : This function tests the passed in position to see if
722 : : // is on the underlying surface.
723 : : //
724 : : //-------------------------------------------------------------------------
725 : 0 : CubitBoolean FacetSurface::is_position_on( CubitVector &test_position )
726 : : {
727 [ # # ]: 0 : CubitVector new_point;
728 [ # # ]: 0 : CubitStatus stat = closest_point(test_position, &new_point, NULL,NULL,NULL);
729 [ # # ]: 0 : if ( !stat )
730 : 0 : return CUBIT_FALSE;
731 [ # # ]: 0 : CubitVector result_vec = test_position - new_point;
732 [ # # ][ # # ]: 0 : if ( result_vec.length_squared() < GEOMETRY_RESABS )
733 : 0 : return CUBIT_TRUE;
734 : 0 : return CUBIT_FALSE;
735 : : }
736 : 0 : CubitPointContainment FacetSurface::point_containment( const CubitVector &/*point*/ )
737 : : {
738 : 0 : return CUBIT_PNT_UNKNOWN;
739 : : }
740 : 0 : CubitPointContainment FacetSurface::point_containment( double /*u_param*/,
741 : : double /*v_param*/ )
742 : : {
743 : 0 : return CUBIT_PNT_UNKNOWN;
744 : : }
745 : : //CubitPointContainment FacetSurface::point_containment( const CubitVector &/*point*/,
746 : : // double /*u_param*/,
747 : : // double /*v_param*/ )
748 : : //{
749 : : // return CUBIT_PNT_UNKNOWN;
750 : : //}
751 : 0 : CubitSense FacetSurface::get_geometry_sense()
752 : : {
753 : : //not sure if this is right for the facet surface...
754 : 0 : CubitSense sense = CUBIT_FORWARD;//get_relative_surface_sense();
755 : 0 : return sense;
756 : : }
757 : : // CubitSense FacetSurface::get_relative_surface_sense()
758 : : // {
759 : : // //not sure if this is right for the facet surface...
760 : : // return sense_;
761 : : // }
762 : :
763 : : /*
764 : :
765 : : void FacetSurface::bodysms(DLIList<BodySM*> &bodies)
766 : : {
767 : : int ii;
768 : : for ( ii = myShells.size(); ii > 0; ii-- )
769 : : {
770 : : myShells.get_and_step()->bodysms(bodies);
771 : : }
772 : : }
773 : :
774 : : void FacetSurface::lumps(DLIList<Lump*> &lumps)
775 : : {
776 : : int ii;
777 : : for ( ii = myShells.size(); ii > 0; ii-- )
778 : : {
779 : : myShells.get_and_step()->lumps(lumps);
780 : : }
781 : : }
782 : :
783 : : void FacetSurface::shellsms(DLIList<ShellSM*> &shellsms)
784 : : {
785 : : int ii;
786 : : for ( ii = myShells.size(); ii > 0; ii-- )
787 : : {
788 : : shellsms.append_unique(myShells.get_and_step());
789 : : }
790 : : }
791 : :
792 : : void FacetSurface::surfaces(DLIList<Surface*> &surfaces)
793 : : {
794 : : surfaces.append_unique(this);
795 : : }
796 : :
797 : : void FacetSurface::loopsms(DLIList<LoopSM*> &loopsms)
798 : : {
799 : : int ii;
800 : : for ( ii = myLoops.size(); ii > 0; ii-- )
801 : : {
802 : : loopsms.append_unique(myLoops.get_and_step());
803 : : }
804 : : }
805 : : void FacetSurface::coedgesms(DLIList<CoEdgeSM*> &coedgesms)
806 : : {
807 : : int ii;
808 : : for ( ii = myLoops.size(); ii > 0; ii-- )
809 : : {
810 : : myLoops.get_and_step()->coedgesms(coedgesms);
811 : : }
812 : : }
813 : :
814 : : void FacetSurface::curves(DLIList<Curve*> &curves)
815 : : {
816 : : int ii;
817 : : for ( ii = myLoops.size(); ii > 0; ii-- )
818 : : {
819 : : myLoops.get_and_step()->curves(curves);
820 : : }
821 : : }
822 : : void FacetSurface::points(DLIList<Point*> &points)
823 : : {
824 : : int ii;
825 : : for ( ii = myLoops.size(); ii > 0; ii-- )
826 : : {
827 : : myLoops.get_and_step()->points(points);
828 : : }
829 : : }
830 : : */
831 : :
832 : :
833 : 231 : void FacetSurface::get_parents_virt( DLIList<TopologyBridge*>& parents )
834 [ + - ][ + + ]: 462 : { CAST_LIST_TO_PARENT( myShells, parents ); }
835 : 1958 : void FacetSurface::get_children_virt( DLIList<TopologyBridge*>& children )
836 [ + - ][ + + ]: 3894 : { CAST_LIST_TO_PARENT( myLoops, children ); }
837 : :
838 : :
839 : :
840 : 616 : CubitStatus FacetSurface::get_my_facets(DLIList<CubitFacet*> &facet_list,
841 : : DLIList<CubitPoint*>& point_list)
842 : : {
843 : 616 : facetEvalTool->get_facets(facet_list);
844 : 616 : facetEvalTool->get_points(point_list);
845 : 616 : return CUBIT_SUCCESS;
846 : : }
847 : :
848 : 0 : void FacetSurface::tris(DLIList<CubitFacet *> &facet_list)
849 : : {
850 : 0 : facetEvalTool->get_facets(facet_list);
851 : 0 : }
852 : :
853 : 66 : void FacetSurface::get_my_points(DLIList<CubitPoint*> &point_list)
854 : : {
855 : 66 : facetEvalTool->get_points(point_list);
856 : 66 : }
857 : :
858 : 0 : void FacetSurface::get_my_facetedges(DLIList<CubitFacetEdge*> &edge_list)
859 : : {
860 : 0 : facetEvalTool->get_edges(edge_list);
861 : 0 : }
862 : :
863 : 275 : void FacetSurface::get_shell_sense( CubitSense &sense0)
864 : : {
865 : 275 : sense0 = myShellSense;
866 : 275 : }
867 : :
868 : :
869 : : // return the sense with respect to the given shell
870 : 473 : CubitSense FacetSurface::get_shell_sense( ShellSM* shell_ptr ) const
871 : : {
872 : : // work around non-constness of DLIList functions
873 : 473 : FacetSurface* nonconst = const_cast<FacetSurface*>(this);
874 : :
875 : 473 : int idx = nonconst->myShells.get_index();
876 [ - + ]: 473 : if(idx > 0){
877 [ # # ][ # # ]: 0 : PRINT_ERROR("Muliple shells attached to surface.\n");
878 : 0 : return CUBIT_UNKNOWN;
879 : : }
880 : 473 : ShellSM *ashell = myShells.get();
881 [ + - ]: 473 : if (ashell == shell_ptr)
882 : : {
883 : 473 : return myShellSense;
884 : : }
885 : : // else
886 : : // {
887 : : // nonconst->myShells.step();
888 : : // idx = nonconst->myShells.get_index();
889 : : // ashell = myShells.get();
890 : : // if (ashell == shell_ptr)
891 : : // {
892 : : // return myShellSense[idx];
893 : : // }
894 : : // }
895 : 473 : return CUBIT_UNKNOWN;
896 : : }
897 : :
898 : : // set the sense of the surface with respect to the shell
899 : 264 : void FacetSurface::set_shell_sense( FacetShell *facet_shell,
900 : : CubitSense thesense )
901 : : {
902 : : // if(thesense == CUBIT_REVERSED){
903 : : // PRINT_INFO("should not do this.");
904 : : // }
905 : 264 : int idx = myShells.get_index();
906 [ - + ]: 264 : if(idx > 0){
907 [ # # ][ # # ]: 0 : PRINT_ERROR("Multiple shells attached to a single surface.\n");
908 : 264 : return;
909 : : }
910 : 264 : ShellSM *shell_ptr = (ShellSM *)facet_shell;
911 : 264 : ShellSM *ashell = myShells.get();
912 [ + - ]: 264 : if (ashell == shell_ptr)
913 : : {
914 : 264 : myShellSense = thesense;
915 : : }
916 : : // else
917 : : // {
918 : : // myShells.step();
919 : : // idx = myShells.get_index();
920 : : // ashell = myShells.get();
921 : : // if (ashell == shell_ptr)
922 : : // {
923 : : // myShellSense[idx] = thesense;
924 : : // }
925 : : // }
926 : : }
927 : :
928 : : //----------------------------------------------------------------
929 : : // Function: copy_facets
930 : : // Description: copy the points and facets
931 : : //
932 : : // Author: sjowen
933 : : //----------------------------------------------------------------
934 : 0 : CubitStatus FacetSurface::copy_facets(DLIList<CubitFacet*>©_facet_list,
935 : : DLIList<CubitPoint*>©_point_list,
936 : : std::map<CubitPoint*, CubitPoint*>&old_to_new_cubit_pts)
937 : : {
938 [ # # ]: 0 : if (!facetEvalTool)
939 : : {
940 [ # # ][ # # ]: 0 : PRINT_ERROR("Couldn't copy facets.");
[ # # ][ # # ]
941 : 0 : return CUBIT_FAILURE;
942 : : }
943 : : int ii;
944 [ # # ]: 0 : DLIList<CubitFacet*>facet_list;
945 [ # # ][ # # ]: 0 : DLIList<CubitPoint*>point_list;
946 [ # # ]: 0 : facetEvalTool->get_facets( facet_list );
947 [ # # ]: 0 : facetEvalTool->get_points( point_list );
948 [ # # ][ # # ]: 0 : CubitPoint **point_array = new CubitPoint* [point_list.size()];
[ # # ]
949 : :
950 : : //- copy the points
951 [ # # ]: 0 : std::map<CubitPoint*, CubitPoint*>::iterator iter;
952 [ # # ]: 0 : point_list.reset();
953 : : CubitPoint *new_point, *the_point;
954 [ # # ][ # # ]: 0 : for(ii=0; ii<point_list.size(); ii++)
955 : : {
956 [ # # ]: 0 : the_point = point_list.get_and_step();
957 : :
958 [ # # ]: 0 : iter = old_to_new_cubit_pts.find( the_point );
959 [ # # ][ # # ]: 0 : if( old_to_new_cubit_pts.end() == iter )
[ # # ]
960 : : {
961 [ # # ][ # # ]: 0 : new_point = new CubitPointData( the_point->coordinates() );
[ # # ]
962 [ # # ]: 0 : copy_point_list.append( new_point );
963 : 0 : point_array[ii] = new_point;
964 [ # # ][ # # ]: 0 : old_to_new_cubit_pts.insert( std::make_pair( the_point, new_point) );
[ # # ]
965 : : }
966 : : else
967 : : {
968 [ # # ]: 0 : point_array[ii] = iter->second;
969 [ # # ][ # # ]: 0 : copy_point_list.append( iter->second );
970 : : }
971 : :
972 [ # # ]: 0 : the_point->marked( ii );
973 : : }
974 : :
975 : : //- copy the facets
976 : :
977 : : int jj, idx;
978 : : CubitFacet *new_facet, *the_facet;
979 : : CubitPoint *points[3];
980 [ # # ][ # # ]: 0 : for (ii=0; ii<facet_list.size(); ii++)
981 : : {
982 [ # # ]: 0 : the_facet = facet_list.get_and_step();
983 [ # # ]: 0 : for (jj=0; jj<3; jj++)
984 : : {
985 [ # # ][ # # ]: 0 : idx = the_facet->point(jj)->marked();
986 : 0 : points[jj] = point_array[idx];
987 : : }
988 [ # # ][ # # ]: 0 : new_facet = new CubitFacetData( points[0], points[1], points[2] );
989 [ # # ]: 0 : copy_facet_list.append( new_facet );
990 : : }
991 : :
992 [ # # ]: 0 : delete [] point_array;
993 : :
994 [ # # ]: 0 : return CUBIT_SUCCESS;
995 : : }
996 : :
997 : 0 : void FacetSurface::get_bodies( DLIList<FacetBody*>& result_list )
998 : : {
999 [ # # ]: 0 : DLIList<FacetLump*> lump_list;
1000 [ # # ]: 0 : get_lumps( lump_list );
1001 [ # # ]: 0 : lump_list.reset();
1002 [ # # ][ # # ]: 0 : for ( int i = lump_list.size(); i--; )
1003 : : {
1004 [ # # ]: 0 : FacetLump* lump = lump_list.get_and_step();
1005 [ # # ][ # # ]: 0 : FacetBody* body = dynamic_cast<FacetBody*>(lump->get_body());
1006 [ # # ]: 0 : if (body)
1007 [ # # ]: 0 : result_list.append_unique(body);
1008 [ # # ]: 0 : }
1009 : 0 : }
1010 : :
1011 : 0 : void FacetSurface::get_lumps( DLIList<FacetLump*>& result_list )
1012 : : {
1013 [ # # ]: 0 : DLIList<FacetShell*> shell_list;
1014 [ # # ]: 0 : get_shells( shell_list );
1015 [ # # ]: 0 : shell_list.reset();
1016 [ # # ][ # # ]: 0 : for ( int i = shell_list.size(); i--; )
1017 : : {
1018 [ # # ]: 0 : FacetShell* shell = shell_list.get_and_step();
1019 [ # # ]: 0 : shell->get_lumps( result_list );
1020 [ # # ][ # # ]: 0 : FacetLump* lump = dynamic_cast<FacetLump*>(shell->get_lump());
1021 [ # # ]: 0 : if (lump)
1022 [ # # ]: 0 : result_list.append_unique(lump);
1023 [ # # ]: 0 : }
1024 : 0 : }
1025 : :
1026 : 132 : void FacetSurface::get_shells( DLIList<FacetShell*>& result_list )
1027 : : {
1028 : 132 : myShells.reset();
1029 [ + + ]: 264 : for ( int i = 0; i < myShells.size(); i++ )
1030 [ + - ][ - + ]: 132 : if ( FacetShell* shell = dynamic_cast<FacetShell*>(myShells.next(i)) )
[ + - ]
1031 [ + - ]: 132 : result_list.append(shell);
1032 : 132 : }
1033 : :
1034 : :
1035 : 957 : void FacetSurface::get_loops( DLIList<FacetLoop*>& result_list )
1036 : : {
1037 : 957 : myLoops.reset();
1038 [ + + ]: 1881 : for ( int i = 0; i < myLoops.size(); i++ )
1039 [ + - ][ - + ]: 924 : if ( FacetLoop* loop = dynamic_cast<FacetLoop*>(myLoops.next(i)) )
[ + - ]
1040 [ + - ]: 924 : result_list.append(loop);
1041 : 957 : }
1042 : :
1043 : 407 : void FacetSurface::get_coedges( DLIList<FacetCoEdge*>& result_list )
1044 : : {
1045 [ + - ]: 407 : DLIList<FacetLoop*> loop_list;
1046 [ + - ]: 407 : get_loops( loop_list );
1047 [ + - ]: 407 : loop_list.reset();
1048 [ + - ][ + + ]: 803 : for ( int i = 0; i < loop_list.size(); i++ )
1049 [ + - ][ + - ]: 803 : loop_list.next(i)->get_coedges( result_list );
[ + - ]
1050 : 407 : }
1051 : :
1052 : 0 : void FacetSurface::get_curves( DLIList<FacetCurve*>& result_list )
1053 : : {
1054 [ # # ]: 0 : DLIList<FacetCoEdge*> coedge_list;
1055 [ # # ]: 0 : get_coedges( coedge_list );
1056 [ # # ]: 0 : coedge_list.reset();
1057 [ # # ][ # # ]: 0 : for ( int i = coedge_list.size(); i--; )
1058 : : {
1059 [ # # ]: 0 : FacetCoEdge* coedge = coedge_list.get_and_step();
1060 [ # # ][ # # ]: 0 : FacetCurve* curve = dynamic_cast<FacetCurve*>(coedge->curve());
1061 [ # # ]: 0 : if (curve)
1062 [ # # ]: 0 : result_list.append_unique(curve);
1063 [ # # ]: 0 : }
1064 : 0 : }
1065 : :
1066 : :
1067 : : //-------------------------------------------------------------------------
1068 : : // Purpose : Remove Shell from shell list
1069 : : //
1070 : : // Special Notes :
1071 : : //
1072 : : // Creator : Jason Kraftcheck
1073 : : //
1074 : : // Creation Date : 09/29/03
1075 : : //-------------------------------------------------------------------------
1076 : 0 : CubitStatus FacetSurface::remove_shell(FacetShell* shell)
1077 : : {
1078 : : // Something strange here -- A DLIList of Shells and a
1079 : : // two-element array for senses? Try to keep the senses
1080 : : // intact anyway...
1081 : 0 : myShells.reset();
1082 [ # # ]: 0 : if (myShells.get() == shell)
1083 : 0 : myShellSense = CUBIT_UNKNOWN;
1084 : :
1085 [ # # ][ # # ]: 0 : if (!myShells.move_to(shell))
1086 : 0 : return CUBIT_FAILURE;
1087 : :
1088 : 0 : myShells.remove();
1089 : 0 : return CUBIT_SUCCESS;
1090 : : }
1091 : :
1092 : : //-------------------------------------------------------------------------
1093 : : // Purpose : Tear down topology
1094 : : //
1095 : : // Special Notes :
1096 : : //
1097 : : // Creator : Jason Kraftcheck
1098 : : //
1099 : : // Creation Date : 09/29/03
1100 : : //-------------------------------------------------------------------------
1101 : 0 : void FacetSurface::disconnect_all_loops()
1102 : : {
1103 : 0 : myLoops.reset();
1104 [ # # ]: 0 : for (int i = myLoops.size(); i--; )
1105 : : {
1106 : 0 : LoopSM* sm_ptr = myLoops.get_and_step();
1107 [ # # ]: 0 : FacetLoop* loop = dynamic_cast<FacetLoop*>(sm_ptr);
1108 [ # # ]: 0 : if (loop)
1109 : : {
1110 [ # # ]: 0 : assert(loop->get_surface() == this);
1111 : 0 : loop->remove_surface();
1112 : : }
1113 : : }
1114 : 0 : myLoops.clean_out();
1115 : 0 : }
1116 : :
1117 : 66 : void FacetSurface::add_transformation( CubitTransformMatrix &tfmat )
1118 : : {
1119 [ - + ]: 66 : if ( myEvaluator )
1120 : 0 : myEvaluator->add_transformation( tfmat );
1121 : 66 : }
1122 : :
1123 : : // ********** END PUBLIC FUNCTIONS **********
1124 : :
1125 : : // ********** BEGIN PROTECTED FUNCTIONS **********
1126 : : // ********** END PROTECTED FUNCTIONS **********
1127 : :
1128 : : // ********** BEGIN PRIVATE FUNCTIONS **********
1129 : 0 : void FacetSurface::reverse_sense()
1130 : : {
1131 [ # # ]: 0 : facetEvalTool->reverse_facets();
1132 [ # # ]: 0 : myLoops.reset();
1133 : : int i,j;
1134 : : FacetLoop* this_loop;
1135 : : LoopSM* this_loop_sm;
1136 [ # # ]: 0 : DLIList<FacetCoEdge *> this_coedge_list;
1137 [ # # ][ # # ]: 0 : for(i=0;i<myLoops.size();i++){
1138 [ # # ]: 0 : this_loop_sm= myLoops.get_and_step();
1139 [ # # ]: 0 : this_loop = dynamic_cast<FacetLoop*>(this_loop_sm);
1140 [ # # ]: 0 : if(!this_loop){
1141 [ # # ][ # # ]: 0 : PRINT_ERROR("Unexpected null pointer for loop.\n");
[ # # ][ # # ]
1142 : 0 : return;
1143 : : }
1144 [ # # ]: 0 : this_loop->reverse();
1145 [ # # ]: 0 : this_coedge_list.clean_out();
1146 [ # # ]: 0 : this_loop->get_coedges(this_coedge_list);
1147 [ # # ][ # # ]: 0 : for(j=0; j<this_coedge_list.size(); j++){
1148 [ # # ][ # # ]: 0 : this_coedge_list.get_and_step()->reverse_sense();
1149 : : }
1150 : : }
1151 : :
1152 : : //sense_ = CubitUtil::opposite_sense( sense_ );
1153 [ # # ][ # # ]: 0 : myShellSense = CubitUtil::opposite_sense( myShellSense );
[ # # ]
1154 : : //myShellSense[1] = CubitUtil::opposite_sense( myShellSense[1] );
1155 : : }
1156 : :
1157 : 0 : CubitStatus FacetSurface::get_projected_distance_on_surface( CubitVector *pos1,
1158 : : CubitVector *pos2,
1159 : : double &distance )
1160 : : {
1161 : 0 : return CUBIT_FAILURE;
1162 : : }
1163 : :
1164 : 0 : CubitStatus FacetSurface::get_sphere_params
1165 : : (
1166 : : CubitVector ¢er,
1167 : : double &radius
1168 : : ) const
1169 : : {
1170 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine sphere parameters for FacetSurfaces.\n");
1171 : 0 : return CUBIT_FAILURE;
1172 : : }
1173 : :
1174 : 0 : CubitStatus FacetSurface::get_cone_params
1175 : : (
1176 : : CubitVector ¢er,
1177 : : CubitVector &normal,
1178 : : CubitVector &major_axis,
1179 : : double &radius_ratio,
1180 : : double &sine_angle,
1181 : : double &cos_angle
1182 : : ) const
1183 : : {
1184 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine cone parameters for FacetSurfaces.\n");
1185 : 0 : return CUBIT_FAILURE;
1186 : : }
1187 : :
1188 : 0 : CubitStatus FacetSurface::get_torus_params
1189 : : (
1190 : : CubitVector ¢er,
1191 : : CubitVector &normal,
1192 : : double &major_radius,
1193 : : double &minor_radius
1194 : : ) const
1195 : : {
1196 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine torus parameters for FacetSurfaces.\n");
1197 : 0 : return CUBIT_FAILURE;
1198 : : }
1199 : :
1200 : :
1201 : 0 : CubitStatus FacetSurface::get_nurb_params
1202 : : (
1203 : : bool &rational,
1204 : : int °ree_u,
1205 : : int °ree_v,
1206 : : int &num_cntrl_pts_u,
1207 : : int &num_cntrl_pts_v,
1208 : : DLIList<CubitVector> &cntrl_pts,
1209 : : DLIList<double> &cntrl_pt_weights,
1210 : : DLIList<double> &u_knots,
1211 : : DLIList<double> &v_knots
1212 : : ) const
1213 : : {
1214 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine nurbs parameters for FacetSurface.\n");
1215 : 0 : return CUBIT_FAILURE;
1216 [ + - ][ + - ]: 6540 : }
1217 : :
1218 : : // ********** END PRIVATE FUNCTIONS **********
1219 : :
1220 : : // ********** BEGIN HELPER CLASSES **********
1221 : : // ********** END HELPER CLASSES **********
1222 : :
1223 : : // ********** BEGIN EXTERN FUNCTIONS **********
1224 : : // ********** END EXTERN FUNCTIONS **********
1225 : :
1226 : : // ********** BEGIN STATIC FUNCTIONS **********
1227 : : // ********** END STATIC FUNCTIONS **********
|
