[occt.git] / src / GeometryTest / GeometryTest_CurveTanCommands.cxx

// Created on: 2017-06-16
// Created by: Natalia ERMOLAEVA
// Copyright (c) 2017 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 <Draw.hxx>
#include <DrawTrSurf.hxx>
#include <Draw_Interpretor.hxx>
#include <GccAna_Circ2d3Tan.hxx>
#include <GccEnt.hxx>
#include <GccEnt_QualifiedLin.hxx>
#include <GccEnt_QualifiedCirc.hxx>
#include <Geom2d_Line.hxx>
#include <Geom2d_Circle.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <GeometryTest.hxx>
#include <GeometryTest_DrawableQualifiedCurve2d.hxx>
#include <Precision.hxx>
#include <TCollection_AsciiString.hxx>
#include <stdio.h>

//=======================================================================
//function : qcircle
//purpose  : Parses command: "qcircle name x y radius [-unqualified|-enclosing|-enclosed|-outside|-noqualifier]"
//=======================================================================
static Standard_Integer qcurve (Draw_Interpretor&, Standard_Integer theArgsNb, const char** theArgVec)
{
  if (theArgsNb < 5)
  {
    cout << "Error: wrong number of arguments.\n";
    return 1;
  }

  Handle(Geom2d_Curve)  aResult2d;
  TCollection_AsciiString aPositionType;
  if (!strcmp (theArgVec[0], "qcircle"))
  {
    if (theArgsNb == 5 || theArgsNb == 6)
      aResult2d = new Geom2d_Circle (gp_Ax22d (gp_Pnt2d (Draw::Atof (theArgVec[2]), Draw::Atof (theArgVec[3])),
                                     gp_Dir2d (1,0)), Draw::Atof (theArgVec[4]));
    else if (theArgsNb == 7 || theArgsNb == 8)
      aResult2d = new Geom2d_Circle (gp_Ax22d (gp_Pnt2d (Draw::Atof (theArgVec[2]), Draw::Atof (theArgVec[3])),
                  gp_Dir2d (Draw::Atof (theArgVec[4]), Draw::Atof (theArgVec[5]))), Draw::Atof (theArgVec[6]));

    if (theArgsNb == 6)
      aPositionType = theArgVec[5];
    else if (theArgsNb == 8)
      aPositionType = theArgVec[7];
  }
  else if(!strcmp (theArgVec[0], "qline"))
  {
    if (theArgsNb < 6)
    {
      cout << "Error: wrong number of arguments.\n";
      return 1;
    }
    aResult2d = new Geom2d_Line (gp_Pnt2d (Draw::Atof (theArgVec[2]), Draw::Atof (theArgVec[3])),
                                 gp_Dir2d (Draw::Atof (theArgVec[4]), Draw::Atof (theArgVec[5])));
    if (theArgsNb == 7)
      aPositionType = theArgVec[6];
  }
  else
  {
    cout << "Error: wrong command name.\n";
    return 1;
  }

  GccEnt_Position aKindOfPosition = GccEnt_unqualified;
  if (!aPositionType.IsEmpty())
  {
    GccEnt_Position aParameterPosition;
    if (GccEnt::PositionFromString (aPositionType.ToCString(), aParameterPosition))
      aKindOfPosition = aParameterPosition;
  }

  Draw::Set (theArgVec[1], new GeometryTest_DrawableQualifiedCurve2d (aResult2d, aKindOfPosition));
  return 0;
}

