// File:	GccIter_Circ2d3Tan.gxx
// Created:	Fri Dec 13 15:27:54 1991
// Author:	Remi GILET
//		<reg@topsn3>

//=========================================================================
//   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);
     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*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*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);
     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*PI;
   Umax(2) = 2*PI;
   Umax(3) = TheCurveTool::LastParameter(Cu3);
   Ufirst(1) = Param1;
   Ufirst(2) = Param2;
   Ufirst(3) = Param3;
   tol(1) = 2.e-15*PI;
   tol(2) = 2.e-15*PI;
   tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));   
   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
   if (Root.IsDone()) {
     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_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);
     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);
     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*PI;
   Umax(2) = TheCurveTool::LastParameter(Cu1);
   Umax(3) = TheCurveTool::LastParameter(Cu2);
   Ufirst(1) = PI;
   Ufirst(2) = Param1;
   Ufirst(3) = Param2;
   tol(1) = 2.e-15*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);
     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*PI;
   Umax(2) = 2*PI;
   Umax(3) = TheCurveTool::LastParameter(Cu1);
   Ufirst(1) = PI;
   Ufirst(2) = PI;
   Ufirst(3) = Param1;
   tol(1) = 2.e-15*PI;
   tol(2) = 2.e-15*PI;
   tol(3) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
   if (Root.IsDone()) {
     Root.Root(Ufirst);
     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*PI;
   Ufirst(2) = Param1;
   Ufirst(3) = Param2;
   Ufirst(1) = 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);
     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*PI;
   Umax(2) = RealLast();
   Umax(3) = TheCurveTool::LastParameter(Cu3);
   Ufirst(1) = Param1;
   Ufirst(2) = Param2;
   Ufirst(3) = Param3;
   tol(1) = 2.e-15*PI;
   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);
     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*PI;
   Umax(3) = TheCurveTool::LastParameter(Cu2);
   Umax(2) = 2*PI;
   Ufirst(1) = Param1;
   Ufirst(2) = PI;
   Ufirst(3) = Param2;
   tol(1) = 2.e-15*PI;
   tol(2) = 2.e-15*PI;
   tol(3) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
   math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
   if (Root.IsDone()) {
     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 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;
}