Integration of OCCT 6.5.0 from SVN

src/GccIter/GccIter.cdl

@@ -0,0 +1,64 @@
+-- File:	GccIter.cdl
+-- Created:	Thu Apr  4 14:27:40 1991
+-- Author:	Remi GILET
+--		<reg@topsn3>
+---Copyright:	 Matra Datavision 1991
+
+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;

src/GccIter/GccIter_Circ2d2TanOn.cdl

@@ -0,0 +1,339 @@
+-- File:	Circ2d2TanOn.cdl
+-- Created:	Fri Mar 29 14:04:23 1991
+-- Author:	Remi GILET
+--		<reg@topsn3>
+---Copyright:	 Matra Datavision 1991
+
+generic class Circ2d2TanOn from GccIter (
+    TheCurve          as any;
+    TheCurveTool      as any;  
+    TheQualifiedCurve as any) -- as QualifiedCurve from GccEnt
+    	    	      	      --                  (TheCurve)
+
+	---Purpose: This class implements the algorithms used to 
+	--          create 2d circles TANgent to 2 entities and 
+	--          having the center ON a curv.
+	--          The order of the tangency argument is always
+	--          QualifiedCirc, QualifiedLin, QualifiedCurv, Pnt2d. 
+	--          the arguments are :
+	--            - The two tangency arguments.
+	--            - The center line.
+	--            - The parameter for each tangency argument which 
+	--            is a curve.
+	--            - The tolerance.
+
+-- inherits Entity from Standard
+
+uses Pnt2d            from gp,
+     Lin2d            from gp,
+     Circ2d           from gp,  
+     QualifiedCirc    from GccEnt,
+     QualifiedLin     from GccEnt,
+     Position         from GccEnt
+     
+raises NotDone    from StdFail
+
+private class FuncTCuCuOnCu instantiates FunctionTanCuCuOnCu from GccIter (
+    	    	    	    	    	    	 TheCurve,TheCurveTool);
+is
+
+-- On a 2d line ..........................................................
+
+Create(Qualified1 : QualifiedCirc     ;
+       Qualified2 : TheQualifiedCurve ;
+       OnLine     : Lin2d             ;
+       Param1     : Real              ;
+       Param2     : Real              ;
+       Param3     : Real              ;
+       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+    ---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.
+    --          Param2 is the initial guess on the curve QualifiedCurv.
+    --          Tolerance is used for the limit cases.
+
+Create(Qualified1 : QualifiedLin      ;
+       Qualified2 : TheQualifiedCurve ;
+       OnLine     : Lin2d             ;
+       Param1     : Real              ;
+       Param2     : Real              ;
+       Param3     : Real              ;
+       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+    ---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 ;
+       OnLine     : Lin2d             ;
+       Param1     : Real              ;
+       Param2     : Real              ;
+       Param3     : Real              ;
+       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+    ---Purpose: This method implements the algorithms used to 
+    --          create 2d circles TANgent to two curves and 
+    --          having the center ON a 2d line.
+    --          Param1 is the initial guess on the first QualifiedCurv.
+    --          Param2 is the initial guess on the first QualifiedCurv.
+    --          Tolerance is used for the limit cases.
+
+Create(Qualified1 : TheQualifiedCurve ;
+       Point2     : Pnt2d             ;
+       OnLine     : Lin2d             ;
+       Param1     : Real              ;
+       Param2     : Real              ;
+       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+    ---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.
+    --          Param2 is the initial guess on the curve QualifiedCurv.
+    --          Tolerance is used for the limit cases.
+
+
+-- -- On a 2d Circle .....................................................
+
+Create(Qualified1 : QualifiedCirc     ;
+       Qualified2 : TheQualifiedCurve ;
+       OnCirc     : Circ2d            ;
+       Param1     : Real              ;
+       Param2     : Real              ;
+       Param3     : Real              ;
+       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+    ---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.
+    --          Param2 is the initial guess on the curve QualifiedCurv.
+    --          Tolerance is used for the limit cases.
+
+Create(Qualified1 : QualifiedLin      ;
+       Qualified2 : TheQualifiedCurve ;
+       OnCirc     : Circ2d            ;
+       Param1     : Real              ;
+       Param2     : Real              ;
+       Param3     : Real              ;
+       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+    ---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 ;
+       OnCirc     : Circ2d            ;
+       Param1     : Real              ;
+       Param2     : Real              ;
+       Param3     : Real              ;
+       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+    ---Purpose: This method implements the algorithms used to 
+    --          create 2d circles TANgent to two curves and 
+    --          having the center ON a 2d circle.
+    --          Param1 is the initial guess on the first QualifiedCurv.
+    --          Param2 is the initial guess on the first QualifiedCurv.
+    --          Tolerance is used for the limit cases.
+
+Create(Qualified1 : TheQualifiedCurve ;
+       Point2     : Pnt2d             ;
+       OnCirc     : Circ2d            ;
+       Param1     : Real              ;
+       Param2     : Real              ;
+       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+    ---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.
+    --          Param2 is the initial guess on the curve QualifiedCurv.
+    --          Tolerance is used for the limit cases.
+
+-- -- On a curve .....................................................
+
+Create(Qualified1 : QualifiedCirc     ;
+       Qualified2 : TheQualifiedCurve ;
+       OnCurv     : TheCurve          ;
+       Param1     : Real              ;
+       Param2     : Real              ;
+       ParamOn    : Real              ;
+       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+    ---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.
+    --          Param2 is the initial guess on the curve QualifiedCurv.
+    --          ParamOn is the initial guess on the center curve OnCurv.
+    --          Tolerance is used for the limit cases.
+
+Create(Qualified1 : QualifiedLin      ;
+       Qualified2 : TheQualifiedCurve ;
+       OnCurve    : TheCurve          ;
+       Param1     : Real              ;
+       Param2     : Real              ;
+       ParamOn    : Real              ;
+       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+    ---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.
+    --          Param2 is the initial guess on the curve QualifiedCurv.
+    --          ParamOn is the initial guess on the center curve OnCurv.
+    --          Tolerance is used for the limit cases.
+
+Create(Qualified1 : TheQualifiedCurve ;
+       Point2     : Pnt2d             ;
+       OnCurve    : TheCurve          ;
+       Param1     : Real              ;
+       ParamOn    : Real              ;
+       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+    ---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.
+    --          Param1 is the initial guess on the curve QualifiedCurv.
+    --          ParamOn is the initial guess on the center curve OnCurv.
+    --          Tolerance is used for the limit cases.
+
+Create(Qualified1 : TheQualifiedCurve ;
+       Qualified2 : TheQualifiedCurve ;
+       OnCurve    : TheCurve          ;
+       Param1     : Real              ;
+       Param2     : Real              ;
+       ParamOn    : Real              ;
+       Tolerance  : Real              ) returns Circ2d2TanOn from GccIter ;
+    ---Purpose: This method implements the algorithms used to 
+    --          create 2d circles TANgent to two curves and 
+    --          having the center ON a 2d curve.
+    --          Param1 is the initial guess on the first curve QualifiedCurv.
+    --          Param1 is the initial guess on the second curve QualifiedCurv.
+    --          ParamOn is the initial guess on the center curve OnCurv.
+    --          Tolerance is used for the limit cases.
+
+-- -- ....................................................................
+
+IsDone(me) returns Boolean
+is static;
+    ---Purpose: This method returns True if the construction 
+    --          algorithm succeeded.
+
+ThisSolution(me) returns Circ2d 
+    ---Purpose: Returns the solution.
+raises NotDone from StdFail
+is static;
+    ---Purpose: It raises NotDone if the construction algorithm 
+    --          didn't succeed.
+
+WhichQualifier(me                                 ; 
+    	       Qualif1  : out Position from GccEnt;
+    	       Qualif2  : out Position from GccEnt)
+raises NotDone from StdFail
+is static;
+    -- It returns the informations about the qualifiers of the tangency 
+    -- arguments concerning the solution number Index.
+    -- It returns the real qualifiers (the qualifiers given to the 
+    -- constructor method in case of enclosed, enclosing and outside 
+    -- and the qualifiers computedin case of unqualified).
+
+Tangency1(me                       ;
+          ParSol,ParArg : out Real ;
+          PntSol        : out Pnt2d)
+    ---Purpose: Returns information about the tangency point between 
+    --          the result and the first argument.
+    --          ParSol is the intrinsic parameter of the point PntSol 
+    --          on the solution curv.
+    --          ParArg is the intrinsic parameter of the point PntSol 
+    --          on the argument curv.
+raises NotDone from StdFail
+is static;
+    ---Purpose: It raises NotDone if the construction algorithm 
+    --          didn't succeed.
+
+Tangency2(me                       ;
+          ParSol,ParArg : out Real ;
+          PntSol        : out Pnt2d)
+    ---Purpose: Returns information about the tangency point between 
+    --          the result and the second argument.
+    --          ParSol is the intrinsic parameter of the point PntSol 
+    --          on the solution curv.
+    --          ParArg is the intrinsic parameter of the point PntSol 
+    --          on the argument curv.
+raises NotDone from StdFail
+is static;
+    ---Purpose: It raises NotDone if the construction algorithm 
+    --          didn't succeed.
+
+CenterOn3 (me                       ;
+           ParArg        : out Real ;
+           PntSol        : out Pnt2d)
+    ---Purpose: Returns information about the center (on the curv) of the
+    --          result and the third argument.
+raises NotDone from StdFail
+is static;
+    ---Purpose: It raises NotDone if the construction algorithm 
+    --          didn't succeed.
+
+IsTheSame1(me) returns Boolean
+    -- Returns True if the solution is equal to the first argument.
+raises NotDone from StdFail
+is static;
+    ---Purpose: It raises NotDone if the construction algorithm 
+    --          didn't succeed.
+
+IsTheSame2(me) returns Boolean
+    -- Returns True if the solution is equal to the second argument.
+raises NotDone from StdFail
+is static;
+    ---Purpose: It raises NotDone if the construction algorithm 
+    --          didn't succeed.
+
+fields
+
+    WellDone : Boolean;
+    ---Purpose: True if the algorithm succeeded.
+
+    cirsol   : Circ2d from gp;
+    -- The solutions.
+
+    qualifier1 : Position from GccEnt;
+    -- The qualifiers of the first argument.
+
+    qualifier2 : Position from GccEnt;
+    -- The qualifiers of the first argument.
+
+    TheSame1 : Boolean;
+    ---Purpose: True if the solution and the first argument are the 
+    --          same in the tolerance of Tolerance.
+    --          False in the other cases.
+
+    TheSame2 : Boolean;
+    ---Purpose: True if the solution and the second argument are the 
+    --          same in the tolerance of Tolerance.
+    --          False in the other cases.
+
+    pnttg1sol   : Pnt2d;
+    ---Purpose: The tangency point between the solution and the first 
+    --          argument on the solution.
+
+    pnttg2sol   : Pnt2d;
+    ---Purpose: The tangency point between the solution and the second 
+    --          argument on the solution.
+
+    pntcen      : Pnt2d;
+    ---Purpose: The center point of the solution on the third argument.
+
+    par1sol   : Real;
+    ---Purpose: The parameter of the tangency point between the 
+    --          solution and the first argument on the solution.
+
+    par2sol   : Real;
+    ---Purpose: The parameter of the tangency point between the 
+    --          solution and the second argument on the solution.
+
+    pararg1   : Real;
+    ---Purpose: The parameter of the tangency point between the 
+    --          solution and the first argument on the first argument.
+
+    pararg2   : Real;
+    ---Purpose: The parameter of the tangency point between the 
+    --          solution and the second argument on the second argument.
+
+    parcen3   : Real;
+    ---Purpose: The parameter of the center point of the solution 
+    --          on the second argument.
+
+end Circ2d2TanOn;

src/GccIter/GccIter_Circ2d3Tan.cdl

@@ -0,0 +1,308 @@
+-- File:	Circ2d3Tan.cdl
+-- Created:	Fri Mar 29 10:00:31 1991
+-- Author:	Remi GILET
+--		<reg@topsn2>
+---Copyright:	 Matra Datavision 1991
+
+generic class Circ2d3Tan from GccIter (
+    TheCurve          as any;
+    TheCurveTool      as any; -- as CurveTool from GccInt (TheCurve)
+    TheQualifiedCurve as any) -- as QualifiedCurve from GccEnt
+    	    	      	      --                  (TheCurve)
+
+	---Purpose: This class implements the algorithms used to 
+	--          create 2d circles tangent to 3 points/lines/circles/
+	--          curves with one curve or more.
+	--          The arguments of all construction methods are :
+	--             - The three qualifiied elements for the 
+	--             tangency constrains (QualifiedCirc, QualifiedLine,
+	--             Qualifiedcurv, Points).
+	--             - A parameter for each QualifiedCurv.
+
+-- inherits Entity from Standard
+
+uses Pnt2d            from gp,
+     Lin2d            from gp, 
+     Circ2d           from gp,
+     QualifiedCirc    from GccEnt,
+     QualifiedLin     from GccEnt,
+     Position         from GccEnt
+
+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            ;
+       Param1     : Real                         ;
+       Param2     : Real                         ;
+       Param3     : Real                         ;
+       Tolerance  : Real                         ) 
+returns Circ2d3Tan from GccIter;
+	---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            ;
+       Param1     : Real                         ;
+       Param2     : Real                         ;
+       Param3     : Real                         ;
+       Tolerance  : Real                         )
+returns Circ2d3Tan from GccIter;
+	---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            ;
+       Param1     : Real                         ;
+       Param2     : Real                         ;
+       Param3     : Real                         ;
+       Tolerance  : Real                         ) 
+returns Circ2d3Tan from GccIter;
+	---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                ;
+       Point3     : Pnt2d                            ;
+       Param1     : Real                             ;
+       Param2     : Real                             ;
+       Tolerance  : Real                             ) 
+returns Circ2d3Tan from GccIter;
+	---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                ;
+       Param1     : Real                             ;
+       Param2     : Real                             ;
+       Param3     : Real                             ;
+       Tolerance  : Real                             ) 
+returns Circ2d3Tan from GccIter;
+	---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                ;
+       Param1     : Real                             ;
+       Param2     : Real                             ;
+       Param3     : Real                             ;
+       Tolerance  : Real                             ) 
+returns Circ2d3Tan from GccIter;
+	---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                ;
+       Point3     : Pnt2d                            ;
+       Param1     : Real                             ;
+       Param2     : Real                             ;
+       Tolerance  : Real                             ) 
+returns Circ2d3Tan from GccIter;
+	---Purpose: This method implements the algorithms used to 
+	--          create 2d circles tangent to a line and a curve 
+	--          and a point.
+
+Create(Qualified1 : TheQualifiedCurve ;
+       Point1     : Pnt2d             ;
+       Point2     : Pnt2d             ;
+       Param1     : Real              ;
+       Tolerance  : Real              ) 
+returns Circ2d3Tan from GccIter;
+	---Purpose: This method implements the algorithms used to 
+	--          create 2d circles tangent to a curve and 2 points.
+
+Create(Qualified1 : TheQualifiedCurve ;
+       Qualified2 : TheQualifiedCurve ;
+       Point2     : Pnt2d             ;
+       Param1     : Real              ;
+       Param2     : Real              ;
+       Tolerance  : Real              ) 
+returns Circ2d3Tan from GccIter;
+	---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 ;
+       Param1     : Real              ;
+       Param2     : Real              ;
+       Param3     : Real              ;
+       Tolerance  : Real              ) 
+returns Circ2d3Tan from GccIter;
+	---Purpose: This method implements the algorithms used to 
+	--          create 2d circles tangent to 3 curves.
+
+-- -- ....................................................................
+
+IsDone(me) returns Boolean
+is static;
+    ---Purpose: This method returns True if the construction 
+    --          algorithm succeeded.
+
+ThisSolution(me) returns Circ2d 
+    ---Purpose: Returns the solution.
+raises NotDone from StdFail
+is static;
+    ---Purpose: It raises NotDone if the construction algorithm 
+    --          didn't succeed.
+
+WhichQualifier(me                                 ; 
+    	       Qualif1  : out Position from GccEnt;
+    	       Qualif2  : out Position from GccEnt;
+    	       Qualif3  : out Position from GccEnt)
+raises NotDone from StdFail
+is static;
+    -- It returns the informations about the qualifiers of the tangency 
+    -- arguments concerning the solution number Index.
+    -- It returns the real qualifiers (the qualifiers given to the 
+    -- constructor method in case of enclosed, enclosing and outside 
+    -- and the qualifiers computedin case of unqualified).
+
+Tangency1(me                       ;
+          ParSol,ParArg : out Real ;
+          PntSol        : out Pnt2d)
+    ---Purpose: Returns informations about the tangency point between 
+    --          the result and the first argument.
+    --          ParSol is the intrinsic parameter of the point PntSol 
+    --          on the solution curv.
+    --          ParArg is the intrinsic parameter of the point PntSol 
+    --          on the argument curv.
+raises NotDone from StdFail
+is static;
+    ---Purpose: It raises NotDone if the construction algorithm 
+    --          didn't succeed.
+
+Tangency2(me                       ;
+          ParSol,ParArg : out Real ;
+          PntSol        : out Pnt2d)
+    ---Purpose: Returns informations about the tangency point between 
+    --          the result and the second argument.
+    --          ParSol is the intrinsic parameter of the point PntSol 
+    --          on the solution curv.
+    --          ParArg is the intrinsic parameter of the point PntSol 
+    --          on the argument curv.
+raises NotDone from StdFail
+is static;
+    ---Purpose: It raises NotDone if the construction algorithm 
+    --          didn't succeed.
+
+Tangency3(me                       ;
+          ParSol,ParArg : out Real ;
+          PntSol        : out Pnt2d)
+    ---Purpose: Returns informations about the tangency point between 
+    --          the result and the third argument.
+    --          ParSol is the intrinsic parameter of the point PntSol 
+    --          on the solution curv.
+    --          ParArg is the intrinsic parameter of the point PntSol 
+    --          on the argument curv.
+raises NotDone from StdFail
+is static;
+    ---Purpose: It raises NotDone if the construction algorithm 
+    --          didn't succeed.
+
+IsTheSame1(me) returns Boolean
+    -- Returns True if the solution is equal to the first argument.
+raises NotDone from StdFail
+is static;
+    ---Purpose: It raises NotDone if the construction algorithm 
+    --          didn't succeed.
+
+IsTheSame2(me) returns Boolean
+    -- Returns True if the solution is equal to the second argument.
+raises NotDone from StdFail
+is static;
+    ---Purpose: It raises NotDone if the construction algorithm 
+    --          didn't succeed.
+
+IsTheSame3(me) returns Boolean
+    -- Returns True if the solution is equal to the third argument.
+raises NotDone from StdFail
+is static;
+    ---Purpose: It raises NotDone if the construction algorithm 
+    --          didn't succeed.
+
+fields
+
+    WellDone : Boolean;
+    ---Purpose: True if the algorithm succeeded.
+
+    cirsol   : Circ2d;
+    ---Purpose: The solutions.
+
+    qualifier1 : Position from GccEnt;
+    -- The qualifiers of the first argument.
+
+    qualifier2 : Position from GccEnt;
+    -- The qualifiers of the first argument.
+
+    qualifier3 : Position from GccEnt;
+    -- The qualifiers of the first argument.
+
+    TheSame1 : Boolean;
+    ---Purpose: True if the solution and the first argument are identical.
+    --          Two circles are identical if the difference between the 
+    --          radius of one and the sum of the radius of the other and 
+    --          the distance between the centers is less than Tolerance. 
+    --          False in the other cases.
+
+    TheSame2 : Boolean;
+    ---Purpose: True if the solution and the second argument are identical.
+    --          Two circles are identical if the difference between the 
+    --          radius of one and the sum of the radius of the other and 
+    --          the distance between the centers is less than Tolerance. 
+    --          False in the other cases.
+
+    TheSame3 : Boolean;
+    ---Purpose: True if the solution and the third argument are identical.
+    --          Two circles are identical if the difference between the 
+    --          radius of one and the sum of the radius of the other and 
+    --          the distance between the centers is less than Tolerance. 
+    --          False in the other cases.
+
+    pnttg1sol   : Pnt2d;
+    ---Purpose: The tangency point between the solution and the first 
+    --          argument on the solution.
+
+    pnttg2sol   : Pnt2d;
+    ---Purpose: The tangency point between the solution and the second 
+    --          argument on the solution.
+
+    pnttg3sol   : Pnt2d;
+    ---Purpose: The tangency point between the solution and the third 
+    --          argument on the solution.
+
+    par1sol   : Real;
+    ---Purpose: The parameter of the tangency point between the solution 
+    --          and the first argument on the solution.
+
+    par2sol   : Real;
+    ---Purpose: The parameter of the tangency point between the solution 
+    --          and the second argument on the solution.
+
+    par3sol   : Real;
+    ---Purpose: The parameter of the tangency point between the solution 
+    --          and the third argument on the solution.
+
+    pararg1   : Real;
+    ---Purpose: The parameter of the tangency point between the solution 
+    --          and the first argument on the first argument.
+
+    pararg2   : Real;
+    ---Purpose: The parameter of the tangency point between the solution 
+    --          and the second argument on the second argument.
+
+    pararg3   : Real;
+    ---Purpose: The parameter of the tangency point between the solution 
+    --          and the third argument on the second argument.
+
+end Circ2d3Tan;

src/GccIter/GccIter_FunctionTanCirCu.cdl

@@ -0,0 +1,55 @@
+-- File:        FunctionTanCirCu.cdl
+-- Created:     Thu Feb 20 7:33:43 1992
+-- Author:      Remy GILET
+--              <reg@topsn3>
+---Copyright:    Matra Datavision 1992
+
+
+generic class FunctionTanCirCu from GccIter (
+    TheCurve     as any;
+    TheCurveTool as any) -- as CurvePGTool from GccInt(TheCurve)
+
+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    
+
+is
+
+Create (Circ   : Circ2d   from gp ;
+    	Curv   : TheCurve         ) returns FunctionTanCirCu from GccIter;
+
+Value (me : in out      ;
+       X  :        Real ;
+       F  :    out Real ) returns Boolean;
+    ---Purpose: Computes the value of the function F for the variable X.
+    --          It returns True if the computation is successfully done,
+    --          False otherwise.
+
+Derivative (me    : in out      ;
+            X     :        Real ;
+            Deriv :    out Real ) returns Boolean;
+    ---Purpose: Computes the derivative of the function F for the variable X.
+    --          It returns True if the computation is successfully done,
+    --          False otherwise.
+
+Values (me    : in out      ;
+        X     :        Real ;
+        F     : out    Real ;
+        Deriv : out    Real ) returns Boolean;
+    ---Purpose: Computes the value and the derivative of the function F 
+    --          for the variable X.
+    --          It returns True if the computation is successfully done,
+    --          False otherwise.
+
+fields
+
+TheCirc  : Circ2d from gp;
+Curve    : TheCurve; 
+-- 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
+
+end FunctionTanCirCu;

src/GccIter/GccIter_FunctionTanCirCu.gxx

@@ -0,0 +1,128 @@
+// File:	GccIter_FunctionTanCirCu.gxx
+// Created:	Mon Jan 20 16:35:40 1992
+// Author:	Remi GILET
+//		<reg@phobox>
+
+#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);
+#ifdef DEB
+  Standard_Real squaredir = TheDirection.SquareMagnitude();
+#else
+  TheDirection.SquareMagnitude();
+#endif
+  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;
+}

