[occt.git] / src / GccAna / GccAna_Circ2d3Tan_1.cxx

// Copyright (c) 1995-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 <ElCLib.hxx>
#include <GccAna_Circ2d3Tan.hxx>
#include <GccAna_CircLin2dBisec.hxx>
#include <GccEnt_BadQualifier.hxx>
#include <GccEnt_QualifiedCirc.hxx>
#include <GccEnt_QualifiedLin.hxx>
#include <GccInt_BLine.hxx>
#include <GccInt_BParab.hxx>
#include <GccInt_IType.hxx>
#include <gp_Circ2d.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Lin2d.hxx>
#include <gp_Pnt2d.hxx>
#include <IntAna2d_AnaIntersection.hxx>
#include <IntAna2d_Conic.hxx>
#include <IntAna2d_IntPoint.hxx>
#include <Precision.hxx>
#include <Standard_OutOfRange.hxx>
#include <StdFail_NotDone.hxx>
#include <TColStd_Array1OfReal.hxx>

//=========================================================================
//   Creation of a circle tangent to two circles and a straight line.     +
//=========================================================================
GccAna_Circ2d3Tan::
   GccAna_Circ2d3Tan (const GccEnt_QualifiedCirc& Qualified1,
                      const GccEnt_QualifiedCirc& Qualified2,
                      const GccEnt_QualifiedLin&  Qualified3,
		      const Standard_Real         Tolerance ):

