[occt.git] / src / Geom2dGcc / Geom2dGcc_Lin2dTanObl.cxx

// Created on: 1992-10-21
// Created by: Remi GILET
// Copyright (c) 1992-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 <GccAna_Lin2dTanObl.hxx>
#include <GccEnt_BadQualifier.hxx>
#include <GccEnt_QualifiedCirc.hxx>
#include <Geom2d_Circle.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dGcc_CurveTool.hxx>
#include <Geom2dGcc_IsParallel.hxx>
#include <Geom2dGcc_Lin2dTanObl.hxx>
#include <Geom2dGcc_Lin2dTanOblIter.hxx>
#include <Geom2dGcc_QCurve.hxx>
#include <Geom2dGcc_QualifiedCurve.hxx>
#include <gp_Lin2d.hxx>
#include <gp_Pnt2d.hxx>
#include <Standard_NegativeValue.hxx>
#include <Standard_OutOfRange.hxx>
#include <StdFail_NotDone.hxx>

Geom2dGcc_Lin2dTanObl::
   Geom2dGcc_Lin2dTanObl (const Geom2dGcc_QualifiedCurve& Qualified1 ,
			  const gp_Lin2d&                 TheLine    ,
			  const Standard_Real             TolAng     ,
			  const Standard_Real             Angle      ):
  linsol(1,2)    ,
  qualifier1(1,2),
  pnttg1sol(1,2) ,
  pntint2sol(1,2),
  par1sol(1,2)   ,
  par2sol(1,2)   ,
  pararg1(1,2)   ,
  pararg2(1,2)   
{
  Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
  Handle(Geom2d_Curve) CC1 = C1.Curve();
  GeomAbs_CurveType Type1 = C1.GetType();

//=============================================================================
//                            Appel a GccAna.                                 +
//=============================================================================

  WellDone = Standard_False;
  NbrSol = 0;
  if (Type1 == GeomAbs_Circle ) {
    Handle(Geom2d_Circle) CCC1 = Handle(Geom2d_Circle)::DownCast(CC1);
    gp_Circ2d c1(CCC1->Circ2d());
    GccEnt_QualifiedCirc Qc1=GccEnt_QualifiedCirc(c1,Qualified1.Qualifier());
    GccAna_Lin2dTanObl Lin(Qc1,TheLine,Angle);
    WellDone = Lin.IsDone();
    if(WellDone) { 
      NbrSol = Lin.NbSolutions();
      for (Standard_Integer i = 1 ; i <= NbrSol ; i++) {
	linsol(i)    = Lin.ThisSolution(i);
	Lin.Tangency1(i,par1sol(i),pararg1(i),pnttg1sol(i));
	Lin.Intersection2(i,par2sol(i),pararg2(i),pntint2sol(i));
	Lin.WhichQualifier(i,qualifier1(i));
      }
    }
  }
  else {
    Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
    Standard_Real      aFirstPar  = Geom2dGcc_CurveTool::FirstParameter(C1);
    Standard_Real      aLastPar   = Geom2dGcc_CurveTool::LastParameter(C1);
    Standard_Integer   aNbSamples = Geom2dGcc_CurveTool::NbSamples(C1);
    Standard_Real      aStep      = (aLastPar - aFirstPar)/aNbSamples;
    Standard_Real      Param1     = aFirstPar;
    Standard_Integer   i;
    
    for (i = 0; i <= aNbSamples && NbrSol < 2; i++) {
      Geom2dGcc_Lin2dTanOblIter Lin(Qc1,TheLine,Param1,TolAng,Angle);

      if (Lin.IsDone()) {
	if (Add(NbrSol + 1, Lin, TolAng, C1))
	  NbrSol++;
      }

      Param1 += aStep;
    }

    WellDone = (NbrSol > 0);
  }
}

