src/BRepFill/BRepFill_CompatibleWires.cxx

   1 // Created on: 1998-07-02
   2 // Created by: Joelle CHAUVET
   3 // Copyright (c) 1998-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_CompatibleWires.ixx>
  18
  19 #include <BRepAdaptor_Curve.hxx>
  20
  21 #include <BRepFill.hxx>
  22 #include <BRepLib.hxx>
  23 #include <BRepLib_FindSurface.hxx>
  24 #include <BRepLib_MakeWire.hxx>
  25 #include <BRepLib_MakeEdge.hxx>
  26 #include <BRepCheck_Wire.hxx>
  27 #include <BRepExtrema_DistShapeShape.hxx>
  28 #include <Bnd_Box.hxx>
  29 #include <BRepBndLib.hxx>
  30 #include <BRep_Builder.hxx>
  31 #include <BRep_Tool.hxx>
  32 #include <BRepTools_WireExplorer.hxx>
  33 #include <BRepLProp.hxx>
  34 #include <BRepGProp.hxx>
  35 #include <GProp_GProps.hxx>
  36 #include <GProp_PrincipalProps.hxx>
  37 #include <Geom_Surface.hxx>
  38 #include <Geom_Plane.hxx>
  39 #include <Precision.hxx>
  40 #include <TopAbs.hxx>
  41 #include <TopExp.hxx>
  42 #include <TopExp_Explorer.hxx>
  43 #include <TopoDS.hxx>
  44 #include <TopoDS_Wire.hxx>
  45 #include <TopTools_ListIteratorOfListOfShape.hxx>
  46 #include <TopTools_DataMapOfShapeListOfShape.hxx>
  47 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
  48 #include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
  49 #include <TopTools_HSequenceOfShape.hxx>
  50 #include <TopTools_SequenceOfShape.hxx>
  51 #include <TopTools_ListOfShape.hxx>
  52
  53 #include <gp.hxx>
  54 #include <gp_Vec.hxx>
  55 #include <gp_Ax2.hxx>
  56 #include <gp_Pln.hxx>
  57 #include <gp_Circ.hxx>
  58 #include <gp_Elips.hxx>
  59 #include <TColgp_HArray1OfVec.hxx>
  60 #include <TColgp_HArray1OfPnt.hxx>
  61
  62 #include <TColStd_Array1OfInteger.hxx>
  63 #include <TColStd_Array1OfReal.hxx>
  64 #include <TColStd_SequenceOfReal.hxx>
  65
  66 #ifdef DEB_EFV
  67 static void EdgesFromVertex (const TopoDS_Wire&   W,
  68                              const TopoDS_Vertex& V,
  69                              TopoDS_Edge& E1,
  70                              TopoDS_Edge& E2)
  71 {
  72   TopTools_IndexedDataMapOfShapeListOfShape Map;
  73   TopExp::MapShapesAndAncestors(W,TopAbs_VERTEX,TopAbs_EDGE,Map);
  74
  75   const TopTools_ListOfShape& List = Map.FindFromKey(V);
  76   TopoDS_Edge          e1   = TopoDS::Edge(List.First());
  77   TopoDS_Edge          e2   = TopoDS::Edge(List. Last());
  78
  79   BRepTools_WireExplorer anExp;
  80   Standard_Integer I1=0, I2=0, NE=0;
  81
  82   for(anExp.Init(W); anExp.More(); anExp.Next()) {
  83     NE++;
  84     const TopoDS_Edge& ECur = anExp.Current();
  85     if (e1.IsSame(ECur)) {
  86       I1 = NE;
  87     }
  88     if (e2.IsSame(ECur)) {
  89       I2 = NE;
  90     }
  91   }
  92
  93   if (Abs(I2-I1)==1) {
  94     // consecutive numbers
  95     if (I2==I1+1) {
  96       E1 = e1;
  97       E2 = e2;
  98     }
  99     else {
 100       E1 = e2;
 101       E2 = e1;
 102     }
 103   }
 104   else {
 105     // non consecutive numbers on a closed wire
 106     if (I1==1&&I2==NE) {
 107       E1 = e2;
 108       E2 = e1;
 109     }
 110     else {
 111       E1 = e1;
 112       E2 = e2;
 113     }
 114   }
 115 }
 116
 117 #endif
 118 static void SeqOfVertices (const TopoDS_Wire&   W,
 119                            TopTools_SequenceOfShape& S)
 120 {
 121   S.Clear();
 122   Standard_Integer jj, cpt = 0;
 123   TopExp_Explorer PE;
 124   for (PE.Init(W,TopAbs_VERTEX); PE.More(); PE.Next()) {
 125     cpt++;
 126     Standard_Boolean trouve=Standard_False;
 127     for (jj=1;jj<=S.Length() && (!trouve);jj++) {
 128       if (S.Value(jj).IsSame(PE.Current())) trouve = Standard_True;
 129       }
 130       if (!trouve) S.Append(PE.Current());
 131     }
 132 }
 133
 134
 135 static Standard_Boolean PlaneOfWire (const TopoDS_Wire& W, gp_Pln& P)
 136 {
 137   Standard_Boolean isplane = Standard_True;
 138   BRepLib_FindSurface findPlanarSurf;
 139   Handle(Geom_Surface) S;
 140   TopLoc_Location      L;
 141
 142   GProp_GProps GP;
 143   BRepGProp::LinearProperties(W,GP);
 144   gp_Pnt Bary = GP.CentreOfMass();
 145
 146 // shielding for particular cases : only one edge circle or ellipse
 147 // on a closed wire !
 148   Standard_Integer nbEdges = 0;
 149   BRepTools_WireExplorer anExp;
 150   anExp.Init(W);
 151   Standard_Boolean wClosed = W.Closed();
 152   if (!wClosed) {
 153     // it is checked if the vertices are the same.
 154     TopoDS_Vertex V1, V2;
 155     TopExp::Vertices(W,V1,V2);
 156     if ( V1.IsSame(V2)) wClosed = Standard_True;
 157   }
 158   TopoDS_Edge Edge = TopoDS::Edge(anExp.Current());
 159   Standard_Real first, last;
 160   Handle(Geom_Curve) curv = BRep_Tool::Curve(Edge, first, last);
 161   if (wClosed) {
 162     GeomAdaptor_Curve AdC;
 163     AdC.Load(curv);
 164     for(; anExp.More(); anExp.Next()) {
 165       nbEdges ++;
 166     }
 167     if ( nbEdges==1 && AdC.GetType() == GeomAbs_Circle ) {
 168       Bary = AdC.Circle().Location();
 169     }
 170     if ( nbEdges==1 && AdC.GetType() == GeomAbs_Ellipse ) {
 171       Bary = AdC.Ellipse().Location();
 172     }
 173   }
 174
 175   findPlanarSurf.Init(W, -1, Standard_True);
 176   if ( findPlanarSurf.Found()) {
 177     S = findPlanarSurf.Surface();
 178     L = findPlanarSurf.Location();
 179     if (!L.IsIdentity()) S = Handle(Geom_Surface)::
 180       DownCast(S->Transformed(L.Transformation()));
 181     P = (Handle(Geom_Plane)::DownCast(S))->Pln();
 182     P.SetLocation(Bary);
 183   }
 184   else {
 185     // wire not plane !
 186     GProp_PrincipalProps Pp  = GP.PrincipalProperties();
 187     gp_Vec Vec;
 188     Standard_Real R1, R2, R3,Tol = Precision::Confusion();
 189     Pp.RadiusOfGyration(R1,R2,R3);
 190     Standard_Real RMax = Max(Max(R1,R2),R3);
 191     if ( ( Abs(RMax-R1)<Tol && Abs(RMax-R2)<Tol )
 192         || ( Abs(RMax-R1)<Tol && Abs(RMax-R3)<Tol )
 193         || ( Abs(RMax-R2)<Tol && Abs(RMax-R3)<Tol ) )
 194       isplane = Standard_False;
 195     else {
 196       if (R1>=R2 && R1>=R3) {
 197         Vec = Pp.FirstAxisOfInertia();
 198       }
 199       else if (R2>=R1 && R2>=R3) {
 200         Vec = Pp.SecondAxisOfInertia();
 201       }
 202       else if (R3>=R1 && R3>=R2) {
 203         Vec = Pp.ThirdAxisOfInertia();
 204       }
 205       gp_Dir NDir(Vec);
 206       if (R3<=R2 && R3<=R1) {
 207         Vec = Pp.ThirdAxisOfInertia();
 208       }
 209       else if (R2<=R1 && R2<=R3) {
 210         Vec = Pp.SecondAxisOfInertia();
 211       }
 212       else if (R1<=R2 && R1<=R3) {
 213         Vec = Pp.FirstAxisOfInertia();
 214       }
 215       gp_Dir XDir(Vec);
 216       gp_Ax3 repere(Bary,NDir,XDir);
 217       Geom_Plane GPlan(repere);
 218       P = GPlan.Pln();
 219     }
 220   }
 221
 222   return isplane;
 223
 224 }
 225
 226
 227 static void WireContinuity (const TopoDS_Wire& W,
 228                             GeomAbs_Shape& contW)
 229 {
 230   contW = GeomAbs_CN;
 231   GeomAbs_Shape cont;
 232   Standard_Boolean IsDegenerated = Standard_False;
 233
 234   BRepTools_WireExplorer anExp;
 235   Standard_Integer nbEdges=0;
 236   Handle(TopTools_HSequenceOfShape) Edges = new TopTools_HSequenceOfShape();
 237   for(anExp.Init(W); anExp.More(); anExp.Next()) {
 238     nbEdges++;
 239     Edges->Append(anExp.Current());
 240     if (BRep_Tool::Degenerated(anExp.Current())) IsDegenerated = Standard_True;
 241   }
 242
 243   if (!IsDegenerated) {
 244
 245     Standard_Boolean testconti = Standard_True;
 246
 247     for (Standard_Integer j=1;j<=nbEdges;j++) {
 248
 249       TopoDS_Edge Edge1, Edge2;
 250
 251       if (j == nbEdges) {
 252         Edge1 = TopoDS::Edge (Edges->Value(nbEdges));
 253         Edge2 = TopoDS::Edge (Edges->Value(1));
 254       }
 255       else {
 256         Edge1 = TopoDS::Edge (Edges->Value(j));
 257         Edge2 = TopoDS::Edge (Edges->Value(j+1));
 258       }
 259
 260       TopoDS_Vertex V1,V2,Vbid;
 261       TopExp::Vertices(Edge1,Vbid,V1,Standard_True);
 262       TopExp::Vertices(Edge2,V2,Vbid,Standard_True);
 263       Standard_Real U1 = BRep_Tool::Parameter(V1,Edge1);
 264       Standard_Real U2 = BRep_Tool::Parameter(V2,Edge2);
 265       BRepAdaptor_Curve Curve1(Edge1);
 266       BRepAdaptor_Curve Curve2(Edge2);
 267       Standard_Real Eps = BRep_Tool::Tolerance(V2) + BRep_Tool::Tolerance(V1);
 268
 269       if(j == nbEdges)
 270         testconti = Curve1.Value(U1).IsEqual(Curve2.Value(U2), Eps);
 271
 272       if(testconti) {
 273         cont = BRepLProp::Continuity(Curve1,Curve2,U1,U2,
 274                                      Eps, Precision::Angular());
 275         if (cont <= contW) contW = cont;
 276       }
 277     }
 278   }
 279
 280 }
 281
 282 static void TrimEdge (const TopoDS_Edge&              CurrentEdge,
 283                       const TColStd_SequenceOfReal&   CutValues,
 284                       const Standard_Real   t0, const Standard_Real   t1,
 285                       const Standard_Boolean          SeqOrder,
 286                       TopTools_SequenceOfShape& S)
 287
 288 {
 289   S.Clear();
 290   Standard_Integer j, ndec=CutValues.Length();
 291   Standard_Real first,last,m0,m1;
 292   Handle(Geom_Curve) C = BRep_Tool::Curve(CurrentEdge,first,last);
 293
 294   TopoDS_Vertex Vf,Vl,Vbid,V0,V1;
 295   TopAbs_Orientation CurrentOrient = CurrentEdge.Orientation();
 296   TopExp::Vertices(CurrentEdge,Vf,Vl);
 297   Vbid.Nullify();
 298
 299   if (SeqOrder) {
 300     // from first to last
 301     m0 = first;
 302     V0 = Vf;
 303     for (j=1; j<=ndec; j++) {
 304       // piece of edge
 305       m1 = (CutValues.Value(j)-t0)*(last-first)/(t1-t0)+first;
 306       TopoDS_Edge CutE = BRepLib_MakeEdge(C,V0,Vbid,m0,m1);
 307       CutE.Orientation(CurrentOrient);
 308       S.Append(CutE);
 309       m0 = m1;
 310       V0 = TopExp::LastVertex(CutE);
 311       if (j==ndec) {
 312         // last piece
 313         TopoDS_Edge LastE = BRepLib_MakeEdge(C,V0,Vl,m0,last);
 314         LastE.Orientation(CurrentOrient);
 315         S.Append(LastE);
 316       }
 317     }
 318   }
 319   else {
 320     // from last to first
 321     m1 = last;
 322     V1 = Vl;
 323     for (j=ndec; j>=1; j--) {
 324       // piece of edge
 325       m0 = (CutValues.Value(j)-t0)*(last-first)/(t1-t0)+first;
 326       TopoDS_Edge CutE = BRepLib_MakeEdge(C,Vbid,V1,m0,m1);
 327       CutE.Orientation(CurrentOrient);
 328       S.Append(CutE);
 329       m1 = m0;
 330       V1 = TopExp::FirstVertex(CutE);
 331       if (j==1) {
 332         // last piece
 333         TopoDS_Edge LastE = BRepLib_MakeEdge(C,Vf,V1,first,m1);
 334         LastE.Orientation(CurrentOrient);
 335         S.Append(LastE);
 336       }
 337     }
 338   }
 339 }
 340
 341
 342
 343 static Standard_Boolean SearchRoot (const TopoDS_Vertex& V,
 344                                     const TopTools_DataMapOfShapeListOfShape& Map,
 345                                     TopoDS_Vertex& VRoot)
 346 {
 347   Standard_Boolean trouve = Standard_False;
 348   VRoot.Nullify();
 349   TopTools_DataMapIteratorOfDataMapOfShapeListOfShape it;
 350   for (it.Initialize(Map); it.More(); it.Next()) {
 351     const TopTools_ListOfShape & List = it.Value();
 352     TopTools_ListIteratorOfListOfShape itL;
 353     Standard_Boolean ilyest = Standard_False;
 354     for (itL.Initialize(List); itL.More(); itL.Next()) {
 355       TopoDS_Vertex Vcur = TopoDS::Vertex(itL.Value());
 356       if (Vcur.IsSame(V)) {
 357         ilyest = Standard_True;
 358       }
 359       if (ilyest) break;
 360     }
 361     if (ilyest) {
 362       trouve = Standard_True;
 363       VRoot = TopoDS::Vertex(it.Key());
 364     }
 365     if (trouve) break;
 366   }
 367   return trouve;
 368 }
 369
 370 static Standard_Boolean SearchVertex (const TopTools_ListOfShape& List,
 371                                       const TopoDS_Wire&   W,
 372                                       TopoDS_Vertex& VonW)
 373 {
 374   Standard_Boolean trouve = Standard_False;
 375   VonW.Nullify();
 376   TopTools_SequenceOfShape SeqV;
 377   SeqOfVertices(W,SeqV);
 378   for (Standard_Integer ii=1;ii<=SeqV.Length();ii++) {
 379     TopoDS_Vertex Vi = TopoDS::Vertex(SeqV.Value(ii));
 380     TopTools_ListIteratorOfListOfShape itL;
 381     Standard_Boolean ilyest = Standard_False;
 382     for (itL.Initialize(List); itL.More(); itL.Next()) {
 383       TopoDS_Vertex Vcur = TopoDS::Vertex(itL.Value());
 384       if (Vcur.IsSame(Vi)) {
 385         ilyest = Standard_True;
 386       }
 387       if (ilyest) break;
 388     }
 389     if (ilyest) {
 390       trouve = Standard_True;
 391       VonW = Vi;
 392     }
 393     if (trouve) break;
 394   }
 395   return trouve;
 396 }
 397
 398
 399 static Standard_Boolean EdgeIntersectOnWire (const gp_Pnt& P1,
 400                                              const gp_Pnt& P2,
 401                                              Standard_Real percent,
 402                                              const TopTools_DataMapOfShapeListOfShape& Map,
 403                                              const TopoDS_Wire&   W,
 404                                              TopoDS_Vertex& Vsol,
 405                                              TopoDS_Wire&   newW)
 406 {
 407
 408   BRepTools_WireExplorer anExp;
 409
 410   // construction of the edge of intersection
 411   Standard_Boolean NewVertex = Standard_False;
 412   gp_Lin droite(P1,gp_Dir(gp_Vec(P1,P2)));
 413   // ATTENTION : it is required to construct a half-straight
 414   //             but there is a bug in BRepExtrema_DistShapeShape
 415   //             it is enough to take 100 * distance between P1 and P2
 416   //             hoping that it is enough until the bug is corrected
 417   //  Standard_Real dernierparam = Precision::Infinite();
 418   // ATTENTION : return !!
 419   //             100 is better than 10 but it is too much !
 420   //             finally, nothing is better than a blocking box
 421   //  Standard_Real dernierparam = 100 * P1.Distance(P2);
 422   Bnd_Box B;
 423   BRepBndLib::Add(W,B);
 424   Standard_Real x1,x2,y1,y2,z1,z2;
 425   B.Get(x1,y1,z1,x2,y2,z2);
 426   gp_Pnt BP1(x1,y1,z1), BP2(x2,y2,z2);
 427   Standard_Real diag = BP1.Distance(BP2);
 428   Standard_Real dernierparam = diag;
 429   BRepLib_MakeEdge ME(droite,0.,dernierparam);
 430   TopoDS_Edge ECur = BRepLib_MakeEdge(droite,0.,P1.Distance(P2));
 431
 432   // calculate the intersection by BRepExtrema (point of min distance)
 433   BRepExtrema_DistShapeShape DSS(ME.Edge(),W);
 434   if (DSS.IsDone()) {
 435     // choose the solution closest to P2
 436     Standard_Integer isol = 1;
 437     Standard_Real dss = P2.Distance(DSS.PointOnShape2(isol));
 438     for (Standard_Integer iss=2; iss<=DSS.NbSolution(); iss++) {
 439       if (dss>P2.Distance(DSS.PointOnShape2(iss))) {
 440         dss = P2.Distance(DSS.PointOnShape2(iss));
 441         isol = iss;
 442       }
 443     }
 444 #ifdef DEB
 445     gp_Pnt Psol =
 446 #endif
 447       DSS.PointOnShape2(isol);
 448     // is the solution a new vertex ?
 449     NewVertex = (DSS.SupportTypeShape2(isol) != BRepExtrema_IsVertex);
 450     if (NewVertex) {
 451       TopoDS_Shape aLocalShape = DSS.SupportOnShape2(isol);
 452       TopoDS_Edge E = TopoDS::Edge(aLocalShape);
 453 //      TopoDS_Edge E = TopoDS::Edge(DSS.SupportOnShape2(isol));
 454       Standard_Real tol = Precision::PConfusion();
 455       Standard_Real first,last,param;
 456       BRep_Tool::Range(E,first,last);
 457       tol = Max(tol,percent*Abs(last-first));
 458       DSS.ParOnEdgeS2(isol,param);
 459       if (Abs(first-param)<tol) {
 460         NewVertex = Standard_False;
 461         Vsol = TopExp::FirstVertex(E);
 462       }
 463       else if (Abs(last-param)<tol) {
 464         NewVertex = Standard_False;
 465         Vsol = TopExp::LastVertex(E);
 466       }
 467       // check
 468       if (!NewVertex) {
 469         TopoDS_Vertex VRoot;
 470         if (SearchRoot(Vsol,Map,VRoot)) NewVertex = Standard_True;
 471       }
 472     }
 473     else {
 474       TopoDS_Shape aLocalShape = DSS.SupportOnShape2(isol);
 475       Vsol = TopoDS::Vertex(aLocalShape);
 476 //      Vsol = TopoDS::Vertex(DSS.SupportOnShape2(isol));
 477     }
 478
 479     // it is required to cut the edge
 480     if (NewVertex) {
 481       TopoDS_Shape aLocalShape = DSS.SupportOnShape2(isol);
 482       TopoDS_Edge E = TopoDS::Edge(aLocalShape);
 483 //      TopoDS_Edge E = TopoDS::Edge(DSS.SupportOnShape2(isol));
 484       Standard_Real first,last,param;
 485       DSS.ParOnEdgeS2(isol,param);
 486       BRep_Tool::Range(E,first,last);
 487       BRepLib_MakeWire MW;
 488       for (anExp.Init(W); anExp.More(); anExp.Next()) {
 489         if (E.IsSame(anExp.Current())) {
 490           Standard_Boolean SO
 491             = (anExp.CurrentVertex().IsSame(TopExp::FirstVertex(E)));
 492           TopTools_SequenceOfShape SE;
 493           SE.Clear();
 494           TColStd_SequenceOfReal SR;
 495           SR.Clear();
 496           SR.Append(param);
 497           TrimEdge(E,SR,first,last,SO,SE);
 498           TopoDS_Vertex VV1,VV2;
 499           TopExp::Vertices(TopoDS::Edge(SE.Value(1)),VV1,VV2);
 500           if (TopExp::FirstVertex(E).IsSame(VV1)
 501               || TopExp::LastVertex(E).IsSame(VV1)) {
 502             Vsol = VV2;
 503           }
 504           if (TopExp::FirstVertex(E).IsSame(VV2)
 505               || TopExp::LastVertex(E).IsSame(VV2)) {
 506             Vsol = VV1;
 507           }
 508           for (Standard_Integer k=1; k<=SE.Length(); k++) {
 509             MW.Add(TopoDS::Edge(SE.Value(k)));
 510           }
 511         }
 512         else {
 513           MW.Add(anExp.Current());
 514         }
 515       }
 516       newW = MW.Wire();
 517     }
 518     else {
 519       newW = W;
 520     }
 521
 522
 523   }
 524
 525   return NewVertex;
 526
 527 }
 528
 529
 530 static void Transform (const Standard_Boolean WithRotation,
 531                        const gp_Pnt& P,
 532                        const gp_Pnt& Pos1,
 533                        const gp_Vec& Ax1,
 534                        const gp_Pnt& Pos2,
 535                        const gp_Vec& Ax2,
 536                        gp_Pnt& Pnew)
 537 {
 538
 539   Pnew = P.Translated (Pos1,Pos2);
 540   gp_Vec axe1 = Ax1, axe2 = Ax2;
 541   if (!axe1.IsParallel(axe2,1.e-4)) {
 542     gp_Vec Vtrans(Pos1,Pos2),Vsign;
 543     Standard_Real alpha,beta,sign=1;
 544     alpha = Vtrans.Dot(axe1);
 545     beta = Vtrans.Dot(axe2);
 546     if (alpha<-1.e-7) axe1 *=-1;
 547     if (beta<1.e-7) axe2 *=-1;
 548     alpha = Vtrans.Dot(axe1);
 549     beta = Vtrans.Dot(axe2);
 550     gp_Vec norm2 = axe1 ^ axe2;
 551     Vsign.SetLinearForm(Vtrans.Dot(axe1),axe2,-Vtrans.Dot(axe2),axe1);
 552     alpha = Vsign.Dot(axe1);
 553     beta = Vsign.Dot(axe2);
 554     Standard_Boolean pasnul = (Abs(alpha)>1.e-4 && Abs(beta)>1.e-4);
 555     if ( alpha*beta>0.0 && pasnul ) sign=-1;
 556     gp_Ax1 Norm(Pos2,norm2);
 557     Standard_Real ang = axe1.AngleWithRef(axe2,norm2);
 558     if (!WithRotation) {
 559       if (ang>M_PI/2) ang = ang - M_PI;
 560       if (ang<-M_PI/2) ang = ang + M_PI;
 561     }
 562     ang *= sign;
 563     Pnew = Pnew.Rotated (Norm,ang);
 564   }
 565 }
 566
 567 static void BuildConnectedEdges(const TopoDS_Wire& aWire,
 568                                 const TopoDS_Edge& StartEdge,
 569                                 const TopoDS_Vertex& StartVertex,
 570                                 TopTools_ListOfShape& ConnectedEdges)
 571 {
 572   TopTools_IndexedDataMapOfShapeListOfShape MapVE;
 573   TopExp::MapShapesAndAncestors(aWire, TopAbs_VERTEX, TopAbs_EDGE, MapVE);
 574   TopoDS_Edge CurEdge = StartEdge;
 575   TopoDS_Vertex CurVertex = StartVertex;
 576   TopoDS_Vertex Origin, V1, V2;
 577   TopExp::Vertices(StartEdge, V1, V2);
 578   Origin = (V1.IsSame(StartVertex))? V2 : V1;
 579
 580   for (;;)
 581     {
 582       TopTools_ListIteratorOfListOfShape itE( MapVE.FindFromKey(CurVertex) );
 583       for (; itE.More(); itE.Next())
 584         {
 585           TopoDS_Edge anEdge = TopoDS::Edge(itE.Value());
 586           if (!anEdge.IsSame(CurEdge))
 587             {
 588               ConnectedEdges.Append(anEdge);
 589               TopExp::Vertices(anEdge, V1, V2);
 590               CurVertex = (V1.IsSame(CurVertex))? V2 : V1;
 591               CurEdge = anEdge;
 592               break;
 593             }
 594         }
 595       if (CurVertex.IsSame(Origin))
 596         break;
 597     }
 598 }
 599
 600 //=======================================================================
 601 //function : BRepFill_CompatibleWires
 602 //purpose  :
 603 //=======================================================================
 604
 605 BRepFill_CompatibleWires::BRepFill_CompatibleWires()
 606 :myIsDone(Standard_False)
 607 {
 608 }
 609
 610
 611 //=======================================================================
 612 //function : BRepFill_CompatibleWires
 613 //purpose  :
 614 //=======================================================================
 615
 616 BRepFill_CompatibleWires::BRepFill_CompatibleWires(const TopTools_SequenceOfShape& Sections)
 617 {
 618   Init(Sections);
 619 }
 620
 621
 622 //=======================================================================
 623 //function : Init
 624 //purpose  :
 625 //=======================================================================
 626
 627 void BRepFill_CompatibleWires::Init(const TopTools_SequenceOfShape& Sections)
 628 {
 629   myInit = Sections;
 630   myWork = Sections;
 631   myPercent = 0.01;
 632   myIsDone = Standard_False;
 633   myMap.Clear();
 634
 635 }
 636
 637
 638 //=======================================================================
 639 //function : SetPercent
 640 //purpose  :
 641 //=======================================================================
 642
 643 void BRepFill_CompatibleWires::SetPercent(const Standard_Real Percent)
 644 {
 645   if (0.<Percent && Percent<1.) myPercent = Percent;
 646
 647 }
 648
 649
 650 //=======================================================================
 651 //function : IsDone
 652 //purpose  :
 653 //=======================================================================
 654
 655 Standard_Boolean BRepFill_CompatibleWires::IsDone() const
 656 {
 657   return myIsDone;
 658 }
 659
 660
 661 //=======================================================================
 662 //function : Shape
 663 //purpose  :
 664 //=======================================================================
 665
 666 const TopTools_SequenceOfShape& BRepFill_CompatibleWires::Shape() const
 667 {
 668   return myWork;
 669 }
 670
 671
 672 //=======================================================================
 673 //function : GeneratedShapes
 674 //purpose  :
 675 //=======================================================================
 676
 677 const TopTools_ListOfShape& BRepFill_CompatibleWires::GeneratedShapes
 678 (const TopoDS_Edge& SubSection) const
 679 {
 680
 681   if (myMap.IsBound(SubSection)) {
 682     return myMap(SubSection);
 683   }
 684   else {
 685     static TopTools_ListOfShape Empty;
 686     return Empty;
 687   }
 688 }
 689
 690
 691 //=======================================================================
 692 //function : Perform
 693 //purpose  :
 694 //=======================================================================
 695
 696 void BRepFill_CompatibleWires::Perform (const Standard_Boolean WithRotation)
 697 {
 698   // compute origin and orientation on wires to avoid twisted results
 699   // and update wires to have same number of edges
 700
 701   // determination of report:
 702   // if the number of elements is the same and if the wires have discontinuities
 703   // by tangency, the report is not carried out by curvilinear abscissa
 704   Standard_Integer nbSects = myWork.Length(), i;
 705   BRepTools_WireExplorer anExp;
 706   Standard_Integer nbmax=0, nbmin=0;
 707   TColStd_Array1OfInteger nbEdges(1,nbSects);
 708   Standard_Boolean report;
 709   GeomAbs_Shape contS=GeomAbs_CN;
 710   GeomAbs_Shape cont;
 711   for (i=1; i<=nbSects; i++) {
 712     TopoDS_Shape aLocalShape = myWork(i).Oriented(TopAbs_FORWARD);
 713     myWork(i) = TopoDS::Wire(aLocalShape);
 714 //    myWork(i) = TopoDS::Wire(myWork(i).Oriented(TopAbs_FORWARD));
 715     TopoDS_Wire W = TopoDS::Wire(myWork(i));
 716     WireContinuity(W,cont);
 717     if (cont<contS) contS=cont;
 718     nbEdges(i) = 0;
 719     for(anExp.Init(W); anExp.More(); anExp.Next() ) nbEdges(i)++;
 720     if (i==1) nbmin = nbEdges(i);
 721     if (nbmax<nbEdges(i)) nbmax = nbEdges(i);
 722     if (nbmin>nbEdges(i)) nbmin = nbEdges(i);
 723   }
 724   // if the number of elements is not the same or if all wires are at least
 725   // C1, the report is carried out by curvilinear abscissa of cuts, otherwise
 726   // a report vertex / Vertex is done
 727   report = (nbmax != nbmin || contS >= GeomAbs_C1 );
 728
 729   // initialization of the map
 730   Standard_Integer nbE = 0;
 731   TopTools_ListOfShape Empty;
 732   for (i=1; i<=nbSects; i++) {
 733     TopoDS_Wire W = TopoDS::Wire(myWork(i));
 734     for(anExp.Init(W); anExp.More(); anExp.Next() ) {
 735       TopoDS_Edge E = TopoDS::Edge(anExp.Current());
 736       myMap.Bind(E,Empty);
 737       myMap(E).Append(E);
 738       nbE++;
 739     }
 740   }
 741
 742   // open/closed sections
 743   // initialisation of myDegen1, myDegen2
 744   Standard_Integer ideb=1, ifin=myWork.Length();
 745   // check if the first wire is punctual
 746   myDegen1 = Standard_True;
 747   for(anExp.Init(TopoDS::Wire(myWork(ideb))); anExp.More(); anExp.Next()) {
 748     myDegen1 = myDegen1 && (BRep_Tool::Degenerated(anExp.Current()));
 749   }
 750   if (myDegen1) ideb++;
 751   // check if the last wire is punctual
 752   myDegen2 = Standard_True;
 753   for(anExp.Init(TopoDS::Wire(myWork(ifin))); anExp.More(); anExp.Next()) {
 754     myDegen2 = myDegen2 && (BRep_Tool::Degenerated(anExp.Current()));
 755   }
 756   if (myDegen2) ifin--;
 757
 758   Standard_Boolean wClosed, allClosed = Standard_True, allOpen = Standard_True;
 759   for (i=ideb; i<=ifin; i++) {
 760     wClosed = myWork(i).Closed();
 761     if (!wClosed) {
 762       // check if the vertices are the same.
 763       TopoDS_Vertex V1, V2;
 764       TopExp::Vertices(TopoDS::Wire(myWork(i)),V1,V2);
 765       if ( V1.IsSame(V2)) wClosed = Standard_True;
 766     }
 767     allClosed = (allClosed && wClosed);
 768     allOpen = (allOpen && !wClosed);
 769   }
 770
 771   if (allClosed) {
 772     // All sections are closed
 773     if (report) {
 774       // same number of elements
 775       SameNumberByPolarMethod(WithRotation);
 776     }
 777     else {
 778       // origin
 779       ComputeOrigin(Standard_False);
 780     }
 781     myIsDone = Standard_True;
 782   }
 783   else if (allOpen) {
 784     // All sections are open
 785     // origin
 786     SearchOrigin();
 787     // same number of elements
 788     if (report) {
 789       SameNumberByACR(report);
 790     }
 791     myIsDone = Standard_True;
 792   }
 793   else {
 794     // There are open and closed sections :
 795     // not processed
 796     Standard_DomainError::Raise("Sections must be all closed or all open");
 797   }
 798
 799 }
 800
 801
 802
 803
 804 //=======================================================================
 805 //function : Generated
 806 //purpose  :
 807 //=======================================================================
 808
 809 const TopTools_DataMapOfShapeListOfShape&  BRepFill_CompatibleWires::Generated() const
 810 {
 811   return myMap;
 812 }
 813
 814
 815 //=======================================================================
 816 //function : SameNumberByPolarMethod
 817 //purpose  :
 818 //=======================================================================
 819
 820 void BRepFill_CompatibleWires::
 821               SameNumberByPolarMethod(const Standard_Boolean WithRotation)
 822 {
 823
 824   // initialisation
 825   Standard_Integer NbSects=myWork.Length();
 826   BRepTools_WireExplorer anExp;
 827   TopoDS_Vertex V1, V2;
 828
 829   Standard_Boolean allClosed = Standard_True;
 830   Standard_Integer i,ii,ideb=1,ifin=NbSects;
 831   for (i=1; i<=NbSects; i++) {
 832     Handle(BRepCheck_Wire) Checker = new BRepCheck_Wire(TopoDS::Wire(myWork(i)));
 833     allClosed = (allClosed && (Checker->Closed() == BRepCheck_NoError));
 834     //allClosed = (allClosed && myWork(i).Closed());
 835   }
 836   if (!allClosed)
 837     Standard_NoSuchObject::Raise("BRepFill_CompatibleWires::SameNumberByPolarMethod : the wires must be closed");
 838
 839   // sections ponctuelles, sections bouclantes ?
 840   if (myDegen1) ideb++;
 841   if (myDegen2) ifin--;
 842   Standard_Boolean vClosed = (!myDegen1) && (!myDegen2)
 843                                 && (myWork(ideb).IsSame(myWork(ifin)));
 844
 845   //Removing degenerated edges
 846   for (i = ideb; i <= ifin; i++)
 847   {
 848     Standard_Boolean hasDegEdge = Standard_False;
 849     TopoDS_Iterator anItw(myWork(i));
 850     for (; anItw.More(); anItw.Next())
 851     {
 852       const TopoDS_Edge& anEdge = TopoDS::Edge(anItw.Value());
 853       if (BRep_Tool::Degenerated(anEdge))
 854       {
 855         hasDegEdge = Standard_True;
 856         break;
 857       }
 858     }
 859     if (hasDegEdge)
 860     {
 861       TopoDS_Wire aNewWire;
 862       BRep_Builder aBBuilder;
 863       aBBuilder.MakeWire(aNewWire);
 864       for (anItw.Initialize(myWork(i)); anItw.More(); anItw.Next())
 865       {
 866         const TopoDS_Edge& anEdge = TopoDS::Edge(anItw.Value());
 867         if (!BRep_Tool::Degenerated(anEdge))
 868           aBBuilder.Add(aNewWire, anEdge);
 869       }
 870       myWork(i) = aNewWire;
 871     }
 872   }
 873
 874   // Nombre max de decoupes possibles
 875   Standard_Integer NbMaxV = 0;
 876   for (i=1; i<=NbSects; i++) {
 877     for(anExp.Init(TopoDS::Wire(myWork(i))); anExp.More(); anExp.Next()) {
 878       NbMaxV++;
 879     }
 880   }
 881
 882   // construction of tables of planes of wires
 883   gp_Pln P;
 884   Handle(TColgp_HArray1OfPnt) Pos
 885     = new (TColgp_HArray1OfPnt) (1,NbSects);
 886   Handle(TColgp_HArray1OfVec) Axe
 887     = new (TColgp_HArray1OfVec) (1,NbSects);
 888   for (i=ideb;i<=ifin;i++) {
 889     if (PlaneOfWire(TopoDS::Wire(myWork(i)),P)) {
 890       Pos->SetValue(i,P.Location());
 891       Axe->SetValue(i,gp_Vec(P.Axis().Direction()));
 892     }
 893   }
 894   TopTools_SequenceOfShape SeqV;
 895   if (myDegen1) {
 896     SeqOfVertices(TopoDS::Wire(myWork(1)),SeqV);
 897     Pos->SetValue(1,BRep_Tool::Pnt(TopoDS::Vertex(SeqV.Value(1))));
 898     Axe->SetValue(1,Axe->Value(ideb));
 899   }
 900   if (myDegen2) {
 901     SeqOfVertices(TopoDS::Wire(myWork(NbSects)),SeqV);
 902     Pos->SetValue(NbSects,BRep_Tool::Pnt(TopoDS::Vertex(SeqV.Value(1))));
 903     Axe->SetValue(NbSects,Axe->Value(ifin));
 904   }
 905
 906   // construction of RMap, map of reports of wire i to wire i-1
 907   TopTools_DataMapOfShapeListOfShape RMap;
 908   RMap.Clear();
 909
 910   // loop on i
 911   for (i=ifin; i>ideb; i--) {
 912
 913     const TopoDS_Wire& wire1 = TopoDS::Wire(myWork(i));
 914
 915     // sequence of vertices of the first wire
 916     SeqOfVertices(wire1,SeqV);
 917     if (SeqV.Length()>NbMaxV)
 918       Standard_NoSuchObject::Raise("BRepFill::SameNumberByPolarMethod failed");
 919
 920     // extremity of the first wire
 921     V1 = TopoDS::Vertex(SeqV.Value(1));
 922     // loop on vertices of wire1
 923     for (ii=1;ii<=SeqV.Length();ii++) {
 924
 925       TopoDS_Vertex Vi = TopoDS::Vertex(SeqV.Value(ii));
 926
 927       // init of RMap for Vi
 928       TopTools_ListOfShape Init;
 929       Init.Clear();
 930       RMap.Bind(Vi,Init);
 931
 932       // it is required to find intersection Vi - wire2
 933       gp_Pnt Pi = BRep_Tool::Pnt(Vi);
 934
 935       // return Pi in the current plane
 936       gp_Pnt Pnew;
 937       Transform(WithRotation,Pi,
 938                 Pos->Value(i),Axe->Value(i),
 939                 Pos->Value(i-1),Axe->Value(i-1),Pnew);
 940
 941       // calculate the intersection
 942       TopoDS_Shape Support;
 943       Standard_Boolean NewVertex;
 944       TopoDS_Vertex Vsol;
 945       TopoDS_Wire newwire;
 946       if (Pnew.Distance(Pos->Value(i-1))>Precision::Confusion()) {
 947         Standard_Real percent = myPercent;
 948         NewVertex = EdgeIntersectOnWire(Pos->Value(i-1),Pnew,percent,
 949                                     RMap,TopoDS::Wire(myWork(i-1)),
 950                                     Vsol,newwire);
 951         if (NewVertex) myWork(i-1) = newwire;
 952         RMap(Vi).Append(Vsol);
 953       }
 954
 955     } // loop on  ii
 956   }   // loop on  i
 957
 958   // initialisation of MapVLV, map of correspondences vertex - list of vertices
 959   TopTools_DataMapOfShapeListOfShape MapVLV;
 960   SeqOfVertices(TopoDS::Wire(myWork(ideb)),SeqV);
 961   Standard_Integer SizeMap = SeqV.Length();
 962   MapVLV.Clear();
 963   for (ii=1;ii<=SizeMap;ii++) {
 964     TopoDS_Vertex Vi = TopoDS::Vertex(SeqV.Value(ii));
 965     TopTools_ListOfShape Init;
 966     Init.Clear();
 967     Init.Append(Vi);
 968     MapVLV.Bind(Vi,Init);
 969     Standard_Integer NbV = 1;
 970     TopoDS_Vertex V0,V1;
 971     V0 = Vi;
 972     Standard_Boolean tantque = SearchRoot(V0,RMap,V1);
 973     while (tantque) {
 974       MapVLV(Vi).Append(V1);
 975       NbV++;
 976       // test on NbV required for looping sections
 977       if (V1.IsSame(Vi) || NbV >= myWork.Length()) {
 978         tantque = Standard_False;
 979       }
 980       else {
 981         V0 = V1;
 982         tantque = SearchRoot(V0,RMap,V1);
 983       }
 984     }
 985   }
 986
 987   // loop on i
 988   for (i=ideb; i<ifin; i++) {
 989
 990     const TopoDS_Wire& wire1 = TopoDS::Wire(myWork(i));
 991
 992     // sequence of vertices of the first wire
 993     SeqOfVertices(wire1,SeqV);
 994     if ( SeqV.Length()>NbMaxV || SeqV.Length()>SizeMap )
 995       Standard_NoSuchObject::Raise("BRepFill::SameNumberByPolarMethod failed");
 996
 997     // extremity of the first wire
 998     V1 = TopoDS::Vertex(SeqV.Value(1));
 999
1000     // next wire
1001     const TopoDS_Wire& wire2 = TopoDS::Wire(myWork(i+1));
1002
1003     // loop on vertices of wire1
1004     for (ii=1;ii<=SeqV.Length();ii++) {
1005
1006       TopoDS_Vertex Vi = TopoDS::Vertex(SeqV.Value(ii));
1007       TopoDS_Vertex VRoot;
1008       VRoot.Nullify();
1009       Standard_Boolean intersect = Standard_True;
1010       if (SearchRoot(Vi,MapVLV,VRoot)) {
1011         const TopTools_ListOfShape& LVi = MapVLV(VRoot);
1012         TopoDS_Vertex VonW;
1013         VonW.Nullify();
1014         intersect = (!SearchVertex(LVi,wire2,VonW));
1015       }
1016
1017       if (intersect) {
1018         // it is necessary to find intersection Vi - wire2
1019         gp_Pnt Pi = BRep_Tool::Pnt(Vi);
1020
1021         // return Pi in the current plane
1022         gp_Pnt Pnew;
1023         Transform(WithRotation,Pi,
1024                   Pos->Value(i),Axe->Value(i),
1025                   Pos->Value(i+1),Axe->Value(i+1),Pnew);
1026
1027         // calculate the intersection
1028         TopoDS_Shape Support;
1029         Standard_Boolean NewVertex;
1030         TopoDS_Vertex Vsol;
1031         TopoDS_Wire newwire;
1032         if (Pnew.Distance(Pos->Value(i+1))>Precision::Confusion()) {
1033           Standard_Real percent = myPercent;
1034           NewVertex = EdgeIntersectOnWire(Pos->Value(i+1),Pnew,percent,
1035                                       MapVLV,TopoDS::Wire(myWork(i+1)),
1036                                       Vsol,newwire);
1037           MapVLV(VRoot).Append(Vsol);
1038           if (NewVertex) myWork(i+1) = newwire;
1039         }
1040
1041       }
1042     } // loop on ii
1043   }   // loop on i
1044
1045   // regularize wires following MapVLV
1046   TopoDS_Wire wire = TopoDS::Wire(myWork(ideb));
1047
1048   // except for the last if the sections loop
1049   Standard_Integer ibout = ifin;
1050   if (vClosed) ibout--;
1051
1052   for ( i=ideb+1; i<=ibout; i++) {
1053
1054     BRepLib_MakeWire MW;
1055
1056     anExp.Init(wire);
1057     TopoDS_Edge ECur = anExp.Current();
1058     TopoDS_Vertex VF,VL;
1059     TopExp::Vertices(ECur,VF,VL,Standard_True);
1060     Standard_Real U1 = BRep_Tool::Parameter(VF,ECur);
1061     Standard_Real U2 = BRep_Tool::Parameter(VL,ECur);
1062     BRepAdaptor_Curve Curve(ECur);
1063     gp_Pnt PPs = Curve.Value(0.1*(U1+9*U2));
1064     TopTools_ListIteratorOfListOfShape itF(MapVLV(VF)),itL(MapVLV(VL));
1065     Standard_Integer rang = ideb;
1066     while (rang < i) {
1067       itF.Next();
1068       itL.Next();
1069       rang++;
1070     }
1071     TopoDS_Vertex V1 = TopoDS::Vertex(itF.Value()), V2 = TopoDS::Vertex(itL.Value());
1072     TopoDS_Edge Esol;
1073     Standard_Real scalmax=0.;
1074     TopoDS_Iterator itW( myWork(i) );
1075
1076     for(; itW.More(); itW.Next())
1077       {
1078         TopoDS_Edge E = TopoDS::Edge(itW.Value());
1079         TopoDS_Vertex VVF,VVL;
1080         TopExp::Vertices(E,VVF,VVL,Standard_True);
1081
1082         // parse candidate edges
1083         Standard_Real scal1,scal2;
1084         if ( (V1.IsSame(VVF)&&V2.IsSame(VVL)) || (V2.IsSame(VVF)&&V1.IsSame(VVL)) ) {
1085           Standard_Real U1 = BRep_Tool::Parameter(VVF,E);
1086           Standard_Real U2 = BRep_Tool::Parameter(VVL,E);
1087           BRepAdaptor_Curve Curve(E);
1088           gp_Pnt PP1 = Curve.Value(0.1*(U1+9*U2));
1089           gp_Pnt PP2 = Curve.Value(0.1*(9*U1+U2));
1090
1091           for (rang=i;rang>ideb;rang--) {
1092             Transform(WithRotation, PP1,
1093                       Pos->Value(rang), Axe->Value(rang),
1094                       Pos->Value(rang-1), Axe->Value(rang-1), PP1);
1095             Transform(WithRotation, PP2,
1096                       Pos->Value(rang), Axe->Value(rang),
1097                       Pos->Value(rang-1), Axe->Value(rang-1), PP2);
1098           }
1099           gp_Vec Ns(Pos->Value(ideb),PPs);
1100           Ns = Ns.Normalized();
1101           gp_Vec N1(Pos->Value(ideb),PP1);
1102           N1 = N1.Normalized();
1103           gp_Vec N2(Pos->Value(ideb),PP2);
1104           N2 = N2.Normalized();
1105           scal1 = N1.Dot(Ns);
1106           if (scal1>scalmax) {
1107             scalmax = scal1;
1108             Esol = E;
1109           }
1110           scal2 = N2.Dot(Ns);
1111           if (scal2>scalmax) {
1112             scalmax = scal2;
1113             TopoDS_Shape aLocalShape = E.Reversed();
1114             Esol = TopoDS::Edge(aLocalShape);
1115           }
1116         }
1117       } //end of for(; itW.More(); itW.Next())
1118     MW.Add(Esol);
1119
1120     TopTools_ListOfShape ConnectedEdges;
1121     BuildConnectedEdges( TopoDS::Wire(myWork(i)), Esol, V2, ConnectedEdges );
1122
1123     TopTools_ListIteratorOfListOfShape itCE(ConnectedEdges);
1124     for(; anExp.More(), itCE.More(); anExp.Next(), itCE.Next())
1125       {
1126         ECur = anExp.Current();
1127         TopExp::Vertices(ECur,VF,VL,Standard_True);
1128         U1 = BRep_Tool::Parameter(VF,ECur);
1129         U2 = BRep_Tool::Parameter(VL,ECur);
1130         Curve.Initialize(ECur);
1131         PPs = Curve.Value(0.1*(U1+9*U2));
1132
1133         TopoDS_Edge E = TopoDS::Edge(itCE.Value());
1134         TopoDS_Vertex VVF,VVL;
1135         TopExp::Vertices(E,VVF,VVL,Standard_True);
1136
1137         // parse candidate edges
1138         Standard_Real scal1,scal2;
1139         U1 = BRep_Tool::Parameter(VVF,E);
1140         U2 = BRep_Tool::Parameter(VVL,E);
1141         Curve.Initialize(E);
1142         gp_Pnt PP1 = Curve.Value(0.1*(U1+9*U2));
1143         gp_Pnt PP2 = Curve.Value(0.1*(9*U1+U2));
1144
1145         for (rang=i;rang>ideb;rang--) {
1146           Transform(WithRotation, PP1,
1147                     Pos->Value(rang), Axe->Value(rang),
1148                     Pos->Value(rang-1), Axe->Value(rang-1), PP1);
1149           Transform(WithRotation, PP2,
1150                     Pos->Value(rang), Axe->Value(rang),
1151                     Pos->Value(rang-1), Axe->Value(rang-1), PP2);
1152         }
1153         gp_Vec Ns(Pos->Value(ideb),PPs);
1154         Ns = Ns.Normalized();
1155         gp_Vec N1(Pos->Value(ideb),PP1);
1156         N1 = N1.Normalized();
1157         gp_Vec N2(Pos->Value(ideb),PP2);
1158         N2 = N2.Normalized();
1159         scal1 = N1.Dot(Ns);
1160         scal2 = N2.Dot(Ns);
1161         if (scal2>scal1)
1162           E.Reverse();
1163         MW.Add(E);
1164       }
1165     myWork(i) = MW.Wire();
1166   }
1167
1168   // blocking sections?
1169   if (vClosed) myWork(myWork.Length()) = myWork(1);
1170
1171   // check the number of edges for debug
1172   Standard_Integer nbmax=0, nbmin=0;
1173   for ( i=ideb; i<=ifin; i++) {
1174     Standard_Integer nbEdges=0;
1175     for(anExp.Init(TopoDS::Wire(myWork(i))); anExp.More(); anExp.Next()) {
1176       nbEdges++;
1177     }
1178     if (i==ideb) nbmin = nbEdges;
1179     if (nbmax<nbEdges) nbmax = nbEdges;
1180     if (nbmin>nbEdges) nbmin = nbEdges;
1181   }
1182   if (nbmin!=nbmax) {
1183     Standard_NoSuchObject::Raise("BRepFill_CompatibleWires::SameNumberByPolarMethod failed");
1184   }
1185
1186 }
1187
1188 //=======================================================================
1189 //function : SameNumberByACR
1190 //purpose  :
1191 //=======================================================================
1192
1193 void BRepFill_CompatibleWires::SameNumberByACR(const  Standard_Boolean  report)
1194 {
1195   // find the dimension
1196   Standard_Integer ideb=1, ifin=myWork.Length();
1197   BRepTools_WireExplorer anExp;
1198
1199   // point sections, blocking  sections?
1200   if (myDegen1) ideb++;
1201   if (myDegen2) ifin--;
1202   Standard_Boolean vClosed = (!myDegen1) && (!myDegen2)
1203                                 && (myWork(ideb).IsSame(myWork(ifin)));
1204
1205   Standard_Integer nbSects = myWork.Length(), i;
1206   Standard_Integer nbmax=0, nbmin=0;
1207   TColStd_Array1OfInteger nbEdges(1,nbSects);
1208   for (i=1; i<=nbSects; i++) {
1209     nbEdges(i) = 0;
1210     for(anExp.Init(TopoDS::Wire(myWork(i))); anExp.More(); anExp.Next()) {
1211       nbEdges(i)++;
1212     }
1213     if (i==1) nbmin = nbEdges(i);
1214     if (nbmax<nbEdges(i)) nbmax = nbEdges(i);
1215     if (nbmin>nbEdges(i)) nbmin = nbEdges(i);
1216   }
1217
1218   if (nbmax>1) {
1219     // several edges
1220
1221     if (report || nbmin<nbmax) {
1222       // insertion of cuts
1223       Standard_Integer nbdec=(nbmax-1)*nbSects+1;
1224       Standard_Real tol = 0.01;
1225       TColStd_Array1OfReal dec(1,nbdec);
1226       dec.Init(0);
1227       dec(2)=1;
1228       // calculate the table of cuts
1229       Standard_Integer j,k,l;
1230       for (i=1; i<=nbSects; i++) {
1231         // current wire
1232         const TopoDS_Wire& wire1 = TopoDS::Wire(myWork(i));
1233         Standard_Integer nbE = 0;
1234         for(anExp.Init(wire1); anExp.More(); anExp.Next()) {
1235           nbE++;
1236         }
1237         // length and ACR of the wire
1238         TColStd_Array1OfReal ACR(0,nbE);
1239         ACR.Init(0);
1240         BRepFill::ComputeACR(wire1, ACR);
1241         // insertion of ACR of the wire in the table of cuts
1242         for (j=1; j<ACR.Length()-1; j++) {
1243           k=1;
1244           while (dec(k)<ACR(j)) {
1245             k++;
1246             if (k>nbdec) break;
1247           }
1248           if (dec(k-1)+tol<ACR(j)&& ACR(j)+tol<dec(k)) {
1249             for (l=nbdec-1;l>=k;l--) {
1250               dec(l+1)=dec(l);
1251             }
1252             dec(k) = ACR(j);
1253           }
1254         }
1255       }
1256
1257       // table of cuts
1258       k=1;
1259       while (dec(k)<1) {
1260         k++;
1261         if (k>nbdec) break;
1262       }
1263       nbdec = k-1;
1264       TColStd_Array1OfReal dec2(1,nbdec);
1265       for (k=1;k<=nbdec;k++) {
1266         dec2(k) = dec(k);
1267       }
1268
1269       // insertion of cuts in each wire
1270       for (i=1; i<=nbSects; i++) {
1271         const TopoDS_Wire& oldwire = TopoDS::Wire(myWork(i));
1272         TopoDS_Wire newwire = BRepFill::InsertACR(oldwire, dec2, tol);
1273         BRepTools_WireExplorer anExp1,anExp2;
1274         anExp1.Init(oldwire);
1275         anExp2.Init(newwire);
1276         for (;anExp1.More();anExp1.Next()) {
1277           const TopoDS_Edge& Ecur = anExp1.Current();
1278           if (!Ecur.IsSame(TopoDS::Edge(anExp2.Current()))) {
1279             TopTools_ListOfShape LE;
1280             LE.Clear();
1281             gp_Pnt P1,P2;
1282             const TopoDS_Vertex& V1 = anExp1.CurrentVertex();
1283             TopoDS_Vertex VF,VR;
1284             TopExp::Vertices(Ecur,VF,VR,Standard_True);
1285             if (V1.IsSame(VF)) P1 = BRep_Tool::Pnt(VR);
1286             if (V1.IsSame(VR)) P1 = BRep_Tool::Pnt(VF);
1287             TopoDS_Vertex V2 = anExp2.CurrentVertex();
1288             TopExp::Vertices(TopoDS::Edge(anExp2.Current()),
1289                              VF,VR,Standard_True);
1290             if (V2.IsSame(VF)) P2 = BRep_Tool::Pnt(VR);
1291             if (V2.IsSame(VR)) P2 = BRep_Tool::Pnt(VF);
1292             while (P1.Distance(P2)>1.e-3) {
1293               LE.Append(anExp2.Current());
1294               anExp2.Next();
1295               V2 = anExp2.CurrentVertex();
1296               TopExp::Vertices(TopoDS::Edge(anExp2.Current()),
1297                                VF,VR,Standard_True);
1298               if (V2.IsSame(VF)) P2 = BRep_Tool::Pnt(VR);
1299               if (V2.IsSame(VR)) P2 = BRep_Tool::Pnt(VF);
1300               if (P1.Distance(P2)<=1.e-3) {
1301                 LE.Append(anExp2.Current());
1302                 anExp2.Next();
1303               }
1304             }
1305
1306             TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itmap;
1307             //TopTools_ListIteratorOfListOfShape itlist;
1308             TopoDS_Edge Ancestor;
1309             Standard_Integer nbedge, nblist=0;
1310             Standard_Boolean found = Standard_False;
1311
1312             for (itmap.Initialize(myMap);itmap.More()&&(!found);itmap.Next()) {
1313               nblist++;
1314               TopTools_ListIteratorOfListOfShape itlist(itmap.Value());
1315               nbedge = 0;
1316               while (itlist.More()&&(!found)) {
1317                 nbedge++;
1318                 TopoDS_Edge ECur = TopoDS::Edge(itlist.Value());
1319
1320                 if (Ecur.IsSame(ECur)) {
1321                   Ancestor = TopoDS::Edge(itmap.Key());
1322                   found = Standard_True;
1323                   myMap(Ancestor).InsertBefore(LE,itlist);
1324                   myMap(Ancestor).Remove(itlist);
1325                 }
1326                 if (itlist.More()) itlist.Next();
1327               }
1328
1329             }
1330
1331           }
1332           else {
1333             anExp2.Next();
1334           }
1335
1336         }
1337         myWork(i) = newwire;
1338       }
1339
1340     }
1341   }
1342
1343   // blocking sections ?
1344   if (vClosed) myWork(myWork.Length()) = myWork(1);
1345
1346   // check the number of edges for debug
1347   nbmax = 0;
1348   for (i=ideb; i<=ifin; i++) {
1349     nbEdges(i) = 0;
1350     for(anExp.Init(TopoDS::Wire(myWork(i))); anExp.More(); anExp.Next()) {
1351       nbEdges(i)++;
1352     }
1353     if (i==ideb) nbmin = nbEdges(i);
1354     if (nbmax<nbEdges(i)) nbmax = nbEdges(i);
1355     if (nbmin>nbEdges(i)) nbmin = nbEdges(i);
1356   }
1357   if (nbmax!=nbmin)
1358     Standard_NoSuchObject::Raise("BRepFill_CompatibleWires::SameNumberByACR failed");
1359 }
1360
1361 //=======================================================================
1362 //function : ComputeOrigin
1363 //purpose  :
1364 //=======================================================================
1365
1366 void BRepFill_CompatibleWires::ComputeOrigin(const  Standard_Boolean /*polar*/ )
1367 {
1368   // reorganize the wires respecting orientation and origin
1369
1370   TopoDS_Vertex Vdeb, Vfin;
1371   gp_Pnt Pdeb, Psuiv, PPs;
1372
1373   BRepTools_WireExplorer anExp;
1374
1375   Standard_Boolean wClosed, allClosed = Standard_True;
1376
1377   Standard_Integer NbSects = myWork.Length();
1378   Standard_Integer i, ideb=1,ifin=NbSects;
1379
1380   // point sections, blocking sections
1381   if (myDegen1) ideb++;
1382   if (myDegen2) ifin--;
1383   Standard_Boolean vClosed = (!myDegen1) && (!myDegen2)
1384                                 && (myWork(ideb).IsSame(myWork(ifin)));
1385
1386
1387   for (i=ideb; i<=ifin; i++) {
1388     wClosed = myWork(i).Closed();
1389     if (!wClosed) {
1390       // check if the vertices are the same.
1391       TopoDS_Vertex V1, V2;
1392       TopExp::Vertices(TopoDS::Wire(myWork(i)),V1,V2);
1393       if ( V1.IsSame(V2)) wClosed = Standard_True;
1394     }
1395     allClosed = (allClosed && wClosed);
1396   }
1397 /*
1398   for (i=ideb; i<=ifin; i++) {
1399     allClosed = (allClosed && myWork(i).Closed());
1400   }
1401 */
1402   if (!allClosed)
1403     Standard_NoSuchObject::Raise("BRepFill_CompatibleWires::ComputeOrigin : the wires must be closed");
1404
1405 /*
1406   // Max number of possible cuts
1407   Standard_Integer NbMaxV = 0;
1408   for (i=1; i<=NbSects; i++) {
1409     for(anExp.Init(TopoDS::Wire(myWork(i))); anExp.More(); anExp.Next()) {
1410       NbMaxV++;
1411     }
1412   }
1413
1414   // construction of tables of planes of wires
1415   gp_Pln P;
1416   Handle(TColgp_HArray1OfPnt) Pos
1417     = new (TColgp_HArray1OfPnt) (1,NbSects);
1418   Handle(TColgp_HArray1OfVec) Axe
1419     = new (TColgp_HArray1OfVec) (1,NbSects);
1420   for (i=ideb;i<=ifin;i++) {
1421     if (PlaneOfWire(TopoDS::Wire(myWork(i)),P)) {
1422       Pos->SetValue(i,P.Location());
1423       Axe->SetValue(i,gp_Vec(P.Axis().Direction()));
1424     }
1425   }
1426   TopTools_SequenceOfShape SeqV;
1427   if (myDegen1) {
1428     SeqOfVertices(TopoDS::Wire(myWork(1)),SeqV);
1429     Pos->SetValue(1,BRep_Tool::Pnt(TopoDS::Vertex(SeqV.Value(1))));
1430     Axe->SetValue(1,Axe->Value(ideb));
1431   }
1432   if (myDegen2) {
1433     SeqOfVertices(TopoDS::Wire(myWork(NbSects)),SeqV);
1434     Pos->SetValue(NbSects,BRep_Tool::Pnt(TopoDS::Vertex(SeqV.Value(1))));
1435     Axe->SetValue(NbSects,Axe->Value(ifin));
1436   }
1437 */
1438
1439   //Consider that all wires have same number of edges (polar==Standard_False)
1440   TopTools_SequenceOfShape PrevSeq;
1441   TopTools_SequenceOfShape PrevEseq;
1442   Standard_Integer theLength = 0;
1443   const TopoDS_Wire& wire = TopoDS::Wire( myWork(ideb) );
1444   for (anExp.Init(wire); anExp.More(); anExp.Next())
1445     {
1446       PrevSeq.Append(anExp.CurrentVertex());
1447       PrevEseq.Append(anExp.Current());
1448       theLength++;
1449     }
1450
1451   Standard_Integer nbs, NbSamples = 0;
1452   if (theLength <= 2)
1453     NbSamples = 4;
1454   gp_Pln FirstPlane;
1455   PlaneOfWire(TopoDS::Wire(myWork(ideb)), FirstPlane);
1456   gp_Pnt FirstBary = FirstPlane.Location();
1457   gp_Vec NormalOfFirstPlane = FirstPlane.Axis().Direction();
1458   for (i = ideb+1; i <= ifin; i++)
1459     {
1460       const TopoDS_Wire& wire = TopoDS::Wire(myWork(i));
1461
1462       //Compute offset vector as current bary center projected on first plane
1463       //to first bary center
1464       gp_Pln CurPlane;
1465       PlaneOfWire(wire, CurPlane);
1466       gp_Pnt CurBary = CurPlane.Location();
1467       gp_Vec aVec(FirstBary, CurBary);
1468       gp_Vec anOffsetProj = (aVec * NormalOfFirstPlane) * NormalOfFirstPlane;
1469       CurBary.Translate(-anOffsetProj); //projected current bary center
1470       gp_Vec Offset(CurBary, FirstBary);
1471
1472       TopoDS_Wire newwire;
1473       BRep_Builder BB;
1474       BB.MakeWire(newwire);
1475
1476       TopTools_SequenceOfShape SeqVertices, SeqEdges;
1477       for (anExp.Init(wire); anExp.More(); anExp.Next())
1478         {
1479           SeqVertices.Append( anExp.CurrentVertex() );
1480           SeqEdges.Append( anExp.Current() );
1481         }
1482
1483       Standard_Real MinSumDist = Precision::Infinite();
1484       Standard_Integer jmin = 1, j, k, n;
1485       Standard_Boolean forward = Standard_False;
1486       if (i == myWork.Length() && myDegen2)
1487         {
1488           // last point section
1489           jmin = 1;
1490           forward = Standard_True;
1491         }
1492       else
1493         for (j = 1; j <= theLength; j++)
1494           {
1495             //Forward
1496             Standard_Real SumDist = 0.;
1497             for (k = j, n = 1; k <= theLength; k++, n++)
1498               {
1499                 const TopoDS_Vertex& Vprev = TopoDS::Vertex( PrevSeq(n) );
1500                 gp_Pnt Pprev = BRep_Tool::Pnt(Vprev);
1501                 const TopoDS_Vertex& V = TopoDS::Vertex( SeqVertices(k) );
1502                 gp_Pnt P = BRep_Tool::Pnt(V).XYZ() + Offset.XYZ();
1503                 SumDist += Pprev.Distance(P);
1504                 if (NbSamples > 0)
1505                 {
1506                   const TopoDS_Edge& PrevEdge = TopoDS::Edge(PrevEseq(n));
1507                   const TopoDS_Edge& CurEdge = TopoDS::Edge(SeqEdges(k));
1508                   BRepAdaptor_Curve PrevEcurve(PrevEdge);
1509                   BRepAdaptor_Curve Ecurve(CurEdge);
1510                   Standard_Real SampleOnPrev = (PrevEcurve.LastParameter()-PrevEcurve.FirstParameter())/NbSamples;
1511                   Standard_Real SampleOnCur = (Ecurve.LastParameter()-Ecurve.FirstParameter())/NbSamples;
1512                   for (nbs = 1; nbs <= NbSamples-1; nbs++)
1513                   {
1514                     Standard_Real ParOnPrev = (PrevEdge.Orientation() == TopAbs_FORWARD)?
1515                       (PrevEcurve.FirstParameter() + nbs*SampleOnPrev) :
1516                       (PrevEcurve.FirstParameter() + (NbSamples-nbs)*SampleOnPrev);
1517                     Standard_Real ParOnCur = (CurEdge.Orientation() == TopAbs_FORWARD)?
1518                       (Ecurve.FirstParameter() + nbs*SampleOnCur) :
1519                       (Ecurve.FirstParameter() + (NbSamples-nbs)*SampleOnCur);
1520                     gp_Pnt PonPrev = PrevEcurve.Value(ParOnPrev);
1521                     gp_Pnt PonCur = Ecurve.Value(ParOnCur).XYZ() + Offset.XYZ();
1522                     SumDist += PonPrev.Distance(PonCur);
1523                   }
1524                 }
1525               }
1526             for (k = 1; k < j; k++, n++)
1527               {
1528                 const TopoDS_Vertex& Vprev = TopoDS::Vertex( PrevSeq(n) );
1529                 gp_Pnt Pprev = BRep_Tool::Pnt(Vprev);
1530                 const TopoDS_Vertex& V = TopoDS::Vertex( SeqVertices(k) );
1531                 gp_Pnt P = BRep_Tool::Pnt(V).XYZ() + Offset.XYZ();
1532                 SumDist += Pprev.Distance(P);
1533                 if (NbSamples > 0)
1534                 {
1535                   const TopoDS_Edge& PrevEdge = TopoDS::Edge(PrevEseq(n));
1536                   const TopoDS_Edge& CurEdge = TopoDS::Edge(SeqEdges(k));
1537                   BRepAdaptor_Curve PrevEcurve(PrevEdge);
1538                   BRepAdaptor_Curve Ecurve(CurEdge);
1539                   Standard_Real SampleOnPrev = (PrevEcurve.LastParameter()-PrevEcurve.FirstParameter())/NbSamples;
1540                   Standard_Real SampleOnCur = (Ecurve.LastParameter()-Ecurve.FirstParameter())/NbSamples;
1541                   for (nbs = 1; nbs <= NbSamples-1; nbs++)
1542                   {
1543                     Standard_Real ParOnPrev = (PrevEdge.Orientation() == TopAbs_FORWARD)?
1544                       (PrevEcurve.FirstParameter() + nbs*SampleOnPrev) :
1545                       (PrevEcurve.FirstParameter() + (NbSamples-nbs)*SampleOnPrev);
1546                     Standard_Real ParOnCur = (CurEdge.Orientation() == TopAbs_FORWARD)?
1547                       (Ecurve.FirstParameter() + nbs*SampleOnCur) :
1548                       (Ecurve.FirstParameter() + (NbSamples-nbs)*SampleOnCur);
1549                     gp_Pnt PonPrev = PrevEcurve.Value(ParOnPrev);
1550                     gp_Pnt PonCur = Ecurve.Value(ParOnCur).XYZ() + Offset.XYZ();
1551                     SumDist += PonPrev.Distance(PonCur);
1552                   }
1553                 }
1554               }
1555             if (SumDist < MinSumDist)
1556               {
1557                 MinSumDist = SumDist;
1558                 jmin = j;
1559                 forward = Standard_True;
1560               }
1561
1562             //Backward
1563             SumDist = 0.;
1564             for (k = j, n = 1; k >= 1; k--, n++)
1565               {
1566                 const TopoDS_Vertex& Vprev = TopoDS::Vertex( PrevSeq(n) );
1567                 gp_Pnt Pprev = BRep_Tool::Pnt(Vprev);
1568                 const TopoDS_Vertex& V = TopoDS::Vertex( SeqVertices(k) );
1569                 gp_Pnt P = BRep_Tool::Pnt(V).XYZ() + Offset.XYZ();
1570                 SumDist += Pprev.Distance(P);
1571                 if (NbSamples > 0)
1572                 {
1573                   Standard_Integer k_cur = k-1;
1574                   if (k_cur == 0)
1575                     k_cur = theLength;
1576                   const TopoDS_Edge& PrevEdge = TopoDS::Edge(PrevEseq(n));
1577                   const TopoDS_Edge& CurEdge = TopoDS::Edge(SeqEdges(k_cur));
1578                   BRepAdaptor_Curve PrevEcurve(PrevEdge);
1579                   BRepAdaptor_Curve Ecurve(CurEdge);
1580                   Standard_Real SampleOnPrev = (PrevEcurve.LastParameter()-PrevEcurve.FirstParameter())/NbSamples;
1581                   Standard_Real SampleOnCur = (Ecurve.LastParameter()-Ecurve.FirstParameter())/NbSamples;
1582                   for (nbs = 1; nbs <= NbSamples-1; nbs++)
1583                   {
1584                     Standard_Real ParOnPrev = (PrevEdge.Orientation() == TopAbs_FORWARD)?
1585                       (PrevEcurve.FirstParameter() + nbs*SampleOnPrev) :
1586                       (PrevEcurve.FirstParameter() + (NbSamples-nbs)*SampleOnPrev);
1587                     Standard_Real ParOnCur = (CurEdge.Orientation() == TopAbs_FORWARD)?
1588                       (Ecurve.FirstParameter() + (NbSamples-nbs)*SampleOnCur) :
1589                       (Ecurve.FirstParameter() + nbs*SampleOnCur);
1590                     gp_Pnt PonPrev = PrevEcurve.Value(ParOnPrev);
1591                     gp_Pnt PonCur = Ecurve.Value(ParOnCur).XYZ() + Offset.XYZ();
1592                     SumDist += PonPrev.Distance(PonCur);
1593                   }
1594                 }
1595               }
1596             for (k = theLength; k > j; k--, n++)
1597               {
1598                 const TopoDS_Vertex& Vprev = TopoDS::Vertex( PrevSeq(n) );
1599                 gp_Pnt Pprev = BRep_Tool::Pnt(Vprev);
1600                 const TopoDS_Vertex& V = TopoDS::Vertex( SeqVertices(k) );
1601                 gp_Pnt P = BRep_Tool::Pnt(V).XYZ() + Offset.XYZ();
1602                 SumDist += Pprev.Distance(P);
1603                 if (NbSamples > 0)
1604                 {
1605                   const TopoDS_Edge& PrevEdge = TopoDS::Edge(PrevEseq(n));
1606                   const TopoDS_Edge& CurEdge = TopoDS::Edge(SeqEdges(k-1));
1607                   BRepAdaptor_Curve PrevEcurve(PrevEdge);
1608                   BRepAdaptor_Curve Ecurve(CurEdge);
1609                   Standard_Real SampleOnPrev = (PrevEcurve.LastParameter()-PrevEcurve.FirstParameter())/NbSamples;
1610                   Standard_Real SampleOnCur = (Ecurve.LastParameter()-Ecurve.FirstParameter())/NbSamples;
1611                   for (nbs = 1; nbs <= NbSamples-1; nbs++)
1612                   {
1613                     Standard_Real ParOnPrev = (PrevEdge.Orientation() == TopAbs_FORWARD)?
1614                       (PrevEcurve.FirstParameter() + nbs*SampleOnPrev) :
1615                       (PrevEcurve.FirstParameter() + (NbSamples-nbs)*SampleOnPrev);
1616                     Standard_Real ParOnCur = (CurEdge.Orientation() == TopAbs_FORWARD)?
1617                       (Ecurve.FirstParameter() + (NbSamples-nbs)*SampleOnCur) :
1618                       (Ecurve.FirstParameter() + nbs*SampleOnCur);
1619                     gp_Pnt PonPrev = PrevEcurve.Value(ParOnPrev);
1620                     gp_Pnt PonCur = Ecurve.Value(ParOnCur).XYZ() + Offset.XYZ();
1621                     SumDist += PonPrev.Distance(PonCur);
1622                   }
1623                 }
1624               }
1625             if (SumDist < MinSumDist)
1626               {
1627                 MinSumDist = SumDist;
1628                 jmin = j;
1629                 forward = Standard_False;
1630               }
1631           }
1632
1633       PrevSeq.Clear();
1634       PrevEseq.Clear();
1635       if (forward)
1636         {
1637           for (j = jmin; j <= theLength; j++)
1638             {
1639               BB.Add( newwire, TopoDS::Edge(SeqEdges(j)) );
1640               PrevSeq.Append( SeqVertices(j) );
1641               PrevEseq.Append( SeqEdges(j) );
1642             }
1643           for (j = 1; j < jmin; j++)
1644             {
1645               BB.Add( newwire, TopoDS::Edge(SeqEdges(j)) );
1646               PrevSeq.Append( SeqVertices(j) );
1647               PrevEseq.Append( SeqEdges(j) );
1648             }
1649         }
1650       else
1651         {
1652           for (j = jmin-1; j >= 1; j--)
1653             {
1654               TopoDS_Shape aLocalShape = SeqEdges(j).Reversed();
1655               BB.Add( newwire, TopoDS::Edge(aLocalShape) );
1656               //PrevSeq.Append( SeqVertices(j) );
1657               PrevEseq.Append( SeqEdges(j).Reversed() );
1658             }
1659           for (j = theLength; j >= jmin; j--)
1660             {
1661               TopoDS_Shape aLocalShape = SeqEdges(j).Reversed();
1662               BB.Add( newwire, TopoDS::Edge(aLocalShape) );
1663               //PrevSeq.Append( SeqVertices(j) );
1664               PrevEseq.Append( SeqEdges(j).Reversed() );
1665             }
1666           for (j = jmin; j >= 1; j--)
1667             PrevSeq.Append( SeqVertices(j) );
1668           for (j = theLength; j > jmin; j--)
1669             PrevSeq.Append( SeqVertices(j) );
1670         }
1671
1672       newwire.Closed( Standard_True );
1673       newwire.Orientation( TopAbs_FORWARD );
1674       myWork(i) = newwire;
1675     }
1676 #ifdef DEB_EFV
1677
1678   for ( i=ideb; i<=myWork.Length(); i++) {
1679
1680     const TopoDS_Wire& wire = TopoDS::Wire(myWork(i));
1681
1682     Standard_Integer nbEdges=0;
1683     for(anExp.Init(TopoDS::Wire(myWork(i))); anExp.More(); anExp.Next())
1684       nbEdges++;
1685     TopExp::Vertices(wire,Vdeb,Vfin);
1686     Standard_Boolean wClosed = wire.Closed();
1687     if (!wClosed) {
1688       // on regarde quand meme si les vertex sont les memes.
1689       if ( Vdeb.IsSame(Vfin)) wClosed = Standard_True;
1690     }
1691
1692
1693     TopoDS_Vertex Vsuiv, VF, VR;
1694     TopoDS_Wire newwire;
1695     BRep_Builder BW;
1696     BW.MakeWire(newwire);
1697     if (i==ideb) {
1698       anExp.Init(wire);
1699       const TopoDS_Edge Ecur = TopoDS::Edge(anExp.Current());
1700       TopExp::Vertices(Ecur,VF,VR);
1701       if (Vdeb.IsSame(VF)) Vsuiv=VR;
1702       else if (Vdeb.IsSame(VR)) Vsuiv=VF;
1703       else {
1704         // par defaut on prend l'origine sur cette arete
1705         if (VR.IsSame(TopoDS::Vertex(anExp.CurrentVertex()))) {
1706           Vdeb = VR;
1707           Vsuiv = VF;
1708         }
1709         else {
1710           Vdeb = VF;
1711           Vsuiv = VR;
1712         }
1713       }
1714       Pdeb=BRep_Tool::Pnt(Vdeb);
1715       Psuiv=BRep_Tool::Pnt(Vsuiv);
1716       Standard_Real U1 = BRep_Tool::Parameter(Vdeb,Ecur);
1717       Standard_Real U2 = BRep_Tool::Parameter(Vsuiv,Ecur);
1718       BRepAdaptor_Curve Curve(Ecur);
1719       PPs = Curve.Value(0.25*(U1+3*U2));
1720       myWork(ideb) = wire;
1721     }
1722     else {
1723       // on ramene Pdeb, Psuiv et PPs dans le plan courant
1724       gp_Pnt Pnew,Pnext,PPn;
1725       Transform(Standard_True,Pdeb,Pos->Value(i-1),Axe->Value(i-1),
1726                               Pos->Value(i),Axe->Value(i),Pnew);
1727       Transform(Standard_True,Psuiv,Pos->Value(i-1),Axe->Value(i-1),
1728                               Pos->Value(i),Axe->Value(i),Pnext);
1729       Transform(Standard_True,PPs,Pos->Value(i-1),Axe->Value(i-1),
1730                               Pos->Value(i),Axe->Value(i),PPn);
1731
1732       Standard_Real distmini,dist;
1733       Standard_Integer rang=0,rangdeb=0;
1734       TopoDS_Vertex Vmini;
1735       gp_Pnt Pmini,P1,P2;
1736       SeqOfVertices(wire,SeqV);
1737       if (SeqV.Length()>NbMaxV)
1738         Standard_NoSuchObject::Raise("BRepFill::ComputeOrigin failed");
1739       if (!polar) {
1740         // choix du vertex le plus proche comme origine
1741         distmini = Precision::Infinite();
1742         for (Standard_Integer ii=1;ii<=SeqV.Length();ii++) {
1743           P1 = BRep_Tool::Pnt(TopoDS::Vertex(SeqV.Value(ii)));
1744           dist = P1.Distance(Pnew);
1745           if (dist<distmini) {
1746             distmini = dist;
1747             Vmini = TopoDS::Vertex(SeqV.Value(ii));
1748           }
1749         }
1750         if (!Vmini.IsNull()) Pmini = BRep_Tool::Pnt(Vmini);
1751       }
1752       else {
1753
1754         // recherche du vertex correspondant a la projection conique
1755         Standard_Real angmin, angV, eta = Precision::Angular();
1756         TopoDS_Vertex Vopti;
1757         angmin = M_PI/2;
1758         distmini = Precision::Infinite();
1759         gp_Dir dir0(gp_Vec(Pnew,P.Location()));
1760         for (Standard_Integer ii=1;ii<=SeqV.Length();ii++) {
1761           P1 = BRep_Tool::Pnt(TopoDS::Vertex(SeqV.Value(ii)));
1762           dist = Pnew.Distance(P1);
1763           if (dist<Precision::Confusion()) {
1764             angV = 0.0;
1765           }
1766           else {
1767             gp_Dir dir1(gp_Vec(Pnew,P1));
1768             angV = dir1.Angle(dir0);
1769           }
1770           if (angV>M_PI/2) angV = M_PI - angV;
1771           if (angmin>angV+eta) {
1772             distmini = dist;
1773             angmin = angV;
1774             Vopti = TopoDS::Vertex(SeqV.Value(ii));
1775           }
1776           else if (Abs(angmin-angV)<eta) {
1777             if (dist<distmini) {
1778               distmini = dist;
1779               angmin = angV;
1780               Vopti = TopoDS::Vertex(SeqV.Value(ii));
1781             }
1782           }
1783         }
1784         gp_Pnt Popti;
1785         if (!Vopti.IsNull()) Popti = BRep_Tool::Pnt(Vopti);
1786         Vmini = Vopti;
1787
1788       }
1789
1790       distmini = Precision::Infinite();
1791       for (anExp.Init(wire); anExp.More(); anExp.Next()) {
1792         TopoDS_Edge Ecur = anExp.Current();
1793         TopoDS_Vertex Vcur = anExp.CurrentVertex();
1794         TopExp::Vertices(Ecur,VF,VR);
1795         if (VF.IsSame(Vmini)) {
1796           P1 = BRep_Tool::Pnt(VR);
1797           dist = P1.Distance(Pnext);
1798           if (dist<=distmini) {
1799             distmini = dist;
1800             Vsuiv = VR;
1801           }
1802         }
1803         if (VR.IsSame(Vmini)) {
1804           P1 = BRep_Tool::Pnt(VF);
1805           dist = P1.Distance(Pnext);
1806           if (dist<distmini) {
1807             distmini = dist;
1808             Vsuiv = VF;
1809           }
1810         }
1811       }
1812
1813       // choix du sens de parcours en fonction de Pnext
1814       Standard_Boolean parcours = Standard_False;
1815       if (i==myWork.Length() && myDegen2) {
1816         // derniere section ponctuelle
1817         rangdeb = 1;
1818         parcours = Standard_True;
1819       }
1820       else {
1821         // cas general
1822         gp_Pnt Pbout = Pnext;
1823         TopoDS_Edge E1,E2;
1824         TopoDS_Vertex V1,V2;
1825         EdgesFromVertex(wire,Vmini,E1,E2);
1826
1827         TopExp::Vertices(E1,V1,V2,Standard_True);
1828 #ifndef DEB
1829         Standard_Real U1=0, U2=0;
1830 #else
1831         Standard_Real U1, U2;
1832 #endif
1833         if (Vmini.IsSame(V1)) {
1834           P1 = BRep_Tool::Pnt(V2);
1835           U1 = 0.25*(BRep_Tool::Parameter(V1,E1)+3*BRep_Tool::Parameter(V2,E1));
1836         }
1837         if (Vmini.IsSame(V2)) {
1838           P1 = BRep_Tool::Pnt(V1);
1839           U1 = 0.25*(3*BRep_Tool::Parameter(V1,E1)+BRep_Tool::Parameter(V2,E1));
1840         }
1841
1842         TopExp::Vertices(E2,V1,V2,Standard_True);
1843         if (Vmini.IsSame(V1)) {
1844           P2 = BRep_Tool::Pnt(V2);
1845           U2 = 0.25*(BRep_Tool::Parameter(V1,E2)+3*BRep_Tool::Parameter(V2,E2));
1846         }
1847         if (Vmini.IsSame(V2)) {
1848           P2 = BRep_Tool::Pnt(V1);
1849           U2 = 0.25*(3*BRep_Tool::Parameter(V1,E2)+BRep_Tool::Parameter(V2,E2));
1850         }
1851
1852         if (Abs(Pbout.Distance(P1)-Pbout.Distance(P2))<Precision::Confusion()) {
1853           // cas limite ; on se decale un peu
1854           Pbout = PPn;
1855           BRepAdaptor_Curve Curve1(E1);
1856           P1 = Curve1.Value(U1);
1857           BRepAdaptor_Curve Curve2(E2);
1858           P2 = Curve2.Value(U2);
1859         }
1860
1861         // calcul de rangdeb
1862         rangdeb = 0;
1863         if (Pbout.Distance(P1)<Pbout.Distance(P2)){
1864           // P1 est plus proche; parcours = False
1865           parcours = Standard_False;
1866           rang = 0;
1867           for (anExp.Init(wire); anExp.More(); anExp.Next()) {
1868             rang++;
1869             TopoDS_Edge Ecur = anExp.Current();
1870             if (E1.IsSame(Ecur)) {
1871               rangdeb = rang;
1872             }
1873           }
1874           BRepAdaptor_Curve Curve(E1);
1875           PPs = Curve.Value(U1);
1876         }
1877         else {
1878           // P2 est plus proche; parcours = True
1879           parcours = Standard_True;
1880           rang = 0;
1881           for (anExp.Init(wire); anExp.More(); anExp.Next()) {
1882             rang++;
1883             TopoDS_Edge Ecur = anExp.Current();
1884             if (E2.IsSame(Ecur)) {
1885               rangdeb = rang;
1886             }
1887           }
1888           BRepAdaptor_Curve Curve(E2);
1889           PPs = Curve.Value(U2);
1890         }
1891       }
1892
1893       // reconstruction du wire a partir de rangdeb
1894       TopTools_SequenceOfShape SeqEdges;
1895       SeqEdges.Clear();
1896       for (anExp.Init(TopoDS::Wire(wire)); anExp.More(); anExp.Next()) {
1897         SeqEdges.Append(anExp.Current());
1898       }
1899       if (parcours) {
1900         for (rang=rangdeb;rang<=nbEdges;rang++) {
1901           BW.Add(newwire,TopoDS::Edge(SeqEdges.Value(rang)));
1902         }
1903         for (rang=1;rang<rangdeb;rang++) {
1904           BW.Add(newwire,TopoDS::Edge(SeqEdges.Value(rang)));
1905         }
1906       }
1907       else {
1908         for (rang=rangdeb;rang>=1;rang--) {
1909           TopoDS_Shape aLocalShape = SeqEdges.Value(rang).Reversed();
1910           BW.Add(newwire,TopoDS::Edge(aLocalShape));
1911 //        BW.Add(newwire,TopoDS::Edge(SeqEdges.Value(rang).Reversed()));
1912         }
1913         for (rang=nbEdges;rang>rangdeb;rang--) {
1914           TopoDS_Shape aLocalShape = SeqEdges.Value(rang).Reversed();
1915           BW.Add(newwire,TopoDS::Edge(aLocalShape));
1916 //        BW.Add(newwire,TopoDS::Edge(SeqEdges.Value(rang).Reversed()));
1917         }
1918       }
1919
1920       myWork(i) = newwire.Oriented(TopAbs_FORWARD);
1921
1922       // on passe au wire suivant
1923       if (!Vmini.IsNull()) Pdeb=BRep_Tool::Pnt(Vmini);
1924       if (!Vsuiv.IsNull()) Psuiv=BRep_Tool::Pnt(Vsuiv);
1925     }
1926   }
1927 #endif
1928
1929   // blocking sections ?
1930   if (vClosed) myWork(myWork.Length()) = myWork(1);
1931 }
1932
1933 //=======================================================================
1934 //function : SearchOrigin
1935 //purpose  :
1936 //=======================================================================
1937
1938 void BRepFill_CompatibleWires::SearchOrigin()
1939 {
1940   // reorganize the open wires respecting orientation and origin
1941
1942   gp_Pln P0,P;
1943
1944   TopoDS_Vertex Vdeb, Vfin;
1945   gp_Pnt Pdeb,  Pfin;//,Psuiv;
1946
1947   BRepTools_WireExplorer anExp;
1948
1949   Standard_Boolean allOpen = Standard_True;
1950   Standard_Integer ideb=1, ifin=myWork.Length();
1951   if (myDegen1) ideb++;
1952   if (myDegen2) ifin--;
1953   Standard_Boolean vClosed = (!myDegen1) && (!myDegen2)
1954                                 && (myWork(ideb).IsSame(myWork(ifin)));
1955
1956 //  for (Standard_Integer i=ideb; i<=ifin; i++) {
1957   Standard_Integer i;
1958   for  (i=ideb; i<=ifin; i++) {
1959     allOpen = (allOpen && !myWork(i).Closed());
1960   }
1961   if (!allOpen)
1962     Standard_NoSuchObject::Raise("BRepFill_CompatibleWires::SearchOrigin : the wires must be open");
1963
1964   // init
1965
1966   TopoDS_Wire wire1 = TopoDS::Wire(myWork(ideb));
1967   wire1.Orientation(TopAbs_FORWARD);
1968   TopExp::Vertices(wire1,Vdeb,Vfin);
1969   Pdeb = BRep_Tool::Pnt(Vdeb);
1970   Pfin = BRep_Tool::Pnt(Vfin);
1971   Standard_Boolean isline0 = (!PlaneOfWire(wire1,P0)), isline;
1972   myWork(ideb) = wire1;
1973   //OCC86
1974   anExp.Init(wire1);
1975   TopoDS_Edge E0 = anExp.Current(), E;
1976
1977   for ( i=ideb+1; i<=ifin; i++) {
1978
1979     TopoDS_Wire wire = TopoDS::Wire(myWork(i));
1980     wire.Orientation(TopAbs_FORWARD);
1981
1982     TopTools_SequenceOfShape SeqEdges;
1983     SeqEdges.Clear();
1984     Standard_Integer nbEdges=0;
1985     //OCC86  for(anExp.Init(wire); anExp.More(); anExp.Next()) {
1986     for(anExp.Init(wire), E = anExp.Current(); anExp.More(); anExp.Next()) {
1987       SeqEdges.Append(anExp.Current());
1988       nbEdges++;
1989     }
1990     TopExp::Vertices(wire,Vdeb,Vfin);
1991     isline = (!PlaneOfWire(wire,P));
1992
1993     TopoDS_Vertex Vmini;
1994     TopoDS_Wire newwire;
1995     BRep_Builder BW;
1996     BW.MakeWire(newwire);
1997     Standard_Boolean parcours = Standard_True;
1998
1999     if (isline0 || isline) {
2000
2001       // particular case of straight segments
2002       gp_Pnt P1 = BRep_Tool::Pnt(Vdeb),
2003              P2 = BRep_Tool::Pnt(Vfin);
2004       Standard_Real dist1, dist2;
2005       dist1 = Pdeb.Distance(P1)+Pfin.Distance(P2);
2006       dist2 = Pdeb.Distance(P2)+Pfin.Distance(P1);
2007       parcours = (dist2>=dist1);
2008     }
2009
2010     else {
2011       //OCC86
2012       gp_Pnt P1 = BRep_Tool::Pnt(Vdeb), P1o = Pdeb,
2013              P2 = BRep_Tool::Pnt(Vfin), P2o = Pfin;
2014 /*    // return Pdeb in the current plane
2015       gp_Pnt Pnew = Pdeb.Translated (P0.Location(),P.Location());
2016       gp_Ax1 A0 = P0.Axis();
2017       gp_Ax1 A1 = P.Axis();
2018
2019       if (!A0.IsParallel(A1,1.e-4)) {
2020         gp_Vec vec1(A0.Direction()), vec2(A1.Direction()),
2021         norm = vec1 ^ vec2;
2022         gp_Ax1 Norm(P.Location(),norm);
2023         Standard_Real ang = vec1.AngleWithRef(vec2,norm);
2024         if (ang > M_PI/2.0)
2025           ang = M_PI - ang;
2026         if (ang < -M_PI/2.0)
2027           ang = -M_PI - ang;
2028         if (Abs(ang-M_PI/2.0)<Precision::Angular()) {
2029           // cas d'ambiguite
2030           gp_Vec Vtrans(P0.Location(),P.Location()),Vsign;
2031           Standard_Real alpha,beta,sign=1;
2032           Vsign.SetLinearForm(Vtrans.Dot(vec1),vec2,-Vtrans.Dot(vec2),vec1);
2033           alpha = Vsign.Dot(vec1);
2034           beta = Vsign.Dot(vec2);
2035           Standard_Boolean pasnul = (Abs(alpha)>1.e-4 && Abs(beta)>1.e-4);
2036           if ( alpha*beta>0.0 && pasnul ) sign=-1;
2037           ang *= sign;
2038         }
2039         Pnew = Pnew.Rotated (Norm,ang);
2040       }
2041       // choix entre Vdeb et Vfin
2042       Standard_Real dist = Pnew.Distance(P1);
2043       parcours = (dist<Pnew.Distance(P2));
2044 */
2045       if(P1.IsEqual(P2,Precision::Confusion()) || P1o.IsEqual(P2o,Precision::Confusion())){
2046         BRepAdaptor_Curve Curve0(E0), Curve(E);
2047         Curve0.D0(Curve0.FirstParameter() + Precision::Confusion(), P2o);
2048         Curve.D0(Curve.FirstParameter() + Precision::Confusion(), P2);
2049       };
2050       gp_Vec VDebFin0(P1o,P2o), VDebFin(P1,P2);
2051       Standard_Real AStraight = VDebFin0.Angle(VDebFin);
2052       parcours = (AStraight < M_PI/2.0? Standard_True: Standard_False);
2053     }
2054
2055     // reconstruction of the wire
2056     Standard_Integer rang;
2057     if (parcours) {
2058       for (rang=1;rang<=nbEdges;rang++) {
2059         TopoDS_Shape alocalshape = SeqEdges.Value(rang);
2060         BW.Add(newwire,TopoDS::Edge(alocalshape));
2061 //      BW.Add(newwire,TopoDS::Edge(SeqEdges.Value(rang)));
2062       }
2063     }
2064     else {
2065       for (rang=nbEdges;rang>=1;rang--) {
2066         TopoDS_Shape alocalshape = SeqEdges.Value(rang).Reversed();
2067         BW.Add(newwire,TopoDS::Edge(alocalshape));
2068 //      BW.Add(newwire,TopoDS::Edge(SeqEdges.Value(rang).Reversed()));
2069       }
2070     }
2071
2072     // orientation of the wire
2073     newwire.Oriented(TopAbs_FORWARD);
2074     myWork(i) = newwire;
2075
2076     // passe to the next wire
2077     if (parcours) {
2078       Pdeb = BRep_Tool::Pnt(Vdeb);
2079       Pfin = BRep_Tool::Pnt(Vfin);
2080     }
2081     else {
2082       Pfin = BRep_Tool::Pnt(Vdeb);
2083       Pdeb = BRep_Tool::Pnt(Vfin);
2084     }
2085     P0 = P;
2086     isline0 = isline;
2087     //OCC86
2088     E0 = E;
2089   }
2090
2091   // blocking sections ?
2092   if (vClosed) myWork(myWork.Length()) = myWork(1);
2093 }