Branch data Line data Source code
1 : : //-----------------------------------------------------------------------------
2 : : //
3 : : // File: CubitFacetEdge.hpp
4 : : //
5 : : // Purpose: optionally used with the CubitFacet class if information
6 : : // is required at the edges of facets
7 : : //
8 : : // Notes: Note that this class does not contain any private data.
9 : : // All data should be defined within the child classes inherited
10 : : // from this class. The current Cubit data class that inherits
11 : : // from CubitFacetEdge is CubitFacetEdgeData. This is done so that
12 : : // other applications using CubitFacetEdges can use their own
13 : : // edge data, but take advantage of the CGM/Cubit functionality.
14 : : // Please do not add private data to this class; instead add the
15 : : // data to the children and access through virtual functions.
16 : : //
17 : : // Do not create a CubitFacetEdge directly. For example, don't do:
18 : : // CubitFacetEdge *cfe = new CubitFacetEdge(...);
19 : : // You should instead create the appropriate child class, and
20 : : // cast it to a CubitFacetEdge for use. For example:
21 : : // CubitFacetEdge *cfe = (CubitFacetEdge *) new CubitFacetEdgeData(...);
22 : : //
23 : : //-----------------------------------------------------------------------------
24 : :
25 : : #ifndef CUBITFACETEDGE_HPP
26 : : #define CUBITFACETEDGE_HPP
27 : :
28 : : // Include for CubitBoolean
29 : : #include "CubitDefines.h"
30 : : #include "CubitVector.hpp"
31 : : #include "DLIList.hpp"
32 : : #include "FacetEntity.hpp"
33 : :
34 : : class CubitFacet;
35 : : class CubitPoint;
36 : : class CubitBox;
37 : :
38 : : class CubitFacetEdge : public FacetEntity
39 : : {
40 : : private:
41 : :
42 : : protected:
43 : :
44 : : CubitVector controlPoints[3];
45 : : //- bezier points on the edge
46 : :
47 : : int bezierOrder;
48 : : //- bezier order
49 : :
50 : : int markedFlag;
51 : : //- marked flag
52 : :
53 : : IttyBit isFeature;
54 : : //- set if this edge is a feature
55 : :
56 : : CubitBoolean isFlipped;
57 : :
58 : : public:
59 : : CubitFacetEdge();
60 : : //- constructors
61 : : virtual ~CubitFacetEdge();
62 : : //- destructor
63 : : virtual int id() = 0;
64 : 0 : virtual void set_id(int /*ent_id*/) {};
65 : :
66 : 0 : int is_flipped()
67 : : {
68 [ # # ]: 0 : if(isFlipped)
69 : 0 : return 1;
70 : 0 : return 0;
71 : : }
72 : : void is_flipped ( int flipped)
73 : : {
74 : : if(flipped)
75 : : isFlipped = CUBIT_TRUE;
76 : : else
77 : : isFlipped = CUBIT_FALSE;
78 : : }
79 : :
80 : 44 : void toggle_is_flipped()
81 : : {
82 : 44 : isFlipped = !isFlipped;
83 : 44 : }
84 : :
85 : :
86 : : virtual CubitPoint *point( int index ) = 0;
87 : : //- get one of its points
88 : : virtual CubitFacet *adj_facet( int index) = 0;
89 : : //- get one of its adjacent facets
90 : 0 : virtual int bezier_order() {return bezierOrder;};
91 : : virtual int control_points( CubitVector *ctrl_pts );
92 : : //- get the control points (return the order)
93 : 2596 : virtual CubitVector *control_points() { return controlPoints; };
94 : : virtual void control_points( CubitVector *ctrl_pts, int order );
95 : : //- set the bezier control points on the edge.
96 : : //- end points are assumed to be the first and last
97 : : //- ctrl pt so they are not passed in. Pass in order-1
98 : : //- control points (max order = 4)
99 : : virtual CubitStatus control_points( CubitFacet *facet, CubitVector *ctrl_pts );
100 : : //- return the control pons on the edge of a facet based
101 : : //- on its edge use direction
102 : : virtual void get_control_points( CubitPoint *point_ptr, CubitVector ctrl_pts[3] );
103 : : virtual void set_control_points( CubitPoint *point_ptr, CubitVector ctrl_pts[3] );
104 : : //- get and set control points oriented with respect to the
105 : : //- point_ptr (ie. point_ptr is the first control point on the edge)
106 : : //- Note: only gets and sets the middle three control points. The
107 : : //- other 2 are the edge vertices.
108 : : void set_control_points( const double *ctrl_pt_array );
109 : 38654 : virtual void set_flag( int my_flag ) {markedFlag = my_flag;};
110 : 31548 : virtual int get_flag( ) {return markedFlag;};
111 : : virtual void facets(DLIList<CubitFacet*> &facet_list ) = 0;
112 : : virtual void edges(DLIList<CubitFacetEdge*> &edge_list ) = 0;
113 : : virtual void points(DLIList<CubitPoint*> &point_list ) = 0;
114 : : virtual int num_adj_facets() = 0;
115 : : void tris(DLIList<CubitFacet*> &facet_list){ facets(facet_list); }
116 : : void tris(int* /*tool_id*/,
117 : : DLIList<CubitFacet*> &facet_list){ facets(facet_list); }
118 : :
119 : :
120 : : //- Implement in the child class if need be.
121 : : //- Assertion will occur if not implemented in the child class
122 : 0 : virtual void add_facet(CubitFacet * /*facet_ptr*/){ assert(0); }
123 : : virtual CubitStatus remove_facet(CubitFacet * /*facet_ptr*/) = 0;
124 : : virtual CubitPoint *start_node() = 0;
125 : : virtual CubitPoint *end_node() = 0;
126 : : virtual void flip() = 0;
127 : :
128 : 0 : virtual int number_tris() { return num_adj_facets(); }
129 : 0 : virtual int number_faces() { return 0; }
130 : :
131 : 0 : virtual void marked (int my_flag ) { set_flag(my_flag); }
132 : 0 : virtual int marked() { return get_flag(); }
133 : :
134 : :
135 : : CubitStatus evaluate_position( const CubitVector &start_position,
136 : : CubitVector *eval_point,
137 : : CubitVector *eval_tangent);
138 : : //- find closet point on non-linear edge
139 : : CubitStatus evaluate( double &t,
140 : : CubitVector *eval_point,
141 : : CubitVector *eval_tangent );
142 : : CubitStatus evaluate_single(double &t,
143 : : CubitVector *outv);
144 : : CubitStatus evaluate_single_tangent(double &t,
145 : : CubitVector *outv);
146 : : CubitStatus evaluate_2nd_derivative(double &t,
147 : : CubitVector *outv);
148 : : //- evaluate location -1 < t < 1
149 : : CubitStatus closest_point(const CubitVector &point,
150 : : CubitVector &closest_point );
151 : : //- return closest point to linear segment
152 : :
153 : : CubitStatus intersect(CubitVector &aa, CubitVector &bb, // end point of segment
154 : : CubitVector &norm, // normal of the common plane
155 : : CubitVector &qq, // return the intersection point
156 : : CubitBoolean &does_intersect );
157 : : // intersect the edge with a segment. Assumes segment and edge
158 : : // are on the same plane (project to facet plane first)
159 : :
160 : : void boundary_edge_points( CubitPoint * &pt0,
161 : : CubitPoint * &pt1,
162 : : int tool_id = 0);
163 : : // return oriented points on a boundary facet edge
164 : :
165 : : double dist_to_edge( const CubitVector &this_point,
166 : : CubitVector &close_point,
167 : : CubitBoolean &outside_edge );
168 : : // return distance from point to an edge
169 : :
170 : : CubitStatus proj_to_line( const CubitVector &this_point,
171 : : CubitVector &proj_point );
172 : : // project point to line defined by edge
173 : :
174 : : CubitStatus edge_tangent( const CubitVector &point_on_edge,
175 : : CubitVector &tangent );
176 : : // compute tangent vector of edge
177 : : CubitStatus edge_curvature( const CubitVector &point_on_edge,
178 : : CubitVector &curvature,
179 : : CubitFacetEdge *closest_edge );
180 : : // compute curvature vector of edge
181 : : double length();
182 : :
183 : : CubitVector position_from_fraction( double zero_to_one );
184 : 0 : CubitVector center() { return position_from_fraction(0.5); }
185 : :
186 : : // compute and return the edge length
187 : : CubitPoint* other_point( CubitPoint *point_ptr );
188 : : // return the other point on the facet edge
189 : :
190 : : void get_parents(DLIList<FacetEntity *> &facet_list);
191 : : // return the adjacent facets to edge
192 : :
193 : : CubitFacet *other_facet( CubitFacet *facet_ptr );
194 : : // return the other facet at the edge
195 : :
196 : : CubitFacet *other_facet_on_surf( CubitFacet *facet_ptr );
197 : : // return the other facet at the edge that has the
198 : : // same tool id
199 : :
200 : : int num_adj_facets_on_surf( int tool_id );
201 : : // return number of adjacent facets with the indicated
202 : : // tool id
203 : :
204 : : CubitFacet *adj_facet_on_surf( int tool_id );
205 : : // return first facet adjacent the edge with the
206 : : // indicated tool id
207 : :
208 : : CubitBoolean contains( CubitPoint *point_ptr );
209 : : //- determines if point is contained in edge
210 : :
211 : 748 : void set_as_feature() { isFeature = 1; }
212 [ + + ]: 12716 : CubitBoolean is_feature( ){return (isFeature ? CUBIT_TRUE : CUBIT_FALSE); }
213 : : // set and get the isFeature bit
214 : :
215 : : void debug_draw(int color = -1, int flush = 1, int draw_uv=0);
216 : : // debug drawing
217 : :
218 : : CubitPoint *shared_point( CubitFacetEdge *edge_ptr );
219 : : // get the common point
220 : : void add_facets( );
221 : : // add this edge to its adjacent facets
222 : :
223 : : CubitBox bounding_box();
224 : : // return the bounding box of the edge
225 : :
226 : : static int intersect_2D_segments( double P0[2], double P1[2],
227 : : double P2[2], double P3[2],
228 : : double qq[4] );
229 : : static int intersect_intervals( double u0, double u1,
230 : : double v0, double v1,
231 : : double w[2] );
232 : : static CubitStatus order_edge_list(DLIList<CubitFacetEdge*> &edge_list,
233 : : CubitPoint *start_point,
234 : : CubitPoint *&end_point);
235 : : static CubitPoint *find_start_point_for_edge_list(DLIList<CubitFacetEdge*> edge_list);
236 : :
237 : : double angle_between_facets();
238 : :
239 : : inline int less_than(CubitFacetEdge*& e1, CubitFacetEdge*& e2)
240 : : {
241 : : double len1 = e1->length();
242 : : double len2 = e2->length();
243 : :
244 : : if (len1 == len2) return 0;
245 : : return (len1 < len2) ? -1 : 1;
246 : : }
247 : :
248 : : };
249 : :
250 : 462 : inline void CubitFacetEdge::control_points(
251 : : CubitVector *ctrl_pts, int order )
252 : : {
253 [ + - ][ - + ]: 462 : assert(order > 0 && order <=4);
254 : 462 : bezierOrder = order;
255 [ + + ]: 1848 : for(int i=0; i<order-1; i++){
256 : 1386 : controlPoints[i] = ctrl_pts[i];
257 : : }
258 : 462 : }
259 : :
260 : : //======================================================================
261 : : // Function: get_control_points (PUBLIC)
262 : : // Description: get control points oriented with respect to the
263 : : // point_ptr (ie. point_ptr is the first control point
264 : : // on the edge)
265 : : // Note: only gets and sets the middle three control points. The
266 : : // other 2 are the edge vertices.
267 : : // Author: sjowen
268 : : // Date: 05/01
269 : : //======================================================================
270 : 0 : inline void CubitFacetEdge::get_control_points( CubitPoint *point_ptr,
271 : : CubitVector ctrl_pts[3] )
272 : : {
273 [ # # ]: 0 : DLIList<CubitPoint*> my_points;
274 [ # # ]: 0 : points(my_points);
275 : :
276 [ # # ][ # # ]: 0 : if (point_ptr == my_points.get())
277 : : {
278 [ # # ]: 0 : ctrl_pts[0] = controlPoints[0];
279 [ # # ]: 0 : ctrl_pts[1] = controlPoints[1];
280 [ # # ]: 0 : ctrl_pts[2] = controlPoints[2];
281 : : }
282 [ # # ][ # # ]: 0 : else if(point_ptr == my_points.next())
283 : : {
284 [ # # ]: 0 : ctrl_pts[0] = controlPoints[2];
285 [ # # ]: 0 : ctrl_pts[1] = controlPoints[1];
286 [ # # ]: 0 : ctrl_pts[2] = controlPoints[0];
287 : : }
288 : : else
289 : : {
290 : 0 : assert(0); // point_ptr does not match either point
291 [ # # ]: 0 : }
292 : 0 : }
293 : :
294 : : //======================================================================
295 : : // Function: set_control_points (PUBLIC)
296 : : // Description: set control points oriented with respect to the
297 : : // point_ptr (ie. point_ptr is the first control point
298 : : // on the edge)
299 : : // Note: only gets and sets the middle three control points. The
300 : : // other 2 are the edge vertices.
301 : : // Author: sjowen
302 : : // Date: 05/01
303 : : //======================================================================
304 : 0 : inline void CubitFacetEdge::set_control_points( CubitPoint *point_ptr,
305 : : CubitVector ctrl_pts[3] )
306 : : {
307 [ # # ]: 0 : DLIList<CubitPoint*> my_points;
308 [ # # ]: 0 : points(my_points);
309 : :
310 [ # # ][ # # ]: 0 : if (point_ptr == my_points.get())
311 : : {
312 [ # # ]: 0 : controlPoints[0] = ctrl_pts[0];
313 [ # # ]: 0 : controlPoints[1] = ctrl_pts[1];
314 [ # # ]: 0 : controlPoints[2] = ctrl_pts[2];
315 : : }
316 [ # # ][ # # ]: 0 : else if(point_ptr == my_points.next())
317 : : {
318 [ # # ]: 0 : controlPoints[0] = ctrl_pts[2];
319 [ # # ]: 0 : controlPoints[1] = ctrl_pts[1];
320 [ # # ]: 0 : controlPoints[2] = ctrl_pts[0];
321 : : }
322 : : else
323 : : {
324 : 0 : assert(0); // point_ptr does not match either point
325 [ # # ]: 0 : }
326 : 0 : }
327 : :
328 : : template <> struct DLIListSorter<CubitFacetEdge*>
329 : : {
330 : : bool operator()(CubitFacetEdge* a, CubitFacetEdge* b) { return a->id() < b->id(); }
331 : : };
332 : :
333 : : #endif
334 : :
335 : :
|
