Branch data Line data Source code
1 : : //- Class: TDFacetBoundaryEdge
2 : : //- Description: Tool data for storing additional information at
3 : : //- the boundary of a facet set
4 : : //- Owner: Steve Owen
5 : : //- Checked by:
6 : : //- Version:
7 : :
8 : : #include "TDFacetBoundaryEdge.hpp"
9 : : #include "TDFacetBoundaryPoint.hpp"
10 : : #include "CubitFacetEdge.hpp"
11 : : #include "CastTo.hpp"
12 : : #include "CubitFacet.hpp"
13 : : #include "CubitPoint.hpp"
14 : : #include "FacetEvalTool.hpp"
15 : : #include "ChollaDebug.hpp"
16 : : #include "CubitMessage.hpp"
17 [ + - ]: 1056 : TDFacetBoundaryEdge::TDFacetBoundaryEdge()
18 : : {
19 : 528 : edgePtr = NULL;
20 : 528 : nextEdgePtr = NULL;
21 : 528 : prevEdgePtr = NULL;
22 : 528 : }
23 : :
24 [ # # ]: 0 : TDFacetBoundaryEdge::~TDFacetBoundaryEdge()
25 : : {
26 : : int ii;
27 [ # # ][ # # ]: 0 : for (ii=0; ii<edgeDataList.size(); ii++)
28 : : {
29 [ # # ]: 0 : BoundaryEdgeData *bed_ptr = edgeDataList.get_and_step();
30 : 0 : delete bed_ptr;
31 : : }
32 [ # # ]: 0 : }
33 : :
34 : :
35 : : //-------------------------------------------------------------------------
36 : : // Purpose : create a new facet boundary edge
37 : : //
38 : : // Special Notes :
39 : : //
40 : : // Creator : Steve Owen
41 : : //
42 : : // Creation Date : 05/01
43 : : //-------------------------------------------------------------------------
44 : 528 : CubitStatus TDFacetBoundaryEdge::add_facet_boundary_edge(
45 : : CubitFacetEdge *edge_ptr )
46 : : {
47 : : ToolData *td;
48 : 528 : td = edge_ptr->get_TD(&TDFacetBoundaryEdge::is_facet_boundary_edge);
49 [ + - ]: 528 : if ( td == NULL )
50 : : {
51 [ + - ]: 528 : TDFacetBoundaryEdge *td_gm = new TDFacetBoundaryEdge;
52 : 528 : edge_ptr->add_TD( td_gm);
53 : 528 : td_gm->set_edge( edge_ptr );
54 : : }
55 : : else
56 : : {
57 [ # # ]: 0 : TDFacetBoundaryEdge *td_gm = CAST_TO(td, TDFacetBoundaryEdge);
58 : 0 : td_gm->set_edge( edge_ptr );
59 : : }
60 : 528 : return CUBIT_SUCCESS;
61 : : }
62 : :
63 : : //-------------------------------------------------------------------------
64 : : // Purpose : get the facet boundary edge from an edge
65 : : //
66 : : // Special Notes :
67 : : //
68 : : // Creator : Steve Owen
69 : : //
70 : : // Creation Date : 05/01
71 : : //-------------------------------------------------------------------------
72 : 8514 : TDFacetBoundaryEdge* TDFacetBoundaryEdge::get_facet_boundary_edge(
73 : : CubitFacetEdge *edge_ptr )
74 : : {
75 : : ToolData *td;
76 : 8514 : td = edge_ptr->get_TD(&TDFacetBoundaryEdge::is_facet_boundary_edge);
77 [ + + ]: 8514 : if ( td != NULL )
78 : : {
79 [ - + ]: 5412 : TDFacetBoundaryEdge *td_gm = CAST_TO(td, TDFacetBoundaryEdge);
80 : 5412 : return td_gm;
81 : : }
82 : 3102 : return (TDFacetBoundaryEdge*) NULL;
83 : : }
84 : :
85 : : //-------------------------------------------------------------------------
86 : : // Purpose : add facet representing a new surface adjacent this edge
87 : : //
88 : : // Special Notes : pass in a list of facets and pick the ones that have
89 : : // this edge as one of its edges
90 : : //
91 : : // Creator : Steve Owen
92 : : //
93 : : // Creation Date : 05/01
94 : : //-------------------------------------------------------------------------
95 : 2112 : void TDFacetBoundaryEdge::add_surf_facet( DLIList<CubitFacet *> &facet_list)
96 : : {
97 : : CubitFacet *facet_ptr;
98 : 2112 : int found = 0;
99 : : int ii,jj;
100 [ + + ]: 6072 : for (ii=0; ii< facet_list.size(); ii++)
101 : : {
102 : 3960 : facet_ptr = facet_list.get_and_step();
103 [ + + ][ + + ]: 11748 : if (facet_ptr->edge( 0 ) == edgePtr ||
104 [ + + ][ + + ]: 7788 : facet_ptr->edge( 1 ) == edgePtr ||
105 : 3696 : facet_ptr->edge( 2 ) == edgePtr)
106 : : {
107 : : // check if has already been added
108 : :
109 : 2112 : found = 0;
110 : : BoundaryEdgeData *bed_ptr;
111 [ + + ][ + + ]: 3696 : for (jj=0; jj<edgeDataList.size() && !found; jj++)
[ + + ]
112 : : {
113 : 1584 : bed_ptr = edgeDataList.get_and_step();
114 [ + + ]: 1584 : if(bed_ptr->adjFacet == facet_ptr)
115 : : {
116 : 1056 : found = 1;
117 : : }
118 : : }
119 [ + + ]: 2112 : if (!found)
120 : : {
121 : : // add a new bed and facet
122 : :
123 [ + - ][ + - ]: 1056 : BoundaryEdgeData *new_bed_ptr = new BoundaryEdgeData;
124 : 1056 : new_bed_ptr->adjFacet = facet_ptr;
125 : 1056 : new_bed_ptr->surfID = -1;
126 [ + - ]: 2112 : edgeDataList.append( new_bed_ptr );
127 : : }
128 : : }
129 : : }
130 : 2112 : }
131 : :
132 : : //======================================================================
133 : : // Function: control_points (PUBLIC)
134 : : // Description: set the Bezier control points on the edge. The first
135 : : // and last control points are assumed to be the end points
136 : : // of the edge, so they are not passed into this function.
137 : : // order-1 points should be passed in. The order of the
138 : : // bezier is returned.
139 : : // Author: sjowen
140 : : // Date: 8/00
141 : : //======================================================================
142 : 0 : void TDFacetBoundaryEdge::control_points(
143 : : CubitVector *ctrl_pts, int order, int surf_id )
144 : : {
145 [ # # ][ # # ]: 0 : assert(order<=4 && order >=0);
146 : 0 : int found = 0;
147 : 0 : BoundaryEdgeData *bed_ptr = NULL;
148 [ # # ]: 0 : for (int ii=0; ii<edgeDataList.size(); ii++)
149 : : {
150 : 0 : bed_ptr = edgeDataList.get_and_step();
151 [ # # ]: 0 : if(bed_ptr->surfID == surf_id)
152 : 0 : found = 1;
153 : : }
154 [ # # ]: 0 : if (0 == found) {
155 [ # # ][ # # ]: 0 : PRINT_ERROR("The surf_id does not match any in the list.\n");
156 : 0 : return;
157 : : }
158 : :
159 : : int jj;
160 [ # # ]: 0 : for(jj=0; jj<order-1; jj++){
161 : 0 : bed_ptr->bezierCtrlPts[jj] = ctrl_pts[jj];
162 : : }
163 : : }
164 : :
165 : : //======================================================================
166 : : // Function: control_points (PUBLIC)
167 : : // Description: return the Bezier control points (including the end points)
168 : : // The order of the bezier is returned.
169 : : // Author: sjowen
170 : : // Date: 8/00
171 : : //======================================================================
172 : 0 : int TDFacetBoundaryEdge::control_points( CubitVector *ctrl_pts, int surf_id )
173 : : {
174 [ # # ]: 0 : ctrl_pts[0] = edgePtr->point(0)->coordinates();
175 : :
176 : : int ii;
177 : 0 : int found = 0;
178 : 0 : BoundaryEdgeData *bed_ptr = NULL;
179 [ # # ]: 0 : for (ii=0; ii<edgeDataList.size(); ii++)
180 : : {
181 : 0 : bed_ptr = edgeDataList.get_and_step();
182 [ # # ]: 0 : if(bed_ptr->surfID == surf_id)
183 : 0 : found = 1;
184 : : }
185 [ # # ]: 0 : if (0 == found) {
186 [ # # ][ # # ]: 0 : PRINT_ERROR("The surf_id does not match any in the list.\n");
187 : 0 : return -1;
188 : : }
189 : :
190 [ # # ]: 0 : for(int i=0; i<3; i++) {
191 : 0 : ctrl_pts[i+1] = bed_ptr->bezierCtrlPts[i];
192 : : }
193 [ # # ]: 0 : ctrl_pts[4] = edgePtr->point(1)->coordinates();
194 : 0 : return 4;
195 : : }
196 : :
197 : : //======================================================================
198 : : // Function: control_points (PUBLIC)
199 : : // Description: return the control points on the edge of a facet based
200 : : // on its edge use direction
201 : : // Author: sjowen
202 : : // Date: 8/00
203 : : //======================================================================
204 : 0 : CubitStatus TDFacetBoundaryEdge::control_points(
205 : : CubitFacet *facet, CubitVector *ctrl_pts )
206 : : {
207 : : // find the edge on the facet
208 : :
209 : 0 : int index = -1;
210 : 0 : CubitBoolean found = CUBIT_FALSE;
211 [ # # ][ # # ]: 0 : for (int i=0; i<3 && !found; i++) {
212 [ # # ]: 0 : if (edgePtr == facet->edge(i)) {
213 : 0 : index = i;
214 : 0 : found = CUBIT_TRUE;
215 : : }
216 : : }
217 [ # # ]: 0 : if (!found) {
218 : 0 : return CUBIT_FAILURE;
219 : : }
220 : :
221 : : // locate the facet in the boundary edge data
222 : :
223 : 0 : found = CUBIT_FALSE;
224 : 0 : BoundaryEdgeData *bed_ptr = NULL;
225 [ # # ]: 0 : for (int ii=0; ii<edgeDataList.size(); ii++)
226 : : {
227 : 0 : bed_ptr = edgeDataList.get_and_step();
228 [ # # ]: 0 : if(bed_ptr->adjFacet == facet)
229 : 0 : found = CUBIT_TRUE;
230 : : }
231 [ # # ]: 0 : if (!found) // the facet does not match any in the list
232 : 0 : return CUBIT_FAILURE;
233 : :
234 : : // retreive the control points
235 : :
236 [ # # # ]: 0 : switch (facet->edge_use(index)) {
237 : : case 1:
238 [ # # ]: 0 : ctrl_pts[0] = edgePtr->point(0)->coordinates();
239 : 0 : ctrl_pts[1] = bed_ptr->bezierCtrlPts[0];
240 : 0 : ctrl_pts[2] = bed_ptr->bezierCtrlPts[1];
241 : 0 : ctrl_pts[3] = bed_ptr->bezierCtrlPts[2];
242 [ # # ]: 0 : ctrl_pts[4] = edgePtr->point(1)->coordinates();
243 : 0 : break;
244 : : case -1:
245 [ # # ]: 0 : ctrl_pts[0] = edgePtr->point(1)->coordinates();
246 : 0 : ctrl_pts[1] = bed_ptr->bezierCtrlPts[2];
247 : 0 : ctrl_pts[2] = bed_ptr->bezierCtrlPts[1];
248 : 0 : ctrl_pts[3] = bed_ptr->bezierCtrlPts[0];
249 [ # # ]: 0 : ctrl_pts[4] = edgePtr->point(0)->coordinates();
250 : 0 : break;
251 : : default:
252 : 0 : return CUBIT_FAILURE;
253 : : }
254 : 0 : return CUBIT_SUCCESS;
255 : : }
256 : :
257 : : //======================================================================
258 : : // Function: get_control_points (PUBLIC)
259 : : // Description: get control points oriented with respect to the
260 : : // point_ptr (ie. point_ptr is the first control point
261 : : // on the edge)
262 : : // Note: only gets and sets the middle three control points. The
263 : : // other 2 are the edge vertices.
264 : : // Author: sjowen
265 : : // Date: 05/01
266 : : //======================================================================
267 : 0 : void TDFacetBoundaryEdge::get_control_points( CubitPoint *point_ptr,
268 : : CubitVector ctrl_pts[3],
269 : : int surf_id )
270 : : {
271 : 0 : CubitBoolean found = CUBIT_FALSE;
272 : 0 : BoundaryEdgeData *bed_ptr = NULL;
273 [ # # ]: 0 : for (int ii=0; ii<edgeDataList.size(); ii++)
274 : : {
275 : 0 : bed_ptr = edgeDataList.get_and_step();
276 [ # # ]: 0 : if(bed_ptr->surfID == surf_id)
277 : 0 : found = CUBIT_TRUE;
278 : : }
279 [ # # ]: 0 : if (0 == found) {
280 [ # # ][ # # ]: 0 : PRINT_ERROR("The surf_id does not match any in the list.\n");
281 : 0 : return;
282 : : }
283 : :
284 [ # # ]: 0 : if (point_ptr == edgePtr->point(0))
285 : : {
286 : 0 : ctrl_pts[0] = bed_ptr->bezierCtrlPts[0];
287 : 0 : ctrl_pts[1] = bed_ptr->bezierCtrlPts[1];
288 : 0 : ctrl_pts[2] = bed_ptr->bezierCtrlPts[2];
289 : : }
290 [ # # ]: 0 : else if(point_ptr == edgePtr->point(1))
291 : : {
292 : 0 : ctrl_pts[0] = bed_ptr->bezierCtrlPts[2];
293 : 0 : ctrl_pts[1] = bed_ptr->bezierCtrlPts[1];
294 : 0 : ctrl_pts[2] = bed_ptr->bezierCtrlPts[0];
295 : : }
296 : : else
297 : : {
298 : 0 : assert(0); // point_ptr does not match either point
299 : : }
300 : : }
301 : :
302 : : //======================================================================
303 : : // Function: set_control_points (PUBLIC)
304 : : // Description: set control points oriented with respect to the
305 : : // point_ptr (ie. point_ptr is the first control point
306 : : // on the edge)
307 : : // Note: only gets and sets the middle three control points. The
308 : : // other 2 are the edge vertices.
309 : : // Author: sjowen
310 : : // Date: 05/01
311 : : //======================================================================
312 : 0 : void TDFacetBoundaryEdge::set_control_points( CubitPoint *point_ptr,
313 : : CubitVector ctrl_pts[3],
314 : : int surf_id )
315 : : {
316 : 0 : CubitBoolean found = CUBIT_FALSE;
317 : 0 : BoundaryEdgeData *bed_ptr = NULL;
318 [ # # ]: 0 : for (int ii=0; ii<edgeDataList.size(); ii++)
319 : : {
320 : 0 : bed_ptr = edgeDataList.get_and_step();
321 [ # # ]: 0 : if(bed_ptr->surfID == surf_id)
322 : 0 : found = CUBIT_TRUE;
323 : : }
324 [ # # ]: 0 : if (0 == found) {
325 [ # # ][ # # ]: 0 : PRINT_ERROR("The surf_id does not match any in the list.\n");
326 : 0 : return;
327 : : }
328 : :
329 [ # # ]: 0 : if (point_ptr == edgePtr->point(0))
330 : : {
331 : 0 : bed_ptr->bezierCtrlPts[0] = ctrl_pts[0];
332 : 0 : bed_ptr->bezierCtrlPts[1] = ctrl_pts[1];
333 : 0 : bed_ptr->bezierCtrlPts[2] = ctrl_pts[2];
334 : : }
335 [ # # ]: 0 : else if(point_ptr == edgePtr->point(1))
336 : : {
337 : 0 : bed_ptr->bezierCtrlPts[0] = ctrl_pts[2];
338 : 0 : bed_ptr->bezierCtrlPts[1] = ctrl_pts[1];
339 : 0 : bed_ptr->bezierCtrlPts[2] = ctrl_pts[0];
340 : : }
341 : : else
342 : : {
343 : 0 : assert(0); // point_ptr does not match either point
344 : : }
345 : : }
346 : :
347 : : //-------------------------------------------------------------------------
348 : : // Purpose : set the surface id of associated with one of the
349 : : // facets adjacent to this edge
350 : : //
351 : : // Special Notes :
352 : : //
353 : : // Creator : Steve Owen
354 : : //
355 : : // Creation Date : 05/01
356 : : //-------------------------------------------------------------------------
357 : 1056 : void TDFacetBoundaryEdge::set_surf_id( CubitFacet *facet_ptr, int surf_id )
358 : : {
359 : 1056 : int found = 0;
360 : : int ii;
361 : : BoundaryEdgeData *bed_ptr;
362 [ + + ][ + + ]: 2354 : for (ii=0; ii<edgeDataList.size() && !found; ii++)
[ + + ]
363 : : {
364 : 1298 : bed_ptr = edgeDataList.get_and_step();
365 [ + + ]: 1298 : if (bed_ptr->adjFacet == facet_ptr)
366 : : {
367 : 1056 : found = 1;
368 : 1056 : bed_ptr->surfID = surf_id;
369 : : }
370 : : }
371 [ - + ]: 1056 : assert(found); // couldn't find the facet adjacent the surface
372 : 1056 : }
373 : :
374 : : //-------------------------------------------------------------------------
375 : : // Purpose : determine if this edge is internal to the surface
376 : : // (ie. surfID on both facets is the same)
377 : : //
378 : : // Special Notes : Assumes surface ids have been set
379 : : //
380 : : // Creator : Steve Owen
381 : : //
382 : : // Creation Date : 05/01
383 : : //-------------------------------------------------------------------------
384 : 1056 : CubitBoolean TDFacetBoundaryEdge::is_internal_edge()
385 : : {
386 [ - + ]: 1056 : if (edgeDataList.size() != 2)
387 : 0 : return CUBIT_FALSE;
388 : 1056 : BoundaryEdgeData *bed0_ptr = edgeDataList.get_and_step();
389 : 1056 : BoundaryEdgeData *bed1_ptr = edgeDataList.get_and_step();
390 [ - + ]: 1056 : if (bed0_ptr->surfID == bed1_ptr->surfID)
391 : : {
392 : 0 : return CUBIT_TRUE;
393 : : }
394 : 1056 : return CUBIT_FALSE;
395 : : }
396 : :
397 : : //===========================================================================
398 : : //Function Name: init_control_points
399 : : //
400 : : //Member Type: PRIVATE
401 : : //Descriptoin: compute the control points for an edge
402 : : //===========================================================================
403 : 264 : CubitStatus TDFacetBoundaryEdge::init_control_points( double min_dot )
404 : : {
405 : : int ii;
406 : 264 : CubitStatus stat = CUBIT_SUCCESS;
407 [ + - ][ + - ]: 264 : CubitVector N0, N3;
408 [ + - ][ + + ]: 792 : for (ii=0; ii<edgeDataList.size(); ii++)
409 : : {
410 : : // get the normals specific to this facet.
411 : :
412 [ + - ]: 528 : BoundaryEdgeData *bed_ptr = edgeDataList.get_and_step();
413 : : TDFacetBoundaryPoint *td_fbp0 =
414 [ + - ][ + - ]: 528 : TDFacetBoundaryPoint::get_facet_boundary_point( edgePtr->point( 0 ) );
415 : : TDFacetBoundaryPoint *td_fbp1 =
416 [ + - ][ + - ]: 528 : TDFacetBoundaryPoint::get_facet_boundary_point( edgePtr->point( 1 ) );
417 [ + - ][ - + ]: 528 : if (!td_fbp0 || !td_fbp1)
418 : 0 : return CUBIT_FAILURE;
419 [ + - ]: 528 : stat = td_fbp0->get_normal( bed_ptr->adjFacet, N0 );
420 [ - + ]: 528 : if (stat != CUBIT_SUCCESS)
421 : 0 : return stat;
422 [ + - ]: 528 : td_fbp1->get_normal( bed_ptr->adjFacet, N3 );
423 [ - + ]: 528 : if (stat != CUBIT_SUCCESS)
424 : 0 : return stat;
425 : :
426 : : // determine the curve tangents
427 : :
428 [ + - ][ + - ]: 528 : CubitVector T0, T3;
429 [ + - ]: 528 : int tool_id = bed_ptr->adjFacet->tool_id();
430 [ + - ]: 528 : stat = compute_curve_tangent( tool_id, edgePtr, min_dot, T0, T3 );
431 [ - + ]: 528 : if (stat != CUBIT_SUCCESS)
432 : 0 : return stat;
433 : :
434 : : // init the control points
435 : :
436 [ + - ][ + - ]: 528 : CubitVector P0 = edgePtr->point(0)->coordinates();
437 [ + - ][ + - ]: 528 : CubitVector P3 = edgePtr->point(1)->coordinates();
438 : : stat = FacetEvalTool::init_edge_control_points( P0, P3, N0, N3, T0, T3,
439 [ + - ]: 528 : bed_ptr->bezierCtrlPts );
440 [ - + ]: 528 : if (stat != CUBIT_SUCCESS)
441 : 0 : return stat;
442 : : }
443 : 264 : return CUBIT_SUCCESS;
444 : : }
445 : :
446 : : //===========================================================================
447 : : //Function Name: merge_control_points
448 : : //
449 : : //Member Type: PRIVATE
450 : : //Descriptoin: merge the control points - find average location for all
451 : : //===========================================================================
452 : 396 : CubitStatus TDFacetBoundaryEdge::merge_control_points()
453 : : {
454 : : int ii, jj;
455 [ + - ][ + + ]: 1584 : CubitVector ctrl_pts[3];
456 [ + - ][ + + ]: 1188 : for (ii=0; ii<edgeDataList.size(); ii++)
457 : : {
458 [ + - ]: 792 : BoundaryEdgeData *bed_ptr = edgeDataList.get_and_step();
459 [ + + ]: 3168 : for (jj=0; jj<3; jj++)
460 [ + - ]: 2376 : ctrl_pts[jj] += bed_ptr->bezierCtrlPts[jj];
461 : : }
462 [ + + ]: 1584 : for (ii=0; ii<3; ii++)
463 [ + - ][ + - ]: 1188 : ctrl_pts[ii] = ctrl_pts[ii] / edgeDataList.size();
[ + - ]
464 [ + - ]: 396 : edgePtr->control_points( ctrl_pts, 4 );
465 : 396 : return CUBIT_SUCCESS;
466 : : }
467 : :
468 : : //===========================================================================
469 : : //Function Name: compute_curve_tangent
470 : : //
471 : : //Member Type: PRIVATE
472 : : //Descriptoin: compute the tangents to the endpoints of a feature edge.
473 : : //===========================================================================
474 : 528 : CubitStatus TDFacetBoundaryEdge::compute_curve_tangent(
475 : : int tool_id,
476 : : CubitFacetEdge *edge,
477 : : double /*min_dot*/,
478 : : CubitVector &T0,
479 : : CubitVector &T3 )
480 : : {
481 : 528 : int mydebug = 0;
482 : :
483 : 528 : CubitPoint *p0 = edge->point( 0 );
484 : 528 : CubitPoint *p1 = edge->point( 1 );
485 : 528 : CubitFacetEdge *prev_edge = NULL; //next_feature_edge( tool_id, edge, p0 );
486 : :
487 : : //If ther is a previous edge that this one should be C1 with, get
488 : : // it, and make this one C1 with it.
489 [ - + ]: 528 : if(get_prev_edge()){
490 : 0 : prev_edge = get_prev_edge();
491 : : }
492 : :
493 [ + - ]: 528 : if (prev_edge == NULL) // could be end of a hard line
494 : : {
495 [ + - ][ + - ]: 528 : T0 = p1->coordinates() - p0->coordinates();
[ + - ]
496 : 528 : T0.normalize();
497 : : }
498 : : else
499 : : {
500 : :
501 [ # # ]: 0 : if(mydebug){
502 : 0 : dcolor(CUBIT_WHITE_INDEX);
503 : 0 : dedraw(prev_edge);
504 : 0 : dcolor(CUBIT_MAGENTA_INDEX);
505 : 0 : dedraw(edge);
506 : 0 : dview();
507 : : }
508 : :
509 : 0 : CubitPoint *p2 = prev_edge->other_point( p0 );
510 [ # # ]: 0 : if (p2)
511 : : {
512 [ # # ][ # # ]: 0 : T0 = (p0->coordinates() - p2->coordinates()) +
[ # # ][ # # ]
513 [ # # ][ # # ]: 0 : (p1->coordinates() - p0->coordinates());
[ # # ]
514 : : }
515 : : else // fall back to chord
516 : : {
517 [ # # ][ # # ]: 0 : T0=p1->coordinates()-p0->coordinates();
[ # # ]
518 : : }
519 : 0 : T0.normalize();
520 : : }
521 : :
522 : :
523 : 528 : CubitFacetEdge *next_edge = NULL; //next_feature_edge( tool_id, edge, p1 );
524 : : //If ther is a next edge that this one should be C1 with, get
525 : : // it, and make this one C1 with it.
526 [ - + ]: 528 : if(get_next_edge()){
527 : 0 : next_edge = get_next_edge();
528 : : }
529 [ + - ]: 528 : if (next_edge == NULL) // could be end of a hard line
530 : : {
531 [ + - ][ + - ]: 528 : T3 = p1->coordinates() - p0->coordinates();
[ + - ]
532 : 528 : T3.normalize();
533 : : }
534 : : else
535 : : {
536 [ # # ]: 0 : if(mydebug){
537 : 0 : dcolor(CUBIT_YELLOW_INDEX);
538 : 0 : dedraw(next_edge);
539 : 0 : dcolor(CUBIT_GREEN_INDEX);
540 : 0 : dedraw(edge);
541 : 0 : dview();
542 : : }
543 : 0 : CubitPoint *p2 = next_edge->other_point( p1 );
544 [ # # ]: 0 : if (p2)
545 : : {
546 [ # # ][ # # ]: 0 : T3 = (p2->coordinates() - p1->coordinates()) +
[ # # ][ # # ]
547 [ # # ][ # # ]: 0 : (p1->coordinates() - p0->coordinates());
[ # # ]
548 : : }
549 : : else
550 : : {
551 [ # # ][ # # ]: 0 : T3 = p1->coordinates() - p0->coordinates();
[ # # ]
552 : : }
553 : 0 : T3.normalize();
554 : : }
555 : :
556 : 528 : return CUBIT_SUCCESS;
557 : : }
558 : :
559 : :
560 : : //===========================================================================
561 : : //Function Name: next_feature_edge
562 : : //
563 : : //Member Type: PRIVATE
564 : : //Descriptoin: given a facet boundary edge and one of its nodes, find the
565 : : // next edge on the same surface
566 : : //===========================================================================
567 : 0 : CubitFacetEdge *TDFacetBoundaryEdge::next_feature_edge(
568 : : int tool_id,
569 : : CubitFacetEdge *this_edge,
570 : : CubitPoint *p0 )
571 : : {
572 : 0 : CubitFacetEdge *next_edge = NULL;
573 : :
574 [ # # ]: 0 : DLIList<CubitFacetEdge*> edge_list;
575 [ # # ]: 0 : p0->edges( edge_list );
576 : : int ii;
577 : :
578 : 0 : CubitFacetEdge *edge_ptr = NULL;
579 : : TDFacetBoundaryEdge *td_fbe;
580 [ # # ][ # # ]: 0 : for (ii=0; ii<edge_list.size() && next_edge == NULL; ii++)
[ # # ][ # # ]
581 : : {
582 [ # # ]: 0 : edge_ptr = edge_list.get_and_step();
583 [ # # ]: 0 : if (edge_ptr != this_edge)
584 : : {
585 [ # # ]: 0 : td_fbe = TDFacetBoundaryEdge::get_facet_boundary_edge( edge_ptr );
586 [ # # ][ # # ]: 0 : if (td_fbe != NULL && td_fbe->is_at_surf( tool_id ))
[ # # ][ # # ]
587 : : {
588 : 0 : next_edge = edge_ptr;
589 : : }
590 : : }
591 : : }
592 : :
593 [ # # ]: 0 : return next_edge;
594 : : }
595 : :
596 : : //===========================================================================
597 : : //Function Name: is_at_surf
598 : : //
599 : : //Member Type: PRIVATE
600 : : //Descriptoin: return whether the given edge has one of its adjacent
601 : : // faces on the given surface
602 : : //===========================================================================
603 : 0 : CubitBoolean TDFacetBoundaryEdge::is_at_surf( int surf_id )
604 : : {
605 : 0 : CubitBoolean found = CUBIT_FALSE;
606 : : BoundaryEdgeData *bed_ptr;
607 [ # # ][ # # ]: 0 : for (int ii=0; ii<edgeDataList.size() && !found; ii++)
[ # # ]
608 : : {
609 : 0 : bed_ptr = edgeDataList.get_and_step();
610 [ # # # # ]: 0 : if(bed_ptr->surfID == surf_id ||
[ # # ]
611 : 0 : bed_ptr->adjFacet->tool_id() == surf_id)
612 : 0 : found = CUBIT_TRUE;
613 : : }
614 : 0 : return found;
615 [ + - ][ + - ]: 6540 : }
|
