Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : FacetLump.cpp
3 : : //
4 : : // Purpose :
5 : : //
6 : : // Creator : David White
7 : : //
8 : : // Creation Date : 7/18/2000
9 : : //
10 : : //-------------------------------------------------------------------------
11 : :
12 : : // ********** BEGIN STANDARD INCLUDES **********
13 : : #include <assert.h>
14 : : // ********** END STANDARD INCLUDES **********
15 : :
16 : :
17 : : // ********** BEGIN CUBIT INCLUDES **********
18 : : #include "FacetQueryEngine.hpp"
19 : : #include "FacetLump.hpp"
20 : : #include "CastTo.hpp"
21 : : #include "Surface.hpp"
22 : : #include "DLIList.hpp"
23 : : #include "CubitFacet.hpp"
24 : : #include "CubitPoint.hpp"
25 : : #include "CubitVector.hpp"
26 : : #include "CubitString.hpp"
27 : : #include "ShellSM.hpp"
28 : : #include "BodySM.hpp"
29 : : #include "Body.hpp"
30 : :
31 : : #include "FacetBody.hpp"
32 : : #include "FacetShell.hpp"
33 : : #include "FacetSurface.hpp"
34 : : #include "FacetLoop.hpp"
35 : : #include "FacetCoEdge.hpp"
36 : : #include "FacetCurve.hpp"
37 : : #include "FacetPoint.hpp"
38 : :
39 : : // ********** END CUBIT INCLUDES **********
40 : :
41 : : // ********** BEGIN FORWARD DECLARATIONS **********
42 : : class RefVolume;
43 : : // ********** END FORWARD DECLARATIONS **********
44 : :
45 : : // ********** BEGIN STATIC DECLARATIONS **********
46 : : // ********** END STATIC DECLARATIONS **********
47 : :
48 : : // ********** BEGIN PUBLIC FUNCTIONS **********
49 : :
50 : : //-------------------------------------------------------------------------
51 : : // Purpose : The constructor with a pointer to the owning shells and body.
52 : : //
53 : : // Special Notes :
54 : : //
55 : : //-------------------------------------------------------------------------
56 : 99 : FacetLump::FacetLump(DLIList<ShellSM*> &shells,
57 [ + - ][ + - ]: 99 : BodySM *body_ptr )
58 : : {
59 : 99 : myBodyPtr = body_ptr;
60 [ + - ]: 99 : myShells += shells;
61 : 99 : }
62 : :
63 : :
64 [ # # ][ # # ]: 0 : FacetLump::~FacetLump()
65 [ # # ]: 0 : {}
66 : :
67 : : //-------------------------------------------------------------------------
68 : : // Purpose : The purpose of this function is to append a
69 : : // attribute to the GE. The name is attached to the
70 : : // underlying solid model entity this one points to.
71 : : //
72 : : //
73 : : // Special Notes :
74 : : //
75 : : // Creator : Malcolm J. Panthaki
76 : : //
77 : : // Creation Date : 11/21/96
78 : : //-------------------------------------------------------------------------
79 : 22 : void FacetLump::append_simple_attribute_virt(const CubitSimpleAttrib &csa)
80 : 22 : { attribSet.append_attribute(csa); }
81 : :
82 : : //-------------------------------------------------------------------------
83 : : // Purpose : The purpose of this function is to remove a simple
84 : : // attribute attached to this geometry entity. The name is
85 : : // removed from the underlying BODY this points to.
86 : : //
87 : : // Special Notes :
88 : : //
89 : : // Creator : David R. White
90 : : //
91 : : // Creation Date : 03/18/97
92 : : //-------------------------------------------------------------------------
93 : 286 : void FacetLump::remove_simple_attribute_virt(const CubitSimpleAttrib &csa )
94 : 286 : { attribSet.remove_attribute(csa); }
95 : :
96 : : //-------------------------------------------------------------------------
97 : : // Purpose : The purpose of this function is to remove all simple
98 : : // attributes attached to this geometry entity. Also
99 : : // removes lingering GTC attributes.
100 : : //
101 : : //
102 : : // Special Notes :
103 : : //
104 : : // Creator : Greg Nielson
105 : : //
106 : : // Creation Date : 07/10/98
107 : : //-------------------------------------------------------------------------
108 : 143 : void FacetLump::remove_all_simple_attribute_virt()
109 : 143 : { attribSet.remove_all_attributes(); }
110 : :
111 : : //-------------------------------------------------------------------------
112 : : // Purpose : The purpose of this function is to get the
113 : : // attributes attached to this geometry entity. The name is
114 : : // attached to the underlying BODY this points to.
115 : : //
116 : : // Special Notes :
117 : : //
118 : : //-------------------------------------------------------------------------
119 : 99 : CubitStatus FacetLump::get_simple_attribute(DLIList<CubitSimpleAttrib>& csa_list)
120 : 99 : { return attribSet.get_attributes( csa_list ); }
121 : :
122 : 44 : CubitStatus FacetLump::get_simple_attribute( const CubitString& name,
123 : : DLIList<CubitSimpleAttrib>& csa_list )
124 : 44 : { return attribSet.get_attributes( name, csa_list ); }
125 : :
126 : 66 : CubitStatus FacetLump::save_attribs( FILE *file_ptr )
127 : 66 : { return attribSet.save_attributes( file_ptr ); }
128 : :
129 : 22 : CubitStatus FacetLump::restore_attribs( FILE *file_ptr, unsigned int endian )
130 : 22 : { return attribSet.restore_attributes( file_ptr, endian ); }
131 : :
132 : :
133 : :
134 : :
135 : : //-------------------------------------------------------------------------
136 : : // Purpose : Get the bounding box of the object.
137 : : //
138 : : // Special Notes :
139 : : //
140 : : //-------------------------------------------------------------------------
141 : 0 : CubitBox FacetLump::bounding_box() const
142 : : {
143 [ # # ][ # # ]: 0 : CubitBox my_box, temp_box;
[ # # ]
144 [ # # ][ # # ]: 0 : DLIList<FacetSurface*> surfaces;
145 : : int ii;
146 [ # # ]: 0 : const_cast<FacetLump*>(this)->get_surfaces(surfaces);
147 [ # # ][ # # ]: 0 : if (surfaces.size() > 0)
148 : : {
149 [ # # ]: 0 : Surface* surface = surfaces.get_and_step();
150 [ # # ][ # # ]: 0 : my_box = surface->bounding_box();
[ # # ]
151 [ # # ][ # # ]: 0 : for ( ii = surfaces.size(); ii > 1; ii-- )
152 : : {
153 [ # # ]: 0 : surface = surfaces.get_and_step();
154 [ # # ][ # # ]: 0 : temp_box = surface->bounding_box();
[ # # ]
155 : : //unite the boxes..
156 [ # # ]: 0 : my_box |= temp_box;
157 : : }
158 : : }
159 : 0 : return my_box;
160 : : }
161 : :
162 : : //-------------------------------------------------------------------------
163 : : // Purpose : Get geometry modeling engine: FacetGeometryEngine
164 : : //
165 : : // Special Notes :
166 : : //
167 : : //-------------------------------------------------------------------------
168 : : GeometryQueryEngine*
169 : 0 : FacetLump::get_geometry_query_engine() const
170 : : {
171 : 0 : return FacetQueryEngine::instance();
172 : : }
173 : :
174 : : //-------------------------------------------------------------------------
175 : : // Purpose : Returns the volume of the Lump
176 : : //
177 : : // Special Notes :
178 : : //
179 : : // Creator :
180 : : //
181 : : // Creation Date :
182 : : //-------------------------------------------------------------------------
183 : 0 : double FacetLump::measure()
184 : : {
185 [ # # ]: 0 : DLIList<CubitFacet*> bounding_facets;
186 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> bounding_points;
187 [ # # ][ # # ]: 0 : DLIList<FacetSurface*> surfaces;
188 : : Surface *curr_surface;
189 : : FacetSurface *facet_surface;
190 : : //if this is a sheet body... return 0.0
191 : :
192 : : //Body *tmp_body = CAST_TO(myBodyPtr->topology_entity(), Body);
193 [ # # ][ # # ]: 0 : if( is_sheet() )
194 : 0 : return 0.0;
195 : :
196 : : int ii;
197 [ # # ]: 0 : get_surfaces(surfaces);
198 [ # # ][ # # ]: 0 : if (surfaces.size() > 0)
199 : : {
200 [ # # ][ # # ]: 0 : for ( ii = surfaces.size(); ii > 0; ii-- )
201 : : {
202 [ # # ]: 0 : curr_surface = surfaces.get_and_step();
203 [ # # ]: 0 : facet_surface = CAST_TO(curr_surface, FacetSurface);
204 [ # # ]: 0 : if ( facet_surface == NULL )
205 : : {
206 [ # # ][ # # ]: 0 : PRINT_ERROR("Facet lump has surfaces that aren't facets?");
[ # # ][ # # ]
207 : 0 : return 1;
208 : : }
209 [ # # ]: 0 : facet_surface->get_my_facets(bounding_facets, bounding_points);
210 : : }
211 : : }
212 : 0 : double volume, curr_facet_area, summation = 0.0;
213 : : CubitFacet *curr_facet;
214 [ # # ][ # # ]: 0 : CubitVector normal_of_curr_facet, vector_of_point;
215 : : CubitPoint *point_1, *point_2, *point_3;
216 : :
217 [ # # ][ # # ]: 0 : for( int jj = bounding_facets.size(); jj > 0; jj-- )
218 : : {
219 [ # # ]: 0 : curr_facet = bounding_facets.get_and_step();
220 [ # # ]: 0 : curr_facet_area = curr_facet->area(); // Current facet's area
221 : :
222 [ # # ][ # # ]: 0 : normal_of_curr_facet = curr_facet->normal(); // Current facet's normal
223 : :
224 [ # # ]: 0 : curr_facet->points(point_1, point_2, point_3); // Current facet's points
225 : :
226 [ # # ][ # # ]: 0 : vector_of_point = point_1->coordinates(); // One point's vector
227 : :
228 [ # # ]: 0 : summation += ( double(vector_of_point % normal_of_curr_facet) * curr_facet_area);
229 : : }
230 : :
231 : 0 : volume = summation / 3;
232 : :
233 [ # # ]: 0 : return volume;
234 : : }
235 : 22 : void FacetLump::get_parents_virt(DLIList<TopologyBridge*> &bodies)
236 : : {
237 [ + - ]: 22 : if (myBodyPtr != NULL )
238 [ + - ]: 22 : bodies.append_unique(myBodyPtr);
239 : 22 : }
240 : :
241 : 352 : void FacetLump::get_children_virt(DLIList<TopologyBridge*> &shellsms)
242 : : {
243 : : int ii;
244 [ + + ]: 704 : for ( ii = myShells.size(); ii > 0; ii-- )
245 : : {
246 [ + - ]: 352 : shellsms.append_unique(myShells.get_and_step());
247 : : }
248 : 352 : }
249 : :
250 : 0 : void FacetLump::get_bodies( DLIList<FacetBody*>& result_list )
251 : : {
252 [ # # ]: 0 : FacetBody* body = dynamic_cast<FacetBody*>(myBodyPtr);
253 [ # # ]: 0 : if (body)
254 [ # # ]: 0 : result_list.append(body);
255 : 0 : }
256 : :
257 : 154 : void FacetLump::get_shells( DLIList<FacetShell*>& result_list )
258 : : {
259 : 154 : myShells.reset();
260 [ + + ]: 308 : for ( int i = 0; i < myShells.size(); i++ )
261 [ + - ][ - + ]: 154 : if ( FacetShell* shell = dynamic_cast<FacetShell*>(myShells.next(i)) )
[ + - ]
262 [ + - ]: 154 : result_list.append(shell);
263 : 154 : }
264 : :
265 : 0 : void FacetLump::get_surfaces( DLIList<FacetSurface*>& result_list )
266 : : {
267 [ # # ]: 0 : DLIList<FacetShell*> shell_list;
268 [ # # ][ # # ]: 0 : DLIList<FacetSurface*> tmp_list;
269 [ # # ]: 0 : get_shells(shell_list);
270 [ # # ]: 0 : shell_list.reset();
271 [ # # ][ # # ]: 0 : for ( int i = 0; i < shell_list.size(); i++ )
272 : : {
273 [ # # ]: 0 : tmp_list.clean_out();
274 [ # # ][ # # ]: 0 : shell_list.next(i)->get_surfaces( tmp_list );
275 [ # # ]: 0 : result_list.merge_unique( tmp_list );
276 [ # # ]: 0 : }
277 : 0 : }
278 : :
279 : :
280 : 0 : void FacetLump::get_coedges( DLIList<FacetCoEdge*>& result_list )
281 : : {
282 [ # # ]: 0 : DLIList<FacetSurface*> surface_list;
283 [ # # ]: 0 : get_surfaces( surface_list );
284 [ # # ]: 0 : surface_list.reset();
285 [ # # ][ # # ]: 0 : for ( int i = 0; i < surface_list.size(); i++ )
286 [ # # ][ # # ]: 0 : surface_list.next(i)->get_coedges( result_list );
[ # # ]
287 : 0 : }
288 : :
289 : 0 : void FacetLump::get_curves( DLIList<FacetCurve*>& result_list )
290 : : {
291 [ # # ]: 0 : DLIList<FacetCoEdge*> coedge_list;
292 [ # # ]: 0 : get_coedges( coedge_list );
293 [ # # ]: 0 : coedge_list.reset();
294 [ # # ][ # # ]: 0 : for ( int i = coedge_list.size(); i--; )
295 : : {
296 [ # # ]: 0 : FacetCoEdge* coedge = coedge_list.get_and_step();
297 [ # # ][ # # ]: 0 : FacetCurve* curve = dynamic_cast<FacetCurve*>(coedge->curve());
298 [ # # ]: 0 : if (curve)
299 [ # # ]: 0 : result_list.append_unique(curve);
300 [ # # ]: 0 : }
301 : 0 : }
302 : :
303 : :
304 : 0 : void FacetLump::add_shell( FacetShell *shell )
305 : : {
306 : : ShellSM* sm_ptr;
307 : 0 : sm_ptr = dynamic_cast<ShellSM*>(shell);
308 : :
309 [ # # ]: 0 : if( sm_ptr )
310 [ # # ]: 0 : myShells.append( sm_ptr );
311 : :
312 [ # # ]: 0 : shell->add_lump( this );
313 : 0 : }
314 : :
315 : 0 : void FacetLump::remove_shell( FacetShell *shell )
316 : : {
317 : : ShellSM* sm_ptr;
318 : 0 : sm_ptr = dynamic_cast<ShellSM*>(shell);
319 : :
320 [ # # ]: 0 : if( sm_ptr )
321 [ # # ]: 0 : myShells.remove( sm_ptr );
322 : :
323 [ # # ]: 0 : shell->remove_lump();
324 : 0 : }
325 : :
326 : : //-------------------------------------------------------------------------
327 : : // Purpose : Tear down topology
328 : : //
329 : : // Special Notes :
330 : : //
331 : : // Creator : Jason Kraftcheck
332 : : //
333 : : // Creation Date : 09/29/03
334 : : //-------------------------------------------------------------------------
335 : 0 : void FacetLump::disconnect_all_shells()
336 : : {
337 : 0 : myShells.reset();
338 [ # # ]: 0 : for (int i = myShells.size(); i--; )
339 : : {
340 : 0 : ShellSM* sm_ptr = myShells.get_and_step();
341 [ # # ]: 0 : FacetShell* shell = dynamic_cast<FacetShell*>(sm_ptr);
342 [ # # ]: 0 : if (shell)
343 : : {
344 [ # # ]: 0 : assert(shell->get_lump() == this);
345 : 0 : shell->remove_lump();
346 : : }
347 : : }
348 : 0 : myShells.clean_out();
349 : 0 : }
350 : :
351 : : //-------------------------------------------------------------------------
352 : : // Purpose : Calculate centroid
353 : : //
354 : : // Special Notes :
355 : : //
356 : : // Creator : Jason Kraftcheck
357 : : //
358 : : // Creation Date : 05/12/04
359 : : //-------------------------------------------------------------------------
360 : : #include "GfxDebug.hpp"
361 : 0 : CubitStatus FacetLump::mass_properties( CubitVector& centroid, double& volume )
362 : : {
363 : : int i;
364 : :
365 [ # # ][ # # ]: 0 : DLIList<FacetShell*> shells( myShells.size() );
366 [ # # ][ # # ]: 0 : CAST_LIST( myShells, shells, FacetShell );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
367 [ # # ][ # # ]: 0 : assert( myShells.size() == shells.size() );
[ # # ]
368 : :
369 [ # # ][ # # ]: 0 : DLIList<FacetSurface*> surfaces;
370 [ # # ][ # # ]: 0 : DLIList<FacetShell*> surf_shells;
371 [ # # ]: 0 : get_surfaces( surfaces );
372 : :
373 [ # # ][ # # ]: 0 : DLIList<CubitFacet*> facets, surf_facets;
[ # # ][ # # ]
374 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> junk;
375 [ # # ][ # # ]: 0 : DLIList<CubitSense> senses;
376 [ # # ][ # # ]: 0 : for (i = surfaces.size(); i--; )
377 : : {
378 [ # # ]: 0 : FacetSurface* surf = surfaces.step_and_get();
379 [ # # ]: 0 : surf_shells.clean_out();
380 [ # # ]: 0 : surf->get_shells( surf_shells );
381 [ # # ]: 0 : surf_shells.intersect( shells );
382 [ # # ][ # # ]: 0 : assert( surf_shells.size() );
383 [ # # ][ # # ]: 0 : CubitSense sense = surf->get_shell_sense( surf_shells.get() );
384 [ # # ][ # # ]: 0 : if (surf_shells.size() == 1 && CUBIT_UNKNOWN != sense)
[ # # ][ # # ]
385 : : {
386 [ # # ]: 0 : surf_facets.clean_out();
387 [ # # ]: 0 : junk.clean_out();
388 [ # # ]: 0 : surf->get_my_facets( surf_facets, junk );
389 [ # # ]: 0 : facets += surf_facets;
390 : :
391 [ # # ][ # # ]: 0 : for (int j = surf_facets.size(); j--; )
392 [ # # ]: 0 : senses.append(sense);
393 : : }
394 : : }
395 : :
396 [ # # ][ # # ]: 0 : const CubitVector p0 = bounding_box().center();
[ # # ]
397 [ # # ][ # # ]: 0 : CubitVector p1, p2, p3, normal;
[ # # ][ # # ]
398 [ # # ]: 0 : centroid.set( 0.0, 0.0, 0.0 );
399 : 0 : volume = 0.0;
400 : :
401 [ # # ]: 0 : facets.reset();
402 [ # # ]: 0 : senses.reset();
403 [ # # ][ # # ]: 0 : for (i = facets.size(); i--; )
404 : : {
405 [ # # ]: 0 : CubitFacet* facet = facets.get_and_step();
406 [ # # ]: 0 : CubitSense sense = senses.get_and_step();
407 [ # # ][ # # ]: 0 : p1 = facet->point(0)->coordinates();
[ # # ]
408 [ # # ][ # # ]: 0 : p2 = facet->point(1)->coordinates();
[ # # ]
409 [ # # ][ # # ]: 0 : p3 = facet->point(2)->coordinates();
[ # # ]
410 [ # # ][ # # ]: 0 : normal = (p3 - p1) * (p2 - p1);
[ # # ][ # # ]
411 : :
412 [ # # ]: 0 : double two_area = normal.length();
413 [ # # ]: 0 : if (two_area > CUBIT_RESABS )
414 : : {
415 [ # # ]: 0 : if (CUBIT_REVERSED == sense)
416 [ # # ][ # # ]: 0 : normal = -normal;
417 : :
418 [ # # ]: 0 : normal /= two_area;
419 : :
420 [ # # ][ # # ]: 0 : double height = normal % (p0 - p1);
421 : 0 : double vol = two_area * height;
422 : :
423 : 0 : volume += vol;
424 [ # # ][ # # ]: 0 : centroid += vol * (p0 + p1 + p2 + p3);
[ # # ][ # # ]
[ # # ]
425 : : }
426 : : }
427 : :
428 [ # # ]: 0 : if (volume > CUBIT_RESABS)
429 [ # # ]: 0 : centroid /= 4.0 * volume;
430 : 0 : volume /= 6.0;
431 [ # # ]: 0 : return CUBIT_SUCCESS;
432 : : }
433 : :
434 : 0 : CubitPointContainment FacetLump::point_containment( const CubitVector &point,
435 : : double tolerance )
436 : : {
437 : : CubitPointContainment pc_value;
438 : : FacetShell *facet_shell;
439 : :
440 : : int i;
441 [ # # ]: 0 : for(i=myShells.size(); i--;)
442 : : {
443 [ # # ]: 0 : facet_shell = dynamic_cast<FacetShell*>(myShells.get_and_step());
444 : 0 : pc_value = facet_shell->point_containment( point, tolerance );
445 [ # # ]: 0 : if( pc_value == CUBIT_PNT_OUTSIDE )
446 : 0 : return CUBIT_PNT_OUTSIDE;
447 [ # # ]: 0 : else if( pc_value == CUBIT_PNT_BOUNDARY )
448 : 0 : return CUBIT_PNT_BOUNDARY;
449 : : }
450 : :
451 : 0 : return CUBIT_PNT_INSIDE;
452 : :
453 : : }
454 : :
455 : : //Determine whether this lump is really a sheet (that is, sheet-body).
456 : 0 : CubitBoolean FacetLump::is_sheet( )
457 : : {
458 : : FacetShell *facet_shell;
459 : : int i;
460 : : //if any of the shells are sheets, the body is assume to be a sheet
461 : : // for our purposes...
462 [ # # ]: 0 : for(i=myShells.size(); i--;)
463 : : {
464 [ # # ]: 0 : facet_shell = dynamic_cast<FacetShell*>(myShells.get_and_step());
465 [ # # ]: 0 : if(facet_shell->is_sheet()){
466 : 0 : return CUBIT_TRUE;
467 : : }
468 : : }
469 : 0 : return CUBIT_FALSE;
470 [ + - ][ + - ]: 6540 : }
471 : :
|
