src/BRepFeat/BRepFeat_RibSlot.cxx

   1 // Created on: 1997-10-08
   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
  18 #include <Bnd_Box.hxx>
  19 #include <BRep_Tool.hxx>
  20 #include <BRep_Builder.hxx>
  21 #include <BRepAdaptor_Surface.hxx>
  22 #include <BRepAlgo.hxx>
  23 #include <BRepAlgoAPI_BooleanOperation.hxx>
  24 #include <BRepAlgoAPI_Cut.hxx>
  25 #include <BRepAlgoAPI_Fuse.hxx>
  26 #include <BRepBndLib.hxx>
  27 #include <BRepClass3d_SolidClassifier.hxx>
  28 #include <BRepFeat.hxx>
  29 #include <BRepFeat_Builder.hxx>
  30 #include <BRepFeat_RibSlot.hxx>
  31 #include <BRepIntCurveSurface_Inter.hxx>
  32 #include <BRepLib.hxx>
  33 #include <BRepLib_MakeEdge.hxx>
  34 #include <BRepLib_MakeFace.hxx>
  35 #include <BRepLib_MakeVertex.hxx>
  36 #include <BRepLib_MakeWire.hxx>
  37 #include <BRepTools_WireExplorer.hxx>
  38 #include <BRepTopAdaptor_FClass2d.hxx>
  39 #include <CSLib.hxx>
  40 #include <ElCLib.hxx>
  41 #include <ElSLib.hxx>
  42 #include <Geom2dAPI_InterCurveCurve.hxx>
  43 #include <Geom_Circle.hxx>
  44 #include <Geom_Curve.hxx>
  45 #include <Geom_Ellipse.hxx>
  46 #include <Geom_Hyperbola.hxx>
  47 #include <Geom_Line.hxx>
  48 #include <Geom_Parabola.hxx>
  49 #include <Geom_Plane.hxx>
  50 #include <Geom_TrimmedCurve.hxx>
  51 #include <GeomAdaptor_Curve.hxx>
  52 #include <GeomAPI.hxx>
  53 #include <GeomAPI_ProjectPointOnCurve.hxx>
  54 #include <GeomLib.hxx>
  55 #include <gp_Ax1.hxx>
  56 #include <gp_Dir.hxx>
  57 #include <gp_Pln.hxx>
  58 #include <gp_Pnt.hxx>
  59 #include <gp_Vec.hxx>
  60 #include <LocOpe.hxx>
  61 #include <LocOpe_CSIntersector.hxx>
  62 #include <LocOpe_FindEdges.hxx>
  63 #include <LocOpe_Gluer.hxx>
  64 #include <LocOpe_PntFace.hxx>
  65 #include <Precision.hxx>
  66 #include <Standard_ConstructionError.hxx>
  67 #include <Standard_NoSuchObject.hxx>
  68 #include <TColGeom_SequenceOfCurve.hxx>
  69 #include <TopAbs.hxx>
  70 #include <TopExp.hxx>
  71 #include <TopExp_Explorer.hxx>
  72 #include <TopoDS.hxx>
  73 #include <TopoDS_Edge.hxx>
  74 #include <TopoDS_Face.hxx>
  75 #include <TopoDS_Shape.hxx>
  76 #include <TopoDS_Vertex.hxx>
  77 #include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
  78 #include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx>
  79 #include <TopTools_ListIteratorOfListOfShape.hxx>
  80 #include <TopTools_ListOfShape.hxx>
  81 #include <TopTools_MapIteratorOfMapOfShape.hxx>
  82 #include <TopTools_MapOfShape.hxx>
  83
  84 #ifdef OCCT_DEBUG
  85 extern Standard_Boolean BRepFeat_GettraceFEAT();
  86 extern Standard_Boolean BRepFeat_GettraceFEATRIB();
  87 #endif
  88
  89 //=======================================================================
  90 //function : LFPerform
  91 //purpose  : topological reconstruction of ribs
  92 //=======================================================================
  93
  94 void BRepFeat_RibSlot::LFPerform()
  95 {
  96 #ifdef OCCT_DEBUG
  97   Standard_Boolean trc = BRepFeat_GettraceFEAT();
  98   if (trc) std::cout << "BRepFeat_RibSlot::LFPerform()" << std::endl;
  99 #endif
 100   if (mySbase.IsNull() || myPbase.IsNull() || mySkface.IsNull()
 101       || myGShape.IsNull() || myLFMap.IsEmpty()) {
 102 #ifdef OCCT_DEBUG
 103     std::cout << "Topological reconstruction is impossible" << std::endl;
 104     if (trc) std::cout << " Fields not initialized" << std::endl;
 105 #endif
 106     myStatusError = BRepFeat_NotInitialized;
 107     NotDone();
 108     return;
 109   }
 110
 111   TopExp_Explorer exp,exp2;
 112   Standard_Integer theOpe = 2;
 113
 114   if (!myGluedF.IsEmpty()) {
 115     theOpe = 1;
 116   }
 117
 118       // Hope that there is just a solid in the result
 119   if (!mySUntil.IsNull()) {
 120     for (exp2.Init(mySUntil,TopAbs_FACE); exp2.More(); exp2.Next()) {
 121       const TopoDS_Shape& funtil = exp2.Current();
 122       for (exp.Init(mySbase,TopAbs_FACE); exp.More(); exp.Next()) {
 123         if (exp.Current().IsSame(funtil)) {
 124           break;
 125         }
 126       }
 127       if (!exp.More()) {
 128         break;
 129       }
 130     }
 131   }
 132
 133   TopTools_ListIteratorOfListOfShape it,it2;
 134   TopTools_DataMapIteratorOfDataMapOfShapeShape itm;
 135   //Standard_Integer sens = 0;
 136
 137   LocOpe_Gluer theGlue;
 138
 139   //case of gluing
 140
 141   if (theOpe == 1) {
 142     Standard_Boolean Collage = Standard_True;
 143
 144     LocOpe_FindEdges theFE;
 145     TopTools_DataMapOfShapeListOfShape locmap;
 146     theGlue.Init(mySbase,myGShape);
 147     for (itm.Initialize(myGluedF); itm.More();itm.Next()) {
 148       const TopoDS_Face& glface = TopoDS::Face(itm.Key());
 149       const TopoDS_Face& fac = TopoDS::Face(myGluedF(glface));
 150       for (exp.Init(myGShape,TopAbs_FACE); exp.More(); exp.Next()) {
 151         if (exp.Current().IsSame(glface)) {
 152           break;
 153         }
 154       }
 155       if (exp.More()) {
 156         Collage = BRepFeat::IsInside(glface, fac);
 157         if(!Collage) {
 158           theOpe = 2;
 159           break;
 160         }
 161         else {
 162           theGlue.Bind(glface, fac);
 163           theFE.Set(glface, fac);
 164           for (theFE.InitIterator(); theFE.More();theFE.Next()) {
 165             theGlue.Bind(theFE.EdgeFrom(),theFE.EdgeTo());
 166           }
 167         }
 168       }
 169     }
 170
 171     LocOpe_Operation ope = theGlue.OpeType();
 172     if (ope == LocOpe_INVALID ||
 173         (myFuse && ope != LocOpe_FUSE) ||
 174         (!myFuse && ope != LocOpe_CUT) ||
 175         (!Collage)) {
 176       theOpe = 2;
 177 #ifdef OCCT_DEBUG
 178       std::cout << "Passage to topological operations" << std::endl;
 179 #endif
 180     }
 181   }
 182
 183 // gluing is always applicable
 184
 185   if (theOpe == 1) {
 186     theGlue.Perform();
 187     if (theGlue.IsDone()) {
 188       UpdateDescendants(theGlue);
 189       myNewEdges = theGlue.Edges();
 190       myTgtEdges = theGlue.TgtEdges();
 191       //
 192       Done();
 193       myShape = theGlue.ResultingShape();
 194       BRepLib::SameParameter(myShape, 1.e-7, Standard_True);
 195     }
 196     else {
 197       theOpe = 2;
 198 #ifdef OCCT_DEBUG
 199       std::cout << "Passage to topologic operation" << std::endl;
 200 #endif
 201     }
 202   }
 203
 204   // case without gluing
 205   if (theOpe == 2) {
 206     BRepFeat_Builder theBuilder;
 207     TopTools_ListOfShape partsoftool;
 208     BRepClass3d_SolidClassifier oussa;
 209     Standard_Boolean bFlag;
 210     TopTools_ListIteratorOfListOfShape aIt;
 211
 212     bFlag = (myPerfSelection == BRepFeat_NoSelection) ? 0 : 1;
 213     //
 214     theBuilder.Init(mySbase, myGShape);
 215     theBuilder.SetOperation(myFuse, bFlag);
 216     //
 217     theBuilder.Perform();
 218     if (bFlag) {
 219       theBuilder.PartsOfTool(partsoftool);
 220       aIt.Initialize(partsoftool);
 221       if (aIt.More() && myPerfSelection != BRepFeat_NoSelection) {
 222         Standard_Real toler = (BRep_Tool::Tolerance(myPbase))*2;
 223         //
 224         for(; aIt.More(); aIt.Next()) {
 225           oussa.Load(aIt.Value());
 226           oussa.Perform(myFirstPnt, toler);
 227           TopAbs_State sp1=oussa.State();
 228           oussa.Perform(myLastPnt, toler);
 229           TopAbs_State sp2=oussa.State();
 230           if (!(sp1 == TopAbs_OUT || sp2 == TopAbs_OUT)) {
 231             const TopoDS_Shape& S = aIt.Value();
 232             theBuilder.KeepPart(S);
 233           }
 234         }
 235       }
 236       //
 237       theBuilder.PerformResult();
 238       myShape = theBuilder.Shape();
 239     } else {
 240       myShape = theBuilder.Shape();
 241     }
 242     Done();
 243   }
 244 }
 245
 246 //=======================================================================
 247 //function : IsDeleted
 248 //purpose  :
 249 //=======================================================================
 250
 251 Standard_Boolean BRepFeat_RibSlot::IsDeleted(const TopoDS_Shape& F)
 252 {
 253   return (myMap(F).IsEmpty());
 254 }
 255
 256
 257 //=======================================================================
 258 //function : Modified
 259 //purpose  :
 260 //=======================================================================
 261
 262 const TopTools_ListOfShape& BRepFeat_RibSlot::Modified
 263    (const TopoDS_Shape& F)
 264 {
 265 #ifdef OCCT_DEBUG
 266   Standard_Boolean trc = BRepFeat_GettraceFEAT();
 267   if (trc) std::cout << "BRepFeat_RibSlot::Modified" << std::endl;
 268 #endif
 269   if (myMap.IsBound(F)) {
 270     static TopTools_ListOfShape list;
 271     list.Clear();
 272     TopTools_ListIteratorOfListOfShape ite(myMap(F));
 273     for(; ite.More(); ite.Next()) {
 274       const TopoDS_Shape& sh = ite.Value();
 275       if(!sh.IsSame(F))
 276         list.Append(sh);
 277     }
 278     return list;
 279   }
 280   return myGenerated; // empty list
 281 }
 282
 283 //=======================================================================
 284 //function : Generated
 285 //purpose  :
 286 //=======================================================================
 287
 288 const TopTools_ListOfShape& BRepFeat_RibSlot::Generated
 289    (const TopoDS_Shape& S)
 290 {
 291 #ifdef OCCT_DEBUG
 292   Standard_Boolean trc = BRepFeat_GettraceFEAT();
 293   if (trc) std::cout << "BRepFeat_RibSlot::Generated" << std::endl;
 294 #endif
 295   if(S.ShapeType() != TopAbs_FACE) {
 296     myGenerated.Clear();
 297     if(myLFMap.IsEmpty() || !myLFMap.IsBound(S)) {
 298       if (myMap.IsBound(S)) { // check if filter on face or not
 299         static TopTools_ListOfShape list;
 300         list.Clear();
 301         TopTools_ListIteratorOfListOfShape ite(myMap(S));
 302         for(; ite.More(); ite.Next()) {
 303           const TopoDS_Shape& sh = ite.Value();
 304           if(!sh.IsSame(S))
 305             list.Append(sh);
 306         }
 307         return list;
 308       }
 309       else return myGenerated;
 310     }
 311     else {
 312       myGenerated.Clear();
 313       TopTools_ListIteratorOfListOfShape it(myLFMap(S));
 314       static TopTools_ListOfShape list;
 315       list.Clear();
 316       for(; it.More(); it.Next()) {
 317         if(myMap.IsBound(it.Value())) {
 318           TopTools_ListIteratorOfListOfShape it1(myMap(it.Value()));
 319           for(; it1.More(); it1.Next()) {
 320             const TopoDS_Shape& sh = it1.Value();
 321             if(!sh.IsSame(S))
 322               list.Append(sh);
 323           }
 324         }
 325       }
 326       return list;
 327     }
 328   }
 329   else return myGenerated;
 330 }
 331
 332
 333 //=======================================================================
 334 //function : UpdateDescendants
 335 //purpose  :
 336 //=======================================================================
 337
 338 void BRepFeat_RibSlot::UpdateDescendants(const LocOpe_Gluer& G)
 339 {
 340   TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itdm;
 341   TopTools_ListIteratorOfListOfShape it,it2;
 342   TopTools_MapIteratorOfMapOfShape itm;
 343
 344   for (itdm.Initialize(myMap);itdm.More();itdm.Next()) {
 345     const TopoDS_Shape& orig = itdm.Key();
 346     TopTools_MapOfShape newdsc;
 347     for (it.Initialize(itdm.Value());it.More();it.Next()) {
 348       const TopoDS_Face& fdsc = TopoDS::Face(it.Value());
 349       for (it2.Initialize(G.DescendantFaces(fdsc));
 350            it2.More();it2.Next()) {
 351         newdsc.Add(it2.Value());
 352       }
 353     }
 354     myMap.ChangeFind(orig).Clear();
 355     for (itm.Initialize(newdsc);itm.More();itm.Next()) {
 356       myMap.ChangeFind(orig).Append(itm.Key());
 357     }
 358   }
 359 }
 360
 361
 362 //=======================================================================
 363 //function : FirstShape
 364 //purpose  :
 365 //=======================================================================
 366
 367 const TopTools_ListOfShape& BRepFeat_RibSlot::FirstShape() const
 368 {
 369   if (!myFShape.IsNull()) {
 370     return myMap(myFShape);
 371   }
 372   return myGenerated; // empty list
 373 }
 374
 375
 376 //=======================================================================
 377 //function : LastShape
 378 //purpose  :
 379 //=======================================================================
 380
 381 const TopTools_ListOfShape& BRepFeat_RibSlot::LastShape() const
 382 {
 383   if (!myLShape.IsNull()) {
 384     return myMap(myLShape);
 385   }
 386   return myGenerated; // empty list
 387 }
 388
 389 //=======================================================================
 390 //function : FacesForDraft
 391 //purpose  :
 392 //=======================================================================
 393
 394 const TopTools_ListOfShape& BRepFeat_RibSlot::FacesForDraft() const
 395 {
 396   return myFacesForDraft;
 397 }
 398
 399
 400 //=======================================================================
 401 //function : NewEdges
 402 //purpose  :
 403 //=======================================================================
 404
 405 const TopTools_ListOfShape& BRepFeat_RibSlot::NewEdges() const
 406 {
 407  return myNewEdges;
 408 }
 409
 410 //=======================================================================
 411 //function : TgtEdges
 412 //purpose  :
 413 //=======================================================================
 414
 415 const TopTools_ListOfShape& BRepFeat_RibSlot::TgtEdges() const
 416 {
 417   return myTgtEdges;
 418 }
 419
 420
 421 //=======================================================================
 422 //function : CurrentStatusError
 423 //purpose  :
 424 //=======================================================================
 425
 426 BRepFeat_StatusError BRepFeat_RibSlot::CurrentStatusError() const
 427 {
 428   return myStatusError;
 429 }
 430
 431
 432 //=======================================================================
 433 //function : CheckPoint
 434 //purpose  : Proofing point material side (side of extrusion)
 435 //=======================================================================
 436
 437 gp_Pnt BRepFeat_RibSlot::CheckPoint(const TopoDS_Edge& e,
 438                                     const Standard_Real ,//bnd,
 439                                     const Handle(Geom_Plane)& Pln)
 440
 441 {
 442 #ifdef OCCT_DEBUG
 443   Standard_Boolean trc = BRepFeat_GettraceFEATRIB();
 444   if (trc) std::cout << "BRepFeat_RibSlot::CheckPoint" << std::endl;
 445 #endif
 446 // Vector product : normal to plane X direction Wire
 447 // -> gives the material side
 448 // Proofing point somewhat inside the material side
 449   Standard_Real f, l;
 450   Handle(Geom_Curve) cc = BRep_Tool::Curve(e, f, l);
 451
 452   gp_Vec tgt; gp_Pnt pp;
 453   Standard_Real par = ( f + l) / 2.;
 454
 455   cc->D1(par, pp, tgt);
 456
 457   if ( e.Orientation() == TopAbs_REVERSED) tgt.Reverse();
 458
 459   gp_Vec D = -tgt.Crossed(Pln->Pln().Position().Direction())/10.;
 460   pp.Translate(D);
 461
 462   return pp;
 463
 464 }
 465
 466
 467 //=======================================================================
 468 //function : Normal
 469 //purpose  : calculate the normal to a face in a point
 470 //=======================================================================
 471
 472 gp_Dir BRepFeat_RibSlot::Normal(const TopoDS_Face& F,const gp_Pnt& P)
 473
 474 {
 475 #ifdef OCCT_DEBUG
 476   Standard_Boolean trc = BRepFeat_GettraceFEATRIB();
 477   if (trc) std::cout << "BRepFeat_RibSlot::Normal" << std::endl;
 478 #endif
 479   Standard_Real U, V;
 480   gp_Pnt pt;
 481
 482   BRepAdaptor_Surface AS(F, Standard_True);
 483
 484   switch ( AS.GetType()) {
 485
 486   case GeomAbs_Plane:
 487     ElSLib::Parameters(AS.Plane(),P,U,V); break;
 488
 489   case GeomAbs_Cylinder:
 490     ElSLib::Parameters(AS.Cylinder(),P,U,V); break;
 491
 492   case GeomAbs_Cone:
 493     ElSLib::Parameters(AS.Cone(),P,U,V); break;
 494
 495   case GeomAbs_Torus:
 496     ElSLib::Parameters(AS.Torus(),P,U,V); break;
 497
 498   default:
 499     {
 500       return gp_Dir(1., 0., 0.);
 501     }
 502   }
 503
 504   gp_Vec D1U, D1V;
 505
 506   AS.D1(U, V, pt, D1U, D1V);
 507   gp_Dir N;
 508   CSLib_DerivativeStatus St;
 509   CSLib::Normal(D1U, D1V, Precision::Confusion(), St, N);
 510   if(F.Orientation() == TopAbs_FORWARD) N.Reverse();
 511   return N;
 512 }
 513
 514 //=======================================================================
 515 //function : IntPar
 516 //purpose  : calculate the parameter of a point on a curve
 517 //=======================================================================
 518
 519 Standard_Real BRepFeat_RibSlot::IntPar(const Handle(Geom_Curve)& C,
 520                                        const gp_Pnt& P)
 521
 522 {
 523   if ( C.IsNull()) return 0.;
 524
 525   GeomAdaptor_Curve AC(C);
 526   Standard_Real U;
 527
 528   switch ( AC.GetType()) {
 529
 530   case GeomAbs_Line:
 531     U = ElCLib::Parameter(AC.Line(),P); break;
 532
 533   case GeomAbs_Circle:
 534     U = ElCLib::Parameter(AC.Circle(),P); break;
 535
 536   case GeomAbs_Ellipse:
 537     U = ElCLib::Parameter(AC.Ellipse(),P); break;
 538
 539   case GeomAbs_Hyperbola:
 540     U = ElCLib::Parameter(AC.Hyperbola(),P); break;
 541
 542   case GeomAbs_Parabola:
 543     U = ElCLib::Parameter(AC.Parabola(),P); break;
 544
 545   default:
 546     U = 0.;
 547   }
 548
 549   return U;
 550 }
 551
 552
 553 //=======================================================================
 554 //function : EdgeExtention
 555 //purpose  : extention of a edge by tangence
 556 //=======================================================================
 557
 558 void BRepFeat_RibSlot::EdgeExtention(TopoDS_Edge& e,
 559                                      const Standard_Real bnd,
 560                                      const Standard_Boolean FirstLast)
 561 {
 562 #ifdef OCCT_DEBUG
 563   Standard_Boolean trc = BRepFeat_GettraceFEAT();
 564   if (trc) std::cout << "BRepFeat_RibSlot::EdgeExtention" << std::endl;
 565 #endif
 566   Standard_Real f, l;
 567   Handle(Geom_Curve) cu = BRep_Tool::Curve(e, f, l);
 568   Handle(Geom_BoundedCurve) C =
 569     new Geom_TrimmedCurve(cu, f, l);
 570
 571   TopoDS_Edge E;
 572
 573   if(cu->DynamicType() == STANDARD_TYPE(Geom_Line) ||
 574      cu->DynamicType() == STANDARD_TYPE(Geom_Circle) ||
 575      cu->DynamicType() == STANDARD_TYPE(Geom_Ellipse) ||
 576      cu->DynamicType() == STANDARD_TYPE(Geom_Hyperbola) ||
 577      cu->DynamicType() == STANDARD_TYPE(Geom_Parabola)) {
 578     if(FirstLast) {
 579       BRepLib_MakeEdge Edg(cu, f-bnd/10., l);
 580       E = TopoDS::Edge(Edg.Shape());
 581     }
 582     else {
 583       BRepLib_MakeEdge Edg(cu, f, l+bnd/10.);
 584       E = TopoDS::Edge(Edg.Shape());
 585     }
 586   }
 587   else {
 588     Handle(Geom_Line) ln;
 589     gp_Pnt Pt;
 590     gp_Pnt pnt;
 591     gp_Vec vct;
 592     if(FirstLast) {
 593       C->D1(f, pnt, vct);
 594       ln = new Geom_Line(pnt, -vct);
 595       ln->D0(bnd/1000., Pt);
 596       GeomLib::ExtendCurveToPoint(C, Pt, GeomAbs_G1, Standard_False);
 597       BRepLib_MakeEdge Edg(C, Pt, BRep_Tool::Pnt(TopExp::LastVertex(e,Standard_True)));
 598       E = TopoDS::Edge(Edg.Shape());
 599     }
 600     else {
 601       C->D1(l, pnt, vct);
 602       ln = new Geom_Line(pnt, vct);
 603       ln->D0(bnd/1000., Pt);
 604       GeomLib::ExtendCurveToPoint(C, Pt, GeomAbs_G1, Standard_True);
 605       BRepLib_MakeEdge Edg(C, BRep_Tool::Pnt(TopExp::FirstVertex(e,Standard_True)), Pt);
 606       E = TopoDS::Edge(Edg.Shape());
 607     }
 608   }
 609   e = E;
 610 }
 611
 612
 613 //=======================================================================
 614 //function : ChoiceOfFaces
 615 //purpose  : choose face of support in case of support on an edge
 616 //=======================================================================
 617
 618 TopoDS_Face BRepFeat_RibSlot::ChoiceOfFaces(TopTools_ListOfShape& faces,
 619                                             const Handle(Geom_Curve)& cc,
 620                                             const Standard_Real par,
 621                                             const Standard_Real ,//bnd,
 622                                             const Handle(Geom_Plane)& Pln)
 623
 624 {
 625 #ifdef OCCT_DEBUG
 626   Standard_Boolean trc = BRepFeat_GettraceFEATRIB();
 627   if (trc) std::cout << "BRepFeat_RibSlot::ChoiceOfFaces" << std::endl;
 628 #endif
 629   TopoDS_Face FFF;
 630
 631   gp_Pnt pp;
 632   gp_Vec tgt;
 633
 634   cc->D1(par, pp, tgt);
 635
 636   Handle(Geom_Line) l1 = new Geom_Line(pp, tgt);
 637
 638   TColGeom_SequenceOfCurve scur;
 639   Standard_Integer Counter = 0;
 640
 641
 642   gp_Ax1 Axe(pp, Pln->Position().Direction());
 643   for ( Standard_Integer i = 1; i <=8; i++) {
 644     Handle(Geom_Curve) L =
 645       Handle(Geom_Curve)::DownCast(l1->Rotated(Axe, i*M_PI/9.));
 646     scur.Append(L);
 647     Counter++;
 648   }
 649
 650   TopTools_ListIteratorOfListOfShape it;
 651   it.Initialize(faces);
 652   Standard_Real Par = RealLast();
 653   for(; it.More(); it.Next()) {
 654     const TopoDS_Face& f = TopoDS::Face(it.Value());
 655     LocOpe_CSIntersector ASI(f);
 656     ASI.Perform(scur);
 657     if(!ASI.IsDone()) continue;
 658     for(Standard_Integer jj = 1; jj<=Counter; jj++) {
 659       if(ASI.NbPoints(jj) >= 1) {
 660         Standard_Real app = ASI.Point(jj,1).Parameter();
 661         if(app >= 0 &&  app < Par) {
 662           Par = app;
 663           FFF = f;
 664         }
 665       }
 666     }
 667   }
 668
 669   return FFF;
 670 }
 671
 672
 673 //=======================================================================
 674 //function : HeightMax
 675 //purpose  : Calculate the height of the prism following the parameters of a bounding box
 676 //=======================================================================
 677
 678 Standard_Real BRepFeat_RibSlot::HeightMax(const TopoDS_Shape& theSbase,
 679                                           const TopoDS_Shape& theSUntil,
 680                                           gp_Pnt& p1,
 681                                           gp_Pnt& p2)
 682 {
 683 #ifdef OCCT_DEBUG
 684   Standard_Boolean trc = BRepFeat_GettraceFEATRIB();
 685   if (trc) std::cout << "BRepFeat_RibSlot::HeightMax" << std::endl;
 686 #endif
 687   Bnd_Box Box;
 688   BRepBndLib::Add(theSbase,Box);
 689   if(!theSUntil.IsNull()) {
 690     BRepBndLib::Add(theSUntil,Box);
 691   }
 692   Standard_Real c[6], bnd;
 693   Box.Get(c[0],c[2],c[4],c[1],c[3],c[5]);
 694   bnd = c[0];
 695   for(Standard_Integer i = 0 ; i < 6; i++) {
 696     if(c[i] > bnd) bnd = c[i];
 697   }
 698   p1.SetCoord(c[0]-2.*bnd, c[1]-2.*bnd, c[2]-2.*bnd);
 699   p2.SetCoord(c[3]+2.*bnd, c[4]+2.*bnd, c[5]+2.*bnd);
 700   return(bnd);
 701 }
 702
 703 //=======================================================================
 704 //function : ExtremeFaces
 705 //purpose  : Calculate the base faces of the rib
 706 //=======================================================================
 707
 708 Standard_Boolean BRepFeat_RibSlot::ExtremeFaces(const Standard_Boolean RevolRib,
 709                                                 const Standard_Real bnd,
 710                                                 const Handle(Geom_Plane)& Pln,
 711                                                 TopoDS_Edge&   FirstEdge,
 712                                                 TopoDS_Edge&   LastEdge,
 713                                                 TopoDS_Face&   FirstFace,
 714                                                 TopoDS_Face&   LastFace,
 715                                                 TopoDS_Vertex& FirstVertex,
 716                                                 TopoDS_Vertex& LastVertex,
 717                                                 Standard_Boolean& OnFirstFace,
 718                                                 Standard_Boolean& OnLastFace,
 719                                                 Standard_Boolean& PtOnFirstEdge,
 720                                                 Standard_Boolean& PtOnLastEdge,
 721                                                 TopoDS_Edge& OnFirstEdge,
 722                                                 TopoDS_Edge& OnLastEdge)
 723
 724 {
 725 #ifdef OCCT_DEBUG
 726   Standard_Boolean trc = BRepFeat_GettraceFEAT();
 727   if (trc) std::cout << "BRepFeat_RibSlot::ExtremeFaces" << std::endl;
 728 #endif
 729   Standard_Boolean Data = Standard_True;
 730   FirstFace.Nullify();
 731   LastFace.Nullify();
 732   FirstEdge.Nullify();
 733   LastEdge.Nullify();
 734   PtOnFirstEdge = Standard_False;
 735   PtOnLastEdge = Standard_False;
 736   OnFirstEdge.Nullify();
 737   OnLastEdge.Nullify();
 738
 739   BRepIntCurveSurface_Inter inter;
 740   BRep_Builder B;
 741   TopExp_Explorer ex1;
 742
 743   Standard_Boolean FirstOK = Standard_False, LastOK = Standard_False;
 744
 745   Standard_Integer NumberOfEdges = 0;
 746   TopExp_Explorer exp(myWire, TopAbs_EDGE);
 747
 748   for(; exp.More(); exp.Next()) {
 749     NumberOfEdges++;
 750   }
 751
 752 // ---the wire includes only one edge
 753   if(NumberOfEdges == 1) {
 754 #ifdef OCCT_DEBUG
 755     if (trc) std::cout << " One Edge" << std::endl;
 756 #endif
 757     exp.ReInit();
 758     Standard_Real f, l;//, f1, l1, temp;
 759     gp_Pnt firstpoint, lastpoint;
 760
 761 // Points limit the unique edge
 762     const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
 763     Handle(Geom_Curve) cc = BRep_Tool::Curve(E, f, l);
 764     gp_Pnt p1 = BRep_Tool::Pnt(TopExp::FirstVertex(E,Standard_True));
 765     gp_Pnt p2 = BRep_Tool::Pnt(TopExp::LastVertex(E,Standard_True));
 766
 767     Standard_Real FirstPar = f; Standard_Real LastPar = l;
 768
 769
 770 // ---Find if 2 points limiting the unique edge of the wire
 771 //    are on an edge or a vertex of the base shape
 772     Standard_Boolean PtOnFirstVertex = Standard_False;
 773     Standard_Boolean PtOnLastVertex = Standard_False;
 774     TopoDS_Vertex OnFirstVertex, OnLastVertex;
 775     PtOnEdgeVertex(RevolRib, mySbase, p1, FirstVertex, LastVertex,
 776                    PtOnFirstEdge, OnFirstEdge, PtOnFirstVertex, OnFirstVertex);
 777     PtOnEdgeVertex(RevolRib, mySbase, p2, FirstVertex, LastVertex,
 778                    PtOnLastEdge, OnLastEdge, PtOnLastVertex, OnLastVertex);
 779
 780     TopTools_MapOfShape Map;
 781
 782     if(PtOnFirstEdge) {
 783       if (!PtOnFirstVertex) {
 784 // Find FirstFace : face of the base shape containing OnFirstEdge
 785 //                  meeting ChoiceOfFaces
 786         TopExp_Explorer ex4, ex5;
 787         ex4.Init(mySbase, TopAbs_FACE);
 788         TopTools_ListOfShape faces;
 789         faces.Clear();
 790         Map.Clear();
 791         for(; ex4.More(); ex4.Next()) {
 792           const TopoDS_Face& fx = TopoDS::Face(ex4.Current());
 793           if ( !Map.Add(fx)) continue;
 794           ex5.Init(ex4.Current(), TopAbs_EDGE);
 795           for(; ex5.More(); ex5.Next()) {
 796             const TopoDS_Edge& ee = TopoDS::Edge(ex5.Current());
 797             if(ee.IsSame(OnFirstEdge)) {
 798               faces.Append(fx);
 799             }
 800           }
 801         }
 802         if(!faces.IsEmpty())  {
 803           TopoDS_Face FFF = ChoiceOfFaces(faces, cc, FirstPar+bnd/50., bnd/50., Pln);
 804           if(!FFF.IsNull()) FirstFace = FFF;
 805         }
 806       }
 807       else if(PtOnFirstVertex) {
 808 // Find FirstFace : face of the base shape containing OnFirstVertex
 809 //                  meeting ChoiceOfFaces
 810         TopExp_Explorer ex4, ex5;
 811         ex4.Init(mySbase, TopAbs_FACE);
 812         TopTools_ListOfShape faces;
 813         faces.Clear();
 814         Map.Clear();
 815         for(; ex4.More(); ex4.Next()) {
 816           const TopoDS_Face& fx = TopoDS::Face(ex4.Current());
 817           if ( !Map.Add(fx)) continue;
 818           ex5.Init(ex4.Current(), TopAbs_VERTEX);
 819           for(; ex5.More(); ex5.Next()) {
 820             const TopoDS_Vertex& vv = TopoDS::Vertex(ex5.Current());
 821             if(vv.IsSame(OnFirstVertex)) {
 822               faces.Append(fx);
 823               break;
 824             }
 825           }
 826         }
 827         if(!faces.IsEmpty())  {
 828           TopoDS_Face FFF = ChoiceOfFaces(faces, cc, FirstPar+bnd/50., bnd/50., Pln);
 829           if(!FFF.IsNull()) FirstFace = FFF;
 830         }
 831       }
 832       FirstEdge = E;
 833       BRepLib_MakeVertex v(p1);
 834       FirstVertex = v;
 835       OnFirstFace = Standard_True;
 836     }
 837
 838     if(PtOnLastEdge) {
 839       if (!PtOnLastVertex) {
 840 // Find LastFace : face of the base shape containing OnLastEdge
 841 //                 meeting ChoiceOfFaces
 842         TopExp_Explorer ex4, ex5;
 843         ex4.Init(mySbase, TopAbs_FACE);
 844         TopTools_ListOfShape faces;
 845         faces.Clear();
 846         Map.Clear();
 847         for(; ex4.More(); ex4.Next()) {
 848           const TopoDS_Face& fx = TopoDS::Face(ex4.Current());
 849           if ( !Map.Add(fx)) continue;
 850           ex5.Init(ex4.Current(), TopAbs_EDGE);
 851           for(; ex5.More(); ex5.Next()) {
 852             const TopoDS_Edge& ee = TopoDS::Edge(ex5.Current());
 853             if(ee.IsSame(OnLastEdge)) {
 854               faces.Append(fx);
 855               break;
 856             }
 857           }
 858         }
 859         if(!faces.IsEmpty())  {
 860           TopoDS_Face FFF = ChoiceOfFaces(faces, cc, LastPar-bnd/50., bnd/50., Pln);
 861           if(!FFF.IsNull()) LastFace = FFF;
 862         }
 863       }
 864       else if(PtOnLastEdge && PtOnLastVertex) {
 865 // Find LastFace : face of the base shape containing OnLastVertex
 866 //                 meeting ChoiceOfFaces
 867         TopExp_Explorer ex4, ex5;
 868         ex4.Init(mySbase, TopAbs_FACE);
 869         TopTools_ListOfShape faces;
 870         faces.Clear();
 871         Map.Clear();
 872         for(; ex4.More(); ex4.Next()) {
 873           const TopoDS_Face& fx = TopoDS::Face(ex4.Current());
 874           if ( !Map.Add(fx)) continue;
 875           ex5.Init(ex4.Current(), TopAbs_VERTEX);
 876           for(; ex5.More(); ex5.Next()) {
 877             const TopoDS_Vertex& vv = TopoDS::Vertex(ex5.Current());
 878             if(vv.IsSame(OnLastVertex)) {
 879               faces.Append(fx);
 880               break;
 881             }
 882           }
 883         }
 884         if(!faces.IsEmpty())  {
 885           TopoDS_Face FFF = ChoiceOfFaces(faces, cc, LastPar-bnd/50., bnd/50., Pln);
 886           if(!FFF.IsNull()) LastFace = FFF;
 887         }
 888       }
 889       LastEdge = E;
 890       BRepLib_MakeVertex v(p2);
 891       LastVertex = v;
 892       OnLastFace = Standard_True;
 893     }
 894
 895     if(!FirstFace.IsNull() && !LastFace.IsNull())  {
 896       return Standard_True;
 897     }
 898
 899 //--- FirstFace or LastFace was not found
 900 #ifdef OCCT_DEBUG
 901     if (trc) std::cout << " FirstFace or LastFace null" << std::endl;
 902 #endif
 903     LocOpe_CSIntersector ASI(mySbase);
 904     TColGeom_SequenceOfCurve scur;
 905     scur.Clear();
 906     scur.Append(cc);
 907     ASI.Perform(scur);
 908     Standard_Real lastpar, firstpar;
 909     if(ASI.IsDone() && ASI.NbPoints(1) >= 2) {
 910       lastpar = ASI.Point(1, ASI.NbPoints(1)).Parameter();
 911       Standard_Integer lastindex = ASI.NbPoints(1);
 912       if(lastpar > l) {
 913         for(Standard_Integer jj=ASI.NbPoints(1)-1; jj>=1; jj--) {
 914           Standard_Real par = ASI.Point(1,jj).Parameter();
 915           if(par <= l) {
 916             lastpar = par;
 917             lastindex = jj;
 918             break;
 919           }
 920         }
 921       }
 922       Standard_Integer firstindex = lastindex -1;
 923       firstpar = ASI.Point(1,firstindex).Parameter();
 924
 925       if(FirstFace.IsNull()) {
 926         FirstFace = ASI.Point(1, firstindex).Face();
 927         cc->D0(firstpar, firstpoint);
 928         BRepLib_MakeVertex v1(firstpoint);
 929         FirstVertex = TopoDS::Vertex(v1.Shape());
 930         FirstEdge = E;
 931       }
 932
 933       if(LastFace.IsNull()) {
 934         LastFace = ASI.Point(1, lastindex).Face();
 935         cc->D0(lastpar, lastpoint);
 936         BRepLib_MakeVertex v2(lastpoint);
 937         LastVertex = TopoDS::Vertex(v2.Shape());
 938         LastEdge = E;
 939       }
 940     }
 941     else {
 942 #ifdef OCCT_DEBUG
 943       if (trc) std::cout << " Less than 2 intersection points" << std::endl;
 944 #endif
 945       Data = Standard_False;
 946       return Data;
 947     }
 948
 949     if(!OnFirstFace) {
 950       if(p1.Distance(firstpoint) <= Precision::Confusion())
 951         OnFirstFace = Standard_True;
 952       else OnFirstFace = Standard_False;
 953     }
 954
 955     if(!OnLastFace) {
 956       if(p2.Distance(lastpoint) <= Precision::Confusion())
 957         OnLastFace = Standard_True;
 958       else OnLastFace = Standard_False;
 959     }
 960
 961     if(FirstFace.IsNull() || LastFace.IsNull()) {
 962 #ifdef OCCT_DEBUG
 963       if (trc) std::cout << " First or Last Faces still null" << std::endl;
 964 #endif
 965       Data = Standard_False;
 966     }
 967     else {
 968 #ifdef OCCT_DEBUG
 969       if (trc) std::cout << " FirstFace and LastFace OK" << std::endl;
 970 #endif
 971       Data = Standard_True;
 972     }
 973
 974     return Data;
 975   }
 976 // ---The wire consists of several edges
 977   else {
 978 #ifdef OCCT_DEBUG
 979     if (trc) std::cout << " Multiple Edges" << std::endl;
 980 #endif
 981     BRepTools_WireExplorer ex(myWire);
 982     for(; ex.More(); ex.Next()) {
 983       const TopoDS_Edge& E = TopoDS::Edge(ex.Current());
 984       Standard_Real f, l;
 985       Handle(Geom_Curve) Cur = BRep_Tool::Curve(E, f, l);
 986       f = f - bnd/10000; l = l +bnd/10000;
 987       Handle(Geom_TrimmedCurve) curve;
 988       curve = new Geom_TrimmedCurve(Cur, f, l, Standard_True);
 989 #ifdef OCCT_DEBUG
 990       gp_Pnt P1 = BRep_Tool::Pnt(TopExp::FirstVertex(E,Standard_True)); (void)P1;
 991 #endif
 992       gp_Pnt P2 = BRep_Tool::Pnt(TopExp::LastVertex(E,Standard_True));
 993       ex1.Init(mySbase, TopAbs_FACE);
 994       TopoDS_Vertex theVertex;
 995       TopoDS_Edge theEdge;
 996       TopoDS_Face theFace;
 997       Standard_Boolean PtOnEdge = Standard_False;
 998       Standard_Boolean PtOnVertex = Standard_False;
 999       TopoDS_Edge OnEdge;
1000       TopoDS_Vertex OnVertex;
1001       Standard_Real intpar;
1002       for(; ex1.More(); ex1.Next()) {
1003         const TopoDS_Face& aCurFace = TopoDS::Face(ex1.Current());
1004         GeomAdaptor_Curve aGAC (curve);
1005         inter.Init (aCurFace, aGAC, BRep_Tool::Tolerance(aCurFace));
1006         if(!inter.More()) continue;
1007         for(; inter.More(); inter.Next()) {
1008           gp_Pnt thePoint = inter.Pnt();
1009           if(!FirstVertex.IsNull()) {
1010             gp_Pnt point = BRep_Tool::Pnt(FirstVertex);
1011             if(point.Distance(thePoint) <= BRep_Tool::Tolerance(aCurFace)) {
1012               continue;
1013             }
1014           }
1015           intpar = IntPar(curve, thePoint);
1016           theEdge = E;
1017           theFace = aCurFace;
1018           B.MakeVertex(theVertex, thePoint, Precision::Confusion());
1019           if(!FirstOK) {
1020             if(thePoint.Distance(P2) <= Precision::Confusion()) {
1021               continue;
1022             }
1023           }
1024
1025 // ---Find thepoint on an edge or a vertex of face f
1026           PtOnEdgeVertex(RevolRib, aCurFace, thePoint, FirstVertex, LastVertex,
1027                          PtOnEdge,OnEdge,PtOnVertex,OnVertex);
1028
1029
1030 //          if(!theEdge.IsNull()) break;
1031
1032           if (FirstEdge.IsNull() && !theEdge.IsNull() &&
1033               !theFace.IsNull() && !theVertex.IsNull()) {
1034             FirstEdge = theEdge;
1035             FirstFace = theFace;
1036             FirstVertex = theVertex;
1037             PtOnFirstEdge = PtOnEdge;
1038             OnFirstEdge = OnEdge;
1039             theEdge.Nullify(); theFace.Nullify(); theVertex.Nullify();
1040             if(PtOnEdge && !PtOnVertex) {
1041               TopTools_ListOfShape faces;
1042               faces.Clear();
1043               faces.Append(FirstFace);
1044               TopExp_Explorer ex2;
1045               ex2.Init(mySbase, TopAbs_FACE);
1046               for(; ex2.More(); ex2.Next()) {
1047                 TopoDS_Face fx = TopoDS::Face(ex2.Current());
1048                 TopExp_Explorer ex3;
1049                 ex3.Init(fx, TopAbs_EDGE);
1050                 for(; ex3.More(); ex3.Next()) {
1051                   const TopoDS_Edge& e = TopoDS::Edge(ex3.Current());
1052                   if(e.IsSame(OnEdge) && !fx.IsSame(FirstFace)) {
1053                     faces.Append(fx);
1054                   }
1055                 }
1056               }
1057               TopoDS_Face FFF = ChoiceOfFaces(faces, curve, intpar+bnd/10., bnd/10., Pln);
1058               if(!FFF.IsNull()) FirstFace = FFF;
1059             }
1060             else if(PtOnEdge && PtOnVertex) {
1061               TopTools_ListOfShape faces;
1062               faces.Clear();
1063               faces.Append(FirstFace);
1064               TopExp_Explorer ex2;
1065               ex2.Init(mySbase, TopAbs_FACE);
1066               for(; ex2.More(); ex2.Next()) {
1067                 TopoDS_Face fx = TopoDS::Face(ex2.Current());
1068                 TopExp_Explorer ex3;
1069                 ex3.Init(fx, TopAbs_VERTEX);
1070                 for(; ex3.More(); ex3.Next()) {
1071                   const TopoDS_Vertex& v = TopoDS::Vertex(ex3.Current());
1072                   if(v.IsSame(OnVertex) && !fx.IsSame(FirstFace)) {
1073                     faces.Append(fx);
1074                   }
1075                 }
1076               }
1077               TopoDS_Face FFF = ChoiceOfFaces(faces, curve, intpar+bnd/10., bnd/10.,  Pln);
1078               if(!FFF.IsNull()) FirstFace = FFF;
1079             }
1080             if(!FirstEdge.IsNull() && !FirstFace.IsNull()
1081              && !FirstVertex.IsNull()) {
1082               FirstOK = Standard_True;
1083             }
1084           }
1085           if(LastEdge.IsNull() && !theEdge.IsNull() &&
1086              !theFace.IsNull() && !theVertex.IsNull() &&
1087              !FirstEdge.IsNull()) {
1088             LastEdge = theEdge;
1089             LastFace = theFace;
1090             LastVertex = theVertex;
1091             PtOnLastEdge = PtOnEdge;
1092             OnLastEdge = OnEdge;
1093             if(PtOnEdge && !PtOnVertex) {
1094               TopTools_ListOfShape faces;
1095               faces.Clear();
1096               faces.Append(LastFace);
1097               TopExp_Explorer ex2;
1098               ex2.Init(mySbase, TopAbs_FACE);
1099               for(; ex2.More(); ex2.Next()) {
1100                 TopoDS_Face fx = TopoDS::Face(ex2.Current());
1101                 TopExp_Explorer ex3;
1102                 ex3.Init(fx, TopAbs_EDGE);
1103                 for(; ex3.More(); ex3.Next()) {
1104                   const TopoDS_Edge& e = TopoDS::Edge(ex3.Current());
1105                   if(e.IsSame(OnEdge) && !fx.IsSame(LastFace)) {
1106                     faces.Append(fx);
1107                   }
1108                 }
1109               }
1110               TopoDS_Face FFF = ChoiceOfFaces(faces, curve, intpar-bnd/10.,bnd/10.,  Pln);
1111               if(!FFF.IsNull()) LastFace = FFF;
1112             }
1113             else if(PtOnEdge && PtOnVertex) {
1114               TopTools_ListOfShape faces;
1115               faces.Clear();
1116               faces.Append(LastFace);
1117               TopExp_Explorer ex2;
1118               ex2.Init(mySbase, TopAbs_FACE);
1119               for(; ex2.More(); ex2.Next()) {
1120                 TopoDS_Face fx = TopoDS::Face(ex2.Current());
1121                 TopExp_Explorer ex3;
1122                 ex3.Init(fx, TopAbs_VERTEX);
1123                 for(; ex3.More(); ex3.Next()) {
1124                   const TopoDS_Vertex& v = TopoDS::Vertex(ex3.Current());
1125                   if(v.IsSame(OnVertex) && !fx.IsSame(LastFace)) {
1126                     faces.Append(fx);
1127                   }
1128                 }
1129               }
1130               TopoDS_Face FFF = ChoiceOfFaces(faces, curve, intpar-bnd/10.,bnd/10.,  Pln);
1131               if(!FFF.IsNull()) LastFace = FFF;
1132             }
1133             if(!LastEdge.IsNull() && !LastFace.IsNull()
1134                && !LastVertex.IsNull()) {
1135               LastOK = Standard_True;
1136             }
1137             break;
1138           }
1139         }
1140       }
1141     }
1142
1143     if(FirstOK && LastOK)  {
1144       Data = Standard_True;
1145       gp_Pnt PP1 = BRep_Tool::Pnt(TopExp::FirstVertex(FirstEdge,Standard_True));
1146       gp_Pnt PP2 = BRep_Tool::Pnt(TopExp::LastVertex(LastEdge,Standard_True));
1147       gp_Pnt p1 = BRep_Tool::Pnt(FirstVertex);
1148       gp_Pnt p2 = BRep_Tool::Pnt(LastVertex);
1149       if(p1.Distance(PP1) <= BRep_Tool::Tolerance(FirstFace)) {
1150         OnFirstFace = Standard_True;
1151       }
1152       if(p2.Distance(PP2) <= BRep_Tool::Tolerance(LastFace)) {
1153         OnLastFace = Standard_True;
1154       }
1155       return Standard_True;
1156     }
1157     else {
1158 #ifdef OCCT_DEBUG
1159       if (trc) std::cout << " First or Last not OK" << std::endl;
1160 #endif
1161       return Standard_False;
1162     }
1163   }
1164 }
1165
1166
1167 //=======================================================================
1168 //function : PtOnEdgeVertex
1169 //purpose  : Find if 2 limit points of the unique edge of a wire
1170 //           are on an edge or a vertex of the base shape
1171 //=======================================================================
1172
1173 void BRepFeat_RibSlot::PtOnEdgeVertex(const Standard_Boolean RevolRib,
1174                                       const TopoDS_Shape& shape,
1175                                       const gp_Pnt& point,
1176                                       const TopoDS_Vertex& ,//FirstVertex,
1177                                       const TopoDS_Vertex& ,//LastVertex,
1178                                       Standard_Boolean& PtOnEdge,
1179                                       TopoDS_Edge& OnEdge,
1180                                       Standard_Boolean& PtOnVertex,
1181                                       TopoDS_Vertex& OnVertex)
1182
1183 {
1184 #ifdef OCCT_DEBUG
1185   Standard_Boolean trc = BRepFeat_GettraceFEATRIB();
1186   if (trc) std::cout << "BRepFeat_RibSlot::PtOnEdgeVertex" << std::endl;
1187 #endif
1188   Standard_Boolean TestOK;
1189 //  PtOnEdge = Standard_False;
1190 //  OnEdge.Nullify();
1191 //  PtOnVertex = Standard_False;
1192 //  OnVertex.Nullify();
1193
1194   TopExp_Explorer EXP;
1195   EXP.Init(shape, TopAbs_EDGE);
1196   TopTools_MapOfShape Map;
1197   for(; EXP.More(); EXP.Next()) {
1198     const TopoDS_Edge& e = TopoDS::Edge(EXP.Current());
1199     if ( !Map.Add(e)) continue;
1200     if (!RevolRib) {
1201       if (BRep_Tool::Degenerated(e)) continue;
1202     }
1203     Standard_Real fff, lll;
1204     Handle(Geom_Curve) ccc = BRep_Tool::Curve(e, fff, lll);
1205     if (!RevolRib) {
1206       ccc = new Geom_TrimmedCurve(ccc, fff, lll);
1207     }
1208     GeomAPI_ProjectPointOnCurve proj(point, ccc);
1209     TestOK = Standard_False;
1210     if (!RevolRib) {
1211       if(proj.NbPoints() == 1) TestOK = Standard_True;
1212     }
1213     else {
1214       if(proj.NbPoints() >= 1) TestOK = Standard_True;
1215     }
1216     if(TestOK && proj.Distance(1) <= BRep_Tool::Tolerance(e)) {
1217       PtOnEdge = Standard_True;
1218       OnEdge = e;
1219       TopoDS_Vertex ev1 = TopExp::FirstVertex(e,Standard_True);
1220       TopoDS_Vertex ev2 = TopExp::LastVertex(e,Standard_True);
1221       gp_Pnt ep1 = BRep_Tool::Pnt(ev1);
1222       gp_Pnt ep2 = BRep_Tool::Pnt(ev2);
1223       if(point.Distance(ep1) <= BRep_Tool::Tolerance(ev1)) {
1224         PtOnVertex = Standard_True;
1225         OnVertex = ev1;
1226         break;
1227       }
1228       else if(point.Distance(ep2) <= BRep_Tool::Tolerance(ev1)) {
1229         PtOnVertex = Standard_True;
1230         OnVertex = ev2;
1231         break;
1232       }
1233       break;
1234     }
1235   }
1236 }
1237
1238
1239 //=======================================================================
1240 //function : SlidingProfile
1241 //purpose  : construction of the profile face in case of sliding
1242 //=======================================================================
1243
1244 Standard_Boolean BRepFeat_RibSlot::SlidingProfile(TopoDS_Face& Prof,
1245                                                   const Standard_Boolean RevolRib,
1246                                                   const Standard_Real myTol,
1247                                                   Standard_Integer& Concavite,
1248                                                   const Handle(Geom_Plane)& myPln,
1249                                                   const TopoDS_Face& BndFace,
1250                                                   const gp_Pnt& CheckPnt,
1251                                                   const TopoDS_Face& FirstFace,
1252                                                   const TopoDS_Face& LastFace,
1253                                                   const TopoDS_Vertex& ,//FirstVertex,
1254                                                   const TopoDS_Vertex& ,//LastVertex,
1255                                                   const TopoDS_Edge& FirstEdge,
1256                                                   const TopoDS_Edge& LastEdge)
1257
1258 {
1259 #ifdef OCCT_DEBUG
1260   Standard_Boolean trc = BRepFeat_GettraceFEAT();
1261   if (trc) std::cout << "BRepFeat_RibSlot::SlidingProfile" << std::endl;
1262 #endif
1263   Standard_Boolean ProfileOK = Standard_True;
1264 // --case of sliding : construction of the wire of the profile
1265 // --> 1 part bounding box + 1 part wire
1266 //   attention to the compatibility of orientations
1267
1268   gp_Dir FN, LN;
1269   BRepLib_MakeWire WW;
1270
1271   FN = Normal(FirstFace, myFirstPnt);
1272   LN = Normal(LastFace, myLastPnt);
1273
1274 // Case of the groove (cut) <> rib (fuse)
1275 // -> we are in the material
1276 // -> make everything in 2d in the working plane : easier
1277   if(!myFuse) {
1278     FN = -FN;
1279     LN = -LN;
1280   }
1281
1282
1283   Handle(Geom_Line) ln1, ln2;
1284   gp_Pnt  Pt;//,p1, p2;
1285
1286   ln2 = new Geom_Line(myFirstPnt, FN);
1287   ln1 = new Geom_Line(myLastPnt, LN);
1288
1289   Handle(Geom2d_Curve) ln2d1 = GeomAPI::To2d(ln1, myPln->Pln());
1290   Handle(Geom2d_Curve) ln2d2 = GeomAPI::To2d(ln2, myPln->Pln());
1291
1292   Geom2dAPI_InterCurveCurve inter(ln2d1, ln2d2, Precision::Confusion());
1293
1294   Standard_Boolean TestOK = Standard_True;
1295   if (RevolRib) {
1296     gp_Dir d1, d2;
1297     d1 = ln1->Position().Direction();
1298     d2 = ln2->Position().Direction();
1299     if(d1.IsOpposite(d2, myTol)) {
1300       Standard_Real par1 = ElCLib::Parameter(ln1->Lin(), myFirstPnt);
1301       Standard_Real par2 = ElCLib::Parameter(ln2->Lin(), myLastPnt);
1302       if(par1 >= myTol  ||  par2 >= myTol)  {
1303         Concavite = 2;    //paralel and concave
1304         BRepLib_MakeEdge e1(myLastPnt, myFirstPnt);
1305         WW.Add(e1);
1306       }
1307     }
1308     if(d1.IsEqual(d2, myTol)) {
1309        if(Concavite == 3) TestOK = Standard_False;
1310     }
1311   }
1312
1313   if(TestOK) {
1314     if(inter.NbPoints() > 0) {
1315       gp_Pnt2d P = inter.Point(1);
1316       myPln->D0(P.X(), P.Y(), Pt);
1317       Standard_Real par = IntPar(ln1, Pt);
1318       if(par>0) Concavite = 1;    //concave
1319     }
1320   }
1321
1322 // ---Construction of the profile face
1323   if(Concavite == 1) {
1324 // if concave : it is possible to extend first and last edges of the wire
1325 //              to the bounding box
1326     BRepLib_MakeEdge e1(myLastPnt, Pt);
1327     WW.Add(e1);
1328     BRepLib_MakeEdge e2(Pt, myFirstPnt);
1329     WW.Add(e2);
1330   }
1331   else if(Concavite == 3) {
1332 // BndEdge : edges of intersection with the bounding box
1333     TopoDS_Edge BndEdge1, BndEdge2;
1334 // Points of intersection with the bounding box / Find Profile
1335     gp_Pnt BndPnt1, BndPnt2, LastPnt;
1336     TopExp_Explorer expl;
1337     expl.Init(BndFace, TopAbs_WIRE);
1338     BRepTools_WireExplorer explo;
1339     TopoDS_Wire BndWire = TopoDS::Wire(expl.Current());
1340     explo.Init(BndWire);
1341     for(; explo.More(); explo.Next()) {
1342       const TopoDS_Edge& e = TopoDS::Edge(explo.Current());
1343       Standard_Real first, last;
1344       Handle(Geom_Curve) c = BRep_Tool::Curve(e, first, last);
1345       Handle(Geom2d_Curve) c2d = GeomAPI::To2d(c, myPln->Pln());
1346       Geom2dAPI_InterCurveCurve intcln1(ln2d1, c2d,
1347                                         Precision::Confusion());
1348       if(intcln1.NbPoints() > 0) {
1349         gp_Pnt2d p2d = intcln1.Point(1);
1350         gp_Pnt p;
1351         myPln->D0(p2d.X(), p2d.Y(), p);
1352         Standard_Real parl = IntPar(ln1, p);
1353         Standard_Real parc = IntPar(c, p);
1354         if(parc >= first && parc <= last && parl >= 0) {
1355           BndEdge1 = e;
1356           BndPnt1 = p;
1357         }
1358       }
1359
1360       Geom2dAPI_InterCurveCurve intcln2(ln2d2, c2d,
1361                                         Precision::Confusion());
1362       if(intcln2.NbPoints() > 0) {
1363         gp_Pnt2d p2d = intcln2.Point(1);
1364         gp_Pnt p;
1365         myPln->D0(p2d.X(), p2d.Y(), p);
1366         Standard_Real parl = IntPar(ln2, p);
1367         Standard_Real parc = IntPar(c, p);
1368         if(parc >= first && parc <= last && parl >= 0) {
1369           BndEdge2 = e;
1370           BndPnt2 = p;
1371         }
1372       }
1373       if(!BndEdge1.IsNull() && !BndEdge2.IsNull()) break;
1374     }
1375
1376     if(BndEdge1.IsNull() || BndEdge2.IsNull())  {
1377 #ifdef OCCT_DEBUG
1378       if (trc) std::cout << " Null bounding edge" << std::endl;
1379 #endif
1380       ProfileOK = Standard_False;
1381       return ProfileOK;
1382     }
1383
1384
1385     BRepLib_MakeEdge e1(myLastPnt, BndPnt1);
1386     WW.Add(e1);
1387
1388     if(BndEdge1.IsSame(BndEdge2)) {
1389 // Particular case : same edge -> simply determined path
1390       BRepLib_MakeEdge e2(BndPnt1, BndPnt2);
1391       WW.Add(e2);
1392       BRepLib_MakeEdge e3(BndPnt2, myFirstPnt);
1393       WW.Add(e3);
1394     }
1395     else {
1396       explo.Init(BndWire);
1397       for(; explo.More(); explo.Next()) {
1398         const TopoDS_Edge& e = TopoDS::Edge(explo.Current());
1399         if(e.IsSame(BndEdge1)) {
1400           gp_Pnt pp;
1401           pp = BRep_Tool::Pnt(TopExp::LastVertex(e,Standard_True));
1402           if(pp.Distance(BndPnt1) >= BRep_Tool::Tolerance(e)) {
1403             LastPnt = pp;
1404           }
1405 //            else {         //LinearForm
1406 //              gp_Pnt ppp = BRep_Tool::Pnt(TopExp::FirstVertex(e,Standard_True));
1407 //              LastPnt = ppp;
1408 //            }
1409           BRepLib_MakeEdge e2(BndPnt1, LastPnt);
1410           WW.Add(e2);
1411           break;
1412         }
1413       }
1414
1415       if(explo.More()) {
1416         explo.Next();
1417         if(explo.Current().IsNull()) explo.Init(BndWire);
1418       }
1419       else explo.Init(BndWire);
1420
1421 // Check if this is BndEdge2
1422 // -> if yes : it is required to turn to join FirstPnt
1423 // -> if no : add edges
1424       Standard_Boolean Fin = Standard_False;
1425       while(!Fin) {
1426         const TopoDS_Edge& e = TopoDS::Edge(explo.Current());
1427         if(!e.IsSame(BndEdge2)) {
1428           gp_Pnt pp;
1429           pp = BRep_Tool::Pnt(TopExp::LastVertex(e,Standard_True));
1430           BRepLib_MakeEdge ee(LastPnt, pp);
1431           WW.Add(ee);
1432           LastPnt = pp;
1433         }
1434         else {
1435 // the path is closed
1436 // -> since met BndEdge2, end of borders on BndFace
1437           Fin = Standard_True;
1438           BRepLib_MakeEdge ee(LastPnt, BndPnt2);
1439           WW.Add(ee);
1440           LastPnt = BndPnt2;
1441         }
1442         if(explo.More()) {
1443           explo.Next();
1444           if(explo.Current().IsNull()) {
1445             explo.Init(BndWire);
1446           }
1447         }
1448         else explo.Init(BndWire);
1449       }
1450
1451       BRepLib_MakeEdge e3(BndPnt2, myFirstPnt);
1452       WW.Add(e3);
1453     }
1454   }
1455
1456 // ---Construction of the profile
1457
1458 // Explore the wire provided by the user
1459 // BRepTools_WireExplorer : correct order - without repetition <> TopExp : non ordered
1460   BRepTools_WireExplorer EX(myWire);
1461
1462   Standard_Real ff, ll;
1463   Handle(Geom_Curve) FirstCurve = BRep_Tool::Curve(FirstEdge, ff, ll);
1464
1465   if(!FirstEdge.IsSame(LastEdge)) {
1466     TopoDS_Vertex FLVert = TopExp::LastVertex(FirstEdge,Standard_True);
1467     gp_Pnt FLPnt = BRep_Tool::Pnt(FLVert);
1468     BRepLib_MakeEdge ef(FirstCurve, myFirstPnt, FLPnt);
1469     WW.Add(ef);
1470     for(; EX.More(); EX.Next()) {
1471       const TopoDS_Edge& E = EX.Current();
1472       if(E.IsSame(FirstEdge))        break;
1473     }
1474     EX.Next();
1475     for(; EX.More(); EX.Next()) {
1476       const TopoDS_Edge& E = EX.Current();
1477       if(!E.IsSame(LastEdge)) {
1478         WW.Add(E);
1479       }
1480       else break;
1481     }
1482     Handle(Geom_Curve) LastCurve = BRep_Tool::Curve(LastEdge, ff, ll);
1483     TopoDS_Vertex LFVert = TopExp::FirstVertex(LastEdge,Standard_True);
1484     gp_Pnt LFPnt = BRep_Tool::Pnt(LFVert);
1485     BRepLib_MakeEdge el(LastCurve, LFPnt, myLastPnt);
1486     WW.Add(el);
1487   }
1488   else {
1489 // only one edge : particular processing
1490     Standard_Real fpar = IntPar(FirstCurve, myFirstPnt);
1491     Standard_Real lpar = IntPar(FirstCurve, myLastPnt);
1492     Handle(Geom_Curve) c;
1493     if(fpar > lpar)
1494       c = FirstCurve->Reversed();
1495     else
1496       c = FirstCurve;
1497
1498     BRepLib_MakeEdge ef(c, myFirstPnt, myLastPnt);
1499     WW.Add(ef);
1500   }
1501
1502   BRepLib_MakeFace f(myPln->Pln(), WW, Standard_True);
1503   TopoDS_Face fac = TopoDS::Face(f.Shape());
1504
1505   if (!BRepAlgo::IsValid(fac)) {
1506 #ifdef OCCT_DEBUG
1507     if (trc) std::cout << " Invalid Face" << std::endl;
1508 #endif
1509     ProfileOK = Standard_False;
1510     return ProfileOK;
1511   }
1512
1513   if(Concavite != 3) {
1514 // if concave : face is OK
1515     Prof = fac;
1516   }
1517   else {
1518 // if not concave
1519 // CheckPnt : point slightly inside the material side
1520 // Bndface  : face/cut of the bounding box in the plane of the profile
1521     BRepTopAdaptor_FClass2d Cl(fac, BRep_Tool::Tolerance(fac));
1522     Standard_Real u, v;
1523     ElSLib::Parameters(myPln->Pln(), CheckPnt, u, v);
1524     gp_Pnt2d checkpnt2d(u, v);
1525     if(Cl.Perform(checkpnt2d, Standard_True) == TopAbs_OUT) {
1526 // If face is not the correct part of BndFace take the complementary
1527       BRepAlgoAPI_Cut c(BndFace, fac);
1528       TopExp_Explorer exp(c.Shape(), TopAbs_WIRE);
1529       const TopoDS_Wire& w = TopoDS::Wire(exp.Current());
1530       BRepLib_MakeFace ffx(w);
1531       Prof = TopoDS::Face(ffx.Shape());
1532     }
1533     else {
1534 // If face is the correct part of BndFace  : face is OK
1535       Prof = fac;
1536     }
1537   }
1538
1539   if (!BRepAlgo::IsValid(Prof)) {
1540 #ifdef OCCT_DEBUG
1541     if (trc) std::cout << " Invalid Face Profile" << std::endl;
1542 #endif
1543     ProfileOK = Standard_False;
1544     return ProfileOK;
1545   }
1546   return ProfileOK;
1547 }
1548 //=======================================================================
1549 //function : NoSlidingProfile
1550 //purpose  : construction of the face profile in case of sliding
1551 //=======================================================================
1552
1553 Standard_Boolean BRepFeat_RibSlot::NoSlidingProfile(TopoDS_Face& Prof,
1554                                                     const Standard_Boolean RevolRib,
1555                                                     const Standard_Real myTol,
1556                                                     Standard_Integer& Concavite,
1557                                                     const Handle(Geom_Plane)& myPln,
1558                                                     const Standard_Real bnd,
1559                                                     const TopoDS_Face& BndFace,
1560                                                     const gp_Pnt& CheckPnt,
1561                                                     const TopoDS_Face& ,//FirstFace,
1562                                                     const TopoDS_Face& ,//LastFace,
1563                                                     const TopoDS_Vertex& ,//FirstVertex,
1564                                                     const TopoDS_Vertex& ,//LastVertex,
1565                                                     const TopoDS_Edge& FirstEdge,
1566                                                     const TopoDS_Edge& LastEdge,
1567                                                     const Standard_Boolean OnFirstFace,
1568                                                     const Standard_Boolean OnLastFace)
1569
1570 {
1571 #ifdef OCCT_DEBUG
1572   Standard_Boolean trc = BRepFeat_GettraceFEAT();
1573   if (trc) std::cout << "BRepFeat_RibSlot::NoSlidingProfile" << std::endl;
1574 #endif
1575   Standard_Boolean ProfileOK = Standard_True;
1576
1577   Standard_Real l1, f1, f2, l2;//, p;
1578   TopoDS_Vertex theFV; theFV.Nullify();
1579   gp_Pnt theFirstpoint;
1580   TopoDS_Edge theLastEdge; theLastEdge.Nullify();
1581   gp_Pnt firstpoint, lastpoint;//, pp1, pp2;
1582   gp_Vec firstvect, lastvect;
1583   TopoDS_Wire w;
1584   BRep_Builder BB;
1585   BB.MakeWire(w);
1586   //gp_Pnt p1, p3;
1587   TopoDS_Edge FalseFirstEdge, FalseLastEdge, FalseOnlyOne;
1588
1589   Handle(Geom_Curve) FirstCurve = BRep_Tool::Curve(FirstEdge, f1, l1);
1590   Handle(Geom_Curve) LastCurve = BRep_Tool::Curve(LastEdge, f2, l2);
1591
1592   Handle(Geom_Line) firstln, lastln;
1593   FirstCurve->D1(f1, firstpoint, firstvect);
1594   lastln = new Geom_Line(firstpoint, -firstvect);
1595   LastCurve->D1(l2, lastpoint, lastvect);
1596   firstln = new Geom_Line(lastpoint, lastvect);
1597
1598   gp_Pnt Pt;
1599
1600   Handle(Geom2d_Curve) ln2d1 = GeomAPI::To2d(firstln, myPln->Pln());
1601   Handle(Geom2d_Curve) ln2d2 = GeomAPI::To2d(lastln, myPln->Pln());
1602
1603   Geom2dAPI_InterCurveCurve inter(ln2d1, ln2d2, Precision::Confusion());
1604
1605   Standard_Boolean TestOK = Standard_True;
1606   if (RevolRib) {
1607     gp_Dir d1, d2;
1608     d1 = firstln->Position().Direction();
1609     d2 = lastln->Position().Direction();
1610     if(d1.IsOpposite(d2, myTol)) {
1611       Standard_Real par1 = ElCLib::Parameter(firstln->Lin(), myFirstPnt);
1612       Standard_Real par2 = ElCLib::Parameter(lastln->Lin(), myLastPnt);
1613       if(par1 >= myTol  ||  par2 >= myTol)
1614         Concavite = 2;    //parallel and concave
1615     }
1616     if(d1.IsEqual(d2, myTol)) {
1617        if(Concavite == 3) TestOK = Standard_False;
1618     }
1619   }
1620
1621   if(TestOK) {
1622     if(inter.NbPoints() > 0) {
1623       gp_Pnt2d P = inter.Point(1);
1624       myPln->D0(P.X(), P.Y(), Pt);
1625       Standard_Real par = IntPar(firstln, Pt);
1626       if(par>0) Concavite = 1;    //concave
1627     }
1628   }
1629
1630 // ---Construction of the face profile
1631   if(Concavite == 3) {
1632     if(OnFirstFace) {
1633       Standard_Real f, l;
1634       FalseFirstEdge = FirstEdge;
1635       EdgeExtention(FalseFirstEdge, bnd, Standard_True);
1636       const TopoDS_Vertex& vv1 = TopExp::FirstVertex(FalseFirstEdge,Standard_True);
1637       firstpoint = BRep_Tool::Pnt(vv1);
1638       Handle(Geom_Curve) cc = BRep_Tool::Curve(FalseFirstEdge, f, l);
1639       cc->D1(f, firstpoint, firstvect);
1640       lastln = new Geom_Line(firstpoint, -firstvect);
1641       if(FirstEdge.IsSame(LastEdge)) FalseOnlyOne = FalseFirstEdge;
1642       ln2d2 = GeomAPI::To2d(lastln, myPln->Pln());
1643     }
1644     if(OnLastFace) {
1645       Standard_Real f, l;
1646       if(!FirstEdge.IsSame(LastEdge)) {
1647         FalseLastEdge = LastEdge;
1648       }
1649       else {
1650         if(FalseOnlyOne.IsNull()) FalseOnlyOne = LastEdge;
1651         FalseLastEdge = FalseOnlyOne;
1652       }
1653       EdgeExtention(FalseLastEdge, bnd, Standard_False);
1654       if(FirstEdge.IsSame(LastEdge)) {
1655         FalseOnlyOne = FalseLastEdge;
1656       }
1657       const TopoDS_Vertex& vv2 = TopExp::LastVertex(FalseLastEdge,Standard_True);
1658       lastpoint = BRep_Tool::Pnt(vv2);
1659       Handle(Geom_Curve) cc = BRep_Tool::Curve(FalseLastEdge, f, l);
1660       cc->D1(l, lastpoint, lastvect);
1661       lastpoint = BRep_Tool::Pnt(vv2);
1662       firstln = new Geom_Line(lastpoint, lastvect);
1663       ln2d1 = GeomAPI::To2d(firstln, myPln->Pln());
1664     }
1665
1666     TopoDS_Edge BndEdge1, BndEdge2;
1667     gp_Pnt BndPnt1, BndPnt2, LastPnt;
1668     TopExp_Explorer expl;
1669     expl.Init(BndFace, TopAbs_WIRE);
1670     BRepTools_WireExplorer explo;
1671     TopoDS_Wire BndWire = TopoDS::Wire(expl.Current());
1672     explo.Init(BndWire);
1673     for(; explo.More(); explo.Next()) {
1674       const TopoDS_Edge& e = TopoDS::Edge(explo.Current());
1675       Standard_Real first, last;
1676       Handle(Geom_Curve) c = BRep_Tool::Curve(e, first, last);
1677       Handle(Geom2d_Curve) c2d = GeomAPI::To2d(c, myPln->Pln());
1678       Geom2dAPI_InterCurveCurve intcln1(ln2d1, c2d,
1679                                         Precision::Confusion());
1680       if(intcln1.NbPoints() > 0) {
1681         gp_Pnt2d p2d = intcln1.Point(1);
1682         gp_Pnt p;
1683         myPln->D0(p2d.X(), p2d.Y(), p);
1684         Standard_Real parl = IntPar(firstln, p);
1685         Standard_Real parc = IntPar(c, p);
1686         if(parc >= first && parc <= last && parl >= 0) {
1687           BndEdge1 = e;
1688           BndPnt1 = p;
1689         }
1690       }
1691
1692       Geom2dAPI_InterCurveCurve intcln2(ln2d2, c2d,
1693                                         Precision::Confusion());
1694       if(intcln2.NbPoints() > 0) {
1695         gp_Pnt2d p2d = intcln2.Point(1);
1696         gp_Pnt p;
1697         myPln->D0(p2d.X(), p2d.Y(), p);
1698         Standard_Real parl = IntPar(lastln, p);
1699         Standard_Real parc = IntPar(c, p);
1700         if(parc >= first && parc <= last && parl >= 0) {
1701           BndEdge2 = e;
1702           BndPnt2 = p;
1703         }
1704       }
1705       if(!BndEdge1.IsNull() && !BndEdge2.IsNull()) break;
1706     }
1707
1708     if(BndEdge1.IsNull() || BndEdge2.IsNull())  {
1709 #ifdef OCCT_DEBUG
1710       if (trc) std::cout << " Null bounding edge" << std::endl;
1711 #endif
1712       ProfileOK = Standard_False;
1713       return ProfileOK;
1714     }
1715
1716     TopoDS_Edge ee1;
1717     if(theLastEdge.IsNull()) {
1718       BRepLib_MakeEdge e1(lastpoint, BndPnt1);
1719       ee1 = TopoDS::Edge(e1.Shape());
1720     }
1721     else {
1722       const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
1723       BRepLib_MakeVertex v2(BndPnt1);
1724       BRepLib_MakeEdge e1(v1, v2);
1725       ee1 = TopoDS::Edge(e1.Shape());
1726     }
1727     BB.Add(w, ee1);
1728     theLastEdge = ee1;
1729     if(theFV.IsNull()) {
1730       theFV = TopExp::FirstVertex(ee1,Standard_True);
1731       theFirstpoint = BRep_Tool::Pnt(theFV);
1732     }
1733
1734     if(BndEdge1.IsSame(BndEdge2)) {
1735       TopoDS_Edge ee2, ee3;
1736       if(theLastEdge.IsNull()) {
1737         BRepLib_MakeEdge e2(BndPnt1, BndPnt2);
1738         ee2 = TopoDS::Edge(e2.Shape());
1739       }
1740       else {
1741         const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
1742         BRepLib_MakeVertex v2(BndPnt2);
1743         BRepLib_MakeEdge e2(v1, v2);
1744         ee2 = TopoDS::Edge(e2.Shape());
1745       }
1746       BB.Add(w, ee2);
1747       theLastEdge = ee2;
1748       if(theFV.IsNull()) {
1749         theFV = TopExp::FirstVertex(ee2,Standard_True);
1750         theFirstpoint = BRep_Tool::Pnt(theFV);
1751       }
1752       if(theLastEdge.IsNull()) {
1753         BRepLib_MakeEdge e3(BndPnt2, firstpoint);
1754         ee3 = TopoDS::Edge(e3.Shape());
1755       }
1756       else {
1757         const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
1758         BRepLib_MakeVertex v2(firstpoint);
1759         BRepLib_MakeEdge e3(v1, v2);
1760         ee3 = TopoDS::Edge(e3.Shape());
1761       }
1762       BB.Add(w, ee3);
1763       theLastEdge = ee3;
1764       if(theFV.IsNull()) {
1765         theFV = TopExp::FirstVertex(ee3,Standard_True);
1766         theFirstpoint = BRep_Tool::Pnt(theFV);
1767       }
1768     }
1769     else {
1770       explo.Init(BndWire);
1771       for(; explo.More(); explo.Next()) {
1772         const TopoDS_Edge& e = TopoDS::Edge(explo.Current());
1773         if(e.IsSame(BndEdge1)) {
1774           gp_Pnt pp;
1775           pp = BRep_Tool::Pnt(TopExp::LastVertex(e,Standard_True));
1776           if(pp.Distance(BndPnt1) > BRep_Tool::Tolerance(e)) {
1777             LastPnt = pp;
1778           }
1779           TopoDS_Edge eee;
1780           if(theLastEdge.IsNull()) {
1781             BRepLib_MakeEdge e2(BndPnt1, LastPnt);
1782             eee = TopoDS::Edge(e2.Shape());
1783           }
1784           else {
1785             const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
1786             BRepLib_MakeVertex v2(LastPnt);
1787             BRepLib_MakeEdge e2(v1, v2);
1788             eee = TopoDS::Edge(e2.Shape());
1789           }
1790           BB.Add(w, eee);
1791           theLastEdge = eee;
1792           if(theFV.IsNull()) {
1793             theFV = TopExp::FirstVertex(eee,Standard_True);
1794             theFirstpoint = BRep_Tool::Pnt(theFV);
1795           }
1796           break;
1797         }
1798       }
1799
1800       if(explo.More()) {
1801         explo.Next();
1802         if(explo.Current().IsNull()) explo.Init(BndWire);
1803       }
1804       else explo.Init(BndWire);
1805       Standard_Boolean Fin = Standard_False;
1806       while(!Fin) {
1807         const TopoDS_Edge& e = TopoDS::Edge(explo.Current());
1808         if(!e.IsSame(BndEdge2)) {
1809           gp_Pnt pp;
1810           pp = BRep_Tool::Pnt(TopExp::LastVertex(e,Standard_True));
1811           TopoDS_Edge eee1;
1812           if(theLastEdge.IsNull()) {
1813             BRepLib_MakeEdge ee(LastPnt, pp);
1814             eee1 = TopoDS::Edge(ee.Shape());
1815           }
1816           else {
1817             const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
1818             BRepLib_MakeVertex v2(pp);
1819             BRepLib_MakeEdge ee(v1, v2);
1820             eee1 = TopoDS::Edge(ee.Shape());
1821           }
1822           BB.Add(w, eee1);
1823           theLastEdge = eee1;
1824           if(theFV.IsNull()) {
1825             theFV = TopExp::FirstVertex(eee1,Standard_True);
1826             theFirstpoint = BRep_Tool::Pnt(theFV);
1827           }
1828           LastPnt = pp;
1829         }
1830         else {
1831           Fin = Standard_True;
1832           TopoDS_Edge eee2;
1833           if(theLastEdge.IsNull()) {
1834             BRepLib_MakeEdge ee(LastPnt, BndPnt2);
1835             eee2 = TopoDS::Edge(ee.Shape());
1836           }
1837           else {
1838             const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
1839             BRepLib_MakeVertex v2(BndPnt2);
1840             BRepLib_MakeEdge ee(v1, v2);
1841             eee2 = TopoDS::Edge(ee.Shape());
1842           }
1843           BB.Add(w, eee2);
1844           theLastEdge = eee2;
1845           if(theFV.IsNull()) {
1846             theFV = TopExp::FirstVertex(eee2,Standard_True);
1847             theFirstpoint = BRep_Tool::Pnt(theFV);
1848           }
1849           LastPnt = BndPnt2;
1850         }
1851         if(explo.More()) {
1852           explo.Next();
1853           if(explo.Current().IsNull()) {
1854             explo.Init(BndWire);
1855           }
1856         }
1857         else explo.Init(BndWire);
1858       }
1859
1860       TopoDS_Edge eee3;
1861       if(theLastEdge.IsNull()) {
1862         BRepLib_MakeEdge e3(BndPnt2, firstpoint);
1863         eee3 = TopoDS::Edge(e3.Shape());
1864       }
1865       else {
1866         const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
1867         BRepLib_MakeVertex v2(firstpoint);
1868         BRepLib_MakeEdge e3(v1, v2);
1869         eee3 = TopoDS::Edge(e3.Shape());
1870       }
1871       BB.Add(w, eee3);
1872       theLastEdge = eee3;
1873       if(theFV.IsNull()) {
1874         theFV = TopExp::FirstVertex(eee3,Standard_True);
1875         theFirstpoint = BRep_Tool::Pnt(theFV);
1876       }
1877     }
1878   }
1879
1880   if(Concavite == 1) {
1881     TopoDS_Edge eee4;
1882     if(theLastEdge.IsNull()) {
1883       BRepLib_MakeEdge  e(Pt, firstpoint);
1884       eee4 = TopoDS::Edge(e.Shape());
1885     }
1886     else {
1887       const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
1888       BRepLib_MakeVertex v2(firstpoint);
1889       BRepLib_MakeEdge e(v1, v2);
1890       eee4 = TopoDS::Edge(e.Shape());
1891     }
1892     BB.Add(w, eee4);
1893     if(theFV.IsNull()) {
1894       theFV = TopExp::FirstVertex(eee4,Standard_True);
1895       theFirstpoint = BRep_Tool::Pnt(theFV);
1896     }
1897     theLastEdge = eee4;
1898   }
1899
1900
1901   if(FirstEdge.IsSame(LastEdge)) {
1902     if(!myLFMap.IsBound(FirstEdge)) {
1903       TopTools_ListOfShape thelist;
1904       myLFMap.Bind(FirstEdge, thelist);
1905     }
1906     if(OnFirstFace || OnLastFace) {
1907       TopoDS_Edge theEdge;
1908       Standard_Real f, l;
1909       Handle(Geom_Curve) cc = BRep_Tool::Curve(FalseOnlyOne, f, l);
1910       if(!theLastEdge.IsNull()) {
1911         const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
1912         TopoDS_Vertex v2;
1913         const gp_Pnt& pp = BRep_Tool::
1914           Pnt(TopExp::LastVertex(FalseOnlyOne,Standard_True));
1915         if(!theFV.IsNull() && theFirstpoint.Distance(pp) <= myTol) {
1916           v2 = theFV;
1917         }
1918         else v2 = TopExp::LastVertex(FalseOnlyOne,Standard_True);
1919         BRepLib_MakeEdge e(cc, v1, v2);
1920         theEdge = TopoDS::Edge(e.Shape());
1921       }
1922       else {
1923         const TopoDS_Vertex& v1 = TopExp::FirstVertex(FalseOnlyOne,Standard_True);
1924         TopoDS_Vertex v2;
1925         const gp_Pnt& pp = BRep_Tool::
1926           Pnt(TopExp::LastVertex(FalseOnlyOne,Standard_True));
1927         if(!theFV.IsNull() && theFirstpoint.Distance(pp) <= myTol) {
1928           v2 = theFV;
1929         }
1930         else v2 = TopExp::LastVertex(FalseOnlyOne,Standard_True);
1931         BRepLib_MakeEdge e(cc, v1, v2);
1932         theEdge = TopoDS::Edge(e.Shape());
1933       }
1934       myLFMap(FirstEdge).Append(theEdge);
1935       BB.Add(w, theEdge);
1936       if(theFV.IsNull()) theFV = TopExp::FirstVertex(theEdge,Standard_True);
1937       theLastEdge = theEdge;
1938     }
1939     else {
1940       Standard_Real f, l;
1941       Handle(Geom_Curve) cc = BRep_Tool::Curve(FirstEdge, f, l);
1942       TopoDS_Edge theEdge;
1943       if(!theLastEdge.IsNull()) {
1944         const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
1945         TopoDS_Vertex v2;
1946 // Attention case Wire Reversed -> LastVertex without Standard_True
1947         const gp_Pnt& pp = BRep_Tool::Pnt(TopExp::LastVertex(FirstEdge));
1948         if(!theFV.IsNull() && theFirstpoint.Distance(pp) <= myTol) {
1949           v2 = theFV;
1950         }
1951         else v2 = TopExp::LastVertex(FirstEdge);
1952         BRepLib_MakeEdge e(cc, v1, v2);
1953         theEdge = TopoDS::Edge(e.Shape());
1954       }
1955       else {
1956         const TopoDS_Vertex& v1 = TopExp::FirstVertex(FirstEdge,Standard_True);
1957         TopoDS_Vertex v2;
1958         const gp_Pnt& pp = BRep_Tool::
1959           Pnt(TopExp::LastVertex(FirstEdge,Standard_True));
1960         if(!theFV.IsNull() && theFirstpoint.Distance(pp) <= myTol) {
1961           v2 = theFV;
1962         }
1963         else v2 = TopExp::LastVertex(FirstEdge,Standard_True);
1964         BRepLib_MakeEdge e(cc, v1, v2);
1965         theEdge = TopoDS::Edge(e.Shape());
1966       }
1967       myLFMap(FirstEdge).Append(theEdge);
1968       BB.Add(w, theEdge);
1969       if(theFV.IsNull()) theFV = TopExp::FirstVertex(theEdge,Standard_True);
1970       theLastEdge = theEdge;
1971     }
1972   }
1973   else {
1974     if(!myLFMap.IsBound(FirstEdge)) {
1975       TopTools_ListOfShape thelist1;
1976       myLFMap.Bind(FirstEdge, thelist1);
1977     }
1978     if(!OnFirstFace) {
1979       TopoDS_Edge theEdge;
1980       Standard_Real f, l;
1981       Handle(Geom_Curve) cc = BRep_Tool::Curve(FirstEdge, f, l);
1982       if(!theLastEdge.IsNull()) {
1983         const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
1984         const TopoDS_Vertex& v2 = TopExp::LastVertex(FirstEdge,Standard_True);
1985         BRepLib_MakeEdge e(cc, v1, v2);
1986         theEdge = TopoDS::Edge(e.Shape());
1987       }
1988       else {
1989         theEdge = FirstEdge;
1990       }
1991       myLFMap(FirstEdge).Append(theEdge);
1992       BB.Add(w, theEdge);
1993       if(theFV.IsNull()) theFV = TopExp::FirstVertex(theEdge,Standard_True);
1994       theLastEdge = theEdge;
1995     }
1996     else {
1997       TopoDS_Edge theEdge;
1998       Standard_Real f, l;
1999       Handle(Geom_Curve) cc = BRep_Tool::Curve(FalseFirstEdge, f, l);
2000       if(!theLastEdge.IsNull()) {
2001         const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
2002         const TopoDS_Vertex& v2 = TopExp::LastVertex(FalseFirstEdge,Standard_True);
2003         BRepLib_MakeEdge e(cc, v1, v2);
2004         theEdge = TopoDS::Edge(e.Shape());
2005       }
2006       else {
2007         theEdge = FalseFirstEdge;
2008       }
2009       myLFMap(FirstEdge).Append(theEdge);
2010       BB.Add(w, theEdge);
2011       if(theFV.IsNull()) theFV = TopExp::FirstVertex(theEdge,Standard_True);
2012       theLastEdge = theEdge;
2013     }
2014
2015     BRepTools_WireExplorer ex(myWire);
2016     for(; ex.More(); ex.Next()) {
2017       const TopoDS_Edge& E = ex.Current();
2018       if(E.IsSame(FirstEdge)) break;
2019     }
2020
2021     ex.Next();
2022
2023     for(; ex.More(); ex.Next()) {
2024       const TopoDS_Edge& E = ex.Current();
2025       if(!E.IsSame(LastEdge)) {
2026         if(!myLFMap.IsBound(E)) {
2027           TopTools_ListOfShape thelist2;
2028           myLFMap.Bind(E, thelist2);
2029         }
2030         TopoDS_Edge eee;
2031         Standard_Real f, l;
2032         Handle(Geom_Curve) cc = BRep_Tool::Curve(E, f, l);
2033         if(!theLastEdge.IsNull()) {
2034           const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
2035           const TopoDS_Vertex& v2 = TopExp::LastVertex(E,Standard_True);
2036           BRepLib_MakeEdge e(cc, v1, v2);
2037           eee = TopoDS::Edge(e.Shape());
2038         }
2039         else {
2040           eee = E;
2041         }
2042         myLFMap(E).Append(eee);
2043         BB.Add(w, eee);
2044         if(theFV.IsNull()) theFV = TopExp::FirstVertex(eee,Standard_True);
2045         theLastEdge = eee;
2046       }
2047       else break;
2048     }
2049
2050
2051     if(!OnLastFace) {
2052       if(!FirstEdge.IsSame(LastEdge)) {
2053         const TopoDS_Edge& edg = TopoDS::Edge(ex.Current());
2054         if(!myLFMap.IsBound(edg)) {
2055           TopTools_ListOfShape thelist3;
2056           myLFMap.Bind(edg, thelist3);
2057         }
2058         TopoDS_Edge eee;
2059         Standard_Real f, l;
2060         Handle(Geom_Curve) cc = BRep_Tool::Curve(edg, f, l);
2061         if(!theLastEdge.IsNull()) {
2062           const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
2063           TopoDS_Vertex v2;
2064           const gp_Pnt& pp = BRep_Tool::
2065             Pnt(TopExp::LastVertex(edg,Standard_True));
2066           if(!theFV.IsNull() && theFirstpoint.Distance(pp) <= myTol) {
2067             v2 = theFV;
2068           }
2069           else v2 = TopExp::LastVertex(edg,Standard_True);
2070           BRepLib_MakeEdge e(cc, v1, v2);
2071           eee = TopoDS::Edge(e.Shape());
2072         }
2073         else {
2074           const TopoDS_Vertex& v1 = TopExp::FirstVertex(edg,Standard_True);
2075           TopoDS_Vertex v2;
2076           const gp_Pnt& pp = BRep_Tool::
2077             Pnt(TopExp::LastVertex(edg,Standard_True));
2078           if(!theFV.IsNull() && theFirstpoint.Distance(pp) <= myTol) {
2079             v2 = theFV;
2080           }
2081           else v2 = TopExp::LastVertex(edg,Standard_True);
2082           BRepLib_MakeEdge e(cc, v1, v2);
2083           eee = TopoDS::Edge(e.Shape());
2084         }
2085         myLFMap(edg).Append(eee);
2086         BB.Add(w, eee);
2087         if(theFV.IsNull()) theFV = TopExp::FirstVertex(eee,Standard_True);
2088         theLastEdge = eee;
2089       }
2090       else {
2091         TopoDS_Edge eee;
2092         Standard_Real f, l;
2093         if(!myLFMap.IsBound(LastEdge)) {
2094           TopTools_ListOfShape thelist4;
2095           myLFMap.Bind(LastEdge, thelist4);
2096         }
2097         Handle(Geom_Curve) cc = BRep_Tool::Curve(FalseOnlyOne, f, l);
2098         if(!theLastEdge.IsNull()) {
2099           const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
2100           TopoDS_Vertex v2;
2101           const gp_Pnt& pp = BRep_Tool::
2102             Pnt(TopExp::LastVertex(FalseOnlyOne,Standard_True));
2103           if(!theFV.IsNull() && theFirstpoint.Distance(pp) <= myTol) {
2104             v2 = theFV;
2105           }
2106           else v2 = TopExp::LastVertex(FalseOnlyOne,Standard_True);
2107           BRepLib_MakeEdge e(cc, v1, v2);
2108           eee = TopoDS::Edge(e.Shape());
2109         }
2110         else {
2111           const TopoDS_Vertex& v1 = TopExp::FirstVertex(FalseOnlyOne,Standard_True);
2112           TopoDS_Vertex v2;
2113           const gp_Pnt& pp = BRep_Tool::
2114             Pnt(TopExp::LastVertex(FalseOnlyOne,Standard_True));
2115           if(!theFV.IsNull() && theFirstpoint.Distance(pp) <= myTol) {
2116             v2 = theFV;
2117           }
2118           else v2 = TopExp::LastVertex(FalseOnlyOne,Standard_True);
2119           BRepLib_MakeEdge e(cc, v1, v2);
2120           eee = TopoDS::Edge(e.Shape());
2121         }
2122         myLFMap(LastEdge).Append(eee);
2123         BB.Add(w, eee);
2124         if(theFV.IsNull()) theFV = TopExp::FirstVertex(eee,Standard_True);
2125         theLastEdge = eee;
2126       }
2127     }
2128     else {
2129       TopoDS_Edge eee;
2130       Standard_Real f, l;
2131       if(!myLFMap.IsBound(LastEdge)) {
2132         TopTools_ListOfShape thelist5;
2133         myLFMap.Bind(LastEdge, thelist5);
2134       }
2135       Handle(Geom_Curve) cc = BRep_Tool::Curve(FalseLastEdge, f, l);
2136       if(!theLastEdge.IsNull()) {
2137         const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
2138         TopoDS_Vertex v2;
2139         const gp_Pnt& pp = BRep_Tool::
2140           Pnt(TopExp::LastVertex(FalseLastEdge,Standard_True));
2141         if(!theFV.IsNull() && theFirstpoint.Distance(pp) <= myTol) {
2142           v2 = theFV;
2143         }
2144         else v2 = TopExp::LastVertex(FalseLastEdge,Standard_True);
2145         BRepLib_MakeEdge e(cc, v1, v2);
2146         eee = TopoDS::Edge(e.Shape());
2147       }
2148       else {
2149         const TopoDS_Vertex& v1 = TopExp::FirstVertex(FalseLastEdge,Standard_True);
2150         TopoDS_Vertex v2;
2151         const gp_Pnt& pp = BRep_Tool::
2152           Pnt(TopExp::LastVertex(FalseLastEdge,Standard_True));
2153         if(!theFV.IsNull() && theFirstpoint.Distance(pp) <= myTol) {
2154           v2 = theFV;
2155         }
2156         else v2 = TopExp::LastVertex(FalseLastEdge,Standard_True);
2157         BRepLib_MakeEdge e(cc, v1, v2);
2158         eee = TopoDS::Edge(e.Shape());
2159       }
2160       myLFMap(LastEdge).Append(eee);
2161       BB.Add(w, eee);
2162       if(theFV.IsNull()) theFV = TopExp::FirstVertex(eee,Standard_True);
2163       theLastEdge = eee;
2164     }
2165   }
2166
2167   if(Concavite == 1)  {
2168     TopoDS_Edge eef;
2169     if(theLastEdge.IsNull()) {
2170       BRepLib_MakeEdge ef(lastpoint, Pt);
2171       eef = TopoDS::Edge(ef.Shape());
2172     }
2173     else {
2174       const TopoDS_Vertex& v1 = TopExp::LastVertex(theLastEdge,Standard_True);
2175       BRepLib_MakeVertex vv(Pt);
2176       TopoDS_Vertex v2 = TopoDS::Vertex(vv.Shape());
2177       if(!theFV.IsNull() &&
2178          Pt.Distance(theFirstpoint) <= myTol) v2 = theFV;
2179
2180       BRepLib_MakeEdge ef(v1, v2);
2181       eef = TopoDS::Edge(ef.Shape());
2182     }
2183     BB.Add(w, eef);
2184     if(theFV.IsNull()) theFV = TopExp::FirstVertex(eef,Standard_True);
2185     theLastEdge = eef;
2186   }
2187
2188   if(Concavite == 2) {
2189     BRepLib_MakeEdge ee(lastpoint, firstpoint);
2190     const TopoDS_Edge& e = ee.Edge();
2191     BB.Add(w, e);
2192   }
2193
2194   w.Closed (BRep_Tool::IsClosed (w));
2195   BRepLib_MakeFace fa(myPln->Pln(), w, Standard_True);
2196   TopoDS_Face fac = TopoDS::Face(fa.Shape());
2197
2198   if (!BRepAlgo::IsValid(fac)) {
2199 #ifdef OCCT_DEBUG
2200     if (trc) std::cout << " Invalid Face" << std::endl;
2201 #endif
2202     ProfileOK = Standard_False;
2203     return ProfileOK;
2204   }
2205
2206 //    if(!Concavite) {
2207   if(Concavite == 3) {
2208     BRepTopAdaptor_FClass2d Cl(fac, BRep_Tool::Tolerance(fac));
2209     Standard_Real u, v;
2210     ElSLib::Parameters(myPln->Pln(), CheckPnt, u, v);
2211     gp_Pnt2d checkpnt2d(u, v);
2212     if(Cl.Perform(checkpnt2d, Standard_True) == TopAbs_OUT) {
2213       BRepAlgoAPI_Cut c(BndFace, fac);
2214       TopExp_Explorer exp(c.Shape(), TopAbs_WIRE);
2215       UpdateDescendants(c, c.Shape(), Standard_False);
2216       const TopoDS_Wire& ww = TopoDS::Wire(exp.Current());
2217       BRepLib_MakeFace ff(ww);
2218       Prof = TopoDS::Face(ff.Shape());
2219     }
2220     else {
2221       Prof = fac;
2222     }
2223   }
2224   else {
2225     Prof = fac;
2226   }
2227
2228   if (!BRepAlgo::IsValid(Prof)) {
2229 #ifdef OCCT_DEBUG
2230     if (trc) std::cout << " Invalid Face Profile" << std::endl;
2231 #endif
2232     ProfileOK = Standard_False;
2233     return ProfileOK;
2234   }
2235   return ProfileOK;
2236 }
2237
2238 //=======================================================================
2239 //function : UpdateDescendants
2240 //purpose  :
2241 //=======================================================================
2242   void BRepFeat_RibSlot::UpdateDescendants(const BRepAlgoAPI_BooleanOperation& aBOP,
2243                                            const TopoDS_Shape& S,
2244                                            const Standard_Boolean SkipFace)
2245 {
2246   TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itdm;
2247   TopTools_ListIteratorOfListOfShape it,it2;
2248   TopTools_MapIteratorOfMapOfShape itm;
2249   TopExp_Explorer exp;
2250
2251   for (itdm.Initialize(myMap);itdm.More();itdm.Next()) {
2252     const TopoDS_Shape& orig = itdm.Key();
2253     if (SkipFace && orig.ShapeType() == TopAbs_FACE) {
2254       continue;
2255     }
2256     TopTools_MapOfShape newdsc;
2257
2258     //if (itdm.Value().IsEmpty()) {myMap.ChangeFind(orig).Append(orig);}
2259
2260     for (it.Initialize(itdm.Value());it.More();it.Next()) {
2261       const TopoDS_Shape& sh = it.Value();
2262       if(sh.ShapeType() != TopAbs_FACE) continue;
2263       const TopoDS_Face& fdsc = TopoDS::Face(it.Value());
2264       for (exp.Init(S,TopAbs_FACE);exp.More();exp.Next()) {
2265         if (exp.Current().IsSame(fdsc)) { // preserved
2266           newdsc.Add(fdsc);
2267           break;
2268         }
2269       }
2270       if (!exp.More()) {
2271         BRepAlgoAPI_BooleanOperation* pBOP=(BRepAlgoAPI_BooleanOperation*)&aBOP;
2272         const TopTools_ListOfShape& aLM=pBOP->Modified(fdsc);
2273         it2.Initialize(aLM);
2274         for (; it2.More(); it2.Next()) {
2275           const TopoDS_Shape& aS=it2.Value();
2276           newdsc.Add(aS);
2277         }
2278
2279       }
2280     }
2281     myMap.ChangeFind(orig).Clear();
2282     for (itm.Initialize(newdsc); itm.More(); itm.Next()) {
2283        // check the belonging to the shape...
2284       for (exp.Init(S,TopAbs_FACE);exp.More();exp.Next()) {
2285         if (exp.Current().IsSame(itm.Key())) {
2286 //          const TopoDS_Shape& sh = itm.Key();
2287           myMap.ChangeFind(orig).Append(itm.Key());
2288           break;
2289         }
2290       }
2291     }
2292   }
2293 }