[occt.git] / src / GccAna / GccAna_Lin2dTanObl.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 STRAIGHT LINE TANGENT to a CIRCLE or PASSING by a POINT +
//                and MAKING ANGLE A with a STRAIGHT LINE.                   +
//=========================================================================

#include <ElCLib.hxx>
#include <GccAna_Lin2dTanObl.hxx>
#include <GccEnt_BadQualifier.hxx>
#include <GccEnt_QualifiedCirc.hxx>
#include <gp_Circ2d.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Lin2d.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Vec2d.hxx>
#include <gp_XY.hxx>
#include <IntAna2d_AnaIntersection.hxx>
#include <IntAna2d_IntPoint.hxx>
#include <Standard_OutOfRange.hxx>
#include <StdFail_NotDone.hxx>

//=========================================================================
//   Creation of a straight line passing by a point : ThePoint                +
//                         making an angle     : TheAngle                +
//                         with straight line  : TheLine.                +
//   Subject the straight line (ThePoint,TheLine.Location()) to a rotation +
//   by angle TheAngle ==> D1.                                            +
//   create straight line passing through ThePoint of direction D1.              +
//=========================================================================
GccAna_Lin2dTanObl::
   GccAna_Lin2dTanObl (const gp_Pnt2d&          ThePoint  ,
                       const gp_Lin2d&          TheLine   ,
                       const Standard_Real      TheAngle  ):
   linsol(1,1)    ,
   qualifier1(1,1),
   pnttg1sol(1,1) ,
   pntint2sol(1,1),
   par1sol(1,1)   ,
   par2sol(1,1)   ,
   pararg1(1,1)   ,
   pararg2(1,1)   
{

   Standard_Real Cosa = TheLine.Direction().X();
   Standard_Real Sina = TheLine.Direction().Y();
   linsol(1) = gp_Lin2d(ThePoint,
// ==============================
                        gp_Dir2d(Cosa*Cos(TheAngle)-Sina*Sin(TheAngle),
//                      ===============================================
				 Sina*Cos(TheAngle)+Sin(TheAngle)*Cosa));
//                               =======================================
   qualifier1(1) = GccEnt_noqualifier;
   pnttg1sol(1) = ThePoint;
   IntAna2d_AnaIntersection Intp(linsol(1),TheLine);
   if (Intp.IsDone()) {
     if (!Intp.IsEmpty()) {
       for (Standard_Integer i = 1 ; i <= Intp.NbPoints() ; i++) {
	 pntint2sol(1) = Intp.Point(i).Value();
       }
     }
     par1sol(1)=ElCLib::Parameter(linsol(1),pnttg1sol(1));
     par2sol(1)=ElCLib::Parameter(linsol(1),pntint2sol(1));
     pararg1(1)=0.;
     pararg2(1)=ElCLib::Parameter(TheLine,pntint2sol(1));
     NbrSol = 1;
     WellDone = Standard_True;
   }
   else { 
     WellDone = Standard_False; 
     NbrSol=0;
   }
 }

//=========================================================================
//   Creation of a straight line tangent to a circle  : Qualified1 (C1)         +
//                         making angle           : TheAngle                +
//                         with a straight line   : TheLine.                +
//   Subject the straight line  (C1.Location,TheLine.Location()) to a       +
//   rotation by angle TheAngle or -TheAngle ==> D1.                       +
//   create the straight line passing by C1 of direction D1.                    +
//=========================================================================

