Branch data Line data Source code
1 : : //-----------------------------------------------------------------------------
2 : : //
3 : : // File: CubitFacet.hpp
4 : : //
5 : : // Purpose: Facet Class used for mesh based geometry and other tools.
6 : : //
7 : : // Notes: A facet is a triangle used for defining surfaces. The
8 : : // default construction is a linear representation, although
9 : : // b-spline control points can be defined to represent a
10 : : // higher order triangular b-spline patch. There is also
11 : : // support for quad facets by using the CubitQuadFacet
12 : : //
13 : : // Note that the main private data components (ie. points, edges)
14 : : // are not contained in this class.
15 : : // This data should be defined within the child classes inherited
16 : : // from this class. The current Cubit data class that inherits
17 : : // from CubitFacet is CubitFacetData. This is done so that
18 : : // other applications using CubitFacets can use their own
19 : : // facet data, but take advantage of the CGM/Cubit functionality.
20 : : // Please do not add private data to this class unless it is only
21 : : // applicable to Cubit algorithms; instead add the
22 : : // data to the children and access through virtual functions.
23 : : //
24 : : // Do not create a CubitFacet directly. For example, don't do:
25 : : // CubitFacet *cf = new CubitFacet(...);
26 : : // You should instead create the appropriate child class, and
27 : : // cast it to a CubitFacet for use. For example:
28 : : // CubitFacet *cf = (CubitFacet *) new CubitFacetData(...);
29 : : //
30 : : //-----------------------------------------------------------------------------
31 : :
32 : : #ifndef CUBITFACET_HPP
33 : : #define CUBITFACET_HPP
34 : :
35 : : #include "CubitDefines.h"
36 : : #include "MemoryManager.hpp"
37 : : #include "DLIList.hpp"
38 : : #include "CubitBox.hpp"
39 : : #include "FacetEntity.hpp"
40 : : #include "CubitVector.hpp"
41 : : #include "CubitPlane.hpp"
42 : :
43 : : class CubitFacetEdge;
44 : : class CubitPoint;
45 : :
46 : : class CubitFacet : public FacetEntity
47 : : {
48 : : public:
49 : : static const int point_edge_conn[30][2];
50 : : static const int point_facet_conn[16][3];
51 : : static const double my_points[15][3];
52 : :
53 : : protected:
54 : :
55 : : CubitPlane *cachedPlane;
56 : : //- cached plane for this facet
57 : :
58 : : CubitBox bBox;
59 : : //- The bounding box for the facet
60 : :
61 : : double facetWeight;
62 : : //- for interpolation
63 : :
64 : : CubitVector *patchCtrlPts;
65 : : //- control points for triangular bezier batch
66 : :
67 : : int markedFlag;
68 : : //- generic marker for list sorting. Assume 0. Users must clean after use.
69 : :
70 : : int isFlat;
71 : : //- facet is flat
72 : :
73 : : int isBackwards;
74 : : //- facet is oriented backwards wrt. orientation of surface
75 : :
76 : : int toolID;
77 : : //- id of facet eval tool
78 : :
79 : : public:
80 : : CubitFacet();
81 : :
82 : : //------------------------------------------------------------------------
83 : : // The following functions are pure virtual and must be
84 : : // implemented in the child class (ie. CubitFacetData or equivalent)
85 : :
86 : : virtual ~CubitFacet();
87 : :
88 : : CubitVector normal();
89 : : //- Returns the normal to this facet.
90 : :
91 : : CubitVector update_normal( void );
92 : : //- update the plane and return the new normal
93 : :
94 : :
95 : 29634 : const CubitBox& bounding_box() {return bBox;};
96 : : void bounding_box( CubitBox &box )
97 : : { bBox = box; }
98 : : void reset_bounding_box();
99 : : //- returns/sets the bounding box of the facet
100 : :
101 : 3564 : void weight(double facweight) { facetWeight = facweight; }
102 : 7128 : double weight() { return facetWeight; }
103 : : //- get/set weight
104 : :
105 : : void get_control_points( CubitVector points[6] );
106 : : void set_control_points( CubitVector points[6] );
107 : : void set_control_points( const double *pt_array );
108 : 1584 : CubitVector *control_points() {return patchCtrlPts;};
109 : : //- get and set the bezier patch internal control points
110 : :
111 : 2288 : int eval_order()
112 [ + - ]: 2288 : { return (patchCtrlPts == NULL) ? 0 : 4; }
113 : : //- return the evaluation order of the facet. Currently only
114 : : //- order 0 (linear) and 4 (b-spline patch) are implemented
115 : :
116 : : virtual CubitPoint* point( int index ) = 0;
117 : : //Get the point at the specified index.
118 : : //asserts that the index is in range, for a
119 : : //triangle, 0 <= index <= 2.
120 : :
121 : 26532 : void marked(int mark) {markedFlag = mark;};
122 : 38522 : int marked() {return markedFlag;};
123 : : //- generic marking functions.
124 : :
125 : : int is_flat();
126 : 528 : void is_flat(int flat) {isFlat = flat;};
127 : : //- get/set isFlat
128 : :
129 : : const CubitPlane& plane();
130 : : void plane(CubitPlane &this_plane);
131 : : void update_plane();
132 : : //- Cache and return the plane containing this triangle.
133 : :
134 : 518694 : int is_backwards() {return isBackwards;};
135 : 528 : void is_backwards( int flipped ) { isBackwards = flipped; }
136 : : //- return whether the facet was reoriented
137 : :
138 : : virtual int id() = 0;
139 : : virtual void set_id( int ii ) = 0;
140 : 14344 : int tool_id(){return toolID;}
141 : 1584 : void set_tool_id(int tool_id){toolID = tool_id;}
142 : :
143 : : virtual CubitFacetEdge *edge( int index ) = 0;
144 : : virtual void edge( CubitFacetEdge *the_edge, int index ) = 0;
145 : : //- get and set edge pointers
146 : :
147 : : virtual void edge_use( int direction, int index ) = 0;
148 : : virtual int edge_use( int index ) = 0;
149 : : //- get and set the edge uses. Direction is 1 or -1 based
150 : : //- upon the orientation of the edge with respect to a CCW orientation
151 : : //- of the facet
152 : :
153 : : virtual void flip() = 0;
154 : : //- reorient the facet
155 : :
156 : : //---------------------------------------------------------------------
157 : : // The following virtual functions are optional. Implement them
158 : : // based upon the application's need. If they are called without
159 : : // being implemented, an assertion will occur.
160 : :
161 : 0 : virtual int sense(int /*index*/){ assert(0); return -1;}
162 : : //- Gives the direction of the edge given the edge index
163 : :
164 : : virtual CubitPoint* split_edge( CubitPoint* edge_pt1,
165 : : CubitPoint* edge_pt2,
166 : : const CubitVector& position );
167 : : //R CubitPoint
168 : : //R- The new CubitPoint created.
169 : : //I edge_pt1, edge_pt2
170 : : //I- The end points of an edge of this triangle.
171 : : //I position
172 : : //I- The position at which to split the edge.
173 : : //- Split an edge on this triangle and the other triangle
174 : : //- sharing the edge, if it exists.
175 : : //-
176 : : //- Note: No check is done on the location of the split
177 : : //- position.
178 : :
179 : : virtual CubitPoint* insert_point( const CubitVector& position,
180 : : CubitFacet*& new_tri1,
181 : : CubitFacet*& new_tri2 );
182 : : //R CubitPoint
183 : : //R- The new CubitPoint created.
184 : : //I position
185 : : //I- The position at which to insert a point in the triangle.
186 : : //O new_facet1, new_facet2
187 : : //O- The two new facets created.
188 : : //- Insert a point in the interior of this triangle.
189 : : //-
190 : : //- Note: No check is done on the location of the split
191 : : //- position.
192 : :
193 : : virtual CubitStatus closest_point( const CubitVector &point,
194 : : CubitVector &closest_point);
195 : : //- Sets the closest point on the plane defined by
196 : : //- this facet to the point in space.
197 : : //- If the normal length to the facet is 0, it will return CUBIT_FAILURE.
198 : :
199 : : //----------------------------------------------------------------------
200 : : // The following functions access the data in a child class
201 : :
202 : : CubitVector center();
203 : : //- Returns the center of the facet.
204 : :
205 : : void debug_draw(int color=-1, int flush_it = 1, int draw_uv=0);
206 : : //- draws the current facet.
207 : :
208 : : CubitStatus closest_point_trimmed( const CubitVector &point,
209 : : CubitVector &closest_point,
210 : : CubitPoint *&next_edge_p1,
211 : : CubitPoint *&next_edge_p2 );
212 : : //- returns the closest point on this facet to the point in space.
213 : : //- If the point is not in the facet, then the edge to which it was closest
214 : : //- will be set and returned. Other wise they will be "NULLED".
215 : :
216 : : void get_edge_1( CubitPoint *&p1, CubitPoint *&p2 )
217 : : { p1 = point(0); p2 = point(1);}
218 : : void get_edge_2( CubitPoint *&p1, CubitPoint *&p2 )
219 : : { p1 = point(1); p2 = point(2);}
220 : : void get_edge_3( CubitPoint *&p1, CubitPoint *&p2 )
221 : : { p1 = point(2); p2 = point(0);}
222 : : //- Get the points that define the three edges of the facet.
223 : : void get_edge_pts( int index, CubitPoint *&p1, CubitPoint *&p2 );
224 : : //- get the points that define an edge
225 : : //- The index of the edge corresponds to the point index on
226 : : //- the facet opposite the edge
227 : :
228 : : CubitFacetEdge *edge_from_pts( CubitPoint *p1, CubitPoint *p2, int &index );
229 : : //- return the edge pointer based on its end points
230 : : int edge_index( CubitPoint *p1, CubitPoint *p2, int &sense );
231 : : int edge_index( CubitFacetEdge *edge );
232 : : //- return the index of the edge on the facet
233 : : int point_index( CubitPoint *pt );
234 : : //- return the index of the point on the facet
235 : :
236 : : void opposite_edge( CubitPoint* point,
237 : : CubitPoint*& p1, CubitPoint*& p2 );
238 : : //- Get the edge on the triangle opposite of the passed point.
239 : : //- p1 and p2 will be passed back as NULL if point is not a
240 : : //- point on this triangle.
241 : :
242 : :
243 : : CubitPoint *opposite_point( CubitFacetEdge *edge );
244 : : //- returns the opposite point of input edge. Input edge should be incident on facet.
245 : : //- If input edge is not incident on facet then any of the one point can be returned
246 : :
247 : :
248 : 7238 : void points( CubitPoint *&p0, CubitPoint *&p1, CubitPoint *&p2 )
249 : 7238 : { p0 = point(0); p1 = point(1); p2 = point(2); }
250 : : void points( CubitPoint *pts[3] )
251 : : { pts[0] = point(0); pts[1] = point(1); pts[2] = point(2); }
252 : 0 : void tri_nodes( CubitPoint *&p0, CubitPoint *&p1, CubitPoint *&p2 )
253 : 0 : { points( p0, p1, p2); }
254 : 0 : void points(DLIList<CubitPoint*> &point_list )
255 [ # # ]: 0 : { for ( int i = 0; i < 3; i++ )
256 [ # # ]: 0 : point_list.append(point(i));
257 : 0 : }
258 : 1056 : void facets(DLIList<CubitFacet*> &facet_list )
259 [ + - ]: 1056 : { facet_list.append( this ); }
260 : 4268 : void edges(DLIList<CubitFacetEdge*> &edge_list )
261 [ + + ]: 17072 : { for ( int i = 0; i < 3; i++ )
262 [ + - ]: 12804 : edge_list.append(edge(i));
263 : 4268 : }
264 : :
265 : : CubitBoolean contains(CubitPoint *p1);
266 : : //- Returns TRUE/FALSE if the point defines this facet.
267 : :
268 : : CubitFacetEdge* shared_edge( CubitFacet *cubit_facet );
269 : :
270 : : CubitFacet* shared_facet( CubitPoint *p1, CubitPoint *p2 );
271 : : //- Returns the "other" facet attached to this edge. (if
272 : : //- there is one., other wise returns NULL).
273 : : void shared_facets( CubitPoint *p1, CubitPoint *p2,
274 : : DLIList <CubitFacet *> &adj_facet_list);
275 : : //- Returns all adjacent facets to this edge (not including
276 : : //- this facet)
277 : :
278 : : CubitFacet *adjacent( int &index, int *tool_data )
279 : : //- Returns all adjacent facets to this edge index(not including
280 : : //- this facet)
281 : : {
282 : : //convert MESHING TRI edge index to GEOMETRY FACET edge index
283 : : index = (index+2)%3;
284 : : CubitPoint *p1, *p2;
285 : :
286 : : get_edge_pts( index, p1, p2 );
287 : : return shared_facet_on_surf( p1, p2, *tool_data );
288 : : }
289 : :
290 : 0 : CubitPoint* next_node(CubitPoint *current_point)
291 : : {
292 : 0 : int index = point_index(current_point);
293 : 0 : return point((index+1)%3);
294 : : }
295 : : //- return the adjacent triangle at the edge index
296 : : CubitFacet* shared_facet_on_surf( CubitPoint *p1, CubitPoint *p2, int tool_id );
297 : : //- same as above except also matches tool_id with toolID
298 : :
299 : : double min_diagonal();
300 : : //- Returns the length of the minimum diagonal of the triangle.
301 : :
302 : : double angle( CubitPoint *pt );
303 : : //- return the angle (radians) at one of the points on the facet
304 : :
305 : : void update_bezier_bounding_box( );
306 : : //- Update the facet bounding box based on its control polygon
307 : :
308 : : CubitFacetEdge *prev_edge( CubitFacetEdge *edge );
309 : : CubitFacetEdge *next_edge( CubitFacetEdge *edge );
310 : : //- return the prvious or next edge on the facet
311 : :
312 : : int other_index( CubitPoint* pt1, CubitPoint* pt2 );
313 : :
314 : : CubitStatus evaluate_position( const CubitVector &start_position,
315 : : CubitVector *eval_point,
316 : : CubitVector *eval_normal = NULL );
317 : :
318 : : CubitStatus evaluate( CubitVector &areacoord,
319 : : CubitVector *eval_point,
320 : : CubitVector *eval_normal = NULL );
321 : :
322 : 0 : void get_parents(DLIList<FacetEntity *> &){};
323 : : // dummy for this class
324 : :
325 : : CubitFacetEdge *next_edge_at_point( CubitFacetEdge *edge_ptr,
326 : : CubitPoint *point_ptr );
327 : : // return the next edge on the triangle at the point
328 : :
329 : : CubitStatus get_edge_control_points( CubitVector P[3][5] );
330 : : // get the control points on the facet edges
331 : :
332 : : double area();
333 : : // return the area of the facet
334 : :
335 : : double aspect_ratio();
336 : :
337 : :
338 : : CubitStatus init_patch( );
339 : : // computes the interior control points for the facet and
340 : : // stores them with the facet. Assumes edge control points
341 : : // have already been computed
342 : :
343 : : void add_edge(CubitFacetEdge *edge);
344 : : //- add an existing edge to a facet
345 : :
346 : : void unlink_from_children( void );
347 : :
348 : : };
349 : :
350 : : inline void CubitFacet::plane(CubitPlane &this_plane)
351 : : {
352 : : this_plane = plane();
353 : : }
354 : :
355 : : template <> struct DLIListSorter<CubitFacet*>
356 : : {
357 : : bool operator()(CubitFacet* a, CubitFacet* b) { return a->id() < b->id(); }
358 : : };
359 : :
360 : : #endif
361 : :
362 : :
|
