src/GeomAlgoAPI/GeomAlgoAPI_SketchBuilder.cpp

   1 // Copyright (C) 2014-2017  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_SketchBuilder.h>
  22 #include <GeomAPI_PlanarEdges.h>
  23
  24 #include <BOPAlgo_Builder.hxx>
  25 #include <BRep_Builder.hxx>
  26 #include <BRepTools_WireExplorer.hxx>
  27 #include <BRepTopAdaptor_FClass2d.hxx>
  28 #include <Geom_Plane.hxx>
  29 #include <Geom_TrimmedCurve.hxx>
  30 #include <Precision.hxx>
  31 #include <TopExp.hxx>
  32 #include <TopExp_Explorer.hxx>
  33 #include <TopoDS.hxx>
  34 #include <TopoDS_Edge.hxx>
  35 #include <TopTools_ListIteratorOfListOfShape.hxx>
  36 #include <GProp_GProps.hxx>
  37 #include <BRepGProp.hxx>
  38
  39 #include <list>
  40 #include <cmath>
  41 #include <algorithm>
  42
  43 static TopoDS_Vertex findStartVertex(const TopoDS_Shape& theShape)
  44 {
  45   static const double aTol = Precision::PConfusion();
  46
  47   TopExp_Explorer anExp(theShape, TopAbs_VERTEX);
  48   TopoDS_Vertex aStart = TopoDS::Vertex(anExp.Current());
  49   gp_Pnt aStartPnt(BRep_Tool::Pnt(aStart));
  50   TopoDS_Vertex aCurrent;
  51   gp_Pnt aCurrentPnt;
  52
  53   for (anExp.Next(); anExp.More(); anExp.Next()) {
  54     aCurrent = TopoDS::Vertex(anExp.Current());
  55     aCurrentPnt = BRep_Tool::Pnt(aCurrent);
  56     if ((aCurrentPnt.X() > aStartPnt.X() + aTol) ||
  57         (aCurrentPnt.X() > aStartPnt.X() - aTol && aCurrentPnt.Y() > aStartPnt.Y() + aTol) ||
  58         (aCurrentPnt.X() > aStartPnt.X() - aTol && aCurrentPnt.Y() > aStartPnt.Y() - aTol &&
  59             aCurrentPnt.Z() > aStartPnt.Z() + aTol)) {
  60       aStart = aCurrent;
  61       aStartPnt = aCurrentPnt;
  62     }
  63   }
  64   return aStart;
  65 }
  66
  67 static TopoDS_Vertex findStartVertex(const TopoDS_Wire& theWire, const TopoDS_Face& theFace,
  68     const std::list<std::shared_ptr<GeomAPI_Shape> >& theInitialShapes)
  69 {
  70   // Try to find edge lying on the one of original edges.
  71   // First found edge will be taken as a start edge for the result wire
  72   std::list<std::shared_ptr<GeomAPI_Shape> >::const_iterator aFeatIt = theInitialShapes.begin();
  73   for (; aFeatIt != theInitialShapes.end(); aFeatIt++) {
  74     std::shared_ptr<GeomAPI_Shape> aShape(*aFeatIt);
  75     const TopoDS_Edge& anEdge = aShape->impl<TopoDS_Edge>();
  76     if (anEdge.ShapeType() != TopAbs_EDGE)
  77       continue;
  78
  79     double aFirst, aLast;
  80     Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, aFirst, aLast);
  81     if (aCurve->DynamicType() == STANDARD_TYPE(Geom_TrimmedCurve))
  82       aCurve = Handle(Geom_TrimmedCurve)::DownCast(aCurve)->BasisCurve();
  83
  84     BRepTools_WireExplorer anExp(theWire, theFace);
  85     for (; anExp.More(); anExp.Next()) {
  86       const TopoDS_Edge& aShapeEdge = anExp.Current();
  87       double aF, aL;
  88       Handle(Geom_Curve) aShapeCurve = BRep_Tool::Curve(aShapeEdge, aF, aL);
  89       if (aShapeCurve->DynamicType() == STANDARD_TYPE(Geom_TrimmedCurve))
  90         aShapeCurve = Handle(Geom_TrimmedCurve)::DownCast(aShapeCurve)->BasisCurve();
  91
  92       if (aCurve != aShapeCurve)
  93         continue;
  94
  95       // the edge is found, search vertex
  96       TopoDS_Vertex aV1, aV2;
  97       TopExp::Vertices(aShapeEdge, aV1, aV2);
  98       return fabs(aF - aFirst) <= fabs(aL - aFirst) ? aV1 : aV2;
  99     }
 100   }
 101
 102   // start vertex is not found, use algorithm to search vertex with the greatest coordinates
 103   return findStartVertex(theWire);
 104 }
 105
 106 // returns true if the first shape must be located earlier than the second
 107 bool isFirst(const TopoDS_Shape& theFirst, const TopoDS_Shape& theSecond,
 108   NCollection_DataMap<TopoDS_Shape, NCollection_Array1<int> >& theAreaToIndex,
 109   const NCollection_DataMap<Handle(Geom_Curve), int>& theCurveToIndex)
 110 {
 111   // fill theAreaToIndex for both shapes if needed
 112   for(int aShapeNum = 1; aShapeNum <= 2; aShapeNum++) {
 113     TopoDS_Shape aShape = aShapeNum == 1 ? theFirst : theSecond;
 114     if (!theAreaToIndex.IsBound(aShape)) { // fill the list of curve indices
 115       NCollection_List<int> aNewList;
 116       TopExp_Explorer anEdgesExp(aShape, TopAbs_EDGE);
 117       for(; anEdgesExp.More(); anEdgesExp.Next()) {
 118         double aFirst, aLast;
 119         Handle(Geom_Curve) aCurve = BRep_Tool::Curve(
 120           TopoDS::Edge(anEdgesExp.Current()), aFirst, aLast);
 121         if (aCurve->DynamicType() == STANDARD_TYPE(Geom_TrimmedCurve))
 122           aCurve = Handle(Geom_TrimmedCurve)::DownCast(aCurve)->BasisCurve();
 123         if (theCurveToIndex.IsBound(aCurve)) {
 124           aNewList.Append(theCurveToIndex.Find(aCurve));
 125         }
 126       }
 127       NCollection_Array1<int> aNewArray(1, aNewList.Extent());
 128       NCollection_List<int>::Iterator aListIter(aNewList);
 129       for(int anIndex = 1; aListIter.More(); aListIter.Next(), anIndex++) {
 130         aNewArray.SetValue(anIndex, aListIter.Value());
 131       }
 132       std::sort(aNewArray.begin(), aNewArray.end());
 133       theAreaToIndex.Bind(aShape, aNewArray);
 134     }
 135   }
 136   // compare lists of indices one by one to find chich list indices are lower
 137   NCollection_Array1<int>::Iterator aFirstList(theAreaToIndex.ChangeFind(theFirst));
 138   NCollection_Array1<int>::Iterator aSecondList(theAreaToIndex.ChangeFind(theSecond));
 139   for(; aFirstList.More() && aSecondList.More(); aFirstList.Next(), aSecondList.Next()) {
 140     if (aFirstList.Value() < aSecondList.Value()) return true;
 141     if (aFirstList.Value() > aSecondList.Value()) return false;
 142   }
 143   // if faces are identical by curves names (circle splitted by line in seam-point), use parameters
 144   if (!aFirstList.More() && !aSecondList.More()) {
 145     GProp_GProps aGProps;
 146     BRepGProp::SurfaceProperties(theFirst, aGProps);
 147     gp_Pnt aCentre1 = aGProps.CentreOfMass();
 148     BRepGProp::SurfaceProperties(theSecond, aGProps);
 149     gp_Pnt aCentre2 = aGProps.CentreOfMass();
 150     return aCentre1.X() + aCentre1.Y() + aCentre1.Z() < aCentre2.X() + aCentre2.Y() + aCentre2.Z();
 151   }
 152   // if in first list there is no elements left, it is the first
 153   return !aFirstList.More();
 154 }
 155
 156 // sorts faces (in theAreas list) to make persistent order: by initial shapes edges
 157 static void sortFaces(TopTools_ListOfShape& theAreas,
 158   const std::list<std::shared_ptr<GeomAPI_Shape> >& theInitialShapes)
 159 {
 160   // collect indices of all edges to operate them quickly
 161   NCollection_DataMap<Handle(Geom_Curve), int> aCurveToIndex; // curve -> index in initial shapes
 162   std::list<std::shared_ptr<GeomAPI_Shape> >::const_iterator aFeatIt = theInitialShapes.begin();
 163   for (int anIndex = 0; aFeatIt != theInitialShapes.end(); aFeatIt++) {
 164     std::shared_ptr<GeomAPI_Shape> aShape(*aFeatIt);
 165     const TopoDS_Edge& anEdge = aShape->impl<TopoDS_Edge>();
 166     if (anEdge.ShapeType() != TopAbs_EDGE)
 167       continue;
 168
 169     double aFirst, aLast;
 170     Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, aFirst, aLast);
 171     if (aCurve->DynamicType() == STANDARD_TYPE(Geom_TrimmedCurve))
 172       aCurve = Handle(Geom_TrimmedCurve)::DownCast(aCurve)->BasisCurve();
 173     if (!aCurveToIndex.IsBound(aCurve))
 174       aCurveToIndex.Bind(aCurve, anIndex++);
 175   }
 176   // map from area to the most first indices of curves (to compare) in it
 177   NCollection_DataMap<TopoDS_Shape, NCollection_Array1<int> > anAreaToIndex;
 178   // sort areas
 179   TopTools_ListOfShape::Iterator anArea1(theAreas);
 180   for(; anArea1.More(); anArea1.Next()) {
 181     TopTools_ListOfShape::Iterator anArea2 = anArea1;
 182     for(anArea2.Next(); anArea2.More(); anArea2.Next()) {
 183       if (!isFirst(anArea1.Value(), anArea2.Value(), anAreaToIndex, aCurveToIndex)) { // exchange
 184         TopoDS_Shape aTmp = anArea1.Value();
 185         anArea1.ChangeValue() = anArea2.Value();
 186         anArea2.ChangeValue() = aTmp;
 187       }
 188     }
 189   }
 190 }
 191
 192 void GeomAlgoAPI_SketchBuilder::createFaces(
 193     const std::shared_ptr<GeomAPI_Pnt>& theOrigin,
 194     const std::shared_ptr<GeomAPI_Dir>& theDirX,
 195     const std::shared_ptr<GeomAPI_Dir>& theNorm,
 196     const std::list<std::shared_ptr<GeomAPI_Shape> >& theFeatures,
 197     std::list<std::shared_ptr<GeomAPI_Shape> >& theResultFaces)
 198 {
 199   if (theFeatures.empty())
 200     return;
 201
 202   BRep_Builder aBuilder;
 203   // Planar face, where the sketch was built
 204   Handle(Geom_Surface) aPlane(new Geom_Plane(theOrigin->impl<gp_Pnt>(), theNorm->impl<gp_Dir>()));
 205   TopoDS_Face aPlnFace;
 206   aBuilder.MakeFace(aPlnFace, aPlane, Precision::Confusion());
 207
 208   // Use General Fuse algorithm to prepare all subfaces, bounded by given list of edges
 209   BOPAlgo_Builder aBB;
 210   aBB.AddArgument(aPlnFace);
 211
 212   BOPCol_ListOfShape anEdges;
 213   BOPCol_ListIteratorOfListOfShape aShapeIt;
 214   std::list<std::shared_ptr<GeomAPI_Shape> >::const_iterator aFeatIt = theFeatures.begin();
 215   for (; aFeatIt != theFeatures.end(); aFeatIt++) {
 216     std::shared_ptr<GeomAPI_Shape> aShape(*aFeatIt);
 217     const TopoDS_Edge& anEdge = aShape->impl<TopoDS_Edge>();
 218     if (anEdge.ShapeType() == TopAbs_EDGE)
 219       aBB.AddArgument(anEdge);
 220   }
 221   aBB.Perform();
 222   if (aBB.HasErrors())
 223     return;
 224   // Collect faces
 225   TopTools_ListOfShape anAreas = aBB.Modified(aPlnFace);
 226   sortFaces(anAreas, theFeatures); // sort faces by the edges in them
 227   TopTools_ListIteratorOfListOfShape anIt(anAreas);
 228   for (; anIt.More(); anIt.Next()) {
 229     TopoDS_Face aFace = TopoDS::Face(anIt.Value());
 230     // avoid infinite faces
 231     BRepTopAdaptor_FClass2d aFClass(aFace, Precision::Confusion());
 232     if (aFClass.PerformInfinitePoint() == TopAbs_IN)
 233       continue;
 234
 235     // rebuild face
 236     TopoDS_Face aNewFace;
 237     aBuilder.MakeFace(aNewFace, aPlane, Precision::Confusion());
 238
 239     // iterate on wires
 240     TopExp_Explorer aWireExp(aFace, TopAbs_WIRE);
 241     for (; aWireExp.More(); aWireExp.Next()) {
 242       TopoDS_Wire aWire = TopoDS::Wire(aWireExp.Current());
 243
 244       // to make faces equal on different platforms, we will find
 245       // a vertex lying on an edge with the lowest index in the list of initial edges
 246       TopoDS_Vertex aStartVertex = findStartVertex(aWire, aFace, theFeatures);
 247
 248       TopoDS_Wire aNewWire;
 249       aBuilder.MakeWire(aNewWire);
 250       std::list<TopoDS_Edge> aSkippedEdges;
 251       bool aStartFound = false;
 252
 253       // remove internal edges from faces and make wire start from found vertex
 254       BRepTools_WireExplorer anExp(aWire, aFace);
 255       for (; anExp.More(); anExp.Next()) {
 256         if (anExp.Current().Orientation() == TopAbs_INTERNAL)
 257           continue;
 258         if (!aStartFound) {
 259           const TopoDS_Edge& anEdge = anExp.Current();
 260           TopoDS_Vertex aV1, aV2;
 261           TopExp::Vertices(anEdge, aV1, aV2, Standard_True);
 262           if (aV1.IsSame(aStartVertex) == Standard_True)
 263             aStartFound = true;
 264           else
 265             aSkippedEdges.push_back(anEdge);
 266         }
 267         if (aStartFound)
 268           aBuilder.Add(aNewWire, anExp.Current());
 269       }
 270       // add skipped edges to the end of wire
 271       std::list<TopoDS_Edge>::const_iterator aSkIt = aSkippedEdges.begin();
 272       for (; aSkIt != aSkippedEdges.end(); ++aSkIt)
 273         aBuilder.Add(aNewWire, *aSkIt);
 274
 275       // check the wire is empty
 276       anExp.Init(aNewWire);
 277       if (anExp.More())
 278         aBuilder.Add(aNewFace, aNewWire);
 279     }
 280
 281     // store face
 282     aFace = aNewFace;
 283     std::shared_ptr<GeomAPI_Shape> aResFace(new GeomAPI_Shape);
 284     aResFace->setImpl(new TopoDS_Face(aFace));
 285     theResultFaces.push_back(aResFace);
 286   }
 287 }
 288
 289 void GeomAlgoAPI_SketchBuilder::createFaces(const std::shared_ptr<GeomAPI_Pnt>& theOrigin,
 290                                             const std::shared_ptr<GeomAPI_Dir>& theDirX,
 291                                             const std::shared_ptr<GeomAPI_Dir>& theNorm,
 292                                             const std::shared_ptr<GeomAPI_Shape>& theWire,
 293                                 std::list<std::shared_ptr<GeomAPI_Shape> >& theResultFaces)
 294 {
 295   std::shared_ptr<GeomAPI_PlanarEdges> aWire =
 296     std::dynamic_pointer_cast<GeomAPI_PlanarEdges>(theWire);
 297   if(aWire) {
 298     // Filter wires, return only faces.
 299     createFaces(theOrigin, theDirX, theNorm, aWire->getEdges(), theResultFaces);
 300   } else { // it may be only one circle
 301     std::shared_ptr<GeomAPI_Edge> anEdge = std::dynamic_pointer_cast<GeomAPI_Edge>(theWire);
 302     if (anEdge) {
 303       std::list<std::shared_ptr<GeomAPI_Shape> > aList;
 304       aList.push_back(anEdge);
 305       createFaces(theOrigin, theDirX, theNorm, aList, theResultFaces);
 306     }
 307   }
 308 }