OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

0024778: Convertation of the generic classes to the non-generic. Part 9

Browse Source 
Generic classes:

 "GccIter_Circ2d2TanOn",
 "GccIter_Circ2d3Tan",
 "GccIter_Lin2d2Tan",
 "GccIter_Lin2dTanObl"

from "GccIter" package were converted to the non-generic classes and moved to the "Geom2dGcc" package. Names of this classes were changed to:

 "Geom2dGcc_Circ2d2TanOnIter",
 "Geom2dGcc_Circ2d3TanIter",
 "Geom2dGcc_Lin2d2TanIter",
 "Geom2dGcc_Lin2dTanOblIter".

And their internal classes:

 "GccIter_FunctionTanCuCuOnCu",
 "GccIter_FunctionTanCuCuCu",
 "GccIter_FunctionTanCirCu",
 "GccIter_FunctionTanCuCu",
 "GccIter_FunctionTanCuPnt",
 "GccIter_FunctionTanObl"

also converted to the non-generic and moved to the "Geom2dGcc" package(their declarations were moved to "Geom2dGcc.cdl").

Enumerations" Type1, Type2 and Type3 were moved to "Geom2dGcc.cdl".

Package "GccIter" was deleted.
This commit is contained in:
dln 2014-03-28 11:28:22 +04:00 committed by apn
parent 578ce4bebf
commit 54e37688ef
41 changed files with 4170 additions and 4236 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
adm/UDLIST
View File

@ -134,7 +134,6 @@ p FilletSurf
p GccAna
p GccEnt
p GccInt
p GccIter
p Geom2dAPI
p Geom2dGcc
p Geom2dHatch

74
src/GccIter/GccIter.cdl
View File

@ -1,74 +0,0 @@
-- 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;

1297
src/GccIter/GccIter_Circ2d2TanOn.gxx
View File

File diff suppressed because it is too large Load Diff

1351
src/GccIter/GccIter_Circ2d3Tan.gxx
View File

File diff suppressed because it is too large Load Diff

134
src/GccIter/GccIter_FunctionTanCirCu.gxx
View File

@ -1,134 +0,0 @@
// 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;
}

213
src/GccIter/GccIter_FunctionTanCuCu.gxx
View File

@ -1,213 +0,0 @@
// 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;
}

96
src/GccIter/GccIter_FunctionTanCuPnt.gxx
View File

@ -1,96 +0,0 @@
// 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;
}

66
src/GccIter/GccIter_FunctionTanObl.gxx
View File

@ -1,66 +0,0 @@
// 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;
}

278
src/GccIter/GccIter_Lin2d2Tan.gxx
View File

@ -1,278 +0,0 @@
// 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;
}
}

150
src/GccIter/GccIter_Lin2dTanObl.gxx
View File

@ -1,150 +0,0 @@
// 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;
}
}

44
src/Geom2dGcc/Geom2dGcc.cdl
View File

@ -33,7 +33,6 @@ package Geom2dGcc
uses GccEnt,
GccAna,
GccIter,
StdFail,
Geom2dInt,
Geom2d,
@ -45,7 +44,8 @@ uses GccEnt,
Adaptor3d,
Adaptor2d,
TColgp,
gp
gp,
math
is
@ -79,25 +79,29 @@ class Circ2dTanCenGeo;
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 Circ2d3TanIter;
private class FunctionTanCuCuCu;
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 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

4
src/Geom2dGcc/Geom2dGcc_Circ2d2TanOn.cdl
View File

@ -43,7 +43,7 @@ uses Curve from Geom2dAdaptor,
Circ2d from gp,
Circ2d2TanOn from GccAna,
Circ2d2TanOnGeo from Geom2dGcc,
MyC2d2TanOn from Geom2dGcc,
Circ2d2TanOnIter from Geom2dGcc,
Position from GccEnt,
Array1OfPosition from GccEnt
@ -285,7 +285,7 @@ fields
-- CircAna : Circ2d2TanOn from GccAna;
-- CircGeo : Circ2d2TanOnGeo from Geom2dGcc;
-- CircIter : MyC2d2TanOn from Geom2dGcc;
-- CircIter : Circ2d2TanOnIter from Geom2dGcc;
-- TypeAna : Boolean;
end Circ2d2TanOn;

26
src/Geom2dGcc/Geom2dGcc_Circ2d2TanOn.cxx
View File

