[occt.git] / src / GccIter / GccIter_Circ2d2TanOn.cdl

-- Created on: 1991-03-29
-- Created by: Remi GILET
-- Copyright (c) 1991-1999 Matra Datavision
-- Copyright (c) 1999-2012 OPEN CASCADE SAS
--
-- The content of this file is subject to the Open CASCADE Technology Public
-- License Version 6.5 (the "License"). You may not use the content of this file
-- except in compliance with the License. Please obtain a copy of the License
-- at http://www.opencascade.org and read it completely before using this file.
--
-- The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
-- main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
--
-- The Original Code and all software distributed under the License is
-- distributed on an "AS IS" basis, without warranty of any kind, and the
-- Initial Developer hereby disclaims all such warranties, including without
-- limitation, any warranties of merchantability, fitness for a particular
-- purpose or non-infringement. Please see the License for the specific terms
-- and conditions governing the rights and limitations under the License.


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;
Commit	Line	Data
b311480e	1	-- Created on: 1991-03-29
	2	-- Created by: Remi GILET
	3	-- Copyright (c) 1991-1999 Matra Datavision
	4	-- Copyright (c) 1999-2012 OPEN CASCADE SAS
	5	--
	6	-- The content of this file is subject to the Open CASCADE Technology Public
	7	-- License Version 6.5 (the "License"). You may not use the content of this file
	8	-- except in compliance with the License. Please obtain a copy of the License
	9	-- at http://www.opencascade.org and read it completely before using this file.
	10	--
	11	-- The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
	12	-- main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
	13	--
	14	-- The Original Code and all software distributed under the License is
	15	-- distributed on an "AS IS" basis, without warranty of any kind, and the
	16	-- Initial Developer hereby disclaims all such warranties, including without
	17	-- limitation, any warranties of merchantability, fitness for a particular
	18	-- purpose or non-infringement. Please see the License for the specific terms
	19	-- and conditions governing the rights and limitations under the License.
	20
