Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : OCCBody.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 : : // ********** BEGIN CUBIT INCLUDES **********
19 : : #include "CubitDefines.h"
20 : : #include "CubitString.hpp"
21 : : #include "CastTo.hpp"
22 : : #include "BodySM.hpp"
23 : : #include "Body.hpp"
24 : : #include "OCCBody.hpp"
25 : : #include "CubitSimpleAttrib.hpp"
26 : : #include "OCCQueryEngine.hpp"
27 : : #include "DLIList.hpp"
28 : : #include "Surface.hpp"
29 : : #include "OCCSurface.hpp"
30 : : #include "CubitTransformMatrix.hpp"
31 : : #include "OCCPoint.hpp"
32 : : #include "OCCCurve.hpp"
33 : : #include "OCCCoEdge.hpp"
34 : : #include "OCCLoop.hpp"
35 : : #include "OCCShell.hpp"
36 : : #include "OCCLump.hpp"
37 : : #include "OCCModifyEngine.hpp"
38 : : #include "OCCAttribSet.hpp"
39 : :
40 : : #include <TopExp.hxx>
41 : : #include <TopTools_IndexedMapOfShape.hxx>
42 : : #include "BRepBuilderAPI_ModifyShape.hxx"
43 : : #include "BRepBuilderAPI_Transform.hxx"
44 : : #include "BRepBuilderAPI_GTransform.hxx"
45 : : #include "TopTools_DataMapOfShapeInteger.hxx"
46 : : #include "TopTools_ListIteratorOfListOfShape.hxx"
47 : : #include "gp_Ax1.hxx"
48 : : #include "gp_Ax2.hxx"
49 : : #include "gp_GTrsf.hxx"
50 : : #include "Bnd_Box.hxx"
51 : : #include "BRepBndLib.hxx"
52 : : #include "TopExp_Explorer.hxx"
53 : : #include "BRep_Builder.hxx"
54 : : #include "TopoDS.hxx"
55 : : #include "GProp_GProps.hxx"
56 : : #include "BRepGProp.hxx"
57 : : #include "Standard_Boolean.hxx"
58 : : #include "LocOpe_SplitShape.hxx"
59 : : #include "TopoDS_Compound.hxx"
60 : : //-------------------------------------------------------------------------
61 : : // Purpose : A constructor with a list of lumps that are attached.
62 : : //
63 : : // Special Notes :
64 : : //
65 : : //-------------------------------------------------------------------------
66 : 2650 : OCCBody::OCCBody(TopoDS_Compound *theShape,
67 [ + - ][ + - ]: 2650 : OCCSurface* surface, OCCShell* shell, Lump* lump)
[ + - ][ + - ]
[ + - ]
68 : : {
69 : 2650 : myTopoDSShape = theShape;
70 [ + + ]: 2650 : if (surface != NULL)
71 [ + - ]: 619 : mySheetSurfaces.append(surface);
72 [ - + ]: 2650 : if( shell != NULL)
73 [ # # ]: 0 : myShells.append(shell);
74 [ + + ]: 2650 : if (lump != NULL)
75 [ + - ]: 1934 : myLumps.append(lump);
76 [ + - ]: 2650 : update_bounding_box();
77 [ + + ][ + - ]: 2650 : if (myTopoDSShape && !myTopoDSShape->IsNull())
[ + - ][ + + ]
78 [ + - ][ - + ]: 97 : assert(myTopoDSShape->ShapeType() == TopAbs_COMPOUND);
79 : 2650 : }
80 : :
81 : 5565 : TopoDS_Compound* OCCBody::get_TopoDS_Shape()
82 : : {
83 [ + + ][ + - ]: 5565 : if (myTopoDSShape && !myTopoDSShape->IsNull())
[ + + ]
84 : : {
85 [ - + ]: 183 : assert(myTopoDSShape->ShapeType() == TopAbs_COMPOUND);
86 : 183 : return myTopoDSShape;
87 : : }
88 : 5382 : return (TopoDS_Compound*)NULL;
89 : : }
90 : :
91 : 4715 : void OCCBody::get_TopoDS_Shape(TopoDS_Shape *& shape)
92 : : {
93 [ + + ][ + + ]: 4715 : if (myTopoDSShape && !myTopoDSShape->IsNull())
[ + + ]
94 : : {
95 [ - + ]: 388 : assert(myTopoDSShape->ShapeType() == TopAbs_COMPOUND);
96 : 388 : shape = myTopoDSShape;
97 : : }
98 : : else
99 : : {
100 [ + - ]: 4327 : DLIList<Lump*> lumps = this->lumps();
101 [ + - ][ + - ]: 8654 : DLIList<OCCShell*> shells = this->shells();
102 [ + - ][ + - ]: 8654 : DLIList<OCCSurface*> surfaces = this->my_sheet_surfaces();
103 [ + - ][ + - ]: 4327 : if(lumps.size() + shells.size() + surfaces.size() == 1)
[ + - ][ + + ]
104 : : {
105 [ + - ][ + + ]: 4239 : if(lumps.size() == 1)
106 : : {
107 [ + - ][ - + ]: 4228 : OCCLump* lump = CAST_TO(lumps.get(), OCCLump);
108 [ - + ]: 4228 : assert(lump != NULL);
109 [ + - ]: 4228 : shape = CAST_TO(lump, OCCLump)->get_TopoDS_Solid();
110 : : }
111 [ + - ][ - + ]: 11 : else if(shells.size() == 1)
112 [ # # ][ # # ]: 0 : shape = shells.get()->get_TopoDS_Shell();
113 : : else
114 [ + - ][ + - ]: 4239 : shape = surfaces.get()->get_TopoDS_Face();
115 : : }
116 : : else
117 [ + - ]: 4415 : shape = NULL;
118 : : }
119 : 4715 : }
120 : :
121 : 271 : void OCCBody::set_sheet_surfaces(DLIList<OCCSurface*> surfaces)
122 : : {
123 : 271 : mySheetSurfaces = surfaces;
124 : 271 : }
125 : :
126 : 271 : void OCCBody::lumps(DLIList<Lump*>& my_lumps)
127 : : {
128 : 271 : myLumps = my_lumps;
129 : 271 : }
130 : :
131 : 11 : CubitBoolean OCCBody::is_sheet_body()
132 : : {
133 [ + - ][ + - ]: 11 : if(myLumps.size() == 0 && myShells.size() == 0 && mySheetSurfaces.size() == 1)
[ + - ][ + - ]
134 : 11 : return CUBIT_TRUE;
135 : 0 : return CUBIT_FALSE;
136 : : }
137 : :
138 : 0 : void OCCBody::set_TopoDS_Shape( TopoDS_Compound& theshape)
139 : : {
140 [ # # ]: 0 : if(!theshape.IsNull())
141 [ # # ]: 0 : assert(theshape.ShapeType() == TopAbs_COMPOUND);
142 : :
143 : : else
144 : : {
145 [ # # ][ # # ]: 0 : if(myTopoDSShape && !myTopoDSShape->IsNull())
[ # # ]
146 : 0 : myTopoDSShape->Nullify();
147 : 0 : return;
148 : : }
149 : :
150 [ # # ][ # # ]: 0 : if(myTopoDSShape && !myTopoDSShape->IsNull() && theshape.IsEqual(*myTopoDSShape))
[ # # ][ # # ]
151 : 0 : return;
152 : :
153 [ # # ][ # # ]: 0 : if (myTopoDSShape && !myTopoDSShape->IsNull() && theshape.IsPartner(*myTopoDSShape))
[ # # ][ # # ]
154 : : {
155 : 0 : myTopoDSShape->Location(theshape.Location());
156 : 0 : myTopoDSShape->Orientation(theshape.Orientation());
157 : : }
158 : :
159 : : else
160 : : {
161 [ # # ]: 0 : if(myTopoDSShape)
162 : 0 : myTopoDSShape->Nullify();
163 : 0 : *myTopoDSShape = theshape;
164 : : }
165 : : }
166 : :
167 : 0 : OCCBody::OCCBody(DLIList<Lump*>& my_lumps,
168 : : DLIList<OCCShell*>& shells,
169 [ # # ][ # # ]: 0 : DLIList<OCCSurface*>& surfaces)
[ # # ][ # # ]
[ # # ]
170 : : {
171 [ # # ]: 0 : myLumps = my_lumps;
172 [ # # ]: 0 : mySheetSurfaces = surfaces;
173 [ # # ]: 0 : myShells = shells;
174 [ # # ]: 0 : TopoDS_Compound* new_top = make_Compound(my_lumps, shells, surfaces);
175 : 0 : myTopoDSShape = new_top;
176 [ # # ][ # # ]: 0 : assert (myTopoDSShape->ShapeType() == TopAbs_COMPOUND);
177 [ # # ]: 0 : update_bounding_box();
178 : 0 : }
179 : :
180 : 0 : TopoDS_Compound* OCCBody::make_Compound(DLIList<Lump*>& my_lumps,
181 : : DLIList<OCCShell*>& shells,
182 : : DLIList<OCCSurface*>& surfaces)
183 : : {
184 : : BRep_Builder B;
185 [ # # ]: 0 : TopoDS_Compound Co;
186 [ # # ]: 0 : B.MakeCompound(Co);
187 [ # # ][ # # ]: 0 : for(int i = 0; i < my_lumps.size(); i ++)
188 : : {
189 [ # # ][ # # ]: 0 : OCCLump* lump = CAST_TO(my_lumps.get_and_step(), OCCLump);
190 [ # # ]: 0 : if(!lump)
191 : : {
192 [ # # ][ # # ]: 0 : PRINT_ERROR("Cannot create an OCC BodySM from the given lumps.\n"
[ # # ]
193 [ # # ]: 0 : "Possible incompatible geometry engines.\n");
194 : 0 : return (TopoDS_Compound *)NULL;
195 : : }
196 [ # # ]: 0 : TopoDS_Solid * solid = CAST_TO(lump, OCCLump)->get_TopoDS_Solid();
197 [ # # ]: 0 : B.Add(Co, *solid);
198 : : }
199 [ # # ][ # # ]: 0 : for(int i = 0; i < shells.size(); i ++)
200 : : {
201 [ # # ][ # # ]: 0 : TopoDS_Shell * shell = shells.get_and_step()->get_TopoDS_Shell();
202 [ # # ]: 0 : B.Add(Co, *shell);
203 : : }
204 [ # # ][ # # ]: 0 : for(int i = 0; i < surfaces.size(); i ++)
205 : : {
206 [ # # ][ # # ]: 0 : TopoDS_Face * face = surfaces.get_and_step()->get_TopoDS_Face();
207 [ # # ]: 0 : B.Add(Co, *face);
208 : : }
209 : :
210 [ # # ][ # # ]: 0 : TopoDS_Compound* new_top = new TopoDS_Compound(Co);
211 [ # # ]: 0 : return new_top;
212 : : }
213 : :
214 [ + - ][ + - ]: 4746 : OCCBody::~OCCBody()
[ + - ][ + - ]
[ + - ]
215 : : {
216 [ + + ]: 1582 : if (myTopoDSShape)
217 : : {
218 [ + - ]: 97 : myTopoDSShape->Nullify();
219 [ + - ][ + - ]: 97 : delete (TopoDS_Compound*)myTopoDSShape;
[ + - ]
220 : 97 : myTopoDSShape = NULL;
221 : : }
222 [ - + ]: 3164 : }
223 : :
224 : 3379 : GeometryQueryEngine* OCCBody::get_geometry_query_engine() const
225 : : {
226 : 3379 : return OCCQueryEngine::instance();
227 : : }
228 : :
229 : 1809 : void OCCBody::append_simple_attribute_virt(const CubitSimpleAttrib &csa)
230 : : {
231 [ + + ]: 1809 : if (myTopoDSShape != NULL)
232 : : {
233 : 140 : OCCAttribSet::append_attribute(csa, *myTopoDSShape);
234 : 140 : return;
235 : : }
236 : 1669 : csa_list.append_unique(csa);
237 : : }
238 : :
239 : 12757 : void OCCBody::remove_simple_attribute_virt(const CubitSimpleAttrib &csa)
240 : : {
241 [ + - ]: 12757 : DLIList<Lump*> my_lumps;
242 [ + - ][ + - ]: 12757 : my_lumps = lumps();
[ + - ]
243 [ + - ][ + - ]: 25514 : DLIList<OCCShell*> shells = this->shells();
[ - + ]
244 [ + - ][ + - ]: 25514 : DLIList<OCCSurface*> surfaces = this->my_sheet_surfaces();
[ - + ]
245 : :
246 [ + + ]: 12757 : if (myTopoDSShape != NULL)
247 : : {
248 [ + - ]: 355 : OCCAttribSet::remove_attribute(csa, *myTopoDSShape);
249 : 355 : return;
250 : : }
251 : :
252 [ + - ][ + + ]: 12402 : else if (my_lumps.size() == 1)
253 : : {
254 [ + - ][ - + ]: 9393 : OCCLump* lump = CAST_TO(my_lumps.get(), OCCLump);
255 [ + - ]: 9393 : TopoDS_Solid* solid = lump->get_TopoDS_Solid();
256 [ + - ]: 9393 : OCCAttribSet::remove_attribute(csa, *solid);
257 [ + - ][ + + ]: 9393 : if(!csa.isEmpty())
258 [ + - ]: 5716 : csa_list.remove(csa);
259 : : else
260 [ + - ]: 3677 : csa_list.clean_out();
261 : 9393 : return;
262 : : }
263 : :
264 [ + - ][ - + ]: 3009 : else if(shells.size() == 1)
265 : : {
266 [ # # ][ # # ]: 0 : TopoDS_Shell * shell = shells.get()->get_TopoDS_Shell();
267 [ # # ]: 0 : OCCAttribSet::remove_attribute(csa, *shell);
268 [ # # ][ # # ]: 0 : if(!csa.isEmpty())
269 [ # # ]: 0 : csa_list.remove(csa);
270 : : else
271 [ # # ]: 0 : csa_list.clean_out();
272 : 0 : return;
273 : : }
274 : :
275 [ + - ][ + - ]: 3009 : else if(surfaces.size() == 1)
276 : : {
277 [ + - ][ + - ]: 3009 : TopoDS_Face* surf = surfaces.get()->get_TopoDS_Face();
278 [ + - ]: 3009 : OCCAttribSet::remove_attribute(csa, *surf);
279 [ + - ][ + + ]: 3009 : if(!csa.isEmpty())
280 [ + - ]: 1419 : csa_list.remove(csa);
281 : : else
282 [ + - ]: 1590 : csa_list.clean_out();
283 [ + - ][ - + ]: 12757 : return;
284 : 12757 : }
285 : : }
286 : :
287 : :
288 : 5406 : void OCCBody::remove_all_simple_attribute_virt()
289 : : {
290 [ + - ]: 5406 : remove_simple_attribute_virt(CubitSimpleAttrib());
291 : 5406 : }
292 : :
293 : 3930 : CubitStatus OCCBody::get_simple_attribute(DLIList<CubitSimpleAttrib>& csas)
294 : : {
295 [ + + ]: 3930 : if (myTopoDSShape != NULL)
296 : 194 : return OCCAttribSet::get_attributes(*myTopoDSShape,csas);
297 : :
298 : : else
299 : 3736 : csas = csa_list;
300 : 3736 : return CUBIT_SUCCESS;
301 : : }
302 : :
303 : 19936 : CubitStatus OCCBody::get_simple_attribute( const CubitString& name,
304 : : DLIList<CubitSimpleAttrib>& csas )
305 : : {
306 [ + + ]: 19936 : if (myTopoDSShape != NULL)
307 : 944 : return OCCAttribSet::get_attributes( name, *myTopoDSShape, csa_list );
308 : :
309 [ + + ]: 23825 : for(int i = 0 ; i < csa_list.size(); i ++)
310 : : {
311 : 4833 : const CubitSimpleAttrib& csa = csa_list.get_and_step();
312 [ + - ]: 4833 : if(csa.string_data_list().size() > 0)
313 [ + + ]: 4833 : if (csa.string_data_list()[0] == name)
314 : 618 : csas.append(csa);
315 : : }
316 : 18992 : return CUBIT_SUCCESS;
317 : : }
318 : :
319 : 0 : CubitStatus OCCBody::get_transforms( CubitTransformMatrix &tfm )
320 : : {
321 : 0 : return CUBIT_SUCCESS;
322 : : }
323 : :
324 : :
325 : : //----------------------------------------------------------------
326 : : // Function: copy
327 : : // Description: create a new copy of the body.
328 : : // Author: sjowen
329 : : //----------------------------------------------------------------
330 : 0 : BodySM* OCCBody::copy()
331 : : {
332 : 0 : return (BodySM*)NULL;
333 : : }
334 : :
335 : : //----------------------------------------------------------------
336 : : // Function: move
337 : : // Description: translate the body and its child entities
338 : : //
339 : : // Author: Jane Hu
340 : : //----------------------------------------------------------------
341 : 766 : CubitStatus OCCBody::move(double dx, double dy, double dz)
342 : : {
343 [ + - ][ + - ]: 766 : double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance();
344 [ + + ][ + + ]: 766 : if(fabs(dx) < tol && fabs(dy) < tol && fabs(dz) < tol)
[ + + ]
345 : 55 : return CUBIT_SUCCESS;
346 : :
347 [ + - ]: 711 : gp_Vec aVec(dx, dy, dz);
348 [ + - ]: 711 : gp_Trsf aTrsf;
349 [ + - ]: 711 : aTrsf.SetTranslation(aVec);
350 : :
351 [ + - ]: 711 : BRepBuilderAPI_Transform aBRepTrsf(aTrsf);
352 : :
353 [ + - ][ + - ]: 766 : return transform(aBRepTrsf);
354 : : }
355 : :
356 : :
357 : : //----------------------------------------------------------------
358 : : // Function: rotate
359 : : // Description: rotate the body and its child entities
360 : : //
361 : : // Author: Jane Hu
362 : : //----------------------------------------------------------------
363 : 11 : CubitStatus OCCBody::rotate( double x, double y, double z,
364 : : double angle )//in radians
365 : : {
366 [ + - ]: 11 : gp_Pnt aOrigin(0,0,0);
367 [ + - ]: 11 : gp_Dir aDir(x, y, z);
368 [ + - ]: 11 : gp_Ax1 anAxis(aOrigin, aDir);
369 : :
370 : : //a is angular value of rotation in radians
371 [ + - ]: 11 : gp_Trsf aTrsf;
372 [ + - ]: 11 : aTrsf.SetRotation(anAxis, angle);
373 : :
374 [ + - ]: 11 : BRepBuilderAPI_Transform aBRepTrsf(aTrsf);
375 : :
376 [ + - ][ + - ]: 11 : return transform(aBRepTrsf);
377 : : }
378 : :
379 : : //----------------------------------------------------------------
380 : : // Function: transform
381 : : // Description: transform the body and its child entities
382 : : // use a transform matrix
383 : : //
384 : : // Author: Jane Hu
385 : : //----------------------------------------------------------------
386 : 733 : CubitStatus OCCBody::transform(BRepBuilderAPI_Transform& aBRepTrsf)
387 : : {
388 : : TopoDS_Shape * shape;
389 [ + - ]: 733 : get_TopoDS_Shape(shape);
390 [ + - ]: 733 : aBRepTrsf.Perform(*shape);
391 : :
392 [ + - ]: 733 : update_OCC_entity(&aBRepTrsf);
393 : : // calculate for bounding box
394 [ + - ]: 733 : update_bounding_box();
395 : :
396 : 733 : return CUBIT_SUCCESS;
397 : : }
398 : :
399 : : //----------------------------------------------------------------
400 : : // Function: scale
401 : : // Description: scale the body and its child entities
402 : : // use a constant scale factor
403 : : //
404 : : // Author: Jane Hu
405 : : //----------------------------------------------------------------
406 : 0 : CubitStatus OCCBody::scale(double scale_factor )
407 : : {
408 [ # # ]: 0 : gp_Trsf aTrsf;
409 [ # # ]: 0 : aTrsf.SetScaleFactor(scale_factor);
410 : :
411 [ # # ]: 0 : BRepBuilderAPI_Transform aBRepTrsf(aTrsf);
412 [ # # ]: 0 : CubitStatus stat = transform(aBRepTrsf);
413 [ # # ]: 0 : return stat;
414 : : }
415 : :
416 : : //----------------------------------------------------------------
417 : : // Function: scale
418 : : // Description: deforming transformation of the body and its child entities
419 : : // Author: Jane Hu
420 : : //----------------------------------------------------------------
421 : 11 : CubitStatus OCCBody::scale(double scale_factor_x,
422 : : double scale_factor_y,
423 : : double scale_factor_z )
424 : : {
425 [ + - ]: 11 : gp_GTrsf gTrsf;
426 [ + - ]: 11 : gTrsf.SetValue(1,1, scale_factor_x);
427 [ + - ]: 11 : gTrsf.SetValue(2,2, scale_factor_y);
428 [ + - ]: 11 : gTrsf.SetValue(3,3, scale_factor_z);
429 : :
430 [ + - ]: 11 : BRepBuilderAPI_GTransform gBRepTrsf(gTrsf);
431 : :
432 : : TopoDS_Shape * shape;
433 [ + - ]: 11 : get_TopoDS_Shape(shape);
434 [ + - ]: 11 : gBRepTrsf.Perform(*shape);
435 : :
436 [ + - ]: 11 : update_OCC_entity(&gBRepTrsf);
437 : : // calculate for bounding box
438 [ + - ]: 11 : update_bounding_box();
439 : :
440 [ + - ]: 11 : return CUBIT_SUCCESS;
441 : : }
442 : :
443 : : //----------------------------------------------------------------
444 : : // Function: reflect
445 : : // Description: reflect the body about an plane given the normal
446 : : // vector.
447 : : //
448 : : // Author: Jane Hu
449 : : //----------------------------------------------------------------
450 : 11 : CubitStatus OCCBody::reflect( double reflect_axis_x,
451 : : double reflect_axis_y,
452 : : double reflect_axis_z )
453 : : {
454 [ + - ]: 11 : gp_Pnt aOrigin(0,0,0);
455 [ + - ]: 11 : gp_Dir aDir(reflect_axis_x, reflect_axis_y,reflect_axis_z);
456 [ + - ]: 11 : gp_Ax2 anAx2(aOrigin, aDir);
457 : :
458 [ + - ]: 11 : gp_Trsf aTrsf;
459 [ + - ]: 11 : aTrsf.SetMirror(anAx2);
460 : :
461 [ + - ]: 11 : BRepBuilderAPI_Transform aBRepTrsf(aTrsf);
462 [ + - ][ + - ]: 11 : return transform(aBRepTrsf);
463 : : }
464 : :
465 : : //----------------------------------------------------------------
466 : : // Function: private function to update the core compound and
467 : : // for any movement of the body.
468 : : // Note: input shape must have the same number of Compound
469 : : // as the body's lumps number.
470 : : // Author: Jane Hu
471 : : //----------------------------------------------------------------
472 : 744 : CubitStatus OCCBody::update_OCC_entity( BRepBuilderAPI_ModifyShape *aBRepTrsf,
473 : : BRepAlgoAPI_BooleanOperation *op)
474 : : {
475 [ - + ][ # # ]: 744 : assert(aBRepTrsf != NULL || op != NULL);
476 : :
477 [ + - ]: 744 : TopoDS_Compound compsolid;
478 [ + - ][ + - ]: 1488 : TopoDS_Shape shape;
479 [ + - ][ + - ]: 744 : shape = aBRepTrsf->Shape();
480 [ + - ][ - + ]: 744 : if(aBRepTrsf && myTopoDSShape)
481 : : {
482 [ # # ][ # # ]: 0 : compsolid = TopoDS::Compound(shape);
483 : :
484 [ # # ][ # # ]: 0 : if(OCCQueryEngine::instance()->OCCMap->IsBound(*myTopoDSShape) )
[ # # ]
485 [ # # ][ # # ]: 0 : OCCQueryEngine::instance()->update_OCC_map(*myTopoDSShape, shape);
486 [ # # ][ # # ]: 0 : else if (!shape.IsEqual(*myTopoDSShape))
487 [ # # ]: 0 : set_TopoDS_Shape(compsolid);
488 : : }
489 : :
490 : : //Boolean operation works only on one lump body
491 : : //set the lumps
492 [ + - ][ + - ]: 1488 : DLIList<Lump *> lumps;
493 [ + - ][ + - ]: 744 : lumps = this->lumps();
[ + - ]
494 [ + - ][ + + ]: 1488 : for (int i = 1; i <= lumps.size(); i++)
495 : : {
496 [ + - ][ - + ]: 744 : OCCLump *lump = CAST_TO(lumps.get_and_step(), OCCLump);
497 [ + - ]: 744 : lump->update_OCC_entity(aBRepTrsf, op);
498 : : }
499 : :
500 [ + - ][ - + ]: 744 : for(int i = 0; i < mySheetSurfaces.size(); i++)
501 : : {
502 [ # # ]: 0 : OCCSurface* surface = mySheetSurfaces.get_and_step();
503 [ # # ]: 0 : surface->update_OCC_entity(aBRepTrsf, op);
504 : : }
505 [ + - ][ - + ]: 744 : for(int i = 0; i <myShells.size() ; i++)
506 : : {
507 [ # # ]: 0 : OCCShell* occ_shell = myShells.get_and_step();
508 [ # # ]: 0 : occ_shell->update_OCC_entity(aBRepTrsf,op);
509 : : }
510 : :
511 [ + - ][ + - ]: 744 : if (aBRepTrsf && !compsolid.IsNull())
[ - + ][ - + ]
512 [ # # ]: 0 : set_TopoDS_Shape(compsolid);
513 : :
514 [ + - ]: 744 : update_bounding_box();
515 : :
516 : : //unset marks.
517 [ + - ][ + - ]: 1488 : DLIList<OCCCurve*> curves;
518 [ + - ][ + - ]: 1488 : DLIList<OCCPoint*> points;
519 [ + - ]: 744 : get_all_curves(curves);
520 [ + - ]: 744 : get_all_points(points);
521 : :
522 [ + - ][ + + ]: 7442 : for(int i = 0; i < curves.size(); i++)
523 [ + - ][ + - ]: 6698 : curves.get_and_step()->set_myMarked(CUBIT_FALSE);
524 : :
525 [ + - ][ + + ]: 5340 : for(int i = 0; i < points.size(); i++)
526 [ + - ][ + - ]: 4596 : points.get_and_step()->set_myMarked(CUBIT_FALSE);
527 [ + - ]: 744 : return CUBIT_SUCCESS;
528 : : }
529 : :
530 : : //----------------------------------------------------------------
531 : : // Function: TopoDS_Shape level function to update the core Body
532 : : // for any Boolean operation of the body.
533 : : // Author: Jane Hu
534 : : //----------------------------------------------------------------
535 : 22 : CubitStatus OCCBody::update_OCC_entity(TopoDS_Shape& old_shape,
536 : : TopoDS_Shape& new_shape,
537 : : BRepBuilderAPI_MakeShape *op,
538 : : LocOpe_SplitShape* sp)
539 : : {
540 : : //set the Shells
541 [ + - ]: 22 : TopTools_IndexedMapOfShape M;
542 [ + - ]: 22 : TopExp::MapShapes(old_shape, TopAbs_SOLID, M);
543 [ + - ][ + - ]: 44 : TopTools_IndexedMapOfShape M_new;
544 [ + - ]: 22 : TopExp::MapShapes(new_shape, TopAbs_SOLID, M_new);
545 [ + - ][ + - ]: 44 : TopTools_ListOfShape shapes;
546 [ + - ][ + - ]: 44 : TopoDS_Shape shape;
547 : :
548 : 22 : CubitBoolean updated = CUBIT_FALSE;
549 [ + - ][ + - ]: 88 : if(!old_shape.IsNull() && old_shape.ShapeType() == TopAbs_COMPOUND &&
[ + - ][ + - ]
[ + - ]
550 [ + - ][ + - ]: 88 : !new_shape.IsNull() && new_shape.ShapeType() == TopAbs_COMPOUND &&
[ + - ][ + - ]
[ + - ]
551 [ + - ]: 22 : !old_shape.IsSame(new_shape))
552 : : {
553 : : //By updating underling solids, shells etc., the old_shape will get changed.
554 : : //trying to make sure the the number of each entity in the old and new
555 : : //shapes are the same, which means that nothing is delete, that we can
556 : : //update the map here. Otherwise, when deleting solids, it'll delete the
557 : : //the old body and create new body. This is Ok for general boolean operation //except imprint when booleans are called, usually the original body are
558 : : // supposed to be kept.
559 : 22 : updated = CUBIT_TRUE;
560 [ + - ][ + - ]: 22 : OCCQueryEngine::instance()->update_OCC_map(old_shape, new_shape);
561 : : }
562 : :
563 [ + - ][ + - ]: 44 : DLIList<int> new_solid_nums;
564 [ + - ][ + - ]: 44 : DLIList<int> unfound_nums;
565 [ + - ][ + + ]: 66 : for(int ii=1; ii<=M.Extent(); ii++)
566 : : {
567 [ + - ][ + - ]: 44 : TopoDS_Solid solid = TopoDS::Solid(M(ii));
[ + - ]
568 : :
569 [ + - ][ + - ]: 88 : TopTools_ListOfShape shapes;
[ + - ]
570 [ + - ]: 44 : if(op)
571 : : {
572 [ + - ][ + - ]: 44 : shapes.Assign(op->Modified(solid));
573 [ + - ][ + - ]: 44 : if(shapes.Extent() == 0)
574 [ + - ][ + - ]: 44 : shapes.Assign(op->Generated(solid));
575 : : }
576 [ # # ]: 0 : else if(sp)
577 [ # # ][ # # ]: 0 : shapes.Assign(sp->DescendantShapes(solid));
578 : :
579 [ + - ][ - + ]: 44 : if (shapes.Extent() == 1)
580 [ # # ][ # # ]: 0 : shape = shapes.First();
581 : :
582 [ + - ][ - + ]: 44 : else if(shapes.Extent() > 1)
583 : : {
584 : : //update all attributes first.
585 [ # # ]: 0 : TopTools_ListIteratorOfListOfShape it;
586 [ # # ]: 0 : it.Initialize(shapes);
587 [ # # ][ # # ]: 0 : for(; it.More(); it.Next())
[ # # ]
588 : : {
589 [ # # ][ # # ]: 0 : shape = it.Value();
590 [ # # ][ # # ]: 0 : OCCQueryEngine::instance()->copy_attributes(solid, shape);
591 : : }
592 [ # # ][ # # ]: 0 : shape = shapes.First();
593 : : }
594 : :
595 [ + - ][ + - ]: 44 : else if(op->IsDeleted(solid))
596 : : {
597 [ + - ][ + - ]: 44 : if (M_new.Extent()== 1 && ii == 1)
[ + + ][ + + ]
598 [ + - ][ + - ]: 22 : shape = M_new(1);
599 [ + - ][ + - ]: 22 : else if(M_new.Extent()== 1 && ii > 1)
[ + - ][ + - ]
600 [ + - ]: 22 : shape.Nullify();
601 [ # # ][ # # ]: 0 : else if(M_new.Extent() > 1)
602 : : {
603 [ # # ]: 0 : GProp_GProps myProps;
604 [ # # ]: 0 : BRepGProp::VolumeProperties(solid, myProps);
605 [ # # ]: 0 : double bf_mass = myProps.Mass();
606 [ # # ]: 0 : gp_Pnt old_center = myProps.CentreOfMass();
607 : 0 : CubitBoolean found = CUBIT_FALSE;
608 [ # # ][ # # ]: 0 : for(int l = 1; l <= M_new.Extent(); l++)
609 : : {
610 [ # # ][ # # ]: 0 : BRepGProp::VolumeProperties(M_new(l), myProps);
611 [ # # ]: 0 : double af_mass = myProps.Mass();
612 [ # # ][ # # ]: 0 : double dTol = OCCQueryEngine::instance()->get_sme_resabs_tolerance();
613 [ # # ]: 0 : if(fabs(bf_mass-af_mass) < dTol) //unchanged
614 : : {
615 [ # # ]: 0 : gp_Pnt new_center = myProps.CentreOfMass();
616 [ # # ][ # # ]: 0 : if(new_center.IsEqual(old_center, dTol))
617 : : {
618 : 0 : found = CUBIT_TRUE;
619 [ # # ][ # # ]: 0 : shape = M_new(l);
620 [ # # ]: 0 : new_solid_nums.append(l);
621 : 0 : break;
622 : : }
623 : : }
624 : : }
625 [ # # ]: 0 : if(!found)
626 : : {
627 [ # # ]: 0 : unfound_nums.append(ii);
628 : 0 : continue;
629 : : }
630 : : }
631 : : else
632 [ # # ]: 44 : shape.Nullify();
633 : : }
634 : : else
635 : : {
636 [ # # ]: 0 : shape = solid;
637 : 0 : continue;
638 : : }
639 : :
640 [ + - ][ + - ]: 44 : if(shapes.Extent() > 0 || (op && op->IsDeleted(solid)))
[ + - ][ + - ]
[ + - ][ + - ]
641 [ + - ][ + - ]: 44 : OCCLump::update_OCC_entity(solid, shape, op, sp);
[ + - ]
642 : 44 : }
643 : :
644 [ + - ][ - + ]: 22 : if( unfound_nums.size() == 1 )
645 : : {
646 [ # # ][ # # ]: 0 : TopoDS_Solid solid = TopoDS::Solid(M(unfound_nums.get()));
[ # # ][ # # ]
647 [ # # ][ # # ]: 0 : for(int kk = 1; kk <= M_new.Extent(); kk++)
648 : : {
649 [ # # ][ # # ]: 0 : if(!new_solid_nums.move_to(kk))
650 : : {
651 [ # # ][ # # ]: 0 : shape = M_new(kk);
652 : 0 : break;
653 : : }
654 : : }
655 [ # # ][ # # ]: 0 : OCCLump::update_OCC_entity(solid, shape, op, sp);
656 : : }
657 [ + - ][ - + ]: 22 : else if(unfound_nums.size() > 1)
658 : : {
659 [ # # ]: 0 : shape.Nullify();
660 [ # # ][ # # ]: 0 : for(int kk = 1; kk <=unfound_nums.size(); kk++)
661 : : {
662 [ # # ][ # # ]: 0 : TopoDS_Solid solid = TopoDS::Solid(M(unfound_nums.get_and_step()));
[ # # ][ # # ]
663 [ # # ]: 0 : OCCLump::update_OCC_entity(solid, shape, op, sp);
664 [ # # ]: 0 : }
665 : : }
666 [ + - ][ + - ]: 22 : if(!old_shape.IsSame(new_shape) && !updated)
[ - + ][ - + ]
667 [ # # ][ # # ]: 0 : OCCQueryEngine::instance()->update_OCC_map(old_shape, new_shape);
668 [ + - ]: 22 : return CUBIT_SUCCESS;
669 : : }
670 : : //----------------------------------------------------------------
671 : : // Function: update_bounding_box
672 : : // Description: calculate for bounding box of this OCCBody
673 : : //
674 : : // Author: janehu
675 : : //----------------------------------------------------------------
676 : 4138 : void OCCBody::update_bounding_box()
677 : : {
678 [ + - ]: 4138 : Bnd_Box box;
679 [ + - ]: 4138 : TopoDS_Shape shape;
680 : :
681 [ + - ][ + + ]: 7560 : for (int i = 0; i < myLumps.size(); i++)
682 : : {
683 [ + - ][ - + ]: 3422 : OCCLump *lump = CAST_TO(myLumps.get_and_step(), OCCLump);
684 [ + - ][ + - ]: 3422 : shape = *lump->get_TopoDS_Solid();
685 [ + - ]: 3422 : BRepBndLib::Add(shape, box);
686 : : }
687 : :
688 [ + - ][ + + ]: 4757 : for(int i = 0; i < mySheetSurfaces.size(); i++)
689 : : {
690 [ + - ]: 619 : OCCSurface* surface = mySheetSurfaces.get_and_step();
691 [ + - ][ + - ]: 619 : shape = *surface->get_TopoDS_Face();
692 [ + - ]: 619 : BRepBndLib::Add(shape, box);
693 : : }
694 : :
695 [ + - ][ - + ]: 4138 : for(int i = 0; i <myShells.size() ; i++)
696 : : {
697 [ # # ]: 0 : OCCShell* occ_shell = myShells.get_and_step();
698 [ # # ][ # # ]: 0 : shape = *occ_shell->get_TopoDS_Shell();
699 [ # # ]: 0 : BRepBndLib::Add(shape, box);
700 : : }
701 : :
702 : : //calculate the bounding box
703 [ + - ][ + - ]: 4138 : if(myLumps.size() + mySheetSurfaces.size() + myShells.size() == 0)
[ + - ][ + + ]
704 : : {
705 [ - + ]: 97 : if(!myTopoDSShape)
706 : 4138 : return;
707 [ + - ]: 97 : TopoDS_Shape shape = *myTopoDSShape;
708 [ + - ][ + - ]: 97 : BRepBndLib::Add(shape, box);
709 : : }
710 : :
711 : : double min[3], max[3];
712 : :
713 : : //get values
714 [ + - ]: 4138 : box.Get(min[0], min[1], min[2], max[0], max[1], max[2]);
715 : :
716 : : //update boundingbox.
717 [ + - ][ + - ]: 4138 : boundingbox.reset(min, max);
[ + - ]
718 : : }
719 : :
720 : : //----------------------------------------------------------------
721 : : // Function: get_bounding_box
722 : : // Description: get the bounding box of this OCCBody
723 : : //
724 : : // Author: janehu
725 : : //----------------------------------------------------------------
726 : 227 : CubitBox OCCBody::get_bounding_box()
727 : : {
728 : 227 : return boundingbox ;
729 : : }
730 : :
731 : 0 : void OCCBody::get_parents_virt( DLIList<TopologyBridge*>& )
732 : 0 : {}
733 : :
734 : 21805 : void OCCBody::get_children_virt( DLIList<TopologyBridge*>& lumps )
735 : : {
736 [ + + ]: 26548 : for(int i = 0; i < mySheetSurfaces.size(); i++)
737 : : {
738 : 4743 : OCCSurface* surface = mySheetSurfaces.get_and_step();
739 [ + - ]: 4743 : lumps.append(surface->my_lump());
740 : : }
741 : :
742 [ - + ]: 21805 : for(int i = 0; i <myShells.size() ; i++)
743 : : {
744 : 0 : OCCShell* occ_shell = myShells.get_and_step();
745 [ # # ]: 0 : lumps.append(occ_shell->my_lump());
746 : : }
747 : :
748 [ + + ]: 40997 : for(int i = 0; i <myLumps.size(); i++)
749 [ + - ]: 19192 : lumps.append( myLumps.get_and_step());
750 : 21805 : return;
751 : : }
752 : :
753 : : //-------------------------------------------------------------------------
754 : : // Purpose : Find centroid and volume for lumps and shells
755 : : //
756 : : // Special Notes :
757 : : //
758 : : // Author : Jane Hu
759 : : //
760 : : // Creation Date : 11/30/07
761 : : //-------------------------------------------------------------------------
762 : 11 : CubitStatus OCCBody::mass_properties( CubitVector& centroid,
763 : : double& volume )
764 : : {
765 [ + - ][ + - ]: 11 : if( myShells.size() == 0 && myLumps.size() == 0)
[ + - ][ - + ]
[ - + ]
766 : 0 : return CUBIT_FAILURE;
767 [ + - ]: 11 : GProp_GProps myProps;
768 : 11 : TopoDS_Shape* pshape = myTopoDSShape;
769 [ - + ][ # # ]: 11 : if(!pshape || pshape->IsNull())//single lump or shell or surface
[ # # ][ + - ]
770 : : {
771 [ + - ]: 11 : DLIList<Lump*> lumps = this->lumps();
772 [ + - ][ + - ]: 11 : if (lumps.size() > 0)
773 [ + - ][ - + ]: 11 : pshape = CAST_TO(lumps.get(), OCCLump)->get_TopoDS_Solid();
[ + - ][ + - ]
774 : : }
775 [ + - ][ + - ]: 11 : if(!pshape || pshape->IsNull())
[ - + ][ - + ]
776 : 0 : return CUBIT_FAILURE;
777 : :
778 [ + - ]: 11 : BRepGProp::VolumeProperties(*pshape, myProps);
779 [ + - ]: 11 : volume = myProps.Mass();
780 [ + - ]: 11 : gp_Pnt pt = myProps.CentreOfMass();
781 [ + - ][ + - ]: 11 : centroid.set(pt.X(), pt.Y(), pt.Z());
[ + - ][ + - ]
782 : 11 : return CUBIT_SUCCESS;
783 : : }
784 : :
785 : : //-------------------------------------------------------------------------
786 : : // Purpose : Used to be OCCQueryEngine::is_point_in_body
787 : : //
788 : : // Special Notes :
789 : : //
790 : : // Creator : Jason Kraftcheck
791 : : //
792 : : // Creation Date : 05/10/04
793 : : //-------------------------------------------------------------------------
794 : 0 : CubitPointContainment OCCBody::point_containment( const CubitVector &point, double /*tolerance*/ )
795 : : {
796 : : CubitPointContainment pc_value;
797 : : OCCLump *lump;
798 : :
799 : : int i;
800 [ # # ]: 0 : for( i=myLumps.size(); i--;)
801 : : {
802 [ # # ]: 0 : lump = dynamic_cast<OCCLump*>(myLumps.get_and_step());
803 : 0 : pc_value = lump->point_containment( point );
804 [ # # ]: 0 : if( pc_value == CUBIT_PNT_INSIDE )
805 : 0 : return CUBIT_PNT_INSIDE;
806 [ # # ]: 0 : else if( pc_value == CUBIT_PNT_BOUNDARY )
807 : 0 : return CUBIT_PNT_BOUNDARY;
808 : : }
809 : :
810 [ # # ]: 0 : for(int i = 0; i < mySheetSurfaces.size(); i++)
811 : : {
812 : 0 : OCCSurface* surface = mySheetSurfaces.get_and_step();
813 : 0 : pc_value = surface->point_containment( point );
814 [ # # ]: 0 : if( pc_value == CUBIT_PNT_INSIDE )
815 : 0 : return CUBIT_PNT_INSIDE;
816 [ # # ]: 0 : else if( pc_value == CUBIT_PNT_BOUNDARY )
817 : 0 : return CUBIT_PNT_BOUNDARY;
818 : : }
819 : :
820 [ # # ]: 0 : for(int i = 0; i <myShells.size() ; i++)
821 : : {
822 [ # # ]: 0 : OCCShell* occ_shell = myShells.get_and_step();
823 [ # # ]: 0 : DLIList<TopologyBridge*> children;
824 [ # # ]: 0 : occ_shell->get_children_virt(children);
825 [ # # ][ # # ]: 0 : for(int j = 0; j < children.size(); j++)
[ # # ][ # # ]
826 : : {
827 [ # # ][ # # ]: 0 : OCCSurface* surface = CAST_TO(children.get_and_step(), OCCSurface);
828 [ # # ]: 0 : pc_value = surface->point_containment( point );
829 [ # # ]: 0 : if( pc_value == CUBIT_PNT_INSIDE )
830 : 0 : return CUBIT_PNT_INSIDE;
831 [ # # ]: 0 : else if( pc_value == CUBIT_PNT_BOUNDARY )
832 : 0 : return CUBIT_PNT_BOUNDARY;
833 : : }
834 : 0 : }
835 : 0 : return CUBIT_PNT_OUTSIDE;
836 : : }
837 : :
838 : : //-------------------------------------------------------------------------
839 : : // Purpose : return all surfaces in this body.
840 : : //
841 : : // Special Notes :
842 : : //
843 : : // Creator : Jane Hu
844 : : //
845 : : // Creation Date : 01/10/08
846 : : //-------------------------------------------------------------------------
847 : :
848 : 1400 : void OCCBody::get_all_surfaces(DLIList<OCCSurface*> &surfaces)
849 : : {
850 : : TopoDS_Shape *shape;
851 [ + - ]: 1400 : get_TopoDS_Shape(shape);
852 : :
853 [ + - ]: 1400 : TopTools_IndexedMapOfShape M;
854 [ + - ]: 1400 : TopExp::MapShapes(*shape, TopAbs_FACE, M);
855 : : int ii;
856 [ + - ][ + + ]: 12974 : for (ii=1; ii<=M.Extent(); ii++) {
857 [ + - ][ + - ]: 11574 : TopologyBridge *face = OCCQueryEngine::instance()->occ_to_cgm(M(ii));
[ + - ]
858 [ - + ]: 11574 : OCCSurface* occ_face = CAST_TO(face, OCCSurface);
859 [ + - ]: 11574 : if (occ_face)
860 [ + - ]: 11574 : surfaces.append_unique(occ_face);
861 [ + - ]: 1400 : }
862 : 1400 : }
863 : :
864 : : //-------------------------------------------------------------------------
865 : : // Purpose : return all curves in this body.
866 : : //
867 : : // Special Notes :
868 : : //
869 : : // Creator : Jane Hu
870 : : //
871 : : // Creation Date : 01/10/08
872 : : //-------------------------------------------------------------------------
873 : :
874 : 1072 : void OCCBody::get_all_curves(DLIList<OCCCurve*> &curves)
875 : : {
876 : : TopoDS_Shape *shape;
877 [ + - ]: 1072 : get_TopoDS_Shape(shape);
878 : :
879 [ + - ]: 1072 : TopTools_IndexedMapOfShape M;
880 [ + - ]: 1072 : TopExp::MapShapes(*shape, TopAbs_EDGE, M);
881 : : int ii;
882 [ + - ][ + + ]: 16204 : for (ii=1; ii<=M.Extent(); ii++) {
883 [ + - ][ + - ]: 15132 : TopologyBridge *curve = OCCQueryEngine::instance()->occ_to_cgm(M(ii));
[ + - ]
884 [ + + ]: 15132 : OCCCurve* occ_curve = CAST_TO(curve, OCCCurve);
885 [ + + ]: 15132 : if (occ_curve)
886 [ + - ]: 14056 : curves.append_unique(occ_curve);
887 [ + - ]: 1072 : }
888 : 1072 : }
889 : :
890 : : //-------------------------------------------------------------------------
891 : : // Purpose : return all points in this body.
892 : : //
893 : : // Special Notes :
894 : : //
895 : : // Creator : Jane Hu
896 : : //
897 : : // Creation Date : 01/10/08
898 : : //-------------------------------------------------------------------------
899 : :
900 : 1072 : void OCCBody::get_all_points(DLIList<OCCPoint*> &points)
901 : : {
902 : : TopoDS_Shape *shape;
903 [ + - ]: 1072 : get_TopoDS_Shape(shape);
904 : :
905 [ + - ]: 1072 : TopTools_IndexedMapOfShape M;
906 [ + - ]: 1072 : TopExp::MapShapes(*shape, TopAbs_VERTEX, M);
907 : : int ii;
908 [ + - ][ + + ]: 10720 : for (ii=1; ii<=M.Extent(); ii++) {
909 [ + - ][ + - ]: 9648 : TopologyBridge *vertex = OCCQueryEngine::instance()->occ_to_cgm(M(ii));
[ + - ]
910 [ - + ]: 9648 : OCCPoint* occ_point = CAST_TO(vertex, OCCPoint);
911 [ + - ]: 9648 : if (occ_point)
912 [ + - ]: 9648 : points.append_unique(occ_point);
913 : : }
914 : :
915 [ + - ][ + - ]: 2144 : DLIList<OCCSurface*> surfaces;
916 [ + - ]: 1072 : this->get_all_surfaces(surfaces);
917 [ + - ][ + + ]: 8654 : for(int i = 0; i < surfaces.size(); i++)
918 : : {
919 [ + - ]: 7582 : OCCSurface* occ_surf = surfaces.get_and_step();
920 [ + - ][ + - ]: 7582 : points += occ_surf->get_hardpoints();
[ + - ]
921 [ + - ]: 1072 : }
922 [ + - ][ + - ]: 7436 : }
923 : :
|
