Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : PartitionCurve-new.cpp
3 : : //
4 : : // Purpose :
5 : : //
6 : : // Special Notes :
7 : : //
8 : : // Creator : Jason Kraftcheck
9 : : //
10 : : // Creation Date : 04/10/02
11 : : //-------------------------------------------------------------------------
12 : :
13 : : #include "PartitionCurve.hpp"
14 : : #include "PartitionPoint.hpp"
15 : : #include "PartitionCoEdge.hpp"
16 : : #include "PartitionSurface.hpp"
17 : : #include "VirtualQueryEngine.hpp"
18 : : #include "PartSurfFacetTool.hpp"
19 : :
20 : : #include "TDVGFacetOwner.hpp"
21 : : #include "CubitFacetEdgeData.hpp"
22 : : #include "CubitPointData.hpp"
23 : : #include "CubitFacetData.hpp"
24 : : #include "CubitTransformMatrix.hpp"
25 : : #include "Surface.hpp"
26 : :
27 : : #include "GfxDebug.hpp"
28 : : #include "GMem.hpp"
29 : :
30 : : /*
31 : : void print_point_list( PartitionPoint* point )
32 : : {
33 : : PRINT_INFO(" Point %p: (%d curves)\n", point, point ? point->num_curves() : 0 );
34 : : if(!point) { PRINT_INFO("\n\n"); return; }
35 : :
36 : : PartitionCurve* curve = 0;
37 : : while( curve = point->next_curve(curve) )
38 : : PRINT_INFO("%10p",curve);
39 : : PRINT_INFO("\n");
40 : : curve = 0;
41 : :
42 : : while( curve = point->next_curve(curve) )
43 : : PRINT_INFO("%10s",
44 : : curve->start_point() == point && curve->end_point() == point ? "(both)" :
45 : : curve->start_point() == point ? "(start)" :
46 : : curve->end_point() == point ? "(end)" : "(none)" );
47 : : PRINT_INFO("\n");
48 : : }
49 : : */
50 : :
51 : 0 : PartitionCurve::PartitionCurve( )
52 : : : firstCoEdge(0),
53 : : startPoint(0),
54 : : endPoint(0),
55 : : startNext(0),
56 [ # # ][ # # ]: 0 : endNext(0)
57 : : {
58 : 0 : }
59 : :
60 [ # # ][ # # ]: 0 : PartitionCurve::~PartitionCurve()
61 : : {
62 [ # # ]: 0 : start_point(0);
63 [ # # ]: 0 : end_point(0);
64 : :
65 [ # # ]: 0 : remove_all_coedges();
66 [ # # ]: 0 : remove_facet_data();
67 [ # # ]: 0 : }
68 : :
69 : 0 : CubitStatus PartitionCurve::add( PartitionCoEdge* coedge )
70 : : {
71 [ # # ]: 0 : if( coedge->myCurve )
72 : 0 : return CUBIT_FAILURE;
73 : :
74 : 0 : coedge->curveNext = firstCoEdge;
75 : 0 : firstCoEdge = coedge;
76 : 0 : coedge->myCurve = this;
77 : 0 : return CUBIT_SUCCESS;
78 : : }
79 : :
80 : 0 : CubitStatus PartitionCurve::remove( PartitionCoEdge* coedge )
81 : : {
82 [ # # ]: 0 : if( coedge->myCurve != this )
83 : 0 : return CUBIT_FAILURE;
84 : :
85 [ # # ]: 0 : if( firstCoEdge == coedge )
86 : : {
87 : 0 : firstCoEdge = coedge->curveNext;
88 : : }
89 : : else
90 : : {
91 : 0 : PartitionCoEdge* prev = firstCoEdge;
92 [ # # ][ # # ]: 0 : while( prev && prev->curveNext != coedge )
93 : 0 : prev = prev->curveNext;
94 : :
95 [ # # ]: 0 : if( !prev )
96 : : {
97 : 0 : assert(0);
98 : : return CUBIT_FAILURE;
99 : : }
100 : :
101 : 0 : prev->curveNext = coedge->curveNext;
102 : : }
103 : :
104 : 0 : coedge->curveNext = 0;
105 : 0 : coedge->myCurve = 0;
106 : 0 : return CUBIT_SUCCESS;
107 : : }
108 : :
109 : 0 : int PartitionCurve::num_coedges() const
110 : : {
111 : 0 : int count = 0;
112 [ # # ]: 0 : for( PartitionCoEdge* coe = firstCoEdge; coe; coe = coe->curveNext )
113 : 0 : count++;
114 : 0 : return count;
115 : : }
116 : :
117 : 0 : void PartitionCurve::remove_all_coedges( )
118 : : {
119 [ # # ][ # # ]: 0 : while( firstCoEdge && remove(firstCoEdge) ) {;}
[ # # ]
120 [ # # ]: 0 : assert( !firstCoEdge );
121 : 0 : }
122 : :
123 : 0 : CubitStatus PartitionCurve::start_point( PartitionPoint* point )
124 : : {
125 [ # # ]: 0 : if( point == startPoint )
126 : 0 : return CUBIT_SUCCESS;
127 : :
128 [ # # ]: 0 : if( !remove_start_point() )
129 : 0 : { assert(0); return CUBIT_FAILURE; }
130 : :
131 [ # # ]: 0 : if( !point )
132 : 0 : return CUBIT_SUCCESS;
133 : :
134 : 0 : startPoint = point;
135 [ # # ]: 0 : if( point == endPoint )
136 : : {
137 : 0 : startNext = endNext;
138 : 0 : endNext = 0;
139 : : }
140 : : else
141 : : {
142 : 0 : startNext = point->firstCurve;
143 : 0 : point->firstCurve = this;
144 : 0 : point->curveCount++;
145 : : }
146 : :
147 : 0 : return CUBIT_SUCCESS;
148 : : }
149 : :
150 : 0 : CubitStatus PartitionCurve::end_point( PartitionPoint* point )
151 : : {
152 [ # # ]: 0 : if( point == endPoint )
153 : 0 : return CUBIT_SUCCESS;
154 : :
155 [ # # ]: 0 : if( !remove_end_point() )
156 : 0 : { assert(0); return CUBIT_FAILURE; }
157 : :
158 [ # # ]: 0 : if( !point )
159 : 0 : return CUBIT_SUCCESS;
160 : :
161 : 0 : endPoint = point;
162 [ # # ]: 0 : if( point != startPoint )
163 : : {
164 : 0 : endNext = point->firstCurve;
165 : 0 : point->firstCurve = this;
166 : 0 : point->curveCount++;
167 : : }
168 : :
169 : 0 : return CUBIT_SUCCESS;
170 : : }
171 : :
172 : 0 : CubitStatus PartitionCurve::remove_start_point()
173 : : {
174 [ # # ]: 0 : if( startPoint == endPoint )
175 : 0 : endNext = startNext;
176 [ # # ][ # # ]: 0 : else if( startPoint && !remove_from_point( startPoint, startNext ) )
[ # # ]
177 : 0 : return CUBIT_FAILURE;
178 : :
179 : 0 : startPoint = 0;
180 : 0 : startNext = 0;
181 : :
182 : 0 : return CUBIT_SUCCESS;
183 : : }
184 : :
185 : 0 : CubitStatus PartitionCurve::remove_end_point()
186 : : {
187 [ # # ][ # # ]: 0 : assert( startPoint != endPoint || !endNext );
188 : : // endNext should be null if points are the same
189 : :
190 [ # # ]: 0 : if( endPoint && endPoint != startPoint &&
[ # # # # ]
[ # # ]
191 : 0 : !remove_from_point( endPoint, endNext ) )
192 : 0 : return CUBIT_FAILURE;
193 : :
194 : 0 : endPoint = 0;
195 : 0 : endNext = 0;
196 : :
197 : 0 : return CUBIT_SUCCESS;
198 : : }
199 : :
200 : 0 : CubitStatus PartitionCurve::remove_from_point( PartitionPoint* point,
201 : : PartitionCurve* next )
202 : : {
203 : 0 : point->curveCount--;
204 [ # # ]: 0 : if( point->firstCurve == this )
205 : : {
206 : 0 : point->firstCurve = next;
207 : : }
208 : : else
209 : : {
210 : 0 : PartitionCurve* prev = point->firstCurve;
211 [ # # ]: 0 : while( prev )
212 : : {
213 : 0 : PartitionCurve* temp = prev->next_curve(point);
214 [ # # ]: 0 : if( temp == this )
215 : 0 : break;
216 : 0 : prev = temp;
217 : : }
218 : :
219 [ # # ]: 0 : if( !prev )
220 : : {
221 : 0 : assert(0);
222 : : return CUBIT_FAILURE;
223 : : }
224 : :
225 [ # # ]: 0 : if( prev->startPoint == point )
226 : 0 : prev->startNext = next;
227 [ # # ]: 0 : else if( prev->endPoint == point )
228 : 0 : prev->endNext = next;
229 : : else
230 : 0 : assert(0);
231 : : }
232 : :
233 : 0 : return CUBIT_SUCCESS;
234 : : }
235 : :
236 : :
237 : :
238 : :
239 : 0 : bool PartitionCurve::is_nonmanifold( const PartitionSurface* surf ) const
240 : : {
241 : 0 : int count = 0;
242 : 0 : PartitionCoEdge* coedge = 0;
243 [ # # ]: 0 : while ( (coedge = next_coedge(coedge)) )
244 [ # # ][ # # ]: 0 : if ( coedge->get_loop() && coedge->get_loop()->get_surface() == surf )
[ # # ]
245 : 0 : count++;
246 : 0 : return count > 1;
247 : : }
248 : :
249 : 0 : bool PartitionCurve::is_in_surface( const PartitionSurface* surf,
250 : : bool manifold_only ) const
251 : : {
252 : 0 : int count = 0;
253 : 0 : PartitionCoEdge* coedge = 0;
254 [ # # ]: 0 : while ( (coedge = next_coedge(coedge)) )
255 [ # # ][ # # ]: 0 : if ( coedge->get_loop() && coedge->get_loop()->get_surface() == surf )
[ # # ]
256 : 0 : count++;
257 : :
258 [ # # ]: 0 : if (manifold_only)
259 : 0 : return count == 1;
260 : : else
261 : 0 : return count > 0;
262 : : }
263 : :
264 : :
265 : 0 : CubitStatus PartitionCurve::move_to_geometry( CubitVector& position )
266 : : {
267 [ # # ]: 0 : const CubitVector copy(position);
268 [ # # ]: 0 : return closest_point( copy, position );
269 : : }
270 : :
271 : 0 : void PartitionCurve::get_parents_virt( DLIList<TopologyBridge*>& result )
272 : : {
273 [ # # ]: 0 : for( PartitionCoEdge* coe = firstCoEdge; coe; coe = coe->curveNext )
274 [ # # ]: 0 : result.append( coe );
275 : 0 : }
276 : :
277 : 0 : void PartitionCurve::get_children_virt( DLIList<TopologyBridge*>& result )
278 : : {
279 [ # # ]: 0 : result.append( startPoint );
280 [ # # ]: 0 : if( startPoint != endPoint )
281 [ # # ]: 0 : result.append( endPoint );
282 : 0 : }
283 : :
284 : 0 : GeometryQueryEngine* PartitionCurve::get_geometry_query_engine() const
285 : : {
286 : 0 : return VirtualQueryEngine::instance();
287 : : }
288 : :
289 : 0 : void PartitionCurve::print_debug_info( const char* prefix,
290 : : bool entset ) const
291 : : {
292 : 0 : const bool print_children = true;
293 : :
294 [ # # ]: 0 : if( prefix == 0 ) prefix = "";
295 [ # # ]: 0 : char* new_prefix = new char[strlen(prefix)+3];
296 : 0 : strcpy( new_prefix, prefix );
297 : 0 : strcat( new_prefix, " ");
298 [ # # ][ # # ]: 0 : PRINT_INFO("%sPartitionCurve %p\n", prefix, (void*)this );
[ # # ][ # # ]
299 : :
300 [ # # ]: 0 : if(entset)
301 [ # # ][ # # ]: 0 : sub_entity_set().print_debug_info( new_prefix );
302 : : else
303 [ # # ]: 0 : print_partitioned_entity();
304 : :
305 : 0 : PartitionCoEdge* coedge = 0;
306 [ # # ]: 0 : DLIList<Surface*> surface_list(1);
307 [ # # ][ # # ]: 0 : while( (coedge = next_coedge(coedge)) )
308 : : {
309 [ # # ]: 0 : surface_list.clean_out();
310 [ # # ]: 0 : coedge->surfaces(surface_list);
311 [ # # ][ # # ]: 0 : Surface* surf_ptr = surface_list.size() == 1 ? surface_list.get() : 0;
[ # # ]
312 [ # # ][ # # ]: 0 : PRINT_INFO("%s %s on Surface %p\n", prefix,
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
313 : : coedge->sense() == CUBIT_FORWARD ? "FORWARD" :
314 : : coedge->sense() == CUBIT_REVERSED ? "REVERSE" : "UNKNOWN",
315 [ # # ]: 0 : (void*)surf_ptr );
316 : : }
317 : :
318 [ # # ][ # # ]: 0 : PRINT_INFO("%s start point: %p\n", prefix, (void*)start_point() );
[ # # ][ # # ]
[ # # ]
319 [ # # ][ # # ]: 0 : if( start_point() && print_children )
[ # # ]
320 [ # # ][ # # ]: 0 : start_point()->print_debug_info( new_prefix, false );
321 : :
322 [ # # ][ # # ]: 0 : if( end_point() && end_point() == start_point() )
[ # # ][ # # ]
[ # # ][ # # ]
323 [ # # ][ # # ]: 0 : PRINT_INFO("%s end point SAME as start point\n", prefix );
[ # # ][ # # ]
324 : : else
325 [ # # ][ # # ]: 0 : PRINT_INFO("%s end point: %p\n", prefix, (void*)end_point() );
[ # # ][ # # ]
[ # # ]
326 [ # # ][ # # ]: 0 : if( end_point() && end_point() != start_point() && print_children )
[ # # ][ # # ]
[ # # ][ # # ]
327 [ # # ][ # # ]: 0 : end_point()->print_debug_info( new_prefix, false );
328 : :
329 [ # # ][ # # ]: 0 : delete [] new_prefix;
330 : 0 : }
331 : :
332 : 0 : void PartitionCurve::append_simple_attribute_virt(const CubitSimpleAttrib& csa)
333 : 0 : { sub_entity_set().add_attribute( this, csa ); }
334 : 0 : void PartitionCurve::remove_simple_attribute_virt(const CubitSimpleAttrib& csa)
335 : 0 : { sub_entity_set().rem_attribute( this, csa ); }
336 : 0 : void PartitionCurve::remove_all_simple_attribute_virt()
337 : 0 : { sub_entity_set().rem_all_attrib( this ); }
338 : 0 : CubitStatus PartitionCurve::get_simple_attribute(DLIList<CubitSimpleAttrib>& list)
339 : : {
340 : 0 : sub_entity_set().get_attributes( this, list );
341 : 0 : return CUBIT_SUCCESS;
342 : : }
343 : 0 : CubitStatus PartitionCurve::get_simple_attribute(const CubitString& name,
344 : : DLIList<CubitSimpleAttrib>& list)
345 : : {
346 : 0 : sub_entity_set().get_attributes( this, name.c_str(), list );
347 : 0 : return CUBIT_SUCCESS;
348 : : }
349 : :
350 : 0 : void PartitionCurve::reverse_point_order()
351 : : {
352 [ # # ]: 0 : if( startPoint != endPoint )
353 : : {
354 : 0 : PartitionPoint* tmp_pt = startPoint;
355 : 0 : startPoint = endPoint;
356 : 0 : endPoint = tmp_pt;
357 : :
358 : 0 : PartitionCurve* tmp_cv = startNext;
359 : 0 : startNext = endNext;
360 : 0 : endNext = tmp_cv;
361 : : }
362 : 0 : }
363 : :
364 : 0 : void PartitionCurve::get_facet_data( DLIList<CubitFacetEdgeData*>& result_list ) const
365 : 0 : { result_list = facetEdges; }
366 : :
367 : 0 : void PartitionCurve::set_facet_data( const DLIList<CubitFacetEdgeData*>& new_list )
368 : : {
369 : 0 : remove_facet_data();
370 : 0 : facetEdges = new_list;
371 [ # # ]: 0 : for( int i = facetEdges.size(); i--; )
372 : 0 : TDVGFacetOwner::set( facetEdges.step_and_get(), this );
373 : 0 : }
374 : :
375 : 0 : void PartitionCurve::remove_facet_data( )
376 : : {
377 [ # # ]: 0 : while( facetEdges.size() )
378 : 0 : TDVGFacetOwner::remove( facetEdges.pop() );
379 : 0 : }
380 : :
381 : :
382 : 0 : void PartitionCurve::notify_split( FacetEntity* old_entity, FacetEntity* new_entity )
383 : : {
384 [ # # ]: 0 : CubitFacetEdgeData* old_ptr = dynamic_cast<CubitFacetEdgeData*>(old_entity);
385 [ # # ]: 0 : CubitFacetEdgeData* new_ptr = dynamic_cast<CubitFacetEdgeData*>(new_entity);
386 [ # # ][ # # ]: 0 : assert(TDVGFacetOwner::get(old_entity) == this);
387 [ # # ][ # # ]: 0 : assert(TDVGFacetOwner::get(new_entity) == 0);
388 [ # # ][ # # ]: 0 : assert(old_ptr && new_ptr);
389 : :
390 [ # # ]: 0 : facetEdges.reset();
391 [ # # ][ # # ]: 0 : if (facetEdges.get() == old_ptr)
392 : : {
393 [ # # ][ # # ]: 0 : if (new_ptr->contains(start_point()->facet_point()))
[ # # ][ # # ]
394 [ # # ]: 0 : facetEdges.insert_first(new_ptr);
395 : : else
396 [ # # ]: 0 : facetEdges.insert(new_ptr);
397 : : }
398 [ # # ][ # # ]: 0 : else if (facetEdges.move_to(old_ptr))
399 : : {
400 [ # # ]: 0 : CubitFacetEdgeData* prev = facetEdges.prev();
401 [ # # ][ # # ]: 0 : if (prev->shared_point(new_ptr))
402 [ # # ]: 0 : facetEdges.back();
403 [ # # ]: 0 : facetEdges.insert(new_ptr);
404 : : }
405 : : else
406 : : {
407 : 0 : assert( 0 /*old_entity not in list*/);
408 : : }
409 : :
410 [ # # ]: 0 : facetEdges.reset();
411 [ # # ]: 0 : TDVGFacetOwner::set( new_ptr, this );
412 : 0 : }
413 : :
414 : :
415 : 0 : CubitStatus PartitionCurve::fix_facet_data( PartitionCurve* new_curve )
416 : : {
417 [ # # ][ # # ]: 0 : if ( !facetEdges.size() )
418 : 0 : return CUBIT_SUCCESS;
419 : :
420 : :
421 [ # # ]: 0 : DLIList<CubitFacetEdgeData*> my_edges(facetEdges);
422 [ # # ][ # # ]: 0 : assert( end_point() == new_curve->start_point() );
[ # # ]
423 [ # # ][ # # ]: 0 : CubitVector pos( end_point()->coordinates() );
424 : :
425 : 0 : double min_edge_len_sqr = CUBIT_DBL_MAX;
426 : 0 : double min_edge_dst_sqr = CUBIT_DBL_MAX;
427 : 0 : CubitFacetEdgeData* closest_edge = 0;
428 [ # # ][ # # ]: 0 : CubitVector point, vect, edge_pos;
[ # # ]
429 : : int i;
430 : :
431 [ # # ][ # # ]: 0 : for ( i = my_edges.size(); i--; ) {
432 [ # # ]: 0 : CubitFacetEdgeData* edge = my_edges.step_and_get();
433 [ # # ][ # # ]: 0 : point = edge->point(0)->coordinates();
[ # # ]
434 [ # # ][ # # ]: 0 : vect = edge->point(1)->coordinates() - point;
[ # # ][ # # ]
435 : :
436 [ # # ]: 0 : double len_sqr = vect.length_squared();
437 [ # # ]: 0 : if ( len_sqr < min_edge_len_sqr )
438 : 0 : min_edge_len_sqr = len_sqr;
439 : :
440 [ # # ]: 0 : point -= pos;
441 [ # # ][ # # ]: 0 : double t = (vect % -point) / len_sqr;
442 [ # # ]: 0 : if ( t < 0.0 ) t = 0.0;
443 [ # # ]: 0 : else if( t > 1.0 ) t = 1.0;
444 [ # # ][ # # ]: 0 : double dst_sqr = (point + t * vect).length_squared();
[ # # ]
445 : :
446 [ # # ]: 0 : if ( dst_sqr < min_edge_dst_sqr ) {
447 : 0 : min_edge_dst_sqr = dst_sqr;
448 : 0 : closest_edge = edge;
449 [ # # ][ # # ]: 0 : edge_pos = edge->point(0)->coordinates() + t * vect;
[ # # ][ # # ]
[ # # ]
450 : : }
451 : : }
452 : :
453 [ # # ]: 0 : my_edges.reset();
454 [ # # ][ # # ]: 0 : DLIList<CubitFacetEdgeData*> new_curve_edges;
455 [ # # ]: 0 : my_edges.last();
456 [ # # ][ # # ]: 0 : while( my_edges.get() != closest_edge ) {
457 [ # # ][ # # ]: 0 : new_curve_edges.append( my_edges.pop() );
458 [ # # ]: 0 : my_edges.last();
459 : : }
460 : :
461 : 0 : min_edge_len_sqr *= 0.2;
462 [ # # ]: 0 : double dst_tol_sqr = CUBIT_MAX( min_edge_len_sqr, GEOMETRY_RESABS*GEOMETRY_RESABS );
463 : :
464 : 0 : bool edge_reversed = false;
465 [ # # ][ # # ]: 0 : if ( my_edges.size() > 1 )
466 : : {
467 [ # # ]: 0 : my_edges.last();
468 [ # # ]: 0 : CubitFacetEdgeData* other = my_edges.prev();
469 [ # # ][ # # ]: 0 : edge_reversed = other->contains( closest_edge->point(1) );
470 : : }
471 [ # # ][ # # ]: 0 : else if( new_curve_edges.size() > 1 )
472 : : {
473 [ # # ]: 0 : new_curve_edges.last();
474 [ # # ]: 0 : CubitFacetEdgeData* other = new_curve_edges.get();
475 [ # # ][ # # ]: 0 : edge_reversed = other->contains( closest_edge->point(0) );
476 : : }
477 : : else
478 : : {
479 [ # # ][ # # ]: 0 : edge_reversed = (start_point()->facet_point() == closest_edge->point(1));
[ # # ]
480 [ # # ][ # # ]: 0 : assert(edge_reversed || start_point()->facet_point() == closest_edge->point(0));
[ # # ][ # # ]
[ # # ]
481 : : }
482 : :
483 : :
484 : 0 : CubitPoint* new_point = 0;
485 [ # # ][ # # ]: 0 : double d1 = (pos - closest_edge->point(0)->coordinates()).length_squared();
[ # # ][ # # ]
486 [ # # ][ # # ]: 0 : double d2 = (pos - closest_edge->point(1)->coordinates()).length_squared();
[ # # ][ # # ]
487 [ # # ][ # # ]: 0 : if ( (!TDVGFacetOwner::get(closest_edge->point(0)) && d1 < dst_tol_sqr) ||
[ # # ][ # # ]
[ # # ][ # # ]
488 : : (d1 < GEOMETRY_RESABS*GEOMETRY_RESABS) )
489 : : {
490 [ # # ]: 0 : if ( !edge_reversed )
491 [ # # ][ # # ]: 0 : new_curve_edges.append( my_edges.pop() );
492 [ # # ]: 0 : new_point = closest_edge->point(0);
493 : : }
494 [ # # ][ # # ]: 0 : else if( (!TDVGFacetOwner::get(closest_edge->point(1)) && d2 < dst_tol_sqr) ||
[ # # ][ # # ]
[ # # ][ # # ]
495 : : (d2 < GEOMETRY_RESABS*GEOMETRY_RESABS) )
496 : : {
497 [ # # ]: 0 : if( edge_reversed )
498 [ # # ][ # # ]: 0 : new_curve_edges.append( my_edges.pop() );
499 [ # # ]: 0 : new_point = closest_edge->point(1);
500 : : }
501 : : else
502 : : {
503 : : CubitFacetEdge* new_edge;
504 : : CubitFacet* new_facet;
505 [ # # ]: 0 : TDVGFacetOwner::remove(closest_edge);
506 [ # # ]: 0 : PartSurfFacetTool::split_edge(closest_edge, edge_pos, 0, new_point, new_edge, new_facet );
507 [ # # ]: 0 : TDVGFacetOwner::set(closest_edge, this);
508 : :
509 [ # # ]: 0 : if ( edge_reversed ) {
510 [ # # ][ # # ]: 0 : new_curve_edges.append( my_edges.pop() );
511 [ # # ][ # # ]: 0 : my_edges.append( dynamic_cast<CubitFacetEdgeData*>(new_edge) );
512 : : } else {
513 [ # # ][ # # ]: 0 : new_curve_edges.append( dynamic_cast<CubitFacetEdgeData*>(new_edge) );
514 : : //TDVGFacetOwner::remove(new_edge);
515 : : }
516 : : }
517 : :
518 [ # # ]: 0 : CubitPointData* new_point_d = dynamic_cast<CubitPointData*>(new_point);
519 [ # # ][ # # ]: 0 : new_point_d->set(end_point()->coordinates());
[ # # ]
520 [ # # ][ # # ]: 0 : end_point()->facet_point( new_point_d );
521 [ # # ]: 0 : set_facet_data(my_edges);
522 [ # # ]: 0 : new_curve_edges.reverse();
523 [ # # ]: 0 : new_curve->set_facet_data(new_curve_edges);
524 : :
525 : 0 : PartitionCoEdge* coedge = 0;
526 [ # # ][ # # ]: 0 : while ((coedge = next_coedge(coedge)) != NULL )
527 : : {
528 [ # # ]: 0 : PartitionLoop* loop = coedge->get_loop();
529 [ # # ]: 0 : if (!loop) continue;
530 : :
531 [ # # ]: 0 : PartitionSurface* surf = loop->get_surface();
532 [ # # ][ # # ]: 0 : if (!surf->notify_moving_point( new_point, pos ))
533 : 0 : return CUBIT_FAILURE;
534 : : }
535 : :
536 [ # # ]: 0 : new_point->set(pos);
537 [ # # ]: 0 : return CUBIT_SUCCESS;
538 : : }
539 : :
540 : 0 : void PartitionCurve::remove_dead_facet( CubitFacetEdgeData* edge )
541 : : {
542 : 0 : facetEdges.remove(edge);
543 : 0 : }
544 : :
545 : 0 : CubitStatus PartitionCurve::get_save_topology( DLIList<int>& end_points )
546 : : {
547 [ # # ]: 0 : for( int i = 0; i < 2; i++ )
548 : : {
549 [ # # ][ # # ]: 0 : PartitionPoint* point = i ? end_point() : start_point();
[ # # ]
550 : : int set_id, pt_id;
551 [ # # ][ # # ]: 0 : if( &(point->sub_entity_set()) == &sub_entity_set() )
[ # # ]
552 : 0 : set_id = 0;
553 : : else
554 [ # # ][ # # ]: 0 : set_id = point->sub_entity_set().get_unique_id();
555 [ # # ][ # # ]: 0 : pt_id = point->sub_entity_set().get_id(point);
[ # # ]
556 [ # # ]: 0 : end_points.append(set_id);
557 [ # # ]: 0 : end_points.append(pt_id);
558 : : }
559 : 0 : return CUBIT_SUCCESS;
560 : : }
561 : :
562 : :
563 : :
564 : 0 : void PartitionCurve::transform(const CubitTransformMatrix& xform)
565 : : {
566 : : int i;
567 : :
568 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> points(facetEdges.size());
569 [ # # ][ # # ]: 0 : for ( i = facetEdges.size(); i--; )
570 : : {
571 [ # # ]: 0 : CubitFacetEdgeData* edge = facetEdges.step_and_get();
572 [ # # ][ # # ]: 0 : edge->point(0)->marked(1);
573 [ # # ][ # # ]: 0 : edge->point(1)->marked(1);
574 : : }
575 [ # # ][ # # ]: 0 : for ( i = facetEdges.size(); i--; )
576 : : {
577 [ # # ]: 0 : CubitFacetEdgeData* edge = facetEdges.step_and_get();
578 [ # # ]: 0 : for ( int j = 0; j < 2; j++ )
579 : : {
580 [ # # ]: 0 : CubitPoint* pt = edge->point(j);
581 [ # # ][ # # ]: 0 : if( pt->marked() )
582 : : {
583 [ # # ]: 0 : pt->marked(0);
584 : :
585 [ # # ][ # # ]: 0 : if( TDVGFacetOwner::get(pt) == 0 )
586 [ # # ]: 0 : points.append(pt);
587 : : }
588 : : }
589 : : }
590 : :
591 [ # # ][ # # ]: 0 : for( i = points.size(); i--; )
592 : : {
593 [ # # ]: 0 : CubitPoint* pt = points.get_and_step();
594 [ # # ][ # # ]: 0 : pt->set( xform * pt->coordinates() );
[ # # ]
595 [ # # ]: 0 : }
596 : 0 : }
597 : :
598 : 0 : void PartitionCurve::replace_facet(CubitFacetEdgeData* dead_facet,
599 : : DLIList<CubitFacetEdgeData*> &new_facets)
600 : : {
601 [ # # ][ # # ]: 0 : assert(new_facets.size() > 1); // doesn't make sense to replace 1 to 1
602 : :
603 [ # # ]: 0 : DLIList<CubitFacetEdgeData*> new_copy = new_facets;
604 : :
605 [ # # ]: 0 : new_facets.reset();
606 [ # # ]: 0 : facetEdges.reset();
607 [ # # ]: 0 : int dead_index = facetEdges.where_is_item(dead_facet);
608 [ # # ]: 0 : assert(-1 != dead_index);
609 : :
610 : : // special case for a single facet on the edge
611 : : // - use curve endpoints to determine order
612 [ # # ][ # # ]: 0 : if (facetEdges.size() == 1)
613 : : {
614 [ # # ]: 0 : facetEdges.clean_out();
615 : :
616 [ # # ]: 0 : new_copy.last();
617 [ # # ][ # # ]: 0 : if (new_copy.get()->contains(start_point()->facet_point()) )
[ # # ][ # # ]
[ # # ]
618 [ # # ]: 0 : new_copy.reverse();
619 : :
620 [ # # ]: 0 : new_copy.reset();
621 [ # # ][ # # ]: 0 : assert( new_copy.get()->contains(start_point()->facet_point()) );
[ # # ][ # # ]
[ # # ]
622 [ # # ]: 0 : new_copy.last();
623 [ # # ][ # # ]: 0 : assert( new_copy.get()->contains(end_point()->facet_point()) );
[ # # ][ # # ]
[ # # ]
624 : :
625 [ # # ]: 0 : facetEdges = new_copy;
626 : : }
627 : : else
628 : : {
629 [ # # ]: 0 : DLIList<CubitFacetEdgeData*> ordered_edges;
630 : : int i;
631 : :
632 : : // copy the edges before the dead edge into a new list
633 [ # # ]: 0 : for (i=0; i< dead_index; i++)
634 [ # # ][ # # ]: 0 : ordered_edges.append(facetEdges.next(i));
635 : :
636 : : // if there are edges before the new edges, find out whether the first or last
637 : : // new edge is adjacent to the one before the dead edge
638 : 0 : CubitFacetEdgeData *prev = NULL;
639 : 0 : CubitFacetEdgeData *next = NULL;
640 : 0 : CubitPoint *new_start_pt = NULL;
641 : 0 : CubitPoint *new_end_pt = NULL;
642 [ # # ]: 0 : if (dead_index > 0)
643 : : {
644 [ # # ]: 0 : prev = facetEdges.next(dead_index-1);
645 [ # # ]: 0 : new_start_pt = prev->shared_point(dead_facet);
646 [ # # ]: 0 : assert(new_start_pt != NULL);
647 : : }
648 : :
649 [ # # ][ # # ]: 0 : if (dead_index < (facetEdges.size() - 1) )
650 : : {
651 [ # # ]: 0 : next = facetEdges.next(dead_index+1);
652 [ # # ]: 0 : new_end_pt = next->shared_point(dead_facet);
653 [ # # ]: 0 : assert(new_end_pt != NULL);
654 : : }
655 : :
656 [ # # ]: 0 : if (prev)
657 : : {
658 [ # # ]: 0 : new_copy.last();
659 [ # # ][ # # ]: 0 : if (new_copy.get()->contains(new_start_pt))
[ # # ]
660 [ # # ]: 0 : new_copy.reverse();
661 : : }
662 : : else
663 : : {
664 : : // use the edge after the dead edge to find out whether to reverse the new
665 : : // edges or not
666 [ # # ]: 0 : assert(next != NULL);
667 [ # # ]: 0 : new_copy.reset();
668 [ # # ][ # # ]: 0 : if (new_copy.get()->contains(new_end_pt))
[ # # ]
669 [ # # ]: 0 : new_copy.reverse();
670 : : }
671 : :
672 [ # # ]: 0 : if (prev)
673 : : {
674 [ # # ]: 0 : new_copy.reset();
675 [ # # ][ # # ]: 0 : assert( prev->shared_point(new_copy.get()) != NULL);
[ # # ]
676 : : }
677 [ # # ]: 0 : if (next)
678 : : {
679 [ # # ]: 0 : new_copy.last();
680 [ # # ][ # # ]: 0 : assert( next->shared_point(new_copy.get()) != NULL);
[ # # ]
681 : : }
682 : :
683 : : // copy the new edges into place in the ordered list
684 [ # # ]: 0 : new_copy.reset();
685 [ # # ][ # # ]: 0 : for (i=new_copy.size(); i>0; i--)
686 [ # # ][ # # ]: 0 : ordered_edges.append(new_copy.get_and_step());
687 : :
688 : : // add the rest of the edges to the list
689 [ # # ]: 0 : facetEdges.reset();
690 [ # # ][ # # ]: 0 : for (i=dead_index+1; i<facetEdges.size(); i++)
691 [ # # ][ # # ]: 0 : ordered_edges.append(facetEdges.next(i));
692 : :
693 : :
694 [ # # ]: 0 : facetEdges.clean_out();
695 [ # # ][ # # ]: 0 : facetEdges = ordered_edges;
696 : : }
697 : :
698 [ # # ]: 0 : TDVGFacetOwner::remove(dead_facet);
699 [ # # ][ # # ]: 0 : for( int j = 0; j < new_facets.size(); j++ )
700 [ # # ][ # # ]: 0 : TDVGFacetOwner::set(new_facets.step_and_get(),this);
[ # # ]
701 : :
702 : : // TODO - memory management - where should the facets get deleted
703 : 0 : }
704 : :
705 : 0 : void PartitionCurve::draw_facets( int color)
706 : : {
707 [ # # ][ # # ]: 0 : if( !facetEdges.size() )
708 : : {
709 [ # # ][ # # ]: 0 : PRINT_ERROR("No facet data.\n");
[ # # ][ # # ]
710 : 0 : return ;
711 : : }
712 : :
713 : : int i;
714 [ # # ][ # # ]: 0 : GPoint* pts = new GPoint[facetEdges.size() + 1];
[ # # ]
715 : :
716 [ # # ]: 0 : facetEdges.reset();
717 : 0 : CubitPoint* pt = 0;
718 [ # # ][ # # ]: 0 : if( facetEdges.size() == 1 )
719 : : {
720 [ # # ][ # # ]: 0 : pt = facetEdges.get()->point(0);
721 : : }
722 : : else
723 : : {
724 [ # # ][ # # ]: 0 : pt = facetEdges.get()->shared_point(facetEdges.next());
[ # # ]
725 [ # # ][ # # ]: 0 : pt = facetEdges.get()->other_point(pt);
726 : : }
727 : :
728 [ # # ]: 0 : CubitVector v = pt->coordinates();
729 [ # # ]: 0 : pts[0].x = (float)v.x();
730 [ # # ]: 0 : pts[0].y = (float)v.y();
731 [ # # ]: 0 : pts[0].z = (float)v.z();
732 : :
733 [ # # ][ # # ]: 0 : for( i = 1; i <= facetEdges.size(); i++ )
734 : : {
735 [ # # ][ # # ]: 0 : pt = facetEdges.get_and_step()->other_point(pt);
736 [ # # ]: 0 : CubitVector v = pt->coordinates();
737 [ # # ]: 0 : pts[i].x = (float)v.x();
738 [ # # ]: 0 : pts[i].y = (float)v.y();
739 [ # # ]: 0 : pts[i].z = (float)v.z();
740 : : }
741 : :
742 [ # # ][ # # ]: 0 : GfxDebug::draw_polyline( pts, facetEdges.size() + 1, color );
743 [ # # ][ # # ]: 0 : for ( i = 0; i <= facetEdges.size(); i++ )
744 : : {
745 [ # # ]: 0 : GfxDebug::draw_point( pts[i].x, pts[i].y, pts[i].z, color );
746 : : }
747 : :
748 [ # # ]: 0 : facetEdges.reset();
749 [ # # ][ # # ]: 0 : for ( i = 0; i < facetEdges.size(); i++ )
750 : : {
751 [ # # ]: 0 : CubitFacetEdge* edge = facetEdges.get_and_step();
752 [ # # ][ # # ]: 0 : CubitVector mid = 0.5*(edge->point(0)->coordinates()+edge->point(1)->coordinates());
[ # # ][ # # ]
[ # # ][ # # ]
753 [ # # ][ # # ]: 0 : GfxDebug::draw_label( i, (float)mid.x(), (float)mid.y(), (float)mid.z(), color );
[ # # ][ # # ]
754 : : }
755 [ # # ]: 0 : GfxDebug::flush();
756 : :
757 [ # # ]: 0 : delete [] pts;
758 : : }
759 : :
760 : 0 : void PartitionCurve::do_facet_cleanup()
761 : : {
762 : : int i;
763 : 0 : const double tol = 10.0 * GEOMETRY_RESABS;
764 : 0 : const double tol_sqr = tol * tol;
765 : :
766 [ # # ]: 0 : DLIList<CubitFacetEdgeData*> edge_list(facetEdges);
767 : 0 : CubitFacetEdgeData* prev_edge = 0;
768 [ # # ]: 0 : edge_list.reset();
769 : :
770 [ # # ][ # # ]: 0 : for ( i = edge_list.size(); i--; )
771 : : {
772 [ # # ]: 0 : CubitFacetEdgeData* edge = edge_list.get_and_step();
773 [ # # ][ # # ]: 0 : PartitionEntity* start_pt = TDVGFacetOwner::get(edge->point(0));
774 [ # # ][ # # ]: 0 : PartitionEntity* end_pt = TDVGFacetOwner::get(edge->point(1));
775 [ # # ][ # # ]: 0 : if ( start_pt && end_pt )
776 : : {
777 : 0 : prev_edge = edge;
778 : 0 : continue;
779 : : }
780 : :
781 [ # # ][ # # ]: 0 : CubitVector edge_vect(edge->point(1)->coordinates());
782 [ # # ][ # # ]: 0 : edge_vect -= edge->point(0)->coordinates();
[ # # ]
783 [ # # ][ # # ]: 0 : if ( edge_vect.length_squared() > tol_sqr )
784 : : {
785 : 0 : prev_edge = edge;
786 : 0 : continue;
787 : : }
788 : :
789 : : CubitPoint *keep, *dead;
790 [ # # ]: 0 : if ( start_pt )
791 : : {
792 [ # # ]: 0 : keep = edge->point(0);
793 [ # # ]: 0 : dead = edge->point(1);
794 : : }
795 [ # # ]: 0 : else if ( end_pt )
796 : : {
797 [ # # ]: 0 : keep = edge->point(1);
798 [ # # ]: 0 : dead = edge->point(0);
799 : : }
800 : : else
801 : : {
802 [ # # ][ # # ]: 0 : double prev = (prev_edge->point(0)->coordinates() -
[ # # ][ # # ]
803 [ # # ][ # # ]: 0 : prev_edge->point(1)->coordinates()).length_squared();
804 [ # # ][ # # ]: 0 : double next = (edge_list.get()->point(0)->coordinates() -
[ # # ][ # # ]
[ # # ]
805 [ # # ][ # # ]: 0 : edge_list.get()->point(1)->coordinates()).length_squared();
[ # # ]
806 [ # # ]: 0 : if ( prev < next )
807 : : {
808 [ # # ]: 0 : dead = prev_edge->shared_point(edge);
809 [ # # ][ # # ]: 0 : keep = edge_list.get()->shared_point(edge);
810 : : }
811 : : else
812 : : {
813 [ # # ][ # # ]: 0 : dead = edge_list.get()->shared_point(edge);
814 [ # # ]: 0 : keep = prev_edge->shared_point(edge);
815 : : }
816 [ # # ][ # # ]: 0 : assert( dead && keep );
817 : : }
818 : :
819 [ # # ][ # # ]: 0 : if ( PartSurfFacetTool::collapse_edge( keep, dead ) )
820 : : {
821 : : ;
822 : : }
823 : : else
824 : : {
825 : 0 : prev_edge = edge;
826 : : }
827 [ # # ]: 0 : }
828 : 0 : }
829 : :
830 : :
831 : 0 : CubitStatus PartitionCurve::move_to_geometry( CubitPoint* point )
832 : : {
833 [ # # ]: 0 : CubitVector new_pos;
834 [ # # ][ # # ]: 0 : if (!closest_point( point->coordinates(), new_pos ))
[ # # ]
835 : 0 : return CUBIT_FAILURE;
836 : :
837 [ # # ]: 0 : point->set(new_pos);
838 : :
839 [ # # ]: 0 : DLIList<PartitionSurface*> surfaces;
840 : 0 : PartitionCoEdge* coedge = 0;
841 [ # # ][ # # ]: 0 : while ((coedge = next_coedge(coedge)) != NULL )
842 : : {
843 [ # # ]: 0 : PartitionLoop* loop = coedge->get_loop();
844 [ # # ]: 0 : if (!loop)
845 : 0 : continue;
846 : :
847 [ # # ]: 0 : PartitionSurface* surf = loop->get_surface();
848 [ # # ]: 0 : surfaces.append_unique(surf);
849 : :
850 [ # # ]: 0 : coedge = coedge->next();
851 : : }
852 : :
853 : : int i;
854 [ # # ]: 0 : surfaces.reset();
855 [ # # ][ # # ]: 0 : for ( i = 0; i < surfaces.size(); i++ )
856 [ # # ][ # # ]: 0 : if (!surfaces.get_and_step()->notify_moving_point( point, new_pos ))
[ # # ]
857 : 0 : break;
858 : :
859 [ # # ][ # # ]: 0 : if (i < surfaces.size())
860 : 0 : return CUBIT_FAILURE;
861 : :
862 [ # # ]: 0 : point->set(new_pos);
863 [ # # ]: 0 : return CUBIT_SUCCESS;
864 [ + - ][ + - ]: 6364 : }
|