//=======================================================================
//function : solutions
//purpose  : 
//=======================================================================
static Standard_Integer solutions (Draw_Interpretor& theDI, GccAna_Circ2d3Tan& theCirTan3, const char* theName)
{
  if (!theCirTan3.IsDone())
  {
    cout << "GccAna_Circ2d3Tan is not done";
    return 1;
  }

  TCollection_AsciiString aName = TCollection_AsciiString (theName) + "_";
  GccEnt_Position aQualifier1, aQualifier2, aQualifier3;
  Standard_Real aParSol, aParArg;
  gp_Pnt2d aPntSol;
  for (Standard_Integer aSolId = 1; aSolId <= theCirTan3.NbSolutions(); aSolId++)
  {
    Handle(Geom2d_Circle) aCircle = new Geom2d_Circle (theCirTan3.ThisSolution (aSolId));
    TCollection_AsciiString aSolIdName = aName;
    aSolIdName += TCollection_AsciiString (aSolId);
    DrawTrSurf::Set (aSolIdName.ToCString(), aCircle);
    theCirTan3.WhichQualifier (aSolId, aQualifier1, aQualifier2, aQualifier3);
    theDI << "circle: " << aSolIdName.ToCString() << ", " << "qualifiers: " << GccEnt::PositionToString (aQualifier1)
          << ", " << GccEnt::PositionToString (aQualifier2) << ", " << GccEnt::PositionToString (aQualifier3) << "\n";

    theDI << "  tangent points: point (parameter on solution, parameter on argument)\n";
    // the first tangent point
    if (theCirTan3.IsTheSame1 (aSolId))
      theDI << "    " << "= the solution number " << aSolId << " is equal to the first argument\n";
    else
    {
      theCirTan3.Tangency1 (aSolId, aParSol, aParArg, aPntSol);
      TCollection_AsciiString aTanPntIdName = aSolIdName + "_tp_1";
      DrawTrSurf::Set (aTanPntIdName.ToCString(), aPntSol);
      theDI << "    " << aTanPntIdName.ToCString() << " (" << aParSol << ", " << aParArg << ")\n";
    }
    // the second tangent point
    if (theCirTan3.IsTheSame2 (aSolId))
      theDI << "    " << "= the solution number " << aSolId << " is equal to the second argument\n";
    else
    {
      theCirTan3.Tangency2 (aSolId, aParSol, aParArg, aPntSol);
      TCollection_AsciiString aTanPntIdName = aSolIdName + "_tp_2";
      DrawTrSurf::Set (aTanPntIdName.ToCString(), aPntSol);
      theDI << "    " << aTanPntIdName.ToCString() << " (" << aParSol << ", " << aParArg << ")\n";
    }
    // the third tangent point
    if (theCirTan3.IsTheSame3 (aSolId))
      theDI << "    " << "= the solution number " << aSolId << " is equal to the third argument\n";
    else
    {
      theCirTan3.Tangency3 (aSolId, aParSol, aParArg, aPntSol);
      TCollection_AsciiString aTanPntIdName = aSolIdName + "_tp_3";
      DrawTrSurf::Set (aTanPntIdName.ToCString(), aPntSol);
      theDI << "    " << aTanPntIdName.ToCString() << " (" << aParSol << ", " << aParArg << ")";
    }
    if (aSolId != theCirTan3.NbSolutions())
      theDI << "\n";
  }
  return 0;
}

