0024778: Convertation of the generic classes to the non-generic. Part 9
authordln <dln@opencascade.com>
Fri, 28 Mar 2014 07:28:22 +0000 (11:28 +0400)
committerapn <apn@opencascade.com>
Fri, 4 Apr 2014 08:57:43 +0000 (12:57 +0400)
Generic classes:

 "GccIter_Circ2d2TanOn",
 "GccIter_Circ2d3Tan",
 "GccIter_Lin2d2Tan",
 "GccIter_Lin2dTanObl"

from "GccIter" package were converted to the non-generic classes and moved to the "Geom2dGcc" package. Names of this classes were changed to:

 "Geom2dGcc_Circ2d2TanOnIter",
 "Geom2dGcc_Circ2d3TanIter",
 "Geom2dGcc_Lin2d2TanIter",
 "Geom2dGcc_Lin2dTanOblIter".

And their internal classes:

 "GccIter_FunctionTanCuCuOnCu",
 "GccIter_FunctionTanCuCuCu",
 "GccIter_FunctionTanCirCu",
 "GccIter_FunctionTanCuCu",
 "GccIter_FunctionTanCuPnt",
 "GccIter_FunctionTanObl"

also converted to the non-generic and moved to the "Geom2dGcc" package(their declarations were moved to "Geom2dGcc.cdl").

Enumerations" Type1, Type2 and Type3 were moved to "Geom2dGcc.cdl".

Package "GccIter" was deleted.

41 files changed:
adm/UDLIST
src/GccIter/GccIter.cdl [deleted file]
src/GccIter/GccIter_Circ2d2TanOn.gxx [deleted file]
src/GccIter/GccIter_Circ2d3Tan.gxx [deleted file]
src/GccIter/GccIter_FunctionTanCirCu.gxx [deleted file]
src/GccIter/GccIter_FunctionTanCuCu.gxx [deleted file]
src/GccIter/GccIter_FunctionTanCuPnt.gxx [deleted file]
src/GccIter/GccIter_FunctionTanObl.gxx [deleted file]
src/GccIter/GccIter_Lin2d2Tan.gxx [deleted file]
src/GccIter/GccIter_Lin2dTanObl.gxx [deleted file]
src/Geom2dGcc/Geom2dGcc.cdl
src/Geom2dGcc/Geom2dGcc_Circ2d2TanOn.cdl
src/Geom2dGcc/Geom2dGcc_Circ2d2TanOn.cxx
src/Geom2dGcc/Geom2dGcc_Circ2d2TanOnIter.cdl [moved from src/GccIter/GccIter_Circ2d2TanOn.cdl with 85% similarity]
src/Geom2dGcc/Geom2dGcc_Circ2d2TanOnIter.cxx [new file with mode: 0644]
src/Geom2dGcc/Geom2dGcc_Circ2d3Tan.cdl
src/Geom2dGcc/Geom2dGcc_Circ2d3Tan.cxx
src/Geom2dGcc/Geom2dGcc_Circ2d3TanIter.cdl [moved from src/GccIter/GccIter_Circ2d3Tan.cdl with 88% similarity]
src/Geom2dGcc/Geom2dGcc_Circ2d3TanIter.cxx [new file with mode: 0644]
src/Geom2dGcc/Geom2dGcc_FunctionTanCirCu.cdl [moved from src/GccIter/GccIter_FunctionTanCirCu.cdl with 86% similarity]
src/Geom2dGcc/Geom2dGcc_FunctionTanCirCu.cxx [new file with mode: 0644]
src/Geom2dGcc/Geom2dGcc_FunctionTanCuCu.cdl [moved from src/GccIter/GccIter_FunctionTanCuCu.cdl with 82% similarity]
src/Geom2dGcc/Geom2dGcc_FunctionTanCuCu.cxx [new file with mode: 0644]
src/Geom2dGcc/Geom2dGcc_FunctionTanCuCuCu.cdl [moved from src/GccIter/GccIter_FunctionTanCuCuCu.cdl with 70% similarity]
src/Geom2dGcc/Geom2dGcc_FunctionTanCuCuCu.cxx [moved from src/GccIter/GccIter_FunctionTanCuCuCu.gxx with 53% similarity]
src/Geom2dGcc/Geom2dGcc_FunctionTanCuCuOnCu.cdl [moved from src/GccIter/GccIter_FunctionTanCuCuOnCu.cdl with 67% similarity]
src/Geom2dGcc/Geom2dGcc_FunctionTanCuCuOnCu.cxx [moved from src/GccIter/GccIter_FunctionTanCuCuOnCu.gxx with 68% similarity]
src/Geom2dGcc/Geom2dGcc_FunctionTanCuPnt.cdl [moved from src/GccIter/GccIter_FunctionTanCuPnt.cdl with 89% similarity]
src/Geom2dGcc/Geom2dGcc_FunctionTanCuPnt.cxx [new file with mode: 0644]
src/Geom2dGcc/Geom2dGcc_FunctionTanObl.cdl [moved from src/GccIter/GccIter_FunctionTanObl.cdl with 84% similarity]
src/Geom2dGcc/Geom2dGcc_FunctionTanObl.cxx [new file with mode: 0644]
src/Geom2dGcc/Geom2dGcc_Lin2d2Tan.cdl
src/Geom2dGcc/Geom2dGcc_Lin2d2Tan.cxx
src/Geom2dGcc/Geom2dGcc_Lin2d2TanIter.cdl [moved from src/GccIter/GccIter_Lin2d2Tan.cdl with 84% similarity]
src/Geom2dGcc/Geom2dGcc_Lin2d2TanIter.cxx [new file with mode: 0644]
src/Geom2dGcc/Geom2dGcc_Lin2dTanObl.cdl
src/Geom2dGcc/Geom2dGcc_Lin2dTanObl.cxx
src/Geom2dGcc/Geom2dGcc_Lin2dTanOblIter.cdl [moved from src/GccIter/GccIter_Lin2dTanObl.cdl with 87% similarity]
src/Geom2dGcc/Geom2dGcc_Lin2dTanOblIter.cxx [new file with mode: 0644]
src/QABugs/QABugs_17.cxx
src/TKGeomAlgo/PACKAGES

index 5c25272..fbe43e9 100644 (file)
@@ -134,7 +134,6 @@ p FilletSurf
 p GccAna
 p GccEnt
 p GccInt
-p GccIter
 p Geom2dAPI
 p Geom2dGcc
 p Geom2dHatch
