0026106: BRepMesh - revision of data model
[occt.git] / src / ElCLib / ElCLib.cxx
1 // Created on: 1991-09-09
2 // Created by: Michel Chauvat
3 // Copyright (c) 1991-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 // Evolutions   JCV Dec 1991 ajout de calculs de derivees et traitement
18 //              d'entites 2d
19 //              JCV Mars 1992 ajout method SetLinearForm
20
21 #define No_Standard_OutOfRange
22
23
24 #include <ElCLib.hxx>
25 #include <gp.hxx>
26 #include <gp_Ax1.hxx>
27 #include <gp_Ax2.hxx>
28 #include <gp_Ax2d.hxx>
29 #include <gp_Ax22d.hxx>
30 #include <gp_Circ.hxx>
31 #include <gp_Circ2d.hxx>
32 #include <gp_Dir.hxx>
33 #include <gp_Dir2d.hxx>
34 #include <gp_Elips.hxx>
35 #include <gp_Elips2d.hxx>
36 #include <gp_Hypr.hxx>
37 #include <gp_Hypr2d.hxx>
38 #include <gp_Lin.hxx>
39 #include <gp_Lin2d.hxx>
40 #include <gp_Parab.hxx>
41 #include <gp_Parab2d.hxx>
42 #include <gp_Pnt.hxx>
43 #include <gp_Pnt2d.hxx>
44 #include <gp_Vec.hxx>
45 #include <gp_Vec2d.hxx>
46
47 static Standard_Real PIPI = M_PI + M_PI;
48
49 //=======================================================================
50 //function : InPeriod
51 //purpose  : Value theULast is never returned.
52 //          Example of some case (checked on WIN64 platform)
53 //          with some surface having period 2*PI = 6.2831853071795862.
54 //            Let theUFirst be equal to 6.1645624650899675. Then,
55 //          theULast must be equal to
56 //              6.1645624650899675+6.2831853071795862=12.4477477722695537.
57 //
58 //          However, real result is 12.447747772269555.
59 //          Therefore, new period value to adjust will be equal to
60 //              12.447747772269555-6.1645624650899675=6.2831853071795871.
61 //
62 //          As we can see, (6.2831853071795871 != 6.2831853071795862).
63 //
64 //          According to above said, this method should be used carefully.
65 //          In order to increase reliability of this method, input arguments
66 //          needs to be replaced with following: 
67 //            (theU, theUFirst, thePeriod). theULast parameter is excess.
68 //=======================================================================
69 Standard_Real  ElCLib::InPeriod(const Standard_Real theU, 
70                                 const Standard_Real theUFirst, 
71                                 const Standard_Real theULast)
72 {
73   if( Precision::IsInfinite(theU) ||
74       Precision::IsInfinite(theUFirst) ||
75       Precision::IsInfinite(theULast))
76   {//In order to avoid FLT_Overflow exception
77     return theU;
78   }
79
80   const Standard_Real aPeriod = theULast - theUFirst;
81
82   if(aPeriod < Epsilon(theULast))
83     return theU;
84
85   return Max(theUFirst, theU + aPeriod*Ceiling((theUFirst-theU)/aPeriod));
86 }
87
88 //=======================================================================
89 //function : AdjustPeriodic
90 //purpose  : 
91 //=======================================================================
92
93 void ElCLib::AdjustPeriodic(const Standard_Real UFirst,
94                             const Standard_Real ULast,
95                             const Standard_Real Preci,
96                             Standard_Real& U1,
97                             Standard_Real& U2)
98 {
99   if (Precision::IsInfinite(UFirst) ||
100       Precision::IsInfinite(ULast))
101   {
102     U1 = UFirst;
103     U2 = ULast;
104     return;
105   }
106   
107   Standard_Real period = ULast - UFirst;
108
109   if (period < Epsilon(ULast))
110   {
111     // In order to avoid FLT_Overflow exception
112     // (test bugs moddata_1 bug22757)
113     U1 = UFirst;
114     U2 = ULast;
115     return;
116   }
117
118   U1 -= Floor((U1-UFirst)/period) * period;
119   if (ULast - U1 < Preci) U1 -= period;
120   U2 -= Floor((U2-U1)/period) * period;
121   if (U2 - U1 < Preci) U2 += period;
122 }
123
124 //=======================================================================
125 //function : LineValue
126 //purpose  : 
127 //=======================================================================
128
129 gp_Pnt ElCLib::LineValue (const Standard_Real U,
130                           const gp_Ax1& Pos)
131 {
132   const gp_XYZ& ZDir = Pos.Direction().XYZ();
133   const gp_XYZ& PLoc = Pos.Location ().XYZ();
134   return gp_Pnt(U * ZDir.X() + PLoc.X(),
135                 U * ZDir.Y() + PLoc.Y(),
136                 U * ZDir.Z() + PLoc.Z());
137 }
138
139 //=======================================================================
140 //function : CircleValue
141 //purpose  : 
142 //=======================================================================
143
144 gp_Pnt ElCLib::CircleValue (const Standard_Real U,
145                             const gp_Ax2& Pos,
146                             const Standard_Real Radius)
147 {
148   const gp_XYZ& XDir = Pos.XDirection().XYZ();
149   const gp_XYZ& YDir = Pos.YDirection().XYZ();
150   const gp_XYZ& PLoc = Pos.Location  ().XYZ();
151   Standard_Real A1 = Radius * cos(U);
152   Standard_Real A2 = Radius * sin(U);
153   return gp_Pnt(A1 * XDir.X() + A2 * YDir.X() + PLoc.X(),
154                 A1 * XDir.Y() + A2 * YDir.Y() + PLoc.Y(),
155                 A1 * XDir.Z() + A2 * YDir.Z() + PLoc.Z());
156 }
157
158 //=======================================================================
159 //function : EllipseValue
160 //purpose  : 
161 //=======================================================================
162
163 gp_Pnt ElCLib::EllipseValue (const Standard_Real U,
164                              const gp_Ax2& Pos, 
165                              const Standard_Real MajorRadius,
166                              const Standard_Real MinorRadius)
167 {
168   const gp_XYZ& XDir = Pos.XDirection().XYZ();
169   const gp_XYZ& YDir = Pos.YDirection().XYZ();
170   const gp_XYZ& PLoc = Pos.Location  ().XYZ();
171   Standard_Real A1 = MajorRadius * cos(U);
172   Standard_Real A2 = MinorRadius * sin(U);
173   return gp_Pnt(A1 * XDir.X() + A2 * YDir.X() + PLoc.X(),
174                 A1 * XDir.Y() + A2 * YDir.Y() + PLoc.Y(),
175                 A1 * XDir.Z() + A2 * YDir.Z() + PLoc.Z());
176 }
177
178 //=======================================================================
179 //function : HyperbolaValue
180 //purpose  : 
181 //=======================================================================
182
183 gp_Pnt ElCLib::HyperbolaValue (const Standard_Real U,
184                                const gp_Ax2& Pos,
185                                const Standard_Real MajorRadius,
186                                const Standard_Real MinorRadius)
187 {
188   const gp_XYZ& XDir = Pos.XDirection().XYZ();
189   const gp_XYZ& YDir = Pos.YDirection().XYZ();
190   const gp_XYZ& PLoc = Pos.Location  ().XYZ();
191   Standard_Real A1 = MajorRadius * Cosh(U);
192   Standard_Real A2 = MinorRadius * Sinh(U);
193   return gp_Pnt(A1 * XDir.X() + A2 * YDir.X() + PLoc.X(),
194                 A1 * XDir.Y() + A2 * YDir.Y() + PLoc.Y(),
195                 A1 * XDir.Z() + A2 * YDir.Z() + PLoc.Z());
196 }
197
198 //=======================================================================
199 //function : ParabolaValue
200 //purpose  : 
201 //=======================================================================
202
203 gp_Pnt ElCLib::ParabolaValue (const Standard_Real U,
204                               const gp_Ax2& Pos,
205                               const Standard_Real Focal)
206 {
207   if (Focal == 0.0) {
208     const gp_XYZ& XDir = Pos.XDirection().XYZ();
209     const gp_XYZ& PLoc = Pos.Location  ().XYZ();
210     return gp_Pnt(U * XDir.X() + PLoc.X(),
211                   U * XDir.Y() + PLoc.Y(),
212                   U * XDir.Z() + PLoc.Z());
213   }
214   const gp_XYZ& XDir = Pos.XDirection().XYZ();
215   const gp_XYZ& YDir = Pos.YDirection().XYZ();
216   const gp_XYZ& PLoc = Pos.Location  ().XYZ();
217   Standard_Real A1 = U * U / (4.0 * Focal);
218   return gp_Pnt(A1 * XDir.X() + U * YDir.X() + PLoc.X(),
219                 A1 * XDir.Y() + U * YDir.Y() + PLoc.Y(),
220                 A1 * XDir.Z() + U * YDir.Z() + PLoc.Z());
221 }
222
223 //=======================================================================
224 //function : LineD1
225 //purpose  : 
226 //=======================================================================
227
228 void ElCLib::LineD1 (const Standard_Real U,
229                      const gp_Ax1& Pos,
230                      gp_Pnt& P,
231                      gp_Vec& V1)
232 {
233   gp_XYZ Coord = Pos.Direction().XYZ();
234   V1.SetXYZ (Coord);
235   Coord.SetLinearForm (U, Coord, Pos.Location().XYZ());
236   P.SetXYZ (Coord);
237 }
238
239 //=======================================================================
240 //function : CircleD1
241 //purpose  : 
242 //=======================================================================
243
244 void ElCLib::CircleD1 (const Standard_Real U,
245                        const gp_Ax2& Pos,
246                        const Standard_Real Radius, 
247                        gp_Pnt& P,
248                        gp_Vec& V1)
249 {
250   Standard_Real Xc = Radius * Cos (U);
251   Standard_Real Yc = Radius * Sin (U);
252   gp_XYZ Coord0;
253   gp_XYZ Coord1 (Pos.XDirection().XYZ());
254   gp_XYZ Coord2 (Pos.YDirection().XYZ());
255   //Point courant :
256   Coord0.SetLinearForm (Xc, Coord1, Yc, Coord2, Pos.Location().XYZ());
257   P.SetXYZ (Coord0);
258   //D1 :
259   Coord0.SetLinearForm (-Yc, Coord1, Xc, Coord2);
260   V1.SetXYZ (Coord0);
261 }
262
263 //=======================================================================
264 //function : EllipseD1
265 //purpose  : 
266 //=======================================================================
267
268 void ElCLib::EllipseD1 (const Standard_Real U,
269                         const gp_Ax2& Pos,
270                         const Standard_Real MajorRadius,
271                         const Standard_Real MinorRadius,
272                         gp_Pnt& P,
273                         gp_Vec& V1)
274 {
275   Standard_Real Xc = Cos (U);
276   Standard_Real Yc = Sin (U);
277   gp_XYZ Coord0;
278   gp_XYZ Coord1 (Pos.XDirection().XYZ());
279   gp_XYZ Coord2 (Pos.YDirection().XYZ());
280   //Point courant :
281   Coord0.SetLinearForm (Xc*MajorRadius, Coord1, 
282                         Yc*MinorRadius, Coord2,
283                         Pos.Location().XYZ());
284   P.SetXYZ (Coord0);
285   //D1 :
286   Coord0.SetLinearForm (-Yc*MajorRadius, Coord1, Xc*MinorRadius, Coord2);
287   V1.SetXYZ (Coord0);
288 }
289
290 //=======================================================================
291 //function : HyperbolaD1
292 //purpose  : 
293 //=======================================================================
294
295 void ElCLib::HyperbolaD1 (const Standard_Real U,
296                           const gp_Ax2& Pos,
297                           const Standard_Real MajorRadius,
298                           const Standard_Real MinorRadius, 
299                           gp_Pnt& P,
300                           gp_Vec& V1)
301 {
302   Standard_Real Xc = Cosh (U);
303   Standard_Real Yc = Sinh (U);
304   gp_XYZ Coord0;
305   gp_XYZ Coord1 (Pos.XDirection().XYZ());
306   gp_XYZ Coord2 (Pos.YDirection().XYZ());
307   //Point courant :
308   Coord0.SetLinearForm (Xc*MajorRadius, Coord1, 
309                         Yc*MinorRadius, Coord2,
310                         Pos.Location().XYZ());
311   P.SetXYZ (Coord0);
312   //D1 :
313   Coord0.SetLinearForm (Yc*MajorRadius, Coord1, Xc*MinorRadius, Coord2);
314   V1.SetXYZ (Coord0);
315 }
316
317 //=======================================================================
318 //function : ParabolaD1
319 //purpose  : 
320 //=======================================================================
321
322 void ElCLib::ParabolaD1 (const Standard_Real U,
323                          const gp_Ax2& Pos,
324                          const Standard_Real Focal,
325                          gp_Pnt& P,
326                          gp_Vec& V1)
327 {
328   gp_XYZ Coord0;
329   gp_XYZ Coord1 (Pos.XDirection().XYZ());
330   if (Focal == 0.0) {      //Parabole degenere en une droite
331     V1.SetXYZ (Coord1);
332     Coord1.Multiply (U);
333     Coord1.Add (Pos.Location().XYZ());
334     P.SetXYZ (Coord1);
335   }
336   else {
337     gp_XYZ Coord2 (Pos.YDirection().XYZ());
338     Coord0.SetLinearForm (U / (2.0 * Focal), Coord1, Coord2);
339     V1.SetXYZ (Coord0);
340     Coord0.SetLinearForm ((U * U) / (4.0 * Focal), Coord1, 
341                           U, Coord2,
342                           Pos.Location().XYZ());
343     P.SetXYZ (Coord0);
344   }
345 }
346
347 //=======================================================================
348 //function : CircleD2
349 //purpose  : 
350 //=======================================================================
351
352 void ElCLib::CircleD2 (const Standard_Real U,
353                        const gp_Ax2& Pos,
354                        const Standard_Real Radius,
355                        gp_Pnt& P,
356                        gp_Vec& V1,
357                        gp_Vec& V2)
358 {
359   Standard_Real Xc = Radius * cos(U);
360   Standard_Real Yc = Radius * sin(U);
361   gp_XYZ Coord0;
362   gp_XYZ Coord1 (Pos.XDirection().XYZ());
363   gp_XYZ Coord2 (Pos.YDirection().XYZ());
364   //Point courant :
365   Coord0.SetLinearForm (Xc, Coord1, Yc, Coord2, Pos.Location().XYZ());
366   P.SetXYZ (Coord0);
367   //D1 :
368   Coord0.SetLinearForm (-Yc, Coord1, Xc, Coord2);
369   V1.SetXYZ (Coord0);
370   //D2 :
371   Coord0.SetLinearForm (-Xc, Coord1, -Yc, Coord2);
372   V2.SetXYZ (Coord0);
373 }
374
375 //=======================================================================
376 //function : EllipseD2
377 //purpose  : 
378 //=======================================================================
379
380 void ElCLib::EllipseD2 (const Standard_Real U,
381                         const gp_Ax2& Pos,
382                         const Standard_Real MajorRadius,
383                         const Standard_Real MinorRadius,
384                         gp_Pnt& P,
385                         gp_Vec& V1,
386                         gp_Vec& V2)
387 {
388   Standard_Real Xc = cos(U);
389   Standard_Real Yc = sin(U);
390   gp_XYZ Coord0; 
391   gp_XYZ Coord1 (Pos.XDirection().XYZ());
392   gp_XYZ Coord2 (Pos.YDirection().XYZ());
393   //Point courant :
394   Coord0.SetLinearForm (Xc*MajorRadius, Coord1, 
395                         Yc*MinorRadius, Coord2,
396                         Pos.Location().XYZ());
397   P.SetXYZ (Coord0);
398   //D1 :
399   Coord0.SetLinearForm (-Yc*MajorRadius, Coord1, Xc*MinorRadius, Coord2);
400   V1.SetXYZ (Coord0);
401   //D2 :
402   Coord0.SetLinearForm (-Xc*MajorRadius, Coord1, -Yc*MinorRadius, Coord2);
403   V2.SetXYZ (Coord0);
404 }
405
406 //=======================================================================
407 //function : HyperbolaD2
408 //purpose  : 
409 //=======================================================================
410
411 void ElCLib::HyperbolaD2 (const Standard_Real U,
412                           const gp_Ax2& Pos,
413                           const Standard_Real MajorRadius,
414                           const Standard_Real MinorRadius,
415                           gp_Pnt& P,
416                           gp_Vec& V1,
417                           gp_Vec& V2)
418 {
419   Standard_Real Xc = Cosh(U);
420   Standard_Real Yc = Sinh(U);
421   gp_XYZ Coord0; 
422   gp_XYZ Coord1 (Pos.XDirection().XYZ());
423   gp_XYZ Coord2 (Pos.YDirection().XYZ());
424
425   //Point courant et D2:
426   Coord0.SetLinearForm (Xc*MajorRadius, Coord1, Yc*MinorRadius, Coord2);
427   V2.SetXYZ (Coord0);
428   Coord0.Add (Pos.Location().XYZ());
429   P.SetXYZ (Coord0);
430   //D1 :
431   Coord0.SetLinearForm (Yc*MajorRadius, Coord1, Xc*MinorRadius, Coord2);
432   V1.SetXYZ (Coord0);
433 }
434
435 //=======================================================================
436 //function : ParabolaD2
437 //purpose  : 
438 //=======================================================================
439
440 void ElCLib::ParabolaD2 (const Standard_Real U,
441                          const gp_Ax2& Pos,
442                          const Standard_Real Focal,
443                          gp_Pnt& P,
444                          gp_Vec& V1,
445                          gp_Vec& V2)
446 {
447   gp_XYZ Coord0(0.0, 0.0, 0.0);
448   gp_XYZ Coord1 (Pos.XDirection().XYZ());
449   if (Focal == 0.0) {
450     V2.SetCoord (0.0, 0.0, 0.0);
451     V1.SetXYZ (Coord1);
452     Coord1.Multiply (U);
453     Coord1.Add (Pos.Location().XYZ());        
454     P.SetXYZ (Coord1);//was: P.SetXYZ (Coord0);
455     
456   }
457   else {
458     gp_XYZ Coord2 (Pos.YDirection().XYZ());
459     Coord0.SetLinearForm ((U * U) / (4.0 * Focal), Coord1, 
460                           U, Coord2,
461                           Pos.Location().XYZ());
462     P.SetXYZ (Coord0);
463     Coord0.SetLinearForm (U / (2.0 * Focal), Coord1, Coord2);
464     V1.SetXYZ (Coord0);
465     Coord1.Multiply (1.0 / (2.0 * Focal));
466     V2.SetXYZ (Coord1);
467   }
468 }
469
470 //=======================================================================
471 //function : CircleD3
472 //purpose  : 
473 //=======================================================================
474
475 void ElCLib::CircleD3 (const Standard_Real U,
476                        const gp_Ax2& Pos,
477                        const Standard_Real Radius, 
478                        gp_Pnt& P,
479                        gp_Vec& V1,
480                        gp_Vec& V2,
481                        gp_Vec& V3)
482 {
483   Standard_Real Xc = Radius * cos(U);
484   Standard_Real Yc = Radius * sin(U);
485   gp_XYZ Coord0;
486   gp_XYZ Coord1 (Pos.XDirection().XYZ());
487   gp_XYZ Coord2 (Pos.YDirection().XYZ());
488   //Point Courant :
489   Coord0.SetLinearForm (Xc, Coord1, Yc, Coord2, Pos.Location().XYZ());
490   P.SetXYZ (Coord0);
491   //D1 :
492   Coord0.SetLinearForm (-Yc, Coord1, Xc, Coord2);
493   V1.SetXYZ (Coord0);
494   //D2 :
495   Coord0.SetLinearForm (-Xc, Coord1, -Yc, Coord2);
496   V2.SetXYZ (Coord0);
497   //D3 :
498   Coord0.SetLinearForm (Yc, Coord1, -Xc, Coord2);
499   V3.SetXYZ (Coord0);
500 }
501
502 //=======================================================================
503 //function : EllipseD3
504 //purpose  : 
505 //=======================================================================
506
507 void ElCLib::EllipseD3 (const Standard_Real U,
508                         const gp_Ax2& Pos,
509                         const Standard_Real MajorRadius,
510                         const Standard_Real MinorRadius,
511                         gp_Pnt& P,
512                         gp_Vec& V1,
513                         gp_Vec& V2,
514                         gp_Vec& V3)
515 {
516   Standard_Real Xc = cos(U);
517   Standard_Real Yc = sin(U);
518   gp_XYZ Coord0;
519   gp_XYZ Coord1 (Pos.XDirection().XYZ());
520   gp_XYZ Coord2 (Pos.YDirection().XYZ());
521   //Point Courant :
522   Coord0.SetLinearForm (Xc*MajorRadius, Coord1,
523                         Yc*MinorRadius, Coord2,
524                         Pos.Location().XYZ());
525   P.SetXYZ (Coord0);
526   //D1 :
527   Coord0.SetLinearForm (-Yc*MajorRadius, Coord1, Xc*MinorRadius, Coord2);
528   V1.SetXYZ (Coord0);
529   //D2 :
530   Coord0.SetLinearForm (-Xc*MajorRadius, Coord1, -Yc*MinorRadius, Coord2);
531   V2.SetXYZ (Coord0);
532   //D3
533   Coord0.SetLinearForm (Yc*MajorRadius, Coord1, -Xc*MinorRadius, Coord2);
534   V3.SetXYZ (Coord0);
535 }
536
537 //=======================================================================
538 //function : HyperbolaD3
539 //purpose  : 
540 //=======================================================================
541
542 void ElCLib::HyperbolaD3 (const Standard_Real U,
543                           const gp_Ax2& Pos,
544                           const Standard_Real MajorRadius,
545                           const Standard_Real MinorRadius,
546                           gp_Pnt& P,
547                           gp_Vec& V1,
548                           gp_Vec& V2,
549                           gp_Vec& V3)
550 {
551   Standard_Real Xc = Cosh(U);
552   Standard_Real Yc = Sinh(U);
553   gp_XYZ Coord0;
554   gp_XYZ Coord1 (Pos.XDirection().XYZ());
555   gp_XYZ Coord2 (Pos.YDirection().XYZ());
556   //Point courant et D2 :
557   Coord0.SetLinearForm (Xc*MajorRadius, Coord1, Yc*MinorRadius, Coord2);
558   V2.SetXYZ (Coord0);
559   Coord0.Add (Pos.Location().XYZ());
560   P.SetXYZ (Coord0);
561   //D1 et D3 :
562   Coord0.SetLinearForm (Yc*MajorRadius, Coord1, Xc*MinorRadius, Coord2);
563   V1.SetXYZ (Coord0);
564   V3.SetXYZ (Coord0);
565 }
566
567 //=======================================================================
568 //function : LineValue
569 //purpose  : 
570 //=======================================================================
571
572 gp_Pnt2d ElCLib::LineValue (const Standard_Real U,
573                             const gp_Ax2d& Pos)
574 {
575   const gp_XY& ZDir = Pos.Direction().XY();
576   const gp_XY& PLoc = Pos.Location ().XY();
577   return gp_Pnt2d(U * ZDir.X() + PLoc.X(),
578                   U * ZDir.Y() + PLoc.Y());
579 }
580
581 //=======================================================================
582 //function : CircleValue
583 //purpose  : 
584 //=======================================================================
585
586 gp_Pnt2d ElCLib::CircleValue (const Standard_Real U,
587                               const gp_Ax22d& Pos,
588                               const Standard_Real Radius)
589 {
590   const gp_XY& XDir = Pos.XDirection().XY();
591   const gp_XY& YDir = Pos.YDirection().XY();
592   const gp_XY& PLoc = Pos.Location  ().XY();
593   Standard_Real A1 = Radius * cos(U);
594   Standard_Real A2 = Radius * sin(U);
595   return gp_Pnt2d(A1 * XDir.X() + A2 * YDir.X() + PLoc.X(),
596                   A1 * XDir.Y() + A2 * YDir.Y() + PLoc.Y());
597 }
598
599 //=======================================================================
600 //function : EllipseValue
601 //purpose  : 
602 //=======================================================================
603
604 gp_Pnt2d ElCLib::EllipseValue (const Standard_Real U,
605                                const gp_Ax22d& Pos,
606                                const Standard_Real MajorRadius,
607                                const Standard_Real MinorRadius)
608 {
609   const gp_XY& XDir = Pos.XDirection().XY();
610   const gp_XY& YDir = Pos.YDirection().XY();
611   const gp_XY& PLoc = Pos.Location  ().XY();
612   Standard_Real A1 = MajorRadius * cos(U);
613   Standard_Real A2 = MinorRadius * sin(U);
614   return gp_Pnt2d(A1 * XDir.X() + A2 * YDir.X() + PLoc.X(),
615                   A1 * XDir.Y() + A2 * YDir.Y() + PLoc.Y());
616 }
617
618 //=======================================================================
619 //function : HyperbolaValue
620 //purpose  : 
621 //=======================================================================
622
623 gp_Pnt2d ElCLib::HyperbolaValue (const Standard_Real U,
624                                  const gp_Ax22d& Pos,
625                                  const Standard_Real MajorRadius,
626                                  const Standard_Real MinorRadius)
627 {
628   const gp_XY& XDir = Pos.XDirection().XY();
629   const gp_XY& YDir = Pos.YDirection().XY();
630   const gp_XY& PLoc = Pos.Location  ().XY();
631   Standard_Real A1 = MajorRadius * Cosh(U);
632   Standard_Real A2 = MinorRadius * Sinh(U);
633   return gp_Pnt2d(A1 * XDir.X() + A2 * YDir.X() + PLoc.X(),
634                   A1 * XDir.Y() + A2 * YDir.Y() + PLoc.Y());
635 }
636
637 //=======================================================================
638 //function : ParabolaValue
639 //purpose  : 
640 //=======================================================================
641
642 gp_Pnt2d ElCLib::ParabolaValue (const Standard_Real U,
643                                 const gp_Ax22d& Pos,
644                                 const Standard_Real Focal)
645 {
646   if (Focal == 0.0) {
647     const gp_XY& XDir = Pos.XDirection().XY();
648     const gp_XY& PLoc = Pos.Location  ().XY();
649     return gp_Pnt2d(U * XDir.X() + PLoc.X(),
650                     U * XDir.Y() + PLoc.Y());
651   }
652   const gp_XY& XDir = Pos.XDirection().XY();
653   const gp_XY& YDir = Pos.YDirection().XY();
654   const gp_XY& PLoc = Pos.Location  ().XY();
655   Standard_Real A1 = U * U / (4.0 * Focal);
656   return gp_Pnt2d(A1 * XDir.X() + U * YDir.X() + PLoc.X(),
657                   A1 * XDir.Y() + U * YDir.Y() + PLoc.Y());
658 }
659
660 //=======================================================================
661 //function : LineD1
662 //purpose  : 
663 //=======================================================================
664
665 void ElCLib::LineD1(const Standard_Real U,
666                     const gp_Ax2d& Pos,
667                     gp_Pnt2d& P,
668                     gp_Vec2d& V1)
669 {
670   gp_XY Coord = Pos.Direction().XY();
671   V1.SetXY (Coord);
672   Coord.SetLinearForm (U, Coord, Pos.Location().XY());
673   P.SetXY (Coord);
674 }
675
676 //=======================================================================
677 //function : CircleD1
678 //purpose  : 
679 //=======================================================================
680
681 void ElCLib::CircleD1 (const Standard_Real U,
682                        const gp_Ax22d& Pos,
683                        const Standard_Real Radius,
684                        gp_Pnt2d& P,
685                        gp_Vec2d& V1)
686 {
687   gp_XY Vxy;
688   gp_XY Xdir (Pos.XDirection().XY());
689   gp_XY Ydir (Pos.YDirection().XY());
690   Standard_Real Xc = Radius * cos(U);
691   Standard_Real Yc = Radius * sin(U);
692   //Point courant :
693   Vxy.SetLinearForm (Xc, Xdir, Yc, Ydir, Pos.Location().XY());
694   P.SetXY (Vxy);
695   //V1 :
696   Vxy.SetLinearForm (-Yc, Xdir, Xc, Ydir);
697   V1.SetXY (Vxy);
698 }
699
700 //=======================================================================
701 //function : EllipseD1
702 //purpose  : 
703 //=======================================================================
704
705 void ElCLib::EllipseD1 (const Standard_Real U,
706                         const gp_Ax22d& Pos,
707                         const Standard_Real MajorRadius,
708                         const Standard_Real MinorRadius,
709                         gp_Pnt2d& P,
710                         gp_Vec2d& V1)
711 {
712   gp_XY Vxy;
713   gp_XY Xdir ((Pos.XDirection()).XY());
714   gp_XY Ydir ((Pos.YDirection()).XY());
715   Standard_Real Xc = cos(U);
716   Standard_Real Yc = sin(U);
717   //Point courant :
718   Vxy.SetLinearForm (Xc*MajorRadius, Xdir,
719                      Yc*MinorRadius, Ydir,
720                      Pos.Location().XY());
721   P.SetXY (Vxy);
722   
723   //V1 :
724   Vxy.SetLinearForm (-Yc*MajorRadius, Xdir, Xc*MinorRadius, Ydir);
725   V1.SetXY (Vxy);
726 }
727
728 //=======================================================================
729 //function : HyperbolaD1
730 //purpose  : 
731 //=======================================================================
732
733 void ElCLib::HyperbolaD1 (const Standard_Real U,
734                           const gp_Ax22d& Pos,
735                           const Standard_Real MajorRadius,
736                           const Standard_Real MinorRadius,
737                           gp_Pnt2d& P,
738                           gp_Vec2d& V1)
739 {
740   gp_XY Vxy;
741   gp_XY Xdir ((Pos.XDirection()).XY());
742   gp_XY Ydir ((Pos.YDirection()).XY());
743   Standard_Real Xc = Cosh(U);
744   Standard_Real Yc = Sinh(U);
745   //Point courant :
746   Vxy.SetLinearForm (Xc*MajorRadius, Xdir, 
747                      Yc*MinorRadius, Ydir,
748                      Pos.Location().XY());
749   P.SetXY (Vxy);
750   
751   //V1 :
752   Vxy.SetLinearForm (Yc*MajorRadius, Xdir, Xc*MinorRadius, Ydir);
753   V1.SetXY (Vxy);
754 }
755
756 //=======================================================================
757 //function : ParabolaD1
758 //purpose  : 
759 //=======================================================================
760
761 void ElCLib::ParabolaD1 (const Standard_Real U,
762                          const gp_Ax22d& Pos,
763                          const Standard_Real Focal,
764                          gp_Pnt2d& P,
765                          gp_Vec2d& V1)
766 {
767   gp_XY Vxy;
768   gp_XY Xdir (Pos.XDirection().XY());
769   if (Focal == 0.0) {      //Parabole degenere en une droite
770     V1.SetXY (Xdir);
771     Vxy.SetLinearForm (U, Xdir, Pos.Location().XY());
772   }
773   else {
774     gp_XY Ydir (Pos.YDirection().XY());
775     Vxy.SetLinearForm (U / (2.0 * Focal), Xdir, Ydir);
776     V1.SetXY (Vxy);
777     Vxy.SetLinearForm ((U * U) / (4.0 * Focal), Xdir, 
778                        U, Ydir,
779                        Pos.Location().XY());
780   }
781   P.SetXY (Vxy);
782 }
783
784 //=======================================================================
785 //function : CircleD2
786 //purpose  : 
787 //=======================================================================
788
789 void ElCLib::CircleD2 (const Standard_Real U,
790                        const gp_Ax22d& Pos,
791                        const Standard_Real Radius, 
792                        gp_Pnt2d& P,
793                        gp_Vec2d& V1,
794                        gp_Vec2d& V2)
795 {
796   gp_XY Vxy;
797   gp_XY Xdir (Pos.XDirection().XY());
798   gp_XY Ydir (Pos.YDirection().XY());
799   Standard_Real Xc = Radius * cos(U);
800   Standard_Real Yc = Radius * sin(U);
801   //V2 :
802   Vxy.SetLinearForm (Xc, Xdir, Yc, Ydir);
803   V2.SetXY (Vxy);
804   V2.Reverse();
805   Vxy.Add (Pos.Location().XY());
806   P.SetXY (Vxy);
807
808   //V1 :
809   Vxy.SetLinearForm (-Yc, Xdir, Xc, Ydir);
810   V1.SetXY (Vxy);
811 }
812
813 //=======================================================================
814 //function : EllipseD2
815 //purpose  : 
816 //=======================================================================
817
818 void ElCLib::EllipseD2 (const Standard_Real U,
819                         const gp_Ax22d& Pos,
820                         const Standard_Real MajorRadius,
821                         const Standard_Real MinorRadius,
822                         gp_Pnt2d& P,
823                         gp_Vec2d& V1,
824                         gp_Vec2d& V2)
825 {
826   gp_XY Vxy;
827   gp_XY Xdir (Pos.XDirection().XY());
828   gp_XY Ydir (Pos.YDirection().XY());
829   Standard_Real Xc = cos(U);
830   Standard_Real Yc = sin(U);
831
832   //V2 :
833   Vxy.SetLinearForm (Xc*MajorRadius, Xdir, Yc*MinorRadius, Ydir);
834   V2.SetXY (Vxy);
835   V2.Reverse ();
836
837   //Point courant :
838   Vxy.Add (Pos.Location().XY());
839   P.SetXY (Vxy);
840
841   //V1 :
842   Vxy.SetLinearForm (-Yc*MajorRadius, Xdir, Xc*MinorRadius, Ydir);
843   V1.SetXY (Vxy);
844 }
845
846 //=======================================================================
847 //function : HyperbolaD2
848 //purpose  : 
849 //=======================================================================
850
851 void ElCLib::HyperbolaD2 (const Standard_Real U,
852                           const gp_Ax22d& Pos,
853                           const Standard_Real MajorRadius,
854                           const Standard_Real MinorRadius,
855                           gp_Pnt2d& P,
856                           gp_Vec2d& V1,
857                           gp_Vec2d& V2)
858 {
859   gp_XY Vxy;
860   gp_XY Xdir (Pos.XDirection().XY()); 
861   gp_XY Ydir (Pos.YDirection().XY()); 
862   Standard_Real Xc = Cosh(U);
863   Standard_Real Yc = Sinh(U);
864
865   //V2 :
866   Vxy.SetLinearForm (Xc*MajorRadius, Xdir, Yc*MinorRadius, Ydir);
867   V2.SetXY (Vxy);
868
869   //Point courant :
870   Vxy.Add (Pos.Location().XY());
871   P.SetXY (Vxy);
872
873   //V1 :
874   Vxy.SetLinearForm (Yc*MajorRadius, Xdir, Xc*MinorRadius, Ydir);
875   V1.SetXY (Vxy);
876 }
877
878 //=======================================================================
879 //function : ParabolaD2
880 //purpose  : 
881 //=======================================================================
882
883 void ElCLib::ParabolaD2 (const Standard_Real U,
884                          const gp_Ax22d& Pos,
885                          const Standard_Real Focal,
886                          gp_Pnt2d& P,
887                          gp_Vec2d& V1,
888                          gp_Vec2d& V2)
889 {
890   gp_XY Vxy;
891   gp_XY Xdir (Pos.XDirection().XY());
892   if (Focal == 0.0) {
893     V2.SetCoord (0.0, 0.0);
894     V1.SetXY (Xdir);
895     Vxy.SetLinearForm (U, Xdir, Pos.Location().XY());
896   }
897   else {
898     gp_XY Ydir (Pos.YDirection().XY());
899     Vxy = Xdir.Multiplied (1.0 / (2.0 * Focal));
900     V2.SetXY (Vxy);
901     Vxy.SetLinearForm (U, Vxy, Ydir);
902     V1.SetXY (Vxy);
903     Vxy.SetLinearForm (U * U / (4.0 * Focal), Xdir, U, Ydir);
904     Vxy.Add (Pos.Location().XY());
905   }
906   P.SetXY (Vxy);
907 }
908
909 //=======================================================================
910 //function : CircleD3
911 //purpose  : 
912 //=======================================================================
913
914 void ElCLib::CircleD3 (const Standard_Real U,
915                        const gp_Ax22d& Pos,
916                        const Standard_Real Radius,
917                        gp_Pnt2d& P,
918                        gp_Vec2d& V1,
919                        gp_Vec2d& V2,
920                        gp_Vec2d& V3)
921 {
922   gp_XY Vxy;
923   gp_XY Xdir (Pos.XDirection().XY());
924   gp_XY Ydir (Pos.YDirection().XY());
925   Standard_Real Xc = Radius * cos(U);
926   Standard_Real Yc = Radius * sin(U);
927
928   //V2 :
929   Vxy.SetLinearForm (Xc, Xdir, Yc, Ydir);
930   V2.SetXY (Vxy);
931   V2.Reverse();
932
933   //Point courant :
934   Vxy.Add (Pos.Location().XY());
935   P.SetXY (Vxy);
936
937   //V1 :
938   Vxy.SetLinearForm (-Yc, Xdir, Xc, Ydir);
939   V1.SetXY (Vxy);
940
941   //V3 :
942   V3.SetXY (Vxy);
943   V3.Reverse ();
944 }
945
946 //=======================================================================
947 //function : EllipseD3
948 //purpose  : 
949 //=======================================================================
950
951 void ElCLib::EllipseD3 (const Standard_Real U,
952                         const gp_Ax22d& Pos,
953                         const Standard_Real MajorRadius,
954                         const Standard_Real MinorRadius,
955                         gp_Pnt2d& P,
956                         gp_Vec2d& V1,
957                         gp_Vec2d& V2,
958                         gp_Vec2d& V3)
959 {
960   gp_XY Vxy;
961   gp_XY Xdir (Pos.XDirection().XY());
962   gp_XY Ydir (Pos.YDirection().XY());
963   Standard_Real Xc = cos(U);
964   Standard_Real Yc = sin(U);
965
966   //V2 :
967   Vxy.SetLinearForm (Xc*MajorRadius, Xdir, Yc*MinorRadius, Ydir);
968   V2.SetXY (Vxy);
969   V2.Reverse ();
970
971   //Point courant :
972   Vxy.Add (Pos.Location().XY());
973   P.SetXY (Vxy);
974
975   //V1 :
976   Vxy.SetLinearForm (-Yc*MajorRadius, Xdir, Xc*MinorRadius, Ydir);
977   V1.SetXY (Vxy);
978
979   //V3 :
980   V3.SetXY (Vxy);
981   V3.Reverse ();
982 }
983
984 //=======================================================================
985 //function : HyperbolaD3
986 //purpose  : 
987 //=======================================================================
988
989 void ElCLib::HyperbolaD3 (const Standard_Real U,
990                           const gp_Ax22d& Pos,
991                           const Standard_Real MajorRadius,
992                           const Standard_Real MinorRadius,
993                           gp_Pnt2d& P,
994                           gp_Vec2d& V1,
995                           gp_Vec2d& V2,
996                           gp_Vec2d& V3)
997 {
998   gp_XY Vxy;
999   gp_XY Xdir (Pos.XDirection().XY());
1000   gp_XY Ydir (Pos.YDirection().XY());
1001   Standard_Real Xc = Cosh(U);
1002   Standard_Real Yc = Sinh(U);
1003
1004   //V2 :
1005   Vxy.SetLinearForm (Xc*MajorRadius, Xdir, Yc*MinorRadius, Ydir);
1006   V2.SetXY (Vxy);
1007
1008   //Point courant :
1009   Vxy.Add (Pos.Location().XY());
1010   P.SetXY (Vxy);
1011
1012   //V1 :
1013   Vxy.SetLinearForm (Yc*MajorRadius, Xdir, Xc*MinorRadius, Ydir);
1014   V1.SetXY (Vxy);
1015
1016   //V3 :
1017   V3.SetXY (Vxy);
1018 }
1019
1020 //=======================================================================
1021 //function : LineDN
1022 //purpose  : 
1023 //=======================================================================
1024
1025 gp_Vec ElCLib::LineDN (const Standard_Real,
1026                        const gp_Ax1& Pos,
1027                        const Standard_Integer N) 
1028 {
1029   if (N == 1) { return gp_Vec(Pos.Direction()); }
1030   return gp_Vec (0., 0., 0.);
1031 }
1032
1033 //=======================================================================
1034 //function : CircleDN
1035 //purpose  : 
1036 //=======================================================================
1037
1038 gp_Vec ElCLib::CircleDN (const Standard_Real U,
1039                          const gp_Ax2& Pos,
1040                          const Standard_Real Radius,
1041                          const Standard_Integer N) 
1042 {
1043   Standard_Real Xc=0, Yc=0;
1044   if (N == 1) {       
1045     Xc = Radius * -sin(U);
1046     Yc = Radius *  cos(U);
1047   }
1048   else if ((N + 2) % 4 == 0) {
1049     Xc = Radius * -cos(U);
1050     Yc = Radius * -sin(U);
1051   }
1052   else if ((N + 1) % 4 == 0) {
1053     Xc = Radius *  sin(U);
1054     Yc = Radius * -cos(U);
1055   }
1056   else if (N % 4 == 0) {
1057     Xc = Radius *  cos(U);
1058     Yc = Radius *  sin(U);
1059   }
1060   else if ((N-1) % 4 == 0) {
1061     Xc = Radius * -sin(U);
1062     Yc = Radius *  cos(U);
1063   }
1064   gp_XYZ Coord1 (Pos.XDirection().XYZ());
1065   Coord1.SetLinearForm (Xc, Coord1, Yc, Pos.YDirection().XYZ());
1066   return gp_Vec (Coord1);
1067 }
1068
1069 //=======================================================================
1070 //function : EllipseDN
1071 //purpose  : 
1072 //=======================================================================
1073
1074 gp_Vec ElCLib::EllipseDN (const Standard_Real U,
1075                           const gp_Ax2& Pos,
1076                           const Standard_Real MajorRadius,
1077                           const Standard_Real MinorRadius,
1078                           const Standard_Integer N)
1079 {
1080   Standard_Real Xc=0, Yc=0;
1081   if (N == 1) {       
1082     Xc = MajorRadius * -sin(U);
1083     Yc = MinorRadius *  cos(U);
1084   }
1085   else if ((N + 2) % 4 == 0) {
1086     Xc = MajorRadius * -cos(U);
1087     Yc = MinorRadius * -sin(U);
1088   }
1089   else if ((N + 1) % 4 == 0) {
1090     Xc = MajorRadius *  sin(U);
1091     Yc = MinorRadius * -cos(U);
1092   }
1093   else if (N % 4 == 0) {
1094     Xc = MajorRadius *  cos(U);
1095     Yc = MinorRadius *  sin(U);
1096   }
1097   else if ((N-1) % 4 == 0) {
1098     Xc = MajorRadius * -sin(U);
1099     Yc = MinorRadius *  cos(U);
1100   }
1101   gp_XYZ Coord1 (Pos.XDirection().XYZ());
1102   Coord1.SetLinearForm (Xc, Coord1, Yc, Pos.YDirection().XYZ());
1103   return gp_Vec (Coord1);
1104 }
1105
1106 //=======================================================================
1107 //function : HyperbolaDN
1108 //purpose  : 
1109 //=======================================================================
1110
1111 gp_Vec ElCLib::HyperbolaDN (const Standard_Real U,
1112                             const gp_Ax2& Pos,
1113                             const Standard_Real MajorRadius,
1114                             const Standard_Real MinorRadius,
1115                             const Standard_Integer N)
1116 {
1117   Standard_Real Xc=0, Yc=0;
1118   if (IsOdd (N)) {       
1119     Xc = MajorRadius * Sinh(U);
1120     Yc = MinorRadius * Cosh(U);
1121   }
1122   else if (IsEven (N)) {
1123     Xc = MajorRadius * Cosh(U);
1124     Yc = MinorRadius * Sinh(U);
1125   }
1126   gp_XYZ Coord1 (Pos.XDirection().XYZ());
1127   Coord1.SetLinearForm (Xc, Coord1, Yc, Pos.YDirection().XYZ());
1128   return gp_Vec (Coord1);
1129 }
1130
1131 //=======================================================================
1132 //function : ParabolaDN
1133 //purpose  : 
1134 //=======================================================================
1135
1136 gp_Vec ElCLib::ParabolaDN (const Standard_Real U,
1137                            const gp_Ax2& Pos,
1138                            const Standard_Real Focal,
1139                            const Standard_Integer N) 
1140 {
1141   if (N <= 2) {
1142     gp_XYZ Coord1 (Pos.XDirection().XYZ());
1143     if (N == 1) {
1144       if (Focal == 0.0) { 
1145         return gp_Vec(Coord1);
1146       }
1147       else {
1148         Coord1.SetLinearForm
1149           (U / (2.0 * Focal), Coord1, Pos.YDirection().XYZ());
1150         return gp_Vec (Coord1);
1151       }
1152     }
1153     else if (N == 2) {
1154       if (Focal == 0.0) { 
1155         return gp_Vec(0.0, 0.0, 0.0);
1156       }
1157       else {
1158         Coord1.Multiply ( 1.0 / (2.0 * Focal));
1159         return gp_Vec (Coord1);
1160       }
1161     }
1162   }
1163   return gp_Vec (0.,0.,0.);
1164 }
1165
1166 //=======================================================================
1167 //function : LineDN
1168 //purpose  : 
1169 //=======================================================================
1170
1171 gp_Vec2d ElCLib::LineDN (const Standard_Real,
1172                          const gp_Ax2d& Pos,
1173                          const Standard_Integer N) 
1174 {
1175   if (N == 1) { return gp_Vec2d (Pos.Direction ()); }
1176   return gp_Vec2d (0.0, 0.0);
1177 }
1178
1179 //=======================================================================
1180 //function : CircleDN
1181 //purpose  : 
1182 //=======================================================================
1183
1184 gp_Vec2d ElCLib::CircleDN (const Standard_Real U,
1185                            const gp_Ax22d& Pos,
1186                            const Standard_Real Radius,
1187                            const Standard_Integer N)
1188 {
1189   Standard_Real Xc=0, Yc=0;
1190   if (N == 1) {       
1191     Xc = Radius * -sin(U);
1192     Yc = Radius *  cos(U);
1193   }
1194   else if ((N + 2) % 4 == 0) {
1195     Xc = Radius * -cos(U);
1196     Yc = Radius * -sin(U);
1197   }
1198   else if ((N + 1) % 4 == 0) {
1199     Xc = Radius *  sin(U);
1200     Yc = Radius * -cos(U);
1201   }
1202   else if (N % 4 == 0) {
1203     Xc = Radius *  cos(U);
1204     Yc = Radius *  sin(U);
1205   }
1206   else if ((N-1) % 4 == 0) {
1207     Xc = Radius * -sin(U);
1208     Yc = Radius *  cos(U);
1209   }
1210   gp_XY Xdir (Pos.XDirection().XY());
1211   gp_XY Ydir (Pos.YDirection().XY());
1212   Xdir.SetLinearForm (Xc, Xdir, Yc, Ydir);
1213   return gp_Vec2d (Xdir);
1214 }
1215
1216 //=======================================================================
1217 //function : EllipseDN
1218 //purpose  : 
1219 //=======================================================================
1220
1221 gp_Vec2d ElCLib::EllipseDN (const Standard_Real U,
1222                             const gp_Ax22d& Pos,
1223                             const Standard_Real MajorRadius,
1224                             const Standard_Real MinorRadius,
1225                             const Standard_Integer N)
1226 {
1227   Standard_Real Xc=0, Yc=0;
1228   if (N == 1) {       
1229     Xc = MajorRadius * -sin(U);
1230     Yc = MinorRadius *  cos(U);
1231   }
1232   else if ((N + 2) % 4 == 0) {
1233     Xc = MajorRadius * -cos(U);
1234     Yc = MinorRadius * -sin(U);
1235   }
1236   else if ((N + 1) % 4 == 0) {
1237     Xc = MajorRadius *  sin(U);
1238     Yc = MinorRadius * -cos(U);
1239   }
1240   else if (N % 4 == 0) {
1241     Xc = MajorRadius *  cos(U);
1242     Yc = MinorRadius *  sin(U);
1243   }
1244   else if ((N-1) % 4 == 0) {
1245     Xc = MajorRadius * -sin(U);
1246     Yc = MinorRadius *  cos(U);
1247   }
1248   gp_XY Xdir (Pos.XDirection().XY());
1249   gp_XY Ydir (Pos.YDirection().XY());
1250   Xdir.SetLinearForm (Xc, Xdir, Yc, Ydir);
1251   return gp_Vec2d (Xdir);
1252 }
1253
1254 //=======================================================================
1255 //function : HyperbolaDN
1256 //purpose  : 
1257 //=======================================================================
1258
1259 gp_Vec2d ElCLib::HyperbolaDN (const Standard_Real U,
1260                               const gp_Ax22d& Pos,
1261                               const Standard_Real MajorRadius,
1262                               const Standard_Real MinorRadius,
1263                               const Standard_Integer N)
1264 {
1265   Standard_Real Xc=0, Yc=0;
1266   if (IsOdd (N)) {       
1267     Xc = MajorRadius * Sinh(U);
1268     Yc = MinorRadius * Cosh(U);
1269   }
1270   else if (IsEven (N)) {
1271     Xc = MajorRadius * Cosh(U);
1272     Yc = MinorRadius * Sinh(U);
1273   }
1274   gp_XY Xdir (Pos.XDirection().XY());
1275   gp_XY Ydir (Pos.YDirection().XY());
1276   Xdir.SetLinearForm (Xc, Xdir, Yc, Ydir);
1277   return gp_Vec2d (Xdir);
1278 }
1279
1280 //=======================================================================
1281 //function : ParabolaDN
1282 //purpose  : 
1283 //=======================================================================
1284
1285 gp_Vec2d ElCLib::ParabolaDN (const Standard_Real U,
1286                              const gp_Ax22d& Pos,
1287                              const Standard_Real Focal,
1288                              const Standard_Integer N)
1289 {
1290   if (N <= 2)  {
1291     gp_XY Xdir (Pos.XDirection().XY());
1292     if (N == 1) {
1293       if (Focal == 0.0) { 
1294         return gp_Vec2d (Xdir);
1295       }
1296       else {
1297         gp_XY Ydir (Pos.YDirection().XY());
1298         Xdir.SetLinearForm (U / (2.0 * Focal), Xdir,  Ydir);
1299         return gp_Vec2d (Xdir);
1300       }
1301     }
1302     else if (N == 2) {
1303       if (Focal == 0.0) { 
1304         return gp_Vec2d (0.0, 0.0);
1305       }
1306       else {
1307         Xdir.Multiply ( 1.0 / (2.0 * Focal));
1308         return gp_Vec2d (Xdir);
1309       }
1310     }
1311   }
1312   return gp_Vec2d (0.0, 0.0); 
1313 }
1314
1315 //=======================================================================
1316 //function : LineParameter
1317 //purpose  : 
1318 //=======================================================================
1319
1320 Standard_Real ElCLib::LineParameter (const gp_Ax1& L, const gp_Pnt& P)
1321 {
1322   return (P.XYZ() - L.Location().XYZ()).Dot (L.Direction().XYZ());
1323 }
1324
1325 //=======================================================================
1326 //function : CircleParameter
1327 //purpose  : 
1328 //=======================================================================
1329 Standard_Real ElCLib::CircleParameter(const gp_Ax2& Pos,
1330                                       const gp_Pnt& P)
1331 {
1332   gp_Vec aVec(Pos.Location(), P);
1333   if (aVec.SquareMagnitude() < gp::Resolution())
1334     // coinciding points -> infinite number of parameters
1335     return 0.0;
1336
1337   const gp_Dir& dir = Pos.Direction();
1338   // Project vector on circle's plane
1339   gp_XYZ aVProj = dir.XYZ().CrossCrossed(aVec.XYZ(), dir.XYZ());
1340
1341   if (aVProj.SquareModulus() < gp::Resolution())
1342     return 0.0;
1343
1344   // Angle between X direction and projected vector
1345   Standard_Real Teta = (Pos.XDirection()).AngleWithRef(aVProj, dir);
1346
1347   if      (Teta < -1.e-16)  Teta += PIPI;
1348   else if (Teta < 0)        Teta = 0;
1349   return Teta;
1350 }
1351
1352 //=======================================================================
1353 //function : EllipseParameter
1354 //purpose  : 
1355 //=======================================================================
1356
1357 Standard_Real ElCLib::EllipseParameter (const gp_Ax2& Pos,
1358                                         const Standard_Real MajorRadius,
1359                                         const Standard_Real MinorRadius,
1360                                         const gp_Pnt& P)
1361 {
1362   gp_XYZ  OP = P.XYZ()-Pos.Location().XYZ();
1363   gp_XYZ xaxis = Pos.XDirection().XYZ();
1364   gp_XYZ yaxis = Pos.YDirection().XYZ();
1365   Standard_Real NY = OP.Dot(yaxis);
1366   Standard_Real NX = OP.Dot(xaxis); 
1367
1368   if(  (Abs(NX) <= gp::Resolution())
1369      &&(Abs(NY) <= gp::Resolution()))
1370     //-- The point P is on the Axis of the Ellipse. 
1371     return(0.0);
1372   
1373   yaxis.Multiply (NY * (MajorRadius/MinorRadius));
1374   gp_XYZ Om = xaxis.Multiplied (NX);
1375   Om.Add (yaxis); 
1376   Standard_Real Teta = gp_Vec(xaxis).AngleWithRef
1377     (gp_Vec(Om), gp_Vec(Pos.Direction()));
1378   if      (Teta < -1.e-16)  Teta += PIPI;
1379   else if (Teta < 0)        Teta = 0;
1380   return Teta;
1381 }
1382
1383 //=======================================================================
1384 //function : HyperbolaParameter
1385 //purpose  : 
1386 //=======================================================================
1387
1388 Standard_Real ElCLib::HyperbolaParameter (const gp_Ax2& Pos,
1389                                           const Standard_Real,
1390                                           const Standard_Real MinorRadius,
1391                                           const gp_Pnt& P)
1392 {
1393   Standard_Real sht = 
1394     gp_Vec(Pos.Location (), P).Dot
1395       (gp_Vec (Pos.YDirection())) / MinorRadius;
1396
1397 #if __QNX__
1398   return std::asinh(sht);
1399 #else
1400   return asinh(sht);
1401 #endif
1402 }
1403
1404 //=======================================================================
1405 //function : ParabolaParameter
1406 //purpose  : 
1407 //=======================================================================
1408
1409 Standard_Real ElCLib::ParabolaParameter (const gp_Ax2& Pos,
1410                                          const gp_Pnt& P)
1411 {
1412   return gp_Vec(Pos.Location(),P).Dot(gp_Vec(Pos.YDirection()));
1413 }
1414
1415 //=======================================================================
1416 //function : LineParameter
1417 //purpose  : 
1418 //=======================================================================
1419
1420 Standard_Real ElCLib::LineParameter (const gp_Ax2d& L,
1421                                      const gp_Pnt2d& P)
1422 {
1423   gp_XY Coord = P.XY();
1424   Coord.Subtract (L.Location().XY());
1425   return Coord.Dot (L.Direction().XY());
1426 }
1427
1428 //=======================================================================
1429 //function : CircleParameter
1430 //purpose  : 
1431 //=======================================================================
1432
1433 Standard_Real ElCLib::CircleParameter (const gp_Ax22d& Pos,
1434                                        const gp_Pnt2d& P)
1435 {
1436   Standard_Real Teta = (Pos.XDirection()).Angle
1437     (gp_Vec2d (Pos.Location(),P));
1438   Teta = ((Pos.XDirection() ^ Pos.YDirection()) >= 0.0) ? Teta: -Teta;
1439   if      (Teta < -1.e-16)  Teta += PIPI;
1440   else if (Teta < 0)        Teta = 0;
1441   return Teta;
1442 }
1443
1444 //=======================================================================
1445 //function : EllipseParameter
1446 //purpose  : 
1447 //=======================================================================
1448
1449 Standard_Real ElCLib::EllipseParameter (const gp_Ax22d& Pos,
1450                                         const Standard_Real MajorRadius,
1451                                         const Standard_Real MinorRadius, 
1452                                         const gp_Pnt2d& P)
1453 {
1454   gp_XY  OP = P.XY();
1455   OP.Subtract (Pos.Location().XY());
1456   gp_XY xaxis = Pos.XDirection().XY();
1457   gp_XY yaxis = Pos.YDirection().XY();
1458   gp_XY Om = xaxis.Multiplied (OP.Dot(xaxis));
1459   yaxis.Multiply ( (OP.Dot(yaxis)) * (MajorRadius/MinorRadius) );
1460   Om.Add (yaxis); 
1461   Standard_Real Teta = gp_Vec2d(xaxis).Angle (gp_Vec2d(Om));
1462   Teta = ((Pos.XDirection() ^ Pos.YDirection()) >= 0.0) ? Teta: -Teta;
1463   if      (Teta < -1.e-16)  Teta += PIPI;
1464   else if (Teta < 0)        Teta = 0;
1465   return Teta;
1466 }
1467
1468 //=======================================================================
1469 //function : HyperbolaParameter
1470 //purpose  : 
1471 //=======================================================================
1472
1473 Standard_Real ElCLib::HyperbolaParameter (const gp_Ax22d& Pos,
1474                                           const Standard_Real,
1475                                           const Standard_Real MinorRadius, 
1476                                           const gp_Pnt2d& P)
1477 {
1478   gp_Vec2d V (Pos.YDirection().XY());
1479   Standard_Real sht = gp_Vec2d(Pos.Location(),P).Dot(V) /MinorRadius;
1480 #if __QNX__
1481   return std::asinh(sht);
1482 #else
1483   return asinh(sht);
1484 #endif
1485 }
1486
1487 //=======================================================================
1488 //function : ParabolaParameter
1489 //purpose  : 
1490 //=======================================================================
1491
1492 Standard_Real ElCLib::ParabolaParameter (const gp_Ax22d& Pos,
1493                                          const gp_Pnt2d& P)
1494 {
1495   gp_Vec2d Directrix (Pos.YDirection().XY());
1496   return gp_Vec2d(Pos.Location(),P).Dot(Directrix);
1497 }
1498
1499 //=======================================================================
1500 //function : To3d
1501 //purpose  : 
1502 //=======================================================================
1503
1504 gp_Pnt ElCLib::To3d (const gp_Ax2& Pos, const gp_Pnt2d& P)
1505 {
1506   gp_XYZ Vxy = Pos.XDirection().XYZ();
1507   Vxy.SetLinearForm (P.X(), Vxy, P.Y(), Pos.YDirection().XYZ(), 
1508                      Pos.Location().XYZ());
1509   return gp_Pnt (Vxy);
1510
1511 }
1512
1513 //=======================================================================
1514 //function : To3d
1515 //purpose  : 
1516 //=======================================================================
1517
1518 gp_Dir ElCLib::To3d (const gp_Ax2& Pos, const gp_Dir2d& V)
1519 {
1520   gp_Vec Vx = Pos.XDirection();
1521   gp_Vec Vy = Pos.YDirection();
1522   Vx.Multiply (V.X());
1523   Vy.Multiply (V.Y());
1524   Vx.Add(Vy);
1525   return gp_Dir (Vx);
1526 }
1527
1528 //=======================================================================
1529 //function : To3d
1530 //purpose  : 
1531 //=======================================================================
1532
1533 gp_Vec ElCLib::To3d (const gp_Ax2& Pos, const gp_Vec2d& V)
1534 {
1535   gp_Vec Vx = Pos.XDirection();
1536   gp_Vec Vy = Pos.YDirection();
1537   Vx.Multiply (V.X());
1538   Vy.Multiply (V.Y());
1539   Vx.Add(Vy);
1540   return Vx;
1541 }
1542
1543 //=======================================================================
1544 //function : To3d
1545 //purpose  : 
1546 //=======================================================================
1547
1548 gp_Ax1 ElCLib::To3d (const gp_Ax2& Pos, const gp_Ax2d& A)
1549 {
1550   gp_Pnt P  = ElCLib::To3d (Pos, A.Location());
1551   gp_Vec V  = ElCLib::To3d (Pos, A.Direction());
1552   return gp_Ax1 (P, V);
1553 }
1554
1555 //=======================================================================
1556 //function : To3d
1557 //purpose  : 
1558 //=======================================================================
1559
1560 gp_Ax2 ElCLib::To3d (const gp_Ax2& Pos, const gp_Ax22d& A)
1561 {
1562   gp_Pnt P  = ElCLib::To3d (Pos, A.Location());
1563   gp_Vec VX = ElCLib::To3d (Pos, A.XDirection());
1564   gp_Vec VY = ElCLib::To3d (Pos, A.YDirection());
1565   return gp_Ax2 (P, VX.Crossed(VY), VX);
1566 }
1567
1568 //=======================================================================
1569 //function : To3d
1570 //purpose  : 
1571 //=======================================================================
1572
1573 gp_Lin ElCLib::To3d (const gp_Ax2& Pos, const gp_Lin2d& L)
1574 {
1575   return gp_Lin (ElCLib::To3d (Pos, L.Position()));
1576 }
1577
1578 //=======================================================================
1579 //function : To3d
1580 //purpose  : 
1581 //=======================================================================
1582
1583 gp_Circ ElCLib::To3d (const gp_Ax2& Pos, const gp_Circ2d& C)
1584 {
1585   return gp_Circ (ElCLib::To3d (Pos, C.Axis()), C.Radius());
1586 }
1587
1588 //=======================================================================
1589 //function : To3d
1590 //purpose  : 
1591 //=======================================================================
1592
1593 gp_Elips ElCLib::To3d (const gp_Ax2& Pos, const gp_Elips2d& E)
1594 {
1595   return gp_Elips (ElCLib::To3d (Pos, E.Axis ()), E.MajorRadius (),
1596                    E.MinorRadius ());
1597 }
1598
1599 //=======================================================================
1600 //function : To3d
1601 //purpose  : 
1602 //=======================================================================
1603
1604 gp_Hypr ElCLib::To3d (const gp_Ax2& Pos, const gp_Hypr2d& H)
1605 {
1606   return gp_Hypr (ElCLib::To3d (Pos, H.Axis ()), H.MajorRadius (),
1607                   H.MinorRadius ());
1608 }
1609
1610 //=======================================================================
1611 //function : To3d
1612 //purpose  : 
1613 //=======================================================================
1614
1615 gp_Parab ElCLib::To3d (const gp_Ax2& Pos, const gp_Parab2d& Prb)
1616 {
1617   return gp_Parab ( ElCLib::To3d (Pos, Prb.Axis ()), Prb.Focal ());
1618 }
1619