//=======================================================================
//function : circ2d3Tan
//purpose  : Parses command: [circ2d3Tan cname qcicrle1/qlin1/point1 qcicrle2/qlin2/point2 qcicrle3/qlin3/point3
//                            tolerance]
//=======================================================================
static Standard_Integer circ2d3Tan (Draw_Interpretor& theDI, Standard_Integer theArgsNb, const char** theArgVec)
{
  if (theArgsNb < 5)
  {
    cout << "Error: wrong number of arguments.\n";
    return 1;
  }

  Handle(GeometryTest_DrawableQualifiedCurve2d) aQCurve1 =
    Handle(GeometryTest_DrawableQualifiedCurve2d)::DownCast (Draw::Get (theArgVec[2]));
  Handle(GeometryTest_DrawableQualifiedCurve2d) aQCurve2 =
    Handle(GeometryTest_DrawableQualifiedCurve2d)::DownCast (Draw::Get (theArgVec[3]));
  Handle(GeometryTest_DrawableQualifiedCurve2d) aQCurve3 =
    Handle(GeometryTest_DrawableQualifiedCurve2d)::DownCast (Draw::Get (theArgVec[4]));

  gp_Pnt2d aPoint1, aPoint2, aPoint3;
  Standard_Boolean anIsPoint1 = DrawTrSurf::GetPoint2d (theArgVec[2], aPoint1);
  Standard_Boolean anIsPoint2 = DrawTrSurf::GetPoint2d (theArgVec[3], aPoint2);
  Standard_Boolean anIsPoint3 = DrawTrSurf::GetPoint2d (theArgVec[4], aPoint3);

  Standard_Real aTolerance = Precision::Confusion();
  if (theArgsNb > 5)
    aTolerance = Draw::Atof (theArgVec[5]);

  if (aQCurve1.IsNull()) // <point, point, point>
  {
    if (!anIsPoint1 || !anIsPoint2 || !anIsPoint3)
    {
      cout << "Error: wrong points definition.\n";
      return 1;
    }
    GccAna_Circ2d3Tan aCircBuilder (aPoint1, aPoint2, aPoint3, aTolerance);
    return solutions (theDI, aCircBuilder, theArgVec[1]);
  }

  // the first curve is not NULL
  if (aQCurve2.IsNull()) // <qcircle, point, point> or <qlin, point, point>
  {
    if (!anIsPoint2 || !anIsPoint3)
    {
      cout << "Error: wrong points definition.\n";
      return 1;
    }
    Geom2dAdaptor_Curve anAdaptorCurve1 (aQCurve1->GetCurve());
    if (anAdaptorCurve1.GetType() == GeomAbs_Circle)
    {
      GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition());
      GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aPoint2, aPoint3, aTolerance);
      return solutions (theDI, aCircBuilder, theArgVec[1]);
    }
    else if (anAdaptorCurve1.GetType() == GeomAbs_Line)
    {
      GccEnt_QualifiedLin aQualifiedLin1 (anAdaptorCurve1.Line(), aQCurve1->GetPosition());
      GccAna_Circ2d3Tan aCircBuilder (aQualifiedLin1, aPoint2, aPoint3, aTolerance);
      return solutions (theDI, aCircBuilder, theArgVec[1]);
    }
    cout << "Error: wrong curve type.\n";
    return 1;
  }

  // the first and the second curves are not NULL
  if (aQCurve3.IsNull()) // <qcircle, qcircle, point> or <qcircle, qlin, point> or <qlin, qlin, point>
  {
    if (!anIsPoint3)
    {
      cout << "Error: wrong point definition.\n";
      return 1;
    }
    Geom2dAdaptor_Curve anAdaptorCurve1 (aQCurve1->GetCurve());
    Geom2dAdaptor_Curve anAdaptorCurve2 (aQCurve2->GetCurve());
    if (anAdaptorCurve1.GetType() == GeomAbs_Circle && anAdaptorCurve2.GetType() == GeomAbs_Circle)
    {
      GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition());
      GccEnt_QualifiedCirc aQualifiedCircle2 (anAdaptorCurve2.Circle(), aQCurve2->GetPosition());
      GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aQualifiedCircle2, aPoint3, aTolerance);
      return solutions (theDI, aCircBuilder, theArgVec[1]);
    }
    else if (anAdaptorCurve1.GetType() == GeomAbs_Circle && anAdaptorCurve2.GetType() == GeomAbs_Line)
    {
      GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition());
      GccEnt_QualifiedLin aQualifiedLin2 (anAdaptorCurve2.Line(), aQCurve2->GetPosition());
      GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aQualifiedLin2, aPoint3, aTolerance);
      return solutions (theDI, aCircBuilder, theArgVec[1]);
    }
    else if (anAdaptorCurve1.GetType() == GeomAbs_Line && anAdaptorCurve2.GetType() == GeomAbs_Line)
    {
      GccEnt_QualifiedLin aQualifiedLin1 (anAdaptorCurve1.Line(), aQCurve1->GetPosition());
      GccEnt_QualifiedLin aQualifiedLin2 (anAdaptorCurve2.Line(), aQCurve2->GetPosition());
      GccAna_Circ2d3Tan aCircBuilder (aQualifiedLin1, aQualifiedLin2, aPoint3, aTolerance);
      return solutions (theDI, aCircBuilder, theArgVec[1]);
    }
    cout << "Error: wrong curve type.\n";
    return 1;
  }

  // the first, the second and the third curves are not NULL
  // <qcircle, qcircle, qcircle> or <qcircle, qcircle, qlin>, <qcircle, qlin, qlin>, <qlin, qlin, qlin>
  Geom2dAdaptor_Curve anAdaptorCurve1 (aQCurve1->GetCurve());
  Geom2dAdaptor_Curve anAdaptorCurve2 (aQCurve2->GetCurve());
  Geom2dAdaptor_Curve anAdaptorCurve3 (aQCurve3->GetCurve());
  if (anAdaptorCurve1.GetType() == GeomAbs_Circle && anAdaptorCurve2.GetType() == GeomAbs_Circle &&
      anAdaptorCurve3.GetType() == GeomAbs_Circle)
  {
    GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition());
    GccEnt_QualifiedCirc aQualifiedCircle2 (anAdaptorCurve2.Circle(), aQCurve2->GetPosition());
    GccEnt_QualifiedCirc aQualifiedCircle3 (anAdaptorCurve3.Circle(), aQCurve3->GetPosition());
    GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aQualifiedCircle2, aQualifiedCircle3, aTolerance);
    return solutions (theDI, aCircBuilder, theArgVec[1]);
  }
  if (anAdaptorCurve1.GetType() == GeomAbs_Circle && anAdaptorCurve2.GetType() == GeomAbs_Circle &&
      anAdaptorCurve3.GetType() == GeomAbs_Line)
  {
    GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition());
    GccEnt_QualifiedCirc aQualifiedCircle2 (anAdaptorCurve2.Circle(), aQCurve2->GetPosition());
    GccEnt_QualifiedLin aQualifiedLin3 (anAdaptorCurve3.Line(), aQCurve3->GetPosition());
    GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aQualifiedCircle2, aQualifiedLin3, aTolerance);
    return solutions (theDI, aCircBuilder, theArgVec[1]);
  }
  if (anAdaptorCurve1.GetType() == GeomAbs_Circle && anAdaptorCurve2.GetType() == GeomAbs_Line &&
      anAdaptorCurve3.GetType() == GeomAbs_Line)
  {
    GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition());
    GccEnt_QualifiedLin aQualifiedLin2 (anAdaptorCurve2.Line(), aQCurve2->GetPosition());
    GccEnt_QualifiedLin aQualifiedLin3 (anAdaptorCurve3.Line(), aQCurve3->GetPosition());
    GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aQualifiedLin2, aQualifiedLin3, aTolerance);
    return solutions (theDI, aCircBuilder, theArgVec[1]);
  }
  if (anAdaptorCurve1.GetType() == GeomAbs_Line && anAdaptorCurve2.GetType() == GeomAbs_Line &&
      anAdaptorCurve3.GetType() == GeomAbs_Line)
  {
    GccEnt_QualifiedLin aQualifiedLin1 (anAdaptorCurve1.Line(), aQCurve1->GetPosition());
    GccEnt_QualifiedLin aQualifiedLin2 (anAdaptorCurve2.Line(), aQCurve2->GetPosition());
    GccEnt_QualifiedLin aQualifiedLin3 (anAdaptorCurve3.Line(), aQCurve3->GetPosition());
    GccAna_Circ2d3Tan aCircBuilder (aQualifiedLin1, aQualifiedLin2, aQualifiedLin3, aTolerance);
    return solutions (theDI, aCircBuilder, theArgVec[1]);
  }

  cout << "Error: wrong curve type.\n";
  return 1;
}

