Branch data Line data Source code
1 : : //-----------------------------------------------------------------------------
2 : : // Filename : GeometryHealerTool.cpp
3 : : //
4 : : // Purpose : Define the healer interface for all solid modeling engines.
5 : : //
6 : : // Special Notes : This is a singleton pattern class for the healer functions.
7 : : //
8 : : // Creator : Tyronne Lim (CAT)
9 : : //
10 : : // Creation Date : 7/21/03
11 : : //
12 : : // Owner :
13 : : //-----------------------------------------------------------------------------
14 : :
15 : : // *** BEGIN INCLUDES *** //
16 : :
17 : : #include "GeometryHealerTool.hpp"
18 : :
19 : : #include "GeometryHealerEngine.hpp"
20 : :
21 : : #include "Body.hpp"
22 : :
23 : : #include "RefEntityFactory.hpp"
24 : : #include "TopologyEntity.hpp"
25 : :
26 : : #include "CastTo.hpp"
27 : : #include "CubitMessage.hpp"
28 : : #include "RefFace.hpp"
29 : : #include "AppUtil.hpp"
30 : : #include "CubitOperationEvent.hpp"
31 : :
32 : : #include "MergeTool.hpp"
33 : :
34 : : // *** END INCLUDES *** //
35 : :
36 : : GeometryHealerTool* GeometryHealerTool::instance_ = 0;
37 : :
38 : : // *** BEGIN PUBLIC FUNCTIONS *** //
39 : :
40 : : //-----------------------------------------------------------------------------
41 : : // Purpose : Controls access/creation of the sole instance of this class.
42 : : //
43 : : // Creator : Tyronne Lim (CAT)
44 : : //
45 : : // Creation Date : 07/21/03
46 : : //-----------------------------------------------------------------------------
47 : 0 : GeometryHealerTool* GeometryHealerTool::instance( GeometryHealerEngine *GHEPtr )
48 : : {
49 : : // Check to see if we have created an instance of the class;
50 : : // if not, proceed to create one.
51 [ # # ]: 0 : if (instance_ == 0)
52 : : {
53 : : // When creating the instance, we should always have a valid
54 : : // ghePtr. If not, complain.
55 [ # # ]: 0 : instance_ = new GeometryHealerTool(GHEPtr);
56 : :
57 : : // Check to make sure there's a ref entity factory extant:
58 : : // RefEntityFactory *factory =
59 : 0 : RefEntityFactory::instance();
60 : : }
61 : : // If there is an existing instance of the class, check if there
62 : : // is a request to set the default engine. If so, do so.
63 [ # # ][ # # ]: 0 : else if ( GHEPtr != NULL && !instance_->gheList.move_to(GHEPtr) )
[ # # ]
64 : : {
65 [ # # ]: 0 : delete instance_->gheList.remove();
66 : 0 : instance_->gheList.insert(GHEPtr);
67 : : }
68 : :
69 : : // Return the a pointer to the instance of the class.
70 : 0 : return instance_;
71 : : }
72 : :
73 : : //-----------------------------------------------------------------------------
74 : : // Purpose : Destructor.
75 : : //
76 : : // Creator : Tyronne Lim (CAT)
77 : : //
78 : : // Creation Date : 07/21/03
79 : : //-----------------------------------------------------------------------------
80 : 0 : GeometryHealerTool::~GeometryHealerTool()
81 : : {
82 [ # # ][ # # ]: 0 : for (int i = gheList.size(); i > 0; i--)
83 [ # # ][ # # ]: 0 : delete gheList.get_and_step();
[ # # ]
84 : :
85 [ # # ]: 0 : gheList.clean_out();
86 : 0 : instance_ = NULL;
87 : 0 : }
88 : :
89 : : // *** BEGIN ENGINE OPERATIONS *** //
90 : : /*
91 : : //-----------------------------------------------------------------------------
92 : : // Purpose : Sets the default engine.
93 : : //
94 : : // Creator : Tyronne Lim (CAT)
95 : : //
96 : : // Creation Date : 07/21/03
97 : : //-----------------------------------------------------------------------------
98 : : void GeometryHealerTool::set_default_engine( GeometryHealerEngine *ghe_ptr )
99 : : {
100 : : default_ghe = ghe_ptr;
101 : : }
102 : : */
103 : : //-----------------------------------------------------------------------------
104 : : // Purpose : Adds a healer engine to the list.
105 : : //
106 : : // Creator : Tyronne Lim (CAT)
107 : : //
108 : : // Creation Date : 07/21/03
109 : : //-----------------------------------------------------------------------------
110 : 0 : void GeometryHealerTool::add_ghe( GeometryHealerEngine *ghe_ptr )
111 : : {
112 [ # # ]: 0 : assert(ghe_ptr != 0);
113 : :
114 : : // for now, GeometryHealerTool is only set up for a single healer engine
115 : : // so if more than one healer is being added all the code for this class needs
116 : : // to be reviewed - Byron 08/12/2003
117 [ # # ]: 0 : assert(gheList.size() == 0);
118 : :
119 [ # # ]: 0 : if (!gheList.move_to(ghe_ptr))
120 : 0 : gheList.append(ghe_ptr);
121 : 0 : }
122 : : /*
123 : : //-----------------------------------------------------------------------------
124 : : // Purpose : Removes a healer engine from the list.
125 : : //
126 : : // Creator : Tyronne Lim (CAT)
127 : : //
128 : : // Creation Date : 07/21/03
129 : : //-----------------------------------------------------------------------------
130 : : CubitStatus GeometryHealerTool::remove_ghe( GeometryHealerEngine *ghe_ptr )
131 : : {
132 : : assert(ghe_ptr != 0);
133 : : CubitStatus status = CUBIT_FAILURE;
134 : :
135 : : if (gheList.move_to(ghe_ptr))
136 : : {
137 : : gheList.remove();
138 : : status = CUBIT_SUCCESS;
139 : : }
140 : :
141 : : return status;
142 : : }
143 : :
144 : : //-----------------------------------------------------------------------------
145 : : // Purpose : Gets the list of healer engines.
146 : : //
147 : : // Creator : Tyronne Lim (CAT)
148 : : //
149 : : // Creation Date : 07/21/03
150 : : //-----------------------------------------------------------------------------
151 : : void GeometryHealerTool::get_ghe_list( DLIList<GeometryHealerEngine*> &ghe_list )
152 : : {
153 : : ghe_list += gheList;
154 : : }
155 : :
156 : : //-----------------------------------------------------------------------------
157 : : // Purpose : Gets the current healer engine (first in the list).
158 : : //
159 : : // Creator : Tyronne Lim (CAT)
160 : : //
161 : : // Creation Date : 07/21/03
162 : : //-----------------------------------------------------------------------------
163 : : GeometryHealerEngine *GeometryHealerTool::get_ghe()
164 : : {
165 : : GeometryHealerEngine *ghe = NULL;
166 : :
167 : : if (gheList.size())
168 : : {
169 : : gheList.reset();
170 : : ghe = gheList.get();
171 : : }
172 : :
173 : : return ghe;
174 : : }
175 : : */
176 : : //-----------------------------------------------------------------------------
177 : : // Purpose : Returns the healer engine of an entity.
178 : : //
179 : : // Creator : Tyronne Lim (CAT)
180 : : //
181 : : // Creation Date : 08/01/03
182 : : //-----------------------------------------------------------------------------
183 : 0 : GeometryHealerEngine* GeometryHealerTool::get_engine( TopologyBridge *tb_ptr ) const
184 : : {
185 : : GeometryHealerEngine *ghe;
186 : :
187 [ # # ]: 0 : for (int i = 0; i < gheList.size(); i++)
188 : : {
189 : 0 : ghe = gheList.next(i);
190 [ # # ]: 0 : if (ghe->is_healer_engine(tb_ptr))
191 : 0 : return ghe;
192 : : }
193 : :
194 : 0 : return NULL;
195 : : }
196 : :
197 : : //-----------------------------------------------------------------------------
198 : : // Purpose : Returns the healer engine of an entity.
199 : : //
200 : : // Creator : Tyronne Lim (CAT)
201 : : //
202 : : // Creation Date : 08/01/03
203 : : //-----------------------------------------------------------------------------
204 : 0 : GeometryHealerEngine* GeometryHealerTool::get_engine( TopologyEntity *te_ptr ) const
205 : : {
206 : : GeometryHealerEngine *ghe;
207 : :
208 : 0 : TopologyBridge *tb_ptr = te_ptr->bridge_manager()->topology_bridge();
209 : :
210 [ # # ]: 0 : for (int i = 0; i < gheList.size(); i++)
211 : : {
212 : 0 : ghe = gheList.next(i);
213 [ # # ]: 0 : if (ghe->is_healer_engine(tb_ptr))
214 : 0 : return ghe;
215 : : }
216 : :
217 : 0 : return NULL;
218 : : }
219 : :
220 : : //-----------------------------------------------------------------------------
221 : : // Purpose : Determines if entities are from the same engine.
222 : : //
223 : : // Creator : Tyronne Lim (CAT)
224 : : //
225 : : // Creation Date : 08/01/03
226 : : //-----------------------------------------------------------------------------
227 : 0 : CubitBoolean GeometryHealerTool::same_healer_engine( DLIList<RefEntity*> &ref_entity_list,
228 : : CubitBoolean check_children ) const
229 : : {
230 [ # # ]: 0 : DLIList<RefEntity*> complete_entity_list;
231 : :
232 : : //Check the check_children option and check all the children if necessary
233 [ # # ]: 0 : if (check_children)
234 : : {
235 : : //Make a complete list of all the RefEntities and their children
236 [ # # ]: 0 : DLIList<RefEntity*> temp = ref_entity_list;
237 : : RefEntity* ref_entity_ptr;
238 : :
239 [ # # ][ # # ]: 0 : for (int i = 0; i < ref_entity_list.size(); i++)
240 : : {
241 [ # # ]: 0 : ref_entity_ptr = ref_entity_list.get_and_step();
242 [ # # ]: 0 : complete_entity_list.clean_out();
243 [ # # ]: 0 : ref_entity_ptr->get_all_child_ref_entities(complete_entity_list);
244 [ # # ]: 0 : temp += complete_entity_list;
245 : : }
246 : :
247 [ # # ]: 0 : complete_entity_list.clean_out();
248 [ # # ][ # # ]: 0 : complete_entity_list.merge_unique(temp);
249 : : }
250 : :
251 : : //Now make sure all the RefEntities are from the same geometry engine
252 [ # # ][ # # ]: 0 : DLIList<TopologyEntity*> te_list;
253 [ # # ][ # # ]: 0 : CAST_LIST(complete_entity_list, te_list, TopologyEntity);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
254 [ # # ][ # # ]: 0 : return same_healer_engine(te_list);
255 : : }
256 : :
257 : : //-----------------------------------------------------------------------------
258 : : // Purpose : Determines if entities are from the same engine.
259 : : //
260 : : // Creator : Tyronne Lim (CAT)
261 : : //
262 : : // Creation Date : 08/01/03
263 : : //-----------------------------------------------------------------------------
264 : 0 : CubitBoolean GeometryHealerTool::same_healer_engine( DLIList<TopologyEntity*> &topo_list ) const
265 : : {
266 : 0 : GeometryHealerEngine *gePtr1 = get_engine(topo_list.get_and_step());
267 : : GeometryHealerEngine *gePtr2;
268 : :
269 [ # # ]: 0 : for (int i = 1; i < topo_list.size(); i++)
270 : : {
271 : 0 : gePtr2 = get_engine(topo_list.get_and_step());
272 [ # # ]: 0 : if (gePtr1 != gePtr2)
273 : : {
274 : 0 : return CUBIT_FALSE;
275 : : }
276 : : }
277 : 0 : return CUBIT_TRUE;
278 : : }
279 : :
280 : : // *** END ENGINE OPERATIONS *** //
281 : :
282 : : // *** BEGIN HEALER FUNCTIONS *** //
283 : :
284 : 0 : CubitStatus GeometryHealerTool::auto_heal_bodies( DLIList<Body*> &body_list,
285 : : DLIList<Body*> &new_body_list,
286 : : DLIList<TopologyEntity*> &bad_geometry,
287 : : CubitBoolean rebuild, CubitBoolean keep_old,
288 : : CubitBoolean make_tolerant, FILE* logfile_ptr )
289 : : {
290 [ # # ]: 0 : DLIList<RefEntity*> ref_entity_list;
291 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT(body_list, ref_entity_list);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
292 : :
293 [ # # ][ # # ]: 0 : if (!same_healer_engine(ref_entity_list, CUBIT_TRUE))
294 : : {
295 [ # # ][ # # ]: 0 : PRINT_ERROR("HEALING bodies from different\n"
[ # # ]
296 [ # # ]: 0 : " geometry engines is not allowed.\n");
297 : 0 : return CUBIT_FAILURE;
298 : : }
299 : :
300 [ # # ][ # # ]: 0 : if(rebuild && !keep_old)
301 : : {
302 [ # # ][ # # ]: 0 : MergeTool::instance()->unmerge(ref_entity_list);
303 : : }
304 : :
305 [ # # ][ # # ]: 0 : GeometryHealerEngine* GHEPtr = get_engine(body_list.get());
306 [ # # ]: 0 : if (GHEPtr)
307 : : {
308 : : CubitStatus healer_status = GHEPtr->auto_heal_bodies(body_list, new_body_list, bad_geometry,
309 [ # # ]: 0 : rebuild, keep_old, make_tolerant, logfile_ptr);
310 : :
311 : : // if( healer_status == CUBIT_SUCCESS )
312 [ # # ][ # # ]: 0 : AppUtil::instance()->send_event(CubitOperationEvent(CubitOperationEvent::HEALER_COMPLETED));
[ # # ][ # # ]
313 : :
314 : 0 : return healer_status;
315 : : }
316 : : else
317 [ # # ][ # # ]: 0 : PRINT_ERROR( "Bodies are of a geometry engine without a healer\n"
[ # # ]
318 [ # # ]: 0 : " and cannot be healed.\n");
319 [ # # ]: 0 : return CUBIT_FAILURE;
320 : : }
321 : :
322 : 0 : CubitStatus GeometryHealerTool::heal_bodies( DLIList<Body*> &body_list,
323 : : DLIList<Body*> &new_body_list,
324 : : DLIList<TopologyEntity*> &bad_geometry,
325 : : CubitBoolean rebuild, CubitBoolean keep_old,
326 : : CubitBoolean make_tolerant, FILE* logfile_ptr )
327 : : {
328 [ # # ]: 0 : DLIList<RefEntity*> ref_entity_list;
329 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT(body_list, ref_entity_list);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
330 : :
331 [ # # ][ # # ]: 0 : if (!same_healer_engine(ref_entity_list, CUBIT_TRUE))
332 : : {
333 [ # # ][ # # ]: 0 : PRINT_ERROR("HEALING bodies from different\n"
[ # # ]
334 [ # # ]: 0 : " geometry engines is not allowed.\n");
335 : 0 : return CUBIT_FAILURE;
336 : : }
337 : :
338 [ # # ][ # # ]: 0 : GeometryHealerEngine* GHEPtr = get_engine(body_list.get());
339 [ # # ]: 0 : if (GHEPtr)
340 : : return GHEPtr->heal_bodies(body_list, new_body_list, bad_geometry,
341 [ # # ]: 0 : rebuild, keep_old, make_tolerant, logfile_ptr);
342 : : else
343 [ # # ][ # # ]: 0 : PRINT_ERROR( "Bodies are of a geometry engine without a healer\n"
[ # # ]
344 [ # # ]: 0 : " and cannot be healed.\n");
345 [ # # ]: 0 : return CUBIT_FAILURE;
346 : : }
347 : :
348 : 0 : CubitStatus GeometryHealerTool::analyze_badgeom( DLIList<Body*> &body_list,
349 : : DLIList<TopologyEntity*> &bad_geometry,
350 : : FILE* logfile)
351 : : {
352 [ # # ]: 0 : DLIList<RefEntity*> ref_entity_list;
353 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT(body_list, ref_entity_list);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
354 : :
355 [ # # ][ # # ]: 0 : if (!same_healer_engine(ref_entity_list, CUBIT_TRUE))
356 : : {
357 [ # # ][ # # ]: 0 : PRINT_ERROR("HEALING bodies from different\n"
[ # # ]
358 [ # # ]: 0 : " geometry engines is not allowed.\n");
359 : 0 : return CUBIT_FAILURE;
360 : : }
361 : :
362 [ # # ][ # # ]: 0 : GeometryHealerEngine* GHEPtr = get_engine(body_list.get());
363 [ # # ]: 0 : if (GHEPtr)
364 [ # # ]: 0 : return GHEPtr->analyze_badgeom(body_list, bad_geometry, logfile);
365 : : else
366 [ # # ][ # # ]: 0 : PRINT_ERROR( "Bodies are of a geometry engine without a healer\n"
[ # # ]
367 [ # # ]: 0 : " and cannot be healed.\n");
368 [ # # ]: 0 : return CUBIT_FAILURE;
369 : : }
370 : :
371 : 0 : CubitStatus GeometryHealerTool::get_badgeom( DLIList<Body*> &body_list,
372 : : DLIList<TopologyEntity*> &bad_geometry )
373 : : {
374 [ # # ]: 0 : DLIList<RefEntity*> ref_entity_list;
375 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT(body_list, ref_entity_list);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
376 : :
377 [ # # ][ # # ]: 0 : if (!same_healer_engine(ref_entity_list, CUBIT_TRUE))
378 : : {
379 [ # # ][ # # ]: 0 : PRINT_ERROR("HEALING bodies from different\n"
[ # # ]
380 [ # # ]: 0 : " geometry engines is not allowed.\n");
381 : 0 : return CUBIT_FAILURE;
382 : : }
383 : :
384 [ # # ][ # # ]: 0 : GeometryHealerEngine* GHEPtr = get_engine(body_list.get());
385 [ # # ]: 0 : if (GHEPtr)
386 [ # # ]: 0 : return GHEPtr->get_badgeom(body_list, bad_geometry);
387 : : else
388 [ # # ][ # # ]: 0 : PRINT_ERROR( "Bodies are of a geometry engine without a healer\n"
[ # # ]
389 [ # # ]: 0 : " and cannot be healed.\n");
390 [ # # ]: 0 : return CUBIT_FAILURE;
391 : : }
392 : :
393 : 0 : CubitStatus GeometryHealerTool::get_tcurves( DLIList<Body*> &body_list,
394 : : DLIList<RefEdge*> &t_curves )
395 : : {
396 [ # # ]: 0 : DLIList<RefEntity*> ref_entity_list;
397 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT(body_list, ref_entity_list);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
398 : :
399 [ # # ][ # # ]: 0 : if (!same_healer_engine(ref_entity_list, CUBIT_TRUE))
400 : : {
401 [ # # ][ # # ]: 0 : PRINT_ERROR("HEALING bodies from different\n"
[ # # ]
402 [ # # ]: 0 : " geometry engines is not allowed.\n");
403 : 0 : return CUBIT_FAILURE;
404 : : }
405 : :
406 [ # # ][ # # ]: 0 : GeometryHealerEngine* GHEPtr = get_engine(body_list.get());
407 [ # # ]: 0 : if (GHEPtr)
408 [ # # ]: 0 : return GHEPtr->get_tcurves(body_list, t_curves);
409 : : else
410 [ # # ][ # # ]: 0 : PRINT_ERROR( "Bodies are of a geometry engine without a healer\n"
[ # # ]
411 [ # # ]: 0 : " and cannot be healed.\n");
412 [ # # ]: 0 : return CUBIT_FAILURE;
413 : : }
414 : :
415 : 0 : CubitStatus GeometryHealerTool::heal_incremental( DLIList<Body*> &body_list,
416 : : DLIList<Body*> &new_bodies,
417 : : DLIList<TopologyEntity*> &bad_geometry,
418 : : double simplify_tol, double stitch_min_tol,
419 : : double stitch_max_tol, double geombuild_tol,
420 : : double analytic_tol, double isospline_tol,
421 : : double reblend_classify_tol, double reblend_tol,
422 : : CubitBoolean keep_old, CubitBoolean make_tolerant,
423 : : FILE* logfile_ptr )
424 : : {
425 [ # # ]: 0 : DLIList<RefEntity*> ref_entity_list;
426 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT(body_list, ref_entity_list);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
427 : :
428 [ # # ][ # # ]: 0 : if (!same_healer_engine(ref_entity_list, CUBIT_TRUE))
429 : : {
430 [ # # ][ # # ]: 0 : PRINT_ERROR("HEALING bodies from different\n"
[ # # ]
431 [ # # ]: 0 : " geometry engines is not allowed.\n");
432 : 0 : return CUBIT_FAILURE;
433 : : }
434 : :
435 [ # # ][ # # ]: 0 : GeometryHealerEngine* GHEPtr = get_engine(body_list.get());
436 [ # # ]: 0 : if (GHEPtr)
437 : : return GHEPtr->heal_incremental(body_list, new_bodies, bad_geometry, simplify_tol,
438 : : stitch_min_tol, stitch_max_tol, geombuild_tol,
439 : : analytic_tol, isospline_tol, reblend_classify_tol,
440 [ # # ]: 0 : reblend_tol, keep_old, make_tolerant, logfile_ptr);
441 : : else
442 [ # # ][ # # ]: 0 : PRINT_ERROR( "Bodies are of a geometry engine without a healer\n"
[ # # ]
443 [ # # ]: 0 : " and cannot be healed.\n");
444 [ # # ]: 0 : return CUBIT_FAILURE;
445 : : }
446 : :
447 : 0 : void GeometryHealerTool::list_incremental()
448 : : {
449 : 0 : gheList.get()->list_incremental();
450 : 0 : }
451 : :
452 : 0 : void GeometryHealerTool::list_tolerances( DLIList<Body*> &body_list )
453 : : {
454 [ # # ]: 0 : DLIList<RefEntity*> ref_entity_list;
455 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT(body_list, ref_entity_list);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
456 : :
457 [ # # ][ # # ]: 0 : if (!same_healer_engine(ref_entity_list, CUBIT_TRUE))
458 : : {
459 [ # # ][ # # ]: 0 : PRINT_ERROR("HEALING bodies from different\n"
[ # # ]
460 [ # # ]: 0 : " geometry engines is not allowed.\n");
461 : : }
462 : :
463 [ # # ][ # # ]: 0 : GeometryHealerEngine* GHEPtr = get_engine(body_list.get());
464 [ # # ]: 0 : if (GHEPtr)
465 [ # # ]: 0 : GHEPtr->list_tolerances(body_list);
466 : : else
467 [ # # ][ # # ]: 0 : PRINT_ERROR( "Bodies are of a geometry engine without a healer\n"
[ # # ]
468 [ # # ][ # # ]: 0 : " and cannot be healed.\n");
469 : 0 : }
470 : :
471 : 0 : double GeometryHealerTool::get_default_simplify_tol()
472 : : {
473 : 0 : return gheList.get()->get_default_simplify_tol();
474 : : }
475 : :
476 : 0 : void GeometryHealerTool::set_default_simplify_tol( double tol )
477 : : {
478 : 0 : gheList.get()->set_default_simplify_tol(tol);
479 : 0 : }
480 : :
481 : 0 : double GeometryHealerTool::get_default_stitch_min_tol()
482 : : {
483 : 0 : return gheList.get()->get_default_stitch_min_tol();
484 : : }
485 : :
486 : 0 : void GeometryHealerTool::set_default_stitch_min_tol( double tol )
487 : : {
488 : 0 : gheList.get()->set_default_stitch_min_tol(tol);
489 : 0 : }
490 : :
491 : 0 : double GeometryHealerTool::get_default_stitch_max_tol()
492 : : {
493 : 0 : return gheList.get()->get_default_stitch_max_tol();
494 : : }
495 : :
496 : 0 : void GeometryHealerTool::set_default_stitch_max_tol( double tol )
497 : : {
498 : 0 : gheList.get()->set_default_stitch_max_tol(tol);
499 : 0 : }
500 : :
501 : 0 : double GeometryHealerTool::get_default_geombuild_tol()
502 : : {
503 : 0 : return gheList.get()->get_default_geombuild_tol();
504 : : }
505 : :
506 : 0 : void GeometryHealerTool::set_default_geombuild_tol( double tol )
507 : : {
508 : 0 : gheList.get()->set_default_geombuild_tol(tol);
509 : 0 : }
510 : :
511 : 0 : double GeometryHealerTool::get_default_analytic_tol()
512 : : {
513 : 0 : return gheList.get()->get_default_analytic_tol();
514 : : }
515 : :
516 : 0 : void GeometryHealerTool::set_default_analytic_tol( double tol )
517 : : {
518 : 0 : gheList.get()->set_default_analytic_tol(tol);
519 : 0 : }
520 : :
521 : 0 : double GeometryHealerTool::get_default_isospline_tol()
522 : : {
523 : 0 : return gheList.get()->get_default_isospline_tol();
524 : : }
525 : :
526 : 0 : void GeometryHealerTool::set_default_isospline_tol( double tol )
527 : : {
528 : 0 : gheList.get()->set_default_isospline_tol(tol);
529 : 0 : }
530 : :
531 : 0 : double GeometryHealerTool::get_default_reblend_classify_tol()
532 : : {
533 : 0 : return gheList.get()->get_default_reblend_classify_tol();
534 : : }
535 : :
536 : 0 : void GeometryHealerTool::set_default_reblend_classify_tol( double tol )
537 : : {
538 : 0 : gheList.get()->set_default_reblend_classify_tol(tol);
539 : 0 : }
540 : :
541 : 0 : double GeometryHealerTool::get_default_reblend_tol()
542 : : {
543 : 0 : return gheList.get()->get_default_reblend_tol();
544 : : }
545 : :
546 : 0 : void GeometryHealerTool::set_default_reblend_tol( double tol )
547 : : {
548 : 0 : gheList.get()->set_default_reblend_tol(tol);
549 : 0 : }
550 : :
551 : 0 : void GeometryHealerTool::reset_default_tolerances()
552 : : {
553 : 0 : gheList.get()->reset_default_tolerances();
554 : 0 : }
555 : :
556 : 0 : void GeometryHealerTool::list_default_tolerances()
557 : : {
558 : 0 : gheList.get()->list_default_tolerances();
559 : 0 : }
560 : :
561 : 0 : void GeometryHealerTool::clean_attributes( DLIList<Body*>& body_list )
562 : : {
563 [ # # ]: 0 : DLIList<RefEntity*> ref_entity_list;
564 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT(body_list, ref_entity_list);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
565 : :
566 [ # # ][ # # ]: 0 : if (!same_healer_engine(ref_entity_list, CUBIT_TRUE))
567 : : {
568 [ # # ][ # # ]: 0 : PRINT_ERROR("HEALING bodies from different\n"
[ # # ]
569 [ # # ]: 0 : " geometry engines is not allowed.\n");
570 : : }
571 : :
572 [ # # ][ # # ]: 0 : GeometryHealerEngine* GHEPtr = get_engine(body_list.get());
573 [ # # ]: 0 : if (GHEPtr)
574 [ # # ]: 0 : GHEPtr->clean_attributes(body_list);
575 : : else
576 [ # # ][ # # ]: 0 : PRINT_ERROR( "Bodies are of a geometry engine without a healer\n"
[ # # ]
577 [ # # ][ # # ]: 0 : " and cannot be healed.\n");
578 : 0 : }
579 : :
580 : 0 : CubitBoolean GeometryHealerTool::get_cleanatt_flg()
581 : : {
582 : 0 : return gheList.get()->get_cleanatt_flg();
583 : : }
584 : :
585 : 0 : void GeometryHealerTool::set_cleanatt_flg( CubitBoolean flg )
586 : : {
587 : 0 : gheList.get()->set_cleanatt_flg(flg);
588 : 0 : }
589 : :
590 : 0 : int GeometryHealerTool::get_show_method()
591 : : {
592 : 0 : return gheList.get()->get_show_method();
593 : : }
594 : :
595 : 0 : void GeometryHealerTool::set_show_method( int method )
596 : : {
597 : 0 : gheList.get()->set_show_method(method);
598 : 0 : }
599 : :
600 : 0 : CubitBoolean GeometryHealerTool::get_show_summary_flg()
601 : : {
602 : 0 : return gheList.get()->get_show_summary_flg();
603 : : }
604 : :
605 : 0 : void GeometryHealerTool::set_show_summary_flg( CubitBoolean flg )
606 : : {
607 : 0 : gheList.get()->set_show_summary_flg(flg);
608 : 0 : }
609 : :
610 : 0 : CubitBoolean GeometryHealerTool::get_show_details_flg()
611 : : {
612 : 0 : return gheList.get()->get_show_details_flg();
613 : : }
614 : :
615 : 0 : void GeometryHealerTool::set_show_details_flg( CubitBoolean flg )
616 : : {
617 : 0 : gheList.get()->set_show_details_flg(flg);
618 : 0 : }
619 : :
620 : 0 : CubitBoolean GeometryHealerTool::get_show_on_heal_flg()
621 : : {
622 : 0 : return gheList.get()->get_show_on_heal_flg();
623 : : }
624 : :
625 : 0 : void GeometryHealerTool::set_show_on_heal_flg( CubitBoolean flg )
626 : : {
627 : 0 : gheList.get()->set_show_on_heal_flg(flg);
628 : 0 : }
629 : :
630 : 0 : CubitBoolean GeometryHealerTool::get_check_vol_on_heal_flg()
631 : : {
632 : 0 : return gheList.get()->get_check_vol_on_heal_flg();
633 : : }
634 : :
635 : 0 : void GeometryHealerTool::set_check_vol_on_heal_flg( CubitBoolean flg )
636 : : {
637 : 0 : gheList.get()->set_check_vol_on_heal_flg(flg);
638 : 0 : }
639 : :
640 : 0 : double GeometryHealerTool::get_vol_on_heal_limit()
641 : : {
642 : 0 : return gheList.get()->get_vol_on_heal_limit();
643 : : }
644 : :
645 : 0 : void GeometryHealerTool::set_vol_on_heal_limit( double limit )
646 : : {
647 : 0 : gheList.get()->set_vol_on_heal_limit(limit);
648 : 0 : }
649 : :
650 : 0 : CubitBoolean GeometryHealerTool::get_check_surf_on_heal_flg()
651 : : {
652 : 0 : return gheList.get()->get_check_surf_on_heal_flg();
653 : : }
654 : :
655 : 0 : void GeometryHealerTool::set_check_surf_on_heal_flg( CubitBoolean flg )
656 : : {
657 : 0 : gheList.get()->set_check_surf_on_heal_flg(flg);
658 : 0 : }
659 : :
660 : 0 : double GeometryHealerTool::get_surf_on_heal_limit()
661 : : {
662 : 0 : return gheList.get()->get_surf_on_heal_limit();
663 : : }
664 : :
665 : 0 : void GeometryHealerTool::set_surf_on_heal_limit( double limit )
666 : : {
667 : 0 : gheList.get()->set_surf_on_heal_limit(limit);
668 : 0 : }
669 : :
670 : 0 : CubitBoolean GeometryHealerTool::get_check_curve_on_heal_flg()
671 : : {
672 : 0 : return gheList.get()->get_check_curve_on_heal_flg();
673 : : }
674 : :
675 : 0 : void GeometryHealerTool::set_check_curve_on_heal_flg( CubitBoolean flg )
676 : : {
677 : 0 : gheList.get()->set_check_curve_on_heal_flg(flg);
678 : 0 : }
679 : :
680 : 0 : double GeometryHealerTool::get_curve_on_heal_limit()
681 : : {
682 : 0 : return gheList.get()->get_curve_on_heal_limit();
683 : : }
684 : :
685 : 0 : void GeometryHealerTool::set_curve_on_heal_limit( double limit )
686 : : {
687 : 0 : gheList.get()->set_curve_on_heal_limit(limit);
688 : 0 : }
689 : :
690 : 0 : CubitBoolean GeometryHealerTool::get_show_bad_vertices_flg()
691 : : {
692 : 0 : return gheList.get()->get_show_bad_vertices_flg();
693 : : }
694 : :
695 : 0 : void GeometryHealerTool::set_show_bad_vertices_flg( CubitBoolean flg )
696 : : {
697 : 0 : gheList.get()->set_show_bad_vertices_flg(flg);
698 : 0 : }
699 : :
700 : 0 : CubitBoolean GeometryHealerTool::get_show_bad_curves_flg()
701 : : {
702 : 0 : return gheList.get()->get_show_bad_curves_flg();
703 : : }
704 : :
705 : 0 : void GeometryHealerTool::set_show_bad_curves_flg( CubitBoolean flg )
706 : : {
707 : 0 : gheList.get()->set_show_bad_curves_flg(flg);
708 : 0 : }
709 : :
710 : 0 : CubitBoolean GeometryHealerTool::get_show_bad_coedges_flg()
711 : : {
712 : 0 : return gheList.get()->get_show_bad_coedges_flg();
713 : : }
714 : :
715 : 0 : void GeometryHealerTool::set_show_bad_coedges_flg( CubitBoolean flg )
716 : : {
717 : 0 : gheList.get()->set_show_bad_coedges_flg(flg);
718 : 0 : }
719 : :
720 : 0 : CubitBoolean GeometryHealerTool::get_show_bad_loops_flg()
721 : : {
722 : 0 : return gheList.get()->get_show_bad_loops_flg();
723 : : }
724 : :
725 : 0 : void GeometryHealerTool::set_show_bad_loops_flg( CubitBoolean flg )
726 : : {
727 : 0 : gheList.get()->set_show_bad_loops_flg(flg);
728 : 0 : }
729 : :
730 : 0 : CubitBoolean GeometryHealerTool::get_show_bad_surfaces_flg()
731 : : {
732 : 0 : return gheList.get()->get_show_bad_surfaces_flg();
733 : : }
734 : :
735 : 0 : void GeometryHealerTool::set_show_bad_surfaces_flg( CubitBoolean flg )
736 : : {
737 : 0 : gheList.get()->set_show_bad_surfaces_flg(flg);
738 : 0 : }
739 : :
740 : 0 : CubitBoolean GeometryHealerTool::get_show_bad_shells_flg()
741 : : {
742 : 0 : return gheList.get()->get_show_bad_shells_flg();
743 : : }
744 : :
745 : 0 : void GeometryHealerTool::set_show_bad_shells_flg( CubitBoolean flg )
746 : : {
747 : 0 : gheList.get()->set_show_bad_shells_flg(flg);
748 : 0 : }
749 : :
750 : 0 : CubitBoolean GeometryHealerTool::get_show_bad_volumes_flg()
751 : : {
752 : 0 : return gheList.get()->get_show_bad_volumes_flg();
753 : : }
754 : :
755 : 0 : void GeometryHealerTool::set_show_bad_volumes_flg( CubitBoolean flg )
756 : : {
757 : 0 : gheList.get()->set_show_bad_volumes_flg(flg);
758 : 0 : }
759 : :
760 : 0 : CubitBoolean GeometryHealerTool::get_show_bad_bodies_flg()
761 : : {
762 : 0 : return gheList.get()->get_show_bad_bodies_flg();
763 : : }
764 : :
765 : 0 : void GeometryHealerTool::set_show_bad_bodies_flg( CubitBoolean flg )
766 : : {
767 : 0 : gheList.get()->set_show_bad_bodies_flg(flg);
768 : 0 : }
769 : :
770 : 0 : void GeometryHealerTool::list_onshow_flgs()
771 : : {
772 : 0 : gheList.get()->list_onshow_flgs();
773 : 0 : }
774 : :
775 : 0 : CubitBoolean GeometryHealerTool::get_inc_preprocess_flg()
776 : : {
777 : 0 : return gheList.get()->get_inc_preprocess_flg();
778 : : }
779 : :
780 : 0 : void GeometryHealerTool::set_inc_preprocess_flg( CubitBoolean flg )
781 : : {
782 : 0 : gheList.get()->set_inc_preprocess_flg(flg);
783 : 0 : }
784 : :
785 : 0 : CubitBoolean GeometryHealerTool::get_inc_simplify_flg()
786 : : {
787 : 0 : return gheList.get()->get_inc_simplify_flg();
788 : : }
789 : :
790 : 0 : void GeometryHealerTool::set_inc_simplify_flg( CubitBoolean flg )
791 : : {
792 : 0 : gheList.get()->set_inc_simplify_flg(flg);
793 : 0 : }
794 : :
795 : 0 : CubitBoolean GeometryHealerTool::get_inc_stitch_flg()
796 : : {
797 : 0 : return gheList.get()->get_inc_stitch_flg();
798 : : }
799 : :
800 : 0 : void GeometryHealerTool::set_inc_stitch_flg( CubitBoolean flg )
801 : : {
802 : 0 : gheList.get()->set_inc_stitch_flg(flg);
803 : 0 : }
804 : :
805 : 0 : CubitBoolean GeometryHealerTool::get_inc_geombuild_flg()
806 : : {
807 : 0 : return gheList.get()->get_inc_geombuild_flg();
808 : : }
809 : :
810 : 0 : void GeometryHealerTool::set_inc_geombuild_flg( CubitBoolean flg )
811 : : {
812 : 0 : gheList.get()->set_inc_geombuild_flg(flg);
813 : 0 : }
814 : :
815 : 0 : CubitBoolean GeometryHealerTool::get_inc_analytic_flg()
816 : : {
817 : 0 : return gheList.get()->get_inc_analytic_flg();
818 : : }
819 : :
820 : 0 : void GeometryHealerTool::set_inc_analytic_flg( CubitBoolean flg )
821 : : {
822 : 0 : gheList.get()->set_inc_analytic_flg(flg);
823 : 0 : }
824 : :
825 : 0 : CubitBoolean GeometryHealerTool::get_inc_isospline_flg()
826 : : {
827 : 0 : return gheList.get()->get_inc_isospline_flg();
828 : : }
829 : :
830 : 0 : void GeometryHealerTool::set_inc_isospline_flg( CubitBoolean flg )
831 : : {
832 : 0 : gheList.get()->set_inc_isospline_flg(flg);
833 : 0 : }
834 : :
835 : 0 : CubitBoolean GeometryHealerTool::get_inc_reblend_flg()
836 : : {
837 : 0 : return gheList.get()->get_inc_reblend_flg();
838 : : }
839 : :
840 : 0 : void GeometryHealerTool::set_inc_reblend_flg( CubitBoolean flg )
841 : : {
842 : 0 : gheList.get()->set_inc_reblend_flg(flg);
843 : 0 : }
844 : :
845 : 0 : CubitBoolean GeometryHealerTool::get_inc_sharpedge_flg()
846 : : {
847 : 0 : return gheList.get()->get_inc_sharpedge_flg();
848 : : }
849 : :
850 : 0 : void GeometryHealerTool::set_inc_sharpedge_flg( CubitBoolean flg )
851 : : {
852 : 0 : gheList.get()->set_inc_sharpedge_flg(flg);
853 : 0 : }
854 : :
855 : 0 : CubitBoolean GeometryHealerTool::get_inc_genericspline_flg()
856 : : {
857 : 0 : return gheList.get()->get_inc_genericspline_flg();
858 : : }
859 : :
860 : 0 : void GeometryHealerTool::set_inc_genericspline_flg( CubitBoolean flg )
861 : : {
862 : 0 : gheList.get()->set_inc_genericspline_flg(flg);
863 : 0 : }
864 : :
865 : 0 : CubitBoolean GeometryHealerTool::get_inc_wrapup_flg()
866 : : {
867 : 0 : return gheList.get()->get_inc_wrapup_flg();
868 : : }
869 : :
870 : 0 : void GeometryHealerTool::set_inc_wrapup_flg( CubitBoolean flg )
871 : : {
872 : 0 : gheList.get()->set_inc_wrapup_flg(flg);
873 : 0 : }
874 : :
875 : 0 : CubitBoolean GeometryHealerTool::get_inc_postprocess_flg()
876 : : {
877 : 0 : return gheList.get()->get_inc_postprocess_flg();
878 : : }
879 : :
880 : 0 : void GeometryHealerTool::set_inc_postprocess_flg( CubitBoolean flg )
881 : : {
882 : 0 : gheList.get()->set_inc_postprocess_flg(flg);
883 : 0 : }
884 : :
885 : 0 : CubitStatus GeometryHealerTool::force_simplify_to_plane( DLIList<RefFace*> &ref_face_list,
886 : : DLIList<Body*>& new_body_list,
887 : : CubitBoolean keep )
888 : : {
889 [ # # ]: 0 : ref_face_list.reset();
890 [ # # ][ # # ]: 0 : DLIList<RefEntity*> ref_entity_list(ref_face_list.size());
891 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT( ref_face_list, ref_entity_list );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
892 : :
893 [ # # ][ # # ]: 0 : if (!same_healer_engine(ref_entity_list, CUBIT_TRUE))
894 : : {
895 [ # # ][ # # ]: 0 : PRINT_ERROR("HEALING faces from different\n"
[ # # ]
896 [ # # ]: 0 : " geometry engines is not allowed.\n");
897 : 0 : return CUBIT_FAILURE;
898 : : }
899 : :
900 [ # # ]: 0 : ref_face_list.reset();
901 [ # # ][ # # ]: 0 : GeometryHealerEngine* GHEPtr = get_engine((TopologyEntity*)(ref_face_list.get()));
902 [ # # ]: 0 : if (GHEPtr)
903 [ # # ]: 0 : return GHEPtr->force_simplify_to_plane(ref_face_list, new_body_list, keep);
904 : : else
905 [ # # ][ # # ]: 0 : PRINT_ERROR( "Faces are of a geometry engine without a healer\n"
[ # # ]
906 [ # # ]: 0 : " and cannot be healed.\n");
907 [ # # ]: 0 : return CUBIT_FAILURE;
908 : : }
909 : :
910 : 0 : CubitStatus GeometryHealerTool::force_simplify_to_cylinder( DLIList<RefFace*> &ref_face_list,
911 : : DLIList<Body*>& new_body_list,
912 : : CubitBoolean keep )
913 : : {
914 [ # # ]: 0 : ref_face_list.reset();
915 [ # # ][ # # ]: 0 : DLIList<RefEntity*> ref_entity_list(ref_face_list.size());
916 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT( ref_face_list, ref_entity_list );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
917 : :
918 [ # # ][ # # ]: 0 : if (!same_healer_engine(ref_entity_list, CUBIT_TRUE))
919 : : {
920 [ # # ][ # # ]: 0 : PRINT_ERROR("HEALING faces from different\n"
[ # # ]
921 [ # # ]: 0 : " geometry engines is not allowed.\n");
922 : 0 : return CUBIT_FAILURE;
923 : : }
924 : :
925 [ # # ]: 0 : ref_face_list.reset();
926 [ # # ][ # # ]: 0 : GeometryHealerEngine* GHEPtr = get_engine((TopologyEntity*)(ref_face_list.get()));
927 [ # # ]: 0 : if (GHEPtr)
928 [ # # ]: 0 : return GHEPtr->force_simplify_to_cylinder(ref_face_list, new_body_list, keep);
929 : : else
930 [ # # ][ # # ]: 0 : PRINT_ERROR( "Faces are of a geometry engine without a healer\n"
[ # # ]
931 [ # # ]: 0 : " and cannot be healed.\n");
932 [ # # ]: 0 : return CUBIT_FAILURE;
933 : : }
934 : :
935 : 0 : CubitStatus GeometryHealerTool::force_simplify_to_cone( DLIList<RefFace*> &ref_face_list,
936 : : DLIList<Body*>& new_body_list,
937 : : CubitBoolean keep )
938 : : {
939 [ # # ]: 0 : ref_face_list.reset();
940 [ # # ][ # # ]: 0 : DLIList<RefEntity*> ref_entity_list(ref_face_list.size());
941 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT( ref_face_list, ref_entity_list );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
942 : :
943 [ # # ][ # # ]: 0 : if (!same_healer_engine(ref_entity_list, CUBIT_TRUE))
944 : : {
945 [ # # ][ # # ]: 0 : PRINT_ERROR("HEALING faces from different\n"
[ # # ]
946 [ # # ]: 0 : " geometry engines is not allowed.\n");
947 : 0 : return CUBIT_FAILURE;
948 : : }
949 : :
950 [ # # ]: 0 : ref_face_list.reset();
951 [ # # ][ # # ]: 0 : GeometryHealerEngine* GHEPtr = get_engine((TopologyEntity*)(ref_face_list.get()));
952 [ # # ]: 0 : if (GHEPtr)
953 [ # # ]: 0 : return GHEPtr->force_simplify_to_cone(ref_face_list, new_body_list, keep);
954 : : else
955 [ # # ][ # # ]: 0 : PRINT_ERROR( "Faces are of a geometry engine without a healer\n"
[ # # ]
956 [ # # ]: 0 : " and cannot be healed.\n");
957 [ # # ]: 0 : return CUBIT_FAILURE;
958 : : }
959 : :
960 : 0 : CubitStatus GeometryHealerTool::force_simplify_to_sphere( DLIList<RefFace*> &ref_face_list,
961 : : DLIList<Body*>& new_body_list,
962 : : CubitBoolean keep )
963 : : {
964 [ # # ]: 0 : ref_face_list.reset();
965 [ # # ][ # # ]: 0 : DLIList<RefEntity*> ref_entity_list(ref_face_list.size());
966 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT( ref_face_list, ref_entity_list );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
967 : :
968 [ # # ][ # # ]: 0 : if (!same_healer_engine(ref_entity_list, CUBIT_TRUE))
969 : : {
970 [ # # ][ # # ]: 0 : PRINT_ERROR("HEALING faces from different\n"
[ # # ]
971 [ # # ]: 0 : " geometry engines is not allowed.\n");
972 : 0 : return CUBIT_FAILURE;
973 : : }
974 : :
975 [ # # ]: 0 : ref_face_list.reset();
976 [ # # ][ # # ]: 0 : GeometryHealerEngine* GHEPtr = get_engine((TopologyEntity*)(ref_face_list.get()));
977 [ # # ]: 0 : if (GHEPtr)
978 [ # # ]: 0 : return GHEPtr->force_simplify_to_sphere(ref_face_list, new_body_list, keep);
979 : : else
980 [ # # ][ # # ]: 0 : PRINT_ERROR( "Faces are of a geometry engine without a healer\n"
[ # # ]
981 [ # # ]: 0 : " and cannot be healed.\n");
982 [ # # ]: 0 : return CUBIT_FAILURE;
983 : : }
984 : :
985 : 0 : CubitStatus GeometryHealerTool::force_simplify_to_torus( DLIList<RefFace*> &ref_face_list,
986 : : DLIList<Body*>& new_body_list,
987 : : CubitBoolean keep )
988 : : {
989 [ # # ]: 0 : ref_face_list.reset();
990 [ # # ][ # # ]: 0 : DLIList<RefEntity*> ref_entity_list(ref_face_list.size());
991 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT( ref_face_list, ref_entity_list );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
992 : :
993 [ # # ][ # # ]: 0 : if (!same_healer_engine(ref_entity_list, CUBIT_TRUE))
994 : : {
995 [ # # ][ # # ]: 0 : PRINT_ERROR("HEALING faces from different\n"
[ # # ]
996 [ # # ]: 0 : " geometry engines is not allowed.\n");
997 : 0 : return CUBIT_FAILURE;
998 : : }
999 : :
1000 [ # # ]: 0 : ref_face_list.reset();
1001 [ # # ][ # # ]: 0 : GeometryHealerEngine* GHEPtr = get_engine((TopologyEntity*)(ref_face_list.get()));
1002 [ # # ]: 0 : if (GHEPtr)
1003 [ # # ]: 0 : return GHEPtr->force_simplify_to_torus(ref_face_list, new_body_list, keep);
1004 : : else
1005 [ # # ][ # # ]: 0 : PRINT_ERROR( "Faces are of a geometry engine without a healer\n"
[ # # ]
1006 [ # # ]: 0 : " and cannot be healed.\n");
1007 [ # # ]: 0 : return CUBIT_FAILURE;
1008 : : }
1009 : :
1010 : : // *** END HEALER FUNCTIONS *** //
1011 : :
1012 : : // *** END PUBLIC FUNCTIONS *** //
1013 : :
1014 : : // *** BEGIN PROTECTED FUNCTIONS *** //
1015 : :
1016 : : //-----------------------------------------------------------------------------
1017 : : // Purpose : Constructor.
1018 : : //
1019 : : // Creator : Tyronne Lim (CAT)
1020 : : //
1021 : : // Creation Date : 07/21/03
1022 : : //-----------------------------------------------------------------------------
1023 : 0 : GeometryHealerTool::GeometryHealerTool( GeometryHealerEngine* GHEPtr )
1024 : : {
1025 [ # # ]: 0 : if (GHEPtr != NULL)
1026 [ # # ]: 0 : add_ghe(GHEPtr);
1027 [ + - ][ + - ]: 6540 : }
1028 : :
1029 : : // *** END PROTECTED FUNCTIONS *** //
1030 : :
1031 : : // *** BEGIN PRIVATE FUNCTIONS *** //
1032 : :
1033 : : // *** END PRIVATE FUNCTIONS *** //
|
