src/BRepFeat/BRepFeat_MakeRevolutionForm.cxx

   1 // Created on: 1997-10-14
   2 // Created by: Olga KOULECHOVA
   3 // Copyright (c) 1997-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 #include <BRepFeat_MakeRevolutionForm.ixx>
  18
  19 #include <BRepFeat.hxx>
  20
  21 #include <LocOpe.hxx>
  22 #include <LocOpe_RevolutionForm.hxx>
  23 #include <LocOpe_CSIntersector.hxx>
  24 #include <LocOpe_PntFace.hxx>
  25 #include <LocOpe_Gluer.hxx>
  26 #include <LocOpe_FindEdges.hxx>
  27
  28 #include <gp_Vec.hxx>
  29 #include <gp_Ax1.hxx>
  30 #include <gp_Pln.hxx>
  31 #include <gp_Lin.hxx>
  32 #include <gp_Pnt.hxx>
  33
  34 #include <gp_Vec2d.hxx>
  35 #include <gp_Pnt2d.hxx>
  36
  37 #include <Geom_Curve.hxx>
  38
  39 #include <Geom2d_Curve.hxx>
  40 #include <Geom2d_Line.hxx>
  41
  42 #include <Geom_Line.hxx>
  43 #include <Geom_Circle.hxx>
  44 #include <Geom_Plane.hxx>
  45 #include <Geom_Surface.hxx>
  46 #include <Geom_CylindricalSurface.hxx>
  47 #include <Geom_ConicalSurface.hxx>
  48 #include <Geom_ToroidalSurface.hxx>
  49 #include <Geom_RectangularTrimmedSurface.hxx>
  50
  51 #include <Geom_TrimmedCurve.hxx>
  52 #include <GeomProjLib.hxx>
  53
  54 #include <Geom2dAPI_InterCurveCurve.hxx>
  55 #include <Geom2dAPI_ExtremaCurveCurve.hxx>
  56 #include <Geom2d_Curve.hxx>
  57 #include <Geom2d_Curve.hxx>
  58
  59
  60 #include <GeomAPI.hxx>
  61 #include <GeomAPI_ProjectPointOnCurve.hxx>
  62
  63 #include <TColgp_SequenceOfPnt.hxx>
  64
  65 #include <TColGeom_SequenceOfCurve.hxx>
  66
  67 #include <TColStd_Array1OfReal.hxx>
  68 #include <IntRes2d_IntersectionPoint.hxx>
  69
  70 #include <BRepTools_WireExplorer.hxx>
  71
  72 #include <BRep_Tool.hxx>
  73 #include <BRep_Builder.hxx>
  74
  75 #include <TopExp_Explorer.hxx>
  76 #include <TopExp.hxx>
  77
  78 #include <TopTools_MapOfShape.hxx>
  79 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
  80 #include <TopTools_ListOfShape.hxx>
  81 #include <TopTools_ListIteratorOfListOfShape.hxx>
  82 #include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
  83 #include <TopTools_MapIteratorOfMapOfShape.hxx>
  84 #include <TopOpeBRepBuild_HBuilder.hxx>
  85 #include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx>
  86
  87 #include <TColgp_Array1OfPnt.hxx>
  88
  89 #include <TColGeom_Array1OfCurve.hxx>
  90
  91 #include <TopoDS.hxx>
  92 #include <TopoDS_Shape.hxx>
  93 #include <TopoDS_Face.hxx>
  94
  95 #include <BRepLib_MakeVertex.hxx>
  96 #include <BRepLib_MakeEdge.hxx>
  97 #include <BRepLib_MakeFace.hxx>
  98
  99 #include <BRepTools.hxx>
 100
 101 #include <BRepPrimAPI_MakeBox.hxx>
 102 #include <BRepBuilderAPI_MakeFace.hxx>
 103
 104 #include <BRepAlgo.hxx>
 105
 106 //modified by NIZNHY-PKV Fri Mar 22 16:56:15 2002
 107 //#include <BRepAlgo_Cut.hxx>
 108 //#include <BRepAlgo_Section.hxx>
 109 //#include <BRepAlgo_Common.hxx>
 110 #include <BRepAlgoAPI_Cut.hxx>
 111 #include <BRepAlgoAPI_Section.hxx>
 112 #include <BRepAlgoAPI_Common.hxx>
 113 //modified by NIZNHY-PKV Fri Mar 22 16:56:17 2002 t
 114
 115 #include <BRepBuilderAPI_Transform.hxx>
 116 #include <BRepExtrema_ExtPC.hxx>
 117 #include <BRepExtrema_ExtCF.hxx>
 118
 119 #include <BRepTools_Modifier.hxx>
 120 #include <BRepTools_TrsfModification.hxx>
 121
 122 #include <BRepTopAdaptor_FClass2d.hxx>
 123
 124 #include <Standard_ConstructionError.hxx>
 125
 126 #include <Precision.hxx>
 127
 128
 129 #include <ElCLib.hxx>
 130 #include <ElSLib.hxx>
 131 #include <CSLib.hxx>
 132
 133 #include <GeomLProp_CLProps.hxx>
 134
 135 #ifdef DEB
 136 extern Standard_Boolean BRepFeat_GettraceFEAT();
 137 extern Standard_Boolean BRepFeat_GettraceFEATRIB();
 138 #endif
 139
 140 static void MajMap(const TopoDS_Shape&, // base
 141                    const LocOpe_RevolutionForm&,
 142                    TopTools_DataMapOfShapeListOfShape&, // myMap
 143                    TopoDS_Shape&,  // myFShape
 144                    TopoDS_Shape&); // myLShape
 145
 146 static void SetGluedFaces(const TopTools_DataMapOfShapeListOfShape& theSlmap,
 147                           LocOpe_RevolutionForm&,
 148                           const TopTools_DataMapOfShapeListOfShape& SlidingMap,
 149                           TopTools_DataMapOfShapeShape&);
 150
 151 //=======================================================================
 152 //function : Init
 153 //purpose  :
 154 //=======================================================================
 155
 156 void BRepFeat_MakeRevolutionForm::Init(const TopoDS_Shape& Sbase,
 157                                        const TopoDS_Wire& W,
 158                                        const Handle(Geom_Plane)& Plane,
 159                                        const gp_Ax1& Axis,
 160                                        const Standard_Real H1,
 161                                        const Standard_Real H2,
 162                                        const Standard_Integer Mode,
 163                                        Standard_Boolean& Modify)
 164 {
 165 #ifdef DEB
 166   Standard_Boolean trc = BRepFeat_GettraceFEAT();
 167   if (trc) cout << "BRepFeat_MakeRevolutionForm::Init" << endl;
 168 #endif
 169   Standard_Boolean RevolRib = Standard_True;
 170   Done();
 171
 172 // modify = 0 if it is not required to make sliding
 173 //        = 1 if it is intended to try to make sliding
 174   Standard_Boolean Sliding = Modify;
 175
 176   myAxe = Axis;
 177   Handle(Geom_Line) Line = new Geom_Line(Axis);
 178   Standard_Real LineFirst, LineLast;
 179
 180   LocOpe_CSIntersector ASI(Sbase);
 181   TColGeom_SequenceOfCurve scur;
 182   scur.Clear();
 183   scur.Append(Line);
 184   ASI.Perform(scur);
 185   if(ASI.IsDone() && ASI.NbPoints(1) >= 2) {
 186     LineLast = ASI.Point(1, ASI.NbPoints(1)).Parameter();
 187     LineFirst = ASI.Point(1, 1).Parameter();
 188   }
 189   else {
 190     LineFirst = RealFirst();
 191     LineLast = RealLast();
 192   }
 193
 194   Handle(Geom2d_Curve) ln2d = GeomAPI::To2d(Line, Plane->Pln());
 195
 196   TopExp_Explorer exx;
 197   Standard_Real Rad = RealLast();
 198
 199   exx.Init(W, TopAbs_EDGE);
 200   for(; exx.More(); exx.Next()) {
 201     const TopoDS_Edge& e = TopoDS::Edge(exx.Current());
 202     Standard_Real f, l;
 203     Handle(Geom_Curve) c = BRep_Tool::Curve(e, f, l);
 204     Handle(Geom2d_Curve) c2d = GeomAPI::To2d(c, Plane->Pln());
 205     Geom2dAPI_ExtremaCurveCurve extr(ln2d, c2d, LineFirst, LineLast,f,l);
 206     Quantity_Length L = RealLast();
 207     if(extr.NbExtrema() >= 1) {
 208       L = extr.LowerDistance();
 209     }
 210     gp_Pnt p1 = c->Value(f);
 211     gp_Pnt p2 = c->Value(l);
 212     GeomAPI_ProjectPointOnCurve proj1(p1, Line);
 213     GeomAPI_ProjectPointOnCurve proj2(p2, Line);
 214     if(proj1.NbPoints() < 1 || proj2.NbPoints() < 1) {
 215 #ifdef DEB
 216       if (trc) cout << " No projection points" << endl;
 217 #endif
 218       myStatusError = BRepFeat_NoProjPt;
 219       NotDone();
 220       return;
 221     }
 222     Standard_Real par1 = proj1.Distance(1);
 223     Standard_Real par2 = proj2.Distance(1);
 224     Standard_Real Par  = Min(par1, par2);
 225     if(Par<L) L = Par;
 226     if(L<Rad && L > 0.) Rad = L;
 227   }
 228
 229   Standard_Real height = Min(H1, H2);
 230
 231   if(Rad <= height) Rad = height + 0.01*height;
 232
 233   myAngle1 = asin(H1/Rad) + M_PI/10.;
 234   myAngle2 = asin(H2/Rad) + M_PI/10.;
 235
 236   if((myAngle1 - M_PI/2) > Precision::Confusion())
 237     myAngle1 = M_PI/2;
 238   if((myAngle2 - M_PI/2) > Precision::Confusion())
 239     myAngle2 = M_PI/2;
 240
 241   mySkface.Nullify();
 242   myPbase.Nullify();
 243
 244   if(Mode == 0)
 245     myFuse   = Standard_False;
 246   else // if(Mode == 1)
 247     myFuse   = Standard_True;
 248 #ifdef DEB
 249   if (trc) {
 250     if (myFuse)  cout << " Fuse" << endl;
 251     if (!myFuse)  cout << " Cut" << endl;
 252   }
 253 #endif
 254
 255 // ---Determination Tolerance : tolerance max on parameters
 256   myTol = Precision::Confusion();
 257
 258   exx.Init(W, TopAbs_VERTEX);
 259   for(; exx.More(); exx.Next()) {
 260     const Standard_Real& tol = BRep_Tool::
 261       Tolerance(TopoDS::Vertex(exx.Current()));
 262     if(tol > myTol) myTol = tol;
 263   }
 264
 265   exx.Init(Sbase, TopAbs_VERTEX);
 266   for(; exx.More(); exx.Next()) {
 267     const Standard_Real& tol = BRep_Tool::
 268       Tolerance(TopoDS::Vertex(exx.Current()));
 269     if(tol > myTol) myTol = tol;
 270   }
 271
 272   TopoDS_Shape aLocalShape = W.Oriented(TopAbs_FORWARD);
 273   myWire = TopoDS::Wire(aLocalShape);
 274 //  myWire = TopoDS::Wire(W.Oriented(TopAbs_FORWARD));
 275   myPln = Plane;
 276   myHeight1 = H1;
 277   myHeight2 = H2;
 278
 279   mySbase  = Sbase;
 280   mySlface.Clear();
 281   myShape.Nullify();
 282   myMap.Clear();
 283   myFShape.Nullify();
 284   myLShape.Nullify();
 285
 286 // ---Calculate bounding box
 287   BRep_Builder BB;
 288
 289   TopTools_ListOfShape theList;
 290
 291   TopoDS_Shape U;
 292   U.Nullify();
 293   gp_Pnt FirstCorner, LastCorner;
 294   Standard_Real bnd = HeightMax(mySbase, U, FirstCorner, LastCorner);
 295   myBnd = bnd;
 296
 297   BRepPrimAPI_MakeBox Bndbox(FirstCorner, LastCorner);
 298   TopoDS_Solid BndBox = Bndbox.Solid();
 299
 300
 301 // ---Construction of the working plane face (section bounding box)
 302   BRepLib_MakeFace PlaneF(myPln->Pln(), -6.*myBnd,
 303                           6.*myBnd, -6.*myBnd, 6.*myBnd);
 304   TopoDS_Face PlaneFace = TopoDS::Face(PlaneF.Shape());
 305
 306   //modified by NIZNHY-PKV Fri Mar 22 16:52:26 2002 f
 307   //BRepAlgo_Common PlaneS(BndBox, PlaneFace);
 308   BRepAlgoAPI_Common PlaneS(BndBox, PlaneFace);
 309   //modified by NIZNHY-PKV Fri Mar 22 16:52:31 2002 t
 310   TopExp_Explorer EXP;
 311   TopoDS_Shape PlaneSect = PlaneS.Shape();
 312   EXP.Init(PlaneSect, TopAbs_WIRE);
 313   TopoDS_Wire www = TopoDS::Wire(EXP.Current());
 314   BRepLib_MakeFace Bndface(myPln->Pln(), www, Standard_True);
 315   TopoDS_Face BndFace = TopoDS::Face(Bndface.Shape());
 316
 317
 318 // ---Find base faces of the rib
 319   TopoDS_Edge FirstEdge, LastEdge;
 320   TopoDS_Face FirstFace, LastFace;
 321   TopoDS_Vertex FirstVertex, LastVertex;
 322
 323   Standard_Boolean OnFirstFace = Standard_False;
 324   Standard_Boolean OnLastFace = Standard_False;
 325   Standard_Boolean PtOnFirstEdge = Standard_False;
 326   Standard_Boolean PtOnLastEdge = Standard_False;
 327   TopoDS_Edge OnFirstEdge, OnLastEdge;
 328   OnFirstEdge.Nullify();
 329   OnLastEdge.Nullify();
 330
 331   Standard_Boolean Data = ExtremeFaces(RevolRib, myBnd, myPln, FirstEdge, LastEdge,
 332                                        FirstFace, LastFace, FirstVertex,
 333                                        LastVertex, OnFirstFace, OnLastFace,
 334                                        PtOnFirstEdge, PtOnLastEdge,
 335                                        OnFirstEdge, OnLastEdge);
 336
 337   if(!Data) {
 338 #ifdef DEB
 339     if (trc) cout << " No Extreme faces" << endl;
 340 #endif
 341     myStatusError = BRepFeat_NoExtFace;
 342     NotDone();
 343     return;
 344   }
 345
 346
 347 // ---Proofing Point for the side of the wire to be filled - material side
 348   gp_Pnt CheckPnt = CheckPoint(FirstEdge, bnd/10., myPln);
 349
 350 //  Standard_Real f, l;
 351
 352 // ---Control sliding valid
 353 // Many cases when the sliding is abandoned
 354   Standard_Integer Concavite = 3;  // a priori the profile is not concave
 355
 356   myFirstPnt = BRep_Tool::Pnt(FirstVertex);
 357   myLastPnt  = BRep_Tool::Pnt(LastVertex);
 358
 359 // SliList : list of faces concerned by the rib
 360   TopTools_ListOfShape SliList;
 361   SliList.Append(FirstFace);
 362
 363   if(Sliding) {    // sliding
 364 #ifdef DEB
 365     if (trc) cout << " Sliding" << endl;
 366 #endif
 367     Handle(Geom_Surface) s = BRep_Tool::Surface(FirstFace);
 368     if (s->DynamicType() ==
 369         STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
 370       s = Handle(Geom_RectangularTrimmedSurface)::
 371         DownCast(s)->BasisSurface();
 372     }
 373     if(s->DynamicType() != STANDARD_TYPE(Geom_Plane) &&
 374        s->DynamicType() != STANDARD_TYPE(Geom_CylindricalSurface) &&
 375        s->DynamicType() != STANDARD_TYPE(Geom_ConicalSurface) &&
 376        s->DynamicType() != STANDARD_TYPE(Geom_ToroidalSurface))
 377       Sliding = Standard_False;
 378   }
 379
 380   if(Sliding) {     // sliding
 381     Handle(Geom_Surface) ss = BRep_Tool::Surface(LastFace);
 382     if (ss->DynamicType() ==
 383         STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
 384       ss = Handle(Geom_RectangularTrimmedSurface)::
 385         DownCast(ss)->BasisSurface();
 386     }
 387     if(ss->DynamicType() != STANDARD_TYPE(Geom_Plane) &&
 388        ss->DynamicType() != STANDARD_TYPE(Geom_CylindricalSurface) &&
 389        ss->DynamicType() != STANDARD_TYPE(Geom_ConicalSurface) &&
 390        ss->DynamicType() != STANDARD_TYPE(Geom_ToroidalSurface))
 391       Sliding = Standard_False;
 392   }
 393
 394 // Control only start and end points no control at the middle to improve
 395 // If make a control between Surface and segment 2 points limited
 396 // -> too expensive - to improve
 397   //gp_Pnt FirstCenter, LastCenter;
 398   gp_Circ FirstCircle, LastCircle;
 399   Handle(Geom_Curve) FirstCrv, LastCrv;
 400
 401   if(Sliding) {    // sliding
 402     GeomAPI_ProjectPointOnCurve proj(myFirstPnt, Line);
 403     if(proj.NbPoints() < 1) {
 404 #ifdef DEB
 405       if (trc) cout << " No First Point projection" << endl;
 406 #endif
 407       myStatusError = BRepFeat_NoProjPt;
 408       NotDone();
 409       return;
 410     }
 411     Standard_Real FirstRayon = proj.Distance(1);
 412     gp_Pnt FirstCenter = proj.Point(1);
 413
 414     GeomAPI_ProjectPointOnCurve proj1(myLastPnt, Line);
 415     if(proj.NbPoints() < 1) {
 416 #ifdef DEB
 417       if (trc) cout << " No Last Point projection" << endl;
 418 #endif
 419       myStatusError = BRepFeat_NoProjPt;
 420       NotDone();
 421       return;
 422     }
 423     Standard_Real LastRayon = proj1.Distance(1);
 424     gp_Pnt LastCenter = proj1.Point(1);
 425
 426     gp_Vec axv(myAxe.Direction());
 427     gp_Ax2 ax2(FirstCenter, axv);
 428     gp_Ax2 ax2p(LastCenter, axv);
 429     gp_Circ theFC(ax2, FirstRayon);
 430     gp_Circ theLC(ax2p, LastRayon);
 431
 432     gp_Pnt RFirstPnt1 = myFirstPnt.Rotated(myAxe, myAngle1);
 433     gp_Pnt RLastPnt1 = myLastPnt.Rotated(myAxe, myAngle1);
 434     gp_Pnt RFirstPnt2 = myFirstPnt.Rotated(myAxe, -myAngle2);
 435     gp_Pnt RLastPnt2 = myLastPnt.Rotated(myAxe, -myAngle2);
 436
 437     BRep_Builder Bu;
 438     TopoDS_Vertex v1, v2, v3, v4;
 439     Bu.MakeVertex(v1, RFirstPnt2, Precision::Confusion());
 440     Bu.MakeVertex(v2, RFirstPnt1, Precision::Confusion());
 441     Bu.MakeVertex(v3, RLastPnt2, Precision::Confusion());
 442     Bu.MakeVertex(v4, RLastPnt1, Precision::Confusion());
 443
 444     BRepLib_MakeEdge ee1(theFC, v1, v2);
 445     BRepLib_MakeEdge ee2(theLC, v3, v4);
 446
 447     if(Sliding && !PtOnFirstEdge) {
 448       BRepExtrema_ExtCF ext1(TopoDS::Edge(ee1.Shape()), FirstFace);
 449       if(ext1.NbExt() < 1 || ext1.SquareDistance(1) > Precision::SquareConfusion())
 450         Sliding = Standard_False;
 451     }
 452     if(Sliding && !PtOnLastEdge) {
 453       BRepExtrema_ExtCF ext2(ee2, LastFace); // ExtCF : curves and surfaces
 454       if(ext2.NbExt() < 1 || ext2.SquareDistance(1) > Precision::SquareConfusion())
 455         Sliding = Standard_False;
 456     }
 457     if(Sliding && PtOnFirstEdge) {
 458       Standard_Real f, l;
 459       FirstCrv = BRep_Tool::Curve(OnFirstEdge, f, l);
 460       if(FirstCrv->DynamicType() != STANDARD_TYPE(Geom_Circle))
 461         Sliding = Standard_False;
 462       else {
 463         Handle(Geom_Circle) C1 = Handle(Geom_Circle)::DownCast(FirstCrv);
 464         gp_Circ Circ = C1->Circ();
 465         FirstCircle = Circ;
 466         gp_Ax1 circax = FirstCircle.Axis();
 467         if(!circax.IsCoaxial(myAxe, Precision::Confusion(),
 468                              Precision::Confusion()))
 469           Sliding = Standard_False;
 470         else {
 471 //#ifndef DEB
 472           if(fabs(FirstCircle.Radius()-FirstRayon) >=
 473 //#else
 474 //        if(abs(FirstCircle.Radius()-FirstRayon) >=
 475 //#endif
 476              Precision::Confusion())
 477             Sliding = Standard_False;
 478         }
 479       }
 480     }
 481
 482     if(Sliding && PtOnLastEdge) {
 483       Standard_Real f, l;
 484       LastCrv = BRep_Tool::Curve(OnLastEdge, f, l);
 485       if(LastCrv->DynamicType() != STANDARD_TYPE(Geom_Circle))
 486         Sliding = Standard_False;
 487       else {
 488         Handle(Geom_Circle) C1 = Handle(Geom_Circle)::DownCast(LastCrv);
 489         gp_Circ Circ = C1->Circ();
 490         LastCircle = Circ;
 491         gp_Ax1 circax = LastCircle.Axis();
 492         if(!circax.IsCoaxial(myAxe, Precision::Confusion(),
 493                              Precision::Confusion()))
 494           Sliding = Standard_False;
 495         else {
 496           Standard_Real rad = LastCircle.Radius();
 497 //#ifndef DEB
 498           if(fabs(rad - LastRayon) >= Precision::Confusion()) {
 499 //#else
 500 //        if(abs(rad - LastRayon) >= Precision::Confusion()) {
 501 //#endif
 502             Sliding = Standard_False;
 503           }
 504         }
 505       }
 506     }
 507   }
 508
 509
 510 // Construct a great profile that goes till the bounding box
 511 // -> by tangency with first and last edge of the Wire
 512 // -> by normals to base faces : statistically better
 513 // Intersect everythin to find the final profile
 514
 515
 516 // ---case of sliding : construction of the face profile
 517   if(Sliding) {
 518 #ifdef DEB
 519     if (trc) cout << " still Sliding" << endl;
 520 #endif
 521     TopoDS_Face Prof;
 522     Standard_Boolean ProfileOK;
 523     ProfileOK = SlidingProfile(Prof,RevolRib,myTol,Concavite,myPln,BndFace,CheckPnt,
 524                                FirstFace,LastFace,FirstVertex,LastVertex,
 525                                FirstEdge,LastEdge);
 526
 527     if (!ProfileOK) {
 528 #ifdef DEB
 529       cout << "Not computable" << endl;
 530       if (trc) cout << "Face profile not computable" << endl;
 531 #endif
 532       myStatusError = BRepFeat_NoFaceProf;
 533       NotDone();
 534       return;
 535     }
 536
 537
 538 // ---Propagation on faces of the initial shape
 539 // to find the faces concerned by the rib
 540     Standard_Boolean falseside = Standard_True;
 541     Sliding = Propagate(SliList, Prof, myFirstPnt, myLastPnt, falseside);
 542 // Control if there is everything required to have the material at the proper side
 543     if(falseside == Standard_False) {
 544 #ifdef DEB
 545       cout << " Verify plane and wire orientation" << endl;
 546 #endif
 547       myStatusError = BRepFeat_FalseSide;
 548       NotDone();
 549       return;
 550     }
 551   }
 552
 553
 554 // ---Generation of the base profile of the rib
 555
 556   TopoDS_Wire w;
 557   BB.MakeWire(w);
 558   TopoDS_Edge thePreviousEdge;
 559   TopoDS_Vertex theFV;
 560   thePreviousEdge.Nullify();
 561
 562 // counter of the number of edges to fill the map
 563   Standard_Integer counter = 1;
 564
 565 // ---case of sliding
 566   if(Sliding && !myListOfEdges.IsEmpty()) {
 567     BRepTools_WireExplorer EX1(myWire);
 568     for(; EX1.More(); EX1.Next()) {
 569       const TopoDS_Edge& E = EX1.Current();
 570       if(!myLFMap.IsBound(E)) {
 571         TopTools_ListOfShape theTmpList;
 572         myLFMap.Bind(E, theTmpList);
 573       }
 574       if(E.IsSame(FirstEdge)) {
 575         Standard_Real f, l;
 576         Handle(Geom_Curve) cc = BRep_Tool::Curve(E, f, l);
 577         gp_Pnt pt;
 578         if(!FirstEdge.IsSame(LastEdge)) {
 579           pt = BRep_Tool::Pnt(TopExp::LastVertex(E,Standard_True));
 580         }
 581         else {
 582           pt = myLastPnt;
 583           Standard_Real fpar = IntPar(cc, myFirstPnt);
 584           Standard_Real lpar = IntPar(cc, pt);
 585           Handle(Geom_Curve) ccc;
 586           if(fpar > lpar) {
 587             ccc = Handle(Geom_Curve)::DownCast(cc->Reversed());
 588             cc = ccc;
 589           }
 590         }
 591         TopoDS_Edge ee1;
 592         if(thePreviousEdge.IsNull()) {
 593           BRepLib_MakeVertex v1(myFirstPnt);
 594           BRepLib_MakeVertex v2(pt);
 595           BRepLib_MakeEdge e(cc, v1, v2);
 596           ee1 = TopoDS::Edge(e.Shape());
 597         }
 598         else {
 599           const TopoDS_Vertex& v1 = TopExp::LastVertex(thePreviousEdge,Standard_True);
 600           BRepLib_MakeVertex v2(pt);
 601
 602           BRepLib_MakeEdge e(cc, v1, v2);
 603           ee1 = TopoDS::Edge(e.Shape());
 604         }
 605         TopoDS_Shape aLocalShape = ee1.Oriented(E.Orientation());
 606         ee1 = TopoDS::Edge(aLocalShape);
 607 //      ee1 = TopoDS::Edge(ee1.Oriented(E.Orientation()));
 608         if(counter == 1) theFV = TopExp::FirstVertex(ee1,Standard_True);
 609         myLFMap(E).Append(ee1);
 610         BB.Add(w, ee1);
 611         thePreviousEdge = ee1;
 612         counter++;
 613         EX1.Next();
 614         break;
 615       }
 616     }
 617
 618 // Case of several edges
 619     if(!FirstEdge.IsSame(LastEdge)) {
 620       for(; EX1.More(); EX1.Next()) {
 621         const TopoDS_Edge& E = EX1.Current();
 622         if(!myLFMap.IsBound(E)) {
 623           TopTools_ListOfShape thelist1;
 624           myLFMap.Bind(E, thelist1);
 625         }
 626         theList.Append(E);
 627         Standard_Real f, l;
 628         if(!E.IsSame(LastEdge)) {
 629           Handle(Geom_Curve) ccc = BRep_Tool::Curve(E, f, l);
 630           TopoDS_Vertex v1, v2;
 631           if(!thePreviousEdge.IsNull()) {
 632             v1 = TopExp::LastVertex(thePreviousEdge,Standard_True);
 633             v2 = TopExp::LastVertex(E,Standard_True);
 634           }
 635           else {
 636 //          v1 = TopExp::LastVertex(E,Standard_True);
 637             v1 = TopExp::FirstVertex(E,Standard_True);
 638             v2 = TopExp::LastVertex(E,Standard_True);
 639           }
 640           BRepLib_MakeEdge E1(ccc, v1, v2);
 641           TopoDS_Edge E11 = TopoDS::Edge(E1.Shape());
 642           TopoDS_Shape aLocalShape = E11.Oriented(E.Orientation());
 643           E11 = TopoDS::Edge(aLocalShape);
 644 //        E11 = TopoDS::Edge(E11.Oriented(E.Orientation()));
 645           thePreviousEdge = E11;
 646           myLFMap(E).Append(E11);
 647           BB.Add(w, E11);
 648           if(counter == 1) theFV = TopExp::FirstVertex(E11,Standard_True);
 649           counter++;
 650         }
 651         else {
 652           Standard_Real f, l;
 653           Handle(Geom_Curve) cc = BRep_Tool::Curve(E, f, l);
 654           gp_Pnt pf = BRep_Tool::Pnt(TopExp::FirstVertex(E,Standard_True));
 655           gp_Pnt pl = myLastPnt;
 656           TopoDS_Edge ee;
 657           if(thePreviousEdge.IsNull()) {
 658             BRepLib_MakeEdge e(cc, pf , pl);
 659             ee = TopoDS::Edge(e.Shape());
 660           }
 661           else {
 662             const TopoDS_Vertex& v1 = TopExp::LastVertex(thePreviousEdge,Standard_True);
 663             BRepLib_MakeVertex v2(pl);
 664             BRepLib_MakeEdge e(cc, v1, v2);
 665             ee = TopoDS::Edge(e.Shape());
 666           }
 667           TopoDS_Shape aLocalShape = ee.Oriented(E.Orientation());
 668           ee = TopoDS::Edge(aLocalShape);
 669 //        ee = TopoDS::Edge(ee.Oriented(E.Orientation()));
 670           BB.Add(w, ee);
 671           myLFMap(E).Append(ee);
 672           if(counter == 1) theFV = TopExp::FirstVertex(ee,Standard_True);
 673           thePreviousEdge = ee;
 674           counter++;
 675           break;
 676         }
 677       }
 678     }
 679
 680     TopTools_ListIteratorOfListOfShape it(myListOfEdges);
 681     Standard_Boolean FirstOK = Standard_False;
 682     Standard_Boolean LastOK = Standard_False;
 683
 684     gp_Pnt theLastPnt = myLastPnt;
 685     Standard_Integer sens = 0;
 686     TopoDS_Edge theEdge, theLEdge, theFEdge;
 687     Standard_Integer counter1 = counter;
 688     TopTools_ListOfShape NewListOfEdges;
 689     NewListOfEdges.Clear();
 690     while (!FirstOK) {
 691       const TopoDS_Edge& edg = TopoDS::Edge(it.Value());
 692       gp_Pnt fp, lp;
 693       Standard_Real f, l;
 694       Handle(Geom_Curve) ccc = BRep_Tool::Curve(edg, f, l);
 695       Handle(Geom_TrimmedCurve) cc = new Geom_TrimmedCurve(ccc, f, l);
 696       if ( edg.Orientation() == TopAbs_REVERSED) cc->Reverse();
 697
 698       fp = cc->Value(cc->FirstParameter());
 699       lp = cc->Value(cc->LastParameter());
 700       Standard_Real dist = fp.Distance(theLastPnt);
 701       if(dist <= myTol) {
 702         sens = 1;
 703         LastOK = Standard_True;
 704       }
 705       else {
 706         dist = lp.Distance(theLastPnt);
 707         if(dist <= myTol) {
 708           sens = 2;
 709           LastOK = Standard_True;
 710           cc->Reverse();
 711         }
 712       }
 713       Standard_Integer FirstFlag = 0;
 714       if(sens==1 && lp.Distance(myFirstPnt) <= myTol) {
 715         FirstOK = Standard_True;
 716         FirstFlag = 1;
 717       }
 718       else if(sens==2 && fp.Distance(myFirstPnt) <= myTol) {
 719         FirstOK = Standard_True;
 720         FirstFlag = 2;
 721       }
 722
 723       if (LastOK) {
 724         TopoDS_Edge eeee;
 725         Standard_Real fpar = cc->FirstParameter();
 726         Standard_Real lpar = cc->LastParameter();
 727         if(!FirstOK) {
 728           if(thePreviousEdge.IsNull()) {
 729             BRepLib_MakeEdge e(cc, fpar, lpar);
 730             eeee = TopoDS::Edge(e.Shape());
 731           }
 732           else {
 733             const TopoDS_Vertex& v1 = TopExp::LastVertex(thePreviousEdge,Standard_True);
 734             BRepLib_MakeVertex v2(cc->Value(lpar));
 735             BRepLib_MakeEdge e(cc, v1, v2);
 736             eeee = TopoDS::Edge(e.Shape());
 737           }
 738         }
 739         else {
 740           if(thePreviousEdge.IsNull()) {
 741             BRepLib_MakeVertex v1(cc->Value(fpar));
 742             BRepLib_MakeEdge e(cc, v1, theFV);
 743             eeee = TopoDS::Edge(e.Shape());
 744           }
 745           else {
 746             const TopoDS_Vertex& v1 = TopExp::LastVertex(thePreviousEdge,Standard_True);
 747             BRepLib_MakeEdge e(cc, v1, theFV);
 748             eeee = TopoDS::Edge(e.Shape());
 749           }
 750         }
 751
 752         thePreviousEdge = eeee;
 753         BB.Add(w, eeee);
 754         if(counter == 1) theFV = TopExp::FirstVertex(eeee,Standard_True);
 755         counter1++;
 756         NewListOfEdges.Append(edg);
 757         theEdge = eeee;
 758
 759         if(dist <= myTol)
 760           theFEdge = edg;
 761         theLastPnt = BRep_Tool::Pnt(TopExp::LastVertex(theEdge,Standard_True));
 762       }
 763
 764       if(FirstFlag == 1) {
 765         theLEdge = edg;
 766       }
 767       else if(FirstFlag == 2) {
 768         theLEdge = theEdge;
 769       }
 770
 771       if(LastOK) {
 772         it.Initialize(myListOfEdges);
 773         LastOK = Standard_False;
 774       }
 775       else if(it.More()) it.Next();
 776       else {
 777         Sliding = Standard_False;
 778         break;
 779       }
 780       sens = 0;
 781     }
 782
 783
 784     TopTools_DataMapOfShapeListOfShape SlidMap;
 785     SlidMap.Clear();
 786
 787     if(Sliding && counter1 > counter) {
 788       TopTools_ListIteratorOfListOfShape it;
 789       TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itm;
 790       TopExp_Explorer EX2(w, TopAbs_EDGE);
 791       Standard_Integer ii = 0;
 792       for(; EX2.More(); EX2.Next()) {
 793         const TopoDS_Edge& E = TopoDS::Edge(EX2.Current());
 794         ii++;
 795         if(ii >= counter && ii <= counter1) {
 796           it.Initialize(NewListOfEdges);
 797           Standard_Integer jj = 0;
 798           for(; it.More(); it.Next()) {
 799             const TopoDS_Edge& e2 = TopoDS::Edge(it.Value());
 800             jj++;
 801             if(jj== (ii - counter +1)) {
 802               itm.Initialize(mySlface);
 803               for(; itm.More(); itm.Next()) {
 804                 const TopoDS_Face& fac = TopoDS::Face(itm.Key());
 805                 const TopTools_ListOfShape& ledg = itm.Value();
 806                 TopTools_ListIteratorOfListOfShape itedg(ledg);
 807                 //Standard_Integer iiii = 0;
 808                 for(; itedg.More(); itedg.Next()) {
 809                   const TopoDS_Edge& e1 = TopoDS::Edge(itedg.Value());
 810                   if(e1.IsSame(e2)){
 811                     if(!SlidMap.IsBound(fac)) {
 812                       TopTools_ListOfShape thelist2;
 813                       SlidMap.Bind(fac, thelist2);
 814                     }
 815                     SlidMap(fac).Append(E);
 816                   }
 817                 }
 818               }
 819             }
 820           }
 821         }
 822       }
 823     }
 824
 825     mySlface.Clear();
 826     mySlface = SlidMap;
 827   }
 828
 829 // ---Arguments of LocOpe_LinearForm : arguments of the prism
 830 // sliding
 831   if(Sliding) {
 832     TopoDS_Face F;
 833     BB.MakeFace(F, myPln, myTol);
 834     BB.Add(F, w);
 835     mySkface = F;
 836     myPbase  = mySkface;
 837     mySUntil.Nullify();
 838   }
 839
 840
 841 // ---Case without sliding : construction of the face profile
 842   if(!Sliding) {
 843 #ifdef DEB
 844     if (trc) {
 845       if (Modify) cout << " Sliding failure" << endl;
 846       cout << " no Sliding" << endl;
 847     }
 848 #endif
 849     TopExp_Explorer explo1(BndFace, TopAbs_WIRE);
 850     TopoDS_Wire WWW = TopoDS::Wire(explo1.Current());
 851     BRepTools_WireExplorer explo(WWW);
 852     BRep_Builder Bu;
 853     TopoDS_Wire Wiwiwi;
 854     Bu.MakeWire(Wiwiwi);
 855     TopoDS_Vertex NewV1, NewV2, LastV, v;
 856     NewV1.Nullify(); NewV2.Nullify(); LastV.Nullify();
 857
 858     for(; explo.More(); explo.Next()) {
 859       const TopoDS_Edge& e = TopoDS::Edge(explo.Current());
 860       TopoDS_Vertex v1 = TopExp::FirstVertex(e,Standard_True);
 861       TopoDS_Vertex v2 = TopExp::LastVertex(e,Standard_True);
 862
 863       Standard_Real f, l;//, t;
 864       Handle(Geom_Curve) ln = BRep_Tool::Curve(e, f, l);
 865 //      Handle(Geom_Curve) lln = BRep_Tool::Curve(e, f, l);
 866 //      Handle(Geom_Curve) ln;
 867 //      if(e.Orientation() == TopAbs_REVERSED) {
 868 //      ln = Handle(Geom_Curve)::DownCast(lln->Reversed());
 869 //      v = v1; v1 = v2; v2= v;
 870 //      f = IntPar(ln, BRep_Tool::Pnt(v1));
 871 //      l = IntPar(ln, BRep_Tool::Pnt(v2));
 872 //      }
 873 //      else ln = lln;
 874
 875       Handle(Geom2d_Curve) l2d = GeomAPI::To2d(ln, Plane->Pln());
 876       Geom2dAPI_InterCurveCurve intcc(l2d, ln2d, Precision::Confusion());
 877       TopoDS_Vertex VV; VV.Nullify();
 878       TopoDS_Edge ee1, ee2;
 879
 880       if(intcc.NbPoints() > 0) {
 881         gp_Pnt2d P = intcc.Point(1);
 882         gp_Pnt point;
 883         myPln->D0(P.X(), P.Y(), point);
 884         Standard_Real par = IntPar(ln, point);
 885         if(f <= par && l >= par) {
 886           Bu.MakeVertex(VV, point, Precision::Confusion());
 887         }
 888       }
 889
 890       if(VV.IsNull() && NewV1.IsNull()) continue;
 891
 892       if(!VV.IsNull() && NewV1.IsNull()) {
 893         NewV1 = VV;
 894         LastV = v2;
 895         BRepLib_MakeEdge ee1(NewV1, LastV);
 896         Bu.Add(Wiwiwi, ee1);
 897         continue;
 898       }
 899
 900       if(VV.IsNull() && !NewV1.IsNull()) {
 901         BRepLib_MakeEdge ee1(LastV, v2);
 902         LastV = v2;
 903         Bu.Add(Wiwiwi, e);
 904         continue;
 905       }
 906
 907       if(!VV.IsNull() && !NewV1.IsNull()) {
 908         NewV2 = VV;
 909         BRepLib_MakeEdge ee1(LastV, NewV2);
 910         LastV = NewV2;
 911         Bu.Add(Wiwiwi, ee1);
 912         BRepLib_MakeEdge ee2(LastV, NewV1);
 913         Bu.Add(Wiwiwi, ee2);
 914         break;
 915       }
 916     }
 917
 918     BRepLib_MakeFace newbndface(myPln->Pln(), Wiwiwi, Standard_True);
 919     TopoDS_Face NewBndFace = TopoDS::Face(newbndface.Shape());
 920
 921     BRepTopAdaptor_FClass2d Cl(NewBndFace, Precision::Confusion());
 922     Standard_Real paru, parv;
 923     ElSLib::Parameters(myPln->Pln(), CheckPnt, paru, parv);
 924     gp_Pnt2d checkpnt2d(paru, parv);
 925     if(Cl.Perform(checkpnt2d, Standard_True) == TopAbs_OUT) {
 926       //modified by NIZNHY-PKV Fri Mar 22 16:52:52 2002 f
 927       //BRepAlgo_Cut c(BndFace, NewBndFace);
 928       BRepAlgoAPI_Cut c(BndFace, NewBndFace);
 929       //modified by NIZNHY-PKV Fri Mar 22 16:52:57 2002 t
 930       TopExp_Explorer exp(c.Shape(), TopAbs_WIRE);
 931       const TopoDS_Wire& w = TopoDS::Wire(exp.Current());
 932       // akm 13/02/02 : we know the plane. Why not to use it?
 933       // BRepLib_MakeFace ff(w);
 934       BRepLib_MakeFace ff(myPln->Pln(), w, Standard_True);
 935       NewBndFace = TopoDS::Face(ff.Shape());
 936     }
 937
 938
 939     if(!BRepAlgo::IsValid(NewBndFace)) {
 940 #ifdef DEB
 941       cout << "Invalid new bounding face" << endl;
 942 #endif
 943       myStatusError = BRepFeat_InvShape;
 944       NotDone();
 945       return;
 946     }
 947
 948     BndFace = NewBndFace;
 949
 950
 951     TopoDS_Face Prof;
 952     Standard_Boolean ProfileOK;
 953     ProfileOK = NoSlidingProfile(Prof,RevolRib,myTol,Concavite,myPln,
 954                                  bnd,BndFace,CheckPnt,
 955                                  FirstFace,LastFace,FirstVertex,LastVertex,
 956                                  FirstEdge,LastEdge,OnFirstFace,OnLastFace);
 957
 958     if (!ProfileOK) {
 959 #ifdef DEB
 960       cout << "Not computable" << endl;
 961       if (trc) cout << " Face profile not computable" << endl;
 962 #endif
 963       myStatusError = BRepFeat_NoFaceProf;
 964       NotDone();
 965       return;
 966     }
 967
 968
 969 // ---Propagation on the faces of the initial shape
 970 // to find the faces concerned by the rib
 971     Standard_Boolean falseside = Standard_True;
 972     Propagate(SliList, Prof, myFirstPnt, myLastPnt, falseside);
 973 // Control if there is everything required to have the material at the proper side
 974     if(falseside == Standard_False) {
 975 #ifdef DEB
 976       cout << " Verify plane and wire orientation" << endl;
 977 #endif
 978       myStatusError = BRepFeat_FalseSide;
 979       NotDone();
 980       return;
 981     }
 982
 983     mySlface.Clear();
 984
 985     TopTools_ListIteratorOfListOfShape it;
 986     it.Initialize(SliList);
 987
 988     TopoDS_Shape comp;
 989
 990     BRep_Builder BB;
 991     BB.MakeShell(TopoDS::Shell(comp));
 992
 993     for(; it.More(); it.Next()) {
 994       BB.Add(comp, it.Value());
 995     }
 996
 997     mySUntil = comp;
 998
 999     mySkface = Prof;
1000     myPbase  = Prof;
1001   }
1002
1003   mySliding = Sliding;
1004
1005   TopExp_Explorer exp;
1006   for ( exp.Init(mySbase,TopAbs_FACE);exp.More();exp.Next()) {
1007     TopTools_ListOfShape thelist3;
1008     myMap.Bind(exp.Current(), thelist3);
1009     myMap(exp.Current()).Append(exp.Current());
1010   }
1011 }
1012
1013
1014
1015 //=======================================================================
1016 //function : Add
1017 //purpose  : add elements of gluing
1018 //=======================================================================
1019
1020 void BRepFeat_MakeRevolutionForm::Add(const TopoDS_Edge& E,
1021                              const TopoDS_Face& F)
1022 {
1023 #ifdef DEB
1024   Standard_Boolean trc = BRepFeat_GettraceFEAT();
1025   if (trc) cout << "BRepFeat_MakeRevolutionForm::Add" << endl;
1026 #endif
1027   if(mySlface.IsEmpty()) {
1028     TopExp_Explorer exp;
1029     for (exp.Init(mySbase,TopAbs_FACE);exp.More();exp.Next()) {
1030       if (exp.Current().IsSame(F)) {
1031         break;
1032       }
1033     }
1034     if (!exp.More()) {
1035       Standard_ConstructionError::Raise();
1036     }
1037
1038     if (!mySlface.IsBound(F)) {
1039       TopTools_ListOfShape thelist;
1040       mySlface.Bind(F, thelist);
1041     }
1042     TopTools_ListIteratorOfListOfShape itl(mySlface(F));
1043     for (; itl.More();itl.Next()) {
1044       if (itl.Value().IsSame(E)) {
1045         break;
1046       }
1047     }
1048     if (!itl.More()) {
1049       mySlface(F).Append(E);
1050     }
1051   }
1052 }
1053
1054
1055
1056 //=======================================================================
1057 //function : Perform
1058 //purpose  : construction
1059 //=======================================================================
1060
1061 void BRepFeat_MakeRevolutionForm::Perform()
1062 {
1063 #ifdef DEB
1064   Standard_Boolean trc = BRepFeat_GettraceFEAT();
1065   if (trc) cout << "BRepFeat_MakeRevolutionForm::Perform()" << endl;
1066 #endif
1067   if(mySbase.IsNull() || mySkface.IsNull() || myPbase.IsNull()) {
1068 #ifdef DEB
1069     if (trc) cout << " Fields not initialized" << endl;
1070 #endif
1071     myStatusError = BRepFeat_NotInitialized;
1072     NotDone();
1073     return;
1074   }
1075
1076   gp_Pnt Pt;
1077
1078   TopExp_Explorer exx(myPbase, TopAbs_VERTEX);
1079   for(; exx.More(); exx.Next()) {
1080     const TopoDS_Vertex& vv = TopoDS::Vertex(exx.Current());
1081     if(!vv.IsNull()) {
1082       Pt = BRep_Tool::Pnt(vv);
1083       break;
1084     }
1085   }
1086
1087   if(myAngle2 != 0) {
1088     gp_Trsf T;
1089     T.SetRotation(myAxe, -myAngle2);
1090     BRepBuilderAPI_Transform trsf(T);
1091     trsf.Perform(myPbase, Standard_False);
1092     TopoDS_Face Pbase = TopoDS::Face(trsf.Shape());
1093     TopTools_DataMapIteratorOfDataMapOfShapeListOfShape iter(myLFMap);
1094     for(; iter.More(); iter.Next()) {
1095       const TopoDS_Shape& e1 = iter.Value().First();
1096       TopExp_Explorer ex1(myPbase, TopAbs_EDGE);
1097       TopExp_Explorer ex2(Pbase, TopAbs_EDGE);
1098       for(; ex1.More(); ex1.Next()) {
1099         if(ex1.Current().IsSame(e1)) {
1100           myLFMap(iter.Key()).Clear();
1101           myLFMap(iter.Key()).Append(ex2.Current());
1102         }
1103         ex2.Next();
1104       }
1105     }
1106
1107     TopTools_DataMapIteratorOfDataMapOfShapeListOfShape iter1(mySlface);
1108     for(; iter1.More(); iter1.Next()) {
1109       const TopoDS_Shape& f1 = iter1.Key();
1110       const TopoDS_Shape& e1 = iter1.Value().First();
1111       TopExp_Explorer ex1(myPbase, TopAbs_EDGE);
1112       TopExp_Explorer ex2(Pbase, TopAbs_EDGE);
1113       for(; ex1.More(); ex1.Next()) {
1114         const TopoDS_Shape& E1 = ex1.Current();
1115         const TopoDS_Shape& E2 = ex2.Current();
1116         if(E1.IsSame(e1)) {
1117           mySlface(f1).Clear();
1118           mySlface(f1).Append(E2);
1119         }
1120         ex2.Next();
1121       }
1122     }
1123     myPbase = Pbase;
1124     trsf.Perform(mySkface, Standard_False);
1125 // flo : check if it is required to reattributr the field mySkface
1126 //    TopoDS_Face mySkface = TopoDS::Face(trsf.Shape());
1127     mySkface = TopoDS::Face(trsf.Shape());
1128   }
1129
1130   LocOpe_RevolutionForm theForm;
1131   theForm.Perform(myPbase, myAxe, (myAngle1+myAngle2));
1132   TopoDS_Shape VraiForm = theForm.Shape();   // uncut  primitive
1133
1134 // management of descendants
1135   MajMap(myPbase,theForm,myMap,myFShape,myLShape);
1136
1137   myGluedF.Clear();
1138
1139
1140
1141   gp_Pln Pln0 = myPln->Pln();
1142   BRepLib_MakeFace f(Pln0);
1143
1144
1145   gp_Vec vec1 = myHeight1*Normal(f, Pt);
1146   gp_Vec vec2 = -myHeight2*Normal(f, Pt);
1147
1148   gp_Pln Pln1 = Pln0.Translated(vec1);
1149   gp_Pln Pln2 = Pln0.Translated(vec2);
1150
1151   BRepLib_MakeFace ff1(Pln1);
1152   BRepLib_MakeFace ff2(Pln2);
1153   TopoDS_Face f1 = TopoDS::Face(ff1.Shape());
1154   TopoDS_Face f2 = TopoDS::Face(ff2.Shape());
1155   BRepFeat::FaceUntil(mySbase, f1);
1156   BRepFeat::FaceUntil(mySbase, f2);
1157
1158   LocOpe_CSIntersector ASI1(f1);
1159   LocOpe_CSIntersector ASI2(f2);
1160
1161   Handle(Geom_Line) normale = new Geom_Line(Pt, vec1);
1162   TColGeom_SequenceOfCurve scur;
1163   scur.Append(normale);
1164
1165   ASI1.Perform(scur);
1166   ASI2.Perform(scur);
1167
1168   if(!ASI1.IsDone() || !ASI2.IsDone() ||
1169      ASI1.NbPoints(1) != 1 || ASI2.NbPoints(1) != 1) {
1170 #ifdef DEB
1171     if (trc) cout << " Intersection failure" << endl;
1172 #endif
1173     myStatusError = BRepFeat_BadIntersect;
1174     NotDone();
1175     return;
1176   }
1177
1178   TopAbs_Orientation Ori1 = ASI1.Point(1,1).Orientation();
1179   TopAbs_Orientation Ori2 = TopAbs::Reverse(ASI2.Point(1,1).Orientation());
1180   TopoDS_Face FF1 = ASI1.Point(1,1).Face();
1181   TopoDS_Face FF2 = ASI2.Point(1,1).Face();
1182
1183   TopoDS_Shape Comp;
1184   BRep_Builder B;
1185   B.MakeCompound(TopoDS::Compound(Comp));
1186   TopoDS_Solid S1 = BRepFeat::Tool(f1,FF1,Ori1);
1187   TopoDS_Solid S2 = BRepFeat::Tool(f2,FF2,Ori2);
1188   if (!S1.IsNull()) B.Add(Comp,S1);
1189   if (!S2.IsNull()) B.Add(Comp,S2);
1190
1191   //modified by NIZNHY-PKV Fri Mar 22 16:53:20 2002 f
1192   //BRepAlgo_Cut trP(VraiForm,Comp);
1193   BRepAlgoAPI_Cut trP(VraiForm,Comp);
1194   //modified by NIZNHY-PKV Fri Mar 22 16:53:23 2002 t
1195   // coupe de la nervure par deux plans parallels
1196   TopTools_DataMapOfShapeListOfShape SlidingMap;
1197
1198 // management of descendants
1199
1200   TopTools_DataMapIteratorOfDataMapOfShapeListOfShape it1;
1201   it1.Initialize(myMap);
1202   for(; it1.More(); it1.Next()) {
1203     const TopoDS_Shape& orig = it1.Key();
1204     if(it1.Value().IsEmpty()) continue;
1205     const TopoDS_Shape& sh = it1.Value().First();
1206     exx.Init(VraiForm, TopAbs_FACE);
1207     for(; exx.More(); exx.Next()) {
1208       const TopoDS_Face& fac = TopoDS::Face(exx.Current());
1209       TopExp_Explorer exx1(fac, TopAbs_WIRE);
1210       const TopoDS_Wire& thew = TopoDS::Wire(exx1.Current());
1211       if(thew.IsSame(myFShape)) {
1212         const TopTools_ListOfShape& desfaces = trP.Modified(f2);
1213         myMap(myFShape) = desfaces;
1214         continue;
1215       }
1216       else if(thew.IsSame(myLShape)) {
1217         const TopTools_ListOfShape& desfaces = trP.Modified(f1);
1218         myMap(myLShape) = desfaces;
1219         continue;
1220       }
1221       if(fac.IsSame(sh)) {
1222         if (trP.IsDeleted(fac)) {
1223         }
1224         else {
1225           const TopTools_ListOfShape& desfaces = trP.Modified(fac);
1226           if(!desfaces.IsEmpty()) {
1227             myMap(orig).Clear();
1228             myMap(orig) = trP.Modified(fac);
1229           }
1230         }
1231       }
1232     }
1233   }
1234
1235   exx.Init(VraiForm, TopAbs_FACE);
1236   for(; exx.More(); exx.Next()) {
1237     const TopoDS_Face& fac = TopoDS::Face(exx.Current());
1238     TopTools_ListOfShape thelist;
1239     SlidingMap.Bind(fac, thelist);
1240     if (trP.IsDeleted(fac)) {
1241     }
1242     else {
1243       const TopTools_ListOfShape& desfaces = trP.Modified(fac);
1244       if(!desfaces.IsEmpty())
1245         SlidingMap(fac) = desfaces;
1246       else
1247         SlidingMap(fac).Append(fac);
1248     }
1249   }
1250
1251
1252 // gestion of faces of sliding
1253   SetGluedFaces(mySlface, theForm, SlidingMap, myGluedF);
1254
1255   VraiForm = trP.Shape();   // primitive cut
1256
1257   if(!myGluedF.IsEmpty())
1258     myPerfSelection = BRepFeat_NoSelection;
1259   else
1260     myPerfSelection = BRepFeat_SelectionSh;
1261
1262   exx.Init(myPbase, TopAbs_EDGE);
1263   for(; exx.More(); exx.Next()) {
1264     const TopoDS_Edge& e = TopoDS::Edge(exx.Current());
1265     if(!myMap.IsBound(e)) {
1266 #ifdef DEB
1267       if (trc) cout << " Sliding face not in Base shape" << endl;
1268 #endif
1269       myStatusError = BRepFeat_IncSlidFace;
1270       NotDone();
1271       return;
1272     }
1273   }
1274
1275   myGShape = VraiForm;
1276
1277   if(!myGluedF.IsEmpty() && !mySUntil.IsNull()) {
1278 #ifdef DEB
1279     cout << "The case is not computable" << endl;
1280     if (trc) cout << " Glued faces not empty and Until shape not null" << endl;
1281 #endif
1282     myStatusError = BRepFeat_InvShape;
1283     NotDone();
1284     return;
1285   }
1286
1287   LFPerform();    // topological reconstruction
1288 }
1289
1290
1291 //=======================================================================
1292 //function : Propagate
1293 //purpose  : propagation on the faces of the inital shape, find faces
1294 // concerned by the rib
1295 //=======================================================================
1296
1297 Standard_Boolean BRepFeat_MakeRevolutionForm::Propagate(TopTools_ListOfShape& SliList,
1298                                                         const TopoDS_Face& fac,
1299                                                         const gp_Pnt& Firstpnt,
1300                                                         const gp_Pnt& Lastpnt,
1301                                                         Standard_Boolean& falseside)
1302 {
1303 #ifdef DEB
1304   Standard_Boolean trc = BRepFeat_GettraceFEATRIB();
1305   if (trc) cout << "BRepFeat_MakeRevolutionForm::Propagate" << endl;
1306 #endif
1307   gp_Pnt Firstpoint = Firstpnt;
1308   gp_Pnt Lastpoint = Lastpnt;
1309
1310   Standard_Boolean result = Standard_True;
1311   TopoDS_Face CurrentFace, saveFace;
1312   CurrentFace = TopoDS::Face(SliList.First());
1313   saveFace = CurrentFace;
1314   //  BRepBuilderAPI_MakeFace fac(myPln);
1315   Standard_Boolean LastOK = Standard_False, FirstOK= Standard_False;
1316   TopoDS_Vertex v1, v2, v3, v4, Vert;
1317   //modified by NIZNHY-PKV Fri Mar 22 16:54:09 2002 f
1318   //BRepAlgo_Section sect (fac, CurrentFace, Standard_False);
1319   BRepAlgoAPI_Section sect (fac, CurrentFace, Standard_False);
1320   //modified by NIZNHY-PKV Fri Mar 22 16:54:14 2002 t
1321   sect.Approximation(Standard_True);
1322   sect.Build();
1323   TopExp_Explorer Ex;
1324   TopoDS_Edge e, e1;
1325   gp_Pnt FP, LP;
1326   Standard_Integer ii = 0;
1327   for (Ex.Init(sect.Shape(), TopAbs_EDGE); Ex.More(); Ex.Next()) {
1328     ii++;
1329     if(ii==1){
1330       e = TopoDS::Edge(Ex.Current());
1331     }
1332     else if (ii > 1) {
1333       e1 = TopoDS::Edge(Ex.Current());
1334       break;
1335     }
1336   }
1337   if(e.IsNull()) {
1338     falseside = Standard_False;
1339     return Standard_False;
1340   }
1341   //
1342   //modified by NIZNHY-PKV Tue Apr  2 15:08:23 2002 f
1343   if(!e1.IsNull()) {
1344     Standard_Real aTolV1, aTolV2;
1345     myListOfEdges.Clear();
1346     TopTools_ListOfShape thelist;
1347     mySlface.Bind(CurrentFace, thelist);
1348     mySlface(CurrentFace).Append(e1);
1349
1350     myListOfEdges.Append(e1);
1351
1352     v1 = TopExp::FirstVertex(e1,Standard_True);
1353     v2 = TopExp::LastVertex (e1,Standard_True);
1354
1355     FP = BRep_Tool::Pnt(v1);
1356     LP = BRep_Tool::Pnt(v2);
1357
1358     aTolV1=BRep_Tool::Tolerance(v1);
1359     aTolV2=BRep_Tool::Tolerance(v2);
1360
1361     if(FP.Distance(Firstpoint) <= aTolV1 ||
1362        FP.Distance(Lastpoint)  <= aTolV1) {
1363       FirstOK = Standard_True;
1364     }
1365     if(LP.Distance(Firstpoint)<= aTolV2 ||
1366        LP.Distance(Lastpoint) <= aTolV2) {
1367       LastOK = Standard_True;
1368     }
1369
1370     if(LastOK && FirstOK) {
1371       return result;
1372     }
1373
1374     else {
1375       myListOfEdges.Clear();
1376     }
1377   }
1378   //modified by NIZNHY-PKV Tue Apr  2 15:08:26 2002 t
1379   //
1380   if(!e1.IsNull()) {
1381     myListOfEdges.Clear();
1382     TopTools_ListOfShape thelist1;
1383     mySlface.Bind(CurrentFace, thelist1);
1384     mySlface(CurrentFace).Append(e);
1385
1386     myListOfEdges.Append(e);
1387
1388 //    mySlface.Bind(CurrentFace,TopTools_ListOfShape());
1389     mySlface(CurrentFace).Append(e1);
1390 //    myListOfEdges.Append(e1);
1391
1392     v1 = TopExp::FirstVertex(e,Standard_True);
1393     v2 = TopExp::LastVertex(e,Standard_True);
1394     v3 = TopExp::FirstVertex(e1,Standard_True);
1395     v4 = TopExp::LastVertex(e1,Standard_True);
1396     gp_Pnt p1, p2, p3, p4;
1397     p1 = BRep_Tool::Pnt(v1); FP = p1;
1398     p2 = BRep_Tool::Pnt(v2);  LP = p2;
1399     p3 = BRep_Tool::Pnt(v3);
1400     p4 = BRep_Tool::Pnt(v4);
1401     if(p1.Distance(Firstpoint) <= BRep_Tool::Tolerance(v1)) {
1402       if(p3.Distance(Lastpoint) <= BRep_Tool::Tolerance(v3)) {
1403         FirstOK = Standard_True;
1404         Lastpoint = p4;
1405       }
1406       else if(p4.Distance(Lastpoint) <= BRep_Tool::Tolerance(v4)) {
1407         FirstOK = Standard_True;
1408         Lastpoint = p3;
1409       }
1410       else {
1411         e1.Nullify();
1412       }
1413     }
1414     else if(p1.Distance(Lastpoint) <= BRep_Tool::Tolerance(v1)) {
1415       if(p3.Distance(Firstpoint) <= BRep_Tool::Tolerance(v3)) {
1416         FirstOK = Standard_True;
1417         Firstpoint = p4;
1418       }
1419       else if(p4.Distance(Firstpoint) <= BRep_Tool::Tolerance(v4)) {
1420         FirstOK = Standard_True;
1421         Firstpoint = p3;
1422       }
1423       else {
1424         e1.Nullify();
1425       }
1426     }
1427     else if(p2.Distance(Firstpoint) <= BRep_Tool::Tolerance(v2)) {
1428       if(p3.Distance(Lastpoint) <= BRep_Tool::Tolerance(v3)) {
1429         LastOK = Standard_True;
1430         Lastpoint = p4;
1431       }
1432       else if(p4.Distance(Lastpoint) <= BRep_Tool::Tolerance(v4)) {
1433         LastOK = Standard_True;
1434         Lastpoint = p3;
1435       }
1436       else {
1437         e1.Nullify();
1438       }
1439     }
1440     else if(p2.Distance(Lastpoint) <= BRep_Tool::Tolerance(v2)) {
1441       if(p3.Distance(Firstpoint) <= BRep_Tool::Tolerance(v3)) {
1442         LastOK = Standard_True;
1443         Firstpoint = p4;
1444       }
1445       else if(p4.Distance(Firstpoint) <= BRep_Tool::Tolerance(v4)) {
1446         LastOK = Standard_True;
1447         Firstpoint = p3;
1448       }
1449       else {
1450         e1.Nullify();
1451       }
1452     }
1453     else {
1454       e = e1;
1455       e1.Nullify();
1456     }
1457   }
1458   if(e1.IsNull()) {
1459     myListOfEdges.Clear();
1460     TopTools_ListOfShape thelist2;
1461     mySlface.Bind(CurrentFace, thelist2);
1462     mySlface(CurrentFace).Append(e);
1463
1464     myListOfEdges.Append(e);
1465
1466     v1 = TopExp::FirstVertex(e,Standard_True);
1467     v2 = TopExp::LastVertex(e,Standard_True);
1468
1469     FP = BRep_Tool::Pnt(v1);
1470     LP = BRep_Tool::Pnt(v2);
1471
1472     if(FP.Distance(Firstpoint) <= BRep_Tool::Tolerance(v1)
1473        || FP.Distance(Lastpoint) <= BRep_Tool::Tolerance(v1)) {
1474       FirstOK = Standard_True;
1475     }
1476     if(LP.Distance(Firstpoint) <= BRep_Tool::Tolerance(v2)
1477        || LP.Distance(Lastpoint) <= BRep_Tool::Tolerance(v2)) {
1478       LastOK = Standard_True;
1479     }
1480
1481     if(LastOK && FirstOK) {
1482       return result;
1483     }
1484   }
1485
1486   TopTools_IndexedDataMapOfShapeListOfShape mapedges;
1487   TopExp::MapShapesAndAncestors(mySbase, TopAbs_EDGE, TopAbs_FACE, mapedges);
1488   TopExp_Explorer ex;
1489   TopoDS_Edge FirstEdge;
1490
1491   TopoDS_Vertex Vprevious;  Vprevious.Nullify();
1492   TopoDS_Vertex Vpreprevious;  Vpreprevious.Nullify();
1493
1494   while(!FirstOK) {
1495    // find edge connected to v1:
1496     gp_Pnt pt;
1497     if(!v1.IsNull()) pt= BRep_Tool::Pnt(v1);
1498     gp_Pnt ptprev;
1499     if(!Vprevious.IsNull()) ptprev = BRep_Tool::Pnt(Vprevious);
1500     gp_Pnt ptpreprev;
1501     if(!Vpreprevious.IsNull()) ptpreprev = BRep_Tool::Pnt(Vpreprevious);
1502
1503     if((!Vprevious.IsNull() && ptprev.Distance(pt) <= myTol) ||
1504        (!Vpreprevious.IsNull() && ptpreprev.Distance(pt) <= myTol)) {
1505       falseside = Standard_False;
1506       return Standard_False;
1507     }
1508
1509     for (ex.Init(CurrentFace, TopAbs_EDGE); ex.More(); ex.Next()) {
1510       const TopoDS_Edge& e = TopoDS::Edge(ex.Current());
1511
1512       BRepExtrema_ExtPC projF(v1, e);
1513
1514       if(projF.IsDone() && projF.NbExt() >=1) {
1515         Standard_Real dist2min = RealLast();
1516         Standard_Integer index = 0;
1517         for (Standard_Integer sol =1 ; sol <= projF.NbExt(); sol++) {
1518           if (projF.SquareDistance(sol) <= dist2min) {
1519             index = sol;
1520             dist2min = projF.SquareDistance(sol);
1521           }
1522         }
1523         if (index != 0) {
1524           if (dist2min <= BRep_Tool::Tolerance(e) * BRep_Tool::Tolerance(e)) {
1525             FirstEdge = e;
1526             break;
1527           }
1528         }
1529       }
1530     }
1531
1532     const TopTools_ListOfShape& L = mapedges.FindFromKey(FirstEdge);
1533     TopTools_ListIteratorOfListOfShape It(L);
1534
1535     for (; It.More(); It.Next()) {
1536       const TopoDS_Face& FF = TopoDS::Face(It.Value());
1537       if (!FF.IsSame(CurrentFace)) {
1538         CurrentFace = FF;
1539         break;
1540       }
1541     }
1542
1543     //modified by NIZNHY-PKV Fri Mar 22 16:54:28 2002 f
1544     //BRepAlgo_Section sectf (fac, CurrentFace, Standard_False);
1545     BRepAlgoAPI_Section sectf (fac, CurrentFace, Standard_False);
1546     //modified by NIZNHY-PKV Fri Mar 22 16:54:33 2002 t
1547     sectf.Approximation(Standard_True);
1548     sectf.Build();
1549
1550     TopoDS_Edge edg1;
1551     for (Ex.Init(sectf.Shape(), TopAbs_EDGE); Ex.More(); Ex.Next()) {
1552       edg1 = TopoDS::Edge(Ex.Current());
1553       gp_Pnt ppp1 = BRep_Tool::Pnt(TopExp::FirstVertex(edg1,Standard_True));
1554       gp_Pnt ppp2 = BRep_Tool::Pnt(TopExp::LastVertex(edg1,Standard_True));
1555       if(ppp1.Distance(BRep_Tool::Pnt(v1)) <= BRep_Tool::Tolerance(v1) ||
1556          ppp2.Distance(BRep_Tool::Pnt(v1)) <= BRep_Tool::Tolerance(v1))
1557         break;
1558     }
1559
1560     TopTools_ListOfShape thelist3;
1561     mySlface.Bind(CurrentFace, thelist3);
1562     mySlface(CurrentFace).Append(edg1);
1563     myListOfEdges.Append(edg1);
1564
1565     if (!edg1.IsNull()) SliList.Prepend(CurrentFace);
1566     else return Standard_False;
1567
1568     Vert = TopExp::FirstVertex(edg1,Standard_True);
1569     gp_Pnt PP = BRep_Tool::Pnt(Vert);
1570     FP = BRep_Tool::Pnt(v1);
1571     Standard_Real tol = BRep_Tool::Tolerance(edg1);
1572     Standard_Real tol1 = BRep_Tool::Tolerance(v1);
1573     if(tol1 > tol) tol = tol1;
1574     Standard_Real dist = PP.Distance(FP);
1575     if (dist <= tol) {
1576       Vpreprevious = Vprevious;
1577       Vprevious = v1;
1578       v1 = TopExp::LastVertex(edg1,Standard_True);
1579     }
1580     else {
1581       Vpreprevious = Vprevious;
1582       Vprevious = v1;
1583       v1 = Vert;
1584     }
1585
1586     FP = BRep_Tool::Pnt(v1);
1587
1588     if(FP.Distance(Firstpoint) <= BRep_Tool::Tolerance(v1)
1589        || FP.Distance(Lastpoint) <= BRep_Tool::Tolerance(v1)) {
1590       FirstOK = Standard_True;
1591     }
1592   }
1593
1594   CurrentFace = saveFace;
1595   Vprevious.Nullify();
1596   Vpreprevious.Nullify();
1597
1598   while(!LastOK) {
1599     // find edge connected to v2:
1600     gp_Pnt pt;
1601     if(!v2.IsNull()) pt= BRep_Tool::Pnt(v2);
1602     gp_Pnt ptprev;
1603     if(!Vprevious.IsNull()) ptprev = BRep_Tool::Pnt(Vprevious);
1604     gp_Pnt ptpreprev;
1605     if(!Vpreprevious.IsNull()) ptpreprev = BRep_Tool::Pnt(Vpreprevious);
1606
1607     if((!Vprevious.IsNull() && ptprev.Distance(pt) <= myTol) ||
1608        (!Vpreprevious.IsNull() && ptpreprev.Distance(pt) <= myTol)) {
1609       falseside = Standard_False;
1610       return Standard_False;
1611     }
1612
1613     for (ex.Init(CurrentFace, TopAbs_EDGE); ex.More(); ex.Next()) {
1614       const TopoDS_Edge& e = TopoDS::Edge(ex.Current());
1615       BRepExtrema_ExtPC projF(v2, e);
1616
1617       if(projF.IsDone() && projF.NbExt() >=1) {
1618         Standard_Real dist2min = RealLast();
1619         Standard_Integer index = 0;
1620         for (Standard_Integer sol =1 ; sol <= projF.NbExt(); sol++) {
1621           if (projF.SquareDistance(sol) <= dist2min) {
1622             index = sol;
1623             dist2min = projF.SquareDistance(sol);
1624           }
1625         }
1626         if (index != 0) {
1627           if (dist2min <= BRep_Tool::Tolerance(e) * BRep_Tool::Tolerance(e)) {
1628             FirstEdge = e;
1629             break;
1630           }
1631         }
1632       }
1633     }
1634
1635     const TopTools_ListOfShape& L = mapedges.FindFromKey(FirstEdge);
1636     TopTools_ListIteratorOfListOfShape It(L);
1637
1638     for (; It.More(); It.Next()) {
1639       const TopoDS_Face& FF = TopoDS::Face(It.Value());
1640       if (!FF.IsSame(CurrentFace)) {
1641         CurrentFace = FF;
1642         break;
1643       }
1644     }
1645
1646     ii = 0;
1647
1648     //modified by NIZNHY-PKV Fri Mar 22 16:54:45 2002 f
1649     //BRepAlgo_Section sectf (fac, CurrentFace, Standard_False);
1650     BRepAlgoAPI_Section sectf (fac, CurrentFace, Standard_False);
1651     //modified by NIZNHY-PKV Fri Mar 22 16:54:52 2002 t
1652     sectf.Approximation(Standard_True);
1653     sectf.Build();
1654
1655     TopoDS_Edge edg2;
1656     for (Ex.Init(sectf.Shape(), TopAbs_EDGE); Ex.More(); Ex.Next()) {
1657       edg2 = TopoDS::Edge(Ex.Current());
1658       gp_Pnt ppp1 = BRep_Tool::Pnt(TopExp::FirstVertex(edg2,Standard_True));
1659       gp_Pnt ppp2 = BRep_Tool::Pnt(TopExp::LastVertex(edg2,Standard_True));
1660       if(ppp1.Distance(BRep_Tool::Pnt(v2)) <= BRep_Tool::Tolerance(v2) ||
1661          ppp2.Distance(BRep_Tool::Pnt(v2)) <= BRep_Tool::Tolerance(v2))
1662         break;
1663     }
1664     TopTools_ListOfShape thelist4;
1665     mySlface.Bind(CurrentFace, thelist4);
1666     mySlface(CurrentFace).Append(edg2);
1667     myListOfEdges.Append(edg2);
1668
1669     if (!edg2.IsNull()) SliList.Append(CurrentFace);
1670     else return Standard_False;
1671
1672     Vert = TopExp::FirstVertex(edg2,Standard_True);
1673     gp_Pnt PP = BRep_Tool::Pnt(Vert);
1674     FP = BRep_Tool::Pnt(v2);
1675     if (PP.Distance(FP)<= BRep_Tool::Tolerance(v2)) {
1676       Vpreprevious = Vprevious;
1677       Vprevious = v2;
1678       v2 = TopExp::LastVertex(edg2,Standard_True);
1679     }
1680     else {
1681       v2 = Vert;
1682     }
1683     FP = BRep_Tool::Pnt(v2);
1684
1685
1686     if(FP.Distance(Firstpoint) <= BRep_Tool::Tolerance(v2)
1687        || FP.Distance(Lastpoint) <= BRep_Tool::Tolerance(v2)) {
1688       LastOK = Standard_True;
1689     }
1690   }
1691   if(!e1.IsNull())     myListOfEdges.Append(e1);
1692   return result;
1693
1694 }
1695
1696
1697 //=======================================================================
1698 //function : MajMap
1699 //purpose  : management of descendants
1700 //=======================================================================
1701
1702 static void MajMap(const TopoDS_Shape& theB,
1703                    const LocOpe_RevolutionForm& theP,
1704                    TopTools_DataMapOfShapeListOfShape& theMap, // myMap
1705                    TopoDS_Shape& theFShape,  // myFShape
1706                    TopoDS_Shape& theLShape) // myLShape
1707 {
1708   TopExp_Explorer exp(theP.FirstShape(),TopAbs_WIRE);
1709   if (exp.More()) {
1710     theFShape = exp.Current();
1711     TopTools_ListOfShape thelist;
1712     theMap.Bind(theFShape, thelist);
1713     for (exp.Init(theP.FirstShape(),TopAbs_FACE);exp.More();exp.Next()) {
1714       const TopoDS_Shape& sh = exp.Current();
1715       theMap(theFShape).Append(sh);
1716     }
1717   }
1718
1719   exp.Init(theP.LastShape(),TopAbs_WIRE);
1720   if (exp.More()) {
1721     theLShape = exp.Current();
1722     TopTools_ListOfShape thelist1;
1723     theMap.Bind(theLShape, thelist1);
1724     for (exp.Init(theP.LastShape(),TopAbs_FACE);exp.More();exp.Next()) {
1725       const TopoDS_Shape& sh = exp.Current();
1726       theMap(theLShape).Append(sh);
1727     }
1728   }
1729
1730   for (exp.Init(theB,TopAbs_EDGE); exp.More(); exp.Next()) {
1731     if (!theMap.IsBound(exp.Current())) {
1732       TopTools_ListOfShape thelist2;
1733       theMap.Bind(exp.Current(), thelist2);
1734       theMap(exp.Current()) = theP.Shapes(exp.Current());
1735     }
1736   }
1737 }
1738
1739
1740  //=======================================================================
1741 //function : SetGluedFaces
1742 //purpose  : managemnet of sliding faces
1743 //=======================================================================
1744
1745 static void SetGluedFaces(const TopTools_DataMapOfShapeListOfShape& theSlmap,
1746                           LocOpe_RevolutionForm& thePrism,
1747                           const TopTools_DataMapOfShapeListOfShape& SlidingMap,
1748                           TopTools_DataMapOfShapeShape& theMap)
1749 {
1750   // Slidings
1751   TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itm(theSlmap);
1752   if(!theSlmap.IsEmpty()) {
1753     for (; itm.More(); itm.Next()) {
1754       const TopoDS_Face& fac = TopoDS::Face(itm.Key());
1755       const TopTools_ListOfShape& ledg = itm.Value();
1756       TopTools_ListIteratorOfListOfShape it;
1757       for (it.Initialize(ledg); it.More(); it.Next()) {
1758         const TopTools_ListOfShape& gfac = thePrism.Shapes(it.Value());
1759         if (gfac.Extent() != 1) {
1760 #ifdef DEB
1761           cout << "Pb SetGluedFace" << endl;
1762 #endif
1763         }
1764         TopTools_DataMapIteratorOfDataMapOfShapeListOfShape iterm(SlidingMap);
1765         for(; iterm.More(); iterm.Next()) {
1766           const TopoDS_Face& ff = TopoDS::Face(iterm.Key());
1767           const TopTools_ListOfShape& lfaces = iterm.Value();
1768           if(lfaces.IsEmpty()) continue;
1769           const TopoDS_Face& fff = TopoDS::Face(lfaces.First());
1770           if(gfac.First().IsSame(ff)) theMap.Bind(fff,fac);
1771         }
1772       }
1773     }
1774   }
1775 }
1776