Branch data Line data Source code
1 : : #include "CubitPoint.hpp"
2 : : #include "CubitFacet.hpp"
3 : : #include "CubitFacetEdge.hpp"
4 : : #include "TDFacetBoundaryPoint.hpp"
5 : : #include "CubitTransformMatrix.hpp"
6 : : #include "GfxDebug.hpp"
7 : : #include "CubitQuadFacet.hpp"
8 : : #include "GeometryDefines.h"
9 : :
10 : : double CubitPoint::boxTol = GEOMETRY_RESABS;
11 : :
12 : : //===========================================================================
13 : : // Function Name: CubitPoint
14 : : //
15 : : // Member Type: PUBLIC
16 : : // Description: constructor
17 : : // Author:
18 : : // Date:
19 : : //===========================================================================
20 : 1430 : CubitPoint::CubitPoint()
21 : : : markedFlag(0), surfNormal(NULL), dCoef(0.0),
22 : : uVal(0.0), vVal(0.0), sizeVal(0.0),
23 : : surfU(NULL), surfV(NULL),
24 : 1430 : coefVector(NULL), isFeature(0)
25 : : {
26 : 1430 : }
27 : :
28 : : //===========================================================================
29 : : // Function Name: ~CubitPoint
30 : : //
31 : : // Member Type: PUBLIC
32 : : // Description: destructor
33 : : // Author:
34 : : // Date:
35 : : //===========================================================================
36 : 0 : CubitPoint::~CubitPoint()
37 : : {
38 [ # # ]: 0 : if (surfNormal) {
39 : 0 : delete surfNormal;
40 : : }
41 [ # # ]: 0 : if (surfU) {
42 : 0 : delete surfU;
43 : : }
44 [ # # ]: 0 : if (surfV) {
45 : 0 : delete surfV;
46 : : }
47 [ # # ]: 0 : if (coefVector) {
48 : 0 : delete coefVector;
49 : : }
50 [ # # ]: 0 : }
51 : :
52 : : //===========================================================================
53 : : // Function Name: shared_facets
54 : : //
55 : : // Member Type: PUBLIC
56 : : // Description: return the facets sharing this point and another point
57 : : // Author:
58 : : // Date:
59 : : //===========================================================================
60 : 0 : void CubitPoint::shared_facets(
61 : : CubitPoint* other_pt,
62 : : CubitFacet *& f1,
63 : : CubitFacet*& f2 )
64 : : {
65 : 0 : f1 = f2 = 0;
66 [ # # ]: 0 : DLIList <CubitFacet *> attached_facets;
67 [ # # ]: 0 : facets( attached_facets );
68 [ # # ][ # # ]: 0 : if( attached_facets.size() > 0 && other_pt )
[ # # ][ # # ]
69 : : {
70 [ # # ][ # # ]: 0 : for( int i = attached_facets.size(); i > 0; i-- )
71 : : {
72 [ # # ]: 0 : CubitFacet* facet = attached_facets.get_and_step();
73 [ # # ][ # # ]: 0 : if( facet->contains( other_pt ) )
74 : : {
75 : : //three facets??
76 [ # # ]: 0 : assert( !f2 );
77 : :
78 [ # # ]: 0 : if( f1 ) f2 = facet;
79 : 0 : else f1 = facet;
80 : : }
81 : : }
82 [ # # ]: 0 : }
83 : 0 : }
84 : 0 : void CubitPoint::shared_facets(
85 : : CubitPoint* other_pt, DLIList<CubitFacet*>& result_set )
86 : : {
87 [ # # ]: 0 : DLIList <CubitFacet *> attached_facets;
88 [ # # ]: 0 : facets( attached_facets );
89 [ # # ][ # # ]: 0 : if( attached_facets.size() > 0 && other_pt )
[ # # ][ # # ]
90 : : {
91 [ # # ][ # # ]: 0 : for( int i = attached_facets.size(); i > 0; i-- )
92 : : {
93 [ # # ]: 0 : CubitFacet* facet = attached_facets.get_and_step();
94 [ # # ][ # # ]: 0 : if( facet->contains( other_pt ) )
95 : : {
96 [ # # ]: 0 : result_set.append( facet );
97 : : }
98 : : }
99 [ # # ]: 0 : }
100 : 0 : }
101 : :
102 : :
103 : : //===========================================================================
104 : : // Function Name: shared_edge
105 : : //
106 : : // Member Type: PUBLIC
107 : : // Description: return the edge sharing this point and another point and
108 : : // assumes there is only one edge shared by two points
109 : : // Author: chynes
110 : : // Date: 6/6/2002
111 : : //===========================================================================
112 : 0 : CubitFacetEdge * CubitPoint::shared_edge( CubitPoint* other_pt )
113 : : {
114 : :
115 : : // CubitFacetEdge *edge = NULL;
116 : : // DLIList <CubitFacetEdge *> attached_edges;
117 : : // edges( attached_edges );
118 : : // if( attached_edges.size() > 0 && other_pt )
119 : : // {
120 : : // for( int i = attached_edges.size(); i > 0; i-- )
121 : : // {
122 : : // edge = attached_edges.get_and_step();
123 : : // if( edge->contains( other_pt ) )
124 : : // {
125 : : // return edge;
126 : : // }
127 : : // }
128 : : // }
129 : : // return edge;
130 : 0 : return get_edge(other_pt);
131 : :
132 : : }
133 : :
134 : :
135 : : //===========================================================================
136 : : // Function Name: normal
137 : : //
138 : : // Member Type: PUBLIC
139 : : // Description: return the facet normal with respect to the surface the
140 : : // facet is on
141 : : // Author:
142 : : // Date:
143 : : //===========================================================================
144 : 1716 : CubitVector CubitPoint::normal( CubitFacet *facet_ptr )
145 : : {
146 : : TDFacetBoundaryPoint *td_bfp =
147 : 1716 : TDFacetBoundaryPoint::get_facet_boundary_point( this );
148 [ + + ]: 1716 : if (td_bfp == NULL)
149 : : {
150 : 132 : return normal();
151 : : }
152 : : else
153 : : {
154 [ + - ]: 1584 : CubitVector norm;
155 [ + - ]: 1584 : td_bfp->get_normal( facet_ptr, norm );
156 [ + - ]: 1716 : return norm;
157 : : }
158 : : }
159 : :
160 : : //===========================================================================
161 : : // Function Name: normal
162 : : //
163 : : // Member Type: PUBLIC
164 : : // Description: return the facet normal with respect to the surface the
165 : : // quad facet is on
166 : : // Author:
167 : : // Date:
168 : : //===========================================================================
169 : 0 : CubitVector CubitPoint::normal( CubitQuadFacet *qfacet_ptr )
170 : : {
171 : 0 : CubitFacet *facet_ptr = qfacet_ptr->get_tri_facet_at_point( this );
172 : 0 : return normal( facet_ptr );
173 : : }
174 : :
175 : :
176 : : //===========================================================================
177 : : // Function Name: normal
178 : : //
179 : : // Member Type: PUBLIC
180 : : // Description: return the facet normal with respect to the surface the
181 : : // facet is on
182 : : // Author:
183 : : // Date:
184 : : //===========================================================================
185 : 132 : CubitVector CubitPoint::normal( CubitFacetEdge *edge_ptr )
186 : : {
187 : : TDFacetBoundaryPoint *td_bfp =
188 : 132 : TDFacetBoundaryPoint::get_facet_boundary_point( this );
189 [ - + ]: 132 : if (td_bfp == NULL)
190 : : {
191 : 0 : return normal();
192 : : }
193 : : else
194 : : {
195 [ + - ]: 132 : CubitVector norm;
196 [ + - ]: 132 : td_bfp->get_normal( edge_ptr, norm );
197 [ + - ]: 132 : return norm;
198 : : }
199 : : }
200 : :
201 : : //===========================================================================
202 : : // Function Name: tangent
203 : : //
204 : : // Member Type: PUBLIC
205 : : // Description: return tangent with respect to the edge
206 : : // Notes : min_dot is the cosine of the feature angle. Tangent vector
207 : : // will use the feature angle to determine tangent
208 : : // Author: sjowen
209 : : // Date: 10/28/2002
210 : : //===========================================================================
211 : 0 : CubitVector CubitPoint::tangent( CubitFacetEdge *edge_ptr,
212 : : double min_dot )
213 : : {
214 : 0 : CubitPoint *p0 = edge_ptr->point( 0 );
215 : 0 : CubitPoint *p1 = edge_ptr->point( 1 );
216 : : int ii;
217 : :
218 [ # # ][ # # ]: 0 : assert( p0 == this || p1 == this ); // the point isn't on the edge
219 : :
220 : : // if this isn't a feature edge, just return the tangent vector of
221 : : // the edge. Otherwise compute the tangent based on neighboring
222 : : // feature edges
223 : :
224 : 0 : CubitVector pt_tangent;
225 [ # # ]: 0 : if (!edge_ptr->is_feature())
226 : : {
227 [ # # ]: 0 : CubitVector tmp_vec = coordinates();
228 : :
229 [ # # ]: 0 : edge_ptr->edge_tangent( tmp_vec, pt_tangent );
230 : : }
231 : : else
232 : : {
233 : : // compute tangent for feature edge at previous
234 [ # # ]: 0 : if (p0 == this)
235 : : {
236 : : CubitFacetEdge *prev_edge;
237 [ # # ]: 0 : DLIList <CubitFacetEdge *>feature_edge_list;
238 [ # # ][ # # ]: 0 : next_feature_edges( edge_ptr, feature_edge_list );
[ # # ]
239 : :
240 : : // average the edges that meet the min_dot criteria
241 [ # # ][ # # ]: 0 : CubitVector e1 = p1->coordinates() - p0->coordinates();
[ # # ]
242 [ # # ]: 0 : pt_tangent = e1;
243 [ # # ]: 0 : e1.normalize();
244 [ # # ][ # # ]: 0 : for (ii=0; ii<feature_edge_list.size(); ii++)
245 : : {
246 [ # # ]: 0 : prev_edge = feature_edge_list.get_and_step();
247 [ # # ]: 0 : CubitPoint *p2 = prev_edge->other_point( p0 );
248 [ # # ][ # # ]: 0 : CubitVector e0 = p0->coordinates() - p2->coordinates();
[ # # ]
249 [ # # ]: 0 : e0.normalize();
250 [ # # ][ # # ]: 0 : if (e0 % e1 >= min_dot)
251 : : {
252 [ # # ][ # # ]: 0 : pt_tangent += (p0->coordinates() - p2->coordinates());
[ # # ][ # # ]
253 : : }
254 : : }
255 [ # # ][ # # ]: 0 : if (feature_edge_list.size() == 0)
256 [ # # ]: 0 : pt_tangent = e1;
257 : : else
258 [ # # ][ # # ]: 0 : pt_tangent.normalize();
259 : : }
260 : :
261 : : // compute tangent for feature edge at next
262 [ # # ]: 0 : else if (p1 == this)
263 : : {
264 : : CubitFacetEdge *next_edge;
265 [ # # ]: 0 : DLIList <CubitFacetEdge *>feature_edge_list;
266 [ # # ][ # # ]: 0 : next_feature_edges( edge_ptr, feature_edge_list );
[ # # ]
267 : :
268 : : // average the edges that meet the min_dot criteria
269 [ # # ][ # # ]: 0 : CubitVector e1 = p1->coordinates() - p0->coordinates();
[ # # ]
270 [ # # ]: 0 : pt_tangent = e1;
271 [ # # ]: 0 : e1.normalize();
272 [ # # ][ # # ]: 0 : for (ii=0; ii<feature_edge_list.size(); ii++)
273 : : {
274 [ # # ]: 0 : next_edge = feature_edge_list.get_and_step();
275 [ # # ]: 0 : CubitPoint *p2 = next_edge->other_point( p1 );
276 [ # # ][ # # ]: 0 : CubitVector e0 = p2->coordinates() - p1->coordinates();
[ # # ]
277 [ # # ]: 0 : e0.normalize();
278 [ # # ][ # # ]: 0 : if (e0 % e1 >= min_dot)
279 : : {
280 [ # # ][ # # ]: 0 : pt_tangent += (p2->coordinates() - p1->coordinates());
[ # # ][ # # ]
281 : : }
282 : : }
283 [ # # ][ # # ]: 0 : if (feature_edge_list.size() == 0)
284 [ # # ]: 0 : pt_tangent = e1;
285 : : else
286 [ # # ][ # # ]: 0 : pt_tangent.normalize();
287 : : }
288 : : }
289 : 0 : return pt_tangent;
290 : : }
291 : :
292 : : //===========================================================================
293 : : //Function Name: next_feature_edges
294 : : //
295 : : //Member Type: PRIVATE
296 : : //Descriptoin: given a facet boundary edge and this point, get a list
297 : : // of the next fetaure edges at this point
298 : : //===========================================================================
299 : 0 : void CubitPoint::next_feature_edges(
300 : : CubitFacetEdge *this_edge_ptr,
301 : : DLIList <CubitFacetEdge *> feature_edge_list )
302 : : {
303 : : //CubitFacetEdge *next_edge_ptr = NULL;
304 : :
305 [ # # ]: 0 : DLIList<CubitFacetEdge*> edge_list;
306 [ # # ]: 0 : edges( edge_list );
307 : : int ii;
308 : :
309 : 0 : CubitFacetEdge *edge_ptr = NULL;
310 [ # # ][ # # ]: 0 : for (ii=0; ii<edge_list.size(); ii++)
311 : : {
312 [ # # ]: 0 : edge_ptr = edge_list.get_and_step();
313 [ # # ]: 0 : if (edge_ptr != this_edge_ptr)
314 : : {
315 [ # # ][ # # ]: 0 : if (edge_ptr->is_feature())
316 : : {
317 [ # # ]: 0 : feature_edge_list.append(edge_ptr);
318 : : }
319 : : }
320 [ # # ]: 0 : }
321 : 0 : }
322 : :
323 : : //===========================================================================
324 : : // Function Name: project_to_tangent_plane
325 : : //
326 : : // Member Type: PUBLIC
327 : : // Descriptoin: Project a point to the tangent plane defined at the CubitPoint
328 : : // Author: sjowen
329 : : // Date: 06/28/00
330 : : //===========================================================================
331 : 0 : CubitVector CubitPoint::project_to_tangent_plane( CubitVector &pt )
332 : : {
333 [ # # ]: 0 : CubitVector surf_normal = normal();
334 [ # # ][ # # ]: 0 : double dist = (surf_normal)%pt + d_coef();
335 [ # # ][ # # ]: 0 : CubitVector point_on_plane( pt.x() - surf_normal.x() * dist,
336 [ # # ][ # # ]: 0 : pt.y() - surf_normal.y() * dist,
337 [ # # ][ # # ]: 0 : pt.z() - surf_normal.z() * dist );
[ # # ]
338 : 0 : return point_on_plane;
339 : : }
340 : :
341 : : //===========================================================================
342 : : // Function Name: adjacent_points
343 : : //
344 : : // Member Type: PUBLIC
345 : : // Description: return array of points sharing adjacent facets
346 : : // Author: sjowen
347 : : // Date: 06/28/00
348 : : //===========================================================================
349 : 0 : void CubitPoint::adjacent_points( CubitPoint **adj_points,
350 : : int &num_adj_points )
351 : : {
352 : 0 : int i, j, k, index = -1, nextindex = -1;
353 : : CubitBoolean found;
354 : : CubitFacet *facet;
355 : 0 : num_adj_points = 0;
356 [ # # ]: 0 : DLIList <CubitFacet *> attached_facets;
357 [ # # ]: 0 : facets( attached_facets );
358 [ # # ][ # # ]: 0 : for(i=0; i<attached_facets.size(); i++) {
359 [ # # ]: 0 : facet = attached_facets.get_and_step();
360 : 0 : found = CUBIT_FALSE;
361 [ # # ][ # # ]: 0 : for (j=0; j<3 && !found; j++) {
362 [ # # ][ # # ]: 0 : if (facet->point(j) == this) {
363 : 0 : index = (j+1)%3;
364 : 0 : nextindex = (j+2)%3;
365 : 0 : found = CUBIT_TRUE;
366 : : }
367 : : }
368 [ # # ]: 0 : if (found) {
369 : 0 : found = CUBIT_FALSE;
370 [ # # ]: 0 : adj_points[num_adj_points++] = facet->point(index);
371 [ # # ][ # # ]: 0 : for (k=0; k<num_adj_points-1 && !found; k++) {
372 [ # # ][ # # ]: 0 : if(adj_points[k] == facet->point(nextindex)){
373 : 0 : found = CUBIT_TRUE;
374 : : }
375 : : }
376 [ # # ]: 0 : if (!found) {
377 [ # # ]: 0 : adj_points[num_adj_points++] = facet->point(nextindex);
378 : : }
379 : : }
380 [ # # ]: 0 : }
381 : 0 : }
382 : 0 : void CubitPoint::adjacent_points( DLIList<CubitPoint*>& result )
383 : : {
384 [ # # ]: 0 : DLIList <CubitFacet *> attached_facets;
385 [ # # ]: 0 : facets( attached_facets );
386 [ # # ][ # # ]: 0 : for( int i = attached_facets.size(); i--; )
387 : : {
388 : : CubitPoint *pt1, *pt2;
389 [ # # ][ # # ]: 0 : attached_facets.get_and_step()->opposite_edge( this, pt1, pt2 );
390 [ # # ]: 0 : result.append_unique(pt1);
391 [ # # ]: 0 : result.append_unique(pt2);
392 [ # # ]: 0 : }
393 : 0 : }
394 : :
395 : : //===========================================================================
396 : : // Function Name: define_tangent_vectors
397 : : //
398 : : // Member Type: PUBLIC
399 : : // Description: define the surface tangent vectors at a point
400 : : // Author: sjowen
401 : : // Date: 06/28/00
402 : : //===========================================================================
403 : 0 : void CubitPoint::define_tangent_vectors()
404 : : {
405 : : // define orthogonal vectors to the normal that are tangent to the
406 : : // the surface. Note that du and dv are not defined in any global
407 : : // parametric space - they are only defined locally. Their directions
408 : : // are defined arbitrarily in the tangent plane by taking the smallest
409 : : // components of the normal vector and setting them to "1" for the
410 : : // du vector and then solving for the other component so that the
411 : : // dot product of du and the normal will be zero. dv is just the cross
412 : : // product of the normal and du
413 : :
414 [ # # ][ # # ]: 0 : CubitVector absnorm, duvec, dvvec;
[ # # ]
415 [ # # ]: 0 : CubitVector surf_normal = normal();
416 [ # # ][ # # ]: 0 : absnorm.x( fabs(surf_normal.x()) );
417 [ # # ][ # # ]: 0 : absnorm.y( fabs(surf_normal.y()) );
418 [ # # ][ # # ]: 0 : absnorm.z( fabs(surf_normal.z()) );
419 [ # # ][ # # ]: 0 : if (absnorm.x() >= absnorm.y() && absnorm.x() >= absnorm.z()) {
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
420 [ # # ][ # # ]: 0 : duvec.x( (-surf_normal.y() - surf_normal.z()) / surf_normal.x() );
[ # # ][ # # ]
421 [ # # ]: 0 : duvec.y( 1.0e0 );
422 [ # # ]: 0 : duvec.z( 1.0e0 );
423 : : }
424 [ # # ][ # # ]: 0 : else if (absnorm.y() >= absnorm.z() ) {
[ # # ]
425 [ # # ]: 0 : duvec.x( 1.0e0 );
426 [ # # ][ # # ]: 0 : duvec.y( (-surf_normal.x() - surf_normal.z()) / surf_normal.y() );
[ # # ][ # # ]
427 [ # # ]: 0 : duvec.z( 1.0e0 );
428 : : }
429 : : else {
430 [ # # ]: 0 : duvec.x( 1.0e0 );
431 [ # # ]: 0 : duvec.y( 1.0e0 );
432 [ # # ][ # # ]: 0 : duvec.z( (-surf_normal.x() - surf_normal.y()) / surf_normal.z() );
[ # # ][ # # ]
433 : : }
434 [ # # ]: 0 : duvec.normalize();
435 [ # # ][ # # ]: 0 : dvvec = surf_normal * duvec;
436 : :
437 : : // //sjowen debug
438 : : // CubitVector test = dvvec * surf_normal;
439 : : // double dot = test % duvec;
440 : : // if (dot < 0.999999999999) {
441 : : // PRINT_ERROR("Error in define_tangent_vectors");
442 : : // }
443 : :
444 [ # # ]: 0 : du( duvec );
445 [ # # ]: 0 : dv( dvvec );
446 : 0 : }
447 : :
448 : : //===========================================================================
449 : : // Function Name: transform_to_local
450 : : //
451 : : // Member Type: PUBLIC
452 : : // Description: transform a vector from global to local system
453 : : // Author: sjowen
454 : : // Date: 06/28/00
455 : : //===========================================================================
456 : 0 : void CubitPoint::transform_to_local( CubitVector &glob_vec,
457 : : CubitVector &loc_vec )
458 : : {
459 : : // Translate to local origin at point
460 : :
461 [ # # ][ # # ]: 0 : CubitVector vect = glob_vec - this->coordinates();
462 : :
463 : : // Multiply by transpose (inverse) of transformation vector */
464 : :
465 [ # # ][ # # ]: 0 : loc_vec.x( vect % du() );
[ # # ]
466 [ # # ][ # # ]: 0 : loc_vec.y( vect % dv() );
[ # # ]
467 [ # # ][ # # ]: 0 : loc_vec.z( vect % normal() );
[ # # ]
468 : 0 : }
469 : :
470 : : //===========================================================================
471 : : // Function Name: transform_to_global
472 : : //
473 : : // Member Type: PUBLIC
474 : : // Description: transform a vector from local to global system
475 : : // Author: sjowen
476 : : // Date: 06/28/00
477 : : //===========================================================================
478 : 0 : void CubitPoint::transform_to_global( CubitVector &loc_vec,
479 : : CubitVector &glob_vec )
480 : : {
481 : : // Multiply by transformation matrix
482 : :
483 [ # # ]: 0 : CubitVector vect;
484 [ # # ]: 0 : CubitVector surf_u = du();
485 [ # # ]: 0 : CubitVector surf_v = dv();
486 [ # # ]: 0 : CubitVector surf_normal = normal();
487 [ # # ][ # # ]: 0 : vect.x( loc_vec.x() * surf_u.x ()+
488 [ # # ][ # # ]: 0 : loc_vec.y() * surf_v.x() +
489 [ # # ][ # # ]: 0 : loc_vec.z() * surf_normal.x() );
[ # # ]
490 [ # # ][ # # ]: 0 : vect.y( loc_vec.x() * surf_u.y ()+
491 [ # # ][ # # ]: 0 : loc_vec.y() * surf_v.y() +
492 [ # # ][ # # ]: 0 : loc_vec.z() * surf_normal.y() );
[ # # ]
493 [ # # ][ # # ]: 0 : vect.z( loc_vec.x() * surf_u.z ()+
494 [ # # ][ # # ]: 0 : loc_vec.y() * surf_v.z() +
495 [ # # ][ # # ]: 0 : loc_vec.z() * surf_normal.z() );
[ # # ]
496 : :
497 : : // Translate from origin
498 : :
499 [ # # ][ # # ]: 0 : glob_vec = vect + this->coordinates();
[ # # ]
500 : 0 : }
501 : :
502 : : //===========================================================================
503 : : // Function Name: get_parents
504 : : //
505 : : // Member Type: PUBLIC
506 : : // Description: get the list of attached edges
507 : : // Author: sjowen
508 : : // Date: 06/28/00
509 : : //===========================================================================
510 : 0 : void CubitPoint::get_parents( DLIList<FacetEntity*> &facet_list )
511 : : {
512 [ # # ]: 0 : DLIList<CubitFacetEdge*> edge_list;
513 [ # # ]: 0 : edges( edge_list );
514 : : int ii;
515 [ # # ][ # # ]: 0 : for (ii=0; ii<edge_list.size(); ii++)
516 [ # # ][ # # ]: 0 : facet_list.append( edge_list.get_and_step() );
[ # # ]
517 : 0 : }
518 : :
519 : : //===========================================================================
520 : : // Function Name: draw
521 : : //
522 : : // Member Type: PUBLIC
523 : : // Description: debug drawing
524 : : // Author: sjowen
525 : : // Date: 5/01
526 : : //===========================================================================
527 : 0 : void CubitPoint::debug_draw( int color, int flush, int /*draw_uv*/ )
528 : : {
529 [ # # ]: 0 : if ( color == -1 )
530 : 0 : color = CUBIT_YELLOW_INDEX;
531 [ # # ]: 0 : CubitVector vec = this->coordinates();
532 [ # # ]: 0 : GfxDebug::draw_point(vec, color);
533 [ # # ]: 0 : if (flush)
534 [ # # ]: 0 : GfxDebug::flush();
535 : 0 : }
536 : :
537 : : //===========================================================================
538 : : // Function Name: normal
539 : : //
540 : : // Member Type: PUBLIC
541 : : // Description: set the normal of the surface at the point. Allocate a
542 : : // new normal vector if necessary
543 : : // Author:
544 : : // Date:
545 : : //===========================================================================
546 : 44 : void CubitPoint::compute_avg_normal()
547 : : {
548 : : int j;
549 [ + - ]: 44 : DLIList<CubitFacet*> adj_facet_list;
550 [ + - ]: 44 : facets(adj_facet_list);
551 [ + - ][ + - ]: 44 : if (adj_facet_list.size() > 0) {
552 [ + - ]: 44 : CubitVector avg_normal(0.0e0, 0.0e0, 0.0e0);
553 : 44 : double totangle = 0.0e0;
554 : :
555 : : // weight the normal by the spanning angle at the point
556 : :
557 [ + - ][ + + ]: 176 : for (j = 0; j < adj_facet_list.size(); j++)
558 : : {
559 [ + - ]: 132 : CubitFacet* facet = adj_facet_list.get_and_step();
560 [ + - ]: 132 : double angle = facet->angle( this );
561 [ + - ]: 132 : facet->weight( angle );
562 : 132 : totangle += angle;
563 : : }
564 [ + - ][ + + ]: 176 : for (j = 0; j < adj_facet_list.size(); j++)
565 : : {
566 [ + - ]: 132 : CubitFacet* facet = adj_facet_list.get_and_step();
567 [ + - ]: 132 : CubitVector normal = facet->normal();
568 [ + - ]: 132 : normal.normalize();
569 [ + - ][ + - ]: 132 : avg_normal += (facet->weight() / totangle) * normal;
[ + - ]
570 : : }
571 [ + - ]: 44 : avg_normal.normalize();
572 [ + - ]: 44 : if(!surfNormal) {
573 [ + - ][ + - ]: 44 : surfNormal = new CubitVector ( avg_normal );
574 : : }
575 : : else
576 : : {
577 [ # # ]: 0 : *surfNormal = avg_normal;
578 : : }
579 [ + - ][ + - ]: 44 : dCoef = -(this->coordinates()%avg_normal);
580 [ + - ]: 44 : }
581 : 44 : }
582 : :
583 : : //===========================================================================
584 : : // Function Name: facets_on_surf
585 : : //
586 : : // Member Type: PUBLIC
587 : : // Description: return facets adjacent this point that are on the given
588 : : // surface
589 : : // surf_id is the FacetEvalTool ToolID
590 : : // Author: sjowen
591 : : // Date: 6/26/01
592 : : //===========================================================================
593 : 0 : CubitBox CubitPoint::bounding_box( )
594 : : {
595 [ # # ][ # # ]: 0 : CubitVector ptmin( coordinates().x() - boxTol,
596 [ # # ][ # # ]: 0 : coordinates().y() - boxTol,
597 [ # # ][ # # ]: 0 : coordinates().z() - boxTol );
[ # # ]
598 [ # # ][ # # ]: 0 : CubitVector ptmax( coordinates().x() + boxTol,
599 [ # # ][ # # ]: 0 : coordinates().y() + boxTol,
600 [ # # ][ # # ]: 0 : coordinates().z() + boxTol );
[ # # ]
601 [ # # ]: 0 : CubitBox ptbox( ptmin, ptmax );
602 : 0 : return ptbox;
603 : : }
604 : :
605 : : //===========================================================================
606 : : // Function Name: facets_on_surf
607 : : //
608 : : // Member Type: PUBLIC
609 : : // Description: return facets adjacent this point that are on the given
610 : : // surface
611 : : // surf_id is the FacetEvalTool ToolID
612 : : // Author: sjowen
613 : : // Date: 6/26/01
614 : : //===========================================================================
615 : 0 : void CubitPoint::facets_on_surf( int surf_id,
616 : : DLIList<CubitFacet *> &facet_list,
617 : : CubitBoolean &on_internal_boundary )
618 : : {
619 [ # # ]: 0 : DLIList<CubitFacet *>all_facets;
620 [ # # ]: 0 : facets( all_facets );
621 : : int ii;
622 : : CubitFacet *facet;
623 [ # # ][ # # ]: 0 : for (ii=0; ii<all_facets.size(); ii++)
624 : : {
625 [ # # ]: 0 : facet = all_facets.get_and_step();
626 [ # # ][ # # ]: 0 : if (facet->tool_id() == surf_id)
627 : : {
628 [ # # ]: 0 : facet_list.append( facet );
629 : : }
630 : : }
631 [ # # ][ # # ]: 0 : if (facet_list.size() == 0)
632 : : {
633 : 0 : on_internal_boundary = CUBIT_FALSE;
634 : : }
635 [ # # ][ # # ]: 0 : else if (all_facets.size() == facet_list.size())
[ # # ]
636 : : {
637 : 0 : on_internal_boundary = CUBIT_FALSE;
638 : : }
639 : : else
640 : : {
641 : 0 : on_internal_boundary = CUBIT_TRUE;
642 [ # # ]: 0 : }
643 : 0 : }
644 : :
645 : : //===========================================================================
646 : : // Function Name: get_uv
647 : : //
648 : : // Member Type: PUBLIC
649 : : // Description: return the u-v coordinates for the surface the facet is on
650 : : // - assumes facet is adjacent to this point
651 : : // Author: sjowen
652 : : // Date: 6/26/01
653 : : //===========================================================================
654 : 0 : CubitStatus CubitPoint::get_uv( CubitFacet *facet, double &u, double &v )
655 : : {
656 : : CubitStatus stat;
657 : : TDFacetBoundaryPoint *td_bfp =
658 : 0 : TDFacetBoundaryPoint::get_facet_boundary_point( this );
659 [ # # ]: 0 : if (!td_bfp)
660 : : {
661 : 0 : u = uVal;
662 : 0 : v = vVal;
663 : 0 : stat = CUBIT_SUCCESS;
664 : : }
665 : : else
666 : : {
667 : 0 : stat = td_bfp->get_uv( facet, u, v );
668 : : }
669 : 0 : return stat;
670 : : }
671 : :
672 : : //===========================================================================
673 : : // Function Name: get_uvs
674 : : //
675 : : // Member Type: PUBLIC
676 : : // Description: return the u-v coordinates and size for the surface the facet is on
677 : : // - assumes facet is adjacent to this point
678 : : // Author: chynes
679 : : // Date: 7/16/02
680 : : //===========================================================================
681 : 0 : CubitStatus CubitPoint::get_uvs( CubitFacet *facet, double &u, double &v, double &s )
682 : : {
683 : : CubitStatus stat;
684 : : TDFacetBoundaryPoint *td_bfp =
685 : 0 : TDFacetBoundaryPoint::get_facet_boundary_point( this );
686 [ # # ]: 0 : if (!td_bfp)
687 : : {
688 : 0 : u = uVal;
689 : 0 : v = vVal;
690 : 0 : s = sizeVal;
691 : 0 : stat = CUBIT_SUCCESS;
692 : : }
693 : : else
694 : : {
695 : 0 : stat = td_bfp->get_uvs( facet, u, v, s );
696 : : }
697 : 0 : return stat;
698 : : }
699 : : //===========================================================================
700 : : // Function Name: merge_points
701 : : //
702 : : // Member Type: PUBLIC
703 : : // Description: merge two points
704 : : // Author: sjowen
705 : : // Date: 9/18/01
706 : : //===========================================================================
707 : 0 : CubitStatus CubitPoint::merge_points( CubitPoint * /*cp*/, CubitBoolean /* keep_point */ )
708 : : {
709 : : // this virtual function must be defined in the inheriting class if you get here
710 : 0 : assert(0);
711 : : return CUBIT_FAILURE;
712 : : }
713 : :
714 : : //===========================================================================
715 : : // Function Name: get_edge
716 : : //
717 : : // Member Type: PUBLIC
718 : : // Description: return the CubitFacetEdge between the two points (if there is one)
719 : : // Author: sjowen
720 : : // Date: 9/25/01
721 : : //===========================================================================
722 : 0 : CubitFacetEdge *CubitPoint::get_edge( CubitPoint *other_point )
723 : : {
724 [ # # ]: 0 : DLIList<CubitFacetEdge *>edge_list;
725 [ # # ]: 0 : edges(edge_list);
726 : : int ii;
727 : : CubitFacetEdge *edge_ptr;
728 [ # # ][ # # ]: 0 : for (ii=0; ii<edge_list.size(); ii++)
729 : : {
730 [ # # ]: 0 : edge_ptr = edge_list.get_and_step();
731 [ # # ][ # # ]: 0 : if (edge_ptr->other_point( this ) == other_point)
732 : 0 : return edge_ptr;
733 : : }
734 [ # # ]: 0 : return (CubitFacetEdge *)NULL;
735 : : }
736 : :
737 : : //===========================================================================
738 : : // Function Name: transform
739 : : //
740 : : // Member Type: PUBLIC
741 : : // Description: transform the location of the point
742 : : // Author: sjowen
743 : : // Date: 3/16/02
744 : : //===========================================================================
745 : 154 : void CubitPoint::transform(CubitTransformMatrix &tfmat)
746 : : {
747 [ + - ]: 154 : CubitVector loc;
748 [ + - ][ + - ]: 154 : loc = tfmat * coordinates();
[ + - ]
749 [ + - ]: 154 : set( loc );
750 : 154 : }
751 : :
752 : : //===========================================================================
753 : : // Function Name: rotate_normal
754 : : //
755 : : // Member Type: PUBLIC
756 : : // Description: transform the location of the point
757 : : // Author: sjowen
758 : : // Date: 3/16/02
759 : : //===========================================================================
760 : 0 : void CubitPoint::rotate_normal(CubitTransformMatrix &rotmat)
761 : : {
762 [ # # ]: 0 : if (surfNormal)
763 : : {
764 [ # # ]: 0 : *surfNormal = rotmat * (*surfNormal);
765 : : }
766 : 0 : TDFacetBoundaryPoint *td = TDFacetBoundaryPoint::get_facet_boundary_point( this );
767 [ # # ]: 0 : if (td)
768 : : {
769 : 0 : td->rotate_normal(rotmat);
770 : : }
771 : 0 : }
772 : :
773 : : //===========================================================================
774 : : // Function Name: check_inverted_facets
775 : : //
776 : : // Member Type: PUBLIC
777 : : // Description: check if moving a point will invert facets
778 : : // Author: jakraft
779 : : // Date: 05/09/03
780 : : //===========================================================================
781 : 0 : CubitStatus CubitPoint::check_inverted_facets( const CubitVector& pos )
782 : : {
783 [ # # ]: 0 : DLIList<CubitFacet*> facets;
784 [ # # ]: 0 : this->facets(facets);
785 [ # # ][ # # ]: 0 : while( facets.size() )
786 : : {
787 [ # # ]: 0 : CubitFacet* facet = facets.pop();
788 [ # # ]: 0 : int index = facet->point_index(this);
789 [ # # ][ # # ]: 0 : CubitVector corner = facet->point((index+1)%3)->coordinates();
790 [ # # ][ # # ]: 0 : CubitVector opposite_edge = facet->point((index+2)%3)->coordinates();
791 [ # # ]: 0 : opposite_edge -= corner;
792 [ # # ][ # # ]: 0 : CubitVector old_edge = corner - coordinates();
793 [ # # ]: 0 : CubitVector new_edge = corner - pos;
794 [ # # ]: 0 : old_edge *= opposite_edge;
795 [ # # ]: 0 : new_edge *= opposite_edge;
796 [ # # ][ # # ]: 0 : if ( (old_edge % new_edge) <= 0.0 )
797 : 0 : return CUBIT_FAILURE;
798 : : }
799 [ # # ]: 0 : return CUBIT_SUCCESS;
800 [ + - ][ + - ]: 6540 : }
801 : :
802 : : //EOF
803 : :
|
