[occt.git] / src / GccAna / GccAna_Circ2dTanCen.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.

//================================================================================
//    Creation of a circle tangent to an element and having center in a point    +
//================================================================================

#include <ElCLib.hxx>
#include <GccAna_Circ2dTanCen.hxx>
#include <GccEnt_BadQualifier.hxx>
#include <GccEnt_QualifiedCirc.hxx>
#include <gp.hxx>
#include <gp_Circ2d.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Lin2d.hxx>
#include <gp_Pnt2d.hxx>
#include <Standard_NegativeValue.hxx>
#include <Standard_OutOfRange.hxx>
#include <StdFail_NotDone.hxx>

//========================================================================
//     Creation of a circle tangent to a circle with center in a point.      +
//   - Calculate the distance between the center of the circle and the point of  +
//     center : dist                                                     +
//   - Check that this distance is compatible with the qualifier of the circle.                                                        +
//       Si yes, the radius of the solution will be :                           +
//          C1.Radius()-dist if the qualifier is Enclosed.              +
//          C1.Radius()+dist if the qualifier is Enclosing.             +
//          dist-C1.Radius() if the qualifier is Outside.               +
//          a mix of these values if the qualifier is Unqualified.  +
//========================================================================
GccAna_Circ2dTanCen::
   GccAna_Circ2dTanCen (const GccEnt_QualifiedCirc& Qualified1,
                        const gp_Pnt2d&             Pcenter   ,
			const Standard_Real                  Tolerance ):

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

   cirsol(1,2)   ,
   qualifier1(1,2) ,
   TheSame1(1,2) ,
   pnttg1sol(1,2),
   par1sol(1,2),
   pararg1(1,2)
{

   NbrSol = 0;
   Standard_Real Radius = 0.0;
   WellDone = Standard_False;
   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
	 Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
     GccEnt_BadQualifier::Raise();
     return;
   }
   gp_Dir2d dirx(1.0,0.0);
   Standard_Real Tol = Abs(Tolerance);
   gp_Circ2d C1 = Qualified1.Qualified();
   Standard_Real R1 = C1.Radius();
   gp_Pnt2d center1(C1.Location());
   Standard_Real dist;
   Standard_Integer signe = 0;
   Standard_Integer signe1 = 0;

   if (!Qualified1.IsUnqualified()) {
     dist = Pcenter.Distance(center1);
     if (Qualified1.IsEnclosed()) {
//   ============================
       if (dist-R1 <= Tol) {
	 Radius = Abs(R1-dist);
	 signe = 1;
       }
       else { WellDone = Standard_True; }
     }
     else if (Qualified1.IsEnclosing()) {
//   =================================
       Radius = R1+dist;
       signe = -1;
     }
     else if (Qualified1.IsOutside()) {
//   ===============================
       if (dist < R1-Tol) { WellDone = Standard_True; }
       else {
	 Radius = Abs(R1-dist);
	 signe = -1;
       }
     }
     if (signe != 0) {
       NbrSol++;
       cirsol(NbrSol) = gp_Circ2d(gp_Ax2d(Pcenter,dirx),Radius);
//     ========================================================
       qualifier1(NbrSol) = Qualified1.Qualifier();
       if (dist <= gp::Resolution()) { TheSame1(NbrSol) = 1; }
       else {
	 TheSame1(NbrSol) = 0;
	 gp_Dir2d d(Pcenter.X()-center1.X(),Pcenter.Y()-center1.Y());
	 pnttg1sol(NbrSol) = gp_Pnt2d(Pcenter.XY()+signe*Radius*d.XY());
	 par1sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol),pnttg1sol(NbrSol));
	 pararg1(NbrSol)=ElCLib::Parameter(C1,pnttg1sol(NbrSol));
       }
       WellDone = Standard_True;
     }
   }
   else {
// ====
     dist = Pcenter.Distance(center1);
     if (dist >= gp::Resolution()) {
       signe = 1;
       for (Standard_Integer i = 1; i <= 2 ; i++) {
	 signe = -signe;
	 if (R1-dist <= 0.) {
	   signe1 = -1;
	 }
	 else {
	   signe1 = -signe;
	 }
	 Radius = Abs(R1+signe*dist);
	 NbrSol++;
	 cirsol(NbrSol) = gp_Circ2d(gp_Ax2d(Pcenter,dirx),Radius);
//       ========================================================
	 Standard_Real distcc1 = Pcenter.Distance(center1);
	 if (!Qualified1.IsUnqualified()) { 
	   qualifier1(NbrSol) = Qualified1.Qualifier();
	 }
	 else if (Abs(distcc1+Radius-R1) < Tol) {
	   qualifier1(NbrSol) = GccEnt_enclosed;
	 }
	 else if (Abs(distcc1-R1-Radius) < Tol) {
	   qualifier1(NbrSol) = GccEnt_outside;
	 }
	 else { qualifier1(NbrSol) = GccEnt_enclosing; }
	 TheSame1(NbrSol) = 0;
	 WellDone = Standard_True;
	 gp_Dir2d d(Pcenter.X()-center1.X(),Pcenter.Y()-center1.Y());
	 pnttg1sol(NbrSol) = gp_Pnt2d(Pcenter.XY()+signe1*Radius*d.XY());
	 par1sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol),pnttg1sol(NbrSol));
	 pararg1(NbrSol)=ElCLib::Parameter(C1,pnttg1sol(NbrSol));
       }
     }
     else {
       NbrSol++;
       cirsol(NbrSol) = gp_Circ2d(C1);
//     ==============================
       qualifier1(1) = Qualified1.Qualifier();
       TheSame1(NbrSol) = 1;
       WellDone = Standard_True;
     }
   }
 }

