Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : GeometryModifyEngine.hpp
3 : : //
4 : : // Purpose : Define the interface for all solid model modify
5 : : // engines.
6 : : //
7 : : // Special Notes : This is an abstract base class.
8 : : //
9 : : // Creator : Tim Tautges
10 : : //
11 : : // Creation Date : 2/01
12 : : //
13 : : // Owner : Tim Tautges
14 : : //-------------------------------------------------------------------------
15 : :
16 : : #ifndef GEOMETRY_MODIFY_ENGINE_HPP
17 : : #define GEOMETRY_MODIFY_ENGINE_HPP
18 : :
19 : : #include "CubitDefines.h"
20 : : #include "GeometryDefines.h"
21 : : #include "CGMGeomConfigure.h"
22 : : #include "FacetShapeDefs.hpp"
23 : :
24 : : #include <map>
25 : : #include "CubitVector.hpp"
26 : :
27 : : class CubitPlane;
28 : : template <class X> class DLIList;
29 : :
30 : : class TopologyBridge;
31 : : class TBPoint;
32 : : class Curve;
33 : : class Surface;
34 : : class Lump;
35 : : class BodySM;
36 : : class LoopSM;
37 : : class GeometryEntity;
38 : : class GeometryQueryEngine;
39 : : class CubitBox;
40 : :
41 : 1715 : class CUBIT_GEOM_EXPORT GeometryModifyEngine
42 : : {
43 : :
44 : : public:
45 : :
46 [ - + ]: 1084 : virtual ~GeometryModifyEngine() {}
47 : : //- virtual destructor
48 : :
49 : : virtual bool supports_interoperability() = 0;
50 : : //- Returns whether intermixing of real and virtual geometry operations
51 : : //- is supported for the current geometry kernel.
52 : :
53 : 0 : virtual bool supports_facets() { return false; }
54 : : //- Returns whether creation of surfaces from facet data is supported
55 : :
56 : : virtual TBPoint* make_Point( CubitVector const& position ) const = 0;
57 : : //R TBPoint*
58 : : //R- Returned pointer to a TBPoint object.
59 : : //I position
60 : : //I- Input coordinates of the point to be created.
61 : : //- This function creates a TBPoint, given coordinates. The particular
62 : : //- type of TBPoint object that is created depends on the specific
63 : : //- modeling engine. For example, if the engine
64 : : //- is OCCGeometryEngine, then a PointOCC is created and returned.
65 : :
66 : : virtual Curve* make_Curve(Curve *curve_ptr,
67 : : std::map<TopologyBridge*, TopologyBridge*> *old_tb_to_new_tb = NULL) const = 0;
68 : : //- creates a curve from an existing curve. This creates totally
69 : : //- new topology. This function is useful for constructing geometry
70 : : //- from existing geometry.
71 : : //- The old_to_new_map is an optional parameter that maps all
72 : : //- the entities of the original to those of the copy.
73 : :
74 : : virtual Curve* make_Curve( TBPoint const* point1_ptr,
75 : : TBPoint const* point2_ptr,
76 : : Surface* ref_face_ptr,
77 : : const CubitVector *third_point = NULL) const = 0;
78 : : //- Create a curve exactly on the give ref_face.
79 : : //- Make sure the points are on the underlying surface.
80 : :
81 : : virtual Curve* make_Curve( DLIList<CubitVector*>& point_list,
82 : : DLIList<CubitVector*>& point_tangents) const = 0;
83 : :
84 : : virtual Curve* make_Curve( GeometryType curve_type,
85 : : TBPoint const* point1_ptr,
86 : : TBPoint const* point2_ptr,
87 : : DLIList<CubitVector*>& vector_list,
88 : : Surface* ref_face_ptr = NULL) const = 0;
89 : :
90 : : virtual Curve* make_Curve( GeometryType curve_type,
91 : : TBPoint const* point1_ptr,
92 : : TBPoint const* point2_ptr,
93 : : CubitVector const* intermediate_point_ptr) const = 0;
94 : : //R Curve*
95 : : //R- Returned pointer to a Curve object.
96 : : //I curve_type
97 : : //I- The type of curve to be created.
98 : : //I point1_ptr, point2_ptr
99 : : //I- Input end points of the curve to be created.
100 : : //I intermediate_point_ptr
101 : : //I- The coordinates of an intermediate point required for the
102 : : //I- generation of the curve.
103 : : //I vector_list
104 : : //I- Input list of CubitVectors. The new Curve interpolates these
105 : : //I- positions.
106 : : //I ref_face_ptr
107 : : //I- If the optional Surface pointer is provided, then the input
108 : : //I- locations (CubitVectors) are moved to the surface of the
109 : : //I- Surface before interpolation is done.
110 : : //I- NOTE: The end Points are *not* moved to the surface. Only the
111 : : //I- (intermediate) points are.
112 : : //- This function creates a Curve, of type, curve_type, given
113 : : //- the end points of the curve and an intermediate point or a set
114 : : //- of points to interpolate through.
115 : : //- The particular type of Curve object
116 : : //- that is created depends on the specific modeling engine. For
117 : : //- example, if the engine is OCCGeometryEngine, then a CurveOCC
118 : : //- is created and returned.
119 : : //-
120 : : //- NOTE on some hideous programming
121 : : //- This function not only creates the Curve, but also
122 : : //- creates the VGI entities Chain and CoVertexes that
123 : : //- will be connected up with the RefEdge. For the sake
124 : : //- of expediency we are assuming that this function is
125 : : //- called when RefEdge needs to be made from RefVertices.
126 : : //-
127 : : //- This function creates non-linear curves (e.g., elliptic and
128 : : //- parabolic curves. curve_type indicates what type of curve is
129 : : //- required.
130 : : //-
131 : : //- Elliptical:
132 : : //- The portion of the ellipse (circle) that is generated goes from
133 : : //- point1 to point2.
134 : : //-
135 : : //- Parabolic:
136 : : //- Construct a parabolic arc from 3 points. intermediate_point is the
137 : : //- peak of the parabola - in this case, the point which is equidistant
138 : : //- from the start and end points of the parabola. The 3 points must form
139 : : //- an isosceles triangle. This definition limits the user to generation
140 : : //- of the tip of parabolic shapes only.
141 : : virtual Curve* make_elliptical_Curve( TBPoint const* point1,
142 : : TBPoint const* point2,
143 : : CubitVector ¢er_point,
144 : : double start_angle,
145 : : double end_angle,
146 : : CubitSense sense) const;
147 : :
148 : :
149 : : virtual Surface* make_Surface(
150 : : Surface *old_surface_ptr,
151 : : std::map< TopologyBridge*, TopologyBridge* > *old_tb_to_new_tb = NULL ) const = 0;
152 : : //R Surface*
153 : : //R- Pointer to a newly created Surface object.
154 : : //R- old_to_new_map
155 : : //R- an optional parameter that maps all the entities of
156 : : //R- the original to those of the copy.
157 : : //I Surface*
158 : : //I- The surface from which we want to create a new one.
159 : : //- This function creates a new surface from an existing one.
160 : : //- The new surface is attached to geometry. The
161 : : //- goemetry is attached to a full data structure, loop, lump, bodies..
162 : :
163 : : virtual BodySM* make_extended_sheet( DLIList<Surface*> &surface_list,
164 : : CubitBox *clip_box = NULL,
165 : : bool preview = false ) const = 0;
166 : : //R BodySM*
167 : : //R- Pointer to a newly created BodySM object.
168 : : //I surface_list
169 : : //I- The surface_list from which we want to create an extended sheet.
170 : : //I clip_box
171 : : //I- An optional bounding box to clip the resultant sheet body by.
172 : : //I preview
173 : : //I- If true just draw the extended sheet instead of creating it
174 : : //- This function creates a sheet body by extending the input surfaces.
175 : : //- The result can be optionally clipped to fit inside of the given
176 : : //- bounding box.
177 : :
178 : : virtual Surface* make_Surface( GeometryType surface_type,
179 : : DLIList<Curve*>& curve_list,
180 : : Surface *old_surface_ptr = NULL,
181 : : bool check_edges = true ) const = 0;
182 : : //R Surface*
183 : : //R- Pointer to a newly created Surface object.
184 : : //I surface_type
185 : : //I- The type of surface to be created.
186 : : //I curve_list
187 : : //I- list of curves to be used as the bounds of the Surface
188 : : //- This function creates a Surface, of type, surface_type, given
189 : : //- the list of curves.
190 : : //- The particular type of Surface object created depends on the
191 : : //- specific modeling engine. For example, if the engine is
192 : : //- OCCGeometryEngine, then a SurfaceOCC is created.
193 : :
194 : : //virtual CubitStatus stitch_surfs(
195 : : // DLIList<BodySM*> &surf_bodies,
196 : : // BodySM *& stitched_Body )const= 0;
197 : : //I List of surface_bodys you want stitched together
198 : : //IO If stitching of FACEs is successful, stitched_Body is resultant BodySM.
199 : : // Means that all surfaces could be stitched together, forming a single BODY,
200 : : // but not a single FACE.
201 : : //returns CUBIT_SUCCESS if stitching was successful, other return FAILURE
202 : :
203 : : virtual Lump* make_Lump( DLIList<Surface*>& surface_list ) const = 0;
204 : : //R Lump*
205 : : //R- Pointer to a newly created Lump object.
206 : : //I lump_type
207 : : //I- The type of surface to be created.
208 : : //I surface_list
209 : : //I- list of surfaces to be used as the bounds of the Lump
210 : : //- This function creates a Lump, of type, lump_type, given
211 : : //- the list of surfaces.
212 : : //- The particular type of Lump object created depends on the
213 : : //- specific modeling engine. For example, if the engine is
214 : : //- OCCGeometryEngine, then a LumpOCC is created.
215 : : //-
216 : : //- NOTE on some hideous programming
217 : : //- This function not only creates the Lump, but also
218 : : //- creates the VGI entities Shell and CoFaces that
219 : : //- will be connected up with the RefVolume. For the sake
220 : : //- of expediency we are assuming that this function is
221 : : //- called when RefVolume needs to be made from Surfaces.
222 : : //-
223 : :
224 : : virtual BodySM* make_BodySM( Surface * ) const = 0;
225 : :
226 : : virtual BodySM* make_BodySM( DLIList<Lump*>& /*lump_list*/ ) const = 0;
227 : : //R BodySM*
228 : : //R- Pointer to a newly created BodySM object.
229 : : //I lump_list
230 : : //I- list of lumps to be used to create the BodySM
231 : : //- This function creates a BodySM given the list of lumps.
232 : : //- The particular type of BodySM object created depends on the
233 : : //- specific modeling engine. For example, if the engine is
234 : : //- OCCGeometryEngine, then a BodyOCC is created. Non-solid
235 : : //- model based engines can use the default implementation
236 : : //- to return a NULL pointer.
237 : : //-
238 : : //- NOTE on some hideous programming
239 : : //- This function not only creates the Lump, but also
240 : : //- creates the VGI entities CoVolumes that
241 : : //- will be connected up with the Body. For the sake
242 : : //- of expediency we are assuming that this function is
243 : : //- called when Body needs to be made from RefVolumes.
244 : : //-
245 : :
246 : : #ifdef KCM_MESH_TO_GEOM
247 : : virtual CubitStatus mesh2brep(std::vector<double> &xvals,
248 : : std::vector<double> &yvals,
249 : : std::vector<double> &zvals,
250 : : std::vector<unsigned int> &tri_connectivity,
251 : : DLIList<BodySM*> &new_body_sms) const = 0;
252 : : //I hex_list
253 : : //I- List of hexes input by user
254 : : //I tet_list
255 : : //I- List of tets input by user
256 : : //I face_list
257 : : //I- List of quad faces input by user
258 : : //I tri_list
259 : : //I- List of tris input by user
260 : : //R new_body_sms
261 : : //R- List of new BodySM pointers.
262 : : //- This function creates a real brep models from the mesh
263 : : //- entities. Any of the lists can be populated or filled
264 : : //- and the function will do what it can.
265 : : #endif
266 : :
267 : : //HEADER- Functions for creation of primitives
268 : : virtual BodySM* sphere(double radius) const = 0 ;
269 : : //R Body*
270 : : //R- A pointer to a newly created Body
271 : : //I radius
272 : : //I- Radius of the sphere
273 : : //- Creates a sphere and assigns it to a Body.
274 : : //- Returns pointer to the newly created body.
275 : :
276 : : virtual BodySM* brick ( double wid, double dep, double hi ) const = 0 ;
277 : : //R Body*
278 : : //R- A pointer to a newly created Body
279 : : //I wid
280 : : //I- Width of the brick
281 : : //I dep
282 : : //I- Depth of the brick
283 : : //I hi
284 : : //I- Height of the brick
285 : : //- Creates a cuboid and assigns it to a Body.
286 : : //- Returns pointer to the newly created body.
287 : :
288 : : virtual BodySM* brick( const CubitVector ¢er,
289 : : const CubitVector axes[3],
290 : : const CubitVector &extension) const = 0 ;
291 : : //R Body*
292 : : //R- A pointer to a newly created Body
293 : : //I center
294 : : //I- Center location of the brick
295 : : //I axes
296 : : //I- XYZ axes of brick
297 : : //I extension
298 : : //I- Size of brick, equivalent to 1/2 width, height, depth
299 : : //- Creates a cuboid and assigns it to a Body.
300 : : //- Returns pointer to the newly created body.
301 : :
302 : : virtual BodySM* prism( double height, int sides, double major,
303 : : double minor) const = 0 ;
304 : : //- Creates a prism and assigns it to a Body $
305 : : //- {height, major, minor} input height, major and minor radii. $
306 : : //- {sides} input number of sides. Must be >= 3.
307 : : //- Returns the ID of the new Body or CUBIT_FAILURE
308 : :
309 : : virtual BodySM* pyramid( double height, int sides, double major,
310 : : double minor, double top=0.0) const = 0 ;
311 : : //- Creates an pyramid and assigns it to a Body $
312 : : //- {height, major, minor} input height, major and minor radii. $
313 : : //- {sides} input number of sides. Must be >= 3.
314 : : //- {top} radius at top of pyramid.
315 : : //- Returns the ID of the new Body or CUBIT_FAILURE
316 : :
317 : : virtual BodySM* cylinder( double hi, double r1, double r2,
318 : : double r3 ) const = 0 ;
319 : : //- Creates an frustum and assigns it to a Body $
320 : : //- {hi} input height $
321 : : //- {r1} input radius in x-direction at base $
322 : : //- {r2} input radius in y-direction at base $
323 : : //- {r3} input radius in x-direction at top
324 : : //- Returns the ID of the new Body or CUBIT_FAILURE
325 : :
326 : : virtual BodySM* torus( double r1, double r2 ) const = 0 ;
327 : : //- Creates an torus and assigns it to a Body $
328 : : //- {r1} input major_radius $
329 : : //- {r2} input minor_radius
330 : : //- Returns the ID of the new Body or CUBIT_FAILURE
331 : :
332 : : virtual BodySM* planar_sheet ( const CubitVector& p1,
333 : : const CubitVector& p2,
334 : : const CubitVector& p3,
335 : : const CubitVector& p4 ) const = 0;
336 : : //- Creates a solid body consisting of a planar sheet (no volume)
337 : : //- {p1} - 1st corner of the sheet
338 : : //- {p2} - 2nd corner of the sheet
339 : : //- {p3} - 3rd corner of the sheet
340 : : //- {p4} - 4th corner of the sheet
341 : :
342 : : virtual BodySM* copy_body ( BodySM* body_sm,
343 : : std::map<TopologyBridge*, TopologyBridge*> *old_tb_to_new_tb = NULL ) const = 0;
344 : : //R Body*
345 : : //R- A pointer to the newly created body
346 : : //R- old_to_new_map
347 : : //R- an optional parameter that maps all the entities of
348 : : //R- the original to those of the copy.
349 : : //I bodyPtr
350 : : //I- A pointer to the body to be copied
351 : : //- This function makes a copy of the input Body and returns a
352 : : //- pointer to the newly created copy. The input Body and the newly
353 : : //- created Body are geometrically identical.
354 : :
355 : : virtual BodySM* create_body( VolumeFacets& volume, std::map<FacetShapes*, GeometryEntity*>& entity_map,
356 : : const FacetPointSet& points, int interp_order) const = 0;
357 : : //- creates a body with a volume from facet data
358 : : //- VolumeFacets is populated with return data to associate sets of facets with newly created geometry entities
359 : :
360 : : //HEADER- Functions for boolean operations
361 : :
362 : : virtual CubitStatus subtract(DLIList<BodySM*> &tool_body_list,
363 : : DLIList<BodySM*> &from_bodies,
364 : : DLIList<BodySM*> &new_bodies,
365 : : bool imprint = false,
366 : : bool keep_old = false) const = 0;
367 : :
368 : : virtual CubitStatus imprint(BodySM* BodyPtr1, BodySM* BodyPtr2,
369 : : BodySM*& newBody1, BodySM*& newBody2,
370 : : bool keep_old) const = 0;
371 : :
372 : : virtual CubitStatus imprint(DLIList<BodySM*> &from_body_list,
373 : : DLIList<BodySM*> &new_from_body_list,
374 : : bool keep_old,
375 : : DLIList<TopologyBridge*> *new_tbs = NULL,
376 : : DLIList<TopologyBridge*> *att_tbs = NULL) const = 0;
377 : :
378 : : virtual CubitStatus imprint( DLIList<BodySM*> &body_list,
379 : : DLIList<Curve*> &ref_edge_list,
380 : : DLIList<BodySM*>& new_body_list,
381 : : DLIList<TopologyBridge*> &temporary_bridges,
382 : : bool keep_old_body,
383 : : bool show_messages= true) const = 0;
384 : : //- Imprints a list of Bodies with a list of RefEdges. All
385 : : //- entities must be entities. Useful for splitting
386 : : //- surfaces. If edge pierces a surface a hardpoint will
387 : : //- result at the pierce location.
388 : :
389 : : virtual CubitStatus imprint( DLIList<Surface*> &ref_face_list,
390 : : DLIList<Curve*> &ref_edge_list,
391 : : DLIList<TopologyBridge*> &temporary_bridges,
392 : : DLIList<BodySM*>& new_body_list,
393 : : bool keep_old_body ) const = 0;
394 : : //- Imprints a list of Surfaces with a list of RefEdges. This is
395 : : //- useful if the user has a curve which spans several surfaces on
396 : : //- a body and only wants to imprint to selected surfaces. Algorithm
397 : : //- does not support imprinting to free surfaces.
398 : :
399 : : virtual CubitStatus imprint( DLIList<Surface*> &surface_list,
400 : : DLIList<DLIList<Curve*>*> &curve_lists_list,
401 : : BodySM*& new_body,
402 : : bool keep_old_body,
403 : : bool expand = true,
404 : : DLIList<TopologyBridge*> *new_tbs = NULL,
405 : : DLIList<TopologyBridge*> *att_tbs = NULL ) const = 0;
406 : : //- Imprints a list of Surfaces with list of Curves, sorted per
407 : : //- Surface (ie., curve_lists_list is same length as surface_list).
408 : : //- All input surfaces must be from the same body.
409 : :
410 : : virtual CubitStatus imprint( DLIList<BodySM*> &body_list,
411 : : DLIList<CubitVector> &vector_list,
412 : : DLIList<BodySM*>& new_body_list,
413 : : bool keep_old_body,
414 : : DLIList<TopologyBridge*> *new_tbs = NULL,
415 : : DLIList<TopologyBridge*> *att_tbs = NULL,
416 : : double *tol_in = NULL,
417 : : bool clean_up_slivers = true) const = 0;
418 : : //- Imprints a list of bodies with a list of vectors. Useful for
419 : : //- splitting curves and creating hardpoints on surfaces.
420 : :
421 : : virtual CubitStatus tolerant_imprint(DLIList<Surface*> &surfs_in,
422 : : DLIList<BodySM*> &new_bodysm_list) const = 0;
423 : : virtual CubitStatus tolerant_imprint_surface_with_curves(
424 : : Surface *surface_to_imprint,
425 : : DLIList<Curve*> &curves,
426 : : DLIList<TopologyBridge*> &temporary_bridges,
427 : : BodySM *&new_body,
428 : : DLIList<TopologyBridge*> *new_tbs = NULL,
429 : : DLIList<TopologyBridge*> *att_tbs = NULL ) const = 0;
430 : :
431 : : virtual CubitStatus tolerant_imprint( DLIList<BodySM*> &bodies_in,
432 : : DLIList<BodySM*> &new_bodies,
433 : : double overlap_tol,
434 : : double imprint_tol,
435 : : DLIList<TopologyBridge*> *new_tbs = NULL,
436 : : DLIList<TopologyBridge*> *att_tbs = NULL ) const = 0;
437 : :
438 : : virtual CubitStatus imprint_projected_edges(
439 : : DLIList<Surface*> &ref_face_list,
440 : : DLIList<Curve*> &ref_edge_list,
441 : : DLIList<BodySM*>& new_body_list,
442 : : DLIList<Curve*>& kept_free_edges,
443 : : bool keep_old_body,
444 : : bool keep_free_edges) const = 0;
445 : : //- Imprints a list of Surfaces with a list of projected RefEdges.
446 : :
447 : : virtual CubitStatus imprint_projected_edges(
448 : : DLIList<Surface*> &ref_face_list,
449 : : DLIList<BodySM*> &body_list,
450 : : DLIList<Curve*> &ref_edge_list,
451 : : DLIList<BodySM*>& new_body_list,
452 : : bool keep_old_body,
453 : : bool keep_free_edges) const = 0;
454 : : //- Imprints a list of Bodies with a list of RefEdges which are projected
455 : : //- to a list of Surfaces
456 : : virtual CubitStatus remove_topology(DLIList<Curve*> &curves_to_remove,
457 : : DLIList<Surface*> &surfs_to_remove,
458 : : double backoff_distance,
459 : : double small_edge_size,
460 : : DLIList<BodySM*> &new_bodysm_list,
461 : : CubitBoolean preview) const = 0;
462 : :
463 : : virtual CubitStatus project_edges(
464 : : DLIList<Surface*> &ref_face_list,
465 : : DLIList<Curve*> &ref_edge_list_in,
466 : : DLIList<Curve*> &ref_edge_list_new,
467 : : bool print_error = true ) const = 0;
468 : : //- Projects list RefEdges to a list of Surfaces
469 : :
470 : : virtual CubitStatus curve_surface_intersection( Surface *surface,
471 : : Curve* curve,
472 : : DLIList<Curve*> &new_curves ) const = 0;
473 : :
474 : : virtual CubitStatus intersect(BodySM* tool_body_ptr,
475 : : DLIList<BodySM*> &from_bodies,
476 : : DLIList<BodySM*> &new_bodies,
477 : : bool keep_old = false,
478 : : bool preview = false ) const = 0;
479 : : //R CubitStatus
480 : : //R- CUBIT_SUCCESS/CUBIT_FAILURE
481 : : //I BodyPtr1, BodyPtr2
482 : : //I- Two Body pointers that will be Booleaned
483 : : //O newBody (or newBody1, newBody2 for imprint)
484 : : //O- The new Body build by boolean operation on two Bodys.
485 : : //O- for imprint, the output is two Bodies.
486 : : //- These functions perform boolean operations on two Bodys and
487 : : //- return the result through the output arguments. If the
488 : : //- boolean operations fails at any stage, a NULL value is assigned
489 : : //- to the output argument(s) and the function returns
490 : : //- CUBIT_FAILURE. If everything goes well, the function returns
491 : : //- CUBIT_SUCCESS. The original Bodys are left untouched during the
492 : : //- boolean operation. The boolean operation is carried out on
493 : : //- copies of the original Bodys.
494 : :
495 : : virtual CubitStatus chop( DLIList<BodySM*> &bodies,
496 : : DLIList<BodySM*> &intersectBodies,
497 : : DLIList<BodySM*> &outsideBodies,
498 : : BodySM*& leftoversBody,
499 : : bool keep_old = false,
500 : : bool nonreg = false) const = 0;
501 : : //R CubitStatus
502 : : //R-the result of the chop operation: Success or Failure
503 : : //I bodies
504 : : //I-DLIList<Body*>: a list of Body pointers that will be united
505 : : //O intersectBody, outsideBody, leftoversBody
506 : : //O- new Bodies build by chop operation on the list of Body pointers.
507 : : //- This function performs a chop of a tool body on a blank body and returns
508 : : //- the result through the output argument intersectBody, outsideBody, leftoversBody. If the chop
509 : : //- operation went through OK, the function returns CUBIT_SUCCESS. If,
510 : : //- for some reason, the chop operation did not go well, the output
511 : : //- argument is assigned a NULL value and the function returns
512 : : //- CUBIT_FAILURE. In either case, the original Bodys are left
513 : : //- untouched.
514 : :
515 : :
516 : : virtual CubitStatus thicken( DLIList<BodySM*>& bodies,
517 : : DLIList<BodySM*>& new_body_list,
518 : : double depth,
519 : : bool both = false) const = 0;
520 : : //R CubitStatus
521 : : //R-the result of the thicken operation: Success or Failure
522 : : //I bodies
523 : : //I-DLIList<Body*>: a list of Body pointers that will be thicken
524 : : //O intersectBody, outsideBody, leftoversBody
525 : : //O- new Bodies build by thicken operation on the list of Body pointers.
526 : : //- This function performs a thicken of sheet bodies and returns
527 : : //- the result through the output argument in_out_body. If the thicken
528 : : //- operation went through OK, the function returns CUBIT_SUCCESS. If,
529 : : //- for some reason, the thicken operation did not go well, the output
530 : : //- argument is assigned a NULL value and the function returns
531 : : //- CUBIT_FAILURE.
532 : :
533 : : virtual CubitStatus flip_normals( DLIList<Surface*>& face_list ) const = 0;
534 : : //R CubitStatus
535 : : //R-the result of the flip_normal operation: Success or Failure
536 : : //I bodies
537 : : //I-DLIList<Surface*>: a list of Face pointers that will be fliped
538 : : //O- If the flip operation went through OK, the function returns CUBIT_SUCCESS. If,
539 : : //- for some reason, the flip operation did not go well, the output
540 : : //- returns CUBIT_FAILURE.
541 : :
542 : : virtual CubitStatus hollow(DLIList<BodySM*>& bodies,
543 : : DLIList<Surface*>& surfs_to_remove,
544 : : DLIList<BodySM*>& new_bodies,
545 : : double depth) const = 0;
546 : : //R CubitStatus
547 : : //R-the result of the hollow operation: Success or Failure
548 : : //I body
549 : : //I- for OCC: a list of solid BodySM's that will be hollowed into a list of
550 : : //I- thick solids.
551 : : //I- surfs_to_remove: the faces to be removed from the original solid (OCC).
552 : : //O- new Bodies build by hollow operation on the body pointers.
553 : : //- This function performs a hollow of solid body and returns
554 : : //- the result through the output argument in_out_body. If the hollow
555 : : //- operation went through OK, the function returns CUBIT_SUCCESS. If,
556 : : //- for some reason, the hollow operation did not go well, the output
557 : : //- argument is assigned a NULL value and the function returns
558 : : //- CUBIT_FAILURE.
559 : :
560 : : virtual void get_possible_invalid_tbs(DLIList<TopologyBridge*> &bridges_in,
561 : : DLIList<TopologyBridge*> &bridges_out) = 0;
562 : : virtual CubitStatus unite( DLIList<BodySM*> &bodies,
563 : : DLIList<BodySM*> &newBodies,
564 : : bool keep_old = false) const = 0;
565 : : //R CubitStatus
566 : : //R- CUBIT_SUCCESS/CUBIT_FAILURE
567 : : //I bodies
568 : : //I- A list of Bodys that will be united
569 : : //O newBody
570 : : //O- The new Body built by the unite operation on the list of Bodys.
571 : : //- This function performs a unite of a list of Bodys and returns
572 : : //- the result through the output argument, "newBody". If the unite
573 : : //- operation went through OK, the function returns CUBIT_SUCCESS. If,
574 : : //- for some reason, the unite operation did not go well, the output
575 : : //- argument is assigned a NULL value and the function returns
576 : : //- CUBIT_FAILURE. In either case, the original Bodys are left
577 : : //- untouched.
578 : :
579 : : //HEADER- Sweep-related functions. All of these are implemented only for
580 : : //HEADER- RefEntities whose underlying geometry is represented by a solid
581 : : //HEADER- model such as occ.
582 : :
583 : : virtual CubitStatus sweep_translational(
584 : : DLIList<GeometryEntity*>& ref_ent_list,
585 : : DLIList<BodySM*>& result_body_list,
586 : : const CubitVector& sweep_vector,
587 : : double draft_angle,
588 : : int draft_type,
589 : : bool switchside,
590 : : bool rigid,
591 : : bool anchor_entity=CUBIT_FALSE,
592 : : bool keep_old=CUBIT_FALSE ) const = 0;
593 : :
594 : : virtual CubitStatus sweep_helical(
595 : : DLIList<GeometryEntity*>& ref_ent_list,
596 : : DLIList<BodySM*>& result_body_list,
597 : : CubitVector &location,
598 : : CubitVector &direction,
599 : : double &thread_distance,
600 : : double &angle,
601 : : bool right_handed,
602 : : bool anchor_entity=CUBIT_FALSE,
603 : : bool keep_old=CUBIT_FALSE ) const;
604 : :
605 : : virtual CubitStatus sweep_perpendicular(
606 : : DLIList<GeometryEntity*>& ref_ent_list,
607 : : DLIList<BodySM*>& result_body_list,
608 : : double distance,
609 : : double draft_angle,
610 : : int draft_type,
611 : : bool switchside,
612 : : bool rigid,
613 : : bool anchor_entity=CUBIT_FALSE,
614 : : bool keep_old=CUBIT_FALSE ) const = 0;
615 : :
616 : : virtual CubitStatus sweep_rotational(
617 : : DLIList<GeometryEntity*>& ref_ent_list,
618 : : DLIList<BodySM*>& result_body_list,
619 : : const CubitVector& point,
620 : : const CubitVector& direction,
621 : : double angle,
622 : : int steps = 0,
623 : : double draft_angle = 0.0,
624 : : int draft_type = 0,
625 : : bool switchside = false,
626 : : bool make_solid = false,
627 : : bool rigid = false,
628 : : bool anchor_entity=CUBIT_FALSE,
629 : : bool keep_old=CUBIT_FALSE ) const = 0;
630 : :
631 : : virtual CubitStatus sweep_along_curve(
632 : : DLIList<GeometryEntity*>& ref_ent_list,
633 : : DLIList<BodySM*>& result_body_list,
634 : : DLIList<Curve*>& ref_edge_list,
635 : : double draft_angle = 0.0,
636 : : int draft_type = 0,
637 : : bool rigid = false,
638 : : bool anchor_entity=CUBIT_FALSE,
639 : : bool keep_old=CUBIT_FALSE ) const= 0;
640 : :
641 : : virtual CubitStatus sweep_to_body(
642 : : DLIList<Curve*> curve_list,
643 : : BodySM *target_body,
644 : : CubitVector distance,
645 : : DLIList<BodySM*> &new_bodies,
646 : : bool unite) const = 0;
647 : : virtual CubitStatus sweep_to_body(
648 : : Surface *source_surface,
649 : : BodySM *target_body,
650 : : CubitVector distance,
651 : : DLIList<BodySM*> &new_bodies ) const = 0;
652 : :
653 : :
654 : : virtual CubitStatus scale( BodySM *&body, const CubitVector& factors ) = 0;
655 : :
656 : : //HEADER- Webcut-related functions
657 : : virtual CubitStatus webcut( DLIList<BodySM*>& webcut_body_list,
658 : : const CubitVector &v1,
659 : : const CubitVector &v2,
660 : : const CubitVector &v3,
661 : : DLIList<BodySM*>& neighbor_imprint_list,
662 : : DLIList<BodySM*>& results_list,
663 : : ImprintType imprint_type = NO_IMPRINT,
664 : : bool preview = false) const = 0;
665 : : //R int
666 : : //R- Number of bodies that were webcut ( >= 0 )
667 : : //I webcut_body_list
668 : : //I- The list of bodies to be webcut
669 : : //I plane
670 : : //I- The plane to be used for webcutting.
671 : : //I merge
672 : : //I- A flag to decide whether the new bodies created by the
673 : : //I- webcutting process should be merged or not.
674 : : //I imprint
675 : : //I- A flag to decide whether the new bodies created by the
676 : : //I- webcutting process should be imprinted or not.
677 : : //- This function webcuts a list of bodies through a plane.
678 : : //- The newly created bodies are merged and imprinted depeding on
679 : : //- the respective flags.
680 : :
681 : : virtual CubitStatus webcut(DLIList<BodySM*>& webcut_body_list,
682 : : BodySM const* tool_body,
683 : : DLIList<BodySM*>& neighbor_imprint_list,
684 : : DLIList<BodySM*>& results_list,
685 : : ImprintType imprint_type = NO_IMPRINT,
686 : : bool preview = false) const = 0 ;
687 : : //R int
688 : : //R- Number of bodies that were webcut ( >= 0 )
689 : : //I webcut_body_list
690 : : //I- The list of bodies to be webcut
691 : : //I tool_body
692 : : //I- The body to be used for webcutting.
693 : : //I merge
694 : : //I- A flag to decide whether the new bodies created by the
695 : : //I- webcutting process should be merged or not.
696 : : //I imprint
697 : : //I- A flag to decide whether the new bodies created by the
698 : : //I- webcutting process should be imprinted or not.
699 : : //- This function webcuts a list of bodies using another body
700 : : //- as the webcutting tool. The newly created bodies are
701 : : //- merged and imprinted depeding on the respective flags.
702 : :
703 : : virtual CubitStatus webcut_across_translate(
704 : : DLIList<BodySM*>& body_list,
705 : : Surface* plane_surf1,
706 : : Surface* plane_surf2,
707 : : DLIList<BodySM*>& neighbor_imprint_list,
708 : : DLIList<BodySM*>& results_list,
709 : : ImprintType imprint_type = NO_IMPRINT,
710 : : bool preview = false) const = 0;
711 : :
712 : :
713 : : //- R status
714 : : //- R-results_list of bodies affected, or created from webcut.
715 : : //- I- Bodies to be webcut, plane to define cuts, and imprint merge flags.
716 : : //- This is an experimental function, hooked to the Cat GUI for making
717 : : //- bodies one to one sweeps.
718 : :
719 : : virtual CubitStatus webcut_with_sheet(DLIList<BodySM*>& webcut_body_list,
720 : : BodySM *sheet_body,
721 : : DLIList<BodySM*>& neighbor_imprint_list,
722 : : DLIList<BodySM*> &new_bodies,
723 : : ImprintType imprint_type = NO_IMPRINT,
724 : : bool preview = false) = 0;
725 : : //- webcuts a body using a sheet body.
726 : : //- It splits the sheet into two single sided bodies.
727 : : //- it then subtracts this with the webcut body.
728 : : //- The result is splitting the webcut_body into halves.
729 : : //- if the webcut body is a topological torus, this routine
730 : : //- will fail...
731 : :
732 : : virtual CubitStatus webcut_with_extended_sheet(
733 : : DLIList<BodySM*> &webcut_body_list,
734 : : DLIList<Surface*> &surface_list,
735 : : DLIList<BodySM*>& neighbor_imprint_list,
736 : : DLIList<BodySM*> &new_bodies,
737 : : int &num_cut,
738 : : ImprintType imprint_type = NO_IMPRINT,
739 : : bool preview = false) = 0;
740 : : //- creates a sheet by extending the given surfaces then webcuts using
741 : : //- this sheet.(see webcut_with_sheet).
742 : :
743 : : virtual CubitStatus webcut_with_sweep_surfaces(
744 : : DLIList<BodySM*> &blank_bodies,
745 : : DLIList<Surface*> &surfaces,
746 : : const CubitVector& sweep_vector,
747 : : bool sweep_perp,
748 : : bool through_all,
749 : : bool outward,
750 : : bool up_to_next,
751 : : Surface *stop_surf,
752 : : Curve *curve_to_sweep_along,
753 : : DLIList<BodySM*>& neighbor_imprint_list,
754 : : DLIList<BodySM*> &results_list,
755 : : ImprintType imprint_type = NO_IMPRINT,
756 : : CubitBoolean preview = false) = 0;
757 : :
758 : : virtual CubitStatus webcut_with_sweep_curves(
759 : : DLIList<BodySM*> &blank_bodies,
760 : : DLIList<Curve*> &curves,
761 : : const CubitVector& sweep_vector,
762 : : bool through_all,
763 : : Surface *stop_surf,
764 : : Curve *curve_to_sweep_along,
765 : : DLIList<BodySM*>& neighbor_imprint_list,
766 : : DLIList<BodySM*> &results_list,
767 : : ImprintType imprint_type = NO_IMPRINT,
768 : : CubitBoolean preview = false) = 0;
769 : :
770 : : virtual CubitStatus webcut_with_sweep_curves_rotated(
771 : : DLIList<BodySM*> &blank_bodies,
772 : : DLIList<Curve*> &curves,
773 : : const CubitVector &point,
774 : : const CubitVector &sweep_axis,
775 : : double angle,
776 : : Surface *stop_surf,
777 : : DLIList<BodySM*>& neighbor_imprint_list,
778 : : DLIList<BodySM*> &results_list,
779 : : ImprintType imprint_type = NO_IMPRINT,
780 : : CubitBoolean preview = false) = 0;
781 : :
782 : : virtual CubitStatus webcut_with_sweep_surfaces_rotated(
783 : : DLIList<BodySM*> &blank_bodies,
784 : : DLIList<Surface*> &surfaces,
785 : : const CubitVector &point,
786 : : const CubitVector &sweep_axis,
787 : : double angle,
788 : : Surface *stop_surf,
789 : : bool up_to_next,
790 : : DLIList<BodySM*>& neighbor_imprint_list,
791 : : DLIList<BodySM*> &results_list,
792 : : ImprintType imprint_type = NO_IMPRINT,
793 : : CubitBoolean preview = false) = 0;
794 : :
795 : : virtual CubitStatus webcut_with_cylinder(
796 : : DLIList<BodySM*> &webcut_body_list, double radius,
797 : : const CubitVector &axis,
798 : : const CubitVector ¢er,
799 : : DLIList<BodySM*>& neighbor_imprint_list,
800 : : DLIList<BodySM*>& results_list,
801 : : ImprintType imprint_type = NO_IMPRINT,
802 : : CubitBoolean preview = false) = 0;
803 : : //- webcuts a body using a cylinder give the input parameters.
804 : :
805 : : virtual CubitStatus webcut_with_brick(
806 : : DLIList<BodySM*>& webcut_body_list,
807 : : const CubitVector ¢er,
808 : : const CubitVector axes[3],
809 : : const CubitVector &extension,
810 : : DLIList<BodySM*>& neighbor_imprint_list,
811 : : DLIList<BodySM*> &results_list,
812 : : ImprintType imprint_type = NO_IMPRINT,
813 : : CubitBoolean preview = false) = 0;
814 : : /**< Webcuts the bodies in the list with a cutting brick.
815 : : * The brick is created by the given parameters - center of
816 : : * brick, xyz axes, and extension. Extension is 1/2 width,
817 : : * height and depth. If one of the brick dimensions is zero
818 : : * the resultant planar sheet is used to webcut (webcut_with_
819 : : * planar_sheet is called). Brick creation is done in the
820 : : * solid modeling engine to reduce the impact on body ids.
821 : : */
822 : :
823 : : virtual CubitStatus webcut_with_planar_sheet(
824 : : DLIList<BodySM*>& webcut_body_list,
825 : : const CubitVector ¢er,
826 : : const CubitVector axes[2],
827 : : double width, double height,
828 : : DLIList<BodySM*>& neighbor_imprint_list,
829 : : DLIList<BodySM*> &results_list,
830 : : ImprintType imprint_type = NO_IMPRINT,
831 : : bool preview = false) = 0;
832 : : /**< Webcuts the bodies in the list with a cutting planar sheet.
833 : : * The sheet is created by the given parameters - center of
834 : : * sheet, xy axes, and width and height. Sheet creation is done
835 : : * in the solid modeling engine to reduce the impact on body ids.
836 : : */
837 : :
838 : : virtual CubitStatus webcut_with_curve_loop(
839 : : DLIList<BodySM*> &webcut_body_list,
840 : : DLIList<Curve*> &ref_edge_list,
841 : : DLIList<BodySM*>& neighbor_imprint_list,
842 : : DLIList<BodySM*>& results_list,
843 : : ImprintType imprint_type = NO_IMPRINT,
844 : : bool preview = false) = 0;
845 : : //- webcuts a body list using a temp sheet body created from the curve loop
846 : :
847 : :
848 : : virtual CubitStatus section( DLIList<BodySM*> §ion_body_list,
849 : : const CubitVector &point_1,
850 : : const CubitVector &point_2,
851 : : const CubitVector &point_3,
852 : : DLIList<BodySM*>& new_body_list,
853 : : bool keep_normal_side,
854 : : bool keep_old = false,
855 : : bool keep_both_sides = false) = 0;
856 : : //- Section will cut a list a bodies and keep a side of the bodies.
857 : : //- The bodies are cut with a planar surface (surface will be extended).
858 : :
859 : : virtual CubitStatus split_body( BodySM *body_ptr,
860 : : DLIList<BodySM*> &new_bodies ) = 0;
861 : : //- Splits a body with multiple volumes into multiple bodies
862 : : //- each having only one volume.
863 : :
864 : : virtual CubitStatus split_free_curve( Curve *curve,
865 : : DLIList<CubitVector> &split_locations,
866 : : DLIList<Curve*> &new_curves );
867 : :
868 : : virtual CubitStatus separate_surfaces( DLIList<Surface*> &surf_list,
869 : : DLIList<BodySM*> &new_bodies ) = 0;
870 : : //- Separates surfaces from sheet bodies into separate bodies. Connected
871 : : //- surfaces will remain connected but be placed in a new body.
872 : :
873 : : virtual CubitStatus reverse_body( BodySM *body_to_reverse ) = 0;
874 : : //- Reverse body (turn it inside-out).
875 : :
876 : : virtual CubitStatus split_periodic( BodySM *body_ptr,
877 : : BodySM *&new_body ) = 0;
878 : : //- Splits the periodic surfaces along the 0 and PI/2's periods.
879 : :
880 : : virtual CubitStatus regularize_body( BodySM *body_ptr,
881 : : BodySM *&new_body_ptr ) = 0;
882 : : //- Removes all unnecessary faces, edges and vertices from the body.
883 : :
884 : : virtual CubitStatus regularize_entity( GeometryEntity *old_entity_ptr,
885 : : BodySM *&new_body_ptr) = 0;
886 : : //- Removes all all unnessesary faces, curves, vertices and associated
887 : : //- data from a refentity.
888 : : virtual CubitStatus test_regularize_entity( GeometryEntity *old_entity_ptr) = 0;
889 : :
890 : : virtual CubitStatus offset_curves( DLIList<Curve*>& ref_edge_list,
891 : : DLIList<Curve*>& result_curve_list,
892 : : double offset_distance,
893 : : const CubitVector& offset_direction,
894 : : int gap_type = 1 ) = 0;
895 : : //- Creates curves offset from a chain of curves. The offset direction is
896 : : //- only used if there is one linear curve. Otherwise, the offset direction
897 : : //- is calculated by occ (the cross product of the wires tangent and the
898 : : //- planar normal). The gap type is 0 - rounded, 1 - extended, 2 - natural.
899 : :
900 : : virtual CubitStatus split_curve( Curve* curve_to_split,
901 : : const CubitVector& split_location,
902 : : DLIList<Curve*>& created_curves ) = 0;
903 : : //- Splits a curve at the specified location.
904 : : //- the single passed in curve is split into two curves at the split location
905 : : //- the two resulting curves are added to the passed in list
906 : :
907 : :
908 : : virtual Curve* trim_curve( Curve* trim_curve,
909 : : const CubitVector& trim_vector,
910 : : const CubitVector& keep_vector,
911 : : bool keep_old = false ) = 0;
912 : : //- Trims or extends a curve, up to the trim_vector. If trimming, the
913 : : //- keep_vector determines which side of the curve to keep. If the curve
914 : : //- is not free, the curve is automatically copied before trimming (so
915 : : //- a new curve results).
916 : :
917 : : virtual CubitStatus create_solid_bodies_from_surfs(
918 : : DLIList<Surface*> &ref_face_list,
919 : : DLIList<BodySM*> &new_bodies,
920 : : bool keep_old = false,
921 : : bool heal = true,
922 : : bool sheet = false ) const = 0;
923 : : //- Creates a single body from a set of faces. The faces can only be attached
924 : : //- to bodies if they are sheet bodies. It is assumed that the calling code will
925 : : //- check for this, ie GeometryTool.
926 : :
927 : : virtual Curve* create_arc(const CubitVector& position,
928 : : double radius,
929 : : double start_angle,
930 : : double end_angle,
931 : : CubitVector plane,
932 : : CubitBoolean preview = CUBIT_FALSE )=0;
933 : :
934 : : virtual Curve* create_arc_radius(const CubitVector ¢er,
935 : : TBPoint* ref_vertex_start,
936 : : TBPoint* ref_vertex_end,
937 : : const CubitVector &normal,
938 : : double radius,
939 : : bool full = false,
940 : : CubitBoolean preview = CUBIT_FALSE )=0;
941 : :
942 : : virtual Curve* create_arc_three( TBPoint* pt1,
943 : : TBPoint* pt2,
944 : : TBPoint* pt3,
945 : : bool full = false,
946 : : CubitBoolean preview = CUBIT_FALSE ) = 0;
947 : : virtual Curve* create_arc_three( Curve* curve1,
948 : : Curve* curve2,
949 : : Curve* curve3,
950 : : bool full = false,
951 : : CubitBoolean preview = CUBIT_FALSE ) = 0;
952 : :
953 : : virtual Curve* create_arc_center_edge( TBPoint* point1,
954 : : TBPoint* point2,
955 : : TBPoint* point3,
956 : : const CubitVector &normal,
957 : : double radius = CUBIT_DBL_MAX,
958 : : bool full = false,
959 : : CubitBoolean preview = CUBIT_FALSE ) = 0;
960 : :
961 : : //- Methods to create arcs. First uses 3 points on arc, next creates arc
962 : : //- tangent to 3 curves, last creates arc using center and two points on arc.
963 : : //- If full option is specified, a full circle is created.
964 : :
965 : : virtual CubitStatus create_curve_combine( DLIList<Curve*>& curve_list,
966 : : Curve *&new_curve_ptr ) = 0;
967 : : //- Uses the solid modeller to create a new RefEdge that is a combination
968 : : //- of the input chain of edges.
969 : : //-
970 : :
971 : : virtual Curve* create_curve_helix( CubitVector &location,
972 : : CubitVector &direction,
973 : : CubitVector &start_point,
974 : : double &thread_distance,
975 : : double &angle,
976 : : bool right_handed) const;
977 : :
978 : :
979 : : virtual GeometryQueryEngine *get_gqe() = 0;
980 : : /**< all gme's should be able to return a gqe
981 : : */
982 : :
983 : 0 : virtual CubitBoolean is_modify_engine(const TopologyBridge *) const
984 : 0 : {return CUBIT_FALSE;};
985 : : /**< return CUBIT_TRUE if the tb_ptr belongs to this modify engine
986 : : */
987 : :
988 : : virtual CubitStatus get_offset_intersections(
989 : : Curve* ref_edge1,
990 : : Curve* ref_edge2,
991 : : DLIList<CubitVector>& intersection_list,
992 : : double offset = 0.0,
993 : : bool ext_first = true ) = 0;
994 : : //- Finds the intersections of a certain distance (offset) between two
995 : : //- curves. The two curves must lie in a plane. The first curve is offset
996 : : //- the offset distance in both directions, and the bounded intersections with
997 : : //- the second curve are found. The first curve and optionally be extended
998 : : //- to infinity for the intersection calculation. The intent of the function
999 : : //- is so that the user can create a point on a curve a certain distance
1000 : : //- from another curve, as in specifying a reference location for a gage
1001 : : //- diameter on an arc in an engineering drawing.
1002 : :
1003 : : virtual CubitStatus get_offset_intersections(
1004 : : Curve* ref_edge_ptr,
1005 : : Surface* ref_face_ptr,
1006 : : DLIList<CubitVector> &intersection_list,
1007 : : double offset = 0.0,
1008 : : bool ext_surf = true ) = 0;
1009 : : //- Finds intersections (points) of the curve and surface. The surface can
1010 : : //- be offset - it is offset to each side and intersections are found. By
1011 : : //- default the surface is extended to infinity (if possible) and the
1012 : : //- intersections are found. The function allocates the CubitVectors in
1013 : : //- the returned list, so be sure to free them.
1014 : :
1015 : : virtual CubitStatus surface_intersection( Surface *surface1_ptr,
1016 : : Surface *surface2_ptr,
1017 : : DLIList<Curve*> &inter_graph,
1018 : : const double tol) const = 0;
1019 : : //- Finds the intersection of two bodies defined by the curves of the
1020 : : //- intersection graph.
1021 : :
1022 : : virtual CubitStatus get_mid_plane( const CubitVector &point_1,
1023 : : const CubitVector &point_2,
1024 : : const CubitVector &point_3,
1025 : : BodySM *body_to_trim_to,
1026 : : BodySM *&midplane_body ) const = 0;
1027 : : //- Finds the mid plane described by the 3 points and trims
1028 : : //- it to the body. It returns the mid planes as part of the
1029 : : //- midplane_body
1030 : :
1031 : : virtual CubitStatus get_spheric_mid_surface( Surface *surface_ptr1,
1032 : : Surface *surface_ptr2,
1033 : : BodySM *body_to_trim_to,
1034 : : BodySM *&midsurface_body ) const = 0;
1035 : :
1036 : : virtual CubitStatus get_conic_mid_surface( Surface *surface_ptr1,
1037 : : Surface *surface_ptr2,
1038 : : BodySM *body_to_trim_to,
1039 : : BodySM *&midsurface_body ) const = 0;
1040 : :
1041 : : virtual CubitStatus get_toric_mid_surface( Surface *surface_ptr1,
1042 : : Surface *surface_ptr2,
1043 : : BodySM *body_to_trim_to,
1044 : : BodySM *&midsurface_body ) const = 0;
1045 : :
1046 : : virtual CubitStatus tweak_bend( DLIList<BodySM*> &bend_bodies,
1047 : : DLIList<BodySM*> &new_bodysm_list,
1048 : : CubitVector& neutral_root,
1049 : : CubitVector& bend_axis,
1050 : : CubitVector& bend_direction,
1051 : : double radius,
1052 : : double angle,
1053 : : DLIList<CubitVector>& bend_regions,
1054 : : double width = -1,
1055 : : CubitBoolean center_bend = CUBIT_FALSE,
1056 : : int num_points = 0,
1057 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1058 : : CubitBoolean preview = CUBIT_FALSE ) const = 0;
1059 : :
1060 : : virtual CubitStatus tweak_chamfer( DLIList<Curve*> &curve_list,
1061 : : double left_offset,
1062 : : DLIList<BodySM*> &new_bodysm_list,
1063 : : double right_offset = -1.0,
1064 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1065 : : CubitBoolean preview = CUBIT_FALSE ) const = 0;
1066 : : /**< Chamfer curves on solid bodies. The left and right offsets are with
1067 : : * respect to the curve direction. If the given right offset is negative,
1068 : : * the left offset is used. Users can preview to clarify the meaning of
1069 : : * left and right.
1070 : : */
1071 : :
1072 : : virtual CubitStatus tweak_chamfer( DLIList<TBPoint*> &point_list,
1073 : : double offset1,
1074 : : DLIList<BodySM*> &new_bodysm_list,
1075 : : Curve *edge1 = NULL,
1076 : : double offset2 = -1.0,
1077 : : Curve *edge2 = NULL,
1078 : : double offset3 = -1.0,
1079 : : Curve *edge3 = NULL,
1080 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1081 : : CubitBoolean preview = CUBIT_FALSE ) const = 0;
1082 : : /**< Chamfer vertices on solid or sheet bodies. On a solid body there can
1083 : : * be up to 3 offsets; on a sheet body up to 2 offsets. The offsets are
1084 : : * in the direction of the supplied edges (for a solid) or the loop
1085 : : * direction (for a sheet). If multiple vertices are supplied, only one
1086 : : * offset value is allowed and the edges are not used.
1087 : : */
1088 : :
1089 : : virtual CubitStatus tweak_fillet( DLIList<Curve*> &curve_list,
1090 : : double radius,
1091 : : DLIList<BodySM*> &new_bodysm_list,
1092 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1093 : : CubitBoolean preview = CUBIT_FALSE ) const = 0;
1094 : : /**< Create a round fillet (or blend) at the given curves on solid bodies.
1095 : : */
1096 : :
1097 : : virtual CubitStatus tweak_fillet( Curve *curve_ptr,
1098 : : double start_radius,
1099 : : double end_radius,
1100 : : BodySM *&new_bodysm_ptr,
1101 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1102 : : CubitBoolean preview = CUBIT_FALSE ) const = 0;
1103 : : /**< Create a round fillet (or blend) at the given curve on a solid body.
1104 : : * The fillet has a variable radius from the start to the end of the curve.
1105 : : */
1106 : :
1107 : : virtual CubitStatus tweak_fillet( DLIList<TBPoint*> &point_list,
1108 : : double radius,
1109 : : DLIList<BodySM*> &new_bodysm_list,
1110 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1111 : : CubitBoolean preview = CUBIT_FALSE ) const = 0;
1112 : : /**< Create a round fillet (or blend) at the given vertices on sheet bodies.
1113 : : */
1114 : :
1115 : : virtual CubitStatus tweak_move( DLIList<Surface*> &surface_list,
1116 : : const CubitVector &delta,
1117 : : DLIList<BodySM*> &new_bodysm_list,
1118 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1119 : : CubitBoolean preview = CUBIT_FALSE ) const = 0;
1120 : : /**< Tweak specified faces of a volume or volumes along a vector.
1121 : : */
1122 : :
1123 : : virtual CubitStatus tweak_move( DLIList<Curve*> &curve_list,
1124 : : const CubitVector &delta,
1125 : : DLIList<BodySM*> &new_bodysm_list,
1126 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1127 : : CubitBoolean preview = CUBIT_FALSE ) const = 0;
1128 : : /**< Tweak specified curves of a sheet body along a vector.
1129 : : */
1130 : :
1131 : : virtual CubitStatus tweak_offset( DLIList<Surface*> &surface_list,
1132 : : double offset_distance,
1133 : : DLIList<Surface*> *add_surface_list_ptr,
1134 : : DLIList<double> *add_offset_list_ptr,
1135 : : DLIList<BodySM*> &new_bodysm_list,
1136 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1137 : : CubitBoolean preview = CUBIT_FALSE ) const = 0;
1138 : : /**< Tweak specified faces of a volume or volumes by offsetting those faces
1139 : : * by the offset distance(s).
1140 : : */
1141 : :
1142 : : virtual CubitStatus tweak_offset( DLIList<Curve*> &curve_list,
1143 : : double offset_distance,
1144 : : DLIList<Curve*> *add_curve_list_ptr,
1145 : : DLIList<double> *add_offset_list_ptr,
1146 : : DLIList<BodySM*> &new_bodysm_list,
1147 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1148 : : CubitBoolean preview = CUBIT_FALSE ) const = 0;
1149 : : /**< Tweak specified curves of a sheet body or bodies by offsetting those
1150 : : * curves by the offset distance(s).
1151 : : */
1152 : :
1153 : : virtual CubitStatus tweak_remove( DLIList<Surface*> &surface_list,
1154 : : DLIList<BodySM*> &new_bodysm_list,
1155 : : CubitBoolean extend_adjoining = CUBIT_TRUE,
1156 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1157 : : CubitBoolean preview = CUBIT_FALSE ) const = 0;
1158 : : /**< Remove surfaces from a body or bodies and then extend the adjoining
1159 : : * surfaces to fill the gap or remove the hole.
1160 : : */
1161 : :
1162 : : virtual CubitStatus tweak_remove( DLIList<Curve*> &curve_list,
1163 : : DLIList<BodySM*> &new_bodysm_list,
1164 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1165 : : CubitBoolean preview = CUBIT_FALSE ) const = 0;
1166 : : /**< Remove curves from a sheet body or bodies and then extend the remaining
1167 : : * curves to fill the gap. If an internal loop of curves is removed the
1168 : : * hole is removed.
1169 : : */
1170 : :
1171 : : virtual CubitStatus tweak_target( DLIList<Surface*> &surface_list,
1172 : : DLIList<Surface*> &target_surf_list,
1173 : : DLIList<BodySM*> &new_bodysm_list,
1174 : : CubitBoolean extend_flg = CUBIT_TRUE,
1175 : : CubitPlane *limit_plane = NULL,
1176 : : CubitBoolean reverse_flg = CUBIT_FALSE,
1177 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1178 : : CubitBoolean preview = CUBIT_FALSE ) const = 0;
1179 : : /**< Tweak specified faces of a volume or volumes up to target surfaces.
1180 : : * If extend flag is true, extend out the targets before tweaking to them
1181 : : * (only used for multiple targets; single targets are always extended).
1182 : : * The optional limit plane is only valid if extend_flg is TRUE; it will
1183 : : * limit the tweak to not go past this plane in the case where the tweaked
1184 : : * body would only partially intersect the extended targets. The reverse
1185 : : * flag should never be needed - if it is, there may be a bug or a bad
1186 : : * normal on a body (i.e., negative volume body), and is only retained for
1187 : : * debugging.
1188 : : */
1189 : :
1190 : : virtual CubitStatus tweak_target( DLIList<Curve*> &curve_list,
1191 : : DLIList<Surface*> &target_surf_list,
1192 : : DLIList<BodySM*> &new_bodysm_list,
1193 : : CubitBoolean extend_flg = CUBIT_TRUE,
1194 : : CubitPlane *limit_plane = NULL,
1195 : : CubitBoolean reverse_flg = CUBIT_FALSE,
1196 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1197 : : CubitBoolean preview = CUBIT_FALSE,
1198 : : double max_area_increase = 0 ) const = 0;
1199 : : /**< Tweak specified edges of a surface or set of surfaces (in sheet
1200 : : * bodies) up to a set of connected target surfaces. This essentially
1201 : : * extends or trims the attached surfaces of the sheet body. If extend
1202 : : * flag is true, extend out the targets before tweaking to them (only used
1203 : : * for multiple targets; single targets are always extended). The
1204 : : * optional limit plane is only valid if extend_flg is TRUE; it will limit
1205 : : * the tweak to not go past this plane in the case where the tweaked body
1206 : : * would only partially intersect the extended targets. The reverse flag
1207 : : * should never be needed - if it is, there may be a bug or a bad normal
1208 : : * on a body (i.e., negative volume body), and is only retained for
1209 : : * debugging. The max_area_increase is a percentage increase for
1210 : : * which the geometry will not be tweaked if the resulting surface area surpasses.
1211 : : */
1212 : :
1213 : : virtual CubitStatus tweak_target( DLIList<Curve*> &curve_list,
1214 : : DLIList<Curve*> &target_curve_list,
1215 : : DLIList<BodySM*> &new_bodysm_list,
1216 : : CubitBoolean extend_flg = CUBIT_TRUE,
1217 : : CubitPlane *limit_plane = NULL,
1218 : : CubitBoolean reverse_flg = CUBIT_FALSE,
1219 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1220 : : CubitBoolean preview = CUBIT_FALSE,
1221 : : double max_area_increase = 0) const = 0;
1222 : : /**< Tweak specified edges of a sheet body or bodies up to a set of target
1223 : : * curves that are part of a sheet body. The target is a surface created
1224 : : * by thickening the owning surface of the target curve. If extend flag
1225 : : * is true, extend out the targets before tweaking to them (only used for
1226 : : * multiple targets; single targets are always extended). The optional
1227 : : * limit plane is only valid if extend_flg is TRUE; it will limit the
1228 : : * tweak to not go past this plane in the case where the tweaked body
1229 : : * would only partially intersect the extended targets. The reverse flag
1230 : : * should never be needed - if it is, there may be a bug or a bad normal
1231 : : * on a body (i.e., negative volume body), and is only retained for
1232 : : * debugging.
1233 : : */
1234 : :
1235 : : virtual CubitStatus tweak_target( TBPoint *point_ptr,
1236 : : DLIList<Surface*> &modify_surface_list,
1237 : : CubitVector &target_loc,
1238 : : BodySM *&new_bodysm_ptr,
1239 : : CubitBoolean keep_old_body = CUBIT_FALSE,
1240 : : CubitBoolean preview = CUBIT_FALSE ) const = 0;
1241 : : /**< Tweak specified vertex of a sheet body to a given location. The
1242 : : * given vertex must be part of a planar surface or surfaces attached to
1243 : : * linear curves only. The user specified which of those surfaces to
1244 : : * actually modify. The given location will be projected to be on the
1245 : : * given planar surface(s) before being used - this projected location
1246 : : * must be the same on all surfaces.
1247 : : */
1248 : :
1249 : : virtual CubitStatus remove_curve_slivers( BodySM *bodies, double lengthlimit ) const = 0;
1250 : :
1251 : : virtual CubitStatus create_net_surface( DLIList<Surface*>& ref_face_list, BodySM *& new_body,
1252 : : DLIList<DLIList<CubitVector*>*> &vec_lists_u,
1253 : : DLIList<DLIList<CubitVector*>*> &vec_lists_v,
1254 : : double net_tol = 1e-3, CubitBoolean heal = CUBIT_TRUE ) const = 0;
1255 : :
1256 : : virtual CubitStatus create_net_surface( DLIList<Curve*>& u_curves, DLIList<Curve*>& v_curves,
1257 : : BodySM *& new_body, double net_tol = 1e-3,
1258 : : CubitBoolean heal = CUBIT_TRUE ) const = 0;
1259 : :
1260 : : virtual CubitStatus create_offset_surface( Surface* ref_face_ptr, BodySM*& new_body, double offset_distance ) const = 0;
1261 : :
1262 : : virtual CubitStatus create_offset_sheet( DLIList<Surface*> &surface_list,
1263 : : double offset_distance,
1264 : : DLIList<Surface*> *add_surface_list_ptr,
1265 : : DLIList<double> *add_offset_list_ptr,
1266 : : DLIList<BodySM*> &new_body_list,
1267 : : CubitBoolean preview = CUBIT_FALSE ) const = 0;
1268 : : /**< Create a sheet body (or bodies) by offsetting the given faces. The
1269 : : * optional additional face list and double list (must be same length)
1270 : : * allow different offset distances for different faces. Adjoining faces
1271 : : * are extended or trimmed to remain joined in the new sheet body. Radial
1272 : : * faces that cannot be so offset are removed and the resulting wound
1273 : : * healed by the surrounding faces.
1274 : : */
1275 : :
1276 : : virtual CubitStatus create_offset_body( BodySM* body_ptr, BodySM*& new_body, double offset_distance ) const = 0;
1277 : :
1278 : : virtual CubitStatus create_skin_surface( DLIList<Curve*>& curves, BodySM*& new_body,
1279 : : DLIList<Curve*>& guides) const = 0;
1280 : :
1281 : :
1282 : :
1283 : :
1284 : : virtual CubitStatus loft_surfaces_to_body( DLIList<Surface*> &surfaces,
1285 : : DLIList<double> &takeoff_factor_list,
1286 : : DLIList<Surface*> &takeoff_vector_surface_list,
1287 : : DLIList<CubitVector> &surface_takeoff_vector_list,
1288 : : DLIList<Curve*> &takeoff_vector_curve_list,
1289 : : DLIList<CubitVector> &curve_takeoff_vector_list,
1290 : : DLIList<Curve*> &guides,
1291 : : DLIList<TBPoint*> &match_vertices_list,
1292 : : BodySM*& new_body,
1293 : : CubitBoolean global_guides,
1294 : : CubitBoolean closed,
1295 : : CubitBoolean show_matching_curves,
1296 : : CubitBoolean preview
1297 : : ) const = 0;
1298 : :
1299 : :
1300 : :
1301 : : virtual CubitStatus create_surface( DLIList<CubitVector*>& vec_list,
1302 : : BodySM *&new_body, Surface *ref_face_ptr,
1303 : : CubitBoolean project_points ) const = 0;
1304 : :
1305 : : virtual CubitStatus create_parallelogram_surface( TBPoint *pt1,
1306 : : TBPoint *pt2,
1307 : : TBPoint *pt3,
1308 : : BodySM *&sheet_body) const;
1309 : :
1310 : : virtual CubitStatus create_rectangle_surface( double width,
1311 : : double height,
1312 : : CubitVector plane,
1313 : : BodySM *&sheet_body) const;
1314 : :
1315 : : virtual CubitStatus create_circle_surface( TBPoint *pt1,
1316 : : CubitVector center_point,
1317 : : TBPoint *pt3,
1318 : : BodySM *&sheet_body) const;
1319 : :
1320 : : virtual CubitStatus create_circle_surface( TBPoint *pt1,
1321 : : TBPoint *pt3,
1322 : : CubitVector center_point,
1323 : : BodySM *&sheet_body) const;
1324 : :
1325 : : virtual CubitStatus create_circle_surface( double radius,
1326 : : CubitVector plane,
1327 : : BodySM *&sheet_body) const;
1328 : :
1329 : : virtual CubitStatus create_ellipse_surface( TBPoint *pt1,
1330 : : TBPoint *pt3,
1331 : : CubitVector center_point,
1332 : : BodySM *&sheet_body) const;
1333 : :
1334 : : virtual CubitStatus create_ellipse_surface( double major_radius,
1335 : : double minor_radius,
1336 : : CubitVector plane,
1337 : : BodySM *&sheet_body) const;
1338 : :
1339 : : virtual CubitStatus create_surface( DLIList<TBPoint*> &points,
1340 : : BodySM *&new_body,
1341 : : Surface *on_surface ) const = 0;
1342 : :
1343 : : virtual CubitStatus create_weld_surface( CubitVector &root,
1344 : : Surface *ref_face1, double leg1, Surface *ref_face2, double leg2,
1345 : : BodySM *&new_body ) const = 0;
1346 : :
1347 : 0 : virtual CubitBoolean bodies_interfering( BodySM *body1, BodySM *body2 ) const {return CUBIT_FALSE;}
1348 : :
1349 : : virtual CubitStatus stitch( DLIList<BodySM*> &bodies_to_stitch,
1350 : : DLIList<BodySM*> &new_bodies,
1351 : : bool tighten_gaps,
1352 : : double tolerance )const = 0;
1353 : :
1354 : : protected:
1355 : :
1356 : : private:
1357 : :
1358 : : };
1359 : :
1360 : : #endif
|