src/GccIter/GccIter_FunctionTanCuCu.cdl

@@ -0,0 +1,81 @@
+-- File:        FunctionTanCuCu.cdl
+-- Created:     Thu Feb 20 7:33:43 1992
+-- Author:      Remy GILET
+--              <reg@topsn3>
+---Copyright:    Matra Datavision 1992
+
+
+generic class FunctionTanCuCu from GccIter (
+    TheCurve     as any;
+    TheCurveTool as any) -- as CurvePGTool from GccInt (TheCurve)
+
+inherits FunctionSetWithDerivatives from math 
+
+    ---Purpose: This abstract class describes a Function of 1 Variable 
+    --          used to find a line tangent to two curves.
+
+uses Vector from math,
+     Matrix from math,
+     Circ2d from gp,
+     Pnt2d  from gp,
+     Vec2d  from gp,
+     Type3  from GccIter
+
+     
+raises ConstructionError
+
+is
+
+Create (Curv1 : TheCurve ;
+        Curv2 : TheCurve ) returns FunctionTanCuCu from GccIter;
+
+Create (Circ1 : Circ2d   from gp ;
+        Curv2 : TheCurve         ) returns FunctionTanCuCu from GccIter;
+
+InitDerivative(me                   : in out                      ;
+    	       X                    :        Vector from math     ;
+	       Point1,Point2        :    out Pnt2d  from gp       ;
+	       Tan1,Tan2,D21,D22    :    out Vec2d  from gp       )
+raises ConstructionError
+is static;
+
+NbVariables(me) returns Integer;
+    ---Purpose: returns the number of variables of the function.
+
+NbEquations(me) returns Integer;
+    ---Purpose: returns the number of equations of the function.
+
+Value (me : in out                 ;
+       X  :        Vector from math;
+       F  :    out Vector from math) returns Boolean;
+    ---Purpose: Computes the value of the function F for the variable X.
+    --          It returns True if the computation is successfully done,
+    --          False otherwise.
+
+Derivatives (me    : in out                 ;
+             X     :        Vector from math;
+             Deriv :    out Matrix from math) returns Boolean;
+    ---Purpose: Computes the derivative of the function F for the variable X.
+    --          It returns True if the computation is successfully done,
+    --          False otherwise.
+
+Values (me    : in out                 ;
+        X     :        Vector from math;
+        F     : out    Vector from math;
+        Deriv : out    Matrix from math) returns Boolean;
+    ---Purpose: Computes the value and the derivative of the function F 
+    --          for the variable X.
+    --          It returns True if the computation is successfully done,
+    --          False otherwise.
+
+fields
+
+TheCurve1     : TheCurve               ;
+TheCurve2     : TheCurve               ;
+TheCirc1      : Circ2d   from gp       ;
+TheType       : Type3    from GccIter  ;
+
+end FunctionTanCuCu;
+
+
+

