0024002: Overall code and build procedure refactoring -- automatic
[occt.git] / src / Adaptor3d / Adaptor3d_SurfaceOfRevolution.cxx
1 // Created on: 1993-04-21
2 // Created by: Bruno DUMORTIER
3 // Copyright (c) 1993-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
18 #include <Adaptor3d_HCurve.hxx>
19 #include <Adaptor3d_HSurface.hxx>
20 #include <Adaptor3d_HSurfaceOfRevolution.hxx>
21 #include <Adaptor3d_SurfaceOfRevolution.hxx>
22 #include <ElCLib.hxx>
23 #include <Geom_BezierSurface.hxx>
24 #include <Geom_BSplineSurface.hxx>
25 #include <gp_Ax1.hxx>
26 #include <gp_Ax3.hxx>
27 #include <gp_Cone.hxx>
28 #include <gp_Cylinder.hxx>
29 #include <gp_Dir.hxx>
30 #include <gp_Pln.hxx>
31 #include <gp_Pnt.hxx>
32 #include <gp_Sphere.hxx>
33 #include <gp_Torus.hxx>
34 #include <gp_Vec.hxx>
35 #include <Precision.hxx>
36 #include <Standard_ConstructionError.hxx>
37 #include <Standard_DomainError.hxx>
38 #include <Standard_NoSuchObject.hxx>
39 #include <Standard_OutOfRange.hxx>
40
41 //=======================================================================
42 //function : Adaptor3d_SurfaceOfRevolution
43 //purpose  : 
44 //=======================================================================
45 Adaptor3d_SurfaceOfRevolution::Adaptor3d_SurfaceOfRevolution()
46 :myHaveAxis(Standard_False)
47 {}
48
49 //=======================================================================
50 //function : Adaptor3d_SurfaceOfRevolution
51 //purpose  : 
52 //=======================================================================
53
54 Adaptor3d_SurfaceOfRevolution::Adaptor3d_SurfaceOfRevolution
55 (const Handle(Adaptor3d_HCurve)& C)
56 :myHaveAxis(Standard_False)
57 {
58   Load( C);
59 }
60
61 //=======================================================================
62 //function : Adaptor3d_SurfaceOfRevolution
63 //purpose  : 
64 //=======================================================================
65
66 Adaptor3d_SurfaceOfRevolution::Adaptor3d_SurfaceOfRevolution
67 (const Handle(Adaptor3d_HCurve)& C,
68  const gp_Ax1&        V)
69 :myHaveAxis(Standard_False)
70 {
71   Load( C);
72   Load( V);
73 }
74
75 //=======================================================================
76 //function : Load
77 //purpose  : 
78 //=======================================================================
79
80 void Adaptor3d_SurfaceOfRevolution::Load( const Handle(Adaptor3d_HCurve)& C)
81 {
82   myBasisCurve = C;
83   if ( myHaveAxis)  Load(myAxis); // to evaluate the new myAxeRev.
84 }
85
86 //=======================================================================
87 //function : Load
88 //purpose  : 
89 //=======================================================================
90
91 void Adaptor3d_SurfaceOfRevolution::Load( const gp_Ax1& V)
92 {
93   myHaveAxis = Standard_True;
94   myAxis = V;
95   
96   // Eval myAxeRev : axe of revolution ( Determination de Ox).
97   gp_Pnt P,Q;
98   gp_Pnt O = myAxis.Location();
99   gp_Dir Ox;
100   gp_Dir Oz = myAxis.Direction();
101   Standard_Boolean yrev = Standard_False;
102   if (myBasisCurve->GetType() == GeomAbs_Line) {
103     if((myBasisCurve->Line().Direction()).Dot(Oz) < 0.){
104       yrev = Standard_True;
105       Oz.Reverse();
106     }
107   }
108
109   if (myBasisCurve->GetType() == GeomAbs_Circle) {
110     Q = P = (myBasisCurve->Circle()).Location();
111   }
112   else {
113     Standard_Real First = myBasisCurve->FirstParameter();
114     P = Value( 0., 0.);// ce qui ne veut pas dire grand chose
115     if ( GetType() == GeomAbs_Cone) {
116       if ( gp_Lin(myAxis).Distance(P) <= Precision::Confusion())
117         Q = ElCLib::Value(1.,myBasisCurve->Line());
118       else 
119         Q = P;
120     }
121     else if (Precision::IsInfinite(First))
122       Q = P; 
123     else 
124       Q = Value( 0., First);
125   }
126   
127   gp_Dir DZ = myAxis.Direction();
128   O.SetXYZ( O.XYZ() + ( gp_Vec(O,P) * DZ) * DZ.XYZ());
129   if ( gp_Lin(myAxis).Distance(Q) > Precision::Confusion()) {
130     Ox = gp_Dir(Q.XYZ() - O.XYZ());
131   }
132   else {
133     Standard_Real First = myBasisCurve->FirstParameter();
134     Standard_Real Last  = myBasisCurve->LastParameter();
135     Standard_Integer Ratio = 1;
136     Standard_Real Dist; 
137     gp_Pnt PP;
138     do {
139       PP = myBasisCurve->Value(First+(Last-First)/Ratio);
140       Dist = gp_Lin(myAxis).Distance(PP);
141       Ratio++;
142     }
143     while ( Dist < Precision::Confusion() && Ratio < 100);
144
145     if ( Ratio >= 100 ) {
146       Standard_ConstructionError::Raise
147         ("Adaptor3d_SurfaceOfRevolution : Axe and meridian are confused");
148     }
149     Ox = ( (Oz^gp_Vec(PP.XYZ()-O.XYZ()))^Oz); 
150   }
151
152   myAxeRev = gp_Ax3(O,Oz,Ox);
153
154   if (yrev) {
155     myAxeRev.YReverse();
156   }
157   else if (myBasisCurve->GetType() == GeomAbs_Circle) {
158     gp_Dir DC = (myBasisCurve->Circle()).Axis().Direction();
159     if ((Ox.Crossed(Oz)).Dot(DC) < 0.)  myAxeRev.ZReverse(); 
160   }
161 }
162
163 //=======================================================================
164 //function : AxeOfRevolution
165 //purpose  : 
166 //=======================================================================
167
168 gp_Ax1 Adaptor3d_SurfaceOfRevolution::AxeOfRevolution() const
169 {
170   return myAxis;
171 }
172
173 //=======================================================================
174 //function : FirstUParameter
175 //purpose  : 
176 //=======================================================================
177
178 Standard_Real Adaptor3d_SurfaceOfRevolution::FirstUParameter() const 
179 {
180   return 0.;
181 }
182
183 //=======================================================================
184 //function : LastUParameter
185 //purpose  : 
186 //=======================================================================
187
188 Standard_Real Adaptor3d_SurfaceOfRevolution::LastUParameter() const 
189 {
190   return 2*M_PI;
191 }
192
193 //=======================================================================
194 //function : FirstVParameter
195 //purpose  : 
196 //=======================================================================
197
198 Standard_Real Adaptor3d_SurfaceOfRevolution::FirstVParameter() const 
199 {
200   return myBasisCurve->FirstParameter();
201 }
202
203 //=======================================================================
204 //function : LastVParameter
205 //purpose  : 
206 //=======================================================================
207
208 Standard_Real Adaptor3d_SurfaceOfRevolution::LastVParameter() const 
209 {
210   return myBasisCurve->LastParameter();
211 }
212
213 //=======================================================================
214 //function : UContinuity
215 //purpose  : 
216 //=======================================================================
217
218 GeomAbs_Shape Adaptor3d_SurfaceOfRevolution::UContinuity() const 
219 {
220   return GeomAbs_CN;
221 }
222
223 //=======================================================================
224 //function : VContinuity
225 //purpose  : 
226 //=======================================================================
227
228 GeomAbs_Shape Adaptor3d_SurfaceOfRevolution::VContinuity() const 
229 {
230   return myBasisCurve->Continuity();
231 }
232
233 //=======================================================================
234 //function : NbUIntervals
235 //purpose  : 
236 //=======================================================================
237
238 Standard_Integer Adaptor3d_SurfaceOfRevolution::NbUIntervals
239 //(const GeomAbs_Shape S) const
240 (const GeomAbs_Shape ) const
241 {
242   return 1;
243 }
244
245 //=======================================================================
246 //function : NbVIntervals
247 //purpose  : 
248 //=======================================================================
249
250 Standard_Integer Adaptor3d_SurfaceOfRevolution::NbVIntervals
251 ( const GeomAbs_Shape S) const 
252 {
253   return myBasisCurve->NbIntervals(S);
254 }
255
256 //=======================================================================
257 //function : UIntervals
258 //purpose  : 
259 //=======================================================================
260
261 void Adaptor3d_SurfaceOfRevolution::UIntervals (TColStd_Array1OfReal& T,
262 //                                            const GeomAbs_Shape S) const 
263                                               const GeomAbs_Shape ) const 
264 {
265   T(T.Lower()  ) = 0.;
266   T(T.Lower()+1) = 2*M_PI;
267 }
268
269
270 //=======================================================================
271 //function : VIntervals
272 //purpose  : 
273 //=======================================================================
274
275 void Adaptor3d_SurfaceOfRevolution::VIntervals(TColStd_Array1OfReal& T,
276                                              const GeomAbs_Shape S) const 
277 {
278   myBasisCurve->Intervals(T,S);
279 }
280
281
282 //=======================================================================
283 //function : UTrim
284 //purpose  : 
285 //=======================================================================
286
287 Handle(Adaptor3d_HSurface) Adaptor3d_SurfaceOfRevolution::UTrim
288 (const Standard_Real 
289 #ifndef No_Exception
290                      First
291 #endif
292  ,const Standard_Real 
293 #ifndef No_Exception
294                      Last
295 #endif
296  ,const Standard_Real 
297                          ) const 
298 {
299 #ifndef No_Exception
300   Standard_Real Eps = Precision::PConfusion();
301 #endif
302   Standard_OutOfRange_Raise_if
303     (  Abs(First) > Eps || Abs(Last - 2.*M_PI) > Eps,
304      "Adaptor3d_SurfaceOfRevolution : UTrim : Parameters out of range");
305
306   Handle(Adaptor3d_HSurfaceOfRevolution) HR =
307     new Adaptor3d_HSurfaceOfRevolution(*this);
308   return HR;
309 }
310
311
312 //=======================================================================
313 //function : VTrim
314 //purpose  : 
315 //=======================================================================
316
317 Handle(Adaptor3d_HSurface) Adaptor3d_SurfaceOfRevolution::VTrim
318 (const Standard_Real First,
319  const Standard_Real Last,
320  const Standard_Real Tol) const 
321 {
322   Handle(Adaptor3d_HSurfaceOfRevolution) HR =
323     new Adaptor3d_HSurfaceOfRevolution(*this);
324   Handle(Adaptor3d_HCurve) HC = BasisCurve()->Trim(First,Last,Tol);
325   HR->ChangeSurface().
326 Load(HC);
327   return HR;
328 }
329
330
331 //=======================================================================
332 //function : IsUClosed
333 //purpose  : 
334 //=======================================================================
335
336 Standard_Boolean Adaptor3d_SurfaceOfRevolution::IsUClosed() const 
337 {
338   return Standard_True;
339 }
340
341 //=======================================================================
342 //function : IsVClosed
343 //purpose  : 
344 //=======================================================================
345
346 Standard_Boolean Adaptor3d_SurfaceOfRevolution::IsVClosed() const 
347 {
348   return myBasisCurve->IsClosed();
349 }
350
351 //=======================================================================
352 //function : IsUPeriodic
353 //purpose  : 
354 //=======================================================================
355
356 Standard_Boolean Adaptor3d_SurfaceOfRevolution::IsUPeriodic() const
357 {
358   return Standard_True;
359 }
360
361 //=======================================================================
362 //function : UPeriod
363 //purpose  : 
364 //=======================================================================
365
366 Standard_Real Adaptor3d_SurfaceOfRevolution::UPeriod() const
367 {
368   return 2*M_PI;
369 }
370
371 //=======================================================================
372 //function : IsVPeriodic
373 //purpose  : 
374 //=======================================================================
375
376 Standard_Boolean Adaptor3d_SurfaceOfRevolution::IsVPeriodic() const
377 {
378   return myBasisCurve->IsPeriodic();
379 }
380
381 //=======================================================================
382 //function : VPeriod
383 //purpose  : 
384 //=======================================================================
385
386 Standard_Real Adaptor3d_SurfaceOfRevolution::VPeriod() const 
387 {
388   return myBasisCurve->Period();
389 }
390
391 //=======================================================================
392 //function : Value
393 //purpose  : 
394 //=======================================================================
395
396 gp_Pnt Adaptor3d_SurfaceOfRevolution::Value(const Standard_Real U, 
397                                           const Standard_Real V) const
398 {
399   gp_Pnt P;
400   myBasisCurve->D0(V,P);
401   P.Rotate( myAxis, U);
402   return P;
403 }
404
405 //=======================================================================
406 //function : D0
407 //purpose  : 
408 //=======================================================================
409
410 void Adaptor3d_SurfaceOfRevolution::D0(const Standard_Real U,
411                                      const Standard_Real V,
412                                            gp_Pnt&       P) const
413 {
414   myBasisCurve->D0(V,P);
415   P.Rotate( myAxis, U);
416 }
417
418 //=======================================================================
419 //function : D1
420 //purpose  : 
421 //=======================================================================
422
423 void Adaptor3d_SurfaceOfRevolution::D1(const Standard_Real U, 
424                                      const Standard_Real V, 
425                                      gp_Pnt& P, gp_Vec& D1U,
426                                      gp_Vec& D1V) const 
427 {
428   myBasisCurve->D1(V,P,D1V);
429   Standard_Real R = gp_Vec(myAxeRev.Location(), P) * myAxeRev.XDirection();
430   
431   D0( U,V,P);
432   D1V.Rotate( myAxis, U);
433   D1U = R*(myAxeRev.YDirection());
434   D1U.Rotate( myAxis, U);
435 }
436
437 //=======================================================================
438 //function : D2
439 //purpose  : 
440 //=======================================================================
441
442 void Adaptor3d_SurfaceOfRevolution::D2(const Standard_Real U, 
443                                      const Standard_Real V,
444                                      gp_Pnt& P, gp_Vec& D1U, 
445                                      gp_Vec& D1V,
446                                      gp_Vec& D2U, gp_Vec& D2V,
447                                      gp_Vec& D2UV) const
448 {
449   myBasisCurve->D2(V,P,D1V,D2V);
450
451   gp_Vec D1 = (myAxeRev.YDirection()).Rotated( myAxis, U);
452   gp_Vec D2 = (myAxeRev.XDirection()).Rotated( myAxis, U);
453
454   Standard_Real R   = gp_Vec(myAxeRev.Location(), P) * myAxeRev.XDirection();
455   Standard_Real D1R = D1V * myAxeRev.XDirection(); // D1R = dR/dV 
456                                                    // et R=AP*XDirection
457
458   D0( U,V,P);
459   D1V.Rotate( myAxis, U);
460   D2V.Rotate( myAxis, U);
461   D1U  =   R * D1;
462   D2U  =  -R * D2;
463   D2UV = D1R * D1;
464 }
465
466 //=======================================================================
467 //function : D3
468 //purpose  : 
469 //=======================================================================
470
471 void Adaptor3d_SurfaceOfRevolution::D3(const Standard_Real U, 
472                                      const Standard_Real V,
473                                      gp_Pnt& P,gp_Vec& D1U, gp_Vec& D1V,
474                                      gp_Vec& D2U, gp_Vec& D2V, gp_Vec& D2UV,
475                                      gp_Vec& D3U, gp_Vec& D3V, gp_Vec& D3UUV,
476                                      gp_Vec& D3UVV) const
477 {
478   myBasisCurve->D3(V,P,D1V,D2V,D3V);
479   
480   gp_Vec D1 = (myAxeRev.YDirection()).Rotated( myAxis, U);
481   gp_Vec D2 = (myAxeRev.XDirection()).Rotated( myAxis, U);
482
483   Standard_Real R   = gp_Vec(myAxeRev.Location(), P) * myAxeRev.XDirection();
484   Standard_Real D1R = D1V * myAxeRev.XDirection();  // D1R = dR/dV et
485                                                     // R=AP*XDirection
486   Standard_Real D2R = D2V * myAxeRev.XDirection();
487
488   D0( U,V,P);
489   D1V.Rotate( myAxis, U);
490   D2V.Rotate( myAxis, U);
491   D3V.Rotate( myAxis, U);
492   D1U   =    R * D1;
493   D2U   =   -R * D2;
494   D3U   =   -R * D1;
495   D2UV  =  D1R * D1;
496   D3UUV = -D1R * D2;
497   D3UVV =  D2R * D1;
498 }
499
500 //=======================================================================
501 //function : DN
502 //purpose  : 
503 //=======================================================================
504
505 gp_Vec Adaptor3d_SurfaceOfRevolution::DN(const Standard_Real    U,
506                                        const Standard_Real    V,
507                                        const Standard_Integer NU,
508                                        const Standard_Integer NV) const 
509 {
510   if ( (NU+NV)<1 || NU<0 || NV<0) {
511     Standard_DomainError::Raise("Adaptor3d_SurfaceOfRevolution::DN");
512   }
513   else {
514     gp_Vec DNv = myBasisCurve->DN( V, NV);
515     if ( NU == 0) {
516       return DNv.Rotated( myAxis, U);
517     }
518     else {
519       Standard_Real DNR = DNv * myAxeRev.XDirection();
520       gp_Vec DNu = ( myAxeRev.XDirection()).Rotated( myAxis, U + NU*M_PI/2);
521       return ( DNR * DNu);
522     }
523   }   
524   // portage WNT
525   return gp_Vec();
526 }
527
528 //=======================================================================
529 //function : UResolution
530 //purpose  : 
531 //=======================================================================
532
533 Standard_Real Adaptor3d_SurfaceOfRevolution::UResolution
534 (const Standard_Real R3d) const 
535 {
536   return Precision::Parametric(R3d);
537 }
538
539 //=======================================================================
540 //function : VResolution
541 //purpose  : 
542 //=======================================================================
543
544 Standard_Real Adaptor3d_SurfaceOfRevolution::VResolution
545 (const Standard_Real R3d) const 
546 {
547   return myBasisCurve->Resolution(R3d);
548 }
549
550 //=======================================================================
551 //function : GetType
552 //purpose  : 
553 //=======================================================================
554
555 GeomAbs_SurfaceType Adaptor3d_SurfaceOfRevolution::GetType() const 
556 {
557   Standard_Real TolConf, TolAng;
558   GeomAbs_SurfaceType bRet;
559   //
560   bRet=GeomAbs_SurfaceOfRevolution;
561   TolConf = Precision::Confusion();
562   TolAng  = Precision::Angular();
563   //
564   switch ( myBasisCurve->GetType()) {
565   case GeomAbs_Line:    {
566     const gp_Ax1& Axe = (myBasisCurve->Line()).Position();
567     
568     if (myAxis.IsParallel(Axe, TolAng)) {
569       bRet=GeomAbs_Cylinder;
570       return bRet;
571     }
572     else if (myAxis.IsNormal( Axe, TolAng)) {
573       bRet=GeomAbs_Plane;
574       return bRet;
575     }
576     else {
577       Standard_Real uf = myBasisCurve->FirstParameter();
578       Standard_Real ul = myBasisCurve->LastParameter();
579       Standard_Boolean istrim = (!Precision::IsInfinite(uf) && 
580                                  !Precision::IsInfinite(ul));
581       if(istrim){
582         gp_Pnt pf = myBasisCurve->Value(uf);
583         gp_Pnt pl = myBasisCurve->Value(ul);
584         Standard_Real len = pf.Distance(pl);
585         //on calcule la distance projetee sur l axe.
586         gp_Vec vlin(pf,pl);
587         gp_Vec vaxe(myAxis.Direction());
588         Standard_Real projlen = Abs(vaxe.Dot(vlin));
589         Standard_Real aTolConf = len*TolAng;
590         if ((len - projlen) <= aTolConf) {
591           bRet=GeomAbs_Cylinder;
592           return bRet;
593         }
594         else if (projlen <= aTolConf) {
595           bRet=GeomAbs_Plane;
596           return bRet;
597         }
598       }
599       gp_Vec V(myAxis.Location(),
600                myBasisCurve->Line().Location());
601       gp_Vec W(Axe.Direction());
602       if (Abs(V.DotCross(myAxis.Direction(),W)) <= TolConf){
603         bRet=GeomAbs_Cone;
604         return bRet;
605       }
606       else {
607         return bRet;
608       }
609     }
610   }//case GeomAbs_Line: 
611   //  
612   case GeomAbs_Circle:   {
613     
614     Standard_Real MajorRadius, aR;
615     gp_Lin aLin(myAxis);
616     //
617     const gp_Circ& C=myBasisCurve->Circle();
618     const gp_Pnt& aLC=C.Location();
619     aR=C.Radius();
620     //
621    
622     if (!C.Position().IsCoplanar(myAxis, TolConf, TolAng)) {
623       return bRet;
624     }
625     else if(aLin.Distance(aLC) <= TolConf) {
626       bRet=GeomAbs_Sphere;
627       return bRet;
628     }
629     else {
630       MajorRadius = aLin.Distance(aLC);
631       if(MajorRadius>aR) {
632         //modified by NIZNHY-PKV Thu Feb 24 09:46:29 2011f
633         Standard_Real aT, aDx, dX;
634         gp_Pnt aPx;
635         //
636         aT=0.;
637         aPx=ElCLib::Value(aT, C);
638         aDx=aLin.Distance(aPx);
639         dX=aDx-MajorRadius-aR;
640         if (dX<0.) {
641           dX=-dX;
642         }
643         if (dX<TolConf) {
644           bRet=GeomAbs_Torus;
645         }
646         //bRet=GeomAbs_Torus;
647         //return bRet;
648         //modified by NIZNHY-PKV Thu Feb 24 09:52:29 2011t
649       }
650       return bRet;
651     }
652   }
653   //  
654   default:
655     break;
656   }
657   
658   return bRet;
659 }
660
661 //=======================================================================
662 //function : Plane
663 //purpose  : 
664 //=======================================================================
665
666 gp_Pln Adaptor3d_SurfaceOfRevolution::Plane() const 
667
668   Standard_NoSuchObject_Raise_if
669     (GetType() != GeomAbs_Plane, "Adaptor3d_SurfaceOfRevolution:Plane");
670
671   gp_Ax3 Axe = myAxeRev;
672   gp_Pnt P;
673   
674   // P = Projection du Point Debut de la generatrice sur l axe de rotation.
675   P.SetXYZ((myAxis.Location()).XYZ() +
676            (Value(0.,0.).XYZ()-(myAxis.Location()).XYZ()).
677            Dot((myAxis.Direction()).XYZ())
678            *(myAxis.Direction()).XYZ());
679   Axe.SetLocation( P);
680   //// modified by jgv, 8.01.03 for OCC1226 ////
681   if (Axe.XDirection().
682       Dot(myBasisCurve->Line().Direction()) >= -Precision::Confusion()) // > 0.
683     Axe.XReverse();
684   //////////////////////////////////////////////
685
686   return gp_Pln( Axe);
687 }
688
689 //=======================================================================
690 //function : Cylinder
691 //purpose  : 
692 //=======================================================================
693
694 gp_Cylinder Adaptor3d_SurfaceOfRevolution::Cylinder() const
695 {
696   Standard_NoSuchObject_Raise_if
697     (GetType() != GeomAbs_Cylinder, "Adaptor3d_SurfaceOfRevolution::Cylinder");
698
699   gp_Pnt P = Value( 0., 0.);
700   Standard_Real R   = gp_Vec(myAxeRev.Location(), P) * myAxeRev.XDirection();
701   return gp_Cylinder( myAxeRev, R);
702 }
703
704 //=======================================================================
705 //function : Cone
706 //purpose  : 
707 //=======================================================================
708
709 gp_Cone Adaptor3d_SurfaceOfRevolution::Cone() const
710 {
711   Standard_NoSuchObject_Raise_if
712     ( GetType() != GeomAbs_Cone, "Adaptor3d_SurfaceOfRevolution:Cone");
713
714   gp_Ax3 Axe = myAxeRev;
715   gp_Dir ldir = (myBasisCurve->Line()).Direction();
716   Standard_Real Angle = (Axe.Direction()).Angle(ldir);
717   gp_Pnt P0 = Value(0., 0.);
718   Standard_Real R = (Axe.Location()).Distance(P0);
719   if ( R >= Precision::Confusion()) {
720     gp_Pnt O = Axe.Location();
721     gp_Vec OP0(O,P0);
722     Standard_Real t = OP0.Dot(Axe.XDirection());
723     t /= ldir.Dot(Axe.XDirection());
724     OP0.Add(-t * gp_Vec(ldir));
725     if ( OP0.Dot(Axe.Direction()) > 0.) Angle = -Angle;
726   }
727   return gp_Cone( Axe, Angle, R);
728 }
729
730
731 //=======================================================================
732 //function : Sphere
733 //purpose  : 
734 //=======================================================================
735
736 gp_Sphere Adaptor3d_SurfaceOfRevolution::Sphere() const 
737 {
738   Standard_NoSuchObject_Raise_if
739     ( GetType() != GeomAbs_Sphere, "Adaptor3d_SurfaceOfRevolution:Sphere");
740
741   gp_Circ C = myBasisCurve->Circle();
742   gp_Ax3 Axe = myAxeRev;
743   Axe.SetLocation( C.Location());
744   return gp_Sphere( Axe, C.Radius());
745 }
746
747
748 //=======================================================================
749 //function : Torus
750 //purpose  : 
751 //=======================================================================
752
753 gp_Torus Adaptor3d_SurfaceOfRevolution::Torus() const 
754 {
755   Standard_NoSuchObject_Raise_if
756     (GetType() != GeomAbs_Torus, "Adaptor3d_SurfaceOfRevolution:Torus");
757
758   gp_Circ C = myBasisCurve->Circle();
759   Standard_Real MajorRadius = gp_Lin(myAxis).Distance(C.Location());
760   return gp_Torus( myAxeRev, MajorRadius, C.Radius());
761 }
762
763 //=======================================================================
764 //function : UDegree
765 //purpose  : 
766 //=======================================================================
767
768 Standard_Integer Adaptor3d_SurfaceOfRevolution::UDegree() const 
769 {
770   Standard_NoSuchObject::Raise("Adaptor3d_SurfaceOfRevolution::UDegree");
771   return 0;
772 }
773
774 //=======================================================================
775 //function : NbUPoles
776 //purpose  : 
777 //=======================================================================
778
779 Standard_Integer Adaptor3d_SurfaceOfRevolution::NbUPoles() const 
780 {
781   Standard_NoSuchObject::Raise("Adaptor3d_SurfaceOfRevolution::NbUPoles");
782   return 0;
783 }
784
785 //=======================================================================
786 //function : VDegree
787 //purpose  : 
788 //=======================================================================
789
790 Standard_Integer Adaptor3d_SurfaceOfRevolution::VDegree() const 
791 {
792   return myBasisCurve->Degree();
793 }
794
795 //=======================================================================
796 //function : NbVPoles
797 //purpose  : 
798 //=======================================================================
799
800 Standard_Integer Adaptor3d_SurfaceOfRevolution::NbVPoles() const
801 {
802   return myBasisCurve -> NbPoles();
803 }
804
805 //=======================================================================
806 //function : NbUKnots
807 //purpose  : 
808 //=======================================================================
809
810 Standard_Integer Adaptor3d_SurfaceOfRevolution::NbUKnots() const 
811 {
812   Standard_NoSuchObject::Raise("Adaptor3d_SurfaceOfRevolution::NbUKnots");
813   return 0;
814 }
815
816
817 //=======================================================================
818 //function : NbVKnots
819 //purpose  : 
820 //=======================================================================
821
822 Standard_Integer Adaptor3d_SurfaceOfRevolution::NbVKnots() const 
823 {
824   Standard_NoSuchObject::Raise("Adaptor3d_SurfaceOfRevolution::NbVKnots");
825   return 0;
826 }
827
828
829
830 //=======================================================================
831 //function : IsURational
832 //purpose  : 
833 //=======================================================================
834
835 Standard_Boolean Adaptor3d_SurfaceOfRevolution::IsURational() const 
836 {
837   Standard_NoSuchObject::Raise("Adaptor3d_SurfaceOfRevolution::IsURational");
838   return Standard_False;
839 }
840
841 //=======================================================================
842 //function : IsVRational
843 //purpose  : 
844 //=======================================================================
845
846 Standard_Boolean Adaptor3d_SurfaceOfRevolution::IsVRational() const 
847 {
848   Standard_NoSuchObject::Raise("Adaptor3d_SurfaceOfRevolution::IsVRational");
849   return Standard_False;
850 }
851
852
853 //=======================================================================
854 //function : Bezier
855 //purpose  : 
856 //=======================================================================
857
858 Handle(Geom_BezierSurface) Adaptor3d_SurfaceOfRevolution::Bezier() const 
859 {
860   Standard_NoSuchObject::Raise("");
861   Handle(Geom_BezierSurface) Dummy;
862   return Dummy;
863 }
864
865
866 //=======================================================================
867 //function : BSpline
868 //purpose  : 
869 //=======================================================================
870
871 Handle(Geom_BSplineSurface) Adaptor3d_SurfaceOfRevolution::BSpline() const 
872 {
873   Standard_NoSuchObject::Raise("");
874   Handle(Geom_BSplineSurface) Dummy;
875   return Dummy;
876 }
877
878
879 //=======================================================================
880 //function : Axis
881 //purpose  : 
882 //=======================================================================
883
884 gp_Ax3 Adaptor3d_SurfaceOfRevolution::Axis() const 
885 {
886   return myAxeRev;
887 }
888
889 //=======================================================================
890 //function : Direction
891 //purpose  : 
892 //=======================================================================
893
894 gp_Dir Adaptor3d_SurfaceOfRevolution::Direction() const 
895 {
896   Standard_NoSuchObject::Raise("");
897   return gp_Dir();
898 }
899
900
901 //=======================================================================
902 //function : BasisCurve
903 //purpose  : 
904 //=======================================================================
905
906 Handle(Adaptor3d_HCurve) Adaptor3d_SurfaceOfRevolution::BasisCurve() const 
907 {
908   return myBasisCurve;
909 }