Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : OCCQueryEngine.cpp
3 : : //
4 : : // Purpose : Implementation of the OCCQueryEngine class.
5 : : // This class provides OCC-based implementations
6 : : // of various virtual functions in the GeometryQueryEngine
7 : : // hierarchy.
8 : : //
9 : : // Special Notes :
10 : : //
11 : : // Creator : David R. White
12 : : //
13 : : // Creation Date : 7/17/00
14 : : //
15 : : //-------------------------------------------------------------------------
16 : : #include <Standard_Version.hxx>
17 : : #include <Standard_Stream.hxx>
18 : : //#include <Standard_SStream.hxx>
19 : : //#include <Standard_String.hxx>
20 : : //#include <stringbuf>
21 : : #if OCC_VERSION_MINOR < 5
22 : : #include "TDataStd_Shape.hxx"
23 : : typedef TDataStd_Shape TDataXtd_Shape;
24 : : typedef Handle_TDataStd_Shape Handle_TDataXtd_Shape;
25 : : #else
26 : : #include "TDataXtd_Shape.hxx"
27 : : #endif
28 : :
29 : : #include "BRep_Tool.hxx"
30 : : #include "gp_Pnt.hxx"
31 : : #include "gp_Ax1.hxx"
32 : : #include "gp_Ax2.hxx"
33 : : #include "Geom_Surface.hxx"
34 : : #include "Geom_Curve.hxx"
35 : : #include "Interface_Static.hxx"
36 : : #include "BRepBuilderAPI.hxx"
37 : : #include "BRepBuilderAPI_Transform.hxx"
38 : : #include "BRepBuilderAPI_GTransform.hxx"
39 : : #include "BRepBuilderAPI_ModifyShape.hxx"
40 : : #include "BRepBuilderAPI_MakeSolid.hxx"
41 : : #include "OCCShapeAttributeSet.hpp"
42 : : //#include "OCCBinToolsShapeSet.hpp"
43 : : #include "BRepBuilderAPI_MakeShell.hxx"
44 : : #include "GProp_GProps.hxx"
45 : : #include "BRepGProp.hxx"
46 : : #include "BRepTools_WireExplorer.hxx"
47 : : #include "TColgp_Array1OfPnt.hxx"
48 : : #include "Poly_Array1OfTriangle.hxx"
49 : : #include "Poly_Triangle.hxx"
50 : : #include "BRepAlgoAPI_BooleanOperation.hxx"
51 : : #include "Handle_Poly_Triangulation.hxx"
52 : : #include "GCPnts_TangentialDeflection.hxx"
53 : : #include "BRepAdaptor_Curve.hxx"
54 : : #include "TopExp.hxx"
55 : : #ifdef HAVE_OCC_STEP
56 : : # include "STEPControl_Reader.hxx"
57 : : # include "STEPControl_Writer.hxx"
58 : : # include "STEPControl_StepModelType.hxx"
59 : : #endif
60 : : #ifdef HAVE_OCC_IGES
61 : : # include "IGESControl_Reader.hxx"
62 : : # include "IGESControl_Writer.hxx"
63 : : #endif
64 : : #include "IFSelect_ReturnStatus.hxx"
65 : : #include "BndLib_Add3dCurve.hxx"
66 : : #include "Poly_Polygon3D.hxx"
67 : : #include "Handle_Poly_Polygon3D.hxx"
68 : : #include "BRepMesh_FastDiscret.hxx"
69 : : #include "OCCQueryEngine.hpp"
70 : : #include "OCCModifyEngine.hpp"
71 : : #include "Poly_Triangulation.hxx"
72 : : #include "TopologyEntity.hpp"
73 : : #include "TopologyBridge.hpp"
74 : : #include "RefEntity.hpp"
75 : : #include "Body.hpp"
76 : : #include "Shell.hpp"
77 : : #include "Loop.hpp"
78 : : #include "Chain.hpp"
79 : : #include "RefVolume.hpp"
80 : : #include "RefFace.hpp"
81 : : #include "RefEdge.hpp"
82 : : #include "RefVertex.hpp"
83 : : #include "GeometryEntity.hpp"
84 : : #include "DLIList.hpp"
85 : : #include "CubitBox.hpp"
86 : : #include "CubitString.hpp"
87 : : #include "OCCPoint.hpp"
88 : : #include "OCCCurve.hpp"
89 : : #include "OCCCoEdge.hpp"
90 : : #include "OCCLoop.hpp"
91 : : #include "OCCSurface.hpp"
92 : : #include "OCCShell.hpp"
93 : : #include "OCCLump.hpp"
94 : : #include "OCCBody.hpp"
95 : : #include "OCCAttribSet.hpp"
96 : : #include "GMem.hpp"
97 : : #include "GeometryQueryTool.hpp"
98 : : #include "CubitObserver.hpp"
99 : : #include "GfxDebug.hpp"
100 : : #include <stdio.h>
101 : : #include <errno.h>
102 : :
103 : : #include <BRep_Builder.hxx>
104 : : #include <BRepTools.hxx>
105 : : #include <TopExp_Explorer.hxx>
106 : : #include <TopoDS.hxx>
107 : : #include "TopoDS_Compound.hxx"
108 : : #include <TopoDS_CompSolid.hxx>
109 : : #include <TopoDS_Solid.hxx>
110 : : #include <TopoDS_Shell.hxx>
111 : : #include <TopoDS_Face.hxx>
112 : : #include <TopoDS_Wire.hxx>
113 : : #include <TopoDS_Edge.hxx>
114 : : #include <TopoDS_Vertex.hxx>
115 : : #include <Bnd_Box.hxx>
116 : : #include <BndLib_AddSurface.hxx>
117 : : #include <Precision.hxx>
118 : : #include <BRepAdaptor_Surface.hxx>
119 : : #include <TDF_ChildIterator.hxx>
120 : : #include <BinTools_ShapeSet.hxx>
121 : : #include "Standard_Boolean.hxx"
122 : :
123 : : #include "TDF_Label.hxx"
124 : : #include "TopTools_DataMapOfShapeInteger.hxx"
125 : : #include "BRepExtrema_DistShapeShape.hxx"
126 : : #include "BRepAlgoAPI_Section.hxx"
127 : : #include "BRepBuilderAPI_MakeEdge.hxx"
128 : : #include "TDocStd_Document.hxx"
129 : : #include "TCollection_ExtendedString.hxx"
130 : : #include "gp_Lin.hxx"
131 : : using namespace NCubitFile;
132 : :
133 : : #include "CGMEngineDynamicLoader.hpp"
134 : :
135 : :
136 : 0 : CGM_ENGINE_EXPORT_CREATE_GQE(OpenCascade)
137 : : {
138 : 0 : return OCCQueryEngine::instance();
139 : : }
140 : :
141 : : OCCQueryEngine* OCCQueryEngine::instance_ = NULL;
142 : :
143 : : typedef std::map<int, TopologyBridge*>::value_type valType;
144 : : typedef std::map<int, TDF_Label>::value_type labType;
145 : : int OCCQueryEngine::iTotalTBCreated = 0;
146 : : int OCCQueryEngine::total_coedges = 0;
147 : : #define NUM_PTS_UV 30
148 : : //================================================================================
149 : : // Description:
150 : : // Author :
151 : : // Date :
152 : : //================================================================================
153 : 6633135 : OCCQueryEngine* OCCQueryEngine::instance()
154 : : {
155 [ + + ]: 6633135 : if (instance_ == NULL ) {
156 [ + - ]: 841 : instance_ = new OCCQueryEngine;
157 : : }
158 : 6633135 : return instance_;
159 : : }
160 : :
161 : : //================================================================================
162 : : // Description: default constructor
163 : : // Author :
164 : : // Date :
165 : : //================================================================================
166 [ + - ][ + - ]: 1682 : OCCQueryEngine::OCCQueryEngine()
167 : : {
168 [ + - ][ + - ]: 841 : GeometryQueryTool::instance()->add_gqe( this );
169 [ + - ][ + - ]: 841 : OCCMap = new TopTools_DataMapOfShapeInteger;
170 [ + - ][ + - ]: 841 : OccToCGM = new std::map<int, TopologyBridge*>;
171 [ + - ][ + - ]: 841 : Shape_Label_Map = new std::map<int, TDF_Label>;
172 [ + - ][ + - ]: 841 : BodyList = new DLIList<OCCBody*>;
173 [ + - ][ + - ]: 841 : WireList = new DLIList<OCCLoop*>;
174 [ + - ][ + - ]: 841 : SurfaceList = new DLIList<OCCSurface*>;
175 [ + - ][ + - ]: 841 : CurveList = new DLIList<OCCCurve*>;
176 [ + - ]: 841 : CubitString name("Doc");
177 [ + - ][ + - ]: 1682 : TCollection_ExtendedString xString((Standard_CString)name.c_str(), CUBIT_TRUE);
[ + - ]
178 [ + - ][ + - ]: 841 : MyDF = new TDocStd_Document(xString);
[ + - ]
179 [ + - ][ + - ]: 841 : mainLabel = MyDF->Main();
180 [ + - ]: 841 : EXPORT_ATTRIB = CUBIT_TRUE;
181 : 841 : }
182 : :
183 : : //================================================================================
184 : : // Description: destructor
185 : : // Author :
186 : : // Date :
187 : : //================================================================================
188 [ + - ]: 813 : OCCQueryEngine::~OCCQueryEngine()
189 : : {
190 : 271 : instance_ = NULL;
191 [ + - ][ + - ]: 271 : delete OCCMap;
[ + - ]
192 [ + - ][ + - ]: 271 : delete OccToCGM;
193 [ + - ][ + - ]: 271 : delete Shape_Label_Map;
194 [ + - ][ + - ]: 271 : delete BodyList;
195 [ + - ][ + - ]: 271 : delete WireList;
196 [ + - ][ + - ]: 271 : delete SurfaceList;
197 [ + - ][ + - ]: 271 : delete CurveList;
198 [ - + ]: 542 : }
199 : :
200 : 0 : int OCCQueryEngine::get_major_version()
201 : : {
202 : 0 : return OCC_VERSION_MAJOR;
203 : : }
204 : :
205 : 0 : int OCCQueryEngine::get_minor_version()
206 : : {
207 : 0 : return OCC_VERSION_MINOR;
208 : : }
209 : :
210 : 0 : int OCCQueryEngine::get_subminor_version()
211 : : {
212 : 0 : return OCC_VERSION_MAINTENANCE;
213 : : }
214 : :
215 : 231 : CubitString OCCQueryEngine::get_engine_version_string()
216 : : {
217 [ + - ][ + - ]: 231 : return CubitString("OpenCascade ") + OCC_VERSION_STRING;
[ + - ]
218 : : }
219 : :
220 : : //================================================================================
221 : : // Description:
222 : : // Author :
223 : : // Date :
224 : : //================================================================================
225 : 0 : const type_info& OCCQueryEngine::entity_type_info() const
226 : : {
227 : 0 : return typeid(OCCQueryEngine);
228 : : }
229 : :
230 : : //================================================================================
231 : : // Description: reflect body about an axis
232 : : // Author : sjowen
233 : : // Date : 9/7/01
234 : : //================================================================================
235 : 11 : CubitStatus OCCQueryEngine::reflect( BodySM *bodysm,
236 : : const CubitVector& axis)
237 : : {
238 [ - + ]: 11 : OCCBody *body = CAST_TO(bodysm, OCCBody);
239 [ - + ]: 11 : if (!body)
240 : : {
241 [ # # ][ # # ]: 0 : PRINT_ERROR("Attempt to reflect OCC-based geometry Body. This body is not OCCBody.");
242 : 0 : return CUBIT_FAILURE;
243 : : }
244 : :
245 : 11 : body->reflect( axis.x(), axis.y(), axis.z() );
246 : :
247 : 11 : return CUBIT_SUCCESS;
248 : : }
249 : :
250 : :
251 : : //================================================================================
252 : : // Description: This function queries OCC for the necessary facets
253 : : // information needed in facetting a RefFace. This
254 : : // information is stored and output in gMem. The
255 : : // number of triangles, points and facets are also
256 : : // output.
257 : : // normal_tolerance is in degree.
258 : : // max_edge_length is not considered in getting graphics.
259 : : // Author : Jane Hu
260 : : // Date : 10/25/07
261 : : //================================================================================
262 : 2943 : CubitStatus OCCQueryEngine::get_graphics( Surface* surface_ptr,
263 : : GMem* g_mem,
264 : : unsigned short normal_tolerance,
265 : : double distance_tolerance,
266 : : double max_edge_length) const
267 : : {
268 : : // Because this may be unnecessarily called twice,
269 : : // say there is one triangle.
270 [ - + ]: 2943 : if (!g_mem)
271 : 0 : return CUBIT_SUCCESS;
272 : :
273 [ - + ]: 2943 : if(max_edge_length > get_sme_resabs_tolerance())
274 : : {
275 [ # # ][ # # ]: 0 : PRINT_WARNING("OCC surface's tessilation doesn't consider edge_length.\n");
276 [ # # ][ # # ]: 0 : PRINT_WARNING("max_edge_length argument is ignored. \n");
277 : : }
278 : :
279 [ - + ]: 2943 : OCCSurface *occ_surface_ptr = CAST_TO(surface_ptr, OCCSurface);
280 : 2943 : TopoDS_Face * Topo_Face = occ_surface_ptr->get_TopoDS_Face();
281 : :
282 : 2943 : return get_graphics( Topo_Face, g_mem, normal_tolerance, distance_tolerance, max_edge_length );
283 : : }
284 : :
285 : 2943 : CubitStatus OCCQueryEngine::get_graphics( TopoDS_Face* face_ptr,
286 : : GMem* g_mem,
287 : : unsigned short normal_tolerance,
288 : : double distance_tolerance,
289 : : double max_edge_length) const
290 : : {
291 [ - + ]: 2943 : if (!face_ptr)
292 : 0 : return CUBIT_FAILURE;
293 : :
294 [ + - ]: 2943 : TopLoc_Location L;
295 [ + - ][ + - ]: 5886 : Handle_Poly_Triangulation facets = BRep_Tool::Triangulation(*face_ptr, L);
[ + - ]
296 : :
297 [ + - ]: 2943 : gp_Trsf tf = L.Transformation();
298 : :
299 [ + - ][ + + ]: 2943 : if(facets.IsNull() || facets->NbTriangles() == 0)
[ + - ][ + - ]
[ - + ][ + + ]
300 : : {
301 : : //do triangulation
302 [ + + ]: 2412 : if(distance_tolerance <= 0.0)
303 : 66 : distance_tolerance = 0.01;
304 : 2412 : double angle = CUBIT_PI * normal_tolerance/180;
305 [ + - ]: 2412 : BRepAdaptor_Surface asurface(*face_ptr);
306 [ + - ]: 2412 : Bnd_Box aBox;
307 [ + - ][ + - ]: 2412 : BndLib_AddSurface::Add(asurface, Precision::Approximation(), aBox);
308 : : BRepMesh_FastDiscret *myMesh =
309 : : #if OCC_VERSION_MAJOR <= 6 && OCC_VERSION_MINOR < 8
310 : : new BRepMesh_FastDiscret(distance_tolerance, *face_ptr, aBox, angle, Standard_True, Standard_True);
311 : : #else
312 [ + - ][ + - ]: 2412 : new BRepMesh_FastDiscret(*face_ptr, distance_tolerance, angle, aBox, Standard_True, Standard_True);
313 : : #endif
314 [ + - ][ + - ]: 2412 : if (myMesh != NULL) delete myMesh;
[ + - ]
315 [ + - ][ + - ]: 2412 : facets = BRep_Tool::Triangulation(*face_ptr, L);
316 [ + - ][ + - ]: 2412 : if(facets.IsNull() || facets->NbTriangles() == 0)
[ + - ][ + - ]
[ - + ][ - + ]
317 : : {
318 [ # # ][ # # ]: 0 : PRINT_ERROR("Can't get triangulation representation for this surface.\n");
[ # # ][ # # ]
319 [ + - ][ + - ]: 2412 : return CUBIT_FAILURE;
320 : 2412 : }
321 : : }
322 : : //if necessary, the face tolerance can be returned. now, no use.
323 : : //double tol = BRep_Tool::Tolerance(*Topo_Face);
324 : :
325 [ + - ][ + - ]: 2943 : int number_points = facets->NbNodes();
326 [ + - ][ + - ]: 2943 : int number_triangles = facets->NbTriangles();
327 : 2943 : int number_facets = 4 * number_triangles;
328 : :
329 [ + - ][ + - ]: 5886 : Poly_Array1OfTriangle triangles(0, number_triangles-1);
330 [ + - ][ + - ]: 2943 : triangles.Assign( facets->Triangles() );
[ + - ]
331 [ + - ][ + - ]: 2943 : int *facetList = new int[number_facets];
332 : : //needs to test that N1, N2, N3 index are starting from 0 to number_points-1
333 : : //otherwise needs to update either facetList or gPnts to make consistent.
334 : : //It's possible also that N's starting from 1.
335 : 2943 : int minN = 100;
336 [ + - ][ + + ]: 1802589 : for (int i = 0; i < triangles.Length(); i++)
337 : : {
338 [ + - ]: 1799646 : Poly_Triangle triangle = triangles.Value( i );
339 : : int N1, N2, N3;
340 [ + - ]: 1799646 : triangle.Get(N1, N2, N3);
341 : 1799646 : facetList[4 * i] = 3;
342 : 1799646 : facetList[4 * i + 1] = N1;
343 [ + + ]: 1799646 : minN = (minN < N1 ? minN : N1);
344 : 1799646 : facetList[4 * i + 2] = N2;
345 [ + + ]: 1799646 : minN = (minN < N2 ? minN : N2);
346 : 1799646 : facetList[4 * i + 3] = N3;
347 [ + + ]: 1799646 : minN = (minN < N3 ? minN : N3);
348 : : }
349 [ + - ]: 2943 : if(minN != 0)
350 : : {
351 : : //subtract the minN from the facetList for all i+1, i+2, i+3 points
352 [ + - ][ + + ]: 1802589 : for (int i = 0; i < triangles.Length(); i++)
353 : : {
354 : 1799646 : facetList[4 * i + 1] -= minN;
355 : 1799646 : facetList[4 * i + 2] -= minN;
356 : 1799646 : facetList[4 * i + 3] -= minN;
357 : : }
358 : : }
359 [ + - ]: 2943 : g_mem->replace_facet_list( facetList, number_facets, number_facets);
360 : :
361 [ + - ][ + - ]: 5886 : TColgp_Array1OfPnt points(0, number_points-1);
362 [ + - ][ + - ]: 2943 : points.Assign(facets->Nodes());
[ + - ]
363 [ + - ][ + - ]: 2943 : GPoint *gPnts= new GPoint[number_points];
364 [ + + ]: 961175 : for (int i = 0; i < number_points ; i ++)
365 : : {
366 [ + - ]: 958232 : gp_Pnt gp_pnt = points.Value(i);
367 [ + - ][ + + ]: 958232 : if( !L.IsIdentity())
368 [ + - ]: 264 : gp_pnt.Transform(tf);
369 : :
370 : : GPoint gPnt;
371 [ + - ]: 958232 : gPnt.x = gp_pnt.X();
372 [ + - ]: 958232 : gPnt.y = gp_pnt.Y();
373 [ + - ]: 958232 : gPnt.z = gp_pnt.Z();
374 : 958232 : gPnts[i] = gPnt;
375 : : }
376 [ + - ]: 2943 : g_mem->replace_point_list( gPnts, number_points, number_points );
377 : :
378 [ + - ]: 2943 : return CUBIT_SUCCESS;
379 : : }
380 : :
381 : : //================================================================================
382 : : // Description: This function queries OCC for the edge information
383 : : // needed in facetting a RefEdge. This information is
384 : : // stored and output in g_mem.
385 : : // Author : Jane Hu
386 : : // Date : 10/26/07
387 : : //================================================================================
388 : 5964 : CubitStatus OCCQueryEngine::get_graphics( Curve* curve_ptr,
389 : : GMem* gMem,
390 : : double angle_tolerance,
391 : : double distance_tolerance,
392 : : double max_edge_length ) const
393 : : {
394 : : // get the OCCCurve.
395 [ - + ]: 5964 : OCCCurve *occ_curve_ptr = CAST_TO(curve_ptr,OCCCurve);
396 [ - + ]: 5964 : assert (gMem);
397 : :
398 [ - + ]: 5964 : if(max_edge_length > get_sme_resabs_tolerance())
399 : : {
400 [ # # ][ # # ]: 0 : PRINT_WARNING("OCC surface's tessilation doesn't consider edge_length.\n");
401 [ # # ][ # # ]: 0 : PRINT_WARNING("max_edge_length argument is ignored. \n");
402 : : }
403 : :
404 : 5964 : TopoDS_Edge *edge_ptr = occ_curve_ptr->get_TopoDS_Edge();
405 : :
406 : 5964 : return get_graphics( edge_ptr, gMem, angle_tolerance, distance_tolerance, max_edge_length );
407 : : }
408 : :
409 : :
410 : :
411 : 5964 : CubitStatus OCCQueryEngine::get_graphics( TopoDS_Edge* edge_ptr,
412 : : GMem* gMem,
413 : : double angle_tolerance,
414 : : double distance_tolerance,
415 : : double max_edge_length ) const
416 : : {
417 [ - + ]: 5964 : if (!edge_ptr)
418 : 0 : return CUBIT_FAILURE;
419 : :
420 : : //do tessellation
421 [ + + ]: 5964 : if(distance_tolerance <= 0.0)
422 : 132 : distance_tolerance = 0.2;
423 [ + + ]: 5964 : if(angle_tolerance == 0.0)
424 : 132 : angle_tolerance = 5;
425 : 5964 : double angle = CUBIT_PI * angle_tolerance/180;
426 [ + - ]: 5964 : BRepAdaptor_Curve acurve(*edge_ptr);
427 : : GCPnts_TangentialDeflection *myMesh =
428 : : new GCPnts_TangentialDeflection(acurve, angle,
429 [ + - ][ + - ]: 5964 : distance_tolerance);
430 [ - + ]: 5964 : if (myMesh == NULL)
431 : : {
432 [ # # ][ # # ]: 0 : PRINT_ERROR("Can't tessellate for this curve.\n");
[ # # ][ # # ]
433 : 0 : return CUBIT_FAILURE;
434 : : }
435 [ + - ]: 5964 : int num_points = myMesh->NbPoints();
436 : :
437 : : //! Note: If the polygon is closed, the point of closure is
438 : : //! repeated at the end of its table of nodes. Thus, on a closed
439 : : //! triangle the function NbNodes returns 4?
440 [ + - ][ + - ]: 5964 : GPoint *gPnts= new GPoint[num_points];
441 [ + + ]: 41152 : for (int i = 1; i <= num_points ; i ++)
442 : : {
443 [ + - ]: 35188 : gp_Pnt gp_pnt = myMesh->Value(i);
444 : : GPoint gPnt;
445 [ + - ]: 35188 : gPnt.x = gp_pnt.X();
446 [ + - ]: 35188 : gPnt.y = gp_pnt.Y();
447 [ + - ]: 35188 : gPnt.z = gp_pnt.Z();
448 : 35188 : gPnts[i-1] = gPnt;
449 : : }
450 [ + - ]: 5964 : gMem->replace_point_list( gPnts, num_points, num_points );
451 : :
452 [ + - ][ + - ]: 5964 : delete myMesh;
[ + - ]
453 [ + - ]: 5964 : return CUBIT_SUCCESS;
454 : : }
455 : :
456 : : //================================================================================
457 : : // Description: Given surface and number of point on u and v parametric
458 : : // direction, find the 3-d point locations
459 : : // Author : Jane Hu
460 : : // Date : 10/22/07
461 : : //================================================================================
462 : 0 : CubitStatus OCCQueryEngine::get_isoparametric_points(Surface* surface,
463 : : int &nu, int &nv,
464 : : GMem*& g_mem) const
465 : : {
466 [ # # ]: 0 : OCCSurface* occ_surface = CAST_TO(surface, OCCSurface);
467 [ # # ]: 0 : TopoDS_Face* Tops_face = occ_surface->get_TopoDS_Face();
468 [ # # ]: 0 : if (Tops_face == NULL)
469 : : {
470 [ # # ][ # # ]: 0 : PRINT_ERROR("This surface is not OCCSurface.");
[ # # ]
[ # # # # ]
471 : 0 : return CUBIT_FAILURE;
472 : : }
473 [ # # ]: 0 : Handle_Geom_Surface HGeom_surface = BRep_Tool::Surface(*Tops_face);
474 : :
475 : : double u1, u2, v1, v2;
476 [ # # ]: 0 : BRepTools::UVBounds(*Tops_face, u1, u2, v1, v2);
477 : :
478 [ # # ][ # # ]: 0 : assert (nu > 1 && nv > 1);
479 [ # # ]: 0 : if(nu <= 1)
480 : 0 : nu = NUM_PTS_UV;
481 [ # # ]: 0 : if(nv <= 1)
482 : 0 : nv = NUM_PTS_UV;
483 [ # # ][ # # ]: 0 : g_mem = new GMem[nu];
[ # # ]
[ # # # # ]
484 : :
485 : :
486 : : // calculate the nu curves
487 : 0 : double interval_u = (u2-u1)/double(nu-1);
488 : 0 : double interval_v = (v2 - v1)/(double)(nv - 1);
489 : :
490 [ # # ]: 0 : for (int i = 0; i < nu; i++)
491 : : {
492 [ # # ][ # # ]: 0 : Handle_Geom_Curve HGeom_curve = HGeom_surface->UIso(u1 + i * interval_u);
493 [ # # ]: 0 : g_mem[i].allocate_polylines(nv-1);
494 [ # # ]: 0 : for (int j = 0; j < nv; j++)
495 : : {
496 [ # # ][ # # ]: 0 : gp_Pnt pnt = HGeom_curve->Value(v1 + j * interval_v);
497 [ # # ][ # # ]: 0 : g_mem[i].point_list()[j].x = pnt.X();
498 [ # # ][ # # ]: 0 : g_mem[i].point_list()[j].y = pnt.Y();
499 [ # # ][ # # ]: 0 : g_mem[i].point_list()[j].z = pnt.Z();
500 : : }
501 : 0 : g_mem[i].pointListCount = nv;
502 [ # # ]: 0 : }
503 : :
504 [ # # ]: 0 : return CUBIT_SUCCESS;
505 : : }
506 : :
507 : 0 : CubitStatus OCCQueryEngine::get_u_isoparametric_points(Surface* surface,
508 : : double v, int&n,
509 : : GMem*& g_mem) const
510 : : {
511 [ # # ]: 0 : OCCSurface* occ_surface = CAST_TO(surface, OCCSurface);
512 [ # # ]: 0 : TopoDS_Face* Tops_face = occ_surface->get_TopoDS_Face();
513 [ # # ]: 0 : TopoDS_Face the_face;
514 [ # # ]: 0 : if (Tops_face == NULL)
515 : : {
516 [ # # ][ # # ]: 0 : PRINT_ERROR("This surface is not OCCSurface.");
[ # # ][ # # ]
517 : 0 : return CUBIT_FAILURE;
518 : : }
519 : :
520 [ # # ]: 0 : the_face = *Tops_face;
521 : :
522 [ # # ][ # # ]: 0 : Handle_Geom_Surface HGeom_surface = BRep_Tool::Surface(the_face);
523 : :
524 : : //n must be given to calculate the points.
525 [ # # ]: 0 : if (n <= 1)
526 : 0 : n = NUM_PTS_UV;
527 : : double u1, u2, v1, v2;
528 [ # # ][ # # ]: 0 : HGeom_surface->Bounds(u1, u2, v1, v2);
529 : 0 : double interval = (u2 - u1)/(n -1);
530 : :
531 [ # # ][ # # ]: 0 : Handle_Geom_Curve HGeom_curve = HGeom_surface->VIso(v);
[ # # ]
532 [ # # ][ # # ]: 0 : g_mem = new GMem;
533 [ # # ]: 0 : g_mem->allocate_polylines(n-1);
534 [ # # ]: 0 : for (int j = 0; j < n; j++)
535 : : {
536 [ # # ][ # # ]: 0 : gp_Pnt pnt = HGeom_curve->Value(u1 + j * interval);
537 [ # # ][ # # ]: 0 : g_mem->point_list()[j].x = pnt.X();
538 [ # # ][ # # ]: 0 : g_mem->point_list()[j].y = pnt.Y();
539 [ # # ][ # # ]: 0 : g_mem->point_list()[j].z = pnt.Z();
540 : : }
541 : 0 : g_mem->pointListCount = n;
542 : :
543 [ # # ]: 0 : return CUBIT_SUCCESS;
544 : : }
545 : :
546 : 0 : CubitStatus OCCQueryEngine::get_v_isoparametric_points(Surface* surface,
547 : : double u, int&n,
548 : : GMem*&g_mem) const
549 : : {
550 [ # # ]: 0 : OCCSurface* occ_surface = CAST_TO(surface, OCCSurface);
551 [ # # ]: 0 : TopoDS_Face* Tops_face = occ_surface->get_TopoDS_Face();
552 [ # # ]: 0 : TopoDS_Face the_face;
553 [ # # ]: 0 : if (Tops_face == NULL)
554 : : {
555 [ # # ][ # # ]: 0 : PRINT_ERROR("This surface is not OCCSurface.");
[ # # ][ # # ]
556 : 0 : return CUBIT_FAILURE;
557 : : }
558 : :
559 [ # # ]: 0 : the_face = *Tops_face;
560 : :
561 [ # # ][ # # ]: 0 : Handle_Geom_Surface HGeom_surface = BRep_Tool::Surface(the_face);
562 : :
563 [ # # ]: 0 : if (n <= 1)
564 : 0 : n = NUM_PTS_UV;
565 : : double u1, u2, v1, v2;
566 [ # # ][ # # ]: 0 : HGeom_surface->Bounds(u1, u2, v1, v2);
567 : 0 : double interval = (v2 - v1)/(n -1);
568 : :
569 [ # # ][ # # ]: 0 : Handle_Geom_Curve HGeom_curve = HGeom_surface->UIso(u);
[ # # ]
570 [ # # ][ # # ]: 0 : g_mem = new GMem;
571 [ # # ]: 0 : g_mem->allocate_polylines(n-1);
572 [ # # ]: 0 : for (int j = 0; j < n; j++)
573 : : {
574 [ # # ][ # # ]: 0 : gp_Pnt pnt = HGeom_curve->Value(v1 + j * interval);
575 [ # # ][ # # ]: 0 : g_mem->point_list()[j].x = pnt.X();
576 [ # # ][ # # ]: 0 : g_mem->point_list()[j].y = pnt.Y();
577 [ # # ][ # # ]: 0 : g_mem->point_list()[j].z = pnt.Z();
578 : : }
579 : 0 : g_mem->pointListCount = n;
580 : :
581 [ # # ]: 0 : return CUBIT_SUCCESS;
582 : : }
583 : :
584 : : //================================================================================
585 : : // Description:
586 : : // Author :
587 : : // Date :
588 : : //================================================================================
589 : 0 : CubitStatus OCCQueryEngine::transform_vec_position( CubitVector const& ,
590 : : BodySM *,
591 : : CubitVector & ) const
592 : : {
593 : : //Nobody is using this function in yet.
594 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for OCC based geometry.\n");
595 : 0 : return CUBIT_FAILURE;
596 : : }
597 : :
598 : : //================================================================================
599 : : // Description: Calculate for intersection points between a curve and
600 : : // a segment defined by two points or
601 : : // between two curves or between a curve and a surface.
602 : : // Author : Jane Hu
603 : : // Date : 10/15/07
604 : : //================================================================================
605 : 0 : CubitStatus OCCQueryEngine::get_intersections( Curve* curve,
606 : : CubitVector& point1,
607 : : CubitVector& point2,
608 : : DLIList<CubitVector>& intscts,
609 : : CubitBoolean bounded,
610 : : CubitBoolean closest)
611 : : {
612 [ # # ]: 0 : OCCCurve *occ_curve = CAST_TO(curve, OCCCurve);
613 [ # # ]: 0 : if (occ_curve == NULL)
614 : : {
615 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for non-occ based geometry.\n");
616 : 0 : return CUBIT_FAILURE;
617 : : }
618 : :
619 [ # # ]: 0 : OCCPoint *pt1 = new OCCPoint(point1);
620 [ # # ]: 0 : OCCPoint *pt2 = new OCCPoint(point2);
621 : : Curve *curve2 =
622 : 0 : OCCModifyEngine::instance()->make_Curve(pt1, pt2);
623 [ # # ]: 0 : if (curve2 == NULL)
624 : : {
625 [ # # ][ # # ]: 0 : PRINT_ERROR( "Unable to create OCC EDGE from points\n" );
626 : 0 : return CUBIT_FAILURE;
627 : : }
628 : :
629 [ # # ]: 0 : OCCCurve *occ_curve2 = CAST_TO(curve2, OCCCurve);
630 : 0 : CubitStatus stat = get_intersections(occ_curve, occ_curve2, intscts, bounded, closest);
631 : 0 : delete_solid_model_entities(occ_curve2);
632 : 0 : return stat;
633 : : }
634 : :
635 : 209 : CubitStatus OCCQueryEngine::get_intersections( Curve* curve1,
636 : : Curve* curve2,
637 : : DLIList<CubitVector>& intscts,
638 : : CubitBoolean bounded,
639 : : CubitBoolean closest)
640 : : {
641 : : //If this function has shortcomes in using BRepExtrema_DistShapeShape,
642 : : //look also at IntTools_EdgeEdge.
643 [ - + ]: 209 : OCCCurve *occ_curve1 = CAST_TO(curve1, OCCCurve);
644 [ - + ]: 209 : if (occ_curve1 == NULL)
645 : : {
646 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for non-occ based geometry.\n");
[ # # ][ # # ]
647 : 0 : return CUBIT_FAILURE;
648 : : }
649 : :
650 [ - + ]: 209 : OCCCurve *occ_curve2 = CAST_TO(curve2, OCCCurve);
651 [ - + ]: 209 : if (occ_curve2 == NULL)
652 : : {
653 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for non-occ based geometry.\n");
[ # # ][ # # ]
654 : 0 : return CUBIT_FAILURE;
655 : : }
656 : :
657 : : //currently, there's no effect on 'closest' argument or bounded.
658 : : BRepExtrema_DistShapeShape distShapeShape(
659 [ + - ]: 209 : *(occ_curve1->get_TopoDS_Edge()),
660 [ + - ][ + - ]: 418 : *(occ_curve2->get_TopoDS_Edge()));
661 : :
662 : : //distShapeShape.Perform();
663 [ + - ][ - + ]: 209 : if (!distShapeShape.IsDone())
664 : : {
665 [ # # ][ # # ]: 0 : PRINT_ERROR("Cannot calculate the intersection points for the input curves.\n");
[ # # ][ # # ]
666 : 0 : return CUBIT_FAILURE;
667 : : }
668 : :
669 [ + - ][ + - ]: 209 : if (distShapeShape.Value() < get_sme_resabs_tolerance())
[ + + ]
670 : : {
671 [ + - ]: 132 : int numPnt = distShapeShape.NbSolution();
672 [ + + ]: 264 : for (int i = 1; i <= numPnt; i++)
673 : : {
674 [ + - ]: 132 : gp_Pnt aPoint = distShapeShape.PointOnShape1(i);
675 : :
676 [ + - ][ + - ]: 132 : CubitVector cv(aPoint.X(), aPoint.Y(), aPoint.Z());
[ + - ][ + - ]
677 [ + - ]: 132 : intscts.append(cv);
678 : : }
679 : : }
680 [ + - ]: 209 : return CUBIT_SUCCESS;
681 : : }
682 : :
683 : : CubitStatus
684 : 11 : OCCQueryEngine::get_intersections( Curve* curve, Surface* surface,
685 : : DLIList<CubitVector>& intscts,
686 : : CubitBoolean bounded )
687 : : {
688 : : // There's no effect of bounded = false.
689 [ - + ]: 11 : OCCCurve *occ_curve = CAST_TO(curve, OCCCurve);
690 [ - + ]: 11 : if (occ_curve == NULL)
691 : : {
692 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for non-occ based geometry.\n");
[ # # ][ # # ]
693 : 0 : return CUBIT_FAILURE;
694 : : }
695 : :
696 [ - + ]: 11 : OCCSurface *occ_surface = CAST_TO(surface, OCCSurface);
697 [ - + ]: 11 : if (occ_surface == NULL)
698 : : {
699 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for non-occ based geometry.\n");
[ # # ][ # # ]
700 : 0 : return CUBIT_FAILURE;
701 : : }
702 : :
703 : : //currently, there's no effect on 'closest' argument or bounded.
704 [ + - ]: 11 : BRepExtrema_DistShapeShape distShapeShape(*(occ_curve->get_TopoDS_Edge()),
705 [ + - ][ + - ]: 22 : *(occ_surface->get_TopoDS_Face()));
706 : :
707 : : //distShapeShape.Perform();
708 [ + - ][ - + ]: 11 : if (!distShapeShape.IsDone())
709 : : {
710 [ # # ][ # # ]: 0 : PRINT_ERROR("Cannot calculate the intersection points for the input curve and surface.\n");
[ # # ][ # # ]
711 : 0 : return CUBIT_FAILURE;
712 : : }
713 : :
714 [ + - ][ + - ]: 11 : if (distShapeShape.Value() < get_sme_resabs_tolerance())
[ - + ]
715 : : {
716 [ # # ]: 0 : int numPnt = distShapeShape.NbSolution();
717 [ # # ]: 0 : for (int i = 1; i <= numPnt; i++)
718 : : {
719 [ # # ]: 0 : gp_Pnt aPoint = distShapeShape.PointOnShape1(i);
720 : :
721 [ # # ][ # # ]: 0 : CubitVector cv(aPoint.X(), aPoint.Y(), aPoint.Z());
[ # # ][ # # ]
722 [ # # ]: 0 : intscts.append(cv);
723 : : }
724 : : }
725 : :
726 [ + - ]: 11 : return CUBIT_SUCCESS;
727 : : }
728 : :
729 : : //================================================================================
730 : : // Description: Find extrema position on an entity list
731 : : // Author : Jane Hu
732 : : // Date : 10/30/07
733 : : //================================================================================
734 : : CubitStatus
735 : 0 : OCCQueryEngine::entity_extrema( DLIList<GeometryEntity*> &ref_entity_list,
736 : : const CubitVector *dir1,
737 : : const CubitVector *dir2,
738 : : const CubitVector *dir3,
739 : : CubitVector &extrema,
740 : : GeometryEntity *&extrema_entity_ptr )
741 : : {
742 : : //in OCC, the api_entity_extrema is used to calculate "possible
743 : : //self-intersecting sweeping and to align lofting sections"
744 [ # # ][ # # ]: 0 : PRINT_ERROR("There's no such call in OCC ");
745 : 0 : return CUBIT_FAILURE;
746 : : }
747 : :
748 : : //================================================================================
749 : : // Description: Find distance between two entities and closest positions.
750 : : // Author : Jane Hu
751 : : // Date : 10/19/07
752 : : //================================================================================
753 : : CubitStatus
754 : 0 : OCCQueryEngine::entity_entity_distance( GeometryEntity *entity1,
755 : : GeometryEntity *entity2,
756 : : CubitVector &pos1, CubitVector &pos2,
757 : : double &distance )
758 : : {
759 : : TopoDS_Shape * shape1;
760 : : TopoDS_Shape * shape2;
761 [ # # ][ # # ]: 0 : if ((shape1 = get_TopoDS_Shape_of_entity(entity1)) == NULL)
762 : : {
763 [ # # ][ # # ]: 0 : PRINT_ERROR( "problem occured getting OCC entity.\n"
[ # # ]
764 [ # # ]: 0 : " Aborting.\n" );
765 : 0 : return CUBIT_FAILURE;
766 : : }
767 : :
768 [ # # ][ # # ]: 0 : if( (shape2 = get_TopoDS_Shape_of_entity( entity2 )) == NULL )
769 : : {
770 [ # # ][ # # ]: 0 : PRINT_ERROR( "problem occured getting OCC entity.\n"
[ # # ]
771 [ # # ]: 0 : " Aborting.\n");
772 : 0 : return CUBIT_FAILURE;
773 : : }
774 : :
775 [ # # ]: 0 : BRepExtrema_DistShapeShape distShapeShape(*shape1, *shape2);
776 : : //distShapeShape.Perform();
777 : :
778 [ # # ][ # # ]: 0 : if (!distShapeShape.IsDone())
779 : : {
780 [ # # ][ # # ]: 0 : PRINT_ERROR( "problem occured getting distance between OCC entities.\n"
[ # # ]
781 [ # # ]: 0 : " Aborting.\n");
782 : 0 : return CUBIT_FAILURE;
783 : : }
784 : :
785 [ # # ]: 0 : distance = distShapeShape.Value();
786 [ # # ]: 0 : gp_Pnt pnt1 = distShapeShape.PointOnShape1(1);
787 [ # # ]: 0 : gp_Pnt pnt2 = distShapeShape.PointOnShape2(1);
788 [ # # ][ # # ]: 0 : pos1 = CubitVector(pnt1.X(), pnt1.Y(), pnt1.Z());
[ # # ][ # # ]
[ # # ]
789 [ # # ][ # # ]: 0 : pos2 = CubitVector(pnt2.X(), pnt2.Y(), pnt2.Z());
[ # # ][ # # ]
[ # # ]
790 [ # # ]: 0 : return CUBIT_SUCCESS;
791 : : }
792 : :
793 : 11 : TopoDS_Shape* OCCQueryEngine::get_TopoDS_Shape_of_entity(TopologyBridge * entity_ptr)
794 : : {
795 [ - + ][ - + ]: 11 : if (OCCBody * occ_body = CAST_TO( entity_ptr, OCCBody))
796 : : {
797 : : TopoDS_Shape* theShape;
798 [ # # ]: 0 : occ_body->get_TopoDS_Shape(theShape);
799 : 0 : return theShape;
800 : : }
801 : :
802 [ - + ][ - + ]: 11 : else if (OCCLump * lump_ptr = CAST_TO( entity_ptr,OCCLump))
803 : : {
804 : 0 : TopoDS_Solid * theSolid = lump_ptr->get_TopoDS_Solid();
805 [ # # ]: 0 : if(theSolid)
806 : 0 : return (TopoDS_Shape*) theSolid;
807 : : else
808 : : {
809 [ # # ][ # # ]: 0 : PRINT_ERROR("OCCLump without TopoDS_Solid at %s:%d.\n", __FILE__, __LINE__ );
810 : 0 : return NULL;
811 : : }
812 : : }
813 : :
814 [ - + ][ + - ]: 11 : else if( OCCSurface * surface_ptr = CAST_TO( entity_ptr, OCCSurface))
815 : : {
816 : 11 : TopoDS_Face *theFace = surface_ptr->get_TopoDS_Face();
817 [ - + ]: 11 : if(!theFace)
818 : : {
819 [ # # ][ # # ]: 0 : PRINT_ERROR("OCCSurface without TopoDS_Face at %s:%d.\n", __FILE__, __LINE__ );
820 : 0 : return NULL;
821 : : }
822 : :
823 : 11 : return (TopoDS_Shape*) theFace;
824 : : }
825 : :
826 [ # # ][ # # ]: 0 : else if( OCCCurve * curve_ptr = CAST_TO( entity_ptr, OCCCurve))
827 : : {
828 : 0 : TopoDS_Edge *theEdge = curve_ptr->get_TopoDS_Edge();
829 [ # # ]: 0 : if (!theEdge)
830 : : {
831 [ # # ][ # # ]: 0 : PRINT_ERROR("OCCCurve without TopoDS_Edge at %s:%d.\n", __FILE__, __LINE__ );
832 : 0 : return NULL;
833 : : }
834 : :
835 : 0 : return (TopoDS_Shape*) theEdge;
836 : : }
837 : :
838 [ # # ][ # # ]: 0 : else if( OCCPoint * point_ptr = CAST_TO( entity_ptr, OCCPoint))
839 : : {
840 : 0 : TopoDS_Vertex *thePoint = point_ptr->get_TopoDS_Vertex();
841 [ # # ]: 0 : if (!thePoint)
842 : : {
843 [ # # ][ # # ]: 0 : PRINT_ERROR("OCCPoint without TopoDS_Point at %s:%d.\n", __FILE__, __LINE__ );
844 : 0 : return NULL;
845 : : }
846 : :
847 : 0 : return (TopoDS_Shape*) thePoint;
848 : : }
849 : :
850 [ # # ][ # # ]: 0 : PRINT_ERROR("Non-OCC TopologyBridge at %s:%d.\n", __FILE__, __LINE__ );
851 : 11 : return NULL;
852 : :
853 : : }
854 : : //===========================================================================
855 : : //Function Name: save_temp_geom_file
856 : : //Member Type: PUBLIC
857 : : //Description: function called for save/restore to save temporary FACET file
858 : : // If file is created, CubitString 'created_file' and
859 : : // 'create_file_type' are set
860 : : //Author: Corey Ernst
861 : : //Date: 1/18/2003
862 : : //===========================================================================
863 : :
864 : 0 : CubitStatus OCCQueryEngine::save_temp_geom_file( DLIList<TopologyBridge*>& ref_entity_list,
865 : : const char *file_name,
866 : : const CubitString &cubit_version,
867 : : CubitString &created_file,
868 : : CubitString &created_file_type)
869 : : {
870 [ # # ]: 0 : int size_before = ref_entity_list.size();
871 [ # # ]: 0 : CubitString temp_filename(file_name);
872 [ # # ][ # # ]: 0 : temp_filename += ".occ";
[ # # ]
873 : :
874 [ # # ][ # # ]: 0 : ModelExportOptions M_O;
875 [ # # ]: 0 : if( export_solid_model( ref_entity_list, temp_filename.c_str(), OCC_TYPE,
876 [ # # ][ # # ]: 0 : cubit_version, M_O ) == CUBIT_FAILURE )
877 : : {
878 [ # # ][ # # ]: 0 : PRINT_ERROR( "Error occured while trying to save temporary OCC_BASED_GEOMETRY file\n");
[ # # ][ # # ]
879 : 0 : return CUBIT_FAILURE;
880 : : }
881 : :
882 [ # # ]: 0 : int size_after = ref_entity_list.size();
883 : :
884 [ # # ]: 0 : if( size_before > size_after )
885 : : {
886 [ # # ]: 0 : created_file += temp_filename;
887 [ # # ][ # # ]: 0 : created_file_type += "OCC";
[ # # ]
888 : : }
889 [ # # ]: 0 : return CUBIT_SUCCESS;
890 : : }
891 : :
892 : : //===========================================================================
893 : : //Function Name:export_solid_model
894 : : //Member Type: PUBLIC
895 : : //Description: function called for save/restore to save temporary Brep file
896 : : //Author: Jane Hu
897 : : //Date: 11/16/2007
898 : : //===========================================================================
899 : :
900 : 285 : CubitStatus OCCQueryEngine::export_solid_model( DLIList<TopologyBridge*>& ref_entity_list,
901 : : const char* file_name,
902 : : Model_File_Type file_type,
903 : : const CubitString &,
904 : : ModelExportOptions &)
905 : : {
906 [ + + ][ + + ]: 285 : if( file_type != OCC_TYPE &&
907 [ - + ]: 22 : file_type != STEP_TYPE &&
908 : : file_type != IGES_TYPE)
909 : : {
910 : : //PRINT_ERROR("The specified file type, %s, is not supported!\n", filetype );
911 : 0 : return CUBIT_FAILURE;
912 : : }
913 : :
914 : : /*
915 : : char* name = "write.iges.unit";
916 : : Standard_CString orig_unit;
917 : : char* unit = "M";
918 : : if(strcmp( file_type, "IGES") == 0 && unit != NULL)
919 : : {
920 : : orig_unit = Interface_Static::CVal(name);
921 : : Interface_Static::SetCVal (name, unit);
922 : : }
923 : : */
924 [ + - ]: 285 : DLIList<OCCBody*> OCC_bodies;
925 [ + - ][ + - ]: 570 : DLIList<OCCSurface*> OCC_surfaces;
926 [ + - ][ + - ]: 570 : DLIList<OCCCurve*> OCC_curves;
927 [ + - ][ + - ]: 570 : DLIList<OCCPoint*> OCC_points;
928 : :
929 [ + - ][ + - ]: 570 : DLIList<TopologyBridge*> ref_entities_handled;
930 : :
931 : : int i;
932 : : //Collect all free entities (bodies, curves, vertices )
933 [ + - ]: 285 : ref_entity_list.reset();
934 [ + - ][ + + ]: 1843 : for(i=ref_entity_list.size(); i>0; i--)
935 : : {
936 [ + - ]: 1558 : TopologyBridge* ref_entity_ptr = ref_entity_list.get();
937 : 1558 : CubitBoolean handled = CUBIT_TRUE;
938 : :
939 : : //if it is a Vertex
940 [ - + ][ - + ]: 1558 : if( OCCPoint* pt = CAST_TO( ref_entity_ptr, OCCPoint) )
941 [ # # ]: 0 : OCC_points.append( pt );
942 : :
943 : : //if it is a Curve
944 [ - + ][ + + ]: 1558 : else if( OCCCurve* curve = CAST_TO( ref_entity_ptr, OCCCurve) )
945 [ + - ]: 737 : OCC_curves.append( curve );
946 : :
947 : : //if it is a surface
948 [ - + ][ - + ]: 821 : else if( OCCSurface* surf = CAST_TO( ref_entity_ptr, OCCSurface) )
949 [ # # ]: 0 : OCC_surfaces.append( surf );
950 : :
951 : : //if it is a Body
952 [ - + ][ + - ]: 821 : else if( OCCBody* body = CAST_TO( ref_entity_ptr, OCCBody ) )
953 [ + - ]: 821 : OCC_bodies.append( body );
954 : :
955 : : else
956 : 1558 : handled = CUBIT_FALSE;
957 : :
958 [ + - ]: 1558 : if( handled == CUBIT_TRUE )
959 : : {
960 [ + - ]: 1558 : ref_entities_handled.append( ref_entity_ptr );
961 [ + - ]: 1558 : ref_entity_list.change_to(NULL);
962 : : }
963 : :
964 [ + - ]: 1558 : ref_entity_list.step();
965 : : }
966 : :
967 [ + - ]: 285 : ref_entity_list.remove_all_with_value(NULL);
968 : :
969 [ + - ]: 285 : int free_body_count = OCC_bodies.size();
970 [ + - ]: 285 : int free_curve_count = OCC_curves.size();
971 [ + - ]: 285 : int free_point_count = OCC_points.size();
972 [ + - ]: 285 : int free_surface_count = OCC_surfaces.size();
973 : :
974 : : //if nothing to write out...return
975 [ + + ][ + - ]: 285 : if( free_body_count == 0 && free_surface_count == 0 &&
[ - + ]
976 [ # # ]: 0 : free_curve_count == 0 && free_point_count == 0)
977 : 0 : return CUBIT_SUCCESS;
978 : :
979 : : //save the facets (geometry info )
980 : : CubitStatus status;
981 : :
982 : : //write out topology and attributes
983 : : status = write_topology( file_name, file_type,
984 : : OCC_bodies, OCC_surfaces,
985 [ + - ]: 285 : OCC_curves, OCC_points );
986 : : /*
987 : : //set the unit back.
988 : : if(strcmp( file_type, "IGES") == 0 && unit != NULL)
989 : : Interface_Static::SetCVal (name,orig_unit);
990 : : */
991 [ - + ]: 285 : if( status == CUBIT_FAILURE ) return CUBIT_FAILURE;
992 : :
993 [ + + ][ + - ]: 285 : if( free_body_count || free_surface_count ||
[ - + ]
994 [ # # ]: 0 : free_curve_count || free_point_count )
995 [ + - ][ + - ]: 285 : PRINT_INFO( "\nExported:" );
[ + - ][ + - ]
996 : :
997 : 285 : int flg = 0;
998 : :
999 [ + + ]: 285 : if( free_body_count )
1000 : : {
1001 [ - + ][ # # ]: 241 : if( flg )PRINT_INFO( " " );else flg=1;
[ # # ][ # # ]
[ # # ]
1002 [ + + ]: 241 : if( free_body_count == 1 )
1003 [ + - ][ + - ]: 88 : PRINT_INFO( "%4d OCC Body to %s\n", free_body_count, file_name );
[ + - ][ + - ]
1004 : : else
1005 [ + - ][ + - ]: 241 : PRINT_INFO( "%4d OCC Bodies to %s\n", free_body_count, file_name );
[ + - ][ + - ]
1006 : : }
1007 : :
1008 [ - + ]: 285 : if( free_surface_count )
1009 : : {
1010 [ # # ][ # # ]: 0 : if( flg )PRINT_INFO( " " );else flg=1;
[ # # ][ # # ]
[ # # ]
1011 [ # # ]: 0 : if( free_surface_count == 1 )
1012 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d OCC Surface to %s\n", free_surface_count, file_name );
[ # # ][ # # ]
1013 : : else
1014 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d OCC Surface to %s\n", free_surface_count, file_name );
[ # # ][ # # ]
1015 : : }
1016 : :
1017 [ + + ]: 285 : if( free_curve_count )
1018 : : {
1019 [ - + ][ # # ]: 44 : if( flg )PRINT_INFO( " " );else flg=1;
[ # # ][ # # ]
[ # # ]
1020 [ - + ]: 44 : if( free_curve_count == 1 )
1021 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d OCC Curve to %s\n", free_curve_count, file_name );
[ # # ][ # # ]
1022 : : else
1023 [ + - ][ + - ]: 44 : PRINT_INFO( "%4d OCC Curves to %s\n", free_curve_count, file_name );
[ + - ][ + - ]
1024 : : }
1025 : :
1026 [ - + ]: 285 : if( free_point_count )
1027 : : {
1028 [ # # ][ # # ]: 0 : if( flg )PRINT_INFO( " " );else flg=1;
[ # # ][ # # ]
[ # # ]
1029 [ # # ]: 0 : if( free_point_count == 1 )
1030 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d OCC Point to %s\n", free_point_count, file_name );
[ # # ][ # # ]
1031 : : else
1032 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d OCC Points to %s\n", free_point_count, file_name );
[ # # ][ # # ]
1033 : : }
1034 [ + - ][ + - ]: 285 : PRINT_INFO( "\n" );
[ + - ][ + - ]
1035 : :
1036 [ + - ]: 570 : return CUBIT_SUCCESS;
1037 : : }
1038 : :
1039 : 0 : CubitStatus OCCQueryEngine::export_solid_model( DLIList<TopologyBridge*>& ref_entity_list,
1040 : : char*& p_buffer,
1041 : : int& n_buffer_size,
1042 : : bool b_export_buffer)
1043 : : {
1044 [ # # ]: 0 : DLIList<OCCBody*> OCC_bodies;
1045 [ # # ][ # # ]: 0 : DLIList<OCCSurface*> OCC_surfaces;
1046 [ # # ][ # # ]: 0 : DLIList<OCCCurve*> OCC_curves;
1047 [ # # ][ # # ]: 0 : DLIList<OCCPoint*> OCC_points;
1048 : :
1049 [ # # ][ # # ]: 0 : DLIList<TopologyBridge*> ref_entities_handled;
1050 : :
1051 : : int i;
1052 : : //Collect all free entities (bodies, curves, vertices )
1053 [ # # ]: 0 : ref_entity_list.reset();
1054 [ # # ][ # # ]: 0 : for(i=ref_entity_list.size(); i>0; i--)
1055 : : {
1056 [ # # ]: 0 : TopologyBridge* ref_entity_ptr = ref_entity_list.get();
1057 : 0 : CubitBoolean handled = CUBIT_TRUE;
1058 : :
1059 : : //if it is a Vertex
1060 [ # # ][ # # ]: 0 : if( OCCPoint* pt = CAST_TO( ref_entity_ptr, OCCPoint) )
1061 [ # # ]: 0 : OCC_points.append( pt );
1062 : :
1063 : : //if it is a Curve
1064 [ # # ][ # # ]: 0 : else if( OCCCurve* curve = CAST_TO( ref_entity_ptr, OCCCurve) )
1065 [ # # ]: 0 : OCC_curves.append( curve );
1066 : :
1067 : : //if it is a surface
1068 [ # # ][ # # ]: 0 : else if( OCCSurface* surf = CAST_TO( ref_entity_ptr, OCCSurface) )
1069 [ # # ]: 0 : OCC_surfaces.append( surf );
1070 : :
1071 : : //if it is a Body
1072 [ # # ][ # # ]: 0 : else if( OCCBody* body = CAST_TO( ref_entity_ptr, OCCBody ) )
1073 [ # # ]: 0 : OCC_bodies.append( body );
1074 : :
1075 : : else
1076 : 0 : handled = CUBIT_FALSE;
1077 : :
1078 [ # # ]: 0 : if( handled == CUBIT_TRUE )
1079 : : {
1080 [ # # ]: 0 : ref_entities_handled.append( ref_entity_ptr );
1081 [ # # ]: 0 : ref_entity_list.change_to(NULL);
1082 : : }
1083 : :
1084 [ # # ]: 0 : ref_entity_list.step();
1085 : : }
1086 : :
1087 [ # # ]: 0 : ref_entity_list.remove_all_with_value(NULL);
1088 : :
1089 [ # # ]: 0 : int free_body_count = OCC_bodies.size();
1090 [ # # ]: 0 : int free_curve_count = OCC_curves.size();
1091 [ # # ]: 0 : int free_point_count = OCC_points.size();
1092 [ # # ]: 0 : int free_surface_count = OCC_surfaces.size();
1093 : :
1094 : : //if nothing to write out...return
1095 [ # # ][ # # ]: 0 : if( free_body_count == 0 && free_surface_count == 0 &&
[ # # ]
1096 [ # # ]: 0 : free_curve_count == 0 && free_point_count == 0)
1097 : 0 : return CUBIT_SUCCESS;
1098 : :
1099 : : //save the facets (geometry info )
1100 : : CubitStatus status;
1101 : :
1102 : : //write out topology and attributes
1103 : : status = write_topology( p_buffer, n_buffer_size,
1104 : : b_export_buffer,
1105 : : OCC_bodies, OCC_surfaces,
1106 [ # # ]: 0 : OCC_curves, OCC_points);
1107 [ # # ]: 0 : if( status == CUBIT_FAILURE ) return CUBIT_FAILURE;
1108 : :
1109 [ # # ][ # # ]: 0 : if( free_body_count || free_surface_count ||
[ # # ]
1110 [ # # ]: 0 : free_curve_count || free_point_count )
1111 : : {
1112 [ # # ][ # # ]: 0 : if (b_export_buffer) PRINT_INFO( "\nExported:" );
[ # # ][ # # ]
[ # # ]
1113 [ # # ][ # # ]: 0 : else PRINT_INFO( "\nSize checked:" );
[ # # ][ # # ]
1114 : : }
1115 : 0 : int flg = 0;
1116 : :
1117 [ # # ]: 0 : if( free_body_count )
1118 : : {
1119 [ # # ][ # # ]: 0 : if( flg )PRINT_INFO( " " );else flg=1;
[ # # ][ # # ]
[ # # ]
1120 [ # # ]: 0 : if( free_body_count == 1 )
1121 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d OCC Body to buffer\n", free_body_count );
[ # # ][ # # ]
1122 : : else
1123 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d OCC Bodies to buffer\n", free_body_count );
[ # # ][ # # ]
1124 : : }
1125 : :
1126 [ # # ]: 0 : if( free_surface_count )
1127 : : {
1128 [ # # ][ # # ]: 0 : if( flg )PRINT_INFO( " " );else flg=1;
[ # # ][ # # ]
[ # # ]
1129 [ # # ]: 0 : if( free_surface_count == 1 )
1130 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d OCC Surface to buffer\n", free_surface_count );
[ # # ][ # # ]
1131 : : else
1132 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d OCC Surface to buffer\n", free_surface_count );
[ # # ][ # # ]
1133 : : }
1134 : :
1135 [ # # ]: 0 : if( free_curve_count )
1136 : : {
1137 [ # # ][ # # ]: 0 : if( flg )PRINT_INFO( " " );else flg=1;
[ # # ][ # # ]
[ # # ]
1138 [ # # ]: 0 : if( free_curve_count == 1 )
1139 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d OCC Curve to buffer\n", free_curve_count );
[ # # ][ # # ]
1140 : : else
1141 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d OCC Curves to buffer\n", free_curve_count );
[ # # ][ # # ]
1142 : : }
1143 : :
1144 [ # # ]: 0 : if( free_point_count )
1145 : : {
1146 [ # # ][ # # ]: 0 : if( flg )PRINT_INFO( " " );else flg=1;
[ # # ][ # # ]
[ # # ]
1147 [ # # ]: 0 : if( free_point_count == 1 )
1148 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d OCC Point to buffer\n", free_point_count );
[ # # ][ # # ]
1149 : : else
1150 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d OCC Points to buffer\n", free_point_count );
[ # # ][ # # ]
1151 : : }
1152 [ # # ][ # # ]: 0 : PRINT_INFO( "\n" );
[ # # ][ # # ]
1153 : :
1154 [ # # ]: 0 : return CUBIT_SUCCESS;
1155 : : }
1156 : :
1157 : 241 : void OCCQueryEngine::body_attributes_for_writing(DLIList<OCCBody*> &OCC_bodies,
1158 : : BRep_Builder &B,
1159 : : TopoDS_Compound &Co,
1160 : : DLIList<OCCLump*> &single_lumps,
1161 : : DLIList< DLIList<CubitSimpleAttrib>*> &lists)
1162 : : {
1163 : : //Add every shape to the compound
1164 : 241 : OCCLump* lump = NULL;
1165 [ + - ]: 241 : DLIList<CubitSimpleAttrib> body_csa_list;
1166 : :
1167 [ + - ][ + + ]: 1062 : for (int i = 0; i < OCC_bodies.size(); i++)
1168 : : {
1169 [ + - ]: 821 : OCCBody* body = OCC_bodies.get_and_step();
1170 [ + - ]: 821 : TopoDS_Compound *shape = body->get_TopoDS_Shape();
1171 [ + + ][ + - ]: 821 : if (shape == NULL || shape->IsNull()) //single lump or sheet or shell body
[ - + ][ + + ]
1172 : : {
1173 [ + - ]: 799 : DLIList<OCCSurface*> surfaces = body->my_sheet_surfaces();
1174 [ + - ][ + - ]: 1598 : DLIList<OCCShell*> shells = body->shells();
1175 [ + - ][ + - ]: 1598 : DLIList<Lump*> lumps = body->lumps();
1176 [ + - ][ + + ]: 799 : if(surfaces.size() == 1)
1177 [ + - ][ + - ]: 473 : B.Add(Co,*(surfaces.get()->get_TopoDS_Face()));
[ + - ]
1178 [ + - ][ - + ]: 326 : else if (shells.size() == 1)
1179 [ # # ][ # # ]: 0 : B.Add(Co,*(shells.get()->get_TopoDS_Shell()));
[ # # ]
1180 : : else
1181 : : {
1182 [ + - ][ - + ]: 326 : lump = CAST_TO(lumps.get(), OCCLump);
1183 [ + - ][ + - ]: 326 : B.Add(Co, *(lump->get_TopoDS_Solid()));
1184 : : //if body has attributes, add them to the solid.
1185 [ + - ]: 326 : DLIList<CubitSimpleAttrib> csa_list;
1186 [ + - ]: 326 : body->get_simple_attribute(csa_list);
1187 [ + - ]: 326 : body_csa_list.clean_out();
1188 [ + - ][ + + ]: 593 : for(int i = 0; i < csa_list.size(); i++)
1189 : : {
1190 [ + - ][ + - ]: 267 : CubitSimpleAttrib body_csa = csa_list.get_and_step();
1191 [ + - ][ + - ]: 534 : CubitString pre_fix("#SINGLELUMP%");
1192 [ + - ][ + - ]: 267 : pre_fix += CubitString::number(i);
[ + - ]
1193 : :
1194 [ + - ][ + - ]: 267 : body_csa.string_data_list().insert(body_csa.string_data_list().begin(), pre_fix);
[ + - ][ + - ]
1195 [ + - ]: 267 : lump->append_simple_attribute_virt(body_csa);
1196 [ + - ]: 267 : body_csa_list.append(body_csa);
1197 [ + - ]: 267 : }
1198 [ + - ][ + + ]: 326 : if(csa_list.size() > 0)
1199 : : {
1200 [ + - ]: 194 : single_lumps.append(lump);
1201 [ + - ][ + - ]: 194 : lists.append(new DLIList<CubitSimpleAttrib>(body_csa_list));
[ + - ]
1202 [ + - ]: 326 : }
1203 : : }
1204 [ + - ]: 1598 : continue;
1205 : : }
1206 [ + - ]: 22 : B.Add(Co, *shape);
1207 [ + - ]: 241 : }
1208 : 241 : }
1209 : : //===========================================================================
1210 : : //Function Name:write_topology
1211 : : //Member Type: PUBLIC
1212 : : //Description: function called for write out temporary Brep file
1213 : : //Author: Jane Hu
1214 : : //Date: 11/16/2007
1215 : : //===========================================================================
1216 : :
1217 : : CubitStatus
1218 : 285 : OCCQueryEngine::write_topology( const char* file_name,
1219 : : Model_File_Type file_type,
1220 : : DLIList<OCCBody*> &OCC_bodies,
1221 : : DLIList<OCCSurface*> &OCC_surfaces,
1222 : : DLIList<OCCCurve*> &OCC_curves,
1223 : : DLIList<OCCPoint*> &OCC_points )
1224 : : {
1225 : :
1226 : : int i;
1227 : : //Create a compound shape to export
1228 : : BRep_Builder B;
1229 [ + - ]: 285 : TopoDS_Compound Co;
1230 [ + - ]: 285 : B.MakeCompound(Co);
1231 : :
1232 : : //Add every shape to the compound
1233 [ + - ][ + - ]: 570 : DLIList<OCCLump*> single_lumps;
1234 [ + - ][ + - ]: 570 : DLIList< DLIList<CubitSimpleAttrib>*> lists;
1235 : 285 : OCCLump* lump = NULL;
1236 : :
1237 [ + - ][ + + ]: 285 : if(OCC_bodies.size() > 0)
1238 [ + - ]: 241 : body_attributes_for_writing(OCC_bodies, B, Co, single_lumps, lists);
1239 : :
1240 [ + - ][ - + ]: 285 : for (i = 0; i < OCC_surfaces.size(); i++)
1241 : : {
1242 [ # # ][ # # ]: 0 : TopoDS_Face *face = OCC_surfaces.get_and_step()->get_TopoDS_Face();
1243 [ # # ]: 0 : B.Add(Co, *face);
1244 : : }
1245 : :
1246 : : //Add standalone wires to the export BRep file
1247 [ + - ][ - + ]: 285 : for (i = 0; i < WireList->size(); i++)
1248 : : {
1249 [ # # ][ # # ]: 0 : TopoDS_Wire *wire = WireList->get_and_step()->get_TopoDS_Wire();
1250 [ # # ]: 0 : B.Add(Co, *wire);
1251 : : }
1252 : :
1253 [ + - ][ + + ]: 1022 : for (i = 0; i < OCC_curves.size(); i++)
1254 : : {
1255 [ + - ][ + - ]: 737 : TopoDS_Edge *edge = OCC_curves.get_and_step()->get_TopoDS_Edge();
1256 [ + - ]: 737 : B.Add(Co, *edge);
1257 : : }
1258 : :
1259 [ + - ][ - + ]: 285 : for (i = 0; i < OCC_points.size(); i++)
1260 : : {
1261 [ # # ][ # # ]: 0 : TopoDS_Vertex *vertex = OCC_points.get_and_step()->get_TopoDS_Vertex();
1262 [ # # ]: 0 : B.Add(Co, *vertex);
1263 : : }
1264 : :
1265 [ + + ]: 285 : if(file_type == OCC_TYPE)
1266 : : {
1267 [ + - ]: 241 : TDF_Label label;
1268 [ + - ]: 241 : if(EXPORT_ATTRIB)
1269 : 241 : label = mainLabel;
1270 : :
1271 [ + - ]: 241 : CubitBoolean result = Write(Co, const_cast<char*>(file_name),label);
1272 : : //remove the body attributes from lump
1273 [ + - ][ + + ]: 435 : for (int i = 0; i < single_lumps.size(); i++)
1274 : : {
1275 [ + - ]: 194 : lump = single_lumps.get_and_step();
1276 [ + - ]: 194 : DLIList<CubitSimpleAttrib>* p_csas = lists.get_and_step();
1277 [ + - ][ + + ]: 461 : for(int j = 0 ; j < p_csas->size(); j ++)
1278 : : {
1279 [ + - ]: 267 : const CubitSimpleAttrib& csa = p_csas->get_and_step();
1280 [ + - ]: 267 : lump->remove_simple_attribute_virt(csa);
1281 : : }
1282 [ + - ][ + - ]: 194 : delete p_csas;
1283 : : }
1284 [ - + ]: 241 : if(!result)
1285 : 241 : return CUBIT_FAILURE;
1286 : : }
1287 : :
1288 : : #ifdef HAVE_OCC_STEP
1289 [ + + ]: 44 : else if(file_type == STEP_TYPE)
1290 : : {
1291 [ + - ]: 22 : STEPControl_Writer writer;
1292 [ + - ][ + - ]: 22 : writer.Model( Standard_True);
1293 [ + - ]: 22 : writer.Transfer(Co, STEPControl_AsIs );
1294 [ + - ]: 22 : IFSelect_ReturnStatus stat = writer.Write( (char*) file_name);
1295 [ - + ]: 22 : if (stat != IFSelect_RetDone)
1296 : : {
1297 [ # # ][ # # ]: 0 : PRINT_INFO("%s: Cannot open file", file_name );
[ # # ][ # # ]
1298 [ + - ][ + - ]: 22 : return CUBIT_FAILURE;
1299 : 22 : }
1300 : : }
1301 : : #endif
1302 : : #ifdef HAVE_OCC_IGES
1303 [ + - ]: 22 : else if (file_type == IGES_TYPE) // IGES file
1304 : : {
1305 [ + - ]: 22 : IGESControl_Writer writer;
1306 [ + - ]: 22 : writer.AddShape(Co);
1307 [ + - ]: 22 : writer.ComputeModel();
1308 [ + - ]: 22 : Standard_Boolean stat = writer.Write( (char*) file_name);
1309 [ - + ]: 22 : if (!stat )
1310 : : {
1311 [ # # ][ # # ]: 0 : PRINT_INFO("%s: Cannot open file", file_name );
[ # # ][ # # ]
1312 [ + - ][ + - ]: 22 : return CUBIT_FAILURE;
1313 : 22 : }
1314 : : }
1315 : : #endif
1316 : : else {
1317 [ # # ][ # # ]: 0 : PRINT_ERROR("File formats other than OCC, STEP and IGES are not supported by OCC.\n");
[ # # ][ # # ]
1318 : 0 : return CUBIT_FAILURE;
1319 : : }
1320 : :
1321 [ + - ]: 570 : return CUBIT_SUCCESS;
1322 : : }
1323 : :
1324 : : CubitStatus
1325 : 0 : OCCQueryEngine::write_topology( char*& p_buffer,
1326 : : int& n_buffer_size,
1327 : : bool b_export_buffer,
1328 : : DLIList<OCCBody*> &OCC_bodies,
1329 : : DLIList<OCCSurface*> &OCC_surfaces,
1330 : : DLIList<OCCCurve*> &OCC_curves,
1331 : : DLIList<OCCPoint*> &OCC_points)
1332 : : {
1333 : :
1334 : : int i;
1335 : : //Create a compound shape to export
1336 : : BRep_Builder B;
1337 [ # # ]: 0 : TopoDS_Compound Co;
1338 [ # # ]: 0 : B.MakeCompound(Co);
1339 : :
1340 : : //Add every shape to the compound
1341 [ # # ][ # # ]: 0 : DLIList<OCCLump*> single_lumps;
1342 [ # # ][ # # ]: 0 : DLIList< DLIList<CubitSimpleAttrib>*> lists;
1343 : 0 : OCCLump* lump = NULL;
1344 : :
1345 [ # # ][ # # ]: 0 : if(OCC_bodies.size() > 0)
1346 [ # # ]: 0 : body_attributes_for_writing(OCC_bodies, B, Co, single_lumps, lists);
1347 : :
1348 [ # # ][ # # ]: 0 : for (i = 0; i < OCC_surfaces.size(); i++)
1349 : : {
1350 [ # # ][ # # ]: 0 : TopoDS_Face *face = OCC_surfaces.get_and_step()->get_TopoDS_Face();
1351 [ # # ]: 0 : B.Add(Co, *face);
1352 : : }
1353 : :
1354 : : //Add standalone wires to the export BRep file
1355 [ # # ][ # # ]: 0 : for (i = 0; i < WireList->size(); i++)
1356 : : {
1357 [ # # ][ # # ]: 0 : TopoDS_Wire *wire = WireList->get_and_step()->get_TopoDS_Wire();
1358 [ # # ]: 0 : B.Add(Co, *wire);
1359 : : }
1360 : :
1361 [ # # ][ # # ]: 0 : for (i = 0; i < OCC_curves.size(); i++)
1362 : : {
1363 [ # # ][ # # ]: 0 : TopoDS_Edge *edge = OCC_curves.get_and_step()->get_TopoDS_Edge();
1364 [ # # ]: 0 : B.Add(Co, *edge);
1365 : : }
1366 : :
1367 [ # # ][ # # ]: 0 : for (i = 0; i < OCC_points.size(); i++)
1368 : : {
1369 [ # # ][ # # ]: 0 : TopoDS_Vertex *vertex = OCC_points.get_and_step()->get_TopoDS_Vertex();
1370 [ # # ]: 0 : B.Add(Co, *vertex);
1371 : : }
1372 : :
1373 : : //if(strcmp(file_type, "OCC") == 0)
1374 : : //{
1375 [ # # ]: 0 : TDF_Label label;
1376 [ # # ]: 0 : if(EXPORT_ATTRIB)
1377 : 0 : label = mainLabel;
1378 : :
1379 [ # # ][ # # ]: 0 : if(!Write(Co, p_buffer, n_buffer_size, b_export_buffer, label))
1380 : 0 : return CUBIT_FAILURE;
1381 : :
1382 : : //remove the body attributes from lump
1383 [ # # ][ # # ]: 0 : for (int i = 0; i < single_lumps.size(); i++)
1384 : : {
1385 [ # # ]: 0 : lump = single_lumps.get_and_step();
1386 [ # # ]: 0 : DLIList<CubitSimpleAttrib>* p_csas = lists.get_and_step();
1387 [ # # ][ # # ]: 0 : for(int j = 0 ; j < p_csas->size(); j ++)
1388 : : {
1389 [ # # ]: 0 : const CubitSimpleAttrib& csa = p_csas->get_and_step();
1390 [ # # ]: 0 : lump->remove_simple_attribute_virt(csa);
1391 : : }
1392 [ # # ][ # # ]: 0 : delete p_csas;
1393 : : }
1394 : :
1395 [ # # ]: 0 : return CUBIT_SUCCESS;
1396 : : }
1397 : :
1398 : 241 : CubitBoolean OCCQueryEngine::Write(const TopoDS_Shape& Sh,
1399 : : const Standard_CString File,
1400 : : TDF_Label label)
1401 : : {
1402 [ + - ]: 241 : ofstream os;
1403 [ + - ]: 241 : os.open(File, ios::out);
1404 [ + - ][ - + ]: 241 : if (!os.rdbuf()->is_open()) return Standard_False;
1405 : :
1406 [ + - ][ + - ]: 241 : CubitBoolean isGood = (os.good() && !os.eof());
[ + - ][ + - ]
1407 [ - + ]: 241 : if(!isGood)
1408 : 0 : return isGood;
1409 : :
1410 [ + - ][ + - ]: 482 : OCCShapeAttributeSet SS;
1411 [ + - ]: 241 : SS.Add(Sh);
1412 : :
1413 [ + - ]: 241 : os << "DBRep_DrawableShape\n"; // for easy Draw read
1414 [ + - ]: 241 : SS.Write(os);
1415 [ + - ]: 241 : isGood = os.good();
1416 [ + - ]: 241 : if(isGood )
1417 [ + - ]: 241 : SS.Write(Sh,os,&label);
1418 [ + - ]: 241 : os.flush();
1419 [ + - ]: 241 : isGood = os.good();
1420 [ + - ]: 241 : os.close();
1421 [ + - ][ + - ]: 241 : isGood = os.good() && isGood;
[ + - ]
1422 : :
1423 [ + - ]: 241 : return isGood;
1424 : : }
1425 : :
1426 : 0 : CubitBoolean OCCQueryEngine::Write(const TopoDS_Shape& Sh,
1427 : : char*& pBuffer,
1428 : : int& n_buffer_size,
1429 : : bool b_write_buffer,
1430 : : TDF_Label label)
1431 : : {
1432 : : // make buffer as ouput stream
1433 [ # # ][ # # ]: 0 : std::stringbuf sb;
1434 [ # # ][ # # ]: 0 : std::iostream os(&sb);
1435 [ # # ][ # # ]: 0 : OCCShapeAttributeSet SS;
1436 : :
1437 : : // write to output stream
1438 [ # # ]: 0 : SS.Add(Sh);
1439 [ # # ]: 0 : os << "DBRep_DrawableShape\n"; // for easy Draw read
1440 [ # # ]: 0 : SS.Write(os);
1441 [ # # ]: 0 : CubitBoolean isGood = os.good();
1442 [ # # ]: 0 : if (!isGood) return isGood;
1443 [ # # ]: 0 : SS.Write(Sh,os,&label);
1444 [ # # ]: 0 : isGood = os.good();
1445 [ # # ]: 0 : if (!isGood) return isGood;
1446 : :
1447 [ # # ][ # # ]: 0 : n_buffer_size = os.rdbuf()->pubseekoff(0, std::ios_base::end, std::ios::out);
[ # # ]
1448 : :
1449 : : // get real geometries from output stream to buffer
1450 [ # # ][ # # ]: 0 : if (b_write_buffer) os.read(pBuffer, n_buffer_size);
1451 : :
1452 [ # # ]: 0 : return CUBIT_TRUE;
1453 : : }
1454 : :
1455 : 186 : CubitBoolean OCCQueryEngine::Read(TopoDS_Shape& Sh,
1456 : : const Standard_CString File,
1457 : : TDF_Label label)
1458 : : {
1459 [ + - ]: 186 : ifstream in( File );
1460 [ + - ][ - + ]: 186 : if (in.fail()) {
1461 [ # # ][ # # ]: 0 : PRINT_INFO("%s: Cannot open file", File );
[ # # ][ # # ]
1462 : 0 : return CUBIT_FAILURE;
1463 : : }
1464 : :
1465 [ + - ][ + - ]: 372 : OCCShapeAttributeSet SS;
1466 [ + - ]: 186 : SS.Read(in, CUBIT_TRUE);
1467 [ + - ]: 186 : int nbshapes = SS.NbShapes();
1468 [ - + ]: 186 : if(!nbshapes) return CUBIT_FALSE;
1469 [ + - ]: 186 : SS.Read(Sh,in,nbshapes, &label);
1470 [ + - ]: 372 : return CUBIT_TRUE;
1471 : : }
1472 : :
1473 : 0 : CubitBoolean OCCQueryEngine::Read(TopoDS_Shape& Sh,
1474 : : const char* pBuffer,
1475 : : const int n_buffer_size,
1476 : : TDF_Label label)
1477 : : {
1478 : : // make buffer as input stream
1479 [ # # ][ # # ]: 0 : std::stringbuf sb;
1480 [ # # ][ # # ]: 0 : std::iostream is(&sb);
1481 [ # # ]: 0 : is.write(pBuffer, n_buffer_size);
1482 : :
1483 : : // read from input stream
1484 [ # # ][ # # ]: 0 : OCCShapeAttributeSet SS;
1485 [ # # ]: 0 : SS.Read(is, false);
1486 [ # # ]: 0 : int nbshapes = SS.NbShapes();
1487 [ # # ]: 0 : if (!nbshapes) return CUBIT_FALSE;
1488 [ # # ]: 0 : SS.Read(Sh, is, nbshapes, &label);
1489 : :
1490 [ # # ]: 0 : return CUBIT_TRUE;
1491 : : }
1492 : :
1493 : : CubitStatus
1494 : 0 : OCCQueryEngine::import_temp_geom_file(FILE* file_ptr,
1495 : : const char* file_name,
1496 : : Model_File_Type file_type,
1497 : : DLIList<TopologyBridge*> &bridge_list )
1498 : : {
1499 [ # # ]: 0 : ModelImportOptions M_O;
1500 [ # # ][ # # ]: 0 : return import_solid_model( file_name, file_type, bridge_list, M_O );
1501 : : }
1502 : :
1503 : : //===========================================================================
1504 : : //Function Name:import_solid_model
1505 : : //Member Type: PUBLIC
1506 : : //Description: function called for read in temporary Brep file
1507 : : //Author: Jane Hu
1508 : : //Date: 11/16/2007
1509 : : //===========================================================================
1510 : :
1511 : 927 : CubitStatus OCCQueryEngine::import_solid_model(
1512 : : const char* file_name ,
1513 : : Model_File_Type file_type,
1514 : : DLIList<TopologyBridge*> &imported_entities,
1515 : : ModelImportOptions &import_options)
1516 : : {
1517 [ + - ][ + - ]: 927 : TopoDS_Shape *aShape = new TopoDS_Shape;
1518 : :
1519 : : //BRep_Builder aBuilder;
1520 [ + + ]: 927 : if(file_type == OCC_TYPE)
1521 : : {
1522 [ + - ]: 186 : Standard_Boolean result = Read(*aShape, (char*) file_name, mainLabel);
1523 [ - + ]: 186 : if (result==0) return CUBIT_FAILURE;
1524 : : }
1525 : : #ifdef HAVE_OCC_STEP
1526 [ + + ]: 741 : else if (file_type == STEP_TYPE)
1527 : : {
1528 [ + - ]: 719 : STEPControl_Reader reader;
1529 : : /*
1530 : : char* name = "xstep.cascade.unit";
1531 : : char* unit = "M";
1532 : : Standard_CString orig_unit = Interface_Static::CVal(name);
1533 : : Interface_Static::SetCVal (name, unit); //this set is good for both step
1534 : : // and iges files.
1535 : : */
1536 [ + - ]: 719 : IFSelect_ReturnStatus stat = reader.ReadFile( (char*) file_name);
1537 : : /*
1538 : : //set the unit back.
1539 : : Interface_Static::SetCVal (name,orig_unit);
1540 : : */
1541 [ - + ]: 719 : if (stat != IFSelect_RetDone)
1542 : : {
1543 [ # # ][ # # ]: 0 : PRINT_INFO("%s: Cannot open file", file_name );
[ # # ][ # # ]
1544 : 0 : return CUBIT_FAILURE;
1545 : : }
1546 [ + - ]: 719 : reader.TransferRoots();
1547 [ + - ][ + - ]: 719 : *aShape = reader.OneShape();
[ + - ][ + - ]
[ + - ]
1548 : : }
1549 : : #endif
1550 : : #ifdef HAVE_OCC_IGES
1551 [ + - ]: 22 : else if(file_type == IGES_TYPE)
1552 : : {
1553 [ + - ]: 22 : IGESControl_Reader reader;
1554 : : /*
1555 : : char* name = "xstep.cascade.unit";
1556 : : char* unit = "M";
1557 : : Interface_Static::SetCVal (name, unit); //this set is good for both step
1558 : : // and iges files.
1559 : : */
1560 : 22 : const Standard_CString string1 = file_name;
1561 [ + - ]: 22 : IFSelect_ReturnStatus stat = reader.ReadFile( string1);
1562 : :
1563 : : // Interface_Static::SetCVal (name, "MM");
1564 : :
1565 [ - + ]: 22 : if (stat != IFSelect_RetDone)
1566 : : {
1567 [ # # ][ # # ]: 0 : PRINT_INFO("%s: Cannot open file", file_name );
[ # # ][ # # ]
1568 : 0 : return CUBIT_FAILURE;
1569 : : }
1570 [ + - ]: 22 : reader.TransferRoots();
1571 [ + - ][ + - ]: 22 : *aShape = reader.OneShape();
[ + - ][ + - ]
[ + - ]
1572 : : }
1573 : : #endif
1574 : : else
1575 : : {
1576 [ # # ][ # # ]: 0 : PRINT_ERROR("File formats other than OCC, STEP and IGES are not supported by OCC\n");
[ # # ][ # # ]
1577 : 0 : return CUBIT_FAILURE;
1578 : : }
1579 : :
1580 : : //All read in shapes are wrapped inside a compound shape. Ignore this one
1581 [ + - ]: 927 : TopoDS_Iterator it(*aShape);
1582 [ + - ][ + + ]: 927 : if(aShape->ShapeType() != TopAbs_COMPOUND)
1583 : : {
1584 [ + - ][ + - ]: 627 : imported_entities += populate_topology_bridge(*aShape);
[ + - ]
1585 : 627 : return CUBIT_SUCCESS;
1586 : : }
1587 : :
1588 [ + - ][ + - ]: 1463 : for(;it.More();it.Next())
[ + + ]
1589 : : {
1590 [ + - ][ + - ]: 1163 : TopoDS_Shape shape = it.Value();
1591 [ + - ][ + - ]: 1163 : imported_entities += populate_topology_bridge(shape);
[ + - ]
1592 [ + - ]: 1163 : }
1593 : :
1594 [ + - ]: 927 : return CUBIT_SUCCESS;
1595 : : }
1596 : :
1597 : 0 : CubitStatus OCCQueryEngine::import_solid_model(DLIList<TopologyBridge*> &imported_entities,
1598 : : const char* pBuffer,
1599 : : const int n_buffer_size)
1600 : : {
1601 [ # # ][ # # ]: 0 : TopoDS_Shape *aShape = new TopoDS_Shape;
1602 [ # # ]: 0 : Standard_Boolean result = Read(*aShape, pBuffer, n_buffer_size, mainLabel);
1603 [ # # ]: 0 : if (result==0) return CUBIT_FAILURE;
1604 : :
1605 : : //All read in shapes are wrapped inside a compound shape. Ignore this one
1606 [ # # ]: 0 : TopoDS_Iterator it(*aShape);
1607 [ # # ][ # # ]: 0 : if(aShape->ShapeType() != TopAbs_COMPOUND)
1608 : : {
1609 [ # # ][ # # ]: 0 : imported_entities += populate_topology_bridge(*aShape);
[ # # ]
1610 : 0 : return CUBIT_SUCCESS;
1611 : : }
1612 : :
1613 [ # # ][ # # ]: 0 : for(;it.More();it.Next())
[ # # ]
1614 : : {
1615 [ # # ][ # # ]: 0 : TopoDS_Shape shape = it.Value();
1616 [ # # ][ # # ]: 0 : imported_entities += populate_topology_bridge(shape);
[ # # ]
1617 [ # # ]: 0 : }
1618 : :
1619 [ # # ]: 0 : return CUBIT_SUCCESS;
1620 : : }
1621 : :
1622 : : //===========================================================================
1623 : : //Function Name:populate_topology_bridge
1624 : : //Member Type: PUBLIC
1625 : : //Description: function called for populating topology bridge for OCC entity
1626 : : //Author: Jane Hu
1627 : : //Date: 11/16/2007
1628 : : //===========================================================================
1629 : :
1630 : 2096 : DLIList<TopologyBridge*> OCCQueryEngine::populate_topology_bridge(TopoDS_Shape& aShape)
1631 : : {
1632 : 2096 : DLIList<TopologyBridge*> tblist;
1633 : : // suitable to populate for a TopoDS_Compound shape.
1634 [ + - ][ + + ]: 2096 : if ( aShape.ShapeType() == TopAbs_COMPOUND)
1635 [ + - ][ + - ]: 229 : tblist.append(populate_topology_bridge(TopoDS::Compound(aShape)));
[ + - ]
1636 : :
1637 [ + - ][ + + ]: 1867 : else if(aShape.ShapeType() == TopAbs_SOLID)
1638 : : {
1639 : : Lump *lump =
1640 [ + - ][ + - ]: 1116 : populate_topology_bridge(TopoDS::Solid(aShape), CUBIT_TRUE);
1641 [ - + ][ + - ]: 1116 : tblist.append(CAST_TO(lump, OCCLump)->get_body());
[ + - ]
1642 : : }
1643 : :
1644 [ + - ][ + + ]: 751 : else if(aShape.ShapeType() == TopAbs_SHELL)
1645 : : {
1646 : : OCCShell* shell =
1647 [ + - ][ + - ]: 311 : populate_topology_bridge(TopoDS::Shell(aShape), CUBIT_TRUE);
1648 [ + - ][ + - ]: 311 : tblist.append(shell->my_body());
1649 : : }
1650 : :
1651 [ + - ][ + + ]: 440 : else if(aShape.ShapeType() == TopAbs_FACE)
1652 : : {
1653 : : Surface* face =
1654 [ + - ][ + - ]: 231 : populate_topology_bridge(TopoDS::Face(aShape), CUBIT_TRUE);
1655 [ + - ]: 231 : if(face)
1656 [ - + ][ + - ]: 231 : tblist.append(CAST_TO(face, OCCSurface)->my_body());
[ + - ]
1657 : : }
1658 : :
1659 [ + - ][ - + ]: 209 : else if(aShape.ShapeType() == TopAbs_WIRE)
1660 [ # # ][ # # ]: 0 : populate_topology_bridge(TopoDS::Wire(aShape), CUBIT_TRUE);
1661 : :
1662 [ + - ][ + - ]: 209 : else if(aShape.ShapeType() == TopAbs_EDGE)
1663 [ + - ][ + - ]: 209 : tblist.append(populate_topology_bridge(TopoDS::Edge(aShape),CUBIT_TRUE));
[ + - ]
1664 : :
1665 [ # # ][ # # ]: 0 : else if(aShape.ShapeType() == TopAbs_VERTEX)
1666 [ # # ][ # # ]: 0 : tblist.append(populate_topology_bridge(TopoDS::Vertex(aShape), CUBIT_TRUE));
[ # # ]
1667 : : else
1668 [ # # ][ # # ]: 0 : PRINT_ERROR("Wrong topology type is given. \n");
[ # # ][ # # ]
1669 [ + - ]: 2096 : tblist.remove_all_with_value(NULL);
1670 : 2096 : return tblist;
1671 : : }
1672 : :
1673 : 282 : BodySM* OCCQueryEngine::populate_topology_bridge(const TopoDS_Compound& aShape)
1674 : : {
1675 [ + - ][ - + ]: 282 : if(aShape.IsNull())
1676 : 0 : return (BodySM*)NULL;
1677 : 282 : OCCBody *body = (OCCBody*)NULL;
1678 [ + - ][ - + ]: 564 : if (!OCCMap->IsBound(aShape) ||
[ # # ][ + - ]
1679 [ # # ][ # # ]: 282 : OccToCGM->find(OCCMap->Find(aShape)) == OccToCGM->end())
[ # # ][ # # ]
[ - + ][ + - ]
[ # # # # ]
1680 : : {
1681 : : //check to see if this compound has only one lump which is already in
1682 : : //in another body. Unite operation will return a one lump compound.
1683 : : //Check also if this compound has only shells. which is or has faces that
1684 : : //are already in another body. Unite faces will return such shell.
1685 [ + - ]: 282 : TopExp_Explorer Ex;
1686 : 282 : int num_lumps = 0, num_shells = 0, num_faces = 0;
1687 [ + - ][ + - ]: 564 : TopoDS_Solid solid;
[ + + ]
1688 [ + - ][ + - ]: 859 : for (Ex.Init(aShape, TopAbs_SOLID); Ex.More(); Ex.Next())
[ + - ][ + + ]
1689 : : {
1690 : 577 : num_lumps++;
1691 [ + - ][ + - ]: 577 : solid = TopoDS::Solid(Ex.Current());
[ + - ]
1692 : : }
1693 : :
1694 [ + - ][ + - ]: 564 : TopoDS_Shell shell;
[ + + ]
1695 [ + - ][ # # ]: 282 : for (Ex.Init(aShape, TopAbs_SHELL, TopAbs_SOLID); Ex.More(); Ex.Next())
[ + - ][ - + ]
1696 : : {
1697 : 0 : num_shells++;
1698 [ # # ][ # # ]: 0 : shell = TopoDS::Shell(Ex.Current());
[ # # ]
1699 : : }
1700 : :
1701 [ + - ][ + - ]: 564 : TopoDS_Face face;
[ + + ]
1702 [ + - ][ # # ]: 282 : for (Ex.Init(aShape, TopAbs_FACE, TopAbs_SHELL); Ex.More(); Ex.Next())
[ + - ][ - + ]
1703 : : {
1704 : 0 : num_faces++;
1705 [ # # ][ # # ]: 0 : face = TopoDS::Face(Ex.Current());
[ # # ]
1706 : : }
1707 : :
1708 [ + + ]: 282 : if(num_faces + num_shells + num_lumps == 1)
1709 : : {
1710 [ - + ][ # # ]: 370 : if (num_faces == 1 && (!OCCMap->IsBound(face) ||
[ # # ][ # # ]
[ - + ]
1711 [ # # ][ # # ]: 185 : OccToCGM->find(OCCMap->Find(face)) == OccToCGM->end()))
[ # # ][ # # ]
[ - + ][ + - ]
[ # # # # ]
1712 : : {
1713 [ # # ]: 0 : Surface* surface = populate_topology_bridge(face, CUBIT_TRUE);
1714 [ # # ][ # # ]: 0 : return CAST_TO(surface, OCCSurface)->my_body();
1715 : : }
1716 [ - + ][ # # ]: 370 : else if (num_shells == 1 && (!OCCMap->IsBound(shell)||
[ # # ][ # # ]
[ - + ]
1717 [ # # ][ # # ]: 185 : OccToCGM->find(OCCMap->Find(shell)) == OccToCGM->end()))
[ # # ][ # # ]
[ - + ][ + - ]
[ # # # # ]
1718 : : {
1719 [ # # ]: 0 : OCCShell* occ_shell = populate_topology_bridge(shell, CUBIT_TRUE);
1720 [ # # ]: 0 : return occ_shell->my_body();
1721 : : }
1722 [ + - ][ + - ]: 718 : else if( num_lumps == 1 && (!OCCMap->IsBound(solid) ||
[ + + ][ - + ]
[ + + ]
1723 [ + - ][ + - ]: 533 : OccToCGM->find(OCCMap->Find(solid)) == OccToCGM->end()))
[ + - ][ + - ]
[ + + ][ + + ]
[ # # # # ]
1724 : : {
1725 [ + - ]: 11 : Lump* lump= populate_topology_bridge(solid, CUBIT_TRUE);
1726 [ - + ][ + - ]: 11 : return CAST_TO(lump, OCCLump)->get_body();
1727 : : }
1728 : : else //find existing body
1729 : : {
1730 : : int k;
1731 [ + - ]: 174 : if(num_lumps == 1)
1732 : : {
1733 [ + - ]: 174 : k = OCCMap->Find(solid);
1734 [ + - ][ + - ]: 174 : OCCLump* lump = (OCCLump*)(OccToCGM->find(k))->second;
1735 [ + - ][ - + ]: 174 : body = CAST_TO(lump->get_body(), OCCBody);
1736 : : }
1737 [ # # ]: 0 : else if (num_shells == 1)
1738 : : {
1739 [ # # ]: 0 : k = OCCMap->Find(shell);
1740 [ # # ][ # # ]: 0 : OCCShell* occ_shell = (OCCShell*)(OccToCGM->find(k))->second;
1741 [ # # ]: 0 : body = occ_shell->my_body();
1742 : : }
1743 : : else
1744 : : {
1745 [ # # ]: 0 : k = OCCMap->Find(face);
1746 [ # # ][ # # ]: 0 : OCCSurface* occ_surface = (OCCSurface*) (OccToCGM->find(k))->second;
1747 [ # # ]: 174 : body = occ_surface->my_body();
1748 : : }
1749 : : }
1750 : : }
1751 : :
1752 : : else
1753 : : {
1754 [ + - ][ + - ]: 97 : TopoDS_Compound *comsolid = new TopoDS_Compound;
1755 [ + - ]: 97 : *comsolid = aShape;
1756 [ + - ][ + - ]: 97 : body = new OCCBody(comsolid);
1757 : : int current_id;
1758 [ + - ][ + - ]: 97 : if(!OCCMap->IsBound(aShape))
1759 : : {
1760 : 97 : iTotalTBCreated++;
1761 : 97 : current_id = iTotalTBCreated;
1762 [ + - ]: 97 : OCCMap->Bind(aShape, current_id);
1763 : : }
1764 : :
1765 : : else
1766 [ # # ]: 0 : current_id = OCCMap->Find(aShape);
1767 : :
1768 : : OccToCGM->insert(valType(current_id,
1769 [ + - ][ + - ]: 97 : (TopologyBridge*)body));
1770 [ + - ][ + - ]: 282 : BodyList->append(body);
[ + + ]
1771 : 282 : }
1772 : : }
1773 : : else
1774 : : {
1775 [ # # ]: 0 : int k = OCCMap->Find(aShape);
1776 [ # # ][ # # ]: 0 : body = (OCCBody*)(OccToCGM->find(k))->second;
1777 [ # # ]: 0 : TopoDS_Compound compound = aShape;
1778 [ # # ][ # # ]: 0 : body->set_TopoDS_Shape(compound);
1779 : : }
1780 : :
1781 [ + - ]: 271 : TopExp_Explorer Ex;
1782 [ + - ][ + - ]: 542 : DLIList<Lump*> lumps;
1783 [ + - ][ + - ]: 837 : for (Ex.Init(aShape, TopAbs_SOLID); Ex.More(); Ex.Next())
[ + - ][ + + ]
1784 : : {
1785 [ + - ][ + - ]: 566 : TopoDS_Shape sh = Ex.Current();
1786 [ + - ][ + - ]: 566 : Lump* lump = populate_topology_bridge(TopoDS::Solid(sh));
1787 [ + - ]: 566 : lumps.append(lump);
1788 [ - + ][ + - ]: 566 : CAST_TO(lump, OCCLump)->add_body(body);
1789 : : //add the solid shape into map
1790 [ + - ][ + - ]: 1132 : TopoDS_Shape parent = aShape;
1791 : : int current_id;
1792 [ + - ]: 566 : add_shape_to_map(sh, parent, current_id);
1793 [ + - ][ + - ]: 2264 : if(!OCCMap->IsBound(sh) ||
[ + + ][ + + ]
1794 [ + - ][ + - ]: 1698 : OccToCGM->find(OCCMap->Find(sh)) == OccToCGM->end())
[ + - ][ + - ]
[ + - ][ - + ]
[ # # # # ]
1795 [ + - ][ + - ]: 392 : OccToCGM->insert(valType(current_id, (TopologyBridge*)lump));
1796 [ + - ]: 566 : }
1797 [ + - ]: 271 : body->lumps(lumps);
1798 : :
1799 [ + - ][ + - ]: 542 : DLIList<OCCShell*> shells;
1800 [ + - ][ # # ]: 271 : for (Ex.Init(aShape, TopAbs_SHELL, TopAbs_SOLID);Ex.More(); Ex.Next())
[ + - ][ - + ]
1801 : : {
1802 [ # # ][ # # ]: 0 : TopoDS_Shape sh = Ex.Current();
1803 [ # # ][ # # ]: 0 : OCCShell * shell = populate_topology_bridge(TopoDS::Shell(sh));
1804 [ # # ]: 0 : OCCLump* lump = shell->my_lump();
1805 [ # # ]: 0 : if(lump == (OCCLump*)NULL)
1806 [ # # ][ # # ]: 0 : lump = new OCCLump(NULL, NULL, shell);
1807 [ # # ]: 0 : lumps.append(lump);
1808 [ # # ]: 0 : lump->add_body(body);
1809 [ # # ]: 0 : shell->set_body(body);
1810 [ # # ]: 0 : shell->set_lump(lump);
1811 [ # # ]: 0 : shells.append(shell);
1812 [ # # ][ # # ]: 0 : TopoDS_Shape parent = aShape;
1813 : : int current_id;
1814 [ # # ]: 0 : add_shape_to_map(sh, parent, current_id);
1815 [ # # ][ # # ]: 0 : if(!OCCMap->IsBound(sh) ||
[ # # ][ # # ]
1816 [ # # ][ # # ]: 0 : OccToCGM->find(OCCMap->Find(sh)) == OccToCGM->end())
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # # ]
1817 [ # # ][ # # ]: 0 : OccToCGM->insert(valType(current_id, (TopologyBridge*)shell));
1818 [ # # ]: 0 : }
1819 [ + - ][ + - ]: 271 : body->shells(shells);
[ + - ]
1820 : :
1821 [ + - ][ + - ]: 542 : DLIList<OCCSurface*> surfaces;
1822 [ + - ][ # # ]: 271 : for (Ex.Init(aShape, TopAbs_FACE, TopAbs_SHELL);Ex.More(); Ex.Next())
[ + - ][ - + ]
1823 : : {
1824 [ # # ][ # # ]: 0 : TopoDS_Shape sh = Ex.Current();
1825 [ # # ][ # # ]: 0 : Surface* face = populate_topology_bridge(TopoDS::Face(sh));
1826 [ # # ]: 0 : OCCSurface *surface = CAST_TO(face, OCCSurface);
1827 [ # # ]: 0 : OCCShell* shell = surface->my_shell();
1828 [ # # ]: 0 : if (shell == (OCCShell*) NULL)
1829 [ # # ][ # # ]: 0 : shell = new OCCShell(NULL, surface);
1830 [ # # ]: 0 : OCCLump* lump = surface->my_lump();
1831 [ # # ]: 0 : if(lump == (OCCLump*) NULL)
1832 [ # # ][ # # ]: 0 : lump = new OCCLump(NULL, surface);
1833 [ # # ]: 0 : lumps.append(lump);
1834 [ # # ]: 0 : lump->add_body(body);
1835 [ # # ]: 0 : surface->set_body(body);
1836 [ # # ]: 0 : surface->set_lump(lump);
1837 [ # # ]: 0 : surface->set_shell(shell);
1838 [ # # ]: 0 : shell->set_body(body);
1839 [ # # ]: 0 : shell->set_lump(lump);
1840 [ # # ][ # # ]: 0 : TopoDS_Shape parent = aShape;
1841 [ # # ]: 0 : surfaces.append(surface);
1842 : : int current_id;
1843 [ # # ]: 0 : add_shape_to_map(sh, parent, current_id);
1844 [ # # ][ # # ]: 0 : if(!OCCMap->IsBound(sh) ||
[ # # ][ # # ]
1845 [ # # ][ # # ]: 0 : OccToCGM->find(OCCMap->Find(sh)) == OccToCGM->end())
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # # ]
1846 [ # # ][ # # ]: 0 : OccToCGM->insert(valType(current_id, (TopologyBridge*)face));
1847 : :
1848 [ # # ]: 0 : }
1849 [ + - ][ + - ]: 271 : body->set_sheet_surfaces(surfaces);
[ + - ]
1850 [ + - ]: 282 : return body;
1851 : : }
1852 : :
1853 : 2533 : Lump* OCCQueryEngine::populate_topology_bridge(const TopoDS_Solid& aShape,
1854 : : CubitBoolean build_body)
1855 : : {
1856 [ + - ][ - + ]: 2533 : if(aShape.IsNull())
1857 : 0 : return (Lump*)NULL;
1858 : :
1859 : 2533 : OCCLump *lump = NULL;
1860 : 2533 : OCCBody *body = NULL;
1861 : 2533 : int current_lump_number = 0;
1862 [ + - ][ + + ]: 6022 : if (!OCCMap->IsBound(aShape) ||
[ + + ][ + + ]
1863 [ + - ][ + - ]: 3489 : OccToCGM->find(OCCMap->Find(aShape)) == OccToCGM->end())
[ + - ][ + - ]
[ + + ][ + + ]
[ # # # # ]
1864 : : {
1865 [ + - ][ + - ]: 2238 : TopoDS_Solid *posolid = new TopoDS_Solid;
1866 [ + - ]: 2238 : *posolid = aShape;
1867 [ + - ][ + - ]: 2238 : lump = new OCCLump(posolid);
1868 [ + + ]: 2238 : if (build_body)
1869 : : {
1870 [ + - ][ + + ]: 1846 : if(OCCMap->IsBound(aShape))
1871 [ + - ]: 183 : current_lump_number = OCCMap->Find(aShape);
1872 : : else
1873 : : {
1874 : 1663 : iTotalTBCreated++;
1875 : 1663 : current_lump_number = iTotalTBCreated;
1876 : : }
1877 [ + - ][ + - ]: 1846 : body = new OCCBody(NULL, NULL, NULL, lump);
1878 [ + - ]: 1846 : DLIList<CubitSimpleAttrib> csa_list;
1879 [ + - ]: 1846 : lump->get_simple_attribute(csa_list);
1880 : : //if there's body attribute, append it to body and delete it from lump.
1881 [ + - ][ + + ]: 2175 : for(int i = 0; i < csa_list.size(); i++)
1882 : : {
1883 [ + - ]: 329 : const CubitSimpleAttrib& csa = csa_list.get_and_step();
1884 [ + - ][ + - ]: 329 : CubitString type = csa.string_data_list()[0];
[ + - ]
1885 [ + - ][ + - ]: 658 : CubitString subtype = type.substr(0,12);
1886 [ + - ][ + - ]: 329 : if(subtype == "#SINGLELUMP%")
[ + - ][ + + ]
1887 : : {
1888 [ + - ]: 146 : lump->remove_simple_attribute_virt(csa);
1889 [ + - ]: 146 : CubitSimpleAttrib copy = csa;
1890 [ + - ][ + - ]: 146 : copy.string_data_list().erase(copy.string_data_list().begin());
[ + - ][ + - ]
1891 [ + - ][ + - ]: 146 : body->append_simple_attribute_virt(copy);
1892 : : }
1893 [ + - ]: 329 : }
1894 [ + - ]: 1846 : BodyList->append(body);
1895 [ + - ][ + - ]: 2238 : lump->add_body(body);
1896 : : }
1897 : : }
1898 : : else
1899 : : {
1900 [ + - ]: 295 : int k = OCCMap->Find(aShape);
1901 [ + - ][ + - ]: 295 : lump = (OCCLump*)(OccToCGM->find(k))->second;
1902 [ + - ][ + - ]: 295 : lump->set_TopoDS_Solid(aShape);
[ + - ]
1903 [ + - ]: 295 : body = static_cast<OCCBody*>(lump->get_body());
1904 : 295 : TopoDS_Shape *b_shape = NULL;
1905 [ + - ]: 295 : if(body)
1906 [ + - ]: 295 : body->get_TopoDS_Shape(b_shape);
1907 [ + - ][ + + ]: 295 : if (!body || b_shape == NULL)
1908 : : {
1909 [ + - ]: 88 : if(body)
1910 [ + - ]: 88 : BodyList->remove(body);
1911 [ + - ][ + - ]: 88 : body = new OCCBody(NULL, NULL, NULL, lump);
1912 [ + - ]: 88 : BodyList->append(body);
1913 [ + - ]: 295 : lump->add_body(body);
1914 : : }
1915 : : }
1916 : :
1917 : 2533 : TopoDS_Compound *shape = NULL;
1918 [ + + ]: 2533 : if(body)
1919 [ + - ]: 2141 : shape = body->get_TopoDS_Shape();
1920 : :
1921 [ + + ][ + - ]: 2533 : if(build_body && OCCMap->IsBound(aShape) && shape && !shape->IsNull())
[ + + ][ - + ]
[ # # ][ # # ]
[ - + ]
1922 : : {
1923 [ # # ][ # # ]: 0 : PRINT_ERROR("Single lump body shouldn't have Compound shape.\n");
[ # # ][ # # ]
1924 : 0 : return (Lump*) NULL;
1925 : : }
1926 : :
1927 [ + - ]: 2533 : TopExp_Explorer Ex;
1928 [ + - ][ + - ]: 5126 : for (Ex.Init(aShape, TopAbs_SHELL); Ex.More(); Ex.Next())
[ + - ][ + + ]
1929 : : {
1930 [ + - ][ + - ]: 2593 : TopoDS_Shape sh = Ex.Current();
1931 [ + - ][ + - ]: 2593 : OCCShell* shell = populate_topology_bridge(TopoDS::Shell(sh));
1932 [ + - ]: 2593 : shell->set_lump(lump);
1933 [ + - ]: 2593 : shell->set_body(body);
1934 [ + - ][ + - ]: 5186 : TopoDS_Shape parent = aShape;
1935 : : int current_id;
1936 [ + - ]: 2593 : add_shape_to_map(sh, parent, current_id);
1937 [ + - ][ + - ]: 10372 : if(!OCCMap->IsBound(sh) ||
[ + + ][ + + ]
1938 [ + - ][ + - ]: 7779 : OccToCGM->find(OCCMap->Find(sh)) == OccToCGM->end())
[ + - ][ + - ]
[ + - ][ - + ]
[ # # # # ]
1939 [ + - ][ + - ]: 2298 : OccToCGM->insert(valType(current_id, (TopologyBridge*)shell));
1940 [ + - ]: 2593 : }
1941 : :
1942 [ + + ][ + - ]: 5674 : if(build_body && (!OCCMap->IsBound(aShape)||
[ + + ][ + + ]
[ + + ]
1943 [ + - ][ + - ]: 3141 : OccToCGM->find(OCCMap->Find(aShape)) == OccToCGM->end()))
[ + - ][ + - ]
[ + + ][ + + ]
[ # # # # ]
1944 : : {
1945 [ + - ][ + + ]: 1846 : if (!OCCMap->IsBound(aShape))
1946 [ + - ]: 1663 : OCCMap->Bind(aShape, current_lump_number);
1947 : : OccToCGM->insert(valType(current_lump_number,
1948 [ + - ][ + - ]: 1846 : (TopologyBridge*)lump));
1949 : : }
1950 [ + - ]: 2533 : return lump;
1951 : : }
1952 : :
1953 : 262761 : void OCCQueryEngine::add_shape_to_map(TopoDS_Shape& sh,
1954 : : TopoDS_Shape& aShape, /*In, parent */
1955 : : int ¤t_id /*Out*/)
1956 : : {
1957 : : //add the shape into map
1958 [ - + ]: 262761 : if(sh.IsNull())
1959 : 262761 : return;
1960 : :
1961 [ + - ][ + + ]: 860188 : if(!OCCMap->IsBound(sh) ||
[ + + ][ + + ]
1962 [ + - ][ + - ]: 597427 : OccToCGM->find(OCCMap->Find(sh)) == OccToCGM->end())
[ + - ][ + - ]
[ + + ][ + + ]
[ # # # # ]
1963 : : {
1964 [ + - ]: 96198 : DLIList<TopoDS_Shape*> list;
1965 : : //find the sh shape without aShape's location.
1966 [ + - ][ + - ]: 192396 : TopLoc_Location L = aShape.Location();
[ + - ]
1967 [ + - ][ + - ]: 192396 : TopoDS_Iterator it(aShape, Standard_True, Standard_False);
1968 [ + - ][ + - ]: 192396 : TopoDS_Shape bare_shape;
1969 [ + - ][ + - ]: 450017 : for(; it.More(); it.Next())
[ + + ]
1970 : : {
1971 [ + - ][ + - ]: 353819 : TopoDS_Shape test_shape = it.Value();
1972 [ + - ]: 353819 : test_shape.Move(L);
1973 [ + - ][ + + ]: 353819 : if(sh.IsEqual(test_shape))
1974 : : {
1975 [ + - ][ + - ]: 87865 : bare_shape = it.Value();
1976 [ + - ][ + + ]: 353819 : break;
1977 : : }
1978 : 265954 : }
1979 [ + - ][ + + ]: 96198 : if(!OCCMap->IsBound(sh))
1980 : : {
1981 : 95428 : CubitBoolean shape_found = false;
1982 [ + - ][ + + ]: 95428 : if(OCCMap->IsBound(bare_shape))
1983 : : {
1984 [ + - ]: 2382 : current_id = OCCMap->Find(bare_shape);
1985 : : //There are two possiblities when coming here:
1986 : : //1. After OCCAttribute binds the bare_shape but not binds the topo.
1987 : : //2. The bare_shape is bound because it binds to a different topo.
1988 [ + - ][ + - ]: 2382 : if( OccToCGM->find(current_id) == OccToCGM->end() )
[ + - ][ + - ]
1989 : : {
1990 [ + - ]: 2382 : OCCMap->UnBind(bare_shape);
1991 : : std::map<int, TDF_Label>::iterator it =
1992 [ + - ]: 2382 : Shape_Label_Map->find(current_id);
1993 [ + - ][ + - ]: 2382 : if(it != Shape_Label_Map->end())
[ + - ]
1994 : : {
1995 [ + - ]: 2382 : TDF_Label aLabel = (*it).second;
1996 [ + - ][ + - ]: 2382 : Handle_TDataXtd_Shape attr_shape = TDataXtd_Shape::Set(aLabel, sh);
1997 : : }
1998 : 2382 : shape_found = true;
1999 : : }
2000 : : }
2001 [ + + ]: 95428 : if(!shape_found)
2002 : : {
2003 : 93046 : iTotalTBCreated++;
2004 : 93046 : current_id = iTotalTBCreated;
2005 : : }
2006 [ + - ]: 95428 : OCCMap->Bind(sh, current_id);
2007 : : }
2008 : : else
2009 [ + - ][ + - ]: 96968 : current_id = OCCMap->Find(sh);
2010 : : }
2011 : : else
2012 : 166563 : current_id = OCCMap->Find(sh);
2013 : : }
2014 : :
2015 : 2904 : OCCShell* OCCQueryEngine::populate_topology_bridge(const TopoDS_Shell& aShape,
2016 : : CubitBoolean standalone)
2017 : : {
2018 [ + - ][ - + ]: 2904 : if(aShape.IsNull())
2019 : 0 : return (OCCShell*)NULL;
2020 : : OCCShell *shell ;
2021 [ + - ][ + + ]: 6398 : if (!OCCMap->IsBound(aShape) ||
[ - + ][ + + ]
2022 [ + - ][ + - ]: 3494 : OccToCGM->find(OCCMap->Find(aShape)) == OccToCGM->end())
[ + - ][ + - ]
[ + + ][ + + ]
[ # # # # ]
2023 : : {
2024 [ + + ]: 2609 : if(standalone)
2025 : : {
2026 : : //check if just has one Face,if so, don't make new shell.
2027 [ + - ]: 311 : TopExp_Explorer Ex;
2028 : 311 : int num_faces = 0;
2029 [ + - ][ + - ]: 622 : TopoDS_Face topo_face;
[ - + ]
2030 [ + - ][ + - ]: 622 : for (Ex.Init(aShape, TopAbs_FACE); Ex.More(); Ex.Next())
[ + - ][ + + ]
2031 : : {
2032 [ + - ][ + - ]: 311 : topo_face = TopoDS::Face(Ex.Current());
[ + - ]
2033 : 311 : num_faces++;
2034 : : }
2035 [ + - ]: 311 : if(num_faces == 1)
2036 : : {
2037 [ + - ]: 311 : Surface* face = populate_topology_bridge(topo_face, standalone);
2038 [ - + ][ + - ]: 311 : return CAST_TO(face, OCCSurface)->my_shell();
[ + - ][ - + ]
2039 : 311 : }
2040 : : }
2041 [ + - ][ + - ]: 2298 : TopoDS_Shell *poshell = new TopoDS_Shell;
2042 [ + - ]: 2298 : *poshell = aShape;
2043 [ + - ][ + - ]: 2298 : shell = new OCCShell(poshell);
2044 [ + - ]: 2298 : shell->set_body(NULL);
2045 [ + - ]: 2298 : shell->set_lump(NULL);
2046 [ - + ]: 2298 : if(standalone)
2047 : : {
2048 [ # # ][ # # ]: 0 : OCCLump* lump = new OCCLump(NULL, NULL, shell);
2049 [ # # ][ # # ]: 0 : OCCBody* body = new OCCBody(NULL, NULL, shell);
2050 [ # # ]: 0 : BodyList->append(body);
2051 [ # # ]: 0 : shell->set_body(body);
2052 [ # # ]: 0 : shell->set_lump(lump);
2053 : : int k;
2054 [ # # ][ # # ]: 0 : if(!OCCMap->IsBound(aShape))
2055 : : {
2056 : 0 : iTotalTBCreated++;
2057 : 0 : k = iTotalTBCreated;
2058 [ # # ]: 0 : OCCMap->Bind(*poshell, k);
2059 : : }
2060 : : else
2061 [ # # ]: 0 : k = OCCMap->Find(aShape);
2062 [ # # ][ # # ]: 2298 : OccToCGM->insert(valType(k, (TopologyBridge*)shell));
2063 : : }
2064 : : }
2065 : : else
2066 : : {
2067 [ + - ]: 295 : int k = OCCMap->Find(aShape);
2068 [ + - ][ + - ]: 295 : shell = (OCCShell*)(OccToCGM->find(k))->second;
2069 [ + - ][ + - ]: 295 : shell->set_TopoDS_Shell(aShape);
[ + - ]
2070 : : }
2071 : :
2072 [ + - ]: 2593 : DLIList<OCCSurface*> memberSurfaces;
2073 [ + - ][ + - ]: 5186 : TopExp_Explorer Ex;
2074 [ + - ][ + - ]: 19740 : for (Ex.Init(aShape, TopAbs_FACE); Ex.More(); Ex.Next())
[ + - ][ + + ]
2075 : : {
2076 [ + - ][ + - ]: 17147 : TopoDS_Shape sh = Ex.Current();
2077 [ + - ][ + - ]: 34294 : TopoDS_Face topo_face = TopoDS::Face(sh);
[ + - ][ + - ]
2078 : : Surface* face =
2079 [ + - ]: 17147 : populate_topology_bridge(topo_face, CUBIT_FALSE);
2080 : :
2081 [ + - ][ + - ]: 34294 : TopoDS_Shape parent = aShape;
[ + - ]
2082 : : int current_id;
2083 [ + - ]: 17147 : add_shape_to_map(sh, parent, current_id);
2084 [ + - ][ + - ]: 68588 : if(!OCCMap->IsBound(sh) ||
[ + + ][ + + ]
2085 [ + - ][ + - ]: 51441 : OccToCGM->find(OCCMap->Find(sh)) == OccToCGM->end())
[ + - ][ + - ]
[ + - ][ - + ]
[ # # # # ]
2086 [ + - ][ + - ]: 15146 : OccToCGM->insert(valType(current_id, (TopologyBridge*)face));
2087 : :
2088 [ - + ]: 17147 : if(!face)
2089 : 0 : continue;
2090 [ - + ]: 17147 : OCCSurface *occ_surface = CAST_TO(face, OCCSurface);
2091 : : //check if surface was a sheet surface, delete it if so
2092 [ + - ][ + + ]: 17147 : if(occ_surface->my_shell() != NULL && occ_surface->my_shell() != shell)
[ + - ][ - + ]
[ - + ]
2093 : : {
2094 : : //if Sheet_body, delete this sheet body
2095 [ # # ]: 0 : OCCBody* occ_body = occ_surface->my_body();
2096 [ # # ]: 0 : if(occ_body != NULL)
2097 : : {
2098 [ # # ]: 0 : delete_solid_model_entities(occ_body);
2099 : : face =
2100 [ # # ]: 0 : populate_topology_bridge(topo_face, CUBIT_FALSE);
2101 : :
2102 [ # # ]: 0 : if(!face)
2103 : 0 : continue;
2104 [ # # ]: 0 : occ_surface = CAST_TO(face, OCCSurface);
2105 [ # # ]: 0 : shell->set_sheet_surface(occ_surface);
2106 : : }
2107 : : }
2108 : :
2109 [ + - ]: 17147 : memberSurfaces.append(occ_surface);
2110 [ + - ][ + - ]: 17147 : occ_surface->set_shell(shell);
[ + - ]
2111 : 17147 : }
2112 : :
2113 [ + - ][ + - ]: 2593 : shell->setMemberSurfaces(memberSurfaces);
[ + - ]
2114 [ + - ]: 2904 : return shell;
2115 : : }
2116 : :
2117 : 17832 : Surface* OCCQueryEngine::populate_topology_bridge(const TopoDS_Face& aShape,
2118 : : CubitBoolean build_body)
2119 : : {
2120 [ + - ][ - + ]: 17832 : if(aShape.IsNull())
2121 : 0 : return (Surface*)NULL;
2122 : 17832 : OCCSurface *surface = NULL;
2123 [ + - ]: 17832 : GProp_GProps myProps;
2124 [ + - ]: 17832 : BRepGProp::SurfaceProperties(aShape, myProps);
2125 [ + - ]: 17832 : double area = myProps.Mass();
2126 [ + - ]: 17832 : double tol = get_sme_resabs_tolerance();
2127 [ - + ][ # # ]: 17832 : if(area < tol * tol && area > 0.)
2128 [ # # ][ # # ]: 0 : PRINT_WARNING("Generated a sliver surface. \n");
[ # # ][ # # ]
2129 : :
2130 [ - + ]: 17832 : else if (area < 0.0)
2131 [ # # ][ # # ]: 0 : PRINT_WARNING("Generated a negative area surface. \n");
[ # # ][ # # ]
2132 : :
2133 [ + - ][ + + ]: 40436 : if (!OCCMap->IsBound(aShape) ||
[ + + ][ + + ]
2134 [ + - ][ + - ]: 22604 : OccToCGM->find(OCCMap->Find(aShape)) == OccToCGM->end())
[ + - ][ + - ]
[ + + ][ + + ]
[ # # # # ]
2135 : : {
2136 [ + - ][ + - ]: 15831 : TopoDS_Face *poface = new TopoDS_Face;
2137 [ + - ]: 15831 : *poface = aShape;
2138 [ + - ][ + - ]: 15831 : surface = new OCCSurface(poface);
2139 [ + - ]: 15831 : SurfaceList->append(surface);
2140 [ + - ]: 15831 : surface->set_body(NULL);
2141 [ + - ]: 15831 : surface->set_lump(NULL);
2142 [ + - ]: 15831 : surface->set_shell(NULL);
2143 [ + + ]: 15831 : if(build_body)
2144 : : {
2145 [ + - ][ + - ]: 619 : OCCShell* shell = new OCCShell(NULL, surface);
2146 [ + - ][ + - ]: 619 : OCCLump* lump = new OCCLump(NULL, surface);
2147 [ + - ][ + - ]: 619 : OCCBody* body = new OCCBody(NULL, surface);
2148 [ + - ]: 619 : surface->set_body(body);
2149 [ + - ]: 619 : surface->set_lump(lump);
2150 [ + - ]: 619 : surface->set_shell(shell);
2151 [ + - ]: 619 : shell->set_body(body);
2152 [ + - ]: 619 : shell->set_lump(lump);
2153 [ + - ]: 619 : BodyList->append(body);
2154 : : int k;
2155 [ + - ][ + - ]: 619 : if(!OCCMap->IsBound(aShape))
2156 : : {
2157 : 619 : iTotalTBCreated++;
2158 : 619 : k = iTotalTBCreated;
2159 [ + - ]: 619 : OCCMap->Bind(*poface, iTotalTBCreated);
2160 : : }
2161 : : else
2162 [ # # ]: 0 : k = OCCMap->Find(aShape);
2163 [ + - ][ + - ]: 15831 : OccToCGM->insert(valType(k, (TopologyBridge*)surface));
2164 : : }
2165 : : }
2166 : :
2167 : : else
2168 : : {
2169 [ + - ]: 2001 : int k = OCCMap->Find(aShape);
2170 [ + - ][ + - ]: 2001 : surface = (OCCSurface*)(OccToCGM->find(k))->second;
2171 [ + - ]: 2001 : TopoDS_Face aFace(aShape);
2172 [ + - ][ + - ]: 2001 : surface->set_TopoDS_Face(aFace);
2173 : : }
2174 : :
2175 [ + - ]: 17832 : TopExp_Explorer Ex;
2176 [ + - ][ + - ]: 36854 : for (Ex.Init(aShape.Oriented(TopAbs_FORWARD), TopAbs_WIRE); Ex.More();
[ + - ][ + - ]
[ + + ]
2177 [ + - ]: 19022 : Ex.Next())
2178 : : {
2179 [ + - ][ + - ]: 19022 : TopoDS_Shape sh = Ex.Current();
2180 : :
2181 [ + - ][ + - ]: 19022 : OCCLoop* loop = populate_topology_bridge(TopoDS::Wire(sh));
2182 : : /*
2183 : : if( aShape.Orientation() == TopAbs_REVERSED )
2184 : : {
2185 : : DLIList<OCCCoEdge*> coedges_new = loop->coedges();
2186 : : coedges_new.reverse();
2187 : : //Reverse all coedges' senses.
2188 : : for (int i = 0; i < coedges_new.size(); i ++)
2189 : : {
2190 : : OCCCoEdge* coedge = coedges_new.get_and_step();
2191 : : CubitSense sense = (coedge->sense() == CUBIT_FORWARD ? CUBIT_REVERSED : CUBIT_FORWARD);
2192 : : coedge->set_sense(sense);
2193 : : }
2194 : : loop->coedges(coedges_new);
2195 : : }
2196 : : */
2197 [ + - ][ + - ]: 38044 : TopoDS_Shape parent = aShape;
2198 : : int current_id;
2199 [ + - ]: 19022 : add_shape_to_map(sh, parent, current_id);
2200 [ + - ][ + - ]: 76088 : if(!OCCMap->IsBound(sh) ||
[ + + ][ + + ]
2201 [ + - ][ + - ]: 57066 : OccToCGM->find(OCCMap->Find(sh)) == OccToCGM->end())
[ + - ][ + - ]
[ + - ][ - + ]
[ # # # # ]
2202 [ + - ][ + - ]: 17281 : OccToCGM->insert(valType(current_id, (TopologyBridge*)loop));
2203 [ + - ]: 19022 : }
2204 : :
2205 [ + - ]: 17832 : return surface;
2206 : : }
2207 : :
2208 : 19022 : OCCLoop* OCCQueryEngine::populate_topology_bridge(const TopoDS_Wire& aShape,
2209 : : CubitBoolean standalone)
2210 : : {
2211 [ + - ][ - + ]: 19022 : if(aShape.IsNull())
2212 : 0 : return (OCCLoop*)NULL;
2213 : :
2214 [ + - ]: 19022 : BRepTools_WireExplorer Ex;
2215 : :
2216 : : OCCLoop *loop ;
2217 [ + - ][ + + ]: 41526 : if (!OCCMap->IsBound(aShape) ||
[ - + ][ + + ]
2218 [ + - ][ + - ]: 22504 : OccToCGM->find(OCCMap->Find(aShape)) == OccToCGM->end())
[ + - ][ + - ]
[ + + ][ + + ]
[ # # # # ]
2219 : : {
2220 [ + - ][ + - ]: 17281 : TopoDS_Wire *powire = new TopoDS_Wire;
2221 [ + - ]: 17281 : *powire = aShape;
2222 [ + - ][ + - ]: 17281 : loop = new OCCLoop(powire);
2223 [ - + ]: 17281 : if(standalone)
2224 : : {
2225 : : int k;
2226 [ # # ][ # # ]: 0 : if(!OCCMap->IsBound(aShape))
2227 : : {
2228 : 0 : iTotalTBCreated++;
2229 : 0 : k = iTotalTBCreated;
2230 [ # # ]: 0 : OCCMap->Bind(aShape, iTotalTBCreated);
2231 : : }
2232 : : else
2233 [ # # ]: 0 : k = OCCMap->Find(aShape);
2234 [ # # ][ # # ]: 0 : OccToCGM->insert(valType(k, (TopologyBridge*)loop));
2235 [ # # ]: 17281 : WireList->append(loop);
2236 : : }
2237 : : }
2238 : : else
2239 : : {
2240 [ + - ]: 1741 : int k = OCCMap->Find(aShape);
2241 [ + - ][ + - ]: 1741 : loop = (OCCLoop*)(OccToCGM->find(k))->second;
2242 [ + - ][ + - ]: 1741 : loop->set_TopoDS_Wire(aShape);
[ + - ]
2243 : : }
2244 : :
2245 [ + - ]: 19022 : CubitVector v;
2246 : :
2247 [ + - ][ + - ]: 38044 : DLIList <OCCCoEdge*> coedges_old, coedges_new;
[ + - ][ + - ]
2248 [ + - ][ + - ]: 19022 : coedges_old = loop->coedges();
[ + - ]
2249 : :
2250 [ + - ][ + - ]: 92486 : for (Ex.Init(aShape); Ex.More(); Ex.Next())
[ + - ][ + + ]
2251 : : {
2252 [ + - ]: 73464 : const TopoDS_Edge& anEdgeForPop = Ex.Current();
2253 [ + - ]: 73464 : TopoDS_Shape crv = anEdgeForPop;
2254 [ + - ]: 73464 : Curve* curve = populate_topology_bridge(anEdgeForPop);
2255 [ + + ]: 73464 : if(!curve)
2256 : 1035 : continue;
2257 [ + - ][ + - ]: 145893 : TopoDS_Shape parent = aShape;
[ + - ][ + + ]
2258 : : int current_id;
2259 [ + - ]: 72429 : add_shape_to_map(crv, parent, current_id);
2260 [ + - ][ + - ]: 289716 : if(!OCCMap->IsBound(crv) ||
[ + + ][ + + ]
2261 [ + - ][ + - ]: 217287 : OccToCGM->find(OCCMap->Find(crv)) == OccToCGM->end())
[ + - ][ + - ]
[ + - ][ - + ]
[ # # # # ]
2262 [ + - ][ + - ]: 34199 : OccToCGM->insert(valType(current_id, (TopologyBridge*)curve));
2263 : :
2264 [ - + ]: 72429 : OCCCurve *occ_curve = CAST_TO(curve, OCCCurve);
2265 [ + - ][ + - ]: 144858 : DLIList<OCCLoop*> loops = occ_curve->loops();
2266 : 72429 : CubitBoolean exist = CUBIT_FALSE;
2267 : 72429 : OCCCoEdge * coedge = NULL;
2268 [ + - ]: 72429 : int size = coedges_old.size();
2269 [ + - ]: 72429 : CubitSense sense = (crv.Orientation() == TopAbs_FORWARD ?
2270 : 72429 : CUBIT_FORWARD : CUBIT_REVERSED);
2271 : :
2272 : : //for the cylinder side face, there are 4 coedges, 2 of them are seam
2273 : : //edges and should have opposite sense.
2274 [ + - ][ + + ]: 197437 : for(int i = 0; i < coedges_new.size(); i++)
2275 : : {
2276 [ + - ]: 126014 : coedge = coedges_new.get_and_step();
2277 [ + - ]: 126014 : Curve* test_c = coedge->curve();
2278 [ + + ]: 126014 : if(test_c == curve)
2279 : : {
2280 [ + - ][ - + ]: 1006 : if(sense == coedge->sense())
2281 [ # # ]: 0 : sense = (sense == CUBIT_FORWARD ? CUBIT_REVERSED : CUBIT_FORWARD);
2282 : :
2283 : 1006 : break;
2284 : : }
2285 : : }
2286 : :
2287 [ + + ]: 76763 : for(int i = 0; i < size; i++)
2288 : : {
2289 [ + - ]: 9868 : coedge = coedges_old.get_and_step();
2290 [ + - ][ + + ]: 9868 : if(coedge->curve() == curve && coedge->sense() == sense)
[ + - ][ + - ]
[ + + ]
2291 : : {
2292 [ + - ]: 5534 : coedge->set_mark(1);
2293 : 5534 : exist = CUBIT_TRUE;
2294 [ + - ]: 5534 : coedge->set_sense(sense);
2295 [ + - ]: 5534 : coedges_new.append(coedge);
2296 : 5534 : break;
2297 : : }
2298 : : }
2299 : :
2300 [ + + ]: 72429 : if(!exist )
2301 : : {
2302 : : //search through the curve loops
2303 [ + - ][ + + ]: 99294 : for(int i = 0; i < loops.size() ; i++)
2304 : : {
2305 [ + - ]: 32399 : OCCLoop* occ_loop = loops.get_and_step();
2306 [ + - ]: 32399 : TopoDS_Wire* wire = occ_loop->get_TopoDS_Wire();
2307 [ + + ][ + - ]: 32399 : if (size > 0 && (wire->IsNull() || !OCCMap->IsBound(*wire)))
[ + - ][ + - ]
[ - + ][ - + ]
2308 : : {
2309 [ # # ]: 0 : DLIList<OCCCoEdge*> coedge_list = occ_loop->coedges();
2310 [ # # ][ # # ]: 0 : for(int j = 0; j < coedge_list.size(); j++)
2311 : : {
2312 [ # # ]: 0 : OCCCoEdge * test_coedge = coedge_list.get_and_step();
2313 [ # # ]: 0 : occ_loop->remove_coedge(test_coedge);
2314 [ # # ]: 0 : occ_curve->remove_loop(occ_loop);
2315 [ # # ][ # # ]: 0 : delete test_coedge;
2316 : : }
2317 [ # # ][ # # ]: 0 : if(!wire->IsNull())
2318 [ # # ]: 0 : wire->Nullify();
2319 [ # # ][ # # ]: 0 : WireList->remove(occ_loop);
2320 : : }
2321 : : }
2322 : :
2323 [ + - ][ + - ]: 66895 : if(occ_curve->loops().size() == 2)
[ + - ][ + + ]
2324 : : {
2325 : : // If there are some assumptions made about manifold geometry . . .
2326 : : //there must be a loop which doesn't have this curve anymore
2327 : : //this is been found in subtract cases while one solid becomes
2328 : : //2 solid, and one face becomes two faces. One face uses/updates
2329 : : //the old face while the other face generates face and wire from
2330 : : //new. However, in order to uses the curves, the old curve is kept
2331 : : //as possible, so curve's loops get kept, but since it's going to
2332 : : //associate with new loop, the old loop should be removed from the
2333 : : //loop list.
2334 [ + - ]: 110 : DLIList<OCCLoop*> old_loops = occ_curve->loops();
2335 [ + + ]: 330 : for (int i = 0; i < 2; i++)
2336 : : {
2337 : 220 : int found = 0;
2338 [ + - ]: 220 : OCCLoop* old_loop = old_loops.get_and_step();
2339 [ + - ]: 220 : TopoDS_Wire* thewire = old_loop->get_TopoDS_Wire();
2340 [ + - ][ + - ]: 220 : if (thewire < (void*) 0x1000 || thewire->IsNull())
[ - + ][ - + ]
2341 : : {
2342 : 0 : found = 1;
2343 : 0 : break;
2344 : : }
2345 [ + - ]: 220 : DLIList<OCCCoEdge*> test_coedges = old_loop->coedges();
2346 [ + - ][ + - ]: 550 : for(int j = 0; j < test_coedges.size() ; j++)
2347 : : {
2348 [ + - ][ + - ]: 550 : if(test_coedges.get()->curve() != curve)
[ + + ]
2349 [ + - ]: 330 : test_coedges.step();
2350 : : else
2351 : : {
2352 : 220 : found = 1;
2353 : 220 : break;
2354 : : }
2355 : : }
2356 [ - + ]: 220 : if(!found)
2357 [ # # ]: 0 : occ_curve->remove_loop(old_loop);
2358 [ + - ][ + - ]: 330 : }
2359 : : }
2360 : : //for unite case, it's possible that the a curve has 3 coedges because
2361 : : //opencascade do not perform unite on surfaces.
2362 [ + - ][ + - ]: 66895 : coedge = new OCCCoEdge( curve, loop, sense);
2363 [ + - ]: 66895 : coedges_new.append(coedge);
2364 [ + - ]: 66895 : occ_curve->add_loop(loop);
2365 : : }
2366 : 73464 : }
2367 : :
2368 : : //Double check edge sense to make sure it consists with loop direction
2369 : : //coedges size = 2 case is checked in the face level so the face normal will
2370 : : //be considered.
2371 [ + - ][ + + ]: 19022 : if(coedges_new.size() > 2)
2372 : : {
2373 [ + - ]: 16143 : OCCCoEdge* coedge = coedges_new.get_and_step();
2374 : : double d1, d1_, d2, d2_;
2375 [ + - ]: 16143 : OCCCoEdge* next_coedge = coedges_new.get();
2376 : : //because of tolerance issue, now check current loop end vertices distance
2377 : : //compared with reversed loop's end vertices distance, which ever shorter
2378 : : //will be the direction.
2379 : : //current loop's parameter not using " _ ", reversed loop's parameter
2380 : : //uses " _ ".
2381 [ + - ][ + + ]: 16143 : if (coedge->sense() == CUBIT_FORWARD)
2382 : : {
2383 [ + - ][ + - ]: 5079 : d1 = coedge->curve()->end_param();
2384 [ + - ][ + - ]: 5079 : d1_ = coedge->curve()->start_param();
2385 : : }
2386 : : else
2387 : : {
2388 [ + - ][ + - ]: 11064 : d1 = coedge->curve()->start_param();
2389 [ + - ][ + - ]: 11064 : d1_ = coedge->curve()->end_param();
2390 : : }
2391 [ + - ][ + + ]: 16143 : if( next_coedge->sense() == CUBIT_FORWARD)
2392 : : {
2393 [ + - ][ + - ]: 12149 : d2_ = next_coedge->curve()->end_param();
2394 [ + - ][ + - ]: 12149 : d2 = next_coedge->curve()->start_param();
2395 : : }
2396 : : else
2397 : : {
2398 [ + - ][ + - ]: 3994 : d2 = next_coedge->curve()->end_param();
2399 [ + - ][ + - ]: 3994 : d2_ = next_coedge->curve()->start_param();
2400 : : }
2401 [ + - ][ + - ]: 16143 : CubitVector v1, v1_, v2, v2_;
[ + - ][ + - ]
2402 [ + - ][ + - ]: 16143 : coedge->curve()->position_from_u(d1, v1);
2403 [ + - ][ + - ]: 16143 : coedge->curve()->position_from_u(d1_, v1_);
2404 [ + - ][ + - ]: 16143 : next_coedge->curve()->position_from_u(d2, v2);
2405 [ + - ][ + - ]: 16143 : next_coedge->curve()->position_from_u(d2_, v2_);
2406 [ + - ][ + - ]: 16143 : if(v1.distance_between(v2) > v1_.distance_between(v2_))
[ - + ]
2407 : : {
2408 : : //Reverse all coedges' senses.
2409 [ # # ][ # # ]: 16143 : for (int i = 0; i < coedges_new.size(); i ++)
2410 : : {
2411 [ # # ]: 0 : coedge = coedges_new.get_and_step();
2412 [ # # ][ # # ]: 0 : CubitSense sense = (coedge->sense() == CUBIT_FORWARD ? CUBIT_REVERSED : CUBIT_FORWARD);
2413 [ # # ]: 0 : coedge->set_sense(sense);
2414 : : }
2415 : : }
2416 : : }
2417 : :
2418 : : /*
2419 : : if(aShape.Orientation() == TopAbs_REVERSED)
2420 : : coedges_new.reverse();
2421 : : //Reverse all coedges' senses.
2422 : : for (int i = 0; i < coedges_new.size(); i ++)
2423 : : {
2424 : : OCCCoEdge* coedge = coedges_new.get_and_step();
2425 : : CubitSense sense = (coedge->sense() == CUBIT_FORWARD ? CUBIT_REVERSED : CUBIT_FORWARD);
2426 : : coedge->set_sense(sense);
2427 : : }
2428 : : */
2429 [ + - ][ + - ]: 19022 : loop->coedges(coedges_new);
[ + - ]
2430 : :
2431 : : //remove unused coedges
2432 [ + - ][ + + ]: 24798 : for(int i = 0; i < coedges_old.size(); i++)
2433 : : {
2434 [ + - ]: 5776 : OCCCoEdge *coedge = coedges_old.get_and_step();
2435 [ + - ][ + + ]: 5776 : if(coedge->get_mark() == 0)
2436 [ + - ][ + - ]: 242 : delete coedge;
2437 : : else
2438 [ + - ]: 5534 : coedge->set_mark(0);
2439 : : }
2440 [ + - ]: 19022 : return loop;
2441 : : }
2442 : :
2443 : 76548 : Curve* OCCQueryEngine::populate_topology_bridge(const TopoDS_Edge& aShape,
2444 : : CubitBoolean stand_along )
2445 : : {
2446 [ + - ][ - + ]: 76548 : if(aShape.IsNull())
2447 : 0 : return (Curve*)NULL;
2448 : : Curve *curve;
2449 [ + - ]: 76548 : GProp_GProps myProps;
2450 [ + - ]: 76548 : BRepGProp::LinearProperties(aShape, myProps);
2451 [ + - ]: 76548 : double length = myProps.Mass();
2452 [ + - ]: 76548 : TopExp_Explorer Ex;
2453 [ + - ][ + + ]: 76548 : if(length < get_sme_resabs_tolerance())
2454 : : {
2455 : : //check if the two vertices are acctually the same point.
2456 [ + - ][ + + ]: 3105 : CubitVector v[2];
2457 : 1035 : int i = 0;
2458 [ + - ][ + - ]: 3105 : for (Ex.Init(aShape, TopAbs_VERTEX); Ex.More(); Ex.Next())
[ + - ][ + + ]
2459 : : {
2460 [ + - ][ + - ]: 2070 : TopoDS_Vertex vt = TopoDS::Vertex(Ex.Current());
[ + - ]
2461 [ + - ]: 2070 : gp_Pnt pt = BRep_Tool::Pnt(vt);
2462 [ + - ][ + - ]: 2070 : v[i] = CubitVector(pt.X(), pt.Y(), pt.Z());
[ + - ][ + - ]
[ + - ]
2463 : 2070 : i++;
2464 [ + - ]: 2070 : }
2465 : :
2466 [ + - ][ + - ]: 1035 : if(v[0] == v[1])
2467 : 1035 : return (Curve*) NULL;
2468 : : else
2469 [ # # ][ # # ]: 0 : PRINT_WARNING("Generated a sliver curve. \n");
[ # # ][ # # ]
2470 : : }
2471 : :
2472 [ + - ][ + + ]: 228168 : if (!OCCMap->IsBound(aShape) ||
[ + + ][ + + ]
2473 [ + - ][ + - ]: 152655 : OccToCGM->find(OCCMap->Find(aShape)) == OccToCGM->end())
[ + - ][ + - ]
[ + + ][ + + ]
[ # # # # ]
2474 : : {
2475 [ + - ][ + - ]: 37272 : TopoDS_Edge *poedge = new TopoDS_Edge;
2476 [ + - ]: 37272 : *poedge = aShape;
2477 [ + - ][ + - ]: 37272 : curve = new OCCCurve(poedge);
2478 [ + - ]: 37272 : CurveList->append((OCCCurve*)curve);
2479 [ + + ]: 37272 : if(stand_along)
2480 : : {
2481 : : int k;
2482 [ + - ][ + - ]: 3062 : if(!OCCMap->IsBound(aShape))
2483 : : {
2484 : 3062 : iTotalTBCreated++;
2485 : 3062 : k = iTotalTBCreated;
2486 [ + - ]: 3062 : OCCMap->Bind(*poedge, iTotalTBCreated);
2487 : : }
2488 : : else
2489 [ # # ]: 0 : k = OCCMap->Find(aShape);
2490 [ + - ][ + - ]: 37272 : OccToCGM->insert(valType(k, (TopologyBridge*)curve));
2491 : : }
2492 : : }
2493 : : else
2494 : : {
2495 [ + - ]: 38241 : int i = OCCMap->Find(aShape);
2496 [ + - ][ + - ]: 38241 : curve = (Curve*)(OccToCGM->find(i))->second;
2497 [ + - ][ - + ]: 38241 : CAST_TO(curve, OCCCurve)->set_TopoDS_Edge(aShape);
[ + - ][ + - ]
2498 : : }
2499 : :
2500 [ + - ][ + - ]: 226517 : for (Ex.Init(aShape, TopAbs_VERTEX); Ex.More(); Ex.Next())
[ + - ][ + + ]
2501 : : {
2502 [ + - ][ + - ]: 151004 : TopoDS_Shape sh = Ex.Current();
2503 : :
2504 : : /* bool alreadyWrapped=false;
2505 : : if(OCCMap->IsBound(sh))
2506 : : {
2507 : : alreadyWrapped=true;
2508 : : }*/
2509 : :
2510 [ + - ][ + - ]: 151004 : TBPoint* point = populate_topology_bridge(TopoDS::Vertex(Ex.Current()));
[ + - ]
2511 [ - + ][ - + ]: 151004 : CAST_TO(point, OCCPoint)->add_curve(CAST_TO(curve, OCCCurve));
[ + - ]
2512 [ + - ][ + - ]: 302008 : TopoDS_Shape parent = aShape;
2513 : : int current_id;
2514 [ + - ]: 151004 : add_shape_to_map(sh, parent, current_id);
2515 [ + - ][ + - ]: 604016 : if(!OCCMap->IsBound(sh) ||
[ + + ][ + + ]
2516 [ + - ][ + - ]: 453012 : OccToCGM->find(OCCMap->Find(sh)) == OccToCGM->end())
[ + - ][ + - ]
[ + - ][ - + ]
[ # # # # ]
2517 [ + - ][ + - ]: 26882 : OccToCGM->insert(valType(current_id, (TopologyBridge*)point));
2518 : :
2519 : :
2520 : : /* if(alreadyWrapped)
2521 : : PRINT_INFO("Vertex Already Wrapped: ");
2522 : : else
2523 : : PRINT_INFO("Vertex Wrapped: ");
2524 : : PRINT_INFO(" Shape ID = %d", OCCMap->Find(sh) );
2525 : : PRINT_INFO(" TBPoint Address: %p", point );
2526 : : PRINT_INFO(" Shape Orientation: %s\n", sh.Orientation()==TopAbs_FORWARD ? "Forward" : "Reversed" );
2527 : : */
2528 : :
2529 [ + - ]: 151004 : }
2530 : :
2531 [ + - ]: 76548 : return curve;
2532 : : }
2533 : :
2534 : 151389 : TBPoint* OCCQueryEngine::populate_topology_bridge(const TopoDS_Vertex& aShape,
2535 : : CubitBoolean stand_along)
2536 : : {
2537 [ - + ]: 151389 : if(aShape.IsNull())
2538 : 0 : return (TBPoint*)NULL;
2539 : : OCCPoint *point;
2540 [ + + ][ + - ]: 551132 : if (iTotalTBCreated == 0 || !OCCMap->IsBound(aShape) ||
[ + + ][ + + ]
[ + + ]
2541 [ + - ][ + - ]: 399743 : OccToCGM->find(OCCMap->Find(aShape)) == OccToCGM->end())
[ + - ][ + - ]
[ + + ][ + + ]
[ # # # # ]
2542 : : {
2543 [ + - ]: 27267 : TopoDS_Vertex *povertex = new TopoDS_Vertex;
2544 : 27267 : *povertex = aShape;
2545 [ + - ]: 27267 : point = new OCCPoint(povertex);
2546 [ + + ]: 27267 : if(stand_along)
2547 : : {
2548 : : int k;
2549 [ + - ][ + - ]: 385 : if(!OCCMap->IsBound(aShape))
2550 : : {
2551 : 385 : iTotalTBCreated++;
2552 : 385 : k = iTotalTBCreated;
2553 [ + - ]: 385 : OCCMap->Bind(*povertex, iTotalTBCreated);
2554 : : }
2555 : : else
2556 [ # # ]: 0 : k = OCCMap->Find(aShape);
2557 [ + - ][ + - ]: 27267 : OccToCGM->insert(valType(k, (TopologyBridge*)point));
2558 : : }
2559 : :
2560 : : }
2561 : : else
2562 : : {
2563 [ + - ]: 124122 : int i = OCCMap->Find(aShape);
2564 [ + - ][ + - ]: 124122 : point = (OCCPoint*)(OccToCGM->find(i))->second;
2565 [ + - ][ + - ]: 124122 : point->set_TopoDS_Vertex(aShape);
[ + - ]
2566 : : }
2567 : 151389 : return point;
2568 : : }
2569 : :
2570 : 802860 : TopologyBridge* OCCQueryEngine::occ_to_cgm(const TopoDS_Shape& shape)
2571 : : {
2572 [ + - ][ + + ]: 802860 : if(!OCCMap->IsBound(shape))
2573 : 39455 : return (TopologyBridge*) NULL;
2574 : :
2575 [ + - ]: 763405 : int k = OCCMap->Find(shape);
2576 [ + - ][ + - ]: 802860 : return (OccToCGM->find(k))->second;
2577 : : }
2578 : :
2579 : : //-----------------------------------------------------------------------
2580 : : // Purpose : Deletes all solid model entities associated with the
2581 : : // Bodies in the input list.
2582 : : //
2583 : : // Special Notes :
2584 : : //
2585 : : // Creator : Jane Hu
2586 : : //
2587 : : // Creation Date : 7/23/11
2588 : : //-------------------------------------------------------------------------
2589 : 97 : void OCCQueryEngine::delete_solid_model_entities(DLIList<BodySM*>&bodyList)const
2590 : : {
2591 : 97 : delete_bodies(bodyList, true);
2592 : 97 : }
2593 : :
2594 : : //-------------------------------------------------------------------------
2595 : : // Purpose : Deletes all solid model entities associated with the
2596 : : // Bodies in the input list depending on remove_lower_entities
2597 : : // flag.
2598 : : //
2599 : : // Special Notes :
2600 : : //
2601 : : // Creator : Steve Owen
2602 : : //
2603 : : // Creation Date : 4/23/01
2604 : : //-------------------------------------------------------------------------
2605 : 97 : void OCCQueryEngine::delete_bodies(DLIList<BodySM*>&bodyList,
2606 : : bool remove_lower_entities ) const
2607 : : {
2608 : 97 : BodySM* BodyPtr = NULL;
2609 [ + + ]: 194 : for (int i = 0; i < bodyList.size(); i++ )
2610 : : {
2611 : 97 : BodyPtr = bodyList.get_and_step();
2612 : 97 : this->delete_body(BodyPtr, remove_lower_entities);
2613 : : }
2614 : :
2615 : 97 : return;
2616 : : }
2617 : :
2618 : 1672 : CubitStatus OCCQueryEngine::delete_solid_model_entities(
2619 : : GeometryEntity* ref_entity_ptr,
2620 : : bool remove_lower_entities) const
2621 : : {
2622 : : //Lump
2623 [ - + ]: 1672 : Lump* lump = CAST_TO(ref_entity_ptr, Lump);
2624 [ + + ]: 1672 : if(lump != NULL)
2625 : : {
2626 [ - + ][ + - ]: 66 : BodySM* body = CAST_TO(lump, OCCLump)->get_body();
2627 [ - + ][ + - ]: 66 : DLIList<Lump*> lumps = CAST_TO(body, OCCBody)->lumps();
2628 : :
2629 [ + - ]: 66 : if (remove_lower_entities)
2630 [ + - ]: 66 : return delete_solid_model_entities(body);
2631 : :
2632 [ # # ][ # # ]: 0 : DLIList<TopologyBridge*> children;
2633 [ # # ][ # # ]: 0 : for(int i = 0; i < lumps.size(); i++)
2634 : : {
2635 [ # # ]: 0 : lump = lumps.get_and_step();
2636 [ # # ][ # # ]: 0 : CAST_TO(lump, OCCLump)->get_children_virt(children);
2637 : : }
2638 : :
2639 [ # # ]: 0 : CubitStatus stat = this->unhook_BodySM_from_OCC(body);
2640 [ # # ]: 0 : if(stat)
2641 : : {
2642 [ # # ][ # # ]: 0 : while (children.size())
2643 [ # # ][ # # ]: 0 : delete children.pop();
[ # # ]
2644 [ # # ][ # # ]: 0 : while(lumps.size())
2645 [ # # ][ # # ]: 0 : delete lumps.pop();
[ # # ]
2646 [ # # ][ # # ]: 0 : delete body;
2647 : : }
2648 [ + - ]: 66 : return stat;
2649 : : }
2650 : :
2651 : : // Surface
2652 [ - + ]: 1606 : Surface* ref_face_ptr = CAST_TO(ref_entity_ptr, Surface);
2653 [ + + ]: 1606 : if (ref_face_ptr != NULL)
2654 : : {
2655 [ - + ]: 242 : if (remove_lower_entities)
2656 : 0 : return ( this->delete_solid_model_entities(ref_face_ptr) );
2657 : 242 : CubitStatus stat = this->unhook_Surface_from_OCC(ref_face_ptr);
2658 [ + - ]: 242 : if(stat)
2659 [ + - ]: 242 : delete ref_face_ptr;
2660 : 242 : return stat;
2661 : : }
2662 : :
2663 : : // Curve
2664 [ - + ]: 1364 : Curve* ref_edge_ptr = CAST_TO(ref_entity_ptr, Curve);
2665 [ + + ]: 1364 : if (ref_edge_ptr != NULL)
2666 : : {
2667 [ - + ]: 836 : if (remove_lower_entities)
2668 : 0 : return ( this->delete_solid_model_entities(ref_edge_ptr));
2669 : 836 : CubitStatus stat = this->unhook_Curve_from_OCC(ref_edge_ptr);
2670 [ + - ]: 836 : if(stat)
2671 [ + - ]: 836 : delete ref_edge_ptr;
2672 : 836 : return stat;
2673 : : }
2674 : :
2675 : : // Point
2676 [ - + ]: 528 : TBPoint* ref_vertex_ptr = CAST_TO(ref_entity_ptr, TBPoint);
2677 [ + - ]: 528 : if (ref_vertex_ptr != NULL)
2678 : : {
2679 : 528 : return ( this->delete_solid_model_entities(ref_vertex_ptr) );
2680 : : }
2681 : :
2682 : : // Oops!
2683 [ # # ]: 0 : PRINT_ERROR("In OCCQueryEngine::delete_solid_model_entities\n"
2684 : : " Can only delete solid model entities underlying \n"
2685 [ # # ]: 0 : "RefFaces, RefEdges and RefVertices.\n");
2686 : 1672 : return CUBIT_FAILURE;
2687 : :
2688 : : }
2689 : : //-------------------------------------------------------------------------
2690 : : // Purpose : Delete a OCCBody and child entities.
2691 : : //
2692 : : // Special Notes :
2693 : : //
2694 : : // Creator : Jane Hu
2695 : : //
2696 : : // Creation Date : 10/29/07
2697 : : //-------------------------------------------------------------------------
2698 : : CubitStatus
2699 : 1474 : OCCQueryEngine::delete_solid_model_entities( BodySM* bodysm) const
2700 : : {
2701 : 1474 : return delete_body(bodysm, true);
2702 : : }
2703 : : //-------------------------------------------------------------------------
2704 : : // Purpose : Delete a OCCBody and child entities depending on
2705 : : // remove_lower_entities flag.
2706 : : //
2707 : : // Special Notes :
2708 : : //
2709 : : // Creator : Jane Hu
2710 : : //
2711 : : // Creation Date : 10/29/07
2712 : : //-------------------------------------------------------------------------
2713 : : CubitStatus
2714 : 1571 : OCCQueryEngine::delete_body( BodySM* bodysm,
2715 : : bool remove_lower_entities) const
2716 : : {
2717 : 1571 : OCCBody* occ_body = static_cast<OCCBody*>(bodysm);
2718 [ - + ]: 1571 : if (!occ_body)
2719 : 0 : return CUBIT_FAILURE;
2720 : :
2721 [ + - ]: 1571 : DLIList<Lump*> lumps;
2722 [ + - ][ + - ]: 3142 : DLIList<ShellSM*> shell_list;
2723 [ + - ][ + - ]: 3142 : DLIList<OCCSurface*> surfaces = occ_body->my_sheet_surfaces();
2724 [ + - ][ + + ]: 1846 : for(int i = 0; i <surfaces.size(); i++)
2725 : : {
2726 [ + - ]: 275 : OCCSurface* occ_surface = surfaces.get_and_step();
2727 [ + - ]: 275 : occ_surface->set_body((OCCBody*)NULL);
2728 [ + - ]: 275 : if(remove_lower_entities)
2729 : : {
2730 [ + - ][ + - ]: 275 : delete occ_surface->my_lump();
[ + - ]
2731 [ + - ]: 275 : OCCShell* shell = occ_surface->my_shell();
2732 [ + - ]: 275 : delete_solid_model_entities(occ_surface);
2733 [ + - ][ + - ]: 275 : delete shell;
2734 : : }
2735 : : }
2736 : :
2737 [ + - ][ + - ]: 3142 : DLIList<OCCShell*> shells = occ_body->shells();
2738 [ + - ][ - + ]: 1571 : for(int i = 0; i <shells.size(); i++)
2739 : : {
2740 [ # # ]: 0 : OCCShell* occ_shell = shells.get_and_step();
2741 [ # # ]: 0 : occ_shell->set_body((OCCBody*)NULL);
2742 [ # # ]: 0 : if(remove_lower_entities)
2743 : : {
2744 [ # # ][ # # ]: 0 : delete occ_shell->my_lump();
[ # # ]
2745 [ # # ]: 0 : DLIList<TopologyBridge*> tb_surfaces;
2746 [ # # ]: 0 : occ_shell->get_children_virt(tb_surfaces);
2747 [ # # ]: 0 : unhook_ShellSM_from_OCC(occ_shell);
2748 [ # # ][ # # ]: 0 : for(int k = 0; k < tb_surfaces.size(); k++)
2749 [ # # ][ # # ]: 0 : delete_solid_model_entities(CAST_TO(tb_surfaces.get_and_step(), Surface));
[ # # ]
2750 [ # # ][ # # ]: 0 : delete occ_shell;
[ # # ]
2751 : : }
2752 : : }
2753 : :
2754 [ + - ][ + - ]: 3142 : DLIList<TopologyBridge*> children;
2755 [ + - ][ + - ]: 1571 : lumps = occ_body->lumps();
[ + - ]
2756 [ + - ]: 1571 : int size = lumps.size();
2757 : :
2758 [ + + ]: 3085 : for(int i =0; i < size; i++)
2759 : : {
2760 [ + - ]: 1514 : Lump* lump = lumps.get_and_step();
2761 [ - + ]: 1514 : OCCLump* occ_lump = CAST_TO(lump, OCCLump);
2762 [ - + ]: 1514 : if (!occ_lump)
2763 : 0 : continue;
2764 [ + - ]: 1514 : occ_lump->remove_body();
2765 [ + - ]: 1514 : if(remove_lower_entities)
2766 : : {
2767 [ + - ]: 1514 : children.clean_out();
2768 [ + - ]: 1514 : occ_lump->get_children_virt(children);
2769 [ + - ][ + + ]: 2907 : for(int j = 0; j < children.size(); j++)
2770 : : {
2771 [ + - ][ - + ]: 1393 : ShellSM* shell = CAST_TO(children.get_and_step(), ShellSM);
2772 : :
2773 [ + - ]: 1393 : if (shell)
2774 [ + - ]: 1393 : shell_list.append(shell);
2775 [ + - ]: 1393 : DLIList<TopologyBridge*> tb_surfaces;
2776 [ + - ]: 1393 : shell->get_children_virt(tb_surfaces);
2777 [ + - ][ + + ]: 10792 : for(int k = 0; k < tb_surfaces.size(); k++)
2778 [ + - ][ - + ]: 9399 : delete_solid_model_entities(CAST_TO(tb_surfaces.get_and_step(), Surface));
[ + - ]
2779 [ + - ]: 1393 : }
2780 : : }
2781 : : }
2782 : 1571 : CubitStatus stat = CUBIT_SUCCESS;
2783 [ + - ]: 1571 : stat = unhook_BodySM_from_OCC(bodysm, remove_lower_entities);
2784 : :
2785 [ + - ]: 1571 : if(remove_lower_entities)
2786 : : {
2787 [ + - ][ + + ]: 2964 : for(int j = 0; j < shell_list.size(); j++)
2788 [ + - ][ + - ]: 1393 : delete shell_list.get_and_step();
[ + - ]
2789 : :
2790 [ + - ][ + + ]: 3085 : for(int i =0; i < lumps.size(); i++)
2791 [ + - ][ + - ]: 1514 : delete lumps.get_and_step();
[ + - ]
2792 : : }
2793 : :
2794 [ + - ]: 1571 : BodyList->remove(occ_body);
2795 [ + - ][ + - ]: 1571 : delete bodysm;
2796 [ + - ]: 1571 : return stat;
2797 : : }
2798 : :
2799 : : CubitStatus
2800 : 1582 : OCCQueryEngine::unhook_BodySM_from_OCC( BodySM* bodysm ,
2801 : : bool remove_lower_entities)const
2802 : : {
2803 [ - + ]: 1582 : OCCBody* occ_body = dynamic_cast<OCCBody*>(bodysm);
2804 [ - + ]: 1582 : if (!occ_body)
2805 : 0 : return CUBIT_FAILURE;
2806 : :
2807 [ + - ]: 1582 : TopoDS_Shape* shape = occ_body->get_TopoDS_Shape();
2808 : :
2809 [ + + ][ + - ]: 1582 : if (shape && !shape->IsNull())
[ + - ][ + + ]
2810 : : {
2811 : : //remove the entry from label tree
2812 [ + - ]: 97 : OCCAttribSet::remove_attribute(*shape) ;
2813 : :
2814 : : //remove the entry from the map
2815 : : int k;
2816 [ + - ][ + - ]: 97 : if(shape && !shape->IsNull() && OCCMap->IsBound(*shape))
[ + - ][ + - ]
[ + - ][ + - ]
2817 : : {
2818 [ + - ]: 97 : k = OCCMap->Find(*shape);
2819 [ + - ]: 97 : OCCMap->UnBind(*shape);
2820 : :
2821 [ + - ][ - + ]: 97 : if(!OccToCGM->erase(k))
2822 [ # # ][ # # ]: 97 : PRINT_ERROR("The OccBody and iCreatedTotal %i pair is not in the map!", k);
[ # # ][ # # ]
2823 : : }
2824 : : }
2825 : :
2826 [ + - ]: 1582 : DLIList<Lump*> lumps = occ_body->lumps();
2827 [ + - ][ + + ]: 3096 : for(int i =0; i < lumps.size()&& remove_lower_entities; i++)
[ + + ][ + + ]
2828 : : {
2829 [ + - ]: 1514 : Lump* lump = lumps.get_and_step();
2830 : : //OCCLump* occ_lump = CAST_TO(lump, OCCLump);
2831 : : //if(occ_lump)
2832 : : // occ_lump->remove_body();
2833 : :
2834 [ + - ]: 1514 : unhook_Lump_from_OCC(lump);
2835 : : }
2836 : :
2837 [ + + ][ + - ]: 1582 : if (shape && !shape->IsNull())
[ + - ][ + + ]
2838 [ + - ]: 97 : shape->Nullify();
2839 [ + - ]: 1582 : return CUBIT_SUCCESS;
2840 : : }
2841 : :
2842 : : //-------------------------------------------------------------------------
2843 : : // Purpose : unhook a OCClumps and child entities.
2844 : : //
2845 : : // Special Notes :
2846 : : //
2847 : : // Creator : Jane Hu
2848 : : //
2849 : : // Creation Date : 11/29/07
2850 : : //-------------------------------------------------------------------------
2851 : : CubitStatus
2852 : 1514 : OCCQueryEngine::unhook_Lump_from_OCC( Lump* lump ) const
2853 : : {
2854 [ - + ]: 1514 : if (lump == NULL)
2855 : 0 : return CUBIT_FAILURE;
2856 : :
2857 [ - + ]: 1514 : OCCLump* occ_lump = dynamic_cast<OCCLump*>(lump);
2858 [ - + ]: 1514 : if (!occ_lump)
2859 : 0 : return CUBIT_FAILURE;
2860 : :
2861 [ + - ]: 1514 : TopoDS_Solid* solid = occ_lump->get_TopoDS_Solid();
2862 : :
2863 [ - + ]: 1514 : if(!solid)
2864 : 0 : return CUBIT_FAILURE;
2865 : :
2866 : : //remove the entry from label tree
2867 [ + - ]: 1514 : OCCAttribSet::remove_attribute(*solid) ;
2868 : :
2869 : : //remove the entry from the map
2870 : : int k;
2871 [ + - ][ + + ]: 1514 : if(OCCMap->IsBound(*solid))
2872 : : {
2873 [ + - ]: 1393 : k = OCCMap->Find(*solid);
2874 : :
2875 [ + - ]: 1393 : OCCMap->UnBind(*solid);
2876 : :
2877 [ + - ][ - + ]: 1393 : if(!OccToCGM->erase(k))
2878 [ # # ][ # # ]: 0 : PRINT_ERROR("The OccLump and iCreatedTotal pair is not in the map!");
[ # # ][ # # ]
2879 : : }
2880 : :
2881 [ + - ]: 1514 : DLIList<TopologyBridge*> children;
2882 [ + - ]: 1514 : occ_lump->get_children_virt(children);
2883 [ + - ][ + + ]: 2907 : for(int i = 0; i < children.size(); i++)
2884 : : {
2885 [ + - ][ - + ]: 1393 : ShellSM* shell = CAST_TO(children.get_and_step(), ShellSM);
2886 [ + - ]: 1393 : unhook_ShellSM_from_OCC(shell);
2887 : : }
2888 [ + - ][ - + ]: 1514 : if (occ_lump->get_body() != NULL)
2889 [ # # ][ # # ]: 0 : BodyList->remove(CAST_TO(occ_lump->get_body(), OCCBody));
[ # # ]
2890 : :
2891 [ + - ][ + - ]: 1514 : if(!solid->IsNull())
2892 [ + - ]: 1514 : solid->Nullify();
2893 [ + - ]: 1514 : return CUBIT_SUCCESS;
2894 : : }
2895 : :
2896 : : //-------------------------------------------------------------------------
2897 : : // Purpose : unhook a ShellSM from its underlining OCC entity.
2898 : : //
2899 : : // Special Notes :
2900 : : //
2901 : : // Creator : Jane Hu
2902 : : //
2903 : : // Creation Date : 12/12/07
2904 : : //-------------------------------------------------------------------------
2905 : : CubitStatus
2906 : 1514 : OCCQueryEngine::unhook_ShellSM_from_OCC( ShellSM* shell) const
2907 : : {
2908 [ - + ]: 1514 : OCCShell* occ_shell = dynamic_cast<OCCShell*>(shell);
2909 [ - + ]: 1514 : if (!occ_shell)
2910 : 0 : return CUBIT_FAILURE;
2911 : :
2912 [ + - ]: 1514 : TopoDS_Shell* Shell = occ_shell->get_TopoDS_Shell();
2913 : :
2914 [ - + ]: 1514 : if(!Shell)
2915 : 0 : return CUBIT_FAILURE;
2916 : :
2917 : : //remove the entry from the map
2918 : : int k;
2919 [ + - ][ + + ]: 1514 : if(OCCMap->IsBound(*Shell))
2920 : : {
2921 [ + - ]: 1393 : k = OCCMap->Find(*Shell);
2922 : :
2923 [ + - ]: 1393 : OCCMap->UnBind(*Shell);
2924 : :
2925 [ + - ][ - + ]: 1393 : if(!OccToCGM->erase(k))
2926 [ # # ][ # # ]: 0 : PRINT_ERROR("The OccShell and iCreatedTotal pair is not in the map!");
[ # # ][ # # ]
2927 : : }
2928 : :
2929 [ + - ][ + - ]: 1514 : if(!Shell->IsNull())
2930 [ + - ]: 1514 : Shell->Nullify();
2931 : 1514 : return CUBIT_SUCCESS;
2932 : : }
2933 : :
2934 : : //-------------------------------------------------------------------------
2935 : : // Purpose : Delete a OCCSurface and child entities.
2936 : : //
2937 : : // Special Notes :
2938 : : //
2939 : : // Creator : Jane Hu
2940 : : //
2941 : : // Creation Date : 10/29/07
2942 : : //-------------------------------------------------------------------------
2943 : : CubitStatus
2944 : 9740 : OCCQueryEngine::delete_solid_model_entities( Surface* surface)const
2945 : : {
2946 [ - + ]: 9740 : OCCSurface* fsurf = dynamic_cast<OCCSurface*>(surface);
2947 [ - + ]: 9740 : if (!fsurf)
2948 : 0 : return CUBIT_FAILURE;
2949 : :
2950 [ + - ]: 9740 : OCCBody* sheet_body = fsurf->my_body();
2951 [ - + ]: 9740 : if(sheet_body != NULL)
2952 [ # # ]: 0 : BodyList->remove(sheet_body);
2953 : :
2954 [ + - ]: 9740 : double d = fsurf->measure();
2955 [ - + ]: 9740 : if(d < 0.0)
2956 [ # # ][ # # ]: 0 : PRINT_WARNING("Negative area surface is being deleted. \n");
[ # # ][ # # ]
2957 : :
2958 [ + - ]: 9740 : DLIList<TopologyBridge*> children;
2959 [ + - ]: 9740 : fsurf->get_children_virt(children);
2960 [ + - ][ + + ]: 19948 : for(int i = 0; i < children.size(); i++)
2961 : : {
2962 [ + - ][ - + ]: 10208 : LoopSM* loop = CAST_TO(children.get_and_step(), LoopSM);
2963 [ + - ]: 10208 : delete_loop(loop);
2964 : : }
2965 [ + - ]: 9740 : CubitStatus stat = unhook_Surface_from_OCC(surface);
2966 [ + - ]: 9740 : if (stat)
2967 [ + - ][ + - ]: 9740 : delete surface;
2968 [ + - ]: 9740 : return stat;
2969 : : }
2970 : :
2971 : : //-------------------------------------------------------------------------
2972 : : // Purpose : unhook a Surface from its underlining OCC entity.
2973 : : //
2974 : : // Special Notes :
2975 : : //
2976 : : // Creator : Jane Hu
2977 : : //
2978 : : // Creation Date : 12/12/07
2979 : : //-------------------------------------------------------------------------
2980 : : CubitStatus
2981 : 9982 : OCCQueryEngine::unhook_Surface_from_OCC( Surface* surface) const
2982 : : {
2983 [ - + ]: 9982 : OCCSurface* fsurf = dynamic_cast<OCCSurface*>(surface);
2984 [ - + ]: 9982 : if (!fsurf)
2985 : 0 : return CUBIT_FAILURE;
2986 : :
2987 [ + - ]: 9982 : TopoDS_Face *face = fsurf->get_TopoDS_Face();
2988 : :
2989 [ - + ]: 9982 : if(!face)
2990 : 0 : return CUBIT_FAILURE;
2991 : :
2992 : : //remove the entry from label tree
2993 [ + - ]: 9982 : OCCAttribSet::remove_attribute(*face) ;
2994 : :
2995 : : //remove the entry from the map
2996 : : int k;
2997 [ + - ][ + + ]: 9982 : if(OCCMap->IsBound(*face))
2998 : : {
2999 [ + - ]: 9674 : k = OCCMap->Find(*face);
3000 : :
3001 [ + - ]: 9674 : OCCMap->UnBind(*face);
3002 : :
3003 [ + - ][ - + ]: 9674 : if(!OccToCGM->erase(k))
3004 [ # # ][ # # ]: 0 : PRINT_WARNING("The OccSurface and iCreatedTotal pair is not in the map!");
[ # # ][ # # ]
3005 : : }
3006 [ + - ]: 9982 : SurfaceList->remove(fsurf);
3007 [ + - ][ + - ]: 9982 : if(!face->IsNull())
3008 [ + - ]: 9982 : face->Nullify();
3009 : 9982 : return CUBIT_SUCCESS;
3010 : : }
3011 : :
3012 : : //-------------------------------------------------------------------------
3013 : : // Purpose : Delete a OCCLoop and child entities.
3014 : : //
3015 : : // Special Notes :
3016 : : //
3017 : : // Creator : Jane Hu
3018 : : //
3019 : : // Creation Date : 10/29/07
3020 : : //-------------------------------------------------------------------------
3021 : : CubitStatus
3022 : 10208 : OCCQueryEngine::delete_loop( LoopSM* loopsm)const
3023 : : {
3024 [ - + ]: 10208 : OCCLoop* occ_loop = dynamic_cast<OCCLoop*>(loopsm);
3025 [ - + ]: 10208 : if (!occ_loop)
3026 : 0 : return CUBIT_FAILURE;
3027 : :
3028 [ + - ]: 10208 : DLIList<OCCCoEdge*> children;
3029 [ + - ][ + - ]: 10208 : children = occ_loop->coedges();
[ + - ]
3030 [ + - ]: 10208 : int size = children.size();
3031 [ + - ][ + - ]: 20416 : DLIList<Curve*> curves;
3032 [ + + ]: 49215 : while(size > 0)
3033 : : {
3034 [ + - ]: 39007 : OCCCoEdge* coedge = children.pop();
3035 [ + - ]: 39007 : Curve* curve = coedge->curve();
3036 [ + - ]: 39007 : curves.append_unique(curve);
3037 [ + - ]: 39007 : size = children.size();
3038 : : }
3039 : :
3040 [ + - ]: 10208 : CubitStatus status = unhook_LoopSM_from_OCC(loopsm);
3041 : :
3042 [ + - ][ + + ]: 48530 : for(int i = 0; i < curves.size(); i ++)
3043 : : {
3044 [ + - ][ - + ]: 38322 : OCCCurve* occ_curve = CAST_TO(curves.get_and_step(), OCCCurve);
3045 [ + - ]: 38322 : unhook_coedges_of_a_curve(occ_curve, occ_loop);
3046 [ + - ]: 38322 : occ_curve->remove_loop(occ_loop);
3047 [ + - ]: 38322 : delete_solid_model_entities(occ_curve);
3048 : : }
3049 : :
3050 [ + - ]: 10208 : if (status)
3051 : : {
3052 [ + - ]: 10208 : WireList->remove(occ_loop);
3053 [ + - ][ + - ]: 10208 : delete loopsm;
3054 : : }
3055 [ + - ]: 10208 : return status;
3056 : : }
3057 : :
3058 : : //-------------------------------------------------------------------------
3059 : : // Purpose : unhook a LoopSM from its underlining OCC entity.
3060 : : //
3061 : : // Special Notes :
3062 : : //
3063 : : // Creator : Jane Hu
3064 : : //
3065 : : // Creation Date : 12/12/07
3066 : : //-------------------------------------------------------------------------
3067 : : CubitStatus
3068 : 10853 : OCCQueryEngine::unhook_LoopSM_from_OCC( LoopSM* loopsm) const
3069 : : {
3070 [ - + ]: 10853 : OCCLoop* occ_loop = dynamic_cast<OCCLoop*>(loopsm);
3071 [ - + ]: 10853 : if (!occ_loop)
3072 : 0 : return CUBIT_FAILURE;
3073 : :
3074 [ + - ]: 10853 : TopoDS_Wire* wire = occ_loop->get_TopoDS_Wire();
3075 : :
3076 [ - + ]: 10853 : if(!wire)
3077 : 0 : return CUBIT_FAILURE;
3078 : :
3079 : : //remove the entry from the map
3080 : : int k;
3081 [ + - ][ + + ]: 10853 : if(OCCMap->IsBound(*wire))
3082 : : {
3083 [ + - ]: 10208 : k = OCCMap->Find(*wire);
3084 : :
3085 [ + - ]: 10208 : OCCMap->UnBind(*wire);
3086 : :
3087 [ + - ][ - + ]: 10208 : if(!OccToCGM->erase(k))
3088 [ # # ][ # # ]: 0 : PRINT_ERROR("The OccLoop and iCreatedTotal pair is not in the map!");
[ # # ][ # # ]
3089 : : }
3090 : :
3091 [ + - ][ + - ]: 10853 : if(!wire->IsNull())
3092 [ + - ]: 10853 : wire->Nullify();
3093 : 10853 : return CUBIT_SUCCESS;
3094 : : }
3095 : :
3096 : : //-------------------------------------------------------------------------
3097 : : // Purpose : unhook a list of OCCCoEdges from their underlining OCC entity.
3098 : : //
3099 : : // Special Notes :
3100 : : //
3101 : : // Creator : Jane Hu
3102 : : //
3103 : : // Creation Date : 12/12/07
3104 : : //-------------------------------------------------------------------------
3105 : : CubitStatus
3106 : 60295 : OCCQueryEngine::unhook_CoEdges_from_OCC( DLIList<OCCCoEdge*>& coedges) const
3107 : : {
3108 : 60295 : int size = coedges.size();
3109 [ + + ]: 100974 : while(size > 0)
3110 : : {
3111 : 40679 : OCCCoEdge* coedge = coedges.pop();
3112 : :
3113 : 40679 : LoopSM* loopsm = coedge->loop();
3114 [ - + ]: 40679 : OCCLoop* loop = CAST_TO(loopsm, OCCLoop);
3115 [ - + ]: 40679 : assert(loop);
3116 : 40679 : loop->remove_coedge(coedge);
3117 : :
3118 [ + - ]: 40679 : delete coedge;
3119 : :
3120 : 40679 : size = coedges.size();
3121 : : }
3122 : 60295 : return CUBIT_SUCCESS;
3123 : : }
3124 : :
3125 : : //-------------------------------------------------------------------------
3126 : : // Purpose : Delete a OCCCurve and child entities.
3127 : : //
3128 : : // Special Notes :
3129 : : //
3130 : : // Creator : Jason Kraftcheck
3131 : : //
3132 : : // Creation Date : 09/29/03
3133 : : //-------------------------------------------------------------------------
3134 : : CubitStatus
3135 : 38883 : OCCQueryEngine::delete_solid_model_entities( Curve* curve)const
3136 : : {
3137 [ - + ]: 38883 : OCCCurve* fcurve = CAST_TO(curve, OCCCurve);
3138 [ - + ]: 38883 : if (!fcurve )
3139 : 0 : return CUBIT_FAILURE;
3140 : :
3141 [ + - ][ + - ]: 38883 : if(fcurve->loops().size() > 0 && fcurve->loops().get() != NULL)
[ + + ][ + - ]
[ + - ][ + - ]
[ + + ][ + - ]
[ + - ][ + - ]
[ + + # #
# # ]
3142 : 17746 : return CUBIT_FAILURE;
3143 : :
3144 [ + - ]: 21137 : DLIList<TopologyBridge*> children;
3145 [ + - ]: 21137 : fcurve->get_children_virt(children);
3146 [ + - ][ + + ]: 62316 : for(int i = 0; i < children.size(); i++)
3147 : : {
3148 [ + - ][ - + ]: 41179 : TBPoint* point = CAST_TO(children.get_and_step(), TBPoint);
3149 [ - + ][ + - ]: 41179 : CAST_TO(point, OCCPoint)->remove_curve(fcurve);
3150 [ + - ]: 41179 : delete_solid_model_entities(point);
3151 : : }
3152 : :
3153 [ + - ]: 21137 : CubitStatus stat = unhook_Curve_from_OCC(curve);
3154 [ - + ]: 21137 : if (!stat)
3155 : 0 : return CUBIT_FAILURE;
3156 : :
3157 [ + - ]: 21137 : CurveList->remove(fcurve);
3158 [ + - ][ + - ]: 21137 : delete fcurve;
3159 [ + - ]: 38883 : return stat;
3160 : : }
3161 : :
3162 : : //-------------------------------------------------------------------------
3163 : : // Purpose : unhook a Curve from its underlining OCC entity.
3164 : : //
3165 : : // Special Notes :
3166 : : //
3167 : : // Creator : Jane Hu
3168 : : //
3169 : : // Creation Date : 12/12/07
3170 : : //-------------------------------------------------------------------------
3171 : : CubitStatus
3172 : 21973 : OCCQueryEngine::unhook_Curve_from_OCC( Curve* curve ) const
3173 : : {
3174 [ - + ]: 21973 : OCCCurve* fcurve = dynamic_cast<OCCCurve*>(curve);
3175 [ - + ]: 21973 : if (!fcurve )
3176 : 0 : return CUBIT_FAILURE;
3177 : :
3178 [ + - ]: 21973 : DLIList<TopologyBridge*> children;
3179 [ + - ]: 21973 : fcurve->get_children_virt(children);
3180 [ + - ][ + + ]: 49145 : for(int i = 0; i < children.size(); i++)
3181 : : {
3182 [ + - ][ - + ]: 27172 : TBPoint* point = CAST_TO(children.get_and_step(), TBPoint);
3183 [ - + ][ + - ]: 27172 : CAST_TO(point, OCCPoint)->remove_curve(fcurve);
3184 : : }
3185 : :
3186 [ + - ]: 21973 : unhook_coedges_of_a_curve(fcurve, NULL);
3187 : :
3188 [ + - ]: 21973 : fcurve->clean_loops();
3189 [ + - ]: 21973 : TopoDS_Edge* edge = fcurve->get_TopoDS_Edge();
3190 [ - + ]: 21973 : if (!edge)
3191 : 0 : return CUBIT_FAILURE;
3192 : :
3193 : : //remove the entry from label tree
3194 [ + - ]: 21973 : OCCAttribSet::remove_attribute(*edge) ;
3195 : :
3196 : : //remove the entry from the map
3197 : : int k;
3198 [ + - ][ + - ]: 21973 : if(edge && !edge->IsNull() && OCCMap->IsBound(*edge))
[ + - ][ + - ]
[ + + ][ + + ]
3199 : : {
3200 [ + - ]: 21126 : k = OCCMap->Find(*edge);
3201 : :
3202 [ + - ]: 21126 : OCCMap->UnBind(*edge);
3203 : :
3204 [ + - ][ - + ]: 21126 : if(!OccToCGM->erase(k))
3205 [ # # ][ # # ]: 0 : PRINT_WARNING("The OccCurve and iCreatedTotal pair is not in the map!");
[ # # ][ # # ]
3206 : : }
3207 [ + - ]: 21973 : CurveList->remove(fcurve);
3208 [ + - ][ + - ]: 21973 : if(!edge->IsNull())
3209 [ + - ]: 21973 : edge->Nullify();
3210 [ + - ]: 21973 : return CUBIT_SUCCESS;
3211 : : }
3212 : : //-------------------------------------------------------------------------
3213 : : // Purpose : Delete a OCCPoint and child entities.
3214 : : //
3215 : : // Special Notes :
3216 : : //
3217 : : // Creator : Jason Kraftcheck
3218 : : //
3219 : : // Creation Date : 09/29/03
3220 : : //-------------------------------------------------------------------------
3221 : : CubitStatus
3222 : 41729 : OCCQueryEngine::delete_solid_model_entities( TBPoint* point) const
3223 : : {
3224 [ - + ]: 41729 : OCCPoint* fpoint = dynamic_cast<OCCPoint*>(point);
3225 [ - + ]: 41729 : if (!fpoint)
3226 : 0 : return CUBIT_FAILURE;
3227 : :
3228 [ + + ]: 41729 : if(fpoint->num_curves() > 0)
3229 : 26380 : return CUBIT_FAILURE;
3230 : :
3231 : 15349 : CubitStatus stat = unhook_Point_from_OCC(point);
3232 : :
3233 [ + - ]: 15349 : if(stat)
3234 [ + - ]: 15349 : delete point;
3235 : 15349 : return stat;
3236 : : }
3237 : :
3238 : : //-------------------------------------------------------------------------
3239 : : // Purpose : unhook a Point from its underlining OCC entity.
3240 : : //
3241 : : // Special Notes :
3242 : : //
3243 : : // Creator : Jane Hu
3244 : : //
3245 : : // Creation Date : 12/12/07
3246 : : //-------------------------------------------------------------------------
3247 : : CubitStatus
3248 : 15349 : OCCQueryEngine::unhook_Point_from_OCC( TBPoint* point) const
3249 : : {
3250 [ - + ]: 15349 : OCCPoint* fpoint = dynamic_cast<OCCPoint*>(point);
3251 [ - + ]: 15349 : if (!fpoint)
3252 : 0 : return CUBIT_FAILURE;
3253 : :
3254 [ + - ]: 15349 : TopoDS_Vertex* vertex = fpoint->get_TopoDS_Vertex();
3255 [ - + ]: 15349 : if (!vertex)
3256 : 0 : return CUBIT_FAILURE;
3257 : :
3258 : : //remove the entry from label tree
3259 [ + - ]: 15349 : OCCAttribSet::remove_attribute(*vertex) ;
3260 : :
3261 : : //remove the entry from the map
3262 : : int k;
3263 [ + - ][ + + ]: 15349 : if(OCCMap->IsBound(*vertex))
3264 : : {
3265 [ + - ]: 14821 : k = OCCMap->Find(*vertex);
3266 : :
3267 [ + - ]: 14821 : OCCMap->UnBind(*vertex);
3268 : :
3269 [ + - ][ - + ]: 14821 : if(!OccToCGM->erase(k))
3270 [ # # ][ # # ]: 0 : PRINT_ERROR("The OccPoint and iCreatedTotal pair is not in the map!");
[ # # ][ # # ]
3271 : : }
3272 [ + - ][ + - ]: 15349 : if(!vertex->IsNull())
3273 [ + - ]: 15349 : vertex->Nullify();
3274 : 15349 : return CUBIT_SUCCESS;
3275 : : }
3276 : :
3277 : :
3278 : : //-------------------------------------------------------------------------
3279 : : // Purpose : fire a ray at the specified body, returning the entities hit.
3280 : : //
3281 : : // Special Notes :
3282 : : //
3283 : : // Creator : Jane Hu
3284 : : //
3285 : : // Creation Date : 12/12/07
3286 : : //-------------------------------------------------------------------------
3287 : 0 : CubitStatus OCCQueryEngine::fire_ray( CubitVector &origin,
3288 : : CubitVector &direction,
3289 : : DLIList<TopologyBridge*> &at_entity_list,
3290 : : DLIList<double> &ray_params,
3291 : : int max_hits ,
3292 : : double ray_radius ,
3293 : : DLIList<TopologyBridge*> *hit_entity_list_ptr )const
3294 : : {
3295 : 0 : CubitStatus status = CUBIT_SUCCESS;
3296 : :
3297 : : //- fire a ray at the specified body, returning the entities hit and
3298 : : //- the parameters along the ray; return CUBIT_FAILURE if error
3299 : : // - line body intersection.
3300 [ # # ][ # # ]: 0 : gp_Pnt p(origin.x(), origin.y(), origin.z());
[ # # ][ # # ]
3301 [ # # ][ # # ]: 0 : gp_Dir dir(direction.x(), direction.y(), direction.z());
[ # # ][ # # ]
3302 [ # # ]: 0 : gp_Lin L(p, dir);
3303 [ # # ][ # # ]: 0 : TopoDS_Edge edge = BRepBuilderAPI_MakeEdge(L);
[ # # ]
3304 : :
3305 [ # # ][ # # ]: 0 : for(int i = 0; i < at_entity_list.size(); i++)
3306 : : {
3307 [ # # ]: 0 : TopologyBridge* tb = at_entity_list.get_and_step();
3308 : : TopoDS_Shape *shape;
3309 [ # # ]: 0 : OCCBody *occBody = CAST_TO(tb, OCCBody);
3310 [ # # ]: 0 : if (occBody )
3311 : : {
3312 [ # # ]: 0 : occBody->get_TopoDS_Shape(shape);
3313 : :
3314 [ # # ]: 0 : BRepExtrema_DistShapeShape distShapeShape(edge, *shape);
3315 : : //distShapeShape.Perform();
3316 [ # # ][ # # ]: 0 : if (!distShapeShape.IsDone())
3317 : : {
3318 [ # # ][ # # ]: 0 : PRINT_ERROR("Cannot calculate the intersection points for the input body.\n");
[ # # ][ # # ]
3319 : 0 : return CUBIT_FAILURE;
3320 : : }
3321 : :
3322 [ # # ][ # # ]: 0 : if (distShapeShape.Value() < get_sme_resabs_tolerance())
[ # # ]
3323 : : {
3324 [ # # ]: 0 : int numPnt = distShapeShape.NbSolution();
3325 [ # # ]: 0 : for (int i = 1; i <= numPnt; i++)
3326 : : {
3327 : : double para;
3328 [ # # ]: 0 : distShapeShape.ParOnEdgeS1(i , para);
3329 [ # # ]: 0 : ray_params.append(para);
3330 : : }
3331 [ # # ][ # # ]: 0 : hit_entity_list_ptr->append(tb);
[ # # ]
3332 : 0 : }
3333 : : }
3334 : : }
3335 [ # # ]: 0 : return status;
3336 : : }
3337 : :
3338 : 119540 : double OCCQueryEngine::get_sme_resabs_tolerance() const
3339 : : {
3340 : 119540 : return Precision::Confusion();
3341 : : }
3342 : : // Gets solid modeler's resolution absolute tolerance
3343 : :
3344 : 0 : double OCCQueryEngine::set_sme_resabs_tolerance( double p)
3345 : : {
3346 : 0 : double old_p = get_sme_resabs_tolerance();
3347 : 0 : BRepBuilderAPI::Precision(p);
3348 : 0 : return old_p;
3349 : : }
3350 : :
3351 : 0 : CubitStatus OCCQueryEngine::set_int_option( const char* , int )
3352 : : {
3353 [ # # ][ # # ]: 0 : PRINT_ERROR("OCCQueryEngine::set_int_option not yet implemented.\n");
3354 : 0 : return CUBIT_FAILURE;
3355 : : }
3356 : :
3357 : 0 : CubitStatus OCCQueryEngine::set_dbl_option( const char* , double )
3358 : : {
3359 [ # # ][ # # ]: 0 : PRINT_ERROR("OCCQueryEngine::set_dbl_option not yet implemented.\n");
3360 : 0 : return CUBIT_FAILURE;
3361 : : }
3362 : :
3363 : 0 : CubitStatus OCCQueryEngine::set_str_option( const char* , const char* )
3364 : : {
3365 [ # # ][ # # ]: 0 : PRINT_ERROR("OCCQueryEngine::set_str_option not yet implemented.\n");
3366 : 0 : return CUBIT_FAILURE;
3367 : : }
3368 : : //- Set solid modeler options
3369 : :
3370 : :
3371 : : //===========================================================================
3372 : : //Function Name: ensure_is_ascii_stl_file
3373 : : //Member Type:
3374 : : //Description: returns CUBIT_TRUE in is_ascii if fp is an ascii stl file
3375 : : //Author: Plamen Stoyanov (USF)
3376 : : //===========================================================================
3377 : 0 : CubitStatus OCCQueryEngine::ensure_is_ascii_stl_file(FILE * fp, CubitBoolean &is_ascii)
3378 : : {
3379 : :
3380 : 0 : char line[128]="";
3381 : :
3382 [ # # ][ # # ]: 0 : if (fgets(line, 128, fp)==NULL)
3383 : : {
3384 : 0 : return CUBIT_FAILURE;
3385 : : }
3386 [ # # ][ # # ]: 0 : if (fgets(line, 128, fp)==NULL)
3387 : : {
3388 : 0 : return CUBIT_FAILURE;
3389 : : }
3390 [ # # ]: 0 : if (strlen(line)==127)
3391 : : {
3392 [ # # ][ # # ]: 0 : if (fgets(line, 128, fp)==NULL)
3393 : : {
3394 : 0 : return CUBIT_FAILURE;
3395 : : }
3396 : : }
3397 : :
3398 : :
3399 : 0 : unsigned int dummy_int=0;
3400 : :
3401 [ # # ][ # # ]: 0 : while (isspace(line[dummy_int])&& dummy_int<strlen(line)) dummy_int++;
3402 : :
3403 [ # # ]: 0 : if (strlen(line)-dummy_int>5)
3404 : : {
3405 [ # # ][ # # ]: 0 : if (tolower(line[dummy_int++])=='f' &&
3406 [ # # ]: 0 : tolower(line[dummy_int++])=='a' &&
3407 [ # # ]: 0 : tolower(line[dummy_int++])=='c' &&
3408 [ # # ][ # # ]: 0 : tolower(line[dummy_int++])=='e' &&
3409 : 0 : tolower(line[dummy_int])=='t')
3410 : : {
3411 [ # # ][ # # ]: 0 : if (fgets(line, 128, fp)==NULL)
3412 : : {
3413 : 0 : return CUBIT_FAILURE;
3414 : : }
3415 : 0 : dummy_int=0;
3416 [ # # ][ # # ]: 0 : while (isspace(line[dummy_int])&& dummy_int<strlen(line))
3417 : : {
3418 : 0 : dummy_int++;
3419 : : }
3420 [ # # ]: 0 : if (strlen(line)-dummy_int>5)
3421 : : {
3422 [ # # ][ # # ]: 0 : if (tolower(line[dummy_int++])=='o' &&
3423 [ # # ]: 0 : tolower(line[dummy_int++])=='u' &&
3424 [ # # ]: 0 : tolower(line[dummy_int++])=='t' &&
3425 [ # # ][ # # ]: 0 : tolower(line[dummy_int++])=='e' &&
3426 : 0 : tolower(line[dummy_int])=='r')
3427 : : {
3428 [ # # ][ # # ]: 0 : if (fgets(line, 128, fp)==NULL)
3429 : : {
3430 : 0 : return CUBIT_FAILURE;
3431 : : }
3432 : 0 : dummy_int=0;
3433 [ # # ][ # # ]: 0 : while (isspace(line[dummy_int])&& dummy_int<strlen(line)) {
3434 : 0 : dummy_int++;
3435 : : }
3436 [ # # ]: 0 : if (strlen(line)-dummy_int>6)
3437 : : {
3438 [ # # ][ # # ]: 0 : if (tolower(line[dummy_int++])=='v' &&
3439 [ # # ]: 0 : tolower(line[dummy_int++])=='e' &&
3440 [ # # ]: 0 : tolower(line[dummy_int++])=='r' &&
3441 [ # # ]: 0 : tolower(line[dummy_int++])=='t' &&
3442 [ # # ][ # # ]: 0 : tolower(line[dummy_int++])=='e' &&
3443 : 0 : tolower(line[dummy_int])=='x')
3444 : : {
3445 : 0 : is_ascii=CUBIT_TRUE;
3446 : : }
3447 : : }
3448 : : }
3449 : : }
3450 : : }
3451 : : }
3452 : 0 : return CUBIT_SUCCESS;
3453 : : }
3454 : :
3455 : :
3456 : : //=============================================================================
3457 : : //Function: create_super_facet_bounding_box(PUBLIC)
3458 : : //Description: Find the bounding box of a list of BodySMs
3459 : : //Author: jdfowle
3460 : : //Date: 12/15/03
3461 : : //=============================================================================
3462 : 0 : CubitStatus OCCQueryEngine::create_super_bounding_box(
3463 : : DLIList<BodySM*>& body_list,
3464 : : CubitBox& super_box )
3465 : : {
3466 : : BodySM *bodySM;
3467 : : int i;
3468 : 0 : CubitStatus status = CUBIT_SUCCESS;
3469 : :
3470 : 0 : body_list.reset();
3471 [ # # ]: 0 : for ( i = 0; i < body_list.size(); i++ ) {
3472 : 0 : bodySM = body_list.get_and_step();
3473 [ # # ]: 0 : OCCBody* occBody = CAST_TO(bodySM, OCCBody);
3474 [ # # ]: 0 : super_box |= occBody->get_bounding_box();
3475 : : }
3476 : :
3477 : 0 : return status;
3478 : : }
3479 : :
3480 : 0 : CubitStatus OCCQueryEngine::restore_transform( BodySM* body )
3481 : : {
3482 : 0 : return CUBIT_FAILURE;
3483 : : }
3484 : :
3485 : 400 : CubitStatus OCCQueryEngine::translate( BodySM* body, const CubitVector& d )
3486 : : {
3487 [ - + ]: 400 : OCCBody* theBody = dynamic_cast<OCCBody*>(body);
3488 [ + - ]: 400 : return theBody ? theBody->move( d.x(), d.y(), d.z() ) : CUBIT_FAILURE;
3489 : : }
3490 : 11 : CubitStatus OCCQueryEngine::rotate( BodySM* body, const CubitVector& v, double a )
3491 : : {
3492 : : // a is in degree.
3493 [ - + ]: 11 : OCCBody* occ_bod = dynamic_cast<OCCBody*>(body);
3494 : 11 : a *= CUBIT_PI/180;
3495 [ + - ]: 11 : return occ_bod ? occ_bod->rotate( v.x(), v.y(), v.z(), a ) : CUBIT_FAILURE;
3496 : : }
3497 : 0 : CubitStatus OCCQueryEngine::scale( BodySM* body, double factor )
3498 : : {
3499 [ # # ]: 0 : OCCBody* facetbod = dynamic_cast<OCCBody*>(body);
3500 [ # # ]: 0 : return facetbod ? facetbod->scale( factor ) : CUBIT_FAILURE;
3501 : : }
3502 : 11 : CubitStatus OCCQueryEngine::scale( BodySM* body, const CubitVector& f )
3503 : : {
3504 [ - + ]: 11 : OCCBody* facetbod = dynamic_cast<OCCBody*>(body);
3505 [ + - ]: 11 : return facetbod ? facetbod->scale( f.x(), f.y(), f.z() ) : CUBIT_FAILURE;
3506 : : }
3507 : :
3508 : : //-------------------------------------------------------------------------
3509 : : // Purpose : Transform a Solid, Surface, Curve, or Vertex
3510 : : //
3511 : : // Special Notes :
3512 : : //
3513 : : // Creator : Jane Hu
3514 : : //
3515 : : // Creation Date : 10/23/07
3516 : : //-------------------------------------------------------------------------
3517 : 0 : CubitStatus OCCQueryEngine::translate( GeometryEntity* entity,
3518 : : const CubitVector& v )
3519 : : {
3520 : : TopoDS_Shape * shape;
3521 [ # # ][ # # ]: 0 : if ((shape = get_TopoDS_Shape_of_entity(entity)) == NULL)
3522 : : {
3523 [ # # ][ # # ]: 0 : PRINT_ERROR( "problem occured getting OCC entity.\n"
[ # # ]
3524 [ # # ]: 0 : " Aborting.\n" );
3525 : 0 : return CUBIT_FAILURE;
3526 : : }
3527 : :
3528 [ # # ][ # # ]: 0 : gp_Vec aVec(v.x(), v.y(),v.z());
[ # # ][ # # ]
3529 [ # # ]: 0 : gp_Trsf aTrsf;
3530 [ # # ]: 0 : aTrsf.SetTranslation(aVec);
3531 : :
3532 [ # # ]: 0 : BRepBuilderAPI_Transform aBRepTrsf(*shape, aTrsf);
3533 : :
3534 [ # # ]: 0 : update_entity_shape(entity, &aBRepTrsf);
3535 [ # # ]: 0 : return CUBIT_SUCCESS;
3536 : : }
3537 : :
3538 : 0 : CubitStatus OCCQueryEngine::update_entity_shape(GeometryEntity* entity_ptr,
3539 : : BRepBuilderAPI_ModifyShape* aBRepTrsf,
3540 : : BRepAlgoAPI_BooleanOperation *op)
3541 : : {
3542 [ # # ][ # # ]: 0 : if (OCCBody *body_ptr = CAST_TO( entity_ptr, OCCBody))
3543 : : {
3544 : 0 : body_ptr->update_OCC_entity(aBRepTrsf, op);
3545 : 0 : return CUBIT_SUCCESS;
3546 : : }
3547 : :
3548 [ # # ][ # # ]: 0 : else if( OCCSurface *surface_ptr = CAST_TO( entity_ptr, OCCSurface))
3549 : : {
3550 : 0 : surface_ptr->update_OCC_entity(aBRepTrsf, op);
3551 : 0 : return CUBIT_SUCCESS;
3552 : : }
3553 : :
3554 [ # # ][ # # ]: 0 : else if( OCCCurve *curve_ptr = CAST_TO( entity_ptr, OCCCurve))
3555 : : {
3556 : 0 : curve_ptr->update_OCC_entity(aBRepTrsf, op);
3557 : 0 : return CUBIT_SUCCESS;
3558 : : }
3559 : :
3560 [ # # ][ # # ]: 0 : else if( OCCPoint *point_ptr = CAST_TO( entity_ptr, OCCPoint))
3561 : : {
3562 : 0 : point_ptr->update_OCC_entity(aBRepTrsf, op);
3563 : 0 : return CUBIT_SUCCESS;
3564 : : }
3565 : :
3566 [ # # ][ # # ]: 0 : PRINT_ERROR("Non-OCC TopologyBridge at %s:%d.\n", __FILE__, __LINE__ );
3567 : 0 : return CUBIT_FAILURE;
3568 : : }
3569 : :
3570 : : //a is angular value of rotation in radians
3571 : 0 : CubitStatus OCCQueryEngine::rotate( GeometryEntity* entity,
3572 : : const CubitVector& v, double a )
3573 : : {
3574 : : TopoDS_Shape * shape;
3575 [ # # ][ # # ]: 0 : if ((shape = get_TopoDS_Shape_of_entity(entity)) == NULL)
3576 : : {
3577 [ # # ][ # # ]: 0 : PRINT_ERROR( "problem occured getting OCC entity.\n"
[ # # ]
3578 [ # # ]: 0 : " Aborting.\n" );
3579 : 0 : return CUBIT_FAILURE;
3580 : : }
3581 : :
3582 [ # # ]: 0 : gp_Pnt aOrigin(0,0,0);
3583 [ # # ][ # # ]: 0 : gp_Dir aDir(v.x(), v.y(), v.z());
[ # # ][ # # ]
3584 [ # # ]: 0 : gp_Ax1 anAxis(aOrigin, aDir);
3585 : :
3586 : : //a is angular value of rotation in radians
3587 [ # # ]: 0 : gp_Trsf aTrsf;
3588 [ # # ]: 0 : aTrsf.SetRotation(anAxis, a);
3589 : :
3590 [ # # ]: 0 : BRepBuilderAPI_Transform aBRepTrsf(*shape, aTrsf);
3591 [ # # ]: 0 : update_entity_shape(entity, &aBRepTrsf);
3592 [ # # ]: 0 : return CUBIT_SUCCESS;
3593 : : }
3594 : :
3595 : 0 : CubitStatus OCCQueryEngine::scale( GeometryEntity* entity, double f )
3596 : : {
3597 : : TopoDS_Shape * shape;
3598 [ # # ][ # # ]: 0 : if ((shape = get_TopoDS_Shape_of_entity(entity)) == NULL)
3599 : : {
3600 [ # # ][ # # ]: 0 : PRINT_ERROR( "problem occured getting OCC entity.\n"
[ # # ]
3601 [ # # ]: 0 : " Aborting.\n" );
3602 : 0 : return CUBIT_FAILURE;
3603 : : }
3604 : :
3605 [ # # ]: 0 : gp_Trsf aTrsf;
3606 [ # # ]: 0 : aTrsf.SetScaleFactor(f);
3607 : :
3608 [ # # ]: 0 : BRepBuilderAPI_Transform aBRepTrsf(*shape, aTrsf);
3609 [ # # ]: 0 : update_entity_shape(entity, &aBRepTrsf);
3610 [ # # ]: 0 : return CUBIT_SUCCESS;
3611 : : }
3612 : :
3613 : 0 : CubitStatus OCCQueryEngine::scale( GeometryEntity* entity,
3614 : : const CubitVector& v )
3615 : : {
3616 : : TopoDS_Shape * shape;
3617 [ # # ][ # # ]: 0 : if ((shape = get_TopoDS_Shape_of_entity(entity)) == NULL)
3618 : : {
3619 [ # # ][ # # ]: 0 : PRINT_ERROR( "problem occured getting OCC entity.\n"
[ # # ]
3620 [ # # ]: 0 : " Aborting.\n" );
3621 : 0 : return CUBIT_FAILURE;
3622 : : }
3623 : :
3624 [ # # ]: 0 : gp_GTrsf gTrsf;
3625 [ # # ][ # # ]: 0 : gTrsf.SetValue(1,1, v.x());
3626 [ # # ][ # # ]: 0 : gTrsf.SetValue(2,2, v.y());
3627 [ # # ][ # # ]: 0 : gTrsf.SetValue(3,3, v.z());
3628 : :
3629 [ # # ]: 0 : BRepBuilderAPI_GTransform gBRepTrsf(gTrsf);
3630 [ # # ]: 0 : gBRepTrsf.Perform(*shape);
3631 [ # # ]: 0 : update_entity_shape(entity, &gBRepTrsf);
3632 [ # # ]: 0 : return CUBIT_SUCCESS;
3633 : : }
3634 : :
3635 : : // like other engines here v is the normal of symmetric plane.
3636 : 0 : CubitStatus OCCQueryEngine::reflect( GeometryEntity* entity,
3637 : : const CubitVector& v)
3638 : : {
3639 : : TopoDS_Shape * shape;
3640 [ # # ][ # # ]: 0 : if ((shape = get_TopoDS_Shape_of_entity(entity)) == NULL)
3641 : : {
3642 [ # # ][ # # ]: 0 : PRINT_ERROR( "problem occured getting OCC entity.\n"
[ # # ]
3643 [ # # ]: 0 : " Aborting.\n" );
3644 : 0 : return CUBIT_FAILURE;
3645 : : }
3646 : :
3647 [ # # ]: 0 : gp_Pnt aOrigin(0,0,0);
3648 [ # # ][ # # ]: 0 : gp_Dir aDir(v.x(), v.y(), v.z());
[ # # ][ # # ]
3649 [ # # ]: 0 : gp_Ax2 anAx2(aOrigin, aDir);
3650 : :
3651 [ # # ]: 0 : gp_Trsf aTrsf;
3652 [ # # ]: 0 : aTrsf.SetMirror(anAx2);
3653 : :
3654 [ # # ]: 0 : BRepBuilderAPI_Transform aBRepTrsf(*shape, aTrsf);
3655 [ # # ]: 0 : update_entity_shape(entity, &aBRepTrsf);
3656 [ # # ]: 0 : return CUBIT_SUCCESS;
3657 : : }
3658 : :
3659 : : //===============================================================================
3660 : : // Function : bodies_overlap
3661 : : // Member Type: PUBLIC
3662 : : // Description: determine if OCC-based bodies overlap
3663 : : // Author : Jane Hu
3664 : : // Date : 10/07
3665 : : //===============================================================================
3666 : 0 : CubitBoolean OCCQueryEngine::bodies_overlap (BodySM * body_ptr_1,
3667 : : BodySM * body_ptr_2 ) const
3668 : : {
3669 [ # # ]: 0 : OCCBody *occ_body1 = CAST_TO(body_ptr_1, OCCBody);
3670 [ # # ]: 0 : if (!occ_body1)
3671 : : {
3672 [ # # ][ # # ]: 0 : PRINT_ERROR("Can't calculate intersection of non-OCC bodies.");
[ # # ][ # # ]
3673 : 0 : return CUBIT_FALSE;
3674 : : }
3675 : :
3676 [ # # ]: 0 : OCCBody *occ_body2 = CAST_TO(body_ptr_2, OCCBody);
3677 [ # # ]: 0 : if (!occ_body2)
3678 : : {
3679 [ # # ][ # # ]: 0 : PRINT_ERROR("Can't calculate intersection of non-OCC bodies.");
[ # # ][ # # ]
3680 : 0 : return CUBIT_FALSE;
3681 : : }
3682 : :
3683 [ # # ]: 0 : CubitBox box_1 = occ_body1->get_bounding_box();
3684 [ # # ][ # # ]: 0 : CubitBox box_2 = occ_body2->get_bounding_box();
3685 [ # # ][ # # ]: 0 : if ( !box_1.overlap( GEOMETRY_RESABS, box_2 ) )
3686 : 0 : return CUBIT_FALSE;
3687 : :
3688 : : TopoDS_Shape *shape1;
3689 [ # # ]: 0 : occ_body1->get_TopoDS_Shape(shape1);
3690 : : TopoDS_Shape *shape2;
3691 [ # # ]: 0 : occ_body2->get_TopoDS_Shape(shape2);
3692 : :
3693 : : //BRepAlgoAPI_Section calculates intersection between faces only.
3694 [ # # ][ # # ]: 0 : TopExp_Explorer Ex1, Ex2;
[ # # ][ # # ]
3695 [ # # ][ # # ]: 0 : for (Ex1.Init(*shape1, TopAbs_SOLID); Ex1.More(); Ex1.Next())
[ # # ][ # # ]
3696 : : {
3697 [ # # ][ # # ]: 0 : TopoDS_Solid *posolid1 = new TopoDS_Solid;
3698 [ # # ][ # # ]: 0 : *posolid1 = TopoDS::Solid(Ex1.Current());
[ # # ]
3699 [ # # ][ # # ]: 0 : OCCLump * lump1 = new OCCLump(posolid1);
3700 [ # # ][ # # ]: 0 : for (Ex2.Init(*shape2, TopAbs_SOLID); Ex2.More(); Ex2.Next())
[ # # ][ # # ]
3701 : : {
3702 [ # # ][ # # ]: 0 : TopoDS_Solid *posolid2 = new TopoDS_Solid;
3703 [ # # ][ # # ]: 0 : *posolid2 = TopoDS::Solid(Ex2.Current());
[ # # ]
3704 [ # # ][ # # ]: 0 : OCCLump * lump2 = new OCCLump(posolid2);
3705 [ # # ]: 0 : CubitBoolean is_overlap = volumes_overlap(lump1, lump2);
3706 [ # # ]: 0 : if(is_overlap)
3707 : 0 : return CUBIT_TRUE;
3708 : : }
3709 : : }
3710 [ # # ]: 0 : return CUBIT_FALSE;
3711 : : }
3712 : :
3713 : 0 : CubitBoolean OCCQueryEngine::volumes_overlap (Lump *lump1, Lump *lump2 ) const
3714 : : {
3715 [ # # ]: 0 : OCCLump *occ_lump1 = CAST_TO(lump1, OCCLump);
3716 [ # # ]: 0 : if (!occ_lump1)
3717 : : {
3718 [ # # ][ # # ]: 0 : PRINT_ERROR("Can't calculate intersection of non-OCC solids.");
[ # # ][ # # ]
3719 : 0 : return CUBIT_FALSE;
3720 : : }
3721 : :
3722 [ # # ]: 0 : OCCLump *occ_lump2 = CAST_TO(lump2, OCCLump);
3723 [ # # ]: 0 : if (!occ_lump2)
3724 : : {
3725 [ # # ][ # # ]: 0 : PRINT_ERROR("Can't calculate intersection of non-OCC solids.");
[ # # ][ # # ]
3726 : 0 : return CUBIT_FALSE;
3727 : : }
3728 : :
3729 [ # # ]: 0 : CubitBox box_1 = occ_lump1->bounding_box();
3730 [ # # ][ # # ]: 0 : CubitBox box_2 = occ_lump2->bounding_box();
3731 [ # # ][ # # ]: 0 : if ( !box_1.overlap( GEOMETRY_RESABS, box_2 ) )
3732 : 0 : return CUBIT_FALSE;
3733 : :
3734 [ # # ]: 0 : TopoDS_Shape *shape1 = (TopoDS_Shape*)(occ_lump1->get_TopoDS_Solid());
3735 [ # # ]: 0 : TopoDS_Shape *shape2 = (TopoDS_Shape*)(occ_lump2->get_TopoDS_Solid());
3736 : :
3737 : : //BRepAlgoAPI_Section calculates intersection between faces only.
3738 [ # # ][ # # ]: 0 : TopExp_Explorer Ex1, Ex2;
[ # # ][ # # ]
3739 [ # # ][ # # ]: 0 : for (Ex1.Init(*shape1, TopAbs_FACE); Ex1.More(); Ex1.Next())
[ # # ][ # # ]
3740 : : {
3741 [ # # ][ # # ]: 0 : for (Ex2.Init(*shape2, TopAbs_FACE); Ex2.More(); Ex2.Next())
[ # # ][ # # ]
3742 : : {
3743 [ # # ][ # # ]: 0 : BRepAlgoAPI_Section section(Ex1.Current(), Ex2.Current());
[ # # ]
3744 [ # # ][ # # ]: 0 : if (section.HasGenerated())
3745 [ # # ][ # # ]: 0 : return CUBIT_TRUE;
3746 : 0 : }
3747 : : }
3748 [ # # ]: 0 : return CUBIT_FALSE;
3749 : : }
3750 : :
3751 : 10365 : void OCCQueryEngine::copy_attributes(TopoDS_Shape& old_shape,
3752 : : TopoDS_Shape& new_shape)
3753 : : {
3754 [ + - ][ + + ]: 10365 : if(new_shape.IsNull())
3755 : 10365 : return;
3756 : :
3757 : : //update the attribute label tree
3758 [ + - ]: 9584 : DLIList<CubitSimpleAttrib> list;
3759 [ + - ]: 9584 : OCCAttribSet::get_attributes(old_shape, list);
3760 : :
3761 [ + - ][ + + ]: 13879 : for(int i = 0; i < list.size(); i ++)
3762 : : {
3763 [ + - ]: 4295 : const CubitSimpleAttrib& s_attr = list.get_and_step();
3764 [ + - ]: 4295 : TopAbs_ShapeEnum type = old_shape.ShapeType();
3765 [ + - ][ + + ]: 4295 : if(new_shape.ShapeType() < type)
3766 : : {
3767 [ + - ]: 66 : TopTools_IndexedMapOfShape M;
3768 [ + - ]: 66 : TopExp::MapShapes(new_shape, type, M);
3769 [ + - ][ + + ]: 198 : for(int j = 1; j <= M.Extent() ; j++ )
3770 : : {
3771 [ + - ][ + - ]: 132 : TopoDS_Shape sub_shape = M(j);
3772 [ + - ]: 132 : OCCAttribSet::append_attribute(s_attr, sub_shape);
3773 [ + - ][ + - ]: 198 : }
3774 : : }
3775 : : else
3776 [ + - ]: 4229 : OCCAttribSet::append_attribute(s_attr, new_shape);
3777 [ + - ]: 9584 : }
3778 : : }
3779 : :
3780 : 30162 : int OCCQueryEngine::update_OCC_map(TopoDS_Shape& old_shape,
3781 : : TopoDS_Shape& new_shape)
3782 : : {
3783 [ + - ][ + - ]: 55947 : if (old_shape.IsNull() || !OCCMap->IsBound(old_shape) ||
[ + - ][ + + ]
[ - + ][ + + ]
3784 [ + - ]: 25785 : old_shape.IsEqual(new_shape))
3785 : 4377 : return -1;
3786 : :
3787 : : //update the attribute label tree
3788 [ + - ]: 25785 : int current_id = OCCMap->Find(old_shape);
3789 : : std::map<int, TDF_Label>::iterator it_lab =
3790 [ + - ]: 25785 : Shape_Label_Map->find(current_id);
3791 : 25785 : CubitBoolean newlyBound = CUBIT_FALSE;
3792 [ + - ]: 25785 : TopTools_IndexedMapOfShape M;
3793 [ + - ][ + - ]: 51570 : TopoDS_Shape new_subshape;
3794 [ + - ]: 25785 : new_subshape.Nullify();
3795 : :
3796 [ + - ][ + + ]: 25785 : if(old_shape.ShapeType() == TopAbs_SOLID)
3797 [ + - ]: 1084 : TopExp::MapShapes(new_shape, TopAbs_SOLID, M);
3798 [ + - ][ + + ]: 24701 : else if (old_shape.ShapeType() == TopAbs_SHELL)
3799 [ + - ]: 1072 : TopExp::MapShapes(new_shape, TopAbs_SHELL, M);
3800 [ + - ][ + + ]: 23629 : else if (old_shape.ShapeType() == TopAbs_FACE)
3801 [ + - ]: 4851 : TopExp::MapShapes(new_shape, TopAbs_FACE, M);
3802 : :
3803 [ + - ][ + - ]: 25785 : if(it_lab != Shape_Label_Map->end())
[ + + ]
3804 : : {
3805 : 4306 : CubitBoolean isNewShapeBound = CUBIT_FALSE;
3806 [ + - ][ + - ]: 16443 : if(old_shape.ShapeType() > TopAbs_COMPOUND && !new_shape.IsNull() &&
[ + + ][ + + ]
[ - + ]
3807 [ + - ][ + - ]: 12137 : new_shape.ShapeType() == TopAbs_COMPOUND && M.Extent() == 1)
[ + - ][ - + ]
3808 : : {
3809 [ # # ][ # # ]: 0 : new_subshape = M(1);
3810 [ # # ]: 0 : isNewShapeBound = OCCMap->IsBound(new_subshape);
3811 [ # # ]: 0 : copy_attributes(old_shape, new_subshape);
3812 [ # # ]: 0 : Shape_Label_Map->erase(current_id);
3813 [ # # ][ # # ]: 0 : if(isNewShapeBound != OCCMap->IsBound(new_subshape))
3814 : 0 : newlyBound = CUBIT_TRUE;
3815 : : }
3816 : : else
3817 : : {
3818 [ + - ]: 4306 : isNewShapeBound = OCCMap->IsBound(new_shape);
3819 [ + - ]: 4306 : copy_attributes(old_shape, new_shape);
3820 [ + - ]: 4306 : Shape_Label_Map->erase(current_id);
3821 [ + - ][ + + ]: 4306 : if(isNewShapeBound != OCCMap->IsBound(new_shape))
3822 : 4306 : newlyBound = CUBIT_TRUE;
3823 : : }
3824 : : }
3825 : :
3826 : : //update CGM-OCC map
3827 : 25785 : int k = current_id;
3828 [ + - ][ - + ]: 25785 : assert (k > 0 && k <= iTotalTBCreated);
3829 : :
3830 [ + - ]: 25785 : std::map<int, TopologyBridge*>::iterator it = OccToCGM->find(k);
3831 : 25785 : TopologyBridge* tb = NULL;
3832 [ + - ][ + - ]: 25785 : if (it != OccToCGM->end())
[ + + ]
3833 [ + - ]: 25773 : tb = (*it).second;
3834 : :
3835 : : //unless just changing location, if the TShape is going to change, remove
3836 : : //old curve_list .
3837 : 25785 : CubitBoolean curve_removed = CUBIT_FALSE;
3838 [ + - ][ + + ]: 25785 : if(old_shape.ShapeType() == TopAbs_VERTEX && !new_shape.IsPartner(old_shape))
[ + - ][ + + ]
[ + + ]
3839 : : {
3840 : : //remove the curve list associated with the vertex too.
3841 [ - + ]: 902 : GeometryEntity* ge = CAST_TO(tb, GeometryEntity);
3842 [ + - ]: 902 : if (ge)
3843 : : {
3844 [ - + ]: 902 : OCCPoint* test_p = CAST_TO(ge, OCCPoint);
3845 [ + - ]: 902 : if(test_p)
3846 : : {
3847 [ + - ]: 902 : test_p->clear_curves();
3848 : 902 : curve_removed = CUBIT_TRUE;
3849 : : }
3850 : : }
3851 : : }
3852 : :
3853 [ + - ]: 25785 : OCCMap->UnBind(old_shape);
3854 [ + - ][ + - ]: 25785 : if(new_subshape.IsNull())
3855 [ + - ]: 25785 : new_subshape = new_shape;
3856 : :
3857 [ + - ][ + + ]: 52630 : if (tb && TopAbs_SOLID == old_shape.ShapeType() && !new_shape.IsNull() &&
[ + - ][ + - ]
[ + + ][ + + ]
3858 [ + + ][ + - ]: 52630 : TopAbs_COMPOUND == new_shape.ShapeType() && M.Extent() > 1)
[ + - ][ + - ]
3859 : : {
3860 [ + - ]: 66 : OccToCGM->erase(k);
3861 [ - + ]: 66 : GeometryEntity* ge = CAST_TO(tb, GeometryEntity);
3862 [ + - ]: 66 : if(ge)
3863 [ + - ]: 66 : delete_solid_model_entities( ge, CUBIT_TRUE);
3864 : 66 : return k;
3865 : : }
3866 : :
3867 [ + - ][ + + ]: 56035 : else if(tb && TopAbs_FACE == old_shape.ShapeType() && !new_shape.IsNull() &&
[ + - ][ + + ]
[ - + ][ - + ]
3868 [ + + ][ + - ]: 56035 : TopAbs_COMPOUND == new_shape.ShapeType() && M.Extent() > 1)
[ # # ][ # # ]
3869 : : {
3870 [ # # ]: 0 : GeometryEntity* ge = CAST_TO(tb, GeometryEntity);
3871 [ # # ]: 0 : if(ge)
3872 : : {
3873 [ # # ]: 0 : OCCSurface *face = CAST_TO(ge, OCCSurface);
3874 [ # # ]: 0 : OCCShell* shell = face->my_shell();
3875 [ # # ]: 0 : if (shell)
3876 : : {
3877 [ # # ]: 0 : TopoDS_Shell* shape = shell->get_TopoDS_Shell();
3878 [ # # ]: 0 : assert(!shape );
3879 [ # # ]: 0 : if (shape) {
3880 [ # # ][ # # ]: 0 : PRINT_ERROR("Unexpected non-NULL TopoDS_Shell pointer.\n");
[ # # ][ # # ]
3881 : 0 : return -1;
3882 : : }
3883 : : }
3884 [ # # ]: 0 : OCCLump* lump = face->my_lump();
3885 [ # # ]: 0 : if(lump)
3886 : : {
3887 [ # # ]: 0 : TopoDS_Solid* shape = lump->get_TopoDS_Solid();
3888 [ # # ]: 0 : assert(!shape );
3889 [ # # ]: 0 : if (shape) {
3890 [ # # ][ # # ]: 0 : PRINT_ERROR("Unexpected non-NULL TopoDS_Solid pointer.\n");
[ # # ][ # # ]
3891 : 0 : return -1;
3892 : : }
3893 [ # # ][ # # ]: 0 : delete lump;
3894 : : }
3895 [ # # ]: 0 : OCCBody* body = face->my_body();
3896 [ # # ]: 0 : if (body)
3897 [ # # ][ # # ]: 0 : delete body;
3898 : :
3899 [ # # ]: 0 : delete_solid_model_entities(ge, CUBIT_TRUE);
3900 [ # # ]: 0 : if(shell)
3901 [ # # ][ # # ]: 0 : delete shell;
3902 : : }
3903 : 0 : return k;
3904 : : }
3905 : :
3906 [ + + ][ + - ]: 104228 : else if (tb && ((!new_subshape.IsNull() && !old_shape.IsSame(new_subshape)&&
[ + + ][ + - ]
[ + - ][ + + ]
[ + + ]
3907 [ + - ][ + + ]: 27083 : OCCMap->IsBound(new_subshape) &&
3908 [ + - ][ + - ]: 57415 : OccToCGM->find(OCCMap->Find(new_subshape))!= OccToCGM->end()) ||
[ + - ][ + - ]
[ + + ][ + + ]
[ + + ]
[ # # # # ]
3909 [ + - ]: 25168 : new_subshape.IsNull()))
3910 : : //already has a TB built on new_shape
3911 : : {
3912 : : //delete the second TB corresponding to old_shape
3913 [ + - ]: 2427 : OccToCGM->erase(k);
3914 [ - + ]: 2427 : GeometryEntity* ge = CAST_TO(tb, GeometryEntity);
3915 [ + + ]: 2427 : if(ge)
3916 : : {
3917 : : //PRINT_INFO("TB: %p\n",ge);
3918 [ - + ]: 1661 : Lump* lump = CAST_TO(ge, Lump);
3919 [ + + ]: 1661 : if(lump)
3920 : : {
3921 [ - + ][ + - ]: 55 : BodySM* body = CAST_TO(lump,OCCLump)->get_body();
3922 [ + - ]: 55 : if(body)
3923 : : {
3924 : : //OCCBody* occ_body = CAST_TO(body, OCCBody);
3925 : : //TopoDS_Compound* pshape = occ_body->get_TopoDS_Shape();
3926 : : //if(!pshape || pshape->IsNull())
3927 [ + - ]: 55 : delete_solid_model_entities(body);
3928 : : }
3929 : : }
3930 : :
3931 : : else
3932 : : {
3933 [ - + ]: 1606 : OCCPoint* test_p = CAST_TO(ge, OCCPoint);
3934 [ + + ]: 1606 : if(test_p)
3935 [ + - ]: 528 : test_p->clear_curves();
3936 [ + - ]: 1661 : delete_solid_model_entities( ge, CUBIT_FALSE );
3937 : : }
3938 : : }
3939 : :
3940 : : else
3941 : : {
3942 [ - + ]: 766 : ShellSM * shell = CAST_TO(tb, ShellSM);
3943 [ + + ]: 766 : if(shell)
3944 : : {
3945 [ + - ]: 121 : DLIList<OCCSurface*> memberSurfaces;
3946 [ - + ]: 121 : OCCShell* occShell = CAST_TO(shell, OCCShell);
3947 [ + - ][ + - ]: 121 : memberSurfaces = occShell->getMemberSurfaces();
[ + - ]
3948 [ + - ][ + + ]: 748 : while (memberSurfaces.size())
3949 : : {
3950 [ + - ]: 627 : OCCSurface* memberSurf = memberSurfaces.pop();
3951 [ + - ][ + + ]: 627 : if (SurfaceList->is_in_list(memberSurf))
3952 : : // if the surface has not been unhooked and deleted
3953 [ + - ]: 627 : memberSurf->set_shell((OCCShell*)NULL);
3954 : : }
3955 : :
3956 [ - + ][ + - ]: 121 : OCCLump* lump = CAST_TO(shell, OCCShell)->my_lump();
3957 [ + - ][ + - ]: 242 : if(lump && (lump->get_TopoDS_Solid() == NULL ||
[ + - ][ - + ]
[ - + ]
3958 [ + - ][ + - ]: 121 : !OCCMap->IsBound(*(lump->get_TopoDS_Solid()))))
3959 : : {
3960 [ # # ][ # # ]: 0 : delete CAST_TO(shell, OCCShell)->my_body();
[ # # ][ # # ]
3961 [ # # ][ # # ]: 0 : delete lump;
3962 : : }
3963 [ + - ]: 121 : unhook_ShellSM_from_OCC(shell);
3964 [ + - ][ + - ]: 121 : delete shell;
3965 [ + - ]: 121 : return k;
3966 : : }
3967 [ - + ]: 645 : LoopSM* loop = CAST_TO(tb, LoopSM);
3968 [ + - ]: 645 : if(loop)
3969 : : {
3970 [ + - ]: 645 : DLIList<OCCCoEdge*> children;
3971 [ - + ][ + - ]: 645 : children = CAST_TO(loop, OCCLoop)->coedges();
[ + - ][ + - ]
3972 [ + - ][ + + ]: 1795 : while(children.size())
3973 : : {
3974 [ + - ]: 1150 : OCCCoEdge* coedge = children.pop();
3975 [ - + ][ + - ]: 1150 : CAST_TO(coedge->curve(), OCCCurve)->remove_loop(CAST_TO(loop, OCCLoop));
[ - + ][ + - ]
3976 [ + - ][ + - ]: 1150 : delete (OCCCoEdge*)coedge;
3977 : : }
3978 [ + - ]: 645 : unhook_LoopSM_from_OCC(loop);
3979 [ + - ][ + - ]: 645 : delete loop;
3980 [ + - ]: 2306 : return k;
3981 : : }
3982 : : }
3983 : : }
3984 : :
3985 : : else
3986 : : {
3987 : : //if the new_shape is bounded in copy_attribute, unbind it and rebind to
3988 : : //the old k
3989 [ + + ]: 23292 : if(newlyBound)
3990 : : {
3991 [ + - ]: 2725 : int new_k = OCCMap->Find(new_subshape);
3992 [ + - ]: 2725 : TDF_Label aLabel;
3993 : 2725 : CubitBoolean found = CUBIT_FALSE;
3994 [ + - ]: 2725 : OCCAttribSet::FindShape(new_subshape, aLabel, found);
3995 [ - + ]: 2725 : assert(found);
3996 [ + - ]: 2725 : Shape_Label_Map->erase(new_k);
3997 [ + - ][ + - ]: 2725 : Shape_Label_Map->insert(labType(k, aLabel));
3998 [ + - ]: 2725 : OCCMap->UnBind(new_subshape);
3999 : : }
4000 [ + - ][ + + ]: 23292 : if(!OCCMap->IsBound(new_subshape))
4001 [ + - ]: 23280 : OCCMap->Bind(new_subshape, k);
4002 [ + + ][ + + ]: 23292 : if(tb && !curve_removed)
4003 [ + - ]: 22906 : set_TopoDS_Shape(tb, new_subshape);
4004 : : }
4005 [ + - ]: 55115 : return k;
4006 : : }
4007 : :
4008 : 60295 : void OCCQueryEngine::unhook_coedges_of_a_curve(OCCCurve* curve,
4009 : : OCCLoop* loop)const
4010 : : {
4011 [ + - ]: 60295 : DLIList<OCCCoEdge*> coedges;
4012 [ + - ][ + - ]: 120590 : DLIList<OCCCoEdge *> children ;
4013 [ + + ]: 60295 : if (loop != NULL)
4014 [ + - ][ + - ]: 38322 : children = loop->coedges();
[ + - ]
4015 : : else
4016 : : {
4017 [ + - ]: 21973 : DLIList<OCCLoop*> loops;
4018 [ + - ][ + - ]: 21973 : loops = curve->loops();
[ + - ]
4019 [ + - ][ + + ]: 23535 : for (int i = 0; i < loops.size(); i ++)
4020 [ + - ][ + - ]: 23535 : children += loops.get_and_step()->coedges();
[ + - ][ + - ]
[ + - ]
4021 : : }
4022 [ + - ][ + + ]: 176369 : for(int j = 0; j < children.size(); j++)
4023 : : {
4024 [ + - ]: 116074 : OCCCoEdge* coedge = children.get_and_step();
4025 [ + - ][ + + ]: 116074 : if (coedge->curve() == curve)
4026 [ + - ]: 40679 : coedges.append(coedge);
4027 : : }
4028 [ + - ][ + - ]: 120590 : unhook_CoEdges_from_OCC(coedges);
4029 : 60295 : }
4030 : :
4031 : 22906 : void OCCQueryEngine::set_TopoDS_Shape(TopologyBridge* tb,
4032 : : TopoDS_Shape& shape)
4033 : : {
4034 [ - + ]: 22906 : BodySM* body = CAST_TO(tb, BodySM);
4035 [ - + ]: 22906 : if(body)
4036 [ # # ]: 0 : return CAST_TO(body, OCCBody)->set_TopoDS_Shape(TopoDS::Compound(shape));
4037 : :
4038 [ - + ]: 22906 : Lump* lump = CAST_TO(tb, Lump);
4039 [ + + ]: 22906 : if(lump)
4040 [ - + ][ + - ]: 951 : return CAST_TO(lump, OCCLump)->set_TopoDS_Solid(TopoDS::Solid(shape));
4041 : :
4042 [ - + ]: 21955 : ShellSM* shell = CAST_TO(tb, ShellSM);
4043 [ + + ]: 21955 : if(shell)
4044 [ - + ][ + - ]: 951 : return CAST_TO(shell, OCCShell)->set_TopoDS_Shell(TopoDS::Shell(shape));
4045 : :
4046 [ - + ]: 21004 : Surface* surface = CAST_TO(tb, Surface);
4047 [ + + ]: 21004 : if (surface)
4048 [ - + ]: 4609 : return CAST_TO(surface, OCCSurface)->set_TopoDS_Face(TopoDS::Face(shape));
4049 : :
4050 [ - + ]: 16395 : LoopSM* loop = CAST_TO(tb, LoopSM);
4051 [ + + ]: 16395 : if(loop)
4052 [ - + ][ + - ]: 4518 : return CAST_TO(loop, OCCLoop)->set_TopoDS_Wire(TopoDS::Wire(shape));
4053 : :
4054 [ - + ]: 11877 : Curve* curve = CAST_TO(tb, Curve);
4055 [ + + ]: 11877 : if (curve)
4056 [ - + ][ + - ]: 7457 : return CAST_TO(curve, OCCCurve)->set_TopoDS_Edge(TopoDS::Edge(shape));
4057 : :
4058 [ - + ]: 4420 : TBPoint* point = CAST_TO(tb, TBPoint);
4059 [ + - ]: 4420 : if(point)
4060 [ - + ][ + - ]: 22906 : return CAST_TO(point, OCCPoint)->set_TopoDS_Vertex(TopoDS::Vertex(shape));
4061 : :
4062 : : }
4063 : :
4064 : : //Added by Jane Hu on 06/17/11
4065 : 0 : void OCCQueryEngine::bound_TopoDS_Shape(const TopoDS_Shape & aShape)
4066 : : {
4067 : 0 : (iTotalTBCreated)++;
4068 [ # # # # : 0 : switch (aShape.ShapeType())
# # # # ]
4069 : : {
4070 : : case TopAbs_COMPOUND:
4071 : 0 : OCCMap->Bind(TopoDS::Compound(aShape), iTotalTBCreated);
4072 : 0 : break;
4073 : : case TopAbs_SOLID:
4074 : 0 : OCCMap->Bind(TopoDS::Solid(aShape), iTotalTBCreated);
4075 : 0 : break;
4076 : : case TopAbs_SHELL:
4077 : 0 : OCCMap->Bind(TopoDS::Shell(aShape), iTotalTBCreated);
4078 : 0 : break;
4079 : : case TopAbs_FACE:
4080 : 0 : OCCMap->Bind(TopoDS::Face(aShape), iTotalTBCreated);
4081 : 0 : break;
4082 : : case TopAbs_WIRE:
4083 : 0 : OCCMap->Bind(TopoDS::Wire(aShape), iTotalTBCreated);
4084 : 0 : break;
4085 : : case TopAbs_EDGE:
4086 : 0 : OCCMap->Bind(TopoDS::Edge(aShape), iTotalTBCreated);
4087 : 0 : break;
4088 : : case TopAbs_VERTEX:
4089 : 0 : OCCMap->Bind(TopoDS::Vertex(aShape), iTotalTBCreated);
4090 : 0 : break;
4091 : :
4092 : : default:
4093 : 0 : (iTotalTBCreated)--;
4094 : : }
4095 [ + - ][ + - ]: 6364 : }
4096 : : //EOF
|
