Branch data Line data Source code
1 : : //-----------------------------------------------------------------------------
2 : : //
3 : : // File: CubitPoint.hpp
4 : : //
5 : : // Purpose: Point Class used for mesh based geometry and other tools. It is
6 : : // primarily used in conjuction with CubitFacet and CubitFacetEdge
7 : : // classes.
8 : : //
9 : : // Notes: Note that this class does not contain any private data.
10 : : // All data should be defined within the child classes inherited
11 : : // from this class. The current Cubit data class that inherits
12 : : // from CubitPoint is CubitPointData. This is done so that
13 : : // other applications using CubitPoints can use their own
14 : : // point data, but take advantage of the CGM/Cubit functionality.
15 : : // Please do not add private data to this class; instead add the
16 : : // data to the children and access through virtual functions.
17 : : //
18 : : // Do not create a CubitPoint directly. For example, don't do:
19 : : // CubitPoint *cp = new CubitPoint(...);
20 : : // You should instead create the appropriate child class, and
21 : : // cast it to a CubitPoint for use. For example:
22 : : // CubitPoint *cp = (CubitPoint *) new CubitPointData(...);
23 : : //
24 : : //-----------------------------------------------------------------------------
25 : :
26 : : #ifndef CUBITPOINT_HPP
27 : : #define CUBITPOINT_HPP
28 : :
29 : : // Include for CubitBoolean
30 : : #include "CubitDefines.h"
31 : : #include "CubitVector.hpp"
32 : : #include "DLIList.hpp"
33 : : #include "MemoryManager.hpp"
34 : : #include "ToolDataUser.hpp"
35 : : #include "CubitMatrix.hpp"
36 : : #include "FacetEntity.hpp"
37 : : class CubitFacet;
38 : : class CubitQuadFacet;
39 : : class CubitFacetEdge;
40 : : class CubitPoint;
41 : : class CubitTransformMatrix;
42 : : class Surface;
43 : : class CubitBox;
44 : :
45 : : class CubitPoint : public FacetEntity
46 : : {
47 : : private:
48 : :
49 : : static double boxTol;
50 : :
51 : : protected:
52 : :
53 : : int markedFlag;
54 : : //-generic marking flag.
55 : :
56 : : CubitVector *surfNormal;
57 : : //- The normalized surface normal (if required)
58 : :
59 : : double dCoef;
60 : : //- D coeficient in tangent plane equation Ax+By+Cz+D=0
61 : : //- where A,B,C is surfNormal
62 : :
63 : : double uVal, vVal, sizeVal;
64 : : //- parametric location of point
65 : :
66 : : CubitVector *surfU, *surfV;
67 : : //- Orthogonal surface tangent vectors at the point
68 : :
69 : : double *coefVector;
70 : : //- coefficients for quadric surface approximation
71 : :
72 : : IttyBit isFeature;
73 : : //- set if this point is a feature
74 : :
75 : : public:
76 : :
77 : : CubitPoint();
78 : : virtual ~CubitPoint();
79 : :
80 : : virtual int id() = 0;
81 : 0 : virtual void set_id( int ) {};
82 : :
83 : : virtual double x() = 0;
84 : : virtual double y() = 0;
85 : : virtual double z() = 0;
86 : : virtual void set( const CubitVector &pos ) = 0;
87 : :
88 : 0 : virtual void marked(int marked) {markedFlag = marked;};
89 : 0 : virtual int marked() {return markedFlag;};
90 : :
91 : : virtual CubitVector coordinates() const = 0;
92 : : virtual void coordinates(double point_array[3]) = 0;
93 : :
94 : : virtual void add_facet( CubitFacet *facet) = 0;
95 : : virtual void remove_facet( CubitFacet *facet) = 0;
96 : : virtual int num_adj_facets() = 0;
97 : :
98 : : virtual void facets( DLIList<CubitFacet*> &facet_list ) = 0;
99 : : virtual void edges( DLIList<CubitFacetEdge*> &edge_list ) = 0;
100 : : virtual void points( DLIList<CubitPoint*> &point_list ) = 0;
101 : :
102 : 0 : virtual void tris( DLIList<CubitFacet*> &facet_list ) { facets(facet_list); }
103 : :
104 : : virtual void normal( CubitVector &surf_norm );
105 : : virtual CubitVector normal();
106 : : virtual CubitVector* normal_ptr();
107 : :
108 : : virtual void set_normal( CubitVector &surf_norm );
109 : : virtual void reset_normal( );
110 : :
111 : 264 : virtual void d_coef( const double d_coefficient ) {dCoef = d_coefficient;};
112 : 0 : virtual double d_coef() {return dCoef;};
113 : :
114 : 1320 : virtual double u() { return uVal; };
115 : 1320 : virtual double v() { return vVal; };
116 : 1320 : virtual double size() {return sizeVal; };
117 : 0 : virtual void set_uv( double u, double v ) { uVal = u; vVal = v; };
118 : 308 : virtual void set_uvs(double u, double v, double s) {uVal = u; vVal = v; sizeVal = s; }
119 : : //- get and set the u-v coordinates (careful with internal boundaries - see TDFacetBoundarPoint)
120 : : virtual CubitStatus get_uv( CubitFacet *facet, double &u, double &v );
121 : : virtual CubitStatus get_uvs( CubitFacet *facet, double &u, double &v, double &s);
122 : : //- return the u-v coords with respect to the surface that the facet is on
123 : :
124 : : virtual void du( CubitVector &duvec );
125 : : virtual CubitVector du();
126 : :
127 : : virtual void dv( CubitVector &dvvec );
128 : : virtual CubitVector dv();
129 : :
130 : : virtual double *coef_vector( );
131 : : virtual void coef_vector( const CubitMatrix& coef );
132 : :
133 : : virtual CubitStatus merge_points( CubitPoint *cp, CubitBoolean keep_point = CUBIT_FALSE );
134 : :
135 : : void shared_facets( CubitPoint* other_point,
136 : : CubitFacet*& facet1,
137 : : CubitFacet*& facet2 );
138 : :
139 : : void shared_facets( CubitPoint* other_point,
140 : : DLIList<CubitFacet*>& result_list );
141 : :
142 : : CubitFacetEdge *shared_edge( CubitPoint* other_point );
143 : :
144 : :
145 : : void adjacent_points( CubitPoint **adj_points,
146 : : int &num_adj_points );
147 : : void adjacent_points( DLIList<CubitPoint*>& result_list );
148 : : //- return array of points sharing adjacent facets
149 : :
150 : : CubitBox bounding_box();
151 : : //-return a box around this point
152 : :
153 : : void facets_on_surf( int surf_id, DLIList<CubitFacet *> &facet_list,
154 : : CubitBoolean &on_internal_boundary );
155 : : //- return facets adjacent this point that are on the given surface
156 : : //- surf_id is the FacetEvalTool ToolID
157 : :
158 : : CubitVector normal( CubitFacet *facet_ptr );
159 : : CubitVector normal( CubitQuadFacet *qfacet_ptr );
160 : : CubitVector normal( CubitFacetEdge *edge_ptr );
161 : : //- return normal with respect to the facet and edge
162 : :
163 : : CubitVector tangent( CubitFacetEdge *edge_ptr, double mindot );
164 : : //- return tangent with respect to the edge
165 : : void next_feature_edges( CubitFacetEdge *this_edge_ptr,
166 : : DLIList <CubitFacetEdge *> feature_edge_list );
167 : : //- given a facet boundary edge and this point, get a list
168 : : //- of the next fetaure edges at this point
169 : :
170 : : CubitVector project_to_tangent_plane( CubitVector &pt );
171 : : //- Project a point to the tangent plane defined at the CubitPoint
172 : :
173 : : void transform_to_local( CubitVector &glob_vec,
174 : : CubitVector &loc_vec );
175 : : void transform_to_global( CubitVector &loc_vec,
176 : : CubitVector &glob_vec );
177 : : //- transform a point between local and global system
178 : :
179 : : void define_tangent_vectors();
180 : : //- set up the tangent vectors at the point for quadratic interpolation
181 : :
182 : : void get_parents( DLIList<FacetEntity*> &facet_list );
183 : :
184 : : void debug_draw( int color = -1, int flush = 1, int draw_uv=0 );
185 : : // debug drawing
186 : :
187 : : void compute_avg_normal();
188 : : //- compute the avg normal at this point based on adjacent facets
189 : :
190 : : CubitFacetEdge *get_edge( CubitPoint *other_point );
191 : : //- return the edge between two points if one exists
192 : :
193 : : void transform(CubitTransformMatrix &tfmat);
194 : : void rotate_normal(CubitTransformMatrix &rotmat);
195 : : //- apply transformations to the point
196 : :
197 : : CubitStatus check_inverted_facets( const CubitVector& new_position );
198 : : //- Check if moving this CubitPoint to the passed position
199 : : //- will invert any adjacent facets. Returns true if no facets
200 : : //- will be inverted, false if one or more facets will be
201 : : //- inerted when the point is moved.
202 : :
203 : 2244 : void set_as_feature() { isFeature = 1; }
204 [ + + ]: 3696 : CubitBoolean is_feature( ){return (isFeature ? CUBIT_TRUE : CUBIT_FALSE); }
205 : : // set and get the isFeature bit
206 : :
207 : 0 : static void set_box_tol( double tol ) {boxTol = tol;}
208 : : };
209 : :
210 : 0 : inline void CubitPoint::coef_vector(const CubitMatrix &input_matrix)
211 : : {
212 [ # # ]: 0 : if (!coefVector) coefVector = new double[5];
213 [ # # ]: 0 : for (int i=0; i<5; i++) {
214 : 0 : coefVector[i] = input_matrix.get(i,0);
215 : : }
216 : 0 : }
217 : :
218 : 264 : inline void CubitPoint::normal( CubitVector &surf_norm )
219 : : {
220 [ + + ][ + - ]: 264 : if(!surfNormal) surfNormal = new CubitVector (surf_norm);
221 : 176 : else *surfNormal = surf_norm;
222 : 264 : }
223 : :
224 : 132 : inline CubitVector CubitPoint::normal()
225 : : {
226 [ + + ]: 132 : if (surfNormal==NULL) compute_avg_normal();
227 : 132 : return *surfNormal;
228 : : }
229 : :
230 : 748 : inline CubitVector* CubitPoint::normal_ptr()
231 : : {
232 : 748 : return surfNormal;
233 : : }
234 : :
235 : 0 : inline void CubitPoint::set_normal( CubitVector &surf_norm )
236 : : {
237 : 0 : *surfNormal = surf_norm;
238 : 0 : }
239 : :
240 : 0 : inline void CubitPoint::reset_normal()
241 : : {
242 : 0 : compute_avg_normal();
243 : 0 : }
244 : :
245 : 0 : inline void CubitPoint::du( CubitVector &duvec )
246 : : {
247 [ # # ][ # # ]: 0 : if(!surfU) surfU = new CubitVector (duvec);
248 : 0 : else *surfU = duvec;
249 : 0 : }
250 : :
251 : 0 : inline void CubitPoint::dv( CubitVector &dvvec )
252 : : {
253 [ # # ][ # # ]: 0 : if(!surfV) surfV = new CubitVector (dvvec);
254 : 0 : else *surfV = dvvec;
255 : 0 : }
256 : :
257 : 0 : inline CubitVector CubitPoint::du()
258 : : {
259 [ # # ]: 0 : assert(surfU != NULL);
260 : 0 : return *surfU;
261 : : }
262 : :
263 : 0 : inline CubitVector CubitPoint::dv()
264 : : {
265 [ # # ]: 0 : assert(surfV != NULL);
266 : 0 : return *surfV;
267 : : }
268 : :
269 : 0 : inline double *CubitPoint::coef_vector( )
270 : : {
271 [ # # ]: 0 : assert (coefVector != NULL);
272 : 0 : return coefVector;
273 : : }
274 : :
275 : : class CubitPointComparator {
276 : : public:
277 : 0 : bool operator () (CubitPoint * a, CubitPoint * b) const
278 : : {
279 [ # # ][ # # ]: 0 : return ( a->x() < b->x() ) || (a->x()==b->x() && a->y()<b->y()) || (a->x() == b->x() && a->y()==b->y() && a->z() < b->z() );
[ # # ][ # # ]
[ # # ][ # # ]
280 : : }
281 : : };
282 : :
283 : : template <> struct DLIListSorter<CubitPoint*>
284 : : {
285 : : bool operator()(CubitPoint* a, CubitPoint* b) { return a->id() < b->id(); }
286 : : };
287 : :
288 : :
289 : : #endif
290 : :
291 : :
292 : :
293 : :
294 : :
295 : :
296 : :
|