//=========================================================================
//   Initialization of fields.                                           +
//=========================================================================

   cirsol(1,16)     , 
   qualifier1(1,16) ,
   qualifier2(1,16) ,
   qualifier3(1,16),
   TheSame1(1,16)   ,
   TheSame2(1,16)   ,
   TheSame3(1,16)   ,
   pnttg1sol(1,16)  ,
   pnttg2sol(1,16)  ,
   pnttg3sol(1,16)  ,
   par1sol(1,16)    ,
   par2sol(1,16)    ,
   par3sol(1,16)    ,
   pararg1(1,16)    ,
   pararg2(1,16)    ,
   pararg3(1,16)    
{

  gp_Dir2d dirx(1.0,0.0);
  Standard_Real Tol = Abs(Tolerance);
  WellDone = Standard_False;
  NbrSol = 0;
  if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
	Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
      !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || 
	Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
      !(Qualified3.IsEnclosed() || 
	Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
    throw GccEnt_BadQualifier();
    return;
  }

//=========================================================================
//   Processing.                                                          +
//=========================================================================

  gp_Circ2d C1 = Qualified1.Qualified();
  gp_Circ2d C2 = Qualified2.Qualified();
  gp_Lin2d L3 = Qualified3.Qualified();
  Standard_Real R1 = C1.Radius();
  Standard_Real R2 = C2.Radius();
  gp_Pnt2d center1(C1.Location());
  gp_Pnt2d center2(C2.Location());
  (void )center2;

  gp_Pnt2d origin3(L3.Location());
  gp_Dir2d dir3(L3.Direction());
  gp_Dir2d normL3(-dir3.Y(),dir3.X());
  
  TColStd_Array1OfReal Radius(1,2);
  GccAna_CircLin2dBisec Bis1(C1,L3);
  GccAna_CircLin2dBisec Bis2(C2,L3);
  if (Bis1.IsDone() && Bis2.IsDone()) {
    Standard_Integer nbsolution1 = Bis1.NbSolutions();
    Standard_Integer nbsolution2 = Bis2.NbSolutions();
    for (Standard_Integer i = 1 ; i <=  nbsolution1; i++) {
      Handle(GccInt_Bisec) Sol1 = Bis1.ThisSolution(i);
      GccInt_IType typ1 = Sol1->ArcType();
      IntAna2d_AnaIntersection Intp;
      for (Standard_Integer k = 1 ; k <=  nbsolution2; k++) {
	Handle(GccInt_Bisec) Sol2 = Bis2.ThisSolution(k);
	GccInt_IType typ2 = Sol2->ArcType();
	if (typ1 == GccInt_Lin) {
	  if (typ2 == GccInt_Lin) {
	    Intp.Perform(Sol1->Line(),Sol2->Line());
	  }
	  else if (typ2 == GccInt_Par) {
	    Intp.Perform(Sol1->Line(),IntAna2d_Conic(Sol2->Parabola()));
	  }
	}
	else if (typ1 == GccInt_Par) {
	  if (typ2 == GccInt_Lin) {
	    Intp.Perform(Sol2->Line(),IntAna2d_Conic(Sol1->Parabola()));
	  }
	  else if (typ2 == GccInt_Par) {
	    Intp.Perform(Sol1->Parabola(),IntAna2d_Conic(Sol2->Parabola()));
	  }
	}
	if (Intp.IsDone()) {
	  if (!Intp.IsEmpty()) {
	    for (Standard_Integer j = 1 ; j <= Intp.NbPoints() ; j++) {
	      Standard_Real Rradius=0;
	      gp_Pnt2d Center(Intp.Point(j).Value());

// pop : if the coordinates are too great, no creation		 
	      if (Center.X() > 1e10 || 
		  Center.Y() > 1e10  ) break;	      

	      Standard_Real dist1 = Center.Distance(C1.Location());
	       Standard_Real dist2 = Center.Distance(C2.Location());
	      Standard_Real dist3 = L3.Distance(Center);

// pop : if the coordinates are too great, no creation			 
	      if (dist3 > 1e10  ) break;	

	      Standard_Integer nbsol1 = 0;
	      Standard_Integer nbsol2 = 0;
	       Standard_Integer nbsol3 = 0;
	      Standard_Boolean ok = Standard_False;
	      if (Qualified1.IsEnclosed()) {
		if (dist1-R1 < Tolerance) {
		  Radius(1) = Abs(R1-dist1);
		   nbsol1 = 1;
		  ok = Standard_True;
		}
	      }
	      else if (Qualified1.IsOutside()) {
		if (R1-dist1 < Tolerance) {
		  Radius(1) = Abs(R1-dist1);
		  nbsol1 = 1;
		  ok = Standard_True;
		}
	      }
	      else if (Qualified1.IsEnclosing()) {
		ok = Standard_True;
		nbsol1 = 1;
		Radius(1) = Abs(R1-dist1);
	       }
	      else if (Qualified1.IsUnqualified()) {
		ok = Standard_True;
		nbsol1 = 2;
		Radius(1) = Abs(R1-dist1);
		Radius(2) = R1+dist1;
	      }
	      if (Qualified2.IsEnclosed() && ok) {
		if (dist2-R2 < Tolerance) {
		  for (Standard_Integer ii = 1 ; ii <= nbsol1 ; ii++) {
		    if (Abs(Radius(ii)-Abs(R2-dist2)) < Tol) {
		      Radius(1) = Abs(R2-dist2);
		      ok = Standard_True;
		      nbsol2 = 1;
		    }
		  }
		}
	      }
	      else if (Qualified2.IsOutside() && ok) {
		if (R2-dist2 < Tolerance) {
		  for (Standard_Integer ii = 1 ; ii <= nbsol1 ; ii++) {
		    if (Abs(Radius(ii)-Abs(R2-dist2)) < Tol) {
		      Radius(1) = Abs(R2-dist2);
		      ok = Standard_True;
		      nbsol2 = 1;
		    }
		  }
		}
	      }
	      else if (Qualified2.IsEnclosing() && ok) {
		for (Standard_Integer ii = 1 ; ii <= nbsol1 ; ii++) {
		  if (Abs(Radius(ii)-R2-dist2) < Tol) {
		    Radius(1) = R2+dist2;
		    ok = Standard_True;
		    nbsol2 = 1;
		  }
		}
	      }
	      else if (Qualified2.IsUnqualified() && ok) {
		for (Standard_Integer ii = 1 ; ii <= nbsol1 ; ii++) {
		  if (Abs(Radius(ii)-Abs(R2-dist2)) < Tol) {
		     Rradius = Abs(R2-dist2);
		     ok = Standard_True;
		     nbsol2++;
		   }
		  else if (Abs(Radius(ii)-R2-dist2) < Tol) {
		    Rradius = R2+dist2;
		    ok = Standard_True;
		    nbsol2++;
		  }
		}
		if (nbsol2 == 1) {
		  Radius(1) = Rradius;
		}
		else if (nbsol2 == 2) {
		  Radius(1) = Abs(R2-dist2);
		  Radius(2) = R2+dist2;
		}
	      }
	      if (Qualified3.IsEnclosed() && ok) {
		if ((((L3.Location().X()-Center.X())*(-L3.Direction().Y()))+
		    ((L3.Location().Y()-Center.Y())*(L3.Direction().X())))<=0){
		  ok = Standard_True;
		  nbsol3 = 1;
		}
	      }
	      else if (Qualified2.IsOutside() && ok) {
		if ((((L3.Location().X()-Center.X())*(-L3.Direction().Y()))+
	            ((L3.Location().Y()-Center.Y())*(L3.Direction().X())))>=0){
		  ok = Standard_True;
		  nbsol3 = 1;
		}
	      }
	      else if (Qualified2.IsUnqualified() && ok) {
		ok = Standard_True;
		nbsol3 = 1;
	      }
	      if (ok) {
		for (Standard_Integer ind3 = 1 ; ind3 <= nbsol3 ; ind3++) {
		  NbrSol++;
		  cirsol(NbrSol) = gp_Circ2d(gp_Ax2d(Center,dirx),Radius(ind3));
//                ==========================================================
		  Standard_Real distcc1 = Center.Distance(center1);
		  if (!Qualified1.IsUnqualified()) { 
		    qualifier1(NbrSol) = Qualified1.Qualifier();
		  }
		  else if (Abs(distcc1+Radius(ind3)-R1) < Tol) {
		    qualifier1(NbrSol) = GccEnt_enclosed;
		  }
		  else if (Abs(distcc1-R1-Radius(ind3)) < Tol) {
		    qualifier1(NbrSol) = GccEnt_outside;
		  }
		  else { qualifier1(NbrSol) = GccEnt_enclosing; }
		  Standard_Real distcc2 = Center.Distance(center1);
		  if (!Qualified2.IsUnqualified()) { 
		    qualifier2(NbrSol) = Qualified2.Qualifier();
		  }
		  else if (Abs(distcc2+Radius(ind3)-R2) < Tol) {
		    qualifier2(NbrSol) = GccEnt_enclosed;
		  }
		  else if (Abs(distcc2-R2-Radius(ind3)) < Tol) {
		    qualifier2(NbrSol) = GccEnt_outside;
		  }
		  else { qualifier2(NbrSol) = GccEnt_enclosing; }
		  gp_Dir2d dc3(origin3.XY()-Center.XY());
		  if (!Qualified3.IsUnqualified()) { 
		    qualifier3(NbrSol) = Qualified3.Qualifier();
		  }
		  else if (dc3.Dot(normL3) > 0.0) {
		    qualifier3(NbrSol) = GccEnt_outside;
		  }
		  else { qualifier3(NbrSol) = GccEnt_enclosed; }
		  if (Center.Distance(C1.Location()) <= Tolerance &&
		      Abs(Radius(ind3)-R1) <= Tolerance) {
		    TheSame1(NbrSol) = 1;
		  }
		  else {
		    TheSame1(NbrSol) = 0;
		    gp_Dir2d dc(C1.Location().XY()-Center.XY());
		    pnttg1sol(NbrSol)=gp_Pnt2d(Center.XY()+Radius(ind3)*dc.XY());
		    // POP for protection if cirsol(NbrSol).Location == pnttg1sol(NbrSol)
		    if (cirsol(NbrSol).Location().IsEqual(pnttg1sol(NbrSol),Precision::Confusion()))
		      par1sol(NbrSol)=1;
		    else
		      par1sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol),
							pnttg1sol(NbrSol));
		    // POP for protection if C1.Location == pnttg1sol(NbrSol)
		    if (C1.Location().IsEqual(pnttg1sol(NbrSol),Precision::Confusion()))
		      pararg1(NbrSol)=1;
		    else
		      pararg1(NbrSol)=ElCLib::Parameter(C1,pnttg1sol(NbrSol));
		  }
		  if (Center.Distance(C2.Location()) <= Tolerance &&
		      Abs(Radius(ind3)-R2) <= Tolerance) {
		    TheSame2(NbrSol) = 1;
		  }
		  else {
		    TheSame2(NbrSol) = 0;
		    gp_Dir2d dc(C2.Location().XY()-Center.XY());
		    pnttg2sol(NbrSol)=gp_Pnt2d(Center.XY()+Radius(ind3)*dc.XY());
		    // POP for protection if cirsol(NbrSol).Location == pnttg1sol(NbrSol)
		    if (cirsol(NbrSol).Location().IsEqual(pnttg1sol(NbrSol),Precision::Confusion()))
		      par1sol(NbrSol)=1;
		    else
		      par2sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol),
							pnttg2sol(NbrSol));
		    // POP for protection if C2.Location == pnttg2sol(NbrSol)
		    if (C2.Location().IsEqual(pnttg2sol(NbrSol),Precision::Confusion()))
		      pararg2(NbrSol)=1;
		    else
		      pararg2(NbrSol)=ElCLib::Parameter(C2,pnttg2sol(NbrSol));
		  }
		  TheSame3(NbrSol) = 0;
		  gp_Dir2d dc(L3.Location().XY()-Center.XY());
		  Standard_Real sign = dc.Dot(gp_Dir2d(-L3.Direction().Y(),
						       L3.Direction().X()));
		  dc = gp_Dir2d(sign*gp_XY(-L3.Direction().Y(),
					   L3.Direction().X()));
		   pnttg3sol(NbrSol) = gp_Pnt2d(Center.XY()+Radius(ind3)*dc.XY());
		  par3sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol),
						    pnttg3sol(NbrSol));
		  pararg3(NbrSol)=ElCLib::Parameter(L3,pnttg3sol(NbrSol));
		}
	      }
	    }
	   }
	   WellDone = Standard_True;
	}
       }
    }
  }
}
Commit	Line	Data
b311480e	1	// Copyright (c) 1995-1999 Matra Datavision
973c2be1	2	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	3	//
973c2be1	4	// This file is part of Open CASCADE Technology software library.
b311480e	5	//
d5f74e42	6	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	7	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	8	// by the Free Software Foundation, with special exception defined in the file
	9	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	10	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	11	//