src/GccIter/GccIter_FunctionTanCuCu.gxx

@@ -0,0 +1,202 @@
+// File:	GccIter_FunctionTanCuCu.gxx
+// Created:	Mon Jan 20 16:35:40 1992
+// Author:	Remi GILET
+//		<reg@phobox>
+
+#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;
+}

src/GccIter/GccIter_FunctionTanCuCuCu.cdl

@@ -0,0 +1,106 @@
+-- File:        FunctionTanCuCuCu.cdl
+-- Created:     Mon May 13 15:33:43 1991
+-- Author:      Laurent PAINNOT
+--              <lpa@topsn3>
+---Copyright:    Matra Datavision 1991
+
+generic class FunctionTanCuCuCu from GccIter(
+    TheCurve     as any;
+    TheCurveTool as any) -- as CurvePGTool from GccInt (TheCurve)
+     
+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,
+     Type1  from GccIter 
+
+raises ConstructionError
+
+is
+
+    Create (C1  : TheCurve ;
+    	    C2  : TheCurve ;
+    	    C3  : TheCurve ) returns FunctionTanCuCuCu from GccIter;
+
+    Create (C1  : Circ2d    from gp ;
+    	    C2  : TheCurve          ;
+    	    C3  : TheCurve          ) returns FunctionTanCuCuCu from GccIter;
+
+    Create (C1  : Circ2d    from gp ;
+    	    C2  : Circ2d    from gp ;
+    	    C3  : TheCurve          ) returns FunctionTanCuCuCu from GccIter;
+
+    Create (C1  : Circ2d    from gp ;
+    	    L2  : Lin2d     from gp ;
+    	    C3  : TheCurve          ) returns FunctionTanCuCuCu from GccIter;
+
+    Create (L1  : Lin2d     from gp ;
+    	    L2  : Lin2d     from gp ;
+    	    C3  : TheCurve          ) returns FunctionTanCuCuCu from GccIter;
+
+    Create (L1  : Lin2d     from gp ;
+    	    C2  : TheCurve          ;
+    	    C3  : TheCurve          ) returns FunctionTanCuCuCu from GccIter;
+
+    Create (C1  : Circ2d    from gp ;
+    	    C2  : TheCurve          ;
+    	    P3  : Pnt2d     from gp ) returns FunctionTanCuCuCu from GccIter;
+
+    Create (L1  : Lin2d     from gp ;
+    	    C2  : TheCurve          ;
+    	    P3  : Pnt2d     from gp ) returns FunctionTanCuCuCu from GccIter;
+
+    Create (C1  : TheCurve          ;
+    	    P2  : Pnt2d     from gp ;
+    	    P3  : Pnt2d     from gp ) returns FunctionTanCuCuCu from GccIter;
+
+InitDerivative(me                         : in out                   ;
+    	       X                          :        Vector from math  ;
+	       Point1,Point2,Point3       :    out Pnt2d  from gp    ;
+	       Tan1,Tan2,Tan3,D21,D22,D23 :    out Vec2d  from gp    )
+raises ConstructionError
+is static;
+
+    NbVariables(me) returns Integer;
+    	---Purpose: Returns the number of variables of the function.
+
+    NbEquations(me) returns Integer;
+    	---Purpose: Returns the number of equations of the function.
+
+    Value(me : in out                 ; 
+    	  X  :        Vector from math; 
+    	  F  :    out Vector from math) returns Boolean;
+    	---Purpose: Computes the values of the Functions for the variable <X>.
+    
+    Derivatives(me : in out                 ;
+    	        X  :        Vector from math;
+    	        D  :    out Matrix from math) returns Boolean;
+    	---Purpose: Returns the values of the derivatives for the variable <X>.
+    
+    Values(me : in out                 ;
+    	   X  :        Vector from math;
+    	   F  :    out Vector from math;
+     	   D  :    out Matrix from math)    returns Boolean;
+    	---Purpose: Returns the values of the functions and the derivatives
+    	--          for the variable <X>.
+    
+fields
+
+Curv1   : TheCurve             ;
+Curv2   : TheCurve             ;
+Curv3   : TheCurve             ;
+Circ1   : Circ2d   from gp     ;
+Circ2   : Circ2d   from gp     ;
+Lin1    : Lin2d    from gp     ;
+Lin2    : Lin2d    from gp     ;
+TheType : Type1    from GccIter;
+
+end FunctionTanCuCuCu;
+

