Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : OCCModifyEngine.hpp
3 : : //
4 : : // Purpose : ModifyEngine for OCC geometry
5 : : //
6 : : // Special Notes : Modeled after GeometryModifyEngine
7 : : //
8 : : // Creator : Jane Hu
9 : : //
10 : : // Creation Date : 6/08
11 : : //
12 : : //-------------------------------------------------------------------------
13 : :
14 : : #ifndef OCC_MODIFY_ENGINE_HPP
15 : : #define OCC_MODIFY_ENGINE_HPP
16 : :
17 : : #include "GeometryModifyEngine.hpp"
18 : : #include <vector>
19 : : #include <map>
20 : : #include "DLIList.hpp"
21 : :
22 : : class TBPoint;
23 : : class TopologyBridge;
24 : : class CoEdgeSM;
25 : : class ShellSM;
26 : : class OCCBody;
27 : : class OCCSurface;
28 : : class OCCCurve;
29 : : class OCCPoint;
30 : : class TopoDS_Shape;
31 : : class TopoDS_Edge;
32 : : class TopoDS_Wire;
33 : : class TopoDS_Face;
34 : : class CubitBox;
35 : : class BRepAlgoAPI_BooleanOperation;
36 : : class BRepOffsetAPI_ThruSections;
37 : : class BRepBuilderAPI_Copy;
38 : : //class OCCHistory;
39 : :
40 : : class OCCModifyEngine : public GeometryModifyEngine
41 : : {
42 : :
43 : : public:
44 : :
45 : : //HEADER- Constructor and Destructor
46 : : private:
47 : :
48 : : OCCModifyEngine();
49 : :
50 : : static OCCModifyEngine* instance_;
51 : :
52 : : CubitStatus copy_body_attributes(TopoDS_Shape orig_shape,
53 : : BRepBuilderAPI_Copy& api_copy)const;
54 : :
55 : : Surface* make_Surface(Surface *old_surface_ptr,
56 : : CubitBoolean extended_from) const;
57 : :
58 : : public:
59 : 1116 : static inline OCCModifyEngine* instance()
60 : : {
61 [ + + ]: 1116 : if( !instance_ )
62 [ + - ]: 841 : instance_ = new OCCModifyEngine;
63 : 1116 : return instance_;
64 : : }
65 : :
66 : : virtual ~OCCModifyEngine();
67 : : //- virtual destructor
68 : :
69 : : virtual TBPoint* make_Point( CubitVector const& point) const ;
70 : :
71 : : virtual Curve* make_Curve( DLIList<CubitVector*>& point_list,
72 : : DLIList<CubitVector*>& point_tangents) const;
73 : :
74 : : virtual Curve* make_Curve(Curve *curve_ptr,
75 : : std::map<TopologyBridge*, TopologyBridge*> *old_tb_to_new_tb = NULL) const;
76 : : //- creates a curve from an existing curve. This creates totally
77 : : //- new topology. This function is useful for constructing geometry
78 : : //- from existing geometry.
79 : :
80 : : virtual Curve* make_Curve( TBPoint const* point1_ptr,
81 : : TBPoint const* point2_ptr,
82 : : Surface* ref_face_ptr = NULL,
83 : : const CubitVector *third_point = NULL) const;
84 : : //- Create a curve exactly on the give ref_face.
85 : : //- Make sure the points are on the underlying surface.
86 : :
87 : : virtual Curve* make_Curve( GeometryType curve_type,
88 : : TBPoint const* point1_ptr,
89 : : TBPoint const* point2_ptr,
90 : : DLIList<CubitVector*>& vector_list,
91 : : Surface* ref_face_ptr = NULL) const;
92 : :
93 : : virtual Curve* make_Curve( GeometryType curve_type,
94 : : TBPoint const* point1_ptr,
95 : : TBPoint const* point2_ptr,
96 : : CubitVector const* intermediate_point_ptr) const;
97 : :
98 : : virtual BodySM* make_extended_sheet( DLIList<Surface*> &surface_list,
99 : : CubitBox *clip_box = NULL,
100 : : bool preview = false) const;
101 : : //R BodySM*
102 : : //R- Pointer to a newly created BodySM object.
103 : : //I surface_list
104 : : //I- The surface_list from which we want to create an extended sheet.
105 : : //I clip_box
106 : : //I- An optional bounding box to clip the resultant sheet body by.
107 : : //I preview
108 : : //I- If true just draw the sheet instead of creating it
109 : : //- This function creates a sheet body by extending the input surfaces.
110 : : //- The result can be optionally clipped to fit inside of the given
111 : : //- bounding box.
112 : :
113 : : virtual Surface* make_Surface( Surface *old_surface_ptr,
114 : : std::map< TopologyBridge*, TopologyBridge* > *old_tb_to_new_tb = NULL) const;
115 : :
116 : : virtual Surface* make_Surface( GeometryType surface_type,
117 : : DLIList<Curve*>& curve_list,
118 : : Surface *old_surface_ptr = NULL,
119 : : bool check_edges = true ) const;
120 : :
121 : : CubitStatus create_rectangle_surface( double width,
122 : : double height,
123 : : CubitVector plane,
124 : : BodySM *&sheet_body) const;
125 : :
126 : : CubitStatus create_ellipse_surface( TBPoint *pt1,
127 : : TBPoint *pt3,
128 : : CubitVector center_point,
129 : : BodySM *&sheet_body) const;
130 : :
131 : : CubitStatus create_ellipse_surface( double major_radius,
132 : : double minor_radius,
133 : : CubitVector plane,
134 : : BodySM *&sheet_body) const;
135 : :
136 : : Curve* make_elliptical_Curve( TBPoint const* point1,
137 : : TBPoint const* point2,
138 : : CubitVector ¢er_point,
139 : : double start_angle,
140 : : double end_angle,
141 : : CubitSense sense) const;
142 : :
143 : : CubitStatus create_circle_surface( TBPoint *pt1,
144 : : CubitVector center_point,
145 : : TBPoint *pt3,
146 : : BodySM *&sheet_body) const;
147 : :
148 : : CubitStatus create_circle_surface( TBPoint *pt1,
149 : : TBPoint *pt3,
150 : : CubitVector center_point,
151 : : BodySM *&sheet_body) const;
152 : :
153 : : CubitStatus create_circle_surface( double radius,
154 : : CubitVector plane,
155 : : BodySM *&sheet_body) const;
156 : :
157 : : virtual Lump* make_Lump( DLIList<Surface*>& surface_list ) const;
158 : :
159 : : //virtual Body *make_Body(Surface *) const;
160 : :
161 : : virtual BodySM* make_BodySM( Surface * ) const;
162 : :
163 : : virtual BodySM* make_BodySM( DLIList<Lump*>& /*lump_list*/ ) const;
164 : :
165 : : //virtual Chain *make_Chain(Curve *) const;
166 : :
167 : : virtual BodySM* sphere(double radius) const ;
168 : :
169 : : virtual BodySM* brick( double wid, double dep, double hi ) const ;
170 : :
171 : : virtual BodySM* brick( const CubitVector ¢er,
172 : : const CubitVector axes[3],
173 : : const CubitVector &extension) const ;
174 : :
175 : : virtual BodySM* prism( double height, int sides, double major,
176 : : double minor) const ;
177 : :
178 : : virtual BodySM* pyramid( double height, int sides, double major,
179 : : double minor, double top=0.0) const ;
180 : :
181 : : virtual BodySM* cylinder( double hi, double r1, double r2,
182 : : double r3 ) const ;
183 : :
184 : : virtual BodySM* torus( double r1, double r2 ) const ;
185 : :
186 : : virtual BodySM* planar_sheet ( const CubitVector& p1,
187 : : const CubitVector& p2,
188 : : const CubitVector& p3,
189 : : const CubitVector& p4 ) const;
190 : :
191 : : virtual BodySM* copy_body( BodySM* body_sm,
192 : : std::map<TopologyBridge*, TopologyBridge*> *old_tb_to_new_tb = NULL ) const;
193 : :
194 : : virtual BodySM* create_body( VolumeFacets& volume,
195 : : std::map<FacetShapes*, GeometryEntity*>& entity_map,
196 : : const FacetPointSet& points,
197 : : int interp_order) const ;
198 : : //- creates a body with a volume from facet data
199 : : //- VolumeFacets is populated with return data to associate sets of facets with newly created geometry entities
200 : :
201 : : virtual CubitStatus subtract(DLIList<BodySM*> &tool_body_list,
202 : : DLIList<BodySM*> &from_bodies,
203 : : DLIList<BodySM*> &new_bodies,
204 : : bool imprint = false,
205 : : bool keep_old = false) const;
206 : :
207 : : virtual CubitStatus imprint(BodySM* BodyPtr1, BodySM* BodyPtr2,
208 : : BodySM*& newBody1, BodySM*& newBody2,
209 : : bool keep_old) const;
210 : :
211 : : virtual CubitStatus imprint(DLIList<BodySM*> &from_body_list,
212 : : DLIList<BodySM*> &new_from_body_list,
213 : : bool keep_old,
214 : : DLIList<TopologyBridge*> *new_tbs = NULL,
215 : : DLIList<TopologyBridge*> *att_tbs = NULL) const;
216 : :
217 : : virtual CubitStatus imprint( DLIList<BodySM*> &body_list,
218 : : DLIList<Curve*> &ref_edge_list,
219 : : DLIList<BodySM*>& new_body_list,
220 : : DLIList<TopologyBridge*> &temporary_bridges,
221 : : bool keep_old_body,
222 : : bool show_messages = true) const;
223 : : //- Imprints a list of Bodies with a list of RefEdges. All entities must
224 : : //- be entities. Useful for splitting surfaces. If edge pierces a
225 : : //- surface a hardpoint will result at the pierce location.
226 : :
227 : : virtual CubitStatus imprint( DLIList<Surface*> &surface_list,
228 : : DLIList<Curve*> &curve_list,
229 : : DLIList<TopologyBridge*> &temporary_bridges,
230 : : DLIList<BodySM*>& new_body_list,
231 : : bool keep_old_body ) const;
232 : : //- Imprints a list of RefFaces with a list of RefEdges. This is
233 : : //- useful if the user has a curve which spans several surfaces on
234 : : //- a body and only wants to imprint to selected surfaces. Algorithm
235 : : //- does not support imprinting to free surfaces.
236 : :
237 : : virtual CubitStatus imprint( DLIList<Surface*> &surface_list,
238 : : DLIList<DLIList<Curve*>*> &curve_lists_list,
239 : : BodySM*& new_body,
240 : : bool keep_old_body,
241 : : bool expand = true,
242 : : DLIList<TopologyBridge*> *new_tbs = NULL,
243 : : DLIList<TopologyBridge*> *att_tbs = NULL ) const;
244 : : //- Imprints a list of Surfaces with list of Curves, sorted per
245 : : //- Surface (ie., curve_lists_list is same length as surface_list).
246 : :
247 : : virtual CubitStatus imprint( DLIList<BodySM*> &body_list,
248 : : DLIList<CubitVector> &vector_list,
249 : : DLIList<BodySM*>& new_body_list,
250 : : bool keep_old_body,
251 : : DLIList<TopologyBridge*> *new_tbs = NULL,
252 : : DLIList<TopologyBridge*> *att_tbs = NULL,
253 : : double *tol_in = NULL,
254 : : bool clean_up_slivers = true) const;
255 : : //- Imprints a list of bodies with a list of vectors. Useful for
256 : : //- splitting curves and creating hardpoints on surfaces.
257 : :
258 : : virtual CubitStatus imprint_projected_edges( DLIList<Surface*> &ref_face_list,
259 : : DLIList<Curve*> &ref_edge_list,
260 : : DLIList<BodySM*>& new_body_list,
261 : : DLIList<Curve*>& kept_free_edges,
262 : : bool keep_old_body,
263 : : bool keep_free_edges) const;
264 : :
265 : : virtual CubitStatus imprint_projected_edges(DLIList<Surface*> &ref_face_list,
266 : : DLIList<BodySM*> &body_list,
267 : : DLIList<Curve*> &ref_edge_list,
268 : : DLIList<BodySM*>& new_body_list,
269 : : bool keep_old_body,
270 : : bool keep_free_edges) const;
271 : :
272 : : virtual CubitStatus project_edges( DLIList<Surface*> &ref_face_list,
273 : : DLIList<Curve*> &ref_edge_list_in,
274 : : DLIList<Curve*> &ref_edge_list_new,
275 : : bool print_error = true ) const;
276 : :
277 : : virtual CubitStatus intersect(BodySM* tool_body_ptr,
278 : : DLIList<BodySM*> &from_bodies,
279 : : DLIList<BodySM*> &new_bodies,
280 : : bool keep_old = CUBIT_FALSE,
281 : : bool preview = false) const;
282 : :
283 : : virtual CubitStatus chop(DLIList<BodySM*> &bodies,
284 : : DLIList<BodySM*> &intersectBodies,
285 : : DLIList<BodySM*> &outsideBody,
286 : : BodySM*& leftoversBody,
287 : : bool keep_old = CUBIT_FALSE,
288 : : bool nonreg = CUBIT_FALSE) const;
289 : :
290 : : virtual CubitStatus unite(DLIList<BodySM*> &bodies,
291 : : DLIList<BodySM*> &newBodies,
292 : : bool keep_old = CUBIT_FALSE) const;
293 : :
294 : : virtual CubitStatus thicken(DLIList<BodySM*>& bodies,
295 : : DLIList<BodySM*>& new_bodies,
296 : : double depth,
297 : : bool both = CUBIT_FALSE) const ;
298 : :
299 : : virtual CubitStatus hollow( DLIList<BodySM*>& bodies,
300 : : DLIList<Surface*>& surfs_to_remove,
301 : : DLIList<BodySM*>& new_bodies,
302 : : double depth) const ;
303 : :
304 : : virtual CubitStatus flip_normals( DLIList<Surface*>& face_list ) const;
305 : :
306 : : virtual CubitStatus sweep_translational(
307 : : DLIList<GeometryEntity*>& ref_ent_list,
308 : : DLIList<BodySM*>& result_body_list,
309 : : const CubitVector& sweep_vector,
310 : : double draft_angle,
311 : : int draft_type,
312 : : bool switchside,
313 : : bool rigid,
314 : : bool anchor_entity=CUBIT_FALSE,
315 : : bool keep_old=CUBIT_FALSE) const;
316 : :
317 : : virtual CubitStatus sweep_perpendicular(
318 : : DLIList<GeometryEntity*>& ref_ent_list,
319 : : DLIList<BodySM*>& result_body_list,
320 : : double distance,
321 : : double draft_angle,
322 : : int draft_type,
323 : : bool switchside,
324 : : bool rigid,
325 : : bool anchor_entity=CUBIT_FALSE,
326 : : bool keep_old=CUBIT_FALSE) const;
327 : :
328 : : virtual CubitStatus sweep_rotational(
329 : : DLIList<GeometryEntity*>& ref_ent_list,
330 : : DLIList<BodySM*>& result_body_list,
331 : : const CubitVector& point,
332 : : const CubitVector& direction,
333 : : double angle,
334 : : int steps = 0,
335 : : double draft_angle = 0.0,
336 : : int draft_type = 0,
337 : : bool switchside = CUBIT_FALSE,
338 : : bool make_solid = CUBIT_FALSE,
339 : : bool rigid = CUBIT_FALSE,
340 : : bool anchor_entity=CUBIT_FALSE,
341 : : bool keep_old=CUBIT_FALSE ) const;
342 : :
343 : : virtual CubitStatus sweep_along_curve(
344 : : DLIList<GeometryEntity*>& ref_ent_list,
345 : : DLIList<BodySM*>& result_body_list,
346 : : DLIList<Curve*>& ref_edge_list,
347 : : double draft_angle = 0.0,
348 : : int draft_type = 0,
349 : : bool rigid = CUBIT_FALSE,
350 : : bool anchor_entity=CUBIT_FALSE,
351 : : bool keep_old=CUBIT_FALSE ) const;
352 : :
353 : : virtual CubitStatus sweep_to_body(
354 : : DLIList<Curve*> curve_list,
355 : : BodySM *target_body,
356 : : CubitVector distance,
357 : : DLIList<BodySM*> &new_bodies,
358 : : bool unite) const ;
359 : : virtual CubitStatus sweep_to_body(
360 : : Surface *source_surface,
361 : : BodySM *target_body,
362 : : CubitVector distance,
363 : : DLIList<BodySM*> &new_bodies ) const ;
364 : :
365 : : //HEADER- Webcut-related functions
366 : : virtual CubitStatus webcut(
367 : : DLIList<BodySM*>& webcut_body_list,
368 : : const CubitVector &v1,
369 : : const CubitVector &v2,
370 : : const CubitVector &v3,
371 : : DLIList<BodySM*>& neighbor_imprint_list,
372 : : DLIList<BodySM*>& results_list,
373 : : ImprintType imprint_type = NO_IMPRINT,
374 : : bool preview = false) const ;
375 : : //R int
376 : : //R- Number of bodies that were webcut ( >= 0 )
377 : : //I webcut_body_list
378 : : //I- The list of bodies to be webcut
379 : : //I plane
380 : : //I- The plane to be used for webcutting.
381 : : //I merge
382 : : //I- A flag to decide whether the new bodies created by the
383 : : //I- webcutting process should be merged or not.
384 : : //I imprint
385 : : //I- A flag to decide whether the new bodies created by the
386 : : //I- webcutting process should be imprinted or not.
387 : : //- This functions webcuts a list of bodies through a plane.
388 : : //- The newly created bodies are merged and imprinted depeding on
389 : : //- the respective flags.
390 : :
391 : : virtual CubitStatus webcut_with_sheet(DLIList<BodySM*>& webcut_body_list,
392 : : BodySM *sheet_body,
393 : : DLIList<BodySM*>& neighbor_imprint_list,
394 : : DLIList<BodySM*> &new_bodies,
395 : : ImprintType imprint_type = NO_IMPRINT,
396 : : bool preview = false) ;
397 : : //- webcuts a body using a sheet body.
398 : : //- It splits the sheet into two single sided bodies.
399 : : //- it then subtracts this with the webcut body.
400 : : //- The result is splitting the webcut_body into halves.
401 : : //- if the webcut body is a topological torus, this routine
402 : : //- will fail...
403 : :
404 : : virtual CubitStatus webcut_with_extended_sheet(
405 : : DLIList<BodySM*> &webcut_body_list,
406 : : DLIList<Surface*> &surface_list,
407 : : DLIList<BodySM*>& neighbor_imprint_list,
408 : : DLIList<BodySM*> &new_bodies,
409 : : int &num_cut,
410 : : ImprintType imprint_type = NO_IMPRINT,
411 : : bool preview = false) ;
412 : : //- creates a sheet by extending the given surfaces then webcuts using
413 : : //- this sheet.(see webcut_with_sheet).
414 : :
415 : : virtual CubitStatus webcut_with_sweep_surfaces(
416 : : DLIList<BodySM*> &blank_bodies,
417 : : DLIList<Surface*> &surfaces,
418 : : const CubitVector& sweep_vector,
419 : : bool sweep_perp,
420 : : bool through_all,
421 : : bool outward,
422 : : bool up_to_next,
423 : : Surface *stop_surf,
424 : : Curve *curve_to_sweep_along,
425 : : DLIList<BodySM*>& neighbor_imprint_list,
426 : : DLIList<BodySM*> &results_list,
427 : : ImprintType imprint_type = NO_IMPRINT,
428 : : CubitBoolean preview = false) ;
429 : :
430 : : virtual CubitStatus webcut_with_sweep_curves(
431 : : DLIList<BodySM*> &blank_bodies,
432 : : DLIList<Curve*> &curves,
433 : : const CubitVector& sweep_vector,
434 : : bool through_all,
435 : : Surface *stop_surf,
436 : : Curve *curve_to_sweep_along,
437 : : DLIList<BodySM*>& neighbor_imprint_list,
438 : : DLIList<BodySM*> &results_list,
439 : : ImprintType imprint_type = NO_IMPRINT,
440 : : CubitBoolean preview = false) ;
441 : :
442 : : virtual CubitStatus webcut_with_sweep_curves_rotated(
443 : : DLIList<BodySM*> &blank_bodies,
444 : : DLIList<Curve*> &curves,
445 : : const CubitVector &point,
446 : : const CubitVector &sweep_axis,
447 : : double angle,
448 : : Surface *stop_surf,
449 : : DLIList<BodySM*>& neighbor_imprint_list,
450 : : DLIList<BodySM*> &results_list,
451 : : ImprintType imprint_type = NO_IMPRINT,
452 : : CubitBoolean preview = false) ;
453 : :
454 : : virtual CubitStatus webcut_with_sweep_surfaces_rotated(
455 : : DLIList<BodySM*> &blank_bodies,
456 : : DLIList<Surface*> &surfaces,
457 : : const CubitVector &point,
458 : : const CubitVector &sweep_axis,
459 : : double angle,
460 : : Surface *stop_surf,
461 : : bool up_to_next,
462 : : DLIList<BodySM*>& neighbor_imprint_list,
463 : : DLIList<BodySM*> &results_list,
464 : : ImprintType imprint_type = NO_IMPRINT,
465 : : CubitBoolean preview = false) ;
466 : :
467 : : virtual CubitStatus webcut_with_cylinder(
468 : : DLIList<BodySM*> &webcut_body_list,
469 : : double radius,
470 : : const CubitVector &axis,
471 : : const CubitVector ¢er,
472 : : DLIList<BodySM*>& neighbor_imprint_list,
473 : : DLIList<BodySM*>& results_list,
474 : : ImprintType imprint_type = NO_IMPRINT,
475 : : CubitBoolean preview = false) ;
476 : : //- webcuts a body using a cylinder give the input parameters.
477 : :
478 : : virtual CubitStatus webcut_with_brick(
479 : : DLIList<BodySM*>& webcut_body_list,
480 : : const CubitVector ¢er,
481 : : const CubitVector axes[3],
482 : : const CubitVector &extension,
483 : : DLIList<BodySM*>& neighbor_imprint_list,
484 : : DLIList<BodySM*> &results_list,
485 : : ImprintType imprint_type = NO_IMPRINT,
486 : : CubitBoolean preview = false) ;
487 : : /**< Webcuts the bodies in the list with a cutting brick.
488 : : * The brick is created by the given parameters - center of
489 : : * brick, xyz axes, and extension. Extension is 1/2 width,
490 : : * height and depth. If one of the brick dimensions is zero
491 : : * the resultant planar sheet is used to webcut (webcut_with_
492 : : * planar_sheet is called). Brick creation is done in the
493 : : * solid modeling engine to reduce the impact on body ids.
494 : : */
495 : :
496 : : virtual CubitStatus webcut_with_planar_sheet(
497 : : DLIList<BodySM*>& webcut_body_list,
498 : : const CubitVector ¢er,
499 : : const CubitVector axes[2],
500 : : double width, double height,
501 : : DLIList<BodySM*>& neighbor_imprint_list,
502 : : DLIList<BodySM*> &results_list,
503 : : ImprintType imprint_type = NO_IMPRINT,
504 : : bool preview = false) ;
505 : : /**< Webcuts the bodies in the list with a cutting planar sheet.
506 : : * The sheet is created by the given parameters - center of
507 : : * sheet, xy axes, and width and height. Sheet creation is done
508 : : * in the solid modeling engine to reduce the impact on body ids.
509 : : */
510 : : virtual CubitStatus webcut_with_curve_loop(
511 : : DLIList<BodySM*> &webcut_body_list,
512 : : DLIList<Curve*> &ref_edge_list,
513 : : DLIList<BodySM*>& neighbor_imprint_list,
514 : : DLIList<BodySM*>& results_list,
515 : : ImprintType imprint_type = NO_IMPRINT,
516 : : bool preview = false) ;
517 : : //- webcuts a body list using a temp sheet body created from the curve loop
518 : :
519 : : virtual CubitStatus webcut( DLIList<BodySM*>& webcut_body_list,
520 : : BodySM const* tool_body,
521 : : DLIList<BodySM*>& neighbor_imprint_list,
522 : : DLIList<BodySM*>& results_list,
523 : : ImprintType imprint_type = NO_IMPRINT,
524 : : bool preview = false) const ;
525 : : //R int
526 : : //R- Number of bodies that were webcut ( >= 0 )
527 : : //I webcut_body_list
528 : : //I- The list of bodies to be webcut
529 : : //I tool_body
530 : : //I- The body to be used for webcutting.
531 : : //I merge
532 : : //I- A flag to decide whether the new bodies created by the
533 : : //I- webcutting process should be merged or not.
534 : : //I imprint
535 : : //I- A flag to decide whether the new bodies created by the
536 : : //I- webcutting process should be imprinted or not.
537 : : //- This functions webcuts a list of bodies using another body
538 : : //- as the webcutting tool. The newly created bodies are
539 : : //- merged and imprinted depeding on the respective flags.
540 : :
541 : : virtual CubitStatus webcut_across_translate( DLIList<BodySM*>& body_list,
542 : : Surface* plane_surf1,
543 : : Surface* plane_surf2,
544 : : DLIList<BodySM*>& neighbor_imprint_list,
545 : : DLIList<BodySM*>& results_list,
546 : : ImprintType imprint_type = NO_IMPRINT,
547 : : bool preview = false) const;
548 : : // In-process function to webcut a flat plate suitable for singe-single sweeping.
549 : :
550 : : virtual CubitStatus separate_surfaces( DLIList<Surface*> &surf_list,
551 : : DLIList<BodySM*> &new_bodies );
552 : : //- Separates surfaces from sheet bodies into separate bodies. Connected
553 : : //- surfaces will remain connected but be placed in a new body.
554 : :
555 : : virtual CubitStatus section( DLIList<BodySM*> §ion_body_list,
556 : : const CubitVector &point_1,
557 : : const CubitVector &point_2,
558 : : const CubitVector &point_3,
559 : : DLIList<BodySM*>& new_body_list,
560 : : bool keep_normal_side,
561 : : bool keep_old = false,
562 : : bool keep_both_sides = false);
563 : :
564 : : virtual CubitStatus split_body( BodySM *body_ptr,
565 : : DLIList<BodySM*> &new_bodies );
566 : :
567 : : virtual CubitStatus reverse_body( BodySM *body_to_reverse );
568 : :
569 : : virtual CubitStatus split_periodic( BodySM *body_ptr,
570 : : BodySM *&new_body );
571 : :
572 : : virtual CubitStatus regularize_body( BodySM *body_ptr,
573 : : BodySM *&new_body_ptr );
574 : :
575 : : virtual CubitStatus regularize_entity(GeometryEntity *old_entity_ptr,
576 : : BodySM *&new_body_ptr);
577 : :
578 : : virtual CubitStatus offset_curves( DLIList<Curve*>& ref_edge_list,
579 : : DLIList<Curve*>& result_curve_list,
580 : : double offset_distance,
581 : : const CubitVector& offset_direction,
582 : : int gap_type = 1 );
583 : :
584 : : virtual CubitStatus scale ( BodySM *&body, const CubitVector& factors );
585 : :
586 : : virtual Curve* trim_curve( Curve* trim_curve,
587 : : const CubitVector& trim_vector,
588 : : const CubitVector& keep_vector,
589 : : bool keep_old = false );
590 : :
591 : : virtual CubitStatus create_solid_bodies_from_surfs(
592 : : DLIList<Surface*> &ref_face_list,
593 : : DLIList<BodySM*> &new_bodies,
594 : : bool keep_old = false,
595 : : bool heal = true,
596 : : bool sheet = false) const;
597 : : //- This function assumes that the reffaces sent into
598 : : //- this function are either sheet bodies, or free surfaces. This
599 : : //- Will have been taken care of in the calling function. GT?
600 : :
601 : 0 : CubitStatus tweak_bend( DLIList<BodySM*> &bend_bodies,
602 : : DLIList<BodySM*> &new_bodysm_list,
603 : : CubitVector& neutral_root,
604 : : CubitVector& bend_axis,
605 : : CubitVector& bend_direction,
606 : : double radius,
607 : : double angle,
608 : : DLIList<CubitVector>& bend_regions,
609 : : double width = -1,
610 : : CubitBoolean center_bend = CUBIT_FALSE,
611 : : int num_points = 0,
612 : : CubitBoolean keep_old_body = CUBIT_FALSE,
613 : : CubitBoolean preview = CUBIT_FALSE ) const
614 : : /**< Bend solid bodies based on a bend radius and angle.
615 : : */
616 : 0 : { return CUBIT_FAILURE;}
617 : :
618 : : virtual Curve* create_arc(const CubitVector& position,
619 : : double radius,
620 : : double start_angle,
621 : : double end_angle,
622 : : CubitVector plane,
623 : : CubitBoolean preview = CUBIT_FALSE );
624 : :
625 : : virtual Curve* create_arc_radius(const CubitVector ¢er,
626 : : TBPoint* ref_vertex_start,
627 : : TBPoint* ref_vertex_end,
628 : : const CubitVector &normal,
629 : : double radius,
630 : : bool full = false,
631 : : CubitBoolean preview = CUBIT_FALSE );
632 : :
633 : : virtual Curve* create_arc_three( TBPoint* ref_vertex1,
634 : : TBPoint* ref_vertex2,
635 : : TBPoint* ref_vertex3,
636 : : bool full = false,
637 : : CubitBoolean preview = CUBIT_FALSE );
638 : :
639 : : virtual Curve* create_arc_three( Curve* ref_edge1,
640 : : Curve* ref_edge2,
641 : : Curve* ref_edge3,
642 : : bool full = false,
643 : : CubitBoolean preview = CUBIT_FALSE );
644 : :
645 : : virtual Curve* create_arc_center_edge(
646 : : TBPoint* ref_vertex1,
647 : : TBPoint* ref_vertex2,
648 : : TBPoint* ref_vertex3,
649 : : const CubitVector &normal,
650 : : double radius = CUBIT_DBL_MAX,
651 : : bool full = false,
652 : : CubitBoolean preview = CUBIT_FALSE );
653 : :
654 : : virtual CubitStatus create_curve_combine( DLIList<Curve*>& curve_list,
655 : : Curve *&new_curve_ptr );
656 : : //- Uses the solid modeller to create a new RefEdge that is a combination
657 : : //- of the input chain of edges.
658 : : //-
659 : :
660 : : virtual GeometryQueryEngine *get_gqe();
661 : :
662 : : virtual CubitBoolean is_modify_engine(const TopologyBridge *tb_ptr) const;
663 : :
664 : : virtual CubitStatus get_offset_intersections(
665 : : Curve* ref_edge1,
666 : : Curve* ref_edge2,
667 : : DLIList<CubitVector>& intersection_list,
668 : : double offset,
669 : : bool ext_first = true );
670 : :
671 : : virtual CubitStatus get_offset_intersections(
672 : : Curve* ref_edge_ptr,
673 : : Surface* ref_face_ptr,
674 : : DLIList<CubitVector> &intersection_list,
675 : : double offset = 0.0,
676 : : bool ext_surf = true );
677 : :
678 : : virtual CubitStatus surface_intersection( Surface *surface1_ptr,
679 : : Surface *surface2_ptr,
680 : : DLIList<Curve*> &inter_graph,
681 : : const double tol) const;
682 : :
683 : : CubitStatus get_3_point_plane( const CubitVector & point_1,
684 : : const CubitVector & point_2,
685 : : const CubitVector & point_3,
686 : : TopoDS_Face*& face)const;
687 : :
688 : : virtual CubitStatus get_mid_plane( const CubitVector &point_1,
689 : : const CubitVector &point_2,
690 : : const CubitVector &point_3,
691 : : BodySM *body_to_trim_to,
692 : : BodySM *&midplane_body ) const;
693 : :
694 : : virtual CubitStatus get_spheric_mid_surface( Surface *surface_ptr1,
695 : : Surface *surface_ptr2,
696 : : BodySM *body_to_trim_to,
697 : : BodySM *&midsurface_body ) const;
698 : :
699 : : virtual CubitStatus get_conic_mid_surface( Surface *surface_ptr1,
700 : : Surface *surface_ptr2,
701 : : BodySM *body_to_trim_to,
702 : : BodySM *&midsurface_body ) const;
703 : :
704 : :
705 : : virtual CubitStatus get_toric_mid_surface( Surface *surface_ptr1,
706 : : Surface *surface_ptr2,
707 : : BodySM *body_to_trim_to,
708 : : BodySM *&midsurface_body ) const;
709 : :
710 : : virtual CubitStatus tweak_chamfer( DLIList<Curve*> &curve_list,
711 : : double left_offset,
712 : : DLIList<BodySM*> &new_bodysm_list,
713 : : double right_offset = -1.0,
714 : : CubitBoolean keep_old_body = CUBIT_FALSE,
715 : : CubitBoolean preview = CUBIT_FALSE ) const;
716 : : /**< Chamfer curves on solid bodies. The left and right offsets are with
717 : : * respect to the curve direction. If the given right offset is negative,
718 : : * the left offset is used. Users can preview to clarify the meaning of
719 : : * left and right.
720 : : */
721 : :
722 : : virtual CubitStatus tweak_chamfer( DLIList<TBPoint*> &point_list,
723 : : double offset1,
724 : : DLIList<BodySM*> &new_bodysm_list,
725 : : Curve *edge1 = NULL,
726 : : double offset2 = -1.0,
727 : : Curve *edge2 = NULL,
728 : : double offset3 = -1.0,
729 : : Curve *edge3 = NULL,
730 : : CubitBoolean keep_old_body = CUBIT_FALSE,
731 : : CubitBoolean preview = CUBIT_FALSE )const ;
732 : : /**< Chamfer vertices on solid or sheet bodies. On a solid body there can
733 : : * be up to 3 offsets; on a sheet body up to 2 offsets. The offsets are
734 : : * in the direction of the supplied edges. If multiple vertices are
735 : : * supplied, only one offset value is allowed and the edges are not used.
736 : : */
737 : :
738 : : virtual CubitStatus tweak_fillet( DLIList<Curve*> &curve_list,
739 : : double radius,
740 : : DLIList<BodySM*> &new_bodysm_list,
741 : : CubitBoolean keep_old_body = CUBIT_FALSE,
742 : : CubitBoolean preview = CUBIT_FALSE ) const;
743 : : /**< Create a round fillet (or blend) at the given curves on solid bodies.
744 : : */
745 : :
746 : : virtual CubitStatus tweak_fillet( Curve *curve_ptr,
747 : : double start_radius,
748 : : double end_radius,
749 : : BodySM *&new_body_ptr,
750 : : CubitBoolean keep_old_body = CUBIT_FALSE,
751 : : CubitBoolean preview = CUBIT_FALSE ) const;
752 : : /**< Create a round fillet (or blend) at the given curve on a solid body.
753 : : * The fillet has a variable radius from the start to the end of the curve.
754 : : */
755 : :
756 : : virtual CubitStatus tweak_fillet( DLIList<TBPoint*> &point_list,
757 : : double radius,
758 : : DLIList<BodySM*> &new_bodysm_list,
759 : : CubitBoolean keep_old_body = CUBIT_FALSE,
760 : : CubitBoolean preview = CUBIT_FALSE ) const;
761 : : /**< Create a round fillet (or blend) at the given vertices on sheet bodies.
762 : : */
763 : :
764 : : virtual CubitStatus tweak_move( DLIList<Surface*> &surface_list,
765 : : const CubitVector &delta,
766 : : DLIList<BodySM*> &new_bodysm_list,
767 : : CubitBoolean keep_old_body = CUBIT_FALSE,
768 : : CubitBoolean preview = CUBIT_FALSE ) const;
769 : : /**< Tweak specified faces of a volume or volumes along a vector.
770 : : */
771 : :
772 : : virtual CubitStatus tweak_move( DLIList<Curve*> &curve_list,
773 : : const CubitVector &delta,
774 : : DLIList<BodySM*> &new_bodysm_list,
775 : : CubitBoolean keep_old_body = CUBIT_FALSE,
776 : : CubitBoolean preview = CUBIT_FALSE ) const;
777 : : /**< Tweak specified curves of a sheet body along a vector.
778 : : */
779 : :
780 : : virtual CubitStatus tweak_offset( DLIList<Surface*> &surface_list,
781 : : double offset_distance,
782 : : DLIList<Surface*> *add_surface_list_ptr,
783 : : DLIList<double>*,
784 : : DLIList<BodySM*>&,
785 : : CubitBoolean keep_old_body = CUBIT_FALSE,
786 : : CubitBoolean preview = CUBIT_FALSE ) const;
787 : : /**< Tweak specified faces of a volume or volumes by offsetting those faces
788 : : * by the offset distance.
789 : : */
790 : :
791 : : virtual CubitStatus tweak_offset( DLIList<Curve*> &curve_list,
792 : : double offset_distance,
793 : : DLIList<Curve*>*,
794 : : DLIList<double>*,
795 : : DLIList<BodySM*> &new_bodysm_list,
796 : : CubitBoolean keep_old_body = CUBIT_FALSE,
797 : : CubitBoolean preview = CUBIT_FALSE ) const;
798 : : /**< Tweak specified curves of a sheet body or bodies by offsetting those
799 : : * curves by the offset distance.
800 : : */
801 : :
802 : : virtual CubitStatus tweak_remove( DLIList<Surface*> &surface_list,
803 : : DLIList<BodySM*> &new_bodysm_list,
804 : : CubitBoolean extend_adjoining = CUBIT_TRUE,
805 : : CubitBoolean keep_old_body = CUBIT_FALSE,
806 : : CubitBoolean preview = CUBIT_FALSE ) const;
807 : : /**< Remove surfaces from a body or bodies and then extend the adjoining
808 : : * surfaces to fill the gap or remove the hole.
809 : : */
810 : :
811 : : virtual CubitStatus tweak_remove( DLIList<Curve*> &curve_list,
812 : : DLIList<BodySM*> &new_bodysm_list,
813 : : CubitBoolean keep_old_body = CUBIT_FALSE,
814 : : CubitBoolean preview = CUBIT_FALSE ) const;
815 : : /**< Remove curves from a sheet body or bodies and then extend the remaining
816 : : * curves to fill the gap. If an internal loop of curves is removed the
817 : : * hole is removed.
818 : : */
819 : :
820 : : virtual CubitStatus tweak_target( DLIList<Surface*> &surface_list,
821 : : DLIList<Surface*> &target_surfs,
822 : : DLIList<BodySM*> &new_bodysm_list,
823 : : CubitBoolean extend_flg = CUBIT_TRUE,
824 : : CubitPlane *limit_plane = NULL,
825 : : CubitBoolean reverse_flg = CUBIT_FALSE,
826 : : CubitBoolean keep_old_body = CUBIT_FALSE,
827 : : CubitBoolean preview = CUBIT_FALSE ) const;
828 : : /**< Tweak specified faces of a volume or volumes up to a target surface.
829 : : */
830 : :
831 : : virtual CubitStatus tweak_target( DLIList<Curve*> &curve_list,
832 : : DLIList<Surface*> &target_surf_list,
833 : : DLIList<BodySM*> &new_bodysm_list,
834 : : CubitBoolean extend_flg = CUBIT_TRUE,
835 : : CubitPlane *limit_plane = NULL,
836 : : CubitBoolean reverse_flg = CUBIT_FALSE,
837 : : CubitBoolean keep_old_body = CUBIT_FALSE,
838 : : CubitBoolean preview = CUBIT_FALSE,
839 : : double max_area_increase = 0 ) const;
840 : : /**< Tweak specified edges of a surface or set of surfaces (in sheet
841 : : * bodies) up to a target surface. This essentially extends or
842 : : * trims the attached surfaces of the sheet body.
843 : : */
844 : :
845 : : virtual CubitStatus tweak_target( DLIList<Curve*> &curve_list,
846 : : DLIList<Curve*> &target_curves,
847 : : DLIList<BodySM*> &new_bodysm_list,
848 : : CubitBoolean extend_flg = CUBIT_TRUE,
849 : : CubitPlane *limit_plane = NULL,
850 : : CubitBoolean reverse_flg = CUBIT_FALSE,
851 : : CubitBoolean keep_old_body = CUBIT_FALSE,
852 : : CubitBoolean preview = CUBIT_FALSE,
853 : : double max_area_increase = 0 ) const;
854 : : /**< Tweak specified edges of a sheet body or bodies up to a target curve
855 : : * that is part of a sheet body. The target is a surface created by
856 : : * thickening the owning surface of the target curve.
857 : : */
858 : :
859 : : virtual CubitStatus tweak_target( TBPoint *point_ptr,
860 : : DLIList<Surface*> &modify_surface_list,
861 : : CubitVector &target_loc,
862 : : BodySM *&new_bodysm_ptr,
863 : : CubitBoolean keep_old_body = CUBIT_FALSE,
864 : : CubitBoolean preview = CUBIT_FALSE ) const ;
865 : : /**< Tweak specified vertex of a sheet body to a given location. The
866 : : * given vertex must be part of a planar surface or surfaces attached to
867 : : * linear curves only. The user specified which of those surfaces to
868 : : * actually modify. The given location will be projected to be on the
869 : : * given planar surface(s) before being used - this projected location
870 : : * must be the same on all surfaces.
871 : : */
872 : :
873 : : virtual CubitStatus split_curve( Curve* curve_to_split,
874 : : const CubitVector& split_location,
875 : : DLIList<Curve*>& created_curves ) ;
876 : : //- Splits a curve at the specified location.
877 : : //- the single passed in curve is split into two curves at the split location
878 : : //- the two resulting curves are added to the passed in list
879 : :
880 : :
881 : : virtual CubitStatus remove_curve_slivers( BodySM *body, double lengthlimit ) const;
882 : :
883 : : virtual CubitStatus create_net_surface( DLIList<Surface*>& ref_face_list, BodySM *& new_body,
884 : : DLIList<DLIList<CubitVector*>*> &vec_lists_u,
885 : : DLIList<DLIList<CubitVector*>*> &vec_lists_v,
886 : : double net_tol = 1e-3,
887 : : CubitBoolean heal = CUBIT_TRUE ) const;
888 : :
889 : : virtual CubitStatus create_net_surface( DLIList<Curve*>& u_curves, DLIList<Curve*>& v_curves,
890 : : BodySM *& new_body,
891 : : double net_tol = 1e-3,
892 : : CubitBoolean heal = CUBIT_TRUE ) const;
893 : :
894 : : virtual CubitStatus create_offset_surface( Surface* ref_face_ptr, BodySM*& new_body, double offset_distance ) const;
895 : :
896 : : virtual CubitStatus create_offset_body( BodySM* body_ptr, BodySM*& new_body, double offset_distance ) const;
897 : :
898 : : virtual CubitStatus create_skin_surface( DLIList<Curve*>& curves, BodySM*& new_body, DLIList<Curve*>& ) const;
899 : :
900 : : /*
901 : : virtual CubitStatus loft_surfaces( Surface *face1, const double &takeoff1,
902 : : Surface *face2, const double &takeoff2,
903 : : BodySM*& new_body,
904 : : CubitBoolean arc_length_option = CUBIT_FALSE,
905 : : CubitBoolean twist_option = CUBIT_FALSE,
906 : : CubitBoolean align_direction = CUBIT_TRUE,
907 : : CubitBoolean perpendicular = CUBIT_TRUE,
908 : : CubitBoolean simplify_option = CUBIT_FALSE) const;
909 : :
910 : : virtual CubitStatus loft_surfaces_to_body( Surface *face1, const double &takeoff1,
911 : : Surface *face2, const double &takeoff2,
912 : : BodySM*& new_body,
913 : : CubitBoolean arc_length_option,
914 : : CubitBoolean twist_option,
915 : : CubitBoolean align_direction,
916 : : CubitBoolean perpendicular,
917 : : CubitBoolean simplify_option) const;
918 : : */
919 : :
920 : : virtual CubitStatus loft_surfaces_to_body(
921 : : DLIList<Surface*> &surfaces,
922 : : DLIList<double> &takeoff_factor_list,
923 : : DLIList<Surface*> &takeoff_vector_surface_list,
924 : : DLIList<CubitVector> &surface_takeoff_vector_list,
925 : : DLIList<Curve*> &takeoff_vector_curve_list,
926 : : DLIList<CubitVector> &curve_takeoff_vector_list,
927 : : DLIList<Curve*> &guides,
928 : : DLIList<TBPoint*> &match_vertices_list,
929 : : BodySM*& new_body,
930 : : CubitBoolean global_guides,
931 : : CubitBoolean closed,
932 : : CubitBoolean show_matching_curves,
933 : : CubitBoolean preview ) const;
934 : :
935 : : virtual CubitStatus create_surface( DLIList<CubitVector*>& vec_list,
936 : : BodySM *&new_body,
937 : : Surface *ref_face_ptr,
938 : : CubitBoolean project_points ) const;
939 : :
940 : : virtual CubitStatus create_surface( DLIList<TBPoint*> &points,
941 : : BodySM *&new_body,
942 : : Surface *on_surface ) const;
943 : :
944 : :
945 : : virtual CubitStatus create_weld_surface( CubitVector &root,
946 : : Surface *ref_face1, double leg1, Surface *ref_face2, double leg2,
947 : : BodySM *&new_body ) const;
948 : :
949 : : CubitStatus tolerant_imprint( DLIList<BodySM*> &bodies_in,
950 : : DLIList<BodySM*> &new_bodies,
951 : : DLIList<TopologyBridge*>*,
952 : : DLIList<TopologyBridge*>* ) const;
953 : :
954 : : virtual CubitStatus tolerant_imprint(DLIList<Surface*> &surfs_in,
955 : : DLIList<BodySM*> &new_bodysm_list) const;
956 : :
957 : : virtual CubitStatus tolerant_imprint_surface_with_curves(
958 : : Surface *surface_to_imprint,
959 : : DLIList<Curve*> &curves,
960 : : DLIList<TopologyBridge*> &temporary_bridges,
961 : : BodySM *&new_body,
962 : : DLIList<TopologyBridge*> *new_tbs = NULL,
963 : : DLIList<TopologyBridge*> *att_tbs = NULL ) const;
964 : : //Imprints a surface with passed-in curves. Can imprint successfully
965 : : //and expectedly with sloppy/dirty geometry.
966 : : virtual CubitStatus tolerant_imprint( DLIList<BodySM*> &bodies_in,
967 : : DLIList<BodySM*> &new_bodies,
968 : : double overlap_tol,
969 : : double imprint_tol,
970 : : DLIList<TopologyBridge*> *new_tbs = NULL,
971 : : DLIList<TopologyBridge*> *att_tbs = NULL ) const;
972 : :
973 : : virtual CubitStatus remove_topology(DLIList<Curve*> &curves_to_remove,
974 : : DLIList<Surface*> &surfs_to_remove,
975 : : double backoff_distance,
976 : : double small_edge_size,
977 : : DLIList<BodySM*> &new_bodysm_list,
978 : : CubitBoolean preview) const;
979 : :
980 : : virtual CubitStatus curve_surface_intersection( Surface *surface,
981 : : Curve* curve,
982 : : DLIList<Curve*> &new_curves ) const;
983 : : //Intersects input surface with input curve to produce intersection curve(s).
984 : : //If intersection results is nothing or a point, CUBIT_FAILURE is returned.
985 : :
986 : : virtual void get_possible_invalid_tbs(DLIList<TopologyBridge*> &bridges_in,
987 : : DLIList<TopologyBridge*> &bridges_out);
988 : :
989 : 0 : virtual CubitStatus create_offset_sheet( DLIList<Surface*> &surface_list,
990 : : double offset_distance,
991 : : DLIList<Surface*> *add_surface_list_ptr,
992 : : DLIList<double> *add_offset_list_ptr,
993 : : DLIList<BodySM*> &new_body_list,
994 : : CubitBoolean preview = CUBIT_FALSE ) const
995 : : /**< Create a sheet body (or bodies) by offsetting the given faces. The
996 : : * optional additional face list and double list (must be same length)
997 : : * allow different offset distances for different faces. Adjoining faces
998 : : * are extended or trimmed to remain joined in the new sheet body. Radial
999 : : * faces that cannot be so offset are removed and the resulting wound
1000 : : * healed by the surrounding faces.
1001 : : */
1002 : 0 : { return CUBIT_FAILURE; }
1003 : :
1004 : 0 : virtual CubitBoolean bodies_interfering( BodySM *body1, BodySM *body2 ) const
1005 : 0 : {return CUBIT_FAILURE; }
1006 : :
1007 : : virtual CubitStatus stitch( DLIList<BodySM*> &bodies_to_stitch,
1008 : : DLIList<BodySM*> &new_bodies,
1009 : : bool tighten_gaps,
1010 : : double tolerance )const;
1011 : :
1012 : : #ifdef CGM_KCM
1013 : : virtual CubitStatus mesh2brep(std::vector<double> &xvals,
1014 : : std::vector<double> &yvals,
1015 : : std::vector<double> &zvals,
1016 : : std::vector<unsigned int> &tri_connectivity,
1017 : : DLIList<BodySM*> &new_body_sms) const;
1018 : : #endif
1019 : : protected:
1020 : :
1021 : : TopoDS_Face* make_TopoDS_Face( GeometryType surface_type,
1022 : : DLIList<DLIList<TopoDS_Edge*>*> topo_edges,
1023 : : Surface* old_surface_ptr) const;
1024 : :
1025 : : int imprint_toposhapes(TopoDS_Shape*&, TopoDS_Shape*,
1026 : : DLIList<TopoDS_Face*>&on_faces ) const;
1027 : :
1028 : : TopoDS_Edge* find_imprinting_edge(TopoDS_Shape& from_shape,
1029 : : TopoDS_Edge& tool_shape,
1030 : : DLIList<TopoDS_Face*>& faces)const;
1031 : :
1032 : : CubitStatus sort_curves(DLIList<Curve*> curve_list,
1033 : : DLIList<DLIList<TopoDS_Edge*>*>& topo_edges_loops)const;
1034 : :
1035 : : CubitStatus stitch_surfs(DLIList<BodySM*>& surf_bodies,
1036 : : TopoDS_Shape& stitched_shape) const;
1037 : :
1038 : : private:
1039 : : CubitStatus result_1_imprint(BodySM* from_body,
1040 : : BodySM* tool_body,
1041 : : BodySM*& newBody)const;
1042 : :
1043 : : CubitStatus result_3_imprint(BodySM* from_body,
1044 : : BodySM* tool_body,
1045 : : BodySM*& newBody)const;
1046 : :
1047 : : //- for periodic surfaces, use webcut first and then unite to get imprints
1048 : :
1049 : 518 : virtual bool supports_interoperability() { return true; }
1050 : : //- Returns whether intermixing of real and virtual geometry operations
1051 : : //- is supported for the current geometry kernel.
1052 : :
1053 : : CubitStatus tweak_chamfer_sheet(TBPoint* pnt,
1054 : : OCCSurface* face,
1055 : : double d1,
1056 : : Curve* edge1,
1057 : : double d2,
1058 : : Curve* edge2,
1059 : : DLIList<BodySM*> & new_bodysm_list,
1060 : : CubitBoolean keep_old_body,
1061 : : CubitBoolean preview ) const;
1062 : :
1063 : : CubitStatus tweak_fillet_chamfer_sheet( DLIList<TBPoint*> & ref_vertex_list,
1064 : : DLIList<OCCSurface*> faces,
1065 : : double radius,
1066 : : CubitBoolean is_fillet,
1067 : : DLIList<BodySM*> & new_bodysm_list,
1068 : : CubitBoolean keep_old_body,
1069 : : CubitBoolean preview ) const;
1070 : :
1071 : : CubitStatus tweak_chamfer_solid( TBPoint* point_ptr,
1072 : : OCCBody* body,
1073 : : double r1,
1074 : : Curve *c1,
1075 : : double r2,
1076 : : Curve *c2,
1077 : : double r3,
1078 : : Curve *c3,
1079 : : DLIList<BodySM *> &new_bodysm_list,
1080 : : CubitBoolean keep_old_body,
1081 : : CubitBoolean preview ) const;
1082 : :
1083 : : CubitStatus tweak_chamfer_solid( DLIList<TBPoint*> &point_list,
1084 : : DLIList<OCCBody*> &bodies,
1085 : : double radius,
1086 : : DLIList<BodySM*> &new_bodysm_list,
1087 : : CubitBoolean keep_old_body,
1088 : : CubitBoolean preview )const;
1089 : :
1090 : : CubitStatus sort_points_by_body_type( DLIList<TBPoint*> &point_list,
1091 : : DLIList<TBPoint*> &solid_points,
1092 : : DLIList<TBPoint*> &sheet_points,
1093 : : DLIList<OCCSurface*> &s_list,
1094 : : DLIList<OCCBody*> &bodies )const;
1095 : :
1096 : : CubitStatus tweak_fillet( Curve * curve_ptr,
1097 : : double start_radius,
1098 : : double end_radius,
1099 : : BodySM *& new_bodysm_ptr,
1100 : : CubitBoolean keep_old_body,
1101 : : CubitBoolean preview,
1102 : : CubitBoolean if_fillet ) const;
1103 : :
1104 : : CubitStatus do_loft(BRepOffsetAPI_ThruSections& loft,
1105 : : DLIList<Surface*>& surf_list) const;
1106 : :
1107 : : CubitStatus do_loft(BRepOffsetAPI_ThruSections& loft,
1108 : : DLIList<DLIList<TopoDS_Edge*>*> loops) const;
1109 : :
1110 : : void make_base_for_prim_pyramid(double major,
1111 : : double minor,
1112 : : double height,
1113 : : int sides,
1114 : : TopoDS_Wire& wire)const;
1115 : :
1116 : : int check_intersection(DLIList<TopoDS_Edge*>*& edge_list,
1117 : : TopoDS_Face from_face)const;
1118 : :
1119 : : CubitStatus get_shape_list(DLIList<BodySM*>& BodySM_list,
1120 : : DLIList<TopoDS_Shape*>& shape_list,
1121 : : DLIList<CubitBoolean>& is_volume,
1122 : : bool keep_old,
1123 : : DLIList<CubitBox*>* b_boxes = NULL) const;
1124 : :
1125 : : CubitStatus face_edge_imprint( DLIList<Surface*> &ref_face_list,
1126 : : DLIList<Curve*> &edge_list,
1127 : : DLIList<TopoDS_Face*>& face_list,
1128 : : DLIList<TopoDS_Shape*>& shape_list,
1129 : : bool keep_old ) const;
1130 : : void shape_to_bodySM( DLIList<TopoDS_Shape*> shape_list,
1131 : : DLIList<BodySM*>& new_body_list)const;
1132 : :
1133 : : void check_operation(TopoDS_Shape& cut_shape,
1134 : : TopoDS_Shape*& from_shape, //output
1135 : : CubitBoolean is_volume,
1136 : : CubitBoolean& has_changed, //output
1137 : : BRepAlgoAPI_BooleanOperation* op,
1138 : : CubitBoolean keep_old) const;
1139 : :
1140 : : CubitStatus get_sweepable_toposhape(OCCSurface*& surface,
1141 : : const CubitVector* sweep_v_p,
1142 : : TopoDS_Shape& toposhape)const;
1143 : :
1144 : : CubitStatus get_sweepable_toposhape(OCCCurve*& curve,
1145 : : TopoDS_Shape& toposhape)const;
1146 : :
1147 : : CubitStatus do_subtract(DLIList<BodySM*> &from_bodies,
1148 : : DLIList<TopoDS_Shape*> &tool_bodies_copy,
1149 : : DLIList<CubitBoolean> &is_tool_volume,
1150 : : DLIList<CubitBox*>* tool_boxes,
1151 : : DLIList<BodySM*> &new_bodies,
1152 : : bool keep_old,
1153 : : bool imprint = CUBIT_FALSE) const;
1154 : :
1155 : : void get_new_tbs(
1156 : : std::map<OCCSurface*, std::pair<CubitVector, double> >& surf_property_map,
1157 : : std::map<OCCCurve*, std::pair<CubitVector, double> >& curve_property_map,
1158 : : DLIList<OCCPoint*> &points,
1159 : : DLIList<OCCSurface*> &new_surfaces,
1160 : : DLIList<OCCCurve*> &new_curves,
1161 : : DLIList<OCCPoint*> &new_points,
1162 : : DLIList<TopologyBridge*> *new_tbs)const;
1163 : :
1164 : : void get_att_tbs(DLIList<OCCSurface*> &new_surfaces,
1165 : : DLIList<OCCCurve*> &new_curves,
1166 : : DLIList<OCCPoint*> &new_points,
1167 : : const CubitString& name,
1168 : : DLIList<TopologyBridge*> *att_tbs)const;
1169 : :
1170 : : CubitStatus split_shape_by_location(TopoDS_Shape *&from_shape,
1171 : : Curve* curve_to_split,
1172 : : const CubitVector& split_location,
1173 : : DLIList<Curve*>& created_curves )const;
1174 : :
1175 : : //- Removes all all unnessesary faces, curves, vertices and associated
1176 : : //- data from a refentity.
1177 : 0 : virtual CubitStatus test_regularize_entity( GeometryEntity *old_entity_ptr)
1178 : 0 : {return CUBIT_FAILURE; }
1179 : :
1180 : : int countEdges(TopoDS_Wire &wire);
1181 : : } ;
1182 : :
1183 : : #endif
|