//=========================================================================
//   Circle tangent to line Linetan and center in a point Pcenter.    +
//   Calculate the distance from the point to the line ==> Radius.                +
//   Create the circle with center Pcenter of radius Radius.                  +
//=========================================================================

GccAna_Circ2dTanCen::
   GccAna_Circ2dTanCen (const gp_Lin2d&            Linetan    ,
                        const gp_Pnt2d&            Pcenter    ):

//=========================================================================
//   Initialisation of fields.                                           +
//=========================================================================

   cirsol(1,1)   ,
   qualifier1(1,1),
   TheSame1(1,1) ,
   pnttg1sol(1,1),
   par1sol(1,1),
   pararg1(1,1) 
{

   gp_Dir2d dirx(1.0,0.0);
   Standard_Real rayon = Linetan.Distance(Pcenter);
   cirsol(1) = gp_Circ2d(gp_Ax2d(Pcenter,dirx),rayon);
// ==================================================
   qualifier1(1) = GccEnt_noqualifier;
   TheSame1(1) = 0;
   Standard_Real xloc = Linetan.Location().X();
   Standard_Real yloc = Linetan.Location().Y();
   Standard_Real xdir = Linetan.Direction().X();
   Standard_Real ydir = Linetan.Direction().Y();

   if (gp_Dir2d(xloc-Pcenter.X(),yloc-Pcenter.Y())
               .Dot(gp_Dir2d(-ydir,xdir)) > 0.0) {
     pnttg1sol(1) = gp_Pnt2d(Pcenter.XY()+rayon*gp_XY(-ydir,xdir));
     par1sol(1)=ElCLib::Parameter(cirsol(1),pnttg1sol(1));
     pararg1(1)=ElCLib::Parameter(Linetan,pnttg1sol(1));
   }
   else {
     pnttg1sol(1) = gp_Pnt2d(Pcenter.XY()+rayon*gp_XY(ydir,-xdir));
     par1sol(1)=ElCLib::Parameter(cirsol(1),pnttg1sol(1));
     pararg1(1)=ElCLib::Parameter(Linetan,pnttg1sol(1));
   }
   NbrSol = 1;
   WellDone = Standard_True;
 }

