Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : VirtualQueryEngine.hpp
3 : : //
4 : : // Purpose : Interface for creation/destruction of CompositeEntities.
5 : : //
6 : : // Special Notes : This is not a complete modeling engine. This class is
7 : : // a container of functions for interaction with
8 : : // CompositeEntities
9 : : //
10 : : // Creator : Jason Kraftcheck
11 : : //
12 : : // Creation Date : 7/31/97
13 : : //-------------------------------------------------------------------------
14 : :
15 : : #ifndef VIRTUAL_GEOMETRY_ENGINE_HPP
16 : : #define VIRTUAL_GEOMETRY_ENGINE_HPP
17 : :
18 : : // ********** BEGIN STANDARD INCLUDES **********
19 : : // ********** END STANDARD INCLUDES **********
20 : :
21 : : // ********** BEGIN MOTIF INCLUDES **********
22 : : // ********** END MOTIF INCLUDES **********
23 : :
24 : : // ********** BEGIN OPEN INVENTOR INCLUDES **********
25 : : // ********** END OPEN INVENTOR INCLUDES **********
26 : :
27 : : // ********** BEGIN CUBIT INCLUDES **********
28 : :
29 : : #include "GeometryQueryEngine.hpp"
30 : : #include "CubitDefines.h"
31 : : #include "GeometryDefines.h"
32 : : #include "CubitString.hpp"
33 : : #include "CubitVector.hpp"
34 : :
35 : : // ********** END CUBIT INCLUDES **********
36 : :
37 : : // ********** BEGIN FORWARD DECLARATIONS **********
38 : : class BasicTopologyEntity;
39 : : class Body;
40 : : class RefVolume;
41 : : class RefEdge;
42 : : class RefFace;
43 : : class RefVertex;
44 : : class TBPoint;
45 : : class Curve;
46 : : class GMem;
47 : : template <class X> class DLIList;
48 : : class RefEntity;
49 : : class Body;
50 : : class CubitVector;
51 : : class TopologyEntity;
52 : : class CoEdge;
53 : :
54 : : class CompositeCurve;
55 : : class CompositeSurface;
56 : : class PartitionCurve;
57 : : class PartitionSurface;
58 : :
59 : : // ********** END FORWARD DECLARATIONS **********
60 : :
61 : : // ********** BEGIN MACRO DEFINITIONS **********
62 : : // ********** END MACRO DEFINITIONS **********
63 : :
64 : : // ********** BEGIN ENUM DEFINITIONS **********
65 : :
66 : : class VirtualQueryEngine : public GeometryQueryEngine
67 : : {
68 : :
69 : : public:
70 : :
71 : : virtual int curve_is_on_ignored_surface(Curve *curve,
72 : : Surface *surf);
73 : : void remove_virtual_geometry( RefEntity* entity_ptr,
74 : : CubitBoolean all_children );
75 : : void remove_virtual_geometry( Body* body, bool all_children );
76 : : void remove_virtual_geometry( RefVolume* vol, bool all_children );
77 : : void remove_virtual_geometry( RefFace* face );
78 : : //- Remove all possible virtual geometry from the passed
79 : : //- entity and its children.
80 : :
81 : :
82 : : static const double param_epsilon_fraction;
83 : : //- This value is used to determine epsilon for
84 : : //- compensating for rounding error in parameter
85 : : //- conversion between virtaul geometry and real
86 : : //- geometry.
87 : :
88 : : inline static VirtualQueryEngine* instance();
89 : : //R CompositeModelingeEngine
90 : : //R- A pointer to the single instance of this class
91 : : //- Access to VirtualQueryEngine must be through this function.
92 : : //- This forces single instance of the class. (constructor is protected)
93 : :
94 : : static void delete_instance();
95 : :
96 : : void register_attributes();
97 : : //- VGE registers attributes required for virtual geometry
98 : : // -- only call this once per session
99 : :
100 : : ~VirtualQueryEngine( );
101 : : //- Destructor
102 : :
103 : 0 : virtual const std::type_info& entity_type_info( ) const
104 : 0 : { return typeid(VirtualQueryEngine); }
105 : : //R- The type of this entity
106 : : //- This function returns the type of this class.
107 : :
108 : 0 : const char * modeler_type()
109 : 0 : { return "virtual"; }
110 : :
111 : :
112 : : virtual int get_major_version();
113 : : virtual int get_minor_version();
114 : : virtual int get_subminor_version();
115 : : virtual CubitString get_engine_version_string();
116 : :
117 : 0 : virtual bool is_intermediate_engine() {return TRUE;}
118 : :
119 : : virtual CubitStatus get_graphics( Surface* surface_ptr,
120 : : GMem *gmem,
121 : : std::vector<TopologyBridge*> &vertex_edge_to_point_vector,
122 : : std::vector<std::pair<TopologyBridge*, std::pair<int,int> > > &facet_edges_on_curves,
123 : : unsigned short normal_tolerance,
124 : : double distance_tolerance,
125 : : double max_edge_length ) const;
126 : :
127 : : virtual CubitStatus get_graphics( Surface* surface_ptr,
128 : : GMem* gMem,
129 : : unsigned short normal_tolerance,
130 : : double distance_tolerance,
131 : : double max_edge_length ) const;
132 : : //R CubitStatus
133 : : //R- CUBIT_SUCCESS/CUBIT_FAILURE
134 : : //I ref_face_ptr
135 : : //I- The RefFAce for which hoops facetting information will be
136 : : //I- gathered.
137 : : //O- The number of polygons (triangles) needed for facetting.
138 : : //O number_points
139 : : //O- The number of points needed for facetting
140 : : //O number_Facets
141 : : //O- The number of facets needed for facetting.
142 : : //O gMem
143 : : //O- The sturage place for facets (and points).
144 : : //= This function gathersw and outputs facet (and point)
145 : : //- information for hoops involved in facetting an RefFace. If
146 : : //- all goes well, CUBIT_Success is retuned.
147 : :
148 : : virtual CubitStatus get_graphics( Curve* curve_ptr,
149 : : GMem* gMem,
150 : : double angle_tolerance=0,
151 : : double distance_tolerance=0,
152 : : double max_edge_length=0 ) const;
153 : : //R CubitStatus
154 : : //R- CUBIT_SUCCESS/CUBIT_FAILURE
155 : : //I ref_edge_ptr
156 : : //I- The RefEdge for which hoops facetting information will be
157 : : //I- gathered/
158 : : //O numSteps
159 : : //O- The number of edges gathered.
160 : : //O gMem
161 : : //O- The sturage place for edges involved in facetting.
162 : : //I tolerance
163 : : //I- The tolerance deviation used when facetting the curve (optional
164 : : //I- and currently IGNORED by this engine).
165 : : //- This function gathers and outputs edge information for
166 : : //- hoops involved in facetting a RefEdge. If all goes well,
167 : : //- CUBIT_SUCCESS is returned. Otherwise, CUBIT_FAILURE is retuned.
168 : :
169 : :
170 : : virtual CubitStatus get_isoparametric_points(Surface* ref_face_ptr,
171 : : int &nu, int &nv,
172 : : GMem *&gMem) const;
173 : :
174 : : virtual CubitStatus get_u_isoparametric_points(Surface* ref_face_ptr,
175 : : double v, int &n,
176 : : GMem *&gMem) const;
177 : :
178 : : virtual CubitStatus get_v_isoparametric_points(Surface* ref_face_ptr,
179 : : double u, int &n,
180 : : GMem *&gMem) const;
181 : :
182 : : virtual CubitStatus transform_vec_position(
183 : : CubitVector const& position_vector,
184 : : BodySM *OSME_ptr,
185 : : CubitVector &transformed_vector ) const;
186 : :
187 : :
188 : : CubitStatus translate( BodySM* body, const CubitVector& offset );
189 : : CubitStatus rotate ( BodySM* body, const CubitVector& axis, double angle );
190 : : CubitStatus scale ( BodySM* body, double factor );
191 : : CubitStatus scale ( BodySM* body, const CubitVector& factors );
192 : : CubitStatus reflect ( BodySM* body, const CubitVector& axis );
193 : : CubitStatus restore_transform( BodySM* body );
194 : :
195 : : CubitStatus translate( GeometryEntity* ent, const CubitVector& offset );
196 : : CubitStatus rotate ( GeometryEntity* ent, const CubitVector& axis, double degrees );
197 : : CubitStatus scale ( GeometryEntity* ent, double factor );
198 : : CubitStatus scale ( GeometryEntity* ent, const CubitVector& factors );
199 : : CubitStatus reflect ( GeometryEntity* ent, const CubitVector& axis );
200 : :
201 : : static void get_VEs( RefVolume* volume_ptr,
202 : : DLIList<TopologyBridge*>& ve_list,
203 : : CubitBoolean visible = CUBIT_FALSE,
204 : : const CubitBoolean children_too = CUBIT_TRUE);
205 : : static void get_VEs( RefFace* face_ptr,
206 : : DLIList<TopologyBridge*>& ve_list,
207 : : CubitBoolean visible = CUBIT_FALSE,
208 : : const CubitBoolean children_too = CUBIT_TRUE );
209 : : static void get_VEs( RefEdge* edge_ptr,
210 : : DLIList<TopologyBridge*>& ve_list,
211 : : CubitBoolean visible = CUBIT_FALSE,
212 : : const CubitBoolean children_too = CUBIT_TRUE );
213 : : static void get_VEs( RefVertex* vertex_ptr,
214 : : DLIList<TopologyBridge*>& ve_list,
215 : : CubitBoolean visible = CUBIT_FALSE,
216 : : const CubitBoolean children_too = CUBIT_TRUE );
217 : : static void get_VEs( TopologyEntity* te_ptr,
218 : : DLIList<TopologyBridge*>& ve_list,
219 : : CubitBoolean visible = CUBIT_FALSE,
220 : : const CubitBoolean children_too = CUBIT_TRUE );
221 : : //R void
222 : : //I te_ptr, volume_ptr, face_ptr, edge_ptr
223 : : //I- Entity to query.
224 : : //O ve_list
225 : : //O- result set.
226 : : //I visible
227 : : //I- Return only entities visible in the model.
228 : : //- Get any virtual geometry of the passed entity or its children.
229 : :
230 : : virtual CubitStatus get_visible_entities( TopologyBridge *hidden_tb,
231 : : DLIList<TopologyBridge*> &real_tbs );
232 : :
233 : : virtual TopologyBridge* get_visible_entity_at_point(TopologyBridge* hidden_tb, CubitVector* point);
234 : : //R TopologyBridge*
235 : : //I hidden_tb, point
236 : : //I- Returns the lowest level visible entity that contains 'point.' (used for fire_ray())
237 : :
238 : : CubitBoolean virtuals_created() const;
239 : : //- returns CUBIT_TRUE if there are virtual entities in the model
240 : :
241 : : static CubitBoolean has_virtual( TopologyEntity* entity);
242 : :
243 : : static CubitBoolean is_virtual(TopologyEntity *entity,
244 : : const CubitBoolean children_too = CUBIT_FALSE);
245 : : static CubitBoolean is_virtual(DLIList<Body*> &entity_list,
246 : : const CubitBoolean children_too = CUBIT_FALSE);
247 : : //- returns CUBIT_TRUE if the entities passed in are virtual or
248 : : //- contain any virtual entities
249 : :
250 : : static CubitBoolean is_virtual(DLIList<RefEntity*> &entity_list,
251 : : const CubitBoolean children_too = CUBIT_FALSE);
252 : : //- returns CUBIT_TRUE if the entities passed in are virtual or
253 : : //- contain any virtual entities
254 : :
255 : : CubitBoolean is_partition( RefEntity *ref_entity );
256 : :
257 : : CubitStatus get_sister_partitions( RefEntity *ref_entity,
258 : : DLIList<RefEntity*> &sisters);
259 : :
260 : : CubitStatus sort_edges( DLIList<RefEdge*>& edge_list ) const;
261 : : //R CubitStatus
262 : : //R- CUBIT_SUCCESS/CUBIT_FAILURE
263 : : //I edge_list
264 : : //I- Input: The list of RefEdges to sort.
265 : : //I- Output: The list of sorted RefEdges.
266 : : //O composite_sense_wrt_first
267 : : //O- The sense of the CompositeCurve relative to the first RefEdge's
268 : : //O- Curve geometry object. NOT w.r.t. the RefEdge.
269 : : //O- in the SORTED list of RefEdges RETURNED.
270 : : //- This function sorts a list of RefEdges using topological
271 : : //- information. The RefEdges are sorted such that they form a
272 : : //- consecutive chain of edges. CUBIT_SUCCESS is returned if the
273 : : //- RefEdges are C0 continous, and CUBIT_FAILURE if they are not.
274 : : //- The C0 continuity is checked topologically, which assumes the
275 : : //- model is manifold.
276 : :
277 : : static CubitStatus associate_curves( DLIList<Curve*>& target_set,
278 : : RefEdge* edge_ptr,
279 : : DLIList<Curve*>& reset_set );
280 : : //- Find the subset of target_set that correspond to the curves contained
281 : : //- in the passed edge_ptr OR any hosts of the passed edge_ptr.
282 : :
283 : : virtual CubitStatus get_underlying_curves(Curve *curve_ptr,
284 : : DLIList<TopologyBridge*>& curve_list);
285 : : virtual CubitStatus get_underlying_surfaces(Surface * surf_ptr,
286 : : DLIList<TopologyBridge*>& surf_list) ;
287 : : virtual CubitStatus get_underlying_bridges(TopologyBridge* bridge_ptr,
288 : : DLIList<TopologyBridge*>& bridge_list);
289 : :
290 : : virtual CubitBoolean bodies_overlap (BodySM *body_ptr_1, BodySM *body_ptr_2 ) const;
291 : : virtual CubitBoolean volumes_overlap (Lump *lump1, Lump *lump2 ) const;
292 : :
293 : : protected:
294 : :
295 : : VirtualQueryEngine();
296 : : //- Constructor.
297 : :
298 : : static VirtualQueryEngine* instance_;
299 : :
300 : : //**** Display related methods
301 : :
302 : : CubitStatus get_composite_curve_facetting( CompositeCurve* ccurve_ptr,
303 : : GMem* gMem,
304 : : double angle_tolerance=0,
305 : : double distance_tolerance=0,
306 : : double max_edge_length=0 ) const;
307 : :
308 : : CubitStatus get_partition_curve_facetting( PartitionCurve* pcurve_ptr,
309 : : GMem* gMem,
310 : : double angle_tolerance=0,
311 : : double distance_tolerance=0,
312 : : double max_edge_length=0 ) const;
313 : :
314 : : CubitStatus get_composite_surface_facetting( CompositeSurface* surf_ptr,
315 : : GMem* gMem,
316 : : std::vector<TopologyBridge*> *vertex_edge_to_point_vector,
317 : : std::vector<std::pair<TopologyBridge*, std::pair<int,int> > > *facet_edges_on_curves,
318 : : unsigned short normal_tol,
319 : : double absolute_tol,
320 : : double longest_edge ) const;
321 : :
322 : : CubitStatus get_partition_surface_facetting( PartitionSurface* surf_ptr,
323 : : GMem* gMem,
324 : : std::vector<TopologyBridge*> *vertex_edge_to_point_vector,
325 : : std::vector<std::pair<TopologyBridge*, std::pair<int,int> > > *facet_edges_on_curves,
326 : : unsigned short normal_tol,
327 : : double absolute_tol,
328 : : double longest_edge ) const;
329 : :
330 : : virtual CubitStatus export_solid_model( DLIList<TopologyBridge*>& bridge_list,
331 : : const char* file_name,
332 : : Model_File_Type file_type,
333 : : const CubitString &cubit_version,
334 : : ModelExportOptions &export_options );
335 : :
336 : 0 : virtual CubitStatus export_solid_model( DLIList<TopologyBridge*>& bridge_list,
337 : : char*& p_buffer,
338 : : int& n_buffer_size,
339 : : bool b_export_buffer)
340 : 0 : {return CUBIT_FAILURE;}
341 : :
342 : : virtual CubitStatus save_temp_geom_file(DLIList<TopologyBridge*>& bridge_list,
343 : : const char *file_name,
344 : : const CubitString &cubit_version,
345 : : CubitString &created_file,
346 : : CubitString &created_file_type);
347 : :
348 : : virtual CubitStatus import_solid_model(
349 : : const char* file_name,
350 : : Model_File_Type file_type,
351 : : DLIList<TopologyBridge*>& imported_entities,
352 : : ModelImportOptions &import_options );
353 : :
354 : 0 : virtual CubitStatus import_solid_model(DLIList<TopologyBridge*> &imported_entities,
355 : : const char* pBuffer,
356 : : const int n_buffer_size)
357 : 0 : {return CUBIT_FAILURE;}
358 : :
359 : : virtual void delete_solid_model_entities(DLIList<BodySM*>&) const;
360 : : virtual CubitStatus delete_solid_model_entities( BodySM* body_ptr ) const;
361 : : virtual CubitStatus delete_solid_model_entities(Surface* surf_ptr ) const;
362 : : virtual CubitStatus delete_solid_model_entities( Curve* curve_ptr ) const;
363 : : virtual CubitStatus delete_solid_model_entities( TBPoint* point_ptr ) const;
364 : :
365 : : virtual CubitStatus fire_ray( CubitVector &origin,
366 : : CubitVector &direction,
367 : : DLIList<TopologyBridge*> &at_entity_list,
368 : : DLIList<double> &ray_params,
369 : : int max_hits,
370 : : double ray_radius,
371 : : DLIList<TopologyBridge*> *hit_entity_list=0 ) const;
372 : : //- Fire a ray at specified entities, returning the parameters (distances)
373 : : //- along the ray and optionally the entities hit. Returned lists are
374 : : //- appended to. Input entities can be any of bodies, volumes, faces,
375 : : //- edges or vertices. Optionally you can specify the maximum number of
376 : : //- hits to return (default = 0 = unlimited), and the ray radius to use for
377 : : //- intersecting the entities (default = 0.0 = use modeller default).
378 : : //- NOTE: returned entities hit might be "hidden" beneath virtual entities.
379 : : //- To resolve to visible entities, use "get_visible_ents_for_hits"
380 : : //- in GeometryQueryTool.
381 : :
382 : : virtual double get_sme_resabs_tolerance() const;
383 : : virtual double set_sme_resabs_tolerance( double new_resabs );
384 : :
385 : : virtual CubitStatus set_int_option( const char* opt_name, int val );
386 : : virtual CubitStatus set_dbl_option( const char* opt_name, double val );
387 : : virtual CubitStatus set_str_option( const char* opt_name, const char* val );
388 : :
389 : : private:
390 : :
391 : : void default_error_message( const char callers_name[] ) const;
392 : : //- Error message for inhereted functions which are not implemented.
393 : :
394 : : static const int VGE_MAJOR_VERSION;
395 : : static const int VGE_MINOR_VERSION;
396 : : static const int VGE_SUBMINOR_VERSION;
397 : :
398 : : public:
399 : : virtual CubitStatus get_intersections(Curve* curve, CubitVector &point1,
400 : : CubitVector &point2,
401 : : DLIList<CubitVector>& intersection_list,
402 : : CubitBoolean bounded,
403 : : CubitBoolean closest );
404 : :
405 : : virtual CubitStatus get_intersections( Curve* ref_edge1, Curve* ref_edge2,
406 : : DLIList<CubitVector>& intersection_list,
407 : : bool bounded = CUBIT_FALSE,
408 : : bool closest = CUBIT_FALSE );
409 : : //- Finds the intersections of the two curves. If the bounded flag is
410 : : //- true, it finds only those intersections within the parameter range
411 : : //- of both curves; otherwise it uses the extensions of the curves. The
412 : : //- closest option is currently valid only if both curves are straight,
413 : : //- in which case it will return the 2 closest intersection locations,
414 : : //- if the straight lines don't actually intersect. The function allocates
415 : : //- the CubitVectors in the returned list, so be sure to free them.
416 : : //- NOT DEFINED YET IN THIS GEOMETRY ENGINE.
417 : :
418 : : virtual CubitStatus get_intersections( Curve* ref_edge, Surface* ref_face,
419 : : DLIList<CubitVector>& intersection_list,
420 : : bool bounded = CUBIT_FALSE );
421 : : //- Finds the intersections of the curve and surface. The curve is extended
422 : : //- if the bounded flag is not false. The function allocates the CubitVectors
423 : : //- in the returned list, so be sure to free them.
424 : : //- NOT DEFINED YET IN THIS GEOMETRY ENGINE.
425 : :
426 : : virtual CubitStatus entity_extrema( DLIList<GeometryEntity*> &ref_entity_list,
427 : : const CubitVector *dir1,
428 : : const CubitVector *dir2,
429 : : const CubitVector *dir3,
430 : : CubitVector &extrema,
431 : : GeometryEntity *&extrema_entity_ptr );
432 : : //- Gets the extrema position along the first given direction. If there
433 : : //- is more than one extrema position, the other directions will be used
434 : : //- to determine a unique position. Directions 2 and 3 can be NULL.
435 : : //- Entities supported include bodies, volumes, surfaces, curves and
436 : : //- vertices. The entity the extrema is found on is also returned.
437 : : //- NOT DEFINED YET IN THIS GEOMETRY ENGINE.
438 : :
439 : : virtual CubitStatus entity_entity_distance( GeometryEntity *ref_entity_ptr1,
440 : : GeometryEntity *ref_entity_ptr2,
441 : : CubitVector &pos1, CubitVector &pos2,
442 : : double &distance );
443 : : //- Gets the minimum distance between two entities and the closest positions
444 : : //- on those entities. Supports vertices, curves, surfaces, volumes and bodies.
445 : : //- NOT DEFINED YET IN THIS GEOMETRY ENGINE.
446 : :
447 : : };
448 : :
449 : :
450 : : // ********** BEGIN INLINE FUNCTIONS **********
451 : 841 : inline VirtualQueryEngine* VirtualQueryEngine::instance()
452 : : {
453 [ + - ]: 841 : if( instance_ == NULL )
454 : : {
455 [ + - ]: 841 : instance_ = new VirtualQueryEngine;
456 [ - + ]: 841 : assert( instance_ != NULL );
457 : : }
458 : :
459 : 841 : return instance_;
460 : : }
461 : :
462 : : // ********** END INLINE FUNCTIONS **********
463 : :
464 : : // ********** BEGIN FRIEND FUNCTIONS **********
465 : : // ********** END FRIEND FUNCTIONS **********
466 : :
467 : : // ********** BEGIN EXTERN FUNCTIONS **********
468 : : // ********** END EXTERN FUNCTIONS **********
469 : :
470 : : // ********** BEGIN HELPER CLASS DECLARATIONS **********
471 : : // ********** END HELPER CLASS DECLARATIONS **********
472 : :
473 : : #endif
|
