0024428: Implementation of LGPL license
[occt.git] / src / Adaptor3d / Adaptor3d_SurfaceOfRevolution.cxx
CommitLineData
b311480e 1// Created on: 1993-04-21
2// Created by: Bruno DUMORTIER
3// Copyright (c) 1993-1999 Matra Datavision
973c2be1 4// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 5//
973c2be1 6// This file is part of Open CASCADE Technology software library.
b311480e 7//
973c2be1 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.
b311480e 13//
973c2be1 14// Alternatively, this file may be used under the terms of Open CASCADE
15// commercial license or contractual agreement.
7fd59977 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
29Adaptor3d_SurfaceOfRevolution::Adaptor3d_SurfaceOfRevolution()
30:myHaveAxis(Standard_False)
31{}
32
33//=======================================================================
34//function : Adaptor3d_SurfaceOfRevolution
35//purpose :
36//=======================================================================
37
38Adaptor3d_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
50Adaptor3d_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
64void 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
75void 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
152gp_Ax1 Adaptor3d_SurfaceOfRevolution::AxeOfRevolution() const
153{
154 return myAxis;
155}
156
157//=======================================================================
158//function : FirstUParameter
159//purpose :
160//=======================================================================
161
162Standard_Real Adaptor3d_SurfaceOfRevolution::FirstUParameter() const
163{
164 return 0.;
165}
166
167//=======================================================================
168//function : LastUParameter
169//purpose :
170//=======================================================================
171
172Standard_Real Adaptor3d_SurfaceOfRevolution::LastUParameter() const
173{
c6541a0c 174 return 2*M_PI;
7fd59977 175}
176
177//=======================================================================
178//function : FirstVParameter
179//purpose :
180//=======================================================================
181
182Standard_Real Adaptor3d_SurfaceOfRevolution::FirstVParameter() const
183{
184 return myBasisCurve->FirstParameter();
185}
186
187//=======================================================================
188//function : LastVParameter
189//purpose :
190//=======================================================================
191
192Standard_Real Adaptor3d_SurfaceOfRevolution::LastVParameter() const
193{
194 return myBasisCurve->LastParameter();
195}
196
197//=======================================================================
198//function : UContinuity
199//purpose :
200//=======================================================================
201
202GeomAbs_Shape Adaptor3d_SurfaceOfRevolution::UContinuity() const
203{
204 return GeomAbs_CN;
205}
206
207//=======================================================================
208//function : VContinuity
209//purpose :
210//=======================================================================
211
212GeomAbs_Shape Adaptor3d_SurfaceOfRevolution::VContinuity() const
213{
214 return myBasisCurve->Continuity();
215}
216
217//=======================================================================
218//function : NbUIntervals
219//purpose :
220//=======================================================================
221
222Standard_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
234Standard_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
245void Adaptor3d_SurfaceOfRevolution::UIntervals (TColStd_Array1OfReal& T,
246// const GeomAbs_Shape S) const
247 const GeomAbs_Shape ) const
248{
249 T(T.Lower() ) = 0.;
c6541a0c 250 T(T.Lower()+1) = 2*M_PI;
7fd59977 251}
252
253
254//=======================================================================
255//function : VIntervals
256//purpose :
257//=======================================================================
258
259void 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
271Handle(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
7fd59977 281 ) const
282{
283#ifndef No_Exception
284 Standard_Real Eps = Precision::PConfusion();
285#endif
286 Standard_OutOfRange_Raise_if
c6541a0c 287 ( Abs(First) > Eps || Abs(Last - 2.*M_PI) > Eps,
7fd59977 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
301Handle(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().
310Load(HC);
311 return HR;
312}
313
314
315//=======================================================================
316//function : IsUClosed
317//purpose :
318//=======================================================================
319
320Standard_Boolean Adaptor3d_SurfaceOfRevolution::IsUClosed() const
321{
322 return Standard_True;
323}
324
325//=======================================================================
326//function : IsVClosed
327//purpose :
328//=======================================================================
329
330Standard_Boolean Adaptor3d_SurfaceOfRevolution::IsVClosed() const
331{
332 return myBasisCurve->IsClosed();
333}
334
335//=======================================================================
336//function : IsUPeriodic
337//purpose :
338//=======================================================================
339
340Standard_Boolean Adaptor3d_SurfaceOfRevolution::IsUPeriodic() const
341{
342 return Standard_True;
343}
344
345//=======================================================================
346//function : UPeriod
347//purpose :
348//=======================================================================
349
350Standard_Real Adaptor3d_SurfaceOfRevolution::UPeriod() const
351{
c6541a0c 352 return 2*M_PI;
7fd59977 353}
354
355//=======================================================================
356//function : IsVPeriodic
357//purpose :
358//=======================================================================
359
360Standard_Boolean Adaptor3d_SurfaceOfRevolution::IsVPeriodic() const
361{
362 return myBasisCurve->IsPeriodic();
363}
364
365//=======================================================================
366//function : VPeriod
367//purpose :
368//=======================================================================
369
370Standard_Real Adaptor3d_SurfaceOfRevolution::VPeriod() const
371{
372 return myBasisCurve->Period();
373}
374
375//=======================================================================
376//function : Value
377//purpose :
378//=======================================================================
379
380gp_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
394void 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
407void 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
426void 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
455void 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
489gp_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();
c6541a0c 504 gp_Vec DNu = ( myAxeRev.XDirection()).Rotated( myAxis, U + NU*M_PI/2);
7fd59977 505 return ( DNR * DNu);
506 }
507 }
508 // portage WNT
509 return gp_Vec();
510}
511
512//=======================================================================
513//function : UResolution
514//purpose :
515//=======================================================================
516
517Standard_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
528Standard_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
539GeomAbs_SurfaceType Adaptor3d_SurfaceOfRevolution::GetType() const
540{
bd05fabf
S
541 Standard_Real TolConf, TolAng;
542 GeomAbs_SurfaceType bRet;
543 //
544 bRet=GeomAbs_SurfaceOfRevolution;
545 TolConf = Precision::Confusion();
546 TolAng = Precision::Angular();
547 //
7fd59977 548 switch ( myBasisCurve->GetType()) {
bd05fabf
S
549 case GeomAbs_Line: {
550 const gp_Ax1& Axe = (myBasisCurve->Line()).Position();
7fd59977 551
bd05fabf
S
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;
7fd59977 577 }
bd05fabf
S
578 else if (projlen <= aTolConf) {
579 bRet=GeomAbs_Plane;
580 return bRet;
7fd59977 581 }
582 }
bd05fabf
S
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;
7fd59977 589 }
590 else {
bd05fabf 591 return bRet;
7fd59977 592 }
7fd59977 593 }
bd05fabf
S
594 }//case GeomAbs_Line:
595 //
596 case GeomAbs_Circle: {
7fd59977 597
bd05fabf
S
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 }
bd05fabf
S
636 }
637 //
7fd59977 638 default:
bd05fabf 639 break;
7fd59977 640 }
641
bd05fabf 642 return bRet;
7fd59977 643}
644
645//=======================================================================
646//function : Plane
647//purpose :
648//=======================================================================
649
650gp_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
678gp_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
693gp_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
720gp_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
737gp_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
752Standard_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
763Standard_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
774Standard_Integer Adaptor3d_SurfaceOfRevolution::VDegree() const
775{
776 return myBasisCurve->Degree();
777}
778
779//=======================================================================
780//function : NbVPoles
781//purpose :
782//=======================================================================
783
784Standard_Integer Adaptor3d_SurfaceOfRevolution::NbVPoles() const
785{
786 return myBasisCurve -> NbPoles();
787}
788
789//=======================================================================
790//function : NbUKnots
791//purpose :
792//=======================================================================
793
794Standard_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
806Standard_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
819Standard_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
830Standard_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
842Handle(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
855Handle(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
868gp_Ax3 Adaptor3d_SurfaceOfRevolution::Axis() const
869{
870 return myAxeRev;
871}
872
873//=======================================================================
874//function : Direction
875//purpose :
876//=======================================================================
877
878gp_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
890Handle(Adaptor3d_HCurve) Adaptor3d_SurfaceOfRevolution::BasisCurve() const
891{
892 return myBasisCurve;
893}