//=========================================================================
//   Circle tangent to point Point1 and centered in a point Pcenter.      +
//   Calculate the distance from Pcenter to Point1 ==> Radius.                +
//   Create the circle with center Pcenter of radius Radius.                  +
//=========================================================================

GccAna_Circ2dTanCen::
   GccAna_Circ2dTanCen (const gp_Pnt2d&            Point1     ,
                        const gp_Pnt2d&            Pcenter    ):

//=========================================================================
//   Initialisation of fields.                                           +
//=========================================================================

   cirsol(1,1)   ,
   qualifier1(1,1),
   TheSame1(1,1) ,
   pnttg1sol(1,1),
   par1sol(1,1)  ,
   pararg1(1,1)  
{

   gp_Dir2d dirx(1.0,0.0);
   Standard_Real rayon = Point1.Distance(Pcenter);
   cirsol(1) = gp_Circ2d(gp_Ax2d(Pcenter,dirx),rayon);
// =================================================
   qualifier1(1) = GccEnt_noqualifier;
   TheSame1(1) = 0;
   pnttg1sol(1) = Point1;
   par1sol(1)=ElCLib::Parameter(cirsol(1),pnttg1sol(1));
   pararg1(1) = 0.0;
   NbrSol = 1;
   WellDone = Standard_True;
 }

//=========================================================================

Standard_Boolean GccAna_Circ2dTanCen::
   IsDone () const { return WellDone; }

Standard_Integer GccAna_Circ2dTanCen::
   NbSolutions () const { return NbrSol; }

gp_Circ2d GccAna_Circ2dTanCen::
   ThisSolution (const Standard_Integer Index) const 
{
  if (Index > NbrSol || Index <= 0) { Standard_OutOfRange::Raise(); }
  return cirsol(Index);
}

void GccAna_Circ2dTanCen::
  WhichQualifier(const Standard_Integer Index   ,
		       GccEnt_Position& Qualif1 ) const
{
  if (!WellDone) { StdFail_NotDone::Raise(); }
   else if (Index <= 0 ||Index > NbrSol) { Standard_OutOfRange::Raise(); }
   else {
     Qualif1 = qualifier1(Index);
   }
}

void GccAna_Circ2dTanCen::
   Tangency1 (const Standard_Integer Index,
              Standard_Real& ParSol,
              Standard_Real& ParArg,
              gp_Pnt2d& PntSol) const{
   if (!WellDone) { StdFail_NotDone::Raise(); }
   else if (Index <= 0 ||Index > NbrSol) { Standard_OutOfRange::Raise(); }
   else {
     if (TheSame1(Index) == 0) {
       PntSol = gp_Pnt2d(pnttg1sol(Index));
       ParSol = par1sol(Index);
       ParArg = pararg1(Index);
     }
     else { StdFail_NotDone::Raise(); }
   }
 }

