0024510: Remove unused local variables
[occt.git] / src / BRepSweep / BRepSweep_Rotation.cxx
1 // Created on: 1993-02-15
2 // Created by: Laurent BOURESCHE
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 <BRepSweep_Rotation.ixx>
18 #include <BRepTools_Quilt.hxx>
19 #include <BRepAdaptor_Curve.hxx>
20 #include <BRepAdaptor_Surface.hxx>
21 #include <BRep_Tool.hxx>
22 #include <BRepTools.hxx>
23 #include <TopoDS.hxx>
24 #include <TopoDS_Shape.hxx>
25 #include <TopoDS_Vertex.hxx>
26 #include <TopExp.hxx>
27 #include <ElSLib.hxx>
28 #include <ElCLib.hxx>
29 #include <GeomAdaptor_Curve.hxx>
30 #include <GeomAdaptor_Surface.hxx>
31 #include <Adaptor3d_SurfaceOfRevolution.hxx>
32 #include <Geom_SurfaceOfRevolution.hxx>
33 #include <Geom_CylindricalSurface.hxx>
34 #include <Geom_ConicalSurface.hxx>
35 #include <Geom_SphericalSurface.hxx>
36 #include <Geom_ToroidalSurface.hxx>
37 #include <Geom_Plane.hxx>
38 #include <Geom_Circle.hxx>
39 #include <Geom_Line.hxx>
40 #include <Geom2d_Circle.hxx>
41 #include <Geom2d_Line.hxx>
42 #include <gp.hxx>
43 #include <gp_Trsf.hxx>
44 #include <gp_Circ2d.hxx>
45 #include <gp_Dir.hxx>
46 #include <gp_Dir2d.hxx>
47 #include <gp_Lin.hxx>
48 #include <gp_Lin2d.hxx>
49 #include <gp_Pnt.hxx>
50 #include <gp_Pnt2d.hxx>
51 #include <gp_Ax22d.hxx>
52 #include <gp_Cylinder.hxx>
53 #include <gp_Pln.hxx>
54 #include <gp_Cone.hxx>
55 #include <gp_Sphere.hxx>
56 #include <gp_Torus.hxx>
57 #include <gp_Ax3.hxx>
58 #include <Precision.hxx>
59 #include <Standard_ConstructionError.hxx>
60
61 #include <GeomAdaptor_HCurve.hxx>
62 #include <Geom_TrimmedCurve.hxx>
63
64 static Standard_Real ComputeTolerance(TopoDS_Edge& E,
65                                       const TopoDS_Face& F,
66                                       const Handle(Geom2d_Curve)& C)
67
68 {
69   if(BRep_Tool::Degenerated(E)) return BRep_Tool::Tolerance(E);
70
71   Standard_Real first,last;
72   
73   Handle(Geom_Surface) surf = BRep_Tool::Surface(F);
74   Handle(Geom_Curve)   c3d  = BRep_Tool::Curve(E,first,last);
75   
76   Standard_Real d2 = 0.;
77   Standard_Integer nn = 23;
78   Standard_Real unsurnn = 1./nn;
79   for(Standard_Integer i = 0; i <= nn; i++){
80     Standard_Real t = unsurnn*i;
81     Standard_Real u = first*(1.-t) + last*t;
82     gp_Pnt Pc3d  = c3d->Value(u);
83     gp_Pnt2d UV  = C->Value(u);
84     gp_Pnt Pcons = surf->Value(UV.X(),UV.Y());
85     if (Precision::IsInfinite(Pcons.X()) ||
86         Precision::IsInfinite(Pcons.Y()) ||
87         Precision::IsInfinite(Pcons.Z())) {
88       d2=Precision::Infinite();
89       break;
90     }
91     Standard_Real temp = Pc3d.SquareDistance(Pcons);
92     if(temp > d2) d2 = temp;
93   }
94   d2 = 1.5*sqrt(d2);
95   if(d2<1.e-7) d2 = 1.e-7;
96   return d2;
97 }
98
99 static void SetThePCurve(const BRep_Builder& B,
100                          TopoDS_Edge& E,
101                          const TopoDS_Face& F,
102                          const TopAbs_Orientation O,
103                          const Handle(Geom2d_Curve)& C)
104 {
105   // check if there is already a pcurve
106   Standard_Real f,l;
107   Handle(Geom2d_Curve) OC;
108   TopLoc_Location SL;
109   Handle(Geom_Plane) GP = Handle(Geom_Plane)::DownCast(BRep_Tool::Surface(F,SL));
110   if (GP.IsNull())
111     OC = BRep_Tool::CurveOnSurface(E,F,f,l);
112   if (OC.IsNull()) 
113     B.UpdateEdge(E,C,F,ComputeTolerance(E,F,C));
114   else {
115     if (O == TopAbs_REVERSED) 
116       B.UpdateEdge(E,OC,C,F,ComputeTolerance(E,F,C));
117     else 
118       B.UpdateEdge(E,C,OC,F,ComputeTolerance(E,F,C));
119   }
120 }
121
122 //=======================================================================
123 //function : BRepSweep_Rotation
124 //purpose  : 
125 //=======================================================================
126
127 BRepSweep_Rotation::BRepSweep_Rotation(const TopoDS_Shape& S, 
128                                        const Sweep_NumShape& N,
129                                        const TopLoc_Location& L,
130                                        const gp_Ax1& A,
131                                        const Standard_Real D,
132                                        const Standard_Boolean C):
133        BRepSweep_Trsf(BRep_Builder(),S,N,L,C),
134        myAng(D),
135        myAxe(A)
136      
137 {
138   Standard_ConstructionError_Raise_if(D < Precision::Angular(),
139                                       "BRepSweep_Rotation::Constructor");
140   Init();
141 }
142
143
144 //=======================================================================
145 //function : MakeEmptyVertex
146 //purpose  : 
147 //=======================================================================
148
149 TopoDS_Shape  BRepSweep_Rotation::MakeEmptyVertex
150   (const TopoDS_Shape& aGenV, 
151    const Sweep_NumShape& aDirV)
152 {
153   //call only in construction mode with copy.
154   Standard_ConstructionError_Raise_if
155     (!myCopy,"BRepSweep_Translation::MakeEmptyVertex");
156   gp_Pnt P = BRep_Tool::Pnt(TopoDS::Vertex(aGenV));
157   TopoDS_Vertex V;
158   if (aDirV.Index()==2) P.Transform(myLocation.Transformation());
159   ////// modified by jgv, 1.10.01, for buc61005 //////
160   //myBuilder.Builder().MakeVertex(V,P,Precision::Confusion());
161   myBuilder.Builder().MakeVertex( V, P, BRep_Tool::Tolerance(TopoDS::Vertex(aGenV)) );
162   ////////////////////////////////////////////////////
163   if (aDirV.Index() == 1 && 
164       IsInvariant(aGenV) && 
165       myDirShapeTool.NbShapes() == 3) {
166     myBuiltShapes(myGenShapeTool.Index(aGenV),3) = Standard_True;
167     myShapes(myGenShapeTool.Index(aGenV),3) = V;
168   }    
169   return V;
170 }
171
172
173 //=======================================================================
174 //function : MakeEmptyDirectingEdge
175 //purpose  : 
176 //=======================================================================
177
178 TopoDS_Shape  BRepSweep_Rotation::MakeEmptyDirectingEdge
179   (const TopoDS_Shape& aGenV, 
180    const Sweep_NumShape&)
181 {
182   TopoDS_Edge E;
183   gp_Pnt P = BRep_Tool::Pnt(TopoDS::Vertex(aGenV));
184   gp_Dir Dirz(myAxe.Direction());
185   gp_Vec V(Dirz);
186   gp_Pnt O(myAxe.Location());
187   O.Translate(V.Dot(gp_Vec(O,P)) * V);
188   if (O.IsEqual(P,Precision::Confusion())) {
189     // make a degenerated edge
190     // temporary make 3D curve null so that 
191     // parameters should be registered.
192     // myBuilder.Builder().MakeEdge(E);
193     gp_Ax2 Axis(O,Dirz);
194     Handle(Geom_Circle) GC = new Geom_Circle(Axis,0.);
195     myBuilder.Builder().
196       MakeEdge(E,GC,BRep_Tool::Tolerance(TopoDS::Vertex(aGenV)));
197     myBuilder.Builder().Degenerated(E,Standard_True);
198   }
199   else {
200     gp_Ax2 Axis(O,Dirz,gp_Dir(gp_Vec(O,P)));
201     Handle(Geom_Circle) GC = new Geom_Circle(Axis,O.Distance(P));
202     Standard_Real tol = BRep_Tool::Tolerance(TopoDS::Vertex(aGenV));
203     myBuilder.Builder().MakeEdge(E, GC, tol);
204
205     gp_Pnt PLast = GC->Value(myAng);
206     if(PLast.SquareDistance(P) > tol*tol) E.Closed(Standard_False);
207
208   }
209
210     
211
212   return E;
213 }
214
215
216 //=======================================================================
217 //function : MakeEmptyGeneratingEdge
218 //purpose  : 
219 //=======================================================================
220
221 TopoDS_Shape  BRepSweep_Rotation::MakeEmptyGeneratingEdge
222   (const TopoDS_Shape& aGenE, 
223    const Sweep_NumShape& aDirV)
224 {
225   //call in case of construction with copy, or only when meridian touches myaxe.
226   Standard_Real First,Last;
227   TopLoc_Location Loc;
228   Handle(Geom_Curve) C = Handle(Geom_Curve)::DownCast
229     (BRep_Tool::Curve(TopoDS::Edge(aGenE),Loc,First,Last)->Copy());
230   C->Transform(Loc.Transformation());
231   TopoDS_Edge E;
232   if(aDirV.Index() == 2) C->Transform(myLocation.Transformation()); 
233   myBuilder.Builder().MakeEdge(E,C,BRep_Tool::Tolerance(TopoDS::Edge(aGenE)));
234   if (aDirV.Index() == 1 && 
235       IsInvariant(aGenE) && 
236       myDirShapeTool.NbShapes() == 3) {
237     myBuiltShapes(myGenShapeTool.Index(aGenE),3) = Standard_True;
238     myShapes(myGenShapeTool.Index(aGenE),3) = E;
239   }
240   return E;
241 }
242
243
244 //=======================================================================
245 //function : SetParameters
246 //purpose  : 
247 //=======================================================================
248
249 void  BRepSweep_Rotation::SetParameters
250   (const TopoDS_Shape& aNewFace, 
251    TopoDS_Shape& aNewVertex, 
252    const TopoDS_Shape& aGenF, 
253    const TopoDS_Shape& aGenV, 
254    const Sweep_NumShape&)
255 {
256   //Glue the parameter of vertices directly included in cap faces.
257   gp_Pnt2d pnt2d = BRep_Tool::Parameters(TopoDS::Vertex(aGenV),
258                                          TopoDS::Face(aGenF));
259   myBuilder.Builder().UpdateVertex
260     (TopoDS::Vertex(aNewVertex),pnt2d.X(),pnt2d.Y(),
261      TopoDS::Face(aNewFace),Precision::PConfusion());
262 }
263
264 //=======================================================================
265 //function : SetDirectingParameter
266 //purpose  : 
267 //=======================================================================
268
269 void  BRepSweep_Rotation::SetDirectingParameter
270   (const TopoDS_Shape& aNewEdge, 
271    TopoDS_Shape& aNewVertex, 
272    const TopoDS_Shape&, 
273    const Sweep_NumShape&, 
274    const Sweep_NumShape& aDirV)
275 {
276   Standard_Real param = 0;
277   TopAbs_Orientation ori = TopAbs_FORWARD;
278   if (aDirV.Index() == 2) {
279     param = myAng;
280     ori = TopAbs_REVERSED;
281   }
282   TopoDS_Vertex V_wnt = TopoDS::Vertex(aNewVertex);
283   V_wnt.Orientation(ori);
284   myBuilder.Builder().UpdateVertex(V_wnt,
285                                    param,TopoDS::Edge(aNewEdge),
286                                    Precision::PConfusion());
287 }
288
289
290 //=======================================================================
291 //function : SetGeneratingParameter
292 //purpose  : 
293 //=======================================================================
294
295 void  BRepSweep_Rotation::SetGeneratingParameter
296   (const TopoDS_Shape& aNewEdge, 
297    TopoDS_Shape& aNewVertex, 
298    const TopoDS_Shape& aGenE, 
299    const TopoDS_Shape& aGenV, 
300    const Sweep_NumShape&)
301 {
302   TopoDS_Vertex vbid = TopoDS::Vertex(aNewVertex); 
303   vbid.Orientation(aGenV.Orientation());
304   myBuilder.Builder().UpdateVertex
305     (vbid,
306      BRep_Tool::Parameter(TopoDS::Vertex(aGenV),TopoDS::Edge(aGenE)),
307      TopoDS::Edge(aNewEdge),Precision::PConfusion());
308 }
309
310
311 //=======================================================================
312 //function : MakeEmptyFace
313 //purpose  : 
314 //=======================================================================
315
316 TopoDS_Shape  BRepSweep_Rotation::MakeEmptyFace
317   (const TopoDS_Shape& aGenS, 
318    const Sweep_NumShape& aDirS)
319 {
320   Standard_Real toler;
321   TopoDS_Face F;
322   Handle(Geom_Surface) S;
323   if(aGenS.ShapeType()==TopAbs_EDGE){
324     TopLoc_Location L;
325     Standard_Real First,Last;
326     Handle(Geom_Curve) C = BRep_Tool::Curve(TopoDS::Edge(aGenS),L,First,Last);
327     toler = BRep_Tool::Tolerance(TopoDS::Edge(aGenS));
328     gp_Trsf Tr = L.Transformation();
329     C = Handle(Geom_Curve)::DownCast(C->Copy());
330     //// modified by jgv, 9.12.03 ////
331     C = new Geom_TrimmedCurve( C, First, Last );
332     //////////////////////////////////
333     C->Transform(Tr);
334
335     Handle(GeomAdaptor_HCurve) HC = new GeomAdaptor_HCurve();
336     HC->ChangeCurve().Load(C,First,Last);
337     Adaptor3d_SurfaceOfRevolution AS(HC,myAxe);
338     switch(AS.GetType()){
339     case GeomAbs_Plane :
340       {
341         Handle(Geom_Plane) Pl = new Geom_Plane(AS.Plane());
342         S = Pl;
343       }
344       break;
345     case GeomAbs_Cylinder :
346       {
347         Handle(Geom_CylindricalSurface) Cy = 
348           new Geom_CylindricalSurface(AS.Cylinder());
349         S = Cy;
350       }
351       break;
352     case GeomAbs_Sphere :
353       {
354         Handle(Geom_SphericalSurface) Sp = 
355           new Geom_SphericalSurface(AS.Sphere());
356         S = Sp;
357       }
358       break;
359     case GeomAbs_Cone :
360       {
361         Handle(Geom_ConicalSurface) Co = 
362           new Geom_ConicalSurface(AS.Cone());
363         S = Co;
364       }
365       break;
366     case GeomAbs_Torus :
367       {
368         Handle(Geom_ToroidalSurface) To = 
369           new Geom_ToroidalSurface(AS.Torus());
370         S = To;
371       }
372       break;
373     default :
374       {
375         Handle(Geom_SurfaceOfRevolution) Se = 
376           new Geom_SurfaceOfRevolution(C,myAxe);
377         S = Se;
378       }
379       break;
380     }
381   }
382   else{
383     TopLoc_Location L;
384     S = BRep_Tool::Surface(TopoDS::Face(aGenS),L);
385     toler = BRep_Tool::Tolerance(TopoDS::Face(aGenS));
386     gp_Trsf Tr = L.Transformation();
387     S = Handle(Geom_Surface)::DownCast(S->Copy());
388     S->Transform(Tr);
389     if (aDirS.Index()==2) S->Transform(myLocation.Transformation());
390   }
391   myBuilder.Builder().MakeFace(F,S,toler);
392   return F;
393 }
394
395
396 //=======================================================================
397 //function : SetPCurve
398 //purpose  : 
399 //=======================================================================
400
401 void  BRepSweep_Rotation::SetPCurve
402   (const TopoDS_Shape& aNewFace, 
403    TopoDS_Shape& aNewEdge, 
404    const TopoDS_Shape& aGenF, 
405    const TopoDS_Shape& aGenE, 
406    const Sweep_NumShape&,
407    const TopAbs_Orientation orien)
408 {
409   //Set on edges of cap faces the same pcurves as 
410   //on edges of the generator face.
411   Standard_Real First,Last;
412   SetThePCurve(myBuilder.Builder(),
413                TopoDS::Edge(aNewEdge),
414                TopoDS::Face(aNewFace),
415                orien,
416                BRep_Tool::CurveOnSurface
417                (TopoDS::Edge(aGenE),TopoDS::Face(aGenF),First,Last));
418 }
419
420
421 //=======================================================================
422 //function : SetGeneratingPCurve
423 //purpose  : 
424 //=======================================================================
425
426 void  BRepSweep_Rotation::SetGeneratingPCurve
427   (const TopoDS_Shape& aNewFace, 
428    TopoDS_Shape& aNewEdge, 
429    const TopoDS_Shape&, 
430    const Sweep_NumShape&, 
431    const Sweep_NumShape& aDirV,
432    const TopAbs_Orientation orien)
433 {
434   TopLoc_Location Loc;
435   GeomAdaptor_Surface AS(BRep_Tool::Surface(TopoDS::Face(aNewFace),Loc));
436   Standard_Real First,Last;
437   Standard_Real u,v;
438   gp_Pnt point;
439   gp_Pnt2d pnt2d;
440   gp_Dir2d dir2d;
441   gp_Lin2d L;
442   if (AS.GetType()==GeomAbs_Plane){
443     gp_Pln pln = AS.Plane();
444     gp_Ax3 ax3 = pln.Position();
445     Handle(Geom_Line) GL = Handle(Geom_Line)::DownCast
446       (BRep_Tool::Curve(TopoDS::Edge(aNewEdge),Loc,First,Last));
447     gp_Lin gl = GL->Lin();
448     gl.Transform(Loc.Transformation());
449     point = gl.Location();
450     gp_Dir dir = gl.Direction();
451     ElSLib::PlaneParameters(ax3,point,u,v);
452     pnt2d.SetCoord(u,v);
453     dir2d.SetCoord(dir.Dot(ax3.XDirection()),dir.Dot(ax3.YDirection()));
454     L.SetLocation(pnt2d);
455     L.SetDirection(dir2d);
456   }
457   else if (AS.GetType()==GeomAbs_Torus){
458     gp_Torus tor = AS.Torus();
459     BRepAdaptor_Curve BC(TopoDS::Edge(aNewEdge));
460     Standard_Real U = BC.FirstParameter();
461     point = BC.Value(U);
462     if (point.Distance(tor.Location()) < Precision::Confusion()) {
463       v = M_PI;
464 //  modified by NIZHNY-EAP Wed Mar  1 17:49:29 2000 ___BEGIN___
465       u = 0.;
466     }
467     else {
468       ElSLib::TorusParameters(tor.Position(),tor.MajorRadius(),
469                               tor.MinorRadius(),point,u,v);
470     }
471 //    u = 0.;
472     v = ElCLib::InPeriod(v,0.,2*M_PI);
473     if((2*M_PI - v) <= Precision::PConfusion()) v -= 2*M_PI;
474     if (aDirV.Index() == 2) {
475       Standard_Real uLeft = u-myAng;
476       ElCLib::AdjustPeriodic(-M_PI,M_PI,Precision::PConfusion(),uLeft,u);
477     }
478     else {
479       Standard_Real uRight = u+myAng;
480       ElCLib::AdjustPeriodic(-M_PI,M_PI,Precision::PConfusion(),u,uRight);
481     }
482 //  modified by NIZHNY-EAP Wed Mar  1 17:49:32 2000 ___END___
483     pnt2d.SetCoord(u,v-U);
484     L.SetLocation(pnt2d);
485     L.SetDirection(gp::DY2d());
486   }
487   else if (AS.GetType()==GeomAbs_Sphere){
488     gp_Sphere sph = AS.Sphere();
489     BRepAdaptor_Curve BC(TopoDS::Edge(aNewEdge));
490     Standard_Real U = BC.FirstParameter();
491     point = BC.Value(U);
492     ElSLib::SphereParameters(sph.Position(),sph.Radius(),point,u,v);
493     u = 0.;
494     if (aDirV.Index() == 2) u = myAng;
495     pnt2d.SetCoord(u,v-U);
496     L.SetLocation(pnt2d);
497     L.SetDirection(gp::DY2d());
498   }
499   else{
500     Standard_Real u = 0;
501     if (aDirV.Index() == 2) u = myAng;
502     L.SetLocation(gp_Pnt2d(u,0));
503     L.SetDirection(gp::DY2d());
504   }
505   Handle(Geom2d_Line) GL = new Geom2d_Line(L);
506   SetThePCurve(myBuilder.Builder(),
507                TopoDS::Edge(aNewEdge),
508                TopoDS::Face(aNewFace),
509                orien,
510                GL);
511 }
512
513
514 //=======================================================================
515 //function : SetDirectingPCurve
516 //purpose  : 
517 //=======================================================================
518
519 void  BRepSweep_Rotation::SetDirectingPCurve
520   (const TopoDS_Shape& aNewFace, 
521    TopoDS_Shape& aNewEdge, 
522    const TopoDS_Shape& aGenE, 
523    const TopoDS_Shape& aGenV, 
524    const Sweep_NumShape&,
525    const TopAbs_Orientation orien)
526 {
527   TopLoc_Location Loc;
528   GeomAdaptor_Surface AS(BRep_Tool::Surface(TopoDS::Face(aNewFace),Loc));
529   Standard_Real 
530     par = BRep_Tool::Parameter(TopoDS::Vertex(aGenV),TopoDS::Edge(aGenE));
531   gp_Pnt p2 = BRep_Tool::Pnt(TopoDS::Vertex(aGenV));
532   gp_Pnt2d p22d;
533   Standard_Real u,v;
534   Handle(Geom2d_Curve) thePCurve;
535
536   switch(AS.GetType()){
537
538   case GeomAbs_Plane : 
539     {
540       gp_Pln pln = AS.Plane();
541       gp_Ax3 ax3 = pln.Position();
542       gp_Pnt p1 = pln.Location();
543       Standard_Real R = p1.Distance(p2);
544       ElSLib::PlaneParameters(ax3,p2,u,v);
545       gp_Dir2d dx2d(u,v);
546       gp_Ax22d axe(gp::Origin2d(),dx2d,gp::DY2d());
547       gp_Circ2d C(axe,R);
548       Handle(Geom2d_Circle) GC = new Geom2d_Circle(C);
549       thePCurve = GC;
550     }
551     break;
552
553   case GeomAbs_Cone : 
554     {
555       gp_Cone cone = AS.Cone();
556       ElSLib::ConeParameters(cone.Position(),cone.RefRadius(),
557                              cone.SemiAngle(),p2,u,v);
558       p22d.SetCoord(0.,v);
559       gp_Lin2d L(p22d,gp::DX2d());
560       Handle(Geom2d_Line) GL = new Geom2d_Line(L);
561       thePCurve = GL;
562     }
563     break;
564
565   case GeomAbs_Sphere : 
566     {
567       gp_Sphere sph = AS.Sphere();
568       ElSLib::SphereParameters(sph.Position(),sph.Radius(),p2,u,v);
569       p22d.SetCoord(0.,v);
570       gp_Lin2d L(p22d,gp::DX2d());
571       Handle(Geom2d_Line) GL = new Geom2d_Line(L);
572       thePCurve = GL;
573     }
574     break;
575
576   case GeomAbs_Torus : 
577     {
578       gp_Pnt p1;
579       Standard_Real u1,u2,v1,v2;
580       gp_Torus tor = AS.Torus();
581       BRepAdaptor_Curve BC(TopoDS::Edge(aGenE));
582       p1 = BC.Value(BC.FirstParameter());
583       if (p1.Distance(tor.Location()) < Precision::Confusion()){
584         v1 = M_PI;
585 //  modified by NIZHNY-EAP Thu Mar  2 09:43:26 2000 ___BEGIN___
586         u1 = 0.;
587 //  modified by NIZHNY-EAP Thu Mar  2 15:28:59 2000 ___END___
588       }
589       else {
590         ElSLib::TorusParameters(tor.Position(),tor.MajorRadius(),
591                                 tor.MinorRadius(),p1,u1,v1);
592       }
593       p2 = BC.Value(BC.LastParameter());
594       if (p2.Distance(tor.Location()) < Precision::Confusion()){
595         v2 = M_PI;
596       }
597       else {
598         ElSLib::TorusParameters(tor.Position(),tor.MajorRadius(),
599                                 tor.MinorRadius(),p2,u2,v2);
600       }
601       ElCLib::AdjustPeriodic(0.,2*M_PI,Precision::PConfusion(),v1,v2);
602 //  modified by NIZHNY-EAP Thu Mar  2 15:29:04 2000 ___BEGIN___
603       u2 = u1 + myAng;
604       ElCLib::AdjustPeriodic(-M_PI,M_PI,Precision::PConfusion(),u1,u2);
605       if (aGenV.Orientation()==TopAbs_FORWARD){
606         p22d.SetCoord(u1,v1);
607       }
608       else {
609         p22d.SetCoord(u1,v2);
610 //  modified by NIZHNY-EAP Thu Mar  2 09:43:32 2000 ___END___
611       }
612       gp_Lin2d L(p22d,gp::DX2d());
613       Handle(Geom2d_Line) GL = new Geom2d_Line(L);
614       thePCurve = GL;
615     }
616     break;
617
618   default :
619     {
620       p22d.SetCoord(0.,par);
621       gp_Lin2d L(p22d,gp::DX2d());
622       Handle(Geom2d_Line) GL = new Geom2d_Line(L);
623       thePCurve = GL;
624     }
625     break;
626   }
627   SetThePCurve(myBuilder.Builder(),
628                TopoDS::Edge(aNewEdge),
629                TopoDS::Face(aNewFace),
630                orien,
631                thePCurve);
632 }
633
634 //modified by NIZNHY-PKV Tue Jun 14 08:33:55 2011f
635 //=======================================================================
636 //function : DirectSolid
637 //purpose  : 
638 //=======================================================================
639 TopAbs_Orientation 
640   BRepSweep_Rotation::DirectSolid (const TopoDS_Shape& aGenS,
641                                    const Sweep_NumShape&)
642 {  // compare the face normal and the direction
643   Standard_Real aU1, aU2, aV1, aV2, aUx, aVx, aX, aMV2, aTol2, aTx;
644   TopAbs_Orientation aOr;
645   gp_Pnt aP;
646   gp_Vec du,dv;
647   BRepAdaptor_Surface surf(TopoDS::Face(aGenS));
648   //
649   aTol2=Precision::Confusion();
650   aTol2=aTol2*aTol2;
651   //
652   const gp_Pnt& aPAxeLoc=myAxe.Location();
653   const gp_Dir& aPAxeDir=myAxe.Direction();
654   //
655   aU1=surf.FirstUParameter();
656   aU2=surf.LastUParameter();
657   aV1=surf.FirstVParameter();
658   aV2=surf.LastVParameter();
659   //
660   aTx=0.5;
661   aUx=aTx*(aU1+aU2);
662   aVx=aTx*(aV1+aV2);
663   surf.D1(aUx, aVx, aP, du, dv);
664   //
665   gp_Vec aV(aPAxeLoc, aP);
666   aV.Cross(aPAxeDir);
667   aMV2=aV.SquareMagnitude();
668   if (aMV2<aTol2) {
669     aTx=0.43213918;
670     aUx=aU1*(1.-aTx)+aU2*aTx;
671     aVx=aV1*(1.-aTx)+aV2*aTx;
672     surf.D1(aUx, aVx, aP, du, dv);
673     aV.SetXYZ(aP.XYZ()-aPAxeLoc.XYZ());
674     aV.Cross(aPAxeDir);
675   }
676   //
677   aX = aV.DotCross(du, dv);
678   aOr = (aX > 0.) ? TopAbs_FORWARD : TopAbs_REVERSED;
679   return aOr;
680 }
681 /*
682 //=======================================================================
683 //function : DirectSolid
684 //purpose  : 
685 //=======================================================================
686 TopAbs_Orientation 
687   BRepSweep_Rotation::DirectSolid (const TopoDS_Shape& aGenS,
688                                    const Sweep_NumShape&)
689 {
690   // compare the face normal and the direction
691   BRepAdaptor_Surface surf(TopoDS::Face(aGenS));
692   gp_Pnt P;
693   gp_Vec du,dv;
694   surf.D1((surf.FirstUParameter() + surf.LastUParameter()) / 2.,
695           (surf.FirstVParameter() + surf.LastVParameter()) / 2.,
696           P,du,dv);
697     
698   gp_Vec V(myAxe.Location(),P);
699   V.Cross(myAxe.Direction());
700   Standard_Real x = V.DotCross(du,dv);
701   TopAbs_Orientation orient = (x > 0) ? TopAbs_FORWARD : TopAbs_REVERSED;
702   return orient;
703 }
704 */
705 //modified by NIZNHY-PKV Tue Jun 14 08:33:59 2011t
706
707 //=======================================================================
708 //function : GGDShapeIsToAdd
709 //purpose  : 
710 //=======================================================================
711
712 Standard_Boolean BRepSweep_Rotation::GGDShapeIsToAdd
713   (const TopoDS_Shape& aNewShape,
714    const TopoDS_Shape& aNewSubShape,
715    const TopoDS_Shape& aGenS,
716    const TopoDS_Shape& aSubGenS,
717    const Sweep_NumShape& aDirS )const
718 {
719   if (aNewShape.ShapeType()==TopAbs_FACE &&
720       aNewSubShape.ShapeType()==TopAbs_EDGE &&
721       aGenS.ShapeType()==TopAbs_EDGE &&
722       aSubGenS.ShapeType()==TopAbs_VERTEX &&
723       aDirS.Type()==TopAbs_EDGE){
724     TopLoc_Location Loc;
725     GeomAdaptor_Surface AS(BRep_Tool::Surface(TopoDS::Face(aNewShape),Loc));
726     if (AS.GetType()==GeomAbs_Plane){
727       return (!IsInvariant(aSubGenS));
728     }
729     else{
730       return Standard_True;
731     }
732   }
733   else{
734     return Standard_True;
735   }
736 }
737
738
739 //=======================================================================
740 //function : GDDShapeIsToAdd
741 //purpose  : 
742 //=======================================================================
743
744 Standard_Boolean BRepSweep_Rotation::GDDShapeIsToAdd
745   (const TopoDS_Shape& aNewShape,
746    const TopoDS_Shape& aNewSubShape,
747    const TopoDS_Shape& aGenS,
748    const Sweep_NumShape& aDirS,
749    const Sweep_NumShape& aSubDirS )const
750 {
751   if ( aNewShape.ShapeType() == TopAbs_SOLID &&
752        aNewSubShape.ShapeType() == TopAbs_FACE &&
753        aGenS.ShapeType() == TopAbs_FACE &&
754        aDirS.Type() == TopAbs_EDGE &&
755        aSubDirS.Type() == TopAbs_VERTEX ){
756     return ( Abs(myAng - 2 * M_PI) > Precision::Angular() );
757   }
758   else if ( aNewShape.ShapeType() == TopAbs_FACE &&
759        aNewSubShape.ShapeType() == TopAbs_EDGE &&
760        aGenS.ShapeType() == TopAbs_EDGE &&
761        aDirS.Type() == TopAbs_EDGE &&
762        aSubDirS.Type() == TopAbs_VERTEX ){
763     TopLoc_Location Loc;
764     GeomAdaptor_Surface AS(BRep_Tool::Surface(TopoDS::Face(aNewShape),Loc));
765     if (AS.GetType()==GeomAbs_Plane){
766       return ( Abs(myAng - 2 * M_PI) > Precision::Angular() );
767     }
768     else {
769       return Standard_True;
770     }
771   }
772   else {
773     return Standard_True;
774   }
775 }
776
777
778 //=======================================================================
779 //function : SeparatedWires
780 //purpose  : 
781 //=======================================================================
782
783 Standard_Boolean BRepSweep_Rotation::SeparatedWires
784   (const TopoDS_Shape& aNewShape,
785    const TopoDS_Shape& aNewSubShape,
786    const TopoDS_Shape& aGenS,
787    const TopoDS_Shape& aSubGenS,
788    const Sweep_NumShape& aDirS )const
789 {
790   if (aNewShape.ShapeType()==TopAbs_FACE &&
791       aNewSubShape.ShapeType()==TopAbs_EDGE &&
792       aGenS.ShapeType()==TopAbs_EDGE &&
793       aSubGenS.ShapeType()==TopAbs_VERTEX &&
794       aDirS.Type()==TopAbs_EDGE){
795     TopLoc_Location Loc;
796     GeomAdaptor_Surface AS(BRep_Tool::Surface(TopoDS::Face(aNewShape),Loc));
797     if (AS.GetType()==GeomAbs_Plane){
798       return (Abs(myAng-2*M_PI) <= Precision::Angular());
799     }
800     else{
801       return Standard_False;
802     }
803   }
804   else{
805     return Standard_False;
806   }
807 }
808
809 //=======================================================================
810 //function : SplitShell
811 //purpose  : 
812 //=======================================================================
813
814 TopoDS_Shape BRepSweep_Rotation::SplitShell(const TopoDS_Shape& aNewShape)const
815 {
816   BRepTools_Quilt Q;
817   Q.Add(aNewShape);
818   return Q.Shells();
819 }
820
821 //=======================================================================
822 //function : HasShape
823 //purpose  : 
824 //=======================================================================
825
826 Standard_Boolean  BRepSweep_Rotation::HasShape
827   (const TopoDS_Shape& aGenS, 
828    const Sweep_NumShape& aDirS)const 
829 {
830   if(aDirS.Type()==TopAbs_EDGE&&
831      aGenS.ShapeType()==TopAbs_EDGE){
832     return !IsInvariant(aGenS);
833   }
834   else{
835     return Standard_True;
836   }
837 }
838
839
840 //=======================================================================
841 //function : IsInvariant
842 //purpose  : 
843 //=======================================================================
844
845 Standard_Boolean  BRepSweep_Rotation::IsInvariant 
846   (const TopoDS_Shape& aGenS)const
847 {
848   if(aGenS.ShapeType()==TopAbs_EDGE){
849     TopLoc_Location Loc;
850     Standard_Real First,Last;
851     Handle(Geom_Curve) 
852       C = BRep_Tool::Curve(TopoDS::Edge(aGenS),Loc,First,Last);
853     Handle(Standard_Type) TheType = C->DynamicType();
854     if ( TheType == STANDARD_TYPE(Geom_Line)) {
855       TopoDS_Vertex V1, V2;
856       TopExp::Vertices(TopoDS::Edge(aGenS), V1, V2);
857       return ( IsInvariant(V1) && IsInvariant(V2));
858     }
859     else{
860       return Standard_False;
861     }
862   }
863   else if(aGenS.ShapeType()==TopAbs_VERTEX){
864     gp_Pnt P = BRep_Tool::Pnt(TopoDS::Vertex(aGenS));
865     gp_Lin Lin (myAxe.Location(), myAxe.Direction());
866     return ( Lin.Distance(P) <= BRep_Tool::Tolerance(TopoDS::Vertex(aGenS))); 
867   }
868   else
869     return Standard_False;
870 }
871
872 //=======================================================================
873 //function : Angle
874 //purpose  : 
875 //=======================================================================
876
877 Standard_Real BRepSweep_Rotation::Angle()const 
878 {
879   return myAng;
880 }
881
882 //=======================================================================
883 //function : Axe
884 //purpose  : 
885 //=======================================================================
886
887 gp_Ax1 BRepSweep_Rotation::Axe()const 
888 {
889   return myAxe;
890 }
891