src/GccIter/GccIter_FunctionTanCuCuCu.gxx

@@ -0,0 +1,469 @@
+// File:	GccIter_FunctionTanCuCuCu.gxx
+// Created:	Mon Jan 20 16:35:40 1992
+// Author:	Remi GILET
+//		<reg@phobox>
+
+#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:
+    {
+      ElCLib::D2(X(1),Circ1,Point1,Tan1,D21);
+      TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
+      TheCurveTool::D2(Curv3,X(3),Point3,Tan3,D23);
+    }
+    break;
+  case GccIter_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);
+    }
+    break;
+  case GccIter_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);
+    }
+    break;
+  case GccIter_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);
+    }
+    break;
+  case GccIter_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);
+    }
+    break;
+  case GccIter_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);
+    }
+    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;
+}
+
+GccIter_FunctionTanCuCuCu::
+  GccIter_FunctionTanCuCuCu(const gp_Circ2d& C1  ,
+			      const TheCurve&  C2  ,
+			      const TheCurve&  C3  ) {
+  Circ1 = C1;
+  Curv2 = C2;
+  Curv3 = C3;
+  TheType = GccIter_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;
+}
+
+GccIter_FunctionTanCuCuCu::
+  GccIter_FunctionTanCuCuCu(const gp_Circ2d& C1  ,
+			      const gp_Lin2d&  L2  ,
+			      const TheCurve&  C3  ) {
+  Circ1 = C1;
+  Lin2 = L2;
+  Curv3 = C3;
+  TheType = GccIter_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;
+}
+
+GccIter_FunctionTanCuCuCu::
+  GccIter_FunctionTanCuCuCu(const gp_Lin2d& L1  ,
+			      const TheCurve& C2  ,
+			      const TheCurve& C3  ) {
+  Lin1 = L1;
+  Curv2 = C2;
+  Curv3 = C3;
+  TheType = GccIter_LiCuCu;
+}
+
+//==========================================================================
+
+Standard_Integer GccIter_FunctionTanCuCuCu::
+  NbVariables () const { return 3; }
+
+Standard_Integer GccIter_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 GccIter_FunctionTanCuCuCu::
+  Derivatives (const math_Vector& X     ,
+	             math_Matrix& Deriv ) {
+#if 0
+  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);
+//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).
+  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.); }
+//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();
+  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.); }
+//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.
+  Standard_Real signe1 = 1.;
+  Standard_Real signe2 = 1.;
+  Standard_Real signe3 = 1.;
+  gp_XY P = Point1.XY();
+  P += Point2.XY();
+  P += Point3.XY();
+  P /= 3.;
+  gp_Pnt2d Pcenter(P);
+  gp_XY fic1 = Pcenter.XY();
+  fic1 -= Point1.XY();
+  gp_XY fic2 = Pcenter.XY();
+  fic2 -= Point2.XY();
+  gp_XY fic3 = Pcenter.XY();
+  fic3 -= 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; }
+
+// 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); }
+  if (NorP1P2 <= gp::Resolution()) { partie2 = 0.; }
+  else {partie2=((Deriv1u1.Dot(p1p2)/(NorP1P2*NorP1P2))*P1P2-Deriv1u1/NorP1P2)
+	  .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); }
+  if (NorP1P2 <= gp::Resolution()) { partie2 = 0.; }
+  else{partie2=((-Deriv1u2.Dot(p1p2)/(NorP1P2*NorP1P2))*P1P2+Deriv1u2/NorP1P2)
+	 .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); }
+  if (NorP2P3 <= gp::Resolution()) { partie2 = 0.; }
+  else { partie2=((Deriv1u2.Dot(p2p3)/(NorP2P3*NorP2P3))*P2P3-Deriv1u2/NorP2P3)
+	   .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); }
+  if (NorP2P3 <= gp::Resolution()) { partie2 = 0.; }
+  else {partie2=((-Deriv1u3.Dot(p2p3)/(NorP2P3*NorP2P3))*P2P3+Deriv1u3/NorP2P3)
+	  .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); }
+  if (NorP3P1 <= gp::Resolution()) { partie2 = 0.; }
+  else {partie2=((-Deriv1u1.Dot(p3p1)/(NorP3P1*NorP3P1))*P3P1+Deriv1u1/NorP3P1)
+	  .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); }
+  if (NorP3P1 <= gp::Resolution()) { partie2 = 0.; }
+  else {partie2=((Deriv1u3.Dot(p3p1)/(NorP3P1*NorP3P1))*P3P1-Deriv1u3/NorP3P1)
+	  .Dot(signe1*nor1+signe3*nor3); }
+  Deriv(3,3) = partie1+partie2;
+#endif
+  return Standard_True;
+}
+
+
+Standard_Boolean GccIter_FunctionTanCuCuCu::
+  Values (const math_Vector& X     ,
+	        math_Vector& Fval  ,
+	        math_Matrix& Deriv ) {
+#if 0
+  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);
+//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).
+  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.); }
+//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();
+  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.); }
+//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.
+  Standard_Real signe1 = 1.;
+  Standard_Real signe2 = 1.;
+  Standard_Real signe3 = 1.;
+  gp_XY P = Point1.XY();
+  P += Point2.XY();
+  P += Point3.XY();
+  P /= 3.;
+  gp_Pnt2d Pcenter(P);
+  gp_XY fic1 = Pcenter.XY();
+  fic1 -= Point1.XY();
+  gp_XY fic2 = Pcenter.XY();
+  fic2 -= Point2.XY();
+  gp_XY fic3 = Pcenter.XY();
+  fic3 -= 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);
+// 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); }
+  if (NorP1P2 <= gp::Resolution()) { partie2 = 0.; }
+  else {partie2=((Deriv1u1.Dot(p1p2)/(NorP1P2*NorP1P2))*P1P2-Deriv1u1/NorP1P2)
+	  .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); }
+  if (NorP1P2 <= gp::Resolution()) { partie2 = 0.; }
+  else{partie2=((-Deriv1u2.Dot(p1p2)/(NorP1P2*NorP1P2))*P1P2+Deriv1u2/NorP1P2)
+	 .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); }
+  if (NorP2P3 <= gp::Resolution()) { partie2 = 0.; }
+  else { partie2=((Deriv1u2.Dot(p2p3)/(NorP2P3*NorP2P3))*P2P3-Deriv1u2/NorP2P3)
+	   .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); }
+  if (NorP2P3 <= gp::Resolution()) { partie2 = 0.; }
+  else {partie2=((-Deriv1u3.Dot(p2p3)/(NorP2P3*NorP2P3))*P2P3+Deriv1u3/NorP2P3)
+	  .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); }
+  if (NorP3P1 <= gp::Resolution()) { partie2 = 0.; }
+  else {partie2=((-Deriv1u1.Dot(p3p1)/(NorP3P1*NorP3P1))*P3P1+Deriv1u1/NorP3P1)
+	  .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); }
+  if (NorP3P1 <= gp::Resolution()) { partie2 = 0.; }
+  else {partie2=((Deriv1u3.Dot(p3p1)/(NorP3P1*NorP3P1))*P3P1-Deriv1u3/NorP3P1)
+	  .Dot(signe1*nor1+signe3*nor3); }
+  Deriv(3,3) = partie1+partie2;
+#endif
+  return Standard_True;
+}
+
+

