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