Geom2dGcc_Lin2dTanObl::
   Geom2dGcc_Lin2dTanObl (const Geom2dGcc_QualifiedCurve& Qualified1 ,
			  const gp_Lin2d&                 TheLine    ,
			  const Standard_Real             TolAng     ,
			  const Standard_Real             Param1     ,
			  const Standard_Real             Angle      ):
  linsol(1,2)    ,
  qualifier1(1,2),
  pnttg1sol(1,2) ,
  pntint2sol(1,2),
  par1sol(1,2)   ,
  par2sol(1,2)   ,
  pararg1(1,2)   ,
  pararg2(1,2)   
{
  Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
  Handle(Geom2d_Curve) CC1 = C1.Curve();
  GeomAbs_CurveType Type1 = C1.GetType();

//=============================================================================
//                            Appel a GccAna.                                 +
//=============================================================================

  WellDone = Standard_False;
  NbrSol = 0;
  if (Type1 == GeomAbs_Circle ) {
    Handle(Geom2d_Circle) CCC1 = Handle(Geom2d_Circle)::DownCast(CC1);
    gp_Circ2d c1(CCC1->Circ2d());
    GccEnt_QualifiedCirc Qc1=GccEnt_QualifiedCirc(c1,Qualified1.Qualifier());
    GccAna_Lin2dTanObl Lin(Qc1,TheLine,Angle);
    WellDone = Lin.IsDone();
    if(WellDone) { 
      NbrSol = Lin.NbSolutions();
      for (Standard_Integer i = 1 ; i <= NbrSol ; i++) {
	linsol(i)    = Lin.ThisSolution(i);
	Lin.Tangency1(i,par1sol(i),pararg1(i),pnttg1sol(i));
	Lin.Intersection2(i,par2sol(i),pararg2(i),pntint2sol(i));
	Lin.WhichQualifier(i,qualifier1(i));
      }
    }
  }
  else {
    Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
    Geom2dGcc_Lin2dTanOblIter Lin(Qc1,TheLine,TolAng,Param1,Angle);
    WellDone = Lin.IsDone();
    if(WellDone) { 
      linsol(1)    = Lin.ThisSolution();
      Lin.Tangency1(par1sol(1),pararg1(1),pnttg1sol(1));
      Lin.Intersection2(par2sol(1),pararg2(1),pntint2sol(1));
      Lin.WhichQualifier(qualifier1(1));
    }
  }
}

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

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

gp_Lin2d Geom2dGcc_Lin2dTanObl::
   ThisSolution (const Standard_Integer Index) const {

   if (Index > NbrSol || Index <= 0) { throw Standard_OutOfRange(); }
   return linsol(Index);
 }

void Geom2dGcc_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 Geom2dGcc_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 = pnttg1sol(Index);
   }
 }

void Geom2dGcc_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 = pntint2sol(Index);
   }
 }

Standard_Boolean Geom2dGcc_Lin2dTanObl::Add
                           (const Standard_Integer       theIndex,
			    const Geom2dGcc_Lin2dTanOblIter &theLin,
			    const Standard_Real          theTol,
			    const Geom2dAdaptor_Curve   &theC1)
{
  Standard_Integer i;
  Standard_Real    aPar1sol;
  Standard_Real    aPar2sol;
  Standard_Real    aPar1arg;
  Standard_Real    aPar2arg;
  gp_Pnt2d         aPnt1Sol;
  gp_Pnt2d         aPnt2Sol;
  gp_Lin2d         aLin   = theLin.ThisSolution();

  theLin.Tangency1(aPar1sol, aPar1arg, aPnt1Sol);
  theLin.Intersection2(aPar2sol, aPar2arg, aPnt2Sol);

  for(i = 1; i < theIndex; i++) {
    if (Abs(aPar1arg - pararg1(i)) <= theTol &&
	Abs(aPar2arg - pararg2(i)) <= theTol)
      return Standard_False;
  }

  gp_Dir2d aLinDir = aLin.Direction();
  gp_Vec2d aVTan;
  gp_Pnt2d aPoint;

  Geom2dGcc_CurveTool::D1(theC1, aPar1arg, aPoint, aVTan);

  if (Abs(aLinDir.Crossed(gp_Dir2d(aVTan))) > theTol)
    return Standard_False;

  linsol(theIndex)     = aLin;
  par1sol(theIndex)    = aPar1sol;
  pararg1(theIndex)    = aPar1arg;
  pnttg1sol(theIndex)  = aPnt1Sol;
  par2sol(theIndex)    = aPar2sol;
  pararg2(theIndex)    = aPar2arg;
  pntint2sol(theIndex) = aPnt2Sol;

  theLin.WhichQualifier(qualifier1(theIndex));

  return Standard_True;
}
Commit	Line	Data
b311480e	1	// Created on: 1992-10-21
	2	// Created by: Remi GILET
	3	// Copyright (c) 1992-1999 Matra Datavision