src/GccIter/GccIter_FunctionTanCuCuOnCu.cdl

@@ -0,0 +1,149 @@
+-- File:        FunctionTanCuCuOnCu.cdl
+-- Created:     Mon May 13 15:33:43 1991
+-- Author:      Laurent PAINNOT
+--              <lpa@topsn3>
+---Copyright:    Matra Datavision 1991
+
+
+generic class FunctionTanCuCuOnCu from GccIter (
+    TheCurve     as any;
+    TheCurveTool as any) -- as CurvePGTool from GccInt (TheCurve)
+
+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
+
+raises ConstructionError
+
+is
+
+    Create (C1    : TheCurve               ;
+    	    C2    : TheCurve               ;
+    	    OnCi  : Circ2d   from gp       ;
+    	    Rad   : Real     from Standard ) 
+returns FunctionTanCuCuOnCu from GccIter;
+
+    Create (C1    : Circ2d   from gp       ;
+    	    C2    : TheCurve               ;
+    	    OnCi  : Circ2d   from gp       ;
+    	    Rad   : Real     from Standard ) 
+returns FunctionTanCuCuOnCu from GccIter;
+
+    Create (L1    : Lin2d    from gp       ;
+    	    C2    : TheCurve               ;
+    	    OnCi  : Circ2d   from gp       ;
+    	    Rad   : Real     from Standard ) 
+returns FunctionTanCuCuOnCu from GccIter;
+
+    Create (C1    : TheCurve               ;
+    	    P2    : Pnt2d    from gp       ;
+    	    OnCi  : Circ2d   from gp       ;
+    	    Rad   : Real     from Standard ) 
+returns FunctionTanCuCuOnCu from GccIter;
+
+------------------------------------------------------------------------
+
+    Create (C1    : TheCurve               ;
+    	    C2    : TheCurve               ;
+    	    OnLi  : Lin2d    from gp       ;
+    	    Rad   : Real     from Standard ) 
+returns FunctionTanCuCuOnCu from GccIter;
+
+    Create (C1    : Circ2d   from gp       ;
+    	    C2    : TheCurve               ;
+    	    OnLi  : Lin2d    from gp       ;
+    	    Rad   : Real     from Standard ) 
+returns FunctionTanCuCuOnCu from GccIter;
+
+    Create (L1    : Lin2d    from gp       ;
+    	    C2    : TheCurve               ;
+    	    OnLi  : Lin2d    from gp       ;
+    	    Rad   : Real     from Standard ) 
+returns FunctionTanCuCuOnCu from GccIter;
+
+    Create (C1    : TheCurve               ;
+    	    P2    : Pnt2d    from gp       ;
+    	    OnLi  : Lin2d    from gp       ;
+    	    Rad   : Real     from Standard ) 
+returns FunctionTanCuCuOnCu from GccIter;
+
+-----------------------------------------------------------------------
+
+    Create (C1    : TheCurve               ;
+    	    C2    : TheCurve               ;
+    	    OnCu  : TheCurve               ;
+    	    Rad   : Real     from Standard ) 
+returns FunctionTanCuCuOnCu from GccIter;
+
+    Create (C1    : Circ2d   from gp       ;
+    	    C2    : TheCurve               ;
+    	    OnCu  : TheCurve               ;
+    	    Rad   : Real     from Standard ) 
+returns FunctionTanCuCuOnCu from GccIter;
+
+    Create (L1    : Lin2d    from gp       ;
+    	    C2    : TheCurve               ;
+    	    OnCu  : TheCurve               ;
+    	    Rad   : Real     from Standard ) 
+returns FunctionTanCuCuOnCu from GccIter;
+
+    Create (C1    : TheCurve               ;
+    	    P1    : Pnt2d    from gp       ;
+    	    OnCu  : TheCurve               ;
+    	    Rad   : Real     from Standard ) 
+returns FunctionTanCuCuOnCu from GccIter;
+
+InitDerivative(me                         : in out                      ;
+    	       X                          :        Vector from math     ;
+	       Point1,Point2,Point3       :    out Pnt2d  from gp       ;
+	       Tan1,Tan2,Tan3,D21,D22,D23 :    out Vec2d  from gp       )
+raises ConstructionError
+is static;
+
+    NbVariables(me) returns Integer;
+    	---Purpose: Returns the number of variables of the function.
+
+    NbEquations(me) returns Integer;
+    	---Purpose: Returns the number of equations of the function.
+
+    Value(me : in out                 ; 
+    	  X  :        Vector from math; 
+    	  F  :    out Vector from math) returns Boolean;
+    	---Purpose: Computes the values of the Functions for the variable <X>.
+    
+    Derivatives(me : in out                 ;
+    	        X  :        Vector from math;
+    	        D  :    out Matrix from math) returns Boolean;
+    	---Purpose: Returns the values of the derivatives for the variable <X>.
+    
+    Values(me : in out                 ;
+    	   X  :        Vector from math;
+    	   F  :    out Vector from math;
+     	   D  :    out Matrix from math)    returns Boolean;
+    	---Purpose: Returns the values of the functions and the derivatives
+    	--          for the variable <X>.
+    
+fields
+
+Curv1    : TheCurve               ;
+Curv2    : TheCurve               ;
+Circ1    : Circ2d   from gp       ;
+Lin1     : Lin2d    from gp       ;
+Pnt2     : Pnt2d    from gp       ;
+Circon   : Circ2d   from gp       ;
+Linon    : Lin2d    from gp       ;
+Curvon   : TheCurve               ;
+FirstRad : Real     from Standard ;
+TheType  : Type2    from GccIter  ;
+
+end FunctionTanCuCuOnCu;
+

src/GccIter/GccIter_FunctionTanCuCuOnCu.gxx