GccAna_Lin2dTanObl::
   GccAna_Lin2dTanObl (const GccEnt_QualifiedCirc& Qualified1 ,
                       const gp_Lin2d&             TheLine    ,
                       const Standard_Real         TheAngle   ):
   linsol(1,2)   ,
   qualifier1(1,2) ,
   pnttg1sol(1,2),
   pntint2sol(1,2),
   par1sol(1,2),
   par2sol(1,2),
   pararg1(1,2),
   pararg2(1,2)
{

   WellDone = Standard_False;
   NbrSol = 0;
   if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
	 Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
     throw GccEnt_BadQualifier();
     return;
   }
   Standard_Real Cosa = TheLine.Direction().X();
   Standard_Real Sina = TheLine.Direction().Y();
   if (Qualified1.IsEnclosed()) {
// ============================
     throw GccEnt_BadQualifier();
   }
   else {
     gp_Circ2d C1 = Qualified1.Qualified();
     Standard_Real R1 = C1.Radius();
     if (Qualified1.IsEnclosing()) {
//   =============================
       gp_XY xy(Cos(TheAngle)*Cosa-Sin(TheAngle)*Sina,
	        Cos(TheAngle)*Sina+Sin(TheAngle)*Cosa);
       pnttg1sol(1) = gp_Pnt2d(C1.Location().XY()+R1*gp_XY(xy.Y(),-xy.X()));
       linsol(1) = gp_Lin2d(pnttg1sol(1),gp_Dir2d(xy));
//     ===============================================
       qualifier1(1) = Qualified1.Qualifier();
       IntAna2d_AnaIntersection Intp(linsol(1),TheLine);
       NbrSol = 1;
       WellDone = Standard_True;
       if (Intp.IsDone()) {
	 if (!Intp.IsEmpty()) {
	   for (Standard_Integer i = 1 ; i <= Intp.NbPoints() ; i++) {
	     pntint2sol(1) = Intp.Point(i).Value();
	   }
	 }
       }
     }
     else if (Qualified1.IsOutside()) {
//   ================================
       gp_XY xy(Cos(TheAngle)*Cosa-Sin(TheAngle)*Sina,
		Cos(TheAngle)*Sina+Sin(TheAngle)*Cosa);
       pnttg1sol(1) = gp_Pnt2d(C1.Location().XY()+R1*gp_XY(-xy.Y(),xy.X()));
       linsol(1) = gp_Lin2d(pnttg1sol(1),gp_Dir2d(xy));
//     ===============================================
       qualifier1(1) = Qualified1.Qualifier();
       IntAna2d_AnaIntersection Intp(linsol(1),TheLine);
       WellDone = Standard_True;
       NbrSol = 1;
       if (Intp.IsDone()) {
	 if (!Intp.IsEmpty()) {
	   for (Standard_Integer i = 1 ; i <= Intp.NbPoints() ; i++) {
	     pntint2sol(1) = Intp.Point(i).Value();
	   }
	 }
       }
     }
     else if (Qualified1.IsUnqualified()) {
//   ====================================
       gp_XY xy(Cos(TheAngle)*Cosa-Sin(TheAngle)*Sina,
		Cos(TheAngle)*Sina+Sin(TheAngle)*Cosa);
       pnttg1sol(1) = gp_Pnt2d(C1.Location().XY()+R1*gp_XY(xy.Y(),-xy.X()));
       linsol(1) = gp_Lin2d(pnttg1sol(1),gp_Dir2d(xy));
//     ===============================================
       qualifier1(1) = GccEnt_enclosing;
       IntAna2d_AnaIntersection Intp(linsol(1),TheLine);
       WellDone = Standard_True;
       NbrSol=1;
       if (Intp.IsDone()) {
	 if (!Intp.IsEmpty()) {
	   for (Standard_Integer i = 1 ; i <= Intp.NbPoints() ; i++) {
	     pntint2sol(1) = Intp.Point(i).Value();
	   }
	 }
       }
       pnttg1sol(2) = gp_Pnt2d(C1.Location().XY()+R1*gp_XY(-xy.Y(),xy.X()));
       linsol(2) = gp_Lin2d(pnttg1sol(2),gp_Dir2d(xy));
//     ===============================================
       qualifier1(2) = GccEnt_outside;
       Intp = IntAna2d_AnaIntersection(linsol(1),TheLine);
       NbrSol++;
       WellDone = Standard_True;
       if (Intp.IsDone()) {
	 if (!Intp.IsEmpty()) {
	   for (Standard_Integer i = 1 ; i <= Intp.NbPoints() ; i++) {
	     pntint2sol(2) = Intp.Point(i).Value();
	   }
	 }
       }
     }
     for (Standard_Integer index = 1; index <= NbrSol; index++) {
       par1sol(index)=ElCLib::Parameter(linsol(index),pnttg1sol(index));
       pararg1(index)=ElCLib::Parameter(C1,pnttg1sol(index));
       par2sol(index)=ElCLib::Parameter(linsol(index),pntint2sol(index));
       pararg2(index)=ElCLib::Parameter(TheLine,pntint2sol(index));
     }
   }
 }

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

Standard_Integer GccAna_Lin2dTanObl::
   NbSolutions () const 
{ 
  if (!WellDone) throw StdFail_NotDone();
  return NbrSol;
}

