Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : FacetQueryEngine.hpp
3 : : //
4 : : // Purpose : Facet geometry engine.
5 : : //
6 : : // This class is implemented as a Singleton pattern. Only
7 : : // one instance is created and it is accessed through the
8 : : // {instance()} static member function.
9 : : //
10 : : // Special Notes :
11 : : //
12 : : // Creator : David R. White
13 : : //
14 : : // Creation Date : 6/29/00
15 : : //
16 : : //-------------------------------------------------------------------------
17 : :
18 : : #ifndef FACET_GEOMETRY_ENGINE_HPP
19 : : #define FACET_GEOMETRY_ENGINE_HPP
20 : :
21 : : // ********** BEGIN STANDARD INCLUDES **********
22 : :
23 : : #include <typeinfo>
24 : :
25 : : // ********** END STANDARD INCLUDES **********
26 : :
27 : : // ********** BEGIN CUBIT INCLUDES **********
28 : :
29 : : #include "CubitFileIOWrapper.hpp"
30 : : #include "GeometryQueryEngine.hpp"
31 : :
32 : : // ********** END CUBIT INCLUDES **********
33 : :
34 : : // ********** BEGIN FORWARD DECLARATIONS
35 : : class TopologyEntity;
36 : : class TopologyBridge;
37 : : class RefEntity;
38 : : class Body;
39 : : class Shell;
40 : : class ShellSM;
41 : : class Loop;
42 : : class Chain;
43 : : class CoEdgeSM;
44 : : class LoopSM;
45 : : class RefVolume;
46 : : class RefFace;
47 : : class RefEdge;
48 : : class RefVertex;
49 : : class TBPoint;
50 : : class Curve;
51 : : class Surface;
52 : : class Lump;
53 : : class BodySM;
54 : :
55 : : class GeometryEntity;
56 : : class CubitBox;
57 : : class CubitString;
58 : :
59 : : class FacetLump;
60 : : class FacetShell;
61 : : class FacetLoop;
62 : : class FacetSurface;
63 : : class FacetBody;
64 : : class FacetCoEdge;
65 : : class FacetCurve;
66 : : class FacetPoint;
67 : :
68 : : class CubitFacet;
69 : : class CubitQuadFacet;
70 : : class CubitFacetEdge;
71 : : class CubitPoint;
72 : : class FacetEntity;
73 : : class CurveFacetEvalTool;
74 : : class FacetEvalTool;
75 : :
76 : : // ********** END FORWARD DECLARATIONS **********
77 : :
78 : : // ********** BEGIN MACRO DEFINITIONS **********
79 : : // ********** END MACRO DEFINITIONS **********
80 : :
81 : : // ********** BEGIN ENUM DEFINITIONS **********
82 : : typedef enum {
83 : : CUBIT_FACET_FILE,
84 : : AVS_FILE,
85 : : CHOLLA_FILE,
86 : : FROM_FACET_LIST,
87 : : STL_FILE
88 : : } FacetFileFormat;
89 : :
90 : : // ********** END ENUM DEFINITIONS **********
91 : :
92 : : class FacetQueryEngine : public GeometryQueryEngine
93 : : {
94 : : public:
95 : : // ********** BEGIN FRIEND DECLARATIONS **********
96 : : friend class FacetSurface;
97 : :
98 : : // ********** END FRIEND DECLARATIONS **********
99 : :
100 : : //HEADER- Constructor and Destructor
101 : :
102 : : static FacetQueryEngine* instance();
103 : : //- Singleton pattern
104 : : //- Controlled access and creation of the sole instance of this class.
105 : :
106 : : virtual ~FacetQueryEngine();
107 : :
108 : : static void delete_instance();
109 : :
110 : 0 : const char* modeler_type()
111 : 0 : { return "facet"; }
112 : :
113 : : int get_major_version();
114 : :
115 : : int get_minor_version();
116 : :
117 : : int get_subminor_version();
118 : :
119 : : CubitString get_engine_version_string();
120 : :
121 : : //HEADER- RTTI and safe casting functions.
122 : :
123 : : virtual const std::type_info& entity_type_info() const ;
124 : : //R- The geometric modeler type
125 : : //- This function returns the type of the geometric modeler.
126 : :
127 : 0 : virtual CubitBoolean is_solid_modeler_type() const
128 : 0 : {return CUBIT_FALSE;}
129 : : //R CubitBoolean
130 : : //R- This is not a solid modeling engine.
131 : : //HEADER- Functions for importing and exporting solid models.
132 : :
133 : : CubitBoolean can_delete_bodies(DLIList<Body*>body_list);
134 : :
135 : : virtual TBPoint* make_Point( GeometryType point_type,
136 : : CubitVector const& point) const ;
137 : : virtual Curve* make_Curve(Curve *) const;
138 : : virtual Curve* make_Curve( TBPoint const* ,
139 : : TBPoint const* ,
140 : : RefFace* ,
141 : : CubitVector * ) const;
142 : : virtual Curve* make_Curve( GeometryType ,
143 : : TBPoint const* ,
144 : : TBPoint const* ,
145 : : DLIList<CubitVector*>& ,
146 : : RefFace* ) const;
147 : : virtual Curve* make_Curve( GeometryType ,
148 : : TBPoint const* ,
149 : : TBPoint const* ,
150 : : CubitVector const* ,
151 : : CubitSense ) const;
152 : : virtual Surface* make_Surface( Surface *,
153 : : DLIList<Loop*> &,
154 : : CubitBoolean ) const;
155 : :
156 : :
157 : : virtual Surface* make_Surface( GeometryType ,
158 : : DLIList<Curve*>& ,
159 : : DLIList<Loop*> &,
160 : : Surface *) const ;
161 : : virtual Lump* make_Lump( GeometryType ,
162 : : DLIList<Surface*>& ) const ;
163 : : virtual BodySM* make_BodySM( Surface * ) const;
164 : : virtual BodySM* make_BodySM( DLIList<Lump*>& ) const ;
165 : :
166 : : Body* copy_body( Body *body_ptr );
167 : :
168 : : virtual CubitStatus get_graphics( BodySM *bodysm, GMem* g_mem,
169 : : std::vector<Surface*> &surface_to_facets_vector,
170 : : std::vector<TopologyBridge*> &vertex_edge_to_point_vector,
171 : : std::vector<std::pair<TopologyBridge*, std::pair<int,int> > > &facet_edges_on_curves,
172 : : unsigned short normal_tolerance,
173 : : double distance_tolerance, double max_edge_length ) const;
174 : :
175 : : virtual CubitStatus get_graphics( Surface* surface_ptr,
176 : : GMem* gMem,
177 : : unsigned short normal_tolerance,
178 : : double distance_tolerance,
179 : : double max_edge_length ) const;
180 : :
181 : : virtual CubitStatus get_graphics( Curve* curve_ptr,
182 : : GMem* gMem,
183 : : double angle_tolerance=0,
184 : : double distance_tolerance=0,
185 : : double max_edge_length=0 ) const;
186 : : //R CubitStatus
187 : : //R- CUBIT_SUCCESS/CUBIT_FAILURE
188 : : //I ref_edge_ptr
189 : : //I- The RefEdge for which hoops facetting information will be
190 : : //I- gathered.
191 : : //O numSteps
192 : : //O- The number of points in resulting polyline.
193 : : //O gMem
194 : : //O- The storage place for edges, involved in facetting.
195 : : //I tolerance
196 : : //I- The tolerance deviation used when facetting the curve (optional
197 : : //I- and currently IGNORED by this engine).
198 : : //- This function gathers and outputs edge information for
199 : : //- hoops involved in facetting a RefEdge. If all goes well,
200 : : //- CUBIT_SUCCESS is returned. Otherwise, CUBIT_FAILURE is
201 : : //- returned.
202 : :
203 : : virtual CubitStatus get_isoparametric_points(Surface* ,
204 : : int &, int &,
205 : : GMem*&) const;
206 : :
207 : : virtual CubitStatus get_u_isoparametric_points(Surface* ref_face_ptr,
208 : : double v, int &n,
209 : : GMem *&gMem) const;
210 : :
211 : : virtual CubitStatus get_v_isoparametric_points(Surface* ref_face_ptr,
212 : : double u, int &n,
213 : : GMem *&gMem) const;
214 : :
215 : : virtual CubitStatus transform_vec_position(
216 : : CubitVector const& ,
217 : : BodySM *,
218 : : CubitVector & ) const;
219 : :
220 : : virtual CubitStatus get_intersections( Curve*, CubitVector& point1,
221 : : CubitVector&,
222 : : DLIList<CubitVector>& ,
223 : : CubitBoolean,
224 : : CubitBoolean );
225 : :
226 : : virtual CubitStatus get_intersections( Curve* , Curve* ,
227 : : DLIList<CubitVector>& ,
228 : : CubitBoolean,
229 : : CubitBoolean );
230 : : virtual CubitStatus get_intersections( Curve* ref_edge1, Curve* ref_edge2,
231 : : DLIList<CubitVector>& intersection_list,
232 : : double offset,
233 : : CubitBoolean ext_first = CUBIT_TRUE );
234 : : virtual CubitStatus get_intersections( Curve* ref_edge, Surface* ref_face,
235 : : DLIList<CubitVector>& intersection_list,
236 : : CubitBoolean bounded = CUBIT_FALSE );
237 : :
238 : : virtual CubitStatus entity_extrema( DLIList<GeometryEntity*> &entity_list,
239 : : const CubitVector *dir1,
240 : : const CubitVector *dir2,
241 : : const CubitVector *dir3,
242 : : CubitVector &extrema,
243 : : GeometryEntity *&extrema_entity_ptr );
244 : : //- Gets the extrema position along the first given direction. If there
245 : : //- is more than one extrema position, the other directions will be used
246 : : //- to determine a unique position. Directions 2 and 3 can be NULL.
247 : : //- Entities supported include bodies, volumes, surfaces, curves and
248 : : //- vertices. The entity the extrema is found on is also returned.
249 : :
250 : : virtual CubitStatus entity_entity_distance( GeometryEntity *ref_entity_ptr1,
251 : : GeometryEntity *ref_entity_ptr2,
252 : : CubitVector &pos1, CubitVector &pos2,
253 : : double &distance );
254 : : //- Gets the minimum distance between two entities and the closest positions
255 : : //- on those entities. Supports vertices, curves, surfaces, volumes and bodies.
256 : :
257 : : virtual CubitStatus export_solid_model( DLIList<TopologyBridge*>& bridge_list,
258 : : const char* file_name,
259 : : Model_File_Type file_type,
260 : : const CubitString &cubit_version,
261 : : ModelExportOptions &export_options );
262 : :
263 : 0 : virtual CubitStatus export_solid_model( DLIList<TopologyBridge*>& bridge_list,
264 : : char*& p_buffer,
265 : : int& n_buffer_size,
266 : : bool b_export_buffer)
267 : 0 : {return CUBIT_FAILURE;}
268 : :
269 : : virtual CubitStatus save_temp_geom_file( DLIList<TopologyBridge*>& ref_entity_list,
270 : : const char *file_name,
271 : : const CubitString &cubit_version,
272 : : CubitString &created_file,
273 : : CubitString &created_file_type );
274 : :
275 : : virtual CubitStatus import_solid_model(const char* file_name,
276 : : Model_File_Type file_type,
277 : : DLIList<TopologyBridge*>& imported_entities,
278 : : ModelImportOptions &import_options );
279 : :
280 : 0 : virtual CubitStatus import_solid_model(DLIList<TopologyBridge*> &imported_entities,
281 : : const char* pBuffer,
282 : : const int n_buffer_size)
283 : 0 : {return CUBIT_FAILURE;}
284 : :
285 : : private:
286 : : CubitStatus import_solid_model(FILE *file_ptr,
287 : : DLIList<TopologyBridge*> &imported_entities );
288 : :
289 : : public:
290 : : virtual void delete_solid_model_entities(DLIList<BodySM*>& body_list) const;
291 : : //- Deletes all solid model entities associated with the Bodies in
292 : : //- the input list.
293 : :
294 : : virtual CubitStatus delete_solid_model_entities( BodySM* body_ptr ) const;
295 : : virtual CubitStatus delete_solid_model_entities(Surface* surf_ptr ) const;
296 : : virtual CubitStatus delete_solid_model_entities( Curve* curve_ptr ) const;
297 : : virtual CubitStatus delete_solid_model_entities( TBPoint* point_ptr ) const;
298 : :
299 : : virtual CubitStatus fire_ray( CubitVector &origin,
300 : : CubitVector &direction,
301 : : DLIList<TopologyBridge*> &at_entity_list,
302 : : DLIList<double> &ray_params,
303 : : int max_hits,
304 : : double ray_radius,
305 : : DLIList<TopologyBridge*> *hit_entity_list=0 ) const;
306 : : //- Fire a ray at specified entities, returning the parameters (distances)
307 : : //- along the ray and optionally the entities hit. Returned lists are
308 : : //- appended to. Input entities can be any of bodies, volumes, faces,
309 : : //- edges or vertices. Optionally you can specify the maximum number of
310 : : //- hits to return (default = 0 = unlimited), and the ray radius to use for
311 : : //- intersecting the entities (default = 0.0 = use modeller default).
312 : : //- NOTE: returned entities hit might be "hidden" beneath virtual entities.
313 : : //- To resolve to visible entities, use "get_visible_ents_for_hits"
314 : : //- in GeometryQueryTool.
315 : :
316 : : virtual double get_sme_resabs_tolerance() const; // Gets solid modeler's resolution absolute tolerance
317 : : virtual double set_sme_resabs_tolerance( double new_resabs );
318 : :
319 : : virtual CubitStatus set_int_option( const char* opt_name, int val );
320 : : virtual CubitStatus set_dbl_option( const char* opt_name, double val );
321 : : virtual CubitStatus set_str_option( const char* opt_name, const char* val );
322 : : //- Set solid modeler options
323 : :
324 : : static CubitStatus make_facets( int *conn, int nfacets,
325 : : DLIList<CubitQuadFacet *> &facet_list );
326 : : static CubitStatus make_facets( int *conn, int nfacets,
327 : : DLIList<CubitFacet *> &facet_list );
328 : : //- create facets from a list of points and connectivity
329 : :
330 : : CubitStatus ensure_is_ascii_stl_file(FILE * fp, CubitBoolean &is_ascii);
331 : : //- returns true in is_ascii if fp points to an ascii stl file
332 : :
333 : : CubitStatus read_facets_stl_tolerance(
334 : : DLIList<CubitFacet *> &tfacet_list,
335 : : DLIList<CubitPoint *> &point_list,
336 : : const char * file_name,
337 : : int &npoints,
338 : : int &ntri,
339 : : long& seek_address,
340 : : double tolerance);
341 : : //- read facets from an stl file and combine vertices within tolerance distance
342 : :
343 : : CubitStatus read_facets_stl(
344 : : DLIList<CubitFacet *> &tfacet_list,
345 : : DLIList<CubitPoint *> &point_list,
346 : : const char * file_name,
347 : : int &npoints,
348 : : int &ntri,
349 : : long& seek_address);
350 : : //- read facets from an stl file
351 : :
352 : : CubitStatus import_facets( const char *file_name,
353 : : CubitBoolean use_feature_angle,
354 : : double feature_angle,
355 : : double tolerance,
356 : : int interp_order,
357 : : CubitBoolean smooth_non_manifold,
358 : : CubitBoolean split_surfaces,
359 : : CubitBoolean stitch,
360 : : CubitBoolean improve,
361 : : DLIList <CubitQuadFacet *>&quad_facet_list,
362 : : DLIList <CubitFacet *> &tri_facet_list,
363 : : DLIList<Surface *> &surface_list,
364 : : FacetFileFormat file_format = CUBIT_FACET_FILE );
365 : : //- import facets from a file and create a geometry model
366 : :
367 : : static CubitStatus read_facets( const char * file_name,
368 : : int *&conn,
369 : : int &npoints,
370 : : int &nquad, int &ntri,
371 : : FacetFileFormat file_format = CUBIT_FACET_FILE );
372 : : static CubitStatus read_cholla_file( const char *file_name,
373 : : double &feature_angle,
374 : : DLIList<CubitPoint *> &point_list,
375 : : DLIList<CubitFacet *> &facet_list);
376 : : //- read points and facets from a file
377 : :
378 : : CubitBoolean is_close(CubitVector &this_point,
379 : : DLIList<CubitFacet *>&facet_list,
380 : : CubitFacet *&lastFacet,
381 : : double tol);
382 : : //- determine if one of the facets in the list is within a
383 : : //- certain distance of the point.
384 : :
385 : : static CubitStatus export_facets(DLIList<CubitFacet*> &facet_list,
386 : : char *filename);
387 : : //- export a list of facets to a facet file for debugging purposes
388 : :
389 : : CubitStatus gather_all_facet_entities( DLIList<FacetBody*> &facet_bodies,
390 : : DLIList<FacetLump*> &facet_lumps,
391 : : DLIList<FacetShell*> &facet_shells,
392 : : DLIList<FacetSurface*> &facet_surfaces,
393 : : DLIList<FacetLoop*> &facet_loops,
394 : : DLIList<FacetCoEdge*> &facet_coedges,
395 : : DLIList<FacetCurve*> &facet_curves,
396 : : DLIList<FacetPoint*> &facet_points );
397 : :
398 : : CubitStatus save_facets( FILE *fp, DLIList<FacetSurface*> facet_surfaces,
399 : : DLIList<FacetCurve*> facet_curves,
400 : : DLIList<FacetPoint*> facet_points );
401 : :
402 : : CubitStatus save_eval_tools( FILE *fp, DLIList<FacetSurface*> facet_surfaces,
403 : : DLIList<FacetCurve*> facet_curves );
404 : :
405 : : CubitStatus dump_facets( FILE *fp,
406 : : DLIList<CubitFacet *> &facet_list,
407 : : DLIList<CubitFacetEdge *> &edge_list,
408 : : DLIList<CubitPoint *> &point_list );
409 : : CubitStatus gather_facets( DLIList<FacetSurface *> facet_surfaces,
410 : : DLIList<FacetCurve *> facet_curves,
411 : : DLIList<FacetPoint *> facet_points,
412 : : DLIList<CubitFacet *> &facet_list,
413 : : DLIList<CubitFacetEdge *> &edge_list,
414 : : DLIList<CubitPoint *> &point_list );
415 : : //- functions for saving the facet geometry representation to a cubit file
416 : :
417 : : CubitStatus restore_eval_tools( FILE *fp,
418 : : unsigned int endian,
419 : : int num_facets,
420 : : int num_edges,
421 : : int num_points,
422 : : CubitFacet **facets,
423 : : CubitFacetEdge **edges,
424 : : CubitPoint **points,
425 : : int &num_cfet,
426 : : int &num_fet,
427 : : CurveFacetEvalTool **&cfeval_tools,
428 : : FacetEvalTool **&feval_tools );
429 : : //- restore facets from CUB file
430 : :
431 : : CubitStatus create_super_facet_bounding_box(
432 : : DLIList<BodySM*>& body_list,
433 : : CubitBox& super_box );
434 : : CubitStatus create_facet_bounding_box(
435 : : BodySM* bodySM,
436 : : CubitBox& bbox );
437 : :
438 : : CubitStatus restore_transform( BodySM* body );
439 : :
440 : : CubitStatus translate( BodySM* body, const CubitVector& offset );
441 : : CubitStatus rotate ( BodySM* body, const CubitVector& axis, double angle );
442 : : CubitStatus scale ( BodySM* body, double factor );
443 : : CubitStatus scale ( BodySM* body, const CubitVector& factors );
444 : : CubitStatus reflect ( BodySM* body, const CubitVector& axis );
445 : :
446 : : CubitStatus translate( GeometryEntity* ent, const CubitVector& offset );
447 : : CubitStatus rotate ( GeometryEntity* ent, const CubitVector& axis, double degrees );
448 : : CubitStatus scale ( GeometryEntity* ent, double factor );
449 : : CubitStatus scale ( GeometryEntity* ent, const CubitVector& factors );
450 : : CubitStatus reflect ( GeometryEntity* ent, const CubitVector& axis );
451 : :
452 : : CubitStatus get_connected_patch( DLIList<FacetSurface*>& remaining_surfs,
453 : : DLIList<FacetSurface*>& output_patch );
454 : : virtual CubitBoolean bodies_overlap (BodySM *body_ptr_1,
455 : : BodySM *body_ptr_2 ) const;
456 : : virtual CubitBoolean volumes_overlap (Lump *lump_ptr_1,
457 : : Lump *lump_ptr_2 ) const;
458 : : //R CubitBoolean
459 : : //R- CUBIT_TRUE if the two bodies overlap, CUBIT_FALSE if they don't
460 : : //R- overlap. If the bodies are touching the function
461 : : //R- should return CUBIT_FALSE.
462 : : //I body_ptr_1, body_ptr_2
463 : : //I- The two body pointers that are being tested for overlap.
464 : : //- The function uses the intersect call to test if the bodies
465 : : //- are overlaping. The full intersect Boolean is needed to see if
466 : : //- the bodies actually overlap and don't just touch.
467 : :
468 : : virtual CubitStatus get_point_containment( DLIList<BodySM*> &bodysm_list,
469 : : DLIList<CubitVector> &point_list,
470 : : double tolerance,
471 : : bool allow_pts_in_multiple_bodies,
472 : : std::vector< std::pair<BodySM*, std::vector<int> > > &bodysm_to_pt_indices );
473 : :
474 : : protected:
475 : :
476 : : FacetQueryEngine();
477 : :
478 : : private:
479 : :
480 : : CubitStatus write_topology( FILE *file_ptr,
481 : : DLIList<FacetBody*> &facet_bodies,
482 : : DLIList<FacetLump*> &facet_lumps,
483 : : DLIList<FacetShell*> &facet_shells,
484 : : DLIList<FacetSurface*> &facet_surfaces,
485 : : DLIList<FacetLoop*> &facet_loops,
486 : : DLIList<FacetCoEdge*> &facet_coedges,
487 : : DLIList<FacetCurve*> &facet_curves,
488 : : DLIList<FacetPoint*> &facet_points );
489 : :
490 : : CubitStatus restore_topology( FILE *file_ptr,
491 : : unsigned int endian,
492 : : int num_points,
493 : : CubitPoint **points_array,
494 : : int num_cfet,
495 : : CurveFacetEvalTool **cfev_array,
496 : : int num_fet,
497 : : FacetEvalTool **fev_array,
498 : : DLIList<TopologyBridge*> &imported_entities );
499 : :
500 : : CubitStatus restore_facets( FILE *file_ptr,
501 : : unsigned int endian,
502 : : int &num_facets,
503 : : int &num_edges,
504 : : int &num_points,
505 : : CubitPoint**&points_array,
506 : : int &num_cfet,
507 : : int &num_fet,
508 : : CurveFacetEvalTool **&cfet_array,
509 : : FacetEvalTool **&fet_array);
510 : :
511 : : CubitStatus read_facets( FILE *fp,
512 : : unsigned int endian,
513 : : int &num_facets, int &num_edges, int &num_points,
514 : : CubitFacet **&facets, CubitFacetEdge **&edges,
515 : : CubitPoint **&points );
516 : :
517 : : static FacetQueryEngine* instance_;
518 : : //- static pointer to unique instance of this class
519 : :
520 : : static CubitStatus init_hash_points( int num_points );
521 : : static CubitStatus add_hash_point( CubitPoint *point_ptr );
522 : : static CubitPoint *get_hash_point( int id );
523 : : static void delete_hash_points( );
524 : : static int get_hash_key( int id );
525 : : static CubitStatus get_all_hash_points(DLIList<CubitPoint *> &point_list);
526 : : static int hashPointSize;
527 : : static DLIList<CubitPoint *> *hashPointArray;
528 : : //- hash table functions used for reading the facet file
529 : :
530 : : static const int FQE_MAJOR_VERSION;
531 : : static const int FQE_MINOR_VERSION;
532 : : static const int FQE_SUBMINOR_VERSION;
533 : : };
534 : :
535 : : // ********** BEGIN INLINE FUNCTIONS **********
536 : : // ********** END INLINE FUNCTIONS **********
537 : :
538 : : // ********** BEGIN FRIEND FUNCTIONS **********
539 : : // ********** END FRIEND FUNCTIONS **********
540 : :
541 : : // ********** BEGIN EXTERN FUNCTIONS **********
542 : : // ********** END EXTERN FUNCTIONS **********
543 : :
544 : : // ********** BEGIN HELPER CLASS DECLARATIONS **********
545 : : // ********** END HELPER CLASS DECLARATIONS **********
546 : :
547 : : #endif
|