@@ -0,0 +1,413 @@
+// File:	GccIter_FunctionTanCuCuOnCu.cxx
+// Created:	Mon Jan 20 16:35:40 1992
+// Author:	Remi GILET
+//		<reg@phobox>
+
+#include <Standard_ConstructionError.hxx>
+#include <ElCLib.hxx>
+
+void GccIter_FunctionTanCuCuOnCu::
+  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_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);
+    }
+    break;
+  case GccIter_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);
+    }
+    break;
+  case GccIter_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);
+    }
+    break;
+  case GccIter_CuPtOnCu:
+    {
+      TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
+      TheCurveTool::D2(Curvon,X(3),Point3,Tan3,D23);
+      Point2 = Pnt2;
+      Tan2 = gp_Vec2d(0.,0.);
+      D22 = gp_Vec2d(0.,0.);
+    }
+    break;
+  case GccIter_CuCuOnCi:
+    {
+      TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
+      TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
+      ElCLib::D2(X(3),Circon,Point3,Tan3,D23);
+    }
+    break;
+  case GccIter_CiCuOnCi:
+    {
+      ElCLib::D2(X(1),Circ1,Point1,Tan1,D21);
+      TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
+      ElCLib::D2(X(3),Circon,Point3,Tan3,D23);
+    }
+    break;
+  case GccIter_LiCuOnCi:
+    {
+      ElCLib::D1(X(1),Lin1,Point1,Tan1);
+      D21 = gp_Vec2d(0.,0.);
+      TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
+      ElCLib::D2(X(3),Circon,Point3,Tan3,D23);
+    }
+    break;
+  case GccIter_CuPtOnCi:
+    {
+      TheCurveTool::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:
+    {
+      TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
+      TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
+      ElCLib::D1(X(3),Linon,Point3,Tan3);
+      D23 = gp_Vec2d(0.,0.);
+    }
+    break;
+  case GccIter_CiCuOnLi:
+    {
+      ElCLib::D2(X(1),Circ1,Point1,Tan1,D21);
+      TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
+      ElCLib::D1(X(3),Linon,Point3,Tan3);
+      D23 = gp_Vec2d(0.,0.);
+    }
+    break;
+  case GccIter_LiCuOnLi:
+    {
+      ElCLib::D1(X(1),Lin1,Point1,Tan1);
+      TheCurveTool::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:
+    {
+      TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
+      Point2 = Pnt2;
+      Tan2 = gp_Vec2d(0.,0.);
+      D22 = gp_Vec2d(0.,0.);
+      ElCLib::D1(X(3),Linon,Point3,Tan3);
+      D23 = gp_Vec2d(0.,0.);
+    }
+    break;
+  default:
+    {
+      Standard_ConstructionError::Raise();
+    }
+  }
+}
+
+GccIter_FunctionTanCuCuOnCu::
+  GccIter_FunctionTanCuCuOnCu(const TheCurve&     C1  ,
+			     const TheCurve&     C2  ,
+			     const TheCurve&     C3  ,
+			     const Standard_Real Rad ) {
+  Curv1  = C1;
+  Curv2  = C2;
+  Curvon = C3;
+  FirstRad = Rad;
+  TheType = GccIter_CuCuOnCu;
+}
+
+GccIter_FunctionTanCuCuOnCu::
+  GccIter_FunctionTanCuCuOnCu(const gp_Circ2d&    C1  ,
+			     const TheCurve&     C2  ,
+			     const TheCurve&     C3  ,
+			     const Standard_Real Rad ) {
+  Circ1  = C1;
+  Curv2  = C2;
+  Curvon = C3;
+  FirstRad = Rad;
+  TheType = GccIter_CiCuOnCu;
+}
+
+GccIter_FunctionTanCuCuOnCu::
+  GccIter_FunctionTanCuCuOnCu(const gp_Lin2d&     L1  ,
+			     const TheCurve&     C2  ,
+			     const TheCurve&     C3  ,
+			     const Standard_Real Rad ) {
+  Lin1  = L1;
+  Curv2  = C2;
+  Curvon = C3;
+  FirstRad = Rad;
+  TheType = GccIter_LiCuOnCu;
+}
+
+GccIter_FunctionTanCuCuOnCu::
+  GccIter_FunctionTanCuCuOnCu(const TheCurve& C1  ,
+			     const gp_Pnt2d&  P2  ,
+			     const TheCurve&  C3  ,
+			     const Standard_Real       Rad ) {
+  Curv1  = C1;
+  Pnt2  = P2;
+  Curvon = C3;
+  FirstRad = Rad;
+  TheType = GccIter_CuPtOnCu;
+}
+
+GccIter_FunctionTanCuCuOnCu::
+  GccIter_FunctionTanCuCuOnCu(const TheCurve& C1   ,
+			     const TheCurve&  C2   ,
+			     const gp_Lin2d&  OnLi ,
+			     const Standard_Real       Rad  ) {
+  Curv1  = C1;
+  Curv2  = C2;
+  Linon = OnLi;
+  FirstRad = Rad;
+  TheType = GccIter_CuCuOnLi;
+}
+
+GccIter_FunctionTanCuCuOnCu::
+  GccIter_FunctionTanCuCuOnCu(const gp_Circ2d&           C1   ,
+			       const TheCurve& C2   ,
+			       const gp_Lin2d&            OnLi ,
+			       const Standard_Real                 Rad  ) {
+  Circ1  = C1;
+  Curv2  = C2;
+  Linon = OnLi;
+  FirstRad = Rad;
+  TheType = GccIter_CiCuOnLi;
+}
+
+GccIter_FunctionTanCuCuOnCu::
+  GccIter_FunctionTanCuCuOnCu(const gp_Lin2d& L1  ,
+			       const TheCurve&  C2  ,
+			       const gp_Lin2d&  OnLi ,
+			       const Standard_Real       Rad ) {
+  Lin1  = L1;
+  Curv2  = C2;
+  Linon = OnLi;
+  FirstRad = Rad;
+  TheType = GccIter_LiCuOnLi;
+}
+
+GccIter_FunctionTanCuCuOnCu::
+  GccIter_FunctionTanCuCuOnCu(const TheCurve& C1  ,
+			       const gp_Pnt2d&            P2  ,
+			       const gp_Lin2d&            OnLi ,
+			       const Standard_Real                 Rad ) {
+  Curv1  = C1;
+  Pnt2  = P2;
+  Linon = OnLi;
+  FirstRad = Rad;
+  TheType = GccIter_CuPtOnLi;
+}
+
+GccIter_FunctionTanCuCuOnCu::
+  GccIter_FunctionTanCuCuOnCu(const TheCurve& C1   ,
+			       const TheCurve& C2   ,
+			       const gp_Circ2d&           OnCi ,
+			       const Standard_Real                 Rad  ) {
+  Curv1  = C1;
+  Curv2  = C2;
+  Circon = OnCi;
+  FirstRad = Rad;
+  TheType = GccIter_CuCuOnCi;
+}
+
+GccIter_FunctionTanCuCuOnCu::
+  GccIter_FunctionTanCuCuOnCu(const gp_Circ2d&           C1  ,
+			       const TheCurve& C2  ,
+			       const gp_Circ2d&           OnCi ,
+			       const Standard_Real                 Rad ) {
+  Circ1  = C1;
+  Curv2  = C2;
+  Circon = OnCi;
+  FirstRad = Rad;
+  TheType = GccIter_CuCuOnCi;
+}
+
+GccIter_FunctionTanCuCuOnCu::
+  GccIter_FunctionTanCuCuOnCu(const gp_Lin2d& L1  ,
+			       const TheCurve&  C2  ,
+			       const gp_Circ2d& OnCi ,
+			       const Standard_Real       Rad ) {
+  Lin1  = L1;
+  Curv2  = C2;
+  Circon = OnCi;
+  FirstRad = Rad;
+  TheType = GccIter_LiCuOnCi;
+}
+
+GccIter_FunctionTanCuCuOnCu::
+  GccIter_FunctionTanCuCuOnCu(const TheCurve& C1  ,
+			       const gp_Pnt2d&            P2  ,
+			       const gp_Circ2d&           OnCi ,
+			       const Standard_Real                 Rad ) {
+  Curv1  = C1;
+  Pnt2  = P2;
+  Circon = OnCi;
+  FirstRad = Rad;
+  TheType = GccIter_CuPtOnCi;
+}
+
+Standard_Integer GccIter_FunctionTanCuCuOnCu::
+  NbVariables () const { return 4; }
+
+Standard_Integer GccIter_FunctionTanCuCuOnCu::
+  NbEquations () const { return 4; }
+
+Standard_Boolean GccIter_FunctionTanCuCuOnCu::
+  Value (const math_Vector& X    ,
+	       math_Vector& Fval ) {
+  gp_Pnt2d Point1,Point2,Point3;
+  gp_Vec2d Tan1,Tan2,Tan3,D21,D22,D23;
+  InitDerivative(X,Point1,Point2,Point3,Tan1,Tan2,Tan3,D21,D22,D23);
+//pipj (normes) et PiPj (non Normes).
+  gp_Vec2d P1P2(Point1,Point2);
+  gp_Vec2d P2P3(Point2,Point3);
+  gp_Vec2d P3P1(Point3,Point1);
+  gp_Vec2d p1p2,p2p3,p3p1;
+//  if (FirstRad < 1.) {FirstRad = 1.; }
+  p1p2 = P1P2/FirstRad;
+  p2p3 = P2P3/FirstRad;
+  p3p1 = P3P1/FirstRad;
+//norme des Tani.
+  Standard_Real nnor1 = Tan1.Magnitude();
+  Standard_Real nnor2 = Tan2.Magnitude();
+#ifdef DEB
+  Standard_Real nnor3 = Tan3.Magnitude();
+#else
+  Tan3.Magnitude();
+#endif
+// Fonctions Fui.
+// ==============
+  Fval(1) = (P3P1.Dot(P3P1)-X(4)*X(4))/(FirstRad*FirstRad);
+  Fval(2) = (P2P3.Dot(P2P3)-X(4)*X(4))/(FirstRad*FirstRad);
+  Fval(3) = P3P1.Dot(Tan1)/(nnor1*FirstRad);
+  Fval(4) = P2P3.Dot(Tan2)/(nnor2*FirstRad);
+  return Standard_True;
+}
+
+Standard_Boolean GccIter_FunctionTanCuCuOnCu::
+  Derivatives (const math_Vector& X     ,
+	             math_Matrix& Deriv ) {
+  gp_Pnt2d Point1,Point2,Point3;
+  gp_Vec2d Tan1,Tan2,Tan3;
+  gp_Vec2d D21,D22,D23;
+  InitDerivative(X,Point1,Point2,Point3,Tan1,Tan2,Tan3,D21,D22,D23);
+//pipj (normes) et PiPj (non Normes).
+  gp_Vec2d P1P2(Point1,Point2);
+  gp_Vec2d P2P3(Point2,Point3);
+  gp_Vec2d P3P1(Point3,Point1);
+  gp_Vec2d p1p2,p2p3,p3p1;
+//  if (FirstRad < 1.) {FirstRad = 1.; }
+  p1p2 = P1P2/FirstRad;
+  p2p3 = P2P3/FirstRad;
+  p3p1 = P3P1/FirstRad;
+//normales au courbes normees Nori et non nromees nori et norme des nori.
+  Standard_Real nnor1 = Tan1.Magnitude();
+  Standard_Real nnor2 = Tan2.Magnitude();
+#ifdef DEB
+  Standard_Real nnor3 = Tan3.Magnitude();
+#else
+  Tan3.Magnitude();
+#endif
+// Derivees dFui/uj  1 <= ui <= 3 , 1 <= uj <= 3
+// =============================================
+  Deriv(1,1) = 2.*Tan1.Dot(P3P1)/(FirstRad*FirstRad);
+  Deriv(1,2) = 0.;
+  Deriv(1,3) = -2.*Tan3.Dot(P3P1)/(FirstRad*FirstRad);
+  Deriv(1,4) = -2.*X(4)/(FirstRad*FirstRad);
+
+  Deriv(2,1) = 0.;
+  Deriv(2,2) = -2.*Tan2.Dot(P2P3)/(FirstRad*FirstRad);
+  Deriv(2,3) = 2.*Tan3.Dot(P2P3)/(FirstRad*FirstRad);
+  Deriv(2,4) = -2.*X(4)/(FirstRad*FirstRad);
+
+  Deriv(3,1) = (P3P1.Dot(D21)+Tan1.Dot(Tan1))/(FirstRad*nnor1)-
+    (P3P1.Dot(Tan1)*D21.Dot(Tan1))/(FirstRad*nnor1*nnor1*nnor1);
+  Deriv(3,2) = 0.;
+  Deriv(3,3) = -(Tan3.Dot(Tan1))/(FirstRad*nnor1);
+  Deriv(3,4) = 0.;
+
+  Deriv(4,1) = 0.;
+  Deriv(4,2) = (P2P3.Dot(D22)-Tan2.Dot(Tan2))/(FirstRad*nnor2)-
+    P2P3.Dot(Tan2)*Tan2.Dot(D22)/(FirstRad*nnor2*nnor2*nnor2);
+  Deriv(4,3) = Tan3.Dot(Tan2)/(FirstRad*nnor1);
+  Deriv(4,4) = 0.;
+  return Standard_True;
+}
+
+Standard_Boolean GccIter_FunctionTanCuCuOnCu::
+  Values (const math_Vector& X     ,
+	        math_Vector& Fval  ,
+	        math_Matrix& Deriv ) {
+  gp_Pnt2d Point1,Point2,Point3;
+  gp_Vec2d Tan1,Tan2,Tan3;
+  gp_Vec2d D21,D22,D23;
+  InitDerivative(X,Point1,Point2,Point3,Tan1,Tan2,Tan3,D21,D22,D23);
+//pipj (normes) et PiPj (non Normes).
+  gp_Vec2d P1P2(Point1,Point2);
+  gp_Vec2d P2P3(Point2,Point3);
+  gp_Vec2d P3P1(Point3,Point1);
+  gp_Vec2d p1p2,p2p3,p3p1;
+//  if (FirstRad < 1.) {FirstRad = 1.; }
+  p1p2 = P1P2/FirstRad;
+  p2p3 = P2P3/FirstRad;
+  p3p1 = P3P1/FirstRad;
+//normales au courbes normees Nori et non nromees nori et norme des nori.
+  Standard_Real nnor1 = Tan1.Magnitude();
+  Standard_Real nnor2 = Tan2.Magnitude();
+#ifdef DEB
+  Standard_Real nnor3 = Tan3.Magnitude();
+#else
+  Tan3.Magnitude();
+#endif
+// Fonctions Fui.
+// ==============
+  Fval(1) = (P3P1.Dot(P3P1)-X(4)*X(4))/(FirstRad*FirstRad);
+  Fval(2) = (P2P3.Dot(P2P3)-X(4)*X(4))/(FirstRad*FirstRad);
+  Fval(3) = P3P1.Dot(Tan1)/(nnor1*FirstRad);
+  Fval(4) = P2P3.Dot(Tan2)/(nnor2*FirstRad);
+// Derivees dFui/uj  1 <= ui <= 3 , 1 <= uj <= 3
+// =============================================
+  Deriv(1,1) = 2.*Tan1.Dot(P3P1)/(FirstRad*FirstRad);
+  Deriv(1,2) = 0.;
+  Deriv(1,3) = -2.*Tan3.Dot(P3P1)/(FirstRad*FirstRad);
+  Deriv(1,4) = -2.*X(4)/(FirstRad*FirstRad);
+
+  Deriv(2,1) = 0.;
+  Deriv(2,2) = -2.*Tan2.Dot(P2P3)/(FirstRad*FirstRad);
+  Deriv(2,3) = 2.*Tan3.Dot(P2P3)/(FirstRad*FirstRad);
+  Deriv(2,4) = -2.*X(4)/(FirstRad*FirstRad);
+
+  Deriv(3,1) = (P3P1.Dot(D21)+Tan1.Dot(Tan1))/(FirstRad*nnor1)-
+    (P3P1.Dot(Tan1)*D21.Dot(Tan1))/(FirstRad*nnor1*nnor1*nnor1);
+  Deriv(3,2) = 0.;
+  Deriv(3,3) = -(Tan3.Dot(Tan1))/(FirstRad*nnor1);
+  Deriv(3,4) = 0.;
+
+  Deriv(4,1) = 0.;
+  Deriv(4,2) = (P2P3.Dot(D22)-Tan2.Dot(Tan2))/(FirstRad*nnor2)-
+    P2P3.Dot(Tan2)*Tan2.Dot(D22)/(FirstRad*nnor2*nnor2*nnor2);
+  Deriv(4,3) = Tan3.Dot(Tan2)/(FirstRad*nnor1);
+  Deriv(4,4) = 0.;
+  return Standard_True;
+}
+

