Branch data Line data Source code
1 : : //-----------------------------------------------------------------------------
2 : : // Filename : GeometryHealerTool.hpp
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 : : #ifndef _GEOMETRYHEALERTOOL_HPP
16 : : #define _GEOMETRYHEALERTOOL_HPP
17 : :
18 : : // *** BEGIN INCLUDES *** //
19 : :
20 : : #include "CubitDefines.h"
21 : : #include "DLIList.hpp"
22 : : #include "CGMGeomConfigure.h"
23 : :
24 : : // *** END INCLUDES *** //
25 : :
26 : : // *** BEGIN FORWARD DECLARATIONS *** //
27 : :
28 : : class GeometryHealerEngine;
29 : :
30 : : class TopologyBridge;
31 : : class TopologyEntity;
32 : :
33 : : class RefEntity;
34 : : class RefFace;
35 : : class RefEdge;
36 : :
37 : : class Body;
38 : : // *** END FORWARD DECLARATIONS *** //
39 : :
40 : : //! Class used for healing geometry. engine -specific.
41 : : class CUBIT_GEOM_EXPORT GeometryHealerTool
42 : : {
43 : : public:
44 : :
45 : : // singleton pattern class instance interface
46 : : static GeometryHealerTool* instance( GeometryHealerEngine* GHEPtr = NULL );
47 : :
48 : 322 : static void delete_instance()
49 : : {
50 [ - + ]: 322 : if (instance_)
51 : : {
52 [ # # ]: 0 : delete instance_;
53 : 0 : instance_ = NULL;
54 : : }
55 : 322 : };
56 : :
57 : : // destructor
58 : : ~GeometryHealerTool();
59 : :
60 : : // *** BEGIN ENGINE OPERATIONS *** //
61 : :
62 : : // set the default healer engine
63 : : // void set_default_engine( GeometryHealerEngine *ghe_ptr );
64 : :
65 : : //! add a healer engine to the list
66 : : void add_ghe( GeometryHealerEngine *ghe_ptr );
67 : :
68 : : // remove a healer engine from the list
69 : : // CubitStatus remove_ghe( GeometryHealerEngine *ghe_ptr );
70 : :
71 : : // get the list of healer engines
72 : : // void get_ghe_list( DLIList<GeometryHealerEngine*> &ghe_list );
73 : :
74 : : private:
75 : : // returns the healer engine of an entity
76 : : GeometryHealerEngine* get_engine( TopologyBridge *tb_ptr ) const;
77 : : GeometryHealerEngine* get_engine( TopologyEntity *te_ptr ) const;
78 : :
79 : : // determines if entities belong to the same engine
80 : : CubitBoolean same_healer_engine( DLIList<RefEntity*> &ref_entity_list,
81 : : CubitBoolean check_children ) const;
82 : : CubitBoolean same_healer_engine( DLIList<TopologyEntity*> &topo_list ) const;
83 : :
84 : : // *** END ENGINE OPERATIONS *** //
85 : :
86 : : // *** BEGIN HEALER FUNCTIONS *** //
87 : : public:
88 : : //! Uses the autohealer to heal the given body list. The rebuild option
89 : : //! can be used for more rigorous healing, where each surface is pulled off,
90 : : //! healed, and then stitched back into a body.
91 : : CubitStatus auto_heal_bodies( DLIList<Body*> &body_list,
92 : : DLIList<Body*> &new_body_list,
93 : : DLIList<TopologyEntity*> &bad_geometry,
94 : : CubitBoolean rebuild = CUBIT_FALSE,
95 : : CubitBoolean keep_old = CUBIT_FALSE,
96 : : CubitBoolean make_tolerant = CUBIT_FALSE,
97 : : FILE* logfile_ptr = NULL );
98 : :
99 : : //! Heals the input bodies, using either autoheal or incremental,
100 : : //! depending on the switches that are setup. Writes to the logfile
101 : : //! if it's been opened.
102 : : CubitStatus heal_bodies( DLIList<Body*> &body_list,
103 : : DLIList<Body*> &new_body_list,
104 : : DLIList<TopologyEntity*> &bad_geometry,
105 : : CubitBoolean rebuild = CUBIT_FALSE,
106 : : CubitBoolean keep_old = CUBIT_FALSE,
107 : : CubitBoolean make_tolerant = CUBIT_FALSE,
108 : : FILE* logfile_ptr = NULL );
109 : :
110 : : //! Uses the healing husk to find bad geometry and give feedback to
111 : : //! the user. A lot more could be done here - this is just a quick
112 : : //! overview for the user (the user will have no idea why the identified
113 : : //! geometry is bad). A logfile can give a little more information.
114 : : CubitStatus analyze_badgeom( DLIList<Body*> &body_list,
115 : : DLIList<TopologyEntity*> &bad_geometry,
116 : : FILE* logfile = NULL );
117 : :
118 : : //! Shows the bad geometry. The geometry must have been analyzed first.
119 : : //! If body_list is empty, shows only for those bodies that have been
120 : : //! analyzed.
121 : : CubitStatus get_badgeom( DLIList<Body*> &body_list,
122 : : DLIList<TopologyEntity*> &bad_geometry );
123 : :
124 : : //! Get tolerant curves. If the body list is empty, all tolerant
125 : : //! curves are retrieved.
126 : : CubitStatus get_tcurves( DLIList<Body*> &body_list,
127 : : DLIList<RefEdge*> &t_curves );
128 : :
129 : : //! Uses the healing husk to perform one or more healing operations.
130 : : //! Which operations are performed is determined by switches in the
131 : : //! healer. The user can set default tolerances (separate from this
132 : : //! function, override the defaults with this function, or just use the
133 : : //! tolerances calculated by the healer (preferred).
134 : : //!
135 : : //! The possible healing steps are:
136 : : //! 1) preprocess - removes zero-length edges, sliver faces, duplicate
137 : : //! vertices. This is the first step which is always
138 : : //! done (user shouldn't suppress this). Tolerance is resabs.
139 : : //! 2) simplify - simplify NURBS into analytic.
140 : : //! Default simplify_tol = .0001
141 : : //! 3) stitch - stitch geometry together. Iterative from min to max
142 : : //! tolerance.
143 : : //! Default min tol = 10e-5
144 : : //! Default max tol = 1
145 : : //! 4) geombuild - geometry-related healing.
146 : : //! Default geombuild_tol = .01
147 : : //! Default analytic_tangency_tol = .01
148 : : //! Default isolspline_solver_tol = .01
149 : : //! Individual geombuild steps can be (instead of doing all):
150 : : //! analytic - performs all of the stages of the analytic solver
151 : : //! subphase of the geometry building phase. The analytic
152 : : //! solver subphase attempts to heal all edges and
153 : : //! vertices shared by analytic surfaces.
154 : : //! isospline - performs all of the stages of the isospline solver
155 : : //! subphase of the geometry building phase. The
156 : : //! isospline solver attempts to heal all edges shared
157 : : //! by tangential isoparametric surfaces (e.g., the
158 : : //! intersection curve is an isoparametric curve of
159 : : //! both splines in the intersection).
160 : : //! reblend - future option
161 : : //! sharpedge - performs all of the stages of the sharp edge solver
162 : : //! subphase of the geometry building phase. The sharp
163 : : //! edge solver attempts to heal all edges and vertices
164 : : //! that are shared by surfaces that intersect sharply.
165 : : //! This includes nontangential surface junctions.
166 : : //! genericspline - performs all of the stages of the generic spline
167 : : //! solver subphase of the geometry building phase.
168 : : //! The generic spline solver attempts to heal
169 : : //! generic tangential spline junctions, (e.g., the
170 : : //! intersection curve is not an isoparametric curve
171 : : //! of both splines in the intersection).
172 : : //! wrapup - handles remaining pcurves, wraps up
173 : : //! geometry buiilding phase (user shouldn't suppress)
174 : : //! 5) postprocess - correction of neg-area faces, duplicate vertices, edge groups;
175 : : //! last step - always done (user shouldn't suppress)
176 : : //! \brief Uses the healing husk to perform one or more healing operations.
177 : : CubitStatus heal_incremental( DLIList<Body*> &body_list,
178 : : DLIList<Body*> &new_bodies,
179 : : DLIList<TopologyEntity*> &bad_geometry,
180 : : double simplify_tol = CUBIT_DBL_MAX,
181 : : double stitch_min_tol = CUBIT_DBL_MAX,
182 : : double stitch_max_tol = CUBIT_DBL_MAX,
183 : : double geombuild_tol = CUBIT_DBL_MAX,
184 : : double analytic_tol = CUBIT_DBL_MAX,
185 : : double isospline_tol = CUBIT_DBL_MAX,
186 : : double reblend_classify_tol = CUBIT_DBL_MAX,
187 : : double reblend_tol = CUBIT_DBL_MAX,
188 : : CubitBoolean keep_old = CUBIT_FALSE,
189 : : CubitBoolean make_tolerant = CUBIT_FALSE,
190 : : FILE* logfile_ptr = NULL);
191 : :
192 : : //! Lists the current settings for incremental healing
193 : : void list_incremental();
194 : :
195 : : //! Lists out the tolerances of each body, separately
196 : : void list_tolerances( DLIList<Body*> &body_list );
197 : :
198 : : //@{
199 : : //! Functions to set the default tolerances used. The healer calculates
200 : : //! the default tolerance per body. These functions allow the user to override
201 : : //! these defaults for all bodies healed. In incremental healing, the user can
202 : : //! override these defaults by sending-in tolerances. For autoheal, these
203 : : //! defaults are used if they are set, otherwise the healer calculates
204 : : //! intelligent defaults.
205 : : double get_default_simplify_tol();
206 : : void set_default_simplify_tol( double tol );
207 : : double get_default_stitch_min_tol();
208 : : void set_default_stitch_min_tol( double tol );
209 : : double get_default_stitch_max_tol();
210 : : void set_default_stitch_max_tol( double tol );
211 : : double get_default_geombuild_tol();
212 : : void set_default_geombuild_tol( double tol );
213 : : double get_default_analytic_tol();
214 : : void set_default_analytic_tol( double tol );
215 : : double get_default_isospline_tol();
216 : : void set_default_isospline_tol( double tol );
217 : : double get_default_reblend_classify_tol();
218 : : void set_default_reblend_classify_tol( double tol );
219 : : double get_default_reblend_tol();
220 : : void set_default_reblend_tol( double tol );
221 : : void reset_default_tolerances();
222 : : void list_default_tolerances();
223 : : //@}
224 : :
225 : : //! Cleans healer attributes from the bodies. These can be left if the
226 : : //! CleanAtt setting was used when doing analysis or healing.
227 : : void clean_attributes( DLIList<Body*>& body_list );
228 : :
229 : : //@{
230 : : //! Get/set flags which determine whether to clean attributes after
231 : : //! analysis and healing.
232 : : CubitBoolean get_cleanatt_flg();
233 : : void set_cleanatt_flg( CubitBoolean flg );
234 : : //@}
235 : :
236 : : //@{
237 : : //! Method determines how bad geometry is displayed
238 : : int get_show_method(); // 0-none, 1-highlight, 2-draw
239 : : void set_show_method( int method );
240 : : //@}
241 : :
242 : : //@{
243 : : //! Flag to determine whether to list a summary when showing bad geometry
244 : : CubitBoolean get_show_summary_flg();
245 : : void set_show_summary_flg( CubitBoolean flg );
246 : : //@}
247 : :
248 : : //@{
249 : : //! Flag to determine whether to list details when showing bad geometry
250 : : CubitBoolean get_show_details_flg();
251 : : void set_show_details_flg( CubitBoolean flg );
252 : : //@}
253 : :
254 : : //@{
255 : : //! Flag to determine whether to show bad geometry after healing
256 : : CubitBoolean get_show_on_heal_flg();
257 : : void set_show_on_heal_flg( CubitBoolean flg );
258 : : //@}
259 : :
260 : : //@{
261 : : //! Allow for checking of short curves after healing
262 : : CubitBoolean get_check_vol_on_heal_flg();
263 : : void set_check_vol_on_heal_flg( CubitBoolean flg );
264 : : double get_vol_on_heal_limit();
265 : : void set_vol_on_heal_limit( double limit );
266 : : //@}
267 : :
268 : : //@{
269 : : //! Allow for checking of small surfaces after healing
270 : : CubitBoolean get_check_surf_on_heal_flg();
271 : : void set_check_surf_on_heal_flg( CubitBoolean flg );
272 : : double get_surf_on_heal_limit();
273 : : void set_surf_on_heal_limit( double limit );
274 : : //@}
275 : :
276 : : //@{
277 : : //! Allow for checking of short curves after healing
278 : : CubitBoolean get_check_curve_on_heal_flg();
279 : : void set_check_curve_on_heal_flg( CubitBoolean flg );
280 : : double get_curve_on_heal_limit();
281 : : void set_curve_on_heal_limit( double limit );
282 : : //@}
283 : :
284 : : //@{
285 : : //! Get/set for flags for what to show during analysis/show
286 : : CubitBoolean get_show_bad_vertices_flg();
287 : : void set_show_bad_vertices_flg( CubitBoolean flg );
288 : : CubitBoolean get_show_bad_curves_flg();
289 : : void set_show_bad_curves_flg( CubitBoolean flg );
290 : : CubitBoolean get_show_bad_coedges_flg();
291 : : void set_show_bad_coedges_flg( CubitBoolean flg );
292 : : CubitBoolean get_show_bad_loops_flg();
293 : : void set_show_bad_loops_flg( CubitBoolean flg );
294 : : CubitBoolean get_show_bad_surfaces_flg();
295 : : void set_show_bad_surfaces_flg( CubitBoolean flg );
296 : : CubitBoolean get_show_bad_shells_flg();
297 : : void set_show_bad_shells_flg( CubitBoolean flg );
298 : : CubitBoolean get_show_bad_volumes_flg();
299 : : void set_show_bad_volumes_flg( CubitBoolean flg );
300 : : CubitBoolean get_show_bad_bodies_flg();
301 : : void set_show_bad_bodies_flg( CubitBoolean flg );
302 : : //@}
303 : :
304 : : //! Function to list to user what the current onshow flags are
305 : : void list_onshow_flgs();
306 : :
307 : : //@{
308 : : // Functions for controlling incremental healing
309 : : CubitBoolean get_inc_preprocess_flg();
310 : : void set_inc_preprocess_flg( CubitBoolean flg );
311 : : CubitBoolean get_inc_simplify_flg();
312 : : void set_inc_simplify_flg( CubitBoolean flg );
313 : : CubitBoolean get_inc_stitch_flg();
314 : : void set_inc_stitch_flg( CubitBoolean flg );
315 : : CubitBoolean get_inc_geombuild_flg();
316 : : void set_inc_geombuild_flg( CubitBoolean flg );
317 : : CubitBoolean get_inc_analytic_flg();
318 : : void set_inc_analytic_flg( CubitBoolean flg );
319 : : CubitBoolean get_inc_isospline_flg();
320 : : void set_inc_isospline_flg( CubitBoolean flg );
321 : : CubitBoolean get_inc_reblend_flg();
322 : : void set_inc_reblend_flg( CubitBoolean flg );
323 : : CubitBoolean get_inc_sharpedge_flg();
324 : : void set_inc_sharpedge_flg( CubitBoolean flg );
325 : : CubitBoolean get_inc_genericspline_flg();
326 : : void set_inc_genericspline_flg( CubitBoolean flg );
327 : : CubitBoolean get_inc_wrapup_flg();
328 : : void set_inc_wrapup_flg( CubitBoolean flg );
329 : : CubitBoolean get_inc_postprocess_flg();
330 : : void set_inc_postprocess_flg( CubitBoolean flg );
331 : : //@}
332 : :
333 : : //@{
334 : : //! Forces a spline surface to be an analytical of the type specified.
335 : : CubitStatus force_simplify_to_plane( DLIList<RefFace*> &ref_face_list, DLIList<Body*>& new_body_list,
336 : : CubitBoolean keep = CUBIT_FALSE );
337 : : CubitStatus force_simplify_to_cylinder( DLIList<RefFace*> &ref_face_list, DLIList<Body*>& new_body_list,
338 : : CubitBoolean keep = CUBIT_FALSE );
339 : : CubitStatus force_simplify_to_cone( DLIList<RefFace*> &ref_face_list, DLIList<Body*>& new_body_list,
340 : : CubitBoolean keep = CUBIT_FALSE );
341 : : CubitStatus force_simplify_to_sphere( DLIList<RefFace*> &ref_face_list, DLIList<Body*>& new_body_list,
342 : : CubitBoolean keep = CUBIT_FALSE );
343 : : CubitStatus force_simplify_to_torus( DLIList<RefFace*> &ref_face_list, DLIList<Body*>& new_body_list,
344 : : CubitBoolean keep = CUBIT_FALSE );
345 : : //@}
346 : :
347 : : // *** END HEALER FUNCTIONS *** //
348 : :
349 : : protected:
350 : :
351 : : // constructor
352 : : GeometryHealerTool( GeometryHealerEngine *GHEPtr );
353 : :
354 : : private:
355 : :
356 : : // singleton pattern class instance interface
357 : : static GeometryHealerTool* instance_;
358 : :
359 : : // list of healer engines
360 : : DLIList<GeometryHealerEngine*> gheList;
361 : : };
362 : :
363 : : #endif
364 : :
|
