Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : OCCCurve.cpp
3 : : //
4 : : // Purpose :
5 : : //
6 : : // Special Notes :
7 : : //
8 : : // Creator : Steven J. Owen
9 : : //
10 : : // Creation Date : 07/14/00
11 : : //
12 : : // Owner : Steven J. Owen
13 : : //-------------------------------------------------------------------------
14 : :
15 : : // ********** BEGIN STANDARD INCLUDES **********
16 : :
17 : : // ********** END STANDARD INCLUDES **********
18 : : // ********** BEGIN CUBIT INCLUDES **********
19 : :
20 : : #include "CastTo.hpp"
21 : : #include "CubitVector.hpp"
22 : : #include "CubitBox.hpp"
23 : : #include "GeometryDefines.h"
24 : : #include "OCCCurve.hpp"
25 : : #include "GeometryQueryEngine.hpp"
26 : : #include "OCCQueryEngine.hpp"
27 : : #include "CoEdgeSM.hpp"
28 : :
29 : : #include "OCCBody.hpp"
30 : : #include "OCCLump.hpp"
31 : : #include "OCCShell.hpp"
32 : : #include "OCCSurface.hpp"
33 : : #include "OCCLoop.hpp"
34 : : #include "OCCCoEdge.hpp"
35 : : #include "OCCPoint.hpp"
36 : : #include "OCCAttribSet.hpp"
37 : :
38 : : #include <BRepAdaptor_Curve.hxx>
39 : : #include <TopExp.hxx>
40 : : #include "GProp_GProps.hxx"
41 : : #include "BRepGProp.hxx"
42 : : #include <TopTools_IndexedMapOfShape.hxx>
43 : : #include "TopTools_ListIteratorOfListOfShape.hxx"
44 : : #include <GCPnts_AbscissaPoint.hxx>
45 : : #include <Bnd_Box.hxx>
46 : : #include <BndLib_Add3dCurve.hxx>
47 : : #include <Precision.hxx>
48 : : #include <Extrema_ExtPC.hxx>
49 : : #include <BRepLProp_CLProps.hxx>
50 : : #include <BRep_Tool.hxx>
51 : : #include <TopoDS.hxx>
52 : : #include "BRepBuilderAPI_MakeEdge.hxx"
53 : : #include "Geom_BezierCurve.hxx"
54 : : #include "Geom_BSplineCurve.hxx"
55 : : #include "GeomAPI_ProjectPointOnCurve.hxx"
56 : : #include "TColgp_Array1OfPnt.hxx"
57 : : #include "GeomAdaptor_Curve.hxx"
58 : : #include "GCPnts_QuasiUniformAbscissa.hxx"
59 : : #include "BRepAlgoAPI_BooleanOperation.hxx"
60 : : #include "TopTools_ListOfShape.hxx"
61 : : #include "BRepAlgo_NormalProjection.hxx"
62 : : #include "TopExp_Explorer.hxx"
63 : : #include "GeomLProp_CurveTool.hxx"
64 : : #include "GeomAPI_ExtremaCurveCurve.hxx"
65 : : #include "Geom_Line.hxx"
66 : : #include "Geom_Circle.hxx"
67 : : #include "Geom_Ellipse.hxx"
68 : : #include "GC_MakeLine.hxx"
69 : : #include "gp_Circ.hxx"
70 : : #include "gp_Elips.hxx"
71 : : #include "BRepBuilderAPI_Transform.hxx"
72 : : #include "BRepBuilderAPI_GTransform.hxx"
73 : : #include "BRepBuilderAPI_ModifyShape.hxx"
74 : : #include "TopTools_DataMapOfShapeInteger.hxx"
75 : : //#include "TopOpeBRep_ShapeIntersector.hxx"
76 : : //#include "TopOpeBRep_Point2d.hxx"
77 : : //#include "TopOpeBRep_EdgesIntersector.hxx"
78 : : //#include "TopOpeBRepTool_ShapeTool.hxx"
79 : : //#include "BRepPrimAPI_MakePrism.hxx"
80 : : // ********** END CUBIT INCLUDES **********
81 : :
82 : : // ********** BEGIN FORWARD DECLARATIONS **********
83 : : // ********** END FORWARD DECLARATIONS **********
84 : :
85 : : // ********** BEGIN STATIC DECLARATIONS **********
86 : : // ********** END STATIC DECLARATIONS **********
87 : :
88 : : // ********** BEGIN PUBLIC FUNCTIONS **********
89 : :
90 : : //-------------------------------------------------------------------------
91 : : // Purpose : The default constructor
92 : : //
93 : : // Special Notes :
94 : : //
95 : : // Creator: : Steve Owen
96 : : //
97 : : // Creation Date : 07/14/00
98 : : //-------------------------------------------------------------------------
99 [ + - ]: 74544 : OCCCurve::OCCCurve( TopoDS_Edge *theEdge )
100 : : {
101 : 37272 : myTopoDSEdge = theEdge;
102 : 37272 : myMarked = CUBIT_FALSE;
103 [ + - ][ - + ]: 37272 : assert (myTopoDSEdge->ShapeType() == TopAbs_EDGE);
104 : 37272 : }
105 : :
106 : : //-------------------------------------------------------------------------
107 : : // Purpose : The destructor.
108 : : //
109 : : // Special Notes :
110 : : //
111 : : // Creator : Steve Owen
112 : : //
113 : : // Creation Date : 07/14/00
114 : : //-------------------------------------------------------------------------
115 [ + - ]: 65919 : OCCCurve::~OCCCurve()
116 : : {
117 [ + - ]: 21973 : if (myTopoDSEdge)
118 : : {
119 [ + - ]: 21973 : myTopoDSEdge->Nullify();
120 [ + - ][ + - ]: 21973 : delete (TopoDS_Edge *)myTopoDSEdge;
[ + - ]
121 : 21973 : myTopoDSEdge = NULL;
122 : : }
123 [ - + ]: 43946 : }
124 : :
125 : : //-------------------------------------------------------------------------
126 : : // Purpose : Add and update looplist for the curve, if input loop is
127 : : // NULL, just update the looplist.
128 : : // Special Notes :
129 : : //
130 : : // Creator : Jane Hu
131 : : //
132 : : // Creation Date : 10/04/12
133 : : //-------------------------------------------------------------------------
134 : 76259 : void OCCCurve::add_loop(OCCLoop* loop)
135 : : {
136 : : //before add the loop into the looplist, check to make sure the
137 : : //looplist is up-to-date
138 : : //It should be done somewhere else, however, in large mcnp2cad test, there's
139 : : //no way to check where the code forget to remove the out-dated loop.
140 [ + + ]: 124248 : for (int i = 0; i < myLoopList.size(); i++)
141 : : {
142 : 47989 : OCCLoop* myLoop = CAST_TO(myLoopList.get(), OCCLoop);
143 : :
144 [ - + ]: 47989 : if(!myLoop)
145 : 0 : this->remove_loop(myLoopList.get());
146 [ - + ]: 47989 : else if(myLoop->get_TopoDS_Wire() < (void*) 0x1000)
147 : 0 : this->remove_loop(myLoop);
148 [ + - ][ + + ]: 47989 : else if(myLoop->coedges().size() == 0)
149 : 973 : this->remove_loop(myLoop);
150 : 47989 : myLoopList.step();
151 : : }
152 [ + + ]: 76259 : if(loop != NULL)
153 : 66895 : myLoopList.append_unique(loop);
154 : 76259 : }
155 : :
156 : 45698 : void OCCCurve::set_TopoDS_Edge(TopoDS_Edge edge)
157 : : {
158 [ + - ][ + + ]: 45698 : if(myTopoDSEdge && edge.IsEqual(*myTopoDSEdge))
[ + + ]
159 : 45698 : return;
160 : :
161 : : else
162 : : {
163 [ + - ]: 29342 : DLIList<OCCPoint*> points ;
164 [ + - ]: 29342 : this->get_points(points);
165 [ + - ][ + + ]: 72688 : for(int i = 0; i < points.size(); i++)
166 : : {
167 [ + - ]: 43346 : OCCPoint* point = points.get_and_step();
168 [ + - ]: 43346 : TopoDS_Vertex* vtx = point->get_TopoDS_Vertex();
169 [ + - ]: 43346 : TopExp_Explorer Ex;
170 : 43346 : CubitBoolean found = false;
171 [ + - ][ + - ]: 107933 : for (Ex.Init(edge, TopAbs_VERTEX); Ex.More(); Ex.Next())
[ + - ][ + + ]
172 : : {
173 [ + - ][ + - ]: 64587 : TopoDS_Shape sh = Ex.Current();
174 [ + - ][ + + ]: 64587 : if(vtx->IsPartner(sh))
175 : : {
176 : 43027 : found = true;
177 [ + - ][ + + ]: 64587 : break;
178 : : }
179 : 21560 : }
180 [ + + ]: 43346 : if (!found)
181 [ + - ]: 319 : point->remove_curve(this);
182 [ + - ][ + - ]: 72688 : }
183 : : }
184 : :
185 [ + - ]: 29342 : if(myTopoDSEdge)
186 : 29342 : myTopoDSEdge->Nullify();
187 : 29342 : *myTopoDSEdge = edge;
188 : : }
189 : :
190 : : //-------------------------------------------------------------------------
191 : : // Purpose : The purpose of this function is to append a
192 : : // attribute to the GE. The name is attached to the
193 : : // underlying solid model entity this one points to.
194 : : //
195 : : //
196 : : // Special Notes :
197 : : //
198 : : // Creator : Steve Owen
199 : : //
200 : : // Creation Date : 07/14/00
201 : : //-------------------------------------------------------------------------
202 : 9538 : void OCCCurve::append_simple_attribute_virt(const CubitSimpleAttrib &csa)
203 : 9538 : { OCCAttribSet::append_attribute(csa, *myTopoDSEdge); }
204 : :
205 : : //-------------------------------------------------------------------------
206 : : // Purpose : The purpose of this function is to remove a simple
207 : : // attribute attached to this geometry entity. The name is
208 : : // removed from the underlying BODY this points to.
209 : : //
210 : : // Special Notes :
211 : : //
212 : : // Creator : Steve Owen
213 : : //
214 : : // Creation Date : 07/14/00
215 : : //-------------------------------------------------------------------------
216 : 89419 : void OCCCurve::remove_simple_attribute_virt(const CubitSimpleAttrib& csa)
217 : 89419 : { OCCAttribSet::remove_attribute(csa, *myTopoDSEdge); }
218 : :
219 : : //-------------------------------------------------------------------------
220 : : // Purpose : The purpose of this function is to remove all simple
221 : : // attributes attached to this geometry entity. Also
222 : : // removes lingering GTC attributes.
223 : : //
224 : : //
225 : : // Special Notes :
226 : : //
227 : : // Creator : Steve Owen
228 : : //
229 : : // Creation Date : 07/14/00
230 : : //-------------------------------------------------------------------------
231 : 73865 : void OCCCurve::remove_all_simple_attribute_virt()
232 : : {
233 [ + - ]: 73865 : OCCAttribSet::remove_attribute(CubitSimpleAttrib(), *myTopoDSEdge);
234 : 73865 : }
235 : :
236 : : //-------------------------------------------------------------------------
237 : : // Purpose : The purpose of this function is to get the
238 : : // attributes attached to this geometry entity. The name is
239 : : // attached to the underlying BODY this points to.
240 : : //
241 : : // Special Notes :
242 : : //
243 : : // Creator : Steve Owen
244 : : //
245 : : // Creation Date : 07/14/00
246 : : //-------------------------------------------------------------------------
247 : 47988 : CubitStatus OCCCurve::get_simple_attribute(DLIList<CubitSimpleAttrib>&
248 : : csa_list)
249 : 47988 : { return OCCAttribSet::get_attributes(*myTopoDSEdge, csa_list); }
250 : :
251 : 421057 : CubitStatus OCCCurve::get_simple_attribute( const CubitString& name,
252 : : DLIList<CubitSimpleAttrib>& csa_list)
253 : 421057 : { return OCCAttribSet::get_attributes( name, *myTopoDSEdge, csa_list ); }
254 : :
255 : : //-------------------------------------------------------------------------
256 : : // Purpose : Get geometry modeling engine: OCCQueryEngine
257 : : //
258 : : // Special Notes :
259 : : //
260 : : // Creator : Steve Owen
261 : : //
262 : : // Creation Date : 07/14/00
263 : : //-------------------------------------------------------------------------
264 : 15060 : GeometryQueryEngine* OCCCurve::get_geometry_query_engine() const
265 : : {
266 : 15060 : return OCCQueryEngine::instance();
267 : : }
268 : :
269 : : //-------------------------------------------------------------------------
270 : : // Purpose : Get the bounding box of the object.
271 : : //
272 : : // Special Notes :
273 : : //
274 : : // Creator : Steve Owen
275 : : //
276 : : // Creation Date : 10/23/96
277 : : //-------------------------------------------------------------------------
278 : 4215 : CubitBox OCCCurve::bounding_box() const
279 : : {
280 [ + - ]: 4215 : BRepAdaptor_Curve acurve(*myTopoDSEdge);
281 [ + - ]: 4215 : Bnd_Box aBox;
282 [ + - ][ + - ]: 4215 : BndLib_Add3dCurve::Add(acurve, Precision::Approximation(), aBox);
283 : : double min[3], max[3];
284 [ + - ]: 4215 : aBox.Get( min[0], min[1], min[2], max[0], max[1], max[2]);
285 [ + - ][ + - ]: 4215 : return CubitBox(min, max);
286 : : }
287 : :
288 : :
289 : : //-------------------------------------------------------------------------
290 : : // Purpose : Return the length of the curve.
291 : : //
292 : : // Special Notes :
293 : : //
294 : : // Creator : Steve Owen
295 : : //
296 : : // Creation Date : 07/14/00
297 : : //-------------------------------------------------------------------------
298 : 41579 : double OCCCurve::measure()
299 : : {
300 [ + - ]: 41579 : GProp_GProps myProps;
301 [ + - ]: 41579 : BRepGProp::LinearProperties(*myTopoDSEdge, myProps);
302 [ + - ]: 41579 : return myProps.Mass();
303 : : }
304 : :
305 : : //-------------------------------------------------------------------------
306 : : // Purpose : Return the arc length along the Curve starting from
307 : : // the point represented by the parameter1 going to the
308 : : // point represented by parameter2.
309 : : //
310 : : // Special Notes : The sign of the returned length value is always positive.
311 : : // Parameter1 and parameter2 are with respect to the EDGE.
312 : : //
313 : : // Creator : Steve Owen
314 : : //
315 : : // Creation Date : 07/14/00
316 : : //-------------------------------------------------------------------------
317 : 0 : double OCCCurve::length_from_u( double parameter1, double parameter2 )
318 : : {
319 [ # # ]: 0 : BRepAdaptor_Curve acurve(*myTopoDSEdge);
320 [ # # ][ # # ]: 0 : return GCPnts_AbscissaPoint::Length(acurve, parameter1, parameter2);
321 : : }
322 : :
323 : : //-------------------------------------------------------------------------
324 : : // Purpose : Returns CUBIT_TRUE and the associated period value. Not
325 : : // implemented yet
326 : : //
327 : : // Special Notes :
328 : : //
329 : : // Creator : Steve Owen
330 : : //
331 : : // Creation Date : 07/14/00
332 : : //-------------------------------------------------------------------------
333 : 15270 : CubitBoolean OCCCurve::is_periodic(double& period)
334 : : {
335 [ + - ]: 15270 : BRepAdaptor_Curve acurve(*myTopoDSEdge);
336 [ + - ][ + + ]: 15270 : if (acurve.IsPeriodic())
337 : : {
338 [ + - ]: 280 : period = acurve.Period();
339 : 280 : return CUBIT_TRUE;
340 : : }
341 [ + - ]: 15270 : return CUBIT_FALSE;
342 : : }
343 : :
344 : : //------------------------------------------------------------------
345 : : // Purpose: Returns CUBIT_TRUE and the associated parametric values,
346 : : // if the facet curve associated with the first EDGE is
347 : : // parametric.
348 : : // Otherwise returns CUBIT_FALSE and the values of
349 : : // the lower and upper parametric bounds are undetermined.
350 : : // NOT IMPLEMENTED YET
351 : : //
352 : : // Creator : Steve Owen
353 : : //
354 : : // Creation Date : 07/14/00
355 : : //-------------------------------------------------------------------
356 : 386913 : CubitBoolean OCCCurve::get_param_range( double& lower_bound,
357 : : double& upper_bound )
358 : : {
359 [ + - ]: 386913 : BRepAdaptor_Curve acurve(*myTopoDSEdge);
360 [ + - ]: 386913 : lower_bound = acurve.FirstParameter();
361 [ + - ]: 386913 : upper_bound = acurve.LastParameter();
362 [ + - ]: 386913 : return CUBIT_TRUE;
363 : : }
364 : :
365 : :
366 : : //------------------------------------------------------------------
367 : : // Purpose: Finds the extrema along this Curve.
368 : : //
369 : : // Special Notes : It is the responsibility of the
370 : : // calling code to delete the CubitVectors added to
371 : : // interior_points!
372 : : //
373 : : // Creator : Jason Kraftcheck
374 : : //
375 : : // Creation Date : 05/29/01
376 : : //-------------------------------------------------------------------
377 : 0 : CubitStatus OCCCurve::get_interior_extrema(
378 : : DLIList<CubitVector*>& interior_points,
379 : : CubitSense& return_sense )
380 : : {
381 [ # # ]: 0 : DLIList<CubitVector*> point_list;
382 [ # # ]: 0 : CubitVector x(1.0, 0.0, 0.0);
383 [ # # ][ # # ]: 0 : get_interior_extrema_in_direction(point_list, x);
384 [ # # ]: 0 : CubitVector y(0.0, 1.0, 0.0);
385 [ # # ][ # # ]: 0 : get_interior_extrema_in_direction(point_list, y);
386 [ # # ]: 0 : CubitVector z(0.0, 0.0, 1.0);
387 [ # # ][ # # ]: 0 : get_interior_extrema_in_direction(point_list, z );
388 : :
389 : : //like , return only points that aren't at an endpoint and are not
390 : : //close to previous point
391 : 0 : const double epsilon = 30.* GEOMETRY_RESABS;
392 : 0 : const double epsilon_squared = epsilon*epsilon;
393 : :
394 : : //get both vertices' coordinates.
395 [ # # ][ # # ]: 0 : CubitVector endpoints[2];
396 : 0 : int i = 0;
397 [ # # ][ # # ]: 0 : TopExp_Explorer aVertexExp(*myTopoDSEdge, TopAbs_VERTEX);
398 [ # # ][ # # ]: 0 : while(aVertexExp.More())
399 : : {
400 [ # # ][ # # ]: 0 : TopoDS_Vertex v = TopoDS::Vertex(aVertexExp.Current());
[ # # ]
401 [ # # ]: 0 : gp_Pnt p = BRep_Tool::Pnt(v);
402 [ # # ][ # # ]: 0 : endpoints[i].x(p.X());
403 [ # # ][ # # ]: 0 : endpoints[i].y(p.Y());
404 [ # # ][ # # ]: 0 : endpoints[i].z(p.Z());
405 : 0 : i++;
406 [ # # ]: 0 : aVertexExp.Next();
407 [ # # ]: 0 : }
408 : :
409 : : //compare to see if the Points in point_list are interior and far apart
410 : : int j;
411 : 0 : CubitVector* cubit_position = NULL;
412 : 0 : CubitVector * temp_position = NULL;
413 [ # # ]: 0 : point_list.sort();
414 [ # # ]: 0 : point_list.reset();
415 [ # # ][ # # ]: 0 : for (j = point_list.size(); j--; )
416 : : {
417 [ # # ]: 0 : temp_position = point_list.get_and_step();
418 : : // save if not equal to an endpoint, or prior point
419 [ # # ][ # # ]: 0 : if (temp_position->distance_between_squared(endpoints[0]) > epsilon_squared
420 [ # # ][ # # ]: 0 : &&
421 [ # # ]: 0 : temp_position->distance_between_squared(endpoints[1]) > epsilon_squared)
422 : : {
423 [ # # ][ # # ]: 0 : if (!cubit_position ||
[ # # ]
424 [ # # ]: 0 : temp_position->distance_between_squared(*cubit_position) > epsilon_squared)
425 : : {
426 : 0 : cubit_position = temp_position ;
427 [ # # ]: 0 : interior_points.append( cubit_position );
428 : : } // If point isn't close to previous point
429 : : } // If point isn't at an endpoint
430 : : } // for each point
431 : :
432 : : // Return sense is whatever the sense of this curve is.
433 [ # # ]: 0 : TopAbs_Orientation sense = myTopoDSEdge->Orientation();
434 : 0 : return_sense = (sense == TopAbs_FORWARD ? CUBIT_FORWARD : CUBIT_REVERSED);
435 : :
436 [ # # ]: 0 : return CUBIT_SUCCESS;
437 : : }
438 : :
439 : 0 : CubitStatus OCCCurve::get_interior_extrema_in_direction(
440 : : DLIList<CubitVector*>& interior_points,
441 : : CubitVector dir)
442 : : {
443 : : //Create a straight line.
444 [ # # ]: 0 : gp_Pnt origin(0.0, 0.0, 0.0);
445 [ # # ][ # # ]: 0 : gp_Dir adir(dir.x(), dir.y(), dir.z());
[ # # ][ # # ]
446 [ # # ][ # # ]: 0 : Handle(Geom_Line) line = GC_MakeLine(origin, adir);
[ # # ]
447 : :
448 : : //get the Geom_Curve of the OCCCurve
449 : : Standard_Real first;
450 : : Standard_Real last;
451 [ # # ][ # # ]: 0 : Handle(Geom_Curve) myCurve = BRep_Tool::Curve(*myTopoDSEdge, first, last);
452 : :
453 [ # # ][ # # ]: 0 : GeomAPI_ExtremaCurveCurve extrema(myCurve, line);
454 [ # # ]: 0 : int nPnt = extrema.NbExtrema();
455 [ # # ]: 0 : for (int i = 1; i <= nPnt ; i++)
456 : : {
457 [ # # ][ # # ]: 0 : gp_Pnt P1, P2;
458 [ # # ]: 0 : extrema.Points(i, P1, P2);
459 [ # # ][ # # ]: 0 : CubitVector* v = new CubitVector(P1.X(), P1.Y(), P1.Z());
[ # # ][ # # ]
[ # # ]
460 [ # # ]: 0 : interior_points.append(v);
461 : : }
462 [ # # ]: 0 : return CUBIT_SUCCESS;
463 : : }
464 : : //-------------------------------------------------------------------------
465 : : // Purpose : This function computes the point on the curve closest
466 : : // to the input location. Optionally, it can also compute
467 : : // the tangent and curvature on the Curve at the point on
468 : : // on the Curve closest to the input location.
469 : : //
470 : : // Special Notes : The tangent direction is always in the positive direction of the
471 : : // owning RefEdge, regardless of the positive direction of the
472 : : // underlying solid model entities.
473 : : //
474 : : // If the calling code needs the tangent and/or the curvature,
475 : : // it is responsible for allocating the memory for these
476 : : // CubitVector(s) and sending in the relevant non-NULL
477 : : // pointers to this routine.
478 : : //
479 : : // Creator : Steve Owen
480 : : //
481 : : // Creation Date : 07/14/00
482 : : //-------------------------------------------------------------------------
483 : 42170 : CubitStatus OCCCurve::closest_point(
484 : : CubitVector const& location,
485 : : CubitVector& closest_location,
486 : : CubitVector* tangent_ptr,
487 : : CubitVector* curvature_ptr,
488 : : double* param)
489 : : {
490 [ + - ]: 42170 : BRepAdaptor_Curve acurve(*myTopoDSEdge);
491 [ + - ][ + - ]: 42170 : gp_Pnt p(location.x(), location.y(), location.z()), newP(0.0, 0.0, 0.0);
[ + - ][ + - ]
[ + - ]
492 [ + - ][ + - ]: 84340 : Extrema_ExtPC ext(p, acurve, Precision::Approximation());
[ + - ]
493 [ + - ][ + + ]: 42170 : if (!ext.IsDone())
494 : 1921 : return CUBIT_FAILURE;
495 : :
496 : 40249 : double sqr_dist = CUBIT_DBL_MAX;
497 : 40249 : double pparam = 0.0;
498 [ + - ][ + + ]: 81089 : for (int i = 1; i <= ext.NbExt(); ++i) {
499 [ + - ][ + - ]: 40840 : double new_sqr_dist = p.SquareDistance( ext.Point(i).Value() );
[ + - ]
500 [ + + ]: 40840 : if (new_sqr_dist < sqr_dist) {
501 : 40249 : sqr_dist = new_sqr_dist;
502 [ + - ][ + - ]: 40249 : newP = ext.Point(i).Value();
503 [ + - ][ + - ]: 40249 : pparam = ext.Point(i).Parameter();
504 : : }
505 : : }
506 : :
507 : : // if we didn't find any minimum...
508 [ - + ]: 40249 : if (sqr_dist == CUBIT_DBL_MAX)
509 : 0 : return CUBIT_FAILURE;
510 : :
511 : : // pass back closest point
512 [ + - ][ + - ]: 40249 : closest_location.set( newP.X(), newP.Y(), newP.Z() );
[ + - ][ + - ]
513 [ + + ]: 40249 : if (param != NULL)
514 : 15281 : *param = pparam;
515 : :
516 : : // pass back tangent
517 [ + + ]: 40249 : if (tangent_ptr != NULL) {
518 [ + - ][ + - ]: 3768 : BRepLProp_CLProps CLP(acurve, 2, Precision::PConfusion());
519 [ + - ]: 3768 : CLP.SetParameter( pparam );
520 [ + - ][ - + ]: 3768 : if (!CLP.IsTangentDefined())
521 : 0 : return CUBIT_FAILURE;
522 : :
523 [ + - ]: 3768 : gp_Dir tangent;
524 [ + - ]: 3768 : CLP.Tangent(tangent);
525 [ + - ][ + - ]: 3768 : tangent_ptr->set( tangent.X(), tangent.Y(), tangent.Z() );
[ + - ][ + - ]
[ + - ][ + - ]
526 : : }
527 : :
528 : : // if requested, pass back curvature
529 [ - + ]: 40249 : if (curvature_ptr != NULL)
530 [ # # ]: 0 : get_curvature( closest_location, *curvature_ptr );
531 : :
532 [ + - ]: 82419 : return CUBIT_SUCCESS;
533 : : }
534 : :
535 : :
536 : : //------------------------------------------------------------------
537 : : // Purpose: This function returns the coordinate of a point in the local
538 : : // parametric (u) space that corresponds to the input position
539 : : // in global (world) space. The input point is first moved to
540 : : // the closest point on the Curve and the parameter value of
541 : : // that point is determined.
542 : : //
543 : : // Creator : Steve Owen
544 : : //
545 : : // Creation Date : 07/14/00
546 : : //-------------------------------------------------------------------
547 : 370287 : CubitStatus OCCCurve::position_from_u (double u_value,
548 : : CubitVector& output_position)
549 : : {
550 [ + - ]: 370287 : BRepAdaptor_Curve acurve(*myTopoDSEdge);
551 [ + - ]: 370287 : gp_Pnt p = acurve.Value(u_value);
552 [ + - ][ + - ]: 370287 : output_position.x(p.X());
553 [ + - ][ + - ]: 370287 : output_position.y(p.Y());
554 [ + - ][ + - ]: 370287 : output_position.z(p.Z());
555 [ + - ]: 370287 : return CUBIT_SUCCESS;
556 : : }
557 : :
558 : : //-------------------------------------------------------------------------
559 : : // Purpose : This function returns the coordinate of a point in the local
560 : : // parametric (u) space that corresponds to the input position
561 : : // in global (world) space. The input point is first moved to
562 : : // the closest point on the Curve and the parameter value of
563 : : // that point is determined.
564 : : //
565 : : // Special Notes :
566 : : //
567 : : // Creator : Malcolm J. Panthaki
568 : : //
569 : : // Creation Date : 2/25/97
570 : : //-------------------------------------------------------------------------
571 : 11 : double OCCCurve::u_from_position (const CubitVector& input_position)
572 : : {
573 : : // Get the closest point on the Curve to the input position
574 [ + - ]: 11 : CubitVector closest_point;
575 : : double u_val;
576 : : this->closest_point(input_position, closest_point,
577 [ + - ]: 11 : NULL, NULL, &u_val);
578 : : // closest_point already makes adjustments for sense and periodicity
579 : :
580 : 11 : return u_val;
581 : : }
582 : :
583 : : //------------------------------------------------------------------
584 : : // Purpose: This function returns the parameter value of the point
585 : : // that is "arc_length" away from the root point, in the
586 : : // positive sense direction of the owning RefEdge.
587 : : //
588 : : // Special Notes :
589 : : // If arc_length is negative, the new point (whose parameter value
590 : : // is being computed) is in the negative sense direction (along
591 : : // the RefEdge) from the root point (whose parameter value is
592 : : // root_param).
593 : : //
594 : : // If the curve is not periodic and the new point, "arc_length"
595 : : // away from the root point in the appropriate direction, goes
596 : : // beyond the end point of the first EDGE, that end point is used
597 : : // to generate the returned parameter value.
598 : : //
599 : : // If the curve is periodic and the new point, "arc_length" away
600 : : // from the root point in the appropriate direction, goes beyond
601 : : // the end point of the first EDGE, wrap around is done. After
602 : : // wrap around, the point is treated as with other curves
603 : : //
604 : : // NOTE:
605 : : // The important assumption that is made in this routine is that
606 : : // the end points of the RefEdge that owns this Curve are the
607 : : // same as the end points of the first EDGE in the list of EDGEs
608 : : // associated with this Curve.
609 : : //
610 : : // Assume that the parameter root_param is with respect to the
611 : : // RefEdge as well as arc_length. Before calling the "curve",
612 : : // we need to get them with respect to the curve.
613 : : //
614 : : // Creator : Malcolm J. Panthaki
615 : : //
616 : : // Creation Date : 2/28/97
617 : : //------------------------------------------------------------------
618 : 1726 : double OCCCurve::u_from_arc_length ( double root_param,
619 : : double arc_length )
620 : : {
621 [ + - ]: 1726 : BRepAdaptor_Curve acurve(*myTopoDSEdge);
622 [ + - ][ + - ]: 3452 : GCPnts_AbscissaPoint abs(acurve, arc_length, root_param);
623 [ + - ][ + - ]: 1726 : if (abs.IsDone()) return abs.Parameter();
[ + - ]
624 [ + - ]: 1726 : else return 0.0;
625 : : }
626 : :
627 : : //-------------------------------------------------------------------------
628 : : // Purpose : This function tests the passed in position to see if
629 : : // is on the underlying curve.
630 : : //
631 : : // Special Notes :
632 : : //
633 : : // Creator : Steve Owen
634 : : //
635 : : // Creation Date : 07/14/00
636 : : //-------------------------------------------------------------------------
637 : 3216 : CubitBoolean OCCCurve::is_position_on( const CubitVector &test_position )
638 : : {
639 [ + - ]: 3216 : CubitVector new_point;
640 [ + - ]: 3216 : CubitStatus stat = closest_point(test_position, new_point, NULL,NULL,NULL);
641 : :
642 [ + + ]: 3216 : if ( !stat )
643 : 198 : return CUBIT_FALSE;
644 [ + - ]: 3018 : CubitVector result_vec = test_position - new_point;
645 [ + - ][ + + ]: 3018 : if ( result_vec.length_squared() < GEOMETRY_RESABS )
646 : 352 : return CUBIT_TRUE;
647 : 3216 : return CUBIT_FALSE;
648 : : }
649 : :
650 : : //-------------------------------------------------------------------------
651 : : // Purpose : This function returns the type of underlying curve.
652 : : //
653 : : // Special Notes : It checks to see if *any* of the curves associated
654 : : // with the EDGEs in the list of EDGEs of this Curve is of
655 : : // a particular type and returns the appropriate value
656 : : // of the enum, CurveType.
657 : : //
658 : : // Creator : Steve Owen
659 : : //
660 : : // Creation Date : 07/14/00
661 : : //-------------------------------------------------------------------------
662 : 1625 : GeometryType OCCCurve::geometry_type()
663 : : {
664 [ + - ]: 1625 : BRepAdaptor_Curve acurve(*myTopoDSEdge);
665 [ + - ][ - + ]: 1625 : if (acurve.GetType() == GeomAbs_BezierCurve)
666 : 0 : return SPLINE_CURVE_TYPE;
667 [ + - ][ + + ]: 1625 : if (acurve.GetType() == GeomAbs_BSplineCurve)
668 : 11 : return SPLINE_CURVE_TYPE;
669 [ + - ][ + + ]: 1614 : if (acurve.GetType() == GeomAbs_Line)
670 : 1479 : return STRAIGHT_CURVE_TYPE;
671 [ + - ][ + + ]: 135 : if (acurve.GetType() == GeomAbs_Parabola)
672 : 11 : return PARABOLA_CURVE_TYPE;
673 [ + - ][ + + ]: 124 : if (acurve.GetType() == GeomAbs_Hyperbola)
674 : 11 : return HYPERBOLA_CURVE_TYPE;
675 [ + - ][ + + ]: 113 : if (acurve.GetType() == GeomAbs_Circle)
676 : 102 : return ARC_CURVE_TYPE;
677 [ + - ][ + - ]: 11 : if (acurve.GetType() == GeomAbs_Ellipse)
678 : 11 : return ELLIPSE_CURVE_TYPE;
679 [ + - ]: 1625 : return UNDEFINED_CURVE_TYPE;
680 : : }
681 : :
682 : : //-------------------------------------------------------------------------
683 : : // Purpose : Return direction of point on curve
684 : : //
685 : : // Special Notes : Finds the underlying line's origin and direction unit vector
686 : : //
687 : : // Creator : Jane Hu
688 : : //
689 : : // Creation Date : 11/14/07
690 : : //-------------------------------------------------------------------------
691 : 0 : CubitStatus OCCCurve::get_point_direction( CubitVector& point,
692 : : CubitVector& direction )
693 : : {
694 [ # # ][ # # ]: 0 : if (geometry_type() != STRAIGHT_CURVE_TYPE)
695 : 0 : return CUBIT_FAILURE;
696 : :
697 : : //get the underlying geometry curve
698 : : double first,last;
699 [ # # ]: 0 : Handle(Geom_Curve) gCurve = BRep_Tool::Curve(*myTopoDSEdge, first, last);
700 : :
701 : : //get the origin and direction of the underlying curve
702 [ # # ][ # # ]: 0 : Handle(Geom_Line) gLine = Handle(Geom_Line)::DownCast(gCurve);
703 [ # # ][ # # ]: 0 : gp_Ax1 axis = gLine->Position();
704 [ # # ]: 0 : gp_Pnt loc = axis.Location();
705 [ # # ]: 0 : gp_Dir dir = axis.Direction();
706 [ # # ][ # # ]: 0 : point.set(loc.X(), loc.Y(), loc.Z());
[ # # ][ # # ]
707 : :
708 : : //Based on the TopoDS_Edge's orientation, give the unit vector.
709 [ # # ][ # # ]: 0 : if (myTopoDSEdge->Orientation() == TopAbs_FORWARD)
710 [ # # ][ # # ]: 0 : direction.set(dir.X(), dir.Y(), dir.Z());
[ # # ][ # # ]
711 [ # # ][ # # ]: 0 : else if(myTopoDSEdge->Orientation() == TopAbs_REVERSED)
712 [ # # ][ # # ]: 0 : direction.set(-dir.X(), -dir.Y(), -dir.Z());
[ # # ][ # # ]
713 [ # # ]: 0 : return CUBIT_SUCCESS;
714 : : }
715 : :
716 : : //-------------------------------------------------------------------------
717 : : // Purpose : Return the center and radius of an arc
718 : : //
719 : : // Special Notes : not currently implemented
720 : : //
721 : : // Creator : Steve Owen
722 : : //
723 : : // Creation Date : 07/14/00
724 : : //-------------------------------------------------------------------------
725 : 0 : CubitStatus OCCCurve::get_center_radius( CubitVector& center,
726 : : double& radius )
727 : : {
728 [ # # ][ # # ]: 0 : if( geometry_type() != ELLIPSE_CURVE_TYPE &&
[ # # ][ # # ]
729 [ # # ]: 0 : geometry_type() != ARC_CURVE_TYPE )
730 : 0 : return CUBIT_FAILURE;
731 : :
732 : : //get the Geom_Curve of the OCCCurve
733 : : Standard_Real first;
734 : : Standard_Real last;
735 [ # # ]: 0 : Handle(Geom_Curve) myCurve = BRep_Tool::Curve(*myTopoDSEdge, first, last);
736 : :
737 [ # # ][ # # ]: 0 : if (Handle(Geom_Circle) gCircle = Handle(Geom_Circle)::DownCast(myCurve))
[ # # ]
738 : : {
739 [ # # ][ # # ]: 0 : radius = gCircle->Radius();
740 [ # # ][ # # ]: 0 : gp_Circ gp_circ = gCircle->Circ();
741 [ # # ]: 0 : gp_Pnt gp_p = gp_circ.Location();
742 [ # # ][ # # ]: 0 : center.set(gp_p.X(), gp_p.Y(), gp_p.Z());
[ # # ][ # # ]
743 : : }
744 : :
745 : : else //ellipse
746 : : {
747 [ # # ]: 0 : Handle(Geom_Ellipse) gEllipse = Handle(Geom_Ellipse)::DownCast(myCurve);
748 [ # # ][ # # ]: 0 : radius = gEllipse->MajorRadius();
749 [ # # ][ # # ]: 0 : gp_Elips gp_ellip = gEllipse->Elips();
750 [ # # ]: 0 : gp_Pnt gp_p = gp_ellip.Location();
751 [ # # ][ # # ]: 0 : center.set(gp_p.X(), gp_p.Y(), gp_p.Z());
[ # # ][ # # ]
[ # # ]
752 [ # # ]: 0 : }
753 [ # # ]: 0 : return CUBIT_SUCCESS;
754 : : }
755 : :
756 : : //-------------------------------------------------------------------------
757 : : // Purpose : This function returns the start parameter.
758 : : //
759 : : // Special Notes : The start param is with respect to the ref_edge.
760 : : //
761 : : // Creator : Steve Owen
762 : : //
763 : : // Creation Date : 07/14/00
764 : : //-------------------------------------------------------------------------
765 : 85590 : double OCCCurve::start_param()
766 : : {
767 : 85590 : double start = 0.0, end = 0.0;
768 [ + - ]: 85590 : get_param_range( start, end );
769 : 85590 : return start;
770 : : }
771 : :
772 : : //-------------------------------------------------------------------------
773 : : // Purpose : This function returns the end parameter.
774 : : //
775 : : // Special Notes : The end param is with respect to the ref_edge.
776 : : //
777 : : // Creator : Steve Owen
778 : : //
779 : : // Creation Date : 07/14/00
780 : : //-------------------------------------------------------------------------
781 : 51090 : double OCCCurve::end_param()
782 : : {
783 : 51090 : double start = 0.0, end = 0.0;
784 : :
785 [ + - ]: 51090 : get_param_range( start, end );
786 : 51090 : return end;
787 : : }
788 : :
789 : :
790 : 9364 : void OCCCurve::get_parents_virt( DLIList<TopologyBridge*>& parents )
791 : : {
792 : : //check to see all myLoops are up-to-date.
793 : 9364 : add_loop(NULL);
794 : :
795 [ + + ]: 24954 : for(int i = 0; i < myLoopList.size(); i++)
796 : : {
797 [ + - ][ + - ]: 15590 : DLIList<OCCCoEdge*> coedges = myLoopList.get_and_step()->coedges();
798 : :
799 [ + - ][ + - ]: 52744 : for(int j = 0; j < coedges.size(); j++)
800 : : {
801 [ + - ]: 52744 : OCCCoEdge * coedge = coedges.get_and_step();
802 [ + - ][ + + ]: 52744 : if(coedge->curve() == this)
803 : : {
804 [ + - ]: 15590 : parents.append(coedge);
805 : 15590 : break;
806 : : }
807 : : }
808 [ + - ]: 15590 : }
809 : 9364 : }
810 : 211931 : void OCCCurve::get_children_virt( DLIList<TopologyBridge*>& children )
811 : : {
812 [ + - ]: 211931 : TopTools_IndexedMapOfShape M;
813 [ + - ]: 211931 : TopExp::MapShapes(*myTopoDSEdge, TopAbs_VERTEX, M);
814 : : int ii ;
815 [ + - ][ + + ]: 626606 : for (ii = M.Extent(); ii > 0; ii--) {
816 [ + - ][ + - ]: 414675 : TopologyBridge *point = OCCQueryEngine::instance()->occ_to_cgm(M(ii));
[ + - ]
817 [ + + ]: 414675 : if (point)
818 [ + - ]: 390362 : children.append_unique(point);
819 : : }
820 [ + - ][ + + ]: 211931 : if(children.size() ==0)
821 : 219410 : return;
822 : : //make sure the points are in the start-end order
823 : : double start , end;
824 [ + - ]: 204452 : get_param_range( start, end );
825 [ + - ]: 204452 : CubitVector v;
826 [ + - ]: 204452 : position_from_u(start, v);
827 [ + - ]: 204452 : children.reset();
828 [ + - ][ + - ]: 204452 : if(!v.about_equal(CAST_TO(children.get(), TBPoint)->coordinates()))
[ + - ][ + - ]
[ + + ]
829 [ + - ][ + - ]: 211931 : children.reverse();
[ + + ]
830 : : }
831 : :
832 : :
833 : :
834 : :
835 : : //-------------------------------------------------------------------------
836 : : // Purpose : Check for G1 discontinuity
837 : : //
838 : : // Special Notes : returns tangency discontinuity all along the Curve
839 : : // at the param, only returns minus tangent = plus tangent
840 : : // when it's C1 continuity.
841 : : //
842 : : // Creator : Jane Hu
843 : : //
844 : : // Creation Date : 11/14/07
845 : : //-------------------------------------------------------------------------
846 : 0 : CubitBoolean OCCCurve::G1_discontinuous(
847 : : double param, CubitVector* mtan, CubitVector* ptan )
848 : : {
849 : 0 : CubitBoolean is_discon = CUBIT_TRUE;
850 : : double first, last;
851 [ # # ]: 0 : Handle(Geom_Curve) gCurve = BRep_Tool::Curve(*myTopoDSEdge, first, last);
852 : :
853 [ # # ][ # # ]: 0 : if (gCurve->Continuity() < GeomAbs_G1)
[ # # ]
854 : 0 : return is_discon;
855 : :
856 [ # # ][ # # ]: 0 : assert(first <= param && param <= last );
857 : :
858 [ # # ]: 0 : gp_Pnt P;
859 [ # # ]: 0 : gp_Vec V1;
860 [ # # ][ # # ]: 0 : gCurve->D1(param, P, V1);
861 : :
862 [ # # ][ # # ]: 0 : mtan = new CubitVector(V1.X(), V1.Y(),V1.Z());
[ # # ][ # # ]
[ # # ]
863 [ # # ][ # # ]: 0 : ptan = new CubitVector(*mtan);
864 : :
865 [ # # ]: 0 : return CUBIT_FALSE;
866 : : }
867 : :
868 : 34333 : void OCCCurve::get_points( DLIList<OCCPoint*>& result_list )
869 : : {
870 [ + - ]: 34333 : TopTools_IndexedMapOfShape M;
871 [ + - ]: 34333 : TopExp::MapShapes(*myTopoDSEdge, TopAbs_VERTEX, M);
872 : : int ii;
873 [ + - ][ + + ]: 101134 : for (ii=M.Extent(); ii>0; ii--) {
874 [ + - ][ + - ]: 66801 : TopologyBridge *point = OCCQueryEngine::instance()->occ_to_cgm(M(ii));
[ + - ]
875 [ + + ]: 66801 : if (point)
876 [ - + ][ + - ]: 52988 : result_list.append_unique(dynamic_cast<OCCPoint*>(point));
877 : : }
878 [ + - ][ + + ]: 34333 : if(result_list.size() ==0)
879 : 41284 : return;
880 : : //make sure the points are in the start-end order
881 : : double start , end;
882 [ + - ]: 27382 : get_param_range( start, end );
883 [ + - ]: 27382 : CubitVector v;
884 [ + - ]: 27382 : position_from_u(start, v);
885 [ + - ]: 27382 : result_list.reset();
886 [ + - ][ + - ]: 27382 : if(!v.about_equal(result_list.get()->coordinates()))
[ + - ][ + + ]
887 [ + - ][ + - ]: 34333 : result_list.reverse();
[ + + ]
888 : :
889 : : }
890 : :
891 : 0 : void OCCCurve::get_tangent( CubitVector const& location,
892 : : CubitVector& tangent)
893 : : {
894 [ # # ]: 0 : double u = u_from_position(location);
895 : : Standard_Real first;
896 : : Standard_Real last;
897 [ # # ]: 0 : Handle(Geom_Curve) myCurve = BRep_Tool::Curve(*myTopoDSEdge, first, last);
898 : :
899 [ # # ]: 0 : gp_Pnt p;
900 [ # # ]: 0 : gp_Vec tan;
901 [ # # ]: 0 : GeomLProp_CurveTool::D1(myCurve, u , p, tan) ;
902 [ # # ][ # # ]: 0 : tangent.set(tan.X(), tan.Y(), tan.Z());
[ # # ][ # # ]
[ # # ]
903 : 0 : }
904 : :
905 : 0 : void OCCCurve::get_curvature( CubitVector const& location,
906 : : CubitVector& curvature)
907 : : {
908 [ # # ]: 0 : double u = u_from_position(location);
909 : : Standard_Real first;
910 : : Standard_Real last;
911 [ # # ]: 0 : Handle(Geom_Curve) myCurve = BRep_Tool::Curve(*myTopoDSEdge, first, last);
912 : :
913 [ # # ]: 0 : gp_Pnt p;
914 [ # # ][ # # ]: 0 : gp_Vec tan, cur;
915 [ # # ]: 0 : GeomLProp_CurveTool::D2(myCurve, u , p, tan, cur) ;
916 [ # # ][ # # ]: 0 : curvature.set(cur.X(), cur.Y(), cur.Z());
[ # # ][ # # ]
[ # # ]
917 : 0 : }
918 : :
919 : : // ********** END PUBLIC FUNCTIONS **********
920 : :
921 : : // ********** BEGIN PROTECTED FUNCTIONS **********
922 : : // ********** END PROTECTED FUNCTIONS **********
923 : :
924 : : // ********** BEGIN PRIVATE FUNCTIONS **********
925 : :
926 : :
927 : : //----------------------------------------------------------------
928 : : // Adjusts the input parameter so that it falls within the
929 : : // parameter range of this Curve, if possible. Necessary for
930 : : // periodic curves.
931 : : //----------------------------------------------------------------
932 : 0 : void OCCCurve::adjust_periodic_parameter(double& param)
933 : : {
934 : : // Adjustment only legal if this is a periodic curve.
935 : : double period;
936 [ # # ][ # # ]: 0 : if ( this->is_periodic(period) && (fabs(period) > CUBIT_RESABS))
[ # # ][ # # ]
937 : : {
938 : : double upper_bound, lower_bound;
939 [ # # ]: 0 : this->get_param_range( lower_bound, upper_bound );
940 [ # # ]: 0 : assert((upper_bound - lower_bound) > CUBIT_RESABS * 100);
941 : :
942 : 0 : lower_bound -= CUBIT_RESABS;
943 : 0 : upper_bound += CUBIT_RESABS;
944 : :
945 : : // Make sure period is positive
946 [ # # ]: 0 : if (period < 0.)
947 : 0 : period = -period;
948 : :
949 : : // Move the parameter above the low param
950 [ # # ]: 0 : while (param < lower_bound)
951 : 0 : param += period;
952 : : // Move the parameter below the high param
953 [ # # ]: 0 : while (param > upper_bound)
954 : 0 : param -= period;
955 : : }
956 : 0 : }
957 : :
958 : : //-------------------------------------------------------------------------
959 : : // Purpose : Return the spline parameters given a curve that is a spline
960 : : //
961 : : // Special Notes :
962 : : //
963 : : // Creator : Jane Hu
964 : : //
965 : : // Creation Date : 2/20/2012
966 : : //-------------------------------------------------------------------------
967 : 0 : CubitStatus OCCCurve::get_spline_params
968 : : (
969 : : bool &rational, // return true/false
970 : : int °ree, // the degree of this spline
971 : : DLIList<CubitVector> &cntrl_pts, // xyz position of controlpoints
972 : : DLIList<double> &cntrl_pt_weights, // if rational, a weight for each cntrl point.
973 : : DLIList<double> &knots // There should be order+cntrl_pts.size()-2 knots
974 : : ) const
975 : : {
976 [ # # ]: 0 : BRepAdaptor_Curve acurve(*myTopoDSEdge);
977 [ # # ][ # # ]: 0 : Handle_Geom_BSplineCurve h_S = NULL;
978 [ # # ][ # # ]: 0 : if (acurve.GetType() == GeomAbs_BSplineCurve)
979 [ # # ][ # # ]: 0 : h_S = acurve.BSpline();
[ # # ]
980 : : else
981 : 0 : return CUBIT_FAILURE;
982 [ # # ][ # # ]: 0 : assert ( h_S != NULL);
983 : :
984 [ # # ][ # # ]: 0 : rational = h_S->IsRational();
985 [ # # ][ # # ]: 0 : degree = h_S->Degree();
986 : :
987 [ # # ][ # # ]: 0 : TColStd_Array1OfReal K(1, h_S->NbKnots());
[ # # ][ # # ]
988 [ # # ][ # # ]: 0 : h_S->Knots(K);
989 [ # # ][ # # ]: 0 : for (int i = K.Lower(); i <= K.Upper(); i++)
[ # # ]
990 [ # # ][ # # ]: 0 : knots.append(K.Value(i));
991 : :
992 [ # # ][ # # ]: 0 : TColgp_Array1OfPnt P(1, h_S->NbPoles());
[ # # ][ # # ]
993 [ # # ][ # # ]: 0 : h_S->Poles(P);
994 [ # # ][ # # ]: 0 : for (int i = P.Lower(); i <= P.Upper(); i++)
[ # # ]
995 : : {
996 [ # # ]: 0 : gp_Pnt point = P.Value(i);
997 [ # # ][ # # ]: 0 : CubitVector v = CubitVector(point.X(), point.Y(), point.Z());
[ # # ][ # # ]
998 [ # # ]: 0 : cntrl_pts.append(v);
999 : : }
1000 : :
1001 [ # # ]: 0 : if(rational)
1002 : : {
1003 [ # # ][ # # ]: 0 : TColStd_Array1OfReal W(1, h_S->NbPoles());
[ # # ]
1004 [ # # ][ # # ]: 0 : h_S->Weights(W);
1005 [ # # ][ # # ]: 0 : for (int i = W.Lower(); i <= W.Upper(); i++)
[ # # ]
1006 [ # # ][ # # ]: 0 : cntrl_pt_weights.append(W.Value(i));
[ # # ]
1007 : : }
1008 [ # # ]: 0 : return CUBIT_SUCCESS;
1009 : : }
1010 : :
1011 : : //-------------------------------------------------------------------------
1012 : : // Purpose : Return the ellipse parameters given a curve that is an ellipse
1013 : : //
1014 : : // Special Notes :
1015 : : //
1016 : : // Creator : Jane Hu
1017 : : //
1018 : : // Creation Date : 2/21/2012
1019 : : //-------------------------------------------------------------------------
1020 : 0 : CubitStatus OCCCurve::get_ellipse_params
1021 : : (
1022 : : CubitVector ¢er_pt,
1023 : : CubitVector &normal,
1024 : : CubitVector &major_axis,
1025 : : double &radius_ratio
1026 : : ) const
1027 : : {
1028 [ # # ]: 0 : BRepAdaptor_Curve acurve(*myTopoDSEdge);
1029 [ # # ]: 0 : gp_Elips ellipse;
1030 [ # # ][ # # ]: 0 : if (acurve.GetType() == GeomAbs_Ellipse)
1031 [ # # ]: 0 : ellipse = acurve.Ellipse();
1032 : : else
1033 : 0 : return CUBIT_FAILURE;
1034 : :
1035 [ # # ]: 0 : gp_Pnt center = ellipse.Location();
1036 [ # # ][ # # ]: 0 : center_pt = CubitVector(center.X(), center.Y(), center.Z());
[ # # ][ # # ]
[ # # ]
1037 : :
1038 [ # # ]: 0 : gp_Ax1 normal_Axis = ellipse.Axis();
1039 [ # # ]: 0 : gp_Dir normal_dir = normal_Axis.Direction();
1040 [ # # ][ # # ]: 0 : normal = CubitVector(normal_dir.X(), normal_dir.Y(), normal_dir.Z());
[ # # ][ # # ]
[ # # ]
1041 : :
1042 [ # # ]: 0 : gp_Ax1 major_Axis = ellipse.Directrix1();
1043 [ # # ]: 0 : gp_Dir major_dir = major_Axis.Direction();
1044 [ # # ][ # # ]: 0 : major_axis = CubitVector(major_dir.X(), major_dir.Y(), major_dir.Z());
[ # # ][ # # ]
[ # # ]
1045 : :
1046 [ # # ]: 0 : double major = ellipse.MajorRadius();
1047 [ # # ]: 0 : double minor = ellipse.MinorRadius();
1048 : 0 : radius_ratio = major/minor;
1049 : :
1050 [ # # ]: 0 : return CUBIT_SUCCESS;
1051 : : }
1052 : :
1053 : 3216 : CubitPointContainment OCCCurve::point_containment( const CubitVector &point )
1054 : : {
1055 [ + + ]: 3216 : if (is_position_on(point) == CUBIT_TRUE)
1056 : : {
1057 [ + - ]: 352 : DLIList<OCCPoint*> points;
1058 [ + - ]: 352 : get_points(points);
1059 [ + - ][ + + ]: 660 : for (int i = 0; i < points.size(); i++)
1060 : : {
1061 [ + - ]: 572 : OCCPoint* pnt = points.get_and_step();
1062 [ + - ]: 572 : CubitVector v = pnt->coordinates();
1063 [ + - ]: 572 : double d = v.distance_between(point);
1064 [ + + ]: 572 : if (d < GEOMETRY_RESABS)
1065 : 264 : return CUBIT_PNT_BOUNDARY;
1066 : : }
1067 [ + - ]: 352 : return CUBIT_PNT_ON;
1068 : : }
1069 : 3216 : return CUBIT_PNT_OFF;
1070 : : }
1071 : :
1072 : : //----------------------------------------------------------------
1073 : : // Function: to update the core Curve
1074 : : // for any movement of the body/surface/curve.
1075 : : // Author: Jane Hu
1076 : : //----------------------------------------------------------------
1077 : 13396 : void OCCCurve::update_OCC_entity( BRepBuilderAPI_ModifyShape *aBRepTrsf,
1078 : : BRepAlgoAPI_BooleanOperation *op)
1079 : : {
1080 [ + + ]: 13396 : if (myMarked == 1)
1081 : 13396 : return;
1082 : :
1083 [ - + ][ # # ]: 6698 : assert(aBRepTrsf != NULL || op != NULL);
1084 : :
1085 [ + - ]: 6698 : TopoDS_Shape shape;
1086 [ + - ]: 6698 : if(aBRepTrsf)
1087 [ + - ][ + - ]: 6698 : shape = aBRepTrsf->ModifiedShape(*get_TopoDS_Edge());
[ + - ]
1088 : : else
1089 : : {
1090 [ # # ]: 0 : TopTools_ListOfShape shapes;
1091 [ # # ][ # # ]: 0 : shapes.Assign(op->Modified(*get_TopoDS_Edge()));
[ # # ]
1092 [ # # ][ # # ]: 0 : if(shapes.Extent() == 0)
1093 [ # # ][ # # ]: 0 : shapes.Assign(op->Generated(*get_TopoDS_Edge()));
[ # # ]
1094 [ # # ][ # # ]: 0 : if(shapes.Extent() == 1)
1095 [ # # ][ # # ]: 0 : shape = shapes.First();
1096 [ # # ][ # # ]: 0 : else if(shapes.Extent() > 1)
1097 : : {
1098 [ # # ][ # # ]: 0 : shape = shapes.First();
1099 : : }
1100 [ # # ][ # # ]: 0 : else if (op->IsDeleted(*get_TopoDS_Edge()))
[ # # ]
1101 : : ;
1102 : : else
1103 [ # # ][ # # ]: 0 : return ;
1104 : : }
1105 [ + - ][ + - ]: 13396 : TopoDS_Edge curve;
[ + - ][ + - ]
1106 [ + - ][ + - ]: 6698 : if(!shape.IsNull())
1107 [ + - ][ + - ]: 6698 : curve = TopoDS::Edge(shape);
1108 : :
1109 : : //make sure the shape (edge) length is greater than 0.
1110 [ + - ]: 6698 : GProp_GProps myProps;
1111 [ + - ]: 6698 : BRepGProp::LinearProperties(curve, myProps);
1112 [ + - ]: 6698 : double d = myProps.Mass();
1113 [ + - ][ + - ]: 6698 : if(d > OCCQueryEngine::instance()->get_sme_resabs_tolerance())
[ + - ]
1114 : : {
1115 : : //set the vertices
1116 [ + - ]: 6698 : DLIList<TopologyBridge*> vertices;
1117 [ + - ]: 6698 : get_children_virt(vertices);
1118 [ + - ][ + + ]: 11294 : for (int i = 1; i <= vertices.size(); i++)
1119 : : {
1120 [ + - ]: 4596 : TopologyBridge* tb = vertices.get_and_step();
1121 [ - + ]: 4596 : OCCPoint *point = CAST_TO(tb, OCCPoint);
1122 [ + - ]: 4596 : if (point)
1123 [ + - ]: 4596 : point->update_OCC_entity(aBRepTrsf, op);
1124 : : }
1125 [ + - ]: 6698 : myMarked = 1;
1126 : : }
1127 : : else
1128 [ # # ]: 0 : curve.Nullify();
1129 [ + - ][ + - ]: 13396 : OCCQueryEngine::instance()->update_OCC_map(*myTopoDSEdge, curve);
1130 : : }
1131 : :
1132 : : //===============================================================================
1133 : : // Function : project_curve
1134 : : // Member Type: PUBLIC
1135 : : // Description: project a curve onto a surface, if closed is true,
1136 : : // make sure it projected as two segment, then combine them
1137 : : // into a closed shape, third_point is used to determine
1138 : : // which segment to use if having two projections.
1139 : : // Author : Jane Hu
1140 : : // Date : 01/08
1141 : : //===============================================================================
1142 : 0 : Curve* OCCCurve::project_curve(Surface* face_ptr,
1143 : : DLIList<TBPoint*>& normal_proj_points,
1144 : : CubitBoolean closed,
1145 : : const CubitVector* third_point)
1146 : : {
1147 [ # # ]: 0 : TopoDS_Edge* edge = get_TopoDS_Edge();
1148 [ # # ]: 0 : if (edge == NULL)
1149 : : {
1150 [ # # ][ # # ]: 0 : PRINT_ERROR("Cannot project the curve .\n"
[ # # ]
1151 [ # # ]: 0 : "Possible incompatible geometry engines.\n");
1152 : 0 : return (Curve*) NULL;
1153 : : }
1154 : :
1155 [ # # ][ # # ]: 0 : TopoDS_Face* face = CAST_TO(face_ptr, OCCSurface)->get_TopoDS_Face();
1156 [ # # ]: 0 : if(face == NULL)
1157 : : {
1158 [ # # ][ # # ]: 0 : PRINT_ERROR("Cannot project the curve to the surface.\n"
[ # # ]
1159 [ # # ]: 0 : "Possible incompatible geometry engines.\n");
1160 : 0 : return (Curve*) NULL;
1161 : : }
1162 : :
1163 [ # # ]: 0 : BRepAlgo_NormalProjection aProjection;
1164 [ # # ]: 0 : aProjection.Init(*face);
1165 [ # # ]: 0 : aProjection.Add(*edge);
1166 [ # # ]: 0 : aProjection.Build();
1167 [ # # ][ # # ]: 0 : if (!aProjection.IsDone())
1168 : : {
1169 [ # # ][ # # ]: 0 : PRINT_ERROR("Cannot project the curve to the surface.\n"
[ # # ]
1170 [ # # ]: 0 : "OCC engine failure.\n");
1171 : 0 : return (Curve*) NULL;
1172 : : }
1173 : :
1174 [ # # ][ # # ]: 0 : TopoDS_Shape new_shape = aProjection.Projection();//compound shape
[ # # ]
1175 : 0 : int num_projection = 0;
1176 [ # # ][ # # ]: 0 : if (new_shape.IsNull())
1177 : : {
1178 [ # # ][ # # ]: 0 : PRINT_ERROR("Cannot project the curve to the surface.\n");
[ # # ][ # # ]
1179 : 0 : return (Curve*) NULL;
1180 : : }
1181 : :
1182 : : else
1183 : : {
1184 : : //count how many free edges and vertices the new_shape has.
1185 [ # # ]: 0 : TopExp_Explorer Ex;
1186 [ # # ][ # # ]: 0 : for (Ex.Init(new_shape,TopAbs_EDGE); Ex.More(); Ex.Next())
[ # # ][ # # ]
1187 : 0 : num_projection++;
1188 [ # # ][ # # ]: 0 : for (Ex.Init(new_shape,TopAbs_VERTEX, TopAbs_EDGE); Ex.More(); Ex.Next())
[ # # ][ # # ]
1189 [ # # ]: 0 : num_projection++;
1190 : : }
1191 : :
1192 [ # # ]: 0 : if(num_projection == 0)
1193 : : {
1194 [ # # ][ # # ]: 0 : PRINT_INFO("No projection on the surface.\n");
[ # # ][ # # ]
1195 : 0 : return (Curve*) NULL;
1196 : : }
1197 : :
1198 [ # # ]: 0 : else if ( num_projection == 1 )
1199 : : {
1200 [ # # ]: 0 : if(closed == true)
1201 [ # # ][ # # ]: 0 : PRINT_WARNING("Cannot project the curve to create a closed projection.\n" "There is only one projection segment.\n");
[ # # ][ # # ]
1202 : :
1203 [ # # ]: 0 : TopExp_Explorer Ex;
1204 [ # # ][ # # ]: 0 : TopoDS_Edge new_edge;
1205 [ # # ][ # # ]: 0 : TopoDS_Vertex new_point;
1206 [ # # ][ # # ]: 0 : for (Ex.Init(new_shape,TopAbs_EDGE); Ex.More(); Ex.Next())
[ # # ]
1207 : : {
1208 [ # # ][ # # ]: 0 : new_edge = TopoDS::Edge(Ex.Current());
[ # # ]
1209 : : return OCCQueryEngine::instance()->populate_topology_bridge(new_edge,
1210 [ # # ][ # # ]: 0 : CUBIT_TRUE );
1211 : : }
1212 [ # # ][ # # ]: 0 : for(Ex.Init(new_shape,TopAbs_VERTEX);Ex.More(); Ex.Next())
[ # # ][ # # ]
1213 : : {
1214 [ # # ][ # # ]: 0 : new_point = TopoDS::Vertex(Ex.Current());
[ # # ]
1215 [ # # ][ # # ]: 0 : normal_proj_points.append(OCCQueryEngine::instance()->populate_topology_bridge(new_point, CUBIT_TRUE));
[ # # ]
1216 : : }
1217 [ # # ]: 0 : return (Curve*) NULL;
1218 : : }
1219 : :
1220 [ # # ]: 0 : else if (num_projection == 2)
1221 : : {
1222 : : double d;
1223 : : double first, last;
1224 [ # # ]: 0 : TopExp_Explorer Ex;
1225 [ # # ][ # # ]: 0 : TopoDS_Edge edge1, edge2;
[ # # ][ # # ]
[ # # ][ # # ]
1226 [ # # ][ # # ]: 0 : TopoDS_Vertex point;
[ # # ]
1227 : :
1228 : 0 : int count = 0;
1229 [ # # ][ # # ]: 0 : for (Ex.Init(new_shape,TopAbs_EDGE); Ex.More(); Ex.Next())
[ # # ][ # # ]
1230 : : {
1231 : 0 : count++;
1232 [ # # ]: 0 : if(count == 1)
1233 [ # # ][ # # ]: 0 : edge1 = TopoDS::Edge(Ex.Current());
[ # # ]
1234 [ # # ]: 0 : if(count == 2)
1235 [ # # ][ # # ]: 0 : edge2 = TopoDS::Edge(Ex.Current());
[ # # ]
1236 : : }
1237 : :
1238 [ # # ][ # # ]: 0 : for(Ex.Init(new_shape,TopAbs_VERTEX);Ex.More(); Ex.Next())
[ # # ][ # # ]
1239 : : {
1240 [ # # ][ # # ]: 0 : point = TopoDS::Vertex(Ex.Current());
[ # # ]
1241 [ # # ][ # # ]: 0 : normal_proj_points.append(OCCQueryEngine::instance()->populate_topology_bridge(point, CUBIT_TRUE));
[ # # ]
1242 : : }
1243 : :
1244 [ # # ][ # # ]: 0 : if(edge1.IsNull())
1245 [ # # ][ # # ]: 0 : return OCCQueryEngine::instance()->populate_topology_bridge(edge2, CUBIT_TRUE);
1246 : :
1247 [ # # ][ # # ]: 0 : if(edge2.IsNull())
1248 [ # # ][ # # ]: 0 : return OCCQueryEngine::instance()->populate_topology_bridge(edge1, CUBIT_TRUE);
1249 : :
1250 [ # # ][ # # ]: 0 : if(edge1.IsNull() && edge2.IsNull())
[ # # ][ # # ]
[ # # ]
1251 : 0 : return (Curve*) NULL;
1252 : :
1253 : : Handle(Geom_Curve) myCurve1 =
1254 [ # # ][ # # ]: 0 : BRep_Tool::Curve(edge1,first,last);
[ # # ]
1255 : :
1256 [ # # ][ # # ]: 0 : Handle(Geom_Curve) myCurve2= BRep_Tool::Curve(edge2, first, last);
[ # # ]
1257 : : //If the surface is periodic, so it has 2 projections, we just need to
1258 : : //find the segment to which the third_point is closer.
1259 [ # # ][ # # ]: 0 : if(closed == CUBIT_FALSE && third_point != NULL)
1260 : : {
1261 [ # # ][ # # ]: 0 : gp_Pnt P (third_point->x(), third_point->y(), third_point->z());
[ # # ][ # # ]
1262 [ # # ]: 0 : GeomAPI_ProjectPointOnCurve projOncurve(P, myCurve1);
1263 [ # # ][ # # ]: 0 : if (projOncurve.NbPoints() == 0)
1264 : : {
1265 [ # # ][ # # ]: 0 : PRINT_ERROR("Cannot project the curve to the surface.\n"
[ # # ]
1266 [ # # ]: 0 : "OCC engine failure.\n");
1267 : 0 : return (Curve*) NULL;
1268 : : }
1269 [ # # ]: 0 : d = projOncurve.LowerDistance();
1270 : :
1271 : : //Compare with the second solution
1272 [ # # ][ # # ]: 0 : GeomAPI_ProjectPointOnCurve projOncurve2(P, myCurve2);
1273 [ # # ][ # # ]: 0 : if (projOncurve2.NbPoints() == 0)
1274 : : {
1275 [ # # ][ # # ]: 0 : PRINT_ERROR("Cannot project the curve to the surface.\n"
[ # # ]
1276 [ # # ]: 0 : "OCC engine failure.\n");
1277 : 0 : return (Curve*) NULL;
1278 : : }
1279 : :
1280 [ # # ]: 0 : double d2 = projOncurve2.LowerDistance();
1281 : : TopoDS_Edge new_edge =
1282 [ # # ][ # # ]: 0 : d > d2 ? edge2 : edge1 ;
[ # # ]
1283 [ # # ][ # # ]: 0 : return OCCQueryEngine::instance()->populate_topology_bridge(new_edge, CUBIT_TRUE);
[ # # ]
1284 : : }
1285 : :
1286 : :
1287 [ # # ]: 0 : else if (closed == CUBIT_TRUE)
1288 : : {
1289 : : //connect the two segment into a closed shape. Assume both segment
1290 : : // has the same curve type, create Bezier closed curve.
1291 [ # # ]: 0 : GeomAdaptor_Curve acurve1(myCurve1);
1292 [ # # ][ # # ]: 0 : GeomAdaptor_Curve acurve2(myCurve2);
1293 : : //get 10 points of each curve, combine them to make one Bezier curve
1294 : 0 : int NbPoints = 10;
1295 [ # # ][ # # ]: 0 : GCPnts_QuasiUniformAbscissa distribution1(acurve1, NbPoints);
1296 [ # # ][ # # ]: 0 : GCPnts_QuasiUniformAbscissa distribution2(acurve2, NbPoints);
1297 [ # # ][ # # ]: 0 : TColgp_Array1OfPnt points(1, 2*NbPoints-1);
1298 : : int i;
1299 [ # # ]: 0 : for (i = 1; i <= NbPoints; i++)
1300 : : {
1301 [ # # ]: 0 : double u = distribution1.Parameter(i);
1302 [ # # ][ # # ]: 0 : gp_Pnt P = myCurve1->Value(u);
1303 [ # # ]: 0 : points.SetValue(i, P);
1304 : : }
1305 : :
1306 [ # # ]: 0 : for (int j = NbPoints-1; j >= 1; j--)
1307 : : {
1308 [ # # ]: 0 : double u = distribution2.Parameter(j);
1309 [ # # ][ # # ]: 0 : gp_Pnt P = myCurve2->Value(u);
1310 [ # # ]: 0 : points.SetValue(++i,P);
1311 : : }
1312 : :
1313 [ # # ][ # # ]: 0 : Geom_BezierCurve BezierCurve(points);
1314 [ # # ][ # # ]: 0 : Handle(Geom_Curve) curve_ptr(&BezierCurve);
1315 [ # # ][ # # ]: 0 : TopoDS_Edge new_edge = BRepBuilderAPI_MakeEdge(curve_ptr);
[ # # ][ # # ]
1316 [ # # ][ # # ]: 0 : return OCCQueryEngine::instance()->populate_topology_bridge(new_edge);
[ # # ][ # # ]
[ # # ]
1317 : 0 : }
1318 : : }
1319 [ # # ]: 0 : return (Curve*) NULL;
1320 : : }
1321 : 0 : CubitStatus OCCCurve::get_spline_params( bool &rational,
1322 : : int °ree,
1323 : : DLIList<CubitVector> &cntrl_pts,
1324 : : DLIList<double> &cntrl_pt_weights,
1325 : : DLIList<double> &knots, // There should be order+cntrl_pts.size()-2 knots
1326 : : bool &spline_is_reversed
1327 : : ) const
1328 : : {
1329 : 0 : return CUBIT_FAILURE;
1330 [ + - ][ + - ]: 6364 : }
1331 : :
1332 : : // ********** END PRIVATE FUNCTIONS **********
1333 : :
1334 : : // ********** BEGIN HELPER CLASSES **********
1335 : : // ********** END HELPER CLASSES **********
1336 : :
1337 : : // ********** BEGIN EXTERN FUNCTIONS **********
1338 : : // ********** END EXTERN FUNCTIONS **********
1339 : :
1340 : : // ********** BEGIN STATIC FUNCTIONS **********
1341 : : // ********** END STATIC FUNCTIONS **********
|