@ -18,7 +18,7 @@
#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>
@ -267,18 +267,13 @@ Geom2dGcc_Circ2d2TanOn::
}
}
}
//=============================================================================
// 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;
@ -292,7 +287,7 @@ Geom2dGcc_Circ2d2TanOn::
}
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;
@ -306,7 +301,7 @@ Geom2dGcc_Circ2d2TanOn::
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;
@ -438,18 +433,13 @@ Geom2dGcc_Circ2d2TanOn::
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;
@ -462,7 +452,7 @@ Geom2dGcc_Circ2d2TanOn::
}
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;
@ -475,7 +465,7 @@ Geom2dGcc_Circ2d2TanOn::
}
}
else {
Geom2dGcc_MyC2d2TanOn Circ(Qc1,Point->Pnt2d(),OnCurve,
Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Point->Pnt2d(),OnCurve,
Param1,ParamOn,Tolerance);
WellDone = Circ.IsDone();
NbrSol = 1;

77
src/GccIter/GccIter_Circ2d2TanOn.cdl → src/Geom2dGcc/Geom2dGcc_Circ2d2TanOnIter.cdl
View File

@ -14,11 +14,7 @@
-- 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
@ -39,23 +35,24 @@ uses Pnt2d from gp,
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.
@ -63,25 +60,25 @@ Create(Qualified1 : QualifiedCirc ;
-- 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.
@ -89,12 +86,12 @@ Create(Qualified1 : TheQualifiedCurve ;
-- 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.
@ -105,12 +102,12 @@ Create(Qualified1 : TheQualifiedCurve ;
-- -- 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.
@ -118,25 +115,25 @@ Create(Qualified1 : QualifiedCirc ;
-- 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.
@ -144,12 +141,12 @@ Create(Qualified1 : TheQualifiedCurve ;
-- 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.
@ -159,12 +156,12 @@ Create(Qualified1 : TheQualifiedCurve ;
-- -- 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.
@ -173,12 +170,12 @@ Create(Qualified1 : QualifiedCirc ;
-- 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.
@ -186,12 +183,12 @@ Create(Qualified1 : QualifiedLin ;
-- 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.
@ -199,13 +196,13 @@ Create(Qualified1 : TheQualifiedCurve ;
-- 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.
@ -346,4 +343,4 @@ fields
---Purpose: The parameter of the center point of the solution
-- on the second argument.
end Circ2d2TanOn;
end Circ2d2TanOnIter;

1302
src/Geom2dGcc/Geom2dGcc_Circ2d2TanOnIter.cxx Normal file
View File

File diff suppressed because it is too large Load Diff

7
src/Geom2dGcc/Geom2dGcc_Circ2d3Tan.cdl
View File

@ -47,7 +47,7 @@ uses QualifiedCurve from Geom2dGcc,
Array1OfReal from TColStd,
Circ2d3Tan from GccAna,
Point from Geom2d,
MyC2d3Tan from Geom2dGcc,
Circ2d3TanIter from Geom2dGcc,
Position from GccEnt,
Array1OfPosition from GccEnt
@ -316,9 +316,4 @@ fields
---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;

8
src/Geom2dGcc/Geom2dGcc_Circ2d3Tan.cxx
View File

@ -19,7 +19,7 @@
#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>
@ -215,7 +215,7 @@ Geom2dGcc_Circ2d3Tan::
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) {
@ -334,7 +334,7 @@ Geom2dGcc_Circ2d3Tan::
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) {
@ -413,7 +413,7 @@ Geom2dGcc_Circ2d3Tan::
}
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;

65
src/GccIter/GccIter_Circ2d3Tan.cdl → src/Geom2dGcc/Geom2dGcc_Circ2d3TanIter.cdl
View File

@ -14,11 +14,7 @@
-- 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/
@ -36,119 +32,120 @@ uses Pnt2d from gp,
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.
@ -315,4 +312,4 @@ fields
---Purpose: The parameter of the tangency point between the solution
-- and the third argument on the second argument.
end Circ2d3Tan;
end Circ2d3TanIter;

1356
src/Geom2dGcc/Geom2dGcc_Circ2d3TanIter.cxx Normal file
View File

File diff suppressed because it is too large Load Diff

15
src/GccIter/GccIter_FunctionTanCirCu.cdl → src/Geom2dGcc/Geom2dGcc_FunctionTanCirCu.cdl
View File

@ -14,21 +14,20 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
generic class FunctionTanCirCu from GccIter (
TheCurve as any;
TheCurveTool as any) -- as CurvePGTool from GccInt(TheCurve)
private class FunctionTanCirCu from Geom2dGcc inherits FunctionWithDerivative from math
inherits FunctionWithDerivative from math
---Purpose: This abstract class describes a Function of 1 Variable
-- used to find a line tangent to a curve and a circle.
uses Circ2d from gp
uses
Circ2d from gp,
Curve from Geom2dAdaptor,
CurveTool from Geom2dGcc
is
Create (Circ : Circ2d from gp ;
Curv : TheCurve ) returns FunctionTanCirCu from GccIter;
Curv : Curve from Geom2dAdaptor ) returns FunctionTanCirCu from Geom2dGcc;
Value (me : in out ;
X : Real ;
@ -56,7 +55,7 @@ Values (me : in out ;
fields
TheCirc : Circ2d from gp;
Curve : TheCurve;
Curve : Curve from Geom2dAdaptor;
-- Modified by Sergey KHROMOV - Thu Apr 5 09:50:18 2001 Begin
myWeight : Real;
-- Modified by Sergey KHROMOV - Thu Apr 5 09:50:19 2001 End

138
src/Geom2dGcc/Geom2dGcc_FunctionTanCirCu.cxx Normal file
View File

@ -0,0 +1,138 @@
// 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 <Geom2dGcc_FunctionTanCirCu.ixx>
#include <gp_Vec2d.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Vec.hxx>
#include <gp_Pnt.hxx>
#include <Geom2dGcc_CurveTool.hxx>
//=========================================================================
// soit P1 le point sur la courbe Geom2dAdaptor_Curve 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. +
//=========================================================================
Geom2dGcc_FunctionTanCirCu::
Geom2dGcc_FunctionTanCirCu(const gp_Circ2d& Circ ,
const Geom2dAdaptor_Curve& Curv ) {
Curve = Curv;
TheCirc = Circ;
// Modified by Sergey KHROMOV - Thu Apr 5 09:51:21 2001 Begin
Standard_Integer aNbSamp = Geom2dGcc_CurveTool::NbSamples(Curve);
Standard_Real aFirst = Geom2dGcc_CurveTool::FirstParameter(Curve);
Standard_Real aLast = Geom2dGcc_CurveTool::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 += (Geom2dGcc_CurveTool::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 Geom2dGcc_FunctionTanCirCu::
Value (const Standard_Real X ,
Standard_Real& Fval ) {
gp_Pnt2d Point;
gp_Vec2d Vect1;
Geom2dGcc_CurveTool::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 Geom2dGcc_FunctionTanCirCu::
Derivative (const Standard_Real X ,
Standard_Real& Deriv ) {
gp_Pnt2d Point;
gp_Vec2d Vect1,Vect2;
Geom2dGcc_CurveTool::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 Geom2dGcc_FunctionTanCirCu::
Values (const Standard_Real X ,
Standard_Real& Fval ,
Standard_Real& Deriv ) {
gp_Pnt2d Point;
gp_Vec2d Vect1,Vect2;
Geom2dGcc_CurveTool::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;
}

22
src/GccIter/GccIter_FunctionTanCuCu.cdl → src/Geom2dGcc/Geom2dGcc_FunctionTanCuCu.cdl
View File

@ -14,11 +14,7 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
generic class FunctionTanCuCu from GccIter (
TheCurve as any;
TheCurveTool as any) -- as CurvePGTool from GccInt (TheCurve)
inherits FunctionSetWithDerivatives from math
private class FunctionTanCuCu from Geom2dGcc inherits FunctionSetWithDerivatives from math
---Purpose: This abstract class describes a Function of 1 Variable
-- used to find a line tangent to two curves.
@ -28,18 +24,20 @@ uses Vector from math,
Circ2d from gp,
Pnt2d from gp,
Vec2d from gp,
Type3 from GccIter
Type3 from Geom2dGcc,
Curve from Geom2dAdaptor,
CurveTool from Geom2dGcc
raises ConstructionError
is
Create (Curv1 : TheCurve ;
Curv2 : TheCurve ) returns FunctionTanCuCu from GccIter;
Create (Curv1 : Curve from Geom2dAdaptor ;
Curv2 : Curve from Geom2dAdaptor ) returns FunctionTanCuCu from Geom2dGcc;
Create (Circ1 : Circ2d from gp ;
Curv2 : TheCurve ) returns FunctionTanCuCu from GccIter;
Curv2 : Curve from Geom2dAdaptor ) returns FunctionTanCuCu from Geom2dGcc;
InitDerivative(me : in out ;
X : Vector from math ;
@ -79,10 +77,10 @@ Values (me : in out ;
fields
TheCurve1 : TheCurve ;
TheCurve2 : TheCurve ;
TheCurve1 : Curve from Geom2dAdaptor ;
TheCurve2 : Curve from Geom2dAdaptor ;
TheCirc1 : Circ2d from gp ;
TheType : Type3 from GccIter ;
TheType : Type3 from Geom2dGcc ;
end FunctionTanCuCu;

219
src/Geom2dGcc/Geom2dGcc_FunctionTanCuCu.cxx Normal file
View File

@ -0,0 +1,219 @@
// 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 <Geom2dGcc_FunctionTanCuCu.ixx>
#include <gp_Vec2d.hxx>
#include <gp_Pnt2d.hxx>
#include <ElCLib.hxx>
#include <Geom2dGcc_CurveTool.hxx>
void Geom2dGcc_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 Geom2dGcc_CuCu:
{
Geom2dGcc_CurveTool::D2(TheCurve1,X(1),Point1,Tan1,D21);
Geom2dGcc_CurveTool::D2(TheCurve2,X(2),Point2,Tan2,D22);
}
break;
case Geom2dGcc_CiCu:
{
ElCLib::D2(X(1),TheCirc1,Point1,Tan1,D21);
Geom2dGcc_CurveTool::D2(TheCurve2,X(2),Point2,Tan2,D22);
}
break;
default:
{
}
}
}
Geom2dGcc_FunctionTanCuCu::
Geom2dGcc_FunctionTanCuCu(const Geom2dAdaptor_Curve& C1 ,
const Geom2dAdaptor_Curve& C2 ) {
TheCurve1 = C1;
TheCurve2 = C2;
TheType = Geom2dGcc_CuCu;
}
Geom2dGcc_FunctionTanCuCu::
Geom2dGcc_FunctionTanCuCu(const gp_Circ2d& C1 ,
const Geom2dAdaptor_Curve& C2 ) {
TheCirc1 = C1;
TheCurve2 = C2;
TheType = Geom2dGcc_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 Geom2dGcc_FunctionTanCuCu::
NbVariables() const { return 2; }
Standard_Integer Geom2dGcc_FunctionTanCuCu::
NbEquations() const { return 2; }
Standard_Boolean Geom2dGcc_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 Geom2dGcc_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 Geom2dGcc_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;
}

50
src/GccIter/GccIter_FunctionTanCuCuCu.cdl → src/Geom2dGcc/Geom2dGcc_FunctionTanCuCuCu.cdl
View File

@ -14,11 +14,7 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
generic class FunctionTanCuCuCu from GccIter(
TheCurve as any;
TheCurveTool as any) -- as CurvePGTool from GccInt (TheCurve)
inherits FunctionSetWithDerivatives from math
private class FunctionTanCuCuCu from Geom2dGcc inherits FunctionSetWithDerivatives from math
---Purpose: This abstract class describes a set on N Functions of
-- M independant variables.
@ -29,47 +25,49 @@ uses Vector from math,
Lin2d from gp,
Pnt2d from gp,
Vec2d from gp,
Type1 from GccIter
Type1 from Geom2dGcc,
Curve from Geom2dAdaptor,
CurveTool from Geom2dGcc
raises ConstructionError
is
Create (C1 : TheCurve ;
C2 : TheCurve ;
C3 : TheCurve ) returns FunctionTanCuCuCu from GccIter;
Create (C1 : Curve from Geom2dAdaptor ;
C2 : Curve from Geom2dAdaptor ;
C3 : Curve from Geom2dAdaptor ) returns FunctionTanCuCuCu from Geom2dGcc;
Create (C1 : Circ2d from gp ;
C2 : TheCurve ;
C3 : TheCurve ) returns FunctionTanCuCuCu from GccIter;
C2 : Curve from Geom2dAdaptor ;
C3 : Curve from Geom2dAdaptor ) returns FunctionTanCuCuCu from Geom2dGcc;
Create (C1 : Circ2d from gp ;
C2 : Circ2d from gp ;
C3 : TheCurve ) returns FunctionTanCuCuCu from GccIter;
C3 : Curve from Geom2dAdaptor ) returns FunctionTanCuCuCu from Geom2dGcc;
Create (C1 : Circ2d from gp ;
L2 : Lin2d from gp ;
C3 : TheCurve ) returns FunctionTanCuCuCu from GccIter;
C3 : Curve from Geom2dAdaptor ) returns FunctionTanCuCuCu from Geom2dGcc;
Create (L1 : Lin2d from gp ;
L2 : Lin2d from gp ;
C3 : TheCurve ) returns FunctionTanCuCuCu from GccIter;
C3 : Curve from Geom2dAdaptor ) returns FunctionTanCuCuCu from Geom2dGcc;
Create (L1 : Lin2d from gp ;
C2 : TheCurve ;
C3 : TheCurve ) returns FunctionTanCuCuCu from GccIter;
C2 : Curve from Geom2dAdaptor ;
C3 : Curve from Geom2dAdaptor ) returns FunctionTanCuCuCu from Geom2dGcc;
Create (C1 : Circ2d from gp ;
C2 : TheCurve ;
P3 : Pnt2d from gp ) returns FunctionTanCuCuCu from GccIter;
C2 : Curve from Geom2dAdaptor ;
P3 : Pnt2d from gp ) returns FunctionTanCuCuCu from Geom2dGcc;
Create (L1 : Lin2d from gp ;
C2 : TheCurve ;
P3 : Pnt2d from gp ) returns FunctionTanCuCuCu from GccIter;
C2 : Curve from Geom2dAdaptor ;
P3 : Pnt2d from gp ) returns FunctionTanCuCuCu from Geom2dGcc;
Create (C1 : TheCurve ;
Create (C1 : Curve from Geom2dAdaptor ;
P2 : Pnt2d from gp ;
P3 : Pnt2d from gp ) returns FunctionTanCuCuCu from GccIter;
P3 : Pnt2d from gp ) returns FunctionTanCuCuCu from Geom2dGcc;
InitDerivative(me : in out ;
X : Vector from math ;
@ -103,14 +101,14 @@ is static;
fields
Curv1 : TheCurve ;
Curv2 : TheCurve ;
Curv3 : TheCurve ;
Curv1 : Curve from Geom2dAdaptor ;
Curv2 : Curve from Geom2dAdaptor ;
Curv3 : Curve from Geom2dAdaptor ;
Circ1 : Circ2d from gp ;
Circ2 : Circ2d from gp ;
Lin1 : Lin2d from gp ;
Lin2 : Lin2d from gp ;
TheType : Type1 from GccIter;
TheType : Type1 from Geom2dGcc;
end FunctionTanCuCuCu;

386
src/GccIter/GccIter_FunctionTanCuCuCu.gxx → src/Geom2dGcc/Geom2dGcc_FunctionTanCuCuCu.cxx
View File

@ -14,214 +14,218 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2dGcc_FunctionTanCuCuCu.ixx>
#include <Standard_ConstructionError.hxx>
#include <ElCLib.hxx>
#include <gp.hxx>
void GccIter_FunctionTanCuCuCu::
InitDerivative(const math_Vector& X,
gp_Pnt2d& Point1,
gp_Pnt2d& Point2,
gp_Pnt2d& Point3,
gp_Vec2d& Tan1,
gp_Vec2d& Tan2,
gp_Vec2d& Tan3,
gp_Vec2d& D21,
gp_Vec2d& D22,
gp_Vec2d& D23) {
switch (TheType) {
case GccIter_CiCuCu:
#include <Geom2dGcc_CurveTool.hxx>
void Geom2dGcc_FunctionTanCuCuCu::
InitDerivative(const math_Vector& X,
gp_Pnt2d& Point1,
gp_Pnt2d& Point2,
gp_Pnt2d& Point3,
gp_Vec2d& Tan1,
gp_Vec2d& Tan2,
gp_Vec2d& Tan3,
gp_Vec2d& D21,
gp_Vec2d& D22,
gp_Vec2d& D23) {
switch (TheType) {
case Geom2dGcc_CiCuCu:
{
ElCLib::D2(X(1),Circ1,Point1,Tan1,D21);
TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
TheCurveTool::D2(Curv3,X(3),Point3,Tan3,D23);
Geom2dGcc_CurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
Geom2dGcc_CurveTool::D2(Curv3,X(3),Point3,Tan3,D23);
}
break;
case GccIter_CiCiCu:
case Geom2dGcc_CiCiCu:
{
ElCLib::D2(X(1),Circ1,Point1,Tan1,D21);
ElCLib::D2(X(2),Circ2,Point2,Tan2,D22);
TheCurveTool::D2(Curv3,X(3),Point3,Tan3,D23);
Geom2dGcc_CurveTool::D2(Curv3,X(3),Point3,Tan3,D23);
}
break;
case GccIter_CiLiCu:
case Geom2dGcc_CiLiCu:
{
ElCLib::D2(X(1),Circ1,Point1,Tan1,D21);
ElCLib::D1(X(2),Lin2,Point2,Tan2);
D22 = gp_Vec2d(0.,0.);
TheCurveTool::D2(Curv3,X(3),Point3,Tan3,D23);
Geom2dGcc_CurveTool::D2(Curv3,X(3),Point3,Tan3,D23);
}
break;
case GccIter_LiCuCu:
case Geom2dGcc_LiCuCu:
{
ElCLib::D1(X(1),Lin1,Point1,Tan1);
D21 = gp_Vec2d(0.,0.);
TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
TheCurveTool::D2(Curv3,X(3),Point3,Tan3,D23);
Geom2dGcc_CurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
Geom2dGcc_CurveTool::D2(Curv3,X(3),Point3,Tan3,D23);
}
break;
case GccIter_LiLiCu:
case Geom2dGcc_LiLiCu:
{
ElCLib::D1(X(1),Lin1,Point1,Tan1);
D21 = gp_Vec2d(0.,0.);
ElCLib::D1(X(2),Lin2,Point2,Tan2);
D22 = gp_Vec2d(0.,0.);
TheCurveTool::D2(Curv3,X(3),Point3,Tan3,D23);
Geom2dGcc_CurveTool::D2(Curv3,X(3),Point3,Tan3,D23);
}
break;
case GccIter_CuCuCu:
case Geom2dGcc_CuCuCu:
{
TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
TheCurveTool::D2(Curv3,X(3),Point3,Tan3,D23);
Geom2dGcc_CurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
Geom2dGcc_CurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
Geom2dGcc_CurveTool::D2(Curv3,X(3),Point3,Tan3,D23);
}
break;
default:
{
Standard_ConstructionError::Raise();
}
}
}
}
GccIter_FunctionTanCuCuCu::
GccIter_FunctionTanCuCuCu(const TheCurve& C1 ,
const TheCurve& C2 ,
const TheCurve& C3 ) {
Curv1 = C1;
Curv2 = C2;
Curv3 = C3;
TheType = GccIter_CuCuCu;
Geom2dGcc_FunctionTanCuCuCu::
Geom2dGcc_FunctionTanCuCuCu(const Geom2dAdaptor_Curve& C1 ,
const Geom2dAdaptor_Curve& C2 ,
const Geom2dAdaptor_Curve& C3 ) {
Curv1 = C1;
Curv2 = C2;
Curv3 = C3;
TheType = Geom2dGcc_CuCuCu;
}
GccIter_FunctionTanCuCuCu::
GccIter_FunctionTanCuCuCu(const gp_Circ2d& C1 ,
const TheCurve& C2 ,
const TheCurve& C3 ) {
Circ1 = C1;
Curv2 = C2;
Curv3 = C3;
TheType = GccIter_CiCuCu;
Geom2dGcc_FunctionTanCuCuCu::
Geom2dGcc_FunctionTanCuCuCu(const gp_Circ2d& C1 ,
const Geom2dAdaptor_Curve& C2 ,
const Geom2dAdaptor_Curve& C3 ) {
Circ1 = C1;
Curv2 = C2;
Curv3 = C3;
TheType = Geom2dGcc_CiCuCu;
}
GccIter_FunctionTanCuCuCu::
GccIter_FunctionTanCuCuCu(const gp_Circ2d& C1 ,
const gp_Circ2d& C2 ,
const TheCurve& C3 ) {
Circ1 = C1;
Circ2 = C2;
Curv3 = C3;
TheType = GccIter_CiCiCu;
Geom2dGcc_FunctionTanCuCuCu::
Geom2dGcc_FunctionTanCuCuCu(const gp_Circ2d& C1 ,
const gp_Circ2d& C2 ,
const Geom2dAdaptor_Curve& C3 ) {
Circ1 = C1;
Circ2 = C2;
Curv3 = C3;
TheType = Geom2dGcc_CiCiCu;
}
GccIter_FunctionTanCuCuCu::
GccIter_FunctionTanCuCuCu(const gp_Circ2d& C1 ,
const gp_Lin2d& L2 ,
const TheCurve& C3 ) {
Circ1 = C1;
Lin2 = L2;
Curv3 = C3;
TheType = GccIter_CiLiCu;
Geom2dGcc_FunctionTanCuCuCu::
Geom2dGcc_FunctionTanCuCuCu(const gp_Circ2d& C1 ,
const gp_Lin2d& L2 ,
const Geom2dAdaptor_Curve& C3 ) {
Circ1 = C1;
Lin2 = L2;
Curv3 = C3;
TheType = Geom2dGcc_CiLiCu;
}
GccIter_FunctionTanCuCuCu::
GccIter_FunctionTanCuCuCu(const gp_Lin2d& L1 ,
const gp_Lin2d& L2 ,
const TheCurve& C3 ) {
Lin1 = L1;
Lin2 = L2;
Curv3 = C3;
TheType = GccIter_LiLiCu;
Geom2dGcc_FunctionTanCuCuCu::
Geom2dGcc_FunctionTanCuCuCu(const gp_Lin2d& L1 ,
const gp_Lin2d& L2 ,
const Geom2dAdaptor_Curve& C3 ) {
Lin1 = L1;
Lin2 = L2;
Curv3 = C3;
TheType = Geom2dGcc_LiLiCu;
}
GccIter_FunctionTanCuCuCu::
GccIter_FunctionTanCuCuCu(const gp_Lin2d& L1 ,
const TheCurve& C2 ,
const TheCurve& C3 ) {
Lin1 = L1;
Curv2 = C2;
Curv3 = C3;
TheType = GccIter_LiCuCu;
Geom2dGcc_FunctionTanCuCuCu::
Geom2dGcc_FunctionTanCuCuCu(const gp_Lin2d& L1 ,
const Geom2dAdaptor_Curve& C2 ,
const Geom2dAdaptor_Curve& C3 ) {
Lin1 = L1;
Curv2 = C2;
Curv3 = C3;
TheType = Geom2dGcc_LiCuCu;
}
//==========================================================================
Standard_Integer GccIter_FunctionTanCuCuCu::
NbVariables () const { return 3; }
Standard_Integer Geom2dGcc_FunctionTanCuCuCu::
NbVariables () const { return 3; }
Standard_Integer GccIter_FunctionTanCuCuCu::
NbEquations () const { return 3; }
Standard_Integer Geom2dGcc_FunctionTanCuCuCu::
NbEquations () const { return 3; }
Standard_Boolean GccIter_FunctionTanCuCuCu::
Value (const math_Vector& X ,
math_Vector& Fval ) {
gp_Pnt2d Point1;
gp_Pnt2d Point2;
gp_Pnt2d Point3;
gp_Vec2d Tan1;
gp_Vec2d Tan2;
gp_Vec2d Tan3;
gp_Vec2d D21;
gp_Vec2d D22;
gp_Vec2d D23;
InitDerivative(X,Point1,Point2,Point3,Tan1,Tan2,Tan3,D21,D22,D23);
//pipj (normes) et PiPj (non Normes).
gp_XY P1P2(gp_Vec2d(Point1,Point2).XY());
gp_XY P2P3(gp_Vec2d(Point2,Point3).XY());
gp_XY P3P1(gp_Vec2d(Point3,Point1).XY());
Standard_Real NorP1P2 = P1P2.Modulus();
Standard_Real NorP2P3 = P2P3.Modulus();
Standard_Real NorP3P1 = P3P1.Modulus();
gp_XY p1p2,p2p3,p3p1;
if (NorP1P2 >= gp::Resolution()) { p1p2 = P1P2/NorP1P2; }
else { p1p2 = gp_XY(0.,0.); }
if (NorP2P3 >= gp::Resolution()) { p2p3 = P2P3/NorP2P3; }
else { p2p3 = gp_XY(0.,0.); }
if (NorP3P1 >= gp::Resolution()) { p3p1 = P3P1/NorP3P1; }
else { p3p1 = gp_XY(0.,0.); }
//derivees premieres non normees Deriv1ui.
gp_XY Deriv1u1(Tan1.XY());
gp_XY Deriv1u2(Tan2.XY());
gp_XY Deriv1u3(Tan3.XY());
//normales aux courbes.
Standard_Real nnor1 = Deriv1u1.Modulus();
Standard_Real nnor2 = Deriv1u2.Modulus();
Standard_Real nnor3 = Deriv1u3.Modulus();
gp_XY Nor1(-Deriv1u1.Y(),Deriv1u1.X());
gp_XY Nor2(-Deriv1u2.Y(),Deriv1u2.X());
gp_XY Nor3(-Deriv1u3.Y(),Deriv1u3.X());
gp_XY nor1,nor2,nor3;
if (nnor1 >= gp::Resolution()) { nor1 = Nor1/nnor1; }
else { nor1 = gp_XY(0.,0.); }
if (nnor2 >= gp::Resolution()) { nor2 = Nor2/nnor2; }
else { nor2 = gp_XY(0.,0.); }
if (nnor3 >= gp::Resolution()) { nor3 = Nor3/nnor3; }
else { nor3 = gp_XY(0.,0.); }
//determination des signes pour les produits scalaires.
Standard_Real signe1 = 1.;
Standard_Real signe2 = 1.;
Standard_Real signe3 = 1.;
gp_Pnt2d Pcenter(gp_XY(Point1.XY()+Point2.XY()+Point3.XY())/3.);
gp_XY fic1(Pcenter.XY()-Point1.XY());
gp_XY fic2(Pcenter.XY()-Point2.XY());
gp_XY fic3(Pcenter.XY()-Point3.XY());
Standard_Real pscal11 = nor1.Dot(fic1);
Standard_Real pscal22 = nor2.Dot(fic2);
Standard_Real pscal33 = nor3.Dot(fic3);
if (pscal11 <= 0.) { signe1 = -1; }
if (pscal22 <= 0.) { signe2 = -1; }
if (pscal33 <= 0.) { signe3 = -1; }
// Fonctions Fui.
// ==============
Fval(1) = signe1*nor1.Dot(p1p2)+signe2*nor2.Dot(p1p2);
Fval(2) = signe2*nor2.Dot(p2p3)+signe3*nor3.Dot(p2p3);
Fval(3) = signe3*nor3.Dot(p3p1)+signe1*nor1.Dot(p3p1);
return Standard_True;
Standard_Boolean Geom2dGcc_FunctionTanCuCuCu::
Value (const math_Vector& X ,
math_Vector& Fval ) {
gp_Pnt2d Point1;
gp_Pnt2d Point2;
gp_Pnt2d Point3;
gp_Vec2d Tan1;
gp_Vec2d Tan2;
gp_Vec2d Tan3;
gp_Vec2d D21;
gp_Vec2d D22;
gp_Vec2d D23;
InitDerivative(X,Point1,Point2,Point3,Tan1,Tan2,Tan3,D21,D22,D23);
//pipj (normes) et PiPj (non Normes).
gp_XY P1P2(gp_Vec2d(Point1,Point2).XY());
gp_XY P2P3(gp_Vec2d(Point2,Point3).XY());
gp_XY P3P1(gp_Vec2d(Point3,Point1).XY());
Standard_Real NorP1P2 = P1P2.Modulus();
Standard_Real NorP2P3 = P2P3.Modulus();
Standard_Real NorP3P1 = P3P1.Modulus();
gp_XY p1p2,p2p3,p3p1;
if (NorP1P2 >= gp::Resolution()) { p1p2 = P1P2/NorP1P2; }
else { p1p2 = gp_XY(0.,0.); }
if (NorP2P3 >= gp::Resolution()) { p2p3 = P2P3/NorP2P3; }
else { p2p3 = gp_XY(0.,0.); }
if (NorP3P1 >= gp::Resolution()) { p3p1 = P3P1/NorP3P1; }
else { p3p1 = gp_XY(0.,0.); }
//derivees premieres non normees Deriv1ui.
gp_XY Deriv1u1(Tan1.XY());
gp_XY Deriv1u2(Tan2.XY());
gp_XY Deriv1u3(Tan3.XY());
//normales aux courbes.
Standard_Real nnor1 = Deriv1u1.Modulus();
Standard_Real nnor2 = Deriv1u2.Modulus();
Standard_Real nnor3 = Deriv1u3.Modulus();
gp_XY Nor1(-Deriv1u1.Y(),Deriv1u1.X());
gp_XY Nor2(-Deriv1u2.Y(),Deriv1u2.X());
gp_XY Nor3(-Deriv1u3.Y(),Deriv1u3.X());
gp_XY nor1,nor2,nor3;
if (nnor1 >= gp::Resolution()) { nor1 = Nor1/nnor1; }
else { nor1 = gp_XY(0.,0.); }
if (nnor2 >= gp::Resolution()) { nor2 = Nor2/nnor2; }
else { nor2 = gp_XY(0.,0.); }
if (nnor3 >= gp::Resolution()) { nor3 = Nor3/nnor3; }
else { nor3 = gp_XY(0.,0.); }
//determination des signes pour les produits scalaires.
Standard_Real signe1 = 1.;
Standard_Real signe2 = 1.;
Standard_Real signe3 = 1.;
gp_Pnt2d Pcenter(gp_XY(Point1.XY()+Point2.XY()+Point3.XY())/3.);
gp_XY fic1(Pcenter.XY()-Point1.XY());
gp_XY fic2(Pcenter.XY()-Point2.XY());
gp_XY fic3(Pcenter.XY()-Point3.XY());
Standard_Real pscal11 = nor1.Dot(fic1);
Standard_Real pscal22 = nor2.Dot(fic2);
Standard_Real pscal33 = nor3.Dot(fic3);
if (pscal11 <= 0.) { signe1 = -1; }
if (pscal22 <= 0.) { signe2 = -1; }
if (pscal33 <= 0.) { signe3 = -1; }
// Fonctions Fui.
// ==============
Fval(1) = signe1*nor1.Dot(p1p2)+signe2*nor2.Dot(p1p2);
Fval(2) = signe2*nor2.Dot(p2p3)+signe3*nor3.Dot(p2p3);
Fval(3) = signe3*nor3.Dot(p3p1)+signe1*nor1.Dot(p3p1);
return Standard_True;
}
Standard_Boolean GccIter_FunctionTanCuCuCu::Derivatives (const math_Vector&,
math_Matrix&)
Standard_Boolean Geom2dGcc_FunctionTanCuCuCu::Derivatives (const math_Vector&,
math_Matrix&)
{
#if 0
gp_Pnt2d Point1;
@ -234,11 +238,11 @@ Standard_Boolean GccIter_FunctionTanCuCuCu::Derivatives (const math_Vector&,
gp_Vec2d D22;
gp_Vec2d D23;
InitDerivative(X,Point1,Point2,Point3,Tan1,Tan2,Tan3,D21,D22,D23);
//derivees premieres non normees Deriv1ui.
//derivees premieres non normees Deriv1ui.
gp_XY Deriv1u1(Tan1.XY());
gp_XY Deriv1u2(Tan2.XY());
gp_XY Deriv1u3(Tan3.XY());
//pipj (normes) et PiPj (non Normes).
//pipj (normes) et PiPj (non Normes).
gp_XY P1P2(gp_Vec2d(Point1,Point2).XY());
gp_XY P2P3(gp_Vec2d(Point2,Point3).XY());
gp_XY P3P1(gp_Vec2d(Point3,Point1).XY());
@ -252,7 +256,7 @@ Standard_Boolean GccIter_FunctionTanCuCuCu::Derivatives (const math_Vector&,
else { p2p3 = gp_XY(0.,0.); }
if (NorP3P1 >= gp::Resolution()) { p3p1 = P3P1/NorP3P1; }
else { p3p1 = gp_XY(0.,0.); }
//normales au courbes normees Nori et non nromees nori et norme des nori.
//normales au courbes normees Nori et non nromees nori et norme des nori.
Standard_Real nnor1 = Deriv1u1.Modulus();
Standard_Real nnor2 = Deriv1u2.Modulus();
Standard_Real nnor3 = Deriv1u3.Modulus();
@ -266,12 +270,12 @@ Standard_Boolean GccIter_FunctionTanCuCuCu::Derivatives (const math_Vector&,
else { nor2 = gp_XY(0.,0.); }
if (nnor3 >= gp::Resolution()) { nor3 = Nor3/nnor3; }
else { nor3 = gp_XY(0.,0.); }
//derivees des normales.
//derivees des normales.
gp_XY NorD21,NorD22,NorD23;
NorD21 = gp_XY(-D21.Y(),D21.X());
NorD22 = gp_XY(-D22.Y(),D22.X());
NorD23 = gp_XY(-D23.Y(),D23.X());
//determination des signes pour les produits scalaires.
//determination des signes pour les produits scalaires.
Standard_Real signe1 = 1.;
Standard_Real signe2 = 1.;
Standard_Real signe3 = 1.;
@ -293,62 +297,62 @@ Standard_Boolean GccIter_FunctionTanCuCuCu::Derivatives (const math_Vector&,
if (pscal22 <= 0.) { signe2 = -1; }
if (pscal33 <= 0.) { signe3 = -1; }
// Derivees dFui/uj 1 <= ui <= 3 , 1 <= uj <= 3
// =============================================
// Derivees dFui/uj 1 <= ui <= 3 , 1 <= uj <= 3
// =============================================
Standard_Real partie1,partie2;
if (nnor1 <= gp::Resolution()) { partie1 = 0.; }
else { partie1 = (signe1*NorD21/nnor1-(Nor1.Dot(NorD21)/(nnor1*nnor1*nnor1))
*Nor1).Dot(p1p2); }
*Nor1).Dot(p1p2); }
if (NorP1P2 <= gp::Resolution()) { partie2 = 0.; }
else {partie2=((Deriv1u1.Dot(p1p2)/(NorP1P2*NorP1P2))*P1P2-Deriv1u1/NorP1P2)
.Dot(signe1*nor1+signe2*nor2); }
.Dot(signe1*nor1+signe2*nor2); }
Deriv(1,1) = partie1 + partie2;
if (nnor2 <= gp::Resolution()) { partie1 = 0.; }
else { partie1=(signe2*NorD22/(nnor2)-(Nor2.Dot(NorD22)/(nnor2*nnor2*nnor2))
*Nor2).Dot(p1p2); }
*Nor2).Dot(p1p2); }
if (NorP1P2 <= gp::Resolution()) { partie2 = 0.; }
else{partie2=((-Deriv1u2.Dot(p1p2)/(NorP1P2*NorP1P2))*P1P2+Deriv1u2/NorP1P2)
.Dot(signe1*nor1+signe2*nor2); }
.Dot(signe1*nor1+signe2*nor2); }
Deriv(1,2) = partie1 + partie2;
Deriv(1,3) = 0.;
Deriv(2,1) = 0.;
if (nnor2 <= gp::Resolution()) { partie1 = 0.; }
else { partie1=(signe2*NorD22/(nnor2)-(Nor2.Dot(NorD22)/(nnor2*nnor2*nnor2))
*Nor2).Dot(p2p3); }
*Nor2).Dot(p2p3); }
if (NorP2P3 <= gp::Resolution()) { partie2 = 0.; }
else { partie2=((Deriv1u2.Dot(p2p3)/(NorP2P3*NorP2P3))*P2P3-Deriv1u2/NorP2P3)
.Dot(signe2*nor2+signe3*nor3); }
.Dot(signe2*nor2+signe3*nor3); }
Deriv(2,2) = partie1 +partie2;
if (nnor3 <= gp::Resolution()) { partie1 = 0.; }
else { partie1=(signe3*NorD23/(nnor3)-(Nor3.Dot(NorD23)/(nnor3*nnor3*nnor3))
*Nor3).Dot(p2p3); }
*Nor3).Dot(p2p3); }
if (NorP2P3 <= gp::Resolution()) { partie2 = 0.; }
else {partie2=((-Deriv1u3.Dot(p2p3)/(NorP2P3*NorP2P3))*P2P3+Deriv1u3/NorP2P3)
.Dot(signe2*nor2+signe3*nor3); }
.Dot(signe2*nor2+signe3*nor3); }
Deriv(2,3) = partie1 + partie2;
if (nnor1 <= gp::Resolution()) { partie1 = 0.; }
else { partie1 =(signe1*NorD21/(nnor1)-(Nor1.Dot(NorD21)/(nnor1*nnor1*nnor1))
*Nor1).Dot(p3p1); }
*Nor1).Dot(p3p1); }
if (NorP3P1 <= gp::Resolution()) { partie2 = 0.; }
else {partie2=((-Deriv1u1.Dot(p3p1)/(NorP3P1*NorP3P1))*P3P1+Deriv1u1/NorP3P1)
.Dot(signe1*nor1+signe3*nor3); }
.Dot(signe1*nor1+signe3*nor3); }
Deriv(3,1) = partie1 + partie2;
Deriv(3,2) = 0.;
if (nnor3 <= gp::Resolution()) { partie1 = 0.; }
else { partie1=(signe3*NorD23/(nnor3)-(Nor3.Dot(NorD23)/(nnor3*nnor3*nnor3))
*Nor3).Dot(p3p1); }
*Nor3).Dot(p3p1); }
if (NorP3P1 <= gp::Resolution()) { partie2 = 0.; }
else {partie2=((Deriv1u3.Dot(p3p1)/(NorP3P1*NorP3P1))*P3P1-Deriv1u3/NorP3P1)
.Dot(signe1*nor1+signe3*nor3); }
.Dot(signe1*nor1+signe3*nor3); }
Deriv(3,3) = partie1+partie2;
#endif
return Standard_True;
}
Standard_Boolean GccIter_FunctionTanCuCuCu:: Values (const math_Vector&,
math_Vector&,
math_Matrix& )
Standard_Boolean Geom2dGcc_FunctionTanCuCuCu:: Values (const math_Vector&,
math_Vector&,
math_Matrix& )
{
#if 0
gp_Pnt2d Point1;
@ -361,11 +365,11 @@ Standard_Boolean GccIter_FunctionTanCuCuCu:: Values (const math_Vector&,
gp_Vec2d D22;
gp_Vec2d D23;
InitDerivative(X,Point1,Point2,Point3,Tan1,Tan2,Tan3,D21,D22,D23);
//derivees premieres non normees Deriv1ui.
//derivees premieres non normees Deriv1ui.
gp_XY Deriv1u1(Tan1.XY());
gp_XY Deriv1u2(Tan2.XY());
gp_XY Deriv1u3(Tan3.XY());
//pipj (normes) et PiPj (non Normes).
//pipj (normes) et PiPj (non Normes).
gp_XY P1P2(gp_Vec2d(Point1,Point2).XY());
gp_XY P2P3(gp_Vec2d(Point2,Point3).XY());
gp_XY P3P1(gp_Vec2d(Point3,Point1).XY());
@ -379,7 +383,7 @@ Standard_Boolean GccIter_FunctionTanCuCuCu:: Values (const math_Vector&,
else { p2p3 = gp_XY(0.,0.); }
if (NorP3P1 >= gp::Resolution()) { p3p1 = P3P1/NorP3P1; }
else { p3p1 = gp_XY(0.,0.); }
//normales au courbes normees Nori et non nromees nori et norme des nori.
//normales au courbes normees Nori et non nromees nori et norme des nori.
Standard_Real nnor1 = Deriv1u1.Modulus();
Standard_Real nnor2 = Deriv1u2.Modulus();
Standard_Real nnor3 = Deriv1u3.Modulus();
@ -393,12 +397,12 @@ Standard_Boolean GccIter_FunctionTanCuCuCu:: Values (const math_Vector&,
else { nor2 = gp_XY(0.,0.); }
if (nnor3 >= gp::Resolution()) { nor3 = Nor3/nnor3; }
else { nor3 = gp_XY(0.,0.); }
//derivees des normales.
//derivees des normales.
gp_XY NorD21,NorD22,NorD23;
NorD21 = gp_XY(-D21.Y(),D21.X());
NorD22 = gp_XY(-D22.Y(),D22.X());
NorD23 = gp_XY(-D23.Y(),D23.X());
//determination des signes pour les produits scalaires.
//determination des signes pour les produits scalaires.
Standard_Real signe1 = 1.;
Standard_Real signe2 = 1.;
Standard_Real signe3 = 1.;
@ -420,58 +424,58 @@ Standard_Boolean GccIter_FunctionTanCuCuCu:: Values (const math_Vector&,
if (pscal22 <= 0.) { signe2 = -1; }
if (pscal33 <= 0.) { signe3 = -1; }
// Fonctions Fui.
// ==============
// Fonctions Fui.
// ==============
Fval(1) = signe1*nor1.Dot(p1p2)+signe2*nor2.Dot(p1p2);
Fval(2) = signe2*nor2.Dot(p2p3)+signe3*nor3.Dot(p2p3);
Fval(3) = signe3*nor3.Dot(p3p1)+signe1*nor1.Dot(p3p1);
// Derivees dFui/uj 1 <= ui <= 3 , 1 <= uj <= 3
// =============================================
// Derivees dFui/uj 1 <= ui <= 3 , 1 <= uj <= 3
// =============================================
Standard_Real partie1,partie2;
if (nnor1 <= gp::Resolution()) { partie1 = 0.; }
else { partie1 = signe1*(NorD21/nnor1-(Nor1.Dot(NorD21)/(nnor1*nnor1*nnor1))
*Nor1).Dot(p1p2); }
*Nor1).Dot(p1p2); }
if (NorP1P2 <= gp::Resolution()) { partie2 = 0.; }
else {partie2=((Deriv1u1.Dot(p1p2)/(NorP1P2*NorP1P2))*P1P2-Deriv1u1/NorP1P2)
.Dot(signe1*nor1+signe2*nor2); }
.Dot(signe1*nor1+signe2*nor2); }
Deriv(1,1) = partie1 + partie2;
if (nnor2 <= gp::Resolution()) { partie1 = 0.; }
else { partie1=signe2*(NorD22/(nnor2)-(Nor2.Dot(NorD22)/(nnor2*nnor2*nnor2))
*Nor2).Dot(p1p2); }
*Nor2).Dot(p1p2); }
if (NorP1P2 <= gp::Resolution()) { partie2 = 0.; }
else{partie2=((-Deriv1u2.Dot(p1p2)/(NorP1P2*NorP1P2))*P1P2+Deriv1u2/NorP1P2)
.Dot(signe1*nor1+signe2*nor2); }
.Dot(signe1*nor1+signe2*nor2); }
Deriv(1,2) = partie1 + partie2;
Deriv(1,3) = 0.;
Deriv(2,1) = 0.;
if (nnor2 <= gp::Resolution()) { partie1 = 0.; }
else { partie1=signe2*(NorD22/(nnor2)-(Nor2.Dot(NorD22)/(nnor2*nnor2*nnor2))
*Nor2).Dot(p2p3); }
*Nor2).Dot(p2p3); }
if (NorP2P3 <= gp::Resolution()) { partie2 = 0.; }
else { partie2=((Deriv1u2.Dot(p2p3)/(NorP2P3*NorP2P3))*P2P3-Deriv1u2/NorP2P3)
.Dot(signe2*nor2+signe3*nor3); }
.Dot(signe2*nor2+signe3*nor3); }
Deriv(2,2) = partie1 +partie2;
if (nnor3 <= gp::Resolution()) { partie1 = 0.; }
else { partie1=signe3*(NorD23/(nnor3)-(Nor3.Dot(NorD23)/(nnor3*nnor3*nnor3))
*Nor3).Dot(p2p3); }
*Nor3).Dot(p2p3); }
if (NorP2P3 <= gp::Resolution()) { partie2 = 0.; }
else {partie2=((-Deriv1u3.Dot(p2p3)/(NorP2P3*NorP2P3))*P2P3+Deriv1u3/NorP2P3)
.Dot(signe2*nor2+signe3*nor3); }
.Dot(signe2*nor2+signe3*nor3); }
Deriv(2,3) = partie1 + partie2;
if (nnor1 <= gp::Resolution()) { partie1 = 0.; }
else { partie1 =signe1*(NorD21/(nnor1)-(Nor1.Dot(NorD21)/(nnor1*nnor1*nnor1))
*Nor1).Dot(p3p1); }
*Nor1).Dot(p3p1); }
if (NorP3P1 <= gp::Resolution()) { partie2 = 0.; }
else {partie2=((-Deriv1u1.Dot(p3p1)/(NorP3P1*NorP3P1))*P3P1+Deriv1u1/NorP3P1)
.Dot(signe1*nor1+signe3*nor3); }
.Dot(signe1*nor1+signe3*nor3); }
Deriv(3,1) = partie1 + partie2;
Deriv(3,2) = 0.;
if (nnor3 <= gp::Resolution()) { partie1 = 0.; }
else { partie1=signe3*(NorD23/(nnor3)-(Nor3.Dot(NorD23)/(nnor3*nnor3*nnor3))
*Nor3).Dot(p3p1); }
*Nor3).Dot(p3p1); }
if (NorP3P1 <= gp::Resolution()) { partie2 = 0.; }
else {partie2=((Deriv1u3.Dot(p3p1)/(NorP3P1*NorP3P1))*P3P1-Deriv1u3/NorP3P1)
.Dot(signe1*nor1+signe3*nor3); }
.Dot(signe1*nor1+signe3*nor3); }
Deriv(3,3) = partie1+partie2;
#endif
return Standard_True;

