OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-07 18:30:55 +03:00
Code Packages Releases Activity
occt/src/Geom2dGcc/Geom2dGcc_Circ2d3TanIter.cxx
ski 9775fa6110 0026937: Eliminate NO_CXX_EXCEPTION macro support 
Macro NO_CXX_EXCEPTION was removed from code.
Method Raise() was replaced by explicit throw statement.
Method Standard_Failure::Caught() was replaced by normal C++mechanism of exception transfer.
Method Standard_Failure::Caught() is deprecated now.
Eliminated empty constructors.
Updated samples.
Eliminate empty method ChangeValue from NCollection_Map class.
Removed not operable methods from NCollection classes.
2017-02-02 16:35:54 +03:00

1368 lines
78 KiB
C++
Raw Blame History

// Created on: 1991-12-13
// Created by: Remi GILET
// Copyright (c) 1991-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 d un cercle tangent a deux elements : Droite. +
// Cercle. +
// Point. +
// Courbes. +
// centre sur un troisieme : Droite. +
// Cercle. +
// Courbes. +
//=========================================================================
#include <GccAna_Circ2d3Tan.hxx>
#include <GccEnt_BadQualifier.hxx>
#include <GccEnt_QualifiedCirc.hxx>
#include <GccEnt_QualifiedLin.hxx>
#include <Geom2dGcc_Circ2d3TanIter.hxx>
#include <Geom2dGcc_CurveTool.hxx>
#include <Geom2dGcc_FunctionTanCuCuCu.hxx>
#include <Geom2dGcc_QCurve.hxx>
#include <gp.hxx>
#include <gp_Ax2d.hxx>
#include <gp_Circ2d.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Vec2d.hxx>
#include <math_FunctionSetRoot.hxx>
#include <math_NewtonFunctionSetRoot.hxx>
#include <StdFail_NotDone.hxx>
Geom2dGcc_Circ2d3TanIter::
Geom2dGcc_Circ2d3TanIter (const Geom2dGcc_QCurve& Qualified1 ,
const Geom2dGcc_QCurve& Qualified2 ,
const Geom2dGcc_QCurve& Qualified3 ,
const Standard_Real Param1 ,
const Standard_Real Param2 ,
const Standard_Real Param3 ,
const Standard_Real Tolerance ) {
TheSame1 = Standard_False;
TheSame2 = Standard_False;
TheSame3 = Standard_False;
par1sol = 0.;
par2sol = 0.;
par3sol = 0.;
pararg1 = 0.;
pararg2 = 0.;
pararg3 = 0.;
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
!(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
throw GccEnt_BadQualifier();
return;
}
Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(Cu1,Cu2,Cu3);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
math_Vector Ufirst(1,3);
math_Vector tol(1,3);
Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
Ufirst(1) = Param1;
Ufirst(2) = Param2;
Ufirst(3) = Param3;
tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
if (Root.IsDone()) {
Root.Root(Ufirst);
Func.Value(Ufirst,Umin);
gp_Pnt2d point1,point2,point3;
gp_Vec2d Tan1,Tan2,Tan3;
Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
if (circ.IsDone()) {
cirsol = circ.ThisSolution(1);
gp_Pnt2d centre = cirsol.Location();
Standard_Real normetan1 = Tan1.Magnitude();
Standard_Real normetan2 = Tan2.Magnitude();
Standard_Real normetan3 = Tan3.Magnitude();
gp_Vec2d Vec1(point1,centre);
gp_Vec2d Vec2(point2,centre);
gp_Vec2d Vec3(point3,centre);
Standard_Real normevec1 = Vec1.Magnitude();
Standard_Real normevec2 = Vec2.Magnitude();
Standard_Real normevec3 = Vec3.Magnitude();
Standard_Real dot1,dot2,dot3;
if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
}
else { dot1 = 0.; }
if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
}
else { dot2 = 0.; }
if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
}
else { dot3 = 0.; }
Tol = 1.e-12;
if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
Standard_Real Angle1 = Vec1.Angle(Tan1);
if (Qualified1.IsUnqualified()||
(Qualified1.IsEnclosing()&&Angle1<=0.)||
(Qualified1.IsOutside() && Angle1 >= 0.) ||
(Qualified1.IsEnclosed() && Angle1 <= 0.)) {
Angle1 = Vec2.Angle(Tan2);
if (Qualified2.IsUnqualified() ||
(Qualified2.IsEnclosing()&&Angle1<=0.)||
(Qualified2.IsOutside() && Angle1 >= 0) ||
(Qualified2.IsEnclosed() && Angle1 <= 0.)) {
Angle1 = Vec3.Angle(Tan3);
if (Qualified3.IsUnqualified() ||
(Qualified3.IsEnclosing()&&Angle1<=0.)||
(Qualified3.IsOutside() && Angle1 >= 0) ||
(Qualified3.IsEnclosed() && Angle1 <= 0.)) {
qualifier1 = Qualified1.Qualifier();
qualifier2 = Qualified2.Qualifier();
qualifier3 = Qualified3.Qualifier();
pararg1 = Ufirst(1);
par1sol = 0.;
pnttg1sol = point1;
pararg2 = Ufirst(2);
pnttg2sol = point2;
par2sol = pnttg2sol.Distance(pnttg1sol);
pnttg3sol = point3;
pararg3 = Ufirst(3);
par3sol = pnttg3sol.Distance(pnttg1sol);
WellDone = Standard_True;
}
}
}
}
}
}
}
Geom2dGcc_Circ2d3TanIter::
Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedCirc& Qualified1 ,
const Geom2dGcc_QCurve& Qualified2 ,
const Geom2dGcc_QCurve& Qualified3 ,
const Standard_Real Param1 ,
const Standard_Real Param2 ,
const Standard_Real Param3 ,
const Standard_Real Tolerance ) {
TheSame1 = Standard_False;
TheSame2 = Standard_False;
TheSame3 = Standard_False;
par1sol = 0.;
par2sol = 0.;
par3sol = 0.;
pararg1 = 0.;
pararg2 = 0.;
pararg3 = 0.;
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
!(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
throw GccEnt_BadQualifier();
return;
}
gp_Circ2d C1 = Qualified1.Qualified();
Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(C1,Cu2,Cu3);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
math_Vector Ufirst(1,3);
math_Vector tol(1,3);
Umin(1) = 0.;
Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
Umax(1) = 2*M_PI;
Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
Ufirst(1) = Param1;
Ufirst(2) = Param2;
Ufirst(3) = Param3;
tol(1) = 2.e-15*M_PI;
tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
if (Root.IsDone()) {
Root.Root(Ufirst);
Func.Value(Ufirst,Umin);
gp_Pnt2d centre1(C1.Location());
Standard_Real R1 = C1.Radius();
gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
gp_Vec2d Tan1(gp_XY(-Sin(Ufirst(1)),Cos(Ufirst(1))));
gp_Pnt2d point2,point3;
// gp_Vec2d Tan2,Tan3,Nor2,Nor3;
gp_Vec2d Tan2,Tan3;
Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
if (circ.IsDone()) {
cirsol = circ.ThisSolution(1);
gp_Pnt2d centre(cirsol.Location());
Standard_Real dist = centre1.Distance(centre);
Standard_Real Rsol = cirsol.Radius();
Standard_Real normetan1 = Tan1.Magnitude();
Standard_Real normetan2 = Tan2.Magnitude();
Standard_Real normetan3 = Tan3.Magnitude();
gp_Vec2d Vec1(point1,centre);
gp_Vec2d Vec2(point2,centre);
gp_Vec2d Vec3(point3,centre);
Standard_Real normevec1 = Vec1.Magnitude();
Standard_Real normevec2 = Vec2.Magnitude();
Standard_Real normevec3 = Vec3.Magnitude();
Standard_Real dot1,dot2,dot3;
if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
}
else { dot1 = 0.; }
if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
}
else { dot2 = 0.; }
if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
}
else { dot3 = 0.; }
Tol = 1.e-12;
if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
if (Qualified1.IsUnqualified() ||
(Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
(Qualified1.IsOutside() && dist >= Rsol) ||
(Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
Standard_Real Angle1 = Vec2.Angle(Tan2);
if (Qualified2.IsUnqualified() ||
(Qualified2.IsEnclosing()&&Angle1<=0.)||
(Qualified2.IsOutside() && Angle1 >= 0) ||
(Qualified2.IsEnclosed() && Angle1 <= 0.)) {
Angle1 = Vec3.Angle(Tan3);
if (Qualified3.IsUnqualified() ||
(Qualified3.IsEnclosing()&&Angle1<=0.)||
(Qualified3.IsOutside() && Angle1 >= 0) ||
(Qualified3.IsEnclosed() && Angle1 <= 0.)) {
qualifier1 = Qualified1.Qualifier();
qualifier2 = Qualified2.Qualifier();
qualifier3 = Qualified3.Qualifier();
pararg1 = Ufirst(1);
par1sol = 0.;
pnttg1sol = point1;
pararg2 = Ufirst(2);
pnttg2sol = point2;
par2sol = 0.;
pararg3 = Ufirst(3);
pnttg3sol = point3;
par3sol = 0.;
WellDone = Standard_True;
}
}
}
}
}
}
}
Geom2dGcc_Circ2d3TanIter::
Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedCirc& Qualified1 ,
const GccEnt_QualifiedCirc& Qualified2 ,
const Geom2dGcc_QCurve& Qualified3 ,
const Standard_Real Param1 ,
const Standard_Real Param2 ,
const Standard_Real Param3 ,
const Standard_Real Tolerance ) {
TheSame1 = Standard_False;
TheSame2 = Standard_False;
TheSame3 = Standard_False;
par1sol = 0.;
par2sol = 0.;
par3sol = 0.;
pararg1 = 0.;
pararg2 = 0.;
pararg3 = 0.;
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
!(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
throw GccEnt_BadQualifier();
return;
}
gp_Circ2d C1 = Qualified1.Qualified();
gp_Circ2d C2 = Qualified2.Qualified();
Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(C1,C2,Cu3);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
math_Vector Ufirst(1,3);
math_Vector tol(1,3);
Umin(1) = 0.;
Umin(2) = 0.;
Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
Umax(1) = 2*M_PI;
Umax(2) = 2*M_PI;
Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
Ufirst(1) = Param1;
Ufirst(2) = Param2;
Ufirst(3) = Param3;
tol(1) = 2.e-15*M_PI;
tol(2) = 2.e-15*M_PI;
tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
if (Root.IsDone()) {
Root.Root(Ufirst);
Func.Value(Ufirst,Umin);
gp_Pnt2d centre1(C1.Location());
Standard_Real R1 = C1.Radius();
gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
gp_Vec2d Tan1(gp_XY(-Sin(Ufirst(1)),Cos(Ufirst(1))));
gp_Pnt2d centre2(C2.Location());
Standard_Real R2 = C2.Radius();
gp_Pnt2d point2(centre2.XY()+R2*gp_XY(Cos(Ufirst(2)),Sin(Ufirst(2))));
gp_Vec2d Tan2(gp_XY(-Sin(Ufirst(2)),Cos(Ufirst(2))));
gp_Pnt2d point3;
gp_Vec2d Tan3;
Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
if (circ.IsDone()) {
cirsol = circ.ThisSolution(1);
gp_Pnt2d centre(cirsol.Location());
Standard_Real dist = centre1.Distance(centre);
Standard_Real Rsol = cirsol.Radius();
Standard_Real normetan1 = Tan1.Magnitude();
Standard_Real normetan2 = Tan2.Magnitude();
Standard_Real normetan3 = Tan3.Magnitude();
gp_Vec2d Vec1(point1,centre);
gp_Vec2d Vec2(point2,centre);
gp_Vec2d Vec3(point3,centre);
Standard_Real normevec1 = Vec1.Magnitude();
Standard_Real normevec2 = Vec2.Magnitude();
Standard_Real normevec3 = Vec3.Magnitude();
Standard_Real dot1,dot2,dot3;
if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
}
else { dot1 = 0.; }
if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
}
else { dot2 = 0.; }
if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
}
else { dot3 = 0.; }
Tol = 1.e-12;
if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
if (Qualified1.IsUnqualified() ||
(Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
(Qualified1.IsOutside() && dist >= Rsol) ||
(Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
dist = centre2.Distance(centre);
if (Qualified1.IsUnqualified() ||
(Qualified1.IsEnclosing() && Rsol >= R2 && dist <= Rsol)||
(Qualified1.IsOutside() && dist >= Rsol) ||
(Qualified1.IsEnclosed() && Rsol <= R2 && dist <= Rsol)) {
gp_Vec2d Vec(point3,centre);
Standard_Real Angle1 = Vec.Angle(Tan3);
if (Qualified3.IsUnqualified() ||
(Qualified3.IsEnclosing()&&Angle1<=0.)||
(Qualified3.IsOutside() && Angle1 >= 0) ||
(Qualified3.IsEnclosed() && Angle1 <= 0.)) {
qualifier1 = Qualified1.Qualifier();
qualifier2 = Qualified2.Qualifier();
qualifier3 = Qualified3.Qualifier();
pararg1 = Ufirst(1);
par1sol = 0.;
pnttg1sol = point1;
pararg2 = Ufirst(2);
pnttg2sol = point2;
par2sol = 0.;
pararg3 = Ufirst(3);
pnttg3sol = point3;
par3sol = 0.;
WellDone = Standard_True;
}
}
}
}
}
}
}
Geom2dGcc_Circ2d3TanIter::
Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedLin& Qualified1 ,
const Geom2dGcc_QCurve& Qualified2 ,
const Geom2dGcc_QCurve& Qualified3 ,
const Standard_Real Param1 ,
const Standard_Real Param2 ,
const Standard_Real Param3 ,
const Standard_Real Tolerance ) {
TheSame1 = Standard_False;
TheSame2 = Standard_False;
TheSame3 = Standard_False;
par1sol = 0.;
par2sol = 0.;
par3sol = 0.;
pararg1 = 0.;
pararg2 = 0.;
pararg3 = 0.;
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
if (!(Qualified1.IsEnclosed() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
!(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
throw GccEnt_BadQualifier();
return;
}
gp_Lin2d L1 = Qualified1.Qualified();
Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(L1,Cu2,Cu3);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
math_Vector Ufirst(1,3);
math_Vector tol(1,3);
Umin(1) = RealFirst();
Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
Umax(1) = RealLast();
Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
Ufirst(1) = Param1;
Ufirst(2) = Param2;
Ufirst(3) = Param3;
tol(1) = 1.e-15;
tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
if (Root.IsDone()) {
Root.Root(Ufirst);
Func.Value(Ufirst,Umin);
gp_Pnt2d centre1(L1.Location());
gp_Pnt2d point1(centre1.XY()+Ufirst(1)*L1.Direction().XY());
gp_Pnt2d point2,point3;
gp_Vec2d Tan2,Tan3;
Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
if (circ.IsDone()) {
cirsol = circ.ThisSolution(1);
gp_Pnt2d centre(cirsol.Location());
// creation vaariables intermediaires pour WNT
gp_XY dummy1 = centre.XY()-L1.Location().XY();
gp_XY dummy2 (-L1.Direction().Y(),L1.Direction().X());
Standard_Real pscal=dummy1.Dot(dummy2);
gp_Vec2d Tan1(L1.Direction().XY());
Standard_Real normetan1 = Tan1.Magnitude();
Standard_Real normetan2 = Tan2.Magnitude();
Standard_Real normetan3 = Tan3.Magnitude();
gp_Vec2d Vec1(point1,centre);
gp_Vec2d Vec2(point2,centre);
gp_Vec2d Vec3(point3,centre);
Standard_Real normevec1 = Vec1.Magnitude();
Standard_Real normevec2 = Vec2.Magnitude();
Standard_Real normevec3 = Vec3.Magnitude();
Standard_Real dot1,dot2,dot3;
if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
}
else { dot1 = 0.; }
if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
}
else { dot2 = 0.; }
if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
}
else { dot3 = 0.; }
Tol = 1.e-12;
if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
if (Qualified1.IsUnqualified() ||
(Qualified1.IsOutside() && pscal <= 0.) ||
(Qualified1.IsEnclosed() && pscal >= 0.)) {
gp_Vec2d Vec(point2,centre);
Standard_Real Angle1 = Vec.Angle(Tan2);
if (Qualified2.IsUnqualified() ||
(Qualified2.IsEnclosing()&&Angle1<=0.)||
(Qualified2.IsOutside() && Angle1 >= 0) ||
(Qualified2.IsEnclosed() && Angle1 <= 0.)) {
Vec = gp_Vec2d(point3,centre);
Angle1 = Vec.Angle(Tan3);
if (Qualified3.IsUnqualified() ||
(Qualified3.IsEnclosing()&&Angle1<=0.)||
(Qualified3.IsOutside() && Angle1 >= 0) ||
(Qualified3.IsEnclosed() && Angle1 <= 0.)) {
qualifier1 = Qualified1.Qualifier();
qualifier2 = Qualified2.Qualifier();
qualifier3 = Qualified3.Qualifier();
pararg1 = Ufirst(1);
par1sol = 0.;
pnttg1sol = point1;
pararg2 = Ufirst(2);
pnttg2sol = point2;
par2sol = 0.;
pararg3 = Ufirst(3);
pnttg3sol = point3;
par3sol = 0.;
WellDone = Standard_True;
}
}
}
}
}
}
}
Geom2dGcc_Circ2d3TanIter::
Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedLin& Qualified1 ,
const GccEnt_QualifiedLin& Qualified2 ,
const Geom2dGcc_QCurve& Qualified3 ,
const Standard_Real Param1 ,
const Standard_Real Param2 ,
const Standard_Real Param3 ,
const Standard_Real Tolerance ){
TheSame1 = Standard_False;
TheSame2 = Standard_False;
TheSame3 = Standard_False;
par1sol = 0.;
par2sol = 0.;
par3sol = 0.;
pararg1 = 0.;
pararg2 = 0.;
pararg3 = 0.;
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
if (!(Qualified1.IsEnclosed() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() ||
Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
!(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
throw GccEnt_BadQualifier();
return;
}
gp_Lin2d L1 = Qualified1.Qualified();
gp_Lin2d L2 = Qualified2.Qualified();
Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(L1,L2,Cu3);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
math_Vector Ufirst(1,3);
math_Vector tol(1,3);
Umin(1) = RealFirst();
Umin(2) = RealFirst();
Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
Umax(1) = RealLast();
Umax(2) = RealLast();
Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
Ufirst(1) = Param1;
Ufirst(2) = Param2;
Ufirst(3) = Param3;
tol(1) = 1.e-15;
tol(2) = 1.e-15;
tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
if (Root.IsDone()) {
Root.Root(Ufirst);
Func.Value(Ufirst,Umin);
gp_Pnt2d centre1(L1.Location());
gp_Pnt2d point1(centre1.XY()+Ufirst(1)*L1.Direction().XY());
gp_Pnt2d centre2(L2.Location());
gp_Pnt2d point2(centre2.XY()+Ufirst(2)*L2.Direction().XY());
gp_Pnt2d point3;
gp_Vec2d Tan3;
Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
if (circ.IsDone()) {
cirsol = circ.ThisSolution(1);
gp_Pnt2d centre(cirsol.Location());
Standard_Real pscal=centre.XY().Dot(gp_XY(-L1.Direction().Y(),
L1.Direction().X()));
if (Qualified1.IsUnqualified() ||
(Qualified1.IsOutside() && pscal <= 0.) ||
(Qualified1.IsEnclosed() && pscal >= 0.)) {
gp_Vec2d Tan1(L1.Direction().XY());
gp_Vec2d Tan2(L2.Direction().XY());
Standard_Real normetan1 = Tan1.Magnitude();
Standard_Real normetan2 = Tan2.Magnitude();
Standard_Real normetan3 = Tan3.Magnitude();
gp_Vec2d Vec1(point1,centre);
gp_Vec2d Vec2(point2,centre);
gp_Vec2d Vec3(point3,centre);
Standard_Real normevec1 = Vec1.Magnitude();
Standard_Real normevec2 = Vec2.Magnitude();
Standard_Real normevec3 = Vec3.Magnitude();
Standard_Real dot1,dot2,dot3;
if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
}
else { dot1 = 0.; }
if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
}
else { dot2 = 0.; }
if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
}
else { dot3 = 0.; }
Tol = 1.e-12;
if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
if (Qualified2.IsUnqualified() ||
(Qualified2.IsOutside() && pscal <= 0.) ||
(Qualified2.IsEnclosed() && pscal >= 0.)) {
Standard_Real Angle1 = Vec3.Angle(Tan3);
if (Qualified3.IsUnqualified() ||
(Qualified3.IsEnclosing()&&Angle1<=0.)||
(Qualified3.IsOutside() && Angle1 >= 0) ||
(Qualified3.IsEnclosed() && Angle1 <= 0.)) {
qualifier1 = Qualified1.Qualifier();
qualifier2 = Qualified2.Qualifier();
qualifier3 = Qualified3.Qualifier();
pararg1 = Ufirst(1);
par1sol = 0.;
pnttg1sol = point1;
pararg2 = Ufirst(2);
pnttg2sol = point2;
par2sol = 0.;
pararg3 = Ufirst(3);
pnttg3sol = point3;
par3sol = 0.;
WellDone = Standard_True;
}
}
}
}
}
}
}
Geom2dGcc_Circ2d3TanIter::
Geom2dGcc_Circ2d3TanIter (const Geom2dGcc_QCurve& Qualified1 ,
const Geom2dGcc_QCurve& Qualified2 ,
const gp_Pnt2d& Point3 ,
const Standard_Real Param1 ,
const Standard_Real Param2 ,
const Standard_Real Tolerance ) {
TheSame1 = Standard_False;
TheSame2 = Standard_False;
TheSame3 = Standard_False;
par1sol = 0.;
par2sol = 0.;
par3sol = 0.;
pararg1 = 0.;
pararg2 = 0.;
pararg3 = 0.;
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
throw GccEnt_BadQualifier();
return;
}
gp_Circ2d C1(gp_Ax2d(Point3,gp_Dir2d(1.,0.)),0.);
Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(C1,Cu1,Cu2);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
math_Vector Ufirst(1,3);
math_Vector tol(1,3);
Umin(1) = 0.;
Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
Umax(1) = 2*M_PI;
Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu1);
Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu2);
Ufirst(1) = M_PI;
Ufirst(2) = Param1;
Ufirst(3) = Param2;
tol(1) = 2.e-15*M_PI;
tol(2) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
tol(3) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
if (Root.IsDone()) {
Root.Root(Ufirst);
Func.Value(Ufirst,Umin);
gp_Pnt2d point1,point2;
// gp_Vec2d Tan1,Tan2,Nor1,Nor2;
gp_Vec2d Tan1,Tan2;
Geom2dGcc_CurveTool::D1(Cu1,Ufirst(2),point1,Tan1);
Geom2dGcc_CurveTool::D1(Cu2,Ufirst(3),point2,Tan2);
GccAna_Circ2d3Tan circ(Point3,point1,point2,Tol);
if (circ.IsDone()) {
cirsol = circ.ThisSolution(1);
gp_Pnt2d centre(cirsol.Location());
gp_Vec2d Tan3(-Sin(Ufirst(1)),Cos(Ufirst(1)));
Standard_Real normetan1 = Tan1.Magnitude();
Standard_Real normetan2 = Tan2.Magnitude();
Standard_Real normetan3 = Tan3.Magnitude();
gp_Vec2d Vec1(point1,centre);
gp_Vec2d Vec2(point2,centre);
gp_Vec2d Vec3(Point3,centre);
Standard_Real normevec1 = Vec1.Magnitude();
Standard_Real normevec2 = Vec2.Magnitude();
Standard_Real normevec3 = Vec3.Magnitude();
Standard_Real dot1,dot2,dot3;
if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
}
else { dot1 = 0.; }
if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
}
else { dot2 = 0.; }
if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
}
else { dot3 = 0.; }
Tol = 1.e-12;
if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
Standard_Real Angle1 = Vec1.Angle(Tan1);
if (Qualified1.IsUnqualified()||
(Qualified1.IsEnclosing()&&Angle1<=0.)||
(Qualified1.IsOutside() && Angle1 >= 0) ||
(Qualified1.IsEnclosed() && Angle1 <= 0.)) {
Angle1 = Vec2.Angle(Tan2);
if (Qualified1.IsUnqualified() ||
(Qualified1.IsEnclosing()&&Angle1<=0.)||
(Qualified1.IsOutside() && Angle1 >= 0) ||
(Qualified1.IsEnclosed() && Angle1 <= 0.)) {
qualifier1 = Qualified1.Qualifier();
qualifier2 = Qualified2.Qualifier();
qualifier3 = GccEnt_noqualifier;
pararg1 = Ufirst(2);
par1sol = 0.;
pnttg1sol = point1;
pararg2 = Ufirst(3);
pnttg2sol = point2;
par2sol = 0.;
pararg3 = 0.;
pnttg3sol = Point3;
par3sol = 0.;
WellDone = Standard_True;
}
}
}
}
}
}
Geom2dGcc_Circ2d3TanIter::
Geom2dGcc_Circ2d3TanIter (const Geom2dGcc_QCurve& Qualified1 ,
const gp_Pnt2d& Point2 ,
const gp_Pnt2d& Point3 ,
const Standard_Real Param1 ,
const Standard_Real Tolerance ) {
TheSame1 = Standard_False;
TheSame2 = Standard_False;
TheSame3 = Standard_False;
par1sol = 0.;
par2sol = 0.;
par3sol = 0.;
pararg1 = 0.;
pararg2 = 0.;
pararg3 = 0.;
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
throw GccEnt_BadQualifier();
return;
}
gp_Dir2d dirx(1.,0.);
gp_Circ2d C1(gp_Ax2d(Point2,dirx),0.);
gp_Circ2d C2(gp_Ax2d(Point3,dirx),0.);
Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(C1,C2,Cu1);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
math_Vector Ufirst(1,3);
math_Vector tol(1,3);
Umin(1) = 0.;
Umin(2) = 0.;
Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
Umax(1) = 2*M_PI;
Umax(2) = 2*M_PI;
Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu1);
Ufirst(1) = M_PI;
Ufirst(2) = M_PI;
Ufirst(3) = Param1;
tol(1) = 2.e-15*M_PI;
tol(2) = 2.e-15*M_PI;
tol(3) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
if (Root.IsDone()) {
Root.Root(Ufirst);
Func.Value(Ufirst,Umin);
gp_Pnt2d point3;
// gp_Vec2d Tan3,Nor3;
gp_Vec2d Tan3;
Geom2dGcc_CurveTool::D1(Cu1,Ufirst(3),point3,Tan3);
GccAna_Circ2d3Tan circ(Point2,Point3,point3,Tol);
if (circ.IsDone()) {
cirsol = circ.ThisSolution(1);
gp_Pnt2d centre(cirsol.Location());
gp_Vec2d Tan2(-Sin(Ufirst(2)),Cos(Ufirst(2)));
gp_Vec2d Tan1(-Sin(Ufirst(1)),Cos(Ufirst(1)));
Standard_Real normetan1 = Tan1.Magnitude();
Standard_Real normetan2 = Tan2.Magnitude();
Standard_Real normetan3 = Tan3.Magnitude();
gp_Vec2d Vec1(Point2,centre);
gp_Vec2d Vec2(Point3,centre);
gp_Vec2d Vec3(point3,centre);
Standard_Real normevec1 = Vec1.Magnitude();
Standard_Real normevec2 = Vec2.Magnitude();
Standard_Real normevec3 = Vec3.Magnitude();
Standard_Real dot1,dot2,dot3;
if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
}
else { dot1 = 0.; }
if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
}
else { dot2 = 0.; }
if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
}
else { dot3 = 0.; }
Tol = 1.e-12;
if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
Standard_Real Angle1 = Vec1.Angle(Tan1);
if (Qualified1.IsUnqualified() ||
(Qualified1.IsEnclosing()&&Angle1<=0.)||
(Qualified1.IsOutside() && Angle1 >= 0) ||
(Qualified1.IsEnclosed() && Angle1 <= 0.)) {
qualifier1 = Qualified1.Qualifier();
qualifier2 = GccEnt_noqualifier;
qualifier3 = GccEnt_noqualifier;
pararg1 = Ufirst(3);
par1sol = 0.;
pnttg1sol = point3;
pararg2 = 0.;
pnttg2sol = Point2;
par2sol = 0.;
pararg3 = 0.;
pnttg3sol = Point3;
par3sol = 0.;
WellDone = Standard_True;
}
}
}
}
}
Geom2dGcc_Circ2d3TanIter::
Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedLin& Qualified1 ,
const Geom2dGcc_QCurve& Qualified2 ,
const gp_Pnt2d& Point3 ,
const Standard_Real Param1 ,
const Standard_Real Param2 ,
const Standard_Real Tolerance ) {
TheSame1 = Standard_False;
TheSame2 = Standard_False;
TheSame3 = Standard_False;
par1sol = 0.;
par2sol = 0.;
par3sol = 0.;
pararg1 = 0.;
pararg2 = 0.;
pararg3 = 0.;
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
if (!(Qualified1.IsEnclosed() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
throw GccEnt_BadQualifier();
return;
}
gp_Dir2d dirx(1.,0.);
gp_Lin2d L1 = Qualified1.Qualified();
Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
gp_Circ2d C3(gp_Ax2d(Point3,dirx),0.);
Geom2dGcc_FunctionTanCuCuCu Func(C3,L1,Cu2);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
math_Vector Ufirst(1,3);
math_Vector tol(1,3);
Umin(2) = RealFirst();
Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
Umin(1) = 0.;
Umax(2) = RealLast();
Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu2);
Umax(1) = 2*M_PI;
Ufirst(2) = Param1;
Ufirst(3) = Param2;
Ufirst(1) = M_PI;
tol(1) = 2.e-15;
tol(2) = 1.e-15;
tol(3) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
if (Root.IsDone()) {
Root.Root(Ufirst);
Func.Value(Ufirst,Umin);
gp_Pnt2d centre1(L1.Location());
gp_Pnt2d point1(centre1.XY()+Ufirst(2)*L1.Direction().XY());
gp_Pnt2d point2;
gp_Vec2d Tan2;
Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
GccAna_Circ2d3Tan circ(point1,point2,Point3,Tol);
if (circ.IsDone()) {
cirsol = circ.ThisSolution(1);
gp_Pnt2d centre(cirsol.Location());
Standard_Real pscal=centre.XY().Dot(gp_XY(-L1.Direction().Y(),
L1.Direction().X()));
gp_Vec2d Tan1(L1.Direction().XY());
gp_Vec2d Tan3(-Sin(Ufirst(1)),Cos(Ufirst(1)));
Standard_Real normetan1 = Tan1.Magnitude();
Standard_Real normetan2 = Tan2.Magnitude();
Standard_Real normetan3 = Tan3.Magnitude();
gp_Vec2d Vec1(point1,centre);
gp_Vec2d Vec2(point2,centre);
gp_Vec2d Vec3(Point3,centre);
Standard_Real normevec1 = Vec1.Magnitude();
Standard_Real normevec2 = Vec2.Magnitude();
Standard_Real normevec3 = Vec3.Magnitude();
Standard_Real dot1,dot2,dot3;
if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
}
else { dot1 = 0.; }
if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
}
else { dot2 = 0.; }
if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
}
else { dot3 = 0.; }
Tol = 1.e-12;
if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
if (Qualified1.IsUnqualified() ||
(Qualified1.IsOutside() && pscal <= 0.) ||
(Qualified1.IsEnclosed() && pscal >= 0.)) {
Standard_Real Angle1 = Vec2.Angle(Tan2);
if (Qualified2.IsUnqualified() ||
(Qualified2.IsEnclosing()&&Angle1<=0.)||
(Qualified2.IsOutside() && Angle1 >= 0) ||
(Qualified2.IsEnclosed() && Angle1 <= 0.)) {
qualifier1 = Qualified1.Qualifier();
qualifier2 = Qualified2.Qualifier();
qualifier3 = GccEnt_noqualifier;
pararg1 = Ufirst(2);
par1sol = 0.;
pnttg1sol = point1;
pararg2 = Ufirst(3);
pnttg2sol = point2;
par2sol = 0.;
pararg3 = 0.;
pnttg3sol = Point3;
par3sol = 0.;
WellDone = Standard_True;
}
}
}
}
}
}
Geom2dGcc_Circ2d3TanIter::
Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedCirc& Qualified1 ,
const GccEnt_QualifiedLin& Qualified2 ,
const Geom2dGcc_QCurve& Qualified3 ,
const Standard_Real Param1 ,
const Standard_Real Param2 ,
const Standard_Real Param3 ,
const Standard_Real Tolerance ) {
TheSame1 = Standard_False;
TheSame2 = Standard_False;
TheSame3 = Standard_False;
par1sol = 0.;
par2sol = 0.;
par3sol = 0.;
pararg1 = 0.;
pararg2 = 0.;
pararg3 = 0.;
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() ||
Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
!(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
throw GccEnt_BadQualifier();
return;
}
gp_Circ2d C1 = Qualified1.Qualified();
gp_Lin2d L2 = Qualified2.Qualified();
Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(C1,L2,Cu3);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
math_Vector Ufirst(1,3);
math_Vector tol(1,3);
Umin(1) = 0.;
Umin(2) = RealFirst();
Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
Umax(1) = 2*M_PI;
Umax(2) = RealLast();
Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
Ufirst(1) = Param1;
Ufirst(2) = Param2;
Ufirst(3) = Param3;
tol(1) = 2.e-15*M_PI;
tol(2) = 1.e-15;
tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
if (Root.IsDone()) {
Func.Value(Ufirst,Umin);
Root.Root(Ufirst);
gp_Pnt2d centre1(C1.Location());
Standard_Real R1 = C1.Radius();
gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
gp_Pnt2d centre2(L2.Location());
gp_Pnt2d point2(centre2.XY()+Ufirst(2)*L2.Direction().XY());
gp_Pnt2d point3;
gp_Vec2d Tan3;
Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
if (circ.IsDone()) {
cirsol = circ.ThisSolution(1);
gp_Pnt2d centre(cirsol.Location());
gp_Vec2d Tan1(-Sin(Ufirst(1)),Cos(Ufirst(1)));
gp_Vec2d Tan2(L2.Direction().XY());
Standard_Real normetan1 = Tan1.Magnitude();
Standard_Real normetan2 = Tan2.Magnitude();
Standard_Real normetan3 = Tan3.Magnitude();
gp_Vec2d Vec1(point1,centre);
gp_Vec2d Vec2(point2,centre);
gp_Vec2d Vec3(point3,centre);
Standard_Real normevec1 = Vec1.Magnitude();
Standard_Real normevec2 = Vec2.Magnitude();
Standard_Real normevec3 = Vec3.Magnitude();
Standard_Real dot1,dot2,dot3;
if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
}
else { dot1 = 0.; }
if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
}
else { dot2 = 0.; }
if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
}
else { dot3 = 0.; }
Tol = 1.e-12;
if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
Standard_Real dist = centre1.Distance(centre);
Standard_Real Rsol = cirsol.Radius();
if (Qualified1.IsUnqualified() ||
(Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
(Qualified1.IsOutside() && dist >= Rsol) ||
(Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
Standard_Real pscal=centre.XY().Dot(gp_XY(-L2.Direction().Y(),
L2.Direction().X()));
if (Qualified2.IsUnqualified() ||
(Qualified2.IsOutside() && pscal <= 0.) ||
(Qualified2.IsEnclosed() && pscal >= 0.)) {
Standard_Real Angle1 = Vec3.Angle(Tan3);
if (Qualified3.IsUnqualified() ||
(Qualified3.IsEnclosing()&&Angle1<=0.)||
(Qualified3.IsOutside() && Angle1 >= 0) ||
(Qualified3.IsEnclosed() && Angle1 <= 0.)) {
qualifier1 = Qualified1.Qualifier();
qualifier2 = Qualified2.Qualifier();
qualifier3 = Qualified3.Qualifier();
pararg1 = Ufirst(1);
par1sol = 0.;
pnttg1sol = point1;
pararg2 = Ufirst(2);
pnttg2sol = point2;
par2sol = 0.;
pararg3 = Ufirst(3);
pnttg3sol = point3;
par3sol = 0.;
WellDone = Standard_True;
}
}
}
}
}
}
}
Geom2dGcc_Circ2d3TanIter::
Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedCirc& Qualified1 ,
const Geom2dGcc_QCurve& Qualified2 ,
const gp_Pnt2d& Point3 ,
const Standard_Real Param1 ,
const Standard_Real Param2 ,
const Standard_Real Tolerance ) {
TheSame1 = Standard_False;
TheSame2 = Standard_False;
TheSame3 = Standard_False;
par1sol = 0.;
par2sol = 0.;
par3sol = 0.;
pararg1 = 0.;
pararg2 = 0.;
pararg3 = 0.;
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
throw GccEnt_BadQualifier();
return;
}
gp_Circ2d C1 = Qualified1.Qualified();
Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
gp_Dir2d dirx(1.,0.);
gp_Circ2d C3(gp_Ax2d(Point3,dirx),0.);
Geom2dGcc_FunctionTanCuCuCu Func(C1,C3,Cu2);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
math_Vector Ufirst(1,3);
math_Vector tol(1,3);
Umin(1) = 0.;
Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
Umin(2) = 0.;
Umax(1) = 2*M_PI;
Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu2);
Umax(2) = 2*M_PI;
Ufirst(1) = Param1;
Ufirst(2) = M_PI;
Ufirst(3) = Param2;
tol(1) = 2.e-15*M_PI;
tol(2) = 2.e-15*M_PI;
tol(3) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
if (Root.IsDone()) {
Root.Root(Ufirst);
Func.Value(Ufirst,Umin);
gp_Pnt2d centre1(C1.Location());
Standard_Real R1 = C1.Radius();
gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
gp_Pnt2d point2;
// gp_Vec2d Tan2,Nor2;
gp_Vec2d Tan2;
Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
GccAna_Circ2d3Tan circ(point1,point2,Point3,Tol);
if (circ.IsDone()) {
cirsol = circ.ThisSolution(1);
gp_Pnt2d centre(cirsol.Location());
gp_Vec2d Tan1(-Sin(Ufirst(1)),Cos(Ufirst(1)));
gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
Standard_Real normetan2 = Tan2.Magnitude();
gp_Vec2d Vec1(point1,centre);
gp_Vec2d Vec2(point2,centre);
gp_Vec2d Vec3(Point3,centre);
Standard_Real normevec1 = Vec1.Magnitude();
Standard_Real normevec2 = Vec2.Magnitude();
Standard_Real normevec3 = Vec3.Magnitude();
Standard_Real dot1,dot2,dot3;
if (normevec1 >= gp::Resolution()) {
dot1 = Vec1.Dot(Tan1)/(normevec1);
}
else { dot1 = 0.; }
if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
}
else { dot2 = 0.; }
if (normevec3 >= gp::Resolution()) {
dot3 = Vec3.Dot(Tan3)/(normevec3);
}
else { dot3 = 0.; }
Tol = 1.e-12;
if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
Standard_Real dist = centre1.Distance(centre);
Standard_Real Rsol = cirsol.Radius();
if (Qualified1.IsUnqualified() ||
(Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
(Qualified1.IsOutside() && dist >= Rsol) ||
(Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
Standard_Real Angle1 = Vec2.Angle(Tan2);
if (Qualified2.IsUnqualified() ||
(Qualified2.IsEnclosing()&&Angle1<=0.)||
(Qualified2.IsOutside() && Angle1 >= 0) ||
(Qualified2.IsEnclosed() && Angle1 <= 0.)) {
qualifier1 = Qualified1.Qualifier();
qualifier2 = Qualified2.Qualifier();
qualifier3 = GccEnt_noqualifier;
pararg1 = Ufirst(1);
par1sol = 0.;
pnttg1sol = point1;
pararg2 = Ufirst(2);
pnttg2sol = point2;
par2sol = 0.;
pararg3 = 0.;
pnttg3sol = Point3;
par3sol = 0.;
WellDone = Standard_True;
}
}
}
}
}
}
Standard_Boolean Geom2dGcc_Circ2d3TanIter::
IsDone () const{ return WellDone; }
gp_Circ2d Geom2dGcc_Circ2d3TanIter::
ThisSolution () const{ return cirsol; }
void Geom2dGcc_Circ2d3TanIter::
WhichQualifier (GccEnt_Position& Qualif1 ,
GccEnt_Position& Qualif2 ,
GccEnt_Position& Qualif3 ) const
{
if (!WellDone) { throw StdFail_NotDone(); }
else {
Qualif1 = qualifier1;
Qualif2 = qualifier2;
Qualif3 = qualifier3;
}
}
void Geom2dGcc_Circ2d3TanIter::
Tangency1 (Standard_Real& ParSol ,
Standard_Real& ParArg ,
gp_Pnt2d& PntSol ) const{
if (!WellDone) { throw StdFail_NotDone(); }
else {
if (TheSame1 == 0) {
ParSol = par1sol;
ParArg = pararg1;
PntSol = pnttg1sol;
}
else { throw StdFail_NotDone(); }
}
}
void Geom2dGcc_Circ2d3TanIter::
Tangency2 (Standard_Real& ParSol ,
Standard_Real& ParArg ,
gp_Pnt2d& PntSol ) const{
if (!WellDone) { throw StdFail_NotDone(); }
else {
ParSol = par2sol;
ParArg = pararg2;
PntSol = pnttg2sol;
}
}
void Geom2dGcc_Circ2d3TanIter::
Tangency3 (Standard_Real& ParSol ,
Standard_Real& ParArg ,
gp_Pnt2d& PntSol ) const{
if (!WellDone) { throw StdFail_NotDone(); }
else {
ParSol = par3sol;
ParArg = pararg3;
PntSol = pnttg3sol;
}
}
Standard_Boolean Geom2dGcc_Circ2d3TanIter::
IsTheSame1 () const
{
if (!WellDone) throw StdFail_NotDone();
if (TheSame1 == 0)
return Standard_False;
return Standard_True;
}
Standard_Boolean Geom2dGcc_Circ2d3TanIter::
IsTheSame2 () const
{
if (!WellDone) throw StdFail_NotDone();
if (TheSame3 == 0)
return Standard_False;
return Standard_True;
}
Standard_Boolean Geom2dGcc_Circ2d3TanIter::
IsTheSame3 () const
{
if (!WellDone) throw StdFail_NotDone();
return Standard_True;
}
View Git Blame Copy Permalink