Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : FacetModifyEngine.hpp
3 : : //
4 : : // Purpose : ModifyEngine for faceted geometry
5 : : //
6 : : // Special Notes : Modeled after GeometryModifyEngine and OCCModifyEngine.
7 : : //
8 : : // Creator : John Fowler
9 : : //
10 : : // Creation Date : 6/02
11 : : //
12 : : // Owner : John Fowler
13 : : //-------------------------------------------------------------------------
14 : :
15 : : #ifndef FACET_MODIFY_ENGINE_HPP
16 : : #define FACET_MODIFY_ENGINE_HPP
17 : :
18 : : #include "GeometryModifyEngine.hpp"
19 : : #include <vector>
20 : : #include <map>
21 : :
22 : : class TBPoint;
23 : : class TopologyBridge;
24 : : class TopologyEntity;
25 : : class ChollaSurface;
26 : : class ChollaCurve;
27 : : class ChollaPoint;
28 : : class ChollaEngine;
29 : : class CurveFacetEvalTool;
30 : : class FacetEvalTool;
31 : : class CubitPoint;
32 : : class CubitFacet;
33 : : class CubitFacetEdge;
34 : : class CubitQuadFacet;
35 : : class TBPoint;
36 : : class CoEdgeSM;
37 : : class ShellSM;
38 : : class FacetBody;
39 : : class Body;
40 : : class RefFace;
41 : : class FacetSurface;
42 : : class FacetCurve;
43 : : class FacetPoint;
44 : : class CubitEvaluatorData;
45 : : class SphereEvaluatorData;
46 : : class CylinderEvaluatorData;
47 : :
48 : : class FacetModifyEngine : public GeometryModifyEngine
49 : : {
50 : :
51 : : public:
52 : :
53 : : //HEADER- Constructor and Destructor
54 : : private:
55 : :
56 : : FacetModifyEngine();
57 : :
58 : : static FacetModifyEngine* instance_;
59 : :
60 : : public:
61 : :
62 : 962 : static inline FacetModifyEngine* instance()
63 : : {
64 [ + + ]: 962 : if( !instance_ )
65 [ + - ]: 874 : instance_ = new FacetModifyEngine;
66 : 962 : return instance_;
67 : : }
68 : :
69 : : static void initialize_settings();
70 : :
71 : : virtual ~FacetModifyEngine();
72 : : //- virtual destructor
73 : :
74 : 0 : virtual bool supports_interoperability() { return false; }
75 : : //- Returns whether intermixing of real and virtual geometry operations
76 : : //- is supported for the current geometry kernel.
77 : :
78 : 0 : virtual bool supports_facets() { return true; }
79 : :
80 : : virtual TBPoint* make_Point( CubitVector const& point) const ;
81 : :
82 : : virtual Curve* make_Curve(Curve *curve_ptr,
83 : : std::map<TopologyBridge*, TopologyBridge*> *old_tb_to_new_tb = NULL) const;
84 : : //- creates a curve from an existing curve. This creates totally
85 : : //- new topology. This function is useful for constructing geometry
86 : : //- from existing geometry.
87 : :
88 : : virtual Curve* make_Curve( TBPoint const* point1_ptr,
89 : : TBPoint const* point2_ptr,
90 : : Surface* ref_face_ptr,
91 : : const CubitVector *third_point = NULL) const;
92 : : //- Create a curve exactly on the give ref_face.
93 : : //- Make sure the points are on the underlying surface.
94 : :
95 : : virtual Curve* make_Curve( GeometryType curve_type,
96 : : TBPoint const* point1_ptr,
97 : : TBPoint const* point2_ptr,
98 : : DLIList<CubitVector*>& vector_list,
99 : : Surface* ref_face_ptr = NULL) const;
100 : :
101 : : virtual Curve* make_Curve( GeometryType curve_type,
102 : : TBPoint const* point1_ptr,
103 : : TBPoint const* point2_ptr,
104 : : CubitVector const* intermediate_point_ptr) const;
105 : :
106 : : virtual Curve* make_Curve( DLIList<CubitVector*>& point_list,
107 : : DLIList<CubitVector*>& point_tangents) const;
108 : :
109 : :
110 : : virtual Surface* make_Surface( Surface *old_surface_ptr,
111 : : std::map< TopologyBridge*, TopologyBridge* > *old_tb_to_new_tb = NULL) const;
112 : :
113 : : virtual BodySM* make_extended_sheet( DLIList<Surface*> &surface_list,
114 : : CubitBox *clip_box = NULL,
115 : : bool preview = false ) const;
116 : :
117 : : #ifdef KCM_MESH_TO_GEOM
118 : : virtual CubitStatus mesh2brep(std::vector<double> &xvals,
119 : : std::vector<double> &yvals,
120 : : std::vector<double> &zvals,
121 : : std::vector<unsigned int> &tri_connectivity,
122 : : DLIList<BodySM*> &new_body_sms) const;
123 : : #endif
124 : :
125 : : virtual Surface* make_Surface( GeometryType surface_type,
126 : : DLIList<Curve*>& curve_list,
127 : : Surface *old_surface_ptr = NULL,
128 : : bool check_edges = true ) const;
129 : :
130 : : virtual Lump* make_Lump( DLIList<Surface*>& surface_list ) const;
131 : :
132 : : //virtual Body *make_Body(Surface *) const;
133 : :
134 : : virtual BodySM* make_BodySM( Surface * ) const;
135 : :
136 : : virtual BodySM* make_BodySM( DLIList<Lump*>& /*lump_list*/ ) const;
137 : :
138 : : //virtual Chain *make_Chain(Curve *) const;
139 : :
140 : : virtual BodySM* sphere(double radius) const ;
141 : :
142 : : virtual BodySM* brick( double wid, double dep, double hi ) const ;
143 : :
144 : : virtual BodySM* brick( const CubitVector ¢er,
145 : : const CubitVector axes[3],
146 : : const CubitVector &extension) const ;
147 : :
148 : : virtual BodySM* prism( double height, int sides, double major,
149 : : double minor) const ;
150 : :
151 : : virtual BodySM* pyramid( double height, int sides, double major,
152 : : double minor, double top=0.0) const ;
153 : :
154 : : virtual BodySM* cylinder( double hi, double r1, double r2,
155 : : double r3 ) const ;
156 : :
157 : : virtual BodySM* torus( double r1, double r2 ) const ;
158 : :
159 : : virtual BodySM* planar_sheet ( const CubitVector& p1,
160 : : const CubitVector& p2,
161 : : const CubitVector& p3,
162 : : const CubitVector& p4 ) const;
163 : :
164 : : virtual BodySM* copy_body( BodySM* body_sm,
165 : : std::map<TopologyBridge*, TopologyBridge*> *old_tb_to_new_tb = NULL ) const;
166 : : /*
167 : : virtual CubitStatus stitch_surfs(
168 : : DLIList<BodySM*>& surf_bodies,
169 : : BodySM*& stitched_body)const;
170 : : */
171 : : virtual BodySM* create_body( VolumeFacets& volume, std::map<FacetShapes*, GeometryEntity*>& entity_map,
172 : : const FacetPointSet& points, int interp_order) const;
173 : :
174 : : virtual CubitStatus subtract(DLIList<BodySM*> &tool_body_list,
175 : : DLIList<BodySM*> &from_bodies,
176 : : DLIList<BodySM*> &new_bodies,
177 : : bool imprint = false,
178 : : bool keep_old = false) const;
179 : :
180 : : virtual CubitStatus imprint(BodySM* BodyPtr1, BodySM* BodyPtr2,
181 : : BodySM*& newBody1, BodySM*& newBody2,
182 : : bool keep_old) const;
183 : :
184 : : virtual CubitStatus imprint(DLIList<BodySM*> &from_body_list,
185 : : DLIList<BodySM*> &new_from_body_list,
186 : : bool keep_old, DLIList<TopologyBridge*> *new_tbs = NULL,
187 : : DLIList<TopologyBridge*> *att_tbs = NULL) const;
188 : :
189 : : virtual CubitStatus imprint( DLIList<BodySM*> &body_list,
190 : : DLIList<Curve*> &ref_edge_list,
191 : : DLIList<BodySM*>& new_body_list,
192 : : DLIList<TopologyBridge*> &temporary_bridges,
193 : : bool keep_old_body,
194 : : bool show_messages=CUBIT_TRUE) const;
195 : :
196 : : virtual CubitStatus imprint( DLIList<Surface*> &ref_face_list,
197 : : DLIList<Curve*> &ref_edge_list,
198 : : DLIList<TopologyBridge*> &temporary_bridges,
199 : : DLIList<BodySM*>& new_body_list,
200 : : bool keep_old_body ) const;
201 : :
202 : : virtual CubitStatus imprint( DLIList<Surface*> &surface_list,
203 : : DLIList<DLIList<Curve*>*> &curve_lists_list,
204 : : BodySM*& new_body,
205 : : bool keep_old_body,
206 : : bool expand = true,
207 : : DLIList<TopologyBridge*> *new_tbs = NULL,
208 : : DLIList<TopologyBridge*> *att_tbs = NULL ) const;
209 : :
210 : : virtual CubitStatus imprint( DLIList<BodySM*> &body_list,
211 : : DLIList<CubitVector> &vector_list,
212 : : DLIList<BodySM*>& new_body_list,
213 : : bool keep_old_body,
214 : : DLIList<TopologyBridge*> *new_tbs = NULL,
215 : : DLIList<TopologyBridge*> *att_tbs = NULL,
216 : : double *tol_in = NULL,
217 : : bool clean_up_slivers = true) const;
218 : :
219 : : virtual CubitStatus imprint_projected_edges( DLIList<Surface*> &ref_face_list,
220 : : DLIList<Curve*> &ref_edge_list,
221 : : DLIList<BodySM*>& new_body_list,
222 : : DLIList<Curve*> &kept_edge_list,
223 : : bool keep_old_body,
224 : : bool keep_free_edges) const;
225 : :
226 : : virtual CubitStatus imprint_projected_edges(DLIList<Surface*> &ref_face_list,
227 : : DLIList<BodySM*> &body_list,
228 : : DLIList<Curve*> &ref_edge_list,
229 : : DLIList<BodySM*>& new_body_list,
230 : : bool keep_old_body,
231 : : bool keep_free_edges) const;
232 : :
233 : : virtual CubitStatus project_edges( DLIList<Surface*> &ref_face_list,
234 : : DLIList<Curve*> &ref_edge_list_in,
235 : : DLIList<Curve*> &ref_edge_list_new,
236 : : bool print_error = true ) const;
237 : :
238 : : virtual CubitStatus remove_topology(DLIList<Curve*> &curves_to_remove,
239 : : DLIList<Surface*> &surfs_to_remove,
240 : : double backoff_distance,
241 : : double small_edge_size,
242 : : DLIList<BodySM*> &new_bodysm_list,
243 : : CubitBoolean preview) const;
244 : :
245 : : virtual CubitStatus curve_surface_intersection( Surface *surface,
246 : : Curve* curve,
247 : : DLIList<Curve*> &new_curves ) const;
248 : :
249 : : virtual CubitStatus intersect(BodySM* tool_body_ptr,
250 : : DLIList<BodySM*> &from_bodies,
251 : : DLIList<BodySM*> &new_bodies,
252 : : bool keep_old = CUBIT_FALSE,
253 : : bool preview = CUBIT_FALSE ) const;
254 : :
255 : : virtual CubitStatus chop(DLIList<BodySM*> &bodies,
256 : : DLIList<BodySM*> &intersectBodies,
257 : : DLIList<BodySM*> &outsideBody,
258 : : BodySM*& leftoversBody,
259 : : bool keep_old = CUBIT_FALSE,
260 : : bool nonreg = CUBIT_FALSE) const;
261 : :
262 : : virtual CubitStatus unite(DLIList<BodySM*> &bodies,
263 : : DLIList<BodySM*> &newBodies,
264 : : bool keep_old = CUBIT_FALSE) const;
265 : :
266 : : virtual void get_possible_invalid_tbs(DLIList<TopologyBridge*> &bridges_in,
267 : : DLIList<TopologyBridge*> &bridges_out);
268 : :
269 : : virtual CubitStatus thicken(DLIList<BodySM*>& bodies,
270 : : DLIList<BodySM*>& new_bodies,
271 : : double depth,
272 : : bool both = CUBIT_FALSE) const ;
273 : :
274 : : virtual CubitStatus hollow(DLIList<BodySM*>& bodies,
275 : : DLIList<Surface*>& surfs_to_remove,
276 : : DLIList<BodySM*>& new_bodies,
277 : : double depth) const ;
278 : :
279 : : virtual CubitStatus flip_normals( DLIList<Surface*>& face_list ) const;
280 : :
281 : : virtual CubitStatus sweep_translational(
282 : : DLIList<GeometryEntity*>& ref_ent_list,
283 : : DLIList<BodySM*>& result_body_list,
284 : : const CubitVector& sweep_vector,
285 : : double draft_angle,
286 : : int draft_type,
287 : : bool switchside,
288 : : bool rigid,
289 : : bool anchor_entity=CUBIT_FALSE,
290 : : bool keep_old=CUBIT_FALSE ) const;
291 : :
292 : : virtual CubitStatus sweep_perpendicular(
293 : : DLIList<GeometryEntity*>& ref_ent_list,
294 : : DLIList<BodySM*>& result_body_list,
295 : : double distance,
296 : : double draft_angle,
297 : : int draft_type,
298 : : bool switchside,
299 : : bool rigid,
300 : : bool anchor_entity=CUBIT_FALSE,
301 : : bool keep_old=CUBIT_FALSE ) const;
302 : :
303 : : virtual CubitStatus sweep_rotational(
304 : : DLIList<GeometryEntity*>& ref_ent_list,
305 : : DLIList<BodySM*>& result_body_list,
306 : : const CubitVector& point,
307 : : const CubitVector& direction,
308 : : double angle,
309 : : int steps = 0,
310 : : double draft_angle = 0.0,
311 : : int draft_type = 0,
312 : : bool switchside = CUBIT_FALSE,
313 : : bool make_solid = CUBIT_FALSE,
314 : : bool rigid = CUBIT_FALSE,
315 : : bool anchor_entity=CUBIT_FALSE,
316 : : bool keep_old=CUBIT_FALSE ) const;
317 : :
318 : : virtual CubitStatus sweep_along_curve(
319 : : DLIList<GeometryEntity*>& ref_ent_list,
320 : : DLIList<BodySM*>& result_body_list,
321 : : DLIList<Curve*>& ref_edge_list,
322 : : double draft_angle = 0.0,
323 : : int draft_type = 0,
324 : : bool rigid = CUBIT_FALSE,
325 : : bool anchor_entity=CUBIT_FALSE,
326 : : bool keep_old=CUBIT_FALSE ) const;
327 : :
328 : : virtual CubitStatus sweep_to_body(
329 : : DLIList<Curve*> curve_list,
330 : : BodySM *target_body,
331 : : CubitVector distance,
332 : : DLIList<BodySM*> &new_bodies,
333 : : bool unite) const;
334 : :
335 : : virtual CubitStatus sweep_to_body(
336 : : Surface *source_surface,
337 : : BodySM *target_body,
338 : : CubitVector distance,
339 : : DLIList<BodySM*> &new_bodies) const;
340 : :
341 : :
342 : : virtual CubitStatus webcut_with_sweep_surfaces(
343 : : DLIList<BodySM*> &blank_bodies,
344 : : DLIList<Surface*> &surfaces,
345 : : const CubitVector& sweep_vector,
346 : : bool sweep_perp,
347 : : bool through_all,
348 : : bool outward,
349 : : bool up_to_next,
350 : : Surface *stop_surf,
351 : : Curve *curve_to_sweep_along,
352 : : DLIList<BodySM*> &neighbor_imprint_list,
353 : : DLIList<BodySM*> &results_list,
354 : : ImprintType imprint_type = NO_IMPRINT,
355 : : CubitBoolean preview = false);
356 : :
357 : : virtual CubitStatus webcut_with_sweep_curves(
358 : : DLIList<BodySM*> &blank_bodies,
359 : : DLIList<Curve*> &curves,
360 : : const CubitVector& sweep_vector,
361 : : bool through_all,
362 : : Surface *stop_surf,
363 : : Curve *curve_to_sweep_along,
364 : : DLIList<BodySM*> &neighbor_imprint_list,
365 : : DLIList<BodySM*> &results_list,
366 : : ImprintType imprint_type = NO_IMPRINT,
367 : : CubitBoolean preview = false);
368 : :
369 : : virtual CubitStatus webcut_with_sweep_curves_rotated(
370 : : DLIList<BodySM*> &blank_bodies,
371 : : DLIList<Curve*> &curves,
372 : : const CubitVector &point,
373 : : const CubitVector &sweep_axis,
374 : : double angle,
375 : : Surface *stop_surf,
376 : : DLIList<BodySM*> &neighbor_imprint_list,
377 : : DLIList<BodySM*> &results_list,
378 : : ImprintType imprint_type = NO_IMPRINT,
379 : : CubitBoolean preview = false);
380 : :
381 : : virtual CubitStatus webcut_with_sweep_surfaces_rotated(
382 : : DLIList<BodySM*> &blank_bodies,
383 : : DLIList<Surface*> &surfaces,
384 : : const CubitVector &point,
385 : : const CubitVector &sweep_axis,
386 : : double angle,
387 : : Surface *stop_surf,
388 : : bool up_to_next,
389 : : DLIList<BodySM*> &neighbor_imprint_list,
390 : : DLIList<BodySM*> &results_list,
391 : : ImprintType imprint_type = NO_IMPRINT,
392 : : CubitBoolean preview = false);
393 : :
394 : : //HEADER- Webcut-related functions
395 : : virtual CubitStatus webcut(DLIList<BodySM*>& webcut_body_list,
396 : : const CubitVector &v1,
397 : : const CubitVector &v2,
398 : : const CubitVector &v3,
399 : : DLIList<BodySM*>& neighbor_imprint_list,
400 : : DLIList<BodySM*>& results_list,
401 : : ImprintType imprint_type = NO_IMPRINT,
402 : : bool preview = false) const;
403 : :
404 : : virtual CubitStatus webcut(DLIList<BodySM*>& webcut_body_list,
405 : : BodySM const* tool_body,
406 : : DLIList<BodySM*>& neighbor_imprint_list,
407 : : DLIList<BodySM*>& results_list,
408 : : ImprintType imprint_type = NO_IMPRINT,
409 : : bool preview = false) const;
410 : :
411 : : virtual CubitStatus webcut_across_translate( DLIList<BodySM*>& body_list,
412 : : Surface* plane_surf1,
413 : : Surface* plane_surf2,
414 : : DLIList<BodySM*>& neighbor_imprint_list,
415 : : DLIList<BodySM*>& results_list,
416 : : ImprintType imprint_type = NO_IMPRINT,
417 : : bool preview = false) const;
418 : :
419 : : virtual CubitStatus webcut_with_sheet(DLIList<BodySM*> &webcut_body_list,
420 : : BodySM *sheet_body,
421 : : DLIList<BodySM*>& neighbor_imprint_list,
422 : : DLIList<BodySM*> &new_bodies,
423 : : ImprintType imprint_type = NO_IMPRINT,
424 : : bool preview = false);
425 : :
426 : : virtual CubitStatus webcut_with_extended_sheet(DLIList<BodySM*> &webcut_body_list,
427 : : DLIList<Surface*> &surface_list,
428 : : DLIList<BodySM*>& neighbor_imprint_list,
429 : : DLIList<BodySM*> &new_bodies,
430 : : int &num_cut,
431 : : ImprintType imprint_type = NO_IMPRINT,
432 : : bool preview = false);
433 : :
434 : : virtual CubitStatus webcut_with_cylinder(DLIList<BodySM*> &webcut_body_list,
435 : : double radius,
436 : : const CubitVector &axis,
437 : : const CubitVector ¢er,
438 : : DLIList<BodySM*>& neighbor_imprint_list,
439 : : DLIList<BodySM*>& results_list,
440 : : ImprintType imprint_type = NO_IMPRINT,
441 : : bool preview = false);
442 : :
443 : : virtual CubitStatus webcut_with_brick( DLIList<BodySM*>& webcut_body_list,
444 : : const CubitVector ¢er,
445 : : const CubitVector axes[3],
446 : : const CubitVector &extension,
447 : : DLIList<BodySM*>& neighbor_imprint_list,
448 : : DLIList<BodySM*> &results_list,
449 : : ImprintType imprint_type = NO_IMPRINT,
450 : : bool preview = false);
451 : :
452 : : virtual CubitStatus webcut_with_planar_sheet( DLIList<BodySM*>& webcut_body_list,
453 : : const CubitVector ¢er,
454 : : const CubitVector axes[2],
455 : : double width, double height,
456 : : DLIList<BodySM*>& neighbor_imprint_list,
457 : : DLIList<BodySM*> &results_list,
458 : : ImprintType imprint_type = NO_IMPRINT,
459 : : bool preview = false);
460 : :
461 : : virtual CubitStatus webcut_with_curve_loop(DLIList<BodySM*> &webcut_body_list,
462 : : DLIList<Curve*> &ref_edge_list,
463 : : DLIList<BodySM*>& results_list,
464 : : DLIList<BodySM*>& neighbor_imprint_list,
465 : : ImprintType imprint_type = NO_IMPRINT,
466 : : bool preview = false);
467 : :
468 : : virtual CubitStatus section( DLIList<BodySM*> §ion_body_list,
469 : : const CubitVector &point_1,
470 : : const CubitVector &point_2,
471 : : const CubitVector &point_3,
472 : : DLIList<BodySM*>& new_body_list,
473 : : bool keep_normal_side,
474 : : bool keep_old = false,
475 : : bool keep_both_sides = false);
476 : :
477 : : virtual CubitStatus split_body( BodySM *body_ptr,
478 : : DLIList<BodySM*> &new_bodies );
479 : :
480 : : virtual CubitStatus separate_surfaces( DLIList<Surface*> &surf_list,
481 : : DLIList<BodySM*> &new_bodies );
482 : :
483 : : virtual CubitStatus reverse_body( BodySM *body_to_reverse );
484 : :
485 : : virtual CubitStatus split_periodic( BodySM *body_ptr,
486 : : BodySM *&new_body );
487 : :
488 : : virtual CubitStatus regularize_body( BodySM *body_ptr,
489 : : BodySM *&new_body_ptr );
490 : :
491 : : virtual CubitStatus regularize_entity(GeometryEntity *old_entity_ptr,
492 : : BodySM *&new_body_ptr);
493 : : virtual CubitStatus test_regularize_entity( GeometryEntity *old_refentity_ptr);
494 : :
495 : : virtual CubitStatus offset_curves( DLIList<Curve*>& ref_edge_list,
496 : : DLIList<Curve*>& result_curve_list,
497 : : double offset_distance,
498 : : const CubitVector& offset_direction,
499 : : int gap_type = 1 );
500 : :
501 : : virtual CubitStatus scale ( BodySM *&body, const CubitVector& factors );
502 : :
503 : : virtual CubitStatus split_curve( Curve* curve_to_split,
504 : : const CubitVector& split_location,
505 : : DLIList<Curve*>& created_curves );
506 : :
507 : : virtual Curve* trim_curve( Curve* trim_curve,
508 : : const CubitVector& trim_vector,
509 : : const CubitVector& keep_vector,
510 : : bool keep_old = false );
511 : :
512 : : virtual CubitStatus create_solid_bodies_from_surfs(DLIList<Surface*> &ref_face_list,
513 : : DLIList<BodySM*> &new_bodies,
514 : : bool keep_old = false,
515 : : bool heal = true,
516 : : bool sheet = false ) const;
517 : :
518 : : virtual Curve* create_arc(const CubitVector& position,
519 : : double radius,
520 : : double start_angle,
521 : : double end_angle,
522 : : CubitVector plane,
523 : : bool preview = false );
524 : :
525 : : virtual Curve* create_arc_radius(const CubitVector ¢er,
526 : : TBPoint* ref_vertex_start,
527 : : TBPoint* ref_vertex_end,
528 : : const CubitVector &normal,
529 : : double radius,
530 : : bool full = false,
531 : : bool preview = false);
532 : :
533 : :
534 : : virtual Curve* create_arc_three( TBPoint* ref_vertex1,
535 : : TBPoint* ref_vertex2,
536 : : TBPoint* ref_vertex3,
537 : : bool full = false,
538 : : bool preview = false );
539 : :
540 : : virtual Curve* create_arc_three( Curve* ref_edge1,
541 : : Curve* ref_edge2,
542 : : Curve* ref_edge3,
543 : : bool full = false ,
544 : : bool preview = false );
545 : :
546 : : virtual Curve* create_arc_center_edge(
547 : : TBPoint* ref_vertex1,
548 : : TBPoint* ref_vertex2,
549 : : TBPoint* ref_vertex3,
550 : : const CubitVector &normal,
551 : : double radius = CUBIT_DBL_MAX,
552 : : bool full = false,
553 : : bool preview = false );
554 : :
555 : : virtual CubitStatus create_curve_combine( DLIList<Curve*>& curve_list,
556 : : Curve *&new_curve_ptr );
557 : : //- Uses the solid modeller to create a new RefEdge that is a combination
558 : : //- of the input chain of edges.
559 : : //-
560 : :
561 : : virtual GeometryQueryEngine *get_gqe();
562 : :
563 : : virtual CubitBoolean is_modify_engine(const TopologyBridge *tb_ptr) const;
564 : :
565 : : virtual CubitStatus get_offset_intersections(
566 : : Curve* ref_edge1,
567 : : Curve* ref_edge2,
568 : : DLIList<CubitVector>& intersection_list,
569 : : double offset,
570 : : bool ext_first = true );
571 : :
572 : : virtual CubitStatus get_offset_intersections(
573 : : Curve* ref_edge_ptr,
574 : : Surface* ref_face_ptr,
575 : : DLIList<CubitVector> &intersection_list,
576 : : double offset = 0.0,
577 : : bool ext_surf = true );
578 : :
579 : : virtual CubitStatus surface_intersection( Surface *surface1_ptr,
580 : : Surface *surface2_ptr,
581 : : DLIList<Curve*> &inter_graph,
582 : : const double tol) const;
583 : :
584 : : virtual CubitStatus get_mid_plane( const CubitVector &point_1,
585 : : const CubitVector &point_2,
586 : : const CubitVector &point_3,
587 : : BodySM *body_to_trim_to,
588 : : BodySM *&midplane_body ) const;
589 : :
590 : : virtual CubitStatus get_spheric_mid_surface( Surface *surface_ptr1,
591 : : Surface *surface_ptr2,
592 : : BodySM *body_to_trim_to,
593 : : BodySM *&midsurface_body ) const;
594 : :
595 : : virtual CubitStatus get_conic_mid_surface( Surface *surface_ptr1,
596 : : Surface *surface_ptr2,
597 : : BodySM *body_to_trim_to,
598 : : BodySM *&midsurface_body ) const;
599 : :
600 : : virtual CubitStatus get_toric_mid_surface( Surface *surface_ptr1,
601 : : Surface *surface_ptr2,
602 : : BodySM *body_to_trim_to,
603 : : BodySM *&midsurface_body ) const;
604 : :
605 : : virtual CubitStatus tweak_bend( DLIList<BodySM*> &bend_bodies,
606 : : DLIList<BodySM*> &new_bodysm_list,
607 : : CubitVector& neutral_root,
608 : : CubitVector& bend_axis,
609 : : CubitVector& bend_direction,
610 : : double radius,
611 : : double angle,
612 : : DLIList<CubitVector>& bend_regions,
613 : : double width = -1,
614 : : CubitBoolean center_bend = CUBIT_FALSE,
615 : : int num_points = 0,
616 : : CubitBoolean keep_old_body = CUBIT_FALSE,
617 : : CubitBoolean preview = CUBIT_FALSE ) const;
618 : : /**< Bend solid bodies based on a bend radius and angle.
619 : : */
620 : :
621 : : virtual CubitStatus tweak_chamfer( DLIList<Curve*> &curve_list,
622 : : double left_offset,
623 : : DLIList<BodySM*> &new_bodysm_list,
624 : : double right_offset = -1.0,
625 : : CubitBoolean keep_old_body = CUBIT_FALSE,
626 : : CubitBoolean preview = CUBIT_FALSE ) const;
627 : : /**< Chamfer curves on solid bodies. The left and right offsets are with
628 : : * respect to the curve direction. If the given right offset is negative,
629 : : * the left offset is used. Users can preview to clarify the meaning of
630 : : * left and right.
631 : : */
632 : :
633 : : virtual CubitStatus tweak_chamfer( DLIList<TBPoint*> &point_list,
634 : : double offset1,
635 : : DLIList<BodySM*> &new_bodysm_list,
636 : : Curve *edge1 = NULL,
637 : : double offset2 = -1.0,
638 : : Curve *edge2 = NULL,
639 : : double offset3 = -1.0,
640 : : Curve *edge3 = NULL,
641 : : CubitBoolean keep_old_body = CUBIT_FALSE,
642 : : CubitBoolean preview = CUBIT_FALSE ) const;
643 : : /**< Chamfer vertices on solid or sheet bodies. On a solid body there can
644 : : * be up to 3 offsets; on a sheet body up to 2 offsets. The offsets are
645 : : * in the direction of the supplied edges. If multiple vertices are
646 : : * supplied, only one offset value is allowed and the edges are not used.
647 : : */
648 : :
649 : : virtual CubitStatus tweak_fillet( DLIList<Curve*> &curve_list,
650 : : double radius,
651 : : DLIList<BodySM*> &new_bodysm_list,
652 : : CubitBoolean keep_old_body = CUBIT_FALSE,
653 : : CubitBoolean preview = CUBIT_FALSE ) const;
654 : : /**< Create a round fillet (or blend) at the given curves on solid bodies.
655 : : */
656 : :
657 : : virtual CubitStatus tweak_fillet( Curve *curve_ptr,
658 : : double start_radius,
659 : : double end_radius,
660 : : BodySM *&new_body_ptr,
661 : : CubitBoolean keep_old_body = CUBIT_FALSE,
662 : : CubitBoolean preview = CUBIT_FALSE ) const;
663 : : /**< Create a round fillet (or blend) at the given curve on a solid body.
664 : : * The fillet has a variable radius from the start to the end of the curve.
665 : : */
666 : :
667 : : virtual CubitStatus tweak_fillet( DLIList<TBPoint*> &point_list,
668 : : double radius,
669 : : DLIList<BodySM*> &new_bodysm_list,
670 : : CubitBoolean keep_old_body = CUBIT_FALSE,
671 : : CubitBoolean preview = CUBIT_FALSE ) const;
672 : : /**< Create a round fillet (or blend) at the given vertices on sheet bodies.
673 : : */
674 : :
675 : : virtual CubitStatus tweak_move( DLIList<Surface*> &surface_list,
676 : : const CubitVector &delta,
677 : : DLIList<BodySM*> &new_bodysm_list,
678 : : CubitBoolean keep_old_body = CUBIT_FALSE,
679 : : CubitBoolean preview = CUBIT_FALSE ) const;
680 : : /**< Tweak specified faces of a volume or volumes along a vector.
681 : : */
682 : :
683 : : virtual CubitStatus tweak_move( DLIList<Curve*> &curve_list,
684 : : const CubitVector &delta,
685 : : DLIList<BodySM*> &new_bodysm_list,
686 : : CubitBoolean keep_old_body = CUBIT_FALSE,
687 : : CubitBoolean preview = CUBIT_FALSE ) const;
688 : : /**< Tweak specified curves of a sheet body along a vector.
689 : : */
690 : :
691 : : virtual CubitStatus tweak_offset( DLIList<Surface*> &surface_list,
692 : : double offset_distance,
693 : : DLIList<Surface*> *add_surface_list_ptr,
694 : : DLIList<double> *add_offset_list_ptr,
695 : : DLIList<BodySM*> &new_bodysm_list,
696 : : CubitBoolean keep_old_body = CUBIT_FALSE,
697 : : CubitBoolean preview = CUBIT_FALSE ) const;
698 : : /**< Tweak specified faces of a volume or volumes by offsetting those faces
699 : : * by the offset distance(s).
700 : : */
701 : :
702 : : virtual CubitStatus tweak_offset( DLIList<Curve*> &curve_list,
703 : : double offset_distance,
704 : : DLIList<Curve*> *add_curve_list_ptr,
705 : : DLIList<double> *add_offset_list_ptr,
706 : : DLIList<BodySM*> &new_bodysm_list,
707 : : CubitBoolean keep_old_body = CUBIT_FALSE,
708 : : CubitBoolean preview = CUBIT_FALSE ) const;
709 : : /**< Tweak specified curves of a sheet body or bodies by offsetting those
710 : : * curves by the offset distance(s).
711 : : */
712 : :
713 : : virtual CubitStatus tweak_remove( DLIList<Surface*> &surface_list,
714 : : DLIList<BodySM*> &new_bodysm_list,
715 : : CubitBoolean extend_adjoining = CUBIT_TRUE,
716 : : CubitBoolean keep_old_body = CUBIT_FALSE,
717 : : CubitBoolean preview = CUBIT_FALSE ) const;
718 : : /**< Remove surfaces from a body or bodies and then extend the adjoining
719 : : * surfaces to fill the gap or remove the hole.
720 : : */
721 : :
722 : : virtual CubitStatus tweak_remove( DLIList<Curve*> &curve_list,
723 : : DLIList<BodySM*> &new_bodysm_list,
724 : : CubitBoolean keep_old_body = CUBIT_FALSE,
725 : : CubitBoolean preview = CUBIT_FALSE ) const;
726 : : /**< Remove curves from a sheet body or bodies and then extend the remaining
727 : : * curves to fill the gap. If an internal loop of curves is removed the
728 : : * hole is removed.
729 : : */
730 : :
731 : : virtual CubitStatus tweak_target( DLIList<Surface*> &surface_list,
732 : : DLIList<Surface*> &target_surf_list,
733 : : DLIList<BodySM*> &new_bodysm_list,
734 : : CubitBoolean extend_flg = CUBIT_TRUE,
735 : : CubitPlane *limit_plane = NULL,
736 : : CubitBoolean reverse_flg = CUBIT_FALSE,
737 : : CubitBoolean keep_old_body = CUBIT_FALSE,
738 : : CubitBoolean preview = CUBIT_FALSE ) const;
739 : : /**< Tweak specified faces of a volume or volumes up to target surfaces.
740 : : */
741 : :
742 : : virtual CubitStatus tweak_target( DLIList<Curve*> &curve_list,
743 : : DLIList<Surface*> &target_surf_list,
744 : : DLIList<BodySM*> &new_bodysm_list,
745 : : CubitBoolean extend_flg = CUBIT_TRUE,
746 : : CubitPlane *limit_plane = NULL,
747 : : CubitBoolean reverse_flg = CUBIT_FALSE,
748 : : CubitBoolean keep_old_body = CUBIT_FALSE,
749 : : CubitBoolean preview = CUBIT_FALSE,
750 : : double surface_area_increase_allowed = 0 ) const;
751 : : /**< Tweak specified edges of a surface or set of surfaces (in sheet
752 : : * bodies) up to a set of target surfaces. This essentially extends or
753 : : * trims the attached surfaces of the sheet body.
754 : : */
755 : :
756 : : virtual CubitStatus tweak_target( DLIList<Curve*> &curve_list,
757 : : DLIList<Curve*> &target_curve_list,
758 : : DLIList<BodySM*> &new_bodysm_list,
759 : : CubitBoolean extend_flg = CUBIT_TRUE,
760 : : CubitPlane *limit_plane = NULL,
761 : : CubitBoolean reverse_flg = CUBIT_FALSE,
762 : : CubitBoolean keep_old_body = CUBIT_FALSE,
763 : : CubitBoolean preview = CUBIT_FALSE,
764 : : double surface_area_increase_allowed = 0 ) const;
765 : : /**< Tweak specified edges of a sheet body or bodies up to a list of target
766 : : * curves that are part of a sheet body. The target is a surface created by
767 : : * thickening the owning surfaces of the target curves.
768 : : */
769 : :
770 : : virtual CubitStatus tweak_target( TBPoint *point_ptr,
771 : : DLIList<Surface*> &modify_surface_list,
772 : : CubitVector &target_loc,
773 : : BodySM *&new_bodysm_ptr,
774 : : CubitBoolean keep_old_body = CUBIT_FALSE,
775 : : CubitBoolean preview = CUBIT_FALSE ) const;
776 : : /**< Tweak specified vertex of a sheet body to a given location. The
777 : : * given vertex must be part of a planar surface or surfaces attached to
778 : : * linear curves only. The user specified which of those surfaces to
779 : : * actually modify. The given location will be projected to be on the
780 : : * given planar surface(s) before being used - this projected location
781 : : * must be the same on all surfaces.
782 : : */
783 : :
784 : : virtual CubitStatus remove_curve_slivers( BodySM *body, double lengthlimit ) const;
785 : :
786 : : virtual CubitStatus create_net_surface( DLIList<Surface*>& ref_face_list, BodySM *& new_body,
787 : : DLIList<DLIList<CubitVector*>*> &vec_lists_u,
788 : : DLIList<DLIList<CubitVector*>*> &vec_lists_v,
789 : : double net_tol = 1e-3,
790 : : CubitBoolean heal = CUBIT_TRUE ) const;
791 : :
792 : : virtual CubitStatus create_net_surface( DLIList<Curve*>& u_curves, DLIList<Curve*>& v_curves,
793 : : BodySM *& new_body,
794 : : double net_tol = 1e-3,
795 : : CubitBoolean heal = CUBIT_TRUE ) const;
796 : :
797 : : virtual CubitStatus create_offset_surface( Surface* ref_face_ptr, BodySM*& new_body, double offset_distance ) const;
798 : :
799 : : virtual CubitStatus create_offset_sheet( DLIList<Surface*> &surface_list,
800 : : double offset_distance,
801 : : DLIList<Surface*> *add_surface_list_ptr,
802 : : DLIList<double> *add_offset_list_ptr,
803 : : DLIList<BodySM*> &new_body_list,
804 : : CubitBoolean preview = CUBIT_FALSE ) const;
805 : : /**< Create a sheet body (or bodies) by offsetting the given faces. The
806 : : * optional additional face list and double list (must be same length)
807 : : * allow different offset distances for different faces. Adjoining faces
808 : : * are extended or trimmed to remain joined in the new sheet body. Radial
809 : : * faces that cannot be so offset are removed and the resulting wound
810 : : * healed by the surrounding faces.
811 : : */
812 : :
813 : : virtual CubitStatus create_offset_body( BodySM* body_ptr, BodySM*& new_body, double offset_distance ) const;
814 : :
815 : : virtual CubitStatus create_skin_surface( DLIList<Curve*>& curves, BodySM*& new_body,
816 : : DLIList<Curve*>& guides) const;
817 : :
818 : :
819 : :
820 : :
821 : : virtual CubitStatus loft_surfaces_to_body( DLIList<Surface*> &surfaces,
822 : : DLIList<double> &takeoff_factor_list,
823 : : DLIList<Surface*> &takeoff_vector_surface_list,
824 : : DLIList<CubitVector> &surface_takeoff_vector_list,
825 : : DLIList<Curve*> &takeoff_vector_curve_list,
826 : : DLIList<CubitVector> &curve_takeoff_vector_list,
827 : : DLIList<Curve*> &guides,
828 : : DLIList<TBPoint*> &match_vertices_list,
829 : : BodySM*& new_body,
830 : : CubitBoolean global_guides,
831 : : CubitBoolean closed,
832 : : CubitBoolean show_matching_curves,
833 : : CubitBoolean preview
834 : : ) const ;
835 : :
836 : : virtual CubitStatus create_surface( DLIList<CubitVector*>& vec_list,
837 : : BodySM *&new_body,
838 : : Surface *ref_face_ptr,
839 : : CubitBoolean project_points ) const;
840 : :
841 : : virtual CubitStatus create_surface( DLIList<TBPoint*> &points,
842 : : BodySM *&new_body,
843 : : Surface *on_surface ) const;
844 : :
845 : : virtual CubitStatus create_weld_surface( CubitVector &root,
846 : : Surface *ref_face1, double leg1, Surface *ref_face2, double leg2,
847 : : BodySM *&new_body ) const;
848 : :
849 : : virtual CubitStatus stitch( DLIList<BodySM*> &bodies_to_stitch,
850 : : DLIList<BodySM*> &new_bodies,
851 : : bool tighten_gaps,
852 : : double tolerance )const;
853 : :
854 : :
855 : : //--------------------------------------------------------------
856 : : //- Methods for building specific facet-based geometry entities
857 : : //--------------------------------------------------------------
858 : : CubitStatus make_facet_point( CubitPoint *thePoint,
859 : : TBPoint *&new_point_ptr );
860 : : CubitStatus make_facet_point( const CubitVector &location,
861 : : TBPoint *&new_point_ptr );
862 : : //- create a new facet point
863 : :
864 : : CubitStatus make_facet_curve( TBPoint *start_ptr,
865 : : TBPoint *end_ptr,
866 : : Curve *&new_curve_ptr,
867 : : CurveFacetEvalTool *eval_tool_ptr = NULL);
868 : : CubitStatus make_facet_curve( TBPoint *start_ptr,
869 : : TBPoint *end_ptr,
870 : : DLIList<CubitFacetEdge*> &edge_list,
871 : : DLIList<CubitPoint*> &point_list,
872 : : Curve *&new_curve_ptr,
873 : : CurveFacetEvalTool *eval_tool_ptr = NULL);
874 : : //- create a new facet curve
875 : :
876 : : CubitStatus make_facet_coedge( Curve *curv_ptr,
877 : : CubitSense sense,
878 : : CoEdgeSM *&new_coedge_ptr );
879 : : //- create a new facet coedge
880 : :
881 : : CubitStatus make_facet_loop( DLIList<CoEdgeSM*> &coedge_list,
882 : : LoopSM *&new_loop_ptr );
883 : : //- create a new facet loop
884 : :
885 : : CubitStatus make_facet_surface(const CubitEvaluatorData *eval_data,
886 : : DLIList<CubitFacet*> &facet_list,
887 : : DLIList<CubitPoint*> &point_list,
888 : : DLIList<LoopSM*> &my_loops,
889 : : int interp_order,
890 : : double min_dot,
891 : : Surface *&new_surface_ptr,
892 : : CubitBoolean use_point_addresses = CUBIT_TRUE,
893 : : FacetEvalTool *eval_tool_ptr = NULL,
894 : : std::map<FacetCurve*, FacetCurve*> *hard_line_curve_map = NULL );
895 : : //-creates a new FacetSurface given the points and facet list.
896 : :
897 : : CubitStatus make_facet_surface(DLIList<CubitQuadFacet*> &facet_list,
898 : : DLIList<CubitPoint*> &point_list,
899 : : DLIList<LoopSM*> &my_loops,
900 : : int interp_order,
901 : : double min_dot,
902 : : Surface *&new_surface_ptr);
903 : : //-creates a new FacetSurface given the points and quad facet list.
904 : :
905 : : CubitStatus make_facet_shell(DLIList<Surface*> &surface_list,
906 : : ShellSM *&new_shell_ptr);
907 : : //-creates a new shell, given the list of surfaces.
908 : :
909 : : CubitStatus make_facet_lump(DLIList<ShellSM*> &shell_list,
910 : : Lump*& new_lump_ptr);
911 : : //-creates a new lump, given the list of shells.
912 : :
913 : : CubitStatus make_facet_body(DLIList<Lump*> &lump_list,
914 : : BodySM *&new_body_ptr);
915 : : //-creates a new body, given the list of lump.
916 : :
917 : : CubitStatus build_facet_surface( const CubitEvaluatorData **eval_data,
918 : : DLIList<CubitFacet *> &facet_list,
919 : : DLIList<CubitPoint *> &point_list,
920 : : double feature_angle,
921 : : int interp_order,
922 : : CubitBoolean smooth_non_manifold,
923 : : CubitBoolean split_surfaces,
924 : : DLIList<Surface *> &surface_list);
925 : : CubitStatus build_facet_surface( DLIList<CubitQuadFacet *> &qfacet_list,
926 : : DLIList<CubitFacet *> &tfacet_list,
927 : : DLIList<CubitPoint *> &point_list,
928 : : double feature_angle,
929 : : int interp_order,
930 : : CubitBoolean smooth_non_manifold,
931 : : CubitBoolean split_surfaces,
932 : : DLIList<Surface *> &surface_list);
933 : : CubitStatus build_facet_surface( DLIList<CubitQuadFacet *> &facet_list,
934 : : DLIList<CubitPoint *> &point_list,
935 : : double feature_angle,
936 : : int interp_order,
937 : : CubitBoolean smooth_non_manifold,
938 : : CubitBoolean split_surfaces,
939 : : DLIList<Surface *> &surface_list);
940 : : //- creates one or more new FacetSurfaces with all of its lower
941 : : //- order entities. Use an optional feature_angle to break
942 : : //- surface
943 : :
944 : : //- Define separate CubitPoint* for the CubitFacet list and CubitQuadFacet
945 : : //- list if they are going to create different surfaces.
946 : : //- Facets sharing the same CubitPoint* will be created into one surfaces.
947 : : //- Separate call of build_facet_surface will try to build different
948 : : //- surfaces, and won't be able to use shared CubitPoint* from other
949 : : //- build_facet_surface call.
950 : : //- As long as facets are defined, the CubitPoint list should be left empty
951 : :
952 : : CubitStatus smooth_facets( RefFace *ref_face_ptr, int niter, CubitBoolean free_laplacian );
953 : : //- attempt to clean up facets by smoothing the points on the surface
954 : : CubitStatus create_shell_offset( BodySM *bodysm_ptr, BodySM *&new_bodysm, double offset );
955 : : // create a shell offset from body
956 : : CubitStatus improve_facets( RefFace *ref_face_ptr );
957 : : // improve the facets by local swaps
958 : :
959 : : CubitStatus build_cholla_surfaces( DLIList<CubitFacet *> facet_list,
960 : : DLIList<CubitPoint *> point_list,
961 : : double feature_angle,
962 : : int interp_order,
963 : : CubitBoolean smooth_non_manifold,
964 : : CubitBoolean split_surfaces,
965 : : ChollaEngine *&cholla_ptr );
966 : :
967 : : /* virtual CubitStatus finish_facet_Body(
968 : : GeometryType surface_type,
969 : : const CubitEvaluatorData *eval_data,
970 : : DLIList <CubitFacet *>facet_list,
971 : : DLIList <CubitPoint *>point_list,
972 : : double feature_angle,
973 : : int interp_order,
974 : : CubitBoolean smooth_non_manifold,
975 : : CubitBoolean split_surfaces,
976 : : BodySM *&body_ptr) const;
977 : : */
978 : : virtual CubitStatus finish_facet_Body( ChollaEngine *cholla_ptr,
979 : : const CubitEvaluatorData **eval_data,
980 : : double feature_angle,
981 : : int interp_order,
982 : : BodySM *&bodysm_ptr) const;
983 : :
984 : : virtual CubitStatus finish_facet_Body( DLIList<Surface*>& surfaces, DLIList<CubitSense>& surface_sense,
985 : : BodySM *&bodysm_ptr) const;
986 : :
987 : : void set_sphere_eval_data( ChollaEngine *cholla_ptr,
988 : : double radius,
989 : : CubitEvaluatorData **&eval_data ) const;
990 : :
991 : : void set_cylinder_eval_data( ChollaEngine *cholla_ptr,
992 : : double height,
993 : : double base_radius_xdir,
994 : : double base_radius_ydir,
995 : : double top_radius,
996 : : CubitEvaluatorData **&eval_data ) const;
997 : :
998 : : // non-virtual specific functions for building facet-based geometry
999 : : // from Cholla geometry
1000 : :
1001 : : CubitStatus build_cholla_geometry(
1002 : : const CubitEvaluatorData **eval_data,
1003 : : DLIList<ChollaSurface*> &cholla_surface_list,
1004 : : DLIList<ChollaCurve*> &cholla_curve_list,
1005 : : DLIList<ChollaPoint*> &cholla_point_list,
1006 : : CubitBoolean use_feature_angle,
1007 : : double feature_angle,
1008 : : int interp_order,
1009 : : DLIList<Surface *> &surface_list);
1010 : : // build the CUBIT geometry based on the Cholla entity class lists
1011 : :
1012 : : CubitStatus build_cholla_point_geometry(
1013 : : DLIList<ChollaPoint*> &cholla_point_list );
1014 : : // From the cholla point list, create geometric points for each
1015 : :
1016 : : CubitStatus build_cholla_curve_geometry(
1017 : : DLIList<ChollaCurve*> &cholla_curve_list );
1018 : : // From the cholla curve list, create geometric curves for each
1019 : :
1020 : : CubitStatus build_cholla_surface_geometry(
1021 : : const CubitEvaluatorData **eval_data,
1022 : : DLIList<ChollaSurface*> &cholla_surface_list,
1023 : : int interp_order,
1024 : : double min_dot,
1025 : : DLIList<Surface *> &surface_list);
1026 : : // From the facet surface list, create geometric surface,
1027 : : // loops and coedges for each surface in the list
1028 : :
1029 : : virtual CubitStatus tolerant_imprint(DLIList<Surface*> &surfs_in,
1030 : : DLIList<BodySM*> &new_bodysm_list) const;
1031 : : CubitStatus tolerant_imprint_surface_with_curves( Surface *surface_to_imprint,
1032 : : DLIList<Curve*> &curves,
1033 : : DLIList<TopologyBridge*> &temporary_bridges,
1034 : : BodySM *&new_body,
1035 : : DLIList<TopologyBridge*> *new_tbs = NULL,
1036 : : DLIList<TopologyBridge*> *att_tbs = NULL ) const;
1037 : :
1038 : : CubitStatus tolerant_imprint( DLIList<BodySM*> &bodies_in,
1039 : : DLIList<BodySM*> &new_bodies,
1040 : : double overlap_tol,
1041 : : double imprint_tol,
1042 : : DLIList<TopologyBridge*> *new_tbs = NULL,
1043 : : DLIList<TopologyBridge*> *att_tbs = NULL ) const;
1044 : :
1045 : 0 : static CubitBoolean is_modify_enabled()
1046 : 0 : {return modifyEnabled;}
1047 : :
1048 : 22 : static void set_modify_enabled(CubitBoolean my_bool)
1049 : 22 : {modifyEnabled = my_bool;}
1050 : :
1051 : :
1052 : :
1053 : :
1054 : : protected:
1055 : :
1056 : : private:
1057 : :
1058 : : static CubitBoolean modifyEnabled;
1059 : :
1060 : : CubitStatus build_cholla_loop_geometry(
1061 : : DLIList<ChollaCurve*> &cholla_curve_list,
1062 : : ChollaSurface *chsurf_ptr,
1063 : : DLIList<LoopSM*> &loop_list,
1064 : : int debug_draw = 0 );
1065 : : // From the cholla curve list of a surface, create geometric loops
1066 : :
1067 : : void fillinedge(
1068 : : int *edge,
1069 : : int numpointsonanedge,
1070 : : double radius,
1071 : : std::vector<CubitPoint *>& points) const;
1072 : : //! Put points on this edge of a triangle being refined.
1073 : :
1074 : : void refinetriangle(
1075 : : int level,
1076 : : int numpointsonanedge,
1077 : : int *iedge1,
1078 : : int *iedge2,
1079 : : int *iedge3,
1080 : : int isign1,
1081 : : int isign2,
1082 : : int isign3,
1083 : : double radius,
1084 : : std::vector<CubitPoint *>& points,
1085 : : DLIList<CubitFacet *>& facet_list) const;
1086 : : //! add internal points and make connections for this triangle
1087 : :
1088 : : void create_facets(
1089 : : const std::vector<std::pair<SurfaceFacets*, CubitSense> >& surfaceTopology,
1090 : : const FacetPointSet& points,
1091 : : int interp_order,
1092 : : DLIList<CubitPoint*>& c_points,
1093 : : std::map<SurfaceFacets*, DLIList<CubitFacet*> >& facet_map,
1094 : : std::map<CurveFacets*, DLIList<CubitFacetEdge*> >& facet_edge_map
1095 : : );
1096 : :
1097 : : CubitStatus process_topology(SurfaceFacets* surface, CubitSense& coface_sense,
1098 : : int interp_order, const DLIList<CubitPoint*>& c_points,
1099 : : std::map<SurfaceFacets*, DLIList<CubitFacet*> >& facet_map,
1100 : : std::map<CurveFacets*, DLIList<CubitFacetEdge*> >& facet_edge_map,
1101 : : std::map<FacetShapes*, GeometryEntity*>& entity_map
1102 : : );
1103 : :
1104 : : void process_topology(CurveFacets* curve, const DLIList<CubitPoint*>& c_points,
1105 : : FacetEvalTool* eval, CubitSense sense,
1106 : : std::map<CurveFacets*, DLIList<CubitFacetEdge*> >& facet_edge_map,
1107 : : std::map<FacetShapes*, GeometryEntity*>& entity_map);
1108 : :
1109 : : } ;
1110 : :
1111 : : #endif
|
