Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : FacetBody.cpp
3 : : //
4 : : // Purpose :
5 : : //
6 : : // Special Notes :
7 : : //
8 : : // Creator : David White
9 : : //
10 : : // Creation Date : 7/18/00
11 : : //
12 : : //-------------------------------------------------------------------------
13 : :
14 : : // ********** BEGIN STANDARD INCLUDES **********
15 : : #include <assert.h>
16 : : // ********** END STANDARD INCLUDES **********
17 : :
18 : :
19 : : // ********** BEGIN CUBIT INCLUDES **********
20 : : #include "CubitDefines.h"
21 : : #include "CubitString.hpp"
22 : : #include "CubitPoint.hpp"
23 : : #include "CastTo.hpp"
24 : : #include "BodySM.hpp"
25 : : #include "Body.hpp"
26 : : #include "FacetBody.hpp"
27 : : #include "CubitSimpleAttrib.hpp"
28 : : #include "FacetQueryEngine.hpp"
29 : : #include "DLIList.hpp"
30 : : #include "FacetEvalTool.hpp"
31 : : #include "CurveFacetEvalTool.hpp"
32 : : #include "Surface.hpp"
33 : : #include "FacetSurface.hpp"
34 : : #include "CubitTransformMatrix.hpp"
35 : : #include "FacetPoint.hpp"
36 : : #include "FacetCurve.hpp"
37 : : #include "FacetCoEdge.hpp"
38 : : #include "FacetLoop.hpp"
39 : : #include "FacetShell.hpp"
40 : : #include "FacetLump.hpp"
41 : : #include "CubitFacetEdge.hpp"
42 : : #include "FacetModifyEngine.hpp"
43 : : #include "FacetAttrib.hpp"
44 : : #include "GfxDebug.hpp"
45 : : #include "CubitSimpleAttrib.hpp"
46 : : #include "CubitPointData.hpp"
47 : :
48 : : //-------------------------------------------------------------------------
49 : : // Purpose : A constructor with a list of lumps that are attached.
50 : : //
51 : : // Special Notes :
52 : : //
53 : : //-------------------------------------------------------------------------
54 [ + - ][ + - ]: 198 : FacetBody::FacetBody(DLIList<Lump*>& my_lumps)
[ + - ]
55 : : {
56 [ + - ]: 99 : myLumps += my_lumps;
57 : 99 : }
58 [ # # ][ # # ]: 0 : FacetBody::~FacetBody()
[ # # ]
59 : : {
60 : : //Not sure what to do..
61 [ # # ]: 0 : }
62 : :
63 : 11 : GeometryQueryEngine* FacetBody::get_geometry_query_engine() const
64 : : {
65 : 11 : return FacetQueryEngine::instance();
66 : : }
67 : :
68 : 22 : void FacetBody::append_simple_attribute_virt(const CubitSimpleAttrib &csa)
69 : 22 : { attribSet.append_attribute(csa); }
70 : :
71 : 286 : void FacetBody::remove_simple_attribute_virt(const CubitSimpleAttrib &csa)
72 : 286 : { attribSet.remove_attribute(csa); }
73 : :
74 : 143 : void FacetBody::remove_all_simple_attribute_virt()
75 : 143 : { attribSet.remove_all_attributes(); }
76 : :
77 : 99 : CubitStatus FacetBody::get_simple_attribute(DLIList<CubitSimpleAttrib>& csa_list)
78 : 99 : { return attribSet.get_attributes(csa_list); }
79 : :
80 : 286 : CubitStatus FacetBody::get_simple_attribute( const CubitString& name,
81 : : DLIList<CubitSimpleAttrib>& csa_list )
82 : 286 : { return attribSet.get_attributes( name, csa_list ); }
83 : :
84 : 66 : CubitStatus FacetBody::save_attribs( FILE *file_ptr )
85 : 66 : { return attribSet.save_attributes( file_ptr); }
86 : :
87 : 22 : CubitStatus FacetBody::restore_attribs( FILE *file_ptr, unsigned int endian )
88 : 22 : { return attribSet.restore_attributes( file_ptr, endian ); }
89 : :
90 : :
91 : :
92 : : //----------------------------------------------------------------
93 : : // Function: copy
94 : : // Description: create a new copy of the body.
95 : : // Author: sjowen
96 : : //----------------------------------------------------------------
97 : 0 : BodySM* FacetBody::copy()
98 : : {
99 : : CubitStatus rv;
100 : :
101 : : // ----------Copy the points on the body------------------------
102 : :
103 [ # # ]: 0 : std::map<TopologyBridge*, TopologyBridge*> old_to_new_map;
104 : :
105 [ # # ][ # # ]: 0 : std::map<CubitPoint*, CubitPoint*> old_to_new_cubit_pts;
106 : :
107 : : int ii;
108 [ # # ][ # # ]: 0 : DLIList<FacetPoint*> point_list;
109 [ # # ]: 0 : get_points(point_list);
110 [ # # ][ # # ]: 0 : DLIList<TBPoint*> copy_points;
111 [ # # ]: 0 : point_list.reset();
112 : : TBPoint *point_ptr;
113 : : TBPoint *point_copy;
114 [ # # ][ # # ]: 0 : for(ii=0; ii<point_list.size(); ii++)
115 : : {
116 [ # # ]: 0 : point_ptr = point_list.get_and_step();
117 [ # # ]: 0 : CubitVector temp_vector = point_ptr->coordinates();
118 : :
119 [ # # ][ # # ]: 0 : CubitPoint *new_cubit_point = new CubitPointData( temp_vector );
120 : :
121 : : rv = FacetModifyEngine::instance()->make_facet_point( new_cubit_point,
122 [ # # ][ # # ]: 0 : point_copy);
123 : :
124 [ # # ]: 0 : if(rv != CUBIT_SUCCESS)
125 : : {
126 [ # # ][ # # ]: 0 : PRINT_ERROR("Couldn't copy points");
[ # # ][ # # ]
127 : 0 : return (BodySM *)NULL;
128 : : }
129 [ # # ]: 0 : copy_points.append( point_copy );
130 : :
131 : 0 : FacetPoint *old_fp = static_cast<FacetPoint*>(point_ptr);
132 : :
133 : : old_to_new_cubit_pts.insert(
134 [ # # ][ # # ]: 0 : std::make_pair(old_fp->get_cubit_point(), new_cubit_point ) );
[ # # ][ # # ]
135 : :
136 : : old_to_new_map.insert(
137 [ # # ][ # # ]: 0 : std::make_pair( point_ptr, point_copy ) );
[ # # ]
138 : : }
139 : :
140 : : // ------------------Copy the curves-------------------------
141 : :
142 : : int jj;
143 [ # # ][ # # ]: 0 : std::map<FacetCurve*, FacetCurve*> hard_line_curve_map;
144 [ # # ][ # # ]: 0 : DLIList<FacetCurve*> curve_list;
145 [ # # ]: 0 : get_curves( curve_list );
146 [ # # ][ # # ]: 0 : DLIList<Curve*> copy_curves;
147 [ # # ]: 0 : curve_list.reset();
148 : : Curve *curve_ptr, *curve_copy;
149 : : FacetCurve *fcurve;
150 : : TBPoint *ptsm_ptr;
151 : 0 : TBPoint *start_ptr, *end_ptr, *copy_start = NULL, *copy_end = NULL;
152 [ # # ][ # # ]: 0 : for (ii=0; ii<curve_list.size(); ii++)
153 : : {
154 [ # # ]: 0 : curve_ptr = curve_list.get_and_step();
155 [ # # ]: 0 : fcurve = CAST_TO( curve_ptr, FacetCurve );
156 [ # # ]: 0 : start_ptr = fcurve->start_point();
157 [ # # ]: 0 : end_ptr = fcurve->end_point();
158 : 0 : int found0 = 0;
159 : 0 : int found1 = 0;
160 : :
161 : : // find the end points
162 : :
163 [ # # ]: 0 : point_list.reset();
164 [ # # ]: 0 : copy_points.reset();
165 [ # # ][ # # ]: 0 : for (jj=0; jj<point_list.size() && (!found0 || !found1); jj++)
[ # # ][ # # ]
[ # # ]
166 : : {
167 [ # # ]: 0 : point_ptr = point_list.get_and_step();
168 : 0 : ptsm_ptr = CAST_TO(point_ptr, TBPoint);
169 [ # # ]: 0 : point_copy = copy_points.get_and_step();
170 [ # # ]: 0 : if (ptsm_ptr == start_ptr)
171 : : {
172 : 0 : copy_start = point_copy;
173 : 0 : found0 = 1;
174 : : }
175 [ # # ]: 0 : if (ptsm_ptr == end_ptr)
176 : : {
177 : 0 : copy_end = point_copy;
178 : 0 : found1 = 1;
179 : : }
180 : : }
181 : :
182 : : // create the new curve and update the points
183 : :
184 : : rv = FacetModifyEngine::instance()->make_facet_curve(copy_start,
185 : : copy_end,
186 [ # # ][ # # ]: 0 : curve_copy);
187 [ # # ]: 0 : if(rv != CUBIT_SUCCESS)
188 : : {
189 [ # # ][ # # ]: 0 : PRINT_ERROR("Couldn't copy curves");
[ # # ][ # # ]
190 : 0 : return (BodySM *)NULL;
191 : : }
192 : :
193 : :
194 [ # # ]: 0 : CurveFacetEvalTool *eval_tool = fcurve->get_eval_tool();
195 [ # # ]: 0 : DLIList<CubitFacetEdge*> facet_edges;
196 [ # # ]: 0 : eval_tool->get_facets( facet_edges );
197 [ # # ]: 0 : CubitFacetEdge *tmp_facet_edge = facet_edges.get();
198 [ # # ][ # # ]: 0 : DLIList<CubitFacet*> adj_facets;
199 [ # # ]: 0 : tmp_facet_edge->facets( adj_facets );
200 [ # # ]: 0 : CubitFacet *tmp_facet = adj_facets.get_and_step();
201 [ # # ]: 0 : tmp_facet->tool_id();
202 : :
203 [ # # ][ # # ]: 0 : for( int k=adj_facets.size(); k--; )
204 : : {
205 [ # # ][ # # ]: 0 : if( tmp_facet_edge->num_adj_facets_on_surf( adj_facets.get_and_step()->tool_id() ) > 1 )
[ # # ][ # # ]
206 : : {
207 : : hard_line_curve_map.insert(
208 [ # # ][ # # ]: 0 : std::map<FacetCurve*, FacetCurve*>::value_type( static_cast<FacetCurve*>( CAST_TO( curve_copy, FacetCurve )),fcurve ));
[ # # ]
209 : 0 : break;
210 : : }
211 : : }
212 : :
213 : : old_to_new_map.insert(
214 [ # # ][ # # ]: 0 : std::make_pair( curve_ptr, curve_copy ) );
[ # # ]
215 : :
216 [ # # ]: 0 : copy_curves.append( curve_copy );
217 [ # # ]: 0 : }
218 : :
219 : : // ------------------copy coedges-----------------------
220 : :
221 [ # # ][ # # ]: 0 : DLIList<FacetCoEdge*> coedge_list;
222 [ # # ]: 0 : get_coedges( coedge_list );
223 [ # # ][ # # ]: 0 : DLIList<CoEdgeSM*> copy_coedges;
224 [ # # ]: 0 : coedge_list.reset();
225 : : Curve *curvsm_ptr;
226 : 0 : Curve *curvsm_copy = NULL;
227 : : CoEdgeSM *coedge_ptr, *coedge_copy;
228 : : FacetCoEdge *fcoedge;
229 [ # # ][ # # ]: 0 : for (ii=0; ii<coedge_list.size(); ii++)
230 : : {
231 [ # # ]: 0 : coedge_ptr = coedge_list.get_and_step();
232 [ # # ]: 0 : fcoedge = CAST_TO( coedge_ptr, FacetCoEdge );
233 [ # # ]: 0 : Curve *curve_at_coedge = fcoedge->curve();
234 : 0 : int found = 0;
235 : :
236 : : // find the associated curve
237 : :
238 [ # # ]: 0 : curve_list.reset();
239 [ # # ]: 0 : copy_curves.reset();
240 [ # # ][ # # ]: 0 : for (jj=0; jj<curve_list.size() && !found; jj++)
[ # # ][ # # ]
241 : : {
242 [ # # ]: 0 : curve_ptr = curve_list.get_and_step();
243 : 0 : curvsm_ptr = CAST_TO(curve_ptr, Curve);
244 [ # # ]: 0 : curvsm_copy = copy_curves.get_and_step();
245 [ # # ]: 0 : if (curve_at_coedge == curvsm_ptr)
246 : : {
247 : 0 : found = 1;
248 : : }
249 : : }
250 : :
251 : : // create the new coedge
252 : :
253 [ # # ]: 0 : CubitSense sense = fcoedge->sense();
254 : : rv = FacetModifyEngine::instance()->make_facet_coedge(curvsm_copy,
255 [ # # ][ # # ]: 0 : sense, coedge_copy);
256 [ # # ]: 0 : if(rv != CUBIT_SUCCESS)
257 : : {
258 [ # # ][ # # ]: 0 : PRINT_ERROR("Couldn't copy coedge");
[ # # ][ # # ]
259 : 0 : return (BodySM *)NULL;
260 : : }
261 [ # # ]: 0 : copy_coedges.append( coedge_copy );
262 : : }
263 : :
264 : : // ----------------------copy loops--------------------------
265 : :
266 : : int kk;
267 [ # # ][ # # ]: 0 : DLIList<FacetLoop*> loop_list;
268 [ # # ]: 0 : get_loops( loop_list );
269 [ # # ][ # # ]: 0 : DLIList<LoopSM*> copy_loops;
270 [ # # ]: 0 : loop_list.reset();
271 : : LoopSM *loop_ptr, *loop_copy;
272 : : FacetLoop *floop;
273 [ # # ][ # # ]: 0 : for (ii=0; ii<loop_list.size(); ii++)
274 : : {
275 [ # # ]: 0 : floop = loop_list.get_and_step();
276 [ # # ]: 0 : DLIList<FacetCoEdge *>coedges_on_loop;
277 [ # # ]: 0 : floop->get_coedges(coedges_on_loop);
278 [ # # ][ # # ]: 0 : DLIList<CoEdgeSM *>copy_coedges_on_loop;
[ # # ]
279 : :
280 : : // find all associated coedges on the loop
281 : :
282 [ # # ][ # # ]: 0 : for(kk=0; kk<coedges_on_loop.size(); kk++)
283 : : {
284 : 0 : int found = 0;
285 [ # # ]: 0 : coedge_list.reset();
286 [ # # ]: 0 : copy_coedges.reset();
287 [ # # ]: 0 : CoEdgeSM *coedge_on_loop = coedges_on_loop.get_and_step();
288 [ # # ][ # # ]: 0 : for (jj=0; jj<coedge_list.size() && !found; jj++)
[ # # ][ # # ]
289 : : {
290 [ # # ]: 0 : coedge_ptr = coedge_list.get_and_step();
291 [ # # ]: 0 : coedge_copy = copy_coedges.get_and_step();
292 [ # # ]: 0 : if (coedge_on_loop == coedge_ptr)
293 : : {
294 : 0 : found = 1;
295 [ # # ]: 0 : copy_coedges_on_loop.append(coedge_copy);
296 : : }
297 : : }
298 : : }
299 : :
300 : : // create the new loop
301 : :
302 : : rv = FacetModifyEngine::instance()->make_facet_loop(copy_coedges_on_loop,
303 [ # # ][ # # ]: 0 : loop_copy);
304 [ # # ]: 0 : if(rv != CUBIT_SUCCESS)
305 : : {
306 [ # # ][ # # ]: 0 : PRINT_ERROR("Couldn't copy loops");
[ # # ][ # # ]
307 : 0 : return (BodySM *)NULL;
308 : : }
309 [ # # ][ # # ]: 0 : copy_loops.append( loop_copy );
[ # # ]
310 : 0 : }
311 : :
312 : : // ----------------------copy surfaces--------------------------
313 [ # # ][ # # ]: 0 : DLIList<FacetSurface*> surface_list;
314 [ # # ]: 0 : get_surfaces(surface_list);
315 [ # # ][ # # ]: 0 : DLIList<Surface*> copy_surfaces;
316 [ # # ]: 0 : surface_list.reset();
317 : : Surface *surface_ptr, *surface_copy;
318 : : FacetSurface *fsurface;
319 [ # # ][ # # ]: 0 : for (ii=0; ii<surface_list.size(); ii++)
320 : : {
321 [ # # ]: 0 : fsurface = surface_list.get_and_step();
322 [ # # ]: 0 : DLIList<FacetLoop *>loops_on_surface;
323 [ # # ]: 0 : fsurface->get_loops(loops_on_surface);
324 [ # # ][ # # ]: 0 : DLIList<LoopSM *>copy_loops_on_surface;
[ # # ]
325 : :
326 : : // find all associated loops on the surface
327 : :
328 [ # # ][ # # ]: 0 : for(kk=0; kk<loops_on_surface.size(); kk++)
329 : : {
330 : 0 : int found = 0;
331 [ # # ]: 0 : loop_list.reset();
332 [ # # ]: 0 : copy_loops.reset();
333 [ # # ]: 0 : LoopSM *loop_on_surface = loops_on_surface.get_and_step();
334 [ # # ][ # # ]: 0 : for (jj=0; jj<loop_list.size() && !found; jj++)
[ # # ][ # # ]
335 : : {
336 [ # # ]: 0 : loop_ptr = loop_list.get_and_step();
337 [ # # ]: 0 : loop_copy = copy_loops.get_and_step();
338 [ # # ]: 0 : if (loop_on_surface == loop_ptr)
339 : : {
340 : 0 : found = 1;
341 [ # # ]: 0 : copy_loops_on_surface.append(loop_copy);
342 : : }
343 : : }
344 : : }
345 : :
346 : : // create the new surface
347 : :
348 [ # # ][ # # ]: 0 : DLIList<CubitFacet*>facet_list;
[ # # ]
349 [ # # ][ # # ]: 0 : DLIList<CubitPoint*>cpoint_list;
[ # # ]
350 [ # # ]: 0 : rv = fsurface->copy_facets( facet_list, cpoint_list, old_to_new_cubit_pts );
351 [ # # ]: 0 : if (rv != CUBIT_SUCCESS)
352 : : {
353 : 0 : return (BodySM *)NULL;
354 : : }
355 [ # # ]: 0 : int interp_order = fsurface->interp_order();
356 [ # # ]: 0 : double min_dot = fsurface->min_dot();
357 [ # # ]: 0 : const CubitEvaluatorData *eval_data = fsurface->evaluator_data();
358 : 0 : CubitBoolean use_point_addresses = CUBIT_FALSE;
359 : : rv = FacetModifyEngine::instance()->make_facet_surface(eval_data,
360 : : facet_list,
361 : : cpoint_list,
362 : : copy_loops_on_surface,
363 : : interp_order,
364 : : min_dot,
365 : : surface_copy,
366 : : use_point_addresses,
367 : : NULL,
368 [ # # ][ # # ]: 0 : &hard_line_curve_map);
369 [ # # ]: 0 : if(rv != CUBIT_SUCCESS)
370 : : {
371 [ # # ][ # # ]: 0 : PRINT_ERROR("Couldn't copy surfaces");
[ # # ][ # # ]
372 : 0 : return (BodySM *)NULL;
373 : : }
374 : :
375 : : old_to_new_map.insert(
376 [ # # ][ # # ]: 0 : std::make_pair( fsurface, surface_copy ) );
[ # # ]
377 : :
378 [ # # ][ # # ]: 0 : copy_surfaces.append( surface_copy );
[ # # ]
379 : 0 : }
380 : :
381 : : // ----------------------copy shells--------------------------
382 : :
383 [ # # ][ # # ]: 0 : DLIList<FacetShell*> shell_list;
384 [ # # ]: 0 : get_shells(shell_list);
385 [ # # ][ # # ]: 0 : DLIList<ShellSM*> copy_shells;
386 [ # # ]: 0 : shell_list.reset();
387 : : ShellSM *shell_ptr, *shell_copy;
388 : : FacetShell *fshell;
389 [ # # ][ # # ]: 0 : for (ii=0; ii<shell_list.size(); ii++)
390 : : {
391 [ # # ]: 0 : fshell = shell_list.get_and_step();
392 [ # # ]: 0 : DLIList<FacetSurface *>surfaces_on_shell;
393 [ # # ]: 0 : fshell->get_surfaces(surfaces_on_shell);
394 [ # # ][ # # ]: 0 : DLIList<Surface *>copy_surfaces_on_shell;
[ # # ]
395 : :
396 : : // find all associated loops on the surface
397 : :
398 [ # # ][ # # ]: 0 : for(kk=0; kk<surfaces_on_shell.size(); kk++)
399 : : {
400 : 0 : int found = 0;
401 [ # # ]: 0 : surface_list.reset();
402 [ # # ]: 0 : copy_surfaces.reset();
403 [ # # ]: 0 : Surface *surface_on_shell = surfaces_on_shell.get_and_step();
404 [ # # ][ # # ]: 0 : for (jj=0; jj<surface_list.size() && !found; jj++)
[ # # ][ # # ]
405 : : {
406 [ # # ]: 0 : surface_ptr = surface_list.get_and_step();
407 [ # # ]: 0 : surface_copy = copy_surfaces.get_and_step();
408 [ # # ]: 0 : if (surface_on_shell == surface_ptr)
409 : : {
410 : 0 : found = 1;
411 [ # # ]: 0 : copy_surfaces_on_shell.append(surface_copy);
412 : : }
413 : : }
414 : : }
415 : :
416 : : // create the new shell
417 : :
418 : : rv = FacetModifyEngine::instance()->make_facet_shell(copy_surfaces_on_shell,
419 [ # # ][ # # ]: 0 : shell_copy);
420 [ # # ]: 0 : if(rv != CUBIT_SUCCESS)
421 : : {
422 [ # # ][ # # ]: 0 : PRINT_ERROR("Couldn't copy shell");
[ # # ][ # # ]
423 : 0 : return (BodySM *)NULL;
424 : : }
425 : :
426 : : // set the sense of the surfaces on the shell - copy from the old shell
427 : :
428 [ # # ]: 0 : FacetShell *fshell_copy = CAST_TO(shell_copy, FacetShell);
429 [ # # ]: 0 : surfaces_on_shell.reset();
430 [ # # ]: 0 : copy_surfaces_on_shell.reset();
431 [ # # ][ # # ]: 0 : for (kk=0; kk<surfaces_on_shell.size(); kk++)
432 : : {
433 [ # # ]: 0 : Surface *surface_on_shell = surfaces_on_shell.get_and_step();
434 [ # # ]: 0 : Surface *copy_surface_on_shell = copy_surfaces_on_shell.get_and_step();
435 [ # # ]: 0 : fsurface = CAST_TO( surface_on_shell, FacetSurface );
436 [ # # ]: 0 : CubitSense sense = fsurface->get_shell_sense(fshell);
437 [ # # ]: 0 : FacetSurface *copy_fsurface = CAST_TO( copy_surface_on_shell, FacetSurface );
438 [ # # ]: 0 : copy_fsurface->set_shell_sense( fshell_copy, sense );
439 : : }
440 [ # # ][ # # ]: 0 : copy_shells.append( shell_copy );
[ # # ]
441 : 0 : }
442 : :
443 : : // ----------------------copy lumps--------------------------
444 : :
445 [ # # ][ # # ]: 0 : DLIList<FacetLump*> lump_list;
446 [ # # ]: 0 : get_lumps(lump_list);
447 [ # # ][ # # ]: 0 : DLIList<Lump*> copy_lumps;
448 [ # # ]: 0 : lump_list.reset();
449 : : Lump *lump_copy;
450 : : FacetLump *flump;
451 [ # # ][ # # ]: 0 : for (ii=0; ii<lump_list.size(); ii++)
452 : : {
453 [ # # ]: 0 : flump = lump_list.get_and_step();
454 [ # # ]: 0 : DLIList<FacetShell *>shells_on_lump;
455 [ # # ]: 0 : flump->get_shells(shells_on_lump);
456 [ # # ][ # # ]: 0 : DLIList<ShellSM *>copy_shells_on_lump;
[ # # ]
457 : :
458 : : // find all associated loops on the surface
459 : :
460 [ # # ][ # # ]: 0 : for(kk=0; kk<shells_on_lump.size(); kk++)
461 : : {
462 : 0 : int found = 0;
463 [ # # ]: 0 : shell_list.reset();
464 [ # # ]: 0 : copy_shells.reset();
465 [ # # ]: 0 : ShellSM *shell_on_lump = shells_on_lump.get_and_step();
466 [ # # ][ # # ]: 0 : for (jj=0; jj<shell_list.size() && !found; jj++)
[ # # ][ # # ]
467 : : {
468 [ # # ]: 0 : shell_ptr = shell_list.get_and_step();
469 [ # # ]: 0 : shell_copy = copy_shells.get_and_step();
470 [ # # ]: 0 : if (shell_on_lump == shell_ptr)
471 : : {
472 : 0 : found = 1;
473 [ # # ]: 0 : copy_shells_on_lump.append(shell_copy);
474 : : }
475 : : }
476 : : }
477 : :
478 : : // create the new lump
479 : :
480 : : rv = FacetModifyEngine::instance()->make_facet_lump(copy_shells_on_lump,
481 [ # # ][ # # ]: 0 : lump_copy);
482 [ # # ]: 0 : if(rv != CUBIT_SUCCESS)
483 : : {
484 [ # # ][ # # ]: 0 : PRINT_ERROR("Couldn't copy lump");
[ # # ][ # # ]
485 : 0 : return (BodySM *)NULL;
486 : : }
487 : :
488 : : old_to_new_map.insert(
489 [ # # ][ # # ]: 0 : std::make_pair( flump, lump_copy ) );
[ # # ]
490 : :
491 [ # # ][ # # ]: 0 : copy_lumps.append( lump_copy );
[ # # ]
492 : 0 : }
493 : :
494 : : // ----------------------copy body--------------------------
495 : :
496 : : BodySM *body_copy;
497 : : rv = FacetModifyEngine::instance()->make_facet_body(copy_lumps,
498 [ # # ][ # # ]: 0 : body_copy);
499 [ # # ]: 0 : if(rv != CUBIT_SUCCESS)
500 : : {
501 [ # # ][ # # ]: 0 : PRINT_ERROR("Couldn't copy lump");
[ # # ][ # # ]
502 : 0 : return (BodySM *)NULL;
503 : : }
504 : :
505 : : //copy the attributes from old to new
506 [ # # ]: 0 : std::map<TopologyBridge*, TopologyBridge*>::iterator iter;
507 [ # # ][ # # ]: 0 : for( iter= old_to_new_map.begin(); iter != old_to_new_map.end(); iter++ )
[ # # ][ # # ]
[ # # ]
508 : : {
509 [ # # ]: 0 : TopologyBridge *old_tb = iter->first;
510 [ # # ]: 0 : TopologyBridge *new_tb = iter->second;
511 : :
512 [ # # ]: 0 : DLIList<CubitSimpleAttrib> old_attribs;
513 [ # # ]: 0 : old_tb->get_simple_attribute( old_attribs );
514 : :
515 [ # # ][ # # ]: 0 : for( int i=old_attribs.size(); i--; )
516 : : {
517 [ # # ]: 0 : const CubitSimpleAttrib& copy = old_attribs.get_and_step();
518 [ # # ]: 0 : new_tb->append_simple_attribute_virt( copy );
519 : : }
520 [ # # ]: 0 : }
521 : :
522 [ # # ]: 0 : return (BodySM*)body_copy;
523 : : }
524 : : //----------------------------------------------------------------
525 : : // Function: can_be_deleted
526 : : // Description: determine if the body can be deleted
527 : : //
528 : : // Author: sjowen
529 : : //----------------------------------------------------------------
530 : 0 : CubitBoolean FacetBody::can_be_deleted( DLIList <Body*> &body_list )
531 : : {
532 : 0 : CubitBoolean delete_ok = CUBIT_TRUE;
533 [ # # ]: 0 : DLIList<FacetSurface *>surf_list;
534 [ # # ]: 0 : get_surfaces(surf_list);
535 : : int ii;
536 [ # # ][ # # ]: 0 : for (ii=0; ii<surf_list.size() && delete_ok; ii++)
[ # # ][ # # ]
537 : : {
538 [ # # ]: 0 : FacetSurface *surf_ptr = surf_list.get_and_step();
539 [ # # ]: 0 : DLIList<FacetBody*>my_body_list;
540 [ # # ]: 0 : surf_ptr->get_bodies(my_body_list);
541 : : int jj;
542 [ # # ][ # # ]: 0 : if (my_body_list.size() >= 2)
543 : : {
544 [ # # ][ # # ]: 0 : for (jj=0; jj<my_body_list.size() && delete_ok; jj++)
[ # # ][ # # ]
545 : : {
546 [ # # ]: 0 : BodySM *my_body_ptr = my_body_list.get_and_step();
547 [ # # ]: 0 : if (my_body_ptr != this)
548 : : {
549 : : int kk;
550 : 0 : int found = 0;
551 [ # # ][ # # ]: 0 : for (kk=0; kk<body_list.size() && !found; kk++)
[ # # ][ # # ]
552 : : {
553 [ # # ]: 0 : Body *body_ptr = body_list.get_and_step();
554 [ # # ][ # # ]: 0 : FacetBody* fbody_ptr = CAST_TO(body_ptr->get_body_sm_ptr(), FacetBody);
555 [ # # ]: 0 : if (fbody_ptr)
556 : : {
557 [ # # ]: 0 : if (my_body_ptr == fbody_ptr)
558 : 0 : found = 1;
559 : : }
560 : : }
561 [ # # ]: 0 : if (!found)
562 : : {
563 : 0 : delete_ok = CUBIT_FALSE;
564 [ # # ][ # # ]: 0 : PRINT_ERROR("Body cannot be deleted because it is merged with adjacent Body\n");
[ # # ][ # # ]
565 [ # # ][ # # ]: 0 : PRINT_INFO(" Mesh Based Geometry entities cannot be unmerged.\n"
[ # # ]
566 [ # # ]: 0 : " Try using the no_merge option when importing the mesh\n");
567 : : }
568 : : }
569 : : }
570 : : }
571 [ # # ]: 0 : }
572 [ # # ]: 0 : return delete_ok;
573 : : }
574 : :
575 : : //----------------------------------------------------------------
576 : : // Function: move
577 : : // Description: translate the body and its child entities
578 : : //
579 : : // Author: sjowen
580 : : //----------------------------------------------------------------
581 : 11 : CubitStatus FacetBody::move(double dx, double dy, double dz)
582 : : {
583 [ + - ]: 11 : CubitTransformMatrix tfmat;
584 [ + - ]: 11 : tfmat.translate( dx, dy, dz );
585 : :
586 [ + - ]: 11 : CubitStatus stat = transform( tfmat, CUBIT_FALSE );
587 : :
588 [ + - ]: 11 : if (stat == CUBIT_SUCCESS)
589 [ + - ]: 11 : myTransforms.translate( dx, dy, dz );
590 : :
591 [ + - ]: 11 : return stat;
592 : : }
593 : :
594 : :
595 : : //----------------------------------------------------------------
596 : : // Function: rotate
597 : : // Description: rotate the body and its child entities
598 : : //
599 : : // Author: sjowen
600 : : //----------------------------------------------------------------
601 : 0 : CubitStatus FacetBody::rotate( double x, double y, double z,
602 : : double angle_in_degrees )
603 : : {
604 : :
605 [ # # ]: 0 : CubitTransformMatrix rotmat;
606 [ # # ]: 0 : CubitVector axis( x, y, z );
607 [ # # ]: 0 : rotmat.rotate( angle_in_degrees, axis );
608 : :
609 [ # # ]: 0 : CubitStatus stat = transform( rotmat, CUBIT_TRUE );
610 : :
611 [ # # ]: 0 : if (stat == CUBIT_SUCCESS)
612 [ # # ]: 0 : myTransforms.rotate( angle_in_degrees, axis );
613 : :
614 [ # # ]: 0 : return stat;
615 : : }
616 : :
617 : : //----------------------------------------------------------------
618 : : // Function: scale
619 : : // Description: scale the body and its child entities
620 : : // use a constant scale factor
621 : : //
622 : : // Author: sjowen
623 : : //----------------------------------------------------------------
624 : 0 : CubitStatus FacetBody::scale(double scale_factor )
625 : : {
626 : 0 : return scale(scale_factor,scale_factor,scale_factor);
627 : : }
628 : :
629 : : //----------------------------------------------------------------
630 : : // Function: scale
631 : : // Description: scale the body and its child entities
632 : : //
633 : : // Author: sjowen
634 : : //----------------------------------------------------------------
635 : 0 : CubitStatus FacetBody::scale(double scale_factor_x,
636 : : double scale_factor_y,
637 : : double scale_factor_z )
638 : : {
639 [ # # ]: 0 : CubitTransformMatrix scalemat;
640 : : scalemat.scale_about_origin( scale_factor_x,
641 : : scale_factor_y,
642 [ # # ]: 0 : scale_factor_z );
643 : :
644 [ # # ]: 0 : CubitStatus stat = transform( scalemat, CUBIT_FALSE );
645 : :
646 [ # # ]: 0 : if (stat == CUBIT_SUCCESS)
647 : : myTransforms.scale_about_origin( scale_factor_x,
648 : : scale_factor_y,
649 [ # # ]: 0 : scale_factor_z );
650 : :
651 : : // scale the facetcurve
652 : :
653 [ # # ][ # # ]: 0 : DLIList<FacetCurve *> curve_list;
654 [ # # ]: 0 : get_curves(curve_list);
655 : : Curve *curv_ptr;
656 [ # # ][ # # ]: 0 : for (int ii=0; ii<curve_list.size(); ii++)
657 : : {
658 [ # # ]: 0 : curv_ptr = curve_list.get_and_step();
659 [ # # ]: 0 : FacetCurve *fcurve = CAST_TO( curv_ptr, FacetCurve );
660 [ # # ]: 0 : if (fcurve)
661 : : {
662 [ # # ]: 0 : fcurve->reset_length();
663 : : }
664 : : }
665 : :
666 [ # # ]: 0 : return stat;
667 : : }
668 : :
669 : : //----------------------------------------------------------------
670 : : // Function: restore
671 : : // Description: restore the body and its child entities
672 : : // to its original coordinates using the inverse
673 : : // transformation matrix
674 : : //
675 : : // Author: sjowen
676 : : //----------------------------------------------------------------
677 : 0 : CubitStatus FacetBody::restore()
678 : : {
679 : : // invert the transformation matrix and apply to entities
680 : : // (assumes an orthogonal matrix (ie. no shear or non-uniform scaling)
681 : :
682 [ # # ]: 0 : CubitTransformMatrix inverse_mat;
683 [ # # ][ # # ]: 0 : inverse_mat = myTransforms.inverse();
684 : :
685 [ # # ]: 0 : CubitStatus stat = transform( inverse_mat, CUBIT_TRUE );
686 : :
687 [ # # ]: 0 : if (stat == CUBIT_SUCCESS)
688 [ # # ]: 0 : myTransforms.set_to_identity();
689 : :
690 [ # # ]: 0 : return stat;
691 : : }
692 : :
693 : : //----------------------------------------------------------------
694 : : // Function: reflect
695 : : // Description: reflect the body about a exis
696 : : //
697 : : // Author: sjowen
698 : : //----------------------------------------------------------------
699 : 0 : CubitStatus FacetBody::reflect( double reflect_axis_x,
700 : : double reflect_axis_y,
701 : : double reflect_axis_z )
702 : : {
703 [ # # ]: 0 : CubitTransformMatrix reflectmat;
704 : : CubitVector reflect_vector( reflect_axis_x,
705 : : reflect_axis_y,
706 [ # # ]: 0 : reflect_axis_z );
707 [ # # ]: 0 : reflectmat.reflect( reflect_vector );
708 : :
709 [ # # ]: 0 : CubitStatus stat = transform( reflectmat, CUBIT_TRUE );
710 : :
711 [ # # ]: 0 : if (stat == CUBIT_SUCCESS)
712 [ # # ]: 0 : myTransforms.reflect( reflect_vector );
713 : :
714 [ # # ]: 0 : return stat;
715 : : }
716 : :
717 : : //----------------------------------------------------------------
718 : : // Function: transform
719 : : // Description: transform the body based on a transformation matrix
720 : : // main function for applying transformations to
721 : : // facet-based bodies
722 : : //
723 : : // Author: sjowen
724 : : //----------------------------------------------------------------
725 : 11 : CubitStatus FacetBody::transform( CubitTransformMatrix &tfmat,
726 : : CubitBoolean is_rotation )
727 : : {
728 : : int ii;
729 : :
730 : : // get the list of surfaces on the body
731 : :
732 [ + - ]: 11 : DLIList<FacetSurface *>surf_list;
733 [ + - ]: 11 : get_surfaces( surf_list );
734 : : Surface *surf;
735 : : FacetSurface *fsurf;
736 : : FacetEvalTool *ftool;
737 : : //CubitVector min, max;
738 : :
739 : : // go through all the surfaces and collect the list of all points.
740 : : // (some may be listed on multiple surfaces)
741 : :
742 [ + - ][ + - ]: 22 : DLIList<CubitPoint *>point_list;
743 [ + - ][ + + ]: 77 : for (ii=0; ii<surf_list.size(); ii++)
744 : : {
745 [ + - ]: 66 : surf = surf_list.get_and_step();
746 [ - + ]: 66 : fsurf = CAST_TO( surf, FacetSurface );
747 [ + - ]: 66 : fsurf->get_my_points( point_list );
748 : : }
749 : :
750 : : // unmark all the points so we can keep track of the ones that have
751 : : // already been transformed
752 : :
753 : : CubitPoint *cp;
754 [ + - ][ + + ]: 341 : for (ii=0; ii<point_list.size(); ii++)
755 : : {
756 [ + - ]: 330 : cp = point_list.get_and_step();
757 [ + - ]: 330 : cp->marked( 0 );
758 : : }
759 : :
760 : : // transform the points
761 : :
762 : : //CubitVector norm, du, dv;
763 [ + - ][ + + ]: 341 : for (ii=0; ii<point_list.size(); ii++)
764 : : {
765 [ + - ]: 330 : cp = point_list.get_and_step();
766 [ + - ][ + + ]: 330 : if (!cp->marked())
767 : : {
768 [ + - ]: 154 : cp->transform( tfmat );
769 [ - + ]: 154 : if (is_rotation)
770 [ # # ]: 0 : cp->rotate_normal( tfmat );
771 [ + - ]: 154 : cp->marked( 1 );
772 : : }
773 : : }
774 : :
775 : : // check the vertices - make sure they are transformed
776 : :
777 : : FacetPoint *fpt;
778 : : TBPoint *pt;
779 [ + - ][ + - ]: 22 : DLIList<FacetPoint*>gpoint_list;
780 [ + - ]: 11 : get_points(gpoint_list);
781 [ + - ][ + + ]: 99 : for (ii=0; ii<gpoint_list.size(); ii++)
782 : : {
783 [ + - ]: 88 : pt = gpoint_list.get_and_step();
784 [ - + ]: 88 : fpt = CAST_TO( pt, FacetPoint );
785 : :
786 : : // only transform the point if it isn't already part of the facets
787 : : // (they could be points by themselves)
788 : :
789 [ + - ]: 88 : cp = fpt->get_cubit_point();
790 [ + - ][ - + ]: 88 : if (cp->num_adj_facets() == 0)
791 : : {
792 [ # # ]: 0 : cp->transform( tfmat );
793 [ # # ]: 0 : if (is_rotation)
794 [ # # ]: 0 : cp->rotate_normal( tfmat );
795 : : }
796 : : }
797 : :
798 : : // reset the bounding box and update the facet normal and plane
799 : :
800 : : // init flags on edges to 0
801 [ + - ][ + - ]: 22 : DLIList<Surface*> tmp_surf_list( surf_list.size() );
[ + - ]
802 [ + - ][ + - ]: 77 : CAST_LIST_TO_PARENT( surf_list, tmp_surf_list );
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + + ]
803 [ + - ]: 11 : init_edge_flags( tmp_surf_list, 0 );
804 [ + - ][ + + ]: 77 : for (ii=0; ii<surf_list.size(); ii++)
805 : : {
806 [ + - ]: 66 : surf = surf_list.get_and_step();
807 [ - + ]: 66 : fsurf = CAST_TO( surf, FacetSurface );
808 : :
809 : : // if we are using a bspline representation, then we also need to
810 : : // transform the control points on the edges and facets
811 : :
812 [ + - ]: 66 : ftool = fsurf->get_eval_tool();
813 [ + - ][ - + ]: 66 : if (ftool->interp_order() == 4)
814 : : {
815 [ # # ]: 0 : ftool->transform_control_points( tfmat );
816 : : }
817 : :
818 [ + - ]: 66 : DLIList<CubitFacet *>flist;
819 [ + - ][ + - ]: 132 : DLIList<CubitPoint *>plist;
820 [ + - ]: 66 : fsurf->get_my_facets( flist, plist);
821 : : int jj;
822 : : CubitFacet *facet_ptr;
823 [ + - ][ + + ]: 330 : for (jj=0; jj<flist.size(); jj++)
824 : : {
825 [ + - ]: 264 : facet_ptr = flist.get_and_step();
826 [ + - ]: 264 : facet_ptr->update_plane();
827 [ + - ]: 264 : facet_ptr->reset_bounding_box();
828 : : }
829 : : //must be done after facet's are reset...
830 [ + - ]: 66 : ftool->reset_bounding_box();
831 : : // if this facet surface has a primitive evaluator, then we need
832 : : // to tell it about the transformation also.
833 [ + - ]: 66 : fsurf->add_transformation( tfmat );
834 : :
835 : : //re-calculate the area of the surface in case it changed
836 [ + - ]: 66 : fsurf->update_measurement();
837 [ + - ]: 66 : }
838 [ + - ]: 11 : init_edge_flags( tmp_surf_list, 0 );
839 : :
840 : : // Some transforms (those incorporating reflections)
841 : : // invert the geometry. Correct for it.
842 : : // -- jason k.
843 [ + - ][ + - ]: 11 : if ( tfmat.sub_matrix(3,3).determinant() < 0.0 )
[ + - ][ - + ]
844 : : {
845 : : // Flip CoFace senses
846 [ # # ]: 0 : DLIList<FacetShell*> shells;
847 [ # # ]: 0 : get_shells( shells );
848 : : //modified. mbrewer. doing both a reverse and a
849 : : //reverse_surfaces. the latter actually changes the
850 : : // underlying surfaces so that the normals can all
851 : : // still be outward pointing. It automatically changes
852 : : // the sense, therefore we also still need excplicity
853 : : // call reverse so that sense is corrected.
854 [ # # ][ # # ]: 0 : while (shells.size()){
855 [ # # ][ # # ]: 0 : shells.get()->reverse_surfaces();
856 [ # # ][ # # ]: 0 : shells.pop()->reverse();
857 [ # # ]: 0 : }
858 : : }
859 : :
860 [ + - ]: 11 : return CUBIT_SUCCESS;
861 : : }
862 : :
863 : : //----------------------------------------------------------------
864 : : // Function: init_edge_flags
865 : : // Description: set the flags on the facet edges
866 : : // Note: Only done for facet eval tool with order 4 interpolation
867 : : // Author: sjowen
868 : : //----------------------------------------------------------------
869 : 22 : void FacetBody::init_edge_flags( DLIList<Surface *>&surf_list,
870 : : int )
871 : : {
872 : : int ii, jj;
873 : : Surface *surf;
874 : : FacetSurface *fsurf;
875 : : FacetEvalTool *ftool;
876 : : CubitFacetEdge *edge_ptr;
877 : :
878 [ + + ]: 154 : for (ii=0; ii<surf_list.size(); ii++)
879 : : {
880 [ + - ]: 132 : DLIList<CubitFacetEdge*>edge_list;
881 [ + - ]: 132 : surf = surf_list.get_and_step();
882 [ - + ]: 132 : fsurf = CAST_TO( surf, FacetSurface );
883 [ + - ]: 132 : ftool = fsurf->get_eval_tool();
884 [ + - ][ - + ]: 132 : if (ftool->interp_order() == 4)
885 : : {
886 [ # # ]: 0 : ftool->get_edges( edge_list );
887 [ # # ][ # # ]: 0 : for (jj=0; jj<edge_list.size(); jj++)
888 : : {
889 [ # # ]: 0 : edge_ptr = edge_list.get_and_step();
890 [ # # ]: 0 : edge_ptr->set_flag( 0 );
891 : : }
892 : : }
893 [ + - ]: 132 : }
894 : 22 : }
895 : :
896 : 66 : CubitStatus FacetBody::get_transforms( CubitTransformMatrix &tfm )
897 : : {
898 : 66 : tfm = myTransforms;
899 : 66 : return CUBIT_SUCCESS;
900 : : }
901 : :
902 : 22 : CubitStatus FacetBody::set_transforms( CubitTransformMatrix tfm )
903 : : {
904 : 22 : myTransforms = tfm;
905 : 22 : return CUBIT_SUCCESS;
906 : : }
907 : :
908 : 0 : int FacetBody::validate(const CubitString &, DLIList <TopologyEntity*>&)
909 : : {
910 [ # # ][ # # ]: 0 : PRINT_ERROR("This option is not available for mesh defined geometry.\n");
911 : 0 : return 0;
912 : : }
913 : :
914 : 0 : void FacetBody::get_parents_virt( DLIList<TopologyBridge*>& )
915 : 0 : {}
916 : :
917 : 396 : void FacetBody::get_children_virt( DLIList<TopologyBridge*>& lumps )
918 [ + - ][ + + ]: 792 : { CAST_LIST_TO_PARENT( myLumps, lumps ); }
919 : :
920 : 154 : void FacetBody::get_lumps( DLIList<FacetLump*>& result_list )
921 : : {
922 : 154 : myLumps.reset();
923 [ + + ]: 308 : for ( int i = 0; i < myLumps.size(); i++ )
924 [ + - ][ - + ]: 154 : if ( FacetLump* lump = dynamic_cast<FacetLump*>(myLumps.next(i)) )
[ + - ]
925 [ + - ]: 154 : result_list.append(lump);
926 : 154 : }
927 : :
928 : 22 : void FacetBody::get_shells( DLIList<FacetShell*>& result_list )
929 : : {
930 [ + - ]: 22 : DLIList<FacetLump*> lump_list;
931 [ + - ]: 22 : get_lumps( lump_list );
932 [ + - ]: 22 : lump_list.reset();
933 [ + - ][ + + ]: 44 : for ( int i = 0; i < lump_list.size(); i++ )
934 [ + - ][ + - ]: 44 : lump_list.next(i)->get_shells( result_list );
[ + - ]
935 : 22 : }
936 : :
937 : 22 : void FacetBody::get_surfaces( DLIList<FacetSurface*>& result_list )
938 : : {
939 [ + - ]: 22 : DLIList<FacetShell*> shell_list;
940 [ + - ][ + - ]: 44 : DLIList<FacetSurface*> tmp_list;
941 [ + - ]: 22 : get_shells(shell_list);
942 [ + - ]: 22 : shell_list.reset();
943 [ + - ][ + + ]: 44 : for ( int i = 0; i < shell_list.size(); i++ )
944 : : {
945 [ + - ]: 22 : tmp_list.clean_out();
946 [ + - ][ + - ]: 22 : shell_list.next(i)->get_surfaces( tmp_list );
947 [ + - ]: 22 : result_list.merge_unique( tmp_list );
948 [ + - ]: 22 : }
949 : 22 : }
950 : :
951 : 0 : void FacetBody::get_loops( DLIList<FacetLoop*>& result_list )
952 : : {
953 [ # # ]: 0 : DLIList<FacetSurface*> surface_list;
954 [ # # ]: 0 : get_surfaces( surface_list );
955 [ # # ]: 0 : surface_list.reset();
956 [ # # ][ # # ]: 0 : for ( int i = 0; i < surface_list.size(); i++ )
957 [ # # ][ # # ]: 0 : surface_list.next(i)->get_loops( result_list );
[ # # ]
958 : 0 : }
959 : :
960 : 11 : void FacetBody::get_coedges( DLIList<FacetCoEdge*>& result_list )
961 : : {
962 [ + - ]: 11 : DLIList<FacetSurface*> surface_list;
963 [ + - ]: 11 : get_surfaces( surface_list );
964 [ + - ]: 11 : surface_list.reset();
965 [ + - ][ + + ]: 77 : for ( int i = 0; i < surface_list.size(); i++ )
966 [ + - ][ + - ]: 77 : surface_list.next(i)->get_coedges( result_list );
[ + - ]
967 : 11 : }
968 : :
969 : 11 : void FacetBody::get_curves( DLIList<FacetCurve*>& result_list )
970 : : {
971 [ + - ]: 11 : DLIList<FacetCoEdge*> coedge_list;
972 [ + - ]: 11 : get_coedges( coedge_list );
973 [ + - ]: 11 : coedge_list.reset();
974 [ + - ][ + + ]: 275 : for ( int i = coedge_list.size(); i--; )
975 : : {
976 [ + - ]: 264 : FacetCoEdge* coedge = coedge_list.get_and_step();
977 [ + - ][ - + ]: 264 : FacetCurve* curve = dynamic_cast<FacetCurve*>(coedge->curve());
978 [ + - ]: 264 : if (curve)
979 [ + - ]: 264 : result_list.append_unique(curve);
980 [ + - ]: 11 : }
981 : 11 : }
982 : :
983 : 11 : void FacetBody::get_points( DLIList<FacetPoint*>& result_list )
984 : : {
985 [ + - ]: 11 : DLIList<FacetCurve*> curve_list;
986 [ + - ]: 11 : get_curves( curve_list );
987 [ + - ]: 11 : curve_list.reset();
988 [ + - ][ + + ]: 143 : for ( int i = curve_list.size(); i--; )
989 : : {
990 [ + - ]: 132 : FacetCurve* curve = curve_list.get_and_step();
991 [ + - ][ - + ]: 132 : FacetPoint* point = dynamic_cast<FacetPoint*>(curve->start_point());
992 [ + - ]: 132 : if (point)
993 [ + - ]: 132 : result_list.append_unique(point);
994 [ + - ][ - + ]: 132 : point = dynamic_cast<FacetPoint*>(curve->end_point());
995 [ + - ]: 132 : if (point)
996 [ + - ]: 132 : result_list.append_unique(point);
997 [ + - ]: 11 : }
998 : 11 : }
999 : :
1000 : 0 : void FacetBody::add_lump( FacetLump *lump_to_add )
1001 : : {
1002 : 0 : Lump* lump = dynamic_cast<Lump*>(lump_to_add);
1003 [ # # ]: 0 : if (lump)
1004 : : {
1005 [ # # ]: 0 : lump_to_add->add_body(this);
1006 [ # # ]: 0 : myLumps.append( lump );
1007 : : }
1008 : 0 : }
1009 : :
1010 : 0 : void FacetBody::remove_lump( FacetLump *lump_to_remove )
1011 : : {
1012 : 0 : FacetLump* lump = dynamic_cast<FacetLump*>(lump_to_remove);
1013 [ # # ]: 0 : if (lump)
1014 : : {
1015 [ # # ]: 0 : assert(lump_to_remove->get_body() == this);
1016 : 0 : lump_to_remove->remove_body();
1017 [ # # ]: 0 : myLumps.remove( lump );
1018 : : }
1019 : 0 : }
1020 : :
1021 : :
1022 : : //-------------------------------------------------------------------------
1023 : : // Purpose : Tear down topology
1024 : : //
1025 : : // Special Notes :
1026 : : //
1027 : : // Creator : Jason Kraftcheck
1028 : : //
1029 : : // Creation Date : 09/29/03
1030 : : //-------------------------------------------------------------------------
1031 : 0 : void FacetBody::disconnect_all_lumps()
1032 : : {
1033 : 0 : myLumps.reset();
1034 [ # # ]: 0 : for (int i = myLumps.size(); i--; )
1035 : : {
1036 : 0 : Lump* sm_ptr = myLumps.get_and_step();
1037 [ # # ]: 0 : FacetLump* lump = dynamic_cast<FacetLump*>(sm_ptr);
1038 [ # # ]: 0 : if (lump)
1039 : : {
1040 [ # # ]: 0 : assert(lump->get_body() == this);
1041 : 0 : lump->remove_body();
1042 : : }
1043 : : }
1044 : 0 : myLumps.clean_out();
1045 : 0 : }
1046 : :
1047 : : //-------------------------------------------------------------------------
1048 : : // Purpose : Find centroid
1049 : : //
1050 : : // Special Notes :
1051 : : //
1052 : : // Creator : Jason Kraftcheck
1053 : : //
1054 : : // Creation Date : 05/10/04
1055 : : //-------------------------------------------------------------------------
1056 : 0 : CubitStatus FacetBody::mass_properties( CubitVector& centroid,
1057 : : double& volume )
1058 : : {
1059 [ # # ]: 0 : centroid.set( 0.0, 0.0, 0.0 );
1060 : 0 : volume = 0.0;
1061 : :
1062 [ # # ][ # # ]: 0 : DLIList<FacetLump*> lumps (myLumps.size());
1063 [ # # ][ # # ]: 0 : CAST_LIST( myLumps, lumps, FacetLump );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1064 [ # # ][ # # ]: 0 : assert( myLumps.size() == lumps.size() );
[ # # ]
1065 [ # # ][ # # ]: 0 : for (int i = lumps.size(); i--; )
1066 : : {
1067 [ # # ]: 0 : CubitVector cent;
1068 : : double vol;
1069 [ # # ][ # # ]: 0 : if (CUBIT_SUCCESS != lumps.get_and_step()->mass_properties(cent,vol))
[ # # ]
1070 : 0 : return CUBIT_FAILURE;
1071 [ # # ][ # # ]: 0 : centroid += vol*cent;
1072 : 0 : volume += vol;
1073 : : }
1074 [ # # ]: 0 : if (volume > CUBIT_RESABS)
1075 : : {
1076 [ # # ]: 0 : centroid /= volume;
1077 : : }
1078 : : else
1079 : : {
1080 [ # # ]: 0 : centroid.set( 0.0, 0.0, 0.0 );
1081 : 0 : volume = 0.0;
1082 : : }
1083 : :
1084 [ # # ]: 0 : return CUBIT_SUCCESS;
1085 : : }
1086 : :
1087 : : //-------------------------------------------------------------------------
1088 : : // Purpose : Used to be FacetQueryEngine::is_point_in_body
1089 : : //
1090 : : // Special Notes :
1091 : : //
1092 : : // Creator : Jason Kraftcheck
1093 : : //
1094 : : // Creation Date : 05/10/04
1095 : : //-------------------------------------------------------------------------
1096 : 0 : CubitPointContainment FacetBody::point_containment( const CubitVector &point, double tolerance )
1097 : : {
1098 : : CubitPointContainment pc_value;
1099 : : FacetLump *facet_lump;
1100 : :
1101 : : int i;
1102 [ # # ]: 0 : for(i=myLumps.size(); i--;)
1103 : : {
1104 [ # # ]: 0 : facet_lump = dynamic_cast<FacetLump*>(myLumps.get_and_step());
1105 : 0 : pc_value = facet_lump->point_containment( point, tolerance );
1106 [ # # ]: 0 : if( pc_value == CUBIT_PNT_INSIDE )
1107 : 0 : return CUBIT_PNT_INSIDE;
1108 [ # # ]: 0 : else if( pc_value == CUBIT_PNT_BOUNDARY )
1109 : 0 : return CUBIT_PNT_BOUNDARY;
1110 : : }
1111 : :
1112 : 0 : return CUBIT_PNT_OUTSIDE;
1113 [ + - ][ + - ]: 6540 : }
1114 : :
1115 : :
|