973c2be1	12	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	13	// commercial license or contractual agreement.
7fd59977	14
7fd59977	15
7fd59977	16	#include <ElCLib.hxx>
42cf5bc1	17	#include <GccAna_Circ2d3Tan.hxx>
7fd59977	18	#include <GccAna_CircLin2dBisec.hxx>
42cf5bc1	19	#include <GccEnt_BadQualifier.hxx>
	20	#include <GccEnt_QualifiedCirc.hxx>
	21	#include <GccEnt_QualifiedLin.hxx>
7fd59977	22	#include <GccInt_BLine.hxx>
7fd59977	23	#include <GccInt_BParab.hxx>
42cf5bc1	24	#include <GccInt_IType.hxx>
	25	#include <gp_Circ2d.hxx>
	26	#include <gp_Dir2d.hxx>
	27	#include <gp_Lin2d.hxx>
	28	#include <gp_Pnt2d.hxx>
	29	#include <IntAna2d_AnaIntersection.hxx>
7fd59977	30	#include <IntAna2d_Conic.hxx>
42cf5bc1	31	#include <IntAna2d_IntPoint.hxx>
7fd59977	32	#include <Precision.hxx>
42cf5bc1	33	#include <Standard_OutOfRange.hxx>
	34	#include <StdFail_NotDone.hxx>
	35	#include <TColStd_Array1OfReal.hxx>
