p GccAna
p GccEnt
p GccInt
-p GccIter
p Geom2dAPI
p Geom2dGcc
p Geom2dHatch
+++ /dev/null
--- Created on: 1991-04-04
--- 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.
-
-package GccIter
-
- ---Purpose :
- -- This package provides an implementation of analytics
- -- algorithms (using only non persistant entities) used
- -- to create 2d lines or circles with geometric constraints.
- --
- -- Exceptions :
- -- IsParallel which inherits DomainError. This exception
- -- is raised in the class Lin2dTanObl when we want to
- -- find the intersection point between the solution and
- -- the second argument with a null angle.
-
-uses GccEnt,
- GccInt,
- GccAna,
- StdFail,
- gp,
- math
-
-is
-
-enumeration Type1 is CuCuCu,CiCuCu,CiCiCu,CiLiCu,LiLiCu,LiCuCu;
-
-enumeration Type2 is CuCuOnCu,CiCuOnCu,LiCuOnCu,CuPtOnCu,
- CuCuOnLi,CiCuOnLi,LiCuOnLi,CuPtOnLi,
- CuCuOnCi,CiCuOnCi,LiCuOnCi,CuPtOnCi;
-
-enumeration Type3 is CuCu,CiCu;
-
-generic class FunctionTanCuCu;
-
-generic class FunctionTanCirCu;
-
-generic class FunctionTanCuCuCu;
-
-generic class FunctionTanCuCuOnCu;
-
-generic class FunctionTanCuPnt;
-
-generic class FunctionTanObl;
-
-generic class Lin2dTanObl, FuncTObl;
- -- Create a 2d line TANgent to a 2d curve and OBLic to a 2d line.
-
-generic class Lin2d2Tan, FuncTCuCu, FuncTCirCu, FuncTCuPt;
- -- Create a 2d line TANgent to 2 2d entities.
-
-generic class Circ2d3Tan, FuncTCuCuCu;
- -- Create a 2d circle TANgent to 3 2d entities.
-
-generic class Circ2d2TanOn, FuncTCuCuOnCu;
- -- Create a 2d circle TANgent to a 2d entity and centered ON a 2d
- -- entity (not a point).
-
-exception IsParallel inherits DomainError from Standard;
-
-end GccIter;
+++ /dev/null
-// 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 <gp_Dir2d.hxx>
-#include <gp_Ax2d.hxx>
-#include <gp.hxx>
-#include <StdFail_NotDone.hxx>
-#include <GccEnt_BadQualifier.hxx>
-#include <math_FunctionSetRoot.hxx>
-#include <ElCLib.hxx>
-
-GccIter_Circ2d2TanOn::
- GccIter_Circ2d2TanOn (const GccEnt_QualifiedLin& Qualified1 ,
- const TheQualifiedCurve& Qualified2 ,
- const gp_Lin2d& OnLine ,
- const Standard_Real Param1 ,
- const Standard_Real Param2 ,
- const Standard_Real Param3 ,
- const Standard_Real Tolang ) {
-
- TheSame1 = Standard_False;
- TheSame2 = Standard_False;
- par1sol = 0.;
- par2sol = 0.;
- pararg1 = 0.;
- pararg2 = 0.;
- parcen3 = 0.;
-
- WellDone = Standard_False;
- Standard_Real Tol = Abs(Tolang);
- WellDone = Standard_False;
- if (!(Qualified1.IsEnclosed() ||
- Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
- !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
- Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- gp_Dir2d dirx(1.,0.);
- gp_Lin2d L1 = Qualified1.Qualified();
- TheCurve Cu2 = Qualified2.Qualified();
- math_Vector Umin(1,4);
- math_Vector Umax(1,4);
- math_Vector Ufirst(1,4);
- math_Vector tol(1,4);
- Umin(1) = RealFirst();
- Umin(2) = TheCurveTool::FirstParameter(Cu2);
- Umin(3) = RealFirst();
- Umin(4) = 0.;
- Umax(1) = RealLast();
- Umax(2) = TheCurveTool::LastParameter(Cu2);
- Umax(3) = RealLast();
- Umax(4) = RealLast();
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- Ufirst(3) = Param3;
- tol(1) = 1.e-15;
- tol(2) = TheCurveTool::EpsX(Cu2,Tolang);
- tol(3) = tol(1);
- tol(4) = tol(1);
- gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
- gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
- gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
- Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
- GccIter_FuncTCuCuOnCu Func(L1,Cu2,OnLine,Ufirst(4));
- math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
- Func.Value(Ufirst,Umin);
- if (Root.IsDone()) {
- Root.Root(Ufirst);
-// gp_Vec2d Tan1,Tan2,Nor1,Nor2;
- gp_Vec2d Tan1,Tan2;
- ElCLib::D1(Ufirst(1),L1,point1,Tan1);
- TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
- gp_Vec2d Tan3(OnLine.Direction().XY());
- gp_Pnt2d point3(OnLine.Location().XY()+Ufirst(3)*Tan3.XY());
- Standard_Real dist1 = point3.Distance(point1);
- Standard_Real dist2 = point3.Distance(point2);
- if ( Abs(dist1-dist2)/2. <= Tol) {
- cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
- Standard_Real normetan2 = Tan2.Magnitude();
- gp_Vec2d Vec1(point1,point3);
- gp_Vec2d Vec2(point2,point3);
- Standard_Real normevec2 = Vec2.Magnitude();
- Standard_Real angle2;
- if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
- angle2 = Vec2.Angle(Tan2);
- }
- else { angle2 = 0.; }
- Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
- L1.Direction().X()));
- if (Qualified1.IsUnqualified() ||
- (Qualified1.IsOutside() && pscal <= 0.) ||
- (Qualified1.IsEnclosed() && pscal >= 0.)) {
- if (Qualified2.IsUnqualified() ||
- (Qualified2.IsEnclosing()&&angle2<=0.)||
- (Qualified2.IsOutside() && angle2 >= 0) ||
- (Qualified2.IsEnclosed() && angle2 <= 0.)) {
- qualifier1 = Qualified1.Qualifier();
- qualifier2 = Qualified2.Qualifier();
- pnttg1sol = point1;
- pararg1 = Ufirst(1);
- par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
- pnttg2sol = point2;
- pararg2 = Ufirst(2);
- par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
- pntcen = point3;
- parcen3 = Ufirst(3);
- WellDone = Standard_True;
- }
- }
- }
- }
- }
-
-GccIter_Circ2d2TanOn::
- GccIter_Circ2d2TanOn (const TheQualifiedCurve& Qualified1 ,
- const TheQualifiedCurve& Qualified2 ,
- const gp_Lin2d& OnLine ,
- const Standard_Real Param1 ,
- const Standard_Real Param2 ,
- const Standard_Real Param3 ,
- const Standard_Real Tolerance ) {
- TheSame1 = Standard_False;
- TheSame2 = Standard_False;
- par1sol = 0.;
- par2sol = 0.;
- pararg1 = 0.;
- pararg2 = 0.;
- parcen3 = 0.;
-
- WellDone = Standard_False;
- if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
- Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
- !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
- Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- Standard_Real Tol = Abs(Tolerance);
- gp_Dir2d dirx(1.,0.);
- TheCurve Cu1 = Qualified1.Qualified();
- TheCurve Cu2 = Qualified2.Qualified();
- math_Vector Umin(1,4);
- math_Vector Umax(1,4);
- math_Vector Ufirst(1,4);
- math_Vector tol(1,4);
- Umin(1) = TheCurveTool::FirstParameter(Cu1);
- Umin(2) = TheCurveTool::FirstParameter(Cu2);
- Umin(3) = RealFirst();
- Umin(4) = 0.;
- Umax(1) = TheCurveTool::LastParameter(Cu1);
- Umax(2) = TheCurveTool::LastParameter(Cu2);
- Umax(3) = RealLast();
- Umax(4) = RealLast();
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- Ufirst(3) = Param3;
- tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
- tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
- tol(3) = 1.e-15;
- tol(4) = Tol/10.;
- gp_Pnt2d point1 = TheCurveTool::Value(Cu1,Param1);
- gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
- gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
- Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
- GccIter_FuncTCuCuOnCu Func(Cu1,Cu2,OnLine,Ufirst(4));
- math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
- Func.Value(Ufirst,Umin);
- if (Root.IsDone()) {
- Root.Root(Ufirst);
- gp_Vec2d Tan1,Tan2;
- TheCurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
- TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
- gp_Vec2d Tan3(OnLine.Direction().XY());
- gp_Pnt2d point3(OnLine.Location().XY()+Ufirst(3)*Tan3.XY());
- Standard_Real dist1 = point3.Distance(point1);
- Standard_Real dist2 = point3.Distance(point2);
- if ( Abs(dist1-dist2)/2. <= Tol) {
- cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
- Standard_Real normetan1 = Tan1.Magnitude();
- Standard_Real normetan2 = Tan2.Magnitude();
- gp_Vec2d Vec1(point1,point3);
- gp_Vec2d Vec2(point2,point3);
- Standard_Real normevec1 = Vec1.Magnitude();
- Standard_Real normevec2 = Vec2.Magnitude();
- Standard_Real angle1,angle2;
- if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
- angle1 = Vec1.Angle(Tan1);
- }
- else { angle1 = 0.; }
- if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
- angle2 = Vec2.Angle(Tan2);
- }
- else { angle2 = 0.; }
- if (Qualified1.IsUnqualified()||
- (Qualified1.IsEnclosing()&&angle1<=0.)||
- (Qualified1.IsOutside() && angle1 >= 0.) ||
- (Qualified1.IsEnclosed() && angle1 <= 0.)) {
- if (Qualified2.IsUnqualified() ||
- (Qualified2.IsEnclosing()&&angle2<=0.)||
- (Qualified2.IsOutside() && angle2 >= 0) ||
- (Qualified2.IsEnclosed() && angle2 <= 0.)) {
- qualifier1 = Qualified1.Qualifier();
- qualifier2 = Qualified2.Qualifier();
- pnttg1sol = point1;
- pararg1 = Ufirst(1);
- par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
- pnttg2sol = point2;
- pararg2 = Ufirst(2);
- par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
- pntcen = point3;
- parcen3 = Ufirst(3);
- WellDone = Standard_True;
- }
- }
- }
- }
- }
-
-GccIter_Circ2d2TanOn::
- GccIter_Circ2d2TanOn (const TheQualifiedCurve& Qualified1 ,
- const gp_Pnt2d& Point2 ,
- const gp_Lin2d& OnLine ,
- const Standard_Real Param1 ,
- const Standard_Real Param2 ,
- const Standard_Real Tolerance ) {
- TheSame1 = Standard_False;
- TheSame2 = Standard_False;
- par1sol = 0.;
- par2sol = 0.;
- pararg1 = 0.;
- pararg2 = 0.;
- parcen3 = 0.;
-
- WellDone = Standard_False;
- if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
- Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- Standard_Real Tol = Abs(Tolerance);
- gp_Dir2d dirx(1.,0.);
- TheCurve Cu1 = Qualified1.Qualified();
- math_Vector Umin(1,3);
- math_Vector Umax(1,3);
- math_Vector Ufirst(1,3);
- math_Vector tol(1,3);
- Umin(1) = TheCurveTool::FirstParameter(Cu1);
- Umin(2) = RealFirst();
- Umin(3) = 0.;
- Umax(1) = TheCurveTool::LastParameter(Cu1);
- Umax(2) = RealLast();
- Umax(3) = RealLast();
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
- tol(2) = 1.e-15;
- tol(3) = Tol/10.;
- gp_Pnt2d point1 = TheCurveTool::Value(Cu1,Param1);
- gp_Pnt2d point3 = ElCLib::Value(Param2,OnLine);
- Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
- GccIter_FuncTCuCuOnCu Func(Cu1,Point2,OnLine,Ufirst(3));
- math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
- Func.Value(Ufirst,Umin);
- if (Root.IsDone()) {
- Root.Root(Ufirst);
- gp_Pnt2d point1,point3;
- gp_Vec2d Tan1,Tan3;
- TheCurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
- ElCLib::D1(Ufirst(2),OnLine,point3,Tan3);
- Standard_Real dist1 = point3.Distance(point1);
- Standard_Real dist2 = point3.Distance(Point2);
- if ( Abs(dist1-dist2)/2. <= Tol) {
- cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
- Standard_Real normetan1 = Tan1.Magnitude();
- gp_Vec2d Vec1(point1,point3);
- Standard_Real normevec1 = Vec1.Magnitude();
- Standard_Real angle1;
- if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
- angle1 = Vec1.Angle(Tan1);
- }
- else { angle1 = 0.; }
- if (Qualified1.IsUnqualified()||
- (Qualified1.IsEnclosing()&&angle1<=0.)||
- (Qualified1.IsOutside() && angle1 >= 0.) ||
- (Qualified1.IsEnclosed() && angle1 <= 0.)) {
- qualifier1 = Qualified1.Qualifier();
- qualifier2 = GccEnt_noqualifier;
- pnttg1sol = point1;
- pararg1 = Ufirst(1);
- par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
- pnttg2sol = Point2;
- pararg2 = Ufirst(2);
- par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
- pntcen = point3;
- parcen3 = Ufirst(3);
- WellDone = Standard_True;
- }
- }
- }
- }
-
-GccIter_Circ2d2TanOn::
- GccIter_Circ2d2TanOn (const GccEnt_QualifiedCirc& Qualified1 ,
- const TheQualifiedCurve& Qualified2 ,
- const gp_Lin2d& OnLine ,
- const Standard_Real Param1 ,
- const Standard_Real Param2 ,
- const Standard_Real Param3 ,
- const Standard_Real Tolerance ) {
- TheSame1 = Standard_False;
- TheSame2 = Standard_False;
- par1sol = 0.;
- par2sol = 0.;
- pararg1 = 0.;
- pararg2 = 0.;
- parcen3 = 0.;
-
- WellDone = Standard_False;
- if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
- Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
- !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
- Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- Standard_Real Tol = Abs(Tolerance);
- gp_Dir2d dirx(1.,0.);
- gp_Circ2d C1 = Qualified1.Qualified();
- Standard_Real R1 = C1.Radius();
- TheCurve Cu2 = Qualified2.Qualified();
- math_Vector Umin(1,4);
- math_Vector Umax(1,4);
- math_Vector Ufirst(1,4);
- math_Vector tol(1,4);
- Umin(1) = RealFirst();
- Umin(2) = TheCurveTool::FirstParameter(Cu2);
- Umin(3) = RealFirst();
- Umin(4) = 0.;
- Umax(1) = RealLast();
- Umax(2) = TheCurveTool::LastParameter(Cu2);
- Umax(3) = RealLast();
- Umax(4) = RealLast();
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- Ufirst(3) = Param3;
- tol(1) = 2.e-15*M_PI;
- tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
- tol(3) = 1.e-15;
- tol(4) = Tol/10.;
- gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
- gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
- gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
- Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
- GccIter_FuncTCuCuOnCu Func(C1,Cu2,OnLine,Ufirst(4));
- math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
- Func.Value(Ufirst,Umin);
- if (Root.IsDone()) {
- Root.Root(Ufirst);
-// gp_Vec2d Tan1,Tan2,Nor1,Nor2;
- gp_Vec2d Tan1,Tan2,Nor2;
- ElCLib::D2(Ufirst(1),C1,point1,Tan1,Nor2);
- TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-#ifdef DEB
- gp_Vec2d Tan3(OnLine.Direction().XY());
-#else
- OnLine.Direction().XY();
-#endif
- point3 = ElCLib::Value(Ufirst(1),OnLine);
- Standard_Real dist1 = point3.Distance(point1);
- Standard_Real dist2 = point3.Distance(point2);
- if ( Abs(dist1-dist2)/2. <= Tol) {
- cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
- Standard_Real normetan2 = Tan2.Magnitude();
- gp_Vec2d Vec1(point1,point3);
- gp_Vec2d Vec2(point2,point3);
- Standard_Real normevec2 = Vec2.Magnitude();
- Standard_Real angle2;
- if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
- angle2 = Vec2.Angle(Tan2);
- }
- else { angle2 = 0.; }
- Standard_Real dist = C1.Location().Distance(point3);
- Standard_Real Rsol = cirsol.Radius();
- if (Qualified1.IsUnqualified() ||
- (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
- (Qualified1.IsOutside() && dist >= Rsol) ||
- (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
- if (Qualified2.IsUnqualified() ||
- (Qualified2.IsEnclosing()&&angle2<=0.)||
- (Qualified2.IsOutside() && angle2 >= 0) ||
- (Qualified2.IsEnclosed() && angle2 <= 0.)) {
- qualifier1 = Qualified1.Qualifier();
- qualifier2 = Qualified2.Qualifier();
- pnttg1sol = point1;
- pararg1 = Ufirst(1);
- par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
- pnttg2sol = point2;
- pararg2 = Ufirst(2);
- par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
- pntcen = point3;
- parcen3 = Ufirst(3);
- WellDone = Standard_True;
- }
- }
- }
- }
- }
-
-GccIter_Circ2d2TanOn::
- GccIter_Circ2d2TanOn (const GccEnt_QualifiedCirc& Qualified1 ,
- const TheQualifiedCurve& Qualified2 ,
- const gp_Circ2d& OnCirc ,
- const Standard_Real Param1 ,
- const Standard_Real Param2 ,
- const Standard_Real Param3 ,
- const Standard_Real Tolerance ) {
- TheSame1 = Standard_False;
- TheSame2 = Standard_False;
- par1sol = 0.;
- par2sol = 0.;
- pararg1 = 0.;
- pararg2 = 0.;
- parcen3 = 0.;
-
- WellDone = Standard_False;
- if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
- Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
- !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
- Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- Standard_Real Tol = Abs(Tolerance);
- gp_Dir2d dirx(1.,0.);
- gp_Circ2d C1 = Qualified1.Qualified();
- Standard_Real R1 = C1.Radius();
- TheCurve Cu2 = Qualified2.Qualified();
- math_Vector Umin(1,4);
- math_Vector Umax(1,4);
- math_Vector Ufirst(1,4);
- math_Vector tol(1,4);
- Umin(1) = RealFirst();
- Umin(2) = TheCurveTool::FirstParameter(Cu2);
- Umin(3) = RealFirst();
- Umin(4) = 0.;
- Umax(1) = RealLast();
- Umax(2) = TheCurveTool::LastParameter(Cu2);
- Umax(3) = RealLast();
- Umax(4) = RealLast();
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- Ufirst(3) = Param3;
- tol(1) = 2.e-15*M_PI;
- tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
- tol(3) = 2.e-15*M_PI;
- tol(4) = Tol/10.;
- gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
- gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
- gp_Pnt2d point3 = ElCLib::Value(Param3,OnCirc);
- Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
- GccIter_FuncTCuCuOnCu Func(C1,Cu2,OnCirc,Ufirst(4));
- math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
- Func.Value(Ufirst,Umin);
- if (Root.IsDone()) {
- Root.Root(Ufirst);
-// gp_Vec2d Tan1,Tan2,Nor1;
- gp_Vec2d Tan1,Tan2;
- ElCLib::D1(Ufirst(1),C1,point1,Tan1);
- TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-#ifdef DEB
- gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
-#endif
- point3 = ElCLib::Value(Ufirst(3),OnCirc);
- Standard_Real dist1 = point3.Distance(point1);
- Standard_Real dist2 = point3.Distance(point2);
- if ( Abs(dist1-dist2)/2. <= Tol) {
- cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
- Standard_Real normetan2 = Tan2.Magnitude();
- gp_Vec2d Vec1(point1,point3);
- gp_Vec2d Vec2(point2,point3);
- Standard_Real normevec2 = Vec2.Magnitude();
- Standard_Real angle2;
- if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
- angle2 = Vec2.Angle(Tan2);
- }
- else { angle2 = 0.; }
- Standard_Real dist = C1.Location().Distance(point3);
- Standard_Real Rsol = cirsol.Radius();
- if (Qualified1.IsUnqualified() ||
- (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
- (Qualified1.IsOutside() && dist >= Rsol) ||
- (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
- if (Qualified2.IsUnqualified() ||
- (Qualified2.IsEnclosing()&&angle2<=0.)||
- (Qualified2.IsOutside() && angle2 >= 0) ||
- (Qualified2.IsEnclosed() && angle2 <= 0.)) {
- qualifier1 = Qualified1.Qualifier();
- qualifier2 = Qualified2.Qualifier();
- pnttg1sol = point1;
- pararg1 = Ufirst(1);
- par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
- pnttg2sol = point2;
- pararg2 = Ufirst(2);
- par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
- pntcen = point3;
- parcen3 = Ufirst(3);
- WellDone = Standard_True;
- }
- }
- }
- }
- }
-
-GccIter_Circ2d2TanOn::
- GccIter_Circ2d2TanOn (const GccEnt_QualifiedLin& Qualified1 ,
- const TheQualifiedCurve& Qualified2 ,
- const gp_Circ2d& OnCirc ,
- const Standard_Real Param1 ,
- const Standard_Real Param2 ,
- const Standard_Real Param3 ,
- const Standard_Real Tolerance ) {
- TheSame1 = Standard_False;
- TheSame2 = Standard_False;
- par1sol = 0.;
- par2sol = 0.;
- pararg1 = 0.;
- pararg2 = 0.;
- parcen3 = 0.;
-
- WellDone = Standard_False;
- if (!(Qualified1.IsEnclosed() ||
- Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
- !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
- Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- Standard_Real Tol = Abs(Tolerance);
- gp_Dir2d dirx(1.,0.);
- gp_Lin2d L1 = Qualified1.Qualified();
- TheCurve Cu2 = Qualified2.Qualified();
- math_Vector Umin(1,4);
- math_Vector Umax(1,4);
- math_Vector Ufirst(1,4);
- math_Vector tol(1,4);
- Umin(1) = RealFirst();
- Umin(2) = TheCurveTool::FirstParameter(Cu2);
- Umin(3) = RealFirst();
- Umin(4) = 0.;
- Umax(1) = RealLast();
- Umax(2) = TheCurveTool::LastParameter(Cu2);
- Umax(3) = RealLast();
- Umax(4) = RealLast();
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- Ufirst(3) = Param3;
- tol(1) = 1.e-15;
- tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
- tol(3) = 2.e-15*M_PI;
- tol(4) = Tol/10.;
- gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
- gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
- gp_Pnt2d point3 = ElCLib::Value(Param3,OnCirc);
- Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
- GccIter_FuncTCuCuOnCu Func(L1,Cu2,OnCirc,Ufirst(4));
- math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
- Func.Value(Ufirst,Umin);
- if (Root.IsDone()) {
- Root.Root(Ufirst);
- gp_Pnt2d point1,point2;
- gp_Vec2d Tan1,Tan2;
- ElCLib::D1(Ufirst(1),L1,point1,Tan1);
- TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-#ifdef DEB
- gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
-#endif
- point3 = ElCLib::Value(Ufirst(3),OnCirc);
- Standard_Real dist1 = point3.Distance(point1);
- Standard_Real dist2 = point3.Distance(point2);
- if ( Abs(dist1-dist2)/2. <= Tol) {
- cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
- Standard_Real normetan2 = Tan2.Magnitude();
- gp_Vec2d Vec1(point1,point3);
- gp_Vec2d Vec2(point2,point3);
- Standard_Real normevec2 = Vec2.Magnitude();
- Standard_Real angle2;
- if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
- angle2 = Vec2.Angle(Tan2);
- }
- else { angle2 = 0.; }
- Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
- L1.Direction().X()));
- if (Qualified1.IsUnqualified() ||
- (Qualified1.IsOutside() && pscal <= 0.) ||
- (Qualified1.IsEnclosed() && pscal >= 0.)) {
- if (Qualified2.IsUnqualified() ||
- (Qualified2.IsEnclosing()&&angle2<=0.)||
- (Qualified2.IsOutside() && angle2 >= 0) ||
- (Qualified2.IsEnclosed() && angle2 <= 0.)) {
- qualifier1 = Qualified1.Qualifier();
- qualifier2 = Qualified2.Qualifier();
- pnttg1sol = point1;
- pararg1 = Ufirst(1);
- par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
- pnttg2sol = point2;
- pararg2 = Ufirst(2);
- par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
- pntcen = point3;
- parcen3 = Ufirst(3);
- WellDone = Standard_True;
- }
- }
- }
- }
- }
-
-GccIter_Circ2d2TanOn::
- GccIter_Circ2d2TanOn (const TheQualifiedCurve& Qualified1 ,
- const TheQualifiedCurve& Qualified2 ,
- const gp_Circ2d& OnCirc ,
- const Standard_Real Param1 ,
- const Standard_Real Param2 ,
- const Standard_Real Param3 ,
- const Standard_Real Tolerance ) {
- TheSame1 = Standard_False;
- TheSame2 = Standard_False;
- par1sol = 0.;
- par2sol = 0.;
- pararg1 = 0.;
- pararg2 = 0.;
- parcen3 = 0.;
-
- WellDone = Standard_False;
- if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
- Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
- !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
- Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- Standard_Real Tol = Abs(Tolerance);
- gp_Dir2d dirx(1.,0.);
- TheCurve Cu1 = Qualified1.Qualified();
- TheCurve Cu2 = Qualified2.Qualified();
- math_Vector Umin(1,4);
- math_Vector Umax(1,4);
- math_Vector Ufirst(1,4);
- math_Vector tol(1,4);
- Umin(1) = TheCurveTool::FirstParameter(Cu1);
- Umin(2) = TheCurveTool::FirstParameter(Cu2);
- Umin(3) = RealFirst();
- Umin(4) = 0.;
- Umax(1) = TheCurveTool::LastParameter(Cu1);
- Umax(2) = TheCurveTool::LastParameter(Cu2);
- Umax(3) = RealLast();
- Umax(4) = RealLast();
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- Ufirst(3) = Param3;
- tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
- tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
- tol(3) = 2.e-15*M_PI;
- tol(4) = Tol/10.;
- gp_Pnt2d point1 = TheCurveTool::Value(Cu1,Param1);
- gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
- Standard_Real R1 = OnCirc.Radius();
- gp_Pnt2d point3(OnCirc.Location().XY()+R1*gp_XY(Cos(Param3),Sin(Param3)));
- Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
- GccIter_FuncTCuCuOnCu Func(Cu1,Cu2,OnCirc,Ufirst(4));
- math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
- Func.Value(Ufirst,Umin);
- if (Root.IsDone()) {
- Root.Root(Ufirst);
-// gp_Vec2d Tan1,Tan2,Nor1;
- gp_Vec2d Tan1,Tan2;
- TheCurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
- TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
-#ifdef DEB
- gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
-#endif
- point3 = gp_Pnt2d(OnCirc.Location().XY()+
- R1*gp_XY(Cos(Ufirst(3)),Sin(Ufirst(3))));
- Standard_Real dist1 = point3.Distance(point1);
- Standard_Real dist2 = point3.Distance(point2);
- if ( Abs(dist1-dist2)/2. <= Tol) {
- cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
- Standard_Real normetan1 = Tan1.Magnitude();
- Standard_Real normetan2 = Tan2.Magnitude();
- gp_Vec2d Vec1(point1,point3);
- gp_Vec2d Vec2(point2,point3);
- Standard_Real normevec1 = Vec1.Magnitude();
- Standard_Real normevec2 = Vec2.Magnitude();
- Standard_Real angle1,angle2;
- if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
- angle1 = Vec1.Angle(Tan1);
- }
- else { angle1 = 0.; }
- if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
- angle2 = Vec2.Angle(Tan2);
- }
- else { angle2 = 0.; }
- if (Qualified1.IsUnqualified()||
- (Qualified1.IsEnclosing()&&angle1<=0.)||
- (Qualified1.IsOutside() && angle1 >= 0.) ||
- (Qualified1.IsEnclosed() && angle1 <= 0.)) {
- if (Qualified2.IsUnqualified() ||
- (Qualified2.IsEnclosing()&&angle2<=0.)||
- (Qualified2.IsOutside() && angle2 >= 0) ||
- (Qualified2.IsEnclosed() && angle2 <= 0.)) {
- qualifier1 = Qualified1.Qualifier();
- qualifier2 = Qualified2.Qualifier();
- pararg1 = Ufirst(1);
- par1sol = 0.;
- pnttg1sol = point1;
- pararg2 = Ufirst(2);
- pnttg2sol = point2;
- par2sol = pnttg2sol.Distance(pnttg1sol);
- pntcen = point3;
- parcen3 = Ufirst(3);
- WellDone = Standard_True;
- }
- }
- }
- }
- }
-
-GccIter_Circ2d2TanOn::
- GccIter_Circ2d2TanOn (const TheQualifiedCurve& Qualified1 ,
- const gp_Pnt2d& Point2 ,
- const gp_Circ2d& OnCirc ,
- const Standard_Real Param1 ,
- const Standard_Real Param2 ,
- const Standard_Real Tolerance ) {
- TheSame1 = Standard_False;
- TheSame2 = Standard_False;
- par1sol = 0.;
- par2sol = 0.;
- pararg1 = 0.;
- pararg2 = 0.;
- parcen3 = 0.;
-
- WellDone = Standard_False;
- if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
- Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- Standard_Real Tol = Abs(Tolerance);
- gp_Dir2d dirx(1.,0.);
- TheCurve Cu1 = Qualified1.Qualified();
- math_Vector Umin(1,3);
- math_Vector Umax(1,3);
- math_Vector Ufirst(1,3);
- math_Vector tol(1,3);
- Umin(1) = TheCurveTool::FirstParameter(Cu1);
- Umin(2) = RealFirst();
- Umin(3) = 0.;
- Umax(1) = TheCurveTool::LastParameter(Cu1);
- Umax(2) = RealLast();
- Umax(3) = RealLast();
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
- tol(2) = 2.e-15*M_PI;
- tol(3) = Tol/10.;
- gp_Pnt2d point1 = TheCurveTool::Value(Cu1,Param1);
- gp_Pnt2d point3 = ElCLib::Value(Param2,OnCirc);
- Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
- GccIter_FuncTCuCuOnCu Func(Cu1,Point2,OnCirc,Ufirst(3));
- math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
- Func.Value(Ufirst,Umin);
- if (Root.IsDone()) {
- Root.Root(Ufirst);
- gp_Pnt2d point1,point3;
- gp_Vec2d Tan1,Tan3;
- TheCurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
- ElCLib::D1(Ufirst(2),OnCirc,point3,Tan3);
- Standard_Real dist1 = point3.Distance(point1);
- Standard_Real dist2 = point3.Distance(Point2);
- if ( Abs(dist1-dist2)/2. <= Tol) {
- cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
- Standard_Real normetan1 = Tan1.Magnitude();
- gp_Vec2d Vec1(point1,point3);
- Standard_Real normevec1 = Vec1.Magnitude();
- Standard_Real angle1;
- if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
- angle1 = Vec1.Angle(Tan1);
- }
- else { angle1 = 0.; }
- if (Qualified1.IsUnqualified()||
- (Qualified1.IsEnclosing()&&angle1<=0.)||
- (Qualified1.IsOutside() && angle1 >= 0.) ||
- (Qualified1.IsEnclosed() && angle1 <= 0.)) {
- qualifier1 = Qualified1.Qualifier();
- qualifier2 = GccEnt_noqualifier;
- pnttg1sol = point1;
- pararg1 = Ufirst(1);
- par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
- pnttg2sol = Point2;
- pararg2 = 0.;
- par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
- pntcen = point3;
- parcen3 = Ufirst(3);
- WellDone = Standard_True;
- }
- }
- }
- }
-
-GccIter_Circ2d2TanOn::
- GccIter_Circ2d2TanOn (const TheQualifiedCurve& Qualified1 ,
- const TheQualifiedCurve& Qualified2 ,
- const TheCurve& OnCurv ,
- const Standard_Real Param1 ,
- const Standard_Real Param2 ,
- const Standard_Real Param3 ,
- const Standard_Real Tolerance ) {
- TheSame1 = Standard_False;
- TheSame2 = Standard_False;
- par1sol = 0.;
- par2sol = 0.;
- pararg1 = 0.;
- pararg2 = 0.;
- parcen3 = 0.;
-
- WellDone = Standard_False;
- 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())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- gp_Dir2d dirx(1.,0.);
- TheCurve Cu1 = Qualified1.Qualified();
- TheCurve Cu2 = Qualified2.Qualified();
- math_Vector Umin(1,4);
- math_Vector Umax(1,4);
- math_Vector Ufirst(1,4);
- math_Vector tol(1,4);
- Umin(1) = TheCurveTool::FirstParameter(Cu1);
- Umin(2) = TheCurveTool::FirstParameter(Cu2);
- Umin(3) = TheCurveTool::FirstParameter(OnCurv);
- Umin(4) = 0.;
- Umax(1) = TheCurveTool::LastParameter(Cu1);
- Umax(2) = TheCurveTool::LastParameter(Cu2);
- Umax(3) = TheCurveTool::LastParameter(OnCurv);
- Umax(4) = RealLast();
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- Ufirst(3) = Param3;
- tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
- tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
- tol(3) = TheCurveTool::EpsX(OnCurv,Abs(Tolerance));
- tol(4) = Tol/10.;
- gp_Pnt2d point1 = TheCurveTool::Value(Cu1,Param1);
- gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
- gp_Pnt2d point3 = TheCurveTool::Value(OnCurv,Param3);
- Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
- GccIter_FuncTCuCuOnCu Func(Cu1,Cu2,OnCurv,Ufirst(4));
- math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
- Func.Value(Ufirst,Umin);
- if (Root.IsDone()) {
- Root.Root(Ufirst);
- gp_Vec2d Tan1,Tan2,Tan3;
- TheCurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
- TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
- TheCurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
- Standard_Real dist1 = point3.Distance(point1);
- Standard_Real dist2 = point3.Distance(point2);
- if ( Abs(dist1-dist2)/2. <= Tol) {
- cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
- Standard_Real normetan1 = Tan1.Magnitude();
- Standard_Real normetan2 = Tan2.Magnitude();
- gp_Vec2d Vec1(point1,point3);
- gp_Vec2d Vec2(point2,point3);
- Standard_Real normevec1 = Vec1.Magnitude();
- Standard_Real normevec2 = Vec2.Magnitude();
- Standard_Real angle1,angle2;
- if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
- angle1 = Vec1.Angle(Tan1);
- }
- else { angle1 = 0.; }
- if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
- angle2 = Vec2.Angle(Tan2);
- }
- else { angle2 = 0.; }
- if (Qualified1.IsUnqualified()||
- (Qualified1.IsEnclosing()&&angle1<=0.)||
- (Qualified1.IsOutside() && angle1 >= 0.) ||
- (Qualified1.IsEnclosed() && angle1 <= 0.)) {
- if (Qualified2.IsUnqualified() ||
- (Qualified2.IsEnclosing()&&angle2<=0.)||
- (Qualified2.IsOutside() && angle2 >= 0) ||
- (Qualified2.IsEnclosed() && angle2 <= 0.)) {
- qualifier1 = Qualified1.Qualifier();
- qualifier2 = Qualified2.Qualifier();
- pararg1 = Ufirst(1);
- par1sol = 0.;
- pnttg1sol = point1;
- pararg2 = Ufirst(2);
- pnttg2sol = point2;
- par2sol = pnttg2sol.Distance(pnttg1sol);
- pntcen = point3;
- parcen3 = Ufirst(3);
- WellDone = Standard_True;
- }
- }
- }
- }
- }
-
-GccIter_Circ2d2TanOn::
- GccIter_Circ2d2TanOn (const GccEnt_QualifiedCirc& Qualified1 ,
- const TheQualifiedCurve& Qualified2 ,
- const TheCurve& OnCurv ,
- const Standard_Real Param1 ,
- const Standard_Real Param2 ,
- const Standard_Real ParamOn ,
- const Standard_Real Tolerance ) {
-
- TheSame1 = Standard_False;
- TheSame2 = Standard_False;
- par1sol = 0.;
- par2sol = 0.;
- pararg1 = 0.;
- pararg2 = 0.;
- parcen3 = 0.;
-
- WellDone = Standard_False;
- if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
- Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
- !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
- Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- Standard_Real Tol = Abs(Tolerance);
- gp_Circ2d C1 = Qualified1.Qualified();
- Standard_Real R1 = C1.Radius();
- TheCurve Cu2 = Qualified2.Qualified();
- math_Vector Umin(1,4);
- math_Vector Umax(1,4);
- math_Vector Ufirst(1,4);
- math_Vector tol(1,4);
- Umin(1) = RealFirst();
- Umin(2) = TheCurveTool::FirstParameter(Cu2);
- Umin(3) = TheCurveTool::FirstParameter(OnCurv);
- Umin(4) = 0.;
- Umax(1) = RealLast();
- Umax(2) = TheCurveTool::LastParameter(Cu2);
- Umax(3) = TheCurveTool::LastParameter(OnCurv);
- Umax(4) = RealLast();
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- Ufirst(3) = ParamOn;
- tol(1) = 2.e-15*M_PI;
- tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
- tol(3) = TheCurveTool::EpsX(OnCurv,Abs(Tolerance));
- tol(4) = Tol/10.;;
- gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
- gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
- gp_Pnt2d point3 = TheCurveTool::Value(OnCurv,ParamOn);
- Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
- GccIter_FuncTCuCuOnCu Func(C1,Cu2,OnCurv,Ufirst(4));
- math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
- Func.Value(Ufirst,Umin);
- if (Root.IsDone()) {
- Root.Root(Ufirst);
- gp_Vec2d Tan1,Tan2,Tan3;
- TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
- TheCurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
- ElCLib::D1(Ufirst(1),C1,point1,Tan1);
- Standard_Real dist1 = point3.Distance(point1);
- Standard_Real dist2 = point3.Distance(point2);
- if ( Abs(dist1-dist2)/2. <= Tol) {
- gp_Dir2d dirx(1.,0.);
- cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
- Standard_Real normetan2 = Tan2.Magnitude();
- gp_Vec2d Vec1(point1.XY(),point3.XY());
- gp_Vec2d Vec2(point2.XY(),point3.XY());
- Standard_Real normevec2 = Vec2.Magnitude();
- Standard_Real angle2;
- if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
- angle2 = Vec2.Angle(Tan2);
- }
- else { angle2 = 0.; }
- Standard_Real dist = C1.Location().Distance(point3);
- Standard_Real Rsol = cirsol.Radius();
- if (Qualified1.IsUnqualified() ||
- (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
- (Qualified1.IsOutside() && dist >= Rsol) ||
- (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
- if (Qualified2.IsUnqualified() ||
- (Qualified2.IsEnclosing()&&angle2<=0.)||
- (Qualified2.IsOutside() && angle2 >= 0) ||
- (Qualified2.IsEnclosed() && angle2 <= 0.)) {
- qualifier1 = Qualified1.Qualifier();
- qualifier2 = Qualified2.Qualifier();
- pnttg1sol = point1;
- pararg1 = Ufirst(1);
- par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
- pnttg2sol = point2;
- pararg2 = Ufirst(2);
- par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
- pntcen = point3;
- parcen3 = Ufirst(3);
- WellDone = Standard_True;
- }
- }
- }
- }
- }
-
-GccIter_Circ2d2TanOn::
- GccIter_Circ2d2TanOn (const GccEnt_QualifiedLin& Qualified1 ,
- const TheQualifiedCurve& Qualified2 ,
- const TheCurve& OnCurv ,
- const Standard_Real Param1 ,
- const Standard_Real Param2 ,
- const Standard_Real ParamOn ,
- const Standard_Real Tolerance ) {
- TheSame1 = Standard_False;
- TheSame2 = Standard_False;
- par1sol = 0.;
- par2sol = 0.;
- pararg1 = 0.;
- pararg2 = 0.;
- parcen3 = 0.;
-
- WellDone = Standard_False;
- if (!(Qualified1.IsEnclosed() ||
- Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
- !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
- Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- Standard_Real Tol = Abs(Tolerance);
- gp_Dir2d dirx(1.,0.);
- gp_Lin2d L1 = Qualified1.Qualified();
- TheCurve Cu2 = Qualified2.Qualified();
- math_Vector Umin(1,4);
- math_Vector Umax(1,4);
- math_Vector Ufirst(1,4);
- math_Vector tol(1,4);
- Umin(1) = RealFirst();
- Umin(2) = TheCurveTool::FirstParameter(Cu2);
- Umin(3) = TheCurveTool::FirstParameter(OnCurv);
- Umin(4) = 0.;
- Umax(1) = RealLast();
- Umax(2) = TheCurveTool::LastParameter(Cu2);
- Umax(3) = TheCurveTool::LastParameter(OnCurv);
- Umax(4) = RealLast();
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- Ufirst(3) = ParamOn;
- tol(1) = 1.e-15;
- tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
- tol(3) = TheCurveTool::EpsX(OnCurv,Abs(Tolerance));
- tol(4) = Tol/10.;
- gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
- gp_Pnt2d point2 = TheCurveTool::Value(Cu2,Param2);
- gp_Pnt2d point3 = TheCurveTool::Value(OnCurv,ParamOn);
- Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
- GccIter_FuncTCuCuOnCu Func(L1,Cu2,OnCurv,Ufirst(4));
- math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
- Func.Value(Ufirst,Umin);
- if (Root.IsDone()) {
- Root.Root(Ufirst);
- gp_Vec2d Tan1,Tan2,Tan3;
- ElCLib::D1(Ufirst(1),L1,point1,Tan1);
- TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
- TheCurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
- Standard_Real dist1 = point3.Distance(point1);
- Standard_Real dist2 = point3.Distance(point2);
- if ( Abs(dist1-dist2)/2. <= Tol) {
- cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
- Standard_Real normetan2 = Tan2.Magnitude();
- gp_Vec2d Vec1(point1,point3);
- gp_Vec2d Vec2(point2,point3);
- Standard_Real normevec2 = Vec2.Magnitude();
- Standard_Real angle2;
- if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
- angle2 = Vec2.Angle(Tan2);
- }
- else { angle2 = 0.; }
- Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
- L1.Direction().X()));
- if (Qualified1.IsUnqualified() ||
- (Qualified1.IsOutside() && pscal <= 0.) ||
- (Qualified1.IsEnclosed() && pscal >= 0.)) {
- if (Qualified2.IsUnqualified() ||
- (Qualified2.IsEnclosing()&&angle2<=0.)||
- (Qualified2.IsOutside() && angle2 >= 0) ||
- (Qualified2.IsEnclosed() && angle2 <= 0.)) {
- qualifier1 = Qualified1.Qualifier();
- qualifier2 = Qualified2.Qualifier();
- pnttg1sol = point1;
- pararg1 = Ufirst(1);
- par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
- pnttg2sol = point2;
- pararg2 = Ufirst(2);
- par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
- pntcen = point3;
- parcen3 = Ufirst(3);
- WellDone = Standard_True;
- }
- }
- }
- }
- }
-
-GccIter_Circ2d2TanOn::
- GccIter_Circ2d2TanOn (const TheQualifiedCurve& Qualified1 ,
- const gp_Pnt2d& Point2 ,
- const TheCurve& OnCurv ,
- const Standard_Real Param1 ,
- const Standard_Real ParamOn ,
- const Standard_Real Tolerance )
-{
- TheSame1 = Standard_False;
- TheSame2 = Standard_False;
- par1sol = 0.;
- par2sol = 0.;
- pararg1 = 0.;
- pararg2 = 0.;
- parcen3 = 0.;
-
- WellDone = Standard_False;
- if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
- Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- Standard_Real Tol = Abs(Tolerance);
- gp_Dir2d dirx(1.,0.);
- TheCurve Cu1 = Qualified1.Qualified();
- math_Vector Umin(1,3);
- math_Vector Umax(1,3);
- math_Vector Ufirst(1,3);
- math_Vector tol(1,3);
- Umin(1) = TheCurveTool::FirstParameter(Cu1);
- Umin(2) = RealFirst();
- Umin(3) = TheCurveTool::FirstParameter(OnCurv);
- Umax(1) = TheCurveTool::LastParameter(Cu1);
- Umax(2) = RealLast();
- Umax(3) = TheCurveTool::LastParameter(OnCurv);
- Ufirst(1) = Param1;
- Ufirst(2) = ParamOn;
- tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
- tol(2) = TheCurveTool::EpsX(OnCurv,Abs(Tolerance));
- tol(3) = Tol/10.;
- gp_Pnt2d point1 = TheCurveTool::Value(Cu1,Param1);
- gp_Pnt2d point3 = TheCurveTool::Value(OnCurv,ParamOn);
- Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
- GccIter_FuncTCuCuOnCu Func(Cu1,Point2,OnCurv,Ufirst(3));
- math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
- Func.Value(Ufirst,Umin);
- if (Root.IsDone()) {
- Root.Root(Ufirst);
-// gp_Vec2d Tan1,Tan2,Tan3;
- gp_Vec2d Tan1,Tan3;
- TheCurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
- TheCurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
- Standard_Real dist1 = point3.Distance(point1);
- Standard_Real dist2 = point3.Distance(Point2);
- if ( Abs(dist1-dist2)/2. <= Tol) {
- cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
- Standard_Real normetan1 = Tan1.Magnitude();
- gp_Vec2d Vec1(point1,point3);
- Standard_Real normevec1 = Vec1.Magnitude();
- Standard_Real angle1;
- if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
- angle1 = Vec1.Angle(Tan1);
- }
- else { angle1 = 0.; }
- if (Qualified1.IsUnqualified()||
- (Qualified1.IsEnclosing()&&angle1<=0.)||
- (Qualified1.IsOutside() && angle1 >= 0.) ||
- (Qualified1.IsEnclosed() && angle1 <= 0.)) {
- qualifier1 = Qualified1.Qualifier();
- qualifier2 = GccEnt_noqualifier;
- pnttg1sol = point1;
- pararg1 = Ufirst(1);
- par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
- pnttg2sol = Point2;
- pararg2 = 0.;
- par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
- pntcen = point3;
- parcen3 = Ufirst(3);
- WellDone = Standard_True;
- }
- }
- }
-}
-
-Standard_Boolean GccIter_Circ2d2TanOn::
- IsDone () const{ return WellDone; }
-
-gp_Circ2d GccIter_Circ2d2TanOn::
- ThisSolution () const{ return cirsol; }
-
-void GccIter_Circ2d2TanOn::
- WhichQualifier (GccEnt_Position& Qualif1 ,
- GccEnt_Position& Qualif2 ) const
-{
- if (!WellDone) { StdFail_NotDone::Raise(); }
- else {
- Qualif1 = qualifier1;
- Qualif2 = qualifier2;
- }
-}
-
-void GccIter_Circ2d2TanOn::
- Tangency1 (Standard_Real& ParSol ,
- Standard_Real& ParArg ,
- gp_Pnt2d& PntSol ) const
-{
- if (!WellDone) { StdFail_NotDone::Raise(); }
- else {
- if (TheSame1 == 0) {
- ParSol = 0;
- ParArg = 0;
- PntSol = pnttg1sol;
- }
- else { StdFail_NotDone::Raise(); }
- }
-}
-
-void GccIter_Circ2d2TanOn::
- Tangency2 (Standard_Real& ParSol ,
- Standard_Real& ParArg ,
- gp_Pnt2d& PntSol ) const
-{
- if (!WellDone) { StdFail_NotDone::Raise(); }
- else {
- ParSol = 0;
- ParArg = 0;
- PntSol = pnttg2sol;
- }
-}
-
-void GccIter_Circ2d2TanOn::
- CenterOn3 (Standard_Real& ParArg ,
- gp_Pnt2d& PntSol ) const
-{
- if (!WellDone) { StdFail_NotDone::Raise(); }
- else {
- ParArg = 0;
- PntSol = pntcen;
- }
-}
-
-Standard_Boolean GccIter_Circ2d2TanOn::
- IsTheSame1 () const
-{
- if (!WellDone) StdFail_NotDone::Raise();
-
- if (TheSame1 == 0)
- return Standard_False;
- return Standard_True;
-}
-
-
-Standard_Boolean GccIter_Circ2d2TanOn::
- IsTheSame2 () const
-{
- if (!WellDone) StdFail_NotDone::Raise();
- return Standard_False;
-}
+++ /dev/null
-// 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 <gp_Dir2d.hxx>
-#include <gp_Ax2d.hxx>
-#include <gp_Vec2d.hxx>
-#include <gp.hxx>
-#include <StdFail_NotDone.hxx>
-#include <GccEnt_BadQualifier.hxx>
-#include <math_FunctionSetRoot.hxx>
-#include <math_NewtonFunctionSetRoot.hxx>
-#include <GccAna_Circ2d3Tan.hxx>
-
-GccIter_Circ2d3Tan::
- GccIter_Circ2d3Tan (const TheQualifiedCurve& Qualified1 ,
- const TheQualifiedCurve& Qualified2 ,
- const TheQualifiedCurve& 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())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- TheCurve Cu1 = Qualified1.Qualified();
- TheCurve Cu2 = Qualified2.Qualified();
- TheCurve Cu3 = Qualified3.Qualified();
- GccIter_FuncTCuCuCu 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) = TheCurveTool::FirstParameter(Cu1);
- Umin(2) = TheCurveTool::FirstParameter(Cu2);
- Umin(3) = TheCurveTool::FirstParameter(Cu3);
- Umax(1) = TheCurveTool::LastParameter(Cu1);
- Umax(2) = TheCurveTool::LastParameter(Cu2);
- Umax(3) = TheCurveTool::LastParameter(Cu3);
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- Ufirst(3) = Param3;
- tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
- tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
- tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));
- math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
- if (Root.IsDone()) {
- Root.Root(Ufirst);
- Func.Value(Ufirst,Umin);
- gp_Pnt2d point1,point2,point3;
- gp_Vec2d Tan1,Tan2,Tan3;
- TheCurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
- TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
- TheCurveTool::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;
- }
- }
- }
- }
- }
- }
- }
-
-GccIter_Circ2d3Tan::
- GccIter_Circ2d3Tan (const GccEnt_QualifiedCirc& Qualified1 ,
- const TheQualifiedCurve& Qualified2 ,
- const TheQualifiedCurve& 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())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- gp_Circ2d C1 = Qualified1.Qualified();
- TheCurve Cu2 = Qualified2.Qualified();
- TheCurve Cu3 = Qualified3.Qualified();
- GccIter_FuncTCuCuCu 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) = TheCurveTool::FirstParameter(Cu2);
- Umin(3) = TheCurveTool::FirstParameter(Cu3);
- Umax(1) = 2*M_PI;
- Umax(2) = TheCurveTool::LastParameter(Cu2);
- Umax(3) = TheCurveTool::LastParameter(Cu3);
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- Ufirst(3) = Param3;
- tol(1) = 2.e-15*M_PI;
- tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
- tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));
- math_FunctionSetRoot Root(Func,Ufirst,tol,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;
- TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
- TheCurveTool::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;
- }
- }
- }
- }
- }
- }
- }
-
-GccIter_Circ2d3Tan::
- GccIter_Circ2d3Tan (const GccEnt_QualifiedCirc& Qualified1 ,
- const GccEnt_QualifiedCirc& Qualified2 ,
- const TheQualifiedCurve& 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())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- gp_Circ2d C1 = Qualified1.Qualified();
- gp_Circ2d C2 = Qualified2.Qualified();
- TheCurve Cu3 = Qualified3.Qualified();
- GccIter_FuncTCuCuCu 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) = TheCurveTool::FirstParameter(Cu3);
- Umax(1) = 2*M_PI;
- Umax(2) = 2*M_PI;
- Umax(3) = TheCurveTool::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) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));
- math_FunctionSetRoot Root(Func,Ufirst,tol,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;
- TheCurveTool::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;
- }
- }
- }
- }
- }
- }
- }
-
-GccIter_Circ2d3Tan::
- GccIter_Circ2d3Tan (const GccEnt_QualifiedLin& Qualified1 ,
- const TheQualifiedCurve& Qualified2 ,
- const TheQualifiedCurve& 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())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- gp_Lin2d L1 = Qualified1.Qualified();
- TheCurve Cu2 = Qualified2.Qualified();
- TheCurve Cu3 = Qualified3.Qualified();
- GccIter_FuncTCuCuCu 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) = TheCurveTool::FirstParameter(Cu2);
- Umin(3) = TheCurveTool::FirstParameter(Cu3);
- Umax(1) = RealLast();
- Umax(2) = TheCurveTool::LastParameter(Cu2);
- Umax(3) = TheCurveTool::LastParameter(Cu3);
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- Ufirst(3) = Param3;
- tol(1) = 1.e-15;
- tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
- tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));
- math_FunctionSetRoot Root(Func,Ufirst,tol,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;
- TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
- TheCurveTool::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;
- }
- }
- }
- }
- }
- }
- }
-
-GccIter_Circ2d3Tan::
- GccIter_Circ2d3Tan (const GccEnt_QualifiedLin& Qualified1 ,
- const GccEnt_QualifiedLin& Qualified2 ,
- const TheQualifiedCurve& 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())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- gp_Lin2d L1 = Qualified1.Qualified();
- gp_Lin2d L2 = Qualified2.Qualified();
- TheCurve Cu3 = Qualified3.Qualified();
- GccIter_FuncTCuCuCu 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) = TheCurveTool::FirstParameter(Cu3);
- Umax(1) = RealLast();
- Umax(2) = RealLast();
- Umax(3) = TheCurveTool::LastParameter(Cu3);
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- Ufirst(3) = Param3;
- tol(1) = 1.e-15;
- tol(2) = 1.e-15;
- tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));
- math_FunctionSetRoot Root(Func,Ufirst,tol,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;
- TheCurveTool::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.)) {
- Standard_Real pscal=centre.XY().Dot(gp_XY(-L1.Direction().Y(),
- L1.Direction().X()));
- 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;
- }
- }
- }
- }
- }
- }
- }
-
-GccIter_Circ2d3Tan::
- GccIter_Circ2d3Tan (const TheQualifiedCurve& Qualified1 ,
- const TheQualifiedCurve& 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())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- gp_Circ2d C1(gp_Ax2d(Point3,gp_Dir2d(1.,0.)),0.);
- TheCurve Cu1 = Qualified1.Qualified();
- TheCurve Cu2 = Qualified2.Qualified();
- GccIter_FuncTCuCuCu 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) = TheCurveTool::FirstParameter(Cu1);
- Umin(3) = TheCurveTool::FirstParameter(Cu2);
- Umax(1) = 2*M_PI;
- Umax(2) = TheCurveTool::LastParameter(Cu1);
- Umax(3) = TheCurveTool::LastParameter(Cu2);
- Ufirst(1) = M_PI;
- Ufirst(2) = Param1;
- Ufirst(3) = Param2;
- tol(1) = 2.e-15*M_PI;
- tol(2) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
- tol(3) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
- math_FunctionSetRoot Root(Func,Ufirst,tol,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;
- TheCurveTool::D1(Cu1,Ufirst(2),point1,Tan1);
- TheCurveTool::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;
- }
- }
- }
- }
- }
- }
-
-GccIter_Circ2d3Tan::
- GccIter_Circ2d3Tan (const TheQualifiedCurve& 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())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- gp_Dir2d dirx(1.,0.);
- gp_Circ2d C1(gp_Ax2d(Point2,dirx),0.);
- gp_Circ2d C2(gp_Ax2d(Point3,dirx),0.);
- TheCurve Cu1 = Qualified1.Qualified();
- GccIter_FuncTCuCuCu 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) = TheCurveTool::FirstParameter(Cu1);
- Umax(1) = 2*M_PI;
- Umax(2) = 2*M_PI;
- Umax(3) = TheCurveTool::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) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
- math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
- if (Root.IsDone()) {
- Root.Root(Ufirst);
- Func.Value(Ufirst,Umin);
- gp_Pnt2d point3;
-// gp_Vec2d Tan3,Nor3;
- gp_Vec2d Tan3;
- TheCurveTool::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;
- }
- }
- }
- }
- }
-
-GccIter_Circ2d3Tan::
- GccIter_Circ2d3Tan (const GccEnt_QualifiedLin& Qualified1 ,
- const TheQualifiedCurve& 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())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- gp_Dir2d dirx(1.,0.);
- gp_Lin2d L1 = Qualified1.Qualified();
- TheCurve Cu2 = Qualified2.Qualified();
- gp_Circ2d C3(gp_Ax2d(Point3,dirx),0.);
- GccIter_FuncTCuCuCu 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) = TheCurveTool::FirstParameter(Cu2);
- Umin(1) = 0.;
- Umax(2) = RealLast();
- Umax(3) = TheCurveTool::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) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
- math_FunctionSetRoot Root(Func,Ufirst,tol,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;
- TheCurveTool::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;
- }
- }
- }
- }
- }
- }
-
-GccIter_Circ2d3Tan::
- GccIter_Circ2d3Tan (const GccEnt_QualifiedCirc& Qualified1 ,
- const GccEnt_QualifiedLin& Qualified2 ,
- const TheQualifiedCurve& 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())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- gp_Circ2d C1 = Qualified1.Qualified();
- gp_Lin2d L2 = Qualified2.Qualified();
- TheCurve Cu3 = Qualified3.Qualified();
- GccIter_FuncTCuCuCu 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) = TheCurveTool::FirstParameter(Cu3);
- Umax(1) = 2*M_PI;
- Umax(2) = RealLast();
- Umax(3) = TheCurveTool::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) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));
- math_FunctionSetRoot Root(Func,Ufirst,tol,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;
- TheCurveTool::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;
- }
- }
- }
- }
- }
- }
- }
-
-GccIter_Circ2d3Tan::
- GccIter_Circ2d3Tan (const GccEnt_QualifiedCirc& Qualified1 ,
- const TheQualifiedCurve& 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())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- gp_Circ2d C1 = Qualified1.Qualified();
- TheCurve Cu2 = Qualified2.Qualified();
- gp_Dir2d dirx(1.,0.);
- gp_Circ2d C3(gp_Ax2d(Point3,dirx),0.);
- GccIter_FuncTCuCuCu 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) = TheCurveTool::FirstParameter(Cu2);
- Umin(2) = 0.;
- Umax(1) = 2*M_PI;
- Umax(3) = TheCurveTool::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) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
- math_FunctionSetRoot Root(Func,Ufirst,tol,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;
- TheCurveTool::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 GccIter_Circ2d3Tan::
- IsDone () const{ return WellDone; }
-
-gp_Circ2d GccIter_Circ2d3Tan::
- ThisSolution () const{ return cirsol; }
-
-void GccIter_Circ2d3Tan::
- WhichQualifier (GccEnt_Position& Qualif1 ,
- GccEnt_Position& Qualif2 ,
- GccEnt_Position& Qualif3 ) const
-{
- if (!WellDone) { StdFail_NotDone::Raise(); }
- else {
- Qualif1 = qualifier1;
- Qualif2 = qualifier2;
- Qualif3 = qualifier3;
- }
-}
-
-void GccIter_Circ2d3Tan::
- Tangency1 (Standard_Real& ParSol ,
- Standard_Real& ParArg ,
- gp_Pnt2d& PntSol ) const{
- if (!WellDone) { StdFail_NotDone::Raise(); }
- else {
- if (TheSame1 == 0) {
- ParSol = par1sol;
- ParArg = pararg1;
- PntSol = pnttg1sol;
- }
- else { StdFail_NotDone::Raise(); }
- }
- }
-
-void GccIter_Circ2d3Tan::
- Tangency2 (Standard_Real& ParSol ,
- Standard_Real& ParArg ,
- gp_Pnt2d& PntSol ) const{
- if (!WellDone) { StdFail_NotDone::Raise(); }
- else {
- ParSol = par2sol;
- ParArg = pararg2;
- PntSol = pnttg2sol;
- }
- }
-
-void GccIter_Circ2d3Tan::
- Tangency3 (Standard_Real& ParSol ,
- Standard_Real& ParArg ,
- gp_Pnt2d& PntSol ) const{
- if (!WellDone) { StdFail_NotDone::Raise(); }
- else {
- ParSol = par3sol;
- ParArg = pararg3;
- PntSol = pnttg3sol;
- }
- }
-
-Standard_Boolean GccIter_Circ2d3Tan::
- IsTheSame1 () const
-{
- if (!WellDone) StdFail_NotDone::Raise();
-
- if (TheSame1 == 0)
- return Standard_False;
-
- return Standard_True;
-}
-
-
-Standard_Boolean GccIter_Circ2d3Tan::
- IsTheSame2 () const
-{
- if (!WellDone) StdFail_NotDone::Raise();
-
- if (TheSame3 == 0)
- return Standard_False;
-
- return Standard_True;
-
-}
-
-Standard_Boolean GccIter_Circ2d3Tan::
- IsTheSame3 () const
-{
- if (!WellDone) StdFail_NotDone::Raise();
-
- return Standard_True;
-}
+++ /dev/null
-// Created on: 1992-01-20
-// 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 <gp_Vec2d.hxx>
-#include <gp_Pnt2d.hxx>
-#include <gp_Vec.hxx>
-#include <gp_Pnt.hxx>
-
-//=========================================================================
-// soit P1 le point sur la courbe TheCurve d abscisse u. +
-// soit C le centre du cercle TheCirc. +
-// Nous recherchons un point P2 appartenant au cercle tel que : +
-// ---> --> +
-// * P1P2 . CP2 = 0 +
-// +
-// * --> 2 2 +
-// ||CP2|| = R +
-// Nous cherchons donc les zeros de la fonction suivante: +
-// --> --> 2 +
-// --> 2 ( CP1 . T ) 2 +
-// ||CP1|| - ----------- - R = F(u) +
-// --> 2 +
-// ||T|| +
-// +
-// La derivee de cette fonction est : +
-// +
-// 2*(CP1.T)(CP1.N) 2*(CP1.T)*(CP1.T)*T.N +
-// f(u) = - ---------------- + --------------------- +
-// T.T (T.T)*(T.T) +
-//=========================================================================
-// +
-// skv: Small addition: The function and the derivative are normalized +
-// by an average square distance between the circle +
-// and the curve. +
-//=========================================================================
-
-GccIter_FunctionTanCirCu::
- GccIter_FunctionTanCirCu(const gp_Circ2d& Circ ,
- const TheCurve& Curv ) {
- Curve = Curv;
- TheCirc = Circ;
-
-// Modified by Sergey KHROMOV - Thu Apr 5 09:51:21 2001 Begin
- Standard_Integer aNbSamp = TheCurveTool::NbSamples(Curve);
- Standard_Real aFirst = TheCurveTool::FirstParameter(Curve);
- Standard_Real aLast = TheCurveTool::LastParameter(Curve);
- Standard_Real aStep = (aLast - aFirst)/aNbSamp;
- Standard_Real anX = aFirst + aStep/2.;
- Standard_Integer aNbP = 0;
- gp_XY aLoc(0., 0.);
-
- while (anX <= aLast) {
- aLoc += (TheCurveTool::Value(Curve, anX)).XY();
- anX += aStep;
- aNbP++;
- }
- myWeight = Max((aLoc - TheCirc.Location().XY()).SquareModulus(), TheCirc.Radius());
-// Modified by Sergey KHROMOV - Thu Apr 5 09:51:25 2001 End
- }
-
-
-Standard_Boolean GccIter_FunctionTanCirCu::
- Value (const Standard_Real X ,
- Standard_Real& Fval ) {
- gp_Pnt2d Point;
- gp_Vec2d Vect1;
- TheCurveTool::D1(Curve,X,Point,Vect1);
- Standard_Real NormeD1 = Vect1.Magnitude();
- gp_Vec2d TheDirection(TheCirc.Location(),Point);
- Standard_Real squaredir = TheDirection.Dot(TheDirection);
- Standard_Real R = TheCirc.Radius();
- Fval = squaredir-R*R-
- (TheDirection.Dot(Vect1))*(TheDirection.Dot(Vect1))/(NormeD1*NormeD1);
-// Modified by Sergey KHROMOV - Thu Apr 5 17:38:05 2001 Begin
- Fval /= myWeight;
-// Modified by Sergey KHROMOV - Thu Apr 5 17:38:06 2001 End
- return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanCirCu::
- Derivative (const Standard_Real X ,
- Standard_Real& Deriv ) {
- gp_Pnt2d Point;
- gp_Vec2d Vect1,Vect2;
- TheCurveTool::D2(Curve,X,Point,Vect1,Vect2);
- Standard_Real NormeD1 = Vect1.SquareMagnitude();
- gp_Vec2d TheDirection(TheCirc.Location(),Point);
- Standard_Real cp1dott = TheDirection.Dot(Vect1);
- Deriv = -2.*(cp1dott/NormeD1)*
- ((TheDirection.Dot(Vect2))-cp1dott*Vect1.Dot(Vect2)/NormeD1);
-// Modified by Sergey KHROMOV - Thu Apr 5 17:38:15 2001 Begin
- Deriv /= myWeight;
-// Modified by Sergey KHROMOV - Thu Apr 5 17:38:15 2001 End
- return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanCirCu::
- Values (const Standard_Real X ,
- Standard_Real& Fval ,
- Standard_Real& Deriv ) {
- gp_Pnt2d Point;
- gp_Vec2d Vect1,Vect2;
- TheCurveTool::D2(Curve,X,Point,Vect1,Vect2);
- Standard_Real NormeD1 = Vect1.SquareMagnitude();
- gp_Vec2d TheDirection(TheCirc.Location(),Point);
- Standard_Real squaredir = TheDirection.SquareMagnitude();
- Standard_Real cp1dott = TheDirection.Dot(Vect1);
- Standard_Real R = TheCirc.Radius();
-
- Fval = squaredir-R*R-cp1dott*cp1dott/NormeD1;
-// Modified by Sergey KHROMOV - Thu Apr 5 17:38:28 2001 Begin
- Fval /= myWeight;
-// Modified by Sergey KHROMOV - Thu Apr 5 17:38:28 2001 End
-
- Deriv = -2.*(cp1dott/NormeD1)*
- ((TheDirection.Dot(Vect2))-cp1dott*Vect1.Dot(Vect2)/NormeD1);
-// Modified by Sergey KHROMOV - Thu Apr 5 17:37:36 2001 Begin
- Deriv /= myWeight;
-// Modified by Sergey KHROMOV - Thu Apr 5 17:37:37 2001 End
- return Standard_True;
-}
+++ /dev/null
-// Created on: 1992-01-20
-// 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 <gp_Vec2d.hxx>
-#include <gp_Pnt2d.hxx>
-#include <ElCLib.hxx>
-
-void GccIter_FunctionTanCuCu::
- InitDerivative(const math_Vector& X ,
- gp_Pnt2d& Point1,
- gp_Pnt2d& Point2,
- gp_Vec2d& Tan1 ,
- gp_Vec2d& Tan2 ,
- gp_Vec2d& D21 ,
- gp_Vec2d& D22 ) {
- switch (TheType) {
- case GccIter_CuCu:
- {
- TheCurveTool::D2(TheCurve1,X(1),Point1,Tan1,D21);
- TheCurveTool::D2(TheCurve2,X(2),Point2,Tan2,D22);
- }
- break;
- case GccIter_CiCu:
- {
- ElCLib::D2(X(1),TheCirc1,Point1,Tan1,D21);
- TheCurveTool::D2(TheCurve2,X(2),Point2,Tan2,D22);
- }
- break;
- default:
- {
- }
- }
-}
-
-GccIter_FunctionTanCuCu::
- GccIter_FunctionTanCuCu(const TheCurve& C1 ,
- const TheCurve& C2 ) {
- TheCurve1 = C1;
- TheCurve2 = C2;
- TheType = GccIter_CuCu;
-}
-
-GccIter_FunctionTanCuCu::
- GccIter_FunctionTanCuCu(const gp_Circ2d& C1 ,
- const TheCurve& C2 ) {
- TheCirc1 = C1;
- TheCurve2 = C2;
- TheType = GccIter_CiCu;
-}
-
-
-//=========================================================================
-// soit P1 le point sur la courbe TheCurve1 d abscisse u1. +
-// soit P2 le point sur la courbe TheCurve2 d abscisse u2. +
-// soit T1 la tangente a la courbe TheCurve1 en P1. +
-// soit T2 la tangente a la courbe TheCurve2 en P2. +
-// Nous voulons P1 et P2 tels que : +
-// ---> --> +
-// * P1P2 /\ T1 = 0 +
-// +
-// --> --> +
-// * T1 /\ T2 = 0 +
-// +
-// Nous cherchons donc les zeros des fonctions suivantes: +
-// ---> --> +
-// * P1P2 /\ T1 +
-// --------------- = F1(u) +
-// ---> --> +
-// ||P1P2||*||T1|| +
-// +
-// --> --> +
-// * T1 /\ T2 +
-// --------------- = F2(u) +
-// --> --> +
-// ||T2||*||T1|| +
-// +
-// Les derivees de ces fonctions sont : +
-// 2 2 +
-// dF1 P1P2/\N1 (P1P2/\T1)*[T1*(-T1).P1P2+P1P2*(T1.N1)] +
-// ----- = --------------- - ----------------------------------------- +
-// du1 3 3 +
-// ||P1P2||*||T1|| ||P1P2|| * ||T1|| +
-// +
-// 2 +
-// dF1 T2/\T1 (P1P2/\T1)*[T1*(T2.P1P2) +
-// ----- = --------------- - ----------------------------------------- +
-// du2 3 3 +
-// ||P1P2||*||T1|| ||P1P2|| * ||T1|| +
-// +
-// 2 +
-// dF2 N1/\T2 T1/\T2*(N1.T1)T2 +
-// ----- = ---------------- - ----------------------------- +
-// du1 3 3 +
-// ||T1||*||T2|| ||T1|| * ||T2|| +
-// +
-// 2 +
-// dF2 T1/\N2 T1/\T2*(N2.T2)T1 +
-// ----- = ---------------- - ----------------------------- +
-// du2 3 3 +
-// ||T1||*||T2|| ||T1|| * ||T2|| +
-// +
-//=========================================================================
-
-Standard_Integer GccIter_FunctionTanCuCu::
- NbVariables() const { return 2; }
-
-Standard_Integer GccIter_FunctionTanCuCu::
- NbEquations() const { return 2; }
-
-Standard_Boolean GccIter_FunctionTanCuCu::
- Value (const math_Vector& X ,
- math_Vector& Fval ) {
- gp_Pnt2d Point1;
- gp_Pnt2d Point2;
- gp_Vec2d Vect11;
- gp_Vec2d Vect21;
- gp_Vec2d Vect12;
- gp_Vec2d Vect22;
- InitDerivative(X,Point1,Point2,Vect11,Vect21,Vect12,Vect22);
- Standard_Real NormeD11 = Vect11.Magnitude();
- Standard_Real NormeD21 = Vect21.Magnitude();
- gp_Vec2d TheDirection(Point1,Point2);
- Standard_Real squaredir = TheDirection.Dot(TheDirection);
- Fval(1) = TheDirection.Crossed(Vect11)/(NormeD11*squaredir);
- Fval(2) = Vect11.Crossed(Vect21)/(NormeD11*NormeD21);
- return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanCuCu::
- Derivatives (const math_Vector& X ,
- math_Matrix& Deriv ) {
- gp_Pnt2d Point1;
- gp_Pnt2d Point2;
- gp_Vec2d Vect11;
- gp_Vec2d Vect21;
- gp_Vec2d Vect12;
- gp_Vec2d Vect22;
- InitDerivative(X,Point1,Point2,Vect11,Vect21,Vect12,Vect22);
- Standard_Real NormeD11 = Vect11.Magnitude();
- Standard_Real NormeD21 = Vect21.Magnitude();
-#ifdef DEB
- gp_Vec2d V2V1(Vect11.XY(),Vect21.XY());
-#else
- Vect11.XY();
- Vect21.XY();
-#endif
- gp_Vec2d TheDirection(Point1,Point2);
- Standard_Real squaredir = TheDirection.Dot(TheDirection);
- Deriv(1,1) = TheDirection.Crossed(Vect12)/(NormeD11*squaredir)+
- (TheDirection.Crossed(Vect11)*NormeD11*NormeD11*Vect11.Dot(TheDirection))/
- (NormeD11*NormeD11*NormeD11*squaredir*squaredir*squaredir);
- Deriv(1,2) = Vect21.Crossed(Vect11)/(NormeD11*squaredir)-
- (TheDirection.Crossed(Vect11)*NormeD11*NormeD11*Vect21.Dot(TheDirection))/
- (NormeD11*NormeD11*NormeD11*squaredir*squaredir*squaredir);
- Deriv(2,1)=(Vect12.Crossed(Vect21))/(NormeD11*NormeD21)-
- (Vect11.Crossed(Vect21))*(Vect12.Dot(Vect11))*NormeD21*NormeD21/
- (NormeD11*NormeD11*NormeD11*NormeD21*NormeD21*NormeD21);
- Deriv(2,2)=(Vect11.Crossed(Vect22))/(NormeD11*NormeD21)-
- (Vect11.Crossed(Vect21))*(Vect22.Dot(Vect21))*NormeD11*NormeD11/
- (NormeD11*NormeD11*NormeD11*NormeD21*NormeD21*NormeD21);
- return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanCuCu::
- Values (const math_Vector& X ,
- math_Vector& Fval ,
- math_Matrix& Deriv ) {
- gp_Pnt2d Point1;
- gp_Pnt2d Point2;
- gp_Vec2d Vect11;
- gp_Vec2d Vect21;
- gp_Vec2d Vect12;
- gp_Vec2d Vect22;
- InitDerivative(X,Point1,Point2,Vect11,Vect21,Vect12,Vect22);
- Standard_Real NormeD11 = Vect11.Magnitude();
- Standard_Real NormeD21 = Vect21.Magnitude();
-#ifdef DEB
- gp_Vec2d V2V1(Vect11.XY(),Vect21.XY());
-#else
- Vect11.XY();
- Vect21.XY();
-#endif
- gp_Vec2d TheDirection(Point1,Point2);
- Standard_Real squaredir = TheDirection.Dot(TheDirection);
- Fval(1) = TheDirection.Crossed(Vect11)/(NormeD11*squaredir);
- Fval(2) = Vect11.Crossed(Vect21)/(NormeD11*NormeD21);
- Deriv(1,1) = TheDirection.Crossed(Vect12)/(NormeD11*squaredir)+
- (TheDirection.Crossed(Vect11)*NormeD11*NormeD11*Vect11.Dot(TheDirection))/
- (NormeD11*NormeD11*NormeD11*squaredir*squaredir*squaredir);
- Deriv(1,2) = Vect21.Crossed(Vect11)/(NormeD11*squaredir)-
- (TheDirection.Crossed(Vect11)*NormeD11*NormeD11*Vect21.Dot(TheDirection))/
- (NormeD11*NormeD11*NormeD11*squaredir*squaredir*squaredir);
- Deriv(2,1)=(Vect12.Crossed(Vect21))/(NormeD11*NormeD21)-
- (Vect11.Crossed(Vect21))*(Vect12.Dot(Vect11))*NormeD21*NormeD21/
- (NormeD11*NormeD11*NormeD11*NormeD21*NormeD21*NormeD21);
- Deriv(2,2)=(Vect11.Crossed(Vect22))/(NormeD11*NormeD21)-
- (Vect11.Crossed(Vect21))*(Vect22.Dot(Vect21))*NormeD11*NormeD11/
- (NormeD11*NormeD11*NormeD11*NormeD21*NormeD21*NormeD21);
- return Standard_True;
-}
+++ /dev/null
-// Created on: 1992-01-20
-// 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 <gp_Vec2d.hxx>
-#include <gp_Pnt2d.hxx>
-#include <gp_Vec.hxx>
-#include <gp_Pnt.hxx>
-
-//=========================================================================
-// soit P1 le point sur la courbe TheCurve d abscisse u. +
-// soit C le point ThePoint. +
-// Nous cherchons donc les zeros de la fonction suivante: +
-// +
-// --> --> +
-// CP1 /\ T +
-// --------------- = F(u) +
-// ||CP1|| * ||T|| +
-// +
-// La derivee de cette fonction est : +
-// CP1 /\ N (T.N)*((CP1/\T).((CP1/\T)) +
-// f(u) = -------- - -------------------------------- +
-// N.N N*N*N*CP1*CP1*CP1 +
-//=========================================================================
-
-GccIter_FunctionTanCuPnt::
- GccIter_FunctionTanCuPnt(const TheCurve& C ,
- const gp_Pnt2d& Point ) {
- TheCurv = C;
- ThePoint = Point;
- }
-
-
-Standard_Boolean GccIter_FunctionTanCuPnt::
- Value (const Standard_Real X ,
- Standard_Real& Fval ) {
- gp_Pnt2d Point;
- gp_Vec2d Vect;
- TheCurveTool::D1(TheCurv,X,Point,Vect);
- Standard_Real NormeD1 = Vect.Magnitude();
- gp_Vec2d TheDirection(ThePoint,Point);
- Standard_Real NormeDir = TheDirection.Magnitude();
- Fval = TheDirection.Crossed(Vect)/(NormeD1*NormeDir);
- return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanCuPnt::
- Derivative (const Standard_Real X ,
- Standard_Real& Deriv ) {
- gp_Pnt2d Point;
- gp_Vec2d Vec1;
- gp_Vec2d Vec2;
- TheCurveTool::D2(TheCurv,X,Point,Vec1,Vec2);
- gp_Vec2d TheDirection(ThePoint.XY(),gp_XY(Point.XY()));
- Standard_Real NormeD1 = Vec1.Magnitude();
- Standard_Real NormeDir = TheDirection.Magnitude();
- Deriv = TheDirection.Crossed(Vec2)/(NormeD1*NormeDir)-
- (TheDirection.Crossed(Vec1)/(NormeD1*NormeDir))*
- (Vec1.Dot(Vec2)/(NormeD1*NormeD1)+
- Vec1.Dot(TheDirection)/(NormeDir*NormeDir));
- return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanCuPnt::
- Values (const Standard_Real X ,
- Standard_Real& Fval ,
- Standard_Real& Deriv ) {
- gp_Pnt2d Point;
- gp_Vec2d Vec1;
- gp_Vec2d Vec2;
- TheCurveTool::D2(TheCurv,X,Point,Vec1,Vec2);
- gp_Vec2d TheDirection(ThePoint.XY(),gp_XY(Point.XY()));
- Standard_Real NormeD1 = Vec1.Magnitude();
- Standard_Real NormeDir = TheDirection.Magnitude();
- Fval = TheDirection.Crossed(Vec1)/(NormeD1*NormeDir);
- Deriv = TheDirection.Crossed(Vec2)/(NormeD1*NormeDir)-
- (TheDirection.Crossed(Vec1)/(NormeD1*NormeDir))*
- (Vec1.Dot(Vec2)/(NormeD1*NormeD1)+
- Vec1.Dot(TheDirection)/(NormeDir*NormeDir));
-
-// cout << "U = "<< X << " F ="<< Fval <<" DF ="<< Deriv<<endl;
-
- return Standard_True;
-}
+++ /dev/null
-// Created on: 1992-01-20
-// 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 <gp_Vec2d.hxx>
-#include <gp_Pnt2d.hxx>
-
-GccIter_FunctionTanObl::
- GccIter_FunctionTanObl(const TheCurve& C ,
- const gp_Dir2d& Dir ) {
- TheCurv = C;
- TheDirection = Dir;
- }
-
-
-Standard_Boolean GccIter_FunctionTanObl::
- Value (const Standard_Real X ,
- Standard_Real& Fval ) {
- gp_Pnt2d Point;
- gp_Vec2d Vect;
- TheCurveTool::D1(TheCurv,X,Point,Vect);
- Standard_Real NormeD1 = Vect.Magnitude();
- Fval = TheDirection.XY().Crossed(Vect.XY())/NormeD1;
- return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanObl::
- Derivative (const Standard_Real X ,
- Standard_Real& Deriv ) {
- gp_Pnt2d Point;
- gp_Vec2d Vec1;
- gp_Vec2d Vec2;
- TheCurveTool::D2(TheCurv,X,Point,Vec1,Vec2);
- Standard_Real NormeD1 = Vec1.Magnitude();
- Deriv = TheDirection.XY().Crossed(Vec2.XY())/NormeD1-
- Vec1.XY().Dot(Vec2.XY())*TheDirection.XY().Crossed(Vec1.XY())/NormeD1;
- return Standard_True;
-}
-
-Standard_Boolean GccIter_FunctionTanObl::
- Values (const Standard_Real X ,
- Standard_Real& Fval ,
- Standard_Real& Deriv ) {
- gp_Pnt2d Point;
- gp_Vec2d Vec1;
- gp_Vec2d Vec2;
- TheCurveTool::D2(TheCurv,X,Point,Vec1,Vec2);
- Standard_Real NormeD1 = Vec1.Magnitude();
- Fval = TheDirection.XY().Crossed(Vec1.XY())/NormeD1;
- Deriv = TheDirection.XY().Crossed(Vec2.XY())/NormeD1-
- Vec1.XY().Dot(Vec2.XY())*TheDirection.XY().Crossed(Vec1.XY())/NormeD1;
- return Standard_True;
-}
-
+++ /dev/null
-// Created on: 1991-12-20
-// 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 UNE LIGNE TANGENTE A DEUX COURBES. +
-//========================================================================
-
-#include <StdFail_NotDone.hxx>
-#include <GccEnt_BadQualifier.hxx>
-#include <gp_XY.hxx>
-#include <gp_Dir2d.hxx>
-#include <gp_Vec2d.hxx>
-#include <gp_Circ2d.hxx>
-#include <math_Vector.hxx>
-#include <math_Matrix.hxx>
-#include <math_FunctionSetRoot.hxx>
-#include <math_FunctionRoot.hxx>
-
-GccIter_Lin2d2Tan::
- GccIter_Lin2d2Tan (const GccEnt_QualifiedCirc& Qualified1 ,
- const TheQualifiedCurve& Qualified2 ,
- const Standard_Real Param2 ,
- const Standard_Real Tolang ) {
-
- par1sol = 0.;
- pararg1 = 0.;
-
- //Standard_Real Tol = Abs(Tolang);
-
- WellDone = Standard_False;
- if (Qualified1.IsEnclosed()) { GccEnt_BadQualifier::Raise(); }
- gp_Circ2d C1 = Qualified1.Qualified();
- TheCurve Cu2 = Qualified2.Qualified();
- Standard_Real U1 = TheCurveTool::FirstParameter(Cu2);
- Standard_Real U2 = TheCurveTool::LastParameter(Cu2);
- GccIter_FuncTCirCu func(C1,Cu2);
- math_FunctionRoot sol(func,Param2,TheCurveTool::EpsX(Cu2,Abs(Tolang)),U1,U2,100);
- if (sol.IsDone()) {
- Standard_Real Usol = sol.Root();
-// gp_Pnt2d Origine,Pt;
-// Modified by Sergey KHROMOV - Thu Apr 5 17:39:47 2001 Begin
- Standard_Real Norm;
- func.Value(Usol, Norm);
- if (Abs(Norm) < Tolang) {
-// Modified by Sergey KHROMOV - Thu Apr 5 17:39:48 2001 End
- gp_Pnt2d Origine;
- gp_Vec2d Vect1;
- gp_Vec2d Vect2;
- TheCurveTool::D2(Cu2,Usol,Origine,Vect1,Vect2);
- gp_Vec2d Vdir(C1.Location().XY() - Origine.XY());
- Standard_Real sign1 = Vect1.Dot(Vdir);
- if (sign1 <= 0. ) { Vect1.Reverse(); }
- Standard_Real sign2 = Vect2.Crossed(Vect1);
- if (Qualified2.IsUnqualified() ||
- (Qualified2.IsEnclosing() && sign2<=0.) ||
- (Qualified2.IsOutside() && sign1 <= 0. && sign2 >= 0.) ||
- (Qualified2.IsEnclosed() && sign1 >= 0. && sign2 >= 0.)) {
- if (Qualified1.IsUnqualified() ||
- (Qualified1.IsOutside() && Vect1.Angle(Vdir) <= 0.) ||
- (Qualified1.IsEnclosing() && Vect1.Angle(Vdir) >= 0.)) {
- gp_Dir2d direc(Vect1);
- Standard_Real R1 = C1.Radius();
- gp_XY normal(-R1*direc.Y(),R1*direc.X());
- sign1 = Vect1.Crossed(Vdir);
- if (Qualified1.IsEnclosing()) {
- pnttg1sol = gp_Pnt2d(C1.Location().XY()-normal);
- }
- else if (Qualified1.IsOutside()) {
- pnttg1sol = gp_Pnt2d(C1.Location().XY()+normal);
- }
- else {
- if (sign1 >= 0.) {
- pnttg1sol = gp_Pnt2d(C1.Location().XY()-normal);
- }
- else {
- pnttg1sol = gp_Pnt2d(C1.Location().XY()+normal);
- }
- }
-// if (gp_Vec2d(direc.XY()).Angle(gp_Vec2d(pnttg1sol,Origine)) <= Tol) {
- pnttg2sol = Origine;
- linsol = gp_Lin2d(pnttg1sol,direc);
- WellDone = Standard_True;
- qualifier1 = Qualified1.Qualifier();
- qualifier2 = Qualified2.Qualifier();
- pararg2 = Usol;
- par1sol = 0.;
- par2sol = pnttg2sol.Distance(pnttg1sol);
- pararg1 = 0.;
- }
- }
- }
- }
- }
-
-GccIter_Lin2d2Tan::
- GccIter_Lin2d2Tan (const TheQualifiedCurve& Qualified1 ,
- const TheQualifiedCurve& Qualified2 ,
- const Standard_Real Param1 ,
- const Standard_Real Param2 ,
- const Standard_Real Tolang ) {
- par1sol = 0.;
- pararg1 = 0.;
- WellDone = Standard_False;
- if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
- Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
- !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
- Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- TheCurve Cu1 = Qualified1.Qualified();
- TheCurve Cu2 = Qualified2.Qualified();
- GccIter_FuncTCuCu Func(Cu1,Cu2);
- math_Vector Umin(1,2);
- math_Vector Umax(1,2);
- math_Vector Ufirst(1,2);
- math_Vector tol(1,2);
- Umin(1) = TheCurveTool::FirstParameter(Cu1);
- Umin(2) = TheCurveTool::FirstParameter(Cu2);
- Umax(1) = TheCurveTool::LastParameter(Cu1);
- Umax(2) = TheCurveTool::LastParameter(Cu2);
- Ufirst(1) = Param1;
- Ufirst(2) = Param2;
- tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolang));
- tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolang));
- math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
- if (Root.IsDone()) {
- Root.Root(Ufirst);
-// Modified by Sergey KHROMOV - Thu Apr 5 17:45:00 2001 Begin
- math_Vector Norm(1,2);
- Func.Value(Ufirst, Norm);
- if (Abs(Norm(1)) < Tolang && Abs(Norm(2)) < Tolang) {
-// Modified by Sergey KHROMOV - Thu Apr 5 17:45:01 2001 End
- gp_Pnt2d point1,point2;
- gp_Vec2d Vect11,Vect12,Vect21,Vect22;
- TheCurveTool::D2(Cu1,Ufirst(1),point1,Vect11,Vect12);
- TheCurveTool::D2(Cu2,Ufirst(2),point2,Vect21,Vect22);
- gp_Vec2d Vec(point1.XY(),point2.XY());
- Standard_Real Angle1 = Vec.Angle(Vect12);
- Standard_Real sign1 = Vect11.Dot(Vec);
- if (Qualified1.IsUnqualified() ||
- (Qualified1.IsEnclosing() && Angle1 >= 0.) ||
- (Qualified1.IsOutside() && Angle1 <= 0. && sign1 <= 0.) ||
- (Qualified1.IsEnclosed() && Angle1 <= 0. && sign1 >= 0.)) {
- Angle1 = Vec.Angle(Vect22);
- sign1 = Vect21.Dot(Vec);
- if (Qualified2.IsUnqualified() ||
- (Qualified2.IsEnclosing() && Angle1 >= 0.) ||
- (Qualified2.IsOutside() && Angle1 <= 0. && sign1 <= 0.) ||
- (Qualified2.IsEnclosed() && Angle1 <= 0. && sign1 >= 0.)) {
- qualifier1 = Qualified1.Qualifier();
- qualifier2 = Qualified2.Qualifier();
- pararg1 = Ufirst(1);
- par1sol = 0.;
- pnttg1sol = point1;
- pararg2 = Ufirst(2);
- pnttg2sol = point2;
- par2sol = pnttg2sol.Distance(pnttg1sol);
- gp_Dir2d dir(pnttg2sol.X()-pnttg1sol.X(),pnttg2sol.Y()-pnttg1sol.Y());
- linsol = gp_Lin2d(pnttg1sol,dir);
- WellDone = Standard_True;
- }
- }
- }
- }
- }
-
-GccIter_Lin2d2Tan::
- GccIter_Lin2d2Tan (const TheQualifiedCurve& Qualified1 ,
- const gp_Pnt2d& ThePoint ,
- const Standard_Real Param1 ,
- const Standard_Real Tolang ) {
-
- par1sol = 0.;
- pararg1 = 0.;
- WellDone = Standard_False;
- if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
- Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- TheCurve Cu1 = Qualified1.Qualified();
- Standard_Real U1 = TheCurveTool::FirstParameter(Cu1);
- Standard_Real U2 = TheCurveTool::LastParameter(Cu1);
- GccIter_FuncTCuPt func(Cu1,ThePoint);
- math_FunctionRoot sol(func,Param1,TheCurveTool::EpsX(Cu1,Abs(Tolang)),U1,U2,100);
- if (sol.IsDone()) {
- Standard_Real Usol = sol.Root();
-// Modified by Sergey KHROMOV - Thu Apr 5 17:45:17 2001 Begin
- Standard_Real Norm;
- func.Value(Usol, Norm);
- if (Abs(Norm) < Tolang) {
-// Modified by Sergey KHROMOV - Thu Apr 5 17:45:19 2001 End
- gp_Pnt2d Origine;
- gp_Vec2d Vect1;
- gp_Vec2d Vect2;
- TheCurveTool::D2(Cu1,Usol,Origine,Vect1,Vect2);
- gp_Vec2d Vdir(ThePoint.XY()-Origine.XY());
- Standard_Real sign1 = Vect1.Dot(Vdir);
- Standard_Real sign2 = Vect2.Crossed(Vdir);
- if (Qualified1.IsUnqualified() ||
- (Qualified1.IsEnclosing() &&
- ((sign1 >= 0. && sign2 <= 0.) || (sign1 <= 0. && sign2 <= 0.))) ||
- (Qualified1.IsOutside() && sign1 <= 0. && sign2 >= 0.) ||
- (Qualified1.IsEnclosed() && sign1 >= 0. && sign2 >= 0.)) {
- WellDone = Standard_True;
- linsol = gp_Lin2d(Origine,gp_Dir2d(Vdir));
- qualifier1 = Qualified1.Qualifier();
- qualifier2 = GccEnt_noqualifier;
- pnttg1sol = Origine;
- pnttg2sol = ThePoint;
- pararg1 = Usol;
- par1sol = 0.;
- pararg2 = ThePoint.Distance(Origine);
- par2sol = 0.;
- }
- }
- }
- }
-
-Standard_Boolean GccIter_Lin2d2Tan::
- IsDone () const { return WellDone; }
-
-gp_Lin2d GccIter_Lin2d2Tan::
- ThisSolution () const
-{
- if (!WellDone) StdFail_NotDone::Raise();
- return linsol;
-}
-
-void GccIter_Lin2d2Tan::
- WhichQualifier (GccEnt_Position& Qualif1 ,
- GccEnt_Position& Qualif2 ) const
-{
- if (!WellDone) { StdFail_NotDone::Raise(); }
- else {
- Qualif1 = qualifier1;
- Qualif2 = qualifier2;
- }
-}
-
-void GccIter_Lin2d2Tan::
- Tangency1 (Standard_Real& ParSol ,
- Standard_Real& ParArg ,
- gp_Pnt2d& Pnt) const {
- if (!WellDone) { StdFail_NotDone::Raise(); }
- else {
- ParSol = par1sol;
- ParArg = pararg1;
- Pnt = pnttg1sol;
- }
- }
-
-void GccIter_Lin2d2Tan::
- Tangency2 (Standard_Real& ParSol ,
- Standard_Real& ParArg ,
- gp_Pnt2d& Pnt) const {
- if (!WellDone) { StdFail_NotDone::Raise(); }
- else {
- ParSol = par2sol;
- ParArg = pararg2;
- Pnt = pnttg2sol;
- }
- }
-
+++ /dev/null
-// Created on: 1991-12-20
-// 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 UNE LIGNE TANGENTE A UNE COURBE ET PARALLELE A UNE DROITE. +
-//========================================================================
-
-#include <IntAna2d_AnaIntersection.hxx>
-#include <IntAna2d_IntPoint.hxx>
-#include <GccIter_IsParallel.hxx>
-#include <StdFail_NotDone.hxx>
-#include <GccEnt_BadQualifier.hxx>
-#include <math_FunctionRoot.hxx>
-#include <gp_XY.hxx>
-#include <gp_Dir2d.hxx>
-#include <gp_Vec2d.hxx>
-#include <gp_Circ2d.hxx>
-
-GccIter_Lin2dTanObl::
- GccIter_Lin2dTanObl (const TheQualifiedCurve& Qualified1 ,
- const gp_Lin2d& TheLin ,
- const Standard_Real Param1 ,
- const Standard_Real TolAng ,
- const Standard_Real Angle ) {
-
- par1sol = 0.;
- pararg1 = 0.;
- WellDone = Standard_False;
- if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
- Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
- GccEnt_BadQualifier::Raise();
- return;
- }
- Paral2 = Standard_False;
- TheCurve Cu1 = Qualified1.Qualified();
- Standard_Real U1 = TheCurveTool::FirstParameter(Cu1);
- Standard_Real U2 = TheCurveTool::LastParameter(Cu1);
- gp_Dir2d Dir(TheLin.Direction());
- Standard_Real A = Dir.X();
- Standard_Real B = Dir.Y();
- gp_Dir2d TheDirection(Dir);
- if (Abs(Angle) > Abs(TolAng)) {
- if (Abs(Abs(Angle)-M_PI) <= Abs(TolAng)) {
- Paral2 = Standard_True;
- TheDirection = Dir.Reversed();
- }
- else if (Abs(Angle-M_PI/2) <= Abs(TolAng)) { TheDirection=gp_Dir2d(-B,A); }
- else if (Abs(Angle+M_PI/2) <= Abs(TolAng)) { TheDirection=gp_Dir2d(B,-A); }
- else {
- TheDirection=gp_Dir2d(A*Cos(Angle)-B*Sin(Angle),
- A*Sin(Angle)+B*Cos(Angle));
- }
- }
- else { Paral2 = Standard_True; }
- GccIter_FuncTObl func(Cu1,TheDirection);
- math_FunctionRoot sol(func,Param1,
- TheCurveTool::EpsX(Cu1,Abs(TolAng)),U1,U2,100);
- if (sol.IsDone()) {
- Standard_Real Usol = sol.Root();
- gp_Pnt2d Origine;
- gp_Vec2d Vect1,Vect2;
- TheCurveTool::D2(Cu1,Usol,Origine,Vect1,Vect2);
- Standard_Real sign1 = Vect1.XY().Dot(TheDirection.XY());
- Standard_Real sign2 = Vect2.XY().Crossed(TheDirection.XY());
- if (Qualified1.IsUnqualified() ||
- (Qualified1.IsEnclosing() && sign2<=0.) ||
- (Qualified1.IsOutside() && sign1 <= 0. && sign2 >= 0.) ||
- (Qualified1.IsEnclosed() && sign1 >= 0. && sign2 >= 0.)) {
- WellDone = Standard_True;
- linsol = gp_Lin2d(Origine,TheDirection);
- pnttg1sol = Origine;
- qualifier1 = Qualified1.Qualifier();
- pararg1 = Usol;
- par1sol = 0.;
- if (!Paral2) {
- IntAna2d_AnaIntersection Intp(linsol,TheLin);
- if (Intp.IsDone() && !Intp.IsEmpty()) {
- if (Intp.NbPoints()==1) {
- pntint2sol = Intp.Point(1).Value();
- par2sol = gp_Vec2d(linsol.Direction()).
- Dot(gp_Vec2d(linsol.Location(),pntint2sol));
- pararg2 = gp_Vec2d(TheLin.Direction()).
- Dot(gp_Vec2d(TheLin.Location(),pntint2sol));
- }
- }
- }
- }
- }
- }
-
-Standard_Boolean GccIter_Lin2dTanObl::
- IsDone () const { return WellDone; }
-
-gp_Lin2d GccIter_Lin2dTanObl::ThisSolution () const
-{
- if (!WellDone) StdFail_NotDone::Raise();
-
- return linsol;
-}
-
-void GccIter_Lin2dTanObl::
- WhichQualifier (GccEnt_Position& Qualif1) const
-{
- if (!WellDone) { StdFail_NotDone::Raise(); }
- else {
- Qualif1 = qualifier1;
- }
-}
-
-Standard_Boolean GccIter_Lin2dTanObl::
- IsParallel2 () const { return Paral2; }
-
-void GccIter_Lin2dTanObl::
- Tangency1 (Standard_Real& ParSol ,
- Standard_Real& ParArg ,
- gp_Pnt2d& PntSol) const {
- if (!WellDone) { StdFail_NotDone::Raise(); }
- else {
- ParSol = par1sol;
- ParArg = pararg1;
- PntSol = gp_Pnt2d(pnttg1sol);
- }
- }
-
-void GccIter_Lin2dTanObl::
- Intersection2 (Standard_Real& ParSol ,
- Standard_Real& ParArg ,
- gp_Pnt2d& PntSol ) const {
- if (!WellDone) { StdFail_NotDone::Raise(); }
- else if (Paral2) { GccIter_IsParallel::Raise(); }
- else {
- PntSol = pntint2sol;
- ParSol = par2sol;
- ParArg = pararg2;
- }
- }
-
uses GccEnt,
GccAna,
- GccIter,
StdFail,
Geom2dInt,
Geom2d,
Adaptor3d,
Adaptor2d,
TColgp,
- gp
+ gp,
+ math
is
class Circ2dTanOnRadGeo;
-class MyC2d3Tan instantiates Circ2d3Tan from GccIter
- (Curve from Geom2dAdaptor,
- CurveTool from Geom2dGcc,
- QCurve from Geom2dGcc);
-
-class MyC2d2TanOn instantiates Circ2d2TanOn from GccIter
- (Curve from Geom2dAdaptor,
- CurveTool from Geom2dGcc,
- QCurve from Geom2dGcc);
-
-class MyL2dTanObl instantiates Lin2dTanObl from GccIter
- (Curve from Geom2dAdaptor,
- CurveTool from Geom2dGcc,
- QCurve from Geom2dGcc);
-
-class MyL2d2Tan instantiates Lin2d2Tan from GccIter
- (Curve from Geom2dAdaptor,
- CurveTool from Geom2dGcc,
- QCurve from Geom2dGcc);
+class Circ2d3TanIter;
+private class FunctionTanCuCuCu;
+
+class Circ2d2TanOnIter;
+private class FunctionTanCuCuOnCu;
+
+class Lin2dTanOblIter;
+private class FunctionTanObl;
+
+class Lin2d2TanIter;
+private class FunctionTanCuCu;
+private class FunctionTanCuPnt;
+private class FunctionTanCirCu;
+
+enumeration Type1 is CuCuCu,CiCuCu,CiCiCu,CiLiCu,LiLiCu,LiCuCu;
+
+enumeration Type2 is CuCuOnCu,CiCuOnCu,LiCuOnCu,CuPtOnCu,
+ CuCuOnLi,CiCuOnLi,LiCuOnLi,CuPtOnLi,
+ CuCuOnCi,CiCuOnCi,LiCuOnCi,CuPtOnCi;
+
+enumeration Type3 is CuCu,CiCu;
+
+exception IsParallel inherits DomainError from Standard;
Unqualified(Obj : Curve from Geom2dAdaptor) returns QualifiedCurve;
---Purpose: Constructs such a qualified curve that the relative
Circ2d from gp,
Circ2d2TanOn from GccAna,
Circ2d2TanOnGeo from Geom2dGcc,
- MyC2d2TanOn from Geom2dGcc,
+ Circ2d2TanOnIter from Geom2dGcc,
Position from GccEnt,
Array1OfPosition from GccEnt
-- CircAna : Circ2d2TanOn from GccAna;
-- CircGeo : Circ2d2TanOnGeo from Geom2dGcc;
--- CircIter : MyC2d2TanOn from Geom2dGcc;
+-- CircIter : Circ2d2TanOnIter from Geom2dGcc;
-- TypeAna : Boolean;
end Circ2d2TanOn;
#include <Geom2dAdaptor_Curve.hxx>
#include <GccAna_Circ2d2TanOn.hxx>
#include <Geom2dGcc_Circ2d2TanOnGeo.hxx>
-#include <Geom2dGcc_MyC2d2TanOn.hxx>
+#include <Geom2dGcc_Circ2d2TanOnIter.hxx>
#include <Geom2dGcc_QCurve.hxx>
#include <GccEnt_BadQualifier.hxx>
#include <Geom2d_Circle.hxx>
}
}
}
-
-//=============================================================================
-// Appel a GccIter. +
-//=============================================================================
-
else {
Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
Geom2dGcc_QCurve Qc2(C2,Qualified2.Qualifier());
if ((Type3 == GeomAbs_Circle || Type3 == GeomAbs_Line)) {
if (Type3 == GeomAbs_Circle) {
Handle(Geom2d_Circle) CCon = Handle(Geom2d_Circle)::DownCast(Con);
- Geom2dGcc_MyC2d2TanOn Circ(Qc1,Qc2,CCon->Circ2d(),
+ Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Qc2,CCon->Circ2d(),
Param1,Param2,ParamOn,Tolerance);
WellDone = Circ.IsDone();
NbrSol = 1;
}
else {
Handle(Geom2d_Line) LLon = Handle(Geom2d_Line)::DownCast(Con);
- Geom2dGcc_MyC2d2TanOn Circ(Qc1,Qc2,LLon->Lin2d(),
+ Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Qc2,LLon->Lin2d(),
Param1,Param2,ParamOn,Tolerance);
WellDone = Circ.IsDone();
NbrSol = 1;
Circ.Tangency2(par2sol(1),pararg2(1),pnttg2sol(1));
}
}
- Geom2dGcc_MyC2d2TanOn Circ(Qc1,Qc2,OnCurve,
+ Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Qc2,OnCurve,
Param1,Param2,ParamOn,Tolerance);
WellDone = Circ.IsDone();
NbrSol = 1;
Results(CircGeo);
}
}
- }
-
-//=============================================================================
-// Appel a GccIter. +
-//=============================================================================
-
+ }
else {
Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
if ((Type3 == GeomAbs_Circle || Type3 == GeomAbs_Line)) {
if (Type3 == GeomAbs_Circle) {
Handle(Geom2d_Circle) CCon = Handle(Geom2d_Circle)::DownCast(Con);
- Geom2dGcc_MyC2d2TanOn Circ(Qc1,Point->Pnt2d(),CCon->Circ2d(),
+ Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Point->Pnt2d(),CCon->Circ2d(),
Param1,ParamOn,Tolerance);
WellDone = Circ.IsDone();
NbrSol = 1;
}
else {
Handle(Geom2d_Line) LLon = Handle(Geom2d_Line)::DownCast(Con);
- Geom2dGcc_MyC2d2TanOn Circ(Qc1,Point->Pnt2d(),LLon->Lin2d(),
+ Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Point->Pnt2d(),LLon->Lin2d(),
Param1,ParamOn,Tolerance);
WellDone = Circ.IsDone();
NbrSol = 1;
}
}
else {
- Geom2dGcc_MyC2d2TanOn Circ(Qc1,Point->Pnt2d(),OnCurve,
+ Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Point->Pnt2d(),OnCurve,
Param1,ParamOn,Tolerance);
WellDone = Circ.IsDone();
NbrSol = 1;
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
-generic class Circ2d2TanOn from GccIter (
- TheCurve as any;
- TheCurveTool as any;
- TheQualifiedCurve as any) -- as QualifiedCurve from GccEnt
- -- (TheCurve)
+class Circ2d2TanOnIter from Geom2dGcc
---Purpose: This class implements the algorithms used to
-- create 2d circles TANgent to 2 entities and
Circ2d from gp,
QualifiedCirc from GccEnt,
QualifiedLin from GccEnt,
- Position from GccEnt
+ Position from GccEnt,
+ Curve from Geom2dAdaptor,
+ CurveTool from Geom2dGcc,
+ QCurve from Geom2dGcc
raises NotDone from StdFail
-private class FuncTCuCuOnCu instantiates FunctionTanCuCuOnCu from GccIter (
- TheCurve,TheCurveTool);
is
-- On a 2d line ..........................................................
Create(Qualified1 : QualifiedCirc ;
- Qualified2 : TheQualifiedCurve ;
+ Qualified2 : QCurve from Geom2dGcc;
OnLine : Lin2d ;
Param1 : Real ;
Param2 : Real ;
Param3 : Real ;
- Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
+ Tolerance : Real ) returns Circ2d2TanOnIter from Geom2dGcc ;
---Purpose: This method implements the algorithms used to
-- create 2d circles TANgent to a 2d circle and a curve and
-- having the center ON a 2d line.
-- Tolerance is used for the limit cases.
Create(Qualified1 : QualifiedLin ;
- Qualified2 : TheQualifiedCurve ;
+ Qualified2 : QCurve from Geom2dGcc;
OnLine : Lin2d ;
Param1 : Real ;
Param2 : Real ;
Param3 : Real ;
- Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
+ Tolerance : Real ) returns Circ2d2TanOnIter from Geom2dGcc ;
---Purpose: This method implements the algorithms used to
-- create 2d circles TANgent to a 2d line and a curve and
-- having the center ON a 2d line.
-- Param2 is the initial guess on the curve QualifiedCurv.
-- Tolerance is used for the limit cases.
-Create(Qualified1 : TheQualifiedCurve ;
- Qualified2 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc;
+ Qualified2 : QCurve from Geom2dGcc;
OnLine : Lin2d ;
Param1 : Real ;
Param2 : Real ;
Param3 : Real ;
- Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
+ Tolerance : Real ) returns Circ2d2TanOnIter from Geom2dGcc ;
---Purpose: This method implements the algorithms used to
-- create 2d circles TANgent to two curves and
-- having the center ON a 2d line.
-- Param2 is the initial guess on the first QualifiedCurv.
-- Tolerance is used for the limit cases.
-Create(Qualified1 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc;
Point2 : Pnt2d ;
OnLine : Lin2d ;
Param1 : Real ;
Param2 : Real ;
- Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
+ Tolerance : Real ) returns Circ2d2TanOnIter from Geom2dGcc ;
---Purpose: This method implements the algorithms used to
-- create 2d circles TANgent to a 2d point and a curve and
-- having the center ON a 2d line.
-- -- On a 2d Circle .....................................................
Create(Qualified1 : QualifiedCirc ;
- Qualified2 : TheQualifiedCurve ;
+ Qualified2 : QCurve from Geom2dGcc;
OnCirc : Circ2d ;
Param1 : Real ;
Param2 : Real ;
Param3 : Real ;
- Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
+ Tolerance : Real ) returns Circ2d2TanOnIter from Geom2dGcc ;
---Purpose: This method implements the algorithms used to
-- create 2d circles TANgent to a 2d circle and a curve and
-- having the center ON a 2d circle.
-- Tolerance is used for the limit cases.
Create(Qualified1 : QualifiedLin ;
- Qualified2 : TheQualifiedCurve ;
+ Qualified2 : QCurve from Geom2dGcc;
OnCirc : Circ2d ;
Param1 : Real ;
Param2 : Real ;
Param3 : Real ;
- Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
+ Tolerance : Real ) returns Circ2d2TanOnIter from Geom2dGcc ;
---Purpose: This method implements the algorithms used to
-- create 2d circles TANgent to a 2d line and a curve and
-- having the center ON a 2d circle.
-- Param2 is the initial guess on the curve QualifiedCurv.
-- Tolerance is used for the limit cases.
-Create(Qualified1 : TheQualifiedCurve ;
- Qualified2 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc;
+ Qualified2 : QCurve from Geom2dGcc;
OnCirc : Circ2d ;
Param1 : Real ;
Param2 : Real ;
Param3 : Real ;
- Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
+ Tolerance : Real ) returns Circ2d2TanOnIter from Geom2dGcc ;
---Purpose: This method implements the algorithms used to
-- create 2d circles TANgent to two curves and
-- having the center ON a 2d circle.
-- Param2 is the initial guess on the first QualifiedCurv.
-- Tolerance is used for the limit cases.
-Create(Qualified1 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc;
Point2 : Pnt2d ;
OnCirc : Circ2d ;
Param1 : Real ;
Param2 : Real ;
- Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
+ Tolerance : Real ) returns Circ2d2TanOnIter from Geom2dGcc ;
---Purpose: This method implements the algorithms used to
-- create 2d circles TANgent to a 2d point and a curve and
-- having the center ON a 2d circle.
-- -- On a curve .....................................................
Create(Qualified1 : QualifiedCirc ;
- Qualified2 : TheQualifiedCurve ;
- OnCurv : TheCurve ;
+ Qualified2 : QCurve from Geom2dGcc;
+ OnCurv : Curve from Geom2dAdaptor;
Param1 : Real ;
Param2 : Real ;
ParamOn : Real ;
- Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
+ Tolerance : Real ) returns Circ2d2TanOnIter from Geom2dGcc ;
---Purpose: This method implements the algorithms used to
-- create 2d circles TANgent to a 2d circle and a curve and
-- having the center ON a 2d curve.
-- Tolerance is used for the limit cases.
Create(Qualified1 : QualifiedLin ;
- Qualified2 : TheQualifiedCurve ;
- OnCurve : TheCurve ;
+ Qualified2 : QCurve from Geom2dGcc;
+ OnCurve : Curve from Geom2dAdaptor;
Param1 : Real ;
Param2 : Real ;
ParamOn : Real ;
- Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
+ Tolerance : Real ) returns Circ2d2TanOnIter from Geom2dGcc ;
---Purpose: This method implements the algorithms used to
-- create 2d circles TANgent to a 2d line and a curve and
-- having the center ON a 2d curve.
-- ParamOn is the initial guess on the center curve OnCurv.
-- Tolerance is used for the limit cases.
-Create(Qualified1 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc;
Point2 : Pnt2d ;
- OnCurve : TheCurve ;
+ OnCurve : Curve from Geom2dAdaptor;
Param1 : Real ;
ParamOn : Real ;
- Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
+ Tolerance : Real ) returns Circ2d2TanOnIter from Geom2dGcc ;
---Purpose: This method implements the algorithms used to
-- create 2d circles TANgent to a 2d Point and a curve and
-- having the center ON a 2d curve.
-- ParamOn is the initial guess on the center curve OnCurv.
-- Tolerance is used for the limit cases.
-Create(Qualified1 : TheQualifiedCurve ;
- Qualified2 : TheQualifiedCurve ;
- OnCurve : TheCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc;
+ Qualified2 : QCurve from Geom2dGcc;
+ OnCurve : Curve from Geom2dAdaptor;
Param1 : Real ;
Param2 : Real ;
ParamOn : Real ;
- Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
+ Tolerance : Real ) returns Circ2d2TanOnIter from Geom2dGcc ;
---Purpose: This method implements the algorithms used to
-- create 2d circles TANgent to two curves and
-- having the center ON a 2d curve.
---Purpose: The parameter of the center point of the solution
-- on the second argument.
-end Circ2d2TanOn;
+end Circ2d2TanOnIter;
--- /dev/null
+// 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 <Geom2dGcc_Circ2d2TanOnIter.ixx>
+
+#include <gp_Dir2d.hxx>
+#include <gp_Ax2d.hxx>
+#include <gp.hxx>
+#include <StdFail_NotDone.hxx>
+#include <GccEnt_BadQualifier.hxx>
+#include <math_FunctionSetRoot.hxx>
+#include <ElCLib.hxx>
+
+#include <Geom2dGcc_CurveTool.hxx>
+#include <Geom2dGcc_FunctionTanCuCuOnCu.hxx>
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin& Qualified1 ,
+ const Geom2dGcc_QCurve& Qualified2 ,
+ const gp_Lin2d& OnLine ,
+ const Standard_Real Param1 ,
+ const Standard_Real Param2 ,
+ const Standard_Real Param3 ,
+ const Standard_Real Tolang ) {
+
+ TheSame1 = Standard_False;
+ TheSame2 = Standard_False;
+ par1sol = 0.;
+ par2sol = 0.;
+ pararg1 = 0.;
+ pararg2 = 0.;
+ parcen3 = 0.;
+
+ WellDone = Standard_False;
+ Standard_Real Tol = Abs(Tolang);
+ WellDone = Standard_False;
+ if (!(Qualified1.IsEnclosed() ||
+ Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+ !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
+ Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+ GccEnt_BadQualifier::Raise();
+ return;
+ }
+ gp_Dir2d dirx(1.,0.);
+ gp_Lin2d L1 = Qualified1.Qualified();
+ Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ math_Vector Umin(1,4);
+ math_Vector Umax(1,4);
+ math_Vector Ufirst(1,4);
+ math_Vector tol(1,4);
+ Umin(1) = RealFirst();
+ Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+ Umin(3) = RealFirst();
+ Umin(4) = 0.;
+ Umax(1) = RealLast();
+ Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+ Umax(3) = RealLast();
+ Umax(4) = RealLast();
+ Ufirst(1) = Param1;
+ Ufirst(2) = Param2;
+ Ufirst(3) = Param3;
+ tol(1) = 1.e-15;
+ tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Tolang);
+ tol(3) = tol(1);
+ tol(4) = tol(1);
+ gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
+ gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+ gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
+ Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+ Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnLine,Ufirst(4));
+ math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+ Func.Value(Ufirst,Umin);
+ if (Root.IsDone()) {
+ Root.Root(Ufirst);
+ // gp_Vec2d Tan1,Tan2,Nor1,Nor2;
+ gp_Vec2d Tan1,Tan2;
+ ElCLib::D1(Ufirst(1),L1,point1,Tan1);
+ Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+ gp_Vec2d Tan3(OnLine.Direction().XY());
+ gp_Pnt2d point3(OnLine.Location().XY()+Ufirst(3)*Tan3.XY());
+ Standard_Real dist1 = point3.Distance(point1);
+ Standard_Real dist2 = point3.Distance(point2);
+ if ( Abs(dist1-dist2)/2. <= Tol) {
+ cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+ Standard_Real normetan2 = Tan2.Magnitude();
+ gp_Vec2d Vec1(point1,point3);
+ gp_Vec2d Vec2(point2,point3);
+ Standard_Real normevec2 = Vec2.Magnitude();
+ Standard_Real angle2;
+ if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+ angle2 = Vec2.Angle(Tan2);
+ }
+ else { angle2 = 0.; }
+ Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
+ L1.Direction().X()));
+ if (Qualified1.IsUnqualified() ||
+ (Qualified1.IsOutside() && pscal <= 0.) ||
+ (Qualified1.IsEnclosed() && pscal >= 0.)) {
+ if (Qualified2.IsUnqualified() ||
+ (Qualified2.IsEnclosing()&&angle2<=0.)||
+ (Qualified2.IsOutside() && angle2 >= 0) ||
+ (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+ qualifier1 = Qualified1.Qualifier();
+ qualifier2 = Qualified2.Qualifier();
+ pnttg1sol = point1;
+ pararg1 = Ufirst(1);
+ par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+ pnttg2sol = point2;
+ pararg2 = Ufirst(2);
+ par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+ pntcen = point3;
+ parcen3 = Ufirst(3);
+ WellDone = Standard_True;
+ }
+ }
+ }
+ }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
+ const Geom2dGcc_QCurve& Qualified2 ,
+ const gp_Lin2d& OnLine ,
+ const Standard_Real Param1 ,
+ const Standard_Real Param2 ,
+ const Standard_Real Param3 ,
+ const Standard_Real Tolerance ) {
+ TheSame1 = Standard_False;
+ TheSame2 = Standard_False;
+ par1sol = 0.;
+ par2sol = 0.;
+ pararg1 = 0.;
+ pararg2 = 0.;
+ parcen3 = 0.;
+
+ WellDone = Standard_False;
+ if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
+ Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+ !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
+ Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+ GccEnt_BadQualifier::Raise();
+ return;
+ }
+ Standard_Real Tol = Abs(Tolerance);
+ gp_Dir2d dirx(1.,0.);
+ Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ math_Vector Umin(1,4);
+ math_Vector Umax(1,4);
+ math_Vector Ufirst(1,4);
+ math_Vector tol(1,4);
+ Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
+ Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+ Umin(3) = RealFirst();
+ Umin(4) = 0.;
+ Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
+ Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+ Umax(3) = RealLast();
+ Umax(4) = RealLast();
+ 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) = 1.e-15;
+ tol(4) = Tol/10.;
+ gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
+ gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+ gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
+ Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+ Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnLine,Ufirst(4));
+ math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+ Func.Value(Ufirst,Umin);
+ if (Root.IsDone()) {
+ Root.Root(Ufirst);
+ gp_Vec2d Tan1,Tan2;
+ Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
+ Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+ gp_Vec2d Tan3(OnLine.Direction().XY());
+ gp_Pnt2d point3(OnLine.Location().XY()+Ufirst(3)*Tan3.XY());
+ Standard_Real dist1 = point3.Distance(point1);
+ Standard_Real dist2 = point3.Distance(point2);
+ if ( Abs(dist1-dist2)/2. <= Tol) {
+ cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+ Standard_Real normetan1 = Tan1.Magnitude();
+ Standard_Real normetan2 = Tan2.Magnitude();
+ gp_Vec2d Vec1(point1,point3);
+ gp_Vec2d Vec2(point2,point3);
+ Standard_Real normevec1 = Vec1.Magnitude();
+ Standard_Real normevec2 = Vec2.Magnitude();
+ Standard_Real angle1,angle2;
+ if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+ angle1 = Vec1.Angle(Tan1);
+ }
+ else { angle1 = 0.; }
+ if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+ angle2 = Vec2.Angle(Tan2);
+ }
+ else { angle2 = 0.; }
+ if (Qualified1.IsUnqualified()||
+ (Qualified1.IsEnclosing()&&angle1<=0.)||
+ (Qualified1.IsOutside() && angle1 >= 0.) ||
+ (Qualified1.IsEnclosed() && angle1 <= 0.)) {
+ if (Qualified2.IsUnqualified() ||
+ (Qualified2.IsEnclosing()&&angle2<=0.)||
+ (Qualified2.IsOutside() && angle2 >= 0) ||
+ (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+ qualifier1 = Qualified1.Qualifier();
+ qualifier2 = Qualified2.Qualifier();
+ pnttg1sol = point1;
+ pararg1 = Ufirst(1);
+ par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+ pnttg2sol = point2;
+ pararg2 = Ufirst(2);
+ par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+ pntcen = point3;
+ parcen3 = Ufirst(3);
+ WellDone = Standard_True;
+ }
+ }
+ }
+ }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
+ const gp_Pnt2d& Point2 ,
+ const gp_Lin2d& OnLine ,
+ const Standard_Real Param1 ,
+ const Standard_Real Param2 ,
+ const Standard_Real Tolerance ) {
+ TheSame1 = Standard_False;
+ TheSame2 = Standard_False;
+ par1sol = 0.;
+ par2sol = 0.;
+ pararg1 = 0.;
+ pararg2 = 0.;
+ parcen3 = 0.;
+
+ WellDone = Standard_False;
+ if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
+ Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
+ GccEnt_BadQualifier::Raise();
+ return;
+ }
+ Standard_Real Tol = Abs(Tolerance);
+ gp_Dir2d dirx(1.,0.);
+ Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ 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) = RealFirst();
+ Umin(3) = 0.;
+ Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
+ Umax(2) = RealLast();
+ Umax(3) = RealLast();
+ Ufirst(1) = Param1;
+ Ufirst(2) = Param2;
+ tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
+ tol(2) = 1.e-15;
+ tol(3) = Tol/10.;
+ gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
+ gp_Pnt2d point3 = ElCLib::Value(Param2,OnLine);
+ Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
+ Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnLine,Ufirst(3));
+ math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+ Func.Value(Ufirst,Umin);
+ if (Root.IsDone()) {
+ Root.Root(Ufirst);
+ gp_Pnt2d point1,point3;
+ gp_Vec2d Tan1,Tan3;
+ Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
+ ElCLib::D1(Ufirst(2),OnLine,point3,Tan3);
+ Standard_Real dist1 = point3.Distance(point1);
+ Standard_Real dist2 = point3.Distance(Point2);
+ if ( Abs(dist1-dist2)/2. <= Tol) {
+ cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+ Standard_Real normetan1 = Tan1.Magnitude();
+ gp_Vec2d Vec1(point1,point3);
+ Standard_Real normevec1 = Vec1.Magnitude();
+ Standard_Real angle1;
+ if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+ angle1 = Vec1.Angle(Tan1);
+ }
+ else { angle1 = 0.; }
+ if (Qualified1.IsUnqualified()||
+ (Qualified1.IsEnclosing()&&angle1<=0.)||
+ (Qualified1.IsOutside() && angle1 >= 0.) ||
+ (Qualified1.IsEnclosed() && angle1 <= 0.)) {
+ qualifier1 = Qualified1.Qualifier();
+ qualifier2 = GccEnt_noqualifier;
+ pnttg1sol = point1;
+ pararg1 = Ufirst(1);
+ par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+ pnttg2sol = Point2;
+ pararg2 = Ufirst(2);
+ par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+ pntcen = point3;
+ parcen3 = Ufirst(3);
+ WellDone = Standard_True;
+ }
+ }
+ }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 ,
+ const Geom2dGcc_QCurve& Qualified2 ,
+ const gp_Lin2d& OnLine ,
+ const Standard_Real Param1 ,
+ const Standard_Real Param2 ,
+ const Standard_Real Param3 ,
+ const Standard_Real Tolerance ) {
+ TheSame1 = Standard_False;
+ TheSame2 = Standard_False;
+ par1sol = 0.;
+ par2sol = 0.;
+ pararg1 = 0.;
+ pararg2 = 0.;
+ parcen3 = 0.;
+
+ WellDone = Standard_False;
+ if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
+ Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+ !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
+ Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+ GccEnt_BadQualifier::Raise();
+ return;
+ }
+ Standard_Real Tol = Abs(Tolerance);
+ gp_Dir2d dirx(1.,0.);
+ gp_Circ2d C1 = Qualified1.Qualified();
+ Standard_Real R1 = C1.Radius();
+ Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ math_Vector Umin(1,4);
+ math_Vector Umax(1,4);
+ math_Vector Ufirst(1,4);
+ math_Vector tol(1,4);
+ Umin(1) = RealFirst();
+ Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+ Umin(3) = RealFirst();
+ Umin(4) = 0.;
+ Umax(1) = RealLast();
+ Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+ Umax(3) = RealLast();
+ Umax(4) = RealLast();
+ 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) = 1.e-15;
+ tol(4) = Tol/10.;
+ gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
+ gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+ gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
+ Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+ Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnLine,Ufirst(4));
+ math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+ Func.Value(Ufirst,Umin);
+ if (Root.IsDone()) {
+ Root.Root(Ufirst);
+ // gp_Vec2d Tan1,Tan2,Nor1,Nor2;
+ gp_Vec2d Tan1,Tan2,Nor2;
+ ElCLib::D2(Ufirst(1),C1,point1,Tan1,Nor2);
+ Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+#ifdef DEB
+ gp_Vec2d Tan3(OnLine.Direction().XY());
+#else
+ OnLine.Direction().XY();
+#endif
+ point3 = ElCLib::Value(Ufirst(1),OnLine);
+ Standard_Real dist1 = point3.Distance(point1);
+ Standard_Real dist2 = point3.Distance(point2);
+ if ( Abs(dist1-dist2)/2. <= Tol) {
+ cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+ Standard_Real normetan2 = Tan2.Magnitude();
+ gp_Vec2d Vec1(point1,point3);
+ gp_Vec2d Vec2(point2,point3);
+ Standard_Real normevec2 = Vec2.Magnitude();
+ Standard_Real angle2;
+ if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+ angle2 = Vec2.Angle(Tan2);
+ }
+ else { angle2 = 0.; }
+ Standard_Real dist = C1.Location().Distance(point3);
+ Standard_Real Rsol = cirsol.Radius();
+ if (Qualified1.IsUnqualified() ||
+ (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
+ (Qualified1.IsOutside() && dist >= Rsol) ||
+ (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
+ if (Qualified2.IsUnqualified() ||
+ (Qualified2.IsEnclosing()&&angle2<=0.)||
+ (Qualified2.IsOutside() && angle2 >= 0) ||
+ (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+ qualifier1 = Qualified1.Qualifier();
+ qualifier2 = Qualified2.Qualifier();
+ pnttg1sol = point1;
+ pararg1 = Ufirst(1);
+ par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+ pnttg2sol = point2;
+ pararg2 = Ufirst(2);
+ par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+ pntcen = point3;
+ parcen3 = Ufirst(3);
+ WellDone = Standard_True;
+ }
+ }
+ }
+ }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 ,
+ const Geom2dGcc_QCurve& Qualified2 ,
+ const gp_Circ2d& OnCirc ,
+ const Standard_Real Param1 ,
+ const Standard_Real Param2 ,
+ const Standard_Real Param3 ,
+ const Standard_Real Tolerance ) {
+ TheSame1 = Standard_False;
+ TheSame2 = Standard_False;
+ par1sol = 0.;
+ par2sol = 0.;
+ pararg1 = 0.;
+ pararg2 = 0.;
+ parcen3 = 0.;
+
+ WellDone = Standard_False;
+ if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
+ Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+ !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
+ Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+ GccEnt_BadQualifier::Raise();
+ return;
+ }
+ Standard_Real Tol = Abs(Tolerance);
+ gp_Dir2d dirx(1.,0.);
+ gp_Circ2d C1 = Qualified1.Qualified();
+ Standard_Real R1 = C1.Radius();
+ Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ math_Vector Umin(1,4);
+ math_Vector Umax(1,4);
+ math_Vector Ufirst(1,4);
+ math_Vector tol(1,4);
+ Umin(1) = RealFirst();
+ Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+ Umin(3) = RealFirst();
+ Umin(4) = 0.;
+ Umax(1) = RealLast();
+ Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+ Umax(3) = RealLast();
+ Umax(4) = RealLast();
+ 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) = 2.e-15*M_PI;
+ tol(4) = Tol/10.;
+ gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
+ gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+ gp_Pnt2d point3 = ElCLib::Value(Param3,OnCirc);
+ Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+ Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnCirc,Ufirst(4));
+ math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+ Func.Value(Ufirst,Umin);
+ if (Root.IsDone()) {
+ Root.Root(Ufirst);
+ // gp_Vec2d Tan1,Tan2,Nor1;
+ gp_Vec2d Tan1,Tan2;
+ ElCLib::D1(Ufirst(1),C1,point1,Tan1);
+ Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+#ifdef DEB
+ gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
+#endif
+ point3 = ElCLib::Value(Ufirst(3),OnCirc);
+ Standard_Real dist1 = point3.Distance(point1);
+ Standard_Real dist2 = point3.Distance(point2);
+ if ( Abs(dist1-dist2)/2. <= Tol) {
+ cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+ Standard_Real normetan2 = Tan2.Magnitude();
+ gp_Vec2d Vec1(point1,point3);
+ gp_Vec2d Vec2(point2,point3);
+ Standard_Real normevec2 = Vec2.Magnitude();
+ Standard_Real angle2;
+ if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+ angle2 = Vec2.Angle(Tan2);
+ }
+ else { angle2 = 0.; }
+ Standard_Real dist = C1.Location().Distance(point3);
+ Standard_Real Rsol = cirsol.Radius();
+ if (Qualified1.IsUnqualified() ||
+ (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
+ (Qualified1.IsOutside() && dist >= Rsol) ||
+ (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
+ if (Qualified2.IsUnqualified() ||
+ (Qualified2.IsEnclosing()&&angle2<=0.)||
+ (Qualified2.IsOutside() && angle2 >= 0) ||
+ (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+ qualifier1 = Qualified1.Qualifier();
+ qualifier2 = Qualified2.Qualifier();
+ pnttg1sol = point1;
+ pararg1 = Ufirst(1);
+ par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+ pnttg2sol = point2;
+ pararg2 = Ufirst(2);
+ par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+ pntcen = point3;
+ parcen3 = Ufirst(3);
+ WellDone = Standard_True;
+ }
+ }
+ }
+ }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin& Qualified1 ,
+ const Geom2dGcc_QCurve& Qualified2 ,
+ const gp_Circ2d& OnCirc ,
+ const Standard_Real Param1 ,
+ const Standard_Real Param2 ,
+ const Standard_Real Param3 ,
+ const Standard_Real Tolerance ) {
+ TheSame1 = Standard_False;
+ TheSame2 = Standard_False;
+ par1sol = 0.;
+ par2sol = 0.;
+ pararg1 = 0.;
+ pararg2 = 0.;
+ parcen3 = 0.;
+
+ WellDone = Standard_False;
+ if (!(Qualified1.IsEnclosed() ||
+ Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+ !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
+ Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+ GccEnt_BadQualifier::Raise();
+ return;
+ }
+ Standard_Real Tol = Abs(Tolerance);
+ gp_Dir2d dirx(1.,0.);
+ gp_Lin2d L1 = Qualified1.Qualified();
+ Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ math_Vector Umin(1,4);
+ math_Vector Umax(1,4);
+ math_Vector Ufirst(1,4);
+ math_Vector tol(1,4);
+ Umin(1) = RealFirst();
+ Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+ Umin(3) = RealFirst();
+ Umin(4) = 0.;
+ Umax(1) = RealLast();
+ Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+ Umax(3) = RealLast();
+ Umax(4) = RealLast();
+ Ufirst(1) = Param1;
+ Ufirst(2) = Param2;
+ Ufirst(3) = Param3;
+ tol(1) = 1.e-15;
+ tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
+ tol(3) = 2.e-15*M_PI;
+ tol(4) = Tol/10.;
+ gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
+ gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+ gp_Pnt2d point3 = ElCLib::Value(Param3,OnCirc);
+ Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+ Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnCirc,Ufirst(4));
+ math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+ Func.Value(Ufirst,Umin);
+ if (Root.IsDone()) {
+ Root.Root(Ufirst);
+ gp_Pnt2d point1,point2;
+ gp_Vec2d Tan1,Tan2;
+ ElCLib::D1(Ufirst(1),L1,point1,Tan1);
+ Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+#ifdef DEB
+ gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
+#endif
+ point3 = ElCLib::Value(Ufirst(3),OnCirc);
+ Standard_Real dist1 = point3.Distance(point1);
+ Standard_Real dist2 = point3.Distance(point2);
+ if ( Abs(dist1-dist2)/2. <= Tol) {
+ cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+ Standard_Real normetan2 = Tan2.Magnitude();
+ gp_Vec2d Vec1(point1,point3);
+ gp_Vec2d Vec2(point2,point3);
+ Standard_Real normevec2 = Vec2.Magnitude();
+ Standard_Real angle2;
+ if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+ angle2 = Vec2.Angle(Tan2);
+ }
+ else { angle2 = 0.; }
+ Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
+ L1.Direction().X()));
+ if (Qualified1.IsUnqualified() ||
+ (Qualified1.IsOutside() && pscal <= 0.) ||
+ (Qualified1.IsEnclosed() && pscal >= 0.)) {
+ if (Qualified2.IsUnqualified() ||
+ (Qualified2.IsEnclosing()&&angle2<=0.)||
+ (Qualified2.IsOutside() && angle2 >= 0) ||
+ (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+ qualifier1 = Qualified1.Qualifier();
+ qualifier2 = Qualified2.Qualifier();
+ pnttg1sol = point1;
+ pararg1 = Ufirst(1);
+ par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+ pnttg2sol = point2;
+ pararg2 = Ufirst(2);
+ par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+ pntcen = point3;
+ parcen3 = Ufirst(3);
+ WellDone = Standard_True;
+ }
+ }
+ }
+ }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
+ const Geom2dGcc_QCurve& Qualified2 ,
+ const gp_Circ2d& OnCirc ,
+ const Standard_Real Param1 ,
+ const Standard_Real Param2 ,
+ const Standard_Real Param3 ,
+ const Standard_Real Tolerance ) {
+ TheSame1 = Standard_False;
+ TheSame2 = Standard_False;
+ par1sol = 0.;
+ par2sol = 0.;
+ pararg1 = 0.;
+ pararg2 = 0.;
+ parcen3 = 0.;
+
+ WellDone = Standard_False;
+ if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
+ Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+ !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
+ Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+ GccEnt_BadQualifier::Raise();
+ return;
+ }
+ Standard_Real Tol = Abs(Tolerance);
+ gp_Dir2d dirx(1.,0.);
+ Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ math_Vector Umin(1,4);
+ math_Vector Umax(1,4);
+ math_Vector Ufirst(1,4);
+ math_Vector tol(1,4);
+ Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
+ Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+ Umin(3) = RealFirst();
+ Umin(4) = 0.;
+ Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
+ Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+ Umax(3) = RealLast();
+ Umax(4) = RealLast();
+ 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) = 2.e-15*M_PI;
+ tol(4) = Tol/10.;
+ gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
+ gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+ Standard_Real R1 = OnCirc.Radius();
+ gp_Pnt2d point3(OnCirc.Location().XY()+R1*gp_XY(Cos(Param3),Sin(Param3)));
+ Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+ Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnCirc,Ufirst(4));
+ math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+ Func.Value(Ufirst,Umin);
+ if (Root.IsDone()) {
+ Root.Root(Ufirst);
+ // gp_Vec2d Tan1,Tan2,Nor1;
+ gp_Vec2d Tan1,Tan2;
+ Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
+ Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+#ifdef DEB
+ gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
+#endif
+ point3 = gp_Pnt2d(OnCirc.Location().XY()+
+ R1*gp_XY(Cos(Ufirst(3)),Sin(Ufirst(3))));
+ Standard_Real dist1 = point3.Distance(point1);
+ Standard_Real dist2 = point3.Distance(point2);
+ if ( Abs(dist1-dist2)/2. <= Tol) {
+ cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+ Standard_Real normetan1 = Tan1.Magnitude();
+ Standard_Real normetan2 = Tan2.Magnitude();
+ gp_Vec2d Vec1(point1,point3);
+ gp_Vec2d Vec2(point2,point3);
+ Standard_Real normevec1 = Vec1.Magnitude();
+ Standard_Real normevec2 = Vec2.Magnitude();
+ Standard_Real angle1,angle2;
+ if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+ angle1 = Vec1.Angle(Tan1);
+ }
+ else { angle1 = 0.; }
+ if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+ angle2 = Vec2.Angle(Tan2);
+ }
+ else { angle2 = 0.; }
+ if (Qualified1.IsUnqualified()||
+ (Qualified1.IsEnclosing()&&angle1<=0.)||
+ (Qualified1.IsOutside() && angle1 >= 0.) ||
+ (Qualified1.IsEnclosed() && angle1 <= 0.)) {
+ if (Qualified2.IsUnqualified() ||
+ (Qualified2.IsEnclosing()&&angle2<=0.)||
+ (Qualified2.IsOutside() && angle2 >= 0) ||
+ (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+ qualifier1 = Qualified1.Qualifier();
+ qualifier2 = Qualified2.Qualifier();
+ pararg1 = Ufirst(1);
+ par1sol = 0.;
+ pnttg1sol = point1;
+ pararg2 = Ufirst(2);
+ pnttg2sol = point2;
+ par2sol = pnttg2sol.Distance(pnttg1sol);
+ pntcen = point3;
+ parcen3 = Ufirst(3);
+ WellDone = Standard_True;
+ }
+ }
+ }
+ }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
+ const gp_Pnt2d& Point2 ,
+ const gp_Circ2d& OnCirc ,
+ const Standard_Real Param1 ,
+ const Standard_Real Param2 ,
+ const Standard_Real Tolerance ) {
+ TheSame1 = Standard_False;
+ TheSame2 = Standard_False;
+ par1sol = 0.;
+ par2sol = 0.;
+ pararg1 = 0.;
+ pararg2 = 0.;
+ parcen3 = 0.;
+
+ WellDone = Standard_False;
+ if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
+ Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
+ GccEnt_BadQualifier::Raise();
+ return;
+ }
+ Standard_Real Tol = Abs(Tolerance);
+ gp_Dir2d dirx(1.,0.);
+ Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ 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) = RealFirst();
+ Umin(3) = 0.;
+ Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
+ Umax(2) = RealLast();
+ Umax(3) = RealLast();
+ Ufirst(1) = Param1;
+ Ufirst(2) = Param2;
+ tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
+ tol(2) = 2.e-15*M_PI;
+ tol(3) = Tol/10.;
+ gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
+ gp_Pnt2d point3 = ElCLib::Value(Param2,OnCirc);
+ Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
+ Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnCirc,Ufirst(3));
+ math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+ Func.Value(Ufirst,Umin);
+ if (Root.IsDone()) {
+ Root.Root(Ufirst);
+ gp_Pnt2d point1,point3;
+ gp_Vec2d Tan1,Tan3;
+ Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
+ ElCLib::D1(Ufirst(2),OnCirc,point3,Tan3);
+ Standard_Real dist1 = point3.Distance(point1);
+ Standard_Real dist2 = point3.Distance(Point2);
+ if ( Abs(dist1-dist2)/2. <= Tol) {
+ cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+ Standard_Real normetan1 = Tan1.Magnitude();
+ gp_Vec2d Vec1(point1,point3);
+ Standard_Real normevec1 = Vec1.Magnitude();
+ Standard_Real angle1;
+ if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+ angle1 = Vec1.Angle(Tan1);
+ }
+ else { angle1 = 0.; }
+ if (Qualified1.IsUnqualified()||
+ (Qualified1.IsEnclosing()&&angle1<=0.)||
+ (Qualified1.IsOutside() && angle1 >= 0.) ||
+ (Qualified1.IsEnclosed() && angle1 <= 0.)) {
+ qualifier1 = Qualified1.Qualifier();
+ qualifier2 = GccEnt_noqualifier;
+ pnttg1sol = point1;
+ pararg1 = Ufirst(1);
+ par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+ pnttg2sol = Point2;
+ pararg2 = 0.;
+ par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+ pntcen = point3;
+ parcen3 = Ufirst(3);
+ WellDone = Standard_True;
+ }
+ }
+ }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
+ const Geom2dGcc_QCurve& Qualified2 ,
+ const Geom2dAdaptor_Curve& OnCurv ,
+ const Standard_Real Param1 ,
+ const Standard_Real Param2 ,
+ const Standard_Real Param3 ,
+ const Standard_Real Tolerance ) {
+ TheSame1 = Standard_False;
+ TheSame2 = Standard_False;
+ par1sol = 0.;
+ par2sol = 0.;
+ pararg1 = 0.;
+ pararg2 = 0.;
+ parcen3 = 0.;
+
+ WellDone = Standard_False;
+ 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())) {
+ GccEnt_BadQualifier::Raise();
+ return;
+ }
+ gp_Dir2d dirx(1.,0.);
+ Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ math_Vector Umin(1,4);
+ math_Vector Umax(1,4);
+ math_Vector Ufirst(1,4);
+ math_Vector tol(1,4);
+ Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
+ Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+ Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
+ Umin(4) = 0.;
+ Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
+ Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+ Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
+ Umax(4) = RealLast();
+ 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(OnCurv,Abs(Tolerance));
+ tol(4) = Tol/10.;
+ gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
+ gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+ gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,Param3);
+ Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+ Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnCurv,Ufirst(4));
+ math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+ Func.Value(Ufirst,Umin);
+ if (Root.IsDone()) {
+ Root.Root(Ufirst);
+ gp_Vec2d Tan1,Tan2,Tan3;
+ Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
+ Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+ Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
+ Standard_Real dist1 = point3.Distance(point1);
+ Standard_Real dist2 = point3.Distance(point2);
+ if ( Abs(dist1-dist2)/2. <= Tol) {
+ cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+ Standard_Real normetan1 = Tan1.Magnitude();
+ Standard_Real normetan2 = Tan2.Magnitude();
+ gp_Vec2d Vec1(point1,point3);
+ gp_Vec2d Vec2(point2,point3);
+ Standard_Real normevec1 = Vec1.Magnitude();
+ Standard_Real normevec2 = Vec2.Magnitude();
+ Standard_Real angle1,angle2;
+ if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+ angle1 = Vec1.Angle(Tan1);
+ }
+ else { angle1 = 0.; }
+ if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+ angle2 = Vec2.Angle(Tan2);
+ }
+ else { angle2 = 0.; }
+ if (Qualified1.IsUnqualified()||
+ (Qualified1.IsEnclosing()&&angle1<=0.)||
+ (Qualified1.IsOutside() && angle1 >= 0.) ||
+ (Qualified1.IsEnclosed() && angle1 <= 0.)) {
+ if (Qualified2.IsUnqualified() ||
+ (Qualified2.IsEnclosing()&&angle2<=0.)||
+ (Qualified2.IsOutside() && angle2 >= 0) ||
+ (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+ qualifier1 = Qualified1.Qualifier();
+ qualifier2 = Qualified2.Qualifier();
+ pararg1 = Ufirst(1);
+ par1sol = 0.;
+ pnttg1sol = point1;
+ pararg2 = Ufirst(2);
+ pnttg2sol = point2;
+ par2sol = pnttg2sol.Distance(pnttg1sol);
+ pntcen = point3;
+ parcen3 = Ufirst(3);
+ WellDone = Standard_True;
+ }
+ }
+ }
+ }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 ,
+ const Geom2dGcc_QCurve& Qualified2 ,
+ const Geom2dAdaptor_Curve& OnCurv ,
+ const Standard_Real Param1 ,
+ const Standard_Real Param2 ,
+ const Standard_Real ParamOn ,
+ const Standard_Real Tolerance ) {
+
+ TheSame1 = Standard_False;
+ TheSame2 = Standard_False;
+ par1sol = 0.;
+ par2sol = 0.;
+ pararg1 = 0.;
+ pararg2 = 0.;
+ parcen3 = 0.;
+
+ WellDone = Standard_False;
+ if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
+ Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+ !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
+ Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+ GccEnt_BadQualifier::Raise();
+ return;
+ }
+ Standard_Real Tol = Abs(Tolerance);
+ gp_Circ2d C1 = Qualified1.Qualified();
+ Standard_Real R1 = C1.Radius();
+ Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ math_Vector Umin(1,4);
+ math_Vector Umax(1,4);
+ math_Vector Ufirst(1,4);
+ math_Vector tol(1,4);
+ Umin(1) = RealFirst();
+ Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+ Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
+ Umin(4) = 0.;
+ Umax(1) = RealLast();
+ Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+ Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
+ Umax(4) = RealLast();
+ Ufirst(1) = Param1;
+ Ufirst(2) = Param2;
+ Ufirst(3) = ParamOn;
+ tol(1) = 2.e-15*M_PI;
+ tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
+ tol(3) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
+ tol(4) = Tol/10.;;
+ gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
+ gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+ gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
+ Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+ Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnCurv,Ufirst(4));
+ math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+ Func.Value(Ufirst,Umin);
+ if (Root.IsDone()) {
+ Root.Root(Ufirst);
+ gp_Vec2d Tan1,Tan2,Tan3;
+ Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+ Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
+ ElCLib::D1(Ufirst(1),C1,point1,Tan1);
+ Standard_Real dist1 = point3.Distance(point1);
+ Standard_Real dist2 = point3.Distance(point2);
+ if ( Abs(dist1-dist2)/2. <= Tol) {
+ gp_Dir2d dirx(1.,0.);
+ cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+ Standard_Real normetan2 = Tan2.Magnitude();
+ gp_Vec2d Vec1(point1.XY(),point3.XY());
+ gp_Vec2d Vec2(point2.XY(),point3.XY());
+ Standard_Real normevec2 = Vec2.Magnitude();
+ Standard_Real angle2;
+ if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+ angle2 = Vec2.Angle(Tan2);
+ }
+ else { angle2 = 0.; }
+ Standard_Real dist = C1.Location().Distance(point3);
+ Standard_Real Rsol = cirsol.Radius();
+ if (Qualified1.IsUnqualified() ||
+ (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
+ (Qualified1.IsOutside() && dist >= Rsol) ||
+ (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
+ if (Qualified2.IsUnqualified() ||
+ (Qualified2.IsEnclosing()&&angle2<=0.)||
+ (Qualified2.IsOutside() && angle2 >= 0) ||
+ (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+ qualifier1 = Qualified1.Qualifier();
+ qualifier2 = Qualified2.Qualifier();
+ pnttg1sol = point1;
+ pararg1 = Ufirst(1);
+ par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+ pnttg2sol = point2;
+ pararg2 = Ufirst(2);
+ par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+ pntcen = point3;
+ parcen3 = Ufirst(3);
+ WellDone = Standard_True;
+ }
+ }
+ }
+ }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin& Qualified1 ,
+ const Geom2dGcc_QCurve& Qualified2 ,
+ const Geom2dAdaptor_Curve& OnCurv ,
+ const Standard_Real Param1 ,
+ const Standard_Real Param2 ,
+ const Standard_Real ParamOn ,
+ const Standard_Real Tolerance ) {
+ TheSame1 = Standard_False;
+ TheSame2 = Standard_False;
+ par1sol = 0.;
+ par2sol = 0.;
+ pararg1 = 0.;
+ pararg2 = 0.;
+ parcen3 = 0.;
+
+ WellDone = Standard_False;
+ if (!(Qualified1.IsEnclosed() ||
+ Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
+ !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
+ Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
+ GccEnt_BadQualifier::Raise();
+ return;
+ }
+ Standard_Real Tol = Abs(Tolerance);
+ gp_Dir2d dirx(1.,0.);
+ gp_Lin2d L1 = Qualified1.Qualified();
+ Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ math_Vector Umin(1,4);
+ math_Vector Umax(1,4);
+ math_Vector Ufirst(1,4);
+ math_Vector tol(1,4);
+ Umin(1) = RealFirst();
+ Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
+ Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
+ Umin(4) = 0.;
+ Umax(1) = RealLast();
+ Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
+ Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
+ Umax(4) = RealLast();
+ Ufirst(1) = Param1;
+ Ufirst(2) = Param2;
+ Ufirst(3) = ParamOn;
+ tol(1) = 1.e-15;
+ tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
+ tol(3) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
+ tol(4) = Tol/10.;
+ gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
+ gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
+ gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
+ Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
+ Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnCurv,Ufirst(4));
+ math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+ Func.Value(Ufirst,Umin);
+ if (Root.IsDone()) {
+ Root.Root(Ufirst);
+ gp_Vec2d Tan1,Tan2,Tan3;
+ ElCLib::D1(Ufirst(1),L1,point1,Tan1);
+ Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
+ Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
+ Standard_Real dist1 = point3.Distance(point1);
+ Standard_Real dist2 = point3.Distance(point2);
+ if ( Abs(dist1-dist2)/2. <= Tol) {
+ cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+ Standard_Real normetan2 = Tan2.Magnitude();
+ gp_Vec2d Vec1(point1,point3);
+ gp_Vec2d Vec2(point2,point3);
+ Standard_Real normevec2 = Vec2.Magnitude();
+ Standard_Real angle2;
+ if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
+ angle2 = Vec2.Angle(Tan2);
+ }
+ else { angle2 = 0.; }
+ Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
+ L1.Direction().X()));
+ if (Qualified1.IsUnqualified() ||
+ (Qualified1.IsOutside() && pscal <= 0.) ||
+ (Qualified1.IsEnclosed() && pscal >= 0.)) {
+ if (Qualified2.IsUnqualified() ||
+ (Qualified2.IsEnclosing()&&angle2<=0.)||
+ (Qualified2.IsOutside() && angle2 >= 0) ||
+ (Qualified2.IsEnclosed() && angle2 <= 0.)) {
+ qualifier1 = Qualified1.Qualifier();
+ qualifier2 = Qualified2.Qualifier();
+ pnttg1sol = point1;
+ pararg1 = Ufirst(1);
+ par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+ pnttg2sol = point2;
+ pararg2 = Ufirst(2);
+ par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+ pntcen = point3;
+ parcen3 = Ufirst(3);
+ WellDone = Standard_True;
+ }
+ }
+ }
+ }
+}
+
+Geom2dGcc_Circ2d2TanOnIter::
+Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
+ const gp_Pnt2d& Point2 ,
+ const Geom2dAdaptor_Curve& OnCurv ,
+ const Standard_Real Param1 ,
+ const Standard_Real ParamOn ,
+ const Standard_Real Tolerance )
+{
+ TheSame1 = Standard_False;
+ TheSame2 = Standard_False;
+ par1sol = 0.;
+ par2sol = 0.;
+ pararg1 = 0.;
+ pararg2 = 0.;
+ parcen3 = 0.;
+
+ WellDone = Standard_False;
+ if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
+ Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
+ GccEnt_BadQualifier::Raise();
+ return;
+ }
+ Standard_Real Tol = Abs(Tolerance);
+ gp_Dir2d dirx(1.,0.);
+ Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ 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) = RealFirst();
+ Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
+ Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
+ Umax(2) = RealLast();
+ Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
+ Ufirst(1) = Param1;
+ Ufirst(2) = ParamOn;
+ tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
+ tol(2) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
+ tol(3) = Tol/10.;
+ gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
+ gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
+ Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
+ Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnCurv,Ufirst(3));
+ math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
+ Func.Value(Ufirst,Umin);
+ if (Root.IsDone()) {
+ Root.Root(Ufirst);
+ // gp_Vec2d Tan1,Tan2,Tan3;
+ gp_Vec2d Tan1,Tan3;
+ Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
+ Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
+ Standard_Real dist1 = point3.Distance(point1);
+ Standard_Real dist2 = point3.Distance(Point2);
+ if ( Abs(dist1-dist2)/2. <= Tol) {
+ cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
+ Standard_Real normetan1 = Tan1.Magnitude();
+ gp_Vec2d Vec1(point1,point3);
+ Standard_Real normevec1 = Vec1.Magnitude();
+ Standard_Real angle1;
+ if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
+ angle1 = Vec1.Angle(Tan1);
+ }
+ else { angle1 = 0.; }
+ if (Qualified1.IsUnqualified()||
+ (Qualified1.IsEnclosing()&&angle1<=0.)||
+ (Qualified1.IsOutside() && angle1 >= 0.) ||
+ (Qualified1.IsEnclosed() && angle1 <= 0.)) {
+ qualifier1 = Qualified1.Qualifier();
+ qualifier2 = GccEnt_noqualifier;
+ pnttg1sol = point1;
+ pararg1 = Ufirst(1);
+ par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
+ pnttg2sol = Point2;
+ pararg2 = 0.;
+ par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
+ pntcen = point3;
+ parcen3 = Ufirst(3);
+ WellDone = Standard_True;
+ }
+ }
+ }
+}
+
+Standard_Boolean Geom2dGcc_Circ2d2TanOnIter::
+IsDone () const{ return WellDone; }
+
+gp_Circ2d Geom2dGcc_Circ2d2TanOnIter::
+ThisSolution () const{ return cirsol; }
+
+void Geom2dGcc_Circ2d2TanOnIter::
+WhichQualifier (GccEnt_Position& Qualif1 ,
+ GccEnt_Position& Qualif2 ) const
+{
+ if (!WellDone) { StdFail_NotDone::Raise(); }
+ else {
+ Qualif1 = qualifier1;
+ Qualif2 = qualifier2;
+ }
+}
+
+void Geom2dGcc_Circ2d2TanOnIter::
+Tangency1 (Standard_Real& ParSol ,
+ Standard_Real& ParArg ,
+ gp_Pnt2d& PntSol ) const
+{
+ if (!WellDone) { StdFail_NotDone::Raise(); }
+ else {
+ if (TheSame1 == 0) {
+ ParSol = 0;
+ ParArg = 0;
+ PntSol = pnttg1sol;
+ }
+ else { StdFail_NotDone::Raise(); }
+ }
+}
+
+void Geom2dGcc_Circ2d2TanOnIter::
+Tangency2 (Standard_Real& ParSol ,
+ Standard_Real& ParArg ,
+ gp_Pnt2d& PntSol ) const
+{
+ if (!WellDone) { StdFail_NotDone::Raise(); }
+ else {
+ ParSol = 0;
+ ParArg = 0;
+ PntSol = pnttg2sol;
+ }
+}
+
+void Geom2dGcc_Circ2d2TanOnIter::
+CenterOn3 (Standard_Real& ParArg ,
+ gp_Pnt2d& PntSol ) const
+{
+ if (!WellDone) { StdFail_NotDone::Raise(); }
+ else {
+ ParArg = 0;
+ PntSol = pntcen;
+ }
+}
+
+Standard_Boolean Geom2dGcc_Circ2d2TanOnIter::
+IsTheSame1 () const
+{
+ if (!WellDone) StdFail_NotDone::Raise();
+
+ if (TheSame1 == 0)
+ return Standard_False;
+ return Standard_True;
+}
+
+
+Standard_Boolean Geom2dGcc_Circ2d2TanOnIter::
+IsTheSame2 () const
+{
+ if (!WellDone) StdFail_NotDone::Raise();
+ return Standard_False;
+}
Array1OfReal from TColStd,
Circ2d3Tan from GccAna,
Point from Geom2d,
- MyC2d3Tan from Geom2dGcc,
+ Circ2d3TanIter from Geom2dGcc,
Position from GccEnt,
Array1OfPosition from GccEnt
---Purpose: The parameter of the tangency point between the solution and the third
-- argument on the second argument.
-
--- CircAna : Circ2d2TanOn from GccAna;
--- CircIter : Circ2d2TanOn from GccIter;
--- TypeAna : Boolean;
-
end Circ2d3Tan;
#include <Geom2d_Line.hxx>
#include <Geom2d_Circle.hxx>
#include <Geom2dGcc_QCurve.hxx>
-#include <Geom2dGcc_MyC2d3Tan.hxx>
+#include <Geom2dGcc_Circ2d3TanIter.hxx>
#include <GccEnt_QualifiedCirc.hxx>
#include <GccEnt_QualifiedLin.hxx>
#include <StdFail_NotDone.hxx>
Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
Geom2dGcc_QCurve Qc2(C2,Qualified2.Qualifier());
Geom2dGcc_QCurve Qc3(C3,Qualified3.Qualifier());
- Geom2dGcc_MyC2d3Tan Circ(Qc1,Qc2,Qc3,Param1,Param2,Param3,Tolerance);
+ Geom2dGcc_Circ2d3TanIter Circ(Qc1,Qc2,Qc3,Param1,Param2,Param3,Tolerance);
WellDone = Circ.IsDone();
NbrSol = 1;
if (WellDone) {
else {
Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
Geom2dGcc_QCurve Qc2(C2,Qualified2.Qualifier());
- Geom2dGcc_MyC2d3Tan Circ(Qc1,Qc2,Point->Pnt2d(),Param1,Param2,Tolerance);
+ Geom2dGcc_Circ2d3TanIter Circ(Qc1,Qc2,Point->Pnt2d(),Param1,Param2,Tolerance);
WellDone = Circ.IsDone();
NbrSol = 1;
if (WellDone) {
}
else {
Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
- Geom2dGcc_MyC2d3Tan Circ(Qc1,Point1->Pnt2d(),Point2->Pnt2d(),
+ Geom2dGcc_Circ2d3TanIter Circ(Qc1,Point1->Pnt2d(),Point2->Pnt2d(),
Param1,Tolerance);
WellDone = Circ.IsDone();
NbrSol = 1;
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
-generic class Circ2d3Tan from GccIter (
- TheCurve as any;
- TheCurveTool as any; -- as CurveTool from GccInt (TheCurve)
- TheQualifiedCurve as any) -- as QualifiedCurve from GccEnt
- -- (TheCurve)
+class Circ2d3TanIter from Geom2dGcc
---Purpose: This class implements the algorithms used to
-- create 2d circles tangent to 3 points/lines/circles/
Circ2d from gp,
QualifiedCirc from GccEnt,
QualifiedLin from GccEnt,
- Position from GccEnt
+ Position from GccEnt,
+ Curve from Geom2dAdaptor,
+ CurveTool from Geom2dGcc,
+ QCurve from Geom2dGcc
raises NotDone from StdFail
-private class FuncTCuCuCu instantiates FunctionTanCuCuCu from GccIter (
- TheCurve,TheCurveTool);
is
Create(Qualified1 : QualifiedCirc from GccEnt ;
Qualified2 : QualifiedCirc from GccEnt ;
- Qualified3 : TheQualifiedCurve ;
+ Qualified3 : QCurve from Geom2dGcc;
Param1 : Real ;
Param2 : Real ;
Param3 : Real ;
Tolerance : Real )
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
---Purpose: This method implements the algorithms used to
-- create 2d circles tangent to 2 circles and a curve.
Create(Qualified1 : QualifiedCirc from GccEnt ;
- Qualified2 : TheQualifiedCurve ;
- Qualified3 : TheQualifiedCurve ;
+ Qualified2 : QCurve from Geom2dGcc;
+ Qualified3 : QCurve from Geom2dGcc;
Param1 : Real ;
Param2 : Real ;
Param3 : Real ;
Tolerance : Real )
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
---Purpose: This method implements the algorithms used to
-- create 2d circles tangent to a circle and 2 curves.
Create(Qualified1 : QualifiedCirc from GccEnt ;
Qualified2 : QualifiedLin from GccEnt ;
- Qualified3 : TheQualifiedCurve ;
+ Qualified3 : QCurve from Geom2dGcc;
Param1 : Real ;
Param2 : Real ;
Param3 : Real ;
Tolerance : Real )
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
---Purpose: This method implements the algorithms used to
-- create 2d circles tangent to a circle and a line and
-- a curve.
Create(Qualified1 : QualifiedCirc from GccEnt ;
- Qualified2 : TheQualifiedCurve ;
+ Qualified2 : QCurve from Geom2dGcc;
Point3 : Pnt2d ;
Param1 : Real ;
Param2 : Real ;
Tolerance : Real )
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
---Purpose: This method implements the algorithms used to
-- create 2d circles tangent to a circle and a point and
-- a curve.
Create(Qualified1 : QualifiedLin from GccEnt ;
Qualified2 : QualifiedLin from GccEnt ;
- Qualified3 : TheQualifiedCurve ;
+ Qualified3 : QCurve from Geom2dGcc;
Param1 : Real ;
Param2 : Real ;
Param3 : Real ;
Tolerance : Real )
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
---Purpose: This method implements the algorithms used to
-- create 2d circles tangent to 2 lines and a curve.
Create(Qualified1 : QualifiedLin from GccEnt ;
- Qualified2 : TheQualifiedCurve ;
- Qualified3 : TheQualifiedCurve ;
+ Qualified2 : QCurve from Geom2dGcc;
+ Qualified3 : QCurve from Geom2dGcc;
Param1 : Real ;
Param2 : Real ;
Param3 : Real ;
Tolerance : Real )
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
---Purpose: This method implements the algorithms used to
-- create 2d circles tangent to a line and 2 curves.
Create(Qualified1 : QualifiedLin from GccEnt ;
- Qualified2 : TheQualifiedCurve ;
+ Qualified2 : QCurve from Geom2dGcc;
Point3 : Pnt2d ;
Param1 : Real ;
Param2 : Real ;
Tolerance : Real )
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
---Purpose: This method implements the algorithms used to
-- create 2d circles tangent to a line and a curve
-- and a point.
-Create(Qualified1 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc;
Point1 : Pnt2d ;
Point2 : Pnt2d ;
Param1 : Real ;
Tolerance : Real )
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
---Purpose: This method implements the algorithms used to
-- create 2d circles tangent to a curve and 2 points.
-Create(Qualified1 : TheQualifiedCurve ;
- Qualified2 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc ;
+ Qualified2 : QCurve from Geom2dGcc ;
Point2 : Pnt2d ;
Param1 : Real ;
Param2 : Real ;
Tolerance : Real )
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
---Purpose: This method implements the algorithms used to
-- create 2d circles tangent to 2 curves and a point.
-Create(Qualified1 : TheQualifiedCurve ;
- Qualified2 : TheQualifiedCurve ;
- Qualified3 : TheQualifiedCurve ;
+Create(Qualified1 : QCurve from Geom2dGcc ;
+ Qualified2 : QCurve from Geom2dGcc ;
+ Qualified3 : QCurve from Geom2dGcc ;
Param1 : Real ;
Param2 : Real ;
Param3 : Real ;
Tolerance : Real )
-returns Circ2d3Tan from GccIter;
+returns Circ2d3TanIter from Geom2dGcc;
---Purpose: This method implements the algorithms used to
-- create 2d circles tangent to 3 curves.
---Purpose: The parameter of the tangency point between the solution
-- and the third argument on the second argument.
-end Circ2d3Tan;
+end Circ2d3TanIter;
--- /dev/null
+// 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 <Geom2dGcc_Circ2d3TanIter.ixx>
+
+#include <gp_Dir2d.hxx>
+#include <gp_Ax2d.hxx>
+#include <gp_Vec2d.hxx>
+#include <gp.hxx>
+#include <StdFail_NotDone.hxx>
+#include <GccEnt_BadQualifier.hxx>
+#include <math_FunctionSetRoot.hxx>
+#include <math_NewtonFunctionSetRoot.hxx>
+#include <GccAna_Circ2d3Tan.hxx>
+
+#include <Geom2dGcc_CurveTool.hxx>
+#include <Geom2dGcc_FunctionTanCuCuCu.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())) {
+ GccEnt_BadQualifier::Raise();
+ 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,Ufirst,tol,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())) {
+ GccEnt_BadQualifier::Raise();
+ 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,Ufirst,tol,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())) {
+ GccEnt_BadQualifier::Raise();
+ 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,Ufirst,tol,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())) {
+ GccEnt_BadQualifier::Raise();
+ 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,Ufirst,tol,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())) {
+ GccEnt_BadQualifier::Raise();
+ 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);
projects / occt.git / commitdiff