92
src/GccIter/GccIter_FunctionTanCuCuOnCu.cdl → src/Geom2dGcc/Geom2dGcc_FunctionTanCuCuOnCu.cdl
View File

@ -14,102 +14,100 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
generic class FunctionTanCuCuOnCu from GccIter (
TheCurve as any;
TheCurveTool as any) -- as CurvePGTool from GccInt (TheCurve)
inherits FunctionSetWithDerivatives from math
private class FunctionTanCuCuOnCu from Geom2dGcc inherits FunctionSetWithDerivatives from math
---Purpose: This abstract class describes a set on N Functions of
-- M independant variables.
uses Vector from math,
Matrix from math,
Circ2d from gp,
Lin2d from gp,
Pnt2d from gp,
Vec2d from gp,
Type2 from GccIter
uses Vector from math,
Matrix from math,
Circ2d from gp,
Lin2d from gp,
Pnt2d from gp,
Vec2d from gp,
Type2 from Geom2dGcc,
Curve from Geom2dAdaptor,
CurveTool from Geom2dGcc
raises ConstructionError
is
Create (C1 : TheCurve ;
C2 : TheCurve ;
Create (C1 : Curve from Geom2dAdaptor;
C2 : Curve from Geom2dAdaptor;
OnCi : Circ2d from gp ;
Rad : Real from Standard )
returns FunctionTanCuCuOnCu from GccIter;
returns FunctionTanCuCuOnCu from Geom2dGcc;
Create (C1 : Circ2d from gp ;
C2 : TheCurve ;
C2 : Curve from Geom2dAdaptor;
OnCi : Circ2d from gp ;
Rad : Real from Standard )
returns FunctionTanCuCuOnCu from GccIter;
returns FunctionTanCuCuOnCu from Geom2dGcc;
Create (L1 : Lin2d from gp ;
C2 : TheCurve ;
C2 : Curve from Geom2dAdaptor;
OnCi : Circ2d from gp ;
Rad : Real from Standard )
returns FunctionTanCuCuOnCu from GccIter;
returns FunctionTanCuCuOnCu from Geom2dGcc;
Create (C1 : TheCurve ;
Create (C1 : Curve from Geom2dAdaptor;
P2 : Pnt2d from gp ;
OnCi : Circ2d from gp ;
Rad : Real from Standard )
returns FunctionTanCuCuOnCu from GccIter;
returns FunctionTanCuCuOnCu from Geom2dGcc;
------------------------------------------------------------------------
Create (C1 : TheCurve ;
C2 : TheCurve ;
Create (C1 : Curve from Geom2dAdaptor;
C2 : Curve from Geom2dAdaptor;
OnLi : Lin2d from gp ;
Rad : Real from Standard )
returns FunctionTanCuCuOnCu from GccIter;
returns FunctionTanCuCuOnCu from Geom2dGcc;
Create (C1 : Circ2d from gp ;
C2 : TheCurve ;
C2 : Curve from Geom2dAdaptor;
OnLi : Lin2d from gp ;
Rad : Real from Standard )
returns FunctionTanCuCuOnCu from GccIter;
returns FunctionTanCuCuOnCu from Geom2dGcc;
Create (L1 : Lin2d from gp ;
C2 : TheCurve ;
C2 : Curve from Geom2dAdaptor;
OnLi : Lin2d from gp ;
Rad : Real from Standard )
returns FunctionTanCuCuOnCu from GccIter;
returns FunctionTanCuCuOnCu from Geom2dGcc;
Create (C1 : TheCurve ;
Create (C1 : Curve from Geom2dAdaptor;
P2 : Pnt2d from gp ;
OnLi : Lin2d from gp ;
Rad : Real from Standard )
returns FunctionTanCuCuOnCu from GccIter;
returns FunctionTanCuCuOnCu from Geom2dGcc;
-----------------------------------------------------------------------
Create (C1 : TheCurve ;
C2 : TheCurve ;
OnCu : TheCurve ;
Create (C1 : Curve from Geom2dAdaptor;
C2 : Curve from Geom2dAdaptor;
OnCu : Curve from Geom2dAdaptor;
Rad : Real from Standard )
returns FunctionTanCuCuOnCu from GccIter;
returns FunctionTanCuCuOnCu from Geom2dGcc;
Create (C1 : Circ2d from gp ;
C2 : TheCurve ;
OnCu : TheCurve ;
C2 : Curve from Geom2dAdaptor;
OnCu : Curve from Geom2dAdaptor;
Rad : Real from Standard )
returns FunctionTanCuCuOnCu from GccIter;
returns FunctionTanCuCuOnCu from Geom2dGcc;
Create (L1 : Lin2d from gp ;
C2 : TheCurve ;
OnCu : TheCurve ;
C2 : Curve from Geom2dAdaptor;
OnCu : Curve from Geom2dAdaptor;
Rad : Real from Standard )
returns FunctionTanCuCuOnCu from GccIter;
returns FunctionTanCuCuOnCu from Geom2dGcc;
Create (C1 : TheCurve ;
Create (C1 : Curve from Geom2dAdaptor;
P1 : Pnt2d from gp ;
OnCu : TheCurve ;
OnCu : Curve from Geom2dAdaptor;
Rad : Real from Standard )
returns FunctionTanCuCuOnCu from GccIter;
returns FunctionTanCuCuOnCu from Geom2dGcc;
InitDerivative(me : in out ;
X : Vector from math ;
@ -143,16 +141,16 @@ is static;
fields
Curv1 : TheCurve ;
Curv2 : TheCurve ;
Curv1 : Curve from Geom2dAdaptor;
Curv2 : Curve from Geom2dAdaptor;
Circ1 : Circ2d from gp ;
Lin1 : Lin2d from gp ;
Pnt2 : Pnt2d from gp ;
Circon : Circ2d from gp ;
Linon : Lin2d from gp ;
Curvon : TheCurve ;
Curvon : Curve from Geom2dAdaptor;
FirstRad : Real from Standard ;
TheType : Type2 from GccIter ;
TheType : Type2 from Geom2dGcc ;
end FunctionTanCuCuOnCu;

176
src/GccIter/GccIter_FunctionTanCuCuOnCu.gxx → src/Geom2dGcc/Geom2dGcc_FunctionTanCuCuOnCu.cxx
View File

@ -14,10 +14,14 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2dGcc_FunctionTanCuCuOnCu.ixx>
#include <Standard_ConstructionError.hxx>
#include <ElCLib.hxx>
void GccIter_FunctionTanCuCuOnCu::
#include <Geom2dGcc_CurveTool.hxx>
void Geom2dGcc_FunctionTanCuCuOnCu::
InitDerivative(const math_Vector& X,
gp_Pnt2d& Point1,
gp_Pnt2d& Point2,
@ -29,96 +33,96 @@ void GccIter_FunctionTanCuCuOnCu::
gp_Vec2d& D22,
gp_Vec2d& D23) {
switch (TheType) {
case GccIter_CuCuOnCu:
case Geom2dGcc_CuCuOnCu:
{
TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
TheCurveTool::D2(Curvon,X(3),Point3,Tan3,D23);
Geom2dGcc_CurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
Geom2dGcc_CurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
Geom2dGcc_CurveTool::D2(Curvon,X(3),Point3,Tan3,D23);
}
break;
case GccIter_CiCuOnCu:
case Geom2dGcc_CiCuOnCu:
{
ElCLib::D2(X(1),Circ1,Point1,Tan1,D21);
TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
TheCurveTool::D2(Curvon,X(3),Point3,Tan3,D23);
Geom2dGcc_CurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
Geom2dGcc_CurveTool::D2(Curvon,X(3),Point3,Tan3,D23);
}
break;
case GccIter_LiCuOnCu:
case Geom2dGcc_LiCuOnCu:
{
ElCLib::D1(X(1),Lin1,Point1,Tan1);
D21 = gp_Vec2d(0.,0.);
TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
TheCurveTool::D2(Curvon,X(3),Point3,Tan3,D23);
Geom2dGcc_CurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
Geom2dGcc_CurveTool::D2(Curvon,X(3),Point3,Tan3,D23);
}
break;
case GccIter_CuPtOnCu:
case Geom2dGcc_CuPtOnCu:
{
TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
TheCurveTool::D2(Curvon,X(3),Point3,Tan3,D23);
Geom2dGcc_CurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
Geom2dGcc_CurveTool::D2(Curvon,X(3),Point3,Tan3,D23);
Point2 = Pnt2;
Tan2 = gp_Vec2d(0.,0.);
D22 = gp_Vec2d(0.,0.);
}
break;
case GccIter_CuCuOnCi:
case Geom2dGcc_CuCuOnCi:
{
TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
Geom2dGcc_CurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
Geom2dGcc_CurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
ElCLib::D2(X(3),Circon,Point3,Tan3,D23);
}
break;
case GccIter_CiCuOnCi:
case Geom2dGcc_CiCuOnCi:
{
ElCLib::D2(X(1),Circ1,Point1,Tan1,D21);
TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
Geom2dGcc_CurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
ElCLib::D2(X(3),Circon,Point3,Tan3,D23);
}
break;
case GccIter_LiCuOnCi:
case Geom2dGcc_LiCuOnCi:
{
ElCLib::D1(X(1),Lin1,Point1,Tan1);
D21 = gp_Vec2d(0.,0.);
TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
Geom2dGcc_CurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
ElCLib::D2(X(3),Circon,Point3,Tan3,D23);
}
break;
case GccIter_CuPtOnCi:
case Geom2dGcc_CuPtOnCi:
{
TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
Geom2dGcc_CurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
Point2 = Pnt2;
Tan2 = gp_Vec2d(0.,0.);
D22 = gp_Vec2d(0.,0.);
ElCLib::D2(X(3),Circon,Point3,Tan3,D23);
}
break;
case GccIter_CuCuOnLi:
case Geom2dGcc_CuCuOnLi:
{
TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
Geom2dGcc_CurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
Geom2dGcc_CurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
ElCLib::D1(X(3),Linon,Point3,Tan3);
D23 = gp_Vec2d(0.,0.);
}
break;
case GccIter_CiCuOnLi:
case Geom2dGcc_CiCuOnLi:
{
ElCLib::D2(X(1),Circ1,Point1,Tan1,D21);
TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
Geom2dGcc_CurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
ElCLib::D1(X(3),Linon,Point3,Tan3);
D23 = gp_Vec2d(0.,0.);
}
break;
case GccIter_LiCuOnLi:
case Geom2dGcc_LiCuOnLi:
{
ElCLib::D1(X(1),Lin1,Point1,Tan1);
TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
Geom2dGcc_CurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
D21 = gp_Vec2d(0.,0.);
ElCLib::D1(X(3),Linon,Point3,Tan3);
D23 = gp_Vec2d(0.,0.);
}
break;
case GccIter_CuPtOnLi:
case Geom2dGcc_CuPtOnLi:
{
TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
Geom2dGcc_CurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
Point2 = Pnt2;
Tan2 = gp_Vec2d(0.,0.);
D22 = gp_Vec2d(0.,0.);
@ -133,92 +137,92 @@ void GccIter_FunctionTanCuCuOnCu::
}
}
GccIter_FunctionTanCuCuOnCu::
GccIter_FunctionTanCuCuOnCu(const TheCurve& C1 ,
const TheCurve& C2 ,
const TheCurve& C3 ,
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1 ,
const Geom2dAdaptor_Curve& C2 ,
const Geom2dAdaptor_Curve& C3 ,
const Standard_Real Rad ) {
Curv1 = C1;
Curv2 = C2;
Curvon = C3;
FirstRad = Rad;
TheType = GccIter_CuCuOnCu;
TheType = Geom2dGcc_CuCuOnCu;
}
GccIter_FunctionTanCuCuOnCu::
GccIter_FunctionTanCuCuOnCu(const gp_Circ2d& C1 ,
const TheCurve& C2 ,
const TheCurve& C3 ,
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const gp_Circ2d& C1 ,
const Geom2dAdaptor_Curve& C2 ,
const Geom2dAdaptor_Curve& C3 ,
const Standard_Real Rad ) {
Circ1 = C1;
Curv2 = C2;
Curvon = C3;
FirstRad = Rad;
TheType = GccIter_CiCuOnCu;
TheType = Geom2dGcc_CiCuOnCu;
}
GccIter_FunctionTanCuCuOnCu::
GccIter_FunctionTanCuCuOnCu(const gp_Lin2d& L1 ,
const TheCurve& C2 ,
const TheCurve& C3 ,
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const gp_Lin2d& L1 ,
const Geom2dAdaptor_Curve& C2 ,
const Geom2dAdaptor_Curve& C3 ,
const Standard_Real Rad ) {
Lin1 = L1;
Curv2 = C2;
Curvon = C3;
FirstRad = Rad;
TheType = GccIter_LiCuOnCu;
TheType = Geom2dGcc_LiCuOnCu;
}
GccIter_FunctionTanCuCuOnCu::
GccIter_FunctionTanCuCuOnCu(const TheCurve& C1 ,
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1 ,
const gp_Pnt2d& P2 ,
const TheCurve& C3 ,
const Geom2dAdaptor_Curve& C3 ,
const Standard_Real Rad ) {
Curv1 = C1;
Pnt2 = P2;
Curvon = C3;
FirstRad = Rad;
TheType = GccIter_CuPtOnCu;
TheType = Geom2dGcc_CuPtOnCu;
}
GccIter_FunctionTanCuCuOnCu::
GccIter_FunctionTanCuCuOnCu(const TheCurve& C1 ,
const TheCurve& C2 ,
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1 ,
const Geom2dAdaptor_Curve& C2 ,
const gp_Lin2d& OnLi ,
const Standard_Real Rad ) {
Curv1 = C1;
Curv2 = C2;
Linon = OnLi;
FirstRad = Rad;
TheType = GccIter_CuCuOnLi;
TheType = Geom2dGcc_CuCuOnLi;
}
GccIter_FunctionTanCuCuOnCu::
GccIter_FunctionTanCuCuOnCu(const gp_Circ2d& C1 ,
const TheCurve& C2 ,
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const gp_Circ2d& C1 ,
const Geom2dAdaptor_Curve& C2 ,
const gp_Lin2d& OnLi ,
const Standard_Real Rad ) {
Circ1 = C1;
Curv2 = C2;
Linon = OnLi;
FirstRad = Rad;
TheType = GccIter_CiCuOnLi;
TheType = Geom2dGcc_CiCuOnLi;
}
GccIter_FunctionTanCuCuOnCu::
GccIter_FunctionTanCuCuOnCu(const gp_Lin2d& L1 ,
const TheCurve& C2 ,
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const gp_Lin2d& L1 ,
const Geom2dAdaptor_Curve& C2 ,
const gp_Lin2d& OnLi ,
const Standard_Real Rad ) {
Lin1 = L1;
Curv2 = C2;
Linon = OnLi;
FirstRad = Rad;
TheType = GccIter_LiCuOnLi;
TheType = Geom2dGcc_LiCuOnLi;
}
GccIter_FunctionTanCuCuOnCu::
GccIter_FunctionTanCuCuOnCu(const TheCurve& C1 ,
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1 ,
const gp_Pnt2d& P2 ,
const gp_Lin2d& OnLi ,
const Standard_Real Rad ) {
@ -226,47 +230,47 @@ GccIter_FunctionTanCuCuOnCu::
Pnt2 = P2;
Linon = OnLi;
FirstRad = Rad;
TheType = GccIter_CuPtOnLi;
TheType = Geom2dGcc_CuPtOnLi;
}
GccIter_FunctionTanCuCuOnCu::
GccIter_FunctionTanCuCuOnCu(const TheCurve& C1 ,
const TheCurve& C2 ,
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1 ,
const Geom2dAdaptor_Curve& C2 ,
const gp_Circ2d& OnCi ,
const Standard_Real Rad ) {
Curv1 = C1;
Curv2 = C2;
Circon = OnCi;
FirstRad = Rad;
TheType = GccIter_CuCuOnCi;
TheType = Geom2dGcc_CuCuOnCi;
}
GccIter_FunctionTanCuCuOnCu::
GccIter_FunctionTanCuCuOnCu(const gp_Circ2d& C1 ,
const TheCurve& C2 ,
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const gp_Circ2d& C1 ,
const Geom2dAdaptor_Curve& C2 ,
const gp_Circ2d& OnCi ,
const Standard_Real Rad ) {
Circ1 = C1;
Curv2 = C2;
Circon = OnCi;
FirstRad = Rad;
TheType = GccIter_CuCuOnCi;
TheType = Geom2dGcc_CuCuOnCi;
}
GccIter_FunctionTanCuCuOnCu::
GccIter_FunctionTanCuCuOnCu(const gp_Lin2d& L1 ,
const TheCurve& C2 ,
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const gp_Lin2d& L1 ,
const Geom2dAdaptor_Curve& C2 ,
const gp_Circ2d& OnCi ,
const Standard_Real Rad ) {
Lin1 = L1;
Curv2 = C2;
Circon = OnCi;
FirstRad = Rad;
TheType = GccIter_LiCuOnCi;
TheType = Geom2dGcc_LiCuOnCi;
}
GccIter_FunctionTanCuCuOnCu::
GccIter_FunctionTanCuCuOnCu(const TheCurve& C1 ,
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1 ,
const gp_Pnt2d& P2 ,
const gp_Circ2d& OnCi ,
const Standard_Real Rad ) {
@ -274,16 +278,16 @@ GccIter_FunctionTanCuCuOnCu::
Pnt2 = P2;
Circon = OnCi;
FirstRad = Rad;
TheType = GccIter_CuPtOnCi;
TheType = Geom2dGcc_CuPtOnCi;
}
Standard_Integer GccIter_FunctionTanCuCuOnCu::
Standard_Integer Geom2dGcc_FunctionTanCuCuOnCu::
NbVariables () const { return 4; }
Standard_Integer GccIter_FunctionTanCuCuOnCu::
Standard_Integer Geom2dGcc_FunctionTanCuCuOnCu::
NbEquations () const { return 4; }
Standard_Boolean GccIter_FunctionTanCuCuOnCu::
Standard_Boolean Geom2dGcc_FunctionTanCuCuOnCu::
Value (const math_Vector& X ,
math_Vector& Fval ) {
gp_Pnt2d Point1,Point2,Point3;
@ -310,7 +314,7 @@ Standard_Boolean GccIter_FunctionTanCuCuOnCu::
return Standard_True;
}
Standard_Boolean GccIter_FunctionTanCuCuOnCu::
Standard_Boolean Geom2dGcc_FunctionTanCuCuOnCu::
Derivatives (const math_Vector& X ,
math_Matrix& Deriv ) {
gp_Pnt2d Point1,Point2,Point3;
@ -355,7 +359,7 @@ Standard_Boolean GccIter_FunctionTanCuCuOnCu::
return Standard_True;
}
Standard_Boolean GccIter_FunctionTanCuCuOnCu::
Standard_Boolean Geom2dGcc_FunctionTanCuCuOnCu::
Values (const math_Vector& X ,
math_Vector& Fval ,
math_Matrix& Deriv ) {

17
src/GccIter/GccIter_FunctionTanCuPnt.cdl → src/Geom2dGcc/Geom2dGcc_FunctionTanCuPnt.cdl
View File

@ -14,22 +14,23 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
generic class FunctionTanCuPnt from GccIter (
TheCurve as any ;
TheCurveTool as any )
private class FunctionTanCuPnt from Geom2dGcc
inherits FunctionWithDerivative from math
---Purpose: This abstract class describes a Function of 1 Variable
-- used to find a line tangent to a curve and passing
-- through a point.
uses Pnt2d from gp
uses
Pnt2d from gp,
Curve from Geom2dAdaptor,
CurveTool from Geom2dGcc
is
Create (C : TheCurve ;
Point : Pnt2d from gp ) returns FunctionTanCuPnt from GccIter;
Create (C : Curve from Geom2dAdaptor ;
Point : Pnt2d from gp ) returns FunctionTanCuPnt from Geom2dGcc;
Value (me : in out ;
X : Real ;
@ -56,7 +57,7 @@ Values (me : in out ;
fields
TheCurv : TheCurve;
TheCurv : Curve from Geom2dAdaptor;
ThePoint : Pnt2d from gp;
end FunctionTanCuPnt;

100
src/Geom2dGcc/Geom2dGcc_FunctionTanCuPnt.cxx Normal file
View File

@ -0,0 +1,100 @@
// 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 <Geom2dGcc_FunctionTanCuPnt.ixx>
#include <gp_Vec2d.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Vec.hxx>
#include <gp_Pnt.hxx>
#include <Geom2dGcc_CurveTool.hxx>
//=========================================================================
// soit P1 le point sur la courbe Geom2dAdaptor_Curve 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 +
//=========================================================================
Geom2dGcc_FunctionTanCuPnt::
Geom2dGcc_FunctionTanCuPnt(const Geom2dAdaptor_Curve& C ,
const gp_Pnt2d& Point ) {
TheCurv = C;
ThePoint = Point;
}
Standard_Boolean Geom2dGcc_FunctionTanCuPnt::
Value (const Standard_Real X ,
Standard_Real& Fval ) {
gp_Pnt2d Point;
gp_Vec2d Vect;
Geom2dGcc_CurveTool::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 Geom2dGcc_FunctionTanCuPnt::
Derivative (const Standard_Real X ,
Standard_Real& Deriv ) {
gp_Pnt2d Point;
gp_Vec2d Vec1;
gp_Vec2d Vec2;
Geom2dGcc_CurveTool::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 Geom2dGcc_FunctionTanCuPnt::
Values (const Standard_Real X ,
Standard_Real& Fval ,
Standard_Real& Deriv ) {
gp_Pnt2d Point;
gp_Vec2d Vec1;
gp_Vec2d Vec2;
Geom2dGcc_CurveTool::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;
}

22
src/GccIter/GccIter_FunctionTanObl.cdl → src/Geom2dGcc/Geom2dGcc_FunctionTanObl.cdl
View File

@ -14,20 +14,18 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
generic class FunctionTanObl from GccIter (
TheCurve as any;
TheCurveTool as any) -- as CurvePGTool from GccInt (TheCurve)
inherits FunctionWithDerivative from math
private class FunctionTanObl from Geom2dGcc inherits FunctionWithDerivative from math
---Purpose: This class describe a function of a single variable.
uses Dir2d from gp
uses
Dir2d from gp,
Curve from Geom2dAdaptor,
CurveTool from Geom2dGcc
is
Create (Curve : TheCurve ;
Dir : Dir2d from gp ) returns FunctionTanObl from GccIter;
Create (Curve : Curve from Geom2dAdaptor ;
Dir : Dir2d from gp ) returns FunctionTanObl from Geom2dGcc;
Value (me : in out ;
X : Real ;
@ -54,13 +52,9 @@ Values (me : in out ;
fields
TheCurv : TheCurve ;
TheCurv : Curve from Geom2dAdaptor ;
TheDirection : Dir2d from gp;
end FunctionTanObl;

73
src/Geom2dGcc/Geom2dGcc_FunctionTanObl.cxx Normal file
View File

@ -0,0 +1,73 @@
// 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 <Geom2dGcc_FunctionTanObl.ixx>
#include <gp_Vec2d.hxx>
#include <gp_Pnt2d.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dGcc_CurveTool.hxx>
Geom2dGcc_FunctionTanObl::
Geom2dGcc_FunctionTanObl(const Geom2dAdaptor_Curve& C,
const gp_Dir2d& Dir )
{
TheCurv = C;
TheDirection = Dir;
}
Standard_Boolean Geom2dGcc_FunctionTanObl::
Value (const Standard_Real X,
Standard_Real& Fval ) {
gp_Pnt2d Point;
gp_Vec2d Vect;
Geom2dGcc_CurveTool::D1(TheCurv,X,Point,Vect);
Standard_Real NormeD1 = Vect.Magnitude();
Fval = TheDirection.XY().Crossed(Vect.XY())/NormeD1;
return Standard_True;
}
Standard_Boolean Geom2dGcc_FunctionTanObl::
Derivative (const Standard_Real X,
Standard_Real& Deriv )
{
gp_Pnt2d Point;
gp_Vec2d Vec1;
gp_Vec2d Vec2;
Geom2dGcc_CurveTool::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 Geom2dGcc_FunctionTanObl::
Values (const Standard_Real X ,
Standard_Real& Fval ,
Standard_Real& Deriv ) {
gp_Pnt2d Point;
gp_Vec2d Vec1;
gp_Vec2d Vec2;
Geom2dGcc_CurveTool::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;
}

4
src/Geom2dGcc/Geom2dGcc_Lin2d2Tan.cdl
View File

@ -43,7 +43,7 @@ uses Pnt2d from gp,
Array1OfLin2d from TColgp,
Position from GccEnt,
Array1OfPosition from GccEnt,
MyL2d2Tan from Geom2dGcc,
Lin2d2TanIter from Geom2dGcc,
Curve from Geom2dAdaptor
raises NotDone from StdFail,
@ -187,7 +187,7 @@ is static;
-- Modified by Sergey KHROMOV - Wed Oct 16 12:04:52 2002 Begin
Add(me: in out; theIndex: Integer from Standard;
theLin : MyL2d2Tan from Geom2dGcc;
theLin : Lin2d2TanIter from Geom2dGcc;
theTol : Real from Standard;
theC1 : Curve from Geom2dAdaptor;
theC2 : Curve from Geom2dAdaptor)

12
src/Geom2dGcc/Geom2dGcc_Lin2d2Tan.cxx
View File

@ -17,7 +17,7 @@
#include <Geom2dGcc_Lin2d2Tan.ixx>
#include <Geom2dGcc_QCurve.hxx>
#include <GccAna_Lin2d2Tan.hxx>
#include <Geom2dGcc_MyL2d2Tan.hxx>
#include <Geom2dGcc_Lin2d2TanIter.hxx>
#include <Geom2d_Circle.hxx>
#include <GccEnt_QualifiedCirc.hxx>
#include <StdFail_NotDone.hxx>
@ -93,7 +93,7 @@ Geom2dGcc_Lin2d2Tan::
Param2 = a2FPar;
for (j = 0; j <= aNbSamples2 && NbrSol < 4; j++) {
Geom2dGcc_MyL2d2Tan Lin(Qc1,Qc2,Param1,Param2,Tolang);
Geom2dGcc_Lin2d2TanIter Lin(Qc1,Qc2,Param1,Param2,Tolang);
if (Lin.IsDone()) {
if (Add(NbrSol + 1, Lin, Tolang, C1, C2))
@ -158,7 +158,7 @@ Geom2dGcc_Lin2d2Tan::
Standard_Integer i;
for (i = 0; i <= aNbSamples && NbrSol < 2; i++) {
Geom2dGcc_MyL2d2Tan Lin(Qc1,ThePoint,Param1,Tolang);
Geom2dGcc_Lin2d2TanIter Lin(Qc1,ThePoint,Param1,Tolang);
if (Lin.IsDone()) {
if (Add(NbrSol + 1, Lin, Tolang, C1, Geom2dAdaptor_Curve()))
@ -226,7 +226,7 @@ Geom2dGcc_Lin2d2Tan::
else {
Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
Geom2dGcc_QCurve Qc2(C2,Qualified2.Qualifier());
Geom2dGcc_MyL2d2Tan Lin(Qc1,Qc2,Param1,Param2,Tolang);
Geom2dGcc_Lin2d2TanIter Lin(Qc1,Qc2,Param1,Param2,Tolang);
WellDone = Lin.IsDone();
// Modified by Sergey KHROMOV - Thu Apr 5 17:51:59 2001 Begin
if (WellDone) {
@ -284,7 +284,7 @@ Geom2dGcc_Lin2d2Tan::
}
else {
Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
Geom2dGcc_MyL2d2Tan Lin(Qc1,ThePoint,Param1,Tolang);
Geom2dGcc_Lin2d2TanIter Lin(Qc1,ThePoint,Param1,Tolang);
WellDone = Lin.IsDone();
// Modified by Sergey KHROMOV - Thu Apr 5 17:53:01 2001 Begin
if (WellDone) {
@ -355,7 +355,7 @@ void Geom2dGcc_Lin2d2Tan::
}
Standard_Boolean Geom2dGcc_Lin2d2Tan::Add(const Standard_Integer theIndex,
const Geom2dGcc_MyL2d2Tan &theLin,
const Geom2dGcc_Lin2d2TanIter &theLin,
const Standard_Real theTol,
const Geom2dAdaptor_Curve &theC1,
const Geom2dAdaptor_Curve &theC2)

36
src/GccIter/GccIter_Lin2d2Tan.cdl → src/Geom2dGcc/Geom2dGcc_Lin2d2TanIter.cdl
View File

@ -14,11 +14,7 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
generic class Lin2d2Tan from GccIter (
TheCurve as any;
TheCurveTool as any;
TheQualifiedCurve as any) -- as QualifiedCurve from GccEnt
-- (TheCurve)
class Lin2d2TanIter from Geom2dGcc
---Purpose: This class implements the algorithms used to
-- create 2d lines tangent to 2 other elements which
@ -33,26 +29,20 @@ generic class Lin2d2Tan from GccIter (
uses Pnt2d from gp,
Lin2d from gp,
QualifiedCirc from GccEnt,
Position from GccEnt
Position from GccEnt,
Curve from Geom2dAdaptor,
CurveTool from Geom2dGcc,
QCurve from Geom2dGcc
raises BadQualifier from GccEnt,
NotDone from StdFail
private class FuncTCuCu instantiates FunctionTanCuCu from GccIter(
TheCurve,TheCurveTool);
private class FuncTCuPt instantiates FunctionTanCuPnt from GccIter(
TheCurve,TheCurveTool);
private class FuncTCirCu instantiates FunctionTanCirCu from GccIter(
TheCurve,TheCurveTool);
is
Create (Qualified1 : TheQualifiedCurve ;
Create (Qualified1 : QCurve from Geom2dGcc ;
ThePoint : Pnt2d ;
Param1 : Real ;
Tolang : Real ) returns Lin2d2Tan from GccIter
Tolang : Real ) returns Lin2d2TanIter from Geom2dGcc
---Purpose: This class implements the algorithms used to create 2d
-- lines passing thrue a point and tangent to a curve.
-- Tolang is used to determine the tolerance for the
@ -61,9 +51,9 @@ Create (Qualified1 : TheQualifiedCurve ;
raises BadQualifier from GccEnt;
Create (Qualified1 : QualifiedCirc ;
Qualified2 : TheQualifiedCurve ;
Qualified2 : QCurve from Geom2dGcc ;
Param2 : Real ;
Tolang : Real ) returns Lin2d2Tan from GccIter
Tolang : Real ) returns Lin2d2TanIter from Geom2dGcc
raises BadQualifier from GccEnt;
---Purpose: This class implements the algorithms used to create 2d
-- line tangent to a circle and to a cuve.
@ -73,11 +63,11 @@ raises BadQualifier from GccEnt;
-- Exception BadQualifier is raised in the case of
-- EnclosedCirc
Create (Qualified1 : TheQualifiedCurve ;
Qualified2 : TheQualifiedCurve ;
Create (Qualified1 : QCurve from Geom2dGcc ;
Qualified2 : QCurve from Geom2dGcc ;
Param1 : Real ;
Param2 : Real ;
Tolang : Real ) returns Lin2d2Tan from GccIter
Tolang : Real ) returns Lin2d2TanIter from Geom2dGcc
raises BadQualifier from GccEnt;
---Purpose: This class implements the algorithms used to create 2d
-- line tangent to two curves.
@ -171,4 +161,4 @@ fields
-- The parameter of the tangency point between the solution and the second
-- argument on the second argument.
end Lin2d2Tan;
end Lin2d2TanIter;

286
src/Geom2dGcc/Geom2dGcc_Lin2d2TanIter.cxx Normal file
View File

@ -0,0 +1,286 @@
// 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 <Geom2dGcc_Lin2d2TanIter.ixx>
#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>
#include <Geom2dGcc_CurveTool.hxx>
#include <Geom2dGcc_FunctionTanCuCu.hxx>
#include <Geom2dGcc_FunctionTanCuPnt.hxx>
#include <Geom2dGcc_FunctionTanCirCu.hxx>
Geom2dGcc_Lin2d2TanIter::
Geom2dGcc_Lin2d2TanIter (const GccEnt_QualifiedCirc& Qualified1 ,
const Geom2dGcc_QCurve& 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();
Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
Standard_Real U1 = Geom2dGcc_CurveTool::FirstParameter(Cu2);
Standard_Real U2 = Geom2dGcc_CurveTool::LastParameter(Cu2);
Geom2dGcc_FunctionTanCirCu func(C1,Cu2);
math_FunctionRoot sol(func,Param2,Geom2dGcc_CurveTool::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;
Geom2dGcc_CurveTool::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.;
}
}
}
}
}
Geom2dGcc_Lin2d2TanIter::
Geom2dGcc_Lin2d2TanIter (const Geom2dGcc_QCurve& Qualified1 ,
const Geom2dGcc_QCurve& 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;
}
Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
Geom2dGcc_FunctionTanCuCu 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) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
Ufirst(1) = Param1;
Ufirst(2) = Param2;
tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolang));
tol(2) = Geom2dGcc_CurveTool::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;
Geom2dGcc_CurveTool::D2(Cu1,Ufirst(1),point1,Vect11,Vect12);
Geom2dGcc_CurveTool::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;
}
}
}
}
}
Geom2dGcc_Lin2d2TanIter::
Geom2dGcc_Lin2d2TanIter (const Geom2dGcc_QCurve& 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;
}
Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
Standard_Real U1 = Geom2dGcc_CurveTool::FirstParameter(Cu1);
Standard_Real U2 = Geom2dGcc_CurveTool::LastParameter(Cu1);
Geom2dGcc_FunctionTanCuPnt func(Cu1,ThePoint);
math_FunctionRoot sol(func,Param1,Geom2dGcc_CurveTool::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;
Geom2dGcc_CurveTool::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 Geom2dGcc_Lin2d2TanIter::
IsDone () const { return WellDone; }
gp_Lin2d Geom2dGcc_Lin2d2TanIter::
ThisSolution () const
{
if (!WellDone) StdFail_NotDone::Raise();
return linsol;
}
void Geom2dGcc_Lin2d2TanIter::
WhichQualifier (GccEnt_Position& Qualif1 ,
GccEnt_Position& Qualif2 ) const
{
if (!WellDone) { StdFail_NotDone::Raise(); }
else {
Qualif1 = qualifier1;
Qualif2 = qualifier2;
}
}
void Geom2dGcc_Lin2d2TanIter::
Tangency1 (Standard_Real& ParSol ,
Standard_Real& ParArg ,
gp_Pnt2d& Pnt) const {
if (!WellDone) { StdFail_NotDone::Raise(); }
else {
ParSol = par1sol;
ParArg = pararg1;
Pnt = pnttg1sol;
}
}
void Geom2dGcc_Lin2d2TanIter::
Tangency2 (Standard_Real& ParSol ,
Standard_Real& ParArg ,
gp_Pnt2d& Pnt) const {
if (!WellDone) { StdFail_NotDone::Raise(); }
else {
ParSol = par2sol;
ParArg = pararg2;
Pnt = pnttg2sol;
}
}

10
src/Geom2dGcc/Geom2dGcc_Lin2dTanObl.cdl
View File

@ -39,11 +39,11 @@ uses Lin2d from gp,
Position from GccEnt,
Array1OfPosition from GccEnt,
Curve from Geom2dAdaptor,
MyL2dTanObl from Geom2dGcc
Lin2dTanOblIter from Geom2dGcc
raises BadQualifier from GccEnt,
NotDone from StdFail,
IsParallel from GccIter,
IsParallel from Geom2dGcc,
OutOfRange from Standard
is
@ -151,7 +151,7 @@ Intersection2 (me ;
Index : Integer from Standard;
ParSol,ParArg : out Real from Standard;
PntSol : out Pnt2d from gp )
raises NotDone from StdFail, IsParallel from GccIter, OutOfRange from Standard
raises NotDone from StdFail, IsParallel from Geom2dGcc, OutOfRange from Standard
is static;
---Purpose: Returns the point of intersection PntSol between the
-- solution of index Index and the second argument (the line) of this algorithm.
@ -159,7 +159,7 @@ is static;
-- solution. ParArg is the parameter of the point PntSol on the second argument (the line).
-- Exceptions
-- StdFail_NotDone if the construction fails.
-- GccIter_IsParallel if the solution and the second
-- Geom2dGcc_IsParallel if the solution and the second
-- argument (the line) are parallel.
-- Standard_OutOfRange if Index is less than zero or
-- greater than the number of solutions computed by this algorithm.
@ -174,7 +174,7 @@ is static;
-- Modified by Sergey KHROMOV - Wed Oct 16 12:04:52 2002 Begin
Add(me: in out; theIndex: Integer from Standard;
theLin : MyL2dTanObl from Geom2dGcc;
theLin : Lin2dTanOblIter from Geom2dGcc;
theTol : Real from Standard;
theC1 : Curve from Geom2dAdaptor)
returns Boolean from Standard

8
src/Geom2dGcc/Geom2dGcc_Lin2dTanObl.cxx
View File

@ -17,7 +17,7 @@
#include <Geom2dGcc_Lin2dTanObl.ixx>
#include <Geom2dGcc_QCurve.hxx>
#include <GccAna_Lin2dTanObl.hxx>
#include <Geom2dGcc_MyL2dTanObl.hxx>
#include <Geom2dGcc_Lin2dTanOblIter.hxx>
#include <Geom2d_Circle.hxx>
#include <GccEnt_QualifiedCirc.hxx>
#include <StdFail_NotDone.hxx>
@ -75,7 +75,7 @@ Geom2dGcc_Lin2dTanObl::
Standard_Integer i;
for (i = 0; i <= aNbSamples && NbrSol < 2; i++) {
Geom2dGcc_MyL2dTanObl Lin(Qc1,TheLine,Param1,TolAng,Angle);
Geom2dGcc_Lin2dTanOblIter Lin(Qc1,TheLine,Param1,TolAng,Angle);
if (Lin.IsDone()) {
if (Add(NbrSol + 1, Lin, TolAng, C1))
@ -132,7 +132,7 @@ Geom2dGcc_Lin2dTanObl::
}
else {
Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
Geom2dGcc_MyL2dTanObl Lin(Qc1,TheLine,TolAng,Param1,Angle);
Geom2dGcc_Lin2dTanOblIter Lin(Qc1,TheLine,TolAng,Param1,Angle);
WellDone = Lin.IsDone();
if(WellDone) {
linsol(1) = Lin.ThisSolution();
@ -195,7 +195,7 @@ void Geom2dGcc_Lin2dTanObl::
Standard_Boolean Geom2dGcc_Lin2dTanObl::Add
(const Standard_Integer theIndex,
const Geom2dGcc_MyL2dTanObl &theLin,
const Geom2dGcc_Lin2dTanOblIter &theLin,
const Standard_Real theTol,
const Geom2dAdaptor_Curve &theC1)
{

28
src/GccIter/GccIter_Lin2dTanObl.cdl → src/Geom2dGcc/Geom2dGcc_Lin2dTanOblIter.cdl
View File

@ -14,35 +14,31 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
generic class Lin2dTanObl from GccIter (
TheCurve as any;
TheCurveTool as any;
TheQualifiedCurve as any) -- as QualifiedCurve from GccEnt
-- (TheCurve)
class Lin2dTanOblIter from Geom2dGcc
---Purpose: This class implements the algorithms used to
-- create 2d line tangent to a curve QualifiedCurv and
-- doing an angle Angle with a line TheLin.
-- The angle must be in Radian.
uses Lin2d from gp,
Pnt2d from gp,
Position from GccEnt
uses Lin2d from gp,
Pnt2d from gp,
Position from GccEnt,
Curve from Geom2dAdaptor,
CurveTool from Geom2dGcc,
QCurve from Geom2dGcc
raises BadQualifier from GccEnt,
NotDone from StdFail,
IsParallel from GccIter
private class FuncTObl instantiates FunctionTanObl from GccIter(
TheCurve,TheCurveTool);
IsParallel from Geom2dGcc
is
Create (Qualified1 : TheQualifiedCurve ;
Create (Qualified1 : QCurve from Geom2dGcc ;
TheLin : Lin2d ;
Param1 : Real ;
TolAng : Real ;
Angle : Real = 0 ) returns Lin2dTanObl from GccIter
Angle : Real = 0 ) returns Lin2dTanOblIter from Geom2dGcc
raises BadQualifier from GccEnt;
---Purpose: This class implements the algorithm used to
-- create 2d line tangent to a curve and doing an
@ -88,7 +84,7 @@ is static;
Intersection2 (me ;
ParSol,ParArg : out Real ;
PntSol : out Pnt2d)
raises NotDone from StdFail, IsParallel from GccIter
raises NotDone from StdFail, IsParallel from Geom2dGcc
is static;
-- Returns informations about the center (on the curv) of the
-- result and the third argument.
@ -137,4 +133,4 @@ fields
-- The parameter of the intersection point between the solution and
-- the second argument on the second argument.
end Lin2dTanObl;
end Lin2dTanOblIter;

156
src/Geom2dGcc/Geom2dGcc_Lin2dTanOblIter.cxx Normal file
View File

@ -0,0 +1,156 @@
// 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 <Geom2dGcc_Lin2dTanOblIter.ixx>
#include <IntAna2d_AnaIntersection.hxx>
#include <IntAna2d_IntPoint.hxx>
#include <Geom2dGcc_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>
#include <Geom2dGcc_CurveTool.hxx>
#include <Geom2dGcc_FunctionTanObl.hxx>
Geom2dGcc_Lin2dTanOblIter::
Geom2dGcc_Lin2dTanOblIter (const Geom2dGcc_QCurve& 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;
Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
Standard_Real U1 = Geom2dGcc_CurveTool::FirstParameter(Cu1);
Standard_Real U2 = Geom2dGcc_CurveTool::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; }
Geom2dGcc_FunctionTanObl func(Cu1,TheDirection);
math_FunctionRoot sol(func,Param1,
Geom2dGcc_CurveTool::EpsX(Cu1,Abs(TolAng)),U1,U2,100);
if (sol.IsDone()) {
Standard_Real Usol = sol.Root();
gp_Pnt2d Origine;
gp_Vec2d Vect1,Vect2;
Geom2dGcc_CurveTool::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 Geom2dGcc_Lin2dTanOblIter::
IsDone () const { return WellDone; }
gp_Lin2d Geom2dGcc_Lin2dTanOblIter::ThisSolution () const
{
if (!WellDone) StdFail_NotDone::Raise();
return linsol;
}
void Geom2dGcc_Lin2dTanOblIter::
WhichQualifier (GccEnt_Position& Qualif1) const
{
if (!WellDone) { StdFail_NotDone::Raise(); }
else {
Qualif1 = qualifier1;
}
}
Standard_Boolean Geom2dGcc_Lin2dTanOblIter::
IsParallel2 () const { return Paral2; }
void Geom2dGcc_Lin2dTanOblIter::
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 Geom2dGcc_Lin2dTanOblIter::
Intersection2 (Standard_Real& ParSol ,
Standard_Real& ParArg ,
gp_Pnt2d& PntSol ) const {
if (!WellDone) { StdFail_NotDone::Raise(); }
else if (Paral2) { Geom2dGcc_IsParallel::Raise(); }
else {
PntSol = pntint2sol;
ParSol = par2sol;
ParArg = pararg2;
}
}

6
src/QABugs/QABugs_17.cxx
View File

@ -43,7 +43,7 @@
#include <Geom2d_Circle.hxx>
#include <Geom2dGcc_QCurve.hxx>
#include <GccEnt_QualifiedCirc.hxx>
#include <Geom2dGcc_MyL2d2Tan.hxx>
#include <Geom2dGcc_Lin2d2TanIter.hxx>
#include <BRepBuilderAPI_MakeWire.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
@ -156,7 +156,7 @@ static Standard_Integer BUC60843 (Draw_Interpretor& di, Standard_Integer argc,co
Geom2dAdaptor_Curve acur(aCur2d2);
Geom2dGcc_QCurve qcur(acur, GccEnt_unqualified);
GccEnt_QualifiedCirc qfromcur(aCir2d->Circ2d(), GccEnt_unqualified);
Geom2dGcc_MyL2d2Tan lintan(qfromcur, qcur , par1, tol);
Geom2dGcc_Lin2d2TanIter lintan(qfromcur, qcur , par1, tol);
if (lintan.IsDone()) {
gp_Lin2d lin = lintan.ThisSolution();
Handle(Geom2d_Line) glin = new Geom2d_Line(lin);
@ -170,7 +170,7 @@ static Standard_Integer BUC60843 (Draw_Interpretor& di, Standard_Integer argc,co
Geom2dAdaptor_Curve acur2(aCur2d2);
Geom2dGcc_QCurve qcur1(acur1, GccEnt_unqualified);
Geom2dGcc_QCurve qcur2(acur2, GccEnt_unqualified);
Geom2dGcc_MyL2d2Tan lintan(qcur1, qcur2 , par1, par2, tol);
Geom2dGcc_Lin2d2TanIter lintan(qcur1, qcur2 , par1, par2, tol);
if (lintan.IsDone()) {
gp_Lin2d lin = lintan.ThisSolution();
Handle(Geom2d_Line) glin = new Geom2d_Line(lin);

1
src/TKGeomAlgo/PACKAGES
View File

@ -16,7 +16,6 @@ ApproxInt
GccAna
GccEnt
GccInt
GccIter
HatchGen
Geom2dHatch
Law