src/BRepFill/BRepFill_Generator.cxx

   1 // Created on: 1994-03-07
   2 // Created by: Bruno DUMORTIER
   3 // Copyright (c) 1994-1999 Matra Datavision
   4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
   5 //
   6 // The content of this file is subject to the Open CASCADE Technology Public
   7 // License Version 6.5 (the "License"). You may not use the content of this file
   8 // except in compliance with the License. Please obtain a copy of the License
   9 // at http://www.opencascade.org and read it completely before using this file.
  10 //
  11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  13 //
  14 // The Original Code and all software distributed under the License is
  15 // distributed on an "AS IS" basis, without warranty of any kind, and the
  16 // Initial Developer hereby disclaims all such warranties, including without
  17 // limitation, any warranties of merchantability, fitness for a particular
  18 // purpose or non-infringement. Please see the License for the specific terms
  19 // and conditions governing the rights and limitations under the License.
  20
  21
  22 #include <BRepFill_Generator.ixx>
  23
  24 #include <TopoDS_Face.hxx>
  25 #include <TopoDS_Wire.hxx>
  26 #include <TopoDS_Edge.hxx>
  27 #include <TopoDS_Vertex.hxx>
  28 #include <BRep_Builder.hxx>
  29 #include <TopLoc_Location.hxx>
  30 #include <TopExp_Explorer.hxx>
  31 #include <gp_Pnt2d.hxx>
  32 #include <gp_Dir2d.hxx>
  33 #include <gp_Ax1.hxx>
  34 #include <gp_Ax3.hxx>
  35 #include <gp_Circ.hxx>
  36 #include <gp_Lin.hxx>
  37 #include <GeomAbs_Shape.hxx>
  38 #include <GeomAdaptor_Curve.hxx>
  39 #include <Geom_Circle.hxx>
  40 #include <Geom_Line.hxx>
  41 #include <Geom_Curve.hxx>
  42 #include <Geom_BezierCurve.hxx>
  43 #include <Geom_TrimmedCurve.hxx>
  44 #include <Geom_Surface.hxx>
  45 #include <Geom_Plane.hxx>
  46 #include <Geom_CylindricalSurface.hxx>
  47 #include <Geom_ConicalSurface.hxx>
  48 #include <Geom_RectangularTrimmedSurface.hxx>
  49 #include <Geom2d_Line.hxx>
  50 #include <Geom2d_BezierCurve.hxx>
  51 #include <GeomFill_Generator.hxx>
  52
  53 #include <TopTools_DataMapOfShapeShape.hxx>
  54 #include <GeomFill.hxx>
  55 #include <BRep_Tool.hxx>
  56 #include <TopoDS.hxx>
  57 #include <TopExp.hxx>
  58 #include <Precision.hxx>
  59 #include <BRepLib.hxx>
  60
  61 #include <TColgp_Array1OfPnt.hxx>
  62 #include <TColgp_Array1OfPnt2d.hxx>
  63 #include <Geom_BSplineCurve.hxx>
  64 #include <gp_Vec.hxx>
  65 #include <GeomConvert.hxx>
  66
  67 #include <BRepTools_WireExplorer.hxx>
  68 #include <BRepTools.hxx>
  69
  70
  71
  72 //=======================================================================
  73 //function : DetectKPart
  74 //purpose  :
  75 //=======================================================================
  76
  77 Standard_Integer DetectKPart(const TopoDS_Edge& Edge1,
  78                              const TopoDS_Edge& Edge2)
  79 {
  80   // initializations
  81   Standard_Integer IType = 0;
  82
  83   // characteristics of the first edge
  84   Standard_Real first1, last1, first2, last2, ff, ll;
  85   TopLoc_Location loc;
  86   TopoDS_Vertex V1, V2;
  87   Handle(Geom_Curve) curv1, curv;
  88   GeomAdaptor_Curve AdC1;
  89   Standard_Boolean degen1 = BRep_Tool::Degenerated(Edge1);
  90
  91   // find the particular case
  92   gp_Pnt pos1, pos;
  93   Standard_Real  dist;
  94   Standard_Real dist1 =0.;
  95   gp_Ax1 axe1, axe;
  96
  97   if (degen1) {
  98     IType = -2;
  99     TopExp::Vertices(Edge1,V1,V2);
 100     pos1 = BRep_Tool::Pnt(V1);
 101   }
 102   else {
 103     curv1 = BRep_Tool::Curve(Edge1, loc, first1, last1);
 104     curv1 =
 105       Handle(Geom_Curve)::DownCast(curv1->Transformed(loc.Transformation()));
 106     ff = first1;
 107     ll = last1;
 108     if (Edge1.Orientation() == TopAbs_REVERSED) {
 109       curv1->Reverse();
 110       first1 = curv1->ReversedParameter(ll);
 111       last1 = curv1->ReversedParameter(ff);
 112     }
 113     AdC1.Load(curv1);
 114     if (AdC1.GetType() == GeomAbs_Circle) {
 115       // first circular section
 116       IType = 1;
 117       pos1 = AdC1.Circle().Location();
 118       dist1 = AdC1.Circle().Radius();
 119       axe1 = AdC1.Circle().Axis();
 120     }
 121     else if (AdC1.GetType() == GeomAbs_Line) {
 122       // first straight line section
 123       IType = 4;
 124       pos1 = AdC1.Line().Location();
 125       dist1 = AdC1.Value(first1).Distance(AdC1.Value(last1));
 126       gp_Vec vec(AdC1.Value(first1),AdC1.Value(last1));
 127       gp_Dir dir(vec);
 128       axe1 = gp_Ax1(AdC1.Value(first1),dir);
 129     }
 130     else {
 131       // first section of any type
 132       IType = 0;
 133     }
 134   }
 135
 136   if (IType!=0) {
 137
 138     Standard_Boolean degen2 = BRep_Tool::Degenerated(Edge2);
 139     if (degen2) {
 140       TopExp::Vertices(Edge2,V1,V2);
 141       pos = BRep_Tool::Pnt(V1);
 142       if (IType==1) {
 143         // the only particular case with degenerated edge at end : the cone
 144         if (pos.IsEqual(pos1,Precision::Confusion())) {
 145           // the top is mixed with the center of the circle
 146           IType = 0;
 147         }
 148         else {
 149           gp_Vec vec(pos1,pos);
 150           gp_Dir dir(vec);
 151           axe = gp_Ax1(pos1,dir);
 152           if (axe.IsParallel(axe1,Precision::Angular())) {
 153             // the top is on the axis of the circle
 154             IType = 2;
 155           }
 156           else {
 157             // incorrect top --> no particular case
 158             IType = 0;
 159           }
 160         }
 161       }
 162       else if (IType != 4) { //not a plane
 163         // no particular case
 164         IType = 0;
 165       }
 166     }
 167     else {
 168       curv = BRep_Tool::Curve(Edge2, loc, first2, last2);
 169       curv =
 170         Handle(Geom_Curve)::DownCast(curv->Transformed(loc.Transformation()));
 171       ff = first2;
 172       ll = last2;
 173       if (Edge2.Orientation() == TopAbs_REVERSED) {
 174         curv->Reverse();
 175         first2 = curv->ReversedParameter(ll);
 176         last2 = curv->ReversedParameter(ff);
 177       }
 178       GeomAdaptor_Curve AdC(curv);
 179
 180       if (IType>0 && IType<4) {
 181         if (AdC.GetType() != GeomAbs_Circle) {
 182           // section not circular --> no particular case
 183           IType = 0;
 184         }
 185         else {
 186           if (AdC.Circle().Axis()
 187               .IsCoaxial(axe1,Precision::Angular(),Precision::Confusion())) {
 188             // same axis
 189             if (Abs(AdC.Circle().Radius()-dist1)< Precision::Confusion()) {
 190               // possibility of cylinder or a piece of cylinder
 191               Standard_Real h1 = Abs(last1-first1), h2 = Abs(last2-first2);
 192               Standard_Boolean Same,
 193                SameParametricLength = ( Abs(h1-h2) < Precision::PConfusion() );
 194               Standard_Real m1=(first1+last1)/2., m2=(first2+last2)/2.;
 195               gp_Pnt P1,P2;
 196               gp_Vec DU;
 197               AdC1.D1(m1,P1,DU);
 198               AdC.D0(m2,P2);
 199               Same = SameParametricLength
 200                 && ( gp_Vec(P1,P2).IsNormal(DU,Precision::Angular()) ) ;
 201               if (Same) {
 202                 // cylinder or piece of cylinder
 203                 IType = 1;
 204               }
 205               else {
 206                 // the interval of definition is not correct
 207                 IType = 0;
 208               }
 209             }
 210             else {
 211               // possibility of cone truncation
 212               Standard_Real h1 = Abs(last1-first1), h2 = Abs(last2-first2);
 213               Standard_Boolean Same,
 214                SameParametricLength = ( Abs(h1-h2) < Precision::PConfusion() );
 215               Standard_Real m1=(first1+last1)/2., m2=(first2+last2)/2.;
 216               gp_Pnt P1,P2;
 217               gp_Vec DU;
 218               AdC1.D1(m1,P1,DU);
 219               AdC.D0(m2,P2);
 220               Same = SameParametricLength
 221                 && ( gp_Vec(P1,P2).IsNormal(DU,Precision::Angular()) ) ;
 222               if (Same) {
 223                 // truncation of cone
 224                 IType = 2;
 225               }
 226               else {
 227                 // the interval of definition is not correct
 228                 IType = 0;
 229               }
 230             }
 231             if (AdC.Circle().Location().IsEqual(pos1,Precision::Confusion())) {
 232               // the centers are mixed
 233               IType = 0;
 234             }
 235           }
 236           else {
 237             // different axis
 238             if (AdC.Circle().Radius()==dist1) {
 239               // torus ?
 240               IType = 3;
 241             }
 242             else {
 243               // different radius --> no particular case
 244               IType = 0;
 245             }
 246           }
 247         }
 248       }
 249       else if (IType>=4) {
 250         if (AdC.GetType() != GeomAbs_Line) {
 251           // not a straight line section --> no particular case
 252           IType = 0;
 253         }
 254         else {
 255           pos = AdC.Line().Location();
 256           dist = AdC.Value(first2).Distance(AdC.Value(last2));
 257           gp_Vec vec(AdC.Value(first2),AdC.Value(last2));
 258           gp_Dir dir(vec);
 259           axe = gp_Ax1(AdC.Value(first2),dir);
 260           if (axe.IsParallel(axe1,Precision::Angular())) {
 261             // parallel straight line
 262             if (Abs(dist-dist1)<Precision::Confusion()) {
 263               gp_Dir dir(gp_Vec(AdC1.Value(first1),AdC.Value(first2)));
 264               if (dir.IsNormal(gp_Dir(vec),Precision::Angular())) {
 265                 // plane
 266                 IType = 4;
 267               }
 268               else {
 269                 // extrusion ?
 270                 IType = 5;
 271               }
 272             }
 273             else {
 274               // different length --> no particular case
 275               IType = 0;
 276             }
 277           }
 278           else {
 279             // not parallel straight line --> no particular case
 280             IType = 0;
 281           }
 282         }
 283       }
 284       else if (IType==-2) {
 285         if (AdC.GetType() == GeomAbs_Line)
 286           IType = 4; //plane
 287         else if (AdC.GetType() == GeomAbs_Circle)
 288           {
 289             // the only particular case with degenerated edge at the beginning the cone
 290             pos = AdC.Circle().Location();
 291             axe = AdC.Circle().Axis();
 292             if (pos1.IsEqual(pos,Precision::Confusion())) {
 293               // the top is mixed with the center of the circle
 294               IType = 0;
 295             }
 296             else {
 297               gp_Vec vec(pos1,pos);
 298               gp_Dir dir(vec);
 299               axe1 = gp_Ax1(pos1,dir);
 300               if (axe.IsParallel(axe1,Precision::Angular())) {
 301                 // the top is on the axis of the circle
 302                 IType = -2;
 303               }
 304               else {
 305                 // incorrect top --> no particular case
 306                 IType = 0;
 307               }
 308             }
 309           }
 310         else
 311           IType = 0;
 312       }
 313     }
 314
 315   }
 316   // torus and extrusion are not particular cases.
 317   if (IType == 3 || IType == 5) IType = 0;
 318   return IType;
 319 }
 320
 321
 322 //=======================================================================
 323 //function : CreateKPart
 324 //purpose  :
 325 //=======================================================================
 326
 327 void CreateKPart(const TopoDS_Edge& Edge1,const TopoDS_Edge& Edge2,
 328                  const Standard_Integer IType,
 329                  Handle(Geom_Surface)& Surf)
 330 {
 331   // find the dimension
 332   TopoDS_Vertex V1, V2;
 333
 334   TopLoc_Location loc;
 335   Standard_Real a1, b1, aa =0., bb =0.;
 336   TopoDS_Vertex v1f,v1l,v2f,v2l;
 337
 338   // find characteristics of the first edge
 339   Handle(Geom_Curve) C1;
 340   Standard_Boolean degen1 = BRep_Tool::Degenerated(Edge1);
 341   if(degen1) {
 342     // cone with degenerated edge at the top
 343     TopExp::Vertices(Edge1,v1f,v1l);
 344   }
 345   else {
 346     C1 = BRep_Tool::Curve(Edge1, loc, a1, b1);
 347     C1 = Handle(Geom_Curve)::DownCast(C1->Transformed(loc.Transformation()));
 348     aa = a1;
 349     bb = b1;
 350     if (Edge1.Orientation() == TopAbs_REVERSED) {
 351       C1->Reverse();
 352       aa = C1->ReversedParameter(b1);
 353       bb = C1->ReversedParameter(a1);
 354       TopExp::Vertices(Edge1,v1l,v1f);
 355     }
 356     else {
 357       TopExp::Vertices(Edge1,v1f,v1l);
 358     }
 359   }
 360
 361   // find characteristics of the second edge
 362   Handle(Geom_Curve) C2;
 363   Standard_Boolean degen2 = BRep_Tool::Degenerated(Edge2);
 364   if(degen2) {
 365     // cone with degenerated edge at the top
 366     TopExp::Vertices(Edge2,v2f,v2l);
 367   }
 368   else {
 369     C2 = BRep_Tool::Curve(Edge2, loc, a1, b1);
 370     C2 = Handle(Geom_Curve)::DownCast(C2->Transformed(loc.Transformation()));
 371     if (Edge2.Orientation() == TopAbs_REVERSED) {
 372       C2->Reverse();
 373       if (degen1) {
 374         aa = a1;
 375         bb = b1;
 376       }
 377       TopExp::Vertices(Edge2,v2l,v2f);
 378     }
 379     else {
 380       if (degen1) {
 381         aa = a1; //C2->ReversedParameter(b1);
 382         bb = b1; //C2->ReversedParameter(a1);
 383       }
 384       TopExp::Vertices(Edge2,v2f,v2l);
 385     }
 386   }
 387
 388   // create the new surface
 389   TopoDS_Shell shell;
 390   TopoDS_Face face;
 391   TopoDS_Wire W;
 392   TopoDS_Edge edge1, edge2, edge3, edge4, couture;
 393
 394   BRep_Builder B;
 395   B.MakeShell(shell);
 396
 397   TopoDS_Wire newW1, newW2;
 398   BRep_Builder BW1, BW2;
 399   BW1.MakeWire(newW1);
 400   BW2.MakeWire(newW2);
 401
 402
 403   // calculate the surface
 404   Handle(Geom_Surface) surface;
 405   Standard_Real V, Rad;
 406   if (IType==1) {
 407     // cylindrical surface
 408     gp_Circ c1 = (Handle(Geom_Circle)::DownCast(C1))->Circ();
 409     gp_Circ c2 = (Handle(Geom_Circle)::DownCast(C2))->Circ();
 410     gp_Ax3 Ac1 = c1.Position();
 411     V = gp_Vec( c1.Location(),c2.Location()).Dot(gp_Vec(Ac1.Direction()));
 412     if ( V < 0.) {
 413       Ac1.ZReverse();
 414       V = -V;
 415     }
 416     Handle(Geom_CylindricalSurface) Cyl =
 417       new Geom_CylindricalSurface( Ac1, c1.Radius());
 418     surface = new Geom_RectangularTrimmedSurface
 419       ( Cyl, aa, bb, Min(0.,V), Max(0.,V) );
 420   }
 421   else if (IType==2) {
 422     // conical surface
 423     gp_Circ k1 = (Handle(Geom_Circle)::DownCast(C1))->Circ();
 424     gp_Ax3 Ak1 = k1.Position();
 425     if (degen2) {
 426       V = gp_Vec( k1.Location(),BRep_Tool::Pnt(v2f))
 427         .Dot(gp_Vec(Ak1.Direction()));
 428       Rad = - k1.Radius();
 429     }
 430     else {
 431       gp_Circ k2 = (Handle(Geom_Circle)::DownCast(C2))->Circ();
 432       V = gp_Vec( k1.Location(),k2.Location()).Dot(gp_Vec(Ak1.Direction()));
 433       Rad = k2.Radius() - k1.Radius();
 434     }
 435
 436     if ( V < 0.) {
 437       Ak1.ZReverse();
 438       V = -V;
 439     }
 440     Standard_Real Ang = ATan( Rad / V);
 441     Handle(Geom_ConicalSurface) Cone =
 442       new Geom_ConicalSurface( Ak1, Ang, k1.Radius());
 443     V /= Cos(Ang);
 444     surface = new Geom_RectangularTrimmedSurface
 445       ( Cone, aa, bb, Min(0.,V), Max(0.,V) );
 446   }
 447   else if (IType==-2) {
 448     // conical surface with the top at the beginning (degen1 is true)
 449     gp_Circ k2 = (Handle(Geom_Circle)::DownCast(C2))->Circ();
 450     gp_Ax3 Ak2 = k2.Position();
 451     Ak2.SetLocation(BRep_Tool::Pnt(v1f));
 452     V = gp_Vec(BRep_Tool::Pnt(v1f),k2.Location())
 453                                 .Dot(gp_Vec(Ak2.Direction()));
 454     Rad = k2.Radius(); // - k2.Radius();
 455     if ( V < 0.) {
 456       Ak2.ZReverse();
 457       V = -V;
 458     }
 459     Standard_Real Ang = ATan( Rad / V);
 460     Handle(Geom_ConicalSurface) Cone =
 461       new Geom_ConicalSurface( Ak2, Ang, 0.);
 462     V /= Cos(Ang);
 463     surface = new Geom_RectangularTrimmedSurface
 464       ( Cone, aa, bb, Min(0.,V), Max(0.,V) );
 465   }
 466   else if (IType==3) {
 467     // torus surface ?
 468   }
 469   else if (IType==4) {
 470     // surface plane
 471     gp_Lin L1, L2, aLine;
 472     if (!degen1)
 473       {
 474         L1 = (Handle(Geom_Line)::DownCast(C1))->Lin();
 475         aLine = L1;
 476       }
 477     if (!degen2)
 478       {
 479         L2 = (Handle(Geom_Line)::DownCast(C2))->Lin();
 480         aLine = L2;
 481       }
 482
 483     gp_Pnt P1 = (degen1)? BRep_Tool::Pnt(v1f) : L1.Location();
 484     gp_Pnt P2 = (degen2)? BRep_Tool::Pnt(v2f) : L2.Location();
 485
 486     gp_Vec P1P2( P1, P2 );
 487     gp_Dir D1 = aLine.Direction();
 488     gp_Ax3 Ax( aLine.Location(), gp_Dir(D1.Crossed(P1P2)), D1 );
 489     Handle(Geom_Plane) Plan = new Geom_Plane(Ax);
 490     V = P1P2.Dot( Ax.YDirection());
 491     surface = Plan;
 492     //surface = new Geom_RectangularTrimmedSurface
 493       //( Plan, aa, bb, Min(0.,V), Max(0.,V) );
 494   }
 495   else if (IType==5) {
 496     // surface of extrusion ?
 497   }
 498   else {
 499     // IType incorrect
 500   }
 501   Surf = surface;
 502 }
 503
 504
 505 //=======================================================================
 506 //function : BRepFill_Generator
 507 //purpose  :
 508 //=======================================================================
 509
 510 BRepFill_Generator::BRepFill_Generator()
 511 {
 512 }
 513
 514
 515 //=======================================================================
 516 //function : AddWire
 517 //purpose  :
 518 //=======================================================================
 519
 520 void BRepFill_Generator::AddWire(const TopoDS_Wire& Wire)
 521 {
 522   myWires.Append( Wire);
 523 }
 524
 525
 526 //=======================================================================
 527 //function : Perform
 528 //purpose  :
 529 //=======================================================================
 530
 531 void BRepFill_Generator::Perform()
 532 {
 533   TopoDS_Shell Shell;
 534   TopoDS_Face  Face;
 535   TopoDS_Shape S1, S2;
 536   TopoDS_Edge  Edge1, Edge2, Edge3, Edge4, Couture;
 537
 538   BRep_Builder B;
 539   B.MakeShell(myShell);
 540
 541   Standard_Integer Nb = myWires.Length();
 542
 543   BRepTools_WireExplorer ex1,ex2;
 544
 545   Standard_Boolean wPoint1, wPoint2, uClosed, DegenFirst, DegenLast;
 546
 547   for ( Standard_Integer i = 1; i <= Nb-1; i++) {
 548
 549     TopoDS_Wire Wire1 = TopoDS::Wire(myWires( i ));
 550     TopoDS_Wire Wire2 = TopoDS::Wire(myWires(i+1));
 551
 552     wPoint1 = Standard_False;
 553     if (i==1) {
 554       wPoint1 = Standard_True;
 555       for(ex1.Init(Wire1); ex1.More(); ex1.Next()) {
 556         wPoint1 = wPoint1 && (BRep_Tool::Degenerated(ex1.Current()));
 557       }
 558       DegenFirst = wPoint1;
 559
 560       TopoDS_Vertex V1, V2;
 561       TopExp::Vertices(Wire1, V1, V2);
 562       uClosed = V1.IsSame(V2);
 563     }
 564
 565     wPoint2 = Standard_False;
 566     if (i==Nb-1) {
 567       wPoint2 = Standard_True;
 568       for(ex2.Init(Wire2); ex2.More(); ex2.Next()) {
 569         wPoint2 = wPoint2 && (BRep_Tool::Degenerated(ex2.Current()));
 570       }
 571       DegenLast = wPoint2;
 572     }
 573
 574     ex1.Init(Wire1);
 575     ex2.Init(Wire2);
 576
 577     TopTools_DataMapOfShapeShape Map;
 578
 579     Standard_Boolean tantque = ex1.More() && ex2.More();
 580
 581     while ( tantque ) {
 582
 583       TopoDS_Vertex V1f,V1l,V2f,V2l, Vf_toMap, Vl_toMap;
 584
 585       Standard_Boolean degen1
 586         = BRep_Tool::Degenerated(TopoDS::Edge(ex1.Current()));
 587       Standard_Boolean degen2
 588         = BRep_Tool::Degenerated(TopoDS::Edge(ex2.Current()));
 589
 590       if ( degen1 ) {
 591         TopoDS_Shape aLocalShape = ex1.Current().EmptyCopied();
 592         Edge1 = TopoDS::Edge(aLocalShape);
 593 //      Edge1 = TopoDS::Edge(ex1.Current().EmptyCopied());
 594 //      aLocalShape = ex1.Current();
 595 //      TopExp::Vertices(TopoDS::Edge(aLocalShape),V1f,V1l);
 596         TopExp::Vertices(TopoDS::Edge(ex1.Current()),V1f,V1l);
 597         V1f.Orientation(TopAbs_FORWARD);
 598         B.Add(Edge1,V1f);
 599         V1l.Orientation(TopAbs_REVERSED);
 600         B.Add(Edge1,V1l);
 601         B.Range(Edge1,0,1);
 602       }
 603       else {
 604         TopoDS_Shape aLocalShape = ex1.Current();
 605         Edge1 = TopoDS::Edge(aLocalShape);
 606 //      Edge1 = TopoDS::Edge(ex1.Current());
 607       }
 608
 609       if ( degen2 ) {
 610         TopoDS_Shape aLocalShape = ex2.Current().EmptyCopied();
 611         Edge2 = TopoDS::Edge(aLocalShape);
 612 //      Edge2 = TopoDS::Edge(ex2.Current().EmptyCopied());
 613         TopExp::Vertices(TopoDS::Edge(ex2.Current()),V2f,V2l);
 614         V2f.Orientation(TopAbs_FORWARD);
 615         B.Add(Edge2,V2f);
 616         V2l.Orientation(TopAbs_REVERSED);
 617         B.Add(Edge2,V2l);
 618         B.Range(Edge2,0,1);
 619       }
 620       else {
 621         Edge2 = TopoDS::Edge(ex2.Current());
 622       }
 623
 624       Standard_Boolean Periodic
 625         = (Edge1.Closed() || degen1) && (Edge2.Closed() || degen2);
 626       // ATTENTION : a non-punctual wire should not
 627       //             contain a punctual edge
 628       if (!wPoint1) ex1.Next();
 629       if (!wPoint2) ex2.Next();
 630
 631       // initialization of vertices
 632       Handle(Geom_Surface) Surf;
 633       Standard_Real f1=0, l1=1, f2=0, l2=1;
 634       if (Edge1.Orientation() == TopAbs_REVERSED)
 635         TopExp::Vertices(Edge1,V1l,V1f);
 636       else
 637         TopExp::Vertices(Edge1,V1f,V1l);
 638       if (Edge2.Orientation() == TopAbs_REVERSED)
 639         TopExp::Vertices(Edge2,V2l,V2f);
 640       else
 641         TopExp::Vertices(Edge2,V2f,V2l);
 642       if (degen1)
 643         {
 644           Vf_toMap = V2f;
 645           Vl_toMap = V2l;
 646         }
 647       else
 648         {
 649           Vf_toMap = V1f;
 650           Vl_toMap = V1l;
 651         }
 652
 653       if(Periodic) {
 654         Standard_Boolean E1IsReallyClosed = BRepTools::Compare(V1f,V1l);
 655         Standard_Boolean E2IsReallyClosed = BRepTools::Compare(V2f,V2l);
 656         Periodic
 657           = (E1IsReallyClosed || degen1) && (E2IsReallyClosed || degen2);
 658       }
 659       // processing of KPart
 660       Standard_Integer IType = DetectKPart(Edge1,Edge2);
 661       if (IType==0) {
 662         // no part cases
 663         TopLoc_Location L,L1,L2;
 664
 665         Handle(Geom_Curve) C1, C2;
 666         TColgp_Array1OfPnt Extremities(1,2);
 667
 668         if (degen1) {
 669           Extremities(1) = BRep_Tool::Pnt(V1f);
 670           Extremities(2) = BRep_Tool::Pnt(V1l);
 671           C1 = new Geom_BezierCurve(Extremities);
 672         }
 673         else {
 674           C1 = BRep_Tool::Curve(Edge1,L1,f1,l1);
 675         }
 676         if (degen2) {
 677           Extremities(1) = BRep_Tool::Pnt(V2l);
 678           Extremities(2) = BRep_Tool::Pnt(V2f);
 679           C2 = new Geom_BezierCurve(Extremities);
 680         }
 681         else {
 682           C2 = BRep_Tool::Curve(Edge2,L2,f2,l2);
 683         }
 684
 685         // compute the location
 686         Standard_Boolean SameLoc = Standard_False;
 687
 688         // transform and trim the curves
 689
 690         if (Abs(f1 - C1->FirstParameter()) > Precision::PConfusion() ||
 691             Abs(l1 - C1->LastParameter())  > Precision::PConfusion()   ) {
 692           C1 = new Geom_TrimmedCurve(C1,f1,l1);
 693         }
 694         else {
 695           C1 = Handle(Geom_Curve)::DownCast(C1->Copy());
 696         }
 697         if (!SameLoc) C1->Transform(L1.Transformation());
 698         if (Edge1.Orientation() == TopAbs_REVERSED) {
 699           C1->Reverse();
 700         }
 701
 702         if (Abs(f2 - C2->FirstParameter()) > Precision::PConfusion() ||
 703             Abs(l2 - C2->LastParameter())  > Precision::PConfusion()   ) {
 704           C2 = new Geom_TrimmedCurve(C2,f2,l2);
 705         }
 706         else {
 707           C2 = Handle(Geom_Curve)::DownCast(C2->Copy());
 708         }
 709         if (!SameLoc) C2->Transform(L2.Transformation());
 710         if (Edge2.Orientation() == TopAbs_REVERSED) {
 711           C2->Reverse();
 712         }
 713
 714         GeomFill_Generator Generator;
 715         Generator.AddCurve( C1);
 716         Generator.AddCurve( C2);
 717         Generator.Perform( Precision::PConfusion());
 718
 719         Surf = Generator.Surface();
 720         B.MakeFace(Face,Surf,Precision::Confusion());
 721       }
 722       else {
 723         // particular case
 724         CreateKPart(Edge1,Edge2,IType,Surf);
 725         B.MakeFace(Face,Surf,Precision::Confusion());
 726       }
 727
 728       // make the missing edges
 729       Standard_Real first,last;
 730       Surf->Bounds(f1,l1,f2,l2);
 731
 732       if ( Map.IsBound(Vf_toMap)) {
 733         TopoDS_Shape aLocalShape = Map(Vf_toMap).Reversed();
 734         Edge3 = TopoDS::Edge(aLocalShape);
 735 //      Edge3 = TopoDS::Edge(Map(V1f).Reversed());
 736       }
 737       else {
 738         Handle(Geom_Curve) CC;
 739         TColgp_Array1OfPnt Extremities(1,2);
 740         if (IType==0) {
 741           // general case : Edge3 corresponds to iso U=f1
 742           CC = Surf->UIso(f1);
 743           first=f2;
 744           last=l2;
 745         }
 746         else {
 747           // particular case : it is required to calculate the curve 3d
 748           Extremities(1) = BRep_Tool::Pnt(V1f);
 749           Extremities(2) = BRep_Tool::Pnt(V2f);
 750           CC = new Geom_BezierCurve(Extremities);
 751           first=0.;
 752           last=1.;
 753         }
 754         B.MakeEdge(Edge3,CC,Precision::Confusion());
 755         V1f.Orientation(TopAbs_FORWARD);
 756         B.Add(Edge3,V1f);
 757         V2f.Orientation(TopAbs_REVERSED);
 758         B.Add(Edge3,V2f);
 759         B.Range(Edge3,first,last);
 760         Edge3.Reverse();
 761         Map.Bind(Vf_toMap, Edge3);
 762       }
 763
 764       Standard_Boolean CommonEdge = Standard_False;
 765       if ( Map.IsBound(Vl_toMap)  ) {
 766         TopoDS_Shape aLocalShape = Map(Vl_toMap).Reversed();
 767         const TopoDS_Edge CommonE = TopoDS::Edge(aLocalShape);
 768 //      const TopoDS_Edge CommonE = TopoDS::Edge(Map(V1l).Reversed());
 769         TopoDS_Vertex V1, V2;
 770         TopExp::Vertices(CommonE,V1,V2);
 771         CommonEdge = V1.IsSame(V1l) && V2.IsSame(V2l);
 772       }
 773       if ( CommonEdge ) {
 774         TopoDS_Shape aLocalShape = Map(Vl_toMap).Reversed();
 775         Edge4 = TopoDS::Edge(aLocalShape);
 776 //      Edge4 = TopoDS::Edge(Map(V1l).Reversed());
 777       }
 778       else {
 779         Handle(Geom_Curve) CC;
 780         TColgp_Array1OfPnt Extremities(1,2);
 781         if (IType==0) {
 782           // general case : Edge4 corresponds to iso U=l1
 783           CC = Surf->UIso(l1);
 784           first=f2;
 785           last=l2;
 786         }
 787         else {
 788           // particular case : it is required to calculate the curve 3d
 789           Extremities(1) = BRep_Tool::Pnt(V1l);
 790           Extremities(2) = BRep_Tool::Pnt(V2l);
 791           CC = new Geom_BezierCurve(Extremities);
 792           first=0.;
 793           last=1.;
 794         }
 795         B.MakeEdge(Edge4,CC,Precision::Confusion());
 796         V1l.Orientation(TopAbs_FORWARD);
 797         B.Add(Edge4,V1l);
 798         V2l.Orientation(TopAbs_REVERSED);
 799         B.Add(Edge4,V2l);
 800         B.Range(Edge4,first,last);
 801         Map.Bind(Vl_toMap, Edge4);
 802       }
 803
 804       // make the wire
 805
 806       TopoDS_Wire W;
 807       B.MakeWire(W);
 808
 809       if (! (degen1 && IType == 4))
 810         B.Add(W,Edge1);
 811       B.Add(W,Edge4);
 812       if (! (degen2 && IType == 4))
 813         B.Add(W,Edge2.Reversed());
 814       B.Add(W,Edge3);
 815
 816       B.Add(Face,W);
 817
 818       B.Add(myShell,Face);
 819
 820     // complete myMap for edge1
 821       if (! (degen1 && IType == 4))
 822         {
 823           TopTools_ListOfShape Empty;
 824           if (!myMap.IsBound(Edge1)) myMap.Bind(Edge1,Empty);
 825           myMap(Edge1).Append(Face);
 826         }
 827
 828       // set the pcurves
 829
 830       Standard_Real T = Precision::Confusion();
 831
 832       if (IType != 4) //not plane
 833         {
 834           if ( Edge1.Orientation() == TopAbs_REVERSED ) {
 835             B.UpdateEdge(Edge1,
 836                          new Geom2d_Line(gp_Pnt2d(0,f2),gp_Dir2d(-1,0)),
 837                          Face,T);
 838             B.Range(Edge1,Face,-l1,-f1);
 839           }
 840           else {
 841             B.UpdateEdge(Edge1,
 842                          new Geom2d_Line(gp_Pnt2d(0,f2),gp_Dir2d(1,0)),
 843                          Face,T);
 844             B.Range(Edge1,Face,f1,l1);
 845           }
 846
 847           if ( Edge2.Orientation() == TopAbs_REVERSED ) {
 848             B.UpdateEdge(Edge2,
 849                          new Geom2d_Line(gp_Pnt2d(0,l2),gp_Dir2d(-1,0)),
 850                          Face,T);
 851             B.Range(Edge2,Face,-l1,-f1);
 852           }
 853           else {
 854             B.UpdateEdge(Edge2,
 855                          new Geom2d_Line(gp_Pnt2d(0,l2),gp_Dir2d(1,0)),
 856                          Face,T);
 857             B.Range(Edge2,Face,f1,l1);
 858           }
 859         }
 860
 861       if (IType==0) {
 862         if ( Periodic) {
 863           B.UpdateEdge(Edge3,
 864                        new Geom2d_Line(gp_Pnt2d(l1,0),gp_Dir2d(0,1)),
 865                        new Geom2d_Line(gp_Pnt2d(f1,0),gp_Dir2d(0,1)),
 866                        Face,T);
 867         }
 868         else {
 869           B.UpdateEdge(Edge3,
 870                        new Geom2d_Line(gp_Pnt2d(f1,0),gp_Dir2d(0,1)),
 871                        Face,T);
 872           B.UpdateEdge(Edge4,
 873                        new Geom2d_Line(gp_Pnt2d(l1,0),gp_Dir2d(0,1)),
 874                        Face,T);
 875         }
 876       }
 877       else {
 878         // KPart
 879         if ( Periodic) {
 880           TColgp_Array1OfPnt2d Extrem1(1,2);
 881           Extrem1(1).SetCoord(l1,f2);
 882           Extrem1(2).SetCoord(l1,l2);
 883           TColgp_Array1OfPnt2d Extrem2(1,2);
 884           Extrem2(1).SetCoord(f1,f2);
 885           Extrem2(2).SetCoord(f1,l2);
 886           B.UpdateEdge(Edge3,
 887                        new Geom2d_BezierCurve(Extrem1),
 888                        new Geom2d_BezierCurve(Extrem2),
 889                        Face,T);
 890         }
 891         else if (IType != 4) { //not plane
 892           TColgp_Array1OfPnt2d Extrem2(1,2);
 893           Extrem2(1).SetCoord(f1,f2);
 894           Extrem2(2).SetCoord(f1,l2);
 895           B.UpdateEdge(Edge3,
 896                        new Geom2d_BezierCurve(Extrem2),
 897                        Face,T);
 898           TColgp_Array1OfPnt2d Extrem1(1,2);
 899           Extrem1(1).SetCoord(l1,f2);
 900           Extrem1(2).SetCoord(l1,l2);
 901           B.UpdateEdge(Edge4,
 902                        new Geom2d_BezierCurve(Extrem1),
 903                        Face,T);
 904         }
 905       }
 906       // Set the non parameter flag;
 907       B.SameParameter(Edge1,Standard_False);
 908       B.SameParameter(Edge2,Standard_False);
 909       B.SameParameter(Edge3,Standard_False);
 910       B.SameParameter(Edge4,Standard_False);
 911       B.SameRange(Edge1,Standard_False);
 912       B.SameRange(Edge2,Standard_False);
 913       B.SameRange(Edge3,Standard_False);
 914       B.SameRange(Edge4,Standard_False);
 915
 916       tantque = ex1.More() && ex2.More();
 917       if (wPoint1) tantque = ex2.More();
 918       if (wPoint2) tantque = ex1.More();
 919     }
 920   }
 921   BRepLib::SameParameter(myShell);
 922
 923   if (uClosed && DegenFirst && DegenLast)
 924     myShell.Closed(Standard_True);
 925 }
 926
 927
 928 //=======================================================================
 929 //function : GeneratedShapes
 930 //purpose  :
 931 //=======================================================================
 932
 933 const TopTools_ListOfShape&
 934  BRepFill_Generator::GeneratedShapes (const TopoDS_Shape& SSection) const
 935 {
 936   if (myMap.IsBound(SSection)) {
 937     return myMap(SSection);
 938   }
 939   else {
 940     static TopTools_ListOfShape Empty;
 941     return Empty;
 942   }
 943 }
 944
 945 //=======================================================================
 946 //function : Generated
 947 //purpose  :
 948 //=================================================================== ====
 949
 950 const TopTools_DataMapOfShapeListOfShape& BRepFill_Generator::Generated() const
 951 {
 952   return myMap;
 953 }
 954
 955