src/GccIter/GccIter_FunctionTanCuPnt.cdl

@@ -0,0 +1,53 @@
+-- File:        FunctionTanCuPnt.cdl
+-- Created:     Thu Feb 20 7:33:43 1992
+-- Author:      Remy GILET
+--              <reg@topsn3>
+---Copyright:    Matra Datavision 1992
+
+
+generic class FunctionTanCuPnt from GccIter (
+    TheCurve     as any ;
+    TheCurveTool as any ) 
+
+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    
+
+is
+
+Create (C      : TheCurve         ;
+        Point  : Pnt2d    from gp ) returns FunctionTanCuPnt from GccIter;
+
+Value (me : in out      ;
+       X  :        Real ;
+       F  :    out Real ) returns Boolean;
+    ---Purpose: Computes the value of the function F for the variable X.
+    --          It returns True if the computation is successfully done,
+    --          False otherwise.
+
+Derivative (me    : in out      ;
+            X     :        Real ;
+            Deriv :    out Real ) returns Boolean;
+    ---Purpose: Computes the derivative of the function F for the variable X.
+    --          It returns True if the computation is successfully done,
+    --          False otherwise.
+
+Values (me    : in out      ;
+        X     :        Real ;
+        F     : out    Real ;
+        Deriv : out    Real ) returns Boolean;
+    ---Purpose: Computes the value and the derivative of the function F 
+    --          for the variable X.
+    --          It returns True if the computation is successfully done,
+    --          False otherwise.
+
+fields
+
+TheCurv      : TheCurve;
+ThePoint     : Pnt2d from gp;
+
+end FunctionTanCuPnt;

src/GccIter/GccIter_FunctionTanCuPnt.gxx

@@ -0,0 +1,85 @@
+// File:	GccIter_FunctionTanCuPnt.gxx
+// Created:	Mon Jan 20 16:35:40 1992
+// Author:	Remi GILET
+//		<reg@phobox>
+
+#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;
+}

src/GccIter/GccIter_FunctionTanObl.cdl

@@ -0,0 +1,56 @@
+-- File:	FunctionTanObl.cdl
+-- Created:	Thu Jan  9 16:43:44 1992
+-- Author:	Remi GILET
+--		<reg@topsn3>
+---Copyright:	 Matra Datavision 1992
+
+generic class FunctionTanObl from GccIter (
+    TheCurve     as any;
+    TheCurveTool as any) -- as CurvePGTool from GccInt (TheCurve)
+
+inherits FunctionWithDerivative from math
+    ---Purpose: This class describe a function of a single variable.
+
+uses Dir2d from gp     
+
+     
+is
+
+Create (Curve : TheCurve      ;
+    	Dir   : Dir2d from gp ) returns FunctionTanObl from GccIter;
+
+Value (me : in out      ;
+       X  :        Real ;
+       F  :    out Real ) returns Boolean;
+    ---Purpose: Computes the value of the function F for the variable X.
+    --          It returns True if the computation is successfully done,
+    --          False otherwise.
+
+Derivative (me    : in out      ;
+            X     :        Real ;
+            Deriv :    out Real ) returns Boolean;
+    ---Purpose: Computes the derivative of the function F for the variable X.
+    --          It returns True if the computation is successfully done,
+    --          False otherwise.
+
+Values (me    : in out      ;
+        X     :        Real ;
+        F     : out    Real ;
+        Deriv : out    Real ) returns Boolean;
+    ---Purpose: Computes the value and the derivative of the function F 
+    --          for the variable X.
+    --          It returns True if the computation is successfully done,
+    --          False otherwise.
+
+fields
+
+TheCurv      : TheCurve        ;
+TheDirection : Dir2d    from gp;
+
+end FunctionTanObl;
+
+
+
+
+
+

src/GccIter/GccIter_FunctionTanObl.gxx

@@ -0,0 +1,55 @@
+// File:	GccIter_FunctionTanObl.gxx
+// Created:	Mon Jan 20 16:35:40 1992
+// Author:	Remi GILET
+//		<reg@phobox>
+
+#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;
+}
+

src/GccIter/GccIter_Lin2d2Tan.cdl