Standard_Boolean GccAna_Circ2dTanCen::
   IsTheSame1 (const Standard_Integer Index) const
{
  if (!WellDone) 
    StdFail_NotDone::Raise();
  if (Index <= 0 ||Index > NbrSol) 
    Standard_OutOfRange::Raise();
 
  if (TheSame1(Index) == 0) 
    return Standard_False;

  return 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
0d969553 Y	15	//================================================================================
	16	// Creation of a circle tangent to an element and having center in a point +
	17	//================================================================================
7fd59977	18
7fd59977	19	#include <ElCLib.hxx>
42cf5bc1	20	#include <GccAna_Circ2dTanCen.hxx>
	21	#include <GccEnt_BadQualifier.hxx>
	22	#include <GccEnt_QualifiedCirc.hxx>
7fd59977	23	#include <gp.hxx>
42cf5bc1	24	#include <gp_Circ2d.hxx>
7fd59977	25	#include <gp_Dir2d.hxx>
42cf5bc1	26	#include <gp_Lin2d.hxx>
	27	#include <gp_Pnt2d.hxx>
	28	#include <Standard_NegativeValue.hxx>
7fd59977	29	#include <Standard_OutOfRange.hxx>
7fd59977	30	#include <StdFail_NotDone.hxx>
7fd59977	31
7fd59977	32	//========================================================================
0d969553 Y	33	// Creation of a circle tangent to a circle with center in a point. +
	34	// - Calculate the distance between the center of the circle and the point of +
	35	// center : dist +
	36	// - Check that this distance is compatible with the qualifier of the circle. +
	37	// Si yes, the radius of the solution will be : +
	38	// C1.Radius()-dist if the qualifier is Enclosed. +
	39	// C1.Radius()+dist if the qualifier is Enclosing. +
	40	// dist-C1.Radius() if the qualifier is Outside. +
	41	// a mix of these values if the qualifier is Unqualified. +
7fd59977	42	//========================================================================
7fd59977	43	GccAna_Circ2dTanCen::
	44	GccAna_Circ2dTanCen (const GccEnt_QualifiedCirc& Qualified1,
	45	const gp_Pnt2d& Pcenter ,
	46	const Standard_Real Tolerance ):
	47
	48	//========================================================================
0d969553	49	// Initialization of fields. +
7fd59977	50	//========================================================================
	51
	52	cirsol(1,2) ,
	53	qualifier1(1,2) ,
	54	TheSame1(1,2) ,
	55	pnttg1sol(1,2),
	56	par1sol(1,2),
	57	pararg1(1,2)
	58	{
	59
	60	NbrSol = 0;
	61	Standard_Real Radius = 0.0;
	62	WellDone = Standard_False;
	63	if (!(Qualified1.IsEnclosed() \|\| Qualified1.IsEnclosing() \|\|
	64	Qualified1.IsOutside() \|\| Qualified1.IsUnqualified())) {
	65	GccEnt_BadQualifier::Raise();
	66	return;
	67	}
	68	gp_Dir2d dirx(1.0,0.0);
	69	Standard_Real Tol = Abs(Tolerance);
	70	gp_Circ2d C1 = Qualified1.Qualified();
	71	Standard_Real R1 = C1.Radius();
	72	gp_Pnt2d center1(C1.Location());
	73	Standard_Real dist;
	74	Standard_Integer signe = 0;
	75	Standard_Integer signe1 = 0;
	76
	77	if (!Qualified1.IsUnqualified()) {
	78	dist = Pcenter.Distance(center1);
	79	if (Qualified1.IsEnclosed()) {
	80	// ============================
	81	if (dist-R1 <= Tol) {
	82	Radius = Abs(R1-dist);
	83	signe = 1;
	84	}
	85	else { WellDone = Standard_True; }
	86	}
	87	else if (Qualified1.IsEnclosing()) {
	88	// =================================
	89	Radius = R1+dist;
	90	signe = -1;
	91	}
	92	else if (Qualified1.IsOutside()) {
	93	// ===============================
	94	if (dist < R1-Tol) { WellDone = Standard_True; }
	95	else {
	96	Radius = Abs(R1-dist);
	97	signe = -1;
	98	}
	99	}
	100	if (signe != 0) {
	101	NbrSol++;
	102	cirsol(NbrSol) = gp_Circ2d(gp_Ax2d(Pcenter,dirx),Radius);
	103	// ========================================================
	104	qualifier1(NbrSol) = Qualified1.Qualifier();
	105	if (dist <= gp::Resolution()) { TheSame1(NbrSol) = 1; }
	106	else {
	107	TheSame1(NbrSol) = 0;
	108	gp_Dir2d d(Pcenter.X()-center1.X(),Pcenter.Y()-center1.Y());
	109	pnttg1sol(NbrSol) = gp_Pnt2d(Pcenter.XY()+signeRadiusd.XY());
	110	par1sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol),pnttg1sol(NbrSol));
	111	pararg1(NbrSol)=ElCLib::Parameter(C1,pnttg1sol(NbrSol));
	112	}
	113	WellDone = Standard_True;
114	}
115	}
116	else {
117	// ====
118	dist = Pcenter.Distance(center1);
119	if (dist >= gp::Resolution()) {
120	signe = 1;
121	for (Standard_Integer i = 1; i <= 2 ; i++) {
122	signe = -signe;
123	if (R1-dist <= 0.) {
124	signe1 = -1;
125	}
126	else {
127	signe1 = -signe;
128	}
129	Radius = Abs(R1+signe*dist);
130	NbrSol++;
131	cirsol(NbrSol) = gp_Circ2d(gp_Ax2d(Pcenter,dirx),Radius);
132	// ========================================================
133	Standard_Real distcc1 = Pcenter.Distance(center1);
134	if (!Qualified1.IsUnqualified()) {
135	qualifier1(NbrSol) = Qualified1.Qualifier();
136	}
137	else if (Abs(distcc1+Radius-R1) < Tol) {
138	qualifier1(NbrSol) = GccEnt_enclosed;
139	}
140	else if (Abs(distcc1-R1-Radius) < Tol) {
141	qualifier1(NbrSol) = GccEnt_outside;
142	}
143	else { qualifier1(NbrSol) = GccEnt_enclosing; }
144	TheSame1(NbrSol) = 0;
145	WellDone = Standard_True;
146	gp_Dir2d d(Pcenter.X()-center1.X(),Pcenter.Y()-center1.Y());
147	pnttg1sol(NbrSol) = gp_Pnt2d(Pcenter.XY()+signe1Radiusd.XY());
148	par1sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol),pnttg1sol(NbrSol));
149	pararg1(NbrSol)=ElCLib::Parameter(C1,pnttg1sol(NbrSol));
150	}
151	}
152	else {
153	NbrSol++;
154	cirsol(NbrSol) = gp_Circ2d(C1);
155	// ==============================
156	qualifier1(1) = Qualified1.Qualifier();
157	TheSame1(NbrSol) = 1;
158	WellDone = Standard_True;
159	}
160	}
161	}
162
163	//=========================================================================
0d969553 Y	164	// Circle tangent to line Linetan and center in a point Pcenter. +
	165	// Calculate the distance from the point to the line ==> Radius. +
	166	// Create the circle with center Pcenter of radius Radius. +
