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