@@ -0,0 +1,164 @@
+-- File:	Lin2d2Tan.cdl
+-- Created:	Wed Apr 24 11:29:07 1991
+-- Author:	Remi GILET
+--		<reg@topsn2>
+---Copyright:	 Matra Datavision 1991
+
+generic class Lin2d2Tan from GccIter (
+    TheCurve          as any;
+    TheCurveTool      as any;
+    TheQualifiedCurve as any) -- as QualifiedCurve from GccEnt
+    	    	      	      --                  (TheCurve)
+
+	---Purpose: This class implements the algorithms used to 
+	--          create 2d lines tangent to 2 other elements which
+	--          can be circles, curves or points.
+	--          More than one argument must be a curve.
+	--
+    	-- Note: Some constructors may check the type of the qualified argument 
+    	--         and raise BadQualifier Error in case of incorrect couple (qualifier,
+    	--         curv).
+    	--         For example: "EnclosedCirc".
+
+uses Pnt2d            from gp,
+     Lin2d            from gp,
+     QualifiedCirc    from GccEnt,
+     Position         from GccEnt
+
+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 ;
+    	ThePoint   : Pnt2d             ;
+        Param1     : Real              ;
+    	Tolang     : Real              ) returns Lin2d2Tan from GccIter
+    ---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 
+    --          tangency points.
+    --          Param2 is used for the initial guess on the curve.
+raises BadQualifier from GccEnt;
+
+Create (Qualified1 : QualifiedCirc     ;
+        Qualified2 : TheQualifiedCurve ;
+    	Param2     : Real              ;
+    	Tolang     : Real              ) returns Lin2d2Tan from GccIter
+raises BadQualifier from GccEnt;
+    ---Purpose: This class implements the algorithms used to create 2d 
+    --          line tangent to a circle and to a cuve.
+    --          Tolang is used to determine the tolerance for the 
+    --          tangency points.
+    --          Param2 is used for the initial guess on the curve.
+    --          Exception BadQualifier is raised in the case of 
+    --          EnclosedCirc
+
+Create (Qualified1 : TheQualifiedCurve ;
+        Qualified2 : TheQualifiedCurve ;
+    	Param1     : Real              ;
+    	Param2     : Real              ;
+    	Tolang     : Real              ) returns Lin2d2Tan from GccIter
+raises BadQualifier from GccEnt;
+    ---Purpose: This class implements the algorithms used to create 2d 
+    --          line tangent to two curves.
+    --          Tolang is used to determine the tolerance for the 
+    --          tangency points.
+    --          Param1 is used for the initial guess on the first curve.
+    --          Param2 is used for the initial guess on the second curve.
+
+--------------------------------------------------------------------------
+
+IsDone (me) returns Boolean
+is static;
+    	---Purpose: This methode returns true when there is a solution 
+    	--          and false in the other cases.
+
+ThisSolution(me) returns Lin2d 
+raises NotDone from StdFail
+is static;
+    ---Purpose: Returns the solution.
+
+WhichQualifier(me                                 ; 
+    	       Qualif1  : out Position from GccEnt;
+    	       Qualif2  : out Position from GccEnt)
+raises NotDone from StdFail
+is static;
+    -- It returns the informations about the qualifiers of the tangency 
+    -- arguments concerning the solution number Index.
+    -- It returns the real qualifiers (the qualifiers given to the 
+    -- constructor method in case of enclosed, enclosing and outside 
+    -- and the qualifiers computedin case of unqualified).
+
+Tangency1(me                       ;
+          ParSol,ParArg : out Real ;
+          PntSol        : out Pnt2d)
+raises NotDone from StdFail
+is static;
+    ---Purpose: Returns informations about the tangency point between the 
+    --          result and the first argument.
+    --          ParSol is the intrinsic parameter of the point PntSol on 
+    --          the solution curv.
+    --          ParArg is the intrinsic parameter of the point PntSol on 
+    --          the argument curv.
+
+Tangency2(me                       ;
+          ParSol,ParArg : out Real ;
+          PntSol        : out Pnt2d)
+raises NotDone from StdFail
+is static;
+    -- Returns informations about the tangency point between the 
+    -- result and the first argument.
+    -- ParSol is the intrinsic parameter of the point PntSol on the solution
+    -- curv.
+    -- ParArg is the intrinsic parameter of the point PntSol on the argument
+    -- curv.
+
+fields
+
+    WellDone : Boolean;
+    -- True if the algorithm succeeded.
+
+    linsol   : Lin2d;
+    ---Purpose : The solutions.
+
+    qualifier1 : Position from GccEnt;
+    -- The qualifiers of the first argument.
+
+    qualifier2 : Position from GccEnt;
+    -- The qualifiers of the first argument.
+
+    pnttg1sol   : Pnt2d;
+    -- The tangency point between the solution and the first argument on 
+    -- the solution.
+
+    pnttg2sol   : Pnt2d;
+    -- The tangency point between the solution and the second argument on 
+    -- the solution.
+
+    par1sol   : Real;
+    -- The parameter of the tangency point between the solution and the 
+    -- first argument on the solution.
+
+    par2sol   : Real;
+    -- The parameter of the tangency point between the solution and the 
+    -- second argument on the solution.
+
+    pararg1   : Real;
+    -- The parameter of the tangency point between the solution and the first 
+    -- argument on the first argument.
+
+    pararg2   : Real;
+    -- The parameter of the tangency point between the solution and the second 
+    -- argument on the second argument.
+
+end Lin2d2Tan;

src/GccIter/GccIter_Lin2d2Tan.gxx

@@ -0,0 +1,267 @@
+// File:	GccIter_Lin2d2Tan.gxx
+// Created:	Fri Dec 20 15:00:23 1991
+// Author:	Remi GILET
+//		<reg@topsn3>
+
+//========================================================================
+//  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.;
+#ifdef DEB
+   Standard_Real Tol = Abs(Tolang);
+#endif
+   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;
+   }
+ }
+

src/GccIter/GccIter_Lin2dTanObl.cdl

@@ -0,0 +1,130 @@
+-- File:	Lin2dTanObl.cdl
+-- Created:	Wed Apr 24 11:39:11 1991
+-- Author:	Remi GILET
+--		<reg@topsn2>
+---Copyright:	 Matra Datavision 1991
+
+generic class Lin2dTanObl from GccIter (
+    TheCurve          as any;
+    TheCurveTool      as any; 
+    TheQualifiedCurve as any) -- as QualifiedCurve from GccEnt
+    	    	      	      --                  (TheCurve)
+
+	---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
+
+raises BadQualifier from GccEnt,
+       NotDone      from StdFail,
+       IsParallel   from GccIter
+
+private class FuncTObl instantiates FunctionTanObl from GccIter(
+    	    	    	    	    	    TheCurve,TheCurveTool);
+
+is
+
+Create (Qualified1 : TheQualifiedCurve ;
+    	TheLin     : Lin2d             ;
+    	Param1     : Real              ;
+    	TolAng     : Real              ;
+        Angle      : Real = 0          ) returns Lin2dTanObl from GccIter
+raises BadQualifier from GccEnt;
+	---Purpose: This class implements the algorithm used to 
+	--          create 2d line tangent to a curve and doing an 
+	--          angle Angle with the line TheLin.
+	--          Angle must be in Radian.
+	--          Param2 is the initial guess on the curve QualifiedCurv.
+	--          Tolang is the angular tolerance.
+
+-- ........................................................................
+
+IsDone(me) returns Boolean
+is static;
+    	---Purpose: This method returns true when there is a solution 
+    	--          and false in the other cases.
+
+ThisSolution(me) returns Lin2d 
+raises NotDone from StdFail
+is static;
+    -- Returns the solution.
+
+WhichQualifier(me                                 ; 
+    	       Qualif1  : out Position from GccEnt)
+raises NotDone from StdFail
+is static;
+    -- It returns the informations about the qualifiers of the tangency 
+    -- arguments concerning the solution number Index.
+    -- It returns the real qualifiers (the qualifiers given to the 
+    -- constructor method in case of enclosed, enclosing and outside 
+    -- and the qualifiers computedin case of unqualified).
+
+Tangency1(me                       ;
+          ParSol,ParArg : out Real ;
+          PntSol        : out Pnt2d)
+raises NotDone from StdFail
+is static;
+    -- Returns informations about the tangency point between the 
+    -- result and the first argument.
+    -- ParSol is the intrinsic parameter of the point ParSol on the solution
+    -- curv.
+    -- ParArg is the intrinsic parameter of the point PntSol on the argument
+    -- curv.
+
+Intersection2 (me                       ;
+               ParSol,ParArg : out Real ;
+               PntSol        : out Pnt2d)
+raises NotDone from StdFail, IsParallel from GccIter
+is static;
+    -- Returns informations about the center (on the curv) of the
+    -- result and the third argument.
+
+IsParallel2(me) returns Boolean
+raises NotDone from StdFail
+is static;
+    -- Returns informations about the center (on the curv) of the
+    -- result and the third argument.
+
+fields
+
+    WellDone : Boolean;
+    -- True if the algorithm succeeded.
+
+    Paral2 : Boolean;
+    -- True if the solution is parallel to the second argument (Angle = 0).
+
+    linsol   : Lin2d;
+    ---Purpose : The solution.
+
+    qualifier1 : Position from GccEnt;
+    -- The qualifiers of the first argument.
+
+    pnttg1sol   : Pnt2d;
+    -- The tangency point between the solution and the first argument on 
+    -- the solution.
+
+    pntint2sol   : Pnt2d;
+    -- The tangency point between the solution and the second argument on 
+    -- the solution.
+
+    par1sol   : Real;
+    -- The parameter of the tangency point between the solution and the 
+    -- first argument on the solution.
+
+    par2sol   : Real;
+    -- The parameter of the intersection point between the solution and the 
+    -- second argument on the solution.
+
+    pararg1   : Real;
+    -- The parameter of the tangency point between the solution and the first 
+    -- argument on the first argument.
+
+    pararg2   : Real;
+    -- The parameter of the intersection point between the solution and 
+    -- the second argument on the second argument.
+
+end Lin2dTanObl;

src/GccIter/GccIter_Lin2dTanObl.gxx

@@ -0,0 +1,139 @@
+// File:	GccIter_Lin2dTanObl.cxx
+// Created:	Fri Dec 20 15:00:23 1991
+// Author:	Remi GILET
+//		<reg@topsn3>
+
+//========================================================================
+// 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)-PI) <= Abs(TolAng)) {
+       Paral2 = Standard_True;
+       TheDirection = Dir.Reversed();
+     }
+     else if (Abs(Angle-PI/2) <= Abs(TolAng)) { TheDirection=gp_Dir2d(-B,A); }
+     else if (Abs(Angle+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;
+   }
+ }
+