Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : OCCSurface.cpp
3 : : //
4 : : // Purpose :
5 : : //
6 : : // Special Notes :
7 : : //
8 : : // Creator : Alexander Danilov
9 : : //
10 : : // Creation Date :
11 : : //
12 : : // Owner :
13 : : //-------------------------------------------------------------------------
14 : :
15 : : // ********** BEGIN OCC INCLUDES **********
16 : : #include "OCCSurface.hpp"
17 : : #include "OCCQueryEngine.hpp"
18 : :
19 : : #include "OCCBody.hpp"
20 : : #include "OCCLump.hpp"
21 : : #include "OCCShell.hpp"
22 : : #include "OCCLoop.hpp"
23 : : #include "OCCCoEdge.hpp"
24 : : #include "OCCCurve.hpp"
25 : : #include "OCCPoint.hpp"
26 : : #include "OCCAttribSet.hpp"
27 : : #include "GfxDebug.hpp"
28 : : #include "OCCDrawTool.hpp"
29 : : // ********** END OCC INCLUDES **********
30 : :
31 : : // ********** BEGIN CUBIT INCLUDES **********
32 : :
33 : : #include "CubitVector.hpp"
34 : : #include "GeometryDefines.h"
35 : : #include "CubitUtil.hpp"
36 : : #include "CastTo.hpp"
37 : : #include "GeometryQueryEngine.hpp"
38 : : #include "DLIList.hpp"
39 : : #include "ShellSM.hpp"
40 : : #include "Lump.hpp"
41 : : #include "LoopSM.hpp"
42 : : // ********** END CUBIT INCLUDES **********
43 : :
44 : :
45 : : // ********** BEGIN OpenCascade INCLUDES **********
46 : :
47 : : #include <BRepAdaptor_Surface.hxx>
48 : : #include <TopExp.hxx>
49 : : #include <TopTools_IndexedMapOfShape.hxx>
50 : : #include <Bnd_Box.hxx>
51 : : #include <BndLib_AddSurface.hxx>
52 : : #include <Precision.hxx>
53 : : #include <TopoDS.hxx>
54 : : #include <Extrema_ExtPS.hxx>
55 : : #include <BRepLProp_SLProps.hxx>
56 : : #include <BRepGProp.hxx>
57 : : #include <GProp_GProps.hxx>
58 : : #include "TopTools_ListIteratorOfListOfShape.hxx"
59 : : #include "TopTools_DataMapOfShapeInteger.hxx"
60 : : #include "TopTools_IndexedDataMapOfShapeListOfShape.hxx"
61 : : #include "BRepClass_FaceClassifier.hxx"
62 : : #include "BRepBuilderAPI_ModifyShape.hxx"
63 : : #include "BRepAlgoAPI_BooleanOperation.hxx"
64 : : #include "BRepBuilderAPI_MakeShape.hxx"
65 : : #include "BRepBuilderAPI_Transform.hxx"
66 : : #include "BRepBuilderAPI_GTransform.hxx"
67 : : #include "BRepFilletAPI_MakeFillet2d.hxx"
68 : : #include "BRepTools_WireExplorer.hxx"
69 : : #include "TopExp.hxx"
70 : : #include "BRep_Tool.hxx"
71 : : #include "BRep_Builder.hxx"
72 : : #include "LocOpe_SplitShape.hxx"
73 : : #include "TopoDS_Compound.hxx"
74 : : #include "BRepExtrema_DistShapeShape.hxx"
75 : : #include "Geom_BSplineSurface.hxx"
76 : : #include "IntCurvesFace_ShapeIntersector.hxx"
77 : : #include "TColgp_Array2OfPnt.hxx"
78 : : #include "TColStd_Array2OfReal.hxx"
79 : : #include "TColStd_Array1OfReal.hxx"
80 : : #include "gp_Dir.hxx"
81 : : #include "gp_Lin.hxx"
82 : : #include "gp_Pnt.hxx"
83 : : #include "gp_Sphere.hxx"
84 : : #include "gp_Cone.hxx"
85 : : #include "gp_Torus.hxx"
86 : : // ********** END OpenCascade INCLUDES **********
87 : :
88 : :
89 : : // ********** BEGIN STATIC DECLARATIONS **********
90 : : // ********** END STATIC DECLARATIONS **********
91 : :
92 : :
93 : : // ********** BEGIN PUBLIC FUNCTIONS **********
94 : :
95 : : //-------------------------------------------------------------------------
96 : : // Purpose : The constructor with a pointer to the TopoDS_Face.
97 : : //
98 : : // Special Notes :
99 : : //
100 : : //-------------------------------------------------------------------------
101 [ + - ]: 31662 : OCCSurface::OCCSurface(TopoDS_Face *theFace)
102 : : {
103 : 15831 : myTopoDSFace = theFace;
104 : 15831 : myShell = NULL;
105 : 15831 : myLump = NULL;
106 : 15831 : myBody = NULL;
107 [ + - ][ + - ]: 15831 : if(myTopoDSFace && !myTopoDSFace->IsNull())
[ + - ][ + - ]
108 [ + - ][ - + ]: 15831 : assert(myTopoDSFace->ShapeType() == TopAbs_FACE);
109 : 15831 : }
110 : :
111 : :
112 [ + - ]: 29946 : OCCSurface::~OCCSurface()
113 : : {
114 [ + - ]: 9982 : if(myTopoDSFace)
115 : : {
116 [ + - ]: 9982 : myTopoDSFace->Nullify();
117 [ + - ][ + - ]: 9982 : delete (TopoDS_Face*)myTopoDSFace;
[ + - ]
118 : 9982 : myTopoDSFace = NULL;
119 : : }
120 [ - + ]: 19964 : }
121 : :
122 : 6610 : void OCCSurface::set_TopoDS_Face(TopoDS_Face& face)
123 : : {
124 [ + - ][ + + ]: 6610 : if(myTopoDSFace && face.IsEqual(*myTopoDSFace))
[ + + ]
125 : 1924 : return;
126 : :
127 [ + - ]: 4686 : if(myTopoDSFace)
128 : 4686 : myTopoDSFace->Nullify();
129 : 4686 : *myTopoDSFace = face ;
130 : : }
131 : :
132 : :
133 : : //-------------------------------------------------------------------------
134 : : // Purpose : The purpose of this function is to append a
135 : : // attribute to the GE. The name is attached to the
136 : : // underlying solid model entity this one points to.
137 : : //
138 : : //
139 : : // Special Notes :
140 : : //
141 : : //-------------------------------------------------------------------------
142 : 11848 : void OCCSurface::append_simple_attribute_virt(const CubitSimpleAttrib &csa)
143 : 11848 : { OCCAttribSet::append_attribute(csa, *myTopoDSFace); }
144 : :
145 : :
146 : : //-------------------------------------------------------------------------
147 : : // Purpose : The purpose of this function is to remove a simple
148 : : // attribute attached to this geometry entity. The name is
149 : : // removed from the underlying BODY this points to.
150 : : //
151 : : // Special Notes :
152 : : //
153 : : //-------------------------------------------------------------------------
154 : 47031 : void OCCSurface::remove_simple_attribute_virt(const CubitSimpleAttrib &csa)
155 : 47031 : { OCCAttribSet::remove_attribute( csa , *myTopoDSFace); }
156 : :
157 : :
158 : : //-------------------------------------------------------------------------
159 : : // Purpose : The purpose of this function is to remove all simple
160 : : // attributes attached to this geometry entity. Also
161 : : // removes lingering GTC attributes.
162 : : //
163 : : //
164 : : // Special Notes :
165 : : //
166 : : //-------------------------------------------------------------------------
167 : 31935 : void OCCSurface::remove_all_simple_attribute_virt()
168 : : {
169 [ + - ]: 31935 : OCCAttribSet::remove_attribute(CubitSimpleAttrib(), *myTopoDSFace);
170 : 31935 : }
171 : :
172 : :
173 : : //-------------------------------------------------------------------------
174 : : // Purpose : The purpose of this function is to get the
175 : : // attributes attached to this geometry entity. The name is
176 : : // attached to the underlying BODY this points to.
177 : : //
178 : : // Special Notes :
179 : : //
180 : : //-------------------------------------------------------------------------
181 : 21655 : CubitStatus OCCSurface::get_simple_attribute(DLIList<CubitSimpleAttrib>&
182 : : csa_list)
183 : 21655 : { return OCCAttribSet::get_attributes(*myTopoDSFace,csa_list); }
184 : :
185 : 181778 : CubitStatus OCCSurface::get_simple_attribute(const CubitString& name,
186 : : DLIList<CubitSimpleAttrib>& csa_list )
187 : 181778 : { return OCCAttribSet::get_attributes( name, *myTopoDSFace, csa_list ); }
188 : :
189 : :
190 : : //-------------------------------------------------------------------------
191 : : // Purpose : Get geometry modeling engine: OCCQueryEngine
192 : : //
193 : : // Special Notes :
194 : : //
195 : : //-------------------------------------------------------------------------
196 : : GeometryQueryEngine*
197 : 7639 : OCCSurface::get_geometry_query_engine() const
198 : : {
199 : 7639 : return OCCQueryEngine::instance();
200 : : }
201 : :
202 : :
203 : 80951 : CubitStatus OCCSurface::closest_point_along_vector(CubitVector& from_point,
204 : : CubitVector& along_vector,
205 : : CubitVector& point_on_surface)
206 : : {
207 : : // define the search ray in a way that OCC will understand
208 [ + - ][ + - ]: 80951 : gp_Pnt vectorOrigin(from_point.x(), from_point.y(), from_point.z());
[ + - ][ + - ]
209 [ + - ][ + - ]: 80951 : gp_Dir vectorDir(along_vector.x(), along_vector.y(), along_vector.z());
[ + - ][ + - ]
210 [ + - ]: 80951 : gp_Lin occVector(vectorOrigin, vectorDir);
211 : :
212 : : // perform the OCC intersection algorithm
213 [ + - ]: 80951 : IntCurvesFace_ShapeIntersector csIntersector;
214 [ + - ][ + - ]: 80951 : csIntersector.Load(*get_TopoDS_Face(), Precision::Intersection());
[ + - ]
215 [ + - ]: 80951 : csIntersector.Perform(occVector, 0, 1e63);
216 : :
217 : : // fail if intersection could not be computed or there is no intersection
218 [ + - ][ + - ]: 80951 : if (!csIntersector.IsDone() || csIntersector.NbPnt() == 0)
[ + - ][ + + ]
[ + + ]
219 : : {
220 : 19838 : return CUBIT_FAILURE;
221 : : }
222 : :
223 : : // identify which of the intersection points along the vector is the closest
224 : 61113 : double minWParam = -1;
225 : 61113 : int minIndex = 0;
226 [ + - ][ + + ]: 126342 : for (int iPntIndx = 1; iPntIndx <= csIntersector.NbPnt(); ++iPntIndx)
227 : : {
228 [ + - ]: 65229 : double wParam = csIntersector.WParameter(iPntIndx);
229 [ + + ][ - + ]: 65229 : if (minIndex == 0 || wParam < minWParam)
230 : : {
231 : 61113 : minIndex = iPntIndx;
232 : 61113 : minWParam = wParam;
233 : : }
234 : : }
235 : :
236 : : // package and return the closest intersection point
237 [ + - ]: 61113 : gp_Pnt closestIntPnt = csIntersector.Pnt(minIndex);
238 : : point_on_surface.set(closestIntPnt.X(),
239 [ + - ][ + - ]: 61113 : closestIntPnt.Y(), closestIntPnt.Z());
[ + - ][ + - ]
240 [ + - ]: 80951 : return CUBIT_SUCCESS;
241 : : }
242 : :
243 : : //-------------------------------------------------------------------------
244 : : // Purpose : Returns a surface type ID -- the values of these are
245 : : // determined by OCC.
246 : : //
247 : : // Special Notes :
248 : : // This code is very -specific and could change with
249 : : // new versions of . There are #defines for the
250 : : // various surface type ID's. These are defined in the
251 : : // header files of each of the specific surface classes
252 : : // in .
253 : : //
254 : : //
255 : : // Creator : Jane HU
256 : : //
257 : : // Creation Date : 12/06/07
258 : : //-------------------------------------------------------------------------
259 : 5317 : GeometryType OCCSurface::geometry_type()
260 : : {
261 [ + - ]: 5317 : BRepAdaptor_Surface asurface(*myTopoDSFace);
262 [ + - ][ - + ]: 5317 : if (asurface.GetType() == GeomAbs_BezierSurface)
263 : 0 : return SPLINE_SURFACE_TYPE;
264 [ + - ][ - + ]: 5317 : if (asurface.GetType() == GeomAbs_BSplineSurface)
265 : 0 : return SPLINE_SURFACE_TYPE;
266 [ + - ][ + + ]: 5317 : if (asurface.GetType() == GeomAbs_Plane)
267 : 4997 : return PLANE_SURFACE_TYPE;
268 [ + - ][ - + ]: 320 : if (asurface.GetType() == GeomAbs_Cylinder ||
[ # # ][ + - ]
269 [ # # ]: 0 : asurface.GetType() == GeomAbs_Cone)
270 : 320 : return CONE_SURFACE_TYPE;
271 [ # # ][ # # ]: 0 : if (asurface.GetType() == GeomAbs_Sphere)
272 : 0 : return SPHERE_SURFACE_TYPE;
273 [ # # ][ # # ]: 0 : if (asurface.GetType() == GeomAbs_Torus)
274 : 0 : return TORUS_SURFACE_TYPE;
275 [ # # ][ # # ]: 0 : if (asurface.GetType() == GeomAbs_SurfaceOfRevolution)
276 : 0 : return UNDEFINED_SURFACE_TYPE;
277 [ # # ][ # # ]: 0 : if (asurface.GetType() == GeomAbs_SurfaceOfExtrusion)
278 : 0 : return UNDEFINED_SURFACE_TYPE;
279 [ # # ][ # # ]: 0 : if (asurface.GetType() == GeomAbs_OffsetSurface)
280 : 0 : return UNDEFINED_SURFACE_TYPE;
281 [ + - ]: 5317 : return UNDEFINED_SURFACE_TYPE;
282 : : }
283 : : //-------------------------------------------------------------------------
284 : : // Purpose : Get the bounding box of the object.
285 : : //
286 : : // Special Notes :
287 : : //
288 : : //-------------------------------------------------------------------------
289 : 28296 : CubitBox OCCSurface::bounding_box() const
290 : : {
291 [ + - ]: 28296 : TopoDS_Face face = *myTopoDSFace;
292 [ + - ][ + - ]: 56592 : BRepAdaptor_Surface asurface(face);
293 [ + - ]: 28296 : Bnd_Box aBox;
294 [ + - ][ + - ]: 28296 : BndLib_AddSurface::Add(asurface, Precision::Approximation(), aBox);
295 : : double min[3], max[3];
296 [ + - ]: 28296 : aBox.Get( min[0], min[1], min[2], max[0], max[1], max[2]);
297 [ + - ][ + - ]: 56592 : return CubitBox(min, max);
298 : : }
299 : :
300 : :
301 : 0 : CubitStatus OCCSurface::get_point_normal( CubitVector& location,
302 : : CubitVector& normal )
303 : : {
304 [ # # ][ # # ]: 0 : return closest_point( bounding_box().center(), &location, &normal );
305 : : }
306 : :
307 : 0 : CubitStatus OCCSurface::closest_point_uv_guess(
308 : : CubitVector const& location,
309 : : double& , double& ,
310 : : CubitVector* closest_location,
311 : : CubitVector* unit_normal )
312 : : {
313 : : // don't use u and v guesses
314 : 0 : return closest_point(location, closest_location, unit_normal);
315 : : }
316 : :
317 : :
318 : : //-------------------------------------------------------------------------
319 : : // Purpose : Computes the closest_point on the surface to the input
320 : : // location. Optionally, it also computes and returns
321 : : // the normal to the surface at closest_location and the
322 : : // principal curvatures(1-min, 2-max)
323 : : //
324 : : //-------------------------------------------------------------------------
325 : 3739327 : CubitStatus OCCSurface::closest_point( CubitVector const& location,
326 : : CubitVector* closest_location,
327 : : CubitVector* unit_normal_ptr,
328 : : CubitVector* curvature_1,
329 : : CubitVector* curvature_2)
330 : : {
331 [ + - ]: 3739327 : BRepAdaptor_Surface asurface(*myTopoDSFace);
332 [ + - ][ + - ]: 3739327 : gp_Pnt p(location.x(), location.y(), location.z()), newP(0.0, 0.0, 0.0);
[ + - ][ + - ]
[ + - ]
333 : 3739327 : double minDist=0.0, u, v;
334 : : int i;
335 [ + - ][ + - ]: 7478654 : BRepLProp_SLProps SLP(asurface, 2, Precision::PConfusion());
[ + - ]
336 [ + - ][ + - ]: 7478654 : Extrema_ExtPS ext(p, asurface, Precision::Approximation(), Precision::Approximation());
[ + - ][ + - ]
337 [ + - ][ + + ]: 3739327 : if (ext.IsDone() && (ext.NbExt() > 0)) {
[ + - ][ + + ]
[ + + ]
338 [ + - ][ + + ]: 7635963 : for ( i = 1 ; i <= ext.NbExt() ; i++ ) {
339 [ + + ][ + - ]: 3898291 : if ( (i==1) || (p.Distance(ext.Point(i).Value()) < minDist) ) {
[ + - ][ + - ]
[ - + ][ + + ]
340 [ + - ][ + - ]: 3737672 : minDist = p.Distance(ext.Point(i).Value());
[ + - ]
341 [ + - ][ + - ]: 3737672 : newP = ext.Point(i).Value();
342 [ + - ][ + - ]: 3737672 : ext.Point(i).Parameter(u, v);
343 [ + - ]: 3737672 : SLP.SetParameters(u, v);
344 : : }
345 : : }
346 : :
347 [ + + ]: 3737672 : if (closest_location != NULL)
348 [ + - ][ + - ]: 147870 : *closest_location = CubitVector(newP.X(), newP.Y(), newP.Z());
[ + - ][ + - ]
[ + - ]
349 [ + + ]: 3737672 : if (unit_normal_ptr != NULL) {
350 [ + - ]: 3728743 : gp_Dir normal;
351 [ + - ][ + - ]: 3728743 : if (SLP.IsNormalDefined()) {
352 [ + - ]: 3728743 : normal = SLP.Normal();
353 [ + - ][ + - ]: 3728743 : *unit_normal_ptr = CubitVector(normal.X(), normal.Y(), normal.Z());
[ + - ][ + - ]
[ + - ]
354 : : }
355 : : }
356 : :
357 [ + - ][ + - ]: 3737672 : gp_Dir MaxD, MinD;
358 [ + - ][ + + ]: 3737672 : if (SLP.IsCurvatureDefined())
359 : : {
360 [ + - ]: 3737107 : SLP.CurvatureDirections(MaxD, MinD);
361 [ + + ]: 3737107 : if (curvature_1 != NULL)
362 [ + - ][ + - ]: 68902 : *curvature_1 = CubitVector(MinD.X(), MinD.Y(), MinD.Z());
[ + - ][ + - ]
[ + - ]
363 [ + + ]: 3737107 : if (curvature_2 != NULL)
364 [ + - ][ + - ]: 68902 : *curvature_2 = CubitVector(MaxD.X(), MaxD.Y(), MaxD.Z());
[ + - ][ + - ]
[ + - ]
365 : : }
366 : 3737672 : return CUBIT_SUCCESS;
367 : : }
368 : : //return as OCC did.
369 [ + - ]: 3740982 : return CUBIT_SUCCESS;
370 : : }
371 : :
372 : : //-------------------------------------------------------------------------
373 : : // Purpose : Computes the closest_point on the trimmed surface to the
374 : : // input location. if the point is not on surface, like in the
375 : : // hole of the surface, try to project to one of the curves.
376 : : //
377 : : // Special Notes :
378 : : //-------------------------------------------------------------------------
379 : 6223 : void OCCSurface::closest_point_trimmed( CubitVector from_point,
380 : : CubitVector& point_on_surface)
381 : : {
382 [ + - ]: 6223 : BRepAdaptor_Surface asurface(*myTopoDSFace);
383 [ + - ][ + - ]: 6223 : gp_Pnt p(from_point.x(), from_point.y(), from_point.z()), newP(0.0, 0.0, 0.0);
[ + - ][ + - ]
[ + - ]
384 : 6223 : double minDist=0.0;
385 : : int i;
386 [ + - ][ + - ]: 12446 : Extrema_ExtPS ext(p, asurface, Precision::Approximation(), Precision::Approximation());
[ + - ][ + - ]
[ + + ]
387 [ + - ][ + + ]: 6223 : if (ext.IsDone() && (ext.NbExt() > 0)) {
[ + - ][ + - ]
[ + + ]
388 [ + - ][ + + ]: 12786 : for ( i = 1 ; i <= ext.NbExt() ; i++ ) {
389 [ + + ][ + - ]: 6583 : if ( (i==1) || (p.Distance(ext.Point(i).Value()) < minDist) ) {
[ + - ][ + - ]
[ - + ][ + + ]
390 [ + - ][ + - ]: 6203 : minDist = p.Distance(ext.Point(i).Value());
[ + - ]
391 [ + - ][ + - ]: 6203 : newP = ext.Point(i).Value();
392 : : }
393 : : }
394 [ + - ][ + - ]: 6203 : point_on_surface = CubitVector(newP.X(), newP.Y(), newP.Z());
[ + - ][ + - ]
[ + - ]
395 : : }
396 : : else
397 : 6243 : return;
398 : :
399 [ + - ]: 6203 : CubitPointContainment pos = point_containment(point_on_surface);
400 [ + + ]: 6203 : if(pos == CUBIT_PNT_OUTSIDE)
401 : : {
402 [ + - ]: 22 : DLIList<OCCCurve*> curves;
403 [ + - ]: 22 : int num_curve = get_curves(curves);
404 : 22 : double d_min = 0., d;
405 : 22 : OCCCurve* the_curve = NULL;
406 [ + - ][ + - ]: 22 : gp_Pnt pt = gp_Pnt(point_on_surface.x(), point_on_surface.y(),
407 [ + - ][ + - ]: 44 : point_on_surface.z());
408 [ + - ][ + - ]: 44 : TopoDS_Vertex theVertex = BRepBuilderAPI_MakeVertex(pt);
[ + - ][ + - ]
409 [ + - ]: 22 : CubitVector closest_location;
410 [ # # ]: 0 : do
411 : : {
412 [ + + ]: 198 : for (i = 0; i < num_curve; i++)
413 : : {
414 [ + - ]: 176 : OCCCurve* curve = curves.get_and_step();
415 [ + - ]: 176 : TopoDS_Edge* theEdge = curve->get_TopoDS_Edge( );
416 [ + - ]: 176 : BRepExtrema_DistShapeShape distShapeShape(*theEdge, theVertex);
417 [ + - ]: 176 : d = distShapeShape.Value();
418 [ + + ][ + + ]: 176 : if ( i == 0 || d_min > d)
419 : : {
420 : 44 : d_min = d;
421 : 44 : the_curve = curve;
422 : : }
423 [ + - ]: 176 : }
424 [ + - ]: 22 : the_curve->closest_point(point_on_surface, closest_location);
425 [ + - ]: 22 : pos = the_curve->point_containment(closest_location);
426 [ - + ]: 22 : if(pos == CUBIT_PNT_OUTSIDE)
427 [ # # ]: 0 : curves.remove(the_curve);
428 : : else
429 : 22 : break;
430 [ # # ]: 0 : }while(curves.size() > 0);
431 [ + - ][ + - ]: 6245 : point_on_surface = closest_location;
[ + - ][ + + ]
432 : 6223 : }
433 : : }
434 : :
435 : : //-------------------------------------------------------------------------
436 : : // Purpose : This functions computes the point on the surface that is
437 : : // closest to the input location and then calculates the
438 : : // magnitudes of the principal curvatures at this (possibly,
439 : : // new) point on the surface. Specifying the RefVolume for
440 : : // reference is optional.
441 : : //
442 : : // Special Notes :
443 : : //
444 : : //-------------------------------------------------------------------------
445 : :
446 : 0 : CubitStatus OCCSurface::principal_curvatures(
447 : : CubitVector const& location,
448 : : double& curvature_1,
449 : : double& curvature_2,
450 : : CubitVector* closest_location )
451 : : {
452 [ # # ]: 0 : BRepAdaptor_Surface asurface(*myTopoDSFace);
453 [ # # ][ # # ]: 0 : gp_Pnt p(location.x(), location.y(), location.z()), newP(0.0, 0.0, 0.0);
[ # # ][ # # ]
[ # # ]
454 : 0 : double minDist=0.0, u, v;
455 : : int i;
456 [ # # ][ # # ]: 0 : BRepLProp_SLProps SLP(asurface, 2, Precision::PConfusion());
[ # # ]
457 [ # # ][ # # ]: 0 : Extrema_ExtPS ext(p, asurface, Precision::Approximation(), Precision::Approximation());
[ # # ][ # # ]
458 [ # # ][ # # ]: 0 : if (ext.IsDone() && (ext.NbExt() > 0)) {
[ # # ][ # # ]
[ # # ]
459 [ # # ][ # # ]: 0 : for ( i = 1 ; i <= ext.NbExt() ; i++ ) {
460 [ # # ][ # # ]: 0 : if ( (i==1) || (p.Distance(ext.Point(i).Value()) < minDist) ) {
[ # # ][ # # ]
[ # # ][ # # ]
461 [ # # ][ # # ]: 0 : minDist = p.Distance(ext.Point(i).Value());
[ # # ]
462 [ # # ][ # # ]: 0 : newP = ext.Point(i).Value();
463 [ # # ][ # # ]: 0 : ext.Point(i).Parameter(u, v);
464 [ # # ]: 0 : SLP.SetParameters(u, v);
465 : : }
466 : : }
467 : : }
468 [ # # ]: 0 : if (closest_location != NULL)
469 [ # # ][ # # ]: 0 : *closest_location = CubitVector(newP.X(), newP.Y(), newP.Z());
[ # # ][ # # ]
[ # # ]
470 : :
471 [ # # ][ # # ]: 0 : if (SLP.IsCurvatureDefined())
472 : : {
473 [ # # ]: 0 : curvature_1 = SLP.MinCurvature();
474 [ # # ]: 0 : curvature_2 = SLP.MaxCurvature();
475 : : }
476 [ # # ]: 0 : return CUBIT_SUCCESS;
477 : : }
478 : :
479 : :
480 : :
481 : :
482 : :
483 : 0 : CubitStatus OCCSurface::evaluate( double u, double v,
484 : : CubitVector *position,
485 : : CubitVector *normal,
486 : : CubitVector *curvature1,
487 : : CubitVector *curvature2 )
488 : : {
489 [ # # ]: 0 : BRepAdaptor_Surface asurface(*myTopoDSFace);
490 : :
491 [ # # ]: 0 : gp_Pnt p = asurface.Value(u, v);
492 [ # # ]: 0 : if(position!=NULL)
493 [ # # ][ # # ]: 0 : position->set(p.X(), p.Y(), p.Z());
[ # # ][ # # ]
494 : :
495 : :
496 [ # # ][ # # ]: 0 : BRepLProp_SLProps SLP(asurface, 2, Precision::PConfusion());
[ # # ]
497 [ # # ]: 0 : SLP.SetParameters(u, v);
498 : :
499 : :
500 [ # # ]: 0 : if(normal!=NULL)
501 : : {
502 [ # # ]: 0 : gp_Dir occ_normal;
503 : : //normal of a RefFace point to outside of the material
504 [ # # ][ # # ]: 0 : if (SLP.IsNormalDefined())
505 : : {
506 [ # # ]: 0 : occ_normal = SLP.Normal();
507 [ # # ][ # # ]: 0 : normal->set(occ_normal.X(), occ_normal.Y(), occ_normal.Z());
[ # # ][ # # ]
508 : : }
509 : : }
510 : :
511 : :
512 [ # # ][ # # ]: 0 : gp_Dir MaxD, MinD;
513 [ # # ][ # # ]: 0 : if (curvature1 && curvature2 && SLP.IsCurvatureDefined())
[ # # ][ # # ]
[ # # ]
514 : : {
515 [ # # ]: 0 : SLP.CurvatureDirections(MaxD, MinD);
516 [ # # ]: 0 : if (curvature1 != NULL)
517 [ # # ][ # # ]: 0 : *curvature1 = CubitVector(MinD.X(), MinD.Y(), MinD.Z());
[ # # ][ # # ]
[ # # ]
518 [ # # ]: 0 : if (curvature2 != NULL)
519 [ # # ][ # # ]: 0 : *curvature2 = CubitVector(MaxD.X(), MaxD.Y(), MaxD.Z());
[ # # ][ # # ]
[ # # ]
520 : : }
521 : :
522 : :
523 [ # # ]: 0 : return CUBIT_SUCCESS;
524 : : }
525 : :
526 : : //-------------------------------------------------------------------------
527 : : // Purpose : Given values of the two parameters, get the position.
528 : : //
529 : : // Special Notes :
530 : : //
531 : : //-------------------------------------------------------------------------
532 : 0 : CubitVector OCCSurface::position_from_u_v (double u, double v)
533 : : {
534 [ # # ]: 0 : BRepAdaptor_Surface asurface(*myTopoDSFace, Standard_False);
535 [ # # ]: 0 : gp_Pnt p = asurface.Value(u, v);
536 [ # # ][ # # ]: 0 : return CubitVector (p.X(), p.Y(), p.Z());
[ # # ][ # # ]
[ # # ]
537 : : }
538 : :
539 : : //-------------------------------------------------------------------------
540 : : // Purpose : This function returns the {u, v} coordinates of the point
541 : : // on the Surface closest to the input point (specified in
542 : : // global space). The closest_location is also returned.
543 : : //
544 : : // Special Notes :
545 : : //
546 : : //-------------------------------------------------------------------------
547 : 1232 : CubitStatus OCCSurface::u_v_from_position( CubitVector const& location,
548 : : double& u,
549 : : double& v,
550 : : CubitVector* closest_location )
551 : : {
552 [ + - ]: 1232 : BRepAdaptor_Surface asurface(*myTopoDSFace);
553 [ + - ][ + - ]: 1232 : gp_Pnt p(location.x(), location.y(), location.z()), newP(0.0, 0.0, 0.0);
[ + - ][ + - ]
[ + - ]
554 : 1232 : double minDist=0.0;
555 : : int i;
556 [ + - ][ + - ]: 2464 : Extrema_ExtPS ext(p, asurface, Precision::Confusion(), Precision::Confusion());
[ + - ][ + - ]
557 [ + - ][ + - ]: 1232 : if (ext.IsDone() && (ext.NbExt() > 0)) {
[ + - ][ + - ]
[ + - ]
558 [ + - ][ + + ]: 2464 : for ( i = 1 ; i <= ext.NbExt() ; i++ ) {
559 [ - + ][ # # ]: 1232 : if ( (i==1) || (p.Distance(ext.Point(i).Value()) < minDist) ) {
[ # # ][ # # ]
[ # # ][ + - ]
560 [ + - ][ + - ]: 1232 : minDist = p.Distance(ext.Point(i).Value());
[ + - ]
561 [ + - ][ + - ]: 1232 : newP = ext.Point(i).Value();
562 [ + - ][ + - ]: 1232 : ext.Point(i).Parameter(u, v);
563 : : }
564 : : }
565 : : }
566 [ + + ][ + - ]: 1232 : if (closest_location != NULL) *closest_location = CubitVector(newP.X(), newP.Y(), newP.Z());
[ + - ][ + - ]
[ + - ][ + - ]
567 [ + - ]: 1232 : return CUBIT_SUCCESS;
568 : : }
569 : :
570 : : //-------------------------------------------------------------------------
571 : : // Purpose : Determines whether the Facet surface is periodic. Not
572 : : // available yet.
573 : : //
574 : : //
575 : : //-------------------------------------------------------------------------
576 : 703 : CubitBoolean OCCSurface::is_periodic()
577 : : {
578 [ + - ]: 703 : BRepAdaptor_Surface asurface(*myTopoDSFace);
579 [ + - ][ + + ]: 703 : return (asurface.IsUPeriodic() || asurface.IsVPeriodic())?CUBIT_TRUE:CUBIT_FALSE;
[ + - ][ - + ]
[ + - ]
580 : : }
581 : :
582 : : //-------------------------------------------------------------------------
583 : : // Purpose : Determines if the face is periodic in the given parameter
584 : : // direction. Not available yet.
585 : : //
586 : : //-------------------------------------------------------------------------
587 : 240 : CubitBoolean OCCSurface::is_periodic_in_U( double& period )
588 : : {
589 : :
590 [ + - ]: 240 : BRepAdaptor_Surface asurface(*myTopoDSFace);
591 [ + - ][ - + ]: 240 : if (!asurface.IsUPeriodic())
592 : 0 : return CUBIT_FALSE;
593 : :
594 [ + - ]: 240 : period = asurface.UPeriod();
595 [ + - ]: 240 : return CUBIT_TRUE;
596 : : }
597 : :
598 : : //-------------------------------------------------------------------------
599 : : // Purpose : Determines if the face is periodic in the given parameter
600 : : // direction. Not available yet.
601 : : //
602 : : //
603 : : //-------------------------------------------------------------------------
604 : 240 : CubitBoolean OCCSurface::is_periodic_in_V( double& period )
605 : : {
606 [ + - ]: 240 : BRepAdaptor_Surface asurface(*myTopoDSFace);
607 [ + - ][ + - ]: 240 : if (!asurface.IsVPeriodic())
608 : 240 : return CUBIT_FALSE;
609 : :
610 [ # # ]: 0 : period = asurface.VPeriod();
611 [ + - ]: 240 : return CUBIT_TRUE;
612 : : }
613 : :
614 : : //-------------------------------------------------------------------------
615 : : // Purpose : Determines if the face is singular in the given parameter
616 : : // direction. Based on comments in Surface: "The
617 : : // assumption is made that the u_param is in the
618 : : // bounds of the surface.
619 : : //
620 : : //-------------------------------------------------------------------------
621 : 0 : CubitBoolean OCCSurface::is_singular_in_U( double u_param)
622 : : {
623 : : //from MasterIndex.htm:
624 : : // singular_u
625 : : // The only singularity recognized is where every value of the
626 : : // nonconstant parameter generates the same object-space point,
627 : : // and these can only occur at the ends of the parameter range
628 : : // as returned by the functions above. A plane is nonsingular
629 : : // in both directions.
630 : : double u_lower, u_upper;
631 [ # # ]: 0 : get_param_range_U( u_lower, u_upper );
632 : :
633 [ # # ][ # # ]: 0 : if ( u_param < u_lower - CUBIT_RESABS ||
634 : 0 : u_param > u_upper + CUBIT_RESABS )
635 : : {
636 [ # # ][ # # ]: 0 : PRINT_ERROR("u parameter is outside parameter bounds.\n");
[ # # ][ # # ]
637 : 0 : return CUBIT_FALSE;
638 : : }
639 : :
640 : : //Currently, haven't found any singularity check in OCC.
641 : 0 : return CUBIT_FALSE;
642 : : }
643 : :
644 : : //-------------------------------------------------------------------------
645 : : // Purpose : Determines if the face is singular in the given parameter
646 : : // direction. Not available yet.
647 : : //-------------------------------------------------------------------------
648 : 0 : CubitBoolean OCCSurface::is_singular_in_V( double v_param)
649 : : {
650 : : double v_lower, v_upper;
651 [ # # ]: 0 : get_param_range_V( v_lower, v_upper );
652 : :
653 [ # # ][ # # ]: 0 : if ( v_param < v_lower - CUBIT_RESABS ||
654 : 0 : v_param > v_upper + CUBIT_RESABS )
655 : : {
656 [ # # ][ # # ]: 0 : PRINT_ERROR("v parameter is outside parameter bounds.\n");
[ # # ][ # # ]
657 : 0 : return CUBIT_FALSE;
658 : : }
659 : :
660 : : //Currently, haven't found any singularity check in OCC.
661 : 0 : return CUBIT_FALSE;
662 : : }
663 : :
664 : : //-------------------------------------------------------------------------
665 : : // Purpose : Determines if the face is closed in the U parameter.
666 : : //
667 : : //-------------------------------------------------------------------------
668 : 0 : CubitBoolean OCCSurface::is_closed_in_U()
669 : : {
670 [ # # ]: 0 : BRepAdaptor_Surface asurface(*myTopoDSFace);
671 [ # # ][ # # ]: 0 : return (asurface.IsUClosed())?CUBIT_TRUE:CUBIT_FALSE;
[ # # ]
672 : : }
673 : :
674 : : //-------------------------------------------------------------------------
675 : : // Purpose : Determines if the face is closed in the V parameter.
676 : : //-------------------------------------------------------------------------
677 : 0 : CubitBoolean OCCSurface::is_closed_in_V()
678 : : {
679 [ # # ]: 0 : BRepAdaptor_Surface asurface(*myTopoDSFace);
680 [ # # ][ # # ]: 0 : return (asurface.IsVClosed())?CUBIT_TRUE:CUBIT_FALSE;
[ # # ]
681 : : }
682 : :
683 : : //-------------------------------------------------------------------------
684 : : // Purpose : Calculates the derivitives at a given parameter location.
685 : : //
686 : : //-------------------------------------------------------------------------
687 : 0 : CubitStatus OCCSurface::uv_derivitives( double u,
688 : : double v,
689 : : CubitVector &du,
690 : : CubitVector &dv )
691 : : {
692 [ # # ]: 0 : BRepAdaptor_Surface asurface(*myTopoDSFace);
693 [ # # ]: 0 : gp_Pnt p;
694 [ # # ][ # # ]: 0 : gp_Vec d1u, d1v;
695 [ # # ]: 0 : asurface.D1(u, v, p, d1u, d1v);
696 [ # # ][ # # ]: 0 : du = CubitVector(d1u.X(), d1u.Y(), d1u.Z());
[ # # ][ # # ]
[ # # ]
697 [ # # ][ # # ]: 0 : dv = CubitVector(d1v.X(), d1v.Y(), d1v.Z());
[ # # ][ # # ]
[ # # ]
698 [ # # ]: 0 : return CUBIT_SUCCESS;
699 : : }
700 : :
701 : : //-------------------------------------------------------------------------
702 : : // Purpose : Calculates the derivitives at a given parameter location.
703 : : //
704 : : //-------------------------------------------------------------------------
705 : : /*
706 : : CubitStatus OCCSurface::uv_2nd_derivitives( double u,
707 : : double v,
708 : : CubitVector &d2u,
709 : : CubitVector &d2v,
710 : : CubitVector &d2uv )
711 : : {
712 : : BRepAdaptor_Surface asurface(*myTopoDSFace);
713 : : gp_Pnt p;
714 : : gp_Vec d1u, d1v, du, dv, duv ;
715 : : asurface.D2(u, v, p, d1u, d1v, du, dv, duv);
716 : : d2u = CubitVector(du.X(), du.Y(), du.Z());
717 : : d2v = CubitVector(dv.X(), dv.Y(), dv.Z());
718 : : d2uv =CubitVector(duv.X(), duv.Y(), duv.Z());
719 : : return CUBIT_SUCCESS;
720 : : }
721 : : */
722 : : //-------------------------------------------------------------------------
723 : : // Purpose : Determines whether the surface is parametrically defined.
724 : : // Hopefully later this will be available.
725 : : //
726 : : //-------------------------------------------------------------------------
727 : 2210 : CubitBoolean OCCSurface::is_parametric()
728 : : {
729 : 2210 : return CUBIT_TRUE;
730 : : }
731 : :
732 : : //-------------------------------------------------------------------------
733 : : // Purpose : Returns the lower and upper parametric bounds of the
734 : : // surface in U, if it is parametric. Otherwise, it returns
735 : : // CUBIT_FALSE and zeroes for the upper and lower parametric
736 : : // bounds.
737 : : //
738 : : // Creator :
739 : : //
740 : : // Creation Date :
741 : : //-------------------------------------------------------------------------
742 : 208 : CubitBoolean OCCSurface::get_param_range_U( double& lower_bound,
743 : : double& upper_bound )
744 : : {
745 [ + - ]: 208 : BRepAdaptor_Surface asurface(*myTopoDSFace);
746 [ + - ]: 208 : lower_bound = asurface.FirstUParameter();
747 [ + - ]: 208 : upper_bound = asurface.LastUParameter();
748 [ + - ]: 208 : return CUBIT_TRUE;
749 : : }
750 : :
751 : : //-------------------------------------------------------------------------
752 : : // Purpose : Returns the lower and upper parametric bounds of the
753 : : // surface in V, if it is parametric. Otherwise, it returns
754 : : // CUBIT_FALSE and zeroes for the upper and lower parametric
755 : : // bounds.
756 : : //
757 : : //-------------------------------------------------------------------------
758 : 208 : CubitBoolean OCCSurface::get_param_range_V( double& lower_bound,
759 : : double& upper_bound )
760 : : {
761 [ + - ]: 208 : BRepAdaptor_Surface asurface(*myTopoDSFace);
762 [ + - ]: 208 : lower_bound = asurface.FirstVParameter();
763 : :
764 [ + - ]: 208 : upper_bound = asurface.LastVParameter();
765 [ + - ]: 208 : return CUBIT_TRUE;
766 : : }
767 : :
768 : : //-------------------------------------------------------------------------
769 : : // Purpose : Returns the area of the Surface
770 : : //
771 : : //-------------------------------------------------------------------------
772 : 10187 : double OCCSurface::measure()
773 : : {
774 [ + - ]: 10187 : GProp_GProps myProps;
775 [ + - ]: 10187 : BRepGProp::SurfaceProperties(*myTopoDSFace, myProps);
776 [ + - ]: 10187 : return myProps.Mass();
777 : : }
778 : :
779 : : //-------------------------------------------------------------------------
780 : : // Purpose : Returns the center of the Surface mass
781 : : //
782 : : //-------------------------------------------------------------------------
783 : 0 : CubitVector OCCSurface::center_point()
784 : : {
785 [ # # ]: 0 : GProp_GProps myProps;
786 [ # # ]: 0 : BRepGProp::SurfaceProperties(*myTopoDSFace, myProps);
787 [ # # ]: 0 : gp_Pnt pt = myProps.CentreOfMass();
788 [ # # ][ # # ]: 0 : CubitVector v(pt.X(),pt.Y(), pt.Z());
[ # # ][ # # ]
789 : 0 : return v;
790 : : }
791 : :
792 : : //-------------------------------------------------------------------------
793 : : // Purpose : This function tests the passed in position to see if
794 : : // is on the underlying surface.
795 : : //
796 : : //-------------------------------------------------------------------------
797 : 0 : CubitBoolean OCCSurface::is_position_on( CubitVector &test_position )
798 : : {
799 [ # # ]: 0 : CubitVector new_point;
800 [ # # ]: 0 : CubitStatus stat = closest_point(test_position, &new_point, NULL,NULL,NULL);
801 [ # # ]: 0 : if ( !stat )
802 : 0 : return CUBIT_FALSE;
803 [ # # ]: 0 : CubitVector result_vec = test_position - new_point;
804 [ # # ][ # # ]: 0 : if ( result_vec.length_squared() < GEOMETRY_RESABS )
805 : 0 : return CUBIT_TRUE;
806 : 0 : return CUBIT_FALSE;
807 : : }
808 : :
809 : 6203 : CubitPointContainment OCCSurface::point_containment( const CubitVector &point )
810 : : {
811 [ + - ]: 6203 : TopoDS_Face *face = get_TopoDS_Face();
812 [ + - ][ + - ]: 6203 : gp_Pnt p(point.x(), point.y(), point.z());
[ + - ][ + - ]
813 [ + - ][ + - ]: 6203 : double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance();
814 : :
815 : : //It's checking the state of the projected point of THIS Point
816 [ + - ]: 6203 : BRepClass_FaceClassifier face_classifier;
817 [ + - ]: 6203 : face_classifier.Perform(*face, p, tol);
818 [ + - ]: 6203 : TopAbs_State state = face_classifier.State();
819 : :
820 [ + + ]: 6203 : if (state == TopAbs_IN)
821 : 4787 : return CUBIT_PNT_INSIDE;
822 [ + + ]: 1416 : else if (state == TopAbs_OUT)
823 : 22 : return CUBIT_PNT_OUTSIDE;
824 [ + - ]: 1394 : else if (state == TopAbs_ON)
825 : 1394 : return CUBIT_PNT_BOUNDARY;
826 : :
827 [ + - ]: 6203 : return CUBIT_PNT_UNKNOWN;
828 : : }
829 : :
830 : 0 : CubitPointContainment OCCSurface::point_containment( double u_param,
831 : : double v_param )
832 : : {
833 [ # # ]: 0 : CubitVector point = position_from_u_v(u_param, v_param);
834 [ # # ]: 0 : return point_containment(point);
835 : : }
836 : :
837 : :
838 : 0 : CubitSense OCCSurface::get_geometry_sense()
839 : : {
840 : 0 : return CUBIT_FORWARD;
841 : : }
842 : :
843 : 4235 : void OCCSurface::get_parents_virt( DLIList<TopologyBridge*>& parents )
844 : : {
845 [ + - ]: 4235 : if(myShell) //shell or sheet body
846 : : {
847 [ + - ]: 4235 : parents.append(myShell);
848 : 4235 : return;
849 : : }
850 : :
851 [ # # ]: 0 : OCCQueryEngine* oqe = (OCCQueryEngine*) get_geometry_query_engine();
852 : 0 : OCCBody * body = NULL;
853 : 0 : DLIList <OCCBody* > *bodies = oqe->BodyList;
854 [ # # ]: 0 : TopTools_IndexedDataMapOfShapeListOfShape M;
855 [ # # ][ # # ]: 0 : for(int i = 0; i < bodies->size(); i++)
856 : : {
857 [ # # ]: 0 : body = bodies->get_and_step();
858 [ # # ]: 0 : DLIList<OCCSurface*> surfaces;
859 [ # # ]: 0 : body = bodies->get_and_step();
860 [ # # ]: 0 : body->get_all_surfaces(surfaces);
861 [ # # ][ # # ]: 0 : if(surfaces.move_to(this))
862 : : {
863 : : TopoDS_Shape* shape = oqe->instance()->
864 [ # # ][ # # ]: 0 : get_TopoDS_Shape_of_entity(CAST_TO(body, TopologyBridge));
865 [ # # ]: 0 : TopExp::MapShapesAndAncestors(*shape, TopAbs_FACE, TopAbs_SHELL, M);
866 [ # # ][ # # ]: 0 : if(!M.Contains(*(get_TopoDS_Face())))
[ # # ]
867 : 0 : continue;
868 : : const TopTools_ListOfShape& ListOfShapes =
869 [ # # ][ # # ]: 0 : M.FindFromKey(*(get_TopoDS_Face()));
870 [ # # ][ # # ]: 0 : if (!ListOfShapes.IsEmpty())
871 : : {
872 [ # # ]: 0 : TopTools_ListIteratorOfListOfShape it(ListOfShapes) ;
873 [ # # ][ # # ]: 0 : for (;it.More(); it.Next())
[ # # ][ # # ]
[ # # ]
874 : : {
875 [ # # ][ # # ]: 0 : TopoDS_Shell Shell = TopoDS::Shell(it.Value());
[ # # ]
876 [ # # ]: 0 : int k = oqe->OCCMap->Find(Shell);
877 [ # # ][ # # ]: 0 : parents.append((OCCShell*)(oqe->OccToCGM->find(k))->second);
[ # # ]
878 [ # # ]: 0 : }
879 : : }
880 : : }
881 [ # # ]: 0 : }
882 : : }
883 : :
884 : 119026 : void OCCSurface::get_children_virt( DLIList<TopologyBridge*>& children )
885 : : {
886 [ + - ]: 119026 : TopTools_IndexedMapOfShape M;
887 [ + - ]: 119026 : TopExp::MapShapes(*myTopoDSFace, TopAbs_WIRE, M);
888 : : int ii;
889 [ + - ][ + + ]: 245790 : for (ii=1; ii<=M.Extent(); ii++) {
890 [ + - ][ + - ]: 126764 : TopologyBridge *loop = OCCQueryEngine::instance()->occ_to_cgm(M(ii));
[ + - ]
891 [ + + ]: 126764 : if(loop)
892 [ + - ]: 126753 : children.append_unique(loop);
893 [ + - ]: 119026 : }
894 : 119026 : }
895 : :
896 : : // return the sense with respect to the given shell
897 : 18411 : CubitSense OCCSurface::get_shell_sense( ShellSM* shell_ptr ) const
898 : : {
899 [ - + ]: 18411 : OCCShell* shell = dynamic_cast<OCCShell*>(shell_ptr);
900 [ - + ]: 18411 : if (!shell) // error
901 : 0 : return CUBIT_UNKNOWN;
902 : :
903 [ + - ][ + + ]: 18411 : if (shell->is_sheet()) // relative sense is "both" for sheet
904 : 597 : return CUBIT_UNKNOWN;
905 : :
906 [ + - ]: 17814 : TopoDS_Shell* shellShapePtr = shell->get_TopoDS_Shell();
907 [ - + ]: 17814 : if (!shellShapePtr) // error
908 : 0 : return CUBIT_UNKNOWN;
909 : :
910 : : TopExp_Explorer shellFaceExp(shellShapePtr->Oriented(TopAbs_FORWARD),
911 [ + - ][ + - ]: 17814 : TopAbs_FACE);
[ + - ]
912 : 17814 : bool isForward = false;
913 : 17814 : bool isReversed = false;
914 [ + - ][ + + ]: 403374 : while (shellFaceExp.More())
915 : : {
916 [ + - ][ + - ]: 385560 : const TopoDS_Shape shellFace = shellFaceExp.Current();
917 [ + - ][ + + ]: 385560 : if (shellFace.IsSame(*myTopoDSFace))
918 : : {
919 [ + - ][ + + ]: 17814 : if (shellFace.Orientation() == TopAbs_FORWARD)
920 : : {
921 : 8710 : isForward = true;
922 : : }
923 [ + - ][ + - ]: 9104 : else if (shellFace.Orientation() == TopAbs_REVERSED)
924 : : {
925 : 9104 : isReversed = true;
926 : : }
927 : : else
928 : : {
929 : 0 : isForward = true;
930 : 17814 : isReversed = true;
931 : : }
932 : : }
933 [ + - ]: 385560 : shellFaceExp.Next();
934 [ + - ]: 385560 : }
935 : :
936 [ + + ][ - + ]: 17814 : if (isForward && isReversed)
937 : 0 : return CUBIT_UNKNOWN;
938 [ + + ]: 17814 : if (isReversed)
939 : 9104 : return CUBIT_REVERSED;
940 [ + - ]: 8710 : if (isForward)
941 : 8710 : return CUBIT_FORWARD;
942 [ + - ]: 18411 : return CUBIT_UNKNOWN;
943 : : }
944 : :
945 : :
946 : 3744 : int OCCSurface::get_loops( DLIList<OCCLoop*>& result_list )
947 : : {
948 [ + - ]: 3744 : TopTools_IndexedMapOfShape M;
949 [ + - ]: 3744 : TopExp::MapShapes(*myTopoDSFace, TopAbs_WIRE, M);
950 : : int ii;
951 [ + - ][ + + ]: 7690 : for (ii=1; ii<=M.Extent(); ii++) {
952 [ + - ][ + - ]: 3946 : TopologyBridge *loop = OCCQueryEngine::instance()->occ_to_cgm(M(ii));
[ + - ]
953 [ + - ]: 3946 : if(loop)
954 [ - + ][ + - ]: 3946 : result_list.append_unique(dynamic_cast<OCCLoop*>(loop));
955 : : }
956 [ + - ][ + - ]: 3744 : return result_list.size();
957 : : }
958 : :
959 : 154 : int OCCSurface::get_coedges( DLIList<OCCCoEdge*>& result_list )
960 : : {
961 [ + - ]: 154 : DLIList<OCCLoop*> loop_list;
962 [ + - ]: 154 : get_loops( loop_list );
963 [ + - ]: 154 : loop_list.reset();
964 [ + - ][ + + ]: 330 : for ( int i = 0; i < loop_list.size(); i++ )
965 : : {
966 [ + - ][ + - ]: 176 : result_list += loop_list.next(i)->coedges( );
[ + - ][ + - ]
967 : : }
968 [ + - ][ + - ]: 154 : return result_list.size();
969 : : }
970 : :
971 : 154 : int OCCSurface::get_curves( DLIList<OCCCurve*>& result_list )
972 : : {
973 [ + - ]: 154 : DLIList<OCCCoEdge*> coedge_list;
974 [ + - ]: 154 : get_coedges( coedge_list );
975 [ + - ]: 154 : coedge_list.reset();
976 [ + - ][ + + ]: 858 : for ( int i = coedge_list.size(); i--; )
977 : : {
978 [ + - ]: 704 : OCCCoEdge* coedge = coedge_list.get_and_step();
979 [ + - ][ - + ]: 704 : OCCCurve* curve = dynamic_cast<OCCCurve*>(coedge->curve());
980 [ + - ]: 704 : if (curve)
981 [ + - ]: 704 : result_list.append_unique(curve);
982 : : }
983 [ + - ][ + - ]: 154 : return result_list.size();
984 : : }
985 : :
986 : 132 : int OCCSurface::get_points(DLIList<OCCPoint*>& points)
987 : : {
988 [ + - ]: 132 : DLIList<OCCCurve*> curves;
989 [ + - ]: 132 : int num_crv = get_curves(curves);
990 [ + + ]: 660 : for(int i = 0; i < num_crv; i++)
991 : : {
992 [ + - ]: 528 : OCCCurve* curve = curves.get_and_step();
993 [ + - ]: 528 : curve->get_points(points);
994 : : }
995 [ + - ][ + - ]: 132 : points += get_hardpoints();
[ + - ]
996 [ + - ][ + - ]: 132 : return points.size();
997 : : }
998 : :
999 : : //----------------------------------------------------------------
1000 : : // Function: to update the core Surface
1001 : : // for any movement or Boolean operation of the body.
1002 : : // Author: Jane Hu
1003 : : //----------------------------------------------------------------
1004 : 3590 : CubitStatus OCCSurface::update_OCC_entity( BRepBuilderAPI_ModifyShape *aBRepTrsf,
1005 : : BRepAlgoAPI_BooleanOperation *op)
1006 : : {
1007 [ - + ][ # # ]: 3590 : assert(aBRepTrsf != NULL || op != NULL);
1008 [ + - ]: 3590 : TopoDS_Shape shape;
1009 : :
1010 [ + - ]: 3590 : if(aBRepTrsf)
1011 [ + - ][ + - ]: 3590 : shape = aBRepTrsf->ModifiedShape(*get_TopoDS_Face());
[ + - ]
1012 : :
1013 : : else
1014 : : {
1015 [ # # ]: 0 : TopTools_ListOfShape shapes;
1016 [ # # ][ # # ]: 0 : shapes.Assign(op->Modified(*get_TopoDS_Face()));
[ # # ]
1017 [ # # ][ # # ]: 0 : if(shapes.Extent() == 0)
1018 [ # # ][ # # ]: 0 : shapes.Assign(op->Generated(*get_TopoDS_Face()));
[ # # ]
1019 [ # # ][ # # ]: 0 : if (shapes.Extent() == 1)
1020 [ # # ][ # # ]: 0 : shape = shapes.First();
1021 [ # # ][ # # ]: 0 : else if(shapes.Extent() > 1)
1022 : : {
1023 [ # # ][ # # ]: 0 : shape = shapes.First();
1024 : : }
1025 [ # # ][ # # ]: 0 : else if(op->IsDeleted(*get_TopoDS_Face()))
[ # # ]
1026 : : ;
1027 : : else
1028 [ # # ][ # # ]: 0 : return CUBIT_SUCCESS;
1029 : : }
1030 : :
1031 [ + - ][ + - ]: 7180 : TopoDS_Face surface;
1032 [ + - ][ + - ]: 3590 : if(!shape.IsNull())
1033 [ + - ][ + - ]: 3590 : surface = TopoDS::Face(shape);
1034 : :
1035 [ + - ]: 3590 : if (aBRepTrsf)
1036 : : {
1037 : : //set the loops
1038 [ + - ]: 3590 : DLIList<OCCLoop *> loops;
1039 [ + - ]: 3590 : this->get_loops(loops);
1040 [ + - ][ + + ]: 7360 : for (int i = 1; i <= loops.size(); i++)
1041 : : {
1042 [ + - ]: 3770 : OCCLoop *loop = loops.get_and_step();
1043 [ + - ]: 3770 : loop->update_OCC_entity(aBRepTrsf, op);
1044 : : }
1045 [ + - ][ + - ]: 3590 : OCCQueryEngine::instance()->update_OCC_map(*myTopoDSFace, surface);
[ + - ]
1046 : : }
1047 : :
1048 [ # # ]: 0 : else if(op)
1049 [ # # ]: 0 : update_OCC_entity(*myTopoDSFace, surface, op);
1050 : :
1051 [ + - ]: 3590 : return CUBIT_SUCCESS;
1052 : : }
1053 : :
1054 : : //----------------------------------------------------------------
1055 : : // Function: TopoDS_Shape level function to update the core Surface
1056 : : // for any movement or Boolean operation of the body.
1057 : : // Author: Jane Hu
1058 : : //----------------------------------------------------------------
1059 : 1525 : CubitStatus OCCSurface::update_OCC_entity(TopoDS_Face& old_surface,
1060 : : TopoDS_Shape& new_surface,
1061 : : BRepBuilderAPI_MakeShape *op,
1062 : : TopoDS_Vertex* removed_vertex,
1063 : : LocOpe_SplitShape* sp)
1064 : : {
1065 [ + - ][ + - ]: 3050 : TopTools_IndexedMapOfShape M, M2;
[ + - ]
1066 [ + - ][ + - ]: 3050 : TopoDS_Shape shape_face, shape, shape2, shape_edge, shape_vertex;
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
1067 [ + - ][ + - ]: 1525 : double dTOL = OCCQueryEngine::instance()->get_sme_resabs_tolerance();
1068 : :
1069 : : //First check if new_surface is type shell.
1070 [ + - ]: 1525 : TopExp::MapShapes(new_surface, TopAbs_FACE,M);
1071 [ + - ][ - + ]: 1525 : if(M.Extent() > 1 )
1072 : : {
1073 [ # # ][ # # ]: 0 : OCCQueryEngine::instance()->update_OCC_map(old_surface, new_surface);
1074 : 0 : return CUBIT_SUCCESS;
1075 : : }
1076 : :
1077 : :
1078 [ + - ][ + + ]: 1525 : if(M.Extent() == 1 )
1079 [ + - ][ + - ]: 1250 : shape_face = M(1);
1080 : :
1081 : : // GfxDebug::clear();
1082 : : //// OCCDrawTool::instance()->draw_FACE(&old_face,CUBIT_BLUE,false,false);
1083 : : // OCCDrawTool::instance()->draw_TopoDS_Shape(&shape_face,CUBIT_GREEN,false,true);
1084 : : // GfxDebug::mouse_xforms();
1085 : :
1086 : :
1087 [ + - ]: 1525 : M.Clear();
1088 : : //set the Wires
1089 [ + - ]: 1525 : TopExp::MapShapes(old_surface, TopAbs_WIRE, M);
1090 : :
1091 [ + - ][ + - ]: 3050 : TopTools_ListOfShape shapes;
1092 : 1525 : BRepFilletAPI_MakeFillet2d* test_op = NULL;
1093 : :
1094 [ + - ][ + + ]: 3182 : for (int ii=1; ii<=M.Extent(); ii++)
1095 : : {
1096 [ + - ][ + - ]: 1657 : TopoDS_Wire wire = TopoDS::Wire(M(ii));
[ + - ]
1097 [ + - ][ + - ]: 3314 : TopTools_ListOfShape shapes;
[ + - ]
1098 [ + - ]: 1657 : if(op)
1099 : : {
1100 : : //test_op = dynamic_cast<BRepFilletAPI_MakeFillet2d*>(op);
1101 : 1657 : test_op = NULL; //casting fails on both OSX and Linux
1102 [ + - ]: 1657 : if(!test_op)
1103 [ + - ][ + - ]: 1657 : shapes.Assign(op->Modified(wire));
1104 [ + - ][ + + ]: 1657 : if(shapes.Extent() == 0)
1105 [ + - ][ + - ]: 1437 : shapes.Assign(op->Generated(wire));
1106 [ + - ][ + + ]: 1657 : if(!new_surface.IsNull())
1107 [ + - ]: 1382 : TopExp::MapShapes(new_surface,TopAbs_WIRE, M2);
1108 : : }
1109 [ # # ]: 0 : else if(sp)
1110 [ # # ][ # # ]: 0 : shapes.Assign(sp->DescendantShapes(wire));
1111 : :
1112 [ + - ][ + + ]: 1657 : if (shapes.Extent() == 1)
1113 : : {
1114 [ + - ][ + - ]: 187 : shape = shapes.First();
1115 [ + - ][ + - ]: 187 : if(M2.Extent() == 1)
1116 : : {
1117 [ + - ][ + - ]: 187 : shape2 = TopoDS::Wire(M2(1));
[ + - ]
1118 [ + - ][ - + ]: 187 : if(!shape.IsSame(shape2))
1119 [ # # ]: 0 : shape = shape2;
1120 : : }
1121 [ # # ][ # # ]: 0 : else if(M2.Extent() > 1)
1122 [ # # ]: 0 : shape.Nullify();
1123 : : }
1124 [ + - ][ + + ]: 1470 : else if(shapes.Extent() > 1)
1125 [ + - ]: 33 : shape.Nullify();
1126 [ + - ][ - + ]: 1437 : else if(op->IsDeleted(wire) || shapes.Extent() == 0)
[ # # ][ # # ]
[ + - ]
1127 : : {
1128 [ + - ]: 1437 : TopTools_IndexedMapOfShape M_new;
1129 [ + - ]: 1437 : TopExp::MapShapes(new_surface, TopAbs_WIRE, M_new);
1130 [ + - ][ + + ]: 1437 : if (M_new.Extent()== 1)
1131 [ + - ][ + - ]: 792 : shape = M_new(1);
1132 [ + - ][ + + ]: 645 : else if(!shape_face.IsNull())
1133 : : {
1134 [ + - ]: 370 : M_new.Clear();
1135 [ + - ]: 370 : TopExp::MapShapes(shape_face, TopAbs_WIRE, M_new);
1136 [ + - ][ - + ]: 370 : if (M_new.Extent()== 1)
1137 [ # # ][ # # ]: 0 : shape = M_new(1);
1138 : : }
1139 : : else
1140 [ + - ][ + - ]: 1437 : shape.Nullify();
1141 : : }
1142 : : else
1143 : : {
1144 [ # # ]: 0 : shape = wire;
1145 : 0 : continue;
1146 : : }
1147 : :
1148 : : //set curves
1149 [ + - ][ + - ]: 3314 : BRepTools_WireExplorer Ex;
[ + - ][ + - ]
1150 : :
1151 [ + - ][ + - ]: 7801 : for(Ex.Init(wire); Ex.More();Ex.Next())
[ + - ][ + + ]
1152 : : {
1153 [ + - ][ + - ]: 6144 : TopoDS_Edge edge = Ex.Current();
1154 : : //check to see if the edge made itself into a curve.
1155 [ + - ]: 6144 : GProp_GProps myProps;
1156 [ + - ]: 6144 : BRepGProp::LinearProperties(edge, myProps);
1157 [ + - ]: 6144 : double length = myProps.Mass();
1158 [ + + ]: 6144 : if(length < dTOL)
1159 : 22 : continue;
1160 [ + - ][ + - ]: 6122 : if(op && !test_op)
1161 : : {
1162 [ + - ][ + - ]: 6122 : shapes.Assign(op->Modified(edge));
1163 [ + - ][ + + ]: 8526 : if(shapes.Extent() == 0)
1164 [ + - ][ + - ]: 2404 : shapes.Assign(op->Generated(edge));
1165 : : }
1166 : :
1167 [ # # ]: 0 : else if(sp)
1168 [ # # ][ # # ]: 0 : shapes.Assign(sp->DescendantShapes(edge));
1169 : :
1170 [ + - ][ + + ]: 6122 : if (shapes.Extent() == 1)
1171 : : {
1172 : : //in fillet creating mothod, one edge could generated a face, so check
1173 : : //it here.
1174 [ + - ][ + - ]: 2948 : TopAbs_ShapeEnum type = shapes.First().TShape()->ShapeType();
[ + - ][ + - ]
1175 [ - + ]: 2948 : if(type != TopAbs_EDGE)
1176 [ # # ]: 0 : shape_edge.Nullify();
1177 : : else
1178 [ + - ][ + - ]: 2948 : shape_edge = shapes.First();
1179 : : }
1180 [ + - ][ + + ]: 3174 : else if (shapes.Extent() > 1)
1181 : : {
1182 : : //update all attributes first.
1183 [ + - ]: 770 : TopTools_ListIteratorOfListOfShape it;
1184 [ + - ]: 770 : it.Initialize(shapes);
1185 [ + - ][ + - ]: 2442 : for(; it.More(); it.Next())
[ + + ]
1186 : : {
1187 [ + - ][ + - ]: 1672 : shape_edge = it.Value();
1188 [ + - ][ + - ]: 1672 : OCCQueryEngine::instance()->copy_attributes(edge, shape_edge);
1189 : : }
1190 [ + - ]: 770 : shape_edge.Nullify();
1191 : : }
1192 [ + - ][ + + ]: 2404 : else if (op->IsDeleted(edge))
1193 [ + - ]: 968 : shape_edge.Nullify();
1194 [ - + ]: 1436 : else if (test_op)
1195 : : {
1196 [ # # ][ # # ]: 0 : if(!test_op->IsModified(edge))
1197 [ # # ]: 0 : shape_edge = edge;
1198 : : else
1199 [ # # ][ # # ]: 0 : shape_edge = (test_op->Modified(edge)).First();
[ # # ]
1200 : : }
1201 : : else
1202 [ + - ]: 1436 : shape_edge = edge;
1203 : :
1204 : : //update vertex
1205 [ + - ][ + - ]: 12266 : TopoDS_Vertex vertex = Ex.CurrentVertex();
[ + - ][ + - ]
[ + + ]
1206 [ + - ]: 6122 : shapes.Clear();
1207 [ - + ]: 6122 : if(test_op)
1208 [ # # ]: 0 : assert(removed_vertex != NULL);
1209 : :
1210 [ + - ][ + - ]: 6122 : if(op && ! test_op )
1211 : : {
1212 [ + - ][ + - ]: 6122 : shapes.Assign(op->Modified(vertex));
1213 [ + - ][ + + ]: 6122 : if(shapes.Extent() == 0)
1214 [ + - ][ + - ]: 3944 : shapes.Assign(op->Generated(vertex));
1215 : : }
1216 [ - + ]: 6122 : if(sp)
1217 [ # # ][ # # ]: 0 : shapes.Assign(sp->DescendantShapes(vertex));
1218 : :
1219 [ + - ][ + + ]: 6122 : if (shapes.Extent() == 1)
1220 [ + - ][ + - ]: 2178 : shape_vertex = shapes.First();
1221 : :
1222 [ + - ][ - + ]: 3944 : else if(shapes.Extent() > 1)
1223 : : {
1224 : : //update all attributes first.
1225 [ # # ]: 0 : TopTools_ListIteratorOfListOfShape it;
1226 [ # # ]: 0 : it.Initialize(shapes);
1227 [ # # ][ # # ]: 0 : for(; it.More(); it.Next())
[ # # ]
1228 : : {
1229 [ # # ][ # # ]: 0 : shape_vertex = it.Value();
1230 [ # # ][ # # ]: 0 : OCCQueryEngine::instance()->copy_attributes(vertex, shape_vertex);
1231 : : }
1232 [ # # ]: 0 : shape_vertex.Nullify() ;
1233 : : }
1234 [ + - ][ + + ]: 3944 : else if(op->IsDeleted(vertex) || (test_op && vertex.IsSame( *removed_vertex)))
[ - + ][ # # ]
[ # # ][ + + ]
1235 : : {
1236 [ + - ][ + + ]: 1254 : if(!shape.IsNull() && !shape_edge.IsNull() && !shape_edge.Closed())
[ + - ][ + + ]
[ + - ][ + - ]
[ + + ]
1237 : : //there should be a vertex corresponding to the old_vertex.
1238 : : //find the vertices within tolerance distance with old_vertex.
1239 : : {
1240 [ + - ]: 484 : TopoDS_Iterator It(shape_edge);
1241 [ + - ][ + - ]: 1452 : for(; It.More(); It.Next())
[ + + ]
1242 : : {
1243 [ + - ][ + - ]: 968 : TopoDS_Vertex v = TopoDS::Vertex(It.Value());
[ + - ]
1244 [ + - ]: 968 : gp_Pnt pt1 = BRep_Tool::Pnt(v);
1245 [ + - ]: 968 : gp_Pnt pt2 = BRep_Tool::Pnt(vertex);
1246 [ + - ][ - + ]: 968 : if(pt1.IsEqual(pt2, dTOL))
1247 : : {
1248 [ # # ]: 0 : shape_vertex = v;
1249 [ + - ][ + - ]: 968 : break;
1250 : : }
1251 [ + - ]: 1452 : }
1252 : : }
1253 : : else
1254 [ + - ]: 1254 : shape_vertex.Nullify() ;
1255 : : }
1256 : : else
1257 [ + - ]: 2690 : shape_vertex = vertex;
1258 : :
1259 [ + - ][ + + ]: 6122 : if(!vertex.IsSame(shape_vertex) )
1260 [ + - ][ + - ]: 2508 : OCCQueryEngine::instance()->update_OCC_map(vertex, shape_vertex);
1261 : :
1262 [ + - ][ + + ]: 6122 : if (!edge.IsSame(shape_edge))
1263 [ + - ][ + - ]: 3784 : OCCQueryEngine::instance()->update_OCC_map(edge, shape_edge);
1264 : 6144 : }
1265 [ + - ][ + + ]: 1657 : if (!wire.IsSame(shape))
1266 [ + - ][ + - ]: 1536 : OCCQueryEngine::instance()->update_OCC_map(wire, shape);
1267 : 1657 : }
1268 : :
1269 [ + - ][ + + ]: 1525 : if (!old_surface.IsSame(new_surface))
1270 : : {
1271 : 1404 : TopAbs_ShapeEnum shapetype = TopAbs_SHAPE;
1272 [ + - ][ + + ]: 1404 : if(!new_surface.IsNull())
1273 [ + - ][ + - ]: 1129 : shapetype = new_surface.TShape()->ShapeType();
[ + - ]
1274 [ + + ][ + - ]: 1404 : if(shapetype == TopAbs_FACE || new_surface.IsNull())
[ + - ][ + - ]
1275 [ + - ][ + - ]: 1404 : OCCQueryEngine::instance()->update_OCC_map(old_surface, new_surface);
1276 : : else
1277 : : {
1278 [ # # ]: 0 : TopTools_IndexedMapOfShape M;
1279 [ # # ]: 0 : TopExp::MapShapes(new_surface, TopAbs_FACE, M);
1280 [ # # ][ # # ]: 0 : TopoDS_Shape new_shape;
1281 [ # # ][ # # ]: 0 : if(M.Extent() == 1)
1282 [ # # ][ # # ]: 0 : new_shape = M(1);
1283 [ # # ][ # # ]: 0 : else if(M.Extent() > 1)
1284 : : {
1285 [ # # ][ # # ]: 0 : for(int i = 1; i <= M.Extent(); i++)
1286 : : {
1287 [ # # ]: 0 : GProp_GProps myProps;
1288 [ # # ]: 0 : BRepGProp::SurfaceProperties(old_surface, myProps);
1289 [ # # ]: 0 : double orig_mass = myProps.Mass();
1290 [ # # ]: 0 : gp_Pnt orig_pnt = myProps.CentreOfMass();
1291 [ # # ][ # # ]: 0 : BRepGProp::SurfaceProperties(M(i), myProps);
1292 [ # # ]: 0 : double after_mass = myProps.Mass();
1293 [ # # ]: 0 : gp_Pnt after_pnt = myProps.CentreOfMass();
1294 [ # # ][ # # ]: 0 : if(fabs(-after_mass + orig_mass) <= dTOL &&
[ # # ]
1295 [ # # ]: 0 : orig_pnt.IsEqual(after_pnt, dTOL))
1296 : : {
1297 [ # # ][ # # ]: 0 : new_shape = M(i);
1298 : 0 : break;
1299 : : }
1300 : : }
1301 : : }
1302 [ # # ][ # # ]: 1404 : OCCQueryEngine::instance()->update_OCC_map(old_surface, new_shape);
[ # # ]
1303 : : }
1304 : : }
1305 [ + - ]: 1525 : return CUBIT_SUCCESS;
1306 : : }
1307 : :
1308 : 11 : CubitStatus OCCSurface::get_bodies(DLIList<OCCBody*>& bodies)
1309 : : {
1310 [ + - ]: 11 : TopoDS_Face* topo_face = this->get_TopoDS_Face();
1311 [ + - ]: 11 : OCCQueryEngine* oqe = OCCQueryEngine::instance();
1312 : 11 : DLIList <OCCBody* > *all_bodies = oqe->BodyList;
1313 [ + - ]: 11 : TopTools_IndexedDataMapOfShapeListOfShape M;
1314 : 11 : OCCBody * body = NULL;
1315 [ + - ][ + + ]: 55 : for(int j = 0; j < all_bodies->size(); j++)
1316 : : {
1317 [ + - ]: 44 : body = all_bodies->get_and_step();
1318 [ + - ]: 44 : TopExp_Explorer Ex;
1319 [ + - ][ + - ]: 88 : TopoDS_Face the_face;
[ + + ]
1320 : : TopoDS_Shape* pshape;
1321 [ + - ]: 44 : body->get_TopoDS_Shape(pshape);
1322 [ + - ][ + - ]: 88 : TopoDS_Shape ashape;
[ + + ]
1323 [ + - ][ + - ]: 132 : if (pshape && !pshape->IsNull() &&
[ + - ][ + - ]
1324 [ + - ][ + - ]: 132 : pshape->ShapeType() <= TopAbs_FACE &&
[ + - ]
1325 [ + - ][ + - ]: 44 : OCCQueryEngine::instance()->OCCMap->IsBound(*pshape) == Standard_True)
1326 [ + - ]: 44 : ashape = *pshape;
1327 [ + - ]: 44 : M.Clear();
1328 : :
1329 [ + - ]: 44 : TopExp::MapShapesAndAncestors(ashape, TopAbs_FACE, TopAbs_COMPOUND, M);
1330 [ + - ][ + + ]: 44 : if(!M.Contains(*topo_face))
1331 : 33 : continue;
1332 [ + - ][ + - ]: 44 : bodies.append_unique(body);
[ + + ]
1333 : 44 : }
1334 [ + - ]: 11 : return CUBIT_SUCCESS;
1335 : : }
1336 : :
1337 : 0 : CubitStatus OCCSurface::get_projected_distance_on_surface( CubitVector *pos1,
1338 : : CubitVector *pos2,
1339 : : double &distance )
1340 : : {
1341 [ # # ]: 0 : CubitVector closest_point1;
1342 [ # # ][ # # ]: 0 : this->closest_point_trimmed(*pos1, closest_point1);
1343 [ # # ]: 0 : CubitVector closest_point2;
1344 [ # # ][ # # ]: 0 : this->closest_point_trimmed(*pos2, closest_point2);
1345 [ # # ]: 0 : distance = closest_point1.distance_between(closest_point2);
1346 : 0 : return CUBIT_SUCCESS;
1347 : : }
1348 : :
1349 : 0 : CubitStatus OCCSurface::get_nurb_params
1350 : : (
1351 : : bool &rational,
1352 : : int °ree_u,
1353 : : int °ree_v,
1354 : : int &num_cntrl_pts_u,
1355 : : int &num_cntrl_pts_v,
1356 : : DLIList<CubitVector> &cntrl_pts,
1357 : : DLIList<double> &cntrl_pt_weights,
1358 : : DLIList<double> &u_knots,
1359 : : DLIList<double> &v_knots
1360 : : ) const
1361 : : {
1362 [ # # ]: 0 : BRepAdaptor_Surface asurf(*myTopoDSFace);
1363 [ # # ][ # # ]: 0 : Handle_Geom_BSplineSurface h_S = NULL;
1364 [ # # ][ # # ]: 0 : if (asurf.GetType() == GeomAbs_BSplineSurface)
1365 [ # # ][ # # ]: 0 : h_S = asurf.BSpline();
[ # # ]
1366 : : else
1367 : 0 : return CUBIT_FAILURE;
1368 [ # # ][ # # ]: 0 : assert ( h_S != NULL);
1369 : :
1370 [ # # ][ # # ]: 0 : if(h_S->IsURational() || h_S->IsVRational())
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1371 : 0 : rational = true;
1372 : : else
1373 : 0 : rational = false;
1374 : :
1375 [ # # ][ # # ]: 0 : degree_u = h_S->UDegree();
1376 [ # # ][ # # ]: 0 : degree_v = h_S->VDegree();
1377 : :
1378 [ # # ][ # # ]: 0 : num_cntrl_pts_u = h_S->NbUPoles();
1379 [ # # ][ # # ]: 0 : num_cntrl_pts_v = h_S->NbVPoles();
1380 : :
1381 [ # # ][ # # ]: 0 : TColgp_Array2OfPnt P(1, h_S->NbUPoles(), 1, h_S->NbVPoles());
[ # # ][ # # ]
[ # # ][ # # ]
1382 [ # # ][ # # ]: 0 : h_S->Poles(P);
1383 [ # # ]: 0 : gp_Pnt cnt_p;
1384 [ # # ][ # # ]: 0 : for(int i = P.LowerRow(); i <= P.UpperRow(); i++)
[ # # ]
1385 : : {
1386 [ # # ][ # # ]: 0 : for (int j = P.LowerCol(); j <= P.UpperCol(); j++)
[ # # ]
1387 : : {
1388 [ # # ]: 0 : cnt_p = P(i,j);
1389 [ # # ][ # # ]: 0 : cntrl_pts.append(CubitVector(cnt_p.X(), cnt_p.Y(), cnt_p.Z()));
[ # # ][ # # ]
[ # # ]
1390 : : }
1391 : : }
1392 [ # # ][ # # ]: 0 : TColStd_Array2OfReal W(1,h_S->NbUPoles(), 1, h_S->NbVPoles());
[ # # ][ # # ]
[ # # ][ # # ]
1393 [ # # ][ # # ]: 0 : h_S->Weights(W);
1394 [ # # ][ # # ]: 0 : for(int i = W.LowerRow(); i <= W.UpperRow(); i++)
[ # # ]
1395 : : {
1396 [ # # ][ # # ]: 0 : for (int j = W.LowerCol(); j <= W.UpperCol(); j++)
[ # # ]
1397 : : {
1398 [ # # ][ # # ]: 0 : cntrl_pt_weights.append(W(i,j));
1399 : : }
1400 : : }
1401 [ # # ][ # # ]: 0 : TColStd_Array1OfReal Ku(1,h_S->NbUKnots()), Kv(1, h_S->NbVKnots());
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
1402 [ # # ][ # # ]: 0 : h_S->UKnots(Ku);
1403 [ # # ][ # # ]: 0 : h_S->VKnots(Kv);
1404 [ # # ][ # # ]: 0 : for(int i = Ku.Lower(); i <= Ku.Upper(); i++)
[ # # ]
1405 [ # # ][ # # ]: 0 : u_knots.append(Ku.Value(i));
1406 : :
1407 [ # # ][ # # ]: 0 : for (int i = Kv.Lower(); i <= Kv.Upper(); i++)
[ # # ]
1408 [ # # ][ # # ]: 0 : v_knots.append(Kv.Value(i));
1409 [ # # ]: 0 : return CUBIT_SUCCESS;
1410 : : }
1411 : : //-------------------------------------------------------------------------
1412 : : // Purpose : Return parameters about a surface assuming that it is
1413 : : // a spherical surface. If it not CUBIT_FAILURE.
1414 : : //
1415 : : // Special Notes :
1416 : : //
1417 : : // Creator : Jane Hu
1418 : : //
1419 : : // Creation Date : 2/28/2012
1420 : : //-------------------------------------------------------------------------
1421 : 0 : CubitStatus OCCSurface::get_sphere_params( CubitVector ¢er,
1422 : : double &radius ) const
1423 : : {
1424 [ # # ][ # # ]: 0 : if(const_cast<OCCSurface*> (this)->geometry_type() != SPHERE_SURFACE_TYPE)
1425 : 0 : return CUBIT_FAILURE;
1426 : :
1427 [ # # ]: 0 : BRepAdaptor_Surface asurface(*myTopoDSFace);
1428 [ # # ]: 0 : gp_Sphere sphere = asurface.Sphere();
1429 [ # # ]: 0 : gp_Pnt center_pt = sphere.Location();
1430 [ # # ][ # # ]: 0 : center = CubitVector(center_pt.X(), center_pt.Y(), center_pt.Z());
[ # # ][ # # ]
[ # # ]
1431 : :
1432 [ # # ]: 0 : radius = sphere.Radius();
1433 [ # # ]: 0 : return CUBIT_SUCCESS;
1434 : : }
1435 : :
1436 : : //-------------------------------------------------------------------------
1437 : : // Purpose : Return parameters about a surface assuming that it is
1438 : : // a conical surface. If it not CUBIT_FAILURE.
1439 : : //
1440 : : // Special Notes :
1441 : : //
1442 : : // Creator : Jane Hu
1443 : : //
1444 : : // Creation Date : 2/28/2012
1445 : : //-------------------------------------------------------------------------
1446 : 0 : CubitStatus OCCSurface::get_cone_params
1447 : : (
1448 : : CubitVector ¢er,
1449 : : CubitVector &normal,
1450 : : CubitVector &major_axis,
1451 : : double &radius_ratio,
1452 : : double &sine_angle,
1453 : : double &cos_angle
1454 : : ) const
1455 : : {
1456 [ # # ][ # # ]: 0 : if(const_cast<OCCSurface*> (this)->geometry_type() != CONE_SURFACE_TYPE)
1457 : 0 : return CUBIT_FAILURE;
1458 : :
1459 : : //all cone type surface in OCC have circular base.
1460 [ # # ]: 0 : BRepAdaptor_Surface asurface(*myTopoDSFace);
1461 [ # # ]: 0 : gp_Cone cone = asurface.Cone();
1462 [ # # ]: 0 : double half_angle = cone.SemiAngle();
1463 : 0 : sine_angle = sin(half_angle);
1464 : 0 : cos_angle = cos(half_angle);
1465 : :
1466 [ # # ]: 0 : gp_Ax1 axis = cone.Axis();
1467 [ # # ]: 0 : gp_Dir dir = axis.Direction();
1468 [ # # ][ # # ]: 0 : normal.set(dir.X(), dir.Y(), dir.Z());
[ # # ][ # # ]
1469 : :
1470 [ # # ]: 0 : gp_Pnt center_pt = cone.Location();
1471 [ # # ][ # # ]: 0 : center = CubitVector(center_pt.X(), center_pt.Y(), center_pt.Z());
[ # # ][ # # ]
[ # # ]
1472 : :
1473 [ # # ]: 0 : gp_Ax1 x_axis = cone.XAxis();
1474 [ # # ]: 0 : dir = x_axis.Direction();
1475 [ # # ][ # # ]: 0 : major_axis.set(dir.X(), dir.Y(), dir.Z());
[ # # ][ # # ]
1476 : :
1477 : 0 : radius_ratio = 1;
1478 [ # # ]: 0 : return CUBIT_SUCCESS;
1479 : : }
1480 : :
1481 : : //-------------------------------------------------------------------------
1482 : : // Purpose : Return parameters about a surface assuming that it is
1483 : : // a torus surface. If it not CUBIT_FAILURE.
1484 : : //
1485 : : // Special Notes :
1486 : : //
1487 : : // Creator : Jane Hu
1488 : : //
1489 : : // Creation Date : 2/28/2012
1490 : : //-------------------------------------------------------------------------
1491 : 0 : CubitStatus OCCSurface::get_torus_params
1492 : : (
1493 : : CubitVector ¢er,
1494 : : CubitVector &normal,
1495 : : double &major_radius,
1496 : : double &minor_radius
1497 : : ) const
1498 : : {
1499 [ # # ][ # # ]: 0 : if(const_cast<OCCSurface*> (this)->geometry_type() != TORUS_SURFACE_TYPE)
1500 : 0 : return CUBIT_FAILURE;
1501 : :
1502 [ # # ]: 0 : BRepAdaptor_Surface asurface(*myTopoDSFace);
1503 [ # # ]: 0 : gp_Torus torus = asurface.Torus();
1504 [ # # ]: 0 : gp_Pnt center_pt = torus.Location();
1505 [ # # ][ # # ]: 0 : center = CubitVector(center_pt.X(), center_pt.Y(), center_pt.Z());
[ # # ][ # # ]
[ # # ]
1506 : :
1507 [ # # ]: 0 : gp_Ax1 axis = torus.Axis();
1508 [ # # ]: 0 : gp_Dir dir = axis.Direction();
1509 [ # # ][ # # ]: 0 : normal.set(dir.X(), dir.Y(), dir.Z());
[ # # ][ # # ]
1510 : :
1511 [ # # ]: 0 : major_radius = torus.MajorRadius();
1512 [ # # ]: 0 : minor_radius = torus.MinorRadius();
1513 : :
1514 [ # # ]: 0 : return CUBIT_SUCCESS;
1515 [ + - ][ + - ]: 6364 : }
1516 : : // ********** END PUBLIC FUNCTIONS **********
1517 : :
1518 : : // ********** BEGIN PROTECTED FUNCTIONS **********
1519 : : // ********** END PROTECTED FUNCTIONS **********
1520 : :
1521 : : // ********** BEGIN PRIVATE FUNCTIONS **********
1522 : :
1523 : :
1524 : : // ********** END PRIVATE FUNCTIONS **********
1525 : :
1526 : : // ********** BEGIN HELPER CLASSES **********
1527 : : // ********** END HELPER CLASSES **********
1528 : :
1529 : : // ********** BEGIN EXTERN FUNCTIONS **********
1530 : : // ********** END EXTERN FUNCTIONS **********
1531 : :
1532 : : // ********** BEGIN STATIC FUNCTIONS **********
1533 : : // ********** END STATIC FUNCTIONS **********
|