gp_Lin2d GccAna_Lin2dTanObl::
   ThisSolution (const Standard_Integer Index) const 
{
  if (!WellDone) 
    throw StdFail_NotDone();
  if (Index <= 0 || Index > NbrSol) 
    throw Standard_OutOfRange();

  return linsol(Index);
}

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

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

void GccAna_Lin2dTanObl::
   Intersection2 (const Standard_Integer Index,
                  Standard_Real& ParSol,
                  Standard_Real& ParArg,
                  gp_Pnt2d& PntSol) const{
   if (!WellDone) { throw StdFail_NotDone(); }
   else if (Index <= 0 ||Index > NbrSol) { throw Standard_OutOfRange(); }
   else {
     ParSol = par2sol(Index);
     ParArg = pararg2(Index);
     PntSol = gp_Pnt2d(pntint2sol(Index));
   }
 }
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	//=========================================================================
0d969553 Y	16	// CREATION of a STRAIGHT LINE TANGENT to a CIRCLE or PASSING by a POINT +
0d969553 Y	17	// and MAKING ANGLE A with a STRAIGHT LINE. +
7fd59977	18	//=========================================================================
7fd59977	19
7fd59977	20	#include <ElCLib.hxx>
42cf5bc1	21	#include <GccAna_Lin2dTanObl.hxx>
	22	#include <GccEnt_BadQualifier.hxx>
	23	#include <GccEnt_QualifiedCirc.hxx>
	24	#include <gp_Circ2d.hxx>
7fd59977	25	#include <gp_Dir2d.hxx>
42cf5bc1	26	#include <gp_Lin2d.hxx>
42cf5bc1	27	#include <gp_Pnt2d.hxx>
7fd59977	28	#include <gp_Vec2d.hxx>
42cf5bc1	29	#include <gp_XY.hxx>
7fd59977	30	#include <IntAna2d_AnaIntersection.hxx>
	31	#include <IntAna2d_IntPoint.hxx>
	32	#include <Standard_OutOfRange.hxx>
42cf5bc1	33	#include <StdFail_NotDone.hxx>
7fd59977	34
7fd59977	35	//=========================================================================
0d969553 Y	36	// Creation of a straight line passing by a point : ThePoint +
	37	// making an angle : TheAngle +
	38	// with straight line : TheLine. +
	39	// Subject the straight line (ThePoint,TheLine.Location()) to a rotation +
	40	// by angle TheAngle ==> D1. +
	41	// create straight line passing through ThePoint of direction D1. +
7fd59977	42	//=========================================================================
7fd59977	43	GccAna_Lin2dTanObl::
	44	GccAna_Lin2dTanObl (const gp_Pnt2d& ThePoint ,
	45	const gp_Lin2d& TheLine ,
	46	const Standard_Real TheAngle ):
	47	linsol(1,1) ,
	48	qualifier1(1,1),
	49	pnttg1sol(1,1) ,
	50	pntint2sol(1,1),
	51	par1sol(1,1) ,
	52	par2sol(1,1) ,
	53	pararg1(1,1) ,
	54	pararg2(1,1)
	55	{
	56
	57	Standard_Real Cosa = TheLine.Direction().X();
	58	Standard_Real Sina = TheLine.Direction().Y();
	59	linsol(1) = gp_Lin2d(ThePoint,
	60	// ==============================
	61	gp_Dir2d(CosaCos(TheAngle)-SinaSin(TheAngle),
	62	// ===============================================
	63	SinaCos(TheAngle)+Sin(TheAngle)Cosa));
	64	// =======================================
	65	qualifier1(1) = GccEnt_noqualifier;
	66	pnttg1sol(1) = ThePoint;
	67	IntAna2d_AnaIntersection Intp(linsol(1),TheLine);
	68	if (Intp.IsDone()) {
	69	if (!Intp.IsEmpty()) {
	70	for (Standard_Integer i = 1 ; i <= Intp.NbPoints() ; i++) {
	71	pntint2sol(1) = Intp.Point(i).Value();
	72	}
	73	}
	74	par1sol(1)=ElCLib::Parameter(linsol(1),pnttg1sol(1));
	75	par2sol(1)=ElCLib::Parameter(linsol(1),pntint2sol(1));
	76	pararg1(1)=0.;
	77	pararg2(1)=ElCLib::Parameter(TheLine,pntint2sol(1));
	78	NbrSol = 1;
	79	WellDone = Standard_True;
	80	}
	81	else {
	82	WellDone = Standard_False;
	83	NbrSol=0;
	84	}
	85	}
	86
	87	//=========================================================================
