0031007: Coding - eliminate warnings issued while compiling with -pedantic flag
[occt.git] / src / Geom2dGcc / Geom2dGcc_Circ2d2TanOnIter.cxx
1 // Created on: 1991-12-13
2 // Created by: Remi GILET
3 // Copyright (c) 1991-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 //   Creation d un cercle tangent a deux elements : Droite.               +
19 //                                                  Cercle.               +
20 //                                                  Point.                +
21 //                                                  Courbes.              +
22 //                        centre sur un troisieme : Droite.               +
23 //                                                  Cercle.               +
24 //                                                  Courbes.              +
25 //=========================================================================
26
27 #include <ElCLib.hxx>
28 #include <GccEnt_BadQualifier.hxx>
29 #include <GccEnt_QualifiedCirc.hxx>
30 #include <GccEnt_QualifiedLin.hxx>
31 #include <Geom2dAdaptor_Curve.hxx>
32 #include <Geom2dGcc_Circ2d2TanOnIter.hxx>
33 #include <Geom2dGcc_CurveTool.hxx>
34 #include <Geom2dGcc_FunctionTanCuCuOnCu.hxx>
35 #include <Geom2dGcc_QCurve.hxx>
36 #include <gp.hxx>
37 #include <gp_Ax2d.hxx>
38 #include <gp_Circ2d.hxx>
39 #include <gp_Dir2d.hxx>
40 #include <gp_Lin2d.hxx>
41 #include <gp_Pnt2d.hxx>
42 #include <math_FunctionSetRoot.hxx>
43 #include <StdFail_NotDone.hxx>
44
45 Geom2dGcc_Circ2d2TanOnIter::
46 Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin&  Qualified1 , 
47                             const Geom2dGcc_QCurve&     Qualified2 , 
48                             const gp_Lin2d&             OnLine     ,
49                             const Standard_Real         Param1     ,
50                             const Standard_Real         Param2     ,
51                             const Standard_Real         Param3     ,
52                             const Standard_Real         Tolang     ) {
53
54                               TheSame1 = Standard_False;
55                               TheSame2 = Standard_False;
56                               par1sol = 0.;
57                               par2sol = 0.;
58                               pararg1 = 0.;
59                               pararg2 = 0.;
60                               parcen3 = 0.;
61
62                               WellDone = Standard_False;
63                               Standard_Real Tol = Abs(Tolang);
64                               WellDone = Standard_False;
65                               if (!(Qualified1.IsEnclosed() ||
66                                 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
67                                 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
68                                 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
69                                   throw GccEnt_BadQualifier();
70                                   return;
71                               }
72                               gp_Dir2d dirx(1.,0.);
73                               gp_Lin2d L1 = Qualified1.Qualified();
74                               Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
75                               math_Vector Umin(1,4);
76                               math_Vector Umax(1,4);
77                               math_Vector Ufirst(1,4);
78                               math_Vector tol(1,4);
79                               Umin(1) = RealFirst();
80                               Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
81                               Umin(3) = RealFirst();
82                               Umin(4) = 0.;
83                               Umax(1) = RealLast();
84                               Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
85                               Umax(3) = RealLast();
86                               Umax(4) = RealLast();
87                               Ufirst(1) = Param1;
88                               Ufirst(2) = Param2;
89                               Ufirst(3) = Param3;
90                               tol(1) = 1.e-15;
91                               tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Tolang);
92                               tol(3) = tol(1);   
93                               tol(4) = tol(1);   
94                               gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
95                               gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
96                               gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
97                               Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
98                               Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnLine,Max(Ufirst(4), Tol));
99                               math_FunctionSetRoot Root(Func, tol);
100                               Root.Perform(Func, Ufirst, Umin, Umax);
101                               Func.Value(Ufirst,Umin);
102                               if (Root.IsDone()) {
103                                 Root.Root(Ufirst);
104                                 //     gp_Vec2d Tan1,Tan2,Nor1,Nor2;
105                                 gp_Vec2d Tan1,Tan2;
106                                 ElCLib::D1(Ufirst(1),L1,point1,Tan1);
107                                 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
108                                 gp_Vec2d Tan3(OnLine.Direction().XY());
109                                 gp_Pnt2d point3new(OnLine.Location().XY()+Ufirst(3)*Tan3.XY());
110                                 Standard_Real dist1 = point3new.Distance(point1);
111                                 Standard_Real dist2 = point3new.Distance(point2);
112                                 if ( Abs(dist1-dist2)/2. <= Tol) {
113                                   cirsol = gp_Circ2d(gp_Ax2d(point3new,dirx),(dist1+dist2)/2.);
114                                   Standard_Real normetan2 = Tan2.Magnitude();
115                                   gp_Vec2d Vec1(point1,point3new);
116                                   gp_Vec2d Vec2(point2,point3new);
117                                   Standard_Real normevec2 = Vec2.Magnitude();
118                                   Standard_Real angle2;
119                                   if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
120                                     angle2 = Vec2.Angle(Tan2);
121                                   }
122                                   else { angle2 = 0.; }
123                                   Standard_Real pscal=point3new.XY().Dot(gp_XY(-L1.Direction().Y(),
124                                     L1.Direction().X()));
125                                   if (Qualified1.IsUnqualified() ||
126                                     (Qualified1.IsOutside() && pscal <= 0.) ||
127                                     (Qualified1.IsEnclosed() && pscal >= 0.)) {
128                                       if (Qualified2.IsUnqualified() || 
129                                         (Qualified2.IsEnclosing()&&angle2<=0.)||
130                                         (Qualified2.IsOutside() && angle2 >= 0) ||
131                                         (Qualified2.IsEnclosed() && angle2 <= 0.)) {
132                                           qualifier1 = Qualified1.Qualifier();
133                                           qualifier2 = Qualified2.Qualifier();
134                                           pnttg1sol = point1;
135                                           pararg1 = Ufirst(1);
136                                           par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
137                                           pnttg2sol = point2;
138                                           pararg2 = Ufirst(2);
139                                           par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
140                                           pntcen  = point3new;
141                                           parcen3 = Ufirst(3);
142                                           WellDone = Standard_True;
143                                       }
144                                   }
145                                 }
146                               }
147 }
148
149 Geom2dGcc_Circ2d2TanOnIter::
150 Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 , 
151                             const Geom2dGcc_QCurve& Qualified2 , 
152                             const gp_Lin2d&          OnLine     ,
153                             const Standard_Real               Param1     ,
154                             const Standard_Real               Param2     ,
155                             const Standard_Real               Param3     ,
156                             const Standard_Real               Tolerance  ) {
157                               TheSame1 = Standard_False;
158                               TheSame2 = Standard_False;
159                               par1sol = 0.;
160                               par2sol = 0.;
161                               pararg1 = 0.;
162                               pararg2 = 0.;
163                               parcen3 = 0.;
164
165                               WellDone = Standard_False;
166                               if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
167                                 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
168                                 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
169                                 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
170                                   throw GccEnt_BadQualifier();
171                                   return;
172                               }
173                               Standard_Real Tol = Abs(Tolerance);
174                               gp_Dir2d dirx(1.,0.);
175                               Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
176                               Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
177                               math_Vector Umin(1,4);
178                               math_Vector Umax(1,4);
179                               math_Vector Ufirst(1,4);
180                               math_Vector tol(1,4);
181                               Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
182                               Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
183                               Umin(3) = RealFirst();  
184                               Umin(4) = 0.;
185                               Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
186                               Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
187                               Umax(3) = RealLast();
188                               Umax(4) = RealLast();
189                               Ufirst(1) = Param1;
190                               Ufirst(2) = Param2;
191                               Ufirst(3) = Param3;
192                               tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
193                               tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
194                               tol(3) = 1.e-15;   
195                               tol(4) = Tol/10.;   
196                               gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
197                               gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
198                               gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
199                               Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
200                               Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnLine,Max(Ufirst(4), Tol));
201                               math_FunctionSetRoot Root(Func, tol);
202                               Root.Perform(Func, Ufirst, Umin, Umax);
203                               Func.Value(Ufirst,Umin);
204                               if (Root.IsDone()) {
205                                 Root.Root(Ufirst);
206                                 gp_Vec2d Tan1,Tan2;
207                                 Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
208                                 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
209                                 gp_Vec2d Tan3(OnLine.Direction().XY());
210                                 gp_Pnt2d point3new(OnLine.Location().XY()+Ufirst(3)*Tan3.XY());
211                                 Standard_Real dist1 = point3new.Distance(point1);
212                                 Standard_Real dist2 = point3new.Distance(point2);
213                                 if((dist1+dist2)/2. < Tol)
214                                 {
215                                   return;
216                                 }
217                                 if ( Abs(dist1-dist2)/2. <= Tol) {
218                                   cirsol = gp_Circ2d(gp_Ax2d(point3new,dirx),(dist1+dist2)/2.);
219                                   Standard_Real normetan1 = Tan1.Magnitude();
220                                   Standard_Real normetan2 = Tan2.Magnitude();
221                                   gp_Vec2d Vec1(point1,point3new);
222                                   gp_Vec2d Vec2(point2,point3new);
223                                   Standard_Real normevec1 = Vec1.Magnitude();
224                                   Standard_Real normevec2 = Vec2.Magnitude();
225                                   Standard_Real angle1,angle2;
226                                   if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
227                                     angle1 = Vec1.Angle(Tan1);
228                                   }
229                                   else { angle1 = 0.; }
230                                   if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
231                                     angle2 = Vec2.Angle(Tan2);
232                                   }
233                                   else { angle2 = 0.; }
234                                   if (Qualified1.IsUnqualified()||
235                                     (Qualified1.IsEnclosing()&&angle1<=0.)||
236                                     (Qualified1.IsOutside() && angle1 >= 0.) ||
237                                     (Qualified1.IsEnclosed() && angle1 <= 0.)) {
238                                       if (Qualified2.IsUnqualified() || 
239                                         (Qualified2.IsEnclosing()&&angle2<=0.)||
240                                         (Qualified2.IsOutside() && angle2 >= 0) ||
241                                         (Qualified2.IsEnclosed() && angle2 <= 0.)) {
242                                           qualifier1 = Qualified1.Qualifier();
243                                           qualifier2 = Qualified2.Qualifier();
244                                           pnttg1sol = point1;
245                                           pararg1 = Ufirst(1);
246                                           par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
247                                           pnttg2sol = point2;
248                                           pararg2 = Ufirst(2);
249                                           par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
250                                           pntcen  = point3new;
251                                           parcen3 = Ufirst(3);
252                                           WellDone = Standard_True;
253                                       }
254                                   }
255                                 }
256                               }
257 }
258
259 Geom2dGcc_Circ2d2TanOnIter::
260 Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 , 
261                             const gp_Pnt2d&          Point2     , 
262                             const gp_Lin2d&          OnLine     ,
263                             const Standard_Real      Param1     ,
264                             const Standard_Real      Param2     ,
265                             const Standard_Real      Tolerance  ) {
266                               TheSame1 = Standard_False;
267                               TheSame2 = Standard_False;
268                               par1sol = 0.;
269                               par2sol = 0.;
270                               pararg1 = 0.;
271                               pararg2 = 0.;
272                               parcen3 = 0.;
273
274                               WellDone = Standard_False;
275                               if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
276                                 Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
277                                   throw GccEnt_BadQualifier();
278                                   return;
279                               }
280                               Standard_Real Tol = Abs(Tolerance);
281                               gp_Dir2d dirx(1.,0.);
282                               Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
283                               math_Vector Umin(1,3);
284                               math_Vector Umax(1,3);
285                               math_Vector Ufirst(1,3);
286                               math_Vector tol(1,3);
287                               Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
288                               Umin(2) = RealFirst();
289                               Umin(3) = 0.;
290                               Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
291                               Umax(2) = RealLast();
292                               Umax(3) = RealLast();
293                               Ufirst(1) = Param1;
294                               Ufirst(2) = Param2;
295                               tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
296                               tol(2) = 1.e-15;
297                               tol(3) = Tol/10.;
298                               gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
299                               gp_Pnt2d point3 = ElCLib::Value(Param2,OnLine);
300                               Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
301                               Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnLine,Max(Ufirst(3), Tol));
302                               math_FunctionSetRoot Root(Func, tol);
303                               Root.Perform(Func, Ufirst, Umin, Umax);
304                               Func.Value(Ufirst,Umin);
305                               if (Root.IsDone()) {
306                                 Root.Root(Ufirst);
307                                 gp_Pnt2d point1new,point3new;
308                                 gp_Vec2d Tan1,Tan3;
309                                 Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1new,Tan1);
310                                 ElCLib::D1(Ufirst(2),OnLine,point3new,Tan3);
311                                 Standard_Real dist1 = point3new.Distance(point1new);
312                                 Standard_Real dist2 = point3new.Distance(Point2);
313                                 if ( Abs(dist1-dist2)/2. <= Tol) {
314                                   cirsol = gp_Circ2d(gp_Ax2d(point3new,dirx),(dist1+dist2)/2.);
315                                   Standard_Real normetan1 = Tan1.Magnitude();
316                                   gp_Vec2d Vec1(point1new,point3new);
317                                   Standard_Real normevec1 = Vec1.Magnitude();
318                                   Standard_Real angle1;
319                                   if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
320                                     angle1 = Vec1.Angle(Tan1);
321                                   }
322                                   else { angle1 = 0.; }
323                                   if (Qualified1.IsUnqualified()||
324                                     (Qualified1.IsEnclosing()&&angle1<=0.)||
325                                     (Qualified1.IsOutside() && angle1 >= 0.) ||
326                                     (Qualified1.IsEnclosed() && angle1 <= 0.)) {
327                                       qualifier1 = Qualified1.Qualifier();
328                                       qualifier2 = GccEnt_noqualifier;
329                                       pnttg1sol = point1new;
330                                       pararg1 = Ufirst(1);
331                                       par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
332                                       pnttg2sol = Point2;
333                                       pararg2 = Ufirst(2);
334                                       par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
335                                       pntcen  = point3new;
336                                       parcen3 = Ufirst(3);
337                                       WellDone = Standard_True;
338                                   }
339                                 }
340                               }
341 }
342
343 Geom2dGcc_Circ2d2TanOnIter::
344 Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 , 
345                             const Geom2dGcc_QCurve&     Qualified2 , 
346                             const gp_Lin2d&             OnLine     ,
347                             const Standard_Real         Param1     ,
348                             const Standard_Real         Param2     ,
349                             const Standard_Real         Param3     ,
350                             const Standard_Real         Tolerance  ) {
351                               TheSame1 = Standard_False;
352                               TheSame2 = Standard_False;
353                               par1sol = 0.;
354                               par2sol = 0.;
355                               pararg1 = 0.;
356                               pararg2 = 0.;
357                               parcen3 = 0.;
358
359                               WellDone = Standard_False;
360                               if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
361                                 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
362                                 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
363                                 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
364                                   throw GccEnt_BadQualifier();
365                                   return;
366                               }
367                               Standard_Real Tol = Abs(Tolerance);
368                               gp_Dir2d dirx(1.,0.);
369                               gp_Circ2d C1 = Qualified1.Qualified();
370                               Standard_Real R1 = C1.Radius();
371                               Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
372                               math_Vector Umin(1,4);
373                               math_Vector Umax(1,4);
374                               math_Vector Ufirst(1,4);
375                               math_Vector tol(1,4);
376                               Umin(1) = RealFirst();
377                               Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
378                               Umin(3) = RealFirst();
379                               Umin(4) = 0.;
380                               Umax(1) = RealLast();
381                               Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
382                               Umax(3) = RealLast();
383                               Umax(4) = RealLast();
384                               Ufirst(1) = Param1;
385                               Ufirst(2) = Param2;
386                               Ufirst(3) = Param3;
387                               tol(1) = 2.e-15*M_PI;
388                               tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
389                               tol(3) = 1.e-15;
390                               tol(4) = Tol/10.;
391                               gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
392                               gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
393                               gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
394                               Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
395                               Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnLine,Max(Ufirst(4), Tol));
396                               math_FunctionSetRoot Root(Func, tol);
397                               Root.Perform(Func, Ufirst, Umin, Umax);
398                               Func.Value(Ufirst,Umin);
399                               if (Root.IsDone()) {
400                                 Root.Root(Ufirst);
401                                 //     gp_Vec2d Tan1,Tan2,Nor1,Nor2;
402                                 gp_Vec2d Tan1,Tan2,Nor2;
403                                 ElCLib::D2(Ufirst(1),C1,point1,Tan1,Nor2);
404                                 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
405 #ifdef OCCT_DEBUG
406                                 gp_Vec2d Tan3(OnLine.Direction().XY());
407 #else
408                                 OnLine.Direction().XY();
409 #endif
410                                 point3 = ElCLib::Value(Ufirst(1),OnLine);
411                                 Standard_Real dist1 = point3.Distance(point1);
412                                 Standard_Real dist2 = point3.Distance(point2);
413                                 if ( Abs(dist1-dist2)/2. <= Tol) {
414                                   cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
415                                   Standard_Real normetan2 = Tan2.Magnitude();
416                                   gp_Vec2d Vec1(point1,point3);
417                                   gp_Vec2d Vec2(point2,point3);
418                                   Standard_Real normevec2 = Vec2.Magnitude();
419                                   Standard_Real angle2;
420                                   if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
421                                     angle2 = Vec2.Angle(Tan2);
422                                   }
423                                   else { angle2 = 0.; }
424                                   Standard_Real dist = C1.Location().Distance(point3);
425                                   Standard_Real Rsol = cirsol.Radius();
426                                   if (Qualified1.IsUnqualified() || 
427                                     (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
428                                     (Qualified1.IsOutside() && dist >= Rsol) ||
429                                     (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
430                                       if (Qualified2.IsUnqualified() || 
431                                         (Qualified2.IsEnclosing()&&angle2<=0.)||
432                                         (Qualified2.IsOutside() && angle2 >= 0) ||
433                                         (Qualified2.IsEnclosed() && angle2 <= 0.)) {
434                                           qualifier1 = Qualified1.Qualifier();
435                                           qualifier2 = Qualified2.Qualifier();
436                                           pnttg1sol = point1;
437                                           pararg1 = Ufirst(1);
438                                           par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
439                                           pnttg2sol = point2;
440                                           pararg2 = Ufirst(2);
441                                           par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
442                                           pntcen  = point3;
443                                           parcen3 = Ufirst(3);
444                                           WellDone = Standard_True;
445                                       }
446                                   }
447                                 }
448                               }
449 }
450
451 Geom2dGcc_Circ2d2TanOnIter::
452 Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 , 
453                             const Geom2dGcc_QCurve&     Qualified2 , 
454                             const gp_Circ2d&            OnCirc     ,
455                             const Standard_Real         Param1     ,
456                             const Standard_Real         Param2     ,
457                             const Standard_Real         Param3     ,
458                             const Standard_Real         Tolerance  ) {
459                               TheSame1 = Standard_False;
460                               TheSame2 = Standard_False;
461                               par1sol = 0.;
462                               par2sol = 0.;
463                               pararg1 = 0.;
464                               pararg2 = 0.;
465                               parcen3 = 0.;
466
467                               WellDone = Standard_False;
468                               if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
469                                 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
470                                 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
471                                 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
472                                   throw GccEnt_BadQualifier();
473                                   return;
474                               }
475                               Standard_Real Tol = Abs(Tolerance);
476                               gp_Dir2d dirx(1.,0.);
477                               gp_Circ2d C1 = Qualified1.Qualified();
478                               Standard_Real R1 = C1.Radius();
479                               Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
480                               math_Vector Umin(1,4);
481                               math_Vector Umax(1,4);
482                               math_Vector Ufirst(1,4);
483                               math_Vector tol(1,4);
484                               Umin(1) = RealFirst();
485                               Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
486                               Umin(3) = RealFirst();
487                               Umin(4) = 0.;
488                               Umax(1) = RealLast();
489                               Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
490                               Umax(3) = RealLast();
491                               Umax(4) = RealLast();
492                               Ufirst(1) = Param1;
493                               Ufirst(2) = Param2;
494                               Ufirst(3) = Param3;
495                               tol(1) = 2.e-15*M_PI;
496                               tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
497                               tol(3) = 2.e-15*M_PI;
498                               tol(4) = Tol/10.;
499                               gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
500                               gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
501                               gp_Pnt2d point3 = ElCLib::Value(Param3,OnCirc);
502                               Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
503                               Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnCirc,Max(Ufirst(4), Tol));
504                               math_FunctionSetRoot Root(Func, tol);
505                               Root.Perform(Func, Ufirst, Umin, Umax);
506                               Func.Value(Ufirst,Umin);
507                               if (Root.IsDone()) {
508                                 Root.Root(Ufirst);
509                                 //     gp_Vec2d Tan1,Tan2,Nor1;
510                                 gp_Vec2d Tan1,Tan2;
511                                 ElCLib::D1(Ufirst(1),C1,point1,Tan1);
512                                 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
513 #ifdef OCCT_DEBUG
514                                 gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
515 #endif
516                                 point3 = ElCLib::Value(Ufirst(3),OnCirc);
517                                 Standard_Real dist1 = point3.Distance(point1);
518                                 Standard_Real dist2 = point3.Distance(point2);
519                                 if ( Abs(dist1-dist2)/2. <= Tol) {
520                                   cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
521                                   Standard_Real normetan2 = Tan2.Magnitude();
522                                   gp_Vec2d Vec1(point1,point3);
523                                   gp_Vec2d Vec2(point2,point3);
524                                   Standard_Real normevec2 = Vec2.Magnitude();
525                                   Standard_Real angle2;
526                                   if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
527                                     angle2 = Vec2.Angle(Tan2);
528                                   }
529                                   else { angle2 = 0.; }
530                                   Standard_Real dist = C1.Location().Distance(point3);
531                                   Standard_Real Rsol = cirsol.Radius();
532                                   if (Qualified1.IsUnqualified() || 
533                                     (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
534                                     (Qualified1.IsOutside() && dist >= Rsol) ||
535                                     (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
536                                       if (Qualified2.IsUnqualified() || 
537                                         (Qualified2.IsEnclosing()&&angle2<=0.)||
538                                         (Qualified2.IsOutside() && angle2 >= 0) ||
539                                         (Qualified2.IsEnclosed() && angle2 <= 0.)) {
540                                           qualifier1 = Qualified1.Qualifier();
541                                           qualifier2 = Qualified2.Qualifier();
542                                           pnttg1sol = point1;
543                                           pararg1 = Ufirst(1);
544                                           par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
545                                           pnttg2sol = point2;
546                                           pararg2 = Ufirst(2);
547                                           par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
548                                           pntcen  = point3;
549                                           parcen3 = Ufirst(3);
550                                           WellDone = Standard_True;
551                                       }
552                                   }
553                                 }
554                               }
555 }
556
557 Geom2dGcc_Circ2d2TanOnIter::
558 Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin&  Qualified1 , 
559                             const Geom2dGcc_QCurve&     Qualified2 , 
560                             const gp_Circ2d&            OnCirc     ,
561                             const Standard_Real         Param1     ,
562                             const Standard_Real         Param2     ,
563                             const Standard_Real         Param3     ,
564                             const Standard_Real         Tolerance  ) {
565                               TheSame1 = Standard_False;
566                               TheSame2 = Standard_False;
567                               par1sol = 0.;
568                               par2sol = 0.;
569                               pararg1 = 0.;
570                               pararg2 = 0.;
571                               parcen3 = 0.;
572
573                               WellDone = Standard_False;
574                               if (!(Qualified1.IsEnclosed() ||
575                                 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
576                                 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
577                                 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
578                                   throw GccEnt_BadQualifier();
579                                   return;
580                               }
581                               Standard_Real Tol = Abs(Tolerance);
582                               gp_Dir2d dirx(1.,0.);
583                               gp_Lin2d L1 = Qualified1.Qualified();
584                               Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
585                               math_Vector Umin(1,4);
586                               math_Vector Umax(1,4);
587                               math_Vector Ufirst(1,4);
588                               math_Vector tol(1,4);
589                               Umin(1) = RealFirst();
590                               Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
591                               Umin(3) = RealFirst();
592                               Umin(4) = 0.;
593                               Umax(1) = RealLast();
594                               Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
595                               Umax(3) = RealLast();
596                               Umax(4) = RealLast();
597                               Ufirst(1) = Param1;
598                               Ufirst(2) = Param2;
599                               Ufirst(3) = Param3;
600                               tol(1) = 1.e-15;
601                               tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
602                               tol(3) = 2.e-15*M_PI;
603                               tol(4) = Tol/10.;
604                               gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
605                               gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
606                               gp_Pnt2d point3 = ElCLib::Value(Param3,OnCirc);
607                               Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
608                               Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnCirc,Max(Ufirst(4), Tol));
609                               math_FunctionSetRoot Root(Func, tol);
610                               Root.Perform(Func, Ufirst, Umin, Umax);
611                               Func.Value(Ufirst,Umin);
612                               if (Root.IsDone()) {
613                                 Root.Root(Ufirst);
614                                 gp_Pnt2d point1new,point2new;
615                                 gp_Vec2d Tan1,Tan2;
616                                 ElCLib::D1(Ufirst(1),L1,point1new,Tan1);
617                                 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2new,Tan2);
618 #ifdef OCCT_DEBUG
619                                 gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
620 #endif
621                                 point3 = ElCLib::Value(Ufirst(3),OnCirc);
622                                 Standard_Real dist1 = point3.Distance(point1new);
623                                 Standard_Real dist2 = point3.Distance(point2new);
624                                 if ( Abs(dist1-dist2)/2. <= Tol) {
625                                   cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
626                                   Standard_Real normetan2 = Tan2.Magnitude();
627                                   gp_Vec2d Vec1(point1new,point3);
628                                   gp_Vec2d Vec2(point2new,point3);
629                                   Standard_Real normevec2 = Vec2.Magnitude();
630                                   Standard_Real angle2;
631                                   if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
632                                     angle2 = Vec2.Angle(Tan2);
633                                   }
634                                   else { angle2 = 0.; }
635                                   Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
636                                     L1.Direction().X()));
637                                   if (Qualified1.IsUnqualified() ||
638                                     (Qualified1.IsOutside() && pscal <= 0.) ||
639                                     (Qualified1.IsEnclosed() && pscal >= 0.)) {
640                                       if (Qualified2.IsUnqualified() || 
641                                         (Qualified2.IsEnclosing()&&angle2<=0.)||
642                                         (Qualified2.IsOutside() && angle2 >= 0) ||
643                                         (Qualified2.IsEnclosed() && angle2 <= 0.)) {
644                                           qualifier1 = Qualified1.Qualifier();
645                                           qualifier2 = Qualified2.Qualifier();
646                                           pnttg1sol = point1new;
647                                           pararg1 = Ufirst(1);
648                                           par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
649                                           pnttg2sol = point2new;
650                                           pararg2 = Ufirst(2);
651                                           par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
652                                           pntcen  = point3;
653                                           parcen3 = Ufirst(3);
654                                           WellDone = Standard_True;
655                                       }
656                                   }
657                                 }
658                               }
659 }
660
661 Geom2dGcc_Circ2d2TanOnIter::
662 Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 , 
663                             const Geom2dGcc_QCurve& Qualified2 , 
664                             const gp_Circ2d&         OnCirc     ,
665                             const Standard_Real               Param1     ,
666                             const Standard_Real               Param2     ,
667                             const Standard_Real               Param3     ,
668                             const Standard_Real               Tolerance  ) {
669                               TheSame1 = Standard_False;
670                               TheSame2 = Standard_False;
671                               par1sol = 0.;
672                               par2sol = 0.;
673                               pararg1 = 0.;
674                               pararg2 = 0.;
675                               parcen3 = 0.;
676
677                               WellDone = Standard_False;
678                               if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
679                                 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
680                                 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
681                                 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
682                                   throw GccEnt_BadQualifier();
683                                   return;
684                               }
685                               Standard_Real Tol = Abs(Tolerance);
686                               gp_Dir2d dirx(1.,0.);
687                               Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
688                               Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
689                               math_Vector Umin(1,4);
690                               math_Vector Umax(1,4);
691                               math_Vector Ufirst(1,4);
692                               math_Vector tol(1,4);
693                               Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
694                               Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
695                               Umin(3) = RealFirst();
696                               Umin(4) = 0.;
697                               Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
698                               Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
699                               Umax(3) = RealLast();
700                               Umax(4) = RealLast();
701                               Ufirst(1) = Param1;
702                               Ufirst(2) = Param2;
703                               Ufirst(3) = Param3;
704                               tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
705                               tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
706                               tol(3) = 2.e-15*M_PI;
707                               tol(4) = Tol/10.;
708                               gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
709                               gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
710                               Standard_Real R1 = OnCirc.Radius();
711                               gp_Pnt2d point3(OnCirc.Location().XY()+R1*gp_XY(Cos(Param3),Sin(Param3)));
712                               Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
713                               Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnCirc,Max(Ufirst(4), Tol));
714                               math_FunctionSetRoot Root(Func, tol);
715                               Root.Perform(Func, Ufirst, Umin, Umax);
716                               Func.Value(Ufirst,Umin);
717                               if (Root.IsDone()) {
718                                 Root.Root(Ufirst);
719                                 //     gp_Vec2d Tan1,Tan2,Nor1;
720                                 gp_Vec2d Tan1,Tan2;
721                                 Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
722                                 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
723 #ifdef OCCT_DEBUG
724                                 gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
725 #endif
726                                 point3 = gp_Pnt2d(OnCirc.Location().XY()+
727                                   R1*gp_XY(Cos(Ufirst(3)),Sin(Ufirst(3))));
728                                 Standard_Real dist1 = point3.Distance(point1);
729                                 Standard_Real dist2 = point3.Distance(point2);
730                                 if ( Abs(dist1-dist2)/2. <= Tol) {
731                                   cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
732                                   Standard_Real normetan1 = Tan1.Magnitude();
733                                   Standard_Real normetan2 = Tan2.Magnitude();
734                                   gp_Vec2d Vec1(point1,point3);
735                                   gp_Vec2d Vec2(point2,point3);
736                                   Standard_Real normevec1 = Vec1.Magnitude();
737                                   Standard_Real normevec2 = Vec2.Magnitude();
738                                   Standard_Real angle1,angle2;
739                                   if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
740                                     angle1 = Vec1.Angle(Tan1);
741                                   }
742                                   else { angle1 = 0.; }
743                                   if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
744                                     angle2 = Vec2.Angle(Tan2);
745                                   }
746                                   else { angle2 = 0.; }
747                                   if (Qualified1.IsUnqualified()||
748                                     (Qualified1.IsEnclosing()&&angle1<=0.)||
749                                     (Qualified1.IsOutside() && angle1 >= 0.) ||
750                                     (Qualified1.IsEnclosed() && angle1 <= 0.)) {
751                                       if (Qualified2.IsUnqualified() || 
752                                         (Qualified2.IsEnclosing()&&angle2<=0.)||
753                                         (Qualified2.IsOutside() && angle2 >= 0) ||
754                                         (Qualified2.IsEnclosed() && angle2 <= 0.)) {
755                                           qualifier1 = Qualified1.Qualifier();
756                                           qualifier2 = Qualified2.Qualifier();
757                                           pararg1 = Ufirst(1);
758                                           par1sol = 0.;
759                                           pnttg1sol = point1;
760                                           pararg2 = Ufirst(2);
761                                           pnttg2sol = point2;
762                                           par2sol = pnttg2sol.Distance(pnttg1sol);
763                                           pntcen  = point3;
764                                           parcen3 = Ufirst(3);
765                                           WellDone = Standard_True;
766                                       }
767                                   }
768                                 }
769                               }
770 }
771
772 Geom2dGcc_Circ2d2TanOnIter::
773 Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve&  Qualified1 ,
774                             const gp_Pnt2d&          Point2     ,
775                             const gp_Circ2d&         OnCirc     ,
776                             const Standard_Real      Param1     ,
777                             const Standard_Real      Param2     ,
778                             const Standard_Real      Tolerance  ) {
779                               TheSame1 = Standard_False;
780                               TheSame2 = Standard_False;
781                               par1sol = 0.;
782                               par2sol = 0.;
783                               pararg1 = 0.;
784                               pararg2 = 0.;
785                               parcen3 = 0.;
786
787                               WellDone = Standard_False;
788                               if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
789                                 Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
790                                   throw GccEnt_BadQualifier();
791                                   return;
792                               }
793                               Standard_Real Tol = Abs(Tolerance);
794                               gp_Dir2d dirx(1.,0.);
795                               Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
796                               math_Vector Umin(1,3);
797                               math_Vector Umax(1,3);
798                               math_Vector Ufirst(1,3);
799                               math_Vector tol(1,3);
800                               Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
801                               Umin(2) = RealFirst();
802                               Umin(3) = 0.;
803                               Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
804                               Umax(2) = RealLast();
805                               Umax(3) = RealLast();
806                               Ufirst(1) = Param1;
807                               Ufirst(2) = Param2;
808                               tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
809                               tol(2) = 2.e-15*M_PI;
810                               tol(3) = Tol/10.;
811                               gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
812                               gp_Pnt2d point3 = ElCLib::Value(Param2,OnCirc);
813                               Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
814                               Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnCirc,Max(Ufirst(3), Tol));
815                               math_FunctionSetRoot Root(Func, tol);
816                               Root.Perform(Func, Ufirst, Umin, Umax);
817                               Func.Value(Ufirst,Umin);
818                               if (Root.IsDone()) {
819                                 Root.Root(Ufirst);
820                                 gp_Pnt2d point1new,point3new;
821                                 gp_Vec2d Tan1,Tan3;
822                                 Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1new,Tan1);
823                                 ElCLib::D1(Ufirst(2),OnCirc,point3new,Tan3);
824                                 Standard_Real dist1 = point3new.Distance(point1new);
825                                 Standard_Real dist2 = point3new.Distance(Point2);
826                                 if ( Abs(dist1-dist2)/2. <= Tol) {
827                                   cirsol = gp_Circ2d(gp_Ax2d(point3new,dirx),(dist1+dist2)/2.);
828                                   Standard_Real normetan1 = Tan1.Magnitude();
829                                   gp_Vec2d Vec1(point1new,point3new);
830                                   Standard_Real normevec1 = Vec1.Magnitude();
831                                   Standard_Real angle1;
832                                   if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
833                                     angle1 = Vec1.Angle(Tan1);
834                                   }
835                                   else { angle1 = 0.; }
836                                   if (Qualified1.IsUnqualified()||
837                                     (Qualified1.IsEnclosing()&&angle1<=0.)||
838                                     (Qualified1.IsOutside() && angle1 >= 0.) ||
839                                     (Qualified1.IsEnclosed() && angle1 <= 0.)) {
840                                       qualifier1 = Qualified1.Qualifier();
841                                       qualifier2 = GccEnt_noqualifier;
842                                       pnttg1sol = point1new;
843                                       pararg1 = Ufirst(1);
844                                       par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
845                                       pnttg2sol = Point2;
846                                       pararg2 = 0.;
847                                       par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
848                                       pntcen  = point3new;
849                                       parcen3 = Ufirst(3);
850                                       WellDone = Standard_True;
851                                   }
852                                 }
853                               }
854 }
855
856 Geom2dGcc_Circ2d2TanOnIter::
857 Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 , 
858                             const Geom2dGcc_QCurve& Qualified2 , 
859                             const Geom2dAdaptor_Curve&          OnCurv     ,
860                             const Standard_Real               Param1     ,
861                             const Standard_Real               Param2     ,
862                             const Standard_Real               Param3     ,
863                             const Standard_Real               Tolerance  ) {
864                               TheSame1 = Standard_False;
865                               TheSame2 = Standard_False;
866                               par1sol = 0.;
867                               par2sol = 0.;
868                               pararg1 = 0.;
869                               pararg2 = 0.;
870                               parcen3 = 0.;
871
872                               WellDone = Standard_False;
873                               Standard_Real Tol = Abs(Tolerance);
874                               WellDone = Standard_False;
875                               if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
876                                 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
877                                 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
878                                 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
879                                   throw GccEnt_BadQualifier();
880                                   return;
881                               }
882                               gp_Dir2d dirx(1.,0.);
883                               Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
884                               Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
885                               math_Vector Umin(1,4);
886                               math_Vector Umax(1,4);
887                               math_Vector Ufirst(1,4);
888                               math_Vector tol(1,4);
889                               Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
890                               Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
891                               Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
892                               Umin(4) = 0.;
893                               Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
894                               Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
895                               Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
896                               Umax(4) = RealLast();
897                               Ufirst(1) = Param1;
898                               Ufirst(2) = Param2;
899                               Ufirst(3) = Param3;
900                               tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
901                               tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
902                               tol(3) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
903                               tol(4) = Tol/10.;
904                               gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
905                               gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
906                               gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,Param3);
907                               Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
908                               Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnCurv,Max(Ufirst(4), Tol));
909                               math_FunctionSetRoot Root(Func, tol);
910                               Root.Perform(Func, Ufirst, Umin, Umax);
911                               Func.Value(Ufirst,Umin);
912                               if (Root.IsDone()) {
913                                 Root.Root(Ufirst);
914                                 gp_Vec2d Tan1,Tan2,Tan3;
915                                 Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
916                                 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
917                                 Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
918                                 Standard_Real dist1 = point3.Distance(point1);
919                                 Standard_Real dist2 = point3.Distance(point2);
920                                 if ( Abs(dist1-dist2)/2. <= Tol) {
921                                   cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
922                                   Standard_Real normetan1 = Tan1.Magnitude();
923                                   Standard_Real normetan2 = Tan2.Magnitude();
924                                   gp_Vec2d Vec1(point1,point3);
925                                   gp_Vec2d Vec2(point2,point3);
926                                   Standard_Real normevec1 = Vec1.Magnitude();
927                                   Standard_Real normevec2 = Vec2.Magnitude();
928                                   Standard_Real angle1,angle2;
929                                   if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
930                                     angle1 = Vec1.Angle(Tan1);
931                                   }
932                                   else { angle1 = 0.; }
933                                   if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
934                                     angle2 = Vec2.Angle(Tan2);
935                                   }
936                                   else { angle2 = 0.; }
937                                   if (Qualified1.IsUnqualified()||
938                                     (Qualified1.IsEnclosing()&&angle1<=0.)||
939                                     (Qualified1.IsOutside() && angle1 >= 0.) ||
940                                     (Qualified1.IsEnclosed() && angle1 <= 0.)) {
941                                       if (Qualified2.IsUnqualified() || 
942                                         (Qualified2.IsEnclosing()&&angle2<=0.)||
943                                         (Qualified2.IsOutside() && angle2 >= 0) ||
944                                         (Qualified2.IsEnclosed() && angle2 <= 0.)) {
945                                           qualifier1 = Qualified1.Qualifier();
946                                           qualifier2 = Qualified2.Qualifier();
947                                           pararg1 = Ufirst(1);
948                                           par1sol = 0.;
949                                           pnttg1sol = point1;
950                                           pararg2 = Ufirst(2);
951                                           pnttg2sol = point2;
952                                           par2sol = pnttg2sol.Distance(pnttg1sol);
953                                           pntcen  = point3;
954                                           parcen3 = Ufirst(3);
955                                           WellDone = Standard_True;
956                                       }
957                                   }
958                                 }
959                               }
960 }
961
962 Geom2dGcc_Circ2d2TanOnIter::
963 Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 , 
964                             const Geom2dGcc_QCurve&       Qualified2 , 
965                             const Geom2dAdaptor_Curve&                OnCurv     ,
966                             const Standard_Real                     Param1     ,
967                             const Standard_Real                     Param2     ,
968                             const Standard_Real                     ParamOn    ,
969                             const Standard_Real                     Tolerance     ) {
970
971                               TheSame1 = Standard_False;
972                               TheSame2 = Standard_False;
973                               par1sol = 0.;
974                               par2sol = 0.;
975                               pararg1 = 0.;
976                               pararg2 = 0.;
977                               parcen3 = 0.;
978
979                               WellDone = Standard_False;
980                               if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
981                                 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
982                                 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
983                                 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
984                                   throw GccEnt_BadQualifier();
985                                   return;
986                               }
987                               Standard_Real Tol = Abs(Tolerance);
988                               gp_Circ2d C1 = Qualified1.Qualified();
989                               Standard_Real R1 = C1.Radius();
990                               Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
991                               math_Vector Umin(1,4);
992                               math_Vector Umax(1,4);
993                               math_Vector Ufirst(1,4);
994                               math_Vector tol(1,4);
995                               Umin(1) = RealFirst();
996                               Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
997                               Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
998                               Umin(4) = 0.;
999                               Umax(1) = RealLast();
1000                               Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
1001                               Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
1002                               Umax(4) = RealLast();
1003                               Ufirst(1) = Param1;
1004                               Ufirst(2) = Param2;
1005                               Ufirst(3) = ParamOn;
1006                               tol(1) = 2.e-15*M_PI;
1007                               tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
1008                               tol(3) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
1009                               tol(4) = Tol/10.;
1010                               gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
1011                               gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
1012                               gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
1013                               Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
1014                               Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnCurv,Max(Ufirst(4), Tol));
1015                               math_FunctionSetRoot Root(Func, tol);
1016                               Root.Perform(Func, Ufirst, Umin, Umax);
1017                               Func.Value(Ufirst,Umin);
1018                               if (Root.IsDone()) {
1019                                 Root.Root(Ufirst);
1020                                 gp_Vec2d Tan1,Tan2,Tan3;
1021                                 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
1022                                 Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
1023                                 ElCLib::D1(Ufirst(1),C1,point1,Tan1);
1024                                 Standard_Real dist1 = point3.Distance(point1);
1025                                 Standard_Real dist2 = point3.Distance(point2);
1026                                 if ( Abs(dist1-dist2)/2. <= Tol) {
1027                                   gp_Dir2d dirx(1.,0.);
1028                                   cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
1029                                   Standard_Real normetan2 = Tan2.Magnitude();
1030                                   gp_Vec2d Vec1(point1.XY(),point3.XY());
1031                                   gp_Vec2d Vec2(point2.XY(),point3.XY());
1032                                   Standard_Real normevec2 = Vec2.Magnitude();
1033                                   Standard_Real angle2;
1034                                   if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
1035                                     angle2 = Vec2.Angle(Tan2);
1036                                   }
1037                                   else { angle2 = 0.; }
1038                                   Standard_Real dist = C1.Location().Distance(point3);
1039                                   Standard_Real Rsol = cirsol.Radius();
1040                                   if (Qualified1.IsUnqualified() || 
1041                                     (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
1042                                     (Qualified1.IsOutside() && dist >= Rsol) ||
1043                                     (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
1044                                       if (Qualified2.IsUnqualified() || 
1045                                         (Qualified2.IsEnclosing()&&angle2<=0.)||
1046                                         (Qualified2.IsOutside() && angle2 >= 0) ||
1047                                         (Qualified2.IsEnclosed() && angle2 <= 0.)) {
1048                                           qualifier1 = Qualified1.Qualifier();
1049                                           qualifier2 = Qualified2.Qualifier();
1050                                           pnttg1sol = point1;
1051                                           pararg1 = Ufirst(1);
1052                                           par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
1053                                           pnttg2sol = point2;
1054                                           pararg2 = Ufirst(2);
1055                                           par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
1056                                           pntcen  = point3;
1057                                           parcen3 = Ufirst(3);
1058                                           WellDone = Standard_True;
1059                                       }
1060                                   }
1061                                 }
1062                               }
1063 }
1064
1065 Geom2dGcc_Circ2d2TanOnIter::
1066 Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin&  Qualified1 , 
1067                             const Geom2dGcc_QCurve&     Qualified2 , 
1068                             const Geom2dAdaptor_Curve&                OnCurv     ,
1069                             const Standard_Real                     Param1     ,
1070                             const Standard_Real                     Param2     ,
1071                             const Standard_Real                     ParamOn    ,
1072                             const Standard_Real                     Tolerance  ) {
1073                               TheSame1 = Standard_False;
1074                               TheSame2 = Standard_False;
1075                               par1sol = 0.;
1076                               par2sol = 0.;
1077                               pararg1 = 0.;
1078                               pararg2 = 0.;
1079                               parcen3 = 0.;
1080
1081                               WellDone = Standard_False;
1082                               if (!(Qualified1.IsEnclosed() ||
1083                                 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
1084                                 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
1085                                 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
1086                                   throw GccEnt_BadQualifier();
1087                                   return;
1088                               }
1089                               Standard_Real Tol = Abs(Tolerance);
1090                               gp_Dir2d dirx(1.,0.);
1091                               gp_Lin2d L1 = Qualified1.Qualified();
1092                               Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
1093                               math_Vector Umin(1,4);
1094                               math_Vector Umax(1,4);
1095                               math_Vector Ufirst(1,4);
1096                               math_Vector tol(1,4);
1097                               Umin(1) = RealFirst();
1098                               Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
1099                               Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
1100                               Umin(4) = 0.;
1101                               Umax(1) = RealLast();
1102                               Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
1103                               Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
1104                               Umax(4) = RealLast();
1105                               Ufirst(1) = Param1;
1106                               Ufirst(2) = Param2;
1107                               Ufirst(3) = ParamOn;
1108                               tol(1) = 1.e-15;
1109                               tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
1110                               tol(3) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
1111                               tol(4) = Tol/10.;
1112                               gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
1113                               gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
1114                               gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
1115                               Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
1116                               Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnCurv,Max(Ufirst(4), Tol));
1117                               math_FunctionSetRoot Root(Func, tol);
1118                               Root.Perform(Func, Ufirst, Umin, Umax);
1119                               Func.Value(Ufirst,Umin);
1120                               if (Root.IsDone()) {
1121                                 Root.Root(Ufirst);
1122                                 gp_Vec2d Tan1,Tan2,Tan3;
1123                                 ElCLib::D1(Ufirst(1),L1,point1,Tan1);
1124                                 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
1125                                 Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
1126                                 Standard_Real dist1 = point3.Distance(point1);
1127                                 Standard_Real dist2 = point3.Distance(point2);
1128                                 if ( Abs(dist1-dist2)/2. <= Tol) {
1129                                   cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
1130                                   Standard_Real normetan2 = Tan2.Magnitude();
1131                                   gp_Vec2d Vec1(point1,point3);
1132                                   gp_Vec2d Vec2(point2,point3);
1133                                   Standard_Real normevec2 = Vec2.Magnitude();
1134                                   Standard_Real angle2;
1135                                   if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
1136                                     angle2 = Vec2.Angle(Tan2);
1137                                   }
1138                                   else { angle2 = 0.; }
1139                                   Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
1140                                     L1.Direction().X()));
1141                                   if (Qualified1.IsUnqualified() ||
1142                                     (Qualified1.IsOutside() && pscal <= 0.) ||
1143                                     (Qualified1.IsEnclosed() && pscal >= 0.)) {
1144                                       if (Qualified2.IsUnqualified() || 
1145                                         (Qualified2.IsEnclosing()&&angle2<=0.)||
1146                                         (Qualified2.IsOutside() && angle2 >= 0) ||
1147                                         (Qualified2.IsEnclosed() && angle2 <= 0.)) {
1148                                           qualifier1 = Qualified1.Qualifier();
1149                                           qualifier2 = Qualified2.Qualifier();
1150                                           pnttg1sol = point1;
1151                                           pararg1 = Ufirst(1);
1152                                           par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
1153                                           pnttg2sol = point2;
1154                                           pararg2 = Ufirst(2);
1155                                           par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
1156                                           pntcen  = point3;
1157                                           parcen3 = Ufirst(3);
1158                                           WellDone = Standard_True;
1159                                       }
1160                                   }
1161                                 }
1162                               }
1163 }
1164
1165 Geom2dGcc_Circ2d2TanOnIter::
1166 Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve&    Qualified1 ,
1167                             const gp_Pnt2d&             Point2     ,
1168                             const Geom2dAdaptor_Curve&             OnCurv     ,
1169                             const Standard_Real                  Param1     ,
1170                             const Standard_Real                  ParamOn    ,
1171                             const Standard_Real                  Tolerance  ) 
1172 {
1173   TheSame1 = Standard_False;
1174   TheSame2 = Standard_False;
1175   par1sol = 0.;
1176   par2sol = 0.;
1177   pararg1 = 0.;
1178   pararg2 = 0.;
1179   parcen3 = 0.;
1180
1181   WellDone = Standard_False;
1182   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
1183     Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
1184       throw GccEnt_BadQualifier();
1185       return;
1186   }
1187   Standard_Real Tol = Abs(Tolerance);
1188   gp_Dir2d dirx(1.,0.);
1189   Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
1190   math_Vector Umin(1,3);
1191   math_Vector Umax(1,3);
1192   math_Vector Ufirst(1,3);
1193   math_Vector tol(1,3);
1194   Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
1195   Umin(2) = RealFirst();
1196   Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
1197   Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
1198   Umax(2) = RealLast();
1199   Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
1200   Ufirst(1) = Param1;
1201   Ufirst(2) = ParamOn;
1202   tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
1203   tol(2) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
1204   tol(3) = Tol/10.;
1205   gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
1206   gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
1207   Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
1208   Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnCurv,Max(Ufirst(3), Tol));
1209   math_FunctionSetRoot Root(Func, tol);
1210   Root.Perform(Func, Ufirst, Umin, Umax);
1211   Func.Value(Ufirst,Umin);
1212   if (Root.IsDone()) {
1213     Root.Root(Ufirst);
1214     //    gp_Vec2d Tan1,Tan2,Tan3;
1215     gp_Vec2d Tan1,Tan3;
1216     Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
1217     Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
1218     Standard_Real dist1 = point3.Distance(point1);
1219     Standard_Real dist2 = point3.Distance(Point2);
1220     if ( Abs(dist1-dist2)/2. <= Tol) {
1221       cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
1222       Standard_Real normetan1 = Tan1.Magnitude();
1223       gp_Vec2d Vec1(point1,point3);
1224       Standard_Real normevec1 = Vec1.Magnitude();
1225       Standard_Real angle1;
1226       if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
1227         angle1 = Vec1.Angle(Tan1);
1228       }
1229       else { angle1 = 0.; }
1230       if (Qualified1.IsUnqualified()||
1231         (Qualified1.IsEnclosing()&&angle1<=0.)||
1232         (Qualified1.IsOutside() && angle1 >= 0.) ||
1233         (Qualified1.IsEnclosed() && angle1 <= 0.)) {
1234           qualifier1 = Qualified1.Qualifier();
1235           qualifier2 = GccEnt_noqualifier;
1236           pnttg1sol = point1;
1237           pararg1 = Ufirst(1);
1238           par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
1239           pnttg2sol = Point2;
1240           pararg2 = 0.;
1241           par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
1242           pntcen  = point3;
1243           parcen3 = Ufirst(3);
1244           WellDone = Standard_True;
1245       }
1246     }
1247   }
1248 }
1249
1250 Standard_Boolean Geom2dGcc_Circ2d2TanOnIter::
1251 IsDone () const{ return WellDone; }
1252
1253 gp_Circ2d Geom2dGcc_Circ2d2TanOnIter::
1254 ThisSolution () const{ return cirsol; }
1255
1256 void Geom2dGcc_Circ2d2TanOnIter:: 
1257 WhichQualifier (GccEnt_Position& Qualif1  ,
1258                 GccEnt_Position& Qualif2  ) const
1259 {
1260   if (!WellDone) { throw StdFail_NotDone(); }
1261   else {
1262     Qualif1 = qualifier1;
1263     Qualif2 = qualifier2;
1264   }
1265 }
1266
1267 void Geom2dGcc_Circ2d2TanOnIter:: 
1268 Tangency1 (Standard_Real&      ParSol         ,
1269            Standard_Real&      ParArg         ,
1270            gp_Pnt2d&  PntSol         ) const
1271 {
1272   if (!WellDone) { throw StdFail_NotDone(); }
1273   else {
1274     if (TheSame1 == 0) {
1275       ParSol = 0;
1276       ParArg = 0;
1277       PntSol = pnttg1sol;
1278     }
1279     else { throw StdFail_NotDone(); }
1280   }
1281 }
1282
1283 void Geom2dGcc_Circ2d2TanOnIter:: 
1284 Tangency2 (Standard_Real&      ParSol         ,
1285            Standard_Real&      ParArg         ,
1286            gp_Pnt2d&  PntSol         ) const
1287 {
1288   if (!WellDone) { throw StdFail_NotDone(); }
1289   else {
1290     ParSol = 0;
1291     ParArg = 0;
1292     PntSol = pnttg2sol;
1293   }
1294 }
1295
1296 void Geom2dGcc_Circ2d2TanOnIter::
1297 CenterOn3 (Standard_Real&      ParArg         ,
1298            gp_Pnt2d&  PntSol         ) const
1299 {
1300   if (!WellDone) { throw StdFail_NotDone(); }
1301   else {
1302     ParArg = 0;
1303     PntSol = pntcen;
1304   }
1305 }
1306
1307 Standard_Boolean Geom2dGcc_Circ2d2TanOnIter::
1308 IsTheSame1 () const
1309 {
1310   if (!WellDone) throw StdFail_NotDone();
1311
1312   if (TheSame1 == 0) 
1313     return Standard_False;
1314   return Standard_True;
1315 }
1316
1317
1318 Standard_Boolean Geom2dGcc_Circ2d2TanOnIter::
1319 IsTheSame2 () const
1320 {
1321   if (!WellDone) throw StdFail_NotDone();
1322   return Standard_False;
1323 }