0028567: Get rid of the unused DRAW commands based on old Boolean Operations (BRepAlgo)
[occt.git] / src / BRepFeat / BRepFeat_MakeRevol.cxx
1 // Created on: 1996-02-13
2 // Created by: Jacques GOUSSARD
3 // Copyright (c) 1996-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 <Bnd_Box.hxx>
19 #include <BRep_Builder.hxx>
20 #include <BRep_Tool.hxx>
21 #include <BRepAlgoAPI_Cut.hxx>
22 #include <BRepAlgoAPI_Fuse.hxx>
23 #include <BRepBndLib.hxx>
24 #include <BRepBuilderAPI.hxx>
25 #include <BRepFeat.hxx>
26 #include <BRepFeat_MakeRevol.hxx>
27 #include <BRepLib_MakeFace.hxx>
28 #include <BRepSweep_Revol.hxx>
29 #include <BRepTools_Modifier.hxx>
30 #include <BRepTools_TrsfModification.hxx>
31 #include <ElCLib.hxx>
32 #include <Geom2d_Curve.hxx>
33 #include <Geom_Circle.hxx>
34 #include <Geom_Curve.hxx>
35 #include <Geom_Plane.hxx>
36 #include <Geom_RectangularTrimmedSurface.hxx>
37 #include <Geom_Surface.hxx>
38 #include <gp_Ax1.hxx>
39 #include <gp_Pln.hxx>
40 #include <gp_Pnt.hxx>
41 #include <gp_Pnt2d.hxx>
42 #include <gp_Vec.hxx>
43 #include <LocOpe.hxx>
44 #include <LocOpe_BuildShape.hxx>
45 #include <LocOpe_CSIntersector.hxx>
46 #include <LocOpe_FindEdges.hxx>
47 #include <LocOpe_Gluer.hxx>
48 #include <LocOpe_PntFace.hxx>
49 #include <LocOpe_Revol.hxx>
50 #include <LocOpe_SequenceOfCirc.hxx>
51 #include <Precision.hxx>
52 #include <Standard_ConstructionError.hxx>
53 #include <TColgp_SequenceOfPnt.hxx>
54 #include <TopExp.hxx>
55 #include <TopExp_Explorer.hxx>
56 #include <TopoDS_Compound.hxx>
57 #include <TopoDS_Edge.hxx>
58 #include <TopoDS_Face.hxx>
59 #include <TopoDS_Shape.hxx>
60 #include <TopoDS_Shell.hxx>
61 #include <TopoDS_Solid.hxx>
62 #include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
63 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
64 #include <TopTools_ListIteratorOfListOfShape.hxx>
65 #include <TopTools_MapIteratorOfMapOfShape.hxx>
66 #include <TopTools_MapOfShape.hxx>
67
68 #ifdef OCCT_DEBUG
69 extern Standard_Boolean BRepFeat_GettraceFEAT();
70 #endif
71
72 static void MajMap(const TopoDS_Shape&, // base
73   const LocOpe_Revol&,
74   TopTools_DataMapOfShapeListOfShape&, // myMap
75   TopoDS_Shape&,  // myFShape
76   TopoDS_Shape&); // myLShape
77
78
79 static void VerifGluedFaces(const TopoDS_Face& theSkface,
80   const TopoDS_Shape& thePbase,
81   Handle(Geom_Curve)& theBCurve,
82   TColGeom_SequenceOfCurve& theCurves,
83   LocOpe_Revol& theRevol,
84   TopTools_DataMapOfShapeShape& theMap);
85
86
87 static Standard_Boolean ToFuse(const TopoDS_Face& ,
88   const TopoDS_Face&);
89
90
91
92
93 //=======================================================================
94 //function : Init
95 //purpose  : 
96 //=======================================================================
97
98 void BRepFeat_MakeRevol::Init(const TopoDS_Shape& Sbase,
99   const TopoDS_Shape& Pbase,
100   const TopoDS_Face& Skface,
101   const gp_Ax1& Axis,
102   const Standard_Integer Mode,
103   const Standard_Boolean Modify)
104 {
105 #ifdef OCCT_DEBUG
106   Standard_Boolean trc = BRepFeat_GettraceFEAT();
107   if (trc) cout << "BRepFeat_MakeRevol::Init" << endl;
108 #endif
109   myAxis   = Axis;
110   myPbase  = Pbase;
111   mySbase  = Sbase;
112   BasisShapeValid();
113   mySkface = Skface;
114   SketchFaceValid();
115   myPbase  = Pbase;
116   mySlface.Clear();
117   if(Mode == 0) {
118     myFuse   = Standard_False;
119     myJustFeat = Standard_False;
120   }
121   else if(Mode == 1) {
122     myFuse   = Standard_True;
123     myJustFeat = Standard_False;
124   }
125   else if(Mode == 2) {
126     myFuse   = Standard_True;
127     myJustFeat = Standard_True;
128   }
129   else {    
130   }
131   myModify = Modify;
132   myJustGluer = Standard_False;
133
134   //-------------- ifv
135   //  mySkface.Nullify();
136   //-------------- ifv
137
138
139   myShape.Nullify();
140   myMap.Clear();
141   myFShape.Nullify();
142   myLShape.Nullify();
143   TopExp_Explorer exp;
144   for (exp.Init(mySbase,TopAbs_FACE);exp.More();exp.Next()) {
145     TopTools_ListOfShape thelist;
146     myMap.Bind(exp.Current(), thelist);
147     myMap(exp.Current()).Append(exp.Current());
148   }
149 #ifdef OCCT_DEBUG
150   if (trc) {
151     if (myJustFeat)  cout << " Just Feature" << endl;
152     if (myFuse)  cout << " Fuse" << endl;
153     if (!myFuse)  cout << " Cut" << endl;
154     if (!myModify) cout << " Modify = 0" << endl;
155   }
156 #endif 
157 }
158
159
160 //=======================================================================
161 //function : Add
162 //purpose  : add faces add edges of sliding
163 //=======================================================================
164
165 void BRepFeat_MakeRevol::Add(const TopoDS_Edge& E,
166   const TopoDS_Face& F)
167 {
168 #ifdef OCCT_DEBUG
169   Standard_Boolean trc = BRepFeat_GettraceFEAT();
170   if (trc) cout << "BRepFeat_MakeRevol::Add(Edge,face)" << endl;
171 #endif
172   TopExp_Explorer exp;
173   for (exp.Init(mySbase,TopAbs_FACE);exp.More();exp.Next()) {
174     if (exp.Current().IsSame(F)) {
175       break;
176     }
177   }
178   if (!exp.More()) {
179     throw Standard_ConstructionError();
180   }
181
182   for (exp.Init(myPbase,TopAbs_EDGE);exp.More();exp.Next()) {
183     if (exp.Current().IsSame(E)) {
184       break;
185     }
186   }
187   if (!exp.More()) {
188     throw Standard_ConstructionError();
189   }
190
191   if (!mySlface.IsBound(F)) {
192     TopTools_ListOfShape thelist;
193     mySlface.Bind(F, thelist);
194   }
195   TopTools_ListIteratorOfListOfShape itl(mySlface(F));
196   for (; itl.More();itl.Next()) {
197     if (itl.Value().IsSame(E)) {
198       break;
199     }
200   }
201   if (!itl.More()) {
202     mySlface(F).Append(E);
203   }
204 }
205
206
207 //=======================================================================
208 //function : Perform
209 //purpose  : 
210 //=======================================================================
211
212 void BRepFeat_MakeRevol::Perform(const Standard_Real Angle)
213 {
214 #ifdef OCCT_DEBUG
215   Standard_Boolean trc = BRepFeat_GettraceFEAT();
216   if (trc) cout << "BRepFeat_MakeRevol::Perform(Angle)" << endl;
217 #endif
218   mySFrom.Nullify();
219   ShapeFromValid();
220   mySUntil.Nullify();
221   ShapeUntilValid();
222   myGluedF.Clear();
223   myPerfSelection = BRepFeat_NoSelection;
224   PerfSelectionValid();
225   Standard_Boolean RevolComp = (2*M_PI-Abs(Angle) <= Precision::Angular());
226   LocOpe_Revol theRevol;
227   Standard_Real angledec = 0.;
228   TopExp_Explorer exp;
229   if(RevolComp) {
230     /*
231     if (!mySkface.IsNull() || !mySlface.IsEmpty()) {
232     for (exp.Init(mySbase,TopAbs_FACE); exp.More(); exp.Next()) {
233     if (exp.Current().IsSame(mySkface)) {
234     angledec = M_PI/5; // pourquoi pas
235     if (myFuse) angledec = -angledec;
236     break;
237     }
238     }
239     }
240     */
241     mySkface.Nullify();
242   }
243   if(angledec == 0.) theRevol.Perform(myPbase, myAxis, Angle);
244   else theRevol.Perform(myPbase, myAxis, Angle, angledec);
245
246   TopoDS_Shape VraiRevol = theRevol.Shape();
247
248   MajMap(myPbase,theRevol,myMap,myFShape,myLShape);
249
250   myGShape = VraiRevol;
251   GeneratedShapeValid();
252   TopoDS_Shape Base = theRevol.FirstShape();
253   exp.Init(Base, TopAbs_FACE);
254   TopoDS_Face theBase = TopoDS::Face(exp.Current());
255   exp.Next();
256   if(exp.More()) {
257     NotDone();
258     myStatusError = BRepFeat_InvFirstShape;
259     return;
260   }
261
262   TopoDS_Face FFace;
263
264   Standard_Boolean found = Standard_False;
265
266   if(!mySkface.IsNull() || !mySlface.IsEmpty()) {
267     if(myLShape.ShapeType() == TopAbs_WIRE) {
268       TopExp_Explorer ex1(VraiRevol, TopAbs_FACE);
269       for(; ex1.More(); ex1.Next()) {
270         TopExp_Explorer ex2(ex1.Current(), TopAbs_WIRE);
271         for(; ex2.More(); ex2.Next()) {
272           if(ex2.Current().IsSame(myLShape)) {
273             FFace = TopoDS::Face(ex1.Current());
274             found = Standard_True;
275             break;
276           }
277         }
278         if(found) break;
279       }
280     }
281
282     TopExp_Explorer anExp(mySbase, TopAbs_FACE);
283     for(; anExp.More(); anExp.Next()) {
284       const TopoDS_Face& ff = TopoDS::Face(anExp.Current());
285       if(ToFuse(ff, FFace)) {
286         TopTools_DataMapOfShapeListOfShape sl;
287         if(!FFace.IsSame(myPbase) && BRepFeat::IsInside(ff, FFace)) 
288           break;
289       }
290     }
291   }
292   GluedFacesValid();
293   if (!mySkface.IsNull()) {
294     VerifGluedFaces(mySkface, theBase, myBCurve, myCurves, theRevol, myGluedF);
295   }
296
297   if(myGluedF.IsEmpty()) {
298     if(myFuse == 1) {
299       BRepAlgoAPI_Fuse f(mySbase, myGShape);
300       myShape = f.Shape();
301       UpdateDescendants(f, myShape, Standard_False);
302       Done();
303     }
304     else if(myFuse == 0) {
305       BRepAlgoAPI_Cut c(mySbase, myGShape);
306       myShape = c.Shape();
307       UpdateDescendants(c, myShape, Standard_False);
308       Done();
309     }
310     else {
311       myShape = myGShape;
312       Done();
313     }
314   }
315   else {
316     theRevol.Curves(myCurves);
317     myBCurve = theRevol.BarycCurve();
318     GlobalPerform();
319   }
320 }
321
322
323 //=======================================================================
324 //function : Perform
325 //purpose  : feature till shape Until
326 //=======================================================================
327
328 void BRepFeat_MakeRevol::Perform(const TopoDS_Shape& Until)
329 {
330 #ifdef OCCT_DEBUG
331   Standard_Boolean trc = BRepFeat_GettraceFEAT();
332   if (trc) cout << "BRepFeat_MakeRevol::Perform(Until)" << endl;
333 #endif
334   Standard_Real Angle = 0.;
335   Standard_Boolean TourComplet = Standard_False;
336
337   if (Until.IsNull()) {
338     throw Standard_ConstructionError();
339   }
340   TopExp_Explorer exp(Until, TopAbs_FACE);
341   if (!exp.More()) {
342     throw Standard_ConstructionError();
343   }
344   if (!mySkface.IsNull() && Until.IsSame(mySkface)) {
345     Angle = 2*M_PI;
346     TourComplet = Standard_True;
347   }
348   myGluedF.Clear();
349   myPerfSelection = BRepFeat_SelectionU;
350   PerfSelectionValid();
351   mySFrom.Nullify();
352   ShapeFromValid();
353   mySUntil = Until;
354   Standard_Boolean Trf = TransformShapeFU(1);
355   ShapeUntilValid();
356
357   // Do systematically almost complete revolution
358   // BRepSweep_Revol theRevol(myPbase,myAxis,2.*M_PI-10.*Precision::Angular());
359   LocOpe_Revol theRevol;
360   if(!TourComplet) {
361     Angle = 2.*M_PI- 3*M_PI/180.;
362 #ifdef OCCT_DEBUG
363     if (trc) cout << " No complete Revolution" << endl;
364 #endif
365   }
366   theRevol.Perform(myPbase, myAxis, Angle);
367   TopoDS_Shape VraiRevol = theRevol.Shape();
368   MajMap(myPbase,theRevol,myMap,myFShape,myLShape);
369
370
371   if(!Trf) {
372
373     myGShape = VraiRevol;
374     GeneratedShapeValid();
375
376     TopoDS_Shape Base = theRevol.FirstShape();
377     exp.Init(Base, TopAbs_FACE);
378     TopoDS_Face theBase = TopoDS::Face(exp.Current());
379     exp.Next();
380     if(exp.More()) {
381       NotDone();
382       myStatusError = BRepFeat_InvFirstShape;
383       return;
384     }
385     GluedFacesValid();
386     //VerifGluedFaces(mySkface, theBase, myBCurve, myCurves, theRevol, myGluedF);
387
388     theRevol.Curves(myCurves);
389     myBCurve = theRevol.BarycCurve();
390     GlobalPerform();
391   }
392   else {
393     TColGeom_SequenceOfCurve scur;
394     theRevol.Curves(myCurves);
395     myBCurve = theRevol.BarycCurve();    
396     scur.Clear();    
397     scur.Append(myBCurve);
398     LocOpe_CSIntersector ASI(mySUntil);
399     ASI.Perform(scur);
400     if (ASI.IsDone() && ASI.NbPoints(1) >=1) {
401       TopAbs_Orientation Or = ASI.Point(1,1).Orientation();
402       TopoDS_Face FUntil = ASI.Point(1,1).Face();
403       TopoDS_Shape Comp;
404       BRep_Builder B;
405       B.MakeCompound(TopoDS::Compound(Comp));
406       TopoDS_Solid S = BRepFeat::Tool(mySUntil, FUntil, Or);
407       if (!S.IsNull()) B.Add(Comp,S);
408       BRepAlgoAPI_Cut trP(VraiRevol,Comp);
409       TopoDS_Shape Cutsh = trP.Shape();
410       TopExp_Explorer ex(Cutsh, TopAbs_SOLID);
411       for(; ex.More(); ex.Next()) {
412         TopExp_Explorer ex1(ex.Current(), TopAbs_FACE);
413         for(; ex1.More(); ex1.Next()) {
414           const TopoDS_Face& fac = TopoDS::Face(ex1.Current());
415           if(fac.IsSame(myPbase)) {
416             VraiRevol = ex.Current();
417             break;
418           }
419         }
420       }
421       if(myFuse == 1) {
422         BRepAlgoAPI_Fuse f(mySbase, VraiRevol);
423         myShape = f.Shape();
424         UpdateDescendants(f, myShape, Standard_False);
425         Done();
426       }
427       else if(myFuse == 0) {
428         BRepAlgoAPI_Cut c(mySbase, VraiRevol);
429         myShape = c.Shape();
430         UpdateDescendants(c, myShape, Standard_False);
431         Done();
432       }
433       else {
434         myShape = VraiRevol;
435         Done(); 
436       }
437     }         
438   }
439 }
440
441
442 //=======================================================================
443 //function : Perform
444 //purpose  : feature limited by two shapes
445 //=======================================================================
446
447 void BRepFeat_MakeRevol::Perform(const TopoDS_Shape& From,
448   const TopoDS_Shape& Until)
449 {
450 #ifdef OCCT_DEBUG
451   Standard_Boolean trc = BRepFeat_GettraceFEAT();
452   if (trc) cout << "BRepFeat_MakeRevol::Perform(From,Until)" << endl;
453 #endif
454   if (From.IsNull() || Until.IsNull()) {
455     throw Standard_ConstructionError();
456   }
457   if (!mySkface.IsNull()) {
458     if (From.IsSame(mySkface)) {
459       myJustGluer = Standard_True;
460       Perform(Until);
461       if (myJustGluer) return;
462     }
463     else if (Until.IsSame(mySkface)) {
464       myJustGluer = Standard_True;
465       myAxis.Reverse();
466       Perform(From);
467       if (myJustGluer) return;
468     }
469   }
470
471   myGluedF.Clear();
472   myPerfSelection = BRepFeat_SelectionFU;
473   PerfSelectionValid();
474
475   TopExp_Explorer exp(From, TopAbs_FACE);
476   if (!exp.More()) {
477     throw Standard_ConstructionError();
478   }
479   exp.Init(Until, TopAbs_FACE);
480   if (!exp.More()) {
481     throw Standard_ConstructionError();
482   }
483
484   mySFrom = From;
485   Standard_Boolean Trff = TransformShapeFU(0);
486   ShapeFromValid();
487   mySUntil = Until;
488   Standard_Boolean Trfu = TransformShapeFU(1);
489   ShapeUntilValid();  
490
491   if(Trfu != Trff) {
492     NotDone();
493     myStatusError = BRepFeat_IncTypes;
494     return;
495   }
496
497   LocOpe_Revol theRevol;
498   theRevol.Perform(myPbase, myAxis, 2*M_PI);
499   TopoDS_Shape VraiRevol = theRevol.Shape();
500
501   MajMap(myPbase,theRevol,myMap,myFShape,myLShape);
502
503   if(!Trff) {    
504     myGShape = VraiRevol;
505     GeneratedShapeValid();
506     GluedFacesValid();
507     //    VerifGluedFaces(mySkface, theBase, myBCurve, myCurves, theRevol, myGluedF);
508
509     theRevol.Curves(myCurves);
510     myBCurve = theRevol.BarycCurve();
511     GlobalPerform();
512   }
513   else {
514     theRevol.Curves(myCurves);
515     myBCurve = theRevol.BarycCurve();    
516     TColGeom_SequenceOfCurve scur;
517     scur.Clear();    
518     scur.Append(myBCurve);
519     LocOpe_CSIntersector ASI1(mySUntil);
520     LocOpe_CSIntersector ASI2(mySFrom);
521     ASI1.Perform(scur);
522     ASI2.Perform(scur);
523     TopAbs_Orientation OrU, OrF;
524     TopoDS_Face FFrom, FUntil;
525     Standard_Real PrF, PrU;
526     if (ASI1.IsDone() && ASI1.NbPoints(1) >=1) {
527       OrU = ASI1.Point(1,1).Orientation();
528       FUntil = ASI1.Point(1,1).Face();
529       PrU = ASI1.Point(1,1).Parameter();
530     }
531     else {
532       NotDone();
533       myStatusError = BRepFeat_NoIntersectU;
534       return;
535     }
536     if (ASI2.IsDone() && ASI2.NbPoints(1) >=1) {
537       Standard_Real pr1 = ASI2.Point(1,1).Parameter();
538       pr1 = ElCLib::InPeriod(pr1,PrU-2*M_PI,PrU);
539       Standard_Real pr2 = ASI2.Point(1,ASI2.NbPoints(1)).Parameter();
540       pr2 = ElCLib::InPeriod(pr2,PrU-2*M_PI,PrU);
541       //OrF = OrU;
542       OrF = TopAbs::Reverse(OrU);
543       FFrom = ASI2.Point(1,1).Face();
544       PrF = Max(pr1, pr2);
545     }
546     else {
547       NotDone();
548       myStatusError = BRepFeat_NoIntersectF;
549       return;
550     }
551     if(!(PrU > PrF)) {
552       NotDone();
553       myStatusError = BRepFeat_IncParameter;
554       return;
555     }
556     TopoDS_Shape Comp;
557     BRep_Builder B;
558     B.MakeCompound(TopoDS::Compound(Comp));
559     TopoDS_Solid SF = BRepFeat::Tool(mySFrom, FFrom, OrF);
560     if (!SF.IsNull()) B.Add(Comp,SF);
561     TopoDS_Solid SU = BRepFeat::Tool(mySUntil, FUntil, OrU);
562     if (!SU.IsNull()) B.Add(Comp,SU);
563     BRepAlgoAPI_Cut trP(VraiRevol,Comp);
564     TopoDS_Shape Cutsh = trP.Shape();
565     TopExp_Explorer ex(Cutsh, TopAbs_SOLID);
566     VraiRevol = ex.Current();
567     for(; ex.More(); ex.Next()) {
568       Standard_Real PrCur = BRepFeat::
569         ParametricBarycenter(ex.Current(), myBCurve);
570       if(PrF <= PrCur && PrU >= PrCur) {
571         VraiRevol = ex.Current();
572         break;
573       }
574     }
575     if(myFuse == 1 && !myJustFeat) {
576       BRepAlgoAPI_Fuse f(mySbase, VraiRevol);
577       myShape = f.Shape();
578       UpdateDescendants(f, myShape, Standard_False);
579       Done();
580     }
581     else if(myFuse == 0 && !myJustFeat) {
582       BRepAlgoAPI_Cut c(mySbase, VraiRevol);
583       myShape = c.Shape();
584       UpdateDescendants(c, myShape, Standard_False);
585       Done();
586     }
587     else {
588       myShape = VraiRevol;
589       Done();   
590     }
591   }
592 }
593
594
595 //=======================================================================
596 //function : PerformThruAll
597 //purpose  : feature throughout the initial shape
598 //=======================================================================
599
600 void BRepFeat_MakeRevol::PerformThruAll()
601 {
602 #ifdef OCCT_DEBUG
603   Standard_Boolean trc = BRepFeat_GettraceFEAT();
604   if (trc) cout << "BRepFeat_MakeRevol::PerformThruAll()" << endl;
605 #endif
606   Perform(2.*M_PI);
607 }
608
609 //=======================================================================
610 //function : PerformUntilAngle
611 //purpose  : feature till shape Until defined with the angle
612 //=======================================================================
613
614 void BRepFeat_MakeRevol::PerformUntilAngle(const TopoDS_Shape& Until,
615   const Standard_Real Angle)
616 {
617 #ifdef OCCT_DEBUG
618   Standard_Boolean trc = BRepFeat_GettraceFEAT();
619   if (trc) cout << "BRepFeat_MakeRevol::PerformUntilAngle(Until,Angle)" << endl;
620 #endif
621   if (Until.IsNull()) {
622     Perform(Angle);
623   }
624   if(Angle == 0) {
625     Perform(Until);
626   }
627   TopExp_Explorer exp(Until, TopAbs_FACE);
628   if (!exp.More()) {
629     throw Standard_ConstructionError();
630   }
631   if (!mySkface.IsNull() && Until.IsSame(mySkface)) {
632     Perform(Angle);
633     return;
634   }
635   myGluedF.Clear();
636   myPerfSelection = BRepFeat_NoSelection;
637   PerfSelectionValid();
638   mySFrom.Nullify();
639   ShapeFromValid();
640   mySUntil = Until;
641   Standard_Boolean Trf = TransformShapeFU(1);
642   ShapeUntilValid();
643
644   // Produce systematicallt an almost complete revolution
645   //  BRepSweep_Revol theRevol(myPbase,myAxis,2.*M_PI-10.*Precision::Angular());
646   LocOpe_Revol theRevol;
647   theRevol.Perform(myPbase, myAxis, Angle);
648   TopoDS_Shape VraiRevol = theRevol.Shape();
649
650   MajMap(myPbase,theRevol,myMap,myFShape,myLShape);
651
652   if(Trf) {
653     myGShape = VraiRevol;
654     GeneratedShapeValid();
655
656     TopoDS_Shape Base = theRevol.FirstShape();
657     exp.Init(Base, TopAbs_FACE);
658     TopoDS_Face theBase = TopoDS::Face(exp.Current());
659     exp.Next();
660     if(exp.More()) {
661       NotDone();
662       myStatusError = BRepFeat_InvFirstShape;
663       return;
664     }
665     GluedFacesValid();
666     //VerifGluedFaces(mySkface, theBase, myBCurve, myCurves, theRevol, myGluedF);
667
668
669     theRevol.Curves(myCurves);
670     myBCurve = theRevol.BarycCurve();
671     GlobalPerform();
672   }
673   else {
674     TColGeom_SequenceOfCurve scur;
675     theRevol.Curves(myCurves);
676     myBCurve = theRevol.BarycCurve();    
677     scur.Clear();    
678     scur.Append(myBCurve);
679     LocOpe_CSIntersector ASI(mySUntil);
680     ASI.Perform(scur);
681     if (ASI.IsDone() && ASI.NbPoints(1) >=1) {
682       TopAbs_Orientation Or = ASI.Point(1,1).Orientation();
683       TopoDS_Face FUntil = ASI.Point(1,1).Face();
684       TopoDS_Shape Comp;
685       BRep_Builder B;
686       B.MakeCompound(TopoDS::Compound(Comp));
687       TopoDS_Solid S = BRepFeat::Tool(mySUntil, FUntil, Or);
688       if (!S.IsNull()) B.Add(Comp,S);
689       BRepAlgoAPI_Cut trP(VraiRevol,Comp);
690       TopoDS_Shape Cutsh = trP.Shape();
691       TopExp_Explorer ex(Cutsh, TopAbs_SOLID);
692       for(; ex.More(); ex.Next()) {
693         TopExp_Explorer ex1(ex.Current(), TopAbs_FACE);
694         for(; ex1.More(); ex1.Next()) {
695           const TopoDS_Face& fac = TopoDS::Face(ex1.Current());
696           if(fac.IsSame(myPbase)) {
697             VraiRevol = ex.Current();
698             break;
699           }
700         }
701       }
702       if(myFuse == 1) {
703         BRepAlgoAPI_Fuse f(mySbase, VraiRevol);
704         myShape = f.Shape();
705         UpdateDescendants(f, myShape, Standard_False);
706         Done();
707       }
708       else if(myFuse == 0) {
709         BRepAlgoAPI_Cut c(mySbase, VraiRevol);
710         myShape = c.Shape();
711         UpdateDescendants(c, myShape, Standard_False);
712         Done();
713       }
714       else {
715         myShape = VraiRevol;
716         Done(); 
717       }
718     }         
719   }
720 }
721 //=======================================================================
722 //function : Curves
723 //purpose  : circles parallel to the generating edge of revolution
724 //=======================================================================
725
726 void BRepFeat_MakeRevol::Curves(TColGeom_SequenceOfCurve& scur)
727 {
728   scur = myCurves;
729 }
730
731 //=======================================================================
732 //function : BarycCurve
733 //purpose  : pass through the center of mass of the primitive
734 //=======================================================================
735
736 Handle(Geom_Curve) BRepFeat_MakeRevol::BarycCurve()
737 {
738   return myBCurve;
739 }
740
741 //=======================================================================
742 //function : VerifGluedFaces
743 //purpose  : Check intersection Tool/theSkface = thePbase
744 //           if yes -> OK otherwise -> case without gluing
745 //=======================================================================
746
747 static void VerifGluedFaces(const TopoDS_Face& theSkface,
748   const TopoDS_Shape& thePbase,
749   Handle(Geom_Curve)& theBCurve,
750   TColGeom_SequenceOfCurve& theCurves,
751   LocOpe_Revol& theRevol,
752   TopTools_DataMapOfShapeShape& theMap)
753 {
754   Standard_Boolean GluedFaces = Standard_True;
755   TopoDS_Shape VraiRevol = theRevol.Shape();
756
757   TColGeom_SequenceOfCurve scur;
758   theRevol.Curves(theCurves);
759   theBCurve = theRevol.BarycCurve();    
760   scur.Clear();    
761   scur.Append(theBCurve);
762   LocOpe_CSIntersector ASI(theSkface);
763   ASI.Perform(scur);
764   if (ASI.IsDone() && ASI.NbPoints(1) >=1) {
765     TopAbs_Orientation Or = ASI.Point(1,1).Orientation();
766     TopoDS_Face FSk = ASI.Point(1,1).Face();
767     TopoDS_Shape Comp;
768     BRep_Builder B;
769     B.MakeCompound(TopoDS::Compound(Comp));
770     TopoDS_Solid S = BRepFeat::Tool(theSkface, FSk, Or);
771     if (!S.IsNull()) B.Add(Comp,S);
772     BRepAlgoAPI_Cut trP(VraiRevol,Comp);
773     TopoDS_Shape Cutsh = trP.Shape();
774     TopExp_Explorer ex(Cutsh, TopAbs_SOLID);
775     for(; ex.More(); ex.Next()) {
776       TopExp_Explorer ex1(ex.Current(), TopAbs_FACE);
777       for(; ex1.More(); ex1.Next()) {
778         const TopoDS_Face& fac1 = TopoDS::Face(ex1.Current());
779         TopExp_Explorer ex2(thePbase, TopAbs_FACE);
780         for(; ex2.More(); ex2.Next()) {
781           const TopoDS_Face& fac2 = TopoDS::Face(ex2.Current());
782           if(fac1.IsSame(fac2)) break;
783         }
784         if (ex2.More()) break;
785       }
786       if (ex1.More()) continue;
787       GluedFaces = Standard_False;
788       break;
789     }
790     if (!GluedFaces) {
791 #ifdef OCCT_DEBUG
792       Standard_Boolean trc = BRepFeat_GettraceFEAT();
793       if (trc) cout << " Intersection Revol/skface : no gluing" << endl;
794 #endif
795       theMap.Clear();
796     }
797   }
798 }
799
800 //=======================================================================
801 //function : MajMap
802 //purpose  : management of descendants
803 //=======================================================================
804
805 static void MajMap(const TopoDS_Shape& theB,
806   const LocOpe_Revol& theP,
807   TopTools_DataMapOfShapeListOfShape& theMap, // myMap
808   TopoDS_Shape& theFShape,  // myFShape
809   TopoDS_Shape& theLShape) // myLShape
810 {
811   TopExp_Explorer exp(theP.FirstShape(),TopAbs_WIRE);
812   if (exp.More()) {
813     theFShape = exp.Current();
814     TopTools_ListOfShape thelist;
815     theMap.Bind(theFShape, thelist);
816     for (exp.Init(theP.FirstShape(),TopAbs_FACE);exp.More();exp.Next()) {
817       theMap(theFShape).Append(exp.Current());
818     }
819   }
820
821   exp.Init(theP.LastShape(),TopAbs_WIRE);
822   if (exp.More()) {
823     theLShape = exp.Current();
824     TopTools_ListOfShape thelist1;
825     theMap.Bind(theLShape, thelist1);
826     for (exp.Init(theP.LastShape(),TopAbs_FACE);exp.More();exp.Next()) {
827       theMap(theLShape).Append(exp.Current());
828     }
829   }
830
831   for (exp.Init(theB,TopAbs_EDGE); exp.More(); exp.Next()) {
832     if (!theMap.IsBound(exp.Current())) {
833       TopTools_ListOfShape thelist2;
834       theMap.Bind(exp.Current(), thelist2);
835       theMap(exp.Current()) = theP.Shapes(exp.Current());
836     }
837   }
838 }
839
840
841
842 //=======================================================================
843 //function : ToFuse
844 //purpose  : two faces samedomaine or not
845 //=======================================================================
846
847 Standard_Boolean ToFuse(const TopoDS_Face& F1,
848   const TopoDS_Face& F2)
849 {
850   if (F1.IsNull() || F2.IsNull()) {
851     return Standard_False;
852   }
853
854   Handle(Geom_Surface) S1,S2;
855   TopLoc_Location loc1, loc2;
856   Handle(Standard_Type) typS1,typS2;
857   const Standard_Real tollin = Precision::Confusion();
858   const Standard_Real tolang = Precision::Angular();
859
860   S1 = BRep_Tool::Surface(F1,loc1);
861   S2 = BRep_Tool::Surface(F2,loc2);
862
863   typS1 = S1->DynamicType();
864   typS2 = S2->DynamicType();
865
866   if (typS1 == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
867     S1 =  Handle(Geom_RectangularTrimmedSurface)::DownCast (S1)->BasisSurface();
868     typS1 = S1->DynamicType();
869   }
870
871   if (typS2 == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
872     S2 =  Handle(Geom_RectangularTrimmedSurface)::DownCast (S2)->BasisSurface();
873     typS2 = S2->DynamicType();
874   }
875
876   if (typS1 != typS2) {
877     return Standard_False;
878   }
879
880
881   Standard_Boolean ValRet = Standard_False;
882   if (typS1 == STANDARD_TYPE(Geom_Plane)) {
883     S1 = BRep_Tool::Surface(F1);  // to apply the location.
884     S2 = BRep_Tool::Surface(F2);
885     gp_Pln pl1( Handle(Geom_Plane)::DownCast (S1)->Pln());
886     gp_Pln pl2( Handle(Geom_Plane)::DownCast (S2)->Pln());
887
888     if (pl1.Position().IsCoplanar(pl2.Position(),tollin,tolang)) {
889       ValRet = Standard_True;
890     }
891   }
892
893   return ValRet;
894 }
895
896
897
898
899
900
901
902
903