7fd59977	21
	22	generic class Circ2d2TanOn from GccIter (
	23	TheCurve as any;
	24	TheCurveTool as any;
	25	TheQualifiedCurve as any) -- as QualifiedCurve from GccEnt
	26	-- (TheCurve)
	27
	28	---Purpose: This class implements the algorithms used to
	29	-- create 2d circles TANgent to 2 entities and
	30	-- having the center ON a curv.
	31	-- The order of the tangency argument is always
	32	-- QualifiedCirc, QualifiedLin, QualifiedCurv, Pnt2d.
	33	-- the arguments are :
	34	-- - The two tangency arguments.
	35	-- - The center line.
	36	-- - The parameter for each tangency argument which
	37	-- is a curve.
	38	-- - The tolerance.
	39
	40	-- inherits Entity from Standard
	41
	42	uses Pnt2d from gp,
	43	Lin2d from gp,
	44	Circ2d from gp,
	45	QualifiedCirc from GccEnt,
	46	QualifiedLin from GccEnt,
	47	Position from GccEnt
	48
	49	raises NotDone from StdFail
	50
	51	private class FuncTCuCuOnCu instantiates FunctionTanCuCuOnCu from GccIter (
	52	TheCurve,TheCurveTool);
	53	is
	54
	55	-- On a 2d line ..........................................................
	56
	57	Create(Qualified1 : QualifiedCirc ;
	58	Qualified2 : TheQualifiedCurve ;
	59	OnLine : Lin2d ;
	60	Param1 : Real ;
	61	Param2 : Real ;
	62	Param3 : Real ;
	63	Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
	64	---Purpose: This method implements the algorithms used to
	65	-- create 2d circles TANgent to a 2d circle and a curve and
	66	-- having the center ON a 2d line.
	67	-- Param2 is the initial guess on the curve QualifiedCurv.
	68	-- Tolerance is used for the limit cases.
	69
	70	Create(Qualified1 : QualifiedLin ;
	71	Qualified2 : TheQualifiedCurve ;
	72	OnLine : Lin2d ;
	73	Param1 : Real ;
	74	Param2 : Real ;
	75	Param3 : Real ;
	76	Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
	77	---Purpose: This method implements the algorithms used to
	78	-- create 2d circles TANgent to a 2d line and a curve and
	79	-- having the center ON a 2d line.
	80	-- Param2 is the initial guess on the curve QualifiedCurv.
	81	-- Tolerance is used for the limit cases.
	82
	83	Create(Qualified1 : TheQualifiedCurve ;
	84	Qualified2 : TheQualifiedCurve ;
85	OnLine : Lin2d ;
86	Param1 : Real ;
87	Param2 : Real ;
88	Param3 : Real ;
89	Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
90	---Purpose: This method implements the algorithms used to
91	-- create 2d circles TANgent to two curves and
92	-- having the center ON a 2d line.
93	-- Param1 is the initial guess on the first QualifiedCurv.
94	-- Param2 is the initial guess on the first QualifiedCurv.
95	-- Tolerance is used for the limit cases.
96
97	Create(Qualified1 : TheQualifiedCurve ;
98	Point2 : Pnt2d ;
99	OnLine : Lin2d ;
100	Param1 : Real ;
101	Param2 : Real ;
102	Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
103	---Purpose: This method implements the algorithms used to
104	-- create 2d circles TANgent to a 2d point and a curve and
105	-- having the center ON a 2d line.
106	-- Param2 is the initial guess on the curve QualifiedCurv.
107	-- Tolerance is used for the limit cases.
108
109
110	-- -- On a 2d Circle .....................................................
111
112	Create(Qualified1 : QualifiedCirc ;
113	Qualified2 : TheQualifiedCurve ;
114	OnCirc : Circ2d ;
115	Param1 : Real ;
116	Param2 : Real ;
117	Param3 : Real ;
118	Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
119	---Purpose: This method implements the algorithms used to
120	-- create 2d circles TANgent to a 2d circle and a curve and
121	-- having the center ON a 2d circle.
122	-- Param2 is the initial guess on the curve QualifiedCurv.
123	-- Tolerance is used for the limit cases.
124
125	Create(Qualified1 : QualifiedLin ;
126	Qualified2 : TheQualifiedCurve ;
127	OnCirc : Circ2d ;
128	Param1 : Real ;
129	Param2 : Real ;
130	Param3 : Real ;
131	Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
132	---Purpose: This method implements the algorithms used to
133	-- create 2d circles TANgent to a 2d line and a curve and
134	-- having the center ON a 2d circle.
135	-- Param2 is the initial guess on the curve QualifiedCurv.
136	-- Tolerance is used for the limit cases.
137
138	Create(Qualified1 : TheQualifiedCurve ;
139	Qualified2 : TheQualifiedCurve ;
140	OnCirc : Circ2d ;
141	Param1 : Real ;
142	Param2 : Real ;
143	Param3 : Real ;
144	Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
145	---Purpose: This method implements the algorithms used to
146	-- create 2d circles TANgent to two curves and
147	-- having the center ON a 2d circle.
148	-- Param1 is the initial guess on the first QualifiedCurv.
149	-- Param2 is the initial guess on the first QualifiedCurv.
150	-- Tolerance is used for the limit cases.
151
152	Create(Qualified1 : TheQualifiedCurve ;
153	Point2 : Pnt2d ;
154	OnCirc : Circ2d ;
155	Param1 : Real ;
156	Param2 : Real ;
157	Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
158	---Purpose: This method implements the algorithms used to
159	-- create 2d circles TANgent to a 2d point and a curve and
160	-- having the center ON a 2d circle.
161	-- Param2 is the initial guess on the curve QualifiedCurv.
162	-- Tolerance is used for the limit cases.
163
164	-- -- On a curve .....................................................
165
166	Create(Qualified1 : QualifiedCirc ;
167	Qualified2 : TheQualifiedCurve ;
168	OnCurv : TheCurve ;
169	Param1 : Real ;
170	Param2 : Real ;
171	ParamOn : Real ;
172	Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
173	---Purpose: This method implements the algorithms used to
174	-- create 2d circles TANgent to a 2d circle and a curve and
175	-- having the center ON a 2d curve.
176	-- Param2 is the initial guess on the curve QualifiedCurv.
177	-- ParamOn is the initial guess on the center curve OnCurv.
178	-- Tolerance is used for the limit cases.
179
180	Create(Qualified1 : QualifiedLin ;
181	Qualified2 : TheQualifiedCurve ;
182	OnCurve : TheCurve ;
183	Param1 : Real ;
184	Param2 : Real ;
185	ParamOn : Real ;
186	Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
187	---Purpose: This method implements the algorithms used to
188	-- create 2d circles TANgent to a 2d line and a curve and
189	-- having the center ON a 2d curve.
190	-- Param2 is the initial guess on the curve QualifiedCurv.
191	-- ParamOn is the initial guess on the center curve OnCurv.
192	-- Tolerance is used for the limit cases.
193
194	Create(Qualified1 : TheQualifiedCurve ;
195	Point2 : Pnt2d ;
196	OnCurve : TheCurve ;
197	Param1 : Real ;
198	ParamOn : Real ;
199	Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
200	---Purpose: This method implements the algorithms used to
201	-- create 2d circles TANgent to a 2d Point and a curve and
202	-- having the center ON a 2d curve.
203	-- Param1 is the initial guess on the curve QualifiedCurv.
204	-- ParamOn is the initial guess on the center curve OnCurv.
205	-- Tolerance is used for the limit cases.
206
207	Create(Qualified1 : TheQualifiedCurve ;
208	Qualified2 : TheQualifiedCurve ;
209	OnCurve : TheCurve ;
210	Param1 : Real ;
211	Param2 : Real ;
212	ParamOn : Real ;
213	Tolerance : Real ) returns Circ2d2TanOn from GccIter ;
214	---Purpose: This method implements the algorithms used to
215	-- create 2d circles TANgent to two curves and
216	-- having the center ON a 2d curve.
217	-- Param1 is the initial guess on the first curve QualifiedCurv.
218	-- Param1 is the initial guess on the second curve QualifiedCurv.
219	-- ParamOn is the initial guess on the center curve OnCurv.
220	-- Tolerance is used for the limit cases.
221
222	-- -- ....................................................................
223
224	IsDone(me) returns Boolean
225	is static;
226	---Purpose: This method returns True if the construction
227	-- algorithm succeeded.
228
229	ThisSolution(me) returns Circ2d
230	---Purpose: Returns the solution.
231	raises NotDone from StdFail
232	is static;
233	---Purpose: It raises NotDone if the construction algorithm
234	-- didn't succeed.
235
236	WhichQualifier(me ;
237	Qualif1 : out Position from GccEnt;
238	Qualif2 : out Position from GccEnt)
239	raises NotDone from StdFail
240	is static;
241	-- It returns the informations about the qualifiers of the tangency
242	-- arguments concerning the solution number Index.
243	-- It returns the real qualifiers (the qualifiers given to the
244	-- constructor method in case of enclosed, enclosing and outside
245	-- and the qualifiers computedin case of unqualified).
246
247	Tangency1(me ;
248	ParSol,ParArg : out Real ;
249	PntSol : out Pnt2d)
250	---Purpose: Returns information about the tangency point between
251	-- the result and the first argument.
252	-- ParSol is the intrinsic parameter of the point PntSol
253	-- on the solution curv.
254	-- ParArg is the intrinsic parameter of the point PntSol
255	-- on the argument curv.
256	raises NotDone from StdFail
257	is static;
258	---Purpose: It raises NotDone if the construction algorithm
259	-- didn't succeed.
260
261	Tangency2(me ;
262	ParSol,ParArg : out Real ;
263	PntSol : out Pnt2d)
264	---Purpose: Returns information about the tangency point between
265	-- the result and the second argument.
266	-- ParSol is the intrinsic parameter of the point PntSol
267	-- on the solution curv.
268	-- ParArg is the intrinsic parameter of the point PntSol
269	-- on the argument curv.
270	raises NotDone from StdFail
271	is static;
272	---Purpose: It raises NotDone if the construction algorithm
273	-- didn't succeed.
274
275	CenterOn3 (me ;
276	ParArg : out Real ;
277	PntSol : out Pnt2d)
278	---Purpose: Returns information about the center (on the curv) of the
279	-- result and the third argument.
280	raises NotDone from StdFail
281	is static;
282	---Purpose: It raises NotDone if the construction algorithm
283	-- didn't succeed.
284
285	IsTheSame1(me) returns Boolean
286	-- Returns True if the solution is equal to the first argument.
287	raises NotDone from StdFail
288	is static;
289	---Purpose: It raises NotDone if the construction algorithm
290	-- didn't succeed.
291
292	IsTheSame2(me) returns Boolean
293	-- Returns True if the solution is equal to the second argument.
294	raises NotDone from StdFail
295	is static;
296	---Purpose: It raises NotDone if the construction algorithm
297	-- didn't succeed.
298
299	fields
300
301	WellDone : Boolean;
302	---Purpose: True if the algorithm succeeded.
303
304	cirsol : Circ2d from gp;
305	-- The solutions.
306
307	qualifier1 : Position from GccEnt;
308	-- The qualifiers of the first argument.
309
310	qualifier2 : Position from GccEnt;
311	-- The qualifiers of the first argument.
312
313	TheSame1 : Boolean;
314	---Purpose: True if the solution and the first argument are the
315	-- same in the tolerance of Tolerance.
316	-- False in the other cases.
317
318	TheSame2 : Boolean;
319	---Purpose: True if the solution and the second argument are the
320	-- same in the tolerance of Tolerance.
321	-- False in the other cases.
322
323	pnttg1sol : Pnt2d;
324	---Purpose: The tangency point between the solution and the first
325	-- argument on the solution.
326
327	pnttg2sol : Pnt2d;
328	---Purpose: The tangency point between the solution and the second
329	-- argument on the solution.
330
331	pntcen : Pnt2d;
332	---Purpose: The center point of the solution on the third argument.
333
334	par1sol : Real;
335	---Purpose: The parameter of the tangency point between the
336	-- solution and the first argument on the solution.
337
338	par2sol : Real;
339	---Purpose: The parameter of the tangency point between the
340	-- solution and the second argument on the solution.
341
342	pararg1 : Real;
343	---Purpose: The parameter of the tangency point between the
344	-- solution and the first argument on the first argument.
345
346	pararg2 : Real;
347	---Purpose: The parameter of the tangency point between the
348	-- solution and the second argument on the second argument.
349
350	parcen3 : Real;
351	---Purpose: The parameter of the center point of the solution
352	-- on the second argument.
353
354	end Circ2d2TanOn;