// 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 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;
}