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