cf145c2855a6e6d0dbdaf1195ac761454834031d
[occt.git] / src / Extrema / Extrema_ExtCC2d.cxx
1 // Created on: 1994-07-06
2 // Created by: Laurent PAINNOT
3 // Copyright (c) 1994-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
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
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.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17
18 #include <Adaptor2d_Curve2d.hxx>
19 #include <ElCLib.hxx>
20 #include <Extrema_Curve2dTool.hxx>
21 #include <Extrema_ECC2d.hxx>
22 #include <Extrema_ExtCC2d.hxx>
23 #include <Extrema_ExtElC.hxx>
24 #include <Extrema_ExtElC2d.hxx>
25 #include <Extrema_POnCurv2d.hxx>
26 #include <Extrema_SequenceOfPOnCurv2d.hxx>
27 #include <Geom2d_Circle.hxx>
28 #include <Geom2d_Curve.hxx>
29 #include <Geom2d_Ellipse.hxx>
30 #include <Geom2d_Hyperbola.hxx>
31 #include <Geom2d_Line.hxx>
32 #include <Geom2d_Parabola.hxx>
33 #include <Geom2d_TrimmedCurve.hxx>
34 #include <GeomAbs_CurveType.hxx>
35 #include <gp_Pnt2d.hxx>
36 #include <Precision.hxx>
37 #include <Standard_Failure.hxx>
38 #include <Standard_NotImplemented.hxx>
39 #include <Standard_OutOfRange.hxx>
40 #include <StdFail_InfiniteSolutions.hxx>
41 #include <StdFail_NotDone.hxx>
42
43 Extrema_ExtCC2d::Extrema_ExtCC2d()
44 {
45 }
46
47
48 Extrema_ExtCC2d::Extrema_ExtCC2d(const Adaptor2d_Curve2d&       C1, 
49                                    const Adaptor2d_Curve2d&       C2,
50                                    const Standard_Real TolC1, 
51                                    const Standard_Real TolC2)
52 {
53   Initialize(C2, Extrema_Curve2dTool::FirstParameter(C2), Extrema_Curve2dTool::LastParameter(C2), TolC1, TolC2);
54   Perform(C1, Extrema_Curve2dTool::FirstParameter(C1), Extrema_Curve2dTool::LastParameter(C1));
55 }
56
57 Extrema_ExtCC2d::Extrema_ExtCC2d(const Adaptor2d_Curve2d&        C1, 
58                                    const Adaptor2d_Curve2d&        C2,
59                                    const Standard_Real  U1,
60                                    const Standard_Real  U2,
61                                    const Standard_Real  V1,
62                                    const Standard_Real  V2,
63                                    const Standard_Real  TolC1,
64                                    const Standard_Real  TolC2)
65 {
66   Initialize(C2, V1, V2, TolC1, TolC2);
67   Perform(C1, U1, U2);
68 }
69
70
71
72 void Extrema_ExtCC2d::Initialize(const Adaptor2d_Curve2d&        C2,
73                                   const Standard_Real  V1,
74                                   const Standard_Real  V2,
75                                   const Standard_Real  TolC1,
76                                   const Standard_Real  TolC2)
77 {
78   myC = (Standard_Address)&C2;
79   myv1 = V1;
80   myv2 = V2;
81   mytolc1 = TolC1;
82   mytolc2 = TolC2;
83 }
84
85
86
87 void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d&       C1,
88                                 const Standard_Real U1,
89                                 const Standard_Real U2)
90 {
91   mypoints.Clear();
92   mySqDist.Clear();
93   GeomAbs_CurveType type1 = Extrema_Curve2dTool::GetType(C1), type2 = Extrema_Curve2dTool::GetType(*((Adaptor2d_Curve2d*)myC));
94   Standard_Real U11, U12, U21, U22, Tol = Min(mytolc1, mytolc2);
95 //  Extrema_POnCurv2d P1, P2;
96   mynbext = 0;
97   inverse = Standard_False;
98   myIsPar = Standard_False;
99
100   U11 = U1;
101   U12 = U2;
102   U21 = myv1;
103   U22 = myv2;
104   P1f = Extrema_Curve2dTool::Value(C1, U11);
105   P1l = Extrema_Curve2dTool::Value(C1, U12);
106   P2f = Extrema_Curve2dTool::Value(*((Adaptor2d_Curve2d*)myC), U21);
107   P2l = Extrema_Curve2dTool::Value(*((Adaptor2d_Curve2d*)myC), U22);
108
109
110   switch(type1) {
111     //
112     //  La premiere courbe est un cercle:
113     //
114   case GeomAbs_Circle: {
115
116     switch(type2) {
117       case GeomAbs_Circle: {
118         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Circle(*((Adaptor2d_Curve2d*)myC)));
119         Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 2*M_PI);
120         }
121         break;
122       case GeomAbs_Ellipse: {
123         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Ellipse(*((Adaptor2d_Curve2d*)myC)));
124         Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 2*M_PI );
125         }
126         break;
127       case GeomAbs_Parabola: {
128         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Parabola(*((Adaptor2d_Curve2d*)myC)));
129         Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0.);
130       }
131         break;
132       case GeomAbs_Hyperbola: {
133         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Hyperbola(*((Adaptor2d_Curve2d*)myC)));
134         Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0. );
135       }
136         break;
137       case GeomAbs_BezierCurve:
138       case GeomAbs_OtherCurve:
139       case GeomAbs_BSplineCurve: {
140         Extrema_ECC2d Xtrem(C1, *((Adaptor2d_Curve2d*)myC));
141                         Xtrem.Perform();
142         Standard_Real Period2 = 0.;
143         if (Extrema_Curve2dTool::IsPeriodic(*((Adaptor2d_Curve2d*)myC))) Period2 = Extrema_Curve2dTool::Period(*((Adaptor2d_Curve2d*)myC));
144         Results(Xtrem, U11, U12, U21, U22, 2*M_PI,Period2);
145         }
146         break;
147       case GeomAbs_Line: {
148         inverse = Standard_True;
149         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Circle(C1), Tol);
150         Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0.);
151         }
152         break;
153       };  // switch(type2)
154     }
155     break;
156
157     //
158     // La premiere courbe est une ellipse:
159     //
160   case GeomAbs_Ellipse: {
161
162     switch(type2) {
163       case GeomAbs_Circle: {
164         inverse = Standard_True;
165         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Ellipse(C1));
166         Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 2*M_PI);
167         }
168         break;
169       case GeomAbs_Ellipse: {
170         //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(C1), Extrema_Curve2dTool::Ellipse(*((Adaptor2d_Curve2d*)myC)));
171         Extrema_ECC2d Xtrem(C1, *((Adaptor2d_Curve2d*)myC));
172                         Xtrem.Perform();
173         Results(Xtrem, U11, U12, U21, U22,2*M_PI, 2*M_PI);
174         }
175         break;
176       case GeomAbs_Parabola: {
177         //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(C1), Extrema_Curve2dTool::Parabola(*((Adaptor2d_Curve2d*)myC)));
178         Extrema_ECC2d Xtrem(C1, *((Adaptor2d_Curve2d*)myC));
179                         Xtrem.Perform();
180         Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0.);
181       }
182         break;
183       case GeomAbs_Hyperbola: {
184         //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(C1), Extrema_Curve2dTool::Hyperbola(*((Adaptor2d_Curve2d*)myC)));
185         Extrema_ECC2d Xtrem(C1, *((Adaptor2d_Curve2d*)myC));
186                         Xtrem.Perform();
187         Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0.);
188       }
189         break;
190       case GeomAbs_BezierCurve:
191       case GeomAbs_OtherCurve:
192       case GeomAbs_BSplineCurve: {
193         Extrema_ECC2d Xtrem(C1, *((Adaptor2d_Curve2d*)myC));
194                         Xtrem.Perform();        
195         Standard_Real Period2 = 0.;
196         if (Extrema_Curve2dTool::IsPeriodic(*((Adaptor2d_Curve2d*)myC))) Period2 = Extrema_Curve2dTool::Period(*((Adaptor2d_Curve2d*)myC));
197         Results(Xtrem, U11, U12, U21, U22, 2*M_PI,Period2);
198         }
199         break;
200       case GeomAbs_Line: {
201         inverse = Standard_True;
202         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Ellipse(C1));
203         Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0.);
204         }
205         break;
206       };  // switch(type2)
207     }
208     break;
209
210     //
211     // La premiere courbe est une parabole: 
212     //
213   case GeomAbs_Parabola: {
214
215     switch(type2) {
216       case GeomAbs_Circle: {
217         inverse = Standard_True;
218         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Parabola(C1));
219         Results(Xtrem, U11, U12, U21, U22, 0., 2*M_PI);
220         }
221         break;
222       case GeomAbs_Ellipse: {
223         //inverse = Standard_True;
224         //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Parabola(C1));
225         Extrema_ECC2d Xtrem(C1, *((Adaptor2d_Curve2d*)myC));
226                         Xtrem.Perform();
227         Results(Xtrem, U11, U12, U21, U22, 0., 2*M_PI);
228         }
229         break;
230       case GeomAbs_Parabola: {
231         //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Parabola(C1), Extrema_Curve2dTool::Parabola(*((Adaptor2d_Curve2d*)myC)));
232         Extrema_ECC2d Xtrem(C1, *((Adaptor2d_Curve2d*)myC));
233                         Xtrem.Perform();
234         Results(Xtrem, U11, U12, U21, U22, 0., 0.);
235       }
236         break;
237       case GeomAbs_Hyperbola: {
238         //inverse = Standard_True;
239         //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Parabola(C1));
240         Extrema_ECC2d Xtrem(C1, *((Adaptor2d_Curve2d*)myC));
241                         Xtrem.Perform();
242         Results(Xtrem, U11, U12, U21, U22, 0., 0.);
243       }
244         break;
245       case GeomAbs_BezierCurve:
246       case GeomAbs_OtherCurve:
247       case GeomAbs_BSplineCurve: {
248         Extrema_ECC2d Xtrem(C1, *((Adaptor2d_Curve2d*)myC));
249                         Xtrem.Perform();
250         Standard_Real Period2 = 0.;
251         if (Extrema_Curve2dTool::IsPeriodic(*((Adaptor2d_Curve2d*)myC))) Period2 = Extrema_Curve2dTool::Period(*((Adaptor2d_Curve2d*)myC));
252         Results(Xtrem, U11, U12, U21, U22, 0., Period2);
253         }
254         break;
255       case GeomAbs_Line: {
256         inverse = Standard_True;
257         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Parabola(C1));
258         Results(Xtrem, U11, U12, U21, U22, 0., 0.);
259         }
260         break;
261       };  // switch(type2)
262     }
263     break;
264
265     //
266     // La premiere courbe est une hyperbole:
267     //
268   case GeomAbs_Hyperbola: {
269
270     switch(type2) {
271       case GeomAbs_Circle: {
272         inverse = Standard_True;
273         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Hyperbola(C1));
274         Results(Xtrem, U11, U12, U21, U22, 0., 2*M_PI);
275         }
276         break;
277       case GeomAbs_Ellipse: {
278         //inverse = Standard_True;
279         //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Hyperbola(C1));
280         Extrema_ECC2d Xtrem(C1, *((Adaptor2d_Curve2d*)myC));
281                         Xtrem.Perform();
282         Results(Xtrem, U11, U12, U21, U22, 0., 2*M_PI );
283         }
284         break;
285       case GeomAbs_Parabola: {
286         //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(C1), Extrema_Curve2dTool::Parabola(*((Adaptor2d_Curve2d*)myC)));
287         Extrema_ECC2d Xtrem(C1, *((Adaptor2d_Curve2d*)myC));
288                         Xtrem.Perform();
289         Results(Xtrem, U11, U12, U21, U22, 0., 0.);
290       }
291         break;
292       case GeomAbs_Hyperbola: {
293         //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(C1), Extrema_Curve2dTool::Hyperbola(*((Adaptor2d_Curve2d*)myC)));
294         Extrema_ECC2d Xtrem(C1, *((Adaptor2d_Curve2d*)myC));
295                         Xtrem.Perform();
296         Results(Xtrem, U11, U12, U21, U22, 0., 0.);
297       }
298         break;
299       case GeomAbs_OtherCurve:
300       case GeomAbs_BezierCurve:
301       case GeomAbs_BSplineCurve: {
302         Extrema_ECC2d Xtrem(C1, *((Adaptor2d_Curve2d*)myC));
303   Xtrem.Perform();
304         Standard_Real Period2 = 0.;
305         if (Extrema_Curve2dTool::IsPeriodic(*((Adaptor2d_Curve2d*)myC))) Period2 = Extrema_Curve2dTool::Period(*((Adaptor2d_Curve2d*)myC));
306         Results(Xtrem, U11, U12, U21, U22, 0., Period2);
307         }
308         break;
309       case GeomAbs_Line: {
310         inverse = Standard_True;
311         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Hyperbola(C1));
312         Results(Xtrem, U11, U12, U21, U22, 0., 0.);
313         }
314         break;
315       };  // switch(type2)
316     }
317     break;
318
319     //
320     // La premiere courbe est une BezierCurve ou une BSplineCurve:
321     //
322   case GeomAbs_BezierCurve:
323   case GeomAbs_OtherCurve:
324   case GeomAbs_BSplineCurve: {
325     Extrema_ECC2d Xtrem(C1, *((Adaptor2d_Curve2d*)myC));
326     Xtrem.Perform();
327     Standard_Real Period1 = 0.;
328     if (Extrema_Curve2dTool::IsPeriodic(C1)) Period1 = Extrema_Curve2dTool::Period(C1);
329     Standard_Real Period2 = 0.;
330     if (Extrema_Curve2dTool::IsPeriodic(*((Adaptor2d_Curve2d*)myC))) Period2 = Extrema_Curve2dTool::Period(*((Adaptor2d_Curve2d*)myC));
331     Results(Xtrem, U11, U12, U21, U22, Period1, Period2);
332   }
333   break;
334
335     //
336     // La premiere courbe est une Line:
337     //
338   case GeomAbs_Line: {
339
340     switch(type2) {
341       case GeomAbs_Circle: {
342         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Circle(*((Adaptor2d_Curve2d*)myC)), Tol);
343         Results(Xtrem, U11, U12, U21, U22, 0., 2*M_PI);
344         }
345         break;
346       case GeomAbs_Ellipse: {
347         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Ellipse(*((Adaptor2d_Curve2d*)myC)));
348         Results(Xtrem, U11, U12, U21, U22, 0., 2*M_PI);
349         }
350         break;
351       case GeomAbs_Parabola: {
352         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Parabola(*((Adaptor2d_Curve2d*)myC)));
353         Results(Xtrem, U11, U12, U21, U22, 0., 0.);
354       }
355         break;
356       case GeomAbs_Hyperbola: {
357         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Hyperbola(*((Adaptor2d_Curve2d*)myC)));
358         Results(Xtrem, U11, U12, U21, U22, 0., 0.);
359       }
360         break;
361       case GeomAbs_BezierCurve:
362       case GeomAbs_OtherCurve:
363       case GeomAbs_BSplineCurve: {
364         Extrema_ECC2d Xtrem(C1, *((Adaptor2d_Curve2d*)myC));
365                         Xtrem.Perform();
366         Standard_Real Period2 = 0.;
367         if (Extrema_Curve2dTool::IsPeriodic(*((Adaptor2d_Curve2d*)myC))) Period2 = Extrema_Curve2dTool::Period(*((Adaptor2d_Curve2d*)myC));
368         Results(Xtrem, U11, U12, U21, U22, 0., Period2);
369         }
370         break;
371       case GeomAbs_Line: {
372         Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Tol);
373         Results(Xtrem, U11, U12, U21, U22, 0., 0.);
374         } 
375         break;
376       };  // switch(type2)
377     }
378     break;
379
380   };
381     
382 }
383
384
385 Standard_Boolean Extrema_ExtCC2d::IsDone() const
386 {
387   return myDone;
388 }
389
390
391 Standard_Real Extrema_ExtCC2d::SquareDistance(const Standard_Integer N) const 
392 {
393   if(!myDone) StdFail_NotDone::Raise();
394   if ((N <= 0) || (N > mynbext)) Standard_OutOfRange::Raise();
395   return mySqDist.Value(N);
396 }
397
398
399 Standard_Integer Extrema_ExtCC2d::NbExt() const
400 {
401   if(!myDone) StdFail_NotDone::Raise();
402   return mynbext;
403 }
404
405
406 void Extrema_ExtCC2d::Points(const Standard_Integer N, 
407                               Extrema_POnCurv2d& P1,
408                               Extrema_POnCurv2d& P2) const
409 {
410   if(!myDone) StdFail_NotDone::Raise();
411   if ((N <= 0) || (N > mynbext)) Standard_OutOfRange::Raise();
412   P1 = mypoints.Value(2*N-1);
413   P2 = mypoints.Value(2*N);
414 }
415
416
417
418 void Extrema_ExtCC2d::TrimmedSquareDistances(Standard_Real& dist11,
419                                         Standard_Real& dist12,
420                                         Standard_Real& dist21,
421                                         Standard_Real& dist22,
422                                         gp_Pnt2d&      P11,
423                                         gp_Pnt2d&      P12,
424                                         gp_Pnt2d&      P21,
425                                         gp_Pnt2d&      P22) const 
426 {
427   dist11 = mydist11;
428   dist12 = mydist12;
429   dist21 = mydist21;
430   dist22 = mydist22;
431   P11 = P1f;
432   P12 = P1l;
433   P21 = P2f;
434   P22 = P2l;
435 }
436
437
438
439 void Extrema_ExtCC2d::Results(const Extrema_ExtElC2d&  AlgExt,
440                                const Standard_Real      Ut11,
441                                const Standard_Real      Ut12,
442                                const Standard_Real      Ut21,
443                                const Standard_Real      Ut22,
444                                const Standard_Real      Period1,
445                                const Standard_Real      Period2)
446 {
447   Standard_Integer i, NbExt;
448   Standard_Real Val, U, U2;
449   Extrema_POnCurv2d P1, P2;
450   
451   myDone = AlgExt.IsDone();
452   myIsPar = AlgExt.IsParallel();
453   if (myDone) {
454     if (!myIsPar) {
455       NbExt = AlgExt.NbExt();
456       for (i = 1; i <= NbExt; i++) {
457         // Verification de la validite des parametres pour le cas trimme:
458         AlgExt.Points(i, P1, P2);
459         if (!inverse) {
460           U = P1.Parameter();
461           if (Period1 != 0.0) U = ElCLib::InPeriod(U,Ut11,Ut11+Period1);
462           U2 = P2.Parameter();
463           if (Period2 != 0.0) U2 = ElCLib::InPeriod(U2,Ut21,Ut21+Period2);
464         }
465         else {
466           U2 = P1.Parameter();
467           if (Period2 != 0.0) U2 = ElCLib::InPeriod(U2,Ut21,Ut21+Period2);
468           U = P2.Parameter();
469           if (Period1 != 0.0) U = ElCLib::InPeriod(U,Ut11,Ut11+Period1);
470         }
471         if ((U  >= Ut11 - Precision::PConfusion())  && 
472             (U  <= Ut12 + Precision::PConfusion())  &&
473             (U2 >= Ut21 - Precision::PConfusion())  &&
474             (U2 <= Ut22 + Precision::PConfusion())) {
475           mynbext++;
476           Val = AlgExt.SquareDistance(i);
477           mySqDist.Append(Val);
478           if (!inverse) {
479             P1.SetValues(U, P1.Value());
480             P2.SetValues(U2, P2.Value());
481             mypoints.Append(P1);
482             mypoints.Append(P2);
483           }
484           else {
485             P1.SetValues(U2, P1.Value());
486             P2.SetValues(U, P2.Value());
487             mypoints.Append(P2);
488             mypoints.Append(P1);
489           }
490         }
491       }
492     }
493
494     mydist11 = P1f.SquareDistance(P2f);
495     mydist12 = P1f.SquareDistance(P2l);
496     mydist21 = P1l.SquareDistance(P2f);
497     mydist22 = P1l.SquareDistance(P2l);
498   }
499 }
500
501
502 void Extrema_ExtCC2d::Results(const Extrema_ECC2d& AlgExt,
503                               const Standard_Real  Ut11,
504                               const Standard_Real  Ut12,
505                               const Standard_Real  Ut21,
506                               const Standard_Real  Ut22,
507                               const Standard_Real  Period1,
508                               const Standard_Real  Period2)
509 {
510   Standard_Integer i, NbExt;
511   Standard_Real Val, U, U2;
512   Extrema_POnCurv2d P1, P2;
513
514   myDone = AlgExt.IsDone();
515   if (myDone)
516   {
517     myIsPar = AlgExt.IsParallel();
518     if (!myIsPar)
519     {
520       NbExt = AlgExt.NbExt();
521       for (i = 1; i <= NbExt; i++)
522       {
523         // Verification de la validite des parametres pour le cas trimme:
524         AlgExt.Points(i, P1, P2);
525         U = P1.Parameter();
526         if (Period1 != 0.0) 
527           U = ElCLib::InPeriod(U,Ut11,Ut11+Period1);
528         U2 = P2.Parameter();
529         if (Period2 != 0.0) 
530           U2 = ElCLib::InPeriod(U2,Ut21,Ut21+Period2);
531
532         if ((U  >= Ut11 - Precision::PConfusion())  && 
533             (U  <= Ut12 + Precision::PConfusion())  &&
534             (U2 >= Ut21 - Precision::PConfusion())  &&
535             (U2 <= Ut22 + Precision::PConfusion()))
536         {
537             mynbext++;
538             Val = AlgExt.SquareDistance(i);
539             P1.SetValues(U, P1.Value());
540             P2.SetValues(U2, P2.Value());
541             mySqDist.Append(Val);
542             mypoints.Append(P1);
543             mypoints.Append(P2);
544         }
545       }
546     }
547
548     mydist11 = P1f.SquareDistance(P2f);
549     mydist12 = P1f.SquareDistance(P2l);
550     mydist21 = P1l.SquareDistance(P2f);
551     mydist22 = P1l.SquareDistance(P2l);
552   }
553 }
554
555
556 Standard_Boolean Extrema_ExtCC2d::IsParallel() const
557 {
558   if (!myDone) StdFail_NotDone::Raise();
559   return myIsPar;
560 }