src/GeomAlgoAPI/GeomAlgoAPI_Filling.cpp

   1 // Copyright (C) 2017-20xx  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or
  18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
  19 //
  20
  21 #include "GeomAlgoAPI_Filling.h"
  22
  23 #include <BRep_Tool.hxx>
  24 #include <BRepBuilderAPI_MakeFace.hxx>
  25 #include <Geom_BSplineCurve.hxx>
  26 #include <Geom_BSplineSurface.hxx>
  27 #include <Geom_TrimmedCurve.hxx>
  28 #include <GeomAPI_PointsToBSplineSurface.hxx>
  29 #include <GeomFill_AppSurf.hxx>
  30 #include <GeomFill_Line.hxx>
  31 #include <GeomFill_SectionGenerator.hxx>
  32 #include <Precision.hxx>
  33 #include <ShapeFix_Face.hxx>
  34 #include <TopoDS_Edge.hxx>
  35 #include <TopoDS_Face.hxx>
  36
  37 static void edgesToCurves(const std::list<GeomEdgePtr>& theEdges,
  38                           std::list<Handle(Geom_Curve)>& theCurves)
  39 {
  40   for (std::list<GeomEdgePtr>::const_iterator anIt = theEdges.begin();
  41        anIt != theEdges.end(); ++anIt) {
  42     const TopoDS_Edge& anEdge = (*anIt)->impl<TopoDS_Edge>();
  43     if (BRep_Tool::Degenerated(anEdge))
  44       continue;
  45
  46     double aFirst, aLast;
  47     Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, aFirst, aLast);
  48
  49     aCurve = new Geom_TrimmedCurve(aCurve, aFirst, aLast);
  50     if (anEdge.Orientation() == TopAbs_REVERSED)
  51       aCurve->Reverse();
  52
  53     theCurves.push_back(aCurve);
  54   }
  55 }
  56
  57
  58 GeomAlgoAPI_Filling::GeomAlgoAPI_Filling(const int theMinDegree,
  59                                          const int theMaxDegree,
  60                                          const int theNbIter,
  61                                          const double theTol2D,
  62                                          const double theTol3D)
  63   : myMinDegree(theMinDegree),
  64     myMaxDegree(theMaxDegree),
  65     myNbIter(theNbIter),
  66     myTol2D(theTol2D),
  67     myTol3D(theTol3D)
  68 {
  69 }
  70
  71 void GeomAlgoAPI_Filling::add(const GeomEdgePtr theEdge)
  72 {
  73   myConstraints.push_back(theEdge);
  74 }
  75
  76 void GeomAlgoAPI_Filling::build(bool isApproximate)
  77 {
  78   if (myConstraints.size() <= 1) // not enough edges
  79     return;
  80
  81   if (isApproximate)
  82     buildByControlPoints();
  83   else
  84     buildByEdges();
  85 }
  86
  87 void GeomAlgoAPI_Filling::buildByEdges()
  88 {
  89   GeomFill_SectionGenerator aSection;
  90
  91   // obtain section curves
  92   std::list<Handle(Geom_Curve)> aCurves;
  93   edgesToCurves(myConstraints, aCurves);
  94   for (std::list<Handle(Geom_Curve)>::iterator anIt = aCurves.begin();
  95        anIt != aCurves.end(); ++anIt)
  96     aSection.AddCurve(*anIt);
  97
  98   // a 'tolerance' is used to compare 2 knots
  99   aSection.Perform(Precision::PConfusion());
 100   int aNbCurves = (int)aCurves.size();
 101   Handle(GeomFill_Line) aLine = new GeomFill_Line(aNbCurves);
 102
 103   // check myMaxDegree >= aCurves.size() - 1 to be able to interpolate a surface
 104   if (myMaxDegree + 1 < aNbCurves) {
 105     myError = "Unable to interpolate surface,"
 106        " Max deg + 1 should be greater or equal than number of sections.";
 107     return;
 108   }
 109
 110   // perform filling by sections
 111   GeomFill_AppSurf anAppSurf(myMinDegree, myMaxDegree, myTol3D, myTol2D, myNbIter);
 112   anAppSurf.Perform(aLine, aSection);
 113   if (!anAppSurf.IsDone()) {
 114     myError = "Approximation algorithm failed.";
 115     return;
 116   }
 117
 118   // build calculated surface
 119   Standard_Integer UDegree, VDegree, NbUPoles, NbVPoles, NbUKnots, NbVKnots;
 120   anAppSurf.SurfShape(UDegree, VDegree, NbUPoles, NbVPoles, NbUKnots, NbVKnots);
 121   Handle(Geom_BSplineSurface) GBS = new Geom_BSplineSurface(
 122     anAppSurf.SurfPoles(), anAppSurf.SurfWeights(), anAppSurf.SurfUKnots(), anAppSurf.SurfVKnots(),
 123     anAppSurf.SurfUMults(), anAppSurf.SurfVMults(), anAppSurf.UDegree(), anAppSurf.VDegree());
 124
 125   if (GBS.IsNull())
 126     return;
 127
 128   // store result
 129   TopoDS_Face aFace = BRepBuilderAPI_MakeFace(GBS, Precision::Confusion());
 130   std::shared_ptr<GeomAPI_Shape> aShape(new GeomAPI_Shape());
 131   aShape->setImpl(new TopoDS_Shape(aFace));
 132   setShape(aShape);
 133   setDone(true);
 134 }
 135
 136 static Handle(Geom_Curve) removeTrim(const Handle(Geom_Curve)& theCurve)
 137 {
 138   Handle(Geom_Curve) aCurve = theCurve;
 139   Handle(Geom_TrimmedCurve) aTC = Handle(Geom_TrimmedCurve)::DownCast(aCurve);
 140   while (!aTC.IsNull()) {
 141     aCurve = aTC->BasisCurve();
 142     aTC = Handle(Geom_TrimmedCurve)::DownCast(aCurve);
 143   }
 144   return aCurve;
 145 }
 146
 147 void GeomAlgoAPI_Filling::buildByControlPoints()
 148 {
 149   // obtain section curves
 150   std::list<Handle(Geom_Curve)> aCurves;
 151   edgesToCurves(myConstraints, aCurves);
 152
 153   // compute maximal number of poles in B-spline curves
 154   int aMaxPoles = 0;
 155   std::list<Handle(Geom_Curve)>::iterator anIt = aCurves.begin();
 156   for (; anIt != aCurves.end(); ++anIt) {
 157     Handle(Geom_BSplineCurve) aBC = Handle(Geom_BSplineCurve)::DownCast(removeTrim(*anIt));
 158     if (!aBC.IsNull())
 159       aMaxPoles = Max(aMaxPoles, aBC->NbPoles());
 160   }
 161
 162   // prepare array of points for creation bspline surface
 163   // size of this array: by U parameter - number of curves,
 164   // by V parameter - determ using MaxNbPoles but it's
 165   // value must be between 21(min) and 101(max)
 166   int aNbSections = (int) aCurves.size();
 167   int aNbPntInSection = Max(21, 2 * aMaxPoles - 1);
 168   TColgp_Array2OfPnt aPoints(1, aNbSections, 1, aNbPntInSection);
 169   anIt = aCurves.begin();
 170   for (int i = 1; anIt != aCurves.end(); ++i, ++anIt) {
 171     Handle(Geom_Curve) aC = *anIt;
 172     double fp = aC->FirstParameter();
 173     double lp = aC->LastParameter();
 174     double dp = (lp - fp) / (aNbPntInSection - 1);
 175
 176     gp_Pnt aPnt;
 177     for (int j = 0; j < aNbPntInSection; j++) {
 178       aC->D0(fp + dp * j, aPnt);
 179       aPoints.SetValue(i, j+1, aPnt);
 180     }
 181   }
 182
 183   // convert a grid of points to B-spline surface
 184   GeomAPI_PointsToBSplineSurface aPTB(aPoints, myMinDegree, myMaxDegree, GeomAbs_C2, myTol3D);
 185   Handle(Geom_BSplineSurface) aBS = aPTB.Surface();
 186   if (aBS.IsNull())
 187     return;
 188
 189   // fix face orientation
 190   TopoDS_Face aFace = BRepBuilderAPI_MakeFace(aBS, Precision::Confusion());
 191   Handle(ShapeFix_Face) aFix = new ShapeFix_Face(aFace);
 192   aFix->Perform();
 193   aFix->FixOrientation();
 194   aFace = aFix->Face();
 195
 196   // store result
 197   std::shared_ptr<GeomAPI_Shape> aShape(new GeomAPI_Shape());
 198   aShape->setImpl(new TopoDS_Shape(aFace));
 199   setShape(aShape);
 200   setDone(true);
 201 }