src/SMESHUtils/SMESH_MAT2d.hxx

   1 // Copyright (C) 2007-2015  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 // File      : SMESH_MAT2d.hxx
  23 // Created   : Thu May 28 17:49:53 2015
  24 // Author    : Edward AGAPOV (eap)
  25
  26 #ifndef __SMESH_MAT2d_HXX__
  27 #define __SMESH_MAT2d_HXX__
  28
  29 #include "SMESH_Utils.hxx"
  30
  31 #include <TopoDS_Face.hxx>
  32 #include <TopoDS_Edge.hxx>
  33
  34 #include <vector>
  35 #include <map>
  36
  37 #include <boost/polygon/polygon.hpp>
  38 #include <boost/polygon/voronoi.hpp>
  39
  40 class Adaptor3d_Curve;
  41
  42 // Medial Axis Transform 2D
  43 namespace SMESH_MAT2d
  44 {
  45   class MedialAxis; // MedialAxis is the entry point
  46   class Branch;
  47   class BranchEnd;
  48   class Boundary;
  49   struct BoundaryPoint;
  50
  51   typedef boost::polygon::voronoi_diagram<double> TVD;
  52   typedef TVD::cell_type                          TVDCell;
  53   typedef TVD::edge_type                          TVDEdge;
  54   typedef TVD::vertex_type                        TVDVertex;
  55
  56   //-------------------------------------------------------------------------------------
  57   // type of Branch end point
  58   enum BranchEndType { BE_UNDEF,
  59                        BE_ON_VERTEX, // branch ends at a convex VRTEX
  60                        BE_BRANCH_POINT, // branch meats 2 or more other branches
  61                        BE_END // branch end equidistant from several adjacent segments
  62   };
  63   //-------------------------------------------------------------------------------------
  64   /*!
  65    * \brief End point of MA Branch
  66    */
  67   struct SMESHUtils_EXPORT BranchEnd
  68   {
  69     const TVDVertex*             _vertex;
  70     BranchEndType                _type;
  71     std::vector< const Branch* > _branches;
  72
  73     BranchEnd(): _vertex(0), _type( BE_UNDEF ) {}
  74   };
  75   //-------------------------------------------------------------------------------------
  76   /*!
  77    * \brief Point on MA Branch
  78    */
  79   struct SMESHUtils_EXPORT BranchPoint
  80   {
  81     const Branch* _branch;
  82     std::size_t   _iEdge; // MA edge index within the branch
  83     double        _edgeParam; // normalized param within the MA edge
  84
  85     BranchPoint(): _branch(0), _iEdge(0), _edgeParam(-1) {}
  86   };
  87   //-------------------------------------------------------------------------------------
  88   /*!
  89    * \brief Branch is a set of MA edges enclosed between branch points and/or MA ends.
  90    *        It's main feature is to return two BoundaryPoint's per a point on it.
  91    */
  92   class SMESHUtils_EXPORT Branch
  93   {
  94   public:
  95     bool getBoundaryPoints(double param, BoundaryPoint& bp1, BoundaryPoint& bp2 ) const;
  96     bool getBoundaryPoints(std::size_t iMAEdge, double maEdgeParam,
  97                            BoundaryPoint& bp1, BoundaryPoint& bp2 ) const;
  98     bool getBoundaryPoints(const BranchPoint& p,
  99                            BoundaryPoint& bp1, BoundaryPoint& bp2 ) const;
 100     bool getParameter(const BranchPoint& p, double & u ) const;
 101
 102     std::size_t      nbEdges() const { return _maEdges.size(); }
 103
 104     const BranchEnd* getEnd(bool the2nd) const { return & ( the2nd ? _endPoint2 : _endPoint1 ); }
 105
 106     bool hasEndOfType(BranchEndType type) const;
 107
 108     void getPoints( std::vector< gp_XY >& points, const double scale[2]) const;
 109
 110     void getGeomEdges( std::vector< std::size_t >& edgeIDs1,
 111                        std::vector< std::size_t >& edgeIDs2 ) const;
 112
 113     void getOppositeGeomEdges( std::vector< std::size_t >& edgeIDs1,
 114                                std::vector< std::size_t >& edgeIDs2,
 115                                std::vector< BranchPoint >& divPoints) const;
 116
 117     // construction
 118     void init( std::vector<const TVDEdge*>&                maEdges,
 119                const Boundary*                             boundary,
 120                std::map< const TVDVertex*, BranchEndType > endType);
 121     void setBranchesToEnds( const std::vector< Branch >&   branches);
 122
 123     static void setGeomEdge( std::size_t geomIndex, const TVDEdge* maEdge );
 124     static std::size_t getGeomEdge( const TVDEdge* maEdge );
 125     static void setBndSegment( std::size_t segIndex, const TVDEdge* maEdge );
 126     static std::size_t getBndSegment( const TVDEdge* maEdge );
 127
 128   private:
 129
 130     bool addDivPntForConcaVertex( std::vector< std::size_t >&        edgeIDs1,
 131                                   std::vector< std::size_t >&        edgeIDs2,
 132                                   std::vector< BranchPoint >&        divPoints,
 133                                   const std::vector<const TVDEdge*>& maEdges,
 134                                   const std::vector<const TVDEdge*>& maEdgesTwin,
 135                                   size_t &                           i) const;
 136
 137     // association of _maEdges with boundary segments is stored in this way:
 138     // index of an EDGE:           TVDEdge->cell()->color()
 139     // index of a segment on EDGE: TVDEdge->color()
 140     std::vector<const TVDEdge*> _maEdges; // MA edges ending at points located at _params
 141     std::vector<double>  _params; // params of points on MA, normalized [0;1] within this branch
 142     const Boundary*      _boundary; // face boundary
 143     BranchEnd            _endPoint1;
 144     BranchEnd            _endPoint2;
 145   };
 146
 147   //-------------------------------------------------------------------------------------
 148   /*!
 149    * \brief Data of a discretized EDGE allowing to get a point on MA by a parameter on EDGE
 150    */
 151   struct BndPoints
 152   {
 153     std::vector< double > _params; // params of discretization points on an EDGE
 154     std::vector< std::pair< const Branch*, int > > _maEdges; /* index of TVDEdge in branch;
 155                                                                 index sign means orientation;
 156                                                                 index == Branch->nbEdges() means
 157                                                                 end point of a Branch */
 158   };
 159   //-------------------------------------------------------------------------------------
 160   /*!
 161    * \brief Face boundary is discretized so that each its segment to correspond to
 162    *        an edge of MA
 163    */
 164   class SMESHUtils_EXPORT Boundary
 165   {
 166   public:
 167
 168     Boundary( std::size_t nbEdges ): _pointsPerEdge( nbEdges ) {}
 169     BndPoints&  getPoints( std::size_t iEdge ) { return _pointsPerEdge[ iEdge ]; }
 170     std::size_t nbEdges() const { return _pointsPerEdge.size(); }
 171
 172     bool getPoint( std::size_t iEdge, std::size_t iSeg, double u, BoundaryPoint& bp ) const;
 173
 174     bool getBranchPoint( const std::size_t iEdge, double u, BranchPoint& p ) const;
 175
 176     bool IsConcaveSegment( std::size_t iEdge, std::size_t iSeg ) const;
 177
 178   private:
 179     std::vector< BndPoints > _pointsPerEdge;
 180   };
 181
 182   //-------------------------------------------------------------------------------------
 183   /*!
 184    * \brief Point on FACE boundary
 185    */
 186   struct SMESHUtils_EXPORT BoundaryPoint
 187   {
 188     std::size_t _edgeIndex; // index of an EDGE in a sequence passed to MedialAxis()
 189     double      _param;     // parameter of this EDGE
 190   };
 191   //-------------------------------------------------------------------------------------
 192   /*!
 193    * \brief Medial axis (MA) is defined as the loci of centres of locally
 194    *        maximal balls inside 2D representation of a face. This class
 195    *        implements a piecewise approximation of MA.
 196    */
 197   class SMESHUtils_EXPORT MedialAxis
 198   {
 199   public:
 200     MedialAxis(const TopoDS_Face&                face,
 201                const std::vector< TopoDS_Edge >& edges,
 202                const double                      minSegLen,
 203                const bool                        ignoreCorners = false );
 204     const Boundary&                        getBoundary() const { return _boundary; }
 205     const std::vector< Branch >&           getBranches() const { return _branch; }
 206     const std::vector< const BranchEnd* >& getBranchPoints() const { return _branchPnt; }
 207
 208     void getPoints( const Branch& branch, std::vector< gp_XY >& points) const;
 209     Adaptor3d_Curve* make3DCurve(const Branch& branch) const;
 210
 211   private:
 212
 213   private:
 214     TopoDS_Face                     _face;
 215     TVD                             _vd;
 216     std::vector< Branch >           _branch;
 217     std::vector< const BranchEnd* > _branchPnt;
 218     Boundary                        _boundary;
 219     double                          _scale[2];
 220   };
 221
 222 }
 223
 224 #endif