diff --git a/src/GccIter/GccIter.cdl b/src/GccIter/GccIter.cdl
deleted file mode 100644 (file)
index ace7551..0000000
+++ /dev/null
@@ -1,74 +0,0 @@
--- Created on: 1991-04-04
--- Created by: Remi GILET
--- Copyright (c) 1991-1999 Matra Datavision
--- Copyright (c) 1999-2014 OPEN CASCADE SAS
---
--- This file is part of Open CASCADE Technology software library.
---
--- This library is free software; you can redistribute it and/or modify it under
--- the terms of the GNU Lesser General Public License version 2.1 as published
--- by the Free Software Foundation, with special exception defined in the file
--- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
--- distribution for complete text of the license and disclaimer of any warranty.
---
--- Alternatively, this file may be used under the terms of Open CASCADE
--- commercial license or contractual agreement.
-
-package GccIter
-
-    ---Purpose :
-    --           This package provides an implementation of analytics 
-    --           algorithms (using only non persistant entities) used 
-    --           to create 2d lines or circles with geometric constraints.
-    --
-    -- Exceptions :
-    --                     IsParallel which inherits DomainError. This exception 
-    --                     is raised in the class Lin2dTanObl when we want to 
-    --                     find the intersection point between the solution and 
-    --                     the second argument with a null angle.
-
-uses GccEnt,
-     GccInt,
-     GccAna,
-     StdFail,
-     gp,
-     math
-
-is
-
-enumeration Type1 is CuCuCu,CiCuCu,CiCiCu,CiLiCu,LiLiCu,LiCuCu;
-
-enumeration Type2 is CuCuOnCu,CiCuOnCu,LiCuOnCu,CuPtOnCu,
-                     CuCuOnLi,CiCuOnLi,LiCuOnLi,CuPtOnLi,
-                    CuCuOnCi,CiCuOnCi,LiCuOnCi,CuPtOnCi;
-
-enumeration Type3 is CuCu,CiCu;
-
-generic class FunctionTanCuCu;
-
-generic class FunctionTanCirCu;
-
-generic class FunctionTanCuCuCu;
-
-generic class FunctionTanCuCuOnCu;
-
-generic class FunctionTanCuPnt;
-
-generic class FunctionTanObl;
-
-generic class Lin2dTanObl, FuncTObl;
-    -- Create a 2d line TANgent to a 2d curve and OBLic to a 2d line.
-
-generic class Lin2d2Tan, FuncTCuCu, FuncTCirCu, FuncTCuPt;
-    -- Create a 2d line TANgent to 2 2d entities.
-
-generic class Circ2d3Tan, FuncTCuCuCu;
-    -- Create a 2d circle TANgent to 3 2d entities.
-
-generic class Circ2d2TanOn, FuncTCuCuOnCu;
-    -- Create a 2d circle TANgent to a 2d entity and centered ON a 2d 
-    -- entity (not a point).
-
-exception IsParallel inherits DomainError from Standard;
-
-end GccIter;
diff --git a/src/GccIter/GccIter_Circ2d2TanOn.gxx b/src/GccIter/GccIter_Circ2d2TanOn.gxx
deleted file mode 100644 (file)
index 44454dd..0000000
+++ /dev/null
@@ -1,1297 +0,0 @@
-// Created on: 1991-12-13
-// Created by: Remi GILET
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//=========================================================================
-//   Creation d un cercle tangent a deux elements : Droite.               +
-//                                                  Cercle.               +
-//                                                  Point.                +
-//                                                  Courbes.              +
-//                        centre sur un troisieme : Droite.               +
-//                                                  Cercle.               +
-//                                                  Courbes.              +
-//=========================================================================
-
-#include <gp_Dir2d.hxx>
-#include <gp_Ax2d.hxx>
-#include <gp.hxx>
-#include <StdFail_NotDone.hxx>
-#include <GccEnt_BadQualifier.hxx>
-#include <math_FunctionSetRoot.hxx>
-#include <ElCLib.hxx>
-
-GccIter_Circ2d2TanOn::
-   GccIter_Circ2d2TanOn (const GccEnt_QualifiedLin&  Qualified1 , 
-                        const TheQualifiedCurve&    Qualified2 , 
-                        const gp_Lin2d&             OnLine     ,
-                        const Standard_Real         Param1     ,
-                        const Standard_Real         Param2     ,
-                        const Standard_Real         Param3     ,
-                        const Standard_Real         Tolang     ) {
-
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   parcen3 = 0.;
-
-   WellDone = Standard_False;
-   Standard_Real Tol = Abs(Tolang);
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() ||
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   gp_Dir2d dirx(1.,0.);
-   gp_Lin2d L1 = Qualified1.Qualified();
-   TheCurve Cu2 = Qualified2.Qualified();
-   math_Vector Umin(1,4);
-   math_Vector Umax(1,4);
-   math_Vector Ufirst(1,4);
-   math_Vector tol(1,4);
-   Umin(1) = RealFirst();
-   Umin(2) = TheCurveTool::FirstParameter(Cu2);
-   Umin(3) = RealFirst();
-   Umin(4) = 0.;
-   Umax(1) = RealLast();
-   Umax(2) = TheCurveTool::LastParameter(Cu2);
-   Umax(3) = RealLast();
-   Umax(4) = RealLast();
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   Ufirst(3) = Param3;
-   tol(1) = 1.e-15;
-   tol(2) = TheCurveTool::EpsX(Cu2,Tolang);
-   tol(3) = tol(1);   
-   tol(4) = tol(1);   
-   gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
-   gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
-   gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
-   Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
-   GccIter_FuncTCuCuOnCu Func(L1,Cu2,OnLine,Ufirst(4));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   Func.Value(Ufirst,Umin);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-//     gp_Vec2d Tan1,Tan2,Nor1,Nor2;
-     gp_Vec2d Tan1,Tan2;
-     ElCLib::D1(Ufirst(1),L1,point1,Tan1);
-     TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-     gp_Vec2d Tan3(OnLine.Direction().XY());
-     gp_Pnt2d point3(OnLine.Location().XY()+Ufirst(3)*Tan3.XY());
-     Standard_Real dist1 = point3.Distance(point1);
-     Standard_Real dist2 = point3.Distance(point2);
-     if ( Abs(dist1-dist2)/2. <= Tol) {
-       cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
-       Standard_Real normetan2 = Tan2.Magnitude();
-       gp_Vec2d Vec1(point1,point3);
-       gp_Vec2d Vec2(point2,point3);
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real angle2;
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        angle2 = Vec2.Angle(Tan2);
-       }
-       else { angle2 = 0.; }
-       Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
-                                       L1.Direction().X()));
-       if (Qualified1.IsUnqualified() ||
-          (Qualified1.IsOutside() && pscal <= 0.) ||
-          (Qualified1.IsEnclosed() && pscal >= 0.)) {
-        if (Qualified2.IsUnqualified() || 
-            (Qualified2.IsEnclosing()&&angle2<=0.)||
-            (Qualified2.IsOutside() && angle2 >= 0) ||
-            (Qualified2.IsEnclosed() && angle2 <= 0.)) {
-          qualifier1 = Qualified1.Qualifier();
-          qualifier2 = Qualified2.Qualifier();
-          pnttg1sol = point1;
-          pararg1 = Ufirst(1);
-          par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
-          pnttg2sol = point2;
-          pararg2 = Ufirst(2);
-          par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
-          pntcen  = point3;
-          parcen3 = Ufirst(3);
-          WellDone = Standard_True;
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d2TanOn::
-   GccIter_Circ2d2TanOn (const TheQualifiedCurve& Qualified1 , 
-                           const TheQualifiedCurve& Qualified2 , 
-                           const gp_Lin2d&          OnLine     ,
-                           const Standard_Real               Param1     ,
-                           const Standard_Real               Param2     ,
-                           const Standard_Real               Param3     ,
-                           const Standard_Real               Tolerance  ) {
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   parcen3 = 0.;
-
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   Standard_Real Tol = Abs(Tolerance);
-   gp_Dir2d dirx(1.,0.);
-   TheCurve Cu1 = Qualified1.Qualified();
-   TheCurve Cu2 = Qualified2.Qualified();
-   math_Vector Umin(1,4);
-   math_Vector Umax(1,4);
-   math_Vector Ufirst(1,4);
-   math_Vector tol(1,4);
-   Umin(1) = TheCurveTool::FirstParameter(Cu1);
-   Umin(2) = TheCurveTool::FirstParameter(Cu2);
-   Umin(3) = RealFirst();
-   Umin(4) = 0.;
-   Umax(1) = TheCurveTool::LastParameter(Cu1);
-   Umax(2) = TheCurveTool::LastParameter(Cu2);
-   Umax(3) = RealLast();
-   Umax(4) = RealLast();
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   Ufirst(3) = Param3;
-   tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
-   tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
-   tol(3) = 1.e-15;   
-   tol(4) = Tol/10.;   
-   gp_Pnt2d point1 = TheCurveTool::Value(Cu1,Param1);
-   gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
-   gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
-   Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
-   GccIter_FuncTCuCuOnCu Func(Cu1,Cu2,OnLine,Ufirst(4));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   Func.Value(Ufirst,Umin);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     gp_Vec2d Tan1,Tan2;
-     TheCurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
-     TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-     gp_Vec2d Tan3(OnLine.Direction().XY());
-     gp_Pnt2d point3(OnLine.Location().XY()+Ufirst(3)*Tan3.XY());
-     Standard_Real dist1 = point3.Distance(point1);
-     Standard_Real dist2 = point3.Distance(point2);
-     if ( Abs(dist1-dist2)/2. <= Tol) {
-       cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
-       Standard_Real normetan1 = Tan1.Magnitude();
-       Standard_Real normetan2 = Tan2.Magnitude();
-       gp_Vec2d Vec1(point1,point3);
-       gp_Vec2d Vec2(point2,point3);
-       Standard_Real normevec1 = Vec1.Magnitude();
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real angle1,angle2;
-       if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
-        angle1 = Vec1.Angle(Tan1);
-       }
-       else { angle1 = 0.; }
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        angle2 = Vec2.Angle(Tan2);
-       }
-       else { angle2 = 0.; }
-       if (Qualified1.IsUnqualified()||
-          (Qualified1.IsEnclosing()&&angle1<=0.)||
-          (Qualified1.IsOutside() && angle1 >= 0.) ||
-          (Qualified1.IsEnclosed() && angle1 <= 0.)) {
-        if (Qualified2.IsUnqualified() || 
-            (Qualified2.IsEnclosing()&&angle2<=0.)||
-            (Qualified2.IsOutside() && angle2 >= 0) ||
-            (Qualified2.IsEnclosed() && angle2 <= 0.)) {
-          qualifier1 = Qualified1.Qualifier();
-          qualifier2 = Qualified2.Qualifier();
-          pnttg1sol = point1;
-          pararg1 = Ufirst(1);
-          par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
-          pnttg2sol = point2;
-          pararg2 = Ufirst(2);
-          par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
-          pntcen  = point3;
-          parcen3 = Ufirst(3);
-          WellDone = Standard_True;
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d2TanOn::
-   GccIter_Circ2d2TanOn (const TheQualifiedCurve& Qualified1 , 
-                        const gp_Pnt2d&          Point2     , 
-                        const gp_Lin2d&          OnLine     ,
-                        const Standard_Real      Param1     ,
-                        const Standard_Real      Param2     ,
-                        const Standard_Real      Tolerance  ) {
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   parcen3 = 0.;
-
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   Standard_Real Tol = Abs(Tolerance);
-   gp_Dir2d dirx(1.,0.);
-   TheCurve Cu1 = Qualified1.Qualified();
-   math_Vector Umin(1,3);
-   math_Vector Umax(1,3);
-   math_Vector Ufirst(1,3);
-   math_Vector tol(1,3);
-   Umin(1) = TheCurveTool::FirstParameter(Cu1);
-   Umin(2) = RealFirst();
-   Umin(3) = 0.;
-   Umax(1) = TheCurveTool::LastParameter(Cu1);
-   Umax(2) = RealLast();
-   Umax(3) = RealLast();
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
-   tol(2) = 1.e-15;
-   tol(3) = Tol/10.;
-   gp_Pnt2d point1 = TheCurveTool::Value(Cu1,Param1);
-   gp_Pnt2d point3 = ElCLib::Value(Param2,OnLine);
-   Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
-   GccIter_FuncTCuCuOnCu Func(Cu1,Point2,OnLine,Ufirst(3));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   Func.Value(Ufirst,Umin);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     gp_Pnt2d point1,point3;
-     gp_Vec2d Tan1,Tan3;
-     TheCurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
-     ElCLib::D1(Ufirst(2),OnLine,point3,Tan3);
-     Standard_Real dist1 = point3.Distance(point1);
-     Standard_Real dist2 = point3.Distance(Point2);
-     if ( Abs(dist1-dist2)/2. <= Tol) {
-       cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
-       Standard_Real normetan1 = Tan1.Magnitude();
-       gp_Vec2d Vec1(point1,point3);
-       Standard_Real normevec1 = Vec1.Magnitude();
-       Standard_Real angle1;
-       if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
-        angle1 = Vec1.Angle(Tan1);
-       }
-       else { angle1 = 0.; }
-       if (Qualified1.IsUnqualified()||
-          (Qualified1.IsEnclosing()&&angle1<=0.)||
-          (Qualified1.IsOutside() && angle1 >= 0.) ||
-          (Qualified1.IsEnclosed() && angle1 <= 0.)) {
-        qualifier1 = Qualified1.Qualifier();
-        qualifier2 = GccEnt_noqualifier;
-        pnttg1sol = point1;
-        pararg1 = Ufirst(1);
-        par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
-        pnttg2sol = Point2;
-        pararg2 = Ufirst(2);
-        par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
-        pntcen  = point3;
-        parcen3 = Ufirst(3);
-        WellDone = Standard_True;
-       }
-     }
-   }
- }
-
-GccIter_Circ2d2TanOn::
-   GccIter_Circ2d2TanOn (const GccEnt_QualifiedCirc& Qualified1 , 
-                        const TheQualifiedCurve&    Qualified2 , 
-                        const gp_Lin2d&             OnLine     ,
-                        const Standard_Real         Param1     ,
-                        const Standard_Real         Param2     ,
-                        const Standard_Real         Param3     ,
-                        const Standard_Real         Tolerance  ) {
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   parcen3 = 0.;
-
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   Standard_Real Tol = Abs(Tolerance);
-   gp_Dir2d dirx(1.,0.);
-   gp_Circ2d C1 = Qualified1.Qualified();
-   Standard_Real R1 = C1.Radius();
-   TheCurve Cu2 = Qualified2.Qualified();
-   math_Vector Umin(1,4);
-   math_Vector Umax(1,4);
-   math_Vector Ufirst(1,4);
-   math_Vector tol(1,4);
-   Umin(1) = RealFirst();
-   Umin(2) = TheCurveTool::FirstParameter(Cu2);
-   Umin(3) = RealFirst();
-   Umin(4) = 0.;
-   Umax(1) = RealLast();
-   Umax(2) = TheCurveTool::LastParameter(Cu2);
-   Umax(3) = RealLast();
-   Umax(4) = RealLast();
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   Ufirst(3) = Param3;
-   tol(1) = 2.e-15*M_PI;
-   tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
-   tol(3) = 1.e-15;
-   tol(4) = Tol/10.;
-   gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
-   gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
-   gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
-   Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
-   GccIter_FuncTCuCuOnCu Func(C1,Cu2,OnLine,Ufirst(4));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   Func.Value(Ufirst,Umin);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-//     gp_Vec2d Tan1,Tan2,Nor1,Nor2;
-     gp_Vec2d Tan1,Tan2,Nor2;
-     ElCLib::D2(Ufirst(1),C1,point1,Tan1,Nor2);
-     TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-#ifdef DEB
-     gp_Vec2d Tan3(OnLine.Direction().XY());
-#else
-     OnLine.Direction().XY();
-#endif
-     point3 = ElCLib::Value(Ufirst(1),OnLine);
-     Standard_Real dist1 = point3.Distance(point1);
-     Standard_Real dist2 = point3.Distance(point2);
-     if ( Abs(dist1-dist2)/2. <= Tol) {
-       cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
-       Standard_Real normetan2 = Tan2.Magnitude();
-       gp_Vec2d Vec1(point1,point3);
-       gp_Vec2d Vec2(point2,point3);
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real angle2;
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        angle2 = Vec2.Angle(Tan2);
-       }
-       else { angle2 = 0.; }
-       Standard_Real dist = C1.Location().Distance(point3);
-       Standard_Real Rsol = cirsol.Radius();
-       if (Qualified1.IsUnqualified() || 
-          (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
-          (Qualified1.IsOutside() && dist >= Rsol) ||
-          (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
-        if (Qualified2.IsUnqualified() || 
-            (Qualified2.IsEnclosing()&&angle2<=0.)||
-            (Qualified2.IsOutside() && angle2 >= 0) ||
-            (Qualified2.IsEnclosed() && angle2 <= 0.)) {
-          qualifier1 = Qualified1.Qualifier();
-          qualifier2 = Qualified2.Qualifier();
-          pnttg1sol = point1;
-          pararg1 = Ufirst(1);
-          par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
-          pnttg2sol = point2;
-          pararg2 = Ufirst(2);
-          par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
-          pntcen  = point3;
-          parcen3 = Ufirst(3);
-          WellDone = Standard_True;
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d2TanOn::
-   GccIter_Circ2d2TanOn (const GccEnt_QualifiedCirc& Qualified1 , 
-                        const TheQualifiedCurve&    Qualified2 , 
-                        const gp_Circ2d&            OnCirc     ,
-                        const Standard_Real         Param1     ,
-                        const Standard_Real         Param2     ,
-                        const Standard_Real         Param3     ,
-                        const Standard_Real         Tolerance  ) {
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   parcen3 = 0.;
-
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   Standard_Real Tol = Abs(Tolerance);
-   gp_Dir2d dirx(1.,0.);
-   gp_Circ2d C1 = Qualified1.Qualified();
-   Standard_Real R1 = C1.Radius();
-   TheCurve Cu2 = Qualified2.Qualified();
-   math_Vector Umin(1,4);
-   math_Vector Umax(1,4);
-   math_Vector Ufirst(1,4);
-   math_Vector tol(1,4);
-   Umin(1) = RealFirst();
-   Umin(2) = TheCurveTool::FirstParameter(Cu2);
-   Umin(3) = RealFirst();
-   Umin(4) = 0.;
-   Umax(1) = RealLast();
-   Umax(2) = TheCurveTool::LastParameter(Cu2);
-   Umax(3) = RealLast();
-   Umax(4) = RealLast();
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   Ufirst(3) = Param3;
-   tol(1) = 2.e-15*M_PI;
-   tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
-   tol(3) = 2.e-15*M_PI;
-   tol(4) = Tol/10.;
-   gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
-   gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
-   gp_Pnt2d point3 = ElCLib::Value(Param3,OnCirc);
-   Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
-   GccIter_FuncTCuCuOnCu Func(C1,Cu2,OnCirc,Ufirst(4));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   Func.Value(Ufirst,Umin);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-//     gp_Vec2d Tan1,Tan2,Nor1;
-     gp_Vec2d Tan1,Tan2;
-     ElCLib::D1(Ufirst(1),C1,point1,Tan1);
-     TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-#ifdef DEB
-     gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
-#endif
-     point3 = ElCLib::Value(Ufirst(3),OnCirc);
-     Standard_Real dist1 = point3.Distance(point1);
-     Standard_Real dist2 = point3.Distance(point2);
-     if ( Abs(dist1-dist2)/2. <= Tol) {
-       cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
-       Standard_Real normetan2 = Tan2.Magnitude();
-       gp_Vec2d Vec1(point1,point3);
-       gp_Vec2d Vec2(point2,point3);
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real angle2;
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        angle2 = Vec2.Angle(Tan2);
-       }
-       else { angle2 = 0.; }
-       Standard_Real dist = C1.Location().Distance(point3);
-       Standard_Real Rsol = cirsol.Radius();
-       if (Qualified1.IsUnqualified() || 
-          (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
-          (Qualified1.IsOutside() && dist >= Rsol) ||
-          (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
-        if (Qualified2.IsUnqualified() || 
-            (Qualified2.IsEnclosing()&&angle2<=0.)||
-            (Qualified2.IsOutside() && angle2 >= 0) ||
-            (Qualified2.IsEnclosed() && angle2 <= 0.)) {
-          qualifier1 = Qualified1.Qualifier();
-          qualifier2 = Qualified2.Qualifier();
-          pnttg1sol = point1;
-          pararg1 = Ufirst(1);
-          par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
-          pnttg2sol = point2;
-          pararg2 = Ufirst(2);
-          par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
-          pntcen  = point3;
-          parcen3 = Ufirst(3);
-          WellDone = Standard_True;
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d2TanOn::
-   GccIter_Circ2d2TanOn (const GccEnt_QualifiedLin&  Qualified1 , 
-                        const TheQualifiedCurve&    Qualified2 , 
-                        const gp_Circ2d&            OnCirc     ,
-                        const Standard_Real         Param1     ,
-                        const Standard_Real         Param2     ,
-                        const Standard_Real         Param3     ,
-                        const Standard_Real         Tolerance  ) {
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   parcen3 = 0.;
-
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() ||
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   Standard_Real Tol = Abs(Tolerance);
-   gp_Dir2d dirx(1.,0.);
-   gp_Lin2d L1 = Qualified1.Qualified();
-   TheCurve Cu2 = Qualified2.Qualified();
-   math_Vector Umin(1,4);
-   math_Vector Umax(1,4);
-   math_Vector Ufirst(1,4);
-   math_Vector tol(1,4);
-   Umin(1) = RealFirst();
-   Umin(2) = TheCurveTool::FirstParameter(Cu2);
-   Umin(3) = RealFirst();
-   Umin(4) = 0.;
-   Umax(1) = RealLast();
-   Umax(2) = TheCurveTool::LastParameter(Cu2);
-   Umax(3) = RealLast();
-   Umax(4) = RealLast();
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   Ufirst(3) = Param3;
-   tol(1) = 1.e-15;
-   tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
-   tol(3) = 2.e-15*M_PI;
-   tol(4) = Tol/10.;
-   gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
-   gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
-   gp_Pnt2d point3 = ElCLib::Value(Param3,OnCirc);
-   Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
-   GccIter_FuncTCuCuOnCu Func(L1,Cu2,OnCirc,Ufirst(4));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   Func.Value(Ufirst,Umin);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     gp_Pnt2d point1,point2;
-     gp_Vec2d Tan1,Tan2;
-     ElCLib::D1(Ufirst(1),L1,point1,Tan1);
-     TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-#ifdef DEB
-     gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
-#endif
-     point3 = ElCLib::Value(Ufirst(3),OnCirc);
-     Standard_Real dist1 = point3.Distance(point1);
-     Standard_Real dist2 = point3.Distance(point2);
-     if ( Abs(dist1-dist2)/2. <= Tol) {
-       cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
-       Standard_Real normetan2 = Tan2.Magnitude();
-       gp_Vec2d Vec1(point1,point3);
-       gp_Vec2d Vec2(point2,point3);
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real angle2;
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        angle2 = Vec2.Angle(Tan2);
-       }
-       else { angle2 = 0.; }
-       Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
-                                       L1.Direction().X()));
-       if (Qualified1.IsUnqualified() ||
-          (Qualified1.IsOutside() && pscal <= 0.) ||
-          (Qualified1.IsEnclosed() && pscal >= 0.)) {
-        if (Qualified2.IsUnqualified() || 
-            (Qualified2.IsEnclosing()&&angle2<=0.)||
-            (Qualified2.IsOutside() && angle2 >= 0) ||
-            (Qualified2.IsEnclosed() && angle2 <= 0.)) {
-          qualifier1 = Qualified1.Qualifier();
-          qualifier2 = Qualified2.Qualifier();
-          pnttg1sol = point1;
-          pararg1 = Ufirst(1);
-          par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
-          pnttg2sol = point2;
-          pararg2 = Ufirst(2);
-          par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
-          pntcen  = point3;
-          parcen3 = Ufirst(3);
-          WellDone = Standard_True;
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d2TanOn::
-   GccIter_Circ2d2TanOn (const TheQualifiedCurve& Qualified1 , 
-                           const TheQualifiedCurve& Qualified2 , 
-                           const gp_Circ2d&         OnCirc     ,
-                           const Standard_Real               Param1     ,
-                           const Standard_Real               Param2     ,
-                           const Standard_Real               Param3     ,
-                           const Standard_Real               Tolerance  ) {
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   parcen3 = 0.;
-
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   Standard_Real Tol = Abs(Tolerance);
-   gp_Dir2d dirx(1.,0.);
-   TheCurve Cu1 = Qualified1.Qualified();
-   TheCurve Cu2 = Qualified2.Qualified();
-   math_Vector Umin(1,4);
-   math_Vector Umax(1,4);
-   math_Vector Ufirst(1,4);
-   math_Vector tol(1,4);
-   Umin(1) = TheCurveTool::FirstParameter(Cu1);
-   Umin(2) = TheCurveTool::FirstParameter(Cu2);
-   Umin(3) = RealFirst();
-   Umin(4) = 0.;
-   Umax(1) = TheCurveTool::LastParameter(Cu1);
-   Umax(2) = TheCurveTool::LastParameter(Cu2);
-   Umax(3) = RealLast();
-   Umax(4) = RealLast();
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   Ufirst(3) = Param3;
-   tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
-   tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
-   tol(3) = 2.e-15*M_PI;
-   tol(4) = Tol/10.;
-   gp_Pnt2d point1 = TheCurveTool::Value(Cu1,Param1);
-   gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
-   Standard_Real R1 = OnCirc.Radius();
-   gp_Pnt2d point3(OnCirc.Location().XY()+R1*gp_XY(Cos(Param3),Sin(Param3)));
-   Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
-   GccIter_FuncTCuCuOnCu Func(Cu1,Cu2,OnCirc,Ufirst(4));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   Func.Value(Ufirst,Umin);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-//     gp_Vec2d Tan1,Tan2,Nor1;
-     gp_Vec2d Tan1,Tan2;
-     TheCurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
-     TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-#ifdef DEB
-     gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
-#endif
-     point3 = gp_Pnt2d(OnCirc.Location().XY()+
-                      R1*gp_XY(Cos(Ufirst(3)),Sin(Ufirst(3))));
-     Standard_Real dist1 = point3.Distance(point1);
-     Standard_Real dist2 = point3.Distance(point2);
-     if ( Abs(dist1-dist2)/2. <= Tol) {
-       cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
-       Standard_Real normetan1 = Tan1.Magnitude();
-       Standard_Real normetan2 = Tan2.Magnitude();
-       gp_Vec2d Vec1(point1,point3);
-       gp_Vec2d Vec2(point2,point3);
-       Standard_Real normevec1 = Vec1.Magnitude();
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real angle1,angle2;
-       if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
-        angle1 = Vec1.Angle(Tan1);
-       }
-       else { angle1 = 0.; }
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        angle2 = Vec2.Angle(Tan2);
-       }
-       else { angle2 = 0.; }
-       if (Qualified1.IsUnqualified()||
-          (Qualified1.IsEnclosing()&&angle1<=0.)||
-          (Qualified1.IsOutside() && angle1 >= 0.) ||
-          (Qualified1.IsEnclosed() && angle1 <= 0.)) {
-        if (Qualified2.IsUnqualified() || 
-            (Qualified2.IsEnclosing()&&angle2<=0.)||
-            (Qualified2.IsOutside() && angle2 >= 0) ||
-            (Qualified2.IsEnclosed() && angle2 <= 0.)) {
-          qualifier1 = Qualified1.Qualifier();
-          qualifier2 = Qualified2.Qualifier();
-          pararg1 = Ufirst(1);
-          par1sol = 0.;
-          pnttg1sol = point1;
-          pararg2 = Ufirst(2);
-          pnttg2sol = point2;
-          par2sol = pnttg2sol.Distance(pnttg1sol);
-          pntcen  = point3;
-          parcen3 = Ufirst(3);
-          WellDone = Standard_True;
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d2TanOn::
-   GccIter_Circ2d2TanOn (const TheQualifiedCurve& Qualified1 ,
-                        const gp_Pnt2d&          Point2     ,
-                        const gp_Circ2d&         OnCirc     ,
-                        const Standard_Real      Param1     ,
-                        const Standard_Real      Param2     ,
-                        const Standard_Real      Tolerance  ) {
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   parcen3 = 0.;
-
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   Standard_Real Tol = Abs(Tolerance);
-   gp_Dir2d dirx(1.,0.);
-   TheCurve Cu1 = Qualified1.Qualified();
-   math_Vector Umin(1,3);
-   math_Vector Umax(1,3);
-   math_Vector Ufirst(1,3);
-   math_Vector tol(1,3);
-   Umin(1) = TheCurveTool::FirstParameter(Cu1);
-   Umin(2) = RealFirst();
-   Umin(3) = 0.;
-   Umax(1) = TheCurveTool::LastParameter(Cu1);
-   Umax(2) = RealLast();
-   Umax(3) = RealLast();
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
-   tol(2) = 2.e-15*M_PI;
-   tol(3) = Tol/10.;
-   gp_Pnt2d point1 = TheCurveTool::Value(Cu1,Param1);
-   gp_Pnt2d point3 = ElCLib::Value(Param2,OnCirc);
-   Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
-   GccIter_FuncTCuCuOnCu Func(Cu1,Point2,OnCirc,Ufirst(3));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   Func.Value(Ufirst,Umin);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     gp_Pnt2d point1,point3;
-     gp_Vec2d Tan1,Tan3;
-     TheCurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
-     ElCLib::D1(Ufirst(2),OnCirc,point3,Tan3);
-     Standard_Real dist1 = point3.Distance(point1);
-     Standard_Real dist2 = point3.Distance(Point2);
-     if ( Abs(dist1-dist2)/2. <= Tol) {
-       cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
-       Standard_Real normetan1 = Tan1.Magnitude();
-       gp_Vec2d Vec1(point1,point3);
-       Standard_Real normevec1 = Vec1.Magnitude();
-       Standard_Real angle1;
-       if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
-        angle1 = Vec1.Angle(Tan1);
-       }
-       else { angle1 = 0.; }
-       if (Qualified1.IsUnqualified()||
-          (Qualified1.IsEnclosing()&&angle1<=0.)||
-          (Qualified1.IsOutside() && angle1 >= 0.) ||
-          (Qualified1.IsEnclosed() && angle1 <= 0.)) {
-        qualifier1 = Qualified1.Qualifier();
-        qualifier2 = GccEnt_noqualifier;
-        pnttg1sol = point1;
-        pararg1 = Ufirst(1);
-        par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
-        pnttg2sol = Point2;
-        pararg2 = 0.;
-        par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
-        pntcen  = point3;
-        parcen3 = Ufirst(3);
-        WellDone = Standard_True;
-       }
-     }
-   }
- }
-
-GccIter_Circ2d2TanOn::
-   GccIter_Circ2d2TanOn (const TheQualifiedCurve& Qualified1 , 
-                        const TheQualifiedCurve& Qualified2 , 
-                        const TheCurve&          OnCurv     ,
-                        const Standard_Real               Param1     ,
-                        const Standard_Real               Param2     ,
-                        const Standard_Real               Param3     ,
-                        const Standard_Real               Tolerance  ) {
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   parcen3 = 0.;
-
-   WellDone = Standard_False;
-   Standard_Real Tol = Abs(Tolerance);
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   gp_Dir2d dirx(1.,0.);
-   TheCurve Cu1 = Qualified1.Qualified();
-   TheCurve Cu2 = Qualified2.Qualified();
-   math_Vector Umin(1,4);
-   math_Vector Umax(1,4);
-   math_Vector Ufirst(1,4);
-   math_Vector tol(1,4);
-   Umin(1) = TheCurveTool::FirstParameter(Cu1);
-   Umin(2) = TheCurveTool::FirstParameter(Cu2);
-   Umin(3) = TheCurveTool::FirstParameter(OnCurv);
-   Umin(4) = 0.;
-   Umax(1) = TheCurveTool::LastParameter(Cu1);
-   Umax(2) = TheCurveTool::LastParameter(Cu2);
-   Umax(3) = TheCurveTool::LastParameter(OnCurv);
-   Umax(4) = RealLast();
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   Ufirst(3) = Param3;
-   tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
-   tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
-   tol(3) = TheCurveTool::EpsX(OnCurv,Abs(Tolerance));
-   tol(4) = Tol/10.;
-   gp_Pnt2d point1 = TheCurveTool::Value(Cu1,Param1);
-   gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
-   gp_Pnt2d point3 = TheCurveTool::Value(OnCurv,Param3);
-   Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
-   GccIter_FuncTCuCuOnCu Func(Cu1,Cu2,OnCurv,Ufirst(4));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   Func.Value(Ufirst,Umin);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     gp_Vec2d Tan1,Tan2,Tan3;
-     TheCurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
-     TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-     TheCurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
-     Standard_Real dist1 = point3.Distance(point1);
-     Standard_Real dist2 = point3.Distance(point2);
-     if ( Abs(dist1-dist2)/2. <= Tol) {
-       cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
-       Standard_Real normetan1 = Tan1.Magnitude();
-       Standard_Real normetan2 = Tan2.Magnitude();
-       gp_Vec2d Vec1(point1,point3);
-       gp_Vec2d Vec2(point2,point3);
-       Standard_Real normevec1 = Vec1.Magnitude();
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real angle1,angle2;
-       if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
-        angle1 = Vec1.Angle(Tan1);
-       }
-       else { angle1 = 0.; }
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        angle2 = Vec2.Angle(Tan2);
-       }
-       else { angle2 = 0.; }
-       if (Qualified1.IsUnqualified()||
-          (Qualified1.IsEnclosing()&&angle1<=0.)||
-          (Qualified1.IsOutside() && angle1 >= 0.) ||
-          (Qualified1.IsEnclosed() && angle1 <= 0.)) {
-        if (Qualified2.IsUnqualified() || 
-            (Qualified2.IsEnclosing()&&angle2<=0.)||
-            (Qualified2.IsOutside() && angle2 >= 0) ||
-            (Qualified2.IsEnclosed() && angle2 <= 0.)) {
-          qualifier1 = Qualified1.Qualifier();
-          qualifier2 = Qualified2.Qualifier();
-          pararg1 = Ufirst(1);
-          par1sol = 0.;
-          pnttg1sol = point1;
-          pararg2 = Ufirst(2);
-          pnttg2sol = point2;
-            par2sol = pnttg2sol.Distance(pnttg1sol);
-          pntcen  = point3;
-          parcen3 = Ufirst(3);
-          WellDone = Standard_True;
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d2TanOn::
-   GccIter_Circ2d2TanOn (const GccEnt_QualifiedCirc& Qualified1 , 
-                        const TheQualifiedCurve&       Qualified2 , 
-                        const TheCurve&                OnCurv     ,
-                        const Standard_Real                     Param1     ,
-                        const Standard_Real                     Param2     ,
-                        const Standard_Real                     ParamOn    ,
-                        const Standard_Real                     Tolerance     ) {
-
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   parcen3 = 0.;
-
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   Standard_Real Tol = Abs(Tolerance);
-   gp_Circ2d C1 = Qualified1.Qualified();
-   Standard_Real R1 = C1.Radius();
-   TheCurve Cu2 = Qualified2.Qualified();
-   math_Vector Umin(1,4);
-   math_Vector Umax(1,4);
-   math_Vector Ufirst(1,4);
-   math_Vector tol(1,4);
-   Umin(1) = RealFirst();
-   Umin(2) = TheCurveTool::FirstParameter(Cu2);
-   Umin(3) = TheCurveTool::FirstParameter(OnCurv);
-   Umin(4) = 0.;
-   Umax(1) = RealLast();
-   Umax(2) = TheCurveTool::LastParameter(Cu2);
-   Umax(3) = TheCurveTool::LastParameter(OnCurv);
-   Umax(4) = RealLast();
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   Ufirst(3) = ParamOn;
-   tol(1) = 2.e-15*M_PI;
-   tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
-   tol(3) = TheCurveTool::EpsX(OnCurv,Abs(Tolerance));
-   tol(4) = Tol/10.;;
-   gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
-   gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
-   gp_Pnt2d point3 = TheCurveTool::Value(OnCurv,ParamOn);
-   Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
-   GccIter_FuncTCuCuOnCu Func(C1,Cu2,OnCurv,Ufirst(4));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   Func.Value(Ufirst,Umin);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     gp_Vec2d Tan1,Tan2,Tan3;
-     TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-     TheCurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
-     ElCLib::D1(Ufirst(1),C1,point1,Tan1);
-     Standard_Real dist1 = point3.Distance(point1);
-     Standard_Real dist2 = point3.Distance(point2);
-     if ( Abs(dist1-dist2)/2. <= Tol) {
-       gp_Dir2d dirx(1.,0.);
-       cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
-       Standard_Real normetan2 = Tan2.Magnitude();
-       gp_Vec2d Vec1(point1.XY(),point3.XY());
-       gp_Vec2d Vec2(point2.XY(),point3.XY());
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real angle2;
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        angle2 = Vec2.Angle(Tan2);
-       }
-       else { angle2 = 0.; }
-       Standard_Real dist = C1.Location().Distance(point3);
-       Standard_Real Rsol = cirsol.Radius();
-       if (Qualified1.IsUnqualified() || 
-          (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
-          (Qualified1.IsOutside() && dist >= Rsol) ||
-          (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
-        if (Qualified2.IsUnqualified() || 
-            (Qualified2.IsEnclosing()&&angle2<=0.)||
-            (Qualified2.IsOutside() && angle2 >= 0) ||
-            (Qualified2.IsEnclosed() && angle2 <= 0.)) {
-          qualifier1 = Qualified1.Qualifier();
-          qualifier2 = Qualified2.Qualifier();
-          pnttg1sol = point1;
-          pararg1 = Ufirst(1);
-          par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
-          pnttg2sol = point2;
-          pararg2 = Ufirst(2);
-          par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
-          pntcen  = point3;
-          parcen3 = Ufirst(3);
-          WellDone = Standard_True;
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d2TanOn::
-   GccIter_Circ2d2TanOn (const GccEnt_QualifiedLin&  Qualified1 , 
-                        const TheQualifiedCurve&       Qualified2 , 
-                        const TheCurve&                OnCurv     ,
-                        const Standard_Real                     Param1     ,
-                        const Standard_Real                     Param2     ,
-                        const Standard_Real                     ParamOn    ,
-                        const Standard_Real                     Tolerance  ) {
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   parcen3 = 0.;
-
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() ||
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   Standard_Real Tol = Abs(Tolerance);
-   gp_Dir2d dirx(1.,0.);
-   gp_Lin2d L1 = Qualified1.Qualified();
-   TheCurve Cu2 = Qualified2.Qualified();
-   math_Vector Umin(1,4);
-   math_Vector Umax(1,4);
-   math_Vector Ufirst(1,4);
-   math_Vector tol(1,4);
-   Umin(1) = RealFirst();
-   Umin(2) = TheCurveTool::FirstParameter(Cu2);
-   Umin(3) = TheCurveTool::FirstParameter(OnCurv);
-   Umin(4) = 0.;
-   Umax(1) = RealLast();
-   Umax(2) = TheCurveTool::LastParameter(Cu2);
-   Umax(3) = TheCurveTool::LastParameter(OnCurv);
-   Umax(4) = RealLast();
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   Ufirst(3) = ParamOn;
-   tol(1) = 1.e-15;
-   tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
-   tol(3) = TheCurveTool::EpsX(OnCurv,Abs(Tolerance));
-   tol(4) = Tol/10.;
-   gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
-   gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
-   gp_Pnt2d point3 = TheCurveTool::Value(OnCurv,ParamOn);
-   Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
-   GccIter_FuncTCuCuOnCu Func(L1,Cu2,OnCurv,Ufirst(4));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   Func.Value(Ufirst,Umin);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     gp_Vec2d Tan1,Tan2,Tan3;
-     ElCLib::D1(Ufirst(1),L1,point1,Tan1);
-     TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-     TheCurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
-     Standard_Real dist1 = point3.Distance(point1);
-     Standard_Real dist2 = point3.Distance(point2);
-     if ( Abs(dist1-dist2)/2. <= Tol) {
-       cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
-       Standard_Real normetan2 = Tan2.Magnitude();
-       gp_Vec2d Vec1(point1,point3);
-       gp_Vec2d Vec2(point2,point3);
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real angle2;
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        angle2 = Vec2.Angle(Tan2);
-       }
-       else { angle2 = 0.; }
-       Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
-                                       L1.Direction().X()));
-       if (Qualified1.IsUnqualified() ||
-          (Qualified1.IsOutside() && pscal <= 0.) ||
-          (Qualified1.IsEnclosed() && pscal >= 0.)) {
-        if (Qualified2.IsUnqualified() || 
-            (Qualified2.IsEnclosing()&&angle2<=0.)||
-            (Qualified2.IsOutside() && angle2 >= 0) ||
-            (Qualified2.IsEnclosed() && angle2 <= 0.)) {
-          qualifier1 = Qualified1.Qualifier();
-          qualifier2 = Qualified2.Qualifier();
-          pnttg1sol = point1;
-          pararg1 = Ufirst(1);
-          par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
-          pnttg2sol = point2;
-          pararg2 = Ufirst(2);
-          par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
-          pntcen  = point3;
-          parcen3 = Ufirst(3);
-          WellDone = Standard_True;
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d2TanOn::
-   GccIter_Circ2d2TanOn (const TheQualifiedCurve&    Qualified1 ,
-                        const gp_Pnt2d&             Point2     ,
-                        const TheCurve&             OnCurv     ,
-                        const Standard_Real                  Param1     ,
-                        const Standard_Real                  ParamOn    ,
-                        const Standard_Real                  Tolerance  ) 
-{
-  TheSame1 = Standard_False;
-  TheSame2 = Standard_False;
-  par1sol = 0.;
-  par2sol = 0.;
-  pararg1 = 0.;
-  pararg2 = 0.;
-  parcen3 = 0.;
-  
-  WellDone = Standard_False;
-  if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-       Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
-    GccEnt_BadQualifier::Raise();
-      return;
-    }
-  Standard_Real Tol = Abs(Tolerance);
-  gp_Dir2d dirx(1.,0.);
-  TheCurve Cu1 = Qualified1.Qualified();
-  math_Vector Umin(1,3);
-  math_Vector Umax(1,3);
-  math_Vector Ufirst(1,3);
-  math_Vector tol(1,3);
-  Umin(1) = TheCurveTool::FirstParameter(Cu1);
-  Umin(2) = RealFirst();
-  Umin(3) = TheCurveTool::FirstParameter(OnCurv);
-  Umax(1) = TheCurveTool::LastParameter(Cu1);
-  Umax(2) = RealLast();
-  Umax(3) = TheCurveTool::LastParameter(OnCurv);
-  Ufirst(1) = Param1;
-  Ufirst(2) = ParamOn;
-  tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
-  tol(2) = TheCurveTool::EpsX(OnCurv,Abs(Tolerance));
-  tol(3) = Tol/10.;
-  gp_Pnt2d point1 = TheCurveTool::Value(Cu1,Param1);
-  gp_Pnt2d point3 = TheCurveTool::Value(OnCurv,ParamOn);
-  Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
-  GccIter_FuncTCuCuOnCu Func(Cu1,Point2,OnCurv,Ufirst(3));
-  math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-  Func.Value(Ufirst,Umin);
-  if (Root.IsDone()) {
-    Root.Root(Ufirst);
-//    gp_Vec2d Tan1,Tan2,Tan3;
-    gp_Vec2d Tan1,Tan3;
-    TheCurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
-    TheCurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
-    Standard_Real dist1 = point3.Distance(point1);
-    Standard_Real dist2 = point3.Distance(Point2);
-    if ( Abs(dist1-dist2)/2. <= Tol) {
-      cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
-      Standard_Real normetan1 = Tan1.Magnitude();
-      gp_Vec2d Vec1(point1,point3);
-      Standard_Real normevec1 = Vec1.Magnitude();
-      Standard_Real angle1;
-      if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
-       angle1 = Vec1.Angle(Tan1);
-      }
-      else { angle1 = 0.; }
-      if (Qualified1.IsUnqualified()||
-         (Qualified1.IsEnclosing()&&angle1<=0.)||
-         (Qualified1.IsOutside() && angle1 >= 0.) ||
-         (Qualified1.IsEnclosed() && angle1 <= 0.)) {
-       qualifier1 = Qualified1.Qualifier();
-       qualifier2 = GccEnt_noqualifier;
-       pnttg1sol = point1;
-       pararg1 = Ufirst(1);
-       par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
-       pnttg2sol = Point2;
-       pararg2 = 0.;
-       par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
-       pntcen  = point3;
-       parcen3 = Ufirst(3);
-       WellDone = Standard_True;
-      }
-    }
-  }
-}
-
-Standard_Boolean GccIter_Circ2d2TanOn::
-  IsDone () const{ return WellDone; }
-
-gp_Circ2d GccIter_Circ2d2TanOn::
-  ThisSolution () const{ return cirsol; }
-
-void GccIter_Circ2d2TanOn:: 
-  WhichQualifier (GccEnt_Position& Qualif1  ,
-                 GccEnt_Position& Qualif2  ) const
-{
-  if (!WellDone) { StdFail_NotDone::Raise(); }
-  else {
-    Qualif1 = qualifier1;
-    Qualif2 = qualifier2;
-  }
-}
-
-void GccIter_Circ2d2TanOn:: 
-  Tangency1 (Standard_Real&      ParSol         ,
-            Standard_Real&      ParArg         ,
-            gp_Pnt2d&  PntSol         ) const
-{
-  if (!WellDone) { StdFail_NotDone::Raise(); }
-  else {
-    if (TheSame1 == 0) {
-      ParSol = 0;
-      ParArg = 0;
-      PntSol = pnttg1sol;
-    }
-    else { StdFail_NotDone::Raise(); }
-  }
-}
-
-void GccIter_Circ2d2TanOn:: 
-  Tangency2 (Standard_Real&      ParSol         ,
-            Standard_Real&      ParArg         ,
-            gp_Pnt2d&  PntSol         ) const
-{
-  if (!WellDone) { StdFail_NotDone::Raise(); }
-  else {
-    ParSol = 0;
-    ParArg = 0;
-    PntSol = pnttg2sol;
-  }
-}
-
-void GccIter_Circ2d2TanOn::
-  CenterOn3 (Standard_Real&      ParArg         ,
-            gp_Pnt2d&  PntSol         ) const
-{
-  if (!WellDone) { StdFail_NotDone::Raise(); }
-  else {
-    ParArg = 0;
-    PntSol = pntcen;
-  }
-}
-
-Standard_Boolean GccIter_Circ2d2TanOn::
-  IsTheSame1 () const
-{
-  if (!WellDone) StdFail_NotDone::Raise();
-
-  if (TheSame1 == 0) 
-    return Standard_False;
-  return Standard_True;
-}
-
-
-Standard_Boolean GccIter_Circ2d2TanOn::
-  IsTheSame2 () const
-{
-  if (!WellDone) StdFail_NotDone::Raise();
-  return Standard_False;
-}
diff --git a/src/GccIter/GccIter_Circ2d3Tan.gxx b/src/GccIter/GccIter_Circ2d3Tan.gxx
deleted file mode 100644 (file)
index 8fe0675..0000000
+++ /dev/null
@@ -1,1351 +0,0 @@
-// Created on: 1991-12-13
-// Created by: Remi GILET
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//=========================================================================
-//   Creation d un cercle tangent a deux elements : Droite.               +
-//                                                  Cercle.               +
-//                                                  Point.                +
-//                                                  Courbes.              +
-//                        centre sur un troisieme : Droite.               +
-//                                                  Cercle.               +
-//                                                  Courbes.              +
-//=========================================================================
-
-#include <gp_Dir2d.hxx>
-#include <gp_Ax2d.hxx>
-#include <gp_Vec2d.hxx>
-#include <gp.hxx>
-#include <StdFail_NotDone.hxx>
-#include <GccEnt_BadQualifier.hxx>
-#include <math_FunctionSetRoot.hxx>
-#include <math_NewtonFunctionSetRoot.hxx>
-#include <GccAna_Circ2d3Tan.hxx>
-
-GccIter_Circ2d3Tan::
-   GccIter_Circ2d3Tan (const TheQualifiedCurve& Qualified1 , 
-                      const TheQualifiedCurve& Qualified2 ,
-                      const TheQualifiedCurve& Qualified3 , 
-                      const Standard_Real      Param1     ,
-                      const Standard_Real      Param2     ,
-                      const Standard_Real      Param3     ,
-                      const Standard_Real      Tolerance  ) {
-
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   TheSame3 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   par3sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   pararg3 = 0.;
-
-   Standard_Real Tol = Abs(Tolerance);
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
-       !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() || 
-        Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   TheCurve Cu1 = Qualified1.Qualified();
-   TheCurve Cu2 = Qualified2.Qualified();
-   TheCurve Cu3 = Qualified3.Qualified();
-   GccIter_FuncTCuCuCu Func(Cu1,Cu2,Cu3);
-   math_Vector Umin(1,3);
-   math_Vector Umax(1,3);
-   math_Vector Ufirst(1,3);
-   math_Vector tol(1,3);
-   Umin(1) = TheCurveTool::FirstParameter(Cu1);
-   Umin(2) = TheCurveTool::FirstParameter(Cu2);
-   Umin(3) = TheCurveTool::FirstParameter(Cu3);
-   Umax(1) = TheCurveTool::LastParameter(Cu1);
-   Umax(2) = TheCurveTool::LastParameter(Cu2);
-   Umax(3) = TheCurveTool::LastParameter(Cu3);
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   Ufirst(3) = Param3;
-   tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
-   tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
-   tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));   
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     Func.Value(Ufirst,Umin);
-     gp_Pnt2d point1,point2,point3;
-     gp_Vec2d Tan1,Tan2,Tan3;
-     TheCurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
-     TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-     TheCurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
-     GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
-     if (circ.IsDone()) { 
-       cirsol = circ.ThisSolution(1);
-       gp_Pnt2d centre = cirsol.Location();
-       Standard_Real normetan1 = Tan1.Magnitude();
-       Standard_Real normetan2 = Tan2.Magnitude();
-       Standard_Real normetan3 = Tan3.Magnitude();
-       gp_Vec2d Vec1(point1,centre);
-       gp_Vec2d Vec2(point2,centre);
-       gp_Vec2d Vec3(point3,centre);
-       Standard_Real normevec1 = Vec1.Magnitude();
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real normevec3 = Vec3.Magnitude();
-       Standard_Real dot1,dot2,dot3;
-       if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
-        dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
-       }
-       else { dot1 = 0.; }
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
-       }
-       else { dot2 = 0.; }
-       if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
-        dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
-       }
-       else { dot3 = 0.; }
-       Tol = 1.e-12;
-       if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
-        Standard_Real Angle1 = Vec1.Angle(Tan1);
-        if (Qualified1.IsUnqualified()||
-            (Qualified1.IsEnclosing()&&Angle1<=0.)||
-            (Qualified1.IsOutside() && Angle1 >= 0.) ||
-            (Qualified1.IsEnclosed() && Angle1 <= 0.)) {
-          Angle1 = Vec2.Angle(Tan2);
-          if (Qualified2.IsUnqualified() || 
-              (Qualified2.IsEnclosing()&&Angle1<=0.)||
-              (Qualified2.IsOutside() && Angle1 >= 0) ||
-              (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
-            Angle1 = Vec3.Angle(Tan3);
-            if (Qualified3.IsUnqualified() || 
-                (Qualified3.IsEnclosing()&&Angle1<=0.)||
-                (Qualified3.IsOutside() && Angle1 >= 0) ||
-                (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
-              qualifier1 = Qualified1.Qualifier();
-              qualifier2 = Qualified2.Qualifier();
-              qualifier3 = Qualified3.Qualifier();
-              pararg1 = Ufirst(1);
-              par1sol = 0.;
-              pnttg1sol = point1;
-              pararg2 = Ufirst(2);
-              pnttg2sol = point2;
-              par2sol = pnttg2sol.Distance(pnttg1sol);
-              pnttg3sol = point3;
-              pararg3 = Ufirst(3);
-              par3sol = pnttg3sol.Distance(pnttg1sol);
-              WellDone = Standard_True;
-            }
-          }
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d3Tan::
-   GccIter_Circ2d3Tan (const GccEnt_QualifiedCirc& Qualified1 , 
-                         const TheQualifiedCurve& Qualified2 ,
-                         const TheQualifiedCurve& Qualified3 , 
-                         const Standard_Real      Param1     ,
-                         const Standard_Real      Param2     ,
-                         const Standard_Real      Param3     ,
-                         const Standard_Real      Tolerance     ) {
-
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   TheSame3 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   par3sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   pararg3 = 0.;
-
-   Standard_Real Tol = Abs(Tolerance);
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
-       !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() || 
-        Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   gp_Circ2d C1 = Qualified1.Qualified();
-   TheCurve Cu2 = Qualified2.Qualified();
-   TheCurve Cu3 = Qualified3.Qualified();
-   GccIter_FuncTCuCuCu Func(C1,Cu2,Cu3);
-   math_Vector Umin(1,3);
-   math_Vector Umax(1,3);
-   math_Vector Ufirst(1,3);
-   math_Vector tol(1,3);
-   Umin(1) = 0.;
-   Umin(2) = TheCurveTool::FirstParameter(Cu2);
-   Umin(3) = TheCurveTool::FirstParameter(Cu3);
-   Umax(1) = 2*M_PI;
-   Umax(2) = TheCurveTool::LastParameter(Cu2);
-   Umax(3) = TheCurveTool::LastParameter(Cu3);
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   Ufirst(3) = Param3;
-   tol(1) = 2.e-15*M_PI;
-   tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
-   tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));   
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     Func.Value(Ufirst,Umin);
-     gp_Pnt2d centre1(C1.Location());
-     Standard_Real R1 = C1.Radius();
-     gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
-     gp_Vec2d Tan1(gp_XY(-Sin(Ufirst(1)),Cos(Ufirst(1))));
-     gp_Pnt2d point2,point3;
-//     gp_Vec2d Tan2,Tan3,Nor2,Nor3;
-     gp_Vec2d Tan2,Tan3;
-     TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-     TheCurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
-     GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
-     if (circ.IsDone()) {
-       cirsol = circ.ThisSolution(1);
-       gp_Pnt2d centre(cirsol.Location());
-       Standard_Real dist = centre1.Distance(centre);
-       Standard_Real Rsol = cirsol.Radius();
-       Standard_Real normetan1 = Tan1.Magnitude();
-       Standard_Real normetan2 = Tan2.Magnitude();
-       Standard_Real normetan3 = Tan3.Magnitude();
-       gp_Vec2d Vec1(point1,centre);
-       gp_Vec2d Vec2(point2,centre);
-       gp_Vec2d Vec3(point3,centre);
-       Standard_Real normevec1 = Vec1.Magnitude();
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real normevec3 = Vec3.Magnitude();
-       Standard_Real dot1,dot2,dot3;
-       if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
-        dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
-       }
-       else { dot1 = 0.; }
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
-       }
-       else { dot2 = 0.; }
-       if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
-        dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
-       }
-       else { dot3 = 0.; }
-       Tol = 1.e-12;
-       if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
-        if (Qualified1.IsUnqualified() || 
-            (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
-            (Qualified1.IsOutside() && dist >= Rsol) ||
-            (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
-          Standard_Real Angle1 = Vec2.Angle(Tan2);
-          if (Qualified2.IsUnqualified() || 
-              (Qualified2.IsEnclosing()&&Angle1<=0.)||
-              (Qualified2.IsOutside() && Angle1 >= 0) ||
-              (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
-            Angle1 = Vec3.Angle(Tan3);
-            if (Qualified3.IsUnqualified() || 
-                (Qualified3.IsEnclosing()&&Angle1<=0.)||
-                (Qualified3.IsOutside() && Angle1 >= 0) ||
-                (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
-              qualifier1 = Qualified1.Qualifier();
-              qualifier2 = Qualified2.Qualifier();
-              qualifier3 = Qualified3.Qualifier();
-              pararg1 = Ufirst(1);
-              par1sol = 0.;
-              pnttg1sol = point1;
-              pararg2 = Ufirst(2);
-              pnttg2sol = point2;
-              par2sol = 0.;
-              pararg3 = Ufirst(3);
-              pnttg3sol = point3;
-              par3sol = 0.;
-              WellDone = Standard_True;
-            }
-          }
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d3Tan::
-   GccIter_Circ2d3Tan (const GccEnt_QualifiedCirc& Qualified1 , 
-                      const GccEnt_QualifiedCirc& Qualified2 , 
-                      const TheQualifiedCurve&    Qualified3 , 
-                      const Standard_Real         Param1     ,
-                      const Standard_Real         Param2     ,
-                      const Standard_Real         Param3     ,
-                      const Standard_Real         Tolerance     ) {
-
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   TheSame3 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   par3sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   pararg3 = 0.;
-
-   Standard_Real Tol = Abs(Tolerance);
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
-       !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() || 
-        Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   gp_Circ2d C1 = Qualified1.Qualified();
-   gp_Circ2d C2 = Qualified2.Qualified();
-   TheCurve Cu3 = Qualified3.Qualified();
-   GccIter_FuncTCuCuCu Func(C1,C2,Cu3);
-   math_Vector Umin(1,3);
-   math_Vector Umax(1,3);
-   math_Vector Ufirst(1,3);
-   math_Vector tol(1,3);
-   Umin(1) = 0.;
-   Umin(2) = 0.;
-   Umin(3) = TheCurveTool::FirstParameter(Cu3);
-   Umax(1) = 2*M_PI;
-   Umax(2) = 2*M_PI;
-   Umax(3) = TheCurveTool::LastParameter(Cu3);
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   Ufirst(3) = Param3;
-   tol(1) = 2.e-15*M_PI;
-   tol(2) = 2.e-15*M_PI;
-   tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));   
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     Func.Value(Ufirst,Umin);
-     gp_Pnt2d centre1(C1.Location());
-     Standard_Real R1 = C1.Radius();
-     gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
-     gp_Vec2d Tan1(gp_XY(-Sin(Ufirst(1)),Cos(Ufirst(1))));
-     gp_Pnt2d centre2(C2.Location());
-     Standard_Real R2 = C2.Radius();
-     gp_Pnt2d point2(centre2.XY()+R2*gp_XY(Cos(Ufirst(2)),Sin(Ufirst(2))));
-     gp_Vec2d Tan2(gp_XY(-Sin(Ufirst(2)),Cos(Ufirst(2))));
-     gp_Pnt2d point3;
-     gp_Vec2d Tan3;
-     TheCurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
-     GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
-     if (circ.IsDone()) {
-       cirsol = circ.ThisSolution(1);
-       gp_Pnt2d centre(cirsol.Location());
-       Standard_Real dist = centre1.Distance(centre);
-       Standard_Real Rsol = cirsol.Radius();
-       Standard_Real normetan1 = Tan1.Magnitude();
-       Standard_Real normetan2 = Tan2.Magnitude();
-       Standard_Real normetan3 = Tan3.Magnitude();
-       gp_Vec2d Vec1(point1,centre);
-       gp_Vec2d Vec2(point2,centre);
-       gp_Vec2d Vec3(point3,centre);
-       Standard_Real normevec1 = Vec1.Magnitude();
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real normevec3 = Vec3.Magnitude();
-       Standard_Real dot1,dot2,dot3;
-       if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
-        dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
-       }
-       else { dot1 = 0.; }
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
-       }
-       else { dot2 = 0.; }
-       if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
-        dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
-       }
-       else { dot3 = 0.; }
-       Tol = 1.e-12;
-       if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
-        if (Qualified1.IsUnqualified() || 
-            (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
-            (Qualified1.IsOutside() && dist >= Rsol) ||
-            (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
-          dist = centre2.Distance(centre);
-          if (Qualified1.IsUnqualified() || 
-              (Qualified1.IsEnclosing() && Rsol >= R2 && dist <= Rsol)||
-              (Qualified1.IsOutside() && dist >= Rsol) ||
-              (Qualified1.IsEnclosed() && Rsol <= R2 && dist <= Rsol)) {
-            gp_Vec2d Vec(point3,centre);
-            Standard_Real Angle1 = Vec.Angle(Tan3);
-            if (Qualified3.IsUnqualified() || 
-                (Qualified3.IsEnclosing()&&Angle1<=0.)||
-                (Qualified3.IsOutside() && Angle1 >= 0) ||
-                (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
-              qualifier1 = Qualified1.Qualifier();
-              qualifier2 = Qualified2.Qualifier();
-              qualifier3 = Qualified3.Qualifier();
-              pararg1 = Ufirst(1);
-              par1sol = 0.;
-              pnttg1sol = point1;
-              pararg2 = Ufirst(2);
-              pnttg2sol = point2;
-              par2sol = 0.;
-              pararg3 = Ufirst(3);
-              pnttg3sol = point3;
-              par3sol = 0.;
-              WellDone = Standard_True;
-            }
-          }
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d3Tan::
-   GccIter_Circ2d3Tan (const GccEnt_QualifiedLin& Qualified1 , 
-                      const TheQualifiedCurve&   Qualified2 ,
-                      const TheQualifiedCurve&   Qualified3 , 
-                      const Standard_Real        Param1     ,
-                      const Standard_Real        Param2     ,
-                      const Standard_Real        Param3     ,
-                      const Standard_Real        Tolerance  ) {
-
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   TheSame3 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   par3sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   pararg3 = 0.;
-
-   Standard_Real Tol = Abs(Tolerance);
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() ||
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
-       !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() || 
-        Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   gp_Lin2d L1 = Qualified1.Qualified();
-   TheCurve Cu2 = Qualified2.Qualified();
-   TheCurve Cu3 = Qualified3.Qualified();
-   GccIter_FuncTCuCuCu Func(L1,Cu2,Cu3);
-   math_Vector Umin(1,3);
-   math_Vector Umax(1,3);
-   math_Vector Ufirst(1,3);
-   math_Vector tol(1,3);
-   Umin(1) = RealFirst();
-   Umin(2) = TheCurveTool::FirstParameter(Cu2);
-   Umin(3) = TheCurveTool::FirstParameter(Cu3);
-   Umax(1) = RealLast();
-   Umax(2) = TheCurveTool::LastParameter(Cu2);
-   Umax(3) = TheCurveTool::LastParameter(Cu3);
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   Ufirst(3) = Param3;
-   tol(1) = 1.e-15;
-   tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
-   tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));   
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     Func.Value(Ufirst,Umin);
-     gp_Pnt2d centre1(L1.Location());
-     gp_Pnt2d point1(centre1.XY()+Ufirst(1)*L1.Direction().XY());
-     gp_Pnt2d point2,point3;
-     gp_Vec2d Tan2,Tan3;
-     TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-     TheCurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
-     GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
-     if (circ.IsDone()) {
-       cirsol = circ.ThisSolution(1);
-       gp_Pnt2d centre(cirsol.Location());
-
-       // creation vaariables intermediaires pour WNT
-       gp_XY dummy1 = centre.XY()-L1.Location().XY();
-       gp_XY dummy2 (-L1.Direction().Y(),L1.Direction().X());
-       Standard_Real pscal=dummy1.Dot(dummy2);
-
-       gp_Vec2d Tan1(L1.Direction().XY());
-       Standard_Real normetan1 = Tan1.Magnitude();
-       Standard_Real normetan2 = Tan2.Magnitude();
-       Standard_Real normetan3 = Tan3.Magnitude();
-       gp_Vec2d Vec1(point1,centre);
-       gp_Vec2d Vec2(point2,centre);
-       gp_Vec2d Vec3(point3,centre);
-       Standard_Real normevec1 = Vec1.Magnitude();
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real normevec3 = Vec3.Magnitude();
-       Standard_Real dot1,dot2,dot3;
-       if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
-        dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
-       }
-       else { dot1 = 0.; }
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
-       }
-       else { dot2 = 0.; }
-       if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
-        dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
-       }
-       else { dot3 = 0.; }
-       Tol = 1.e-12;
-       if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
-        if (Qualified1.IsUnqualified() || 
-            (Qualified1.IsOutside() && pscal <= 0.) ||
-            (Qualified1.IsEnclosed() && pscal >= 0.)) {
-          gp_Vec2d Vec(point2,centre);
-          Standard_Real Angle1 = Vec.Angle(Tan2);
-          if (Qualified2.IsUnqualified() || 
-              (Qualified2.IsEnclosing()&&Angle1<=0.)||
-              (Qualified2.IsOutside() && Angle1 >= 0) ||
-              (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
-            Vec = gp_Vec2d(point3,centre);
-            Angle1 = Vec.Angle(Tan3);
-            if (Qualified3.IsUnqualified() || 
-                (Qualified3.IsEnclosing()&&Angle1<=0.)||
-                (Qualified3.IsOutside() && Angle1 >= 0) ||
-                (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
-              qualifier1 = Qualified1.Qualifier();
-              qualifier2 = Qualified2.Qualifier();
-              qualifier3 = Qualified3.Qualifier();
-              pararg1 = Ufirst(1);
-              par1sol = 0.;
-              pnttg1sol = point1;
-              pararg2 = Ufirst(2);
-              pnttg2sol = point2;
-              par2sol = 0.;
-              pararg3 = Ufirst(3);
-              pnttg3sol = point3;
-              par3sol = 0.;
-              WellDone = Standard_True;
-            }
-          }
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d3Tan::
-   GccIter_Circ2d3Tan (const GccEnt_QualifiedLin&  Qualified1 , 
-                      const GccEnt_QualifiedLin&  Qualified2 , 
-                      const TheQualifiedCurve&    Qualified3 , 
-                      const Standard_Real         Param1     ,
-                      const Standard_Real         Param2     ,
-                      const Standard_Real         Param3     ,
-                      const Standard_Real         Tolerance  ){
-
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   TheSame3 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   par3sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   pararg3 = 0.;
-
-   Standard_Real Tol = Abs(Tolerance);
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
-       !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() || 
-        Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   gp_Lin2d L1 = Qualified1.Qualified();
-   gp_Lin2d L2 = Qualified2.Qualified();
-   TheCurve Cu3 = Qualified3.Qualified();
-   GccIter_FuncTCuCuCu Func(L1,L2,Cu3);
-   math_Vector Umin(1,3);
-   math_Vector Umax(1,3);
-   math_Vector Ufirst(1,3);
-   math_Vector tol(1,3);
-   Umin(1) = RealFirst();
-   Umin(2) = RealFirst();
-   Umin(3) = TheCurveTool::FirstParameter(Cu3);
-   Umax(1) = RealLast();
-   Umax(2) = RealLast();
-   Umax(3) = TheCurveTool::LastParameter(Cu3);
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   Ufirst(3) = Param3;
-   tol(1) = 1.e-15;
-   tol(2) = 1.e-15;
-   tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));   
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     Func.Value(Ufirst,Umin);
-     gp_Pnt2d centre1(L1.Location());
-     gp_Pnt2d point1(centre1.XY()+Ufirst(1)*L1.Direction().XY());
-     gp_Pnt2d centre2(L2.Location());
-     gp_Pnt2d point2(centre2.XY()+Ufirst(2)*L2.Direction().XY());
-     gp_Pnt2d point3;
-     gp_Vec2d Tan3;
-     TheCurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
-     GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
-     if (circ.IsDone()) {
-       cirsol = circ.ThisSolution(1);
-       gp_Pnt2d centre(cirsol.Location());
-       Standard_Real pscal=centre.XY().Dot(gp_XY(-L1.Direction().Y(),
-                                       L1.Direction().X()));
-       if (Qualified1.IsUnqualified() || 
-          (Qualified1.IsOutside() && pscal <= 0.) ||
-          (Qualified1.IsEnclosed() && pscal >= 0.)) {
-        Standard_Real pscal=centre.XY().Dot(gp_XY(-L1.Direction().Y(),
-                                         L1.Direction().X()));
-        gp_Vec2d Tan1(L1.Direction().XY());
-        gp_Vec2d Tan2(L2.Direction().XY());
-        Standard_Real normetan1 = Tan1.Magnitude();
-        Standard_Real normetan2 = Tan2.Magnitude();
-        Standard_Real normetan3 = Tan3.Magnitude();
-        gp_Vec2d Vec1(point1,centre);
-        gp_Vec2d Vec2(point2,centre);
-        gp_Vec2d Vec3(point3,centre);
-        Standard_Real normevec1 = Vec1.Magnitude();
-        Standard_Real normevec2 = Vec2.Magnitude();
-        Standard_Real normevec3 = Vec3.Magnitude();
-        Standard_Real dot1,dot2,dot3;
-        if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
-          dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
-        }
-        else { dot1 = 0.; }
-        if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-          dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
-        }
-        else { dot2 = 0.; }
-        if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
-          dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
-        }
-        else { dot3 = 0.; }
-        Tol = 1.e-12;
-        if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
-          if (Qualified2.IsUnqualified() || 
-              (Qualified2.IsOutside() && pscal <= 0.) ||
-              (Qualified2.IsEnclosed() && pscal >= 0.)) {
-            Standard_Real Angle1 = Vec3.Angle(Tan3);
-            if (Qualified3.IsUnqualified() || 
-                (Qualified3.IsEnclosing()&&Angle1<=0.)||
-                (Qualified3.IsOutside() && Angle1 >= 0) ||
-                (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
-              qualifier1 = Qualified1.Qualifier();
-              qualifier2 = Qualified2.Qualifier();
-              qualifier3 = Qualified3.Qualifier();
-              pararg1 = Ufirst(1);
-              par1sol = 0.;
-              pnttg1sol = point1;
-              pararg2 = Ufirst(2);
-              pnttg2sol = point2;
-              par2sol = 0.;
-              pararg3 = Ufirst(3);
-              pnttg3sol = point3;
-              par3sol = 0.;
-              WellDone = Standard_True;
-            }
-          }
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d3Tan::
-   GccIter_Circ2d3Tan (const TheQualifiedCurve& Qualified1 ,
-                      const TheQualifiedCurve& Qualified2 , 
-                      const gp_Pnt2d&          Point3     ,
-                      const Standard_Real      Param1     ,
-                      const Standard_Real      Param2     ,
-                      const Standard_Real      Tolerance  ) {
-
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   TheSame3 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   par3sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   pararg3 = 0.;
-
-   Standard_Real Tol = Abs(Tolerance);
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   gp_Circ2d C1(gp_Ax2d(Point3,gp_Dir2d(1.,0.)),0.);
-   TheCurve Cu1 = Qualified1.Qualified();
-   TheCurve Cu2 = Qualified2.Qualified();
-   GccIter_FuncTCuCuCu Func(C1,Cu1,Cu2);
-   math_Vector Umin(1,3);
-   math_Vector Umax(1,3);
-   math_Vector Ufirst(1,3);
-   math_Vector tol(1,3);
-   Umin(1) = 0.;
-   Umin(2) = TheCurveTool::FirstParameter(Cu1);
-   Umin(3) = TheCurveTool::FirstParameter(Cu2);
-   Umax(1) = 2*M_PI;
-   Umax(2) = TheCurveTool::LastParameter(Cu1);
-   Umax(3) = TheCurveTool::LastParameter(Cu2);
-   Ufirst(1) = M_PI;
-   Ufirst(2) = Param1;
-   Ufirst(3) = Param2;
-   tol(1) = 2.e-15*M_PI;
-   tol(2) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
-   tol(3) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     Func.Value(Ufirst,Umin);
-     gp_Pnt2d point1,point2;
-//     gp_Vec2d Tan1,Tan2,Nor1,Nor2;
-     gp_Vec2d Tan1,Tan2;
-     TheCurveTool::D1(Cu1,Ufirst(2),point1,Tan1);
-     TheCurveTool::D1(Cu2,Ufirst(3),point2,Tan2);
-     GccAna_Circ2d3Tan circ(Point3,point1,point2,Tol);
-     if (circ.IsDone()) {
-       cirsol = circ.ThisSolution(1);
-       gp_Pnt2d centre(cirsol.Location());
-       gp_Vec2d Tan3(-Sin(Ufirst(1)),Cos(Ufirst(1)));
-       Standard_Real normetan1 = Tan1.Magnitude();
-       Standard_Real normetan2 = Tan2.Magnitude();
-       Standard_Real normetan3 = Tan3.Magnitude();
-       gp_Vec2d Vec1(point1,centre);
-       gp_Vec2d Vec2(point2,centre);
-       gp_Vec2d Vec3(Point3,centre);
-       Standard_Real normevec1 = Vec1.Magnitude();
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real normevec3 = Vec3.Magnitude();
-       Standard_Real dot1,dot2,dot3;
-       if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
-        dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
-       }
-       else { dot1 = 0.; }
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
-       }
-       else { dot2 = 0.; }
-       if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
-        dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
-       }
-       else { dot3 = 0.; }
-       Tol = 1.e-12;
-       if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
-        Standard_Real Angle1 = Vec1.Angle(Tan1);
-        if (Qualified1.IsUnqualified()||
-            (Qualified1.IsEnclosing()&&Angle1<=0.)||
-            (Qualified1.IsOutside() && Angle1 >= 0) ||
-            (Qualified1.IsEnclosed() && Angle1 <= 0.)) {
-          Angle1 = Vec2.Angle(Tan2);
-          if (Qualified1.IsUnqualified() ||
-              (Qualified1.IsEnclosing()&&Angle1<=0.)||
-              (Qualified1.IsOutside() && Angle1 >= 0) ||
-              (Qualified1.IsEnclosed() && Angle1 <= 0.)) {
-            qualifier1 = Qualified1.Qualifier();
-            qualifier2 = Qualified2.Qualifier();
-            qualifier3 = GccEnt_noqualifier;
-            pararg1 = Ufirst(2);
-            par1sol = 0.;
-            pnttg1sol = point1;
-            pararg2 = Ufirst(3);
-            pnttg2sol = point2;
-            par2sol = 0.;
-            pararg3 = 0.;
-            pnttg3sol = Point3;
-            par3sol = 0.;
-            WellDone = Standard_True;
-          }
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d3Tan::
-   GccIter_Circ2d3Tan (const TheQualifiedCurve& Qualified1 ,
-                         const gp_Pnt2d&          Point2     ,
-                         const gp_Pnt2d&          Point3     ,
-                         const Standard_Real      Param1     ,
-                         const Standard_Real      Tolerance     ) {
-
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   TheSame3 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   par3sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   pararg3 = 0.;
-
-   Standard_Real Tol = Abs(Tolerance);
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   gp_Dir2d dirx(1.,0.);
-   gp_Circ2d C1(gp_Ax2d(Point2,dirx),0.);
-   gp_Circ2d C2(gp_Ax2d(Point3,dirx),0.);
-   TheCurve Cu1 = Qualified1.Qualified();
-   GccIter_FuncTCuCuCu Func(C1,C2,Cu1);
-   math_Vector Umin(1,3);
-   math_Vector Umax(1,3);
-   math_Vector Ufirst(1,3);
-   math_Vector tol(1,3);
-   Umin(1) = 0.;
-   Umin(2) = 0.;
-   Umin(3) = TheCurveTool::FirstParameter(Cu1);
-   Umax(1) = 2*M_PI;
-   Umax(2) = 2*M_PI;
-   Umax(3) = TheCurveTool::LastParameter(Cu1);
-   Ufirst(1) = M_PI;
-   Ufirst(2) = M_PI;
-   Ufirst(3) = Param1;
-   tol(1) = 2.e-15*M_PI;
-   tol(2) = 2.e-15*M_PI;
-   tol(3) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     Func.Value(Ufirst,Umin);
-     gp_Pnt2d point3;
-//     gp_Vec2d Tan3,Nor3;
-     gp_Vec2d Tan3;
-     TheCurveTool::D1(Cu1,Ufirst(3),point3,Tan3);
-     GccAna_Circ2d3Tan circ(Point2,Point3,point3,Tol);
-     if (circ.IsDone()) { 
-       cirsol = circ.ThisSolution(1);
-       gp_Pnt2d centre(cirsol.Location());
-       gp_Vec2d Tan2(-Sin(Ufirst(2)),Cos(Ufirst(2)));
-       gp_Vec2d Tan1(-Sin(Ufirst(1)),Cos(Ufirst(1)));
-       Standard_Real normetan1 = Tan1.Magnitude();
-       Standard_Real normetan2 = Tan2.Magnitude();
-       Standard_Real normetan3 = Tan3.Magnitude();
-       gp_Vec2d Vec1(Point2,centre);
-       gp_Vec2d Vec2(Point3,centre);
-       gp_Vec2d Vec3(point3,centre);
-       Standard_Real normevec1 = Vec1.Magnitude();
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real normevec3 = Vec3.Magnitude();
-       Standard_Real dot1,dot2,dot3;
-       if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
-        dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
-       }
-       else { dot1 = 0.; }
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
-       }
-       else { dot2 = 0.; }
-       if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
-        dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
-       }
-       else { dot3 = 0.; }
-       Tol = 1.e-12;
-       if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
-        Standard_Real Angle1 = Vec1.Angle(Tan1);
-        if (Qualified1.IsUnqualified() ||
-            (Qualified1.IsEnclosing()&&Angle1<=0.)||
-            (Qualified1.IsOutside() && Angle1 >= 0) ||
-            (Qualified1.IsEnclosed() && Angle1 <= 0.)) {
-          qualifier1 = Qualified1.Qualifier();
-          qualifier2 = GccEnt_noqualifier;
-          qualifier3 = GccEnt_noqualifier;
-          pararg1 = Ufirst(3);
-          par1sol = 0.;
-          pnttg1sol = point3;
-          pararg2 = 0.;
-          pnttg2sol = Point2;
-          par2sol = 0.;
-          pararg3 = 0.;
-          pnttg3sol = Point3;
-          par3sol = 0.;
-          WellDone = Standard_True;
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d3Tan::
-   GccIter_Circ2d3Tan (const GccEnt_QualifiedLin&  Qualified1 , 
-                      const TheQualifiedCurve&    Qualified2 ,
-                      const gp_Pnt2d&             Point3     ,
-                      const Standard_Real         Param1     ,
-                      const Standard_Real         Param2     ,
-                      const Standard_Real         Tolerance  ) {
-
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   TheSame3 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   par3sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   pararg3 = 0.;
-
-   Standard_Real Tol = Abs(Tolerance);
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() ||
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   gp_Dir2d dirx(1.,0.);
-   gp_Lin2d L1 = Qualified1.Qualified();
-   TheCurve Cu2 = Qualified2.Qualified();
-   gp_Circ2d C3(gp_Ax2d(Point3,dirx),0.);
-   GccIter_FuncTCuCuCu Func(C3,L1,Cu2);
-   math_Vector Umin(1,3);
-   math_Vector Umax(1,3);
-   math_Vector Ufirst(1,3);
-   math_Vector tol(1,3);
-   Umin(2) = RealFirst();
-   Umin(3) = TheCurveTool::FirstParameter(Cu2);
-   Umin(1) = 0.;
-   Umax(2) = RealLast();
-   Umax(3) = TheCurveTool::LastParameter(Cu2);
-   Umax(1) = 2*M_PI;
-   Ufirst(2) = Param1;
-   Ufirst(3) = Param2;
-   Ufirst(1) = M_PI;
-   tol(1) = 2.e-15;
-   tol(2) = 1.e-15;
-   tol(3) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     Func.Value(Ufirst,Umin);
-     gp_Pnt2d centre1(L1.Location());
-     gp_Pnt2d point1(centre1.XY()+Ufirst(2)*L1.Direction().XY());
-     gp_Pnt2d point2;
-     gp_Vec2d Tan2;
-     TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-     GccAna_Circ2d3Tan circ(point1,point2,Point3,Tol);
-     if (circ.IsDone()) {
-       cirsol = circ.ThisSolution(1);
-       gp_Pnt2d centre(cirsol.Location());
-       Standard_Real pscal=centre.XY().Dot(gp_XY(-L1.Direction().Y(),
-                                       L1.Direction().X()));
-       gp_Vec2d Tan1(L1.Direction().XY());
-       gp_Vec2d Tan3(-Sin(Ufirst(1)),Cos(Ufirst(1)));
-       Standard_Real normetan1 = Tan1.Magnitude();
-       Standard_Real normetan2 = Tan2.Magnitude();
-       Standard_Real normetan3 = Tan3.Magnitude();
-       gp_Vec2d Vec1(point1,centre);
-       gp_Vec2d Vec2(point2,centre);
-       gp_Vec2d Vec3(Point3,centre);
-       Standard_Real normevec1 = Vec1.Magnitude();
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real normevec3 = Vec3.Magnitude();
-       Standard_Real dot1,dot2,dot3;
-       if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
-        dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
-       }
-       else { dot1 = 0.; }
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
-       }
-       else { dot2 = 0.; }
-       if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
-        dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
-       }
-       else { dot3 = 0.; }
-       Tol = 1.e-12;
-       if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
-        if (Qualified1.IsUnqualified() || 
-            (Qualified1.IsOutside() && pscal <= 0.) ||
-            (Qualified1.IsEnclosed() && pscal >= 0.)) {
-          Standard_Real Angle1 = Vec2.Angle(Tan2);
-          if (Qualified2.IsUnqualified() || 
-              (Qualified2.IsEnclosing()&&Angle1<=0.)||
-              (Qualified2.IsOutside() && Angle1 >= 0) ||
-              (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
-            qualifier1 = Qualified1.Qualifier();
-            qualifier2 = Qualified2.Qualifier();
-            qualifier3 = GccEnt_noqualifier;
-            pararg1 = Ufirst(2);
-            par1sol = 0.;
-            pnttg1sol = point1;
-            pararg2 = Ufirst(3);
-            pnttg2sol = point2;
-            par2sol = 0.;
-            pararg3 = 0.;
-            pnttg3sol = Point3;
-            par3sol = 0.;
-            WellDone = Standard_True;
-          }
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d3Tan::
-   GccIter_Circ2d3Tan (const GccEnt_QualifiedCirc& Qualified1 , 
-                      const GccEnt_QualifiedLin&  Qualified2 , 
-                      const TheQualifiedCurve&    Qualified3 , 
-                      const Standard_Real         Param1     ,
-                      const Standard_Real         Param2     ,
-                      const Standard_Real         Param3     ,
-                      const Standard_Real         Tolerance  ) {
-     
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   TheSame3 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   par3sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   pararg3 = 0.;
-
-   Standard_Real Tol = Abs(Tolerance);
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() ||
-        Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
-       !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() || 
-        Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   gp_Circ2d C1 = Qualified1.Qualified();
-   gp_Lin2d L2 = Qualified2.Qualified();
-   TheCurve Cu3 = Qualified3.Qualified();
-   GccIter_FuncTCuCuCu Func(C1,L2,Cu3);
-   math_Vector Umin(1,3);
-   math_Vector Umax(1,3);
-   math_Vector Ufirst(1,3);
-   math_Vector tol(1,3);
-   Umin(1) = 0.;
-   Umin(2) = RealFirst();
-   Umin(3) = TheCurveTool::FirstParameter(Cu3);
-   Umax(1) = 2*M_PI;
-   Umax(2) = RealLast();
-   Umax(3) = TheCurveTool::LastParameter(Cu3);
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   Ufirst(3) = Param3;
-   tol(1) = 2.e-15*M_PI;
-   tol(2) = 1.e-15;
-   tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   if (Root.IsDone()) {
-     Func.Value(Ufirst,Umin);
-     Root.Root(Ufirst);
-     gp_Pnt2d centre1(C1.Location());
-     Standard_Real R1 = C1.Radius();
-     gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
-     gp_Pnt2d centre2(L2.Location());
-     gp_Pnt2d point2(centre2.XY()+Ufirst(2)*L2.Direction().XY());
-     gp_Pnt2d point3;
-     gp_Vec2d Tan3;
-     TheCurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
-     GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
-     if (circ.IsDone()) {
-       cirsol = circ.ThisSolution(1);
-       gp_Pnt2d centre(cirsol.Location());
-       gp_Vec2d Tan1(-Sin(Ufirst(1)),Cos(Ufirst(1)));
-       gp_Vec2d Tan2(L2.Direction().XY());
-       Standard_Real normetan1 = Tan1.Magnitude();
-       Standard_Real normetan2 = Tan2.Magnitude();
-       Standard_Real normetan3 = Tan3.Magnitude();
-       gp_Vec2d Vec1(point1,centre);
-       gp_Vec2d Vec2(point2,centre);
-       gp_Vec2d Vec3(point3,centre);
-       Standard_Real normevec1 = Vec1.Magnitude();
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real normevec3 = Vec3.Magnitude();
-       Standard_Real dot1,dot2,dot3;
-       if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
-        dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
-       }
-       else { dot1 = 0.; }
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
-       }
-       else { dot2 = 0.; }
-       if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
-        dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
-       }
-       else { dot3 = 0.; }
-       Tol = 1.e-12;
-       if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
-        Standard_Real dist = centre1.Distance(centre);
-        Standard_Real Rsol = cirsol.Radius();
-        if (Qualified1.IsUnqualified() || 
-            (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
-            (Qualified1.IsOutside() && dist >= Rsol) ||
-            (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
-          Standard_Real pscal=centre.XY().Dot(gp_XY(-L2.Direction().Y(),
-                                           L2.Direction().X()));
-          if (Qualified2.IsUnqualified() || 
-              (Qualified2.IsOutside() && pscal <= 0.) ||
-              (Qualified2.IsEnclosed() && pscal >= 0.)) {
-            Standard_Real Angle1 = Vec3.Angle(Tan3);
-            if (Qualified3.IsUnqualified() || 
-                (Qualified3.IsEnclosing()&&Angle1<=0.)||
-                (Qualified3.IsOutside() && Angle1 >= 0) ||
-                (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
-              qualifier1 = Qualified1.Qualifier();
-              qualifier2 = Qualified2.Qualifier();
-              qualifier3 = Qualified3.Qualifier();
-              pararg1 = Ufirst(1);
-              par1sol = 0.;
-              pnttg1sol = point1;
-              pararg2 = Ufirst(2);
-              pnttg2sol = point2;
-              par2sol = 0.;
-              pararg3 = Ufirst(3);
-              pnttg3sol = point3;
-              par3sol = 0.;
-              WellDone = Standard_True;
-            }
-          }
-        }
-       }
-     }
-   }
- }
-
-GccIter_Circ2d3Tan::
-   GccIter_Circ2d3Tan (const GccEnt_QualifiedCirc& Qualified1 , 
-                      const TheQualifiedCurve&    Qualified2 ,
-                      const gp_Pnt2d&             Point3     ,
-                      const Standard_Real         Param1     ,
-                      const Standard_Real         Param2     ,
-                      const Standard_Real         Tolerance  ) {
-     
-   TheSame1 = Standard_False;
-   TheSame2 = Standard_False;
-   TheSame3 = Standard_False;
-   par1sol = 0.;
-   par2sol = 0.;
-   par3sol = 0.;
-   pararg1 = 0.;
-   pararg2 = 0.;
-   pararg3 = 0.;
-
-   Standard_Real Tol = Abs(Tolerance);
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   gp_Circ2d C1 = Qualified1.Qualified();
-   TheCurve Cu2 = Qualified2.Qualified();
-   gp_Dir2d dirx(1.,0.);
-   gp_Circ2d C3(gp_Ax2d(Point3,dirx),0.);
-   GccIter_FuncTCuCuCu Func(C1,C3,Cu2);
-   math_Vector Umin(1,3);
-   math_Vector Umax(1,3);
-   math_Vector Ufirst(1,3);
-   math_Vector tol(1,3);
-   Umin(1) = 0.;
-   Umin(3) = TheCurveTool::FirstParameter(Cu2);
-   Umin(2) = 0.;
-   Umax(1) = 2*M_PI;
-   Umax(3) = TheCurveTool::LastParameter(Cu2);
-   Umax(2) = 2*M_PI;
-   Ufirst(1) = Param1;
-   Ufirst(2) = M_PI;
-   Ufirst(3) = Param2;
-   tol(1) = 2.e-15*M_PI;
-   tol(2) = 2.e-15*M_PI;
-   tol(3) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-     Func.Value(Ufirst,Umin);
-     gp_Pnt2d centre1(C1.Location());
-     Standard_Real R1 = C1.Radius();
-     gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
-     gp_Pnt2d point2;
-//     gp_Vec2d Tan2,Nor2;
-     gp_Vec2d Tan2;
-     TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-     GccAna_Circ2d3Tan circ(point1,point2,Point3,Tol);
-     if (circ.IsDone()) {
-       cirsol = circ.ThisSolution(1);
-       gp_Pnt2d centre(cirsol.Location());
-       gp_Vec2d Tan1(-Sin(Ufirst(1)),Cos(Ufirst(1)));
-       gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
-       Standard_Real normetan2 = Tan2.Magnitude();
-       gp_Vec2d Vec1(point1,centre);
-       gp_Vec2d Vec2(point2,centre);
-       gp_Vec2d Vec3(Point3,centre);
-       Standard_Real normevec1 = Vec1.Magnitude();
-       Standard_Real normevec2 = Vec2.Magnitude();
-       Standard_Real normevec3 = Vec3.Magnitude();
-       Standard_Real dot1,dot2,dot3;
-       if (normevec1 >= gp::Resolution()) {
-        dot1 = Vec1.Dot(Tan1)/(normevec1);
-       }
-       else { dot1 = 0.; }
-       if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
-        dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
-       }
-       else { dot2 = 0.; }
-       if (normevec3 >= gp::Resolution()) {
-        dot3 = Vec3.Dot(Tan3)/(normevec3);
-       }
-       else { dot3 = 0.; }
-       Tol = 1.e-12;
-       if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
-        Standard_Real dist = centre1.Distance(centre);
-        Standard_Real Rsol = cirsol.Radius();
-        if (Qualified1.IsUnqualified() || 
-            (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
-            (Qualified1.IsOutside() && dist >= Rsol) ||
-            (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
-          Standard_Real Angle1 = Vec2.Angle(Tan2);
-          if (Qualified2.IsUnqualified() || 
-              (Qualified2.IsEnclosing()&&Angle1<=0.)||
-              (Qualified2.IsOutside() && Angle1 >= 0) ||
-              (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
-            qualifier1 = Qualified1.Qualifier();
-            qualifier2 = Qualified2.Qualifier();
-            qualifier3 = GccEnt_noqualifier;
-            pararg1 = Ufirst(1);
-            par1sol = 0.;
-            pnttg1sol = point1;
-            pararg2 = Ufirst(2);
-            pnttg2sol = point2;
-            par2sol = 0.;
-            pararg3 = 0.;
-            pnttg3sol = Point3;
-            par3sol = 0.;
-            WellDone = Standard_True;
-          }
-        }
-       }
-     }
-   }
- }
-
-Standard_Boolean GccIter_Circ2d3Tan::
-   IsDone () const{ return WellDone; }
-
-gp_Circ2d GccIter_Circ2d3Tan::
-   ThisSolution () const{ return cirsol; }
-
-void GccIter_Circ2d3Tan:: 
-  WhichQualifier (GccEnt_Position& Qualif1  ,
-                 GccEnt_Position& Qualif2  ,
-                 GccEnt_Position& Qualif3  ) const
-{
-  if (!WellDone) { StdFail_NotDone::Raise(); }
-  else {
-    Qualif1 = qualifier1;
-    Qualif2 = qualifier2;
-    Qualif3 = qualifier3;
-  }
-}
-
-void GccIter_Circ2d3Tan:: 
-   Tangency1 (Standard_Real&      ParSol ,
-             Standard_Real&      ParArg ,
-             gp_Pnt2d&           PntSol ) const{
-   if (!WellDone) { StdFail_NotDone::Raise(); }
-   else {
-     if (TheSame1 == 0) {
-       ParSol = par1sol;
-       ParArg = pararg1;
-       PntSol = pnttg1sol;
-     }
-     else { StdFail_NotDone::Raise(); }
-   }
- }
-
-void GccIter_Circ2d3Tan:: 
-   Tangency2 (Standard_Real&      ParSol         ,
-             Standard_Real&      ParArg         ,
-             gp_Pnt2d&  PntSol         ) const{
-   if (!WellDone) { StdFail_NotDone::Raise(); }
-   else {
-     ParSol = par2sol;
-     ParArg = pararg2;
-     PntSol = pnttg2sol;
-   }
- }
-
-void GccIter_Circ2d3Tan:: 
-   Tangency3 (Standard_Real&      ParSol         ,
-             Standard_Real&      ParArg         ,
-             gp_Pnt2d&  PntSol         ) const{
-   if (!WellDone) { StdFail_NotDone::Raise(); }
-   else {
-     ParSol = par3sol;
-     ParArg = pararg3;
-     PntSol = pnttg3sol;
-   }
- }
-
-Standard_Boolean GccIter_Circ2d3Tan::
-   IsTheSame1 () const
-{
-  if (!WellDone) StdFail_NotDone::Raise();
-
-  if (TheSame1 == 0) 
-    return Standard_False;
-    
-  return Standard_True;
-}
-
-
-Standard_Boolean GccIter_Circ2d3Tan::
-   IsTheSame2 () const
-{
-  if (!WellDone) StdFail_NotDone::Raise();
-  
-  if (TheSame3 == 0) 
-    return Standard_False;
-  
-  return Standard_True;
-  
-}
-
-Standard_Boolean GccIter_Circ2d3Tan::
-   IsTheSame3 () const
-{
-  if (!WellDone) StdFail_NotDone::Raise();
-  return Standard_True;
-}
diff --git a/src/GccIter/GccIter_FunctionTanCirCu.gxx b/src/GccIter/GccIter_FunctionTanCirCu.gxx
deleted file mode 100644 (file)
index fd44747..0000000
+++ /dev/null
@@ -1,134 +0,0 @@
-// Created on: 1992-01-20
-// Created by: Remi GILET
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <gp_Vec2d.hxx>
-#include <gp_Pnt2d.hxx>
-#include <gp_Vec.hxx>
-#include <gp_Pnt.hxx>
-
-//=========================================================================
-//  soit P1 le point sur la courbe TheCurve d abscisse u.                 +
-//  soit C  le centre du cercle TheCirc.                                  +
-//  Nous recherchons un point P2 appartenant au cercle tel que :          +
-//           --->   -->                                                   +
-//        *  P1P2 . CP2 = 0                                               +
-//                                                                        +
-//        *    -->  2    2                                                +
-//           ||CP2||  = R                                                 +
-//  Nous cherchons donc les zeros de la fonction suivante:                +
-//                         -->  --> 2                                     +
-//             -->  2    ( CP1 . T )      2                               +
-//           ||CP1||  -  -----------  -  R   =  F(u)                      +
-//                          --> 2                                         +
-//                         ||T||                                          +
-//                                                                        +
-//  La derivee de cette fonction est :                                    +
-//                                                                        +
-//             2*(CP1.T)(CP1.N)     2*(CP1.T)*(CP1.T)*T.N                 +
-//  f(u) =  -  ----------------  +  ---------------------                 +
-//                  T.T                  (T.T)*(T.T)                      +
-//=========================================================================
-//                                                                        +
-// skv: Small addition: The function and the derivative are normalized    +
-//                      by an average square distance between the circle  +
-//                      and the curve.                                    +
-//=========================================================================
-
-GccIter_FunctionTanCirCu::
-  GccIter_FunctionTanCirCu(const gp_Circ2d& Circ   ,
-                         const TheCurve&  Curv   ) {
-  Curve = Curv;
-  TheCirc = Circ;
-
-//  Modified by Sergey KHROMOV - Thu Apr  5 09:51:21 2001 Begin
-  Standard_Integer aNbSamp = TheCurveTool::NbSamples(Curve);
-  Standard_Real    aFirst  = TheCurveTool::FirstParameter(Curve);
-  Standard_Real    aLast   = TheCurveTool::LastParameter(Curve);
-  Standard_Real    aStep   = (aLast - aFirst)/aNbSamp;
-  Standard_Real    anX     = aFirst + aStep/2.;
-  Standard_Integer aNbP    = 0;
-  gp_XY            aLoc(0., 0.);
-
-  while (anX <= aLast) {
-    aLoc += (TheCurveTool::Value(Curve, anX)).XY();
-    anX  += aStep;
-    aNbP++;
-  }
-  myWeight = Max((aLoc - TheCirc.Location().XY()).SquareModulus(), TheCirc.Radius());
-//  Modified by Sergey KHROMOV - Thu Apr  5 09:51:25 2001 End
- }
-
-
-Standard_Boolean GccIter_FunctionTanCirCu::
-  Value (const Standard_Real  X    ,
-              Standard_Real& Fval ) {
-  gp_Pnt2d Point;
-  gp_Vec2d Vect1;
-  TheCurveTool::D1(Curve,X,Point,Vect1);
-  Standard_Real NormeD1 = Vect1.Magnitude();
-  gp_Vec2d TheDirection(TheCirc.Location(),Point);
-  Standard_Real squaredir = TheDirection.Dot(TheDirection);
-  Standard_Real R = TheCirc.Radius();
-  Fval = squaredir-R*R-
-    (TheDirection.Dot(Vect1))*(TheDirection.Dot(Vect1))/(NormeD1*NormeD1);
-//  Modified by Sergey KHROMOV - Thu Apr  5 17:38:05 2001 Begin
-  Fval /= myWeight;
-//  Modified by Sergey KHROMOV - Thu Apr  5 17:38:06 2001 End
-  return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanCirCu::
-  Derivative (const Standard_Real  X     ,
-                   Standard_Real& Deriv ) {
-  gp_Pnt2d Point;
-  gp_Vec2d Vect1,Vect2;
-  TheCurveTool::D2(Curve,X,Point,Vect1,Vect2);
-  Standard_Real NormeD1 = Vect1.SquareMagnitude();
-  gp_Vec2d TheDirection(TheCirc.Location(),Point);
-  Standard_Real cp1dott = TheDirection.Dot(Vect1);
-  Deriv = -2.*(cp1dott/NormeD1)*
-    ((TheDirection.Dot(Vect2))-cp1dott*Vect1.Dot(Vect2)/NormeD1);
-//  Modified by Sergey KHROMOV - Thu Apr  5 17:38:15 2001 Begin
-  Deriv /= myWeight;
-//  Modified by Sergey KHROMOV - Thu Apr  5 17:38:15 2001 End
-  return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanCirCu::
-  Values (const Standard_Real  X     ,
-               Standard_Real& Fval  ,
-               Standard_Real& Deriv ) {
-  gp_Pnt2d Point;
-  gp_Vec2d Vect1,Vect2;
-  TheCurveTool::D2(Curve,X,Point,Vect1,Vect2);
-  Standard_Real NormeD1 = Vect1.SquareMagnitude();
-  gp_Vec2d TheDirection(TheCirc.Location(),Point);
-  Standard_Real squaredir = TheDirection.SquareMagnitude();
-  Standard_Real cp1dott = TheDirection.Dot(Vect1);
-  Standard_Real R = TheCirc.Radius();
-
-  Fval = squaredir-R*R-cp1dott*cp1dott/NormeD1;
-//  Modified by Sergey KHROMOV - Thu Apr  5 17:38:28 2001 Begin
-  Fval /= myWeight;
-//  Modified by Sergey KHROMOV - Thu Apr  5 17:38:28 2001 End
-
-  Deriv = -2.*(cp1dott/NormeD1)*
-    ((TheDirection.Dot(Vect2))-cp1dott*Vect1.Dot(Vect2)/NormeD1);
-//  Modified by Sergey KHROMOV - Thu Apr  5 17:37:36 2001 Begin
-  Deriv /= myWeight;
-//  Modified by Sergey KHROMOV - Thu Apr  5 17:37:37 2001 End
-  return Standard_True;
-}
diff --git a/src/GccIter/GccIter_FunctionTanCuCu.gxx b/src/GccIter/GccIter_FunctionTanCuCu.gxx
deleted file mode 100644 (file)
index 1ef062e..0000000
+++ /dev/null
@@ -1,213 +0,0 @@
-// Created on: 1992-01-20
-// Created by: Remi GILET
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <gp_Vec2d.hxx>
-#include <gp_Pnt2d.hxx>
-#include <ElCLib.hxx>
-
-void GccIter_FunctionTanCuCu::
-  InitDerivative(const math_Vector& X     ,
-                      gp_Pnt2d&    Point1,
-                      gp_Pnt2d&    Point2,
-                      gp_Vec2d&    Tan1  ,
-                      gp_Vec2d&    Tan2  ,
-                      gp_Vec2d&    D21   ,
-                      gp_Vec2d&    D22   ) {
-  switch (TheType) {
-  case GccIter_CuCu:
-    {
-      TheCurveTool::D2(TheCurve1,X(1),Point1,Tan1,D21);
-      TheCurveTool::D2(TheCurve2,X(2),Point2,Tan2,D22);
-    }
-    break;
-  case GccIter_CiCu:
-    {
-      ElCLib::D2(X(1),TheCirc1,Point1,Tan1,D21);
-      TheCurveTool::D2(TheCurve2,X(2),Point2,Tan2,D22);
-    }
-    break;
-  default:
-    {
-    }
-  }
-}
-
-GccIter_FunctionTanCuCu::
-  GccIter_FunctionTanCuCu(const TheCurve& C1  ,
-                           const TheCurve& C2  ) {
-  TheCurve1 = C1;
-  TheCurve2 = C2;
-  TheType = GccIter_CuCu;
-}
-
-GccIter_FunctionTanCuCu::
-  GccIter_FunctionTanCuCu(const gp_Circ2d& C1  ,
-                           const TheCurve&  C2  ) {
-  TheCirc1 = C1;
-  TheCurve2 = C2;
-  TheType = GccIter_CiCu;
-}
-
-
-//=========================================================================
-//  soit P1 le point sur la courbe TheCurve1 d abscisse u1.               +
-//  soit P2 le point sur la courbe TheCurve2 d abscisse u2.               +
-//  soit T1 la tangente a la courbe TheCurve1 en P1.                      +
-//  soit T2 la tangente a la courbe TheCurve2 en P2.                      +
-//  Nous voulons P1 et P2 tels que :                                      +
-//           --->    -->                                                  +
-//        *  P1P2 /\ T1 = 0                                               +
-//                                                                        +
-//           -->   -->                                                    +
-//        *  T1 /\ T2 = 0                                                 +
-//                                                                        +
-//  Nous cherchons donc les zeros des fonctions suivantes:                +
-//             --->    -->                                                +
-//        *    P1P2 /\ T1                                                 +
-//          --------------- = F1(u)                                       +
-//            --->     -->                                                +
-//          ||P1P2||*||T1||                                               +
-//                                                                        +
-//              -->   -->                                                 +
-//        *     T1 /\ T2                                                  +
-//          --------------- = F2(u)                                       +
-//             -->    -->                                                 +
-//           ||T2||*||T1||                                                +
-//                                                                        +
-//  Les derivees de ces fonctions sont :                                  +
-//                                           2              2             +
-//   dF1        P1P2/\N1       (P1P2/\T1)*[T1*(-T1).P1P2+P1P2*(T1.N1)]    +
-//  ----- = --------------- - -----------------------------------------   +
-//   du1                                     3        3                   +
-//           ||P1P2||*||T1||         ||P1P2|| * ||T1||                    +
-//                                                                        +
-//                                                    2                   +
-//   dF1        T2/\T1                  (P1P2/\T1)*[T1*(T2.P1P2)          +
-//  ----- = --------------- - -----------------------------------------   +
-//   du2                                     3        3                   +
-//           ||P1P2||*||T1||         ||P1P2|| * ||T1||                    +
-//                                                                        +
-//                                                          2             +
-//   dF2             N1/\T2                 T1/\T2*(N1.T1)T2              +
-//  ----- =     ----------------  -  -----------------------------        +
-//   du1                                          3        3              +
-//                ||T1||*||T2||             ||T1|| * ||T2||               +
-//                                                                        +
-//                                                          2             +
-//   dF2             T1/\N2                 T1/\T2*(N2.T2)T1              +
-//  ----- =     ----------------  -  -----------------------------        +
-//   du2                                          3        3              +
-//                ||T1||*||T2||             ||T1|| * ||T2||               +
-//                                                                        +
-//=========================================================================
-
-Standard_Integer GccIter_FunctionTanCuCu::
-  NbVariables() const { return 2; }
-
-Standard_Integer GccIter_FunctionTanCuCu::
-  NbEquations() const { return 2; }
-
-Standard_Boolean GccIter_FunctionTanCuCu::
-  Value (const math_Vector& X    ,
-              math_Vector& Fval ) {
-  gp_Pnt2d Point1;
-  gp_Pnt2d Point2;
-  gp_Vec2d Vect11;
-  gp_Vec2d Vect21;
-  gp_Vec2d Vect12;
-  gp_Vec2d Vect22;
-  InitDerivative(X,Point1,Point2,Vect11,Vect21,Vect12,Vect22);
-  Standard_Real NormeD11 = Vect11.Magnitude();
-  Standard_Real NormeD21 = Vect21.Magnitude();
-  gp_Vec2d TheDirection(Point1,Point2);
-  Standard_Real squaredir = TheDirection.Dot(TheDirection);
-  Fval(1) = TheDirection.Crossed(Vect11)/(NormeD11*squaredir);
-  Fval(2) = Vect11.Crossed(Vect21)/(NormeD11*NormeD21);
-  return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanCuCu::
-  Derivatives (const math_Vector& X     ,
-                    math_Matrix& Deriv ) {
-  gp_Pnt2d Point1;
-  gp_Pnt2d Point2;
-  gp_Vec2d Vect11;
-  gp_Vec2d Vect21;
-  gp_Vec2d Vect12;
-  gp_Vec2d Vect22;
-  InitDerivative(X,Point1,Point2,Vect11,Vect21,Vect12,Vect22);
-  Standard_Real NormeD11 = Vect11.Magnitude();
-  Standard_Real NormeD21 = Vect21.Magnitude();
-#ifdef DEB
-  gp_Vec2d V2V1(Vect11.XY(),Vect21.XY());
-#else
-  Vect11.XY();
-  Vect21.XY();
-#endif
-  gp_Vec2d TheDirection(Point1,Point2);
-  Standard_Real squaredir = TheDirection.Dot(TheDirection);
-  Deriv(1,1) = TheDirection.Crossed(Vect12)/(NormeD11*squaredir)+
-    (TheDirection.Crossed(Vect11)*NormeD11*NormeD11*Vect11.Dot(TheDirection))/
-     (NormeD11*NormeD11*NormeD11*squaredir*squaredir*squaredir);
-  Deriv(1,2) = Vect21.Crossed(Vect11)/(NormeD11*squaredir)-
-    (TheDirection.Crossed(Vect11)*NormeD11*NormeD11*Vect21.Dot(TheDirection))/
-     (NormeD11*NormeD11*NormeD11*squaredir*squaredir*squaredir);
-  Deriv(2,1)=(Vect12.Crossed(Vect21))/(NormeD11*NormeD21)-
-      (Vect11.Crossed(Vect21))*(Vect12.Dot(Vect11))*NormeD21*NormeD21/
-     (NormeD11*NormeD11*NormeD11*NormeD21*NormeD21*NormeD21);
-  Deriv(2,2)=(Vect11.Crossed(Vect22))/(NormeD11*NormeD21)-
-      (Vect11.Crossed(Vect21))*(Vect22.Dot(Vect21))*NormeD11*NormeD11/
-     (NormeD11*NormeD11*NormeD11*NormeD21*NormeD21*NormeD21);
-  return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanCuCu::
-  Values (const math_Vector& X     ,
-               math_Vector& Fval  ,
-               math_Matrix& Deriv ) {
-  gp_Pnt2d Point1;
-  gp_Pnt2d Point2;
-  gp_Vec2d Vect11;
-  gp_Vec2d Vect21;
-  gp_Vec2d Vect12;
-  gp_Vec2d Vect22;
-  InitDerivative(X,Point1,Point2,Vect11,Vect21,Vect12,Vect22);
-  Standard_Real NormeD11 = Vect11.Magnitude();
-  Standard_Real NormeD21 = Vect21.Magnitude();
-#ifdef DEB
-  gp_Vec2d V2V1(Vect11.XY(),Vect21.XY());
-#else
-  Vect11.XY();
-  Vect21.XY();
-#endif
-  gp_Vec2d TheDirection(Point1,Point2);
-  Standard_Real squaredir = TheDirection.Dot(TheDirection);
-  Fval(1) = TheDirection.Crossed(Vect11)/(NormeD11*squaredir);
-  Fval(2) = Vect11.Crossed(Vect21)/(NormeD11*NormeD21);
-  Deriv(1,1) = TheDirection.Crossed(Vect12)/(NormeD11*squaredir)+
-    (TheDirection.Crossed(Vect11)*NormeD11*NormeD11*Vect11.Dot(TheDirection))/
-     (NormeD11*NormeD11*NormeD11*squaredir*squaredir*squaredir);
-  Deriv(1,2) = Vect21.Crossed(Vect11)/(NormeD11*squaredir)-
-    (TheDirection.Crossed(Vect11)*NormeD11*NormeD11*Vect21.Dot(TheDirection))/
-     (NormeD11*NormeD11*NormeD11*squaredir*squaredir*squaredir);
-  Deriv(2,1)=(Vect12.Crossed(Vect21))/(NormeD11*NormeD21)-
-      (Vect11.Crossed(Vect21))*(Vect12.Dot(Vect11))*NormeD21*NormeD21/
-     (NormeD11*NormeD11*NormeD11*NormeD21*NormeD21*NormeD21);
-  Deriv(2,2)=(Vect11.Crossed(Vect22))/(NormeD11*NormeD21)-
-      (Vect11.Crossed(Vect21))*(Vect22.Dot(Vect21))*NormeD11*NormeD11/
-     (NormeD11*NormeD11*NormeD11*NormeD21*NormeD21*NormeD21);
-  return Standard_True;
-}
diff --git a/src/GccIter/GccIter_FunctionTanCuPnt.gxx b/src/GccIter/GccIter_FunctionTanCuPnt.gxx
deleted file mode 100644 (file)
index 2ff8050..0000000
+++ /dev/null
@@ -1,96 +0,0 @@
-// Created on: 1992-01-20
-// Created by: Remi GILET
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <gp_Vec2d.hxx>
-#include <gp_Pnt2d.hxx>
-#include <gp_Vec.hxx>
-#include <gp_Pnt.hxx>
-
-//=========================================================================
-//  soit P1 le point sur la courbe TheCurve d abscisse u.                 +
-//  soit C  le point ThePoint.                                            +
-//  Nous cherchons donc les zeros de la fonction suivante:                +
-//                                                                        +
-//                 -->   -->                                              +
-//                 CP1 /\ T                                               +
-//             ---------------  =  F(u)                                   +
-//             ||CP1|| * ||T||                                            +
-//                                                                        +
-//  La derivee de cette fonction est :                                    +
-//            CP1 /\ N        (T.N)*((CP1/\T).((CP1/\T))                  +
-//     f(u) = --------  -  --------------------------------               +
-//               N.N            N*N*N*CP1*CP1*CP1                         +
-//=========================================================================
-
-GccIter_FunctionTanCuPnt::
-  GccIter_FunctionTanCuPnt(const TheCurve& C      ,
-                            const gp_Pnt2d& Point  ) {
-  TheCurv = C;
-  ThePoint = Point;
- }
-
-
-Standard_Boolean GccIter_FunctionTanCuPnt::
-  Value (const Standard_Real  X    ,
-              Standard_Real& Fval ) {
-  gp_Pnt2d Point;
-  gp_Vec2d Vect;
-  TheCurveTool::D1(TheCurv,X,Point,Vect);
-  Standard_Real NormeD1 = Vect.Magnitude();
-  gp_Vec2d TheDirection(ThePoint,Point);
-  Standard_Real NormeDir = TheDirection.Magnitude();
-  Fval = TheDirection.Crossed(Vect)/(NormeD1*NormeDir);
-  return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanCuPnt::
-  Derivative (const Standard_Real  X     ,
-                   Standard_Real& Deriv ) {
-  gp_Pnt2d Point;
-  gp_Vec2d Vec1;
-  gp_Vec2d Vec2;
-  TheCurveTool::D2(TheCurv,X,Point,Vec1,Vec2);
-  gp_Vec2d TheDirection(ThePoint.XY(),gp_XY(Point.XY()));
-  Standard_Real NormeD1 = Vec1.Magnitude();
-  Standard_Real NormeDir = TheDirection.Magnitude();
-  Deriv = TheDirection.Crossed(Vec2)/(NormeD1*NormeDir)-
-    (TheDirection.Crossed(Vec1)/(NormeD1*NormeDir))*
-      (Vec1.Dot(Vec2)/(NormeD1*NormeD1)+
-       Vec1.Dot(TheDirection)/(NormeDir*NormeDir));
-  return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanCuPnt::
-  Values (const Standard_Real  X     ,
-               Standard_Real& Fval  ,
-               Standard_Real& Deriv ) {
-  gp_Pnt2d Point;
-  gp_Vec2d Vec1;
-  gp_Vec2d Vec2;
-  TheCurveTool::D2(TheCurv,X,Point,Vec1,Vec2);
-  gp_Vec2d TheDirection(ThePoint.XY(),gp_XY(Point.XY()));
-  Standard_Real NormeD1 = Vec1.Magnitude();
-  Standard_Real NormeDir = TheDirection.Magnitude();
-  Fval = TheDirection.Crossed(Vec1)/(NormeD1*NormeDir);
-  Deriv = TheDirection.Crossed(Vec2)/(NormeD1*NormeDir)-
-    (TheDirection.Crossed(Vec1)/(NormeD1*NormeDir))*
-      (Vec1.Dot(Vec2)/(NormeD1*NormeD1)+
-       Vec1.Dot(TheDirection)/(NormeDir*NormeDir));
-
-//  cout  << "U = "<< X << " F ="<< Fval <<" DF ="<< Deriv<<endl;
-
-  return Standard_True;
-}
diff --git a/src/GccIter/GccIter_FunctionTanObl.gxx b/src/GccIter/GccIter_FunctionTanObl.gxx
deleted file mode 100644 (file)
index 14159e4..0000000
+++ /dev/null
@@ -1,66 +0,0 @@
-// Created on: 1992-01-20
-// Created by: Remi GILET
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <gp_Vec2d.hxx>
-#include <gp_Pnt2d.hxx>
-
-GccIter_FunctionTanObl::
-  GccIter_FunctionTanObl(const TheCurve& C      ,
-                       const gp_Dir2d& Dir    ) {
-  TheCurv = C;
-  TheDirection = Dir;
- }
-
-
-Standard_Boolean GccIter_FunctionTanObl::
-  Value (const Standard_Real  X    ,
-              Standard_Real& Fval ) {
-  gp_Pnt2d Point;
-  gp_Vec2d Vect;
-  TheCurveTool::D1(TheCurv,X,Point,Vect);
-  Standard_Real NormeD1 = Vect.Magnitude();
-  Fval = TheDirection.XY().Crossed(Vect.XY())/NormeD1;
-  return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanObl::
-  Derivative (const Standard_Real  X     ,
-                   Standard_Real& Deriv ) {
-  gp_Pnt2d Point;
-  gp_Vec2d Vec1;
-  gp_Vec2d Vec2;
-  TheCurveTool::D2(TheCurv,X,Point,Vec1,Vec2);
-  Standard_Real NormeD1 = Vec1.Magnitude();
-  Deriv = TheDirection.XY().Crossed(Vec2.XY())/NormeD1-
-      Vec1.XY().Dot(Vec2.XY())*TheDirection.XY().Crossed(Vec1.XY())/NormeD1;
-  return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanObl::
-  Values (const Standard_Real  X     ,
-               Standard_Real& Fval  ,
-               Standard_Real& Deriv ) {
-  gp_Pnt2d Point;
-  gp_Vec2d Vec1;
-  gp_Vec2d Vec2;
-  TheCurveTool::D2(TheCurv,X,Point,Vec1,Vec2);
-  Standard_Real NormeD1 = Vec1.Magnitude();
-  Fval = TheDirection.XY().Crossed(Vec1.XY())/NormeD1;
-  Deriv = TheDirection.XY().Crossed(Vec2.XY())/NormeD1-
-      Vec1.XY().Dot(Vec2.XY())*TheDirection.XY().Crossed(Vec1.XY())/NormeD1;
-  return Standard_True;
-}
-
diff --git a/src/GccIter/GccIter_Lin2d2Tan.gxx b/src/GccIter/GccIter_Lin2d2Tan.gxx
deleted file mode 100644 (file)
index a23117f..0000000
+++ /dev/null
@@ -1,278 +0,0 @@
-// Created on: 1991-12-20
-// Created by: Remi GILET
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//========================================================================
-//  CREATION D UNE LIGNE TANGENTE A DEUX COURBES.                        +
-//========================================================================
-
-#include <StdFail_NotDone.hxx>
-#include <GccEnt_BadQualifier.hxx>
-#include <gp_XY.hxx>
-#include <gp_Dir2d.hxx>
-#include <gp_Vec2d.hxx>
-#include <gp_Circ2d.hxx>
-#include <math_Vector.hxx>
-#include <math_Matrix.hxx>
-#include <math_FunctionSetRoot.hxx>
-#include <math_FunctionRoot.hxx>
-
-GccIter_Lin2d2Tan::
-   GccIter_Lin2d2Tan (const GccEnt_QualifiedCirc& Qualified1 ,
-                     const TheQualifiedCurve&    Qualified2 ,
-                     const Standard_Real         Param2     ,
-                     const Standard_Real         Tolang     ) {
-     
-   par1sol = 0.;
-   pararg1 = 0.;
-
-   //Standard_Real Tol = Abs(Tolang);
-
-   WellDone = Standard_False;
-   if (Qualified1.IsEnclosed()) { GccEnt_BadQualifier::Raise(); }
-   gp_Circ2d C1 = Qualified1.Qualified();
-   TheCurve Cu2 = Qualified2.Qualified();
-   Standard_Real U1 = TheCurveTool::FirstParameter(Cu2);
-   Standard_Real U2 = TheCurveTool::LastParameter(Cu2);
-   GccIter_FuncTCirCu func(C1,Cu2);
-   math_FunctionRoot sol(func,Param2,TheCurveTool::EpsX(Cu2,Abs(Tolang)),U1,U2,100);
-   if (sol.IsDone()) {
-     Standard_Real Usol = sol.Root();
-//     gp_Pnt2d Origine,Pt;
-//  Modified by Sergey KHROMOV - Thu Apr  5 17:39:47 2001 Begin
-     Standard_Real Norm;
-     func.Value(Usol, Norm);
-     if (Abs(Norm) < Tolang) {
-//  Modified by Sergey KHROMOV - Thu Apr  5 17:39:48 2001 End
-     gp_Pnt2d Origine;
-     gp_Vec2d Vect1;
-     gp_Vec2d Vect2;
-     TheCurveTool::D2(Cu2,Usol,Origine,Vect1,Vect2);
-     gp_Vec2d Vdir(C1.Location().XY() - Origine.XY());
-     Standard_Real sign1 = Vect1.Dot(Vdir);
-     if (sign1 <= 0. ) { Vect1.Reverse(); }
-     Standard_Real sign2 = Vect2.Crossed(Vect1);
-     if (Qualified2.IsUnqualified() || 
-        (Qualified2.IsEnclosing() && sign2<=0.) ||
-        (Qualified2.IsOutside() && sign1 <= 0. && sign2 >= 0.) ||
-        (Qualified2.IsEnclosed() && sign1 >= 0. && sign2 >= 0.)) {
-       if (Qualified1.IsUnqualified() ||
-          (Qualified1.IsOutside() && Vect1.Angle(Vdir) <= 0.) ||
-          (Qualified1.IsEnclosing() && Vect1.Angle(Vdir) >= 0.)) {
-        gp_Dir2d direc(Vect1);
-        Standard_Real R1 = C1.Radius();
-        gp_XY normal(-R1*direc.Y(),R1*direc.X());
-        sign1 = Vect1.Crossed(Vdir);
-        if (Qualified1.IsEnclosing()) {
-          pnttg1sol = gp_Pnt2d(C1.Location().XY()-normal);
-        }
-        else if (Qualified1.IsOutside()) {
-          pnttg1sol = gp_Pnt2d(C1.Location().XY()+normal);
-        }
-        else {
-          if (sign1 >= 0.) {
-            pnttg1sol = gp_Pnt2d(C1.Location().XY()-normal);
-          }
-          else {
-            pnttg1sol = gp_Pnt2d(C1.Location().XY()+normal);
-          }
-        }
-//      if (gp_Vec2d(direc.XY()).Angle(gp_Vec2d(pnttg1sol,Origine)) <= Tol) {
-          pnttg2sol = Origine;
-          linsol = gp_Lin2d(pnttg1sol,direc);
-          WellDone = Standard_True;
-          qualifier1 = Qualified1.Qualifier();
-          qualifier2 = Qualified2.Qualifier();
-          pararg2 = Usol;
-          par1sol = 0.;
-          par2sol = pnttg2sol.Distance(pnttg1sol);
-          pararg1 = 0.;
-        }
-       }
-     }
-   }
- }
-
-GccIter_Lin2d2Tan::
-   GccIter_Lin2d2Tan (const TheQualifiedCurve& Qualified1 ,
-                     const TheQualifiedCurve& Qualified2 ,
-                     const Standard_Real      Param1     ,
-                     const Standard_Real      Param2     ,
-                     const Standard_Real      Tolang     ) {
-   par1sol = 0.;
-   pararg1 = 0.;
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
-       !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
-        Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   TheCurve Cu1 = Qualified1.Qualified();
-   TheCurve Cu2 = Qualified2.Qualified();
-   GccIter_FuncTCuCu Func(Cu1,Cu2);
-   math_Vector Umin(1,2);
-   math_Vector Umax(1,2);
-   math_Vector Ufirst(1,2);
-   math_Vector tol(1,2);
-   Umin(1) = TheCurveTool::FirstParameter(Cu1);
-   Umin(2) = TheCurveTool::FirstParameter(Cu2);
-   Umax(1) = TheCurveTool::LastParameter(Cu1);
-   Umax(2) = TheCurveTool::LastParameter(Cu2);
-   Ufirst(1) = Param1;
-   Ufirst(2) = Param2;
-   tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolang));
-   tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolang));
-   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
-   if (Root.IsDone()) {
-     Root.Root(Ufirst);
-//  Modified by Sergey KHROMOV - Thu Apr  5 17:45:00 2001 Begin
-     math_Vector Norm(1,2);
-     Func.Value(Ufirst, Norm);
-     if (Abs(Norm(1)) < Tolang && Abs(Norm(2)) < Tolang) {
-//  Modified by Sergey KHROMOV - Thu Apr  5 17:45:01 2001 End
-       gp_Pnt2d point1,point2;
-       gp_Vec2d Vect11,Vect12,Vect21,Vect22;
-       TheCurveTool::D2(Cu1,Ufirst(1),point1,Vect11,Vect12);
-       TheCurveTool::D2(Cu2,Ufirst(2),point2,Vect21,Vect22);
-       gp_Vec2d Vec(point1.XY(),point2.XY());
-       Standard_Real Angle1 = Vec.Angle(Vect12);
-       Standard_Real sign1 = Vect11.Dot(Vec);
-       if (Qualified1.IsUnqualified() || 
-          (Qualified1.IsEnclosing() && Angle1 >= 0.) ||
-          (Qualified1.IsOutside() && Angle1 <= 0. && sign1 <= 0.) ||
-          (Qualified1.IsEnclosed() && Angle1 <= 0. && sign1 >= 0.)) {
-        Angle1 = Vec.Angle(Vect22);
-        sign1 = Vect21.Dot(Vec);
-        if (Qualified2.IsUnqualified() || 
-            (Qualified2.IsEnclosing() && Angle1 >= 0.) ||
-            (Qualified2.IsOutside() && Angle1 <= 0. && sign1 <= 0.) ||
-            (Qualified2.IsEnclosed() && Angle1 <= 0. && sign1 >= 0.)) {
-          qualifier1 = Qualified1.Qualifier();
-          qualifier2 = Qualified2.Qualifier();
-          pararg1 = Ufirst(1);
-          par1sol = 0.;
-          pnttg1sol = point1;
-          pararg2 = Ufirst(2);
-          pnttg2sol = point2;
-          par2sol = pnttg2sol.Distance(pnttg1sol);
-          gp_Dir2d dir(pnttg2sol.X()-pnttg1sol.X(),pnttg2sol.Y()-pnttg1sol.Y());
-          linsol = gp_Lin2d(pnttg1sol,dir);
-          WellDone = Standard_True;
-        }
-       }
-     }
-   }
- }
-
-GccIter_Lin2d2Tan::
-   GccIter_Lin2d2Tan (const TheQualifiedCurve& Qualified1 ,
-                     const gp_Pnt2d&          ThePoint   ,
-                     const Standard_Real      Param1     ,
-                     const Standard_Real      Tolang     ) {
-     
-   par1sol = 0.;
-   pararg1 = 0.;
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   TheCurve Cu1 = Qualified1.Qualified();
-   Standard_Real U1 = TheCurveTool::FirstParameter(Cu1);
-   Standard_Real U2 = TheCurveTool::LastParameter(Cu1);
-   GccIter_FuncTCuPt func(Cu1,ThePoint);
-   math_FunctionRoot sol(func,Param1,TheCurveTool::EpsX(Cu1,Abs(Tolang)),U1,U2,100);
-   if (sol.IsDone()) {
-     Standard_Real Usol = sol.Root();
-//  Modified by Sergey KHROMOV - Thu Apr  5 17:45:17 2001 Begin
-     Standard_Real Norm;
-     func.Value(Usol, Norm);
-     if (Abs(Norm) < Tolang) {
-//  Modified by Sergey KHROMOV - Thu Apr  5 17:45:19 2001 End
-       gp_Pnt2d Origine;
-       gp_Vec2d Vect1;
-       gp_Vec2d Vect2;
-       TheCurveTool::D2(Cu1,Usol,Origine,Vect1,Vect2);
-       gp_Vec2d Vdir(ThePoint.XY()-Origine.XY());
-       Standard_Real sign1 = Vect1.Dot(Vdir);
-       Standard_Real sign2 = Vect2.Crossed(Vdir);
-       if (Qualified1.IsUnqualified() || 
-          (Qualified1.IsEnclosing() && 
-           ((sign1 >= 0. && sign2 <= 0.) || (sign1 <= 0. && sign2 <= 0.))) ||
-          (Qualified1.IsOutside() && sign1 <= 0. && sign2 >= 0.) ||
-          (Qualified1.IsEnclosed() && sign1 >= 0. && sign2 >= 0.)) {
-        WellDone = Standard_True;
-        linsol = gp_Lin2d(Origine,gp_Dir2d(Vdir));
-        qualifier1 = Qualified1.Qualifier();
-        qualifier2 = GccEnt_noqualifier;
-        pnttg1sol = Origine;
-        pnttg2sol = ThePoint;
-        pararg1 = Usol;
-        par1sol = 0.;
-        pararg2 = ThePoint.Distance(Origine);
-        par2sol = 0.;
-       }
-     }
-   }
- }
-
-Standard_Boolean GccIter_Lin2d2Tan::
-   IsDone () const { return WellDone; }
-
-gp_Lin2d GccIter_Lin2d2Tan::
-   ThisSolution () const 
-{
-  if (!WellDone) StdFail_NotDone::Raise();
-  return linsol;
-}
-
-void GccIter_Lin2d2Tan:: 
-  WhichQualifier (GccEnt_Position& Qualif1  ,
-                 GccEnt_Position& Qualif2  ) const
-{
-  if (!WellDone) { StdFail_NotDone::Raise(); }
-  else {
-    Qualif1 = qualifier1;
-    Qualif2 = qualifier2;
-  }
-}
-
-void GccIter_Lin2d2Tan::
-   Tangency1 (Standard_Real& ParSol ,
-              Standard_Real& ParArg ,
-              gp_Pnt2d& Pnt) const {
-   if (!WellDone) { StdFail_NotDone::Raise(); }
-   else {
-     ParSol = par1sol;
-     ParArg = pararg1;
-     Pnt    = pnttg1sol;
-   }
- }
-
-void GccIter_Lin2d2Tan::
-   Tangency2 (Standard_Real& ParSol ,
-              Standard_Real& ParArg ,
-              gp_Pnt2d& Pnt) const {
-   if (!WellDone) { StdFail_NotDone::Raise(); }
-   else {
-     ParSol = par2sol;
-     ParArg = pararg2;
-     Pnt    = pnttg2sol;
-   }
- }
-
diff --git a/src/GccIter/GccIter_Lin2dTanObl.gxx b/src/GccIter/GccIter_Lin2dTanObl.gxx
deleted file mode 100644 (file)
index 288e864..0000000
+++ /dev/null
@@ -1,150 +0,0 @@
-// Created on: 1991-12-20
-// Created by: Remi GILET
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//========================================================================
-// CREATION D UNE LIGNE TANGENTE A UNE COURBE ET PARALLELE A UNE DROITE. +
-//========================================================================
-
-#include <IntAna2d_AnaIntersection.hxx>
-#include <IntAna2d_IntPoint.hxx>
-#include <GccIter_IsParallel.hxx>
-#include <StdFail_NotDone.hxx>
-#include <GccEnt_BadQualifier.hxx>
-#include <math_FunctionRoot.hxx>
-#include <gp_XY.hxx>
-#include <gp_Dir2d.hxx>
-#include <gp_Vec2d.hxx>
-#include <gp_Circ2d.hxx>
-
-GccIter_Lin2dTanObl::
-   GccIter_Lin2dTanObl (const TheQualifiedCurve& Qualified1 ,
-                       const gp_Lin2d&          TheLin     ,
-                       const Standard_Real      Param1     ,
-                       const Standard_Real      TolAng     ,
-                       const Standard_Real      Angle      ) {
-
-   par1sol = 0.;
-   pararg1 = 0.;
-   WellDone = Standard_False;
-   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
-        Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
-     GccEnt_BadQualifier::Raise();
-     return;
-   }
-   Paral2 = Standard_False;
-   TheCurve Cu1 = Qualified1.Qualified();
-   Standard_Real U1 = TheCurveTool::FirstParameter(Cu1);
-   Standard_Real U2 = TheCurveTool::LastParameter(Cu1);
-   gp_Dir2d Dir(TheLin.Direction());
-   Standard_Real A = Dir.X();
-   Standard_Real B = Dir.Y();
-   gp_Dir2d TheDirection(Dir);
-   if (Abs(Angle) > Abs(TolAng)) {
-     if (Abs(Abs(Angle)-M_PI) <= Abs(TolAng)) {
-       Paral2 = Standard_True;
-       TheDirection = Dir.Reversed();
-     }
-     else if (Abs(Angle-M_PI/2) <= Abs(TolAng)) { TheDirection=gp_Dir2d(-B,A); }
-     else if (Abs(Angle+M_PI/2) <= Abs(TolAng)) { TheDirection=gp_Dir2d(B,-A); }
-     else {
-       TheDirection=gp_Dir2d(A*Cos(Angle)-B*Sin(Angle),
-                            A*Sin(Angle)+B*Cos(Angle));
-     }
-   }
-   else { Paral2 = Standard_True; }
-   GccIter_FuncTObl func(Cu1,TheDirection);
-   math_FunctionRoot sol(func,Param1,
-                        TheCurveTool::EpsX(Cu1,Abs(TolAng)),U1,U2,100);
-   if (sol.IsDone()) {
-     Standard_Real Usol = sol.Root();
-     gp_Pnt2d Origine;
-     gp_Vec2d Vect1,Vect2;
-     TheCurveTool::D2(Cu1,Usol,Origine,Vect1,Vect2);
-     Standard_Real sign1 = Vect1.XY().Dot(TheDirection.XY());
-     Standard_Real sign2 = Vect2.XY().Crossed(TheDirection.XY());
-     if (Qualified1.IsUnqualified() || 
-        (Qualified1.IsEnclosing() && sign2<=0.) ||
-        (Qualified1.IsOutside() && sign1 <= 0. && sign2 >= 0.) ||
-        (Qualified1.IsEnclosed() && sign1 >= 0. && sign2 >= 0.)) {
-       WellDone = Standard_True;
-       linsol = gp_Lin2d(Origine,TheDirection);
-       pnttg1sol = Origine;
-       qualifier1 = Qualified1.Qualifier();
-       pararg1 = Usol;
-       par1sol = 0.;
-       if (!Paral2) {
-        IntAna2d_AnaIntersection Intp(linsol,TheLin);
-        if (Intp.IsDone() && !Intp.IsEmpty()) {
-          if (Intp.NbPoints()==1) {
-            pntint2sol = Intp.Point(1).Value();
-            par2sol = gp_Vec2d(linsol.Direction()).
-              Dot(gp_Vec2d(linsol.Location(),pntint2sol));
-            pararg2 = gp_Vec2d(TheLin.Direction()).
-              Dot(gp_Vec2d(TheLin.Location(),pntint2sol));
-          }
-        }
-       }
-     }
-   }
- }
-
-Standard_Boolean GccIter_Lin2dTanObl::
-   IsDone () const { return WellDone; }
-
-gp_Lin2d GccIter_Lin2dTanObl::ThisSolution () const 
-{      
-  if (!WellDone) StdFail_NotDone::Raise();
-
-  return linsol;
-}
-
-void GccIter_Lin2dTanObl:: 
-  WhichQualifier (GccEnt_Position& Qualif1) const
-{
-  if (!WellDone) { StdFail_NotDone::Raise(); }
-  else {
-    Qualif1 = qualifier1;
-  }
-}
-
-Standard_Boolean GccIter_Lin2dTanObl::
-   IsParallel2 () const { return Paral2; }
-
-void GccIter_Lin2dTanObl::
-   Tangency1 (Standard_Real& ParSol    ,
-              Standard_Real& ParArg    ,
-              gp_Pnt2d& PntSol) const {
-   if (!WellDone) { StdFail_NotDone::Raise(); }
-   else {
-     ParSol = par1sol;
-     ParArg = pararg1;
-     PntSol = gp_Pnt2d(pnttg1sol);
-   }
- }
-
-void GccIter_Lin2dTanObl::
-  Intersection2 (Standard_Real&     ParSol ,
-                Standard_Real&     ParArg ,
-                gp_Pnt2d& PntSol ) const {
-   if (!WellDone) { StdFail_NotDone::Raise(); }
-   else if (Paral2) { GccIter_IsParallel::Raise(); }
-   else {
-     PntSol = pntint2sol;
-     ParSol = par2sol;
-     ParArg = pararg2;
-   }
- }
-
index b8dae28..4a859d4 100644 (file)
@@ -33,7 +33,6 @@ package Geom2dGcc
 
 uses GccEnt,
      GccAna,
-     GccIter,
      StdFail,
      Geom2dInt,
      Geom2d,
@@ -45,7 +44,8 @@ uses GccEnt,
      Adaptor3d,
      Adaptor2d,
      TColgp,
-     gp
+     gp,
+     math
 
 is
 
@@ -79,25 +79,29 @@ class Circ2dTanCenGeo;
 
 class Circ2dTanOnRadGeo;
 
-class MyC2d3Tan instantiates Circ2d3Tan from GccIter
-           (Curve          from Geom2dAdaptor,
-            CurveTool      from Geom2dGcc,
-            QCurve         from Geom2dGcc);
-            
-class MyC2d2TanOn instantiates Circ2d2TanOn from GccIter
-           (Curve          from Geom2dAdaptor,
-            CurveTool      from Geom2dGcc,
-            QCurve         from Geom2dGcc);
-
-class MyL2dTanObl instantiates Lin2dTanObl from GccIter
-           (Curve          from Geom2dAdaptor,
-            CurveTool      from Geom2dGcc,
-            QCurve         from Geom2dGcc);
-            
-class MyL2d2Tan instantiates Lin2d2Tan from GccIter
-        (Curve          from Geom2dAdaptor,
-         CurveTool      from Geom2dGcc,
-         QCurve         from Geom2dGcc);
+class Circ2d3TanIter;
+private class FunctionTanCuCuCu;
+
+class Circ2d2TanOnIter;
+private class FunctionTanCuCuOnCu;
+
+class Lin2dTanOblIter;
+private class FunctionTanObl;
+
+class Lin2d2TanIter;
+private class FunctionTanCuCu;
+private class FunctionTanCuPnt;
+private class FunctionTanCirCu;
+
+enumeration Type1 is CuCuCu,CiCuCu,CiCiCu,CiLiCu,LiLiCu,LiCuCu;
+
+enumeration Type2 is CuCuOnCu,CiCuOnCu,LiCuOnCu,CuPtOnCu,
+                     CuCuOnLi,CiCuOnLi,LiCuOnLi,CuPtOnLi,
+                     CuCuOnCi,CiCuOnCi,LiCuOnCi,CuPtOnCi;
+
+enumeration Type3 is CuCu,CiCu;
+
+exception IsParallel inherits DomainError from Standard;
 
 Unqualified(Obj : Curve from Geom2dAdaptor) returns QualifiedCurve;
        ---Purpose: Constructs such a qualified curve that the relative
index e2778ff..b68b3a4 100644 (file)
@@ -43,7 +43,7 @@ uses Curve            from Geom2dAdaptor,
      Circ2d           from gp,
      Circ2d2TanOn     from GccAna,
      Circ2d2TanOnGeo from Geom2dGcc,
-     MyC2d2TanOn      from Geom2dGcc,
+     Circ2d2TanOnIter from Geom2dGcc,
      Position         from GccEnt,
      Array1OfPosition from GccEnt
      
@@ -285,7 +285,7 @@ fields
 
 --    CircAna  : Circ2d2TanOn from GccAna;
 --    CircGeo  : Circ2d2TanOnGeo from Geom2dGcc;
---    CircIter : MyC2d2TanOn from Geom2dGcc;
+--    CircIter : Circ2d2TanOnIter from Geom2dGcc;
 --    TypeAna  : Boolean;
 
 end Circ2d2TanOn;
index 54e6bdf..95fb5fd 100644 (file)
@@ -18,7 +18,7 @@
 #include <Geom2dAdaptor_Curve.hxx>
 #include <GccAna_Circ2d2TanOn.hxx>
 #include <Geom2dGcc_Circ2d2TanOnGeo.hxx>
-#include <Geom2dGcc_MyC2d2TanOn.hxx>
+#include <Geom2dGcc_Circ2d2TanOnIter.hxx>
 #include <Geom2dGcc_QCurve.hxx>
 #include <GccEnt_BadQualifier.hxx>
 #include <Geom2d_Circle.hxx>
@@ -267,18 +267,13 @@ Geom2dGcc_Circ2d2TanOn::
       }
     }
   }
-
-//=============================================================================
-//                            Appel a GccIter.                                +
-//=============================================================================
-
   else {
     Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
     Geom2dGcc_QCurve Qc2(C2,Qualified2.Qualifier());
     if ((Type3 == GeomAbs_Circle || Type3 == GeomAbs_Line)) {
       if (Type3 == GeomAbs_Circle) {
        Handle(Geom2d_Circle) CCon = Handle(Geom2d_Circle)::DownCast(Con);
-       Geom2dGcc_MyC2d2TanOn Circ(Qc1,Qc2,CCon->Circ2d(),
+       Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Qc2,CCon->Circ2d(),
                                   Param1,Param2,ParamOn,Tolerance);
        WellDone = Circ.IsDone();
        NbrSol = 1;
@@ -292,7 +287,7 @@ Geom2dGcc_Circ2d2TanOn::
       }
       else {
        Handle(Geom2d_Line) LLon = Handle(Geom2d_Line)::DownCast(Con);
-       Geom2dGcc_MyC2d2TanOn Circ(Qc1,Qc2,LLon->Lin2d(),
+       Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Qc2,LLon->Lin2d(),
                                       Param1,Param2,ParamOn,Tolerance);
        WellDone = Circ.IsDone();
        NbrSol = 1;
@@ -306,7 +301,7 @@ Geom2dGcc_Circ2d2TanOn::
        Circ.Tangency2(par2sol(1),pararg2(1),pnttg2sol(1));
       }
     }
-    Geom2dGcc_MyC2d2TanOn Circ(Qc1,Qc2,OnCurve,
+    Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Qc2,OnCurve,
                                   Param1,Param2,ParamOn,Tolerance);
     WellDone = Circ.IsDone();
     NbrSol = 1;
@@ -438,18 +433,13 @@ Geom2dGcc_Circ2d2TanOn::
        Results(CircGeo);
       }
     }
-  }
-
-//=============================================================================
-//                            Appel a GccIter.                                +
-//=============================================================================
-
+  }                                   
   else {
     Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
     if ((Type3 == GeomAbs_Circle || Type3 == GeomAbs_Line)) {
       if (Type3 == GeomAbs_Circle) {
        Handle(Geom2d_Circle) CCon = Handle(Geom2d_Circle)::DownCast(Con);
-       Geom2dGcc_MyC2d2TanOn Circ(Qc1,Point->Pnt2d(),CCon->Circ2d(),
+       Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Point->Pnt2d(),CCon->Circ2d(),
                                   Param1,ParamOn,Tolerance);
        WellDone = Circ.IsDone();
        NbrSol = 1;
@@ -462,7 +452,7 @@ Geom2dGcc_Circ2d2TanOn::
       }
       else {
        Handle(Geom2d_Line) LLon = Handle(Geom2d_Line)::DownCast(Con);
-       Geom2dGcc_MyC2d2TanOn Circ(Qc1,Point->Pnt2d(),LLon->Lin2d(),
+       Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Point->Pnt2d(),LLon->Lin2d(),
                                       Param1,ParamOn,Tolerance);
        WellDone = Circ.IsDone();
        NbrSol = 1;
@@ -475,7 +465,7 @@ Geom2dGcc_Circ2d2TanOn::
       }
     }
     else {
-      Geom2dGcc_MyC2d2TanOn Circ(Qc1,Point->Pnt2d(),OnCurve,
+      Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Point->Pnt2d(),OnCurve,
                                 Param1,ParamOn,Tolerance);
       WellDone = Circ.IsDone();
       NbrSol = 1;
similarity index 85%
rename from src/GccIter/GccIter_Circ2d2TanOn.cdl
rename to src/Geom2dGcc/Geom2dGcc_Circ2d2TanOnIter.cdl
index 1d4ef50..2209e40 100644 (file)
 -- Alternatively, this file may be used under the terms of Open CASCADE
 -- commercial license or contractual agreement.
 
-generic class Circ2d2TanOn from GccIter (
-    TheCurve          as any;
-    TheCurveTool      as any;  
-    TheQualifiedCurve as any) -- as QualifiedCurve from GccEnt
-                             --                  (TheCurve)
+class Circ2d2TanOnIter from Geom2dGcc
 
        ---Purpose: This class implements the algorithms used to 
        --          create 2d circles TANgent to 2 entities and 
@@ -39,23 +35,24 @@ uses Pnt2d            from gp,
      Circ2d           from gp,  
      QualifiedCirc    from GccEnt,
      QualifiedLin     from GccEnt,
-     Position         from GccEnt
+     Position         from GccEnt,
+     Curve            from Geom2dAdaptor,
+     CurveTool        from Geom2dGcc,
+     QCurve           from Geom2dGcc
      
 raises NotDone    from StdFail
 
-private class FuncTCuCuOnCu instantiates FunctionTanCuCuOnCu from GccIter (
-                                                TheCurve,TheCurveTool);
 is
 
 -- On a 2d line ..........................................................
 
 Create(Qualified1 : QualifiedCirc     ;
-       Qualified2 : TheQualifiedCurve ;
+       Qualified2 : QCurve from Geom2dGcc;
        OnLine     : Lin2d             ;
        Param1     : Real              ;
        Param2     : Real              ;
        Param3     : Real              ;
-       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+       Tolerance  : Real              ) returns Circ2d2TanOnIter from Geom2dGcc ;
     ---Purpose: This method implements the algorithms used to 
     --          create 2d circles TANgent to a 2d circle and a curve and 
     --          having the center ON a 2d line.
@@ -63,25 +60,25 @@ Create(Qualified1 : QualifiedCirc     ;
     --          Tolerance is used for the limit cases.
 
 Create(Qualified1 : QualifiedLin      ;
-       Qualified2 : TheQualifiedCurve ;
+       Qualified2 : QCurve from Geom2dGcc;
        OnLine     : Lin2d             ;
        Param1     : Real              ;
        Param2     : Real              ;
        Param3     : Real              ;
-       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+       Tolerance  : Real              ) returns Circ2d2TanOnIter from Geom2dGcc ;
     ---Purpose: This method implements the algorithms used to 
     --          create 2d circles TANgent to a 2d line and a curve and 
     --          having the center ON a 2d line.
     --          Param2 is the initial guess on the curve QualifiedCurv.
     --          Tolerance is used for the limit cases.
 
-Create(Qualified1 : TheQualifiedCurve ;
-       Qualified2 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc;
+       Qualified2 : QCurve from Geom2dGcc;
        OnLine     : Lin2d             ;
        Param1     : Real              ;
        Param2     : Real              ;
        Param3     : Real              ;
-       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+       Tolerance  : Real              ) returns Circ2d2TanOnIter from Geom2dGcc ;
     ---Purpose: This method implements the algorithms used to 
     --          create 2d circles TANgent to two curves and 
     --          having the center ON a 2d line.
@@ -89,12 +86,12 @@ Create(Qualified1 : TheQualifiedCurve ;
     --          Param2 is the initial guess on the first QualifiedCurv.
     --          Tolerance is used for the limit cases.
 
-Create(Qualified1 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc;
        Point2     : Pnt2d             ;
        OnLine     : Lin2d             ;
        Param1     : Real              ;
        Param2     : Real              ;
-       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+       Tolerance  : Real              ) returns Circ2d2TanOnIter from Geom2dGcc ;
     ---Purpose: This method implements the algorithms used to 
     --          create 2d circles TANgent to a 2d point and a curve and 
     --          having the center ON a 2d line.
@@ -105,12 +102,12 @@ Create(Qualified1 : TheQualifiedCurve ;
 -- -- On a 2d Circle .....................................................
 
 Create(Qualified1 : QualifiedCirc     ;
-       Qualified2 : TheQualifiedCurve ;
+       Qualified2 : QCurve from Geom2dGcc;
        OnCirc     : Circ2d            ;
        Param1     : Real              ;
        Param2     : Real              ;
        Param3     : Real              ;
-       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+       Tolerance  : Real              ) returns Circ2d2TanOnIter from Geom2dGcc ;
     ---Purpose: This method implements the algorithms used to 
     --          create 2d circles TANgent to a 2d circle and a curve and 
     --          having the center ON a 2d circle.
@@ -118,25 +115,25 @@ Create(Qualified1 : QualifiedCirc     ;
     --          Tolerance is used for the limit cases.
 
 Create(Qualified1 : QualifiedLin      ;
-       Qualified2 : TheQualifiedCurve ;
+       Qualified2 : QCurve from Geom2dGcc;
        OnCirc     : Circ2d            ;
        Param1     : Real              ;
        Param2     : Real              ;
        Param3     : Real              ;
-       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+       Tolerance  : Real              ) returns Circ2d2TanOnIter from Geom2dGcc ;
     ---Purpose: This method implements the algorithms used to 
     --          create 2d circles TANgent to a 2d line and a curve and 
     --          having the center ON a 2d circle.
     --          Param2 is the initial guess on the curve QualifiedCurv.
     --          Tolerance is used for the limit cases.
 
-Create(Qualified1 : TheQualifiedCurve ;
-       Qualified2 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc;
+       Qualified2 : QCurve from Geom2dGcc;
        OnCirc     : Circ2d            ;
        Param1     : Real              ;
        Param2     : Real              ;
        Param3     : Real              ;
-       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+       Tolerance  : Real              ) returns Circ2d2TanOnIter from Geom2dGcc ;
     ---Purpose: This method implements the algorithms used to 
     --          create 2d circles TANgent to two curves and 
     --          having the center ON a 2d circle.
@@ -144,12 +141,12 @@ Create(Qualified1 : TheQualifiedCurve ;
     --          Param2 is the initial guess on the first QualifiedCurv.
     --          Tolerance is used for the limit cases.
 
-Create(Qualified1 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc;
        Point2     : Pnt2d             ;
        OnCirc     : Circ2d            ;
        Param1     : Real              ;
        Param2     : Real              ;
-       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+       Tolerance  : Real              ) returns Circ2d2TanOnIter from Geom2dGcc ;
     ---Purpose: This method implements the algorithms used to 
     --          create 2d circles TANgent to a 2d point and a curve and 
     --          having the center ON a 2d circle.
@@ -159,12 +156,12 @@ Create(Qualified1 : TheQualifiedCurve ;
 -- -- On a curve .....................................................
 
 Create(Qualified1 : QualifiedCirc     ;
-       Qualified2 : TheQualifiedCurve ;
-       OnCurv     : TheCurve          ;
+       Qualified2 : QCurve from Geom2dGcc;
+       OnCurv     : Curve from Geom2dAdaptor;
        Param1     : Real              ;
        Param2     : Real              ;
        ParamOn    : Real              ;
-       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+       Tolerance  : Real              ) returns Circ2d2TanOnIter from Geom2dGcc ;
     ---Purpose: This method implements the algorithms used to 
     --          create 2d circles TANgent to a 2d circle and a curve and 
     --          having the center ON a 2d curve.
@@ -173,12 +170,12 @@ Create(Qualified1 : QualifiedCirc     ;
     --          Tolerance is used for the limit cases.
 
 Create(Qualified1 : QualifiedLin      ;
-       Qualified2 : TheQualifiedCurve ;
-       OnCurve    : TheCurve          ;
+       Qualified2 : QCurve from Geom2dGcc;
+       OnCurve    : Curve from Geom2dAdaptor;
        Param1     : Real              ;
        Param2     : Real              ;
        ParamOn    : Real              ;
-       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+       Tolerance  : Real              ) returns Circ2d2TanOnIter from Geom2dGcc ;
     ---Purpose: This method implements the algorithms used to 
     --          create 2d circles TANgent to a 2d line and a curve and 
     --          having the center ON a 2d curve.
@@ -186,12 +183,12 @@ Create(Qualified1 : QualifiedLin      ;
     --          ParamOn is the initial guess on the center curve OnCurv.
     --          Tolerance is used for the limit cases.
 
-Create(Qualified1 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc;
        Point2     : Pnt2d             ;
-       OnCurve    : TheCurve          ;
+       OnCurve    : Curve from Geom2dAdaptor;
        Param1     : Real              ;
        ParamOn    : Real              ;
-       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+       Tolerance  : Real              ) returns Circ2d2TanOnIter from Geom2dGcc ;
     ---Purpose: This method implements the algorithms used to 
     --          create 2d circles TANgent to a 2d Point and a curve and 
     --          having the center ON a 2d curve.
@@ -199,13 +196,13 @@ Create(Qualified1 : TheQualifiedCurve ;
     --          ParamOn is the initial guess on the center curve OnCurv.
     --          Tolerance is used for the limit cases.
 
-Create(Qualified1 : TheQualifiedCurve ;
-       Qualified2 : TheQualifiedCurve ;
-       OnCurve    : TheCurve          ;
+Create(Qualified1 : QCurve from Geom2dGcc;
+       Qualified2 : QCurve from Geom2dGcc;
+       OnCurve    : Curve from Geom2dAdaptor;
        Param1     : Real              ;
        Param2     : Real              ;
        ParamOn    : Real              ;
-       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+       Tolerance  : Real              ) returns Circ2d2TanOnIter from Geom2dGcc ;
     ---Purpose: This method implements the algorithms used to 
     --          create 2d circles TANgent to two curves and 
     --          having the center ON a 2d curve.
@@ -346,4 +343,4 @@ fields
     ---Purpose: The parameter of the center point of the solution 
     --          on the second argument.
 
-end Circ2d2TanOn;
+end Circ2d2TanOnIter;
diff --git a/src/Geom2dGcc/Geom2dGcc_Circ2d2TanOnIter.cxx b/src/Geom2dGcc/Geom2dGcc_Circ2d2TanOnIter.cxx
new file mode 100644 (file)
index 0000000..aa6de82
--- /dev/null
@@ -0,0 +1,1302 @@
+// Created on: 1991-12-13
+// Created by: Remi GILET
+// Copyright (c) 1991-1999 Matra Datavision
+// Copyright (c) 1999-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+//=========================================================================
+//   Creation d un cercle tangent a deux elements : Droite.               +
+//                                                  Cercle.               +
+//                                                  Point.                +
+//                                                  Courbes.              +
+//                        centre sur un troisieme : Droite.               +
+//                                                  Cercle.               +
+//                                                  Courbes.              +
+//=========================================================================
+
+#include <Geom2dGcc_Circ2d2TanOnIter.ixx>
+
+#include <gp_Dir2d.hxx>
+#include <gp_Ax2d.hxx>
+#include <gp.hxx>
+#include <StdFail_NotDone.hxx>
+#include <GccEnt_BadQualifier.hxx>
+#include <math_FunctionSetRoot.hxx>
+#include <ElCLib.hxx>
+
+#include <Geom2dGcc_CurveTool.hxx>
+#include <Geom2dGcc_FunctionTanCuCuOnCu.hxx>
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin&  Qualified1 , 
+                            const Geom2dGcc_QCurve&     Qualified2 , 
+                            const gp_Lin2d&             OnLine     ,
+                            const Standard_Real         Param1     ,
+                            const Standard_Real         Param2     ,
+                            const Standard_Real         Param3     ,
+                            const Standard_Real         Tolang     ) {
+
+                              TheSame1 = Standard_False;
+                              TheSame2 = Standard_False;
+                              par1sol = 0.;
+                              par2sol = 0.;
+                              pararg1 = 0.;
+                              pararg2 = 0.;
+                              parcen3 = 0.;
+
+                              WellDone = Standard_False;
+                              Standard_Real Tol = Abs(Tolang);
+                              WellDone = Standard_False;
+                              if (!(Qualified1.IsEnclosed() ||
+                                Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+                                !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
+                                Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+                                  GccEnt_BadQualifier::Raise();
+                                  return;
+                              }
+                              gp_Dir2d dirx(1.,0.);
+                              gp_Lin2d L1 = Qualified1.Qualified();
+                              Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+                              math_Vector Umin(1,4);
+                              math_Vector Umax(1,4);
+                              math_Vector Ufirst(1,4);
+                              math_Vector tol(1,4);
+                              Umin(1) = RealFirst();
+                              Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+                              Umin(3) = RealFirst();
+                              Umin(4) = 0.;
+                              Umax(1) = RealLast();
+                              Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+                              Umax(3) = RealLast();
+                              Umax(4) = RealLast();
+                              Ufirst(1) = Param1;
+                              Ufirst(2) = Param2;
+                              Ufirst(3) = Param3;
+                              tol(1) = 1.e-15;
+                              tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Tolang);
+                              tol(3) = tol(1);   
+                              tol(4) = tol(1);   
+                              gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
+                              gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+                              gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
+                              Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+                              Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnLine,Ufirst(4));
+                              math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+                              Func.Value(Ufirst,Umin);
+                              if (Root.IsDone()) {
+                                Root.Root(Ufirst);
+                                //     gp_Vec2d Tan1,Tan2,Nor1,Nor2;
+                                gp_Vec2d Tan1,Tan2;
+                                ElCLib::D1(Ufirst(1),L1,point1,Tan1);
+                                Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+                                gp_Vec2d Tan3(OnLine.Direction().XY());
+                                gp_Pnt2d point3(OnLine.Location().XY()+Ufirst(3)*Tan3.XY());
+                                Standard_Real dist1 = point3.Distance(point1);
+                                Standard_Real dist2 = point3.Distance(point2);
+                                if ( Abs(dist1-dist2)/2. <= Tol) {
+                                  cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+                                  Standard_Real normetan2 = Tan2.Magnitude();
+                                  gp_Vec2d Vec1(point1,point3);
+                                  gp_Vec2d Vec2(point2,point3);
+                                  Standard_Real normevec2 = Vec2.Magnitude();
+                                  Standard_Real angle2;
+                                  if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+                                    angle2 = Vec2.Angle(Tan2);
+                                  }
+                                  else { angle2 = 0.; }
+                                  Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
+                                    L1.Direction().X()));
+                                  if (Qualified1.IsUnqualified() ||
+                                    (Qualified1.IsOutside() && pscal <= 0.) ||
+                                    (Qualified1.IsEnclosed() && pscal >= 0.)) {
+                                      if (Qualified2.IsUnqualified() || 
+                                        (Qualified2.IsEnclosing()&&angle2<=0.)||
+                                        (Qualified2.IsOutside() && angle2 >= 0) ||
+                                        (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+                                          qualifier1 = Qualified1.Qualifier();
+                                          qualifier2 = Qualified2.Qualifier();
+                                          pnttg1sol = point1;
+                                          pararg1 = Ufirst(1);
+                                          par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+                                          pnttg2sol = point2;
+                                          pararg2 = Ufirst(2);
+                                          par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+                                          pntcen  = point3;
+                                          parcen3 = Ufirst(3);
+                                          WellDone = Standard_True;
+                                      }
+                                  }
+                                }
+                              }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 , 
+                            const Geom2dGcc_QCurve& Qualified2 , 
+                            const gp_Lin2d&          OnLine     ,
+                            const Standard_Real               Param1     ,
+                            const Standard_Real               Param2     ,
+                            const Standard_Real               Param3     ,
+                            const Standard_Real               Tolerance  ) {
+                              TheSame1 = Standard_False;
+                              TheSame2 = Standard_False;
+                              par1sol = 0.;
+                              par2sol = 0.;
+                              pararg1 = 0.;
+                              pararg2 = 0.;
+                              parcen3 = 0.;
+
+                              WellDone = Standard_False;
+                              if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
+                                Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+                                !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
+                                Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+                                  GccEnt_BadQualifier::Raise();
+                                  return;
+                              }
+                              Standard_Real Tol = Abs(Tolerance);
+                              gp_Dir2d dirx(1.,0.);
+                              Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+                              Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+                              math_Vector Umin(1,4);
+                              math_Vector Umax(1,4);
+                              math_Vector Ufirst(1,4);
+                              math_Vector tol(1,4);
+                              Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
+                              Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+                              Umin(3) = RealFirst();
+                              Umin(4) = 0.;
+                              Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
+                              Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+                              Umax(3) = RealLast();
+                              Umax(4) = RealLast();
+                              Ufirst(1) = Param1;
+                              Ufirst(2) = Param2;
+                              Ufirst(3) = Param3;
+                              tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
+                              tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
+                              tol(3) = 1.e-15;   
+                              tol(4) = Tol/10.;   
+                              gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
+                              gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+                              gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
+                              Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+                              Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnLine,Ufirst(4));
+                              math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+                              Func.Value(Ufirst,Umin);
+                              if (Root.IsDone()) {
+                                Root.Root(Ufirst);
+                                gp_Vec2d Tan1,Tan2;
+                                Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
+                                Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+                                gp_Vec2d Tan3(OnLine.Direction().XY());
+                                gp_Pnt2d point3(OnLine.Location().XY()+Ufirst(3)*Tan3.XY());
+                                Standard_Real dist1 = point3.Distance(point1);
+                                Standard_Real dist2 = point3.Distance(point2);
+                                if ( Abs(dist1-dist2)/2. <= Tol) {
+                                  cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+                                  Standard_Real normetan1 = Tan1.Magnitude();
+                                  Standard_Real normetan2 = Tan2.Magnitude();
+                                  gp_Vec2d Vec1(point1,point3);
+                                  gp_Vec2d Vec2(point2,point3);
+                                  Standard_Real normevec1 = Vec1.Magnitude();
+                                  Standard_Real normevec2 = Vec2.Magnitude();
+                                  Standard_Real angle1,angle2;
+                                  if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+                                    angle1 = Vec1.Angle(Tan1);
+                                  }
+                                  else { angle1 = 0.; }
+                                  if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+                                    angle2 = Vec2.Angle(Tan2);
+                                  }
+                                  else { angle2 = 0.; }
+                                  if (Qualified1.IsUnqualified()||
+                                    (Qualified1.IsEnclosing()&&angle1<=0.)||
+                                    (Qualified1.IsOutside() && angle1 >= 0.) ||
+                                    (Qualified1.IsEnclosed() && angle1 <= 0.)) {
+                                      if (Qualified2.IsUnqualified() || 
+                                        (Qualified2.IsEnclosing()&&angle2<=0.)||
+                                        (Qualified2.IsOutside() && angle2 >= 0) ||
+                                        (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+                                          qualifier1 = Qualified1.Qualifier();
+                                          qualifier2 = Qualified2.Qualifier();
+                                          pnttg1sol = point1;
+                                          pararg1 = Ufirst(1);
+                                          par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+                                          pnttg2sol = point2;
+                                          pararg2 = Ufirst(2);
+                                          par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+                                          pntcen  = point3;
+                                          parcen3 = Ufirst(3);
+                                          WellDone = Standard_True;
+                                      }
+                                  }
+                                }
+                              }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 , 
+                            const gp_Pnt2d&          Point2     , 
+                            const gp_Lin2d&          OnLine     ,
+                            const Standard_Real      Param1     ,
+                            const Standard_Real      Param2     ,
+                            const Standard_Real      Tolerance  ) {
+                              TheSame1 = Standard_False;
+                              TheSame2 = Standard_False;
+                              par1sol = 0.;
+                              par2sol = 0.;
+                              pararg1 = 0.;
+                              pararg2 = 0.;
+                              parcen3 = 0.;
+
+                              WellDone = Standard_False;
+                              if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
+                                Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
+                                  GccEnt_BadQualifier::Raise();
+                                  return;
+                              }
+                              Standard_Real Tol = Abs(Tolerance);
+                              gp_Dir2d dirx(1.,0.);
+                              Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+                              math_Vector Umin(1,3);
+                              math_Vector Umax(1,3);
+                              math_Vector Ufirst(1,3);
+                              math_Vector tol(1,3);
+                              Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
+                              Umin(2) = RealFirst();
+                              Umin(3) = 0.;
+                              Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
+                              Umax(2) = RealLast();
+                              Umax(3) = RealLast();
+                              Ufirst(1) = Param1;
+                              Ufirst(2) = Param2;
+                              tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
+                              tol(2) = 1.e-15;
+                              tol(3) = Tol/10.;
+                              gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
+                              gp_Pnt2d point3 = ElCLib::Value(Param2,OnLine);
+                              Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
+                              Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnLine,Ufirst(3));
+                              math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+                              Func.Value(Ufirst,Umin);
+                              if (Root.IsDone()) {
+                                Root.Root(Ufirst);
+                                gp_Pnt2d point1,point3;
+                                gp_Vec2d Tan1,Tan3;
+                                Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
+                                ElCLib::D1(Ufirst(2),OnLine,point3,Tan3);
+                                Standard_Real dist1 = point3.Distance(point1);
+                                Standard_Real dist2 = point3.Distance(Point2);
+                                if ( Abs(dist1-dist2)/2. <= Tol) {
+                                  cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+                                  Standard_Real normetan1 = Tan1.Magnitude();
+                                  gp_Vec2d Vec1(point1,point3);
+                                  Standard_Real normevec1 = Vec1.Magnitude();
+                                  Standard_Real angle1;
+                                  if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+                                    angle1 = Vec1.Angle(Tan1);
+                                  }
+                                  else { angle1 = 0.; }
+                                  if (Qualified1.IsUnqualified()||
+                                    (Qualified1.IsEnclosing()&&angle1<=0.)||
+                                    (Qualified1.IsOutside() && angle1 >= 0.) ||
+                                    (Qualified1.IsEnclosed() && angle1 <= 0.)) {
+                                      qualifier1 = Qualified1.Qualifier();
+                                      qualifier2 = GccEnt_noqualifier;
+                                      pnttg1sol = point1;
+                                      pararg1 = Ufirst(1);
+                                      par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+                                      pnttg2sol = Point2;
+                                      pararg2 = Ufirst(2);
+                                      par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+                                      pntcen  = point3;
+                                      parcen3 = Ufirst(3);
+                                      WellDone = Standard_True;
+                                  }
+                                }
+                              }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 , 
+                            const Geom2dGcc_QCurve&     Qualified2 , 
+                            const gp_Lin2d&             OnLine     ,
+                            const Standard_Real         Param1     ,
+                            const Standard_Real         Param2     ,
+                            const Standard_Real         Param3     ,
+                            const Standard_Real         Tolerance  ) {
+                              TheSame1 = Standard_False;
+                              TheSame2 = Standard_False;
+                              par1sol = 0.;
+                              par2sol = 0.;
+                              pararg1 = 0.;
+                              pararg2 = 0.;
+                              parcen3 = 0.;
+
+                              WellDone = Standard_False;
+                              if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
+                                Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+                                !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
+                                Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+                                  GccEnt_BadQualifier::Raise();
+                                  return;
+                              }
+                              Standard_Real Tol = Abs(Tolerance);
+                              gp_Dir2d dirx(1.,0.);
+                              gp_Circ2d C1 = Qualified1.Qualified();
+                              Standard_Real R1 = C1.Radius();
+                              Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+                              math_Vector Umin(1,4);
+                              math_Vector Umax(1,4);
+                              math_Vector Ufirst(1,4);
+                              math_Vector tol(1,4);
+                              Umin(1) = RealFirst();
+                              Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+                              Umin(3) = RealFirst();
+                              Umin(4) = 0.;
+                              Umax(1) = RealLast();
+                              Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+                              Umax(3) = RealLast();
+                              Umax(4) = RealLast();
+                              Ufirst(1) = Param1;
+                              Ufirst(2) = Param2;
+                              Ufirst(3) = Param3;
+                              tol(1) = 2.e-15*M_PI;
+                              tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
+                              tol(3) = 1.e-15;
+                              tol(4) = Tol/10.;
+                              gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
+                              gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+                              gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
+                              Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+                              Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnLine,Ufirst(4));
+                              math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+                              Func.Value(Ufirst,Umin);
+                              if (Root.IsDone()) {
+                                Root.Root(Ufirst);
+                                //     gp_Vec2d Tan1,Tan2,Nor1,Nor2;
+                                gp_Vec2d Tan1,Tan2,Nor2;
+                                ElCLib::D2(Ufirst(1),C1,point1,Tan1,Nor2);
+                                Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+#ifdef DEB
+                                gp_Vec2d Tan3(OnLine.Direction().XY());
+#else
+                                OnLine.Direction().XY();
+#endif
+                                point3 = ElCLib::Value(Ufirst(1),OnLine);
+                                Standard_Real dist1 = point3.Distance(point1);
+                                Standard_Real dist2 = point3.Distance(point2);
+                                if ( Abs(dist1-dist2)/2. <= Tol) {
+                                  cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+                                  Standard_Real normetan2 = Tan2.Magnitude();
+                                  gp_Vec2d Vec1(point1,point3);
+                                  gp_Vec2d Vec2(point2,point3);
+                                  Standard_Real normevec2 = Vec2.Magnitude();
+                                  Standard_Real angle2;
+                                  if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+                                    angle2 = Vec2.Angle(Tan2);
+                                  }
+                                  else { angle2 = 0.; }
+                                  Standard_Real dist = C1.Location().Distance(point3);
+                                  Standard_Real Rsol = cirsol.Radius();
+                                  if (Qualified1.IsUnqualified() || 
+                                    (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
+                                    (Qualified1.IsOutside() && dist >= Rsol) ||
+                                    (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
+                                      if (Qualified2.IsUnqualified() || 
+                                        (Qualified2.IsEnclosing()&&angle2<=0.)||
+                                        (Qualified2.IsOutside() && angle2 >= 0) ||
+                                        (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+                                          qualifier1 = Qualified1.Qualifier();
+                                          qualifier2 = Qualified2.Qualifier();
+                                          pnttg1sol = point1;
+                                          pararg1 = Ufirst(1);
+                                          par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+                                          pnttg2sol = point2;
+                                          pararg2 = Ufirst(2);
+                                          par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+                                          pntcen  = point3;
+                                          parcen3 = Ufirst(3);
+                                          WellDone = Standard_True;
+                                      }
+                                  }
+                                }
+                              }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 , 
+                            const Geom2dGcc_QCurve&     Qualified2 , 
+                            const gp_Circ2d&            OnCirc     ,
+                            const Standard_Real         Param1     ,
+                            const Standard_Real         Param2     ,
+                            const Standard_Real         Param3     ,
+                            const Standard_Real         Tolerance  ) {
+                              TheSame1 = Standard_False;
+                              TheSame2 = Standard_False;
+                              par1sol = 0.;
+                              par2sol = 0.;
+                              pararg1 = 0.;
+                              pararg2 = 0.;
+                              parcen3 = 0.;
+
+                              WellDone = Standard_False;
+                              if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
+                                Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+                                !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
+                                Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+                                  GccEnt_BadQualifier::Raise();
+                                  return;
+                              }
+                              Standard_Real Tol = Abs(Tolerance);
+                              gp_Dir2d dirx(1.,0.);
+                              gp_Circ2d C1 = Qualified1.Qualified();
+                              Standard_Real R1 = C1.Radius();
+                              Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+                              math_Vector Umin(1,4);
+                              math_Vector Umax(1,4);
+                              math_Vector Ufirst(1,4);
+                              math_Vector tol(1,4);
+                              Umin(1) = RealFirst();
+                              Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+                              Umin(3) = RealFirst();
+                              Umin(4) = 0.;
+                              Umax(1) = RealLast();
+                              Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+                              Umax(3) = RealLast();
+                              Umax(4) = RealLast();
+                              Ufirst(1) = Param1;
+                              Ufirst(2) = Param2;
+                              Ufirst(3) = Param3;
+                              tol(1) = 2.e-15*M_PI;
+                              tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
+                              tol(3) = 2.e-15*M_PI;
+                              tol(4) = Tol/10.;
+                              gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
+                              gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+                              gp_Pnt2d point3 = ElCLib::Value(Param3,OnCirc);
+                              Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+                              Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnCirc,Ufirst(4));
+                              math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+                              Func.Value(Ufirst,Umin);
+                              if (Root.IsDone()) {
+                                Root.Root(Ufirst);
+                                //     gp_Vec2d Tan1,Tan2,Nor1;
+                                gp_Vec2d Tan1,Tan2;
+                                ElCLib::D1(Ufirst(1),C1,point1,Tan1);
+                                Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+#ifdef DEB
+                                gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
+#endif
+                                point3 = ElCLib::Value(Ufirst(3),OnCirc);
+                                Standard_Real dist1 = point3.Distance(point1);
+                                Standard_Real dist2 = point3.Distance(point2);
+                                if ( Abs(dist1-dist2)/2. <= Tol) {
+                                  cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+                                  Standard_Real normetan2 = Tan2.Magnitude();
+                                  gp_Vec2d Vec1(point1,point3);
+                                  gp_Vec2d Vec2(point2,point3);
+                                  Standard_Real normevec2 = Vec2.Magnitude();
+                                  Standard_Real angle2;
+                                  if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+                                    angle2 = Vec2.Angle(Tan2);
+                                  }
+                                  else { angle2 = 0.; }
+                                  Standard_Real dist = C1.Location().Distance(point3);
+                                  Standard_Real Rsol = cirsol.Radius();
+                                  if (Qualified1.IsUnqualified() || 
+                                    (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
+                                    (Qualified1.IsOutside() && dist >= Rsol) ||
+                                    (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
+                                      if (Qualified2.IsUnqualified() || 
+                                        (Qualified2.IsEnclosing()&&angle2<=0.)||
+                                        (Qualified2.IsOutside() && angle2 >= 0) ||
+                                        (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+                                          qualifier1 = Qualified1.Qualifier();
+                                          qualifier2 = Qualified2.Qualifier();
+                                          pnttg1sol = point1;
+                                          pararg1 = Ufirst(1);
+                                          par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+                                          pnttg2sol = point2;
+                                          pararg2 = Ufirst(2);
+                                          par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+                                          pntcen  = point3;
+                                          parcen3 = Ufirst(3);
+                                          WellDone = Standard_True;
+                                      }
+                                  }
+                                }
+                              }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin&  Qualified1 , 
+                            const Geom2dGcc_QCurve&     Qualified2 , 
+                            const gp_Circ2d&            OnCirc     ,
+                            const Standard_Real         Param1     ,
+                            const Standard_Real         Param2     ,
+                            const Standard_Real         Param3     ,
+                            const Standard_Real         Tolerance  ) {
+                              TheSame1 = Standard_False;
+                              TheSame2 = Standard_False;
+                              par1sol = 0.;
+                              par2sol = 0.;
+                              pararg1 = 0.;
+                              pararg2 = 0.;
+                              parcen3 = 0.;
+
+                              WellDone = Standard_False;
+                              if (!(Qualified1.IsEnclosed() ||
+                                Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+                                !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
+                                Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+                                  GccEnt_BadQualifier::Raise();
+                                  return;
+                              }
+                              Standard_Real Tol = Abs(Tolerance);
+                              gp_Dir2d dirx(1.,0.);
+                              gp_Lin2d L1 = Qualified1.Qualified();
+                              Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+                              math_Vector Umin(1,4);
+                              math_Vector Umax(1,4);
+                              math_Vector Ufirst(1,4);
+                              math_Vector tol(1,4);
+                              Umin(1) = RealFirst();
+                              Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+                              Umin(3) = RealFirst();
+                              Umin(4) = 0.;
+                              Umax(1) = RealLast();
+                              Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+                              Umax(3) = RealLast();
+                              Umax(4) = RealLast();
+                              Ufirst(1) = Param1;
+                              Ufirst(2) = Param2;
+                              Ufirst(3) = Param3;
+                              tol(1) = 1.e-15;
+                              tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
+                              tol(3) = 2.e-15*M_PI;
+                              tol(4) = Tol/10.;
+                              gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
+                              gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+                              gp_Pnt2d point3 = ElCLib::Value(Param3,OnCirc);
+                              Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+                              Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnCirc,Ufirst(4));
+                              math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+                              Func.Value(Ufirst,Umin);
+                              if (Root.IsDone()) {
+                                Root.Root(Ufirst);
+                                gp_Pnt2d point1,point2;
+                                gp_Vec2d Tan1,Tan2;
+                                ElCLib::D1(Ufirst(1),L1,point1,Tan1);
+                                Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+#ifdef DEB
+                                gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
+#endif
+                                point3 = ElCLib::Value(Ufirst(3),OnCirc);
+                                Standard_Real dist1 = point3.Distance(point1);
+                                Standard_Real dist2 = point3.Distance(point2);
+                                if ( Abs(dist1-dist2)/2. <= Tol) {
+                                  cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+                                  Standard_Real normetan2 = Tan2.Magnitude();
+                                  gp_Vec2d Vec1(point1,point3);
+                                  gp_Vec2d Vec2(point2,point3);
+                                  Standard_Real normevec2 = Vec2.Magnitude();
+                                  Standard_Real angle2;
+                                  if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+                                    angle2 = Vec2.Angle(Tan2);
+                                  }
+                                  else { angle2 = 0.; }
+                                  Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
+                                    L1.Direction().X()));
+                                  if (Qualified1.IsUnqualified() ||
+                                    (Qualified1.IsOutside() && pscal <= 0.) ||
+                                    (Qualified1.IsEnclosed() && pscal >= 0.)) {
+                                      if (Qualified2.IsUnqualified() || 
+                                        (Qualified2.IsEnclosing()&&angle2<=0.)||
+                                        (Qualified2.IsOutside() && angle2 >= 0) ||
+                                        (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+                                          qualifier1 = Qualified1.Qualifier();
+                                          qualifier2 = Qualified2.Qualifier();
+                                          pnttg1sol = point1;
+                                          pararg1 = Ufirst(1);
+                                          par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+                                          pnttg2sol = point2;
+                                          pararg2 = Ufirst(2);
+                                          par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+                                          pntcen  = point3;
+                                          parcen3 = Ufirst(3);
+                                          WellDone = Standard_True;
+                                      }
+                                  }
+                                }
+                              }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 , 
+                            const Geom2dGcc_QCurve& Qualified2 , 
+                            const gp_Circ2d&         OnCirc     ,
+                            const Standard_Real               Param1     ,
+                            const Standard_Real               Param2     ,
+                            const Standard_Real               Param3     ,
+                            const Standard_Real               Tolerance  ) {
+                              TheSame1 = Standard_False;
+                              TheSame2 = Standard_False;
+                              par1sol = 0.;
+                              par2sol = 0.;
+                              pararg1 = 0.;
+                              pararg2 = 0.;
+                              parcen3 = 0.;
+
+                              WellDone = Standard_False;
+                              if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
+                                Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+                                !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
+                                Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+                                  GccEnt_BadQualifier::Raise();
+                                  return;
+                              }
+                              Standard_Real Tol = Abs(Tolerance);
+                              gp_Dir2d dirx(1.,0.);
+                              Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+                              Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+                              math_Vector Umin(1,4);
+                              math_Vector Umax(1,4);
+                              math_Vector Ufirst(1,4);
+                              math_Vector tol(1,4);
+                              Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
+                              Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+                              Umin(3) = RealFirst();
+                              Umin(4) = 0.;
+                              Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
+                              Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+                              Umax(3) = RealLast();
+                              Umax(4) = RealLast();
+                              Ufirst(1) = Param1;
+                              Ufirst(2) = Param2;
+                              Ufirst(3) = Param3;
+                              tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
+                              tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
+                              tol(3) = 2.e-15*M_PI;
+                              tol(4) = Tol/10.;
+                              gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
+                              gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+                              Standard_Real R1 = OnCirc.Radius();
+                              gp_Pnt2d point3(OnCirc.Location().XY()+R1*gp_XY(Cos(Param3),Sin(Param3)));
+                              Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+                              Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnCirc,Ufirst(4));
+                              math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+                              Func.Value(Ufirst,Umin);
+                              if (Root.IsDone()) {
+                                Root.Root(Ufirst);
+                                //     gp_Vec2d Tan1,Tan2,Nor1;
+                                gp_Vec2d Tan1,Tan2;
+                                Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
+                                Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+#ifdef DEB
+                                gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
+#endif
+                                point3 = gp_Pnt2d(OnCirc.Location().XY()+
+                                  R1*gp_XY(Cos(Ufirst(3)),Sin(Ufirst(3))));
+                                Standard_Real dist1 = point3.Distance(point1);
+                                Standard_Real dist2 = point3.Distance(point2);
+                                if ( Abs(dist1-dist2)/2. <= Tol) {
+                                  cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+                                  Standard_Real normetan1 = Tan1.Magnitude();
+                                  Standard_Real normetan2 = Tan2.Magnitude();
+                                  gp_Vec2d Vec1(point1,point3);
+                                  gp_Vec2d Vec2(point2,point3);
+                                  Standard_Real normevec1 = Vec1.Magnitude();
+                                  Standard_Real normevec2 = Vec2.Magnitude();
+                                  Standard_Real angle1,angle2;
+                                  if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+                                    angle1 = Vec1.Angle(Tan1);
+                                  }
+                                  else { angle1 = 0.; }
+                                  if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+                                    angle2 = Vec2.Angle(Tan2);
+                                  }
+                                  else { angle2 = 0.; }
+                                  if (Qualified1.IsUnqualified()||
+                                    (Qualified1.IsEnclosing()&&angle1<=0.)||
+                                    (Qualified1.IsOutside() && angle1 >= 0.) ||
+                                    (Qualified1.IsEnclosed() && angle1 <= 0.)) {
+                                      if (Qualified2.IsUnqualified() || 
+                                        (Qualified2.IsEnclosing()&&angle2<=0.)||
+                                        (Qualified2.IsOutside() && angle2 >= 0) ||
+                                        (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+                                          qualifier1 = Qualified1.Qualifier();
+                                          qualifier2 = Qualified2.Qualifier();
+                                          pararg1 = Ufirst(1);
+                                          par1sol = 0.;
+                                          pnttg1sol = point1;
+                                          pararg2 = Ufirst(2);
+                                          pnttg2sol = point2;
+                                          par2sol = pnttg2sol.Distance(pnttg1sol);
+                                          pntcen  = point3;
+                                          parcen3 = Ufirst(3);
+                                          WellDone = Standard_True;
+                                      }
+                                  }
+                                }
+                              }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve&  Qualified1 ,
+                            const gp_Pnt2d&          Point2     ,
+                            const gp_Circ2d&         OnCirc     ,
+                            const Standard_Real      Param1     ,
+                            const Standard_Real      Param2     ,
+                            const Standard_Real      Tolerance  ) {
+                              TheSame1 = Standard_False;
+                              TheSame2 = Standard_False;
+                              par1sol = 0.;
+                              par2sol = 0.;
+                              pararg1 = 0.;
+                              pararg2 = 0.;
+                              parcen3 = 0.;
+
+                              WellDone = Standard_False;
+                              if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
+                                Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
+                                  GccEnt_BadQualifier::Raise();
+                                  return;
+                              }
+                              Standard_Real Tol = Abs(Tolerance);
+                              gp_Dir2d dirx(1.,0.);
+                              Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+                              math_Vector Umin(1,3);
+                              math_Vector Umax(1,3);
+                              math_Vector Ufirst(1,3);
+                              math_Vector tol(1,3);
+                              Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
+                              Umin(2) = RealFirst();
+                              Umin(3) = 0.;
+                              Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
+                              Umax(2) = RealLast();
+                              Umax(3) = RealLast();
+                              Ufirst(1) = Param1;
+                              Ufirst(2) = Param2;
+                              tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
+                              tol(2) = 2.e-15*M_PI;
+                              tol(3) = Tol/10.;
+                              gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
+                              gp_Pnt2d point3 = ElCLib::Value(Param2,OnCirc);
+                              Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
+                              Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnCirc,Ufirst(3));
+                              math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+                              Func.Value(Ufirst,Umin);
+                              if (Root.IsDone()) {
+                                Root.Root(Ufirst);
+                                gp_Pnt2d point1,point3;
+                                gp_Vec2d Tan1,Tan3;
+                                Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
+                                ElCLib::D1(Ufirst(2),OnCirc,point3,Tan3);
+                                Standard_Real dist1 = point3.Distance(point1);
+                                Standard_Real dist2 = point3.Distance(Point2);
+                                if ( Abs(dist1-dist2)/2. <= Tol) {
+                                  cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+                                  Standard_Real normetan1 = Tan1.Magnitude();
+                                  gp_Vec2d Vec1(point1,point3);
+                                  Standard_Real normevec1 = Vec1.Magnitude();
+                                  Standard_Real angle1;
+                                  if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+                                    angle1 = Vec1.Angle(Tan1);
+                                  }
+                                  else { angle1 = 0.; }
+                                  if (Qualified1.IsUnqualified()||
+                                    (Qualified1.IsEnclosing()&&angle1<=0.)||
+                                    (Qualified1.IsOutside() && angle1 >= 0.) ||
+                                    (Qualified1.IsEnclosed() && angle1 <= 0.)) {
+                                      qualifier1 = Qualified1.Qualifier();
+                                      qualifier2 = GccEnt_noqualifier;
+                                      pnttg1sol = point1;
+                                      pararg1 = Ufirst(1);
+                                      par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+                                      pnttg2sol = Point2;
+                                      pararg2 = 0.;
+                                      par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+                                      pntcen  = point3;
+                                      parcen3 = Ufirst(3);
+                                      WellDone = Standard_True;
+                                  }
+                                }
+                              }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 , 
+                            const Geom2dGcc_QCurve& Qualified2 , 
+                            const Geom2dAdaptor_Curve&          OnCurv     ,
+                            const Standard_Real               Param1     ,
+                            const Standard_Real               Param2     ,
+                            const Standard_Real               Param3     ,
+                            const Standard_Real               Tolerance  ) {
+                              TheSame1 = Standard_False;
+                              TheSame2 = Standard_False;
+                              par1sol = 0.;
+                              par2sol = 0.;
+                              pararg1 = 0.;
+                              pararg2 = 0.;
+                              parcen3 = 0.;
+
+                              WellDone = Standard_False;
+                              Standard_Real Tol = Abs(Tolerance);
+                              WellDone = Standard_False;
+                              if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
+                                Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+                                !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
+                                Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+                                  GccEnt_BadQualifier::Raise();
+                                  return;
+                              }
+                              gp_Dir2d dirx(1.,0.);
+                              Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+                              Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+                              math_Vector Umin(1,4);
+                              math_Vector Umax(1,4);
+                              math_Vector Ufirst(1,4);
+                              math_Vector tol(1,4);
+                              Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
+                              Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+                              Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
+                              Umin(4) = 0.;
+                              Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
+                              Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+                              Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
+                              Umax(4) = RealLast();
+                              Ufirst(1) = Param1;
+                              Ufirst(2) = Param2;
+                              Ufirst(3) = Param3;
+                              tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
+                              tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
+                              tol(3) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
+                              tol(4) = Tol/10.;
+                              gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
+                              gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+                              gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,Param3);
+                              Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+                              Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnCurv,Ufirst(4));
+                              math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+                              Func.Value(Ufirst,Umin);
+                              if (Root.IsDone()) {
+                                Root.Root(Ufirst);
+                                gp_Vec2d Tan1,Tan2,Tan3;
+                                Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
+                                Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+                                Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
+                                Standard_Real dist1 = point3.Distance(point1);
+                                Standard_Real dist2 = point3.Distance(point2);
+                                if ( Abs(dist1-dist2)/2. <= Tol) {
+                                  cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+                                  Standard_Real normetan1 = Tan1.Magnitude();
+                                  Standard_Real normetan2 = Tan2.Magnitude();
+                                  gp_Vec2d Vec1(point1,point3);
+                                  gp_Vec2d Vec2(point2,point3);
+                                  Standard_Real normevec1 = Vec1.Magnitude();
+                                  Standard_Real normevec2 = Vec2.Magnitude();
+                                  Standard_Real angle1,angle2;
+                                  if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+                                    angle1 = Vec1.Angle(Tan1);
+                                  }
+                                  else { angle1 = 0.; }
+                                  if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+                                    angle2 = Vec2.Angle(Tan2);
+                                  }
+                                  else { angle2 = 0.; }
+                                  if (Qualified1.IsUnqualified()||
+                                    (Qualified1.IsEnclosing()&&angle1<=0.)||
+                                    (Qualified1.IsOutside() && angle1 >= 0.) ||
+                                    (Qualified1.IsEnclosed() && angle1 <= 0.)) {
+                                      if (Qualified2.IsUnqualified() || 
+                                        (Qualified2.IsEnclosing()&&angle2<=0.)||
+                                        (Qualified2.IsOutside() && angle2 >= 0) ||
+                                        (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+                                          qualifier1 = Qualified1.Qualifier();
+                                          qualifier2 = Qualified2.Qualifier();
+                                          pararg1 = Ufirst(1);
+                                          par1sol = 0.;
+                                          pnttg1sol = point1;
+                                          pararg2 = Ufirst(2);
+                                          pnttg2sol = point2;
+                                          par2sol = pnttg2sol.Distance(pnttg1sol);
+                                          pntcen  = point3;
+                                          parcen3 = Ufirst(3);
+                                          WellDone = Standard_True;
+                                      }
+                                  }
+                                }
+                              }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 , 
+                            const Geom2dGcc_QCurve&       Qualified2 , 
+                            const Geom2dAdaptor_Curve&                OnCurv     ,
+                            const Standard_Real                     Param1     ,
+                            const Standard_Real                     Param2     ,
+                            const Standard_Real                     ParamOn    ,
+                            const Standard_Real                     Tolerance     ) {
+
+                              TheSame1 = Standard_False;
+                              TheSame2 = Standard_False;
+                              par1sol = 0.;
+                              par2sol = 0.;
+                              pararg1 = 0.;
+                              pararg2 = 0.;
+                              parcen3 = 0.;
+
+                              WellDone = Standard_False;
+                              if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
+                                Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+                                !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
+                                Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+                                  GccEnt_BadQualifier::Raise();
+                                  return;
+                              }
+                              Standard_Real Tol = Abs(Tolerance);
+                              gp_Circ2d C1 = Qualified1.Qualified();
+                              Standard_Real R1 = C1.Radius();
+                              Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+                              math_Vector Umin(1,4);
+                              math_Vector Umax(1,4);
+                              math_Vector Ufirst(1,4);
+                              math_Vector tol(1,4);
+                              Umin(1) = RealFirst();
+                              Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+                              Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
+                              Umin(4) = 0.;
+                              Umax(1) = RealLast();
+                              Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+                              Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
+                              Umax(4) = RealLast();
+                              Ufirst(1) = Param1;
+                              Ufirst(2) = Param2;
+                              Ufirst(3) = ParamOn;
+                              tol(1) = 2.e-15*M_PI;
+                              tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
+                              tol(3) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
+                              tol(4) = Tol/10.;;
+                              gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
+                              gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+                              gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
+                              Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+                              Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnCurv,Ufirst(4));
+                              math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+                              Func.Value(Ufirst,Umin);
+                              if (Root.IsDone()) {
+                                Root.Root(Ufirst);
+                                gp_Vec2d Tan1,Tan2,Tan3;
+                                Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+                                Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
+                                ElCLib::D1(Ufirst(1),C1,point1,Tan1);
+                                Standard_Real dist1 = point3.Distance(point1);
+                                Standard_Real dist2 = point3.Distance(point2);
+                                if ( Abs(dist1-dist2)/2. <= Tol) {
+                                  gp_Dir2d dirx(1.,0.);
+                                  cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+                                  Standard_Real normetan2 = Tan2.Magnitude();
+                                  gp_Vec2d Vec1(point1.XY(),point3.XY());
+                                  gp_Vec2d Vec2(point2.XY(),point3.XY());
+                                  Standard_Real normevec2 = Vec2.Magnitude();
+                                  Standard_Real angle2;
+                                  if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+                                    angle2 = Vec2.Angle(Tan2);
+                                  }
+                                  else { angle2 = 0.; }
+                                  Standard_Real dist = C1.Location().Distance(point3);
+                                  Standard_Real Rsol = cirsol.Radius();
+                                  if (Qualified1.IsUnqualified() || 
+                                    (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
+                                    (Qualified1.IsOutside() && dist >= Rsol) ||
+                                    (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
+                                      if (Qualified2.IsUnqualified() || 
+                                        (Qualified2.IsEnclosing()&&angle2<=0.)||
+                                        (Qualified2.IsOutside() && angle2 >= 0) ||
+                                        (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+                                          qualifier1 = Qualified1.Qualifier();
+                                          qualifier2 = Qualified2.Qualifier();
+                                          pnttg1sol = point1;
+                                          pararg1 = Ufirst(1);
+                                          par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+                                          pnttg2sol = point2;
+                                          pararg2 = Ufirst(2);
+                                          par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+                                          pntcen  = point3;
+                                          parcen3 = Ufirst(3);
+                                          WellDone = Standard_True;
+                                      }
+                                  }
+                                }
+                              }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin&  Qualified1 , 
+                            const Geom2dGcc_QCurve&     Qualified2 , 
+                            const Geom2dAdaptor_Curve&                OnCurv     ,
+                            const Standard_Real                     Param1     ,
+                            const Standard_Real                     Param2     ,
+                            const Standard_Real                     ParamOn    ,
+                            const Standard_Real                     Tolerance  ) {
+                              TheSame1 = Standard_False;
+                              TheSame2 = Standard_False;
+                              par1sol = 0.;
+                              par2sol = 0.;
+                              pararg1 = 0.;
+                              pararg2 = 0.;
+                              parcen3 = 0.;
+
+                              WellDone = Standard_False;
+                              if (!(Qualified1.IsEnclosed() ||
+                                Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+                                !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
+                                Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+                                  GccEnt_BadQualifier::Raise();
+                                  return;
+                              }
+                              Standard_Real Tol = Abs(Tolerance);
+                              gp_Dir2d dirx(1.,0.);
+                              gp_Lin2d L1 = Qualified1.Qualified();
+                              Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+                              math_Vector Umin(1,4);
+                              math_Vector Umax(1,4);
+                              math_Vector Ufirst(1,4);
+                              math_Vector tol(1,4);
+                              Umin(1) = RealFirst();
+                              Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+                              Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
+                              Umin(4) = 0.;
+                              Umax(1) = RealLast();
+                              Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+                              Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
+                              Umax(4) = RealLast();
+                              Ufirst(1) = Param1;
+                              Ufirst(2) = Param2;
+                              Ufirst(3) = ParamOn;
+                              tol(1) = 1.e-15;
+                              tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
+                              tol(3) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
+                              tol(4) = Tol/10.;
+                              gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
+                              gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+                              gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
+                              Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+                              Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnCurv,Ufirst(4));
+                              math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+                              Func.Value(Ufirst,Umin);
+                              if (Root.IsDone()) {
+                                Root.Root(Ufirst);
+                                gp_Vec2d Tan1,Tan2,Tan3;
+                                ElCLib::D1(Ufirst(1),L1,point1,Tan1);
+                                Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+                                Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
+                                Standard_Real dist1 = point3.Distance(point1);
+                                Standard_Real dist2 = point3.Distance(point2);
+                                if ( Abs(dist1-dist2)/2. <= Tol) {
+                                  cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+                                  Standard_Real normetan2 = Tan2.Magnitude();
+                                  gp_Vec2d Vec1(point1,point3);
+                                  gp_Vec2d Vec2(point2,point3);
+                                  Standard_Real normevec2 = Vec2.Magnitude();
+                                  Standard_Real angle2;
+                                  if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+                                    angle2 = Vec2.Angle(Tan2);
+                                  }
+                                  else { angle2 = 0.; }
+                                  Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
+                                    L1.Direction().X()));
+                                  if (Qualified1.IsUnqualified() ||
+                                    (Qualified1.IsOutside() && pscal <= 0.) ||
+                                    (Qualified1.IsEnclosed() && pscal >= 0.)) {
+                                      if (Qualified2.IsUnqualified() || 
+                                        (Qualified2.IsEnclosing()&&angle2<=0.)||
+                                        (Qualified2.IsOutside() && angle2 >= 0) ||
+                                        (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+                                          qualifier1 = Qualified1.Qualifier();
+                                          qualifier2 = Qualified2.Qualifier();
+                                          pnttg1sol = point1;
+                                          pararg1 = Ufirst(1);
+                                          par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+                                          pnttg2sol = point2;
+                                          pararg2 = Ufirst(2);
+                                          par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+                                          pntcen  = point3;
+                                          parcen3 = Ufirst(3);
+                                          WellDone = Standard_True;
+                                      }
+                                  }
+                                }
+                              }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve&    Qualified1 ,
+                            const gp_Pnt2d&             Point2     ,
+                            const Geom2dAdaptor_Curve&             OnCurv     ,
+                            const Standard_Real                  Param1     ,
+                            const Standard_Real                  ParamOn    ,
+                            const Standard_Real                  Tolerance  ) 
+{
+  TheSame1 = Standard_False;
+  TheSame2 = Standard_False;
+  par1sol = 0.;
+  par2sol = 0.;
+  pararg1 = 0.;
+  pararg2 = 0.;
+  parcen3 = 0.;
+
+  WellDone = Standard_False;
+  if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
+    Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
+      GccEnt_BadQualifier::Raise();
+      return;
+  }
+  Standard_Real Tol = Abs(Tolerance);
+  gp_Dir2d dirx(1.,0.);
+  Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+  math_Vector Umin(1,3);
+  math_Vector Umax(1,3);
+  math_Vector Ufirst(1,3);
+  math_Vector tol(1,3);
+  Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
+  Umin(2) = RealFirst();
+  Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
+  Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
+  Umax(2) = RealLast();
+  Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
+  Ufirst(1) = Param1;
+  Ufirst(2) = ParamOn;
+  tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
+  tol(2) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
+  tol(3) = Tol/10.;
+  gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
+  gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
+  Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
+  Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnCurv,Ufirst(3));
+  math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+  Func.Value(Ufirst,Umin);
+  if (Root.IsDone()) {
+    Root.Root(Ufirst);
+    //    gp_Vec2d Tan1,Tan2,Tan3;
+    gp_Vec2d Tan1,Tan3;
+    Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
+    Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
+    Standard_Real dist1 = point3.Distance(point1);
+    Standard_Real dist2 = point3.Distance(Point2);
+    if ( Abs(dist1-dist2)/2. <= Tol) {
+      cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+      Standard_Real normetan1 = Tan1.Magnitude();
+      gp_Vec2d Vec1(point1,point3);
+      Standard_Real normevec1 = Vec1.Magnitude();
+      Standard_Real angle1;
+      if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+        angle1 = Vec1.Angle(Tan1);
+      }
+      else { angle1 = 0.; }
+      if (Qualified1.IsUnqualified()||
+        (Qualified1.IsEnclosing()&&angle1<=0.)||
+        (Qualified1.IsOutside() && angle1 >= 0.) ||
+        (Qualified1.IsEnclosed() && angle1 <= 0.)) {
+          qualifier1 = Qualified1.Qualifier();
+          qualifier2 = GccEnt_noqualifier;
+          pnttg1sol = point1;
+          pararg1 = Ufirst(1);
+          par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+          pnttg2sol = Point2;
+          pararg2 = 0.;
+          par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+          pntcen  = point3;
+          parcen3 = Ufirst(3);
+          WellDone = Standard_True;
+      }
+    }
+  }
+}
+
+Standard_Boolean Geom2dGcc_Circ2d2TanOnIter::
+IsDone () const{ return WellDone; }
+
+gp_Circ2d Geom2dGcc_Circ2d2TanOnIter::
+ThisSolution () const{ return cirsol; }
+
+void Geom2dGcc_Circ2d2TanOnIter:: 
+WhichQualifier (GccEnt_Position& Qualif1  ,
+                GccEnt_Position& Qualif2  ) const
+{
+  if (!WellDone) { StdFail_NotDone::Raise(); }
+  else {
+    Qualif1 = qualifier1;
+    Qualif2 = qualifier2;
+  }
+}
+
+void Geom2dGcc_Circ2d2TanOnIter:: 
+Tangency1 (Standard_Real&      ParSol         ,
+           Standard_Real&      ParArg         ,
+           gp_Pnt2d&  PntSol         ) const
+{
+  if (!WellDone) { StdFail_NotDone::Raise(); }
+  else {
+    if (TheSame1 == 0) {
+      ParSol = 0;
+      ParArg = 0;
+      PntSol = pnttg1sol;
+    }
+    else { StdFail_NotDone::Raise(); }
+  }
+}
+
+void Geom2dGcc_Circ2d2TanOnIter:: 
+Tangency2 (Standard_Real&      ParSol         ,
+           Standard_Real&      ParArg         ,
+           gp_Pnt2d&  PntSol         ) const
+{
+  if (!WellDone) { StdFail_NotDone::Raise(); }
+  else {
+    ParSol = 0;
+    ParArg = 0;
+    PntSol = pnttg2sol;
+  }
+}
+
+void Geom2dGcc_Circ2d2TanOnIter::
+CenterOn3 (Standard_Real&      ParArg         ,
+           gp_Pnt2d&  PntSol         ) const
+{
+  if (!WellDone) { StdFail_NotDone::Raise(); }
+  else {
+    ParArg = 0;
+    PntSol = pntcen;
+  }
+}
+
+Standard_Boolean Geom2dGcc_Circ2d2TanOnIter::
+IsTheSame1 () const
+{
+  if (!WellDone) StdFail_NotDone::Raise();
+
+  if (TheSame1 == 0) 
+    return Standard_False;
+  return Standard_True;
+}
+
+
+Standard_Boolean Geom2dGcc_Circ2d2TanOnIter::
+IsTheSame2 () const
+{
+  if (!WellDone) StdFail_NotDone::Raise();
+  return Standard_False;
+}
index 64512fe..2c83d66 100644 (file)
@@ -47,7 +47,7 @@ uses QualifiedCurve  from Geom2dGcc,
      Array1OfReal    from TColStd,
      Circ2d3Tan      from GccAna,
      Point           from Geom2d,
-     MyC2d3Tan       from Geom2dGcc,
+     Circ2d3TanIter   from Geom2dGcc,
      Position         from GccEnt,
      Array1OfPosition from GccEnt
 
@@ -316,9 +316,4 @@ fields
        ---Purpose: The parameter of the tangency point between the solution and the third
        -- argument on the second argument.
 
-
---    CircAna  : Circ2d2TanOn from GccAna;
---    CircIter : Circ2d2TanOn from GccIter;
---    TypeAna  : Boolean;
-
 end Circ2d3Tan;
index 356a400..f97f1b3 100644 (file)
@@ -19,7 +19,7 @@
 #include <Geom2d_Line.hxx>
 #include <Geom2d_Circle.hxx>
 #include <Geom2dGcc_QCurve.hxx>
-#include <Geom2dGcc_MyC2d3Tan.hxx>
+#include <Geom2dGcc_Circ2d3TanIter.hxx>
 #include <GccEnt_QualifiedCirc.hxx>
 #include <GccEnt_QualifiedLin.hxx>
 #include <StdFail_NotDone.hxx>
@@ -215,7 +215,7 @@ Geom2dGcc_Circ2d3Tan::
     Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
     Geom2dGcc_QCurve Qc2(C2,Qualified2.Qualifier());
     Geom2dGcc_QCurve Qc3(C3,Qualified3.Qualifier());
-    Geom2dGcc_MyC2d3Tan Circ(Qc1,Qc2,Qc3,Param1,Param2,Param3,Tolerance);
+    Geom2dGcc_Circ2d3TanIter Circ(Qc1,Qc2,Qc3,Param1,Param2,Param3,Tolerance);
     WellDone = Circ.IsDone();
     NbrSol = 1;
     if (WellDone) {
@@ -334,7 +334,7 @@ Geom2dGcc_Circ2d3Tan::
   else {
     Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
     Geom2dGcc_QCurve Qc2(C2,Qualified2.Qualifier());
-    Geom2dGcc_MyC2d3Tan Circ(Qc1,Qc2,Point->Pnt2d(),Param1,Param2,Tolerance);
+    Geom2dGcc_Circ2d3TanIter Circ(Qc1,Qc2,Point->Pnt2d(),Param1,Param2,Tolerance);
     WellDone = Circ.IsDone();
     NbrSol = 1;
     if (WellDone) {
@@ -413,7 +413,7 @@ Geom2dGcc_Circ2d3Tan::
   }
   else {
     Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
-    Geom2dGcc_MyC2d3Tan Circ(Qc1,Point1->Pnt2d(),Point2->Pnt2d(),
+    Geom2dGcc_Circ2d3TanIter Circ(Qc1,Point1->Pnt2d(),Point2->Pnt2d(),
                             Param1,Tolerance);
     WellDone = Circ.IsDone();
     NbrSol = 1;
similarity index 88%
rename from src/GccIter/GccIter_Circ2d3Tan.cdl
rename to src/Geom2dGcc/Geom2dGcc_Circ2d3TanIter.cdl
index 79b5c23..e01465d 100644 (file)
 -- Alternatively, this file may be used under the terms of Open CASCADE
 -- commercial license or contractual agreement.
 
-generic class Circ2d3Tan from GccIter (
-    TheCurve          as any;
-    TheCurveTool      as any; -- as CurveTool from GccInt (TheCurve)
-    TheQualifiedCurve as any) -- as QualifiedCurve from GccEnt
-                             --                  (TheCurve)
+class Circ2d3TanIter from Geom2dGcc
 
        ---Purpose: This class implements the algorithms used to 
        --          create 2d circles tangent to 3 points/lines/circles/
@@ -36,119 +32,120 @@ uses Pnt2d            from gp,
      Circ2d           from gp,
      QualifiedCirc    from GccEnt,
      QualifiedLin     from GccEnt,
-     Position         from GccEnt
+     Position         from GccEnt,
+     Curve            from Geom2dAdaptor,
+     CurveTool        from Geom2dGcc,
+     QCurve           from Geom2dGcc
 
 raises NotDone    from StdFail
 
-private class FuncTCuCuCu instantiates FunctionTanCuCuCu from GccIter (
-                                           TheCurve,TheCurveTool);
 is
 
 Create(Qualified1 : QualifiedCirc from GccEnt ;
        Qualified2 : QualifiedCirc from GccEnt ;
-       Qualified3 : TheQualifiedCurve            ;
+       Qualified3 : QCurve from Geom2dGcc;
        Param1     : Real                         ;
        Param2     : Real                         ;
        Param3     : Real                         ;
        Tolerance  : Real                         ) 
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
        ---Purpose: This method implements the algorithms used to 
        --          create 2d circles tangent to 2 circles and a curve.
 
 Create(Qualified1 : QualifiedCirc from GccEnt ;
-       Qualified2 : TheQualifiedCurve            ;
-       Qualified3 : TheQualifiedCurve            ;
+       Qualified2 : QCurve from Geom2dGcc;
+       Qualified3 : QCurve from Geom2dGcc;
        Param1     : Real                         ;
        Param2     : Real                         ;
        Param3     : Real                         ;
        Tolerance  : Real                         )
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
        ---Purpose: This method implements the algorithms used to 
        --          create 2d circles tangent to a circle and 2 curves.
 
 Create(Qualified1 : QualifiedCirc from GccEnt ;
        Qualified2 : QualifiedLin  from GccEnt ;
-       Qualified3 : TheQualifiedCurve            ;
+       Qualified3 : QCurve from Geom2dGcc;
        Param1     : Real                         ;
        Param2     : Real                         ;
        Param3     : Real                         ;
        Tolerance  : Real                         ) 
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
        ---Purpose: This method implements the algorithms used to 
        --          create 2d circles tangent to a circle and a line and
        --          a curve.
 
 Create(Qualified1 : QualifiedCirc     from GccEnt ;
-       Qualified2 : TheQualifiedCurve                ;
+       Qualified2 : QCurve from Geom2dGcc;
        Point3     : Pnt2d                            ;
        Param1     : Real                             ;
        Param2     : Real                             ;
        Tolerance  : Real                             ) 
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
        ---Purpose: This method implements the algorithms used to 
        --          create 2d circles tangent to a circle and a point and
        --          a curve.
 
 Create(Qualified1 : QualifiedLin      from GccEnt ;
        Qualified2 : QualifiedLin      from GccEnt ;
-       Qualified3 : TheQualifiedCurve                ;
+       Qualified3 : QCurve from Geom2dGcc;
        Param1     : Real                             ;
        Param2     : Real                             ;
        Param3     : Real                             ;
        Tolerance  : Real                             ) 
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
        ---Purpose: This method implements the algorithms used to 
        --          create 2d circles tangent to 2 lines and a curve.
 
 Create(Qualified1 : QualifiedLin      from GccEnt ;
-       Qualified2 : TheQualifiedCurve                ;
-       Qualified3 : TheQualifiedCurve                ;
+       Qualified2 : QCurve from Geom2dGcc;
+       Qualified3 : QCurve from Geom2dGcc;
        Param1     : Real                             ;
        Param2     : Real                             ;
        Param3     : Real                             ;
        Tolerance  : Real                             ) 
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
        ---Purpose: This method implements the algorithms used to 
        --          create 2d circles tangent to a line and 2 curves.
 
 Create(Qualified1 : QualifiedLin      from GccEnt ;
-       Qualified2 : TheQualifiedCurve                ;
+       Qualified2 : QCurve from Geom2dGcc;
        Point3     : Pnt2d                            ;
        Param1     : Real                             ;
        Param2     : Real                             ;
        Tolerance  : Real                             ) 
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
        ---Purpose: This method implements the algorithms used to 
        --          create 2d circles tangent to a line and a curve 
        --          and a point.
 
-Create(Qualified1 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc;
        Point1     : Pnt2d             ;
        Point2     : Pnt2d             ;
        Param1     : Real              ;
        Tolerance  : Real              ) 
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
        ---Purpose: This method implements the algorithms used to 
        --          create 2d circles tangent to a curve and 2 points.
 
-Create(Qualified1 : TheQualifiedCurve ;
-       Qualified2 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc ;
+       Qualified2 : QCurve from Geom2dGcc ;
        Point2     : Pnt2d             ;
        Param1     : Real              ;
        Param2     : Real              ;
        Tolerance  : Real              ) 
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
        ---Purpose: This method implements the algorithms used to 
        --          create 2d circles tangent to 2 curves and a point.
 
-Create(Qualified1 : TheQualifiedCurve ;
-       Qualified2 : TheQualifiedCurve ;
-       Qualified3 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc ;
+       Qualified2 : QCurve from Geom2dGcc ;
+       Qualified3 : QCurve from Geom2dGcc ;
        Param1     : Real              ;
        Param2     : Real              ;
        Param3     : Real              ;
        Tolerance  : Real              ) 
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
        ---Purpose: This method implements the algorithms used to 
        --          create 2d circles tangent to 3 curves.
 
@@ -315,4 +312,4 @@ fields
     ---Purpose: The parameter of the tangency point between the solution 
     --          and the third argument on the second argument.
 
-end Circ2d3Tan;
+end Circ2d3TanIter;
diff --git a/src/Geom2dGcc/Geom2dGcc_Circ2d3TanIter.cxx b/src/Geom2dGcc/Geom2dGcc_Circ2d3TanIter.cxx
new file mode 100644 (file)
index 0000000..f503380
--- /dev/null
@@ -0,0 +1,1356 @@
+// Created on: 1991-12-13
+// Created by: Remi GILET
+// Copyright (c) 1991-1999 Matra Datavision
+// Copyright (c) 1999-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+//=========================================================================
+//   Creation d un cercle tangent a deux elements : Droite.               +
+//                                                  Cercle.               +
+//                                                  Point.                +
+//                                                  Courbes.              +
+//                        centre sur un troisieme : Droite.               +
+//                                                  Cercle.               +
+//                                                  Courbes.              +
+//=========================================================================
+
+#include <Geom2dGcc_Circ2d3TanIter.ixx>
+
+#include <gp_Dir2d.hxx>
+#include <gp_Ax2d.hxx>
+#include <gp_Vec2d.hxx>
+#include <gp.hxx>
+#include <StdFail_NotDone.hxx>
+#include <GccEnt_BadQualifier.hxx>
+#include <math_FunctionSetRoot.hxx>
+#include <math_NewtonFunctionSetRoot.hxx>
+#include <GccAna_Circ2d3Tan.hxx>
+
+#include <Geom2dGcc_CurveTool.hxx>
+#include <Geom2dGcc_FunctionTanCuCuCu.hxx>
+
+Geom2dGcc_Circ2d3TanIter::
+Geom2dGcc_Circ2d3TanIter (const Geom2dGcc_QCurve& Qualified1 , 
+                          const Geom2dGcc_QCurve& Qualified2 ,
+                          const Geom2dGcc_QCurve& Qualified3 , 
+                          const Standard_Real      Param1     ,
+                          const Standard_Real      Param2     ,
+                          const Standard_Real      Param3     ,
+                          const Standard_Real      Tolerance  ) {
+
+                            TheSame1 = Standard_False;
+                            TheSame2 = Standard_False;
+                            TheSame3 = Standard_False;
+                            par1sol = 0.;
+                            par2sol = 0.;
+                            par3sol = 0.;
+                            pararg1 = 0.;
+                            pararg2 = 0.;
+                            pararg3 = 0.;
+
+                            Standard_Real Tol = Abs(Tolerance);
+                            WellDone = Standard_False;
+                            if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
+                              Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+                              !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
+                              Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
+                              !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() || 
+                              Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
+                                GccEnt_BadQualifier::Raise();
+                                return;
+                            }
+                            Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+                            Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+                            Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
+                            Geom2dGcc_FunctionTanCuCuCu Func(Cu1,Cu2,Cu3);
+                            math_Vector Umin(1,3);
+                            math_Vector Umax(1,3);
+                            math_Vector Ufirst(1,3);
+                            math_Vector tol(1,3);
+                            Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
+                            Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+                            Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
+                            Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
+                            Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+                            Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
+                            Ufirst(1) = Param1;
+                            Ufirst(2) = Param2;
+                            Ufirst(3) = Param3;
+                            tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
+                            tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
+                            tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));   
+                            math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+                            if (Root.IsDone()) {
+                              Root.Root(Ufirst);
+                              Func.Value(Ufirst,Umin);
+                              gp_Pnt2d point1,point2,point3;
+                              gp_Vec2d Tan1,Tan2,Tan3;
+                              Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
+                              Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+                              Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
+                              GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
+                              if (circ.IsDone()) { 
+                                cirsol = circ.ThisSolution(1);
+                                gp_Pnt2d centre = cirsol.Location();
+                                Standard_Real normetan1 = Tan1.Magnitude();
+                                Standard_Real normetan2 = Tan2.Magnitude();
+                                Standard_Real normetan3 = Tan3.Magnitude();
+                                gp_Vec2d Vec1(point1,centre);
+                                gp_Vec2d Vec2(point2,centre);
+                                gp_Vec2d Vec3(point3,centre);
+                                Standard_Real normevec1 = Vec1.Magnitude();
+                                Standard_Real normevec2 = Vec2.Magnitude();
+                                Standard_Real normevec3 = Vec3.Magnitude();
+                                Standard_Real dot1,dot2,dot3;
+                                if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+                                  dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
+                                }
+                                else { dot1 = 0.; }
+                                if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+                                  dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
+                                }
+                                else { dot2 = 0.; }
+                                if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
+                                  dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
+                                }
+                                else { dot3 = 0.; }
+                                Tol = 1.e-12;
+                                if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
+                                  Standard_Real Angle1 = Vec1.Angle(Tan1);
+                                  if (Qualified1.IsUnqualified()||
+                                    (Qualified1.IsEnclosing()&&Angle1<=0.)||
+                                    (Qualified1.IsOutside() && Angle1 >= 0.) ||
+                                    (Qualified1.IsEnclosed() && Angle1 <= 0.)) {
+                                      Angle1 = Vec2.Angle(Tan2);
+                                      if (Qualified2.IsUnqualified() || 
+                                        (Qualified2.IsEnclosing()&&Angle1<=0.)||
+                                        (Qualified2.IsOutside() && Angle1 >= 0) ||
+                                        (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
+                                          Angle1 = Vec3.Angle(Tan3);
+                                          if (Qualified3.IsUnqualified() || 
+                                            (Qualified3.IsEnclosing()&&Angle1<=0.)||
+                                            (Qualified3.IsOutside() && Angle1 >= 0) ||
+                                            (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
+                                              qualifier1 = Qualified1.Qualifier();
+                                              qualifier2 = Qualified2.Qualifier();
+                                              qualifier3 = Qualified3.Qualifier();
+                                              pararg1 = Ufirst(1);
+                                              par1sol = 0.;
+                                              pnttg1sol = point1;
+                                              pararg2 = Ufirst(2);
+                                              pnttg2sol = point2;
+                                              par2sol = pnttg2sol.Distance(pnttg1sol);
+                                              pnttg3sol = point3;
+                                              pararg3 = Ufirst(3);
+                                              par3sol = pnttg3sol.Distance(pnttg1sol);
+                                              WellDone = Standard_True;
+                                          }
+                                      }
+                                  }
+                                }
+                              }
+                            }
+}
+
+Geom2dGcc_Circ2d3TanIter::
+Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedCirc& Qualified1 , 
+                          const Geom2dGcc_QCurve& Qualified2 ,
+                          const Geom2dGcc_QCurve& Qualified3 , 
+                          const Standard_Real      Param1     ,
+                          const Standard_Real      Param2     ,
+                          const Standard_Real      Param3     ,
+                          const Standard_Real      Tolerance     ) {
+
+                            TheSame1 = Standard_False;
+                            TheSame2 = Standard_False;
+                            TheSame3 = Standard_False;
+                            par1sol = 0.;
+                            par2sol = 0.;
+                            par3sol = 0.;
+                            pararg1 = 0.;
+                            pararg2 = 0.;
+                            pararg3 = 0.;
+
+                            Standard_Real Tol = Abs(Tolerance);
+                            WellDone = Standard_False;
+                            if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
+                              Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+                              !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
+                              Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
+                              !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() || 
+                              Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
+                                GccEnt_BadQualifier::Raise();
+                                return;
+                            }
+                            gp_Circ2d C1 = Qualified1.Qualified();
+                            Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+                            Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
+                            Geom2dGcc_FunctionTanCuCuCu Func(C1,Cu2,Cu3);
+                            math_Vector Umin(1,3);
+                            math_Vector Umax(1,3);
+                            math_Vector Ufirst(1,3);
+                            math_Vector tol(1,3);
+                            Umin(1) = 0.;
+                            Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+                            Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
+                            Umax(1) = 2*M_PI;
+                            Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+                            Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
+                            Ufirst(1) = Param1;
+                            Ufirst(2) = Param2;
+                            Ufirst(3) = Param3;
+                            tol(1) = 2.e-15*M_PI;
+                            tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
+                            tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));   
+                            math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+                            if (Root.IsDone()) {
+                              Root.Root(Ufirst);
+                              Func.Value(Ufirst,Umin);
+                              gp_Pnt2d centre1(C1.Location());
+                              Standard_Real R1 = C1.Radius();
+                              gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
+                              gp_Vec2d Tan1(gp_XY(-Sin(Ufirst(1)),Cos(Ufirst(1))));
+                              gp_Pnt2d point2,point3;
+                              //     gp_Vec2d Tan2,Tan3,Nor2,Nor3;
+                              gp_Vec2d Tan2,Tan3;
+                              Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+                              Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
+                              GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
+                              if (circ.IsDone()) {
+                                cirsol = circ.ThisSolution(1);
+                                gp_Pnt2d centre(cirsol.Location());
+                                Standard_Real dist = centre1.Distance(centre);
+                                Standard_Real Rsol = cirsol.Radius();
+                                Standard_Real normetan1 = Tan1.Magnitude();
+                                Standard_Real normetan2 = Tan2.Magnitude();
+                                Standard_Real normetan3 = Tan3.Magnitude();
+                                gp_Vec2d Vec1(point1,centre);
+                                gp_Vec2d Vec2(point2,centre);
+                                gp_Vec2d Vec3(point3,centre);
+                                Standard_Real normevec1 = Vec1.Magnitude();
+                                Standard_Real normevec2 = Vec2.Magnitude();
+                                Standard_Real normevec3 = Vec3.Magnitude();
+                                Standard_Real dot1,dot2,dot3;
+                                if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+                                  dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
+                                }
+                                else { dot1 = 0.; }
+                                if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+                                  dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
+                                }
+                                else { dot2 = 0.; }
+                                if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
+                                  dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
+                                }
+                                else { dot3 = 0.; }
+                                Tol = 1.e-12;
+                                if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
+                                  if (Qualified1.IsUnqualified() || 
+                                    (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
+                                    (Qualified1.IsOutside() && dist >= Rsol) ||
+                                    (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
+                                      Standard_Real Angle1 = Vec2.Angle(Tan2);
+                                      if (Qualified2.IsUnqualified() || 
+                                        (Qualified2.IsEnclosing()&&Angle1<=0.)||
+                                        (Qualified2.IsOutside() && Angle1 >= 0) ||
+                                        (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
+                                          Angle1 = Vec3.Angle(Tan3);
+                                          if (Qualified3.IsUnqualified() || 
+                                            (Qualified3.IsEnclosing()&&Angle1<=0.)||
+                                            (Qualified3.IsOutside() && Angle1 >= 0) ||
+                                            (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
+                                              qualifier1 = Qualified1.Qualifier();
+                                              qualifier2 = Qualified2.Qualifier();
+                                              qualifier3 = Qualified3.Qualifier();
+                                              pararg1 = Ufirst(1);
+                                              par1sol = 0.;
+                                              pnttg1sol = point1;
+                                              pararg2 = Ufirst(2);
+                                              pnttg2sol = point2;
+                                              par2sol = 0.;
+                                              pararg3 = Ufirst(3);
+                                              pnttg3sol = point3;
+                                              par3sol = 0.;
+                                              WellDone = Standard_True;
+                                          }
+                                      }
+                                  }
+                                }
+                              }
+                            }
+}
+
+Geom2dGcc_Circ2d3TanIter::
+Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedCirc& Qualified1 , 
+                          const GccEnt_QualifiedCirc& Qualified2 , 
+                          const Geom2dGcc_QCurve&    Qualified3 , 
+                          const Standard_Real         Param1     ,
+                          const Standard_Real         Param2     ,
+                          const Standard_Real         Param3     ,
+                          const Standard_Real         Tolerance     ) {
+
+                            TheSame1 = Standard_False;
+                            TheSame2 = Standard_False;
+                            TheSame3 = Standard_False;
+                            par1sol = 0.;
+                            par2sol = 0.;
+                            par3sol = 0.;
+                            pararg1 = 0.;
+                            pararg2 = 0.;
+                            pararg3 = 0.;
+
+                            Standard_Real Tol = Abs(Tolerance);
+                            WellDone = Standard_False;
+                            if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
+                              Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+                              !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
+                              Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
+                              !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() || 
+                              Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
+                                GccEnt_BadQualifier::Raise();
+                                return;
+                            }
+                            gp_Circ2d C1 = Qualified1.Qualified();
+                            gp_Circ2d C2 = Qualified2.Qualified();
+                            Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
+                            Geom2dGcc_FunctionTanCuCuCu Func(C1,C2,Cu3);
+                            math_Vector Umin(1,3);
+                            math_Vector Umax(1,3);
+                            math_Vector Ufirst(1,3);
+                            math_Vector tol(1,3);
+                            Umin(1) = 0.;
+                            Umin(2) = 0.;
+                            Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
+                            Umax(1) = 2*M_PI;
+                            Umax(2) = 2*M_PI;
+                            Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
+                            Ufirst(1) = Param1;
+                            Ufirst(2) = Param2;
+                            Ufirst(3) = Param3;
+                            tol(1) = 2.e-15*M_PI;
+                            tol(2) = 2.e-15*M_PI;
+                            tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));   
+                            math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+                            if (Root.IsDone()) {
+                              Root.Root(Ufirst);
+                              Func.Value(Ufirst,Umin);
+                              gp_Pnt2d centre1(C1.Location());
+                              Standard_Real R1 = C1.Radius();
+                              gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
+                              gp_Vec2d Tan1(gp_XY(-Sin(Ufirst(1)),Cos(Ufirst(1))));
+                              gp_Pnt2d centre2(C2.Location());
+                              Standard_Real R2 = C2.Radius();
+                              gp_Pnt2d point2(centre2.XY()+R2*gp_XY(Cos(Ufirst(2)),Sin(Ufirst(2))));
+                              gp_Vec2d Tan2(gp_XY(-Sin(Ufirst(2)),Cos(Ufirst(2))));
+                              gp_Pnt2d point3;
+                              gp_Vec2d Tan3;
+                              Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
+                              GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
+                              if (circ.IsDone()) {
+                                cirsol = circ.ThisSolution(1);
+                                gp_Pnt2d centre(cirsol.Location());
+                                Standard_Real dist = centre1.Distance(centre);
+                                Standard_Real Rsol = cirsol.Radius();
+                                Standard_Real normetan1 = Tan1.Magnitude();
+                                Standard_Real normetan2 = Tan2.Magnitude();
+                                Standard_Real normetan3 = Tan3.Magnitude();
+                                gp_Vec2d Vec1(point1,centre);
+                                gp_Vec2d Vec2(point2,centre);
+                                gp_Vec2d Vec3(point3,centre);
+                                Standard_Real normevec1 = Vec1.Magnitude();
+                                Standard_Real normevec2 = Vec2.Magnitude();
+                                Standard_Real normevec3 = Vec3.Magnitude();
+                                Standard_Real dot1,dot2,dot3;
+                                if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+                                  dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
+                                }
+                                else { dot1 = 0.; }
+                                if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+                                  dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
+                                }
+                                else { dot2 = 0.; }
+                                if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
+                                  dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
+                                }
+                                else { dot3 = 0.; }
+                                Tol = 1.e-12;
+                                if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
+                                  if (Qualified1.IsUnqualified() || 
+                                    (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
+                                    (Qualified1.IsOutside() && dist >= Rsol) ||
+                                    (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
+                                      dist = centre2.Distance(centre);
+                                      if (Qualified1.IsUnqualified() || 
+                                        (Qualified1.IsEnclosing() && Rsol >= R2 && dist <= Rsol)||
+                                        (Qualified1.IsOutside() && dist >= Rsol) ||
+                                        (Qualified1.IsEnclosed() && Rsol <= R2 && dist <= Rsol)) {
+                                          gp_Vec2d Vec(point3,centre);
+                                          Standard_Real Angle1 = Vec.Angle(Tan3);
+                                          if (Qualified3.IsUnqualified() || 
+                                            (Qualified3.IsEnclosing()&&Angle1<=0.)||
+                                            (Qualified3.IsOutside() && Angle1 >= 0) ||
+                                            (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
+                                              qualifier1 = Qualified1.Qualifier();
+                                              qualifier2 = Qualified2.Qualifier();
+                                              qualifier3 = Qualified3.Qualifier();
+                                              pararg1 = Ufirst(1);
+                                              par1sol = 0.;
+                                              pnttg1sol = point1;
+                                              pararg2 = Ufirst(2);
+                                              pnttg2sol = point2;
+                                              par2sol = 0.;
+                                              pararg3 = Ufirst(3);
+                                              pnttg3sol = point3;
+                                              par3sol = 0.;
+                                              WellDone = Standard_True;
+                                          }
+                                      }
+                                  }
+                                }
+                              }
+                            }
+}
+
+Geom2dGcc_Circ2d3TanIter::
+Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedLin& Qualified1 , 
+                          const Geom2dGcc_QCurve&   Qualified2 ,
+                          const Geom2dGcc_QCurve&   Qualified3 , 
+                          const Standard_Real        Param1     ,
+                          const Standard_Real        Param2     ,
+                          const Standard_Real        Param3     ,
+                          const Standard_Real        Tolerance  ) {
+
+                            TheSame1 = Standard_False;
+                            TheSame2 = Standard_False;
+                            TheSame3 = Standard_False;
+                            par1sol = 0.;
+                            par2sol = 0.;
+                            par3sol = 0.;
+                            pararg1 = 0.;
+                            pararg2 = 0.;
+                            pararg3 = 0.;
+
+                            Standard_Real Tol = Abs(Tolerance);
+                            WellDone = Standard_False;
+                            if (!(Qualified1.IsEnclosed() ||
+                              Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+                              !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
+                              Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
+                              !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() || 
+                              Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
+                                GccEnt_BadQualifier::Raise();
+                                return;
+                            }
+                            gp_Lin2d L1 = Qualified1.Qualified();
+                            Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+                            Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
+                            Geom2dGcc_FunctionTanCuCuCu Func(L1,Cu2,Cu3);
+                            math_Vector Umin(1,3);
+                            math_Vector Umax(1,3);
+                            math_Vector Ufirst(1,3);
+                            math_Vector tol(1,3);
+                            Umin(1) = RealFirst();
+                            Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+                            Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
+                            Umax(1) = RealLast();
+                            Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+                            Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
+                            Ufirst(1) = Param1;
+                            Ufirst(2) = Param2;
+                            Ufirst(3) = Param3;
+                            tol(1) = 1.e-15;
+                            tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
+                            tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));   
+                            math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+                            if (Root.IsDone()) {
+                              Root.Root(Ufirst);
+                              Func.Value(Ufirst,Umin);
+                              gp_Pnt2d centre1(L1.Location());
+                              gp_Pnt2d point1(centre1.XY()+Ufirst(1)*L1.Direction().XY());
+                              gp_Pnt2d point2,point3;
+                              gp_Vec2d Tan2,Tan3;
+                              Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+                              Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
+                              GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
+                              if (circ.IsDone()) {
+                                cirsol = circ.ThisSolution(1);
+                                gp_Pnt2d centre(cirsol.Location());
+
+                                // creation vaariables intermediaires pour WNT
+                                gp_XY dummy1 = centre.XY()-L1.Location().XY();
+                                gp_XY dummy2 (-L1.Direction().Y(),L1.Direction().X());
+                                Standard_Real pscal=dummy1.Dot(dummy2);
+
+                                gp_Vec2d Tan1(L1.Direction().XY());
+                                Standard_Real normetan1 = Tan1.Magnitude();
+                                Standard_Real normetan2 = Tan2.Magnitude();
+                                Standard_Real normetan3 = Tan3.Magnitude();
+                                gp_Vec2d Vec1(point1,centre);
+                                gp_Vec2d Vec2(point2,centre);
+                                gp_Vec2d Vec3(point3,centre);
+                                Standard_Real normevec1 = Vec1.Magnitude();
+                                Standard_Real normevec2 = Vec2.Magnitude();
+                                Standard_Real normevec3 = Vec3.Magnitude();
+                                Standard_Real dot1,dot2,dot3;
+                                if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+                                  dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
+                                }
+                                else { dot1 = 0.; }
+                                if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+                                  dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
+                                }
+                                else { dot2 = 0.; }
+                                if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
+                                  dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
+                                }
+                                else { dot3 = 0.; }
+                                Tol = 1.e-12;
+                                if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
+                                  if (Qualified1.IsUnqualified() || 
+                                    (Qualified1.IsOutside() && pscal <= 0.) ||
+                                    (Qualified1.IsEnclosed() && pscal >= 0.)) {
+                                      gp_Vec2d Vec(point2,centre);
+                                      Standard_Real Angle1 = Vec.Angle(Tan2);
+                                      if (Qualified2.IsUnqualified() || 
+                                        (Qualified2.IsEnclosing()&&Angle1<=0.)||
+                                        (Qualified2.IsOutside() && Angle1 >= 0) ||
+                                        (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
+                                          Vec = gp_Vec2d(point3,centre);
+                                          Angle1 = Vec.Angle(Tan3);
+                                          if (Qualified3.IsUnqualified() || 
+                                            (Qualified3.IsEnclosing()&&Angle1<=0.)||
+                                            (Qualified3.IsOutside() && Angle1 >= 0) ||
+                                            (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
+                                              qualifier1 = Qualified1.Qualifier();
+                                              qualifier2 = Qualified2.Qualifier();
+                                              qualifier3 = Qualified3.Qualifier();
+                                              pararg1 = Ufirst(1);
+                                              par1sol = 0.;
+                                              pnttg1sol = point1;
+                                              pararg2 = Ufirst(2);
+                                              pnttg2sol = point2;
+                                              par2sol = 0.;
+                                              pararg3 = Ufirst(3);
+                                              pnttg3sol = point3;
+                                              par3sol = 0.;
+                                              WellDone = Standard_True;
+                                          }
+                                      }
+                                  }
+                                }
+                              }
+                            }
+}
+
+Geom2dGcc_Circ2d3TanIter::
+Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedLin&  Qualified1 , 
+                          const GccEnt_QualifiedLin&  Qualified2 , 
+                          const Geom2dGcc_QCurve&    Qualified3 , 
+                          const Standard_Real         Param1     ,
+                          const Standard_Real         Param2     ,
+                          const Standard_Real         Param3     ,
+                          const Standard_Real         Tolerance  ){
+
+                            TheSame1 = Standard_False;
+                            TheSame2 = Standard_False;
+                            TheSame3 = Standard_False;
+                            par1sol = 0.;
+                            par2sol = 0.;
+                            par3sol = 0.;
+                            pararg1 = 0.;
+                            pararg2 = 0.;
+                            pararg3 = 0.;
+
+                            Standard_Real Tol = Abs(Tolerance);
+                            WellDone = Standard_False;
+                            if (!(Qualified1.IsEnclosed() || 
+                              Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+                              !(Qualified2.IsEnclosed() || 
+                              Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
+                              !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() || 
+                              Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
+                                GccEnt_BadQualifier::Raise();
+                                return;
+                            }
+                            gp_Lin2d L1 = Qualified1.Qualified();
+                            gp_Lin2d L2 = Qualified2.Qualified();
+                            Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
+                            Geom2dGcc_FunctionTanCuCuCu Func(L1,L2,Cu3);
+                            math_Vector Umin(1,3);
+                            math_Vector Umax(1,3);
+                            math_Vector Ufirst(1,3);
+                            math_Vector tol(1,3);
+                            Umin(1) = RealFirst();
+                            Umin(2) = RealFirst();
+                            Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
+                            Umax(1) = RealLast();
+                            Umax(2) = RealLast();
+                            Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);