//=======================================================================
//function : CurveTanCommands
//purpose  : 
//=======================================================================
void  GeometryTest::CurveTanCommands (Draw_Interpretor& theCommands)
{
  static Standard_Boolean aLoaded = Standard_False;
  if (aLoaded) return;
  aLoaded = Standard_True;
  
  DrawTrSurf::BasicCommands (theCommands);
  
  const char* aGroup;
  aGroup = "GEOMETRY tangent curves creation";

  theCommands.Add ("qcircle",
            "qcircle name {x y [ux uy] radius} [-unqualified|-enclosing|-enclosed|-outside|-noqualifier]"
    "\n\t\t: Creates qualified circle.",
   __FILE__, qcurve, aGroup);

  theCommands.Add ("qline",
            "qline name x y dx dy [-unqualified|-enclosing|-enclosed|-outside|-noqualifier]"
    "\n\t\t: Creates qualified line.",
    __FILE__, qcurve, aGroup);

  theCommands.Add ("circ2d3Tan",
            "circ2d3Tan cname {qcicrle1|qlin1|point1} {qcicrle2|qlin2|point2} {qcicrle3|qlin3|point3} [tolerance]"
    "\n\t\t: Creates 2d circles tangent to 3 arguments. The arguments are points, lines or circles."
    "\n\t\t: Possible arguments combinations:"
    "\n\t\t:            <qcircle, qcircle, qcircle>,"
    "\n\t\t:            <qcircle, qcircle, qlin>,"
    "\n\t\t:            <qcircle, qcircle, point>,"
    "\n\t\t:            <qcircle, qlin, qlin>,"
    "\n\t\t:            <qcircle, qlin, point>,"
    "\n\t\t:            <qcircle, qlin, qlin>,"
    "\n\t\t:            <qcircle, point, point>,"
    "\n\t\t:            <qlin, qlin, qlin>,"
    "\n\t\t:            <qlin, qlin, point>,"
    "\n\t\t:            <qlin, point, point>,"
    "\n\t\t:            <point, point, point>.",
    __FILE__, circ2d3Tan, aGroup);
}
Commit	Line	Data
9294c8f7	1	// Created on: 2017-06-16
	2	// Created by: Natalia ERMOLAEVA
	3	// Copyright (c) 2017 OPEN CASCADE SAS
	4	//
	5	// This file is part of Open CASCADE Technology software library.
	6	//
	7	// This library is free software; you can redistribute it and/or modify it under
	8	// the terms of the GNU Lesser General Public License version 2.1 as published
	9	// by the Free Software Foundation, with special exception defined in the file
	10	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	11	// distribution for complete text of the license and disclaimer of any warranty.
	12	//
	13	// Alternatively, this file may be used under the terms of Open CASCADE
	14	// commercial license or contractual agreement.
	15
	16	#include <Draw.hxx>
	17	#include <DrawTrSurf.hxx>
	18	#include <Draw_Interpretor.hxx>
	19	#include <GccAna_Circ2d3Tan.hxx>
	20	#include <GccEnt.hxx>
	21	#include <GccEnt_QualifiedLin.hxx>
	22	#include <GccEnt_QualifiedCirc.hxx>
	23	#include <Geom2d_Line.hxx>
	24	#include <Geom2d_Circle.hxx>
	25	#include <Geom2dAdaptor_Curve.hxx>
	26	#include <GeometryTest.hxx>
	27	#include <GeometryTest_DrawableQualifiedCurve2d.hxx>
	28	#include <Precision.hxx>
	29	#include <TCollection_AsciiString.hxx>
	30	#include <stdio.h>
	31
	32	//=======================================================================
	33	//function : qcircle
	34	//purpose : Parses command: "qcircle name x y radius [-unqualified\|-enclosing\|-enclosed\|-outside\|-noqualifier]"
	35	//=======================================================================
	36	static Standard_Integer qcurve (Draw_Interpretor&, Standard_Integer theArgsNb, const char** theArgVec)
	37	{
	38	if (theArgsNb < 5)
	39	{
	40	cout << "Error: wrong number of arguments.\n";
	41	return 1;
	42	}
	43
	44	Handle(Geom2d_Curve) aResult2d;
	45	TCollection_AsciiString aPositionType;
	46	if (!strcmp (theArgVec[0], "qcircle"))
	47	{
	48	if (theArgsNb == 5 \|\| theArgsNb == 6)
	49	aResult2d = new Geom2d_Circle (gp_Ax22d (gp_Pnt2d (Draw::Atof (theArgVec[2]), Draw::Atof (theArgVec[3])),
	50	gp_Dir2d (1,0)), Draw::Atof (theArgVec[4]));
	51	else if (theArgsNb == 7 \|\| theArgsNb == 8)
	52	aResult2d = new Geom2d_Circle (gp_Ax22d (gp_Pnt2d (Draw::Atof (theArgVec[2]), Draw::Atof (theArgVec[3])),
	53	gp_Dir2d (Draw::Atof (theArgVec[4]), Draw::Atof (theArgVec[5]))), Draw::Atof (theArgVec[6]));
	54
	55	if (theArgsNb == 6)
	56	aPositionType = theArgVec[5];
	57	else if (theArgsNb == 8)
	58	aPositionType = theArgVec[7];
	59	}
	60	else if(!strcmp (theArgVec[0], "qline"))
	61	{
	62	if (theArgsNb < 6)
	63	{
	64	cout << "Error: wrong number of arguments.\n";
65	return 1;
66	}
67	aResult2d = new Geom2d_Line (gp_Pnt2d (Draw::Atof (theArgVec[2]), Draw::Atof (theArgVec[3])),
68	gp_Dir2d (Draw::Atof (theArgVec[4]), Draw::Atof (theArgVec[5])));
69	if (theArgsNb == 7)
70	aPositionType = theArgVec[6];
71	}
72	else
73	{
74	cout << "Error: wrong command name.\n";
75	return 1;
76	}
77
78	GccEnt_Position aKindOfPosition = GccEnt_unqualified;
79	if (!aPositionType.IsEmpty())
80	{
81	GccEnt_Position aParameterPosition;
82	if (GccEnt::PositionFromString (aPositionType.ToCString(), aParameterPosition))
83	aKindOfPosition = aParameterPosition;
84	}
85
86	Draw::Set (theArgVec[1], new GeometryTest_DrawableQualifiedCurve2d (aResult2d, aKindOfPosition));
87	return 0;
88	}
89
90	//=======================================================================
91	//function : solutions
92	//purpose :
93	//=======================================================================
94	static Standard_Integer solutions (Draw_Interpretor& theDI, GccAna_Circ2d3Tan& theCirTan3, const char* theName)
95	{
96	if (!theCirTan3.IsDone())
97	{
98	cout << "GccAna_Circ2d3Tan is not done";
99	return 1;
100	}
101
102	TCollection_AsciiString aName = TCollection_AsciiString (theName) + "_";
103	GccEnt_Position aQualifier1, aQualifier2, aQualifier3;
104	Standard_Real aParSol, aParArg;
105	gp_Pnt2d aPntSol;
106	for (Standard_Integer aSolId = 1; aSolId <= theCirTan3.NbSolutions(); aSolId++)
107	{
108	Handle(Geom2d_Circle) aCircle = new Geom2d_Circle (theCirTan3.ThisSolution (aSolId));
109	TCollection_AsciiString aSolIdName = aName;
110	aSolIdName += TCollection_AsciiString (aSolId);
111	DrawTrSurf::Set (aSolIdName.ToCString(), aCircle);
112	theCirTan3.WhichQualifier (aSolId, aQualifier1, aQualifier2, aQualifier3);
113	theDI << "circle: " << aSolIdName.ToCString() << ", " << "qualifiers: " << GccEnt::PositionToString (aQualifier1)
114	<< ", " << GccEnt::PositionToString (aQualifier2) << ", " << GccEnt::PositionToString (aQualifier3) << "\n";
115
116	theDI << " tangent points: point (parameter on solution, parameter on argument)\n";
117	// the first tangent point
118	if (theCirTan3.IsTheSame1 (aSolId))
119	theDI << " " << "= the solution number " << aSolId << " is equal to the first argument\n";
120	else
121	{
122	theCirTan3.Tangency1 (aSolId, aParSol, aParArg, aPntSol);
123	TCollection_AsciiString aTanPntIdName = aSolIdName + "_tp_1";
124	DrawTrSurf::Set (aTanPntIdName.ToCString(), aPntSol);
125	theDI << " " << aTanPntIdName.ToCString() << " (" << aParSol << ", " << aParArg << ")\n";
126	}
127	// the second tangent point
128	if (theCirTan3.IsTheSame2 (aSolId))
129	theDI << " " << "= the solution number " << aSolId << " is equal to the second argument\n";
130	else
131	{
132	theCirTan3.Tangency2 (aSolId, aParSol, aParArg, aPntSol);
133	TCollection_AsciiString aTanPntIdName = aSolIdName + "_tp_2";
134	DrawTrSurf::Set (aTanPntIdName.ToCString(), aPntSol);
135	theDI << " " << aTanPntIdName.ToCString() << " (" << aParSol << ", " << aParArg << ")\n";
136	}
137	// the third tangent point
138	if (theCirTan3.IsTheSame3 (aSolId))
139	theDI << " " << "= the solution number " << aSolId << " is equal to the third argument\n";
140	else
141	{
142	theCirTan3.Tangency3 (aSolId, aParSol, aParArg, aPntSol);
143	TCollection_AsciiString aTanPntIdName = aSolIdName + "_tp_3";
144	DrawTrSurf::Set (aTanPntIdName.ToCString(), aPntSol);
145	theDI << " " << aTanPntIdName.ToCString() << " (" << aParSol << ", " << aParArg << ")";
146	}
147	if (aSolId != theCirTan3.NbSolutions())
148	theDI << "\n";
149	}
150	return 0;
151	}
152
153	//=======================================================================
154	//function : circ2d3Tan
155	//purpose : Parses command: [circ2d3Tan cname qcicrle1/qlin1/point1 qcicrle2/qlin2/point2 qcicrle3/qlin3/point3
156	// tolerance]
157	//=======================================================================
158	static Standard_Integer circ2d3Tan (Draw_Interpretor& theDI, Standard_Integer theArgsNb, const char** theArgVec)
159	{
160	if (theArgsNb < 5)
161	{
162	cout << "Error: wrong number of arguments.\n";
163	return 1;
164	}
165
166	Handle(GeometryTest_DrawableQualifiedCurve2d) aQCurve1 =
167	Handle(GeometryTest_DrawableQualifiedCurve2d)::DownCast (Draw::Get (theArgVec[2]));
168	Handle(GeometryTest_DrawableQualifiedCurve2d) aQCurve2 =
169	Handle(GeometryTest_DrawableQualifiedCurve2d)::DownCast (Draw::Get (theArgVec[3]));
170	Handle(GeometryTest_DrawableQualifiedCurve2d) aQCurve3 =
171	Handle(GeometryTest_DrawableQualifiedCurve2d)::DownCast (Draw::Get (theArgVec[4]));
172
173	gp_Pnt2d aPoint1, aPoint2, aPoint3;
174	Standard_Boolean anIsPoint1 = DrawTrSurf::GetPoint2d (theArgVec[2], aPoint1);
175	Standard_Boolean anIsPoint2 = DrawTrSurf::GetPoint2d (theArgVec[3], aPoint2);
176	Standard_Boolean anIsPoint3 = DrawTrSurf::GetPoint2d (theArgVec[4], aPoint3);
177
178	Standard_Real aTolerance = Precision::Confusion();
179	if (theArgsNb > 5)
180	aTolerance = Draw::Atof (theArgVec[5]);
181
182	if (aQCurve1.IsNull()) // <point, point, point>
183	{
184	if (!anIsPoint1 \|\| !anIsPoint2 \|\| !anIsPoint3)
185	{
186	cout << "Error: wrong points definition.\n";
187	return 1;
188	}
189	GccAna_Circ2d3Tan aCircBuilder (aPoint1, aPoint2, aPoint3, aTolerance);
190	return solutions (theDI, aCircBuilder, theArgVec[1]);
191	}
192
193	// the first curve is not NULL
194	if (aQCurve2.IsNull()) // <qcircle, point, point> or <qlin, point, point>
195	{
196	if (!anIsPoint2 \|\| !anIsPoint3)
197	{
198	cout << "Error: wrong points definition.\n";
199	return 1;
200	}
201	Geom2dAdaptor_Curve anAdaptorCurve1 (aQCurve1->GetCurve());
202	if (anAdaptorCurve1.GetType() == GeomAbs_Circle)
203	{
204	GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition());
205	GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aPoint2, aPoint3, aTolerance);
206	return solutions (theDI, aCircBuilder, theArgVec[1]);
207	}
208	else if (anAdaptorCurve1.GetType() == GeomAbs_Line)
209	{
210	GccEnt_QualifiedLin aQualifiedLin1 (anAdaptorCurve1.Line(), aQCurve1->GetPosition());
211	GccAna_Circ2d3Tan aCircBuilder (aQualifiedLin1, aPoint2, aPoint3, aTolerance);
212	return solutions (theDI, aCircBuilder, theArgVec[1]);
213	}
214	cout << "Error: wrong curve type.\n";
215	return 1;
216	}
217
218	// the first and the second curves are not NULL
219	if (aQCurve3.IsNull()) // <qcircle, qcircle, point> or <qcircle, qlin, point> or <qlin, qlin, point>
220	{
221	if (!anIsPoint3)
222	{
223	cout << "Error: wrong point definition.\n";
224	return 1;
225	}
226	Geom2dAdaptor_Curve anAdaptorCurve1 (aQCurve1->GetCurve());
227	Geom2dAdaptor_Curve anAdaptorCurve2 (aQCurve2->GetCurve());
228	if (anAdaptorCurve1.GetType() == GeomAbs_Circle && anAdaptorCurve2.GetType() == GeomAbs_Circle)
229	{
230	GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition());
231	GccEnt_QualifiedCirc aQualifiedCircle2 (anAdaptorCurve2.Circle(), aQCurve2->GetPosition());
232	GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aQualifiedCircle2, aPoint3, aTolerance);
233	return solutions (theDI, aCircBuilder, theArgVec[1]);
234	}
235	else if (anAdaptorCurve1.GetType() == GeomAbs_Circle && anAdaptorCurve2.GetType() == GeomAbs_Line)
236	{
237	GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition());
238	GccEnt_QualifiedLin aQualifiedLin2 (anAdaptorCurve2.Line(), aQCurve2->GetPosition());
239	GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aQualifiedLin2, aPoint3, aTolerance);
240	return solutions (theDI, aCircBuilder, theArgVec[1]);
241	}
242	else if (anAdaptorCurve1.GetType() == GeomAbs_Line && anAdaptorCurve2.GetType() == GeomAbs_Line)
243	{
244	GccEnt_QualifiedLin aQualifiedLin1 (anAdaptorCurve1.Line(), aQCurve1->GetPosition());
245	GccEnt_QualifiedLin aQualifiedLin2 (anAdaptorCurve2.Line(), aQCurve2->GetPosition());
246	GccAna_Circ2d3Tan aCircBuilder (aQualifiedLin1, aQualifiedLin2, aPoint3, aTolerance);
247	return solutions (theDI, aCircBuilder, theArgVec[1]);
248	}
249	cout << "Error: wrong curve type.\n";
250	return 1;
251	}
252
253	// the first, the second and the third curves are not NULL
254	// <qcircle, qcircle, qcircle> or <qcircle, qcircle, qlin>, <qcircle, qlin, qlin>, <qlin, qlin, qlin>
255	Geom2dAdaptor_Curve anAdaptorCurve1 (aQCurve1->GetCurve());
256	Geom2dAdaptor_Curve anAdaptorCurve2 (aQCurve2->GetCurve());
257	Geom2dAdaptor_Curve anAdaptorCurve3 (aQCurve3->GetCurve());
258	if (anAdaptorCurve1.GetType() == GeomAbs_Circle && anAdaptorCurve2.GetType() == GeomAbs_Circle &&
259	anAdaptorCurve3.GetType() == GeomAbs_Circle)
260	{
261	GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition());
262	GccEnt_QualifiedCirc aQualifiedCircle2 (anAdaptorCurve2.Circle(), aQCurve2->GetPosition());
263	GccEnt_QualifiedCirc aQualifiedCircle3 (anAdaptorCurve3.Circle(), aQCurve3->GetPosition());
264	GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aQualifiedCircle2, aQualifiedCircle3, aTolerance);
265	return solutions (theDI, aCircBuilder, theArgVec[1]);
266	}
267	if (anAdaptorCurve1.GetType() == GeomAbs_Circle && anAdaptorCurve2.GetType() == GeomAbs_Circle &&
268	anAdaptorCurve3.GetType() == GeomAbs_Line)
269	{
270	GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition());
271	GccEnt_QualifiedCirc aQualifiedCircle2 (anAdaptorCurve2.Circle(), aQCurve2->GetPosition());
272	GccEnt_QualifiedLin aQualifiedLin3 (anAdaptorCurve3.Line(), aQCurve3->GetPosition());
273	GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aQualifiedCircle2, aQualifiedLin3, aTolerance);
274	return solutions (theDI, aCircBuilder, theArgVec[1]);
275	}
276	if (anAdaptorCurve1.GetType() == GeomAbs_Circle && anAdaptorCurve2.GetType() == GeomAbs_Line &&
277	anAdaptorCurve3.GetType() == GeomAbs_Line)
278	{
279	GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition());
280	GccEnt_QualifiedLin aQualifiedLin2 (anAdaptorCurve2.Line(), aQCurve2->GetPosition());
281	GccEnt_QualifiedLin aQualifiedLin3 (anAdaptorCurve3.Line(), aQCurve3->GetPosition());
282	GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aQualifiedLin2, aQualifiedLin3, aTolerance);
283	return solutions (theDI, aCircBuilder, theArgVec[1]);
284	}
285	if (anAdaptorCurve1.GetType() == GeomAbs_Line && anAdaptorCurve2.GetType() == GeomAbs_Line &&
286	anAdaptorCurve3.GetType() == GeomAbs_Line)
287	{
288	GccEnt_QualifiedLin aQualifiedLin1 (anAdaptorCurve1.Line(), aQCurve1->GetPosition());
289	GccEnt_QualifiedLin aQualifiedLin2 (anAdaptorCurve2.Line(), aQCurve2->GetPosition());
290	GccEnt_QualifiedLin aQualifiedLin3 (anAdaptorCurve3.Line(), aQCurve3->GetPosition());
291	GccAna_Circ2d3Tan aCircBuilder (aQualifiedLin1, aQualifiedLin2, aQualifiedLin3, aTolerance);
292	return solutions (theDI, aCircBuilder, theArgVec[1]);
293	}
294
295	cout << "Error: wrong curve type.\n";
296	return 1;
297	}
298
299	//=======================================================================
300	//function : CurveTanCommands
301	//purpose :
302	//=======================================================================
303	void GeometryTest::CurveTanCommands (Draw_Interpretor& theCommands)
304	{
305	static Standard_Boolean aLoaded = Standard_False;
306	if (aLoaded) return;
307	aLoaded = Standard_True;
308
309	DrawTrSurf::BasicCommands (theCommands);
310
311	const char* aGroup;
312	aGroup = "GEOMETRY tangent curves creation";
313
314	theCommands.Add ("qcircle",
315	"qcircle name {x y [ux uy] radius} [-unqualified\|-enclosing\|-enclosed\|-outside\|-noqualifier]"
316	"\n\t\t: Creates qualified circle.",
317	__FILE__, qcurve, aGroup);
318
319	theCommands.Add ("qline",
320	"qline name x y dx dy [-unqualified\|-enclosing\|-enclosed\|-outside\|-noqualifier]"
321	"\n\t\t: Creates qualified line.",
322	__FILE__, qcurve, aGroup);
323
324	theCommands.Add ("circ2d3Tan",
325	"circ2d3Tan cname {qcicrle1\|qlin1\|point1} {qcicrle2\|qlin2\|point2} {qcicrle3\|qlin3\|point3} [tolerance]"
326	"\n\t\t: Creates 2d circles tangent to 3 arguments. The arguments are points, lines or circles."
327	"\n\t\t: Possible arguments combinations:"
328	"\n\t\t: <qcircle, qcircle, qcircle>,"
329	"\n\t\t: <qcircle, qcircle, qlin>,"
330	"\n\t\t: <qcircle, qcircle, point>,"
331	"\n\t\t: <qcircle, qlin, qlin>,"
332	"\n\t\t: <qcircle, qlin, point>,"
333	"\n\t\t: <qcircle, qlin, qlin>,"
334	"\n\t\t: <qcircle, point, point>,"
335	"\n\t\t: <qlin, qlin, qlin>,"
336	"\n\t\t: <qlin, qlin, point>,"
337	"\n\t\t: <qlin, point, point>,"
338	"\n\t\t: <point, point, point>.",
339	__FILE__, circ2d3Tan, aGroup);
340	}