7fd59977	167	//=========================================================================
	168
	169	GccAna_Circ2dTanCen::
	170	GccAna_Circ2dTanCen (const gp_Lin2d& Linetan ,
	171	const gp_Pnt2d& Pcenter ):
	172
	173	//=========================================================================
0d969553	174	// Initialisation of fields. +
7fd59977	175	//=========================================================================
	176
	177	cirsol(1,1) ,
	178	qualifier1(1,1),
	179	TheSame1(1,1) ,
	180	pnttg1sol(1,1),
	181	par1sol(1,1),
	182	pararg1(1,1)
	183	{
	184
	185	gp_Dir2d dirx(1.0,0.0);
	186	Standard_Real rayon = Linetan.Distance(Pcenter);
	187	cirsol(1) = gp_Circ2d(gp_Ax2d(Pcenter,dirx),rayon);
	188	// ==================================================
	189	qualifier1(1) = GccEnt_noqualifier;
	190	TheSame1(1) = 0;
	191	Standard_Real xloc = Linetan.Location().X();
	192	Standard_Real yloc = Linetan.Location().Y();
	193	Standard_Real xdir = Linetan.Direction().X();
	194	Standard_Real ydir = Linetan.Direction().Y();
	195
	196	if (gp_Dir2d(xloc-Pcenter.X(),yloc-Pcenter.Y())
	197	.Dot(gp_Dir2d(-ydir,xdir)) > 0.0) {
	198	pnttg1sol(1) = gp_Pnt2d(Pcenter.XY()+rayon*gp_XY(-ydir,xdir));
	199	par1sol(1)=ElCLib::Parameter(cirsol(1),pnttg1sol(1));
	200	pararg1(1)=ElCLib::Parameter(Linetan,pnttg1sol(1));
	201	}
	202	else {
	203	pnttg1sol(1) = gp_Pnt2d(Pcenter.XY()+rayon*gp_XY(ydir,-xdir));
	204	par1sol(1)=ElCLib::Parameter(cirsol(1),pnttg1sol(1));
	205	pararg1(1)=ElCLib::Parameter(Linetan,pnttg1sol(1));
	206	}
	207	NbrSol = 1;
	208	WellDone = Standard_True;
	209	}
	210
	211	//=========================================================================
