src/BRepBndLib/BRepBndLib.cxx

   1 // Copyright (c) 1995-1999 Matra Datavision
   2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   3 //
   4 // This file is part of Open CASCADE Technology software library.
   5 //
   6 // This library is free software; you can redistribute it and/or modify it under
   7 // the terms of the GNU Lesser General Public License version 2.1 as published
   8 // by the Free Software Foundation, with special exception defined in the file
   9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  10 // distribution for complete text of the license and disclaimer of any warranty.
  11 //
  12 // Alternatively, this file may be used under the terms of Open CASCADE
  13 // commercial license or contractual agreement.
  14
  15
  16 #include <Bnd_Box.hxx>
  17 #include <BndLib_Add3dCurve.hxx>
  18 #include <BndLib_AddSurface.hxx>
  19 #include <BRep_Polygon3D.hxx>
  20 #include <BRep_Tool.hxx>
  21 #include <BRepAdaptor_Curve.hxx>
  22 #include <BRepAdaptor_Surface.hxx>
  23 #include <BRepBndLib.hxx>
  24 #include <Geom_Curve.hxx>
  25 #include <Geom_Surface.hxx>
  26 #include <GeomAdaptor_Curve.hxx>
  27 #include <Poly_Polygon3D.hxx>
  28 #include <Poly_PolygonOnTriangulation.hxx>
  29 #include <Poly_Triangulation.hxx>
  30 #include <TColgp_Array1OfPnt.hxx>
  31 #include <TColStd_Array1OfInteger.hxx>
  32 #include <TColStd_HArray1OfInteger.hxx>
  33 #include <TopExp_Explorer.hxx>
  34 #include <TopLoc_Location.hxx>
  35 #include <TopoDS.hxx>
  36 #include <TopoDS_Shape.hxx>
  37 #include <Adaptor3d_HCurve.hxx>
  38 #include <Adaptor3d_HSurface.hxx>
  39 #include <BRepTools.hxx>
  40 #include <Geom_BSplineSurface.hxx>
  41 #include <Geom_BezierSurface.hxx>
  42 #include <Bnd_Box2d.hxx>
  43 #include <BndLib_Add2dCurve.hxx>
  44 #include <BRepTopAdaptor_FClass2d.hxx>
  45 #include <ElSLib.hxx>
  46 #include <ElCLib.hxx>
  47 #include <Geom_Plane.hxx>
  48 #include <Extrema_ExtSS.hxx>
  49 #include <GeomAdaptor_Surface.hxx>
  50 //
  51 static Standard_Boolean CanUseEdges(const Adaptor3d_Surface& BS);
  52 //
  53 static void FindExactUVBounds(const TopoDS_Face F,
  54                               Standard_Real& umin, Standard_Real& umax,
  55                               Standard_Real& vmin, Standard_Real& vmax,
  56                               const Standard_Real Tol,
  57                               Standard_Boolean& isNaturalRestriction);
  58 //
  59 static void AdjustFaceBox(const BRepAdaptor_Surface& BS,
  60                           const Standard_Real umin, const Standard_Real umax,
  61                           const Standard_Real vmin, const Standard_Real vmax,
  62                           Bnd_Box& FaceBox,
  63                           const Bnd_Box& EdgeBox, const Standard_Real Tol);
  64 //
  65 static Standard_Boolean IsModifySize(const BRepAdaptor_Surface& theBS,
  66                                      const gp_Pln& thePln, const gp_Pnt& theP,
  67                                      const Standard_Real umin, const Standard_Real umax,
  68                                      const Standard_Real vmin, const Standard_Real vmax,
  69                                      const BRepTopAdaptor_FClass2d& theFClass,
  70                                      const Standard_Real theTolU, const Standard_Real theTolV);
  71
  72 //
  73 //=======================================================================
  74 //function : Add
  75 //purpose  : Add a shape bounding to a box
  76 //=======================================================================
  77 void BRepBndLib::Add(const TopoDS_Shape& S, Bnd_Box& B, Standard_Boolean useTriangulation)
  78 {
  79   TopExp_Explorer ex;
  80
  81   // Add the faces
  82   BRepAdaptor_Surface BS;
  83   TopLoc_Location l, aDummyLoc;
  84   Standard_Integer i, nbNodes;
  85   BRepAdaptor_Curve BC;
  86
  87   for (ex.Init(S,TopAbs_FACE); ex.More(); ex.Next()) {
  88     const TopoDS_Face& F = TopoDS::Face(ex.Current());
  89     const Handle(Poly_Triangulation)& T = BRep_Tool::Triangulation(F, l);
  90     const Handle(Geom_Surface)& GS = BRep_Tool::Surface (F, aDummyLoc);
  91     if ((useTriangulation || GS.IsNull()) && !T.IsNull())
  92     {
  93       nbNodes = T->NbNodes();
  94       const TColgp_Array1OfPnt& Nodes = T->Nodes();
  95       for (i = 1; i <= nbNodes; i++) {
  96         if (l.IsIdentity()) B.Add(Nodes(i));
  97         else B.Add(Nodes(i).Transformed(l));
  98       }
  99       //       B.Enlarge(T->Deflection());
 100       B.Enlarge(T->Deflection() + BRep_Tool::Tolerance(F));
 101     } else
 102     {
 103       if (!GS.IsNull()) {
 104         BS.Initialize(F, Standard_False);
 105         if (BS.GetType() != GeomAbs_Plane) {
 106           BS.Initialize(F);
 107           BndLib_AddSurface::Add(BS, BRep_Tool::Tolerance(F), B);
 108         }
 109         else {
 110           // on travaille directement sur les courbes 3d.
 111           TopExp_Explorer ex2(F, TopAbs_EDGE);
 112           if (!ex2.More()) {
 113             BS.Initialize(F);
 114             BndLib_AddSurface::Add(BS, BRep_Tool::Tolerance(F), B);
 115           }
 116           else {
 117             for (;ex2.More();ex2.Next()) {
 118               const TopoDS_Edge& anEdge = TopoDS::Edge(ex2.Current());
 119               if (BRep_Tool::IsGeometric (anEdge))
 120               {
 121                 BC.Initialize (anEdge);
 122                 BndLib_Add3dCurve::Add (BC, BRep_Tool::Tolerance (anEdge), B);
 123               }
 124             }
 125             B.Enlarge(BRep_Tool::Tolerance(F));
 126           }
 127         }
 128       }
 129     }
 130   }
 131
 132   // Add the edges not in faces
 133   Handle(TColStd_HArray1OfInteger) HIndices;
 134   Handle(Poly_PolygonOnTriangulation) Poly;
 135   Handle(Poly_Triangulation) T;
 136   for (ex.Init(S,TopAbs_EDGE,TopAbs_FACE); ex.More(); ex.Next())
 137   {
 138     const TopoDS_Edge& E = TopoDS::Edge(ex.Current());
 139     Handle(Poly_Polygon3D) P3d = BRep_Tool::Polygon3D(E, l);
 140     if (!P3d.IsNull())
 141     {
 142       const TColgp_Array1OfPnt& Nodes = P3d->Nodes();
 143       nbNodes = P3d->NbNodes();
 144       for (i = 1; i <= nbNodes; i++)
 145       {
 146         if (l.IsIdentity()) B.Add(Nodes(i));
 147         else B.Add(Nodes(i).Transformed(l));
 148       }
 149       //       B.Enlarge(P3d->Deflection());
 150       B.Enlarge(P3d->Deflection() + BRep_Tool::Tolerance(E));
 151     }
 152     else
 153     {
 154       BRep_Tool::PolygonOnTriangulation(E, Poly, T, l);
 155       if (useTriangulation && !Poly.IsNull())
 156       {
 157         const TColStd_Array1OfInteger& Indices = Poly->Nodes();
 158         const TColgp_Array1OfPnt& Nodes = T->Nodes();
 159         nbNodes = Indices.Length();
 160         for (i = 1; i <= nbNodes; i++)
 161         {
 162           if (l.IsIdentity()) B.Add(Nodes(Indices(i)));
 163           else B.Add(Nodes(Indices(i)).Transformed(l));
 164         }
 165         //      B.Enlarge(T->Deflection());
 166         B.Enlarge(Poly->Deflection() + BRep_Tool::Tolerance(E));
 167       }
 168       else {
 169         if (BRep_Tool::IsGeometric(E))
 170         {
 171           BC.Initialize(E);
 172           BndLib_Add3dCurve::Add(BC, BRep_Tool::Tolerance(E), B);
 173         }
 174       }
 175     }
 176   }
 177
 178   // Add the vertices not in edges
 179
 180   for (ex.Init(S,TopAbs_VERTEX,TopAbs_EDGE); ex.More(); ex.Next()) {
 181     B.Add(BRep_Tool::Pnt(TopoDS::Vertex(ex.Current())));
 182     B.Enlarge(BRep_Tool::Tolerance(TopoDS::Vertex(ex.Current())));
 183   }
 184 }
 185
 186
 187
 188 //=======================================================================
 189 //function : AddClose
 190 //purpose  : Add a precise shape bounding to a box
 191 //=======================================================================
 192
 193 void BRepBndLib::AddClose(const TopoDS_Shape& S, Bnd_Box& B)
 194 {
 195   TopExp_Explorer ex;
 196
 197   // No faces
 198
 199   // Add the edges
 200
 201   BRepAdaptor_Curve BC;
 202
 203   for (ex.Init(S,TopAbs_EDGE); ex.More(); ex.Next()) {
 204     const TopoDS_Edge& anEdge = TopoDS::Edge (ex.Current());
 205     if (BRep_Tool::IsGeometric (anEdge))
 206     {
 207       BC.Initialize (anEdge);
 208       BndLib_Add3dCurve::Add(BC,0.,B);
 209     }
 210   }
 211
 212   // Add the vertices not in edges
 213
 214   for (ex.Init(S,TopAbs_VERTEX,TopAbs_EDGE); ex.More(); ex.Next()) {
 215     B.Add(BRep_Tool::Pnt(TopoDS::Vertex(ex.Current())));
 216   }
 217 }
 218
 219 //=======================================================================
 220 //function : AddOptimal
 221 //purpose  : Add a shape bounding to a box
 222 //=======================================================================
 223 void BRepBndLib::AddOptimal(const TopoDS_Shape& S, Bnd_Box& B,
 224                             const Standard_Boolean useTriangulation,
 225                             const Standard_Boolean useShapeTolerance)
 226 {
 227   TopExp_Explorer ex;
 228
 229   // Add the faces
 230   BRepAdaptor_Surface BS;
 231   Handle(Poly_Triangulation) T;
 232   TopLoc_Location l;
 233   Standard_Integer i, nbNodes;
 234   BRepAdaptor_Curve BC;
 235
 236   for (ex.Init(S,TopAbs_FACE); ex.More(); ex.Next()) {
 237     const TopoDS_Face& F = TopoDS::Face(ex.Current());
 238     T = BRep_Tool::Triangulation(F, l);
 239     Bnd_Box aLocBox;
 240     if (useTriangulation && !T.IsNull())
 241     {
 242       nbNodes = T->NbNodes();
 243       const TColgp_Array1OfPnt& Nodes = T->Nodes();
 244       for (i = 1; i <= nbNodes; i++) {
 245         if (l.IsIdentity()) aLocBox.Add(Nodes(i));
 246         else aLocBox.Add(Nodes(i).Transformed(l));
 247       }
 248       //       B.Enlarge(T->Deflection());
 249       aLocBox.Enlarge(T->Deflection() + BRep_Tool::Tolerance(F));
 250       Standard_Real xmin, ymin, zmin, xmax, ymax, zmax;
 251       aLocBox.Get(xmin, ymin, zmin, xmax, ymax, zmax);
 252       B.Update(xmin, ymin, zmin, xmax, ymax, zmax);
 253     }
 254     else
 255     {
 256       const Handle(Geom_Surface)& GS = BRep_Tool::Surface(F, l);
 257       if (!GS.IsNull()) {
 258         BS.Initialize(F, Standard_False);
 259         if (CanUseEdges(BS)) {
 260           TopExp_Explorer ex2(F, TopAbs_EDGE);
 261           if (!ex2.More()) {
 262             BS.Initialize(F);
 263             Standard_Real Tol = useShapeTolerance?  BRep_Tool::Tolerance(F) : 0.;
 264             BndLib_AddSurface::AddOptimal(BS, Tol, aLocBox);
 265           }
 266           else
 267           {
 268             Standard_Real Tol;
 269             for (;ex2.More();ex2.Next()) {
 270               Bnd_Box anEBox;
 271               const TopoDS_Edge& anE = TopoDS::Edge(ex2.Current());
 272               if (BRep_Tool::Degenerated (anE) || !BRep_Tool::IsGeometric (anE))
 273               {
 274                 continue;
 275               }
 276               BC.Initialize(anE);
 277               Tol = useShapeTolerance?  BRep_Tool::Tolerance(anE) : 0.;
 278               BndLib_Add3dCurve::AddOptimal(BC, Tol, anEBox);
 279               aLocBox.Add(anEBox);
 280             }
 281           }
 282         }
 283         else
 284         {
 285           Standard_Real umin, umax, vmin, vmax;
 286           Standard_Boolean isNaturalRestriction = Standard_False;
 287           Standard_Real Tol = useShapeTolerance?  BRep_Tool::Tolerance(F) : 0.;
 288           FindExactUVBounds(F, umin, umax, vmin, vmax, Tol, isNaturalRestriction);
 289           BndLib_AddSurface::AddOptimal(BS, umin, umax, vmin, vmax,
 290                                         Tol, aLocBox);
 291           //
 292           if(!isNaturalRestriction)
 293           {
 294             TopExp_Explorer ex2(F, TopAbs_EDGE);
 295             Bnd_Box EBox;
 296             for (;ex2.More();ex2.Next()) {
 297               Bnd_Box anEBox;
 298               const TopoDS_Edge& anE = TopoDS::Edge(ex2.Current());
 299               if (BRep_Tool::Degenerated (anE) || !BRep_Tool::IsGeometric (anE))
 300               {
 301                 continue;
 302               }
 303               BC.Initialize(anE);
 304               Tol = useShapeTolerance?  BRep_Tool::Tolerance(anE) : 0.;
 305               BndLib_Add3dCurve::AddOptimal(BC, Tol, anEBox);
 306               EBox.Add(anEBox);
 307             }
 308             Tol = useShapeTolerance?  BRep_Tool::Tolerance(F) : 0.;
 309             AdjustFaceBox(BS, umin, umax, vmin, vmax, aLocBox, EBox,
 310                           Tol);
 311           }
 312         }
 313         Standard_Real xmin, ymin, zmin, xmax, ymax, zmax;
 314         aLocBox.Get(xmin, ymin, zmin, xmax, ymax, zmax);
 315         B.Update(xmin, ymin, zmin, xmax, ymax, zmax);
 316       }
 317     }
 318   }
 319
 320   // Add the edges not in faces
 321   Handle(TColStd_HArray1OfInteger) HIndices;
 322   Handle(Poly_PolygonOnTriangulation) Poly;
 323
 324   for (ex.Init(S,TopAbs_EDGE,TopAbs_FACE); ex.More(); ex.Next())
 325   {
 326     const TopoDS_Edge& E = TopoDS::Edge(ex.Current());
 327     Bnd_Box aLocBox;
 328     Handle(Poly_Polygon3D) P3d = BRep_Tool::Polygon3D(E, l);
 329     if (useTriangulation && (!P3d.IsNull()))
 330     {
 331       const TColgp_Array1OfPnt& Nodes = P3d->Nodes();
 332       nbNodes = P3d->NbNodes();
 333       for (i = 1; i <= nbNodes; i++)
 334       {
 335         if (l.IsIdentity()) aLocBox.Add(Nodes(i));
 336         else aLocBox.Add(Nodes(i).Transformed(l));
 337       }
 338       Standard_Real Tol = useShapeTolerance?  BRep_Tool::Tolerance(E) : 0.;
 339       aLocBox.Enlarge(P3d->Deflection() + Tol);
 340     }
 341     else
 342     {
 343       BRep_Tool::PolygonOnTriangulation(E, Poly, T, l);
 344       if (useTriangulation && !Poly.IsNull())
 345       {
 346         const TColStd_Array1OfInteger& Indices = Poly->Nodes();
 347         const TColgp_Array1OfPnt& Nodes = T->Nodes();
 348         nbNodes = Indices.Length();
 349         for (i = 1; i <= nbNodes; i++)
 350         {
 351           if (l.IsIdentity()) aLocBox.Add(Nodes(Indices(i)));
 352           else aLocBox.Add(Nodes(Indices(i)).Transformed(l));
 353         }
 354         Standard_Real Tol = useShapeTolerance?  BRep_Tool::Tolerance(E) : 0.;
 355         aLocBox.Enlarge(Poly->Deflection() + Tol);
 356       }
 357       else {
 358         if (BRep_Tool::IsGeometric(E))
 359         {
 360           BC.Initialize(E);
 361           Standard_Real Tol = useShapeTolerance?  BRep_Tool::Tolerance(E) : 0.;
 362           BndLib_Add3dCurve::AddOptimal(BC, Tol, aLocBox);
 363         }
 364       }
 365     }
 366     if (!aLocBox.IsVoid())
 367     {
 368       Standard_Real xmin, ymin, zmin, xmax, ymax, zmax;
 369       aLocBox.Get(xmin, ymin, zmin, xmax, ymax, zmax);
 370       B.Update(xmin, ymin, zmin, xmax, ymax, zmax);
 371     }
 372   }
 373
 374   // Add the vertices not in edges
 375
 376   for (ex.Init(S,TopAbs_VERTEX,TopAbs_EDGE); ex.More(); ex.Next()) {
 377     Bnd_Box aLocBox;
 378     const TopoDS_Vertex& aV = TopoDS::Vertex(ex.Current());
 379     aLocBox.Add(BRep_Tool::Pnt(aV));
 380     Standard_Real Tol = useShapeTolerance?  BRep_Tool::Tolerance(aV) : 0.;
 381     aLocBox.Enlarge(Tol);
 382     Standard_Real xmin, ymin, zmin, xmax, ymax, zmax;
 383     aLocBox.Get(xmin, ymin, zmin, xmax, ymax, zmax);
 384     B.Update(xmin, ymin, zmin, xmax, ymax, zmax);
 385   }
 386 }
 387
 388 //=======================================================================
 389 //function : CanUseEdges
 390 //purpose  : Define is it possible using only edges bnd boxes
 391 //           to get face bnd box
 392 //=======================================================================
 393 Standard_Boolean CanUseEdges(const Adaptor3d_Surface& BS)
 394 {
 395   GeomAbs_SurfaceType aST = BS.GetType();
 396   if(aST == GeomAbs_Plane ||
 397      aST == GeomAbs_Cylinder ||
 398      aST == GeomAbs_Cone ||
 399      aST == GeomAbs_SurfaceOfExtrusion)
 400   {
 401     return Standard_True;
 402   }
 403   else if(aST == GeomAbs_SurfaceOfRevolution)
 404   {
 405     const Handle(Adaptor3d_HCurve)& aBC = BS.BasisCurve();
 406     if(aBC->GetType() == GeomAbs_Line)
 407     {
 408       return Standard_True;
 409     }
 410     else
 411     {
 412       return Standard_False;
 413     }
 414   }
 415   else if(aST == GeomAbs_OffsetSurface)
 416   {
 417     const Handle(Adaptor3d_HSurface)& aS = BS.BasisSurface();
 418     return CanUseEdges(aS->Surface());
 419   }
 420   else if(aST == GeomAbs_BSplineSurface)
 421   {
 422     Handle(Geom_BSplineSurface) aBSpl = BS.BSpline();
 423     if((aBSpl->UDegree() == 1 && aBSpl->NbUKnots() == 2) ||
 424        (aBSpl->VDegree() == 1 && aBSpl->NbVKnots() == 2))
 425     {
 426       return Standard_True;
 427     }
 428     else
 429     {
 430       return Standard_False;
 431     }
 432   }
 433   else if(aST == GeomAbs_BezierSurface)
 434   {
 435     Handle(Geom_BezierSurface) aBz = BS.Bezier();
 436     if((aBz->UDegree() == 1 ) ||
 437        (aBz->VDegree() == 1 ))
 438     {
 439       return Standard_True;
 440     }
 441     else
 442     {
 443       return Standard_False;
 444     }
 445   }
 446   return Standard_False;
 447 }
 448
 449 //=======================================================================
 450 //function : FindExactUVBounds
 451 //purpose  :
 452 //=======================================================================
 453 void FindExactUVBounds(const TopoDS_Face FF,
 454                        Standard_Real& umin, Standard_Real& umax,
 455                        Standard_Real& vmin, Standard_Real& vmax,
 456                        const Standard_Real Tol,
 457                        Standard_Boolean& isNaturalRestriction)
 458 {
 459   TopoDS_Face F = FF;
 460   F.Orientation(TopAbs_FORWARD);
 461   TopExp_Explorer ex(F,TopAbs_EDGE);
 462   //
 463   //Check Natural restriction
 464   isNaturalRestriction = BRep_Tool::NaturalRestriction(F); //Can we trust this flag?
 465   BRepAdaptor_Surface aBAS(F, Standard_False);
 466   if(!isNaturalRestriction)
 467   {
 468     //Check by comparing pcurves and surface boundaries
 469     umin = aBAS.FirstUParameter();
 470     umax = aBAS.LastUParameter();
 471     vmin = aBAS.FirstVParameter();
 472     vmax = aBAS.LastVParameter();
 473     Standard_Boolean isUperiodic = aBAS.IsUPeriodic(), isVperiodic = aBAS.IsVPeriodic();
 474     Standard_Real aT1, aT2;
 475     Standard_Real TolU = Max(aBAS.UResolution(Tol), Precision::PConfusion());
 476     Standard_Real TolV = Max(aBAS.VResolution(Tol), Precision::PConfusion());
 477     Standard_Integer Nu = 0, Nv = 0, NbEdges = 0;
 478     gp_Vec2d Du(1, 0), Dv(0, 1);
 479     gp_Pnt2d aP;
 480     gp_Vec2d aV;
 481     for (;ex.More();ex.Next()) {
 482       NbEdges++;
 483       if(NbEdges > 4)
 484       {
 485         break;
 486       }
 487       const TopoDS_Edge& aE = TopoDS::Edge(ex.Current());
 488       const Handle(Geom2d_Curve) aC2D = BRep_Tool::CurveOnSurface(aE, F, aT1, aT2);
 489       if (aC2D.IsNull())
 490       {
 491         break;
 492       }
 493       //
 494       aC2D->D1((aT1 + aT2)/2., aP, aV);
 495       Standard_Real magn = aV.SquareMagnitude();
 496       if(magn < gp::Resolution())
 497       {
 498         break;
 499       }
 500       else
 501       {
 502         aV /= Sqrt(magn);
 503       }
 504       Standard_Real u = aP.X(), v = aP.Y();
 505       if(isUperiodic)
 506       {
 507         ElCLib::InPeriod(u, umin, umax);
 508       }
 509       if(isVperiodic)
 510       {
 511         ElCLib::InPeriod(v, vmin, vmax);
 512       }
 513       //
 514       if(Abs(u - umin) <= TolU || Abs(u - umax) <= TolU)
 515       {
 516         Standard_Real d = Dv * aV;
 517         if(1. - Abs(d) <= Precision::PConfusion())
 518         {
 519           Nu++;
 520           if(Nu > 2)
 521           {
 522             break;
 523           }
 524         }
 525         else
 526         {
 527           break;
 528         }
 529       }
 530       else if(Abs(v - vmin) <= TolV || Abs(v - vmax) <= TolV)
 531       {
 532         Standard_Real d = Du * aV;
 533         if(1. - Abs(d) <= Precision::PConfusion())
 534         {
 535           Nv++;
 536           if(Nv > 2)
 537           {
 538             break;
 539           }
 540         }
 541         else
 542         {
 543           break;
 544         }
 545       }
 546       else
 547       {
 548         break;
 549       }
 550     }
 551     if(Nu == 2 && Nv == 2)
 552     {
 553       isNaturalRestriction = Standard_True;
 554     }
 555   }
 556   //
 557   if(isNaturalRestriction)
 558   {
 559     umin = aBAS.FirstUParameter();
 560     umax = aBAS.LastUParameter();
 561     vmin = aBAS.FirstVParameter();
 562     vmax = aBAS.LastVParameter();
 563     return;
 564   }
 565
 566   // fill box for the given face
 567   Standard_Real aT1, aT2;
 568   Standard_Real TolU = Max(aBAS.UResolution(Tol), Precision::PConfusion());
 569   Standard_Real TolV = Max(aBAS.VResolution(Tol), Precision::PConfusion());
 570   Standard_Real TolUV = Max(TolU, TolV);
 571   Bnd_Box2d aBox;
 572   ex.Init(F,TopAbs_EDGE);
 573   for (;ex.More();ex.Next()) {
 574     const TopoDS_Edge& aE = TopoDS::Edge(ex.Current());
 575     const Handle(Geom2d_Curve) aC2D = BRep_Tool::CurveOnSurface(aE, F, aT1, aT2);
 576     if (aC2D.IsNull())
 577     {
 578       continue;
 579     }
 580     //
 581     BndLib_Add2dCurve::AddOptimal(aC2D, aT1, aT2, TolUV, aBox);
 582     //
 583   }
 584   //
 585   aBox.Get(umin, vmin, umax, vmax);
 586   //
 587   TopLoc_Location aLoc;
 588   Handle(Geom_Surface) aS = BRep_Tool::Surface(FF, aLoc);
 589   Standard_Real aUmin, aUmax, aVmin, aVmax;
 590   aS->Bounds(aUmin, aUmax, aVmin, aVmax);
 591   if(!aS->IsUPeriodic())
 592   {
 593     umin = Max(aUmin, umin);
 594     umax = Min(aUmax, umax);
 595   }
 596   else
 597   {
 598     if(umax - umin > aS->UPeriod())
 599     {
 600       Standard_Real delta = umax - umin - aS->UPeriod();
 601       umin += delta/2.;
 602       umax -= delta/2;
 603     }
 604   }
 605   //
 606   if(!aS->IsVPeriodic())
 607   {
 608     vmin = Max(aVmin, vmin);
 609     vmax = Min(aVmax, vmax);
 610   }
 611   else
 612   {
 613     if(vmax - vmin > aS->VPeriod())
 614     {
 615       Standard_Real delta = vmax - vmin - aS->VPeriod();
 616       vmin += delta/2.;
 617       vmax -= delta/2;
 618     }
 619   }
 620 }
 621 //=======================================================================
 622 //function : Reorder
 623 //purpose  :
 624 //=======================================================================
 625 inline void Reorder(Standard_Real& a, Standard_Real& b)
 626 {
 627   if(a > b)
 628   {
 629     Standard_Real t = a;
 630     a = b;
 631     b = t;
 632   }
 633 }
 634 //=======================================================================
 635 //function : IsModifySize
 636 //purpose  :
 637 //=======================================================================
 638 Standard_Boolean IsModifySize(const BRepAdaptor_Surface& theBS,
 639                               const gp_Pln& thePln, const gp_Pnt& theP,
 640                               const Standard_Real umin, const Standard_Real umax,
 641                               const Standard_Real vmin, const Standard_Real vmax,
 642                               const BRepTopAdaptor_FClass2d& theFClass,
 643                               const Standard_Real theTolU, const Standard_Real theTolV)
 644 {
 645   Standard_Real pu1 = 0, pu2, pv1 = 0, pv2;
 646   ElSLib::PlaneParameters(thePln.Position(), theP, pu2, pv2);
 647   Reorder(pu1, pu2);
 648   Reorder(pv1, pv2);
 649   Handle(Geom_Plane) aPlane = new Geom_Plane(thePln);
 650   GeomAdaptor_Surface aGAPln(aPlane, pu1, pu2, pv1, pv2);
 651   Extrema_ExtSS anExtr(aGAPln, theBS, pu1, pu2, pv1, pv2, umin, umax, vmin, vmax, theTolU, theTolV);
 652   if(anExtr.IsDone())
 653   {
 654     if(anExtr.NbExt() > 0)
 655     {
 656       Standard_Integer i, imin = 0;
 657       Standard_Real dmin = RealLast();
 658       Standard_Real uextr = 0., vextr = 0.;
 659       Extrema_POnSurf P1, P2;
 660       for(i = 1; i <= anExtr.NbExt(); ++i)
 661       {
 662         Standard_Real d = anExtr.SquareDistance(i);
 663         if(d < dmin)
 664         {
 665           imin = i;
 666           dmin = d;
 667         }
 668       }
 669       if(imin > 0)
 670       {
 671         anExtr.Points(imin, P1, P2);
 672         P2.Parameter(uextr, vextr);
 673       }
 674       else
 675       {
 676         return Standard_False;
 677       }
 678       //
 679       gp_Pnt2d aP2d(uextr, vextr);
 680       TopAbs_State aSt = theFClass.Perform(aP2d);
 681       if(aSt != TopAbs_IN)
 682       {
 683         return Standard_True;
 684       }
 685     }
 686     else
 687     {
 688       return Standard_True; //extrema point seems to be out of face UV bounds
 689     }
 690   }
 691   //
 692   return Standard_False;
 693 }
 694 //
 695 //=======================================================================
 696 //function : AdjustFaceBox
 697 //purpose  :
 698 //=======================================================================
 699 void AdjustFaceBox(const BRepAdaptor_Surface& BS,
 700                    const Standard_Real umin, const Standard_Real umax,
 701                    const Standard_Real vmin, const Standard_Real vmax,
 702                    Bnd_Box& FaceBox,
 703                    const Bnd_Box& EdgeBox, const Standard_Real Tol)
 704 {
 705   Standard_Real fxmin, fymin, fzmin, fxmax, fymax, fzmax;
 706   Standard_Real exmin, eymin, ezmin, exmax, eymax, ezmax;
 707   //
 708   FaceBox.Get(fxmin, fymin, fzmin, fxmax, fymax, fzmax);
 709   EdgeBox.Get(exmin, eymin, ezmin, exmax, eymax, ezmax);
 710   //
 711   Standard_Real TolU = Max(BS.UResolution(Tol), Precision::PConfusion());
 712   Standard_Real TolV = Max(BS.VResolution(Tol), Precision::PConfusion());
 713   BRepTopAdaptor_FClass2d FClass(BS.Face(), Max(TolU, TolV));
 714   //
 715   Standard_Boolean isModified = Standard_False;
 716   if(exmin > fxmin)
 717   {
 718     //
 719     gp_Pln pl(gp_Ax3(gp_Pnt(fxmin, fymin, fzmin), gp::DX()));
 720     gp_Pnt aP(fxmin, fymax, fzmax);
 721     if(IsModifySize(BS, pl, aP,
 722                     umin, umax, vmin, vmax, FClass, TolU, TolV))
 723     {
 724       fxmin = exmin;
 725       isModified = Standard_True;
 726     }
 727   }
 728   if(exmax < fxmax)
 729   {
 730     //
 731     gp_Pln pl(gp_Ax3(gp_Pnt(fxmax, fymax, fzmax), gp::DX()));
 732     gp_Pnt aP(fxmax, fymin, fzmin);
 733     if(IsModifySize(BS, pl, aP,
 734                     umin, umax, vmin, vmax, FClass, TolU, TolV))
 735     {
 736       fxmax = exmax;
 737       isModified = Standard_True;
 738     }
 739   }
 740   //
 741   if(eymin > fymin)
 742   {
 743     //
 744     gp_Pln pl(gp_Ax3(gp_Pnt(fxmin, fymin, fzmin), gp::DY()));
 745     gp_Pnt aP(fxmax, fymin, fzmax);
 746     if(IsModifySize(BS, pl, aP,
 747                     umin, umax, vmin, vmax, FClass, TolU, TolV))
 748     {
 749       fymin = eymin;
 750       isModified = Standard_True;
 751     }
 752   }
 753   if(eymax < fymax)
 754   {
 755     //
 756     gp_Pln pl(gp_Ax3(gp_Pnt(fxmax, fymax, fzmax), gp::DY()));
 757     gp_Pnt aP(fxmin, fymax, fzmin);
 758     if(IsModifySize(BS, pl, aP,
 759                     umin, umax, vmin, vmax, FClass, TolU, TolV))
 760     {
 761       fymax = eymax;
 762       isModified = Standard_True;
 763     }
 764   }
 765   //
 766   if(ezmin > fzmin)
 767   {
 768     //
 769     gp_Pln pl(gp_Ax3(gp_Pnt(fxmin, fymin, fzmin), gp::DZ()));
 770     gp_Pnt aP(fxmax, fymax, fzmin);
 771     if(IsModifySize(BS, pl, aP,
 772                     umin, umax, vmin, vmax, FClass, TolU, TolV))
 773     {
 774       fzmin = ezmin;
 775       isModified = Standard_True;
 776     }
 777   }
 778   if(ezmax < fzmax)
 779   {
 780     //
 781     gp_Pln pl(gp_Ax3(gp_Pnt(fxmax, fymax, fzmax), gp::DZ()));
 782     gp_Pnt aP(fxmin, fymin, fzmax);
 783     if(IsModifySize(BS, pl, aP,
 784                     umin, umax, vmin, vmax, FClass, TolU, TolV))
 785     {
 786       fzmax = ezmax;
 787       isModified = Standard_True;
 788     }
 789   }
 790   //
 791   if(isModified)
 792   {
 793     FaceBox.SetVoid();
 794     FaceBox.Update(fxmin, fymin, fzmin, fxmax, fymax, fzmax);
 795   }
 796 }
 797