0d969553 Y	88	// Creation of a straight line tangent to a circle : Qualified1 (C1) +
	89	// making angle : TheAngle +
	90	// with a straight line : TheLine. +
	91	// Subject the straight line (C1.Location,TheLine.Location()) to a +
	92	// rotation by angle TheAngle or -TheAngle ==> D1. +
	93	// create the straight line passing by C1 of direction D1. +
7fd59977	94	//=========================================================================
	95
	96	GccAna_Lin2dTanObl::
	97	GccAna_Lin2dTanObl (const GccEnt_QualifiedCirc& Qualified1 ,
	98	const gp_Lin2d& TheLine ,
	99	const Standard_Real TheAngle ):
	100	linsol(1,2) ,
	101	qualifier1(1,2) ,
	102	pnttg1sol(1,2),
	103	pntint2sol(1,2),
	104	par1sol(1,2),
	105	par2sol(1,2),
	106	pararg1(1,2),
	107	pararg2(1,2)
	108	{
	109
	110	WellDone = Standard_False;
	111	NbrSol = 0;
	112	if (!(Qualified1.IsEnclosed() \|\| Qualified1.IsEnclosing() \|\|
	113	Qualified1.IsOutside() \|\| Qualified1.IsUnqualified())) {
9775fa61	114	throw GccEnt_BadQualifier();
7fd59977	115	return;
	116	}
	117	Standard_Real Cosa = TheLine.Direction().X();
	118	Standard_Real Sina = TheLine.Direction().Y();
	119	if (Qualified1.IsEnclosed()) {
	120	// ============================
9775fa61	121	throw GccEnt_BadQualifier();
7fd59977	122	}
	123	else {
	124	gp_Circ2d C1 = Qualified1.Qualified();
	125	Standard_Real R1 = C1.Radius();
	126	if (Qualified1.IsEnclosing()) {
	127	// =============================
	128	gp_XY xy(Cos(TheAngle)Cosa-Sin(TheAngle)Sina,
	129	Cos(TheAngle)Sina+Sin(TheAngle)Cosa);
	130	pnttg1sol(1) = gp_Pnt2d(C1.Location().XY()+R1*gp_XY(xy.Y(),-xy.X()));
	131	linsol(1) = gp_Lin2d(pnttg1sol(1),gp_Dir2d(xy));
	132	// ===============================================
	133	qualifier1(1) = Qualified1.Qualifier();
	134	IntAna2d_AnaIntersection Intp(linsol(1),TheLine);
	135	NbrSol = 1;
	136	WellDone = Standard_True;
	137	if (Intp.IsDone()) {
	138	if (!Intp.IsEmpty()) {
	139	for (Standard_Integer i = 1 ; i <= Intp.NbPoints() ; i++) {
	140	pntint2sol(1) = Intp.Point(i).Value();
	141	}
	142	}
	143	}
	144	}
	145	else if (Qualified1.IsOutside()) {
	146	// ================================
	147	gp_XY xy(Cos(TheAngle)Cosa-Sin(TheAngle)Sina,
	148	Cos(TheAngle)Sina+Sin(TheAngle)Cosa);
	149	pnttg1sol(1) = gp_Pnt2d(C1.Location().XY()+R1*gp_XY(-xy.Y(),xy.X()));
	150	linsol(1) = gp_Lin2d(pnttg1sol(1),gp_Dir2d(xy));
	151	// ===============================================
	152	qualifier1(1) = Qualified1.Qualifier();
	153	IntAna2d_AnaIntersection Intp(linsol(1),TheLine);
	154	WellDone = Standard_True;
	155	NbrSol = 1;
	156	if (Intp.IsDone()) {
	157	if (!Intp.IsEmpty()) {
	158	for (Standard_Integer i = 1 ; i <= Intp.NbPoints() ; i++) {
	159	pntint2sol(1) = Intp.Point(i).Value();
	160	}
	161	}
	162	}
	163	}
	164	else if (Qualified1.IsUnqualified()) {
	165	// ====================================
	166	gp_XY xy(Cos(TheAngle)Cosa-Sin(TheAngle)Sina,
	167	Cos(TheAngle)Sina+Sin(TheAngle)Cosa);
	168	pnttg1sol(1) = gp_Pnt2d(C1.Location().XY()+R1*gp_XY(xy.Y(),-xy.X()));
	169	linsol(1) = gp_Lin2d(pnttg1sol(1),gp_Dir2d(xy));
	170	// ===============================================
	171	qualifier1(1) = GccEnt_enclosing;
	172	IntAna2d_AnaIntersection Intp(linsol(1),TheLine);
	173	WellDone = Standard_True;
	174	NbrSol=1;
	175	if (Intp.IsDone()) {
	176	if (!Intp.IsEmpty()) {
	177	for (Standard_Integer i = 1 ; i <= Intp.NbPoints() ; i++) {
	178	pntint2sol(1) = Intp.Point(i).Value();
	179	}
	180	}
	181	}
	182	pnttg1sol(2) = gp_Pnt2d(C1.Location().XY()+R1*gp_XY(-xy.Y(),xy.X()));
	183	linsol(2) = gp_Lin2d(pnttg1sol(2),gp_Dir2d(xy));
	184	// ===============================================
	185	qualifier1(2) = GccEnt_outside;
186	Intp = IntAna2d_AnaIntersection(linsol(1),TheLine);
187	NbrSol++;
188	WellDone = Standard_True;
189	if (Intp.IsDone()) {
190	if (!Intp.IsEmpty()) {
191	for (Standard_Integer i = 1 ; i <= Intp.NbPoints() ; i++) {
192	pntint2sol(2) = Intp.Point(i).Value();
193	}
194	}
195	}
196	}
197	for (Standard_Integer index = 1; index <= NbrSol; index++) {
198	par1sol(index)=ElCLib::Parameter(linsol(index),pnttg1sol(index));
199	pararg1(index)=ElCLib::Parameter(C1,pnttg1sol(index));
200	par2sol(index)=ElCLib::Parameter(linsol(index),pntint2sol(index));
201	pararg2(index)=ElCLib::Parameter(TheLine,pntint2sol(index));
202	}
203	}
204	}
205
206	Standard_Boolean GccAna_Lin2dTanObl::
207	IsDone () const { return WellDone; }
208
209	Standard_Integer GccAna_Lin2dTanObl::
210	NbSolutions () const
211	{
9775fa61	212	if (!WellDone) throw StdFail_NotDone();
7fd59977	213	return NbrSol;
	214	}
	215
	216	gp_Lin2d GccAna_Lin2dTanObl::
	217	ThisSolution (const Standard_Integer Index) const
	218	{
	219	if (!WellDone)
9775fa61	220	throw StdFail_NotDone();
7fd59977	221	if (Index <= 0 \|\| Index > NbrSol)
9775fa61	222	throw Standard_OutOfRange();
7fd59977	223
	224	return linsol(Index);
	225	}
	226
	227	void GccAna_Lin2dTanObl::
	228	WhichQualifier(const Standard_Integer Index ,
	229	GccEnt_Position& Qualif1 ) const
	230	{
9775fa61	231	if (!WellDone) { throw StdFail_NotDone(); }
9775fa61	232	else if (Index <= 0 \|\|Index > NbrSol) { throw Standard_OutOfRange(); }
7fd59977	233	else {
	234	Qualif1 = qualifier1(Index);
	235	}
	236	}
	237
	238	void GccAna_Lin2dTanObl::
	239	Tangency1 (const Standard_Integer Index,
	240	Standard_Real& ParSol,
	241	Standard_Real& ParArg,
	242	gp_Pnt2d& PntSol) const{
9775fa61	243	if (!WellDone) { throw StdFail_NotDone(); }
9775fa61	244	else if (Index <= 0 \|\|Index > NbrSol) { throw Standard_OutOfRange(); }
7fd59977	245	else {
	246	ParSol = par1sol(Index);
	247	ParArg = pararg1(Index);
	248	PntSol = gp_Pnt2d(pnttg1sol(Index));
	249	}
	250	}
	251
	252	void GccAna_Lin2dTanObl::
	253	Intersection2 (const Standard_Integer Index,
	254	Standard_Real& ParSol,
	255	Standard_Real& ParArg,
	256	gp_Pnt2d& PntSol) const{
9775fa61	257	if (!WellDone) { throw StdFail_NotDone(); }
9775fa61	258	else if (Index <= 0 \|\|Index > NbrSol) { throw Standard_OutOfRange(); }
7fd59977	259	else {
	260	ParSol = par2sol(Index);
	261	ParArg = pararg2(Index);
	262	PntSol = gp_Pnt2d(pntint2sol(Index));
	263	}
	264	}
	265
	266