src/StdMeshers/StdMeshers_ProjectionUtils.hxx

   1 // Copyright (C) 2007-2013  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.
  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
  23 //  SMESH SMESH : idl implementation based on 'SMESH' unit's calsses
  24 // File      : StdMeshers_ProjectionUtils.hxx
  25 // Created   : Thu Oct 26 15:37:24 2006
  26 // Author    : Edward AGAPOV (eap)
  27 //
  28 #ifndef StdMeshers_ProjectionUtils_HeaderFile
  29 #define StdMeshers_ProjectionUtils_HeaderFile
  30
  31 #include "SMESH_StdMeshers.hxx"
  32
  33 #include <TopTools_DataMapOfShapeShape.hxx>
  34 #include <TopoDS_Edge.hxx>
  35 #include <TopoDS_Vertex.hxx>
  36 #include <TopoDS_Face.hxx>
  37
  38 #include <list>
  39 #include <map>
  40
  41 class SMDS_MeshNode;
  42 class SMESH_Algo;
  43 class SMESH_Hypothesis;
  44 class SMESH_Mesh;
  45 class SMESH_subMesh;
  46 class TopTools_IndexedDataMapOfShapeListOfShape;
  47 class TopoDS_Shape;
  48
  49 /*!
  50  * \brief Struct used instead of a sole TopTools_DataMapOfShapeShape to avoid
  51  *        problems with bidirectional bindings
  52  */
  53 struct StdMeshers_ShapeShapeBiDirectionMap
  54 {
  55   TopTools_DataMapOfShapeShape _map1to2, _map2to1;
  56
  57   // convention: s1 - target, s2 - source
  58   bool Bind( const TopoDS_Shape& s1, const TopoDS_Shape& s2 )
  59   { _map1to2.Bind( s1, s2 ); return _map2to1.Bind( s2, s1 ); }
  60   bool IsBound( const TopoDS_Shape& s, const bool isShape2=false ) const
  61   { return (isShape2 ? _map2to1 : _map1to2).IsBound( s ); }
  62   bool IsEmpty() const { return _map1to2.IsEmpty(); }
  63   int  Extent()  const { return _map1to2.Extent(); }
  64   void Clear() { _map1to2.Clear(); _map2to1.Clear(); }
  65   const TopoDS_Shape& operator()( const TopoDS_Shape& s, const bool isShape2=false ) const
  66   { // if we get a Standard_NoSuchObject here, it means that the calling code
  67     // passes incorrect isShape2
  68     return (isShape2 ? _map2to1 : _map1to2)( s );
  69   }
  70 };
  71
  72 /*!
  73  * \brief Methods common to Projection algorithms
  74  */
  75 namespace StdMeshers_ProjectionUtils
  76 {
  77   typedef StdMeshers_ShapeShapeBiDirectionMap                  TShapeShapeMap;
  78   typedef TopTools_IndexedDataMapOfShapeListOfShape            TAncestorMap;
  79   typedef std::map<const SMDS_MeshNode*, const SMDS_MeshNode*> TNodeNodeMap;
  80
  81   /*!
  82    * \brief Looks for association of all sub-shapes of two shapes
  83    * \param theShape1 - shape 1
  84    * \param theMesh1 - mesh built on shape 1
  85    * \param theShape2 - shape 2
  86    * \param theMesh2 - mesh built on shape 2
  87    * \param theAssociation - association map to be filled that may
  88    *                         contain association of one or two pairs of vertices
  89    * \retval bool - true if association found
  90    */
  91   bool FindSubShapeAssociation(const TopoDS_Shape& theShape1,
  92                                SMESH_Mesh*         theMesh1,
  93                                const TopoDS_Shape& theShape2,
  94                                SMESH_Mesh*         theMesh2,
  95                                TShapeShapeMap &    theAssociationMap);
  96
  97   /*!
  98    * \brief Find association of edges of faces
  99    * \param face1 - face 1
 100    * \param VV1 - vertices of face 1
 101    * \param face2 - face 2
 102    * \param VV2 - vertices of face 2 associated with oned of face 1
 103    * \param edges1 - out list of edges of face 1
 104    * \param edges2 - out list of edges of face 2
 105    * \retval int - nb of edges in an outer wire in a success case, else zero
 106    */
 107   int FindFaceAssociation(const TopoDS_Face&         face1,
 108                           TopoDS_Vertex              VV1[2],
 109                           const TopoDS_Face&         face2,
 110                           TopoDS_Vertex              VV2[2],
 111                           std::list< TopoDS_Edge > & edges1,
 112                           std::list< TopoDS_Edge > & edges2);
 113
 114   /*!
 115    * \brief Insert vertex association defined by a hypothesis into a map
 116    * \param theHyp - hypothesis
 117    * \param theAssociationMap - association map
 118    * \param theTargetShape - the shape theHyp assigned to
 119    */
 120   void InitVertexAssociation( const SMESH_Hypothesis* theHyp,
 121                               TShapeShapeMap &        theAssociationMap);
 122
 123   /*!
 124    * \brief Inserts association theShape1 <-> theShape2 to TShapeShapeMap
 125    * \param theShape1 - target shape
 126    * \param theShape2 - source shape
 127    * \param theAssociationMap - association map
 128    * \param theBidirectional - if false, inserts theShape1 -> theShape2 association
 129    * \retval bool - true if there was no association for these shapes before
 130    */
 131   bool InsertAssociation( const TopoDS_Shape& theShape1, // target
 132                           const TopoDS_Shape& theShape2, // source
 133                           TShapeShapeMap &    theAssociationMap);
 134
 135   /*!
 136    * \brief Finds an edge by its vertices in a main shape of the mesh
 137    */
 138   TopoDS_Edge GetEdgeByVertices( SMESH_Mesh*          aMesh,
 139                                  const TopoDS_Vertex& V1,
 140                                  const TopoDS_Vertex& V2);
 141
 142   /*!
 143    * \brief Return another face sharing an edge
 144    * \param edgeToFaces - data map of descendants to ancestors
 145    */
 146   TopoDS_Face GetNextFace( const TAncestorMap& edgeToFaces,
 147                            const TopoDS_Edge&  edge,
 148                            const TopoDS_Face&  face);
 149   /*!
 150    * \brief Return other vertex of an edge
 151    */
 152   TopoDS_Vertex GetNextVertex(const TopoDS_Edge&   edge,
 153                               const TopoDS_Vertex& vertex);
 154
 155   /*!
 156    * \brief Return an oriented propagation edge
 157    * \param aMesh - mesh
 158    * \param fromEdge - start edge for propagation
 159    * \retval pair<int,TopoDS_Edge> - propagation step and found edge
 160    */
 161   std::pair<int,TopoDS_Edge> GetPropagationEdge( SMESH_Mesh*        aMesh,
 162                                                  const TopoDS_Edge& anEdge,
 163                                                  const TopoDS_Edge& fromEdge);
 164
 165   /*!
 166    * \brief Find corresponding nodes on two faces
 167    * \param face1 - the first face
 168    * \param mesh1 - mesh containing elements on the first face
 169    * \param face2 - the second face
 170    * \param mesh2 - mesh containing elements on the second face
 171    * \param assocMap - map associating sub-shapes of the faces
 172    * \param nodeIn2OutMap - map containing found matching nodes
 173    * \retval bool - is a success
 174    */
 175   bool FindMatchingNodesOnFaces( const TopoDS_Face&     face1,
 176                                  SMESH_Mesh*            mesh1,
 177                                  const TopoDS_Face&     face2,
 178                                  SMESH_Mesh*            mesh2,
 179                                  const TShapeShapeMap & assocMap,
 180                                  TNodeNodeMap &         nodeIn2OutMap);
 181   /*!
 182    * \brief Return any sub-shape of a face belonging to the outer wire
 183    * \param face - the face
 184    * \param type - type of sub-shape to return
 185    * \retval TopoDS_Shape - the found sub-shape
 186    */
 187   TopoDS_Shape OuterShape( const TopoDS_Face& face,
 188                            TopAbs_ShapeEnum   type);
 189
 190   /*!
 191    * \brief Check that submeshis is computed and try to compute it if is not
 192    * \param sm - submesh to compute
 193    * \param iterationNb - int used to stop infinite recursive call
 194    * \retval bool - true if computed
 195    */
 196   bool MakeComputed(SMESH_subMesh * sm, const int iterationNb = 0);
 197
 198   /*!
 199    * \brief Returns an error message to show in case if MakeComputed( sm ) fails.
 200    */
 201   std::string SourceNotComputedError( SMESH_subMesh * sm = 0,
 202                                       SMESH_Algo*     projAlgo=0);
 203
 204   /*!
 205    * \brief Set event listeners to submesh with projection algo
 206    * \param subMesh - submesh with projection algo
 207    * \param srcShape - source shape
 208    * \param srcMesh - source mesh
 209    */
 210   void SetEventListener(SMESH_subMesh* subMesh,
 211                         TopoDS_Shape   srcShape,
 212                         SMESH_Mesh*    srcMesh);
 213
 214   /*!
 215    * \brief Return a boundary EDGE (or all boundary EDGEs) of edgeContainer
 216    */
 217   TopoDS_Edge GetBoundaryEdge(const TopoDS_Shape&       edgeContainer,
 218                               const SMESH_Mesh&         mesh,
 219                               std::list< TopoDS_Edge >* allBndEdges = 0 );
 220 };
 221
 222 #endif