7fd59977	36
7fd59977	37	//=========================================================================
0d969553	38	// Creation of a circle tangent to two circles and a straight line. +
7fd59977	39	//=========================================================================
7fd59977	40	GccAna_Circ2d3Tan::
	41	GccAna_Circ2d3Tan (const GccEnt_QualifiedCirc& Qualified1,
	42	const GccEnt_QualifiedCirc& Qualified2,
	43	const GccEnt_QualifiedLin& Qualified3,
	44	const Standard_Real Tolerance ):
	45
	46	//=========================================================================
0d969553	47	// Initialization of fields. +
7fd59977	48	//=========================================================================
	49
	50	cirsol(1,16) ,
	51	qualifier1(1,16) ,
	52	qualifier2(1,16) ,
	53	qualifier3(1,16),
	54	TheSame1(1,16) ,
	55	TheSame2(1,16) ,
	56	TheSame3(1,16) ,
	57	pnttg1sol(1,16) ,
	58	pnttg2sol(1,16) ,
	59	pnttg3sol(1,16) ,
	60	par1sol(1,16) ,
	61	par2sol(1,16) ,
	62	par3sol(1,16) ,
	63	pararg1(1,16) ,
	64	pararg2(1,16) ,
	65	pararg3(1,16)
	66	{
	67
	68	gp_Dir2d dirx(1.0,0.0);
	69	Standard_Real Tol = Abs(Tolerance);
	70	WellDone = Standard_False;
	71	NbrSol = 0;
	72	if (!(Qualified1.IsEnclosed() \|\| Qualified1.IsEnclosing() \|\|
	73	Qualified1.IsOutside() \|\| Qualified1.IsUnqualified()) \|\|
	74	!(Qualified2.IsEnclosed() \|\| Qualified2.IsEnclosing() \|\|
	75	Qualified2.IsOutside() \|\| Qualified2.IsUnqualified()) \|\|
	76	!(Qualified3.IsEnclosed() \|\|
	77	Qualified3.IsOutside() \|\| Qualified3.IsUnqualified())) {
9775fa61	78	throw GccEnt_BadQualifier();
7fd59977	79	return;
	80	}
	81
	82	//=========================================================================
0d969553	83	// Processing. +
7fd59977	84	//=========================================================================
	85
	86	gp_Circ2d C1 = Qualified1.Qualified();
	87	gp_Circ2d C2 = Qualified2.Qualified();
	88	gp_Lin2d L3 = Qualified3.Qualified();
	89	Standard_Real R1 = C1.Radius();
	90	Standard_Real R2 = C2.Radius();
	91	gp_Pnt2d center1(C1.Location());
7fd59977	92	gp_Pnt2d center2(C2.Location());
8dbf0462	93	(void )center2;
8dbf0462	94
7fd59977	95	gp_Pnt2d origin3(L3.Location());
	96	gp_Dir2d dir3(L3.Direction());
	97	gp_Dir2d normL3(-dir3.Y(),dir3.X());
	98
	99	TColStd_Array1OfReal Radius(1,2);
	100	GccAna_CircLin2dBisec Bis1(C1,L3);
	101	GccAna_CircLin2dBisec Bis2(C2,L3);
	102	if (Bis1.IsDone() && Bis2.IsDone()) {
	103	Standard_Integer nbsolution1 = Bis1.NbSolutions();
	104	Standard_Integer nbsolution2 = Bis2.NbSolutions();
	105	for (Standard_Integer i = 1 ; i <= nbsolution1; i++) {
	106	Handle(GccInt_Bisec) Sol1 = Bis1.ThisSolution(i);
	107	GccInt_IType typ1 = Sol1->ArcType();
	108	IntAna2d_AnaIntersection Intp;
	109	for (Standard_Integer k = 1 ; k <= nbsolution2; k++) {
	110	Handle(GccInt_Bisec) Sol2 = Bis2.ThisSolution(k);
	111	GccInt_IType typ2 = Sol2->ArcType();
	112	if (typ1 == GccInt_Lin) {
	113	if (typ2 == GccInt_Lin) {
	114	Intp.Perform(Sol1->Line(),Sol2->Line());
	115	}
	116	else if (typ2 == GccInt_Par) {
	117	Intp.Perform(Sol1->Line(),IntAna2d_Conic(Sol2->Parabola()));
	118	}
	119	}
	120	else if (typ1 == GccInt_Par) {
	121	if (typ2 == GccInt_Lin) {
	122	Intp.Perform(Sol2->Line(),IntAna2d_Conic(Sol1->Parabola()));
	123	}
	124	else if (typ2 == GccInt_Par) {
	125	Intp.Perform(Sol1->Parabola(),IntAna2d_Conic(Sol2->Parabola()));
	126	}
	127	}
	128	if (Intp.IsDone()) {
	129	if (!Intp.IsEmpty()) {
	130	for (Standard_Integer j = 1 ; j <= Intp.NbPoints() ; j++) {
	131	Standard_Real Rradius=0;
	132	gp_Pnt2d Center(Intp.Point(j).Value());
	133
0d969553	134	// pop : if the coordinates are too great, no creation
7fd59977	135	if (Center.X() > 1e10 \|\|
	136	Center.Y() > 1e10 ) break;
	137
	138	Standard_Real dist1 = Center.Distance(C1.Location());
	139	Standard_Real dist2 = Center.Distance(C2.Location());
	140	Standard_Real dist3 = L3.Distance(Center);
	141
0d969553	142	// pop : if the coordinates are too great, no creation
7fd59977	143	if (dist3 > 1e10 ) break;
	144
	145	Standard_Integer nbsol1 = 0;
	146	Standard_Integer nbsol2 = 0;
	147	Standard_Integer nbsol3 = 0;
	148	Standard_Boolean ok = Standard_False;
	149	if (Qualified1.IsEnclosed()) {
	150	if (dist1-R1 < Tolerance) {
	151	Radius(1) = Abs(R1-dist1);
	152	nbsol1 = 1;
	153	ok = Standard_True;
	154	}
	155	}
	156	else if (Qualified1.IsOutside()) {
	157	if (R1-dist1 < Tolerance) {
	158	Radius(1) = Abs(R1-dist1);
	159	nbsol1 = 1;
	160	ok = Standard_True;
	161	}
	162	}
	163	else if (Qualified1.IsEnclosing()) {
	164	ok = Standard_True;
	165	nbsol1 = 1;
	166	Radius(1) = Abs(R1-dist1);
	167	}
	168	else if (Qualified1.IsUnqualified()) {
	169	ok = Standard_True;
	170	nbsol1 = 2;
	171	Radius(1) = Abs(R1-dist1);
	172	Radius(2) = R1+dist1;
	173	}
	174	if (Qualified2.IsEnclosed() && ok) {
	175	if (dist2-R2 < Tolerance) {
	176	for (Standard_Integer ii = 1 ; ii <= nbsol1 ; ii++) {
	177	if (Abs(Radius(ii)-Abs(R2-dist2)) < Tol) {
	178	Radius(1) = Abs(R2-dist2);
	179	ok = Standard_True;
	180	nbsol2 = 1;
	181	}
	182	}
	183	}
	184	}
	185	else if (Qualified2.IsOutside() && ok) {
	186	if (R2-dist2 < Tolerance) {
	187	for (Standard_Integer ii = 1 ; ii <= nbsol1 ; ii++) {
	188	if (Abs(Radius(ii)-Abs(R2-dist2)) < Tol) {
	189	Radius(1) = Abs(R2-dist2);
	190	ok = Standard_True;
	191	nbsol2 = 1;
	192	}
	193	}
	194	}
	195	}
	196	else if (Qualified2.IsEnclosing() && ok) {
	197	for (Standard_Integer ii = 1 ; ii <= nbsol1 ; ii++) {
	198	if (Abs(Radius(ii)-R2-dist2) < Tol) {
	199	Radius(1) = R2+dist2;
	200	ok = Standard_True;
	201	nbsol2 = 1;
	202	}
	203	}
	204	}
	205	else if (Qualified2.IsUnqualified() && ok) {
	206	for (Standard_Integer ii = 1 ; ii <= nbsol1 ; ii++) {
207	if (Abs(Radius(ii)-Abs(R2-dist2)) < Tol) {
208	Rradius = Abs(R2-dist2);
209	ok = Standard_True;
210	nbsol2++;
211	}
212	else if (Abs(Radius(ii)-R2-dist2) < Tol) {
213	Rradius = R2+dist2;
214	ok = Standard_True;
215	nbsol2++;
216	}
217	}
218	if (nbsol2 == 1) {
219	Radius(1) = Rradius;
220	}
221	else if (nbsol2 == 2) {
222	Radius(1) = Abs(R2-dist2);
223	Radius(2) = R2+dist2;
224	}
225	}
226	if (Qualified3.IsEnclosed() && ok) {
227	if ((((L3.Location().X()-Center.X())*(-L3.Direction().Y()))+
228	((L3.Location().Y()-Center.Y())*(L3.Direction().X())))<=0){
229	ok = Standard_True;
230	nbsol3 = 1;
231	}
232	}
233	else if (Qualified2.IsOutside() && ok) {
234	if ((((L3.Location().X()-Center.X())*(-L3.Direction().Y()))+
235	((L3.Location().Y()-Center.Y())*(L3.Direction().X())))>=0){
236	ok = Standard_True;
237	nbsol3 = 1;
238	}
239	}
240	else if (Qualified2.IsUnqualified() && ok) {
241	ok = Standard_True;
242	nbsol3 = 1;
243	}
244	if (ok) {
245	for (Standard_Integer ind3 = 1 ; ind3 <= nbsol3 ; ind3++) {
246	NbrSol++;
247	cirsol(NbrSol) = gp_Circ2d(gp_Ax2d(Center,dirx),Radius(ind3));
248	// ==========================================================
249	Standard_Real distcc1 = Center.Distance(center1);
250	if (!Qualified1.IsUnqualified()) {
251	qualifier1(NbrSol) = Qualified1.Qualifier();
252	}
253	else if (Abs(distcc1+Radius(ind3)-R1) < Tol) {
254	qualifier1(NbrSol) = GccEnt_enclosed;
255	}
256	else if (Abs(distcc1-R1-Radius(ind3)) < Tol) {
257	qualifier1(NbrSol) = GccEnt_outside;
258	}
259	else { qualifier1(NbrSol) = GccEnt_enclosing; }
260	Standard_Real distcc2 = Center.Distance(center1);
261	if (!Qualified2.IsUnqualified()) {
262	qualifier2(NbrSol) = Qualified2.Qualifier();
263	}
264	else if (Abs(distcc2+Radius(ind3)-R2) < Tol) {
265	qualifier2(NbrSol) = GccEnt_enclosed;
266	}
267	else if (Abs(distcc2-R2-Radius(ind3)) < Tol) {
268	qualifier2(NbrSol) = GccEnt_outside;
269	}
270	else { qualifier2(NbrSol) = GccEnt_enclosing; }
271	gp_Dir2d dc3(origin3.XY()-Center.XY());
272	if (!Qualified3.IsUnqualified()) {
273	qualifier3(NbrSol) = Qualified3.Qualifier();
274	}
275	else if (dc3.Dot(normL3) > 0.0) {
276	qualifier3(NbrSol) = GccEnt_outside;
277	}
278	else { qualifier3(NbrSol) = GccEnt_enclosed; }
279	if (Center.Distance(C1.Location()) <= Tolerance &&
280	Abs(Radius(ind3)-R1) <= Tolerance) {
281	TheSame1(NbrSol) = 1;
282	}
283	else {
284	TheSame1(NbrSol) = 0;
285	gp_Dir2d dc(C1.Location().XY()-Center.XY());
286	pnttg1sol(NbrSol)=gp_Pnt2d(Center.XY()+Radius(ind3)*dc.XY());
0d969553	287	// POP for protection if cirsol(NbrSol).Location == pnttg1sol(NbrSol)
7fd59977	288	if (cirsol(NbrSol).Location().IsEqual(pnttg1sol(NbrSol),Precision::Confusion()))
	289	par1sol(NbrSol)=1;
	290	else
	291	par1sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol),
	292	pnttg1sol(NbrSol));
0d969553	293	// POP for protection if C1.Location == pnttg1sol(NbrSol)
7fd59977	294	if (C1.Location().IsEqual(pnttg1sol(NbrSol),Precision::Confusion()))
	295	pararg1(NbrSol)=1;
	296	else
	297	pararg1(NbrSol)=ElCLib::Parameter(C1,pnttg1sol(NbrSol));
	298	}
	299	if (Center.Distance(C2.Location()) <= Tolerance &&
	300	Abs(Radius(ind3)-R2) <= Tolerance) {
	301	TheSame2(NbrSol) = 1;
	302	}
	303	else {
	304	TheSame2(NbrSol) = 0;
	305	gp_Dir2d dc(C2.Location().XY()-Center.XY());
	306	pnttg2sol(NbrSol)=gp_Pnt2d(Center.XY()+Radius(ind3)*dc.XY());
0d969553	307	// POP for protection if cirsol(NbrSol).Location == pnttg1sol(NbrSol)
7fd59977	308	if (cirsol(NbrSol).Location().IsEqual(pnttg1sol(NbrSol),Precision::Confusion()))
	309	par1sol(NbrSol)=1;
	310	else
	311	par2sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol),
	312	pnttg2sol(NbrSol));
0d969553	313	// POP for protection if C2.Location == pnttg2sol(NbrSol)
7fd59977	314	if (C2.Location().IsEqual(pnttg2sol(NbrSol),Precision::Confusion()))
	315	pararg2(NbrSol)=1;
	316	else
	317	pararg2(NbrSol)=ElCLib::Parameter(C2,pnttg2sol(NbrSol));
	318	}
	319	TheSame3(NbrSol) = 0;
	320	gp_Dir2d dc(L3.Location().XY()-Center.XY());
	321	Standard_Real sign = dc.Dot(gp_Dir2d(-L3.Direction().Y(),
	322	L3.Direction().X()));
	323	dc = gp_Dir2d(sign*gp_XY(-L3.Direction().Y(),
	324	L3.Direction().X()));
	325	pnttg3sol(NbrSol) = gp_Pnt2d(Center.XY()+Radius(ind3)*dc.XY());
	326	par3sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol),
	327	pnttg3sol(NbrSol));
	328	pararg3(NbrSol)=ElCLib::Parameter(L3,pnttg3sol(NbrSol));
	329	}
	330	}
	331	}
	332	}
	333	WellDone = Standard_True;
	334	}
	335	}
	336	}
	337	}
	338	}