Branch data Line data Source code
1 : : #include "PST_Data.hpp"
2 : : #include "GMem.hpp"
3 : : #include "GfxDebug.hpp"
4 : : #include "GeometryDefines.h"
5 : : #include "CubitMessage.hpp"
6 : :
7 : : #define PST_MAX_LIST_LEN 1000
8 : : // Used only for debugging. Has no effect
9 : : // if compiled -DNDEBUG.
10 : :
11 : : const double RESABS_SQR = GEOMETRY_RESABS * GEOMETRY_RESABS;
12 : :
13 : :
14 : : /*************************************************************************
15 : : * PST_Point
16 : : ************************************************************************/
17 : :
18 : 0 : PST_Point::~PST_Point()
19 : : {
20 [ # # ]: 0 : while( edge_ )
21 [ # # ][ # # ]: 0 : delete edge_;
22 [ # # ]: 0 : }
23 : :
24 : 0 : PST_Edge* PST_Point::common( PST_Point* pt )
25 : : {
26 [ # # ]: 0 : if( edge_ )
27 : : {
28 : : #ifndef NDEBUG
29 : 0 : int debug = 0;
30 : : #endif
31 : :
32 : 0 : PST_Edge* e = edge_;
33 [ # # ]: 0 : do
34 : : {
35 [ # # ]: 0 : if( e->other(pt) == this )
36 : 0 : return e;
37 : 0 : e = next( e );
38 : :
39 : : #ifndef NDEBUG
40 [ # # ]: 0 : assert( ++debug < PST_MAX_LIST_LEN );
41 : : #endif
42 [ # # ]: 0 : } while( e && e != edge_ );
43 : : }
44 : 0 : return 0;
45 : : }
46 : :
47 : :
48 : 0 : int PST_Point::faces( DLIList<PST_Face*>* list )
49 : : {
50 : 0 : int count = 0;
51 [ # # ]: 0 : if( edge() )
52 : : {
53 : 0 : PST_Edge* e = edge();
54 [ # # ]: 0 : do
55 : : {
56 [ # # ]: 0 : if (e->forward()->face())
57 : 0 : e->forward()->face()->private_mark_ = true;
58 [ # # ]: 0 : if (e->reverse()->face())
59 : 0 : e->reverse()->face()->private_mark_ = true;
60 : 0 : e = e->next(this);
61 : 0 : } while( e != edge() );
62 : :
63 [ # # ]: 0 : do
64 : : {
65 [ # # ][ # # ]: 0 : if( e->forward()->face() && e->forward()->face()->private_mark_ )
[ # # ]
66 : : {
67 : 0 : count++;
68 : 0 : e->forward()->face()->private_mark_ = false;
69 [ # # ][ # # ]: 0 : if( list ) list->append(e->forward()->face());
70 : : }
71 [ # # ][ # # ]: 0 : if( e->reverse()->face() && e->reverse()->face()->private_mark_ )
[ # # ]
72 : : {
73 : 0 : count++;
74 : 0 : e->reverse()->face()->private_mark_ = false;
75 [ # # ][ # # ]: 0 : if( list ) list->append(e->reverse()->face());
76 : : }
77 : 0 : e = e->next(this);
78 : 0 : } while( e != edge() );
79 : : }
80 : :
81 : 0 : return count;
82 : : }
83 : :
84 : : /*************************************************************************
85 : : * PST_Face
86 : : ************************************************************************/
87 : :
88 : 0 : void PST_Face::append_points( DLIList<PST_Point*>& result_list )
89 : : {
90 : 0 : PST_CoEdge* ce = coedge_;
91 : : #ifndef NDEBUG
92 : 0 : int debug = 0;
93 : : #endif
94 [ # # ]: 0 : do
95 : : {
96 [ # # ]: 0 : result_list.append( ce->end_point() );
97 : 0 : ce = ce->next();
98 : :
99 : : #ifndef NDEBUG
100 [ # # ]: 0 : assert( ++debug < PST_MAX_LIST_LEN );
101 : : #endif
102 : 0 : } while( ce != coedge_ );
103 : 0 : }
104 : :
105 : 0 : PST_Point* PST_Face::opposite( PST_Edge* edge )
106 : : {
107 : 0 : PST_CoEdge* ce = coedge_;
108 : : #ifndef NDEBUG
109 : 0 : int debug = 0;
110 : : #endif
111 [ # # ]: 0 : do
112 : : {
113 [ # # ]: 0 : if( ce->edge() == edge )
114 : 0 : return ce->next()->end_point();
115 : 0 : ce = ce->next();
116 : :
117 : : #ifndef NDEBUG
118 [ # # ]: 0 : assert( ++debug < PST_MAX_LIST_LEN );
119 : : #endif
120 : 0 : } while( ce != coedge_ );
121 : :
122 : 0 : return 0;
123 : : }
124 : :
125 : 0 : PST_Edge* PST_Face::opposite( PST_Point* point )
126 : : {
127 : 0 : PST_CoEdge* ce = coedge_;
128 : : #ifndef NDEBUG
129 : 0 : int debug = 0;
130 : : #endif
131 [ # # ]: 0 : do
132 : : {
133 [ # # ]: 0 : if( ce->start_point() == point )
134 : 0 : return ce->next()->edge();
135 : 0 : ce = ce->next();
136 : :
137 : : #ifndef NDEBUG
138 [ # # ]: 0 : assert( ++debug < PST_MAX_LIST_LEN );
139 : : #endif
140 : 0 : } while( ce != coedge_ );
141 : :
142 : 0 : return 0;
143 : : }
144 : :
145 : 0 : bool PST_Face::two_edges( PST_Point* point, PST_Edge*& e1, PST_Edge*& e2 )
146 : : {
147 : 0 : e1 = e2 = 0;
148 : 0 : PST_CoEdge* ce = coedge_;
149 : : #ifndef NDEBUG
150 : 0 : int debug = 0;
151 : : #endif
152 [ # # ]: 0 : do
153 : : {
154 [ # # ]: 0 : if( ce->end_point() == point )
155 : : {
156 [ # # ][ # # ]: 0 : if( e1 || e2 )
157 : 0 : return false;
158 : 0 : e1 = ce->edge();
159 : 0 : e2 = ce->next()->edge();
160 : : }
161 : 0 : ce = ce->next();
162 : :
163 : : #ifndef NDEBUG
164 [ # # ]: 0 : assert( ++debug < PST_MAX_LIST_LEN );
165 : : #endif
166 : 0 : } while( ce != coedge_ );
167 : :
168 [ # # ][ # # ]: 0 : return e1 && e2;
169 : : }
170 : :
171 : :
172 : 0 : bool PST_Face::calculate_plane()
173 : : {
174 : 0 : update_plane_ = 0;
175 : :
176 : : // Use Newell's method
177 : :
178 [ # # ][ # # ]: 0 : CubitVector dif, sum, ref(0.,0.,0.);
[ # # ]
179 [ # # ]: 0 : CubitVector norm(0.,0.,0.);
180 : :
181 : : // For each coedge...
182 : :
183 : 0 : PST_CoEdge* ce = coedge_;
184 : 0 : int count = 0;
185 [ # # ]: 0 : do
186 : : {
187 : 0 : count++;
188 [ # # ]: 0 : const CubitVector& pt1 = ce->start_coord();
189 [ # # ]: 0 : const CubitVector& pt2 = ce->end_coord();
190 [ # # ][ # # ]: 0 : dif = pt2 - pt1;
191 [ # # ][ # # ]: 0 : sum = pt2 + pt1;
192 [ # # ]: 0 : ref += pt1;
193 [ # # ][ # # ]: 0 : norm += CubitVector( dif.y()*sum.z(), dif.z()*sum.x(), dif.x()*sum.y() );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
194 [ # # ]: 0 : ce = ce->next();
195 : :
196 [ # # ]: 0 : assert( count < PST_MAX_LIST_LEN );
197 : 0 : } while( ce != coedge_ );
198 : :
199 : : // Degenerate?
200 : :
201 [ # # ]: 0 : double len = norm.length();
202 [ # # ]: 0 : if( len > CUBIT_RESABS )
203 : : {
204 [ # # ]: 0 : double d = (ref % norm) / (count * len);
205 [ # # ]: 0 : norm /= -len; //reverse and normalize
206 : :
207 [ # # ]: 0 : plane_.normal( norm );
208 [ # # ]: 0 : plane_.coefficient( d );
209 : :
210 : 0 : return true;
211 : : }
212 : : else
213 : : {
214 [ # # ][ # # ]: 0 : plane_.normal( CubitVector(0.,0.,0.) );
215 [ # # ]: 0 : plane_.coefficient( 0. );
216 : :
217 : 0 : return false;
218 : : }
219 : : }
220 : :
221 : :
222 : :
223 : : /*************************************************************************
224 : : * PST_CoEdge
225 : : ************************************************************************/
226 : 0 : PST_CoEdge* PST_CoEdge::previous()
227 : : {
228 [ # # ]: 0 : if( !next_ )
229 : 0 : return 0;
230 : :
231 : 0 : PST_CoEdge* coedge = this;
232 : : #ifndef NDEBUG
233 : 0 : int debug = 0;
234 : : #endif
235 [ # # ]: 0 : while( coedge->next_ != this )
236 : : {
237 : 0 : coedge = coedge->next_;
238 : : #ifndef NDEBUG
239 [ # # ]: 0 : assert( ++debug < PST_MAX_LIST_LEN );
240 : : #endif
241 : : }
242 : 0 : return coedge;
243 : : }
244 : :
245 : : /*************************************************************************
246 : : * PST_Edge
247 : : ************************************************************************/
248 : :
249 [ # # ][ # # ]: 0 : PST_Edge::~PST_Edge()
250 : : {
251 : : // Update list "head" pointers on points, if necessary.
252 [ # # ][ # # ]: 0 : if( start_point() )
253 [ # # ]: 0 : remove_start_point();
254 [ # # ][ # # ]: 0 : if( end_point() )
255 [ # # ]: 0 : remove_end_point();
256 : :
257 : : // Destroy parent facets
258 [ # # ]: 0 : for ( int i = 0; i < 2; i++ )
259 : : {
260 [ # # ][ # # ]: 0 : PST_CoEdge* coedge = i ? reverse() : forward();
[ # # ]
261 [ # # ][ # # ]: 0 : if ( coedge->face() )
262 : : {
263 [ # # ]: 0 : PST_Face* face = coedge->face();
264 : 0 : face->coedge_ = 0;
265 : :
266 : 0 : PST_CoEdge* first = coedge;
267 [ # # ]: 0 : do {
268 [ # # ][ # # ]: 0 : assert(coedge->face() == face);
269 : 0 : coedge->face_ = 0;
270 [ # # ]: 0 : PST_CoEdge* next = coedge->next();
271 : 0 : coedge->next_ = 0;
272 : 0 : coedge = next;
273 : : } while( first != coedge );
274 [ # # ][ # # ]: 0 : delete face ;
275 : : }
276 : : }
277 [ # # ]: 0 : }
278 : :
279 : 0 : double PST_Edge::closest_on_line( const CubitVector& P )
280 : : {
281 [ # # ][ # # ]: 0 : CubitVector B = start_coord();
282 [ # # ][ # # ]: 0 : CubitVector M = end_coord() - B;
283 [ # # ][ # # ]: 0 : if( M.length_squared() < RESABS_SQR )
284 : 0 : return 0.0;
285 [ # # ][ # # ]: 0 : return ( M % ( P - B ) ) / ( M % M );
[ # # ]
286 : : }
287 : :
288 : 0 : double PST_Edge::closest_on_edge( const CubitVector& p )
289 : : {
290 : 0 : double t = closest_on_line( p );
291 [ # # ]: 0 : if( t < 0.0 )
292 : 0 : t = 0.0;
293 [ # # ]: 0 : else if( t > 1.0 )
294 : 0 : t = 1.0;
295 : 0 : return t;
296 : : }
297 : :
298 : 0 : double PST_Edge::closest_on_line( const CubitVector& B2,
299 : : const CubitVector& M2 )
300 : : {
301 [ # # ][ # # ]: 0 : CubitVector B1 = start_coord();
302 [ # # ]: 0 : CubitVector M1 = direction();
303 : :
304 [ # # ][ # # ]: 0 : if( M1.length_squared() < RESABS_SQR )
305 : 0 : return 0.0;
306 : :
307 [ # # ][ # # ]: 0 : if( M2.length_squared() < RESABS_SQR )
308 [ # # ]: 0 : return closest_on_line( B2 );
309 : :
310 [ # # ]: 0 : CubitVector cross = M2 * M1;
311 [ # # ][ # # ]: 0 : if( cross.length_squared() < CUBIT_RESABS ) //parallel
312 : 0 : return 0.0;
313 : :
314 [ # # ]: 0 : CubitVector N = M2 * cross;
315 [ # # ]: 0 : double D = -( N % B2 );
316 [ # # ][ # # ]: 0 : return -( N % B1 + D ) / ( N % M1 );
317 : : }
318 : :
319 : :
320 : 0 : PST_Edge* PST_Edge::other( PST_Point* point, PST_Face* face )
321 : : {
322 : 0 : PST_Edge *result = 0;
323 [ # # ]: 0 : for( PST_Edge* e = point->next(this); e != this; e = point->next(e) )
324 : : {
325 [ # # ][ # # ]: 0 : if( e->forward()->face() == face || e->reverse()->face() == face )
[ # # ]
326 : : {
327 [ # # ][ # # ]: 0 : if( result && result != e )
328 : 0 : return 0;
329 : 0 : result = e;
330 : : }
331 : : }
332 : 0 : return result;
333 : : }
334 : :
335 : : /*************************************************************************
336 : : * Construction Methods
337 : : ************************************************************************/
338 : :
339 : 0 : PST_Face* PST_Edge::create_face( PST_Point* pt1, PST_Point* pt2, PST_Point* pt3 )
340 : : {
341 : : // It is trivial to generalize this function for creating
342 : : // faces with an arbitrary number of sides, but I just
343 : : // want triangles.
344 : 0 : const int size = 3;
345 : 0 : PST_Point* p[size] = { pt1, pt2, pt3 };
346 : :
347 : : int i;
348 : : PST_Edge* e[size];
349 : : PST_CoEdge* c[size];
350 : :
351 : : // Initialize edge and coedge arrays, creating
352 : : // edges if necessary.
353 [ # # ]: 0 : for( i = 0; i < size; i++ )
354 : : {
355 [ # # ]: 0 : e[i] = p[i]->common( p[(i+1)%size] );
356 [ # # ]: 0 : if( !e[i] )
357 : : {
358 [ # # ][ # # ]: 0 : e[i] = new PST_Edge( p[i], p[(i+1)%size] );
359 [ # # ]: 0 : c[i] = e[i]->forward();
360 : : }
361 : : else
362 : : {
363 [ # # ][ # # ]: 0 : c[i] = e[i]->start_point() == p[i] ? e[i]->forward() : e[i]->reverse();
[ # # ][ # # ]
364 : :
365 : : // If the co-edge in the appropriate direction is already
366 : : // part of a face (other than the boundary face), then we
367 : : // can't proceed.
368 : : // if( !c[i]->face()->boundary() )
369 [ # # ][ # # ]: 0 : if( c[i]->face() )
370 : : {
371 [ # # ]: 0 : while( --i >= 0 )
372 [ # # ][ # # ]: 0 : if( ! c[i]->face() )
373 [ # # ][ # # ]: 0 : delete e[i];
374 : 0 : return 0;
375 : : }
376 : : }
377 : : }
378 : :
379 [ # # ][ # # ]: 0 : PST_Face* result = new PST_Face( c[0] );
380 [ # # ]: 0 : for ( i = 0; i < size; i++ )
381 : : {
382 : 0 : int next = (i + 1) % size;
383 : 0 : c[i]->face_ = result;
384 : 0 : c[i]->next_ = c[next];
385 : : }
386 : 0 : return result;
387 : :
388 : : }
389 : :
390 : :
391 : 0 : PST_Edge* PST_Edge::split_face( PST_Point* start, PST_Point* end, PST_Face* face )
392 : : {
393 [ # # ][ # # ]: 0 : if( !start->edge_ || !end->edge_ )
394 : 0 : return 0;
395 : :
396 [ # # ]: 0 : if( ! face )
397 : : {
398 : 0 : PST_Edge* start_edge = start->edge();
399 [ # # ]: 0 : do
400 : : {
401 : 0 : PST_Face* curr_face = start_edge->forward()->face();
402 : 0 : PST_Face* rev_face = start_edge->reverse()->face();
403 : : while( true )
404 : : {
405 : 0 : PST_CoEdge* coe = curr_face->coedge_;
406 [ # # ]: 0 : do
407 : : {
408 [ # # ]: 0 : if( coe->other( end ) )
409 : : {
410 [ # # ]: 0 : if( face ) return 0;
411 : :
412 : 0 : face = curr_face;
413 : 0 : curr_face = rev_face;
414 : 0 : break;
415 : : }
416 : 0 : coe = coe->next();
417 : 0 : } while( coe != curr_face->coedge_ );
418 : :
419 [ # # ]: 0 : if( curr_face == rev_face )
420 : 0 : break;
421 : : else
422 : 0 : curr_face = rev_face;
423 : : }
424 : :
425 : 0 : start_edge = start_edge->next(start);
426 : 0 : } while( start_edge != start->edge() );
427 : :
428 [ # # ]: 0 : if( !face ) return 0;
429 : : }
430 : :
431 : 0 : PST_CoEdge* start_coedge = 0;
432 : 0 : PST_CoEdge* end_coedge = 0;
433 : :
434 : 0 : PST_CoEdge* coedge = face->coedge_;
435 [ # # ]: 0 : do
436 : : {
437 [ # # ]: 0 : if( coedge->end_point() == start )
438 : : {
439 : 0 : start_coedge = coedge;
440 : 0 : break;
441 : : }
442 : 0 : coedge = coedge->next();
443 : 0 : } while( coedge != face->coedge_ );
444 : :
445 [ # # ]: 0 : if( ! start_coedge )
446 : 0 : return 0;
447 : :
448 : 0 : coedge = start_coedge->next();
449 : 0 : PST_CoEdge* stop = start_coedge;
450 [ # # ]: 0 : do
451 : : {
452 [ # # ]: 0 : if( coedge->end_point() == start )
453 : : {
454 : 0 : start_coedge = coedge;
455 : : }
456 : :
457 [ # # ]: 0 : if( coedge->end_point() == end )
458 : : {
459 : 0 : end_coedge = coedge;
460 : 0 : break;
461 : : }
462 : :
463 : 0 : coedge = coedge->next();
464 : : } while( coedge != stop );
465 : :
466 [ # # ]: 0 : if( ! end_coedge )
467 : 0 : return 0;
468 : :
469 : :
470 : 0 : return split_face( start_coedge, end_coedge );
471 : : }
472 : :
473 : 0 : PST_Edge* PST_Edge::split_face( PST_CoEdge* coedge1, PST_CoEdge* coedge2 )
474 : : {
475 : 0 : PST_Point* point1 = coedge1->end_point();
476 : 0 : PST_Point* point2 = coedge2->end_point();
477 : :
478 [ # # ][ # # ]: 0 : if( (coedge1->edge() == coedge2->edge() ) ||
479 [ # # ]: 0 : (coedge1->face() != coedge2->face() ) ||
480 [ # # # # ]: 0 : (point1 == point2 ) ||
481 : 0 : ( point1->common( point2 ) ) )
482 : 0 : return 0;
483 : :
484 [ # # ]: 0 : PST_Edge* new_edge = new PST_Edge( point1, point2 );
485 : 0 : new_edge->forward_.next_ = coedge2->next_;
486 : 0 : new_edge->reverse_.next_ = coedge1->next_;
487 : 0 : coedge1->next_ = new_edge->forward();
488 : 0 : coedge2->next_ = new_edge->reverse();
489 : :
490 : 0 : PST_Face* old_face = coedge1->face();
491 [ # # ]: 0 : PST_Face* new_face = new PST_Face( new_edge->forward(), old_face );
492 : : //new_face->boundary(0);
493 : 0 : old_face->coedge_ = new_edge->reverse();
494 : 0 : new_edge->reverse_.face_ = old_face;
495 : :
496 : 0 : coedge1 = new_edge->forward();
497 [ # # ]: 0 : do
498 : : {
499 : 0 : coedge1->face_ = new_face;
500 : 0 : coedge1 = coedge1->next();
501 : 0 : } while( coedge1 != new_edge->forward() );
502 : :
503 : 0 : return new_edge;
504 : : }
505 : :
506 : :
507 : 0 : PST_Edge* PST_Edge::insert_in_face( PST_Point* end,
508 : : PST_CoEdge* after_this )
509 : : {
510 [ # # ]: 0 : if( end->edge_ )
511 : 0 : return 0;
512 : :
513 : 0 : PST_Point* start = after_this->end_point();
514 [ # # ]: 0 : PST_Edge* new_edge = new PST_Edge( start, end );
515 : 0 : new_edge->forward_.next_ = new_edge->reverse();
516 : 0 : new_edge->reverse_.next_ = after_this->next_;
517 : 0 : new_edge->forward_.face_ = new_edge->reverse_.face_ = after_this->face_;
518 : 0 : after_this->next_ = new_edge->forward();
519 : 0 : after_this->face_->modified(true);
520 : 0 : return new_edge;
521 : : }
522 : :
523 : :
524 : 0 : PST_Edge* PST_Edge::split( PST_Point* point )
525 : : {
526 [ # # ]: 0 : if( point->edge_ )
527 : 0 : return 0;
528 : :
529 [ # # ]: 0 : PST_Edge* new_edge = new PST_Edge( point, end_ );
530 : :
531 [ # # ]: 0 : if (forward()->face()) {
532 : 0 : new_edge->forward_.face_ = forward_.face_;
533 : 0 : new_edge->forward_.next_ = forward_.next_;
534 : 0 : forward_.next_ = new_edge->forward();
535 : 0 : forward_.face_->modified(true);
536 : : }
537 [ # # ]: 0 : if (reverse()->face()) {
538 : 0 : new_edge->reverse_.face_ = reverse_.face_;
539 : 0 : new_edge->reverse_.next_ = reverse();
540 : 0 : reverse_.previous()->next_ = new_edge->reverse();
541 : 0 : reverse_.face_->modified(true);
542 : : }
543 : :
544 : 0 : set_end_point(point);
545 : :
546 : 0 : return new_edge;
547 : : }
548 : :
549 : :
550 : 0 : void PST_Edge::set_point( PST_Point* pt,
551 : : PST_Point*& ptr,
552 : : PST_Edge*& next )
553 : : {
554 [ # # ]: 0 : if( ptr )
555 : 0 : remove_point( ptr, next );
556 : :
557 : :
558 [ # # ]: 0 : if( pt->edge_ )
559 : : {
560 [ # # ]: 0 : if( pt->edge()->start_point() == pt )
561 : : {
562 : 0 : next = pt->edge()->start_next_;
563 : 0 : pt->edge()->start_next_ = this;
564 : : }
565 : : else
566 : : {
567 [ # # ]: 0 : assert( pt->edge()->end_point() == pt );
568 : 0 : next = pt->edge()->end_next_;
569 : 0 : pt->edge()->end_next_ = this;
570 : : }
571 : : }
572 : : else
573 : : {
574 : 0 : next = this;
575 : 0 : pt->edge_ = this;
576 : : }
577 : :
578 : 0 : ptr = pt;
579 : 0 : }
580 : :
581 : 0 : void PST_Edge::remove_point( PST_Point*& ptr, PST_Edge*& next )
582 : : {
583 [ # # ]: 0 : if( next == this )
584 : : {
585 : 0 : ptr->edge_ = 0;
586 : 0 : next= 0;
587 : 0 : ptr = 0;
588 : 0 : return;
589 : : }
590 : :
591 : 0 : PST_Edge* prev = next;
592 [ # # ]: 0 : while( prev->next(ptr) != this )
593 : : {
594 : 0 : prev = prev->next(ptr);
595 [ # # ]: 0 : assert( prev != next );
596 : : }
597 : :
598 [ # # ]: 0 : if( prev->start_next_ == this )
599 : : {
600 : 0 : prev->start_next_ = next;
601 : : }
602 : : else
603 : : {
604 [ # # ]: 0 : assert(prev->end_next_ == this);
605 : 0 : prev->end_next_ = next;
606 : : }
607 : :
608 [ # # ]: 0 : if( ptr->edge_ == this )
609 : 0 : ptr->edge_ = next;
610 : : }
611 : :
612 : :
613 : 0 : void PST_Point::debug_draw( int color, bool flush )
614 : : {
615 : 0 : GfxDebug::draw_point( float(x()), float(y()), float(z()), color );
616 [ # # ]: 0 : if( flush )
617 : 0 : GfxDebug::flush();
618 : 0 : }
619 : :
620 : 0 : void PST_Edge::debug_draw( int color, bool flush )
621 : : {
622 : : GfxDebug::draw_line(
623 : 0 : float(start_coord().x()), float(start_coord().y()), float(start_coord().z()),
624 : 0 : float( end_coord().x()), float( end_coord().y()), float( end_coord().z()),
625 : 0 : color );
626 [ # # ]: 0 : if( flush ) GfxDebug::flush();
627 : 0 : }
628 : :
629 : 0 : void PST_Face::debug_draw( int color, bool flush )
630 : : {
631 : 0 : PST_CoEdge* coedge = first_coedge();
632 [ # # ]: 0 : do
633 : : {
634 : 0 : coedge->edge()->debug_draw( color, false );
635 : 0 : coedge = coedge->next();
636 : 0 : } while( coedge != first_coedge() );
637 [ # # ]: 0 : if( flush ) GfxDebug::flush();
638 : 0 : }
639 : :
640 : 0 : void PST_Edge::make_gmem( GMem& gmem, DLIList<PST_Face*>& facets )
641 : : {
642 [ # # ][ # # ]: 0 : DLIList<PST_Point*> point_list, temp_list;
[ # # ]
643 : : int i, j, pcount, fcount;
644 : :
645 [ # # ][ # # ]: 0 : for( i = facets.size(); i--; )
646 : : {
647 [ # # ]: 0 : PST_Face* facet = facets.get_and_step();
648 : : // if( facet->boundary() )
649 : : // continue;
650 : :
651 [ # # ]: 0 : temp_list.clean_out();
652 [ # # ]: 0 : facet->append_points( temp_list );
653 [ # # ][ # # ]: 0 : for( j = temp_list.size(); j--; )
654 : : {
655 [ # # ]: 0 : temp_list.get_and_step()->mark = -1;
656 : : }
657 : : }
658 : :
659 : 0 : pcount = 0;
660 : 0 : fcount = 0;
661 [ # # ][ # # ]: 0 : for( i = facets.size(); i--; )
662 : : {
663 [ # # ]: 0 : PST_Face* facet = facets.get_and_step();
664 : : // if( facet->boundary() )
665 : : // continue;
666 : :
667 [ # # ]: 0 : temp_list.clean_out();
668 [ # # ]: 0 : facet->append_points( temp_list );
669 [ # # ]: 0 : fcount += temp_list.size() + 1;
670 [ # # ][ # # ]: 0 : for( j = temp_list.size(); j--; )
671 : : {
672 [ # # ]: 0 : PST_Point* pt_ptr = temp_list.get_and_step();
673 [ # # ]: 0 : if( pt_ptr->mark == -1 )
674 : : {
675 : 0 : pt_ptr->mark = pcount++;
676 [ # # ]: 0 : point_list.append( pt_ptr );
677 : : }
678 : : }
679 : : }
680 : :
681 [ # # ][ # # ]: 0 : gmem.allocate_tri( facets.size() );
682 [ # # ]: 0 : gmem.pointListCount = point_list.size();
683 [ # # ]: 0 : GPoint* pt_array = gmem.point_list();
684 : :
685 [ # # ]: 0 : point_list.reset();
686 [ # # ][ # # ]: 0 : for( i = 0; i < point_list.size(); i++ )
687 : : {
688 [ # # ]: 0 : PST_Point* pt_ptr = point_list.get_and_step();
689 [ # # ]: 0 : pt_array[i].x = float(pt_ptr->x());
690 [ # # ]: 0 : pt_array[i].y = float(pt_ptr->y());
691 [ # # ]: 0 : pt_array[i].z = float(pt_ptr->z());
692 : : }
693 : :
694 [ # # ]: 0 : gmem.fListCount = facets.size() * 4;
695 [ # # ]: 0 : int* offset = gmem.facet_list();
696 [ # # ][ # # ]: 0 : for( i = facets.size(); i--; )
697 : : {
698 : : // if( facets.get()->boundary() )
699 : : // continue;
700 : :
701 [ # # ]: 0 : temp_list.clean_out();
702 [ # # ][ # # ]: 0 : facets.get_and_step()->append_points( temp_list );
703 [ # # ]: 0 : *(offset++) = temp_list.size();
704 [ # # ][ # # ]: 0 : for( j = temp_list.size(); j--; )
705 : : {
706 [ # # ]: 0 : *(offset++) = temp_list.get_and_step()->mark;
707 : : }
708 [ # # ]: 0 : }
709 : 0 : }
710 : :
711 : 0 : void PST_Edge::make_gmem( GMem& gmem, DLIList<PST_Edge*>& edges )
712 : : {
713 [ # # ]: 0 : DLIList<PST_Face*> face_list;
714 [ # # ]: 0 : PST_Edge::faces( edges, face_list );
715 [ # # ][ # # ]: 0 : make_gmem( gmem, face_list );
716 : 0 : }
717 : :
718 : 0 : void PST_Point::debug_draw_points( DLIList<PST_Point*>& point_list, int color, bool flush )
719 : : {
720 [ # # ]: 0 : for( int p = point_list.size(); p--; )
721 : 0 : point_list.get_and_step()->debug_draw(color, false);
722 [ # # ]: 0 : if( flush ) GfxDebug::flush();
723 : 0 : }
724 : :
725 : 0 : void PST_Edge::debug_draw_points( DLIList<PST_Edge*>& edge_list,
726 : : int color, int boundary_color, bool flush )
727 : : {
728 [ # # ]: 0 : if( ! boundary_color ) boundary_color = color;
729 : :
730 [ # # ]: 0 : DLIList<PST_Point*> point_list;
731 [ # # ][ # # ]: 0 : DLIList<PST_Point*> boundary_list;
732 [ # # ]: 0 : PST_Edge::points( edge_list, point_list );
733 [ # # ][ # # ]: 0 : for( int i = point_list.size(); i--; )
734 : : {
735 [ # # ]: 0 : PST_Point* pt = point_list.step_and_get();
736 [ # # ]: 0 : PST_Edge* e = pt->edge();
737 [ # # ]: 0 : do
738 : : {
739 [ # # ][ # # ]: 0 : if( !e->forward()->face() || !e->reverse()->face() )
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
740 : 0 : break;
741 [ # # ]: 0 : e = e->next(pt);
742 [ # # ]: 0 : } while( e != pt->edge() );
743 [ # # ][ # # ]: 0 : if( !e->forward()->face() || !e->reverse()->face() )
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
744 : : {
745 [ # # ]: 0 : point_list.change_to( 0 );
746 [ # # ]: 0 : boundary_list.append( pt );
747 : : }
748 : : }
749 [ # # ]: 0 : point_list.remove_all_with_value(0);
750 : :
751 [ # # ]: 0 : PST_Point::debug_draw_points( point_list, color, false );
752 [ # # ][ # # ]: 0 : PST_Point::debug_draw_points( boundary_list, boundary_color, flush );
753 : 0 : }
754 : :
755 : 0 : void PST_Edge::debug_draw_edges( DLIList<PST_Edge*>& edge_list,
756 : : int color, int boundary_color,
757 : : bool flush )
758 : : {
759 [ # # ]: 0 : if( !boundary_color ) boundary_color = color;
760 : :
761 [ # # ]: 0 : for( int e = edge_list.size(); e--; )
762 : : {
763 : 0 : PST_Edge* edge_ptr = edge_list.get_and_step();
764 [ # # ]: 0 : int c = !edge_ptr->forward()->face() || !edge_ptr->reverse()->face()
765 [ # # ]: 0 : ? boundary_color : color;
766 : 0 : edge_ptr->debug_draw( c, false );
767 : : }
768 [ # # ]: 0 : if( flush ) GfxDebug::flush();
769 : 0 : }
770 : :
771 : 0 : void PST_Edge::debug_draw_faces( DLIList<PST_Edge*>& edge_list, int color, bool flush )
772 : : {
773 [ # # ]: 0 : DLIList<PST_Face*> face_list;
774 [ # # ]: 0 : PST_Edge::faces( edge_list, face_list );
775 [ # # ][ # # ]: 0 : PST_Face::debug_draw_faces( face_list, color, flush );
776 : 0 : }
777 : :
778 : 0 : void PST_Edge::faces( DLIList<PST_Edge*>& edges, DLIList<PST_Face*>& faces )
779 : : {
780 : : int e;
781 [ # # ]: 0 : for( e = edges.size(); e--; )
782 : : {
783 : 0 : PST_Edge* edge_ptr = edges.get_and_step();
784 [ # # ]: 0 : if( edge_ptr->forward()->face() )
785 : 0 : edge_ptr->forward()->face()->private_mark_ = 1;
786 [ # # ]: 0 : if( edge_ptr->reverse()->face() )
787 : 0 : edge_ptr->reverse()->face()->private_mark_ = 1;
788 : : }
789 [ # # ]: 0 : for( e = edges.size(); e--; )
790 : : {
791 [ # # ]: 0 : PST_Edge* edge_ptr = edges.get_and_step();
792 [ # # ][ # # ]: 0 : PST_Face* fface_ptr = edge_ptr->forward()->face();
793 [ # # ][ # # ]: 0 : PST_Face* rface_ptr = edge_ptr->reverse()->face();
794 [ # # ][ # # ]: 0 : if( fface_ptr && fface_ptr->private_mark_ )
795 : : {
796 : 0 : fface_ptr->private_mark_ = 0;
797 [ # # ]: 0 : faces.append( fface_ptr );
798 : : }
799 [ # # ][ # # ]: 0 : if( rface_ptr && rface_ptr->private_mark_ )
800 : : {
801 : 0 : rface_ptr->private_mark_ = 0;
802 [ # # ]: 0 : faces.append( rface_ptr );
803 : : }
804 : : }
805 : 0 : }
806 : :
807 : 0 : void PST_Edge::edges( DLIList<PST_Face*>& faces, DLIList<PST_Edge*>& edges )
808 : : {
809 : : int f;
810 [ # # ]: 0 : for( f = faces.size(); f--; )
811 : : {
812 : 0 : PST_CoEdge* first = faces.get_and_step()->first_coedge();
813 : 0 : PST_CoEdge* coedge = first;
814 [ # # ]: 0 : do
815 : : {
816 : 0 : coedge->edge()->private_mark_ = 1;
817 : 0 : coedge = coedge->next();
818 : : } while( coedge != first );
819 : : }
820 : :
821 [ # # ]: 0 : for( f = faces.size(); f--; )
822 : : {
823 : 0 : PST_CoEdge* first = faces.get_and_step()->first_coedge();
824 : 0 : PST_CoEdge* coedge = first;
825 [ # # ]: 0 : do
826 : : {
827 [ # # ]: 0 : if( coedge->edge()->private_mark_ )
828 : : {
829 : 0 : coedge->edge()->private_mark_ = 0;
830 [ # # ]: 0 : edges.append( coedge->edge() );
831 : : }
832 : 0 : coedge = coedge->next();
833 : : } while( coedge != first );
834 : : }
835 : 0 : }
836 : :
837 : 0 : void PST_Edge::edges( DLIList<PST_Point*>& pts, DLIList<PST_Edge*>& edges )
838 : : {
839 : : int p;
840 [ # # ]: 0 : for( p = pts.size(); p--; )
841 : : {
842 : 0 : PST_Point* pt = pts.get_and_step();
843 : 0 : PST_Edge* edge = pt->edge();
844 [ # # # # ]: 0 : if( edge ) do
845 : : {
846 : 0 : edge->private_mark_ = 1;
847 : 0 : edge = edge->next( pt );
848 : 0 : } while( edge != pt->edge() );
849 : : }
850 : :
851 [ # # ]: 0 : for( p = pts.size(); p--; )
852 : : {
853 [ # # ]: 0 : PST_Point* pt = pts.get_and_step();
854 [ # # ]: 0 : PST_Edge* edge = pt->edge();
855 [ # # ][ # # ]: 0 : if( edge ) do
856 : : {
857 [ # # ]: 0 : if( edge->private_mark_ )
858 : : {
859 : 0 : edge->private_mark_ = 0;
860 [ # # ]: 0 : edges.append( edge );
861 : : }
862 [ # # ]: 0 : edge = edge->next( pt );
863 [ # # ]: 0 : } while( edge != pt->edge() );
864 : : }
865 : 0 : }
866 : :
867 : :
868 : 0 : void PST_Edge::points( DLIList<PST_Edge*>& edges, DLIList<PST_Point*>& points )
869 : : {
870 : : int e;
871 [ # # ]: 0 : for( e = edges.size(); e--; )
872 : : {
873 : 0 : PST_Edge* edge_ptr = edges.get_and_step();
874 : 0 : edge_ptr->start_point()->private_mark_ = 1;
875 : 0 : edge_ptr->end_point()->private_mark_ = 1;
876 : : }
877 [ # # ]: 0 : for( e = edges.size(); e--; )
878 : : {
879 [ # # ]: 0 : PST_Edge* edge_ptr = edges.get_and_step();
880 [ # # ]: 0 : PST_Point* sp = edge_ptr->start_point();
881 [ # # ]: 0 : PST_Point* ep = edge_ptr->end_point();
882 [ # # ]: 0 : if( sp->private_mark_ )
883 : : {
884 : 0 : sp->private_mark_ = 0;
885 [ # # ]: 0 : points.append( sp );
886 : : }
887 [ # # ]: 0 : if( ep->private_mark_ )
888 : : {
889 : 0 : ep->private_mark_ = 0;
890 [ # # ]: 0 : points.append( ep );
891 : : }
892 : : }
893 : 0 : }
894 : :
895 : 0 : void PST_Face::debug_draw_faces( DLIList<PST_Face*>& face_list, int color, bool flush )
896 : : {
897 [ # # ]: 0 : for( int f = face_list.size(); f--; )
898 : 0 : face_list.get_and_step()->debug_draw( color, false );
899 [ # # ]: 0 : if( flush ) GfxDebug::flush();
900 : 0 : }
901 : :
902 : 0 : void PST_Edge::make_facets( GMem& gmem, double tolerance,
903 : : DLIList<PST_Edge*>& edge_list )
904 : : {
905 [ # # ]: 0 : assert(gmem.fListCount % 4 == 0);
906 [ # # ]: 0 : std::vector<double> points(gmem.pointListCount*3);
907 [ # # ][ # # ]: 0 : std::vector<int> facets(gmem.fListCount*3/4);
908 : : int i;
909 [ # # ]: 0 : GPoint* pitor = gmem.point_list();
910 [ # # ]: 0 : std::vector<double>::iterator ditor = points.begin();
911 [ # # ]: 0 : for ( i = gmem.pointListCount; i--; )
912 : : {
913 [ # # ][ # # ]: 0 : *ditor++ = pitor->x;
914 [ # # ][ # # ]: 0 : *ditor++ = pitor->y;
915 [ # # ][ # # ]: 0 : *ditor++ = pitor->z;
916 : 0 : pitor++;
917 : : }
918 : :
919 [ # # ]: 0 : int* fitor = gmem.facet_list();
920 [ # # ]: 0 : std::vector<int>::iterator iitor = facets.begin();
921 [ # # ]: 0 : for ( i = 0; i < gmem.fListCount; i += 4 )
922 : : {
923 [ # # ]: 0 : assert( *fitor++ == 3 );
924 [ # # ][ # # ]: 0 : *iitor++ = *fitor++;
925 [ # # ][ # # ]: 0 : *iitor++ = *fitor++;
926 [ # # ][ # # ]: 0 : *iitor++ = *fitor++;
927 : : }
928 : :
929 [ # # ][ # # ]: 0 : make_facets( points, facets, tolerance, edge_list );
930 : 0 : }
931 : :
932 : 0 : void PST_Edge::make_facets(
933 : : const std::vector<double>& coordinates,
934 : : const std::vector<int>& connections,
935 : : double tolerance,
936 : : DLIList<PST_Edge*>& edge_list )
937 : : {
938 [ # # ]: 0 : DLIList<PST_Face*> face_list;
939 : 0 : double tol_sqr = tolerance * tolerance;
940 : : int i, j, k, numcoords, numtriangles;
941 : :
942 [ # # ]: 0 : numcoords = coordinates.size()/3;
943 [ # # ]: 0 : numtriangles = connections.size()/3;
944 : : //The list of points created.
945 [ # # ][ # # ]: 0 : PST_Point** ptlist = new PST_Point*[numcoords];
946 : :
947 : : //The list of indices into ptlist, where the index into this
948 : : //list is the same as the index into the point list, and
949 : : //the value in this list is the index of the corresponding
950 : : //point in ptlist. This is used because some points will
951 : : //be merged due to the tolerance.
952 [ # # ][ # # ]: 0 : int* ptindex_list = new int[numcoords];
953 : :
954 : : //Create the points
955 : 0 : k = 0;
956 [ # # ]: 0 : for( i = 0; i < numcoords; i++ )
957 : : {
958 [ # # ][ # # ]: 0 : CubitVector pos( coordinates[3*i], coordinates[3*i+1], coordinates[3*i+2] );
[ # # ][ # # ]
959 : :
960 : : //Check if we need to merge this point with a different point
961 [ # # ]: 0 : for( j = 0; j < k; j++ )
962 : : {
963 [ # # ][ # # ]: 0 : if( (*(ptlist[j]) - pos).length_squared() <= tol_sqr )
[ # # ]
964 : 0 : break;
965 : : }
966 [ # # ]: 0 : if( j == k )
967 : : {
968 [ # # ][ # # ]: 0 : ptlist[k] = new PST_Point( pos );
969 : 0 : ptlist[k++]->sequence = i;
970 : : }
971 : 0 : ptindex_list[i] = j;
972 : : }
973 : :
974 : 0 : int fail_count = 0;
975 [ # # ]: 0 : for ( i = 0; i < numtriangles; i++ )
976 : : {
977 [ # # ]: 0 : int i1 = ptindex_list[connections[3*i ]];
978 [ # # ]: 0 : int i2 = ptindex_list[connections[3*i+1]];
979 [ # # ]: 0 : int i3 = ptindex_list[connections[3*i+2]];
980 [ # # ][ # # ]: 0 : if ( i1 == i2 || i2 == i3 || i3 == i1 )
[ # # ]
981 : : {
982 [ # # ][ # # ]: 0 : PRINT_ERROR("Degenerate facet encountered in PST_Edge::make_facets()\n");
[ # # ][ # # ]
983 : 0 : fail_count++;
984 : : }
985 : : else
986 : : {
987 : : PST_Face* new_face
988 [ # # ]: 0 : = PST_Edge::create_face( ptlist[i1], ptlist[i2], ptlist[i3] );
989 [ # # ]: 0 : if( new_face ){
990 [ # # ]: 0 : face_list.append(new_face);
991 : 0 : new_face->sequence = i;
992 : : }
993 : : else{
994 : 0 : fail_count++;
995 : : }
996 : : }
997 : : }
998 : :
999 [ # # ]: 0 : if( fail_count > 0 )
1000 [ # # ][ # # ]: 0 : PRINT_ERROR("Failed to construct %d facets in PST_Data::make_facets(..)\n",
[ # # ]
1001 [ # # ]: 0 : fail_count);
1002 : :
1003 [ # # ]: 0 : delete [] ptindex_list;
1004 [ # # ]: 0 : delete [] ptlist;
1005 : :
1006 [ # # ]: 0 : if(fail_count == 0)
1007 : : {
1008 [ # # ]: 0 : PST_Edge::edges( face_list, edge_list );
1009 [ # # ]: 0 : validate( edge_list, true );
1010 : 0 : bool debug1 = false;
1011 [ # # ]: 0 : if (debug1)
1012 [ # # ]: 0 : debug_draw_edges( edge_list, CUBIT_BLUE_INDEX, CUBIT_RED_INDEX, true );
1013 [ # # ]: 0 : }
1014 : 0 : }
1015 : :
1016 : 0 : int PST_Point::validate(CubitBoolean print)
1017 : : {
1018 [ # # ][ # # ]: 0 : if( edge_ && !edge_->other(this) )
[ # # ]
1019 : : {
1020 [ # # ]: 0 : if( print )
1021 : : {
1022 [ # # ][ # # ]: 0 : PRINT_INFO("Bad point->edge link. Point %p, Edge %p.\n", (void*)this, (void*)edge_);
1023 : : }
1024 : 0 : return 1;
1025 : : }
1026 : 0 : return 0;
1027 : : }
1028 : :
1029 : 0 : int PST_Edge::validate(CubitBoolean print)
1030 : : {
1031 : 0 : int result = 0;
1032 : 0 : int count = 0;
1033 : 0 : PST_Edge* edge = 0;
1034 : :
1035 [ # # ]: 0 : if( !start_ )
1036 : : {
1037 [ # # ][ # # ]: 0 : if( print ) PRINT_ERROR("Edge %p has null start point.\n", (void*)this);
[ # # ]
1038 : 0 : result++;
1039 : : }
1040 : : else
1041 : : {
1042 : 0 : result += start_->validate(print);
1043 : :
1044 : 0 : edge = this;
1045 : 0 : count = 0;
1046 [ # # ]: 0 : do
1047 : : {
1048 [ # # ]: 0 : if( count++ > PST_MAX_LIST_LEN )
1049 : : {
1050 [ # # ]: 0 : if( print )
1051 : : {
1052 [ # # ][ # # ]: 0 : PRINT_ERROR("Bad edge list around Point %p.\n", (void*)start_);
1053 : : }
1054 : 0 : result++;
1055 : 0 : break;
1056 : : }
1057 : 0 : edge = edge->next( start_ );
1058 : : } while( edge != this );
1059 : : }
1060 : :
1061 : :
1062 [ # # ]: 0 : if( !end_ )
1063 : : {
1064 [ # # ][ # # ]: 0 : if( print ) PRINT_ERROR("Edge %p has null end point.\n", (void*)this);
[ # # ]
1065 : 0 : result++;
1066 : : }
1067 : : else
1068 : : {
1069 : 0 : result += end_->validate(print);
1070 : :
1071 : 0 : count = 0;
1072 : 0 : edge = this;
1073 [ # # ]: 0 : do
1074 : : {
1075 [ # # ]: 0 : if( count++ > PST_MAX_LIST_LEN )
1076 : : {
1077 [ # # ]: 0 : if( print )
1078 : : {
1079 [ # # ][ # # ]: 0 : PRINT_ERROR("Bad edge list around Point %p.\n", (void*)end_);
1080 : : }
1081 : 0 : result++;
1082 : 0 : break;
1083 : : }
1084 : 0 : edge = edge->next( end_ );
1085 : : } while( edge != this );
1086 : : }
1087 : :
1088 [ # # ][ # # ]: 0 : if (forward_.face_ && !forward_.next_)
1089 : : {
1090 [ # # ]: 0 : if( print )
1091 [ # # ]: 0 : PRINT_ERROR("Forward CoEdge on Edge %p as Face %p but no next().\n",
1092 [ # # ]: 0 : (void*)this, (void*)forward_.face_);
1093 : 0 : count++;
1094 : : }
1095 : :
1096 [ # # ][ # # ]: 0 : if (reverse_.face_ && !reverse_.next_)
1097 : : {
1098 [ # # ]: 0 : if( print )
1099 [ # # ]: 0 : PRINT_ERROR("Reverse CoEdge on Edge %p as Face %p but no next().\n",
1100 [ # # ]: 0 : (void*)this, (void*)reverse_.face_);
1101 : 0 : count++;
1102 : : }
1103 : :
1104 [ # # ][ # # ]: 0 : if (!forward_.face_ && forward_.next_)
1105 : : {
1106 [ # # ]: 0 : if( print )
1107 [ # # ]: 0 : PRINT_ERROR("Forward CoEdge on Edge %p as %p as next CoEdge but no Face.\n",
1108 [ # # ]: 0 : (void*)this, (void*)forward_.next_);
1109 : 0 : count++;
1110 : : }
1111 : :
1112 [ # # ][ # # ]: 0 : if (!reverse_.face_ && reverse_.next_)
1113 : : {
1114 [ # # ]: 0 : if( print )
1115 [ # # ]: 0 : PRINT_ERROR("Reverse CoEdge on Edge %p as %p as next CoEdge but no Face.\n",
1116 [ # # ]: 0 : (void*)this, (void*)reverse_.next_);
1117 : 0 : count++;
1118 : : }
1119 : :
1120 : 0 : return result;
1121 : : }
1122 : :
1123 : 0 : int PST_CoEdge::validate( CubitBoolean print )
1124 : : {
1125 : 0 : int result = 0;
1126 [ # # ]: 0 : if( ! edge_ )
1127 : : {
1128 [ # # ][ # # ]: 0 : if( print ) PRINT_ERROR("Coedge %p has null edge.\n", (void*)this);
[ # # ]
1129 : 0 : result++;
1130 : : }
1131 : : else
1132 : : {
1133 [ # # ]: 0 : if( ! edge_->other( this ) )
1134 : : {
1135 [ # # ]: 0 : if( print )
1136 [ # # ]: 0 : PRINT_ERROR( "Inconsistent coedge->edge link. CoEdge: %p Edge: %p\n",
1137 [ # # ]: 0 : (void*)edge_, (void*)this );
1138 : 0 : result++;
1139 : : }
1140 : 0 : result += edge_->validate(print);
1141 : : }
1142 : 0 : return result;
1143 : : }
1144 : :
1145 : 0 : int PST_Face::validate( CubitBoolean print )
1146 : : {
1147 : 0 : PST_CoEdge* coe = coedge_;
1148 : :
1149 [ # # ]: 0 : if( !coedge_ )
1150 : : {
1151 [ # # ][ # # ]: 0 : if(print) PRINT_ERROR("Face %p has null loop.\n", (void*)this);
[ # # ]
1152 : 0 : return 1;
1153 : : }
1154 : :
1155 : 0 : int count = 0;
1156 : 0 : int result = 0;
1157 [ # # ]: 0 : do
1158 : : {
1159 [ # # ]: 0 : if( count++ > PST_MAX_LIST_LEN )
1160 : : {
1161 [ # # ][ # # ]: 0 : if( print ) PRINT_ERROR("Face %p loop is infinite.\n", (void*)this);
[ # # ]
1162 : 0 : result++;
1163 : 0 : break;
1164 : : }
1165 : :
1166 [ # # ]: 0 : if( coe->face() != this )
1167 : : {
1168 [ # # ]: 0 : if( print )
1169 [ # # ]: 0 : PRINT_ERROR("Loop for face %p contains face %p on edge %p.\n",
1170 [ # # ]: 0 : (void*)this, (void*)coe->face(), (void*)coe->edge() );
1171 : 0 : result++;
1172 : : }
1173 : :
1174 [ # # ]: 0 : if( coe->edge() )
1175 : : {
1176 : 0 : result += coe->edge()->validate( print );
1177 : : }
1178 : : else
1179 : : {
1180 [ # # ]: 0 : if( print )
1181 [ # # ][ # # ]: 0 : PRINT_ERROR("Coedge %p in face %p has null edge.\n", (void*)coe, (void*)this);
1182 : 0 : result++;
1183 : : }
1184 : :
1185 [ # # ]: 0 : if( ! coe->next() )
1186 : : {
1187 [ # # ]: 0 : if( print )
1188 [ # # ][ # # ]: 0 : PRINT_ERROR("Null coedge after coedge %p in face %p.\n", (void*)coe, (void*)this );
1189 : 0 : result++;
1190 : 0 : break;
1191 : : }
1192 : :
1193 : 0 : coe = coe->next();
1194 : :
1195 : 0 : } while( coe != coedge_ );
1196 : :
1197 : 0 : return result;
1198 : : }
1199 : :
1200 : 0 : int PST_Edge::validate( DLIList<PST_Edge*>& edges, CubitBoolean print )
1201 : : {
1202 [ # # ]: 0 : DLIList<PST_Face*> faces;
1203 [ # # ]: 0 : PST_Edge::faces( edges, faces );
1204 : :
1205 : 0 : int result = 0;
1206 [ # # ][ # # ]: 0 : for( int f = faces.size(); f--; )
1207 [ # # ][ # # ]: 0 : result += faces.get_and_step()->validate(print);
1208 [ # # ]: 0 : return result;
1209 : : }
1210 : :
1211 : 0 : void PST_Face::print()
1212 : : {
1213 [ # # ]: 0 : if( ! coedge_ )
1214 : : {
1215 [ # # ][ # # ]: 0 : PRINT_ERROR("Face %p has null coedge.\n", (void*)this);
1216 : 0 : return;
1217 : : }
1218 : :
1219 [ # # ]: 0 : PRINT_INFO("Face CoEdge Edge Start Pt End Pt\n"
1220 [ # # ]: 0 : "---------- ----------- ----------- ----------- -----------\n" );
1221 : 0 : PST_CoEdge* coe = coedge_;
1222 [ # # ]: 0 : PRINT_INFO("%10p %10p %10p %10p %10p\n",
1223 [ # # ]: 0 : (void*)this, (void*)coe, (void*)coe->edge(), (void*)coe->start_point(), (void*)coe->end_point() );
1224 : 0 : coe = coe->next();
1225 [ # # ][ # # ]: 0 : while( coe && coe != coedge_ )
1226 : : {
1227 [ # # ]: 0 : PRINT_INFO(" %10p %10p %10p %10p\n",
1228 [ # # ]: 0 : (void*)coe, (void*)coe->edge(), (void*)coe->start_point(), (void*)coe->end_point() );
1229 : 0 : coe = coe->next();
1230 : : }
1231 : : }
1232 : :
1233 : 0 : void PST_Edge::print()
1234 : : {
1235 [ # # ]: 0 : PRINT_INFO("Edge %p: Points: Start: %p End: %p Faces: Forward: %p Reverse: %p\n",
1236 [ # # ]: 0 : (void*)this, (void*)start_, (void*)end_, (void*)forward_.face_, (void*)reverse_.face_ );
1237 : 0 : }
1238 : :
1239 : 0 : void PST_Point::print()
1240 : : {
1241 [ # # ][ # # ]: 0 : PRINT_INFO("Point %p : ( %f, %f, %f )", (void*)this , x(), y(), z() );
1242 : :
1243 [ # # ]: 0 : if( edge_ )
1244 : : {
1245 [ # # ][ # # ]: 0 : PRINT_INFO(" Edges:");
1246 : 0 : int count = 0;
1247 : 0 : PST_Edge* edge = edge_;
1248 [ # # ]: 0 : do
1249 : : {
1250 [ # # ]: 0 : if( count )
1251 : : {
1252 [ # # ][ # # ]: 0 : PRINT_INFO("\t%8p", (void*)edge);
1253 : : }
1254 : : else
1255 : : {
1256 [ # # ][ # # ]: 0 : PRINT_INFO("\n\t%8p", (void*)edge);
1257 : : }
1258 : :
1259 : 0 : count = (count + 1) % 4;
1260 : 0 : edge = edge->next(this);
1261 : :
1262 [ # # ]: 0 : } while( edge && edge != edge_ );
1263 : :
1264 : : }
1265 [ # # ][ # # ]: 0 : PRINT_INFO("\n");
1266 : 0 : }
1267 : :
1268 : :
1269 : 0 : PST_Entity::~PST_Entity()
1270 [ + - ][ + - ]: 6540 : { }
[ # # ]
1271 : :
|