973c2be1	4	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	5	//
973c2be1	6	// This file is part of Open CASCADE Technology software library.
b311480e	7	//
d5f74e42	8	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	9	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	10	// by the Free Software Foundation, with special exception defined in the file
	11	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	12	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	13	//
973c2be1	14	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	15	// commercial license or contractual agreement.
7fd59977	16
42cf5bc1	17
7fd59977	18	#include <GccAna_Lin2dTanObl.hxx>
42cf5bc1	19	#include <GccEnt_BadQualifier.hxx>
7fd59977	20	#include <GccEnt_QualifiedCirc.hxx>
42cf5bc1	21	#include <Geom2d_Circle.hxx>
	22	#include <Geom2dAdaptor_Curve.hxx>
	23	#include <Geom2dGcc_CurveTool.hxx>
	24	#include <Geom2dGcc_IsParallel.hxx>
	25	#include <Geom2dGcc_Lin2dTanObl.hxx>
	26	#include <Geom2dGcc_Lin2dTanOblIter.hxx>
	27	#include <Geom2dGcc_QCurve.hxx>
	28	#include <Geom2dGcc_QualifiedCurve.hxx>
	29	#include <gp_Lin2d.hxx>
	30	#include <gp_Pnt2d.hxx>
7fd59977	31	#include <Standard_NegativeValue.hxx>
7fd59977	32	#include <Standard_OutOfRange.hxx>
42cf5bc1	33	#include <StdFail_NotDone.hxx>
7fd59977	34
	35	Geom2dGcc_Lin2dTanObl::
	36	Geom2dGcc_Lin2dTanObl (const Geom2dGcc_QualifiedCurve& Qualified1 ,
	37	const gp_Lin2d& TheLine ,
	38	const Standard_Real TolAng ,
	39	const Standard_Real Angle ):
	40	linsol(1,2) ,
	41	qualifier1(1,2),
	42	pnttg1sol(1,2) ,
	43	pntint2sol(1,2),
	44	par1sol(1,2) ,
	45	par2sol(1,2) ,
	46	pararg1(1,2) ,
	47	pararg2(1,2)
	48	{
	49	Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
	50	Handle(Geom2d_Curve) CC1 = C1.Curve();
	51	GeomAbs_CurveType Type1 = C1.GetType();
	52
	53	//=============================================================================
	54	// Appel a GccAna. +
	55	//=============================================================================
	56
	57	WellDone = Standard_False;
	58	NbrSol = 0;
	59	if (Type1 == GeomAbs_Circle ) {
	60	Handle(Geom2d_Circle) CCC1 = Handle(Geom2d_Circle)::DownCast(CC1);
	61	gp_Circ2d c1(CCC1->Circ2d());
	62	GccEnt_QualifiedCirc Qc1=GccEnt_QualifiedCirc(c1,Qualified1.Qualifier());
	63	GccAna_Lin2dTanObl Lin(Qc1,TheLine,Angle);
773f53f1	64	WellDone = Lin.IsDone();
773f53f1	65	if(WellDone) {
7fd59977	66	NbrSol = Lin.NbSolutions();
	67	for (Standard_Integer i = 1 ; i <= NbrSol ; i++) {
	68	linsol(i) = Lin.ThisSolution(i);
	69	Lin.Tangency1(i,par1sol(i),pararg1(i),pnttg1sol(i));
	70	Lin.Intersection2(i,par2sol(i),pararg2(i),pntint2sol(i));
	71	Lin.WhichQualifier(i,qualifier1(i));
	72	}
	73	}
	74	}
	75	else {
0b85f9a6	76	Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
7fd59977	77	Standard_Real aFirstPar = Geom2dGcc_CurveTool::FirstParameter(C1);
	78	Standard_Real aLastPar = Geom2dGcc_CurveTool::LastParameter(C1);
	79	Standard_Integer aNbSamples = Geom2dGcc_CurveTool::NbSamples(C1);
	80	Standard_Real aStep = (aLastPar - aFirstPar)/aNbSamples;
	81	Standard_Real Param1 = aFirstPar;
	82	Standard_Integer i;
	83
	84	for (i = 0; i <= aNbSamples && NbrSol < 2; i++) {
54e37688	85	Geom2dGcc_Lin2dTanOblIter Lin(Qc1,TheLine,Param1,TolAng,Angle);
7fd59977	86
	87	if (Lin.IsDone()) {
	88	if (Add(NbrSol + 1, Lin, TolAng, C1))
	89	NbrSol++;
	90	}
	91
	92	Param1 += aStep;
	93	}
	94
	95	WellDone = (NbrSol > 0);
	96	}
	97	}
	98
	99	Geom2dGcc_Lin2dTanObl::
	100	Geom2dGcc_Lin2dTanObl (const Geom2dGcc_QualifiedCurve& Qualified1 ,
	101	const gp_Lin2d& TheLine ,
	102	const Standard_Real TolAng ,
	103	const Standard_Real Param1 ,
	104	const Standard_Real Angle ):
	105	linsol(1,2) ,
	106	qualifier1(1,2),
	107	pnttg1sol(1,2) ,
	108	pntint2sol(1,2),
	109	par1sol(1,2) ,
	110	par2sol(1,2) ,
	111	pararg1(1,2) ,
	112	pararg2(1,2)
	113	{
	114	Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
	115	Handle(Geom2d_Curve) CC1 = C1.Curve();
	116	GeomAbs_CurveType Type1 = C1.GetType();
	117
	118	//=============================================================================
	119	// Appel a GccAna. +
	120	//=============================================================================
	121
	122	WellDone = Standard_False;
	123	NbrSol = 0;
	124	if (Type1 == GeomAbs_Circle ) {
	125	Handle(Geom2d_Circle) CCC1 = Handle(Geom2d_Circle)::DownCast(CC1);
	126	gp_Circ2d c1(CCC1->Circ2d());
	127	GccEnt_QualifiedCirc Qc1=GccEnt_QualifiedCirc(c1,Qualified1.Qualifier());
	128	GccAna_Lin2dTanObl Lin(Qc1,TheLine,Angle);
773f53f1	129	WellDone = Lin.IsDone();
773f53f1	130	if(WellDone) {
7fd59977	131	NbrSol = Lin.NbSolutions();
	132	for (Standard_Integer i = 1 ; i <= NbrSol ; i++) {
	133	linsol(i) = Lin.ThisSolution(i);
	134	Lin.Tangency1(i,par1sol(i),pararg1(i),pnttg1sol(i));
	135	Lin.Intersection2(i,par2sol(i),pararg2(i),pntint2sol(i));
	136	Lin.WhichQualifier(i,qualifier1(i));
	137	}
	138	}
	139	}
	140	else {
0b85f9a6	141	Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
54e37688	142	Geom2dGcc_Lin2dTanOblIter Lin(Qc1,TheLine,TolAng,Param1,Angle);
773f53f1	143	WellDone = Lin.IsDone();
773f53f1	144	if(WellDone) {
7fd59977	145	linsol(1) = Lin.ThisSolution();
	146	Lin.Tangency1(par1sol(1),pararg1(1),pnttg1sol(1));
	147	Lin.Intersection2(par2sol(1),pararg2(1),pntint2sol(1));
	148	Lin.WhichQualifier(qualifier1(1));
	149	}
	150	}
	151	}
	152
	153	Standard_Boolean Geom2dGcc_Lin2dTanObl::
	154	IsDone () const { return WellDone; }
	155
	156	Standard_Integer Geom2dGcc_Lin2dTanObl::
	157	NbSolutions () const { return NbrSol; }
	158
	159	gp_Lin2d Geom2dGcc_Lin2dTanObl::
	160	ThisSolution (const Standard_Integer Index) const {
	161
9775fa61	162	if (Index > NbrSol \|\| Index <= 0) { throw Standard_OutOfRange(); }
7fd59977	163	return linsol(Index);
	164	}
	165
	166	void Geom2dGcc_Lin2dTanObl::
	167	WhichQualifier (const Standard_Integer Index,
	168	GccEnt_Position& Qualif1) const
	169	{
9775fa61	170	if (!WellDone) { throw StdFail_NotDone(); }
9775fa61	171	else if (Index <= 0 \|\|Index > NbrSol) { throw Standard_OutOfRange(); }
7fd59977	172	else { Qualif1 = qualifier1(Index); }
	173	}
	174
	175	void Geom2dGcc_Lin2dTanObl::
	176	Tangency1 (const Standard_Integer Index,
	177	Standard_Real& ParSol,
	178	Standard_Real& ParArg,
	179	gp_Pnt2d& PntSol) const {
9775fa61	180	if (!WellDone) { throw StdFail_NotDone(); }
9775fa61	181	else if (Index <= 0 \|\|Index > NbrSol) { throw Standard_OutOfRange(); }
7fd59977	182	else {
	183	ParSol = par1sol(Index);
	184	ParArg = pararg1(Index);
	185	PntSol = pnttg1sol(Index);
	186	}
	187	}
	188
	189	void Geom2dGcc_Lin2dTanObl::
	190	Intersection2 (const Standard_Integer Index ,
	191	Standard_Real& ParSol ,
	192	Standard_Real& ParArg ,
	193	gp_Pnt2d& PntSol ) const {
9775fa61	194	if (!WellDone) { throw StdFail_NotDone(); }
9775fa61	195	else if (Index <= 0 \|\|Index > NbrSol) { throw Standard_OutOfRange(); }
7fd59977	196	else {
	197	ParSol = par2sol(Index);
	198	ParArg = pararg2(Index);
	199	PntSol = pntint2sol(Index);
	200	}
	201	}
	202
	203	Standard_Boolean Geom2dGcc_Lin2dTanObl::Add
	204	(const Standard_Integer theIndex,
54e37688	205	const Geom2dGcc_Lin2dTanOblIter &theLin,
7fd59977	206	const Standard_Real theTol,
	207	const Geom2dAdaptor_Curve &theC1)
	208	{
	209	Standard_Integer i;
	210	Standard_Real aPar1sol;
	211	Standard_Real aPar2sol;
	212	Standard_Real aPar1arg;
	213	Standard_Real aPar2arg;
	214	gp_Pnt2d aPnt1Sol;
	215	gp_Pnt2d aPnt2Sol;
	216	gp_Lin2d aLin = theLin.ThisSolution();
	217
	218	theLin.Tangency1(aPar1sol, aPar1arg, aPnt1Sol);
	219	theLin.Intersection2(aPar2sol, aPar2arg, aPnt2Sol);
	220
	221	for(i = 1; i < theIndex; i++) {
	222	if (Abs(aPar1arg - pararg1(i)) <= theTol &&
	223	Abs(aPar2arg - pararg2(i)) <= theTol)
	224	return Standard_False;
	225	}
	226
	227	gp_Dir2d aLinDir = aLin.Direction();
	228	gp_Vec2d aVTan;
	229	gp_Pnt2d aPoint;
	230
	231	Geom2dGcc_CurveTool::D1(theC1, aPar1arg, aPoint, aVTan);
	232
	233	if (Abs(aLinDir.Crossed(gp_Dir2d(aVTan))) > theTol)
	234	return Standard_False;
	235
	236	linsol(theIndex) = aLin;
	237	par1sol(theIndex) = aPar1sol;
	238	pararg1(theIndex) = aPar1arg;
	239	pnttg1sol(theIndex) = aPnt1Sol;
	240	par2sol(theIndex) = aPar2sol;
	241	pararg2(theIndex) = aPar2arg;
	242	pntint2sol(theIndex) = aPnt2Sol;
	243
	244	theLin.WhichQualifier(qualifier1(theIndex));
	245
	246	return Standard_True;
	247	}