Branch data Line data Source code
1 : : #ifndef CUBITFACETDATA_HPP
2 : : #define CUBITFACETDATA_HPP
3 : :
4 : : // Include for CubitBoolean
5 : : #include "CubitDefines.h"
6 : : #include "MemoryManager.hpp"
7 : : #include "CubitPoint.hpp"
8 : : #include "DLIList.hpp"
9 : : #include "CubitBox.hpp"
10 : : #include "CubitFacet.hpp"
11 : : class CubitVector;
12 : : class CubitBox;
13 : : class CubitPlane;
14 : : class CubitFacetEdge;
15 : :
16 : : class CubitFacetData : public CubitFacet
17 : : {
18 : : private:
19 : : CubitPoint *pointArray[3];
20 : : CubitFacetEdge *edgeArray[3];
21 : : int edgeUse[3];
22 : : static MemoryManager memoryManager;
23 : : //- memory management object
24 : : int entityId;
25 : : //- for debug tracking...
26 : : void allocate_edge(CubitPoint *p1, CubitPoint *p2, int edge_index);
27 : : void define_point(CubitFacetEdge *e1, CubitFacetEdge *e2,
28 : : int point_index);
29 : : void define_bounding_box();
30 : :
31 : : public:
32 : : CubitFacetData( CubitPoint *p1, CubitPoint *p2,
33 : : CubitPoint *p3);
34 : : CubitFacetData( CubitPoint *p1, CubitPoint *p2,
35 : : CubitPoint *p3, int *tool_data);
36 : : CubitFacetData( CubitFacetEdge *e1, CubitFacetEdge *e2,
37 : : CubitFacetEdge *e3);
38 : : ~CubitFacetData();
39 : :
40 : : void destruct_facet_internals();
41 : :
42 : 5016 : virtual int id(){return entityId;}
43 : 792 : virtual void set_id( int ii ) { entityId = ii; }
44 : :
45 : 3168 : SetDynamicMemoryAllocation(memoryManager)
46 : : //- class specific new and delete operators
47 : : CubitStatus closest_point( const CubitVector &point,
48 : : CubitVector &closest_point);
49 : : //- Sets the closest point on the plane defined by
50 : : //- this facet to the point in space.
51 : : //- If the normal length to the facet is 0, it will return CUBIT_FAILURE.
52 : :
53 : : CubitPoint* point( int index );
54 : : //Get the point at the specified index.
55 : : //asserts that the index is in range, for a
56 : : //triangle, 0 <= index <= 2.
57 : :
58 : :
59 : : void set_point( CubitPoint *the_point, int index );
60 : : //- sets the point into the facet.
61 : :
62 : : CubitFacetEdge *edge( int index );
63 : : void edge( CubitFacetEdge *the_edge, int index );
64 : : //- get and set edge pointers
65 : :
66 : : void edge_use( int direction, int index );
67 : : int edge_use( int index );
68 : : //- get and set the edge uses
69 : : int sense(int index);
70 : :
71 : : CubitPoint* split_edge( int edge_index, const CubitVector& position );
72 : : CubitPoint* split_edge( CubitPoint* edge_pt1, CubitPoint* edge_pt2,
73 : : const CubitVector& position );
74 : : //R CubitPoint
75 : : //R- The new CubitPoint created.
76 : : //I edge_pt1, edge_pt2
77 : : //I- The end points of an edge of this triangle.
78 : : //I position
79 : : //I- The position at which to split the edge.
80 : : //O new_facet1
81 : : //O- The new facet resulting from splitting the edge on
82 : : //O- this triangle.
83 : : //O new_facet2
84 : : //O- The new facet resulting from splitting the same edge
85 : : //O- on the ajacent triangle. If there is no other
86 : : //O- triangle sharing the edge, NULL will be passed back.
87 : : //- Split an edge on this triangle and the other triangle
88 : : //- sharing the edge, if it exists.
89 : : //-
90 : : //- Note: No check is done on the location of the split
91 : : //- position.
92 : :
93 : : CubitPoint* insert_point( const CubitVector& position,
94 : : CubitFacet*& new_tri1,
95 : : CubitFacet*& new_tri2 );
96 : : //R CubitPoint
97 : : //R- The new CubitPoint created.
98 : : //I position
99 : : //I- The position at which to insert a point in the triangle.
100 : : //O new_facet1, new_facet2
101 : : //O- The two new facets created.
102 : : //- Insert a point in the interior of this triangle.
103 : : //-
104 : : //- Note: No check is done on the location of the split
105 : : //- position.
106 : :
107 : : CubitStatus flip_edge( int edge_index );
108 : : CubitStatus flip_edge( CubitFacetEdge *edge );
109 : : //- Given an edge shared by exactly two facets,
110 : : //- flip the edge such that it connects the
111 : : //- "other" two facet points instead.
112 : : //-
113 : : //- *----* *----*
114 : : //- |\ | | /|
115 : : //- | \ | ==> | / |
116 : : //- | \ | | / |
117 : : //- | \| |/ |
118 : : //- *----* *----*
119 : : //-
120 : : //- NOTE: If you are trying to reverse the sense of
121 : : //- an edge, this is NOT the function you want!
122 : :
123 : : void flip();
124 : : //- reorient the facet
125 : :
126 : : };
127 : :
128 : :
129 : 144452 : inline CubitPoint* CubitFacetData::point( int index )
130 : : {
131 [ + - ][ - + ]: 144452 : assert( (index >= 0) && (index < 3) );
132 [ + - ]: 144452 : if (!is_backwards())
133 : 144452 : return pointArray[index];
134 : : else
135 : : {
136 [ # # # # ]: 0 : switch(index)
137 : : {
138 : 0 : case 0: return pointArray[0];
139 : 0 : case 1: return pointArray[2];
140 : 0 : case 2: return pointArray[1];
141 : : }
142 : : }
143 : 0 : return NULL;
144 : : }
145 : :
146 : 0 : inline void CubitFacetData::set_point( CubitPoint* the_point, int index )
147 : : {
148 [ # # ][ # # ]: 0 : assert( (index >= 0) && (index < 3) );
149 [ # # ]: 0 : if (!is_backwards())
150 : 0 : pointArray[index] = the_point;
151 : : else
152 : : {
153 [ # # # # ]: 0 : switch(index)
154 : : {
155 : 0 : case 0: pointArray[0] = the_point; break;
156 : 0 : case 1: pointArray[2] = the_point; break;
157 : 0 : case 2: pointArray[1] = the_point; break;
158 : : }
159 : : }
160 : 0 : }
161 : :
162 : 105039 : inline CubitFacetEdge* CubitFacetData::edge( int index )
163 : : {
164 [ + - ][ - + ]: 105039 : assert( (index >= 0) && (index < 3) );
165 [ + - ]: 105039 : if (!is_backwards()) {
166 : 105039 : return edgeArray[index];
167 : : }
168 : : else
169 : : {
170 [ # # # # ]: 0 : switch(index)
171 : : {
172 : 0 : case 0:return edgeArray[0];
173 : 0 : case 1:return edgeArray[2];
174 : 0 : case 2:return edgeArray[1];
175 : : }
176 : : }
177 : 0 : return NULL;
178 : : }
179 : :
180 : :
181 : 3168 : inline void CubitFacetData::edge( CubitFacetEdge *the_edge, int index )
182 : : {
183 [ + - ][ - + ]: 3168 : assert( (index >= 0) && (index < 3) );
184 [ + - ]: 3168 : if (!is_backwards())
185 : 3168 : edgeArray[index] = the_edge;
186 : : else
187 : : {
188 [ # # # # ]: 0 : switch(index)
189 : : {
190 : 0 : case 0: edgeArray[0] = the_edge; break;
191 : 0 : case 1: edgeArray[2] = the_edge; break;
192 : 0 : case 2: edgeArray[1] = the_edge; break;
193 : : }
194 : : }
195 : 3168 : }
196 : :
197 : 2420 : inline int CubitFacetData::edge_use( int index )
198 : : {
199 [ + - ][ - + ]: 2420 : assert( (index >= 0) && (index < 3) );
200 [ + - ]: 2420 : if (!is_backwards())
201 : 2420 : return edgeUse[index];
202 : : else
203 : : {
204 [ # # # # ]: 0 : switch(index)
205 : : {
206 : 0 : case 0: return -edgeUse[0];
207 : 0 : case 1: return -edgeUse[2];
208 : 0 : case 2: return -edgeUse[1];
209 : : }
210 : : }
211 : 0 : return 0;
212 : : }
213 : :
214 : : //- This function is defined so that Meshing and Geometry Entities
215 : : //- return the same values as needed in the FacetorTool
216 : 0 : inline int CubitFacetData::sense( int index ) {
217 [ # # ]: 0 : if(edge_use(index) == 1)
218 : 0 : return CUBIT_FORWARD;
219 [ # # ]: 0 : else if(edge_use(index) == -1)
220 : 0 : return CUBIT_REVERSED;
221 : : else
222 : 0 : return CUBIT_UNKNOWN;
223 : : }
224 : :
225 : 3212 : inline void CubitFacetData::edge_use( int direction, int index )
226 : : {
227 [ + - ][ - + ]: 3212 : assert( (index >= 0) && (index < 3) );
228 [ + - ]: 3212 : if (!is_backwards())
229 : 3212 : edgeUse[index] = direction;
230 : : else
231 : : {
232 [ # # # # ]: 0 : switch(index)
233 : : {
234 : 0 : case 0: edgeUse[0] = -direction; break;
235 : 0 : case 1: edgeUse[2] = -direction; break;
236 : 0 : case 2: edgeUse[1] = -direction; break;
237 : : }
238 : : }
239 : 3212 : }
240 : :
241 : : #endif
242 : :
243 : :
|
