Commit | Line | Data |
---|---|---|
b311480e | 1 | // Created on: 1999-09-21 |
2 | // Created by: Edward AGAPOV | |
3 | // Copyright (c) 1999-1999 Matra Datavision | |
973c2be1 | 4 | // Copyright (c) 1999-2014 OPEN CASCADE SAS |
b311480e | 5 | // |
973c2be1 | 6 | // This file is part of Open CASCADE Technology software library. |
b311480e | 7 | // |
d5f74e42 | 8 | // This library is free software; you can redistribute it and/or modify it under |
9 | // the terms of the GNU Lesser General Public License version 2.1 as published | |
973c2be1 | 10 | // by the Free Software Foundation, with special exception defined in the file |
11 | // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT | |
12 | // distribution for complete text of the license and disclaimer of any warranty. | |
b311480e | 13 | // |
973c2be1 | 14 | // Alternatively, this file may be used under the terms of Open CASCADE |
15 | // commercial license or contractual agreement. | |
7fd59977 | 16 | |
42cf5bc1 | 17 | |
7fd59977 | 18 | #include <Adaptor3d_HCurve.hxx> |
6b84c3f7 | 19 | #include <GeomAdaptor_HSurfaceOfRevolution.hxx> |
42cf5bc1 | 20 | #include <ElCLib.hxx> |
7fd59977 | 21 | #include <Extrema_ExtPElC.hxx> |
42cf5bc1 | 22 | #include <Extrema_ExtPRevS.hxx> |
7fd59977 | 23 | #include <Extrema_GenExtPS.hxx> |
24 | #include <Extrema_POnCurv.hxx> | |
25 | #include <Extrema_POnSurf.hxx> | |
26 | #include <gp_Ax1.hxx> | |
27 | #include <gp_Ax2.hxx> | |
28 | #include <gp_Lin.hxx> | |
29 | #include <gp_Pln.hxx> | |
30 | #include <gp_Pnt.hxx> | |
31 | #include <gp_Trsf.hxx> | |
32 | #include <gp_Vec.hxx> | |
33 | #include <Precision.hxx> | |
42cf5bc1 | 34 | #include <Standard_OutOfRange.hxx> |
35 | #include <Standard_Type.hxx> | |
36 | #include <StdFail_NotDone.hxx> | |
7fd59977 | 37 | |
92efcf78 | 38 | IMPLEMENT_STANDARD_RTTIEXT(Extrema_ExtPRevS,Standard_Transient) |
39 | ||
6b84c3f7 | 40 | static gp_Ax2 GetPosition (const GeomAdaptor_SurfaceOfRevolution& S)//const Handle(Adaptor_HCurve)& C) |
7fd59977 | 41 | { |
42 | Handle(Adaptor3d_HCurve) C = S.BasisCurve(); | |
43 | ||
44 | switch (C->GetType()) { | |
45 | ||
46 | case GeomAbs_Line: { | |
47 | gp_Lin L = C->Line(); | |
48 | gp_Dir N = S.AxeOfRevolution().Direction(); | |
49 | if (N.IsParallel(L.Direction(), Precision::Angular())) { | |
50 | gp_Vec OO (L.Location(), S.AxeOfRevolution().Location()); | |
51 | if (OO.Magnitude() <= gp::Resolution()) { | |
52 | OO = gp_Vec(L.Location(), ElCLib::Value(100,L)); | |
53 | if (N.IsParallel(OO, Precision::Angular())) | |
54 | return gp_Ax2(); // Line and axe of revolution coinside | |
55 | } | |
56 | N ^= OO; | |
57 | } | |
58 | else { | |
59 | N ^= L.Direction(); | |
60 | } | |
61 | return gp_Ax2 (L.Location(), N, L.Direction()); | |
62 | } | |
63 | case GeomAbs_Circle: | |
64 | return C->Circle().Position(); | |
65 | case GeomAbs_Ellipse: | |
66 | return C->Ellipse().Position(); | |
67 | case GeomAbs_Hyperbola: | |
68 | return C->Hyperbola().Position(); | |
69 | case GeomAbs_Parabola: | |
70 | return C->Parabola().Position(); | |
71 | default: | |
72 | return gp_Ax2(); | |
73 | } | |
74 | } | |
75 | ||
76 | //======================================================================= | |
77 | //function : HasSingularity | |
78 | //purpose : | |
79 | //======================================================================= | |
80 | ||
6b84c3f7 | 81 | static Standard_Boolean HasSingularity(const GeomAdaptor_SurfaceOfRevolution& S) |
7fd59977 | 82 | { |
83 | ||
84 | const Handle(Adaptor3d_HCurve) C = S.BasisCurve(); | |
85 | gp_Dir N = S.AxeOfRevolution().Direction(); | |
86 | gp_Pnt P = S.AxeOfRevolution().Location(); | |
87 | ||
88 | gp_Lin L(P, N); | |
89 | ||
90 | P = C->Value(C->FirstParameter()); | |
91 | ||
08cd2f6b | 92 | if(L.SquareDistance(P) < Precision::SquareConfusion()) return Standard_True; |
7fd59977 | 93 | |
94 | P = C->Value(C->LastParameter()); | |
95 | ||
08cd2f6b | 96 | if(L.SquareDistance(P) < Precision::SquareConfusion()) return Standard_True; |
7fd59977 | 97 | |
98 | return Standard_False; | |
99 | } | |
100 | ||
101 | //============================================================================= | |
102 | ||
103 | static void PerformExtPElC (Extrema_ExtPElC& E, | |
104 | const gp_Pnt& P, | |
105 | const Handle(Adaptor3d_HCurve)& C, | |
106 | const Standard_Real Tol) | |
107 | { | |
108 | switch (C->GetType()) { | |
109 | case GeomAbs_Hyperbola: | |
110 | E.Perform(P, C->Hyperbola(), Tol, -Precision::Infinite(),Precision::Infinite()); | |
111 | return; | |
112 | case GeomAbs_Line: | |
113 | E.Perform(P, C->Line(), Tol, -Precision::Infinite(),Precision::Infinite()); | |
114 | return; | |
115 | case GeomAbs_Circle: | |
c6541a0c | 116 | E.Perform(P, C->Circle(), Tol, 0.0, 2.0 * M_PI); |
7fd59977 | 117 | return; |
118 | case GeomAbs_Ellipse: | |
c6541a0c | 119 | E.Perform(P, C->Ellipse(), Tol, 0.0, 2.0 * M_PI); |
7fd59977 | 120 | return; |
121 | case GeomAbs_Parabola: | |
122 | E.Perform(P, C->Parabola(), Tol, -Precision::Infinite(),Precision::Infinite()); | |
123 | return; | |
7fd59977 | 124 | default: |
125 | return ; | |
7fd59977 | 126 | } |
127 | } | |
128 | ||
129 | //======================================================================= | |
130 | //function : IsCaseAnalyticallyComputable | |
131 | //purpose : | |
132 | //======================================================================= | |
133 | ||
134 | static Standard_Boolean IsCaseAnalyticallyComputable | |
135 | (const GeomAbs_CurveType& theType, | |
136 | const gp_Ax2& theCurvePos, | |
137 | const gp_Ax1& AxeOfRevolution) | |
138 | { | |
139 | // check type | |
140 | switch (theType) { | |
141 | case GeomAbs_Line: | |
142 | case GeomAbs_Circle: | |
143 | case GeomAbs_Ellipse: | |
144 | case GeomAbs_Hyperbola: | |
145 | case GeomAbs_Parabola: | |
146 | break; | |
147 | default: | |
148 | return Standard_False; | |
149 | } | |
150 | // the axe of revolution must be in the plane of the curve. | |
151 | gp_Pln pl(theCurvePos.Location(), theCurvePos.Direction()); | |
152 | gp_Pnt p1 = AxeOfRevolution.Location(); | |
153 | Standard_Real dist = 100., dist2 = dist * dist; | |
154 | Standard_Real aThreshold = Precision::Angular() * Precision::Angular() * dist2; | |
155 | gp_Pnt p2 = AxeOfRevolution.Location().XYZ() + dist * AxeOfRevolution.Direction().XYZ(); | |
156 | ||
157 | if((pl.SquareDistance(p1) < aThreshold) && | |
158 | (pl.SquareDistance(p2) < aThreshold)) | |
159 | return Standard_True; | |
160 | return Standard_False; | |
161 | // gp_Vec V (AxeOfRevolution.Location(),theCurvePos.Location()); | |
162 | // if (Abs( V * theCurvePos.Direction()) <= gp::Resolution()) | |
163 | // return Standard_True; | |
164 | // else | |
165 | // return Standard_False; | |
166 | } | |
167 | ||
168 | //======================================================================= | |
169 | //function : IsOriginalPnt | |
170 | //purpose : | |
171 | //======================================================================= | |
172 | ||
173 | static Standard_Boolean IsOriginalPnt (const gp_Pnt& P, | |
174 | const Extrema_POnSurf* Points, | |
175 | const Standard_Integer NbPoints) | |
176 | { | |
177 | for (Standard_Integer i=1; i<=NbPoints; i++) { | |
6f94f1df | 178 | if (Points[i-1].Value().IsEqual(P, Precision::Confusion())) { |
7fd59977 | 179 | return Standard_False; |
180 | } | |
181 | } | |
182 | return Standard_True; | |
183 | } | |
184 | //======================================================================= | |
185 | //function : IsExtremum | |
186 | //purpose : | |
187 | //======================================================================= | |
188 | ||
189 | static Standard_Boolean IsExtremum (const Standard_Real U, const Standard_Real V, | |
190 | const gp_Pnt& P, const Adaptor3d_SurfacePtr& S, | |
191 | gp_Pnt& E, Standard_Real& Dist2, | |
192 | const Standard_Boolean IsVSup, | |
193 | const Standard_Boolean IsMin) | |
194 | { | |
195 | E = S->Value(U,V); | |
196 | Dist2 = P.SquareDistance(E); | |
197 | if (IsMin) | |
198 | return (Dist2 < P.SquareDistance(S->Value(U+1,V)) && | |
199 | Dist2 < P.SquareDistance(S->Value(U-1,V)) && | |
200 | Dist2 < P.SquareDistance(S->Value(U, IsVSup ? V-1 : V+1))); | |
201 | else | |
202 | return (Dist2 > P.SquareDistance(S->Value(U+1,V)) && | |
203 | Dist2 > P.SquareDistance(S->Value(U-1,V)) && | |
204 | Dist2 > P.SquareDistance(S->Value(U, IsVSup ? V-1 : V+1))); | |
205 | } | |
206 | //======================================================================= | |
207 | //function : Extrema_ExtPRevS | |
208 | //purpose : | |
209 | //======================================================================= | |
210 | ||
211 | Extrema_ExtPRevS::Extrema_ExtPRevS() | |
212 | { | |
7fd59977 | 213 | myDone = Standard_False; |
214 | } | |
215 | //======================================================================= | |
216 | //function : Extrema_ExtPRevS | |
217 | //purpose : | |
218 | //======================================================================= | |
219 | ||
0734c53d | 220 | Extrema_ExtPRevS::Extrema_ExtPRevS (const gp_Pnt& theP, |
6b84c3f7 | 221 | const Handle(GeomAdaptor_HSurfaceOfRevolution)& theS, |
0734c53d | 222 | const Standard_Real theUmin, |
223 | const Standard_Real theUsup, | |
224 | const Standard_Real theVmin, | |
225 | const Standard_Real theVsup, | |
226 | const Standard_Real theTolU, | |
227 | const Standard_Real theTolV) | |
7fd59977 | 228 | { |
0734c53d | 229 | Initialize (theS, |
230 | theUmin, | |
231 | theUsup, | |
232 | theVmin, | |
233 | theVsup, | |
234 | theTolU, | |
235 | theTolV); | |
236 | ||
237 | Perform (theP); | |
7fd59977 | 238 | } |
239 | //======================================================================= | |
240 | //function : Extrema_ExtPRevS | |
241 | //purpose : | |
242 | //======================================================================= | |
243 | ||
0734c53d | 244 | Extrema_ExtPRevS::Extrema_ExtPRevS (const gp_Pnt& theP, |
6b84c3f7 | 245 | const Handle(GeomAdaptor_HSurfaceOfRevolution)& theS, |
0734c53d | 246 | const Standard_Real theTolU, |
247 | const Standard_Real theTolV) | |
7fd59977 | 248 | { |
0734c53d | 249 | Initialize (theS, |
250 | theS->FirstUParameter(), | |
251 | theS->LastUParameter(), | |
252 | theS->FirstVParameter(), | |
253 | theS->LastVParameter(), | |
254 | theTolU, | |
255 | theTolV); | |
256 | ||
257 | Perform (theP); | |
7fd59977 | 258 | } |
259 | //======================================================================= | |
260 | //function : Initialize | |
261 | //purpose : | |
262 | //======================================================================= | |
263 | ||
6b84c3f7 | 264 | void Extrema_ExtPRevS::Initialize (const Handle(GeomAdaptor_HSurfaceOfRevolution)& theS, |
0734c53d | 265 | const Standard_Real theUmin, |
266 | const Standard_Real theUsup, | |
267 | const Standard_Real theVmin, | |
268 | const Standard_Real theVsup, | |
269 | const Standard_Real theTolU, | |
270 | const Standard_Real theTolV) | |
7fd59977 | 271 | { |
0734c53d | 272 | myvinf = theVmin; |
273 | myvsup = theVsup; | |
274 | mytolv = theTolV; | |
275 | ||
276 | Handle(Adaptor3d_HCurve) anACurve = theS->BasisCurve(); | |
277 | ||
278 | if (myS != theS) | |
279 | { | |
280 | myS = theS; | |
281 | myPosition = GetPosition (theS->ChangeSurface()); | |
7fd59977 | 282 | myIsAnalyticallyComputable = |
0734c53d | 283 | IsCaseAnalyticallyComputable (anACurve->GetType(), myPosition, theS->AxeOfRevolution()); |
7fd59977 | 284 | } |
7fd59977 | 285 | |
0734c53d | 286 | if (!myIsAnalyticallyComputable) |
287 | { | |
288 | Standard_Integer aNbu = 32, aNbv = 32; | |
289 | ||
290 | if (HasSingularity (theS->ChangeSurface())) | |
291 | { | |
292 | aNbv = 100; | |
293 | } | |
7fd59977 | 294 | |
0734c53d | 295 | myExtPS.Initialize (theS->ChangeSurface(), |
296 | aNbu, | |
297 | aNbv, | |
298 | theUmin, | |
299 | theUsup, | |
300 | theVmin, | |
301 | theVsup, | |
302 | theTolU, | |
303 | theTolV); | |
7fd59977 | 304 | } |
305 | } | |
306 | //======================================================================= | |
307 | //function : Perform | |
308 | //purpose : | |
309 | //======================================================================= | |
310 | ||
311 | void Extrema_ExtPRevS::Perform(const gp_Pnt& P) | |
312 | { | |
313 | myDone = Standard_False; | |
314 | myNbExt = 0; | |
315 | ||
316 | if (!myIsAnalyticallyComputable) { | |
317 | ||
318 | myExtPS.Perform(P); | |
319 | myDone = myExtPS.IsDone(); | |
320 | myNbExt = myExtPS.NbExt(); | |
321 | return; | |
322 | } | |
323 | ||
324 | Handle(Adaptor3d_HCurve) anACurve = myS->BasisCurve(); | |
325 | ||
326 | gp_Ax1 Ax = myS->AxeOfRevolution(); | |
327 | gp_Vec Dir = Ax.Direction(), Z = myPosition.Direction(); | |
328 | gp_Pnt O = Ax.Location(); | |
329 | ||
330 | Standard_Real OPdir = gp_Vec(O,P).Dot(Dir); | |
331 | gp_Pnt Pp = P.Translated(Dir.Multiplied(-OPdir)); | |
332 | if (O.IsEqual(Pp,Precision::Confusion())) // P is on the AxeOfRevolution | |
333 | return; | |
334 | ||
335 | Standard_Real U,V; | |
336 | gp_Pnt P1, Ppp; | |
337 | Standard_Real OPpz = gp_Vec(O,Pp).Dot(Z); | |
338 | if (Abs(OPpz) <= gp::Resolution()) { | |
339 | Ppp = Pp; | |
340 | U = 0; | |
341 | } | |
342 | else { | |
343 | Ppp = Pp.Translated(Z.Multiplied(-OPpz)); | |
344 | if (O.IsEqual(Ppp,Precision::Confusion())) | |
c6541a0c | 345 | U = M_PI/2; |
7fd59977 | 346 | else { |
347 | U = gp_Vec(O,Ppp).AngleWithRef(gp_Vec(O,Pp),Dir); | |
348 | } | |
349 | } | |
350 | ||
c6541a0c D |
351 | gp_Vec OPpp (O,Ppp), OPq (O, myS->Value(M_PI/2,0)); |
352 | if (U != M_PI/2) { | |
7fd59977 | 353 | if (Abs(OPq.Magnitude()) <= gp::Resolution()) |
c6541a0c | 354 | OPq = gp_Vec(O, myS->Value(M_PI/2,anACurve->LastParameter()/10)); |
7fd59977 | 355 | if (OPpp.AngleWithRef(OPq,Dir) < 0) |
c6541a0c | 356 | U += M_PI; |
7fd59977 | 357 | } |
358 | ||
359 | gp_Trsf T; | |
360 | T.SetRotation(Ax, -U); | |
361 | P1 = P.Transformed(T); | |
362 | ||
363 | gp_Pnt E; | |
364 | Standard_Real Dist2; | |
365 | Standard_Integer i; | |
366 | ||
367 | Extrema_ExtPElC anExt; | |
368 | PerformExtPElC(anExt, P1, anACurve, mytolv); | |
369 | ||
370 | if (anExt.IsDone()) { | |
371 | myDone = Standard_True; | |
372 | for (i=1; i<=anExt.NbExt(); i++) { | |
373 | Extrema_POnCurv POC=anExt.Point(i); | |
374 | V = POC.Parameter(); | |
375 | if (V > myvsup) { | |
376 | // if ( !IsExtremum (U, V = myvsup, P, myS, E, Dist2, | |
377 | // Standard_True, anExt.IsMin(i))) continue; | |
378 | Standard_Real newV = myvsup; | |
379 | ||
380 | if((anACurve->GetType() == GeomAbs_Circle) || | |
381 | (anACurve->GetType() == GeomAbs_Ellipse)) { | |
c6541a0c | 382 | newV = ElCLib::InPeriod(V, myvinf, myvinf + 2. * M_PI); |
7fd59977 | 383 | |
384 | if (newV > myvsup) { | |
a20400b3 | 385 | newV -= 2. * M_PI; |
386 | ||
387 | if (newV + mytolv < myvinf) { | |
388 | newV = myvsup; | |
389 | } else if (newV < myvinf) { | |
390 | newV = myvinf; | |
391 | } | |
7fd59977 | 392 | } |
393 | } | |
394 | V = newV; | |
395 | ||
0734c53d | 396 | if ( !IsExtremum (U, V, P, &(myS->ChangeSurface()), E, Dist2, |
7fd59977 | 397 | Standard_True, anExt.IsMin(i))) { |
398 | continue; | |
399 | } | |
400 | } else if (V < myvinf) { | |
401 | // if ( !IsExtremum (U, V = myvinf, P, myS, E, Dist2, | |
402 | // Standard_False, anExt.IsMin(i))) continue; | |
403 | ||
404 | Standard_Real newV = myvinf; | |
405 | ||
406 | if((anACurve->GetType() == GeomAbs_Circle) || | |
407 | (anACurve->GetType() == GeomAbs_Ellipse)) { | |
c6541a0c | 408 | newV = ElCLib::InPeriod(V, myvsup - 2. * M_PI, myvsup); |
7fd59977 | 409 | |
a20400b3 | 410 | if(newV < myvinf) { |
411 | newV += 2. * M_PI; | |
412 | ||
413 | if (newV - mytolv > myvsup) { | |
414 | newV = myvinf; | |
415 | } else if (newV > myvsup) { | |
416 | newV = myvsup; | |
417 | } | |
418 | } | |
7fd59977 | 419 | } |
420 | V = newV; | |
421 | ||
0734c53d | 422 | if ( !IsExtremum (U, V, P, &(myS->ChangeSurface()), E, Dist2, |
7fd59977 | 423 | Standard_False, anExt.IsMin(i))) continue; |
424 | } else { | |
425 | E = myS->Value(U,V); | |
426 | Dist2 = P.SquareDistance(E); | |
427 | } | |
428 | if (IsOriginalPnt(E, myPoint, myNbExt)) { | |
6f94f1df | 429 | myPoint[myNbExt] = Extrema_POnSurf(U,V,E); |
7fd59977 | 430 | mySqDist[myNbExt] = Dist2; |
6f94f1df | 431 | myNbExt++; |
7fd59977 | 432 | } |
433 | } | |
434 | } | |
c6541a0c | 435 | T.SetRotation(Ax, M_PI); |
7fd59977 | 436 | P1.Transform(T); |
437 | ||
438 | PerformExtPElC(anExt, P1, anACurve, mytolv); | |
439 | if (anExt.IsDone()) { | |
440 | myDone = Standard_True; | |
441 | ||
c6541a0c | 442 | U += M_PI; |
7fd59977 | 443 | |
444 | for (i=1; i<=anExt.NbExt(); i++) { | |
445 | Extrema_POnCurv POC=anExt.Point(i); | |
446 | V = POC.Parameter(); | |
447 | if (V > myvsup) { | |
448 | // if ( !IsExtremum (U, V = myvsup, P, myS, E, Dist2, | |
449 | // Standard_True, anExt.IsMin(i))) continue; | |
450 | ||
451 | Standard_Real newV = myvsup; | |
452 | ||
453 | if((anACurve->GetType() == GeomAbs_Circle) || | |
454 | (anACurve->GetType() == GeomAbs_Ellipse)) { | |
c6541a0c | 455 | newV = ElCLib::InPeriod(V, myvinf, myvinf + 2. * M_PI); |
7fd59977 | 456 | |
457 | if (newV > myvsup) { | |
a20400b3 | 458 | newV -= 2. * M_PI; |
459 | ||
460 | if (newV + mytolv < myvinf) { | |
461 | newV = myvsup; | |
462 | } else if (newV < myvinf) { | |
463 | newV = myvinf; | |
464 | } | |
7fd59977 | 465 | } |
466 | } | |
467 | V = newV; | |
468 | ||
0734c53d | 469 | if ( !IsExtremum (U, V, P, &(myS->ChangeSurface()), E, Dist2, |
7fd59977 | 470 | Standard_True, anExt.IsMin(i))) continue; |
471 | } else if (V < myvinf) { | |
472 | // if ( !IsExtremum (U, V = myvinf, P, myS, E, Dist2, | |
473 | // Standard_False, anExt.IsMin(i))) continue; | |
474 | Standard_Real newV = myvinf; | |
475 | ||
476 | if((anACurve->GetType() == GeomAbs_Circle) || | |
477 | (anACurve->GetType() == GeomAbs_Ellipse)) { | |
c6541a0c | 478 | newV = ElCLib::InPeriod(V, myvsup - 2. * M_PI, myvsup); |
7fd59977 | 479 | |
a20400b3 | 480 | if(newV < myvinf) { |
481 | newV += 2. * M_PI; | |
482 | ||
483 | if (newV - mytolv > myvsup) { | |
484 | newV = myvinf; | |
485 | } else if (newV > myvsup) { | |
486 | newV = myvsup; | |
487 | } | |
488 | } | |
7fd59977 | 489 | } |
490 | V = newV; | |
491 | ||
0734c53d | 492 | if ( !IsExtremum (U, V, P, &(myS->ChangeSurface()), E, Dist2, |
7fd59977 | 493 | Standard_False, anExt.IsMin(i))) continue; |
494 | } else { | |
495 | E = myS->Value(U,V); | |
496 | Dist2 = P.SquareDistance(E); | |
497 | } | |
498 | if (IsOriginalPnt(E, myPoint, myNbExt)) { | |
6f94f1df | 499 | myPoint[myNbExt] = Extrema_POnSurf(U,V,E); |
7fd59977 | 500 | mySqDist[myNbExt] = Dist2; |
6f94f1df | 501 | myNbExt++; |
7fd59977 | 502 | } |
503 | } | |
504 | } | |
505 | } | |
506 | ||
507 | ||
508 | //======================================================================= | |
509 | //function : IsDone | |
510 | //purpose : | |
511 | //======================================================================= | |
512 | ||
513 | Standard_Boolean Extrema_ExtPRevS::IsDone() const | |
514 | { | |
515 | return myDone; | |
516 | } | |
517 | ||
518 | ||
519 | //======================================================================= | |
520 | //function : NbExt | |
521 | //purpose : | |
522 | //======================================================================= | |
523 | ||
524 | Standard_Integer Extrema_ExtPRevS::NbExt() const | |
525 | { | |
526 | if (!IsDone()) { StdFail_NotDone::Raise(); } | |
527 | return myNbExt; | |
528 | } | |
529 | ||
530 | ||
531 | //======================================================================= | |
532 | //function : Value | |
533 | //purpose : | |
534 | //======================================================================= | |
535 | ||
536 | Standard_Real Extrema_ExtPRevS::SquareDistance(const Standard_Integer N) const | |
537 | { | |
538 | if (!IsDone()) { StdFail_NotDone::Raise(); } | |
539 | if ((N < 1) || (N > myNbExt)) { Standard_OutOfRange::Raise(); } | |
540 | if (myIsAnalyticallyComputable) | |
6f94f1df | 541 | return mySqDist[N-1]; |
7fd59977 | 542 | else |
543 | return myExtPS.SquareDistance(N); | |
544 | } | |
545 | //======================================================================= | |
546 | //function : Point | |
547 | //purpose : | |
548 | //======================================================================= | |
549 | ||
5d99f2c8 | 550 | const Extrema_POnSurf& Extrema_ExtPRevS::Point(const Standard_Integer N) const |
7fd59977 | 551 | { |
552 | if (!IsDone()) { StdFail_NotDone::Raise(); } | |
553 | if ((N < 1) || (N > myNbExt)) { Standard_OutOfRange::Raise(); } | |
554 | if (myIsAnalyticallyComputable) | |
6f94f1df | 555 | return myPoint[N-1]; |
7fd59977 | 556 | else |
557 | return myExtPS.Point(N); | |
558 | } | |
559 | ||
560 |