0d969553 Y	212	// Circle tangent to point Point1 and centered in a point Pcenter. +
	213	// Calculate the distance from Pcenter to Point1 ==> Radius. +
	214	// Create the circle with center Pcenter of radius Radius. +
7fd59977	215	//=========================================================================
	216
	217	GccAna_Circ2dTanCen::
	218	GccAna_Circ2dTanCen (const gp_Pnt2d& Point1 ,
	219	const gp_Pnt2d& Pcenter ):
	220
	221	//=========================================================================
0d969553	222	// Initialisation of fields. +
7fd59977	223	//=========================================================================
	224
	225	cirsol(1,1) ,
	226	qualifier1(1,1),
	227	TheSame1(1,1) ,
	228	pnttg1sol(1,1),
	229	par1sol(1,1) ,
	230	pararg1(1,1)
	231	{
	232
	233	gp_Dir2d dirx(1.0,0.0);
	234	Standard_Real rayon = Point1.Distance(Pcenter);
	235	cirsol(1) = gp_Circ2d(gp_Ax2d(Pcenter,dirx),rayon);
	236	// =================================================
	237	qualifier1(1) = GccEnt_noqualifier;
	238	TheSame1(1) = 0;
	239	pnttg1sol(1) = Point1;
	240	par1sol(1)=ElCLib::Parameter(cirsol(1),pnttg1sol(1));
	241	pararg1(1) = 0.0;
	242	NbrSol = 1;
	243	WellDone = Standard_True;
	244	}
	245
	246	//=========================================================================
	247
	248	Standard_Boolean GccAna_Circ2dTanCen::
	249	IsDone () const { return WellDone; }
	250
	251	Standard_Integer GccAna_Circ2dTanCen::
	252	NbSolutions () const { return NbrSol; }
	253
	254	gp_Circ2d GccAna_Circ2dTanCen::
	255	ThisSolution (const Standard_Integer Index) const
	256	{
	257	if (Index > NbrSol \|\| Index <= 0) { Standard_OutOfRange::Raise(); }
	258	return cirsol(Index);
	259	}
	260
	261	void GccAna_Circ2dTanCen::
	262	WhichQualifier(const Standard_Integer Index ,
	263	GccEnt_Position& Qualif1 ) const
	264	{
	265	if (!WellDone) { StdFail_NotDone::Raise(); }
	266	else if (Index <= 0 \|\|Index > NbrSol) { Standard_OutOfRange::Raise(); }
	267	else {
	268	Qualif1 = qualifier1(Index);
	269	}
	270	}
	271
	272	void GccAna_Circ2dTanCen::
	273	Tangency1 (const Standard_Integer Index,
	274	Standard_Real& ParSol,
	275	Standard_Real& ParArg,
	276	gp_Pnt2d& PntSol) const{
	277	if (!WellDone) { StdFail_NotDone::Raise(); }
	278	else if (Index <= 0 \|\|Index > NbrSol) { Standard_OutOfRange::Raise(); }
	279	else {
	280	if (TheSame1(Index) == 0) {
	281	PntSol = gp_Pnt2d(pnttg1sol(Index));
	282	ParSol = par1sol(Index);
	283	ParArg = pararg1(Index);
	284	}
	285	else { StdFail_NotDone::Raise(); }
	286	}
287	}
288
289	Standard_Boolean GccAna_Circ2dTanCen::
290	IsTheSame1 (const Standard_Integer Index) const
291	{
292	if (!WellDone)
293	StdFail_NotDone::Raise();
294	if (Index <= 0 \|\|Index > NbrSol)
295	Standard_OutOfRange::Raise();
296
297	if (TheSame1(Index) == 0)
298	return Standard_False;
299
300	return Standard_True;
301	}