PAL13473 (Build repetitive mesh):

New meshers implemented

src/StdMeshers/Makefile.in

@@ -51,7 +51,18 @@ EXPORT_HEADERS = \
 	StdMeshers_AutomaticLength.hxx \
 	StdMeshers_Distribution.hxx \
 	StdMeshers_QuadranglePreference.hxx \
-	StdMeshers_QuadraticMesh.hxx
+	StdMeshers_QuadraticMesh.hxx \
+	StdMeshers_NumberOfLayers.hxx \
+	StdMeshers_Prism_3D.hxx \
+	StdMeshers_ProjectionSource1D.hxx \
+	StdMeshers_ProjectionSource2D.hxx \
+	StdMeshers_ProjectionSource3D.hxx \
+	StdMeshers_Projection_1D.hxx \
+	StdMeshers_Projection_2D.hxx \
+	StdMeshers_Projection_3D.hxx \
+	StdMeshers_RadialPrism_3D.hxx  \
+	StdMeshers_ProjectionUtils.hxx \
+	StdMeshers_LayerDistribution.hxx
 
 EXPORT_PYSCRIPTS =
 
@@ -78,7 +89,18 @@ LIB_SRC = \
 	StdMeshers_AutomaticLength.cxx \
 	StdMeshers_Distribution.cxx \
 	StdMeshers_QuadranglePreference.cxx \
-	StdMeshers_QuadraticMesh.cxx
+	StdMeshers_QuadraticMesh.cxx \
+	StdMeshers_NumberOfLayers.cxx \
+	StdMeshers_Prism_3D.cxx \
+	StdMeshers_ProjectionSource1D.cxx \
+	StdMeshers_ProjectionSource2D.cxx \
+	StdMeshers_ProjectionSource3D.cxx \
+	StdMeshers_Projection_1D.cxx \
+	StdMeshers_Projection_2D.cxx \
+	StdMeshers_Projection_3D.cxx \
+	StdMeshers_RadialPrism_3D.cxx \
+	StdMeshers_ProjectionUtils.cxx \
+	StdMeshers_LayerDistribution.cxx
 
 LIB_SERVER_IDL = 
 

src/StdMeshers/StdMeshers_LayerDistribution.cxx

@@ -0,0 +1,148 @@
+//  SMESH SMESH : idl implementation based on 'SMESH' unit's classes
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+//  File   : StdMeshers_LayerDistribution.cxx
+//  Author : Edward AGAPOV
+//  Module : SMESH
+//  $Header$
+
+#include "StdMeshers_LayerDistribution.hxx"
+
+#include "utilities.h"
+
+using namespace std;
+
+
+//=============================================================================
+/*!
+ *  StdMeshers_LayerDistribution::StdMeshers_LayerDistribution
+ *
+ *  Constructor
+ */
+//=============================================================================
+
+StdMeshers_LayerDistribution::StdMeshers_LayerDistribution(int hypId, int studyId,
+                                                           SMESH_Gen * gen)
+  : SMESH_Hypothesis(hypId, studyId, gen)
+{
+  _name = "LayerDistribution"; // used by RadialPrism_3D
+  _param_algo_dim = 3; // 3D
+  myHyp = 0;
+}
+
+//=============================================================================
+/*!
+ *  StdMeshers_LayerDistribution::~StdMeshers_LayerDistribution
+ *
+ *  Destructor
+ */
+//=============================================================================
+
+StdMeshers_LayerDistribution::~StdMeshers_LayerDistribution()
+{
+  MESSAGE( "StdMeshers_LayerDistribution::~StdMeshers_LayerDistribution" );
+}
+
+//=============================================================================
+  /*!
+   * \brief Sets  1D hypothesis specifying distribution of layers
+    * \param hyp1D - 1D hypothesis
+   */
+//=============================================================================
+
+void StdMeshers_LayerDistribution::SetLayerDistribution(SMESH_Hypothesis* hyp1D)
+  throw ( SALOME_Exception )
+{
+  if ( myHyp != hyp1D ) {
+    if ( myHyp && hyp1D->GetDim() != 1 )
+      throw SALOME_Exception(LOCALIZED("1D hypothesis is expected"));
+    myHyp = hyp1D;
+  }
+  std::ostringstream os;
+  if ( myHyp )
+    myHyp->SaveTo( os );
+
+  if ( mySavedHyp != os.str() )
+    NotifySubMeshesHypothesisModification();
+
+  mySavedHyp = os.str();
+}
+
+//=============================================================================
+/*!
+ *  Servant saves and loads my hypothesis
+ */
+//=============================================================================
+
+ostream & StdMeshers_LayerDistribution::SaveTo(ostream & save)
+{
+  return save;
+}
+
+//=============================================================================
+/*!
+ *   Servant saves and loads my hypothesis
+ */
+//=============================================================================
+
+istream & StdMeshers_LayerDistribution::LoadFrom(istream & load)
+{
+  return load;
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+ostream & operator <<(ostream & save, StdMeshers_LayerDistribution & hyp)
+{
+  return hyp.SaveTo( save );
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+istream & operator >>(istream & load, StdMeshers_LayerDistribution & hyp)
+{
+  return hyp.LoadFrom( load );
+}
+
+//================================================================================
+/*!
+ * \brief Initialize start and end length by the mesh built on the geometry
+ * \param theMesh - the built mesh
+ * \param theShape - the geometry of interest
+ * \retval bool - true if parameter values have been successfully defined
+ */
+//================================================================================
+
+bool StdMeshers_LayerDistribution::SetParametersByMesh(const SMESH_Mesh*   ,
+                                                       const TopoDS_Shape& )
+{
+  return false;
+}

src/StdMeshers/StdMeshers_LayerDistribution.hxx

@@ -0,0 +1,91 @@
+//  SMESH SMESH : idl implementation based on 'SMESH' unit's calsses
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+//  File   : StdMeshers_LayerDistribution.hxx
+//  Author : Edward AGAPOV
+//  Module : SMESH
+//  $Header$
+
+#ifndef _SMESH_LayerDistribution_HXX_
+#define _SMESH_LayerDistribution_HXX_
+
+#include "SMESH_Hypothesis.hxx"
+#include "Utils_SALOME_Exception.hxx"
+
+#include <string>
+
+class SMESH_Gen;
+
+// =========================================================
+// =========================================================
+/*!
+ * This hypothesis is used by "Radial prism" algorithm.
+ * It specifies 1D hypothesis defining distribution of segments between the internal 
+ * and the external surfaces.
+ */
+// =========================================================
+// =========================================================
+
+class StdMeshers_LayerDistribution:  public SMESH_Hypothesis
+{
+public:
+  // Constructor
+  StdMeshers_LayerDistribution( int hypId, int studyId, SMESH_Gen * gen );
+  // Destructor
+  virtual ~StdMeshers_LayerDistribution();
+
+  /*!
+   * \brief Sets  1D hypothesis specifying distribution of layers
+    * \param hyp1D - 1D hypothesis
+   */
+  void SetLayerDistribution(SMESH_Hypothesis* hyp1D)
+    throw ( SALOME_Exception );
+
+  /*!
+   * \brief Returns 1D hypothesis specifying distribution of layers
+    * \retval SMESH::SMESH_Hypothesis_ptr - 1D hypothesis
+   */
+  SMESH_Hypothesis* GetLayerDistribution() const { return myHyp; }
+
+  virtual std::ostream & SaveTo(std::ostream & save);
+  virtual std::istream & LoadFrom(std::istream & load);
+  friend std::ostream & operator <<(std::ostream & save, StdMeshers_LayerDistribution & hyp);
+  friend std::istream & operator >>(std::istream & load, StdMeshers_LayerDistribution & hyp);
+
+  /*!
+   * \brief Initialize parameters by the mesh built on the geometry
+    * \param theMesh - the built mesh
+    * \param theShape - the geometry of interest
+    * \retval bool - true if parameter values have been successfully defined
+    *
+    * Implementation does noting
+   */
+  virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
+
+protected:
+  SMESH_Hypothesis* myHyp;
+  std::string       mySavedHyp;
+};
+
+#endif
+

src/StdMeshers/StdMeshers_NumberOfLayers.cxx

@@ -0,0 +1,162 @@
+//  SMESH SMESH : idl implementation based on 'SMESH' unit's classes
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+//  File   : StdMeshers_NumberOfLayers.cxx
+//  Author : Edward AGAPOV
+//  Module : SMESH
+//  $Header$
+
+#include "StdMeshers_NumberOfLayers.hxx"
+
+
+#include "utilities.h"
+
+using namespace std;
+
+
+//=============================================================================
+/*!
+ *  StdMeshers_NumberOfLayers::StdMeshers_NumberOfLayers
+ *
+ *  Constructor
+ */
+//=============================================================================
+
+StdMeshers_NumberOfLayers::StdMeshers_NumberOfLayers(int hypId, int studyId,
+                                                     SMESH_Gen * gen)
+  : SMESH_Hypothesis(hypId, studyId, gen)
+{
+  _name = "NumberOfLayers"; // used by RadialPrism_3D
+  _param_algo_dim = 3; // 3D
+  _nbLayers = 1;
+}
+
+//=============================================================================
+/*!
+ *  StdMeshers_NumberOfLayers::~StdMeshers_NumberOfLayers
+ *
+ *  Destructor
+ */
+//=============================================================================
+
+StdMeshers_NumberOfLayers::~StdMeshers_NumberOfLayers()
+{
+  MESSAGE( "StdMeshers_NumberOfLayers::~StdMeshers_NumberOfLayers" );
+}
+
+//=============================================================================
+/*!
+ *  StdMeshers_NumberOfLayers::SetNumberOfLayers
+ *
+ *  Sets <number of segments> parameter value
+ */
+//=============================================================================
+
+void StdMeshers_NumberOfLayers::SetNumberOfLayers(int numberOfLayers)
+  throw ( SALOME_Exception )
+{
+  if ( _nbLayers != numberOfLayers ) {
+    if ( numberOfLayers <= 0 )
+      throw SALOME_Exception(LOCALIZED("numberOfLayers must be positive"));
+    _nbLayers = numberOfLayers;
+
+    NotifySubMeshesHypothesisModification();
+  }
+}
+
+//=============================================================================
+/*!
+ *  StdMeshers_NumberOfLayers::GetNumberOfLayers
+ *
+ *  Returns <number of layers> parameter value
+ */
+//=============================================================================
+
+int StdMeshers_NumberOfLayers::GetNumberOfLayers() const
+{
+  return _nbLayers;
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+ostream & StdMeshers_NumberOfLayers::SaveTo(ostream & save)
+{
+  save << _nbLayers;
+  return save;
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+istream & StdMeshers_NumberOfLayers::LoadFrom(istream & load)
+{
+  bool isOK = true;
+  isOK = (load >> _nbLayers);
+  if (!isOK)
+    load.clear(ios::badbit | load.rdstate());
+  return load;
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+ostream & operator <<(ostream & save, StdMeshers_NumberOfLayers & hyp)
+{
+  return hyp.SaveTo( save );
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+istream & operator >>(istream & load, StdMeshers_NumberOfLayers & hyp)
+{
+  return hyp.LoadFrom( load );
+}
+
+//================================================================================
+/*!
+ * \brief Initialize start and end length by the mesh built on the geometry
+ * \param theMesh - the built mesh
+ * \param theShape - the geometry of interest
+ * \retval bool - true if parameter values have been successfully defined
+ */
+//================================================================================
+
+bool StdMeshers_NumberOfLayers::SetParametersByMesh(const SMESH_Mesh*   ,
+                                                    const TopoDS_Shape& )
+{
+  return false;
+}

src/StdMeshers/StdMeshers_NumberOfLayers.hxx

@@ -0,0 +1,81 @@
+//  SMESH SMESH : idl implementation based on 'SMESH' unit's calsses
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+//  File   : StdMeshers_NumberOfLayers.hxx
+//  Author : Edward AGAPOV
+//  Module : SMESH
+//  $Header$
+
+#ifndef _SMESH_NumberOfLayers_HXX_
+#define _SMESH_NumberOfLayers_HXX_
+
+#include "SMESH_Hypothesis.hxx"
+#include "Utils_SALOME_Exception.hxx"
+
+class SMESH_Gen;
+
+// =========================================================
+// =========================================================
+/*!
+ * This hypothesis is used by "Radial prism" algorithm.
+ * It specifies number of segments between the internal 
+ * and the external surfaces.
+ */
+// =========================================================
+// =========================================================
+
+class StdMeshers_NumberOfLayers:  public SMESH_Hypothesis
+{
+public:
+  // Constructor
+  StdMeshers_NumberOfLayers( int hypId, int studyId, SMESH_Gen * gen );
+  // Destructor
+  virtual ~StdMeshers_NumberOfLayers();
+
+  // Sets <number of segments> parameter value
+  void SetNumberOfLayers(int numberOfLayers) throw ( SALOME_Exception );
+
+  // Returns <number of layers> parameter value
+  int GetNumberOfLayers() const;
+
+  virtual std::ostream & SaveTo(std::ostream & save);
+  virtual std::istream & LoadFrom(std::istream & load);
+  friend std::ostream & operator <<(std::ostream & save, StdMeshers_NumberOfLayers & hyp);
+  friend std::istream & operator >>(std::istream & load, StdMeshers_NumberOfLayers & hyp);
+
+  /*!
+   * \brief Initialize parameters by the mesh built on the geometry
+    * \param theMesh - the built mesh
+    * \param theShape - the geometry of interest
+    * \retval bool - true if parameter values have been successfully defined
+    *
+    * Implementation does noting
+   */
+  virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
+
+protected:
+  int _nbLayers;
+};
+
+#endif
+

src/StdMeshers/StdMeshers_Prism_3D.hxx

@@ -0,0 +1,425 @@
+//  SMESH SMESH : implementaion of SMESH idl descriptions
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+//  File   : StdMeshers_Prism_3D.hxx
+//  Module : SMESH
+
+#ifndef _SMESH_Prism_3D_HXX_
+#define _SMESH_Prism_3D_HXX_
+
+#include "SMESH_3D_Algo.hxx"
+#include "SMDS_TypeOfPosition.hxx"
+#include "SMDS_MeshNode.hxx"
+#include "SMESH_Block.hxx"
+#include "SMESH_Mesh.hxx"
+#include "SMESHDS_Mesh.hxx"
+#include "SMESH_subMesh.hxx"
+#include "SMESH_MesherHelper.hxx"
+
+#include <vector.h>
+#include <map.h>
+
+#include <Adaptor3d_Curve.hxx>
+#include <Adaptor3d_Surface.hxx>
+#include <Adaptor2d_Curve2d.hxx>
+#include <BRepAdaptor_Surface.hxx>
+#include <TopTools_IndexedMapOfOrientedShape.hxx>
+#include <gp_XYZ.hxx>
+
+
+class SMESHDS_SubMesh;
+class TopoDS_Edge;
+class TopoDS_Faces;
+struct TNode;
+
+//typedef std::map<const SMDS_MeshNode*, const SMDS_MeshNode*> TNodeNodeMap;
+typedef std::vector<const SMDS_MeshNode* > TNodeColumn;
+
+// map of bottom nodes to the column of nodes above them
+// (the column includes the bottom nodes)
+typedef std::map< TNode, TNodeColumn > TNode2ColumnMap;
+typedef std::map< double, TNodeColumn > TParam2ColumnMap;
+typedef std::map< double, TNodeColumn >::const_iterator TParam2ColumnIt;
+
+typedef TopTools_IndexedMapOfOrientedShape TBlockShapes;
+
+// ===============================================
+/*!
+ * \brief Structure containing node relative data
+ */
+// ===============================================
+
+struct TNode
+{
+  const SMDS_MeshNode* myNode;
+  gp_XYZ               myParams;
+
+  gp_XYZ GetCoords() const { return gp_XYZ( myNode->X(), myNode->Y(), myNode->Z() ); }
+  gp_XYZ GetParams() const { return myParams; }
+  gp_XYZ& ChangeParams() { return myParams; }
+  SMDS_TypeOfPosition GetPositionType() const
+  { return myNode ? myNode->GetPosition()->GetTypeOfPosition() : SMDS_TOP_UNSPEC; }
+
+  TNode(const SMDS_MeshNode* node = 0): myNode(node) {}
+  bool operator < (const TNode& other) const { return myNode < other.myNode; }
+};
+
+// ===============================================================
+/*!
+ * \brief Tool analyzing and giving access to a prism geometry 
+ *  treating it like a block, i.e. the four side faces are
+ *  emulated by division/uniting of missing/excess faces.
+ *  It also manage associations between block subshapes and a mesh.
+ */
+// ===============================================================
+
+class StdMeshers_PrismAsBlock: public SMESH_Block
+{
+public:
+  /*!
+   * \brief Constructor. Initialization is needed
+   */
+  StdMeshers_PrismAsBlock();
+
+  ~StdMeshers_PrismAsBlock();
+
+  /*!
+   * \brief Initialization.
+    * \param helper - helper loaded with mesh and 3D shape
+    * \param shape3D - a closed shell or solid
+    * \retval bool - false if a mesh or a shape are KO
+    *
+    * Analyse shape geometry and mesh.
+    * If there are triangles on one of faces, it becomes 'bottom'
+   */
+  bool Init(SMESH_MesherHelper* helper, const TopoDS_Shape& shape3D);
+
+  /*!
+   * \brief Return number of nodes on every vertical edge
+    * \retval int - number of nodes including end nodes
+   */
+  int VerticalSize() const { return myParam2ColumnMaps[0].begin()->second.size(); }
+
+  bool HasNotQuadElemOnTop() const { return myNotQuadOnTop; }
+
+  /*!
+   * \brief Return pointer to column of nodes
+    * \param node - bottom node from which the returned column goes up
+    * \retval const TNodeColumn* - the found column
+   */
+  const TNodeColumn* GetNodeColumn(const SMDS_MeshNode* node) const;
+
+  /*!
+   * \brief Return TParam2ColumnMap for a base edge
+    * \param baseEdgeID - base edge SMESHDS Index
+    * \param isReverse - columns in-block orientation
+    * \retval const TParam2ColumnMap& - map
+   */
+  const TParam2ColumnMap& GetParam2ColumnMap(const int baseEdgeID,
+                                             bool &    isReverse)
+  {
+    std::pair< TParam2ColumnMap*, bool > & col_frw =
+      myShapeIndex2ColumnMap[ baseEdgeID ];
+    isReverse = !col_frw.second;
+    return * col_frw.first;
+  }
+  
+  /*!
+   * \brief Return pointer to mesh
+    * \retval SMESH_Mesh - mesh
+   */
+  SMESH_Mesh* Mesh() const { return myHelper->GetMesh(); }
+
+  /*!
+   * \brief Return pointer to mesh DS
+    * \retval SMESHDS_Mesh - mesh DS
+   */
+  SMESHDS_Mesh* MeshDS() const { return Mesh()->GetMeshDS(); }
+
+  /*!
+   * \brief Return submesh of a shape
+    * \param shapeID - shape given by in-block index
+    * \retval SMESH_subMesh* - found submesh
+   */
+  SMESH_subMesh* SubMesh(const int shapeID) const
+  { return Mesh()->GetSubMesh( Shape( shapeID )); }
+
+  /*!
+   * \brief Return submesh DS of a shape
+    * \param shapeID - shape given by in-block index
+    * \retval SMESHDS_SubMesh* - found submesh DS
+   */
+  SMESHDS_SubMesh* SubMeshDS(const int shapeID) const
+  { return SubMesh(shapeID)->GetSubMeshDS(); }
+
+  /*!
+   * \brief Return a in-block shape
+    * \param shapeID - shape given by in-block index
+    * \retval SMESHDS_SubMesh* - found submesh
+   */
+  const TopoDS_Shape& Shape(const int shapeID) const
+  { return myShapeIDMap( shapeID ); }
+
+  /*!
+   * \brief Return in-block ID of a shape
+    * \param shape - block subshape
+    * \retval int - ID or zero if the shape has no ID
+   */
+  int ShapeID(const TopoDS_Shape& shape) const
+  { return myShapeIDMap.FindIndex( shape ); }
+
+  /*!
+   * \brief Check curve orientation of a bootom edge
+   *  \param meshDS - mesh DS
+   *  \param columnsMap - node columns map of side face
+   *  \param bottomEdge - the bootom edge
+   *  \param sideFaceID - side face in-block ID
+   *  \retval bool - true if orienation coinside with in-block froward orienation
+   */
+  static bool IsForwardEdge(SMESHDS_Mesh*           meshDS,
+                            const TParam2ColumnMap& columnsMap,
+                            const TopoDS_Edge &     bottomEdge,
+                            const int               sideFaceID);
+  /*!
+   * \brief Find wall faces by bottom edges
+    * \param mesh - the mesh
+    * \param mainShape - the prism
+    * \param bottomFace - the bottom face
+    * \param bottomEdges - edges bounding the bottom face
+    * \param wallFaces - faces list to fill in
+   */
+  static bool GetWallFaces( SMESH_Mesh*                     mesh,
+                            const TopoDS_Shape &            mainShape,
+                            const TopoDS_Shape &            bottomFace,
+                            const std::list< TopoDS_Edge >& bottomEdges,
+                            std::list< TopoDS_Face >&       wallFaces);
+
+private:
+
+  // --------------------------------------------------------------------
+  /*!
+   * \brief Class representing a part of a geom face or
+   * a union of seleral faces. Or just an ordinary geom face
+   *
+   * It's parametrization is within [0,1] range.
+   * It redefines Adaptor3d_Surface::Value(U,V) where U and V are within [0,1]
+   */
+  // --------------------------------------------------------------------
+  class TSideFace: public Adaptor3d_Surface
+  {
+    int                             myID; //!< in-block ID
+    // map used to find out real UV by it's normalized UV
+    TParam2ColumnMap*               myParamToColumnMap;
+    BRepAdaptor_Surface             mySurface;
+    TopoDS_Edge                     myBaseEdge;
+    // first and last normalized params and orientaion for each component or it-self
+    vector< pair< double, double> > myParams;
+    bool                            myIsForward;
+    vector< TSideFace* >            myComponents;
+    SMESH_MesherHelper *            myHelper;
+  public:
+    TSideFace( SMESH_MesherHelper* helper,
+               const int           faceID,
+               const TopoDS_Face&  face,
+               const TopoDS_Edge&  baseEdge,
+               TParam2ColumnMap*   columnsMap,
+               const double        first = 0.0,
+               const double        last = 1.0);
+    TSideFace( const std::vector< TSideFace* >&             components,
+               const std::vector< pair< double, double> > & params);
+    TSideFace( const TSideFace& other );
+    ~TSideFace();
+    bool IsComplex() const
+    { return ( NbComponents() > 0 || myParams[0].first != 0. || myParams[0].second != 1. ); }
+    int FaceID() const { return myID; }
+    TParam2ColumnMap* GetColumns() const { return myParamToColumnMap; }
+    gp_XY GetNodeUV(const TopoDS_Face& F, const SMDS_MeshNode* n) const
+    { return myHelper->GetNodeUV( F, n ); }
+    const TopoDS_Edge & BaseEdge() const { return myBaseEdge; }
+    int ColumnHeight() const {
+      if ( NbComponents() ) return GetComponent(0)->GetColumns()->begin()->second.size();
+      else                  return GetColumns()->begin()->second.size(); }
+    double GetColumns(const double U, TParam2ColumnIt & col1, TParam2ColumnIt& col2 ) const;
+    int NbComponents() const { return myComponents.size(); }
+    TSideFace* GetComponent(const int i) const { return myComponents.at( i ); }
+    void SetComponent(const int i, TSideFace* c)
+    { if ( myComponents[i] ) delete myComponents[i]; myComponents[i]=c; }
+    TSideFace* GetComponent(const double U, double& localU) const;
+    bool IsForward() const { return myIsForward; }
+    // boundary geometry for a face
+    Adaptor3d_Surface* Surface() const { return new TSideFace( *this ); }
+    bool GetPCurves(Adaptor2d_Curve2d* pcurv[4]) const;
+    Adaptor2d_Curve2d* HorizPCurve(const bool isTop, const TopoDS_Face& horFace) const;
+    Adaptor3d_Curve* HorizCurve(const bool isTop) const;
+    Adaptor3d_Curve* VertiCurve(const bool isMax) const;
+    TopoDS_Edge GetEdge( const int edge ) const;
+    int InsertSubShapes( TBlockShapes& shapeMap ) const;
+    // redefine Adaptor methods
+    gp_Pnt Value(const Standard_Real U,const Standard_Real V) const;
+  };
+
+  // --------------------------------------------------------------------
+  /*!
+   * \brief Class emulating geometry of a vertical edge
+   */
+  // --------------------------------------------------------------------
+  class TVerticalEdgeAdaptor: public Adaptor3d_Curve
+  {
+    const TNodeColumn* myNodeColumn;
+  public:
+    TVerticalEdgeAdaptor( const TParam2ColumnMap* columnsMap, const double parameter );
+    gp_Pnt Value(const Standard_Real U) const;
+    Standard_Real FirstParameter() const { return 0; }
+    Standard_Real LastParameter() const { return 1; }
+  };
+
+  // --------------------------------------------------------------------
+  /*!
+   * \brief Class emulating geometry of a hirizontal edge
+   */
+  // --------------------------------------------------------------------
+  class THorizontalEdgeAdaptor: public Adaptor3d_Curve
+  {
+    const TSideFace* mySide;
+    double           myV;
+  public:
+    THorizontalEdgeAdaptor( const TSideFace* sideFace, const bool isTop)
+      :mySide(sideFace), myV( isTop ? 1.0 : 0.0 ) {}
+    gp_Pnt Value(const Standard_Real U) const;
+    Standard_Real FirstParameter() const { return 0; }
+    Standard_Real LastParameter() const { return 1; }
+  };
+
+  // --------------------------------------------------------------------
+  /*!
+   * \brief Class emulating pcurve on a hirizontal face
+   */
+  // --------------------------------------------------------------------
+  class TPCurveOnHorFaceAdaptor: public Adaptor2d_Curve2d
+  {
+    const TSideFace*  mySide;
+    int               myZ;
+    TopoDS_Face       myFace;
+  public:
+    TPCurveOnHorFaceAdaptor( const TSideFace*   sideFace,
+                             const bool         isTop,
+                             const TopoDS_Face& horFace)
+      : mySide(sideFace), myFace(horFace), myZ(isTop ? mySide->ColumnHeight() - 1 : 0 ) {}
+    gp_Pnt2d Value(const Standard_Real U) const;
+    Standard_Real FirstParameter() const { return 0; }
+    Standard_Real LastParameter() const { return 1; }
+  };
+  // --------------------------------------------------------------------
+
+  bool myNotQuadOnTop;
+  SMESH_MesherHelper* myHelper;
+  TBlockShapes myShapeIDMap;
+
+  // container of 4 side faces
+  TSideFace*                 mySide; 
+  // node columns for each base edge
+  vector< TParam2ColumnMap > myParam2ColumnMaps;
+  // to find a column for a node by edge SMESHDS Index
+  map< int, pair< TParam2ColumnMap*, bool > > myShapeIndex2ColumnMap;
+
+  
+  //vector< SMESH_subMesh* >           mySubMeshesVec; // submesh by in-block id
+};
+
+// =============================================
+/*!
+ * \brief Algo building prisms on a prism shape
+ */
+// =============================================
+
+class StdMeshers_Prism_3D: public SMESH_3D_Algo
+{
+public:
+  StdMeshers_Prism_3D(int hypId, int studyId, SMESH_Gen* gen);
+  virtual ~StdMeshers_Prism_3D();
+
+  virtual bool CheckHypothesis(SMESH_Mesh&                          aMesh,
+                               const TopoDS_Shape&                  aShape,
+                               SMESH_Hypothesis::Hypothesis_Status& aStatus);
+
+  virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
+
+  /*!
+   * \brief Enable removal of quadrangles from the bottom face and
+   * triangles creation there by projection from the top
+   * (sole face meshed with triangles is considered to be a bottom one).
+   * If there are two faces with triangles, triangles must
+   * be of the same topology, else the algo fails.
+   * The method must be called before Compute()
+   */
+  void ProjectTriangles() { myProjectTriangles = true; }
+
+  /*!
+   * \brief Create prisms
+    * \param nodeColumns - columns of nodes generated from nodes of a mesh face
+    * \param helper - helper initialized by mesh and shape to add prisms to
+   */
+  static void AddPrisms( vector<const TNodeColumn*> & nodeColumns,
+                         SMESH_MesherHelper*          helper);
+
+private:
+
+  /*!
+   * \brief Find correspondence between bottom and top nodes.
+   *  If elements on the bottom and top faces are topologically different,
+   *  and projection is possible and allowed, perform the projection
+    * \retval bool - is a success or not
+   */
+  bool assocOrProjBottom2Top();
+
+  /*!
+   * \brief Remove quadrangles from the top face and
+   * create triangles there by projection from the bottom
+    * \retval bool - a success or not
+   */
+  bool projectBottomToTop();
+
+  /*!
+   * \brief Set projection coordinates of a node to a face and it's subshapes
+    * \param faceID - the face given by in-block ID
+    * \param params - node normalized parameters
+    * \retval bool - is a success
+   */
+  bool setFaceAndEdgesXYZ( const int faceID, const gp_XYZ& params, int z );
+
+private:
+
+  bool myProjectTriangles;
+
+  StdMeshers_PrismAsBlock myBlock;
+  SMESH_MesherHelper*     myHelper;
+
+  vector<gp_XYZ>            myShapeXYZ; // point on each sub-shape
+
+  // map of bottom nodes to the column of nodes above them
+  // (the column includes the bottom node)
+  typedef std::map< TNode, TNodeColumn > TNode2ColumnMap;
+  TNode2ColumnMap  myBotToColumnMap;
+};
+
+#endif

src/StdMeshers/StdMeshers_ProjectionSource1D.cxx

@@ -0,0 +1,219 @@
+//  SMESH SMESH : idl implementation based on 'SMESH' unit's classes
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+//  File   : StdMeshers_ProjectionSource1D.cxx
+//  Author : Edward AGAPOV
+//  Module : SMESH
+//  $Header$
+
+#include "StdMeshers_ProjectionSource1D.hxx"
+
+#include "SMESH_Mesh.hxx"
+
+#include "utilities.h"
+
+#include <TopoDS.hxx>
+
+using namespace std;
+
+
+//=============================================================================
+/*!
+ *  StdMeshers_ProjectionSource1D::StdMeshers_ProjectionSource1D
+ *
+ *  Constructor
+ */
+//=============================================================================
+
+StdMeshers_ProjectionSource1D::StdMeshers_ProjectionSource1D(int hypId, int studyId,
+                                                             SMESH_Gen * gen)
+  : SMESH_Hypothesis(hypId, studyId, gen)
+{
+  _name = "ProjectionSource1D"; // used by Projection_1D
+  _param_algo_dim = 1; // 1D
+  _sourceMesh = 0;
+}
+
+//=============================================================================
+/*!
+ *  StdMeshers_ProjectionSource1D::~StdMeshers_ProjectionSource1D
+ *
+ *  Destructor
+ */
+//=============================================================================
+
+StdMeshers_ProjectionSource1D::~StdMeshers_ProjectionSource1D()
+{
+  MESSAGE( "StdMeshers_ProjectionSource1D::~StdMeshers_ProjectionSource1D" );
+}
+
+//=============================================================================
+  /*!
+   * Sets source <edge> to take a mesh pattern from
+   */
+//=============================================================================
+
+void StdMeshers_ProjectionSource1D::SetSourceEdge(const TopoDS_Shape& edge)
+  throw ( SALOME_Exception )
+{
+  if ( edge.IsNull() )
+    throw SALOME_Exception(LOCALIZED("Null edge is not allowed"));
+
+  if ( edge.ShapeType() != TopAbs_EDGE )
+    throw SALOME_Exception(LOCALIZED("Wrong shape type"));
+
+  if ( !_sourceEdge.IsSame( edge ) )
+  {
+    _sourceEdge = TopoDS::Edge( edge );
+
+    NotifySubMeshesHypothesisModification();
+  }
+}
+
+//=============================================================================
+/*!
+ * Sets vertex association between the source edge and the target one.
+ * This parameter is optional
+ */
+//=============================================================================
+
+void StdMeshers_ProjectionSource1D::SetVertexAssociation(const TopoDS_Shape& sourceVertex,
+                                                         const TopoDS_Shape& targetVertex)
+  throw ( SALOME_Exception )
+{
+  if ( sourceVertex.IsNull() != targetVertex.IsNull() )
+    throw SALOME_Exception(LOCALIZED("Two or none vertices must be provided"));
+
+  if ( !sourceVertex.IsNull() ) {
+    if ( sourceVertex.ShapeType() != TopAbs_VERTEX ||
+         targetVertex.ShapeType() != TopAbs_VERTEX )
+      throw SALOME_Exception(LOCALIZED("Wrong shape type"));
+  }
+
+  if ( !_sourceVertex.IsSame( sourceVertex ) ||
+       !_targetVertex.IsSame( targetVertex ) )
+  {
+    _sourceVertex = TopoDS::Vertex( sourceVertex );
+    _targetVertex = TopoDS::Vertex( targetVertex );
+
+    NotifySubMeshesHypothesisModification();
+  }
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+ostream & StdMeshers_ProjectionSource1D::SaveTo(ostream & save)
+{
+  // we store it in order to be able to detect that hypo is really modified
+  save << " " << _sourceEdge.TShape().operator->()  ;
+  save << " " << _sourceVertex.TShape().operator->();
+  save << " " << _targetVertex.TShape().operator->();
+  save << " " << ( _sourceMesh ? _sourceMesh->GetId() : -1 );
+  return save;
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+istream & StdMeshers_ProjectionSource1D::LoadFrom(istream & load)
+{
+  // impossible to restore w/o any context
+  return load;
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+ostream & operator <<(ostream & save, StdMeshers_ProjectionSource1D & hyp)
+{
+  return hyp.SaveTo( save );
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+istream & operator >>(istream & load, StdMeshers_ProjectionSource1D & hyp)
+{
+  return hyp.LoadFrom( load );
+}
+
+//================================================================================
+/*!
+ * \brief Initialize start and end length by the mesh built on the geometry
+ * \param theMesh - the built mesh
+ * \param theShape - the geometry of interest
+ * \retval bool - true if parameter values have been successfully defined
+ */
+//================================================================================
+
+bool StdMeshers_ProjectionSource1D::SetParametersByMesh(const SMESH_Mesh*   ,
+                                                        const TopoDS_Shape& )
+{
+  return false;
+}
+
+//================================================================================
+/*!
+ * \brief Return all parameters
+ */
+//================================================================================
+
+void StdMeshers_ProjectionSource1D::GetStoreParams(TopoDS_Shape& s1,
+                                                   TopoDS_Shape& s2,
+                                                   TopoDS_Shape& s3) const
+{
+  s1 = _sourceEdge;
+  s2 = _sourceVertex;
+  s3 = _targetVertex;
+}
+
+//================================================================================
+/*!
+ * \brief Set all parameters without notifying on modification
+ */
+//================================================================================
+
+void StdMeshers_ProjectionSource1D::RestoreParams(const TopoDS_Shape& s1,
+                                                  const TopoDS_Shape& s2,
+                                                  const TopoDS_Shape& s3,
+                                                  SMESH_Mesh*         mesh)
+{
+  _sourceEdge   = TopoDS::Edge( s1 );
+  _sourceVertex = TopoDS::Vertex( s2 );
+  _targetVertex = TopoDS::Vertex( s3 );
+  _sourceMesh   = mesh;
+}
+

src/StdMeshers/StdMeshers_ProjectionSource1D.hxx

@@ -0,0 +1,142 @@
+//  SMESH SMESH : idl implementation based on 'SMESH' unit's calsses
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+//  File   : StdMeshers_ProjectionSource1D.hxx
+//  Author : Edward AGAPOV
+//  Module : SMESH
+//  $Header$
+
+#ifndef _SMESH_ProjectionSource1D_HXX_
+#define _SMESH_ProjectionSource1D_HXX_
+
+#include "SMESH_Hypothesis.hxx"
+#include "Utils_SALOME_Exception.hxx"
+
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Vertex.hxx>
+
+class SMESH_Gen;
+
+// =========================================================
+  /*!
+   * This hypothesis specifies a meshed edge to take a mesh pattern from
+   * and optionally association of vertices between the source edge and a
+   * target one (where a hipothesis is assigned to)
+   */
+// =========================================================
+
+class StdMeshers_ProjectionSource1D: public SMESH_Hypothesis
+{
+public:
+  // Constructor
+  StdMeshers_ProjectionSource1D( int hypId, int studyId, SMESH_Gen * gen );
+  // Destructor
+  virtual ~StdMeshers_ProjectionSource1D();
+
+  /*!
+   * Sets source <edge> to take a mesh pattern from
+   */
+  void SetSourceEdge(const TopoDS_Shape& edge)
+    throw ( SALOME_Exception );
+
+  /*!
+   * Returns the source edge
+   */
+  TopoDS_Edge GetSourceEdge() const { return _sourceEdge; }
+
+  /*!
+   * Sets source <mesh> to take a mesh pattern from
+   */
+  void SetSourceMesh(SMESH_Mesh* mesh) { _sourceMesh = mesh; }
+
+  /*!
+   * Return source mesh
+   */
+  SMESH_Mesh* GetSourceMesh() const { return _sourceMesh; }
+
+  /*!
+   * Sets vertex association between the source edge and the target one.
+   * This parameter is optional
+   */
+  void SetVertexAssociation(const TopoDS_Shape& sourceVertex,
+                            const TopoDS_Shape& targetVertex)
+    throw ( SALOME_Exception );
+
+  /*!
+   * Returns the vertex associated with the target vertex.
+   * Result may be nil if association not set
+   */
+  TopoDS_Vertex GetSourceVertex() const { return _sourceVertex; }
+
+  /*!
+   * Returns the vertex associated with the source vertex.
+   * Result may be nil if association not set
+   */
+  TopoDS_Vertex GetTargetVertex() const { return _targetVertex; }
+
+  /*!
+   * \brief Test if vertex association defined
+    * \retval bool - test result
+   */
+  bool HasVertexAssociation() const
+  { return ( !_sourceVertex.IsNull() && !_targetVertex.IsNull() ); }
+
+  /*!
+   * \brief Return all parameters
+   */
+  void GetStoreParams(TopoDS_Shape& s1,
+                      TopoDS_Shape& s2,
+                      TopoDS_Shape& s3) const;
+
+  /*!
+   * \brief Set all parameters without notifying on modification
+   */
+  void RestoreParams(const TopoDS_Shape& s1,
+                     const TopoDS_Shape& s2,
+                     const TopoDS_Shape& s3,
+                     SMESH_Mesh*         mesh);
+
+  virtual std::ostream & SaveTo(std::ostream & save);
+  virtual std::istream & LoadFrom(std::istream & load);
+  friend std::ostream & operator <<(std::ostream & save, StdMeshers_ProjectionSource1D & hyp);
+  friend std::istream & operator >>(std::istream & load, StdMeshers_ProjectionSource1D & hyp);
+
+  /*!
+   * \brief Initialize parameters by the mesh built on the geometry
+    * \param theMesh - the built mesh
+    * \param theShape - the geometry of interest
+    * \retval bool - true if parameter values have been successfully defined
+    *
+    * Implementation does noting
+   */
+  virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
+
+protected:
+
+  TopoDS_Edge   _sourceEdge;
+  SMESH_Mesh*   _sourceMesh;
+  TopoDS_Vertex _sourceVertex;
+  TopoDS_Vertex _targetVertex;
+};
+
+#endif

src/StdMeshers/StdMeshers_ProjectionSource2D.cxx

@@ -0,0 +1,287 @@
+//  SMESH SMESH : idl implementation based on 'SMESH' unit's classes
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+//  File   : StdMeshers_ProjectionSource2D.cxx
+//  Author : Edward AGAPOV
+//  Module : SMESH
+//  $Header$
+
+
+#include "StdMeshers_ProjectionSource2D.hxx"
+
+#include "SMESH_Mesh.hxx"
+
+#include "utilities.h"
+
+#include <TopoDS.hxx>
+
+using namespace std;
+
+//=============================================================================
+/*!
+ *  StdMeshers_ProjectionSource2D::StdMeshers_ProjectionSource2D
+ *
+ *  Constructor
+ */
+//=============================================================================
+
+StdMeshers_ProjectionSource2D::StdMeshers_ProjectionSource2D(int hypId, int studyId,
+                                                             SMESH_Gen * gen)
+  : SMESH_Hypothesis(hypId, studyId, gen)
+{
+  _name = "ProjectionSource2D"; // used by Projection_2D
+  _param_algo_dim = 2; // 2D
+  _sourceMesh = 0;
+}
+
+//=============================================================================
+/*!
+ *  StdMeshers_ProjectionSource2D::~StdMeshers_ProjectionSource2D
+ *
+ *  Destructor
+ */
+//=============================================================================
+
+StdMeshers_ProjectionSource2D::~StdMeshers_ProjectionSource2D()
+{
+  MESSAGE( "StdMeshers_ProjectionSource2D::~StdMeshers_ProjectionSource2D" );
+}
+
+//=============================================================================
+  /*!
+   * Sets a source <face> to take a mesh pattern from
+   */
+//=============================================================================
+
+void StdMeshers_ProjectionSource2D::SetSourceFace(const TopoDS_Shape& Face)
+  throw ( SALOME_Exception )
+{
+  if ( Face.IsNull() )
+    throw SALOME_Exception(LOCALIZED("Null Face is not allowed"));
+
+  if ( Face.ShapeType() != TopAbs_FACE )
+    throw SALOME_Exception(LOCALIZED("Wrong shape type"));
+
+  if ( !_sourceFace.IsSame( Face ) )
+  {
+    _sourceFace = TopoDS::Face( Face );
+
+    NotifySubMeshesHypothesisModification();
+  }
+}
+
+//=============================================================================
+/*!
+ * Sets vertex association between the source face and the target one.
+ * This parameter is optional.
+ * Two vertices must belong to one edge of a face
+ */
+//=============================================================================
+
+void StdMeshers_ProjectionSource2D::SetVertexAssociation(const TopoDS_Shape& sourceVertex1,
+                                                         const TopoDS_Shape& sourceVertex2,
+                                                         const TopoDS_Shape& targetVertex1,
+                                                         const TopoDS_Shape& targetVertex2)
+  throw ( SALOME_Exception )
+{
+  if ( sourceVertex1.IsNull() != targetVertex1.IsNull() ||
+       sourceVertex2.IsNull() != targetVertex2.IsNull() ||
+       sourceVertex1.IsNull() != targetVertex2.IsNull() )
+    throw SALOME_Exception(LOCALIZED("Two or none pairs of vertices must be provided"));
+
+  if ( !sourceVertex1.IsNull() ) {
+    if ( sourceVertex1.ShapeType() != TopAbs_VERTEX ||
+         sourceVertex2.ShapeType() != TopAbs_VERTEX ||
+         targetVertex1.ShapeType() != TopAbs_VERTEX ||
+         targetVertex2.ShapeType() != TopAbs_VERTEX )
+      throw SALOME_Exception(LOCALIZED("Wrong shape type"));
+  }
+
+  if ( !_sourceVertex1.IsSame( sourceVertex1 ) ||
+       !_sourceVertex2.IsSame( sourceVertex2 ) ||
+       !_targetVertex1.IsSame( targetVertex1 ) ||
+       !_targetVertex2.IsSame( targetVertex2 ) )
+  {
+    _sourceVertex1 = TopoDS::Vertex( sourceVertex1 );
+    _sourceVertex2 = TopoDS::Vertex( sourceVertex2 );
+    _targetVertex1 = TopoDS::Vertex( targetVertex1 );
+    _targetVertex2 = TopoDS::Vertex( targetVertex2 );
+
+    NotifySubMeshesHypothesisModification();
+  }
+}
+
+//=============================================================================
+/*!
+ * Returns the source face
+ */
+//=============================================================================
+
+TopoDS_Face StdMeshers_ProjectionSource2D::GetSourceFace() const
+{
+  return _sourceFace;
+}
+
+//=============================================================================
+/*!
+ * Returns the vertex associated with the target vertex.
+ * Result may be nil if association not set
+ */
+//=============================================================================
+
+TopoDS_Vertex StdMeshers_ProjectionSource2D::GetSourceVertex(int i) const
+  throw ( SALOME_Exception )
+{
+  if ( i == 1 )
+    return _sourceVertex1;
+  else if ( i == 2 )
+    return _sourceVertex2;
+  else
+    throw SALOME_Exception(LOCALIZED("Wrong vertex index"));
+}
+
+//=============================================================================
+/*!
+ * Returns the <i>-th target vertex associated with the <i>-th source vertex.
+ * Result may be nil if association not set.
+ */
+//=============================================================================
+
+TopoDS_Vertex StdMeshers_ProjectionSource2D::GetTargetVertex(int i) const
+  throw ( SALOME_Exception )
+{
+  if ( i == 1 )
+    return _targetVertex1;
+  else if ( i == 2 )
+    return _targetVertex2;
+  else
+    throw SALOME_Exception(LOCALIZED("Wrong vertex index"));
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+ostream & StdMeshers_ProjectionSource2D::SaveTo(ostream & save)
+{
+  // we store it in order to be able to detect that hypo is really modified
+  save << " " << _sourceFace.TShape().operator->()  ;
+  save << " " << _sourceVertex1.TShape().operator->();
+  save << " " << _targetVertex1.TShape().operator->();
+  save << " " << _sourceVertex2.TShape().operator->();
+  save << " " << _targetVertex2.TShape().operator->();
+  save << " " << ( _sourceMesh ? _sourceMesh->GetId() : -1 );
+  return save;
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+istream & StdMeshers_ProjectionSource2D::LoadFrom(istream & load)
+{
+  // impossible to restore w/o any context
+  // It is done by servant
+  return load;
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+ostream & operator <<(ostream & save, StdMeshers_ProjectionSource2D & hyp)
+{
+  return hyp.SaveTo( save );
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+istream & operator >>(istream & load, StdMeshers_ProjectionSource2D & hyp)
+{
+  return hyp.LoadFrom( load );
+}
+
+//================================================================================
+/*!
+ * \brief Initialize start and end length by the mesh built on the geometry
+ * \param theMesh - the built mesh
+ * \param theShape - the geometry of interest
+ * \retval bool - true if parameter values have been successfully defined
+ */
+//================================================================================
+
+bool StdMeshers_ProjectionSource2D::SetParametersByMesh(const SMESH_Mesh*   ,
+                                                        const TopoDS_Shape& )
+{
+  return false;
+}
+
+//================================================================================
+/*!
+ * \brief Return all parameters
+ */
+//================================================================================
+
+void StdMeshers_ProjectionSource2D::GetStoreParams(TopoDS_Shape& s1,
+                                                   TopoDS_Shape& s2,
+                                                   TopoDS_Shape& s3,
+                                                   TopoDS_Shape& s4,
+                                                   TopoDS_Shape& s5) const
+{
+  s1 = _sourceFace;
+  s2 = _sourceVertex1;
+  s3 = _sourceVertex2;
+  s4 = _targetVertex1;
+  s5 = _targetVertex2;
+}
+
+//================================================================================
+/*!
+ * \brief Set all parameters without notifying on modification
+ */
+//================================================================================
+
+void StdMeshers_ProjectionSource2D::RestoreParams(const TopoDS_Shape& s1,
+                                                  const TopoDS_Shape& s2,
+                                                  const TopoDS_Shape& s3,
+                                                  const TopoDS_Shape& s4,
+                                                  const TopoDS_Shape& s5,
+                                                  SMESH_Mesh*         mesh)
+{
+  _sourceFace    = TopoDS::Face( s1 );
+  _sourceVertex1 = TopoDS::Vertex( s2 );
+  _sourceVertex2 = TopoDS::Vertex( s3 );
+  _targetVertex1 = TopoDS::Vertex( s4 );
+  _targetVertex2 = TopoDS::Vertex( s5 );
+  _sourceMesh   = mesh;
+}

src/StdMeshers/StdMeshers_ProjectionSource2D.hxx

@@ -0,0 +1,155 @@
+//  SMESH SMESH : idl implementation based on 'SMESH' unit's calsses
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+//  File   : StdMeshers_ProjectionSource2D.hxx
+//  Author : Edward AGAPOV
+//  Module : SMESH
+//  $Header$
+
+#ifndef _SMESH_ProjectionSource2D_HXX_
+#define _SMESH_ProjectionSource2D_HXX_
+
+#include "SMESH_Hypothesis.hxx"
+#include "Utils_SALOME_Exception.hxx"
+
+#include <TopoDS_Face.hxx>
+#include <TopoDS_Vertex.hxx>
+
+class SMESH_Gen;
+
+// =========================================================
+/*!
+ * This hypothesis specifies a meshed face to take a mesh pattern from
+ * and optionally association of vertices between the source face and a
+ * target one (where a hipothesis is assigned to)
+ */
+// =========================================================
+
+class StdMeshers_ProjectionSource2D: public SMESH_Hypothesis
+{
+public:
+  // Constructor
+  StdMeshers_ProjectionSource2D( int hypId, int studyId, SMESH_Gen * gen );
+  // Destructor
+  virtual ~StdMeshers_ProjectionSource2D();
+
+  /*!
+   * Sets a source <face> to take a mesh pattern from
+   */
+  void SetSourceFace(const TopoDS_Shape& face)
+    throw ( SALOME_Exception );
+
+  /*!
+   * Returns the source face
+   */
+  TopoDS_Face GetSourceFace() const;
+
+  /*!
+   * Sets source <mesh> to take a mesh pattern from
+   */
+  void SetSourceMesh(SMESH_Mesh* mesh) { _sourceMesh = mesh; }
+
+  /*!
+   * Return source mesh
+   */
+  SMESH_Mesh* GetSourceMesh() const { return _sourceMesh; }
+
+  /*!
+   * Sets vertex association between the source face and the target one.
+   * This parameter is optional.
+   * Two vertices must belong to one edge of a face
+   */
+  void SetVertexAssociation(const TopoDS_Shape& sourceVertex1,
+                            const TopoDS_Shape& sourceVertex2,
+                            const TopoDS_Shape& targetVertex1,
+                            const TopoDS_Shape& targetVertex2)
+    throw ( SALOME_Exception );
+
+  /*!
+   * Returns the <i>-th source vertex associated with the <i>-th target vertex.
+   * Result may be nil if association not set.
+   * Valid indices are 1 and 2
+   */
+  TopoDS_Vertex GetSourceVertex(int i) const throw ( SALOME_Exception );
+
+  /*!
+   * Returns the <i>-th target vertex associated with the <i>-th source vertex.
+   * Result may be nil if association not set.
+   * Valid indices are 1 and 2
+   */
+  TopoDS_Vertex GetTargetVertex(int i) const throw ( SALOME_Exception );
+
+  /*!
+   * \brief Test if vertex association defined
+    * \retval bool - test result
+   */
+  bool HasVertexAssociation() const
+  { return ( !_sourceVertex1.IsNull() && !_targetVertex1.IsNull() &&
+             !_sourceVertex2.IsNull() && !_targetVertex2.IsNull()); }
+
+  /*!
+   * \brief Return all parameters
+   */
+  void GetStoreParams(TopoDS_Shape& s1,
+                      TopoDS_Shape& s2,
+                      TopoDS_Shape& s3,
+                      TopoDS_Shape& s4,
+                      TopoDS_Shape& s5) const;
+
+  /*!
+   * \brief Set all parameters without notifying on modification
+   */
+  void RestoreParams(const TopoDS_Shape& s1,
+                     const TopoDS_Shape& s2,
+                     const TopoDS_Shape& s3,
+                     const TopoDS_Shape& s4,
+                     const TopoDS_Shape& s5,
+                     SMESH_Mesh*         mesh);
+
+  virtual std::ostream & SaveTo(std::ostream & save);
+  virtual std::istream & LoadFrom(std::istream & load);
+  friend std::ostream & operator <<(std::ostream & save, StdMeshers_ProjectionSource2D & hyp);
+  friend std::istream & operator >>(std::istream & load, StdMeshers_ProjectionSource2D & hyp);
+
+  /*!
+   * \brief Initialize parameters by the mesh built on the geometry
+    * \param theMesh - the built mesh
+    * \param theShape - the geometry of interest
+    * \retval bool - true if parameter values have been successfully defined
+    *
+    * Implementation does noting
+   */
+  virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
+
+protected:
+
+  TopoDS_Face   _sourceFace;
+  SMESH_Mesh*   _sourceMesh;
+  TopoDS_Vertex _sourceVertex1;
+  TopoDS_Vertex _sourceVertex2;
+  TopoDS_Vertex _targetVertex1;
+  TopoDS_Vertex _targetVertex2;
+};
+
+#endif
+

src/StdMeshers/StdMeshers_ProjectionSource3D.cxx

@@ -0,0 +1,286 @@
+//  SMESH SMESH : idl implementation based on 'SMESH' unit's classes
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+//  File   : StdMeshers_ProjectionSource3D.cxx
+//  Author : Edward AGAPOV
+//  Module : SMESH
+//  $Header$
+
+#include "StdMeshers_ProjectionSource3D.hxx"
+
+#include "utilities.h"
+#include "SMESH_Gen.hxx"
+
+#include <TopoDS.hxx>
+
+using namespace std;
+
+//=============================================================================
+/*!
+ *  StdMeshers_ProjectionSource3D::StdMeshers_ProjectionSource3D
+ *
+ *  Constructor
+ */
+//=============================================================================
+
+StdMeshers_ProjectionSource3D::StdMeshers_ProjectionSource3D(int hypId, int studyId,
+                                                             SMESH_Gen * gen)
+  : SMESH_Hypothesis(hypId, studyId, gen)
+{
+  _name = "ProjectionSource3D"; // used by Projection_3D
+  _param_algo_dim = 3; // 3D
+  _sourceMesh = 0;
+}
+
+//=============================================================================
+/*!
+ *  StdMeshers_ProjectionSource3D::~StdMeshers_ProjectionSource3D
+ *
+ *  Destructor
+ */
+//=============================================================================
+
+StdMeshers_ProjectionSource3D::~StdMeshers_ProjectionSource3D()
+{
+  MESSAGE( "StdMeshers_ProjectionSource3D::~StdMeshers_ProjectionSource3D" );
+}
+
+//=============================================================================
+  /*!
+   * Sets a source <face> to take a mesh pattern from
+   */
+//=============================================================================
+
+void StdMeshers_ProjectionSource3D::SetSource3DShape(const TopoDS_Shape& Shape)
+  throw ( SALOME_Exception )
+{
+  if ( Shape.IsNull() )
+    throw SALOME_Exception(LOCALIZED("Null Shape is not allowed"));
+
+  if ( SMESH_Gen::GetShapeDim( Shape ) != 3 )
+    throw SALOME_Exception(LOCALIZED("Wrong shape type"));
+
+  if ( !_sourceShape.IsSame( Shape ) )
+  {
+    _sourceShape = Shape;
+
+    NotifySubMeshesHypothesisModification();
+  }
+}
+
+//=============================================================================
+/*!
+ * Sets vertex association between the source shape and the target one.
+ * This parameter is optional.
+ * Two vertices must belong to one edge of a shape
+ */
+//=============================================================================
+
+void StdMeshers_ProjectionSource3D::SetVertexAssociation(const TopoDS_Shape& sourceVertex1,
+                                                         const TopoDS_Shape& sourceVertex2,
+                                                         const TopoDS_Shape& targetVertex1,
+                                                         const TopoDS_Shape& targetVertex2)
+  throw ( SALOME_Exception )
+{
+  if ( sourceVertex1.IsNull() != targetVertex1.IsNull() ||
+       sourceVertex2.IsNull() != targetVertex2.IsNull() ||
+       sourceVertex1.IsNull() != targetVertex2.IsNull() )
+    throw SALOME_Exception(LOCALIZED("Two or none pairs of vertices must be provided"));
+
+  if ( !sourceVertex1.IsNull() ) {
+    if ( sourceVertex1.ShapeType() != TopAbs_VERTEX ||
+         sourceVertex2.ShapeType() != TopAbs_VERTEX ||
+         targetVertex1.ShapeType() != TopAbs_VERTEX ||
+         targetVertex2.ShapeType() != TopAbs_VERTEX )
+      throw SALOME_Exception(LOCALIZED("Wrong shape type"));
+  }
+
+  if ( !_sourceVertex1.IsSame( sourceVertex1 ) ||
+       !_sourceVertex2.IsSame( sourceVertex2 ) ||
+       !_targetVertex1.IsSame( targetVertex1 ) ||
+       !_targetVertex2.IsSame( targetVertex2 ) )
+  {
+    _sourceVertex1 = TopoDS::Vertex( sourceVertex1 );
+    _sourceVertex2 = TopoDS::Vertex( sourceVertex2 );
+    _targetVertex1 = TopoDS::Vertex( targetVertex1 );
+    _targetVertex2 = TopoDS::Vertex( targetVertex2 );
+
+    NotifySubMeshesHypothesisModification();
+  }
+}
+
+//=============================================================================
+/*!
+ * Returns the source face
+ */
+//=============================================================================
+
+TopoDS_Shape StdMeshers_ProjectionSource3D::GetSource3DShape() const
+{
+  return _sourceShape;
+}
+
+//=============================================================================
+/*!
+ * Returns the vertex associated with the target vertex.
+ * Result may be nil if association not set
+ */
+//=============================================================================
+
+TopoDS_Vertex StdMeshers_ProjectionSource3D::GetSourceVertex(int i) const
+  throw ( SALOME_Exception )
+{
+  if ( i == 1 )
+    return _sourceVertex1;
+  else if ( i == 2 )
+    return _sourceVertex2;
+  else
+    throw SALOME_Exception(LOCALIZED("Wrong vertex index"));
+}
+
+//=============================================================================
+/*!
+ * Returns the <i>-th target vertex associated with the <i>-th source vertex.
+ * Result may be nil if association not set.
+ */
+//=============================================================================
+
+TopoDS_Vertex StdMeshers_ProjectionSource3D::GetTargetVertex(int i) const
+  throw ( SALOME_Exception )
+{
+  if ( i == 1 )
+    return _targetVertex1;
+  else if ( i == 2 )
+    return _targetVertex2;
+  else
+    throw SALOME_Exception(LOCALIZED("Wrong vertex index"));
+}
+
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+ostream & StdMeshers_ProjectionSource3D::SaveTo(ostream & save)
+{
+  // we store it in order to be able to detect that hypo is really modified
+  save << " " << _sourceShape.TShape().operator->()  ;
+  save << " " << _sourceVertex1.TShape().operator->();
+  save << " " << _targetVertex1.TShape().operator->();
+  save << " " << _sourceVertex2.TShape().operator->();
+  save << " " << _targetVertex2.TShape().operator->();
+  save << " " << ( _sourceMesh ? _sourceMesh->GetId() : -1 );
+  return save;
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+istream & StdMeshers_ProjectionSource3D::LoadFrom(istream & load)
+{
+  // impossible to restore w/o any context
+  // It is done by servant
+  return load;
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+ostream & operator <<(ostream & save, StdMeshers_ProjectionSource3D & hyp)
+{
+  return hyp.SaveTo( save );
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+istream & operator >>(istream & load, StdMeshers_ProjectionSource3D & hyp)
+{
+  return hyp.LoadFrom( load );
+}
+
+//================================================================================
+/*!
+ * \brief Initialize start and end length by the mesh built on the geometry
+ * \param theMesh - the built mesh
+ * \param theShape - the geometry of interest
+ * \retval bool - true if parameter values have been successfully defined
+ */
+//================================================================================
+
+bool StdMeshers_ProjectionSource3D::SetParametersByMesh(const SMESH_Mesh*   ,
+                                                        const TopoDS_Shape& )
+{
+  return false;
+}
+
+//================================================================================
+/*!
+ * \brief Return all parameters
+ */
+//================================================================================
+
+void StdMeshers_ProjectionSource3D::GetStoreParams(TopoDS_Shape& s1,
+                                                   TopoDS_Shape& s2,
+                                                   TopoDS_Shape& s3,
+                                                   TopoDS_Shape& s4,
+                                                   TopoDS_Shape& s5) const
+{
+  s1 = _sourceShape;
+  s2 = _sourceVertex1;
+  s3 = _sourceVertex2;
+  s4 = _targetVertex1;
+  s5 = _targetVertex2;
+}
+
+//================================================================================
+/*!
+ * \brief Set all parameters without notifying on modification
+ */
+//================================================================================
+
+void StdMeshers_ProjectionSource3D::RestoreParams(const TopoDS_Shape& s1,
+                                                  const TopoDS_Shape& s2,
+                                                  const TopoDS_Shape& s3,
+                                                  const TopoDS_Shape& s4,
+                                                  const TopoDS_Shape& s5,
+                                                  SMESH_Mesh*         mesh)
+{
+  _sourceShape   = s1;
+  _sourceVertex1 = TopoDS::Vertex( s2 );
+  _sourceVertex2 = TopoDS::Vertex( s3 );
+  _targetVertex1 = TopoDS::Vertex( s4 );
+  _targetVertex2 = TopoDS::Vertex( s5 );
+  _sourceMesh   = mesh;
+}

src/StdMeshers/StdMeshers_ProjectionSource3D.hxx

@@ -0,0 +1,153 @@
+//  SMESH SMESH : idl implementation based on 'SMESH' unit's calsses
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+//  File   : StdMeshers_ProjectionSource3D.hxx
+//  Author : Edward AGAPOV
+//  Module : SMESH
+//  $Header$
+
+#ifndef _SMESH_ProjectionSource3D_HXX_
+#define _SMESH_ProjectionSource3D_HXX_
+
+#include "SMESH_Hypothesis.hxx"
+#include "Utils_SALOME_Exception.hxx"
+
+#include <TopoDS_Vertex.hxx>
+
+class SMESH_Gen;
+
+// =========================================================
+/*!
+ * This hypothesis specifies a meshed shell or solid to take a mesh pattern from
+ * and optionally association of vertices between the source shape and a
+ * target one (where a hipothesis is assigned to)
+ */
+// =========================================================
+
+class StdMeshers_ProjectionSource3D:  public SMESH_Hypothesis
+{
+public:
+  // Constructor
+  StdMeshers_ProjectionSource3D( int hypId, int studyId, SMESH_Gen * gen );
+  // Destructor
+  virtual ~StdMeshers_ProjectionSource3D();
+
+  /*!
+   * Sets a source <shape> to take a mesh pattern from
+   */
+  void SetSource3DShape(const TopoDS_Shape& shape)
+    throw ( SALOME_Exception );
+
+  /*!
+   * Returns the source shape
+   */
+  TopoDS_Shape GetSource3DShape() const;
+
+  /*!
+   * Sets source <mesh> to take a mesh pattern from
+   */
+  void SetSourceMesh(SMESH_Mesh* mesh) { _sourceMesh = mesh; }
+
+  /*!
+   * Return source mesh
+   */
+  SMESH_Mesh* GetSourceMesh() const { return _sourceMesh; }
+
+  /*!
+   * Sets vertex association between the source shape and the target one.
+   * This parameter is optional.
+   * Two vertices must belong to one edge of a shape
+   */
+  void SetVertexAssociation(const TopoDS_Shape& sourceVertex1,
+                            const TopoDS_Shape& sourceVertex2,
+                            const TopoDS_Shape& targetVertex1,
+                            const TopoDS_Shape& targetVertex2)
+    throw ( SALOME_Exception );
+
+  /*!
+   * Returns the <i>-th source vertex associated with the <i>-th target vertex.
+   * Result may be nil if association not set.
+   */
+  TopoDS_Vertex GetSourceVertex(int i) const throw ( SALOME_Exception );
+
+  /*!
+   * Returns the <i>-th target vertex associated with the <i>-th source vertex.
+   * Result may be nil if association not set.
+   */
+  TopoDS_Vertex GetTargetVertex(int i) const throw ( SALOME_Exception );
+
+  /*!
+   * \brief Test if vertex association defined
+    * \retval bool - test result
+   */
+  bool HasVertexAssociation() const
+  { return ( !_sourceVertex1.IsNull() && !_targetVertex1.IsNull() &&
+             !_sourceVertex2.IsNull() && !_targetVertex2.IsNull()); }
+
+  /*!
+   * \brief Return all parameters
+   */
+  void GetStoreParams(TopoDS_Shape& s1,
+                      TopoDS_Shape& s2,
+                      TopoDS_Shape& s3,
+                      TopoDS_Shape& s4,
+                      TopoDS_Shape& s5) const;
+
+  /*!
+   * \brief Set all parameters without notifying on modification
+   */
+  void RestoreParams(const TopoDS_Shape& s1,
+                     const TopoDS_Shape& s2,
+                     const TopoDS_Shape& s3,
+                     const TopoDS_Shape& s4,
+                     const TopoDS_Shape& s5,
+                     SMESH_Mesh*         mesh);
+
+  virtual std::ostream & SaveTo(std::ostream & save);
+  virtual std::istream & LoadFrom(std::istream & load);
+  friend std::ostream & operator <<(std::ostream & save, StdMeshers_ProjectionSource3D & hyp);
+  friend std::istream & operator >>(std::istream & load, StdMeshers_ProjectionSource3D & hyp);
+
+  /*!
+   * \brief Initialize parameters by the mesh built on the geometry
+    * \param theMesh - the built mesh
+    * \param theShape - the geometry of interest
+    * \retval bool - true if parameter values have been successfully defined
+    *
+    * Implementation does noting
+   */
+  virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
+
+protected:
+
+  TopoDS_Shape  _sourceShape;
+  SMESH_Mesh*   _sourceMesh;
+  TopoDS_Vertex _sourceVertex1;
+  TopoDS_Vertex _sourceVertex2;
+  TopoDS_Vertex _targetVertex1;
+  TopoDS_Vertex _targetVertex2;
+
+};
+
+#endif
+

src/StdMeshers/StdMeshers_ProjectionUtils.hxx

@@ -0,0 +1,198 @@
+//  SMESH SMESH : idl implementation based on 'SMESH' unit's calsses
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+// File      : StdMeshers_ProjectionUtils.hxx
+// Created   : Thu Oct 26 15:37:24 2006
+// Author    : Edward AGAPOV (eap)
+
+
+#ifndef StdMeshers_ProjectionUtils_HeaderFile
+#define StdMeshers_ProjectionUtils_HeaderFile
+
+#include <TopTools_DataMapOfShapeShape.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Vertex.hxx>
+#include <TopoDS_Face.hxx>
+
+#include <list>
+#include <map>
+
+class TopoDS_Shape;
+class SMDS_MeshNode;
+class SMESH_Mesh;
+class SMESH_Hypothesis;
+class SMESH_subMesh;
+
+/*!
+ * \brief Class encapsulating methods common to Projection algorithms
+ */
+class StdMeshers_ProjectionUtils
+{
+ public:
+
+  typedef TopTools_DataMapOfShapeShape                         TShapeShapeMap;
+  typedef std::map<const SMDS_MeshNode*, const SMDS_MeshNode*> TNodeNodeMap;
+
+  /*!
+   * \brief Looks for association of all subshapes of two shapes
+    * \param theShape1 - shape 1
+    * \param theMesh1 - mesh built on shape 1
+    * \param theShape2 - shape 2
+    * \param theMesh2 - mesh built on shape 2
+    * \param theAssociation - association map to be filled that may
+    *                         contain association of one or two pairs of vertices
+    * \retval bool - true if association found
+   */
+  static bool FindSubShapeAssociation(const TopoDS_Shape& theShape1,
+                                      SMESH_Mesh*         theMesh1,
+                                      const TopoDS_Shape& theShape2,
+                                      SMESH_Mesh*         theMesh2,
+                                      TShapeShapeMap &    theAssociationMap);
+
+  /*!
+   * \brief Find association of edges of faces
+    * \param face1 - face 1
+    * \param VV1 - vertices of face 1
+    * \param face2 - face 2
+    * \param VV2 - vertices of face 2 associated with oned of face 1
+    * \param edges1 - out list of edges of face 1
+    * \param edges2 - out list of edges of face 2
+    * \retval int - nb of edges in an outer wire in a success case, else zero
+   */
+  static int FindFaceAssociation(const TopoDS_Face&    face1,
+                                 TopoDS_Vertex         VV1[2],
+                                 const TopoDS_Face&    face2,
+                                 TopoDS_Vertex         VV2[2],
+                                 list< TopoDS_Edge > & edges1,
+                                 list< TopoDS_Edge > & edges2);
+
+  /*!
+   * \brief Insert vertex association defined by a hypothesis into a map
+    * \param theHyp - hypothesis
+    * \param theAssociationMap - association map
+   */
+  static void InitVertexAssociation( const SMESH_Hypothesis* theHyp,
+                                     TShapeShapeMap &        theAssociationMap);
+
+  /*!
+   * \brief Inserts association theShape1 <-> theShape2 to TShapeShapeMap
+    * \param theShape1 - shape 1
+    * \param theShape2 - shape 2
+    * \param theAssociationMap - association map 
+    * \param theBidirectional - if false, inserts theShape1 -> theShape2 association
+    * \retval bool - true if there was no association for these shapes before
+   */
+  static bool InsertAssociation( const TopoDS_Shape& theShape1,
+                                 const TopoDS_Shape& theShape2,
+                                 TShapeShapeMap &    theAssociationMap,
+                                 const bool          theBidirectional=true);
+
+  static bool IsSubShape( const TopoDS_Shape& shape, SMESH_Mesh* aMesh );
+
+  static bool IsSubShape( const TopoDS_Shape& shape, const TopoDS_Shape& mainShape );
+
+  /*!
+   * \brief Finds an edge by its vertices in a main shape of the mesh
+    * \param aMesh - the mesh
+    * \param V1 - vertex 1
+    * \param V2 - vertex 2
+    * \retval TopoDS_Edge - found edge
+   */
+  static TopoDS_Edge GetEdgeByVertices( SMESH_Mesh*          aMesh,
+                                        const TopoDS_Vertex& V1,
+                                        const TopoDS_Vertex& V2);
+                                        
+  /*!
+   * \brief Return another face sharing an edge
+    * \param aMesh - mesh
+    * \param edge - edge
+    * \param face - face
+    * \retval TopoDS_Face - found face
+   */
+  static TopoDS_Face GetNextFace( SMESH_Mesh*        aMesh,
+                                  const TopoDS_Edge& edge,
+                                  const TopoDS_Face& face);
+
+  /*!
+   * \brief Return an oriented propagation edge
+    * \param aMesh - mesh
+    * \param fromEdge - start edge for propagation
+    * \retval TopoDS_Edge - found edge
+   */
+  static TopoDS_Edge GetPropagationEdge( SMESH_Mesh*        aMesh,
+                                         const TopoDS_Edge& anEdge,
+                                         const TopoDS_Edge& fromEdge);
+
+  /*!
+   * \brief Find corresponding nodes on two faces
+    * \param face1 - the first face
+    * \param mesh1 - mesh containing elements on the first face
+    * \param face2 - the second face
+    * \param mesh2 - mesh containing elements on the second face
+    * \param assocMap - map associating subshapes of the faces
+    * \param nodeIn2OutMap - map containing found matching nodes
+    * \retval bool - is a success
+   */
+  static bool FindMatchingNodesOnFaces( const TopoDS_Face&     face1,
+                                        SMESH_Mesh*            mesh1,
+                                        const TopoDS_Face&     face2,
+                                        SMESH_Mesh*            mesh2,
+                                        const TShapeShapeMap & assocMap,
+                                        TNodeNodeMap &         nodeIn2OutMap);
+  /*!
+   * \brief Check if the first and last vertices of an edge are the same
+    * \param anEdge - the edge to check
+    * \retval bool - true if same
+   */
+  static bool IsClosedEdge( const TopoDS_Edge& anEdge );
+
+  /*!
+   * \brief Return any subshape of a face belonging to the outer wire
+    * \param face - the face
+    * \param type - type of subshape to return
+    * \retval TopoDS_Shape - the found subshape
+   */
+  static TopoDS_Shape OuterShape( const TopoDS_Face& face,
+                                  TopAbs_ShapeEnum   type);
+
+  /*!
+   * \brief Check that submeshis is computed and try to compute it if is not
+    * \param sm - submesh to compute
+    * \param iterationNb - int used to stop infinite recursive call
+    * \retval bool - true if computed
+   */
+  static bool MakeComputed(SMESH_subMesh * sm, const int iterationNb = 0);
+
+  /*!
+   * \brief Count nb of subshapes
+    * \param shape - the shape
+    * \param type - the type of subshapes to count
+    * \param ignoreSame - if true, use map not to count same shapes, esle use explorer
+    * \retval int - the calculated number
+   */
+  static int Count(const TopoDS_Shape&    shape,
+                   const TopAbs_ShapeEnum type,
+                   const bool             ignoreSame);
+};
+
+#endif

src/StdMeshers/StdMeshers_Projection_1D.cxx

@@ -0,0 +1,362 @@
+//  SMESH SMESH : implementaion of SMESH idl descriptions
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+// File      : StdMeshers_Projection_1D.cxx
+// Module    : SMESH
+// Created   : Fri Oct 20 11:37:07 2006
+// Author    : Edward AGAPOV (eap)
+
+
+#include "StdMeshers_Projection_1D.hxx"
+
+#include "StdMeshers_ProjectionSource1D.hxx"
+#include "StdMeshers_ProjectionUtils.hxx"
+
+#include "SMDS_MeshNode.hxx"
+#include "SMDS_MeshElement.hxx"
+#include "SMESHDS_Mesh.hxx"
+#include "SMESHDS_SubMesh.hxx"
+#include "SMESH_Mesh.hxx"
+#include "SMESH_MesherHelper.hxx"
+#include "SMESH_subMesh.hxx"
+#include "SMESH_subMeshEventListener.hxx"
+#include "SMESH_Gen.hxx"
+
+#include <BRepAdaptor_Curve.hxx>
+#include <BRep_Tool.hxx>
+#include <GCPnts_AbscissaPoint.hxx>
+#include <TopoDS.hxx>
+#include <gp_Pnt.hxx>
+
+#include "utilities.h"
+
+
+using namespace std;
+
+#define RETURN_BAD_RESULT(msg) { MESSAGE(msg); return false; }
+
+typedef StdMeshers_ProjectionUtils TAssocTool;
+
+//=======================================================================
+//function : StdMeshers_Projection_1D
+//purpose  : 
+//=======================================================================
+
+StdMeshers_Projection_1D::StdMeshers_Projection_1D(int hypId, int studyId, SMESH_Gen* gen)
+  :SMESH_1D_Algo(hypId, studyId, gen)
+{
+  _name = "Projection_1D";
+  _shapeType = (1 << TopAbs_EDGE);	// 1 bit per shape type
+
+  _compatibleHypothesis.push_back("ProjectionSource1D");
+  _sourceHypo = 0;
+}
+
+//================================================================================
+/*!
+ * \brief Destructor
+ */
+//================================================================================
+
+StdMeshers_Projection_1D::~StdMeshers_Projection_1D()
+{}
+
+//=======================================================================
+//function : CheckHypothesis
+//purpose  : 
+//=======================================================================
+
+bool StdMeshers_Projection_1D::CheckHypothesis(SMESH_Mesh&                          aMesh,
+                                               const TopoDS_Shape&                  aShape,
+                                               SMESH_Hypothesis::Hypothesis_Status& aStatus)
+{
+  _sourceHypo = 0;
+  list <const SMESHDS_Hypothesis * >::const_iterator itl;
+
+  const list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(aMesh, aShape);
+  if ( hyps.size() == 0 )
+  {
+    aStatus = SMESH_Hypothesis::HYP_MISSING;
+    return false;  // can't work with no hypothesis
+  }
+
+  if ( hyps.size() > 1 )
+  {
+    aStatus = SMESH_Hypothesis::HYP_ALREADY_EXIST;
+    return false;
+  }
+
+  const SMESHDS_Hypothesis *theHyp = hyps.front();
+
+  string hypName = theHyp->GetName();
+
+  aStatus = SMESH_Hypothesis::HYP_OK;
+
+  if (hypName == "ProjectionSource1D")
+  {
+    _sourceHypo = static_cast<const StdMeshers_ProjectionSource1D *>(theHyp);
+
+    // Check hypo parameters
+
+    SMESH_Mesh* srcMesh = _sourceHypo->GetSourceMesh();
+    SMESH_Mesh* tgtMesh = & aMesh;
+    if ( !srcMesh )
+      srcMesh = tgtMesh;
+
+    // check vertices
+    if ( _sourceHypo->HasVertexAssociation() )
+    {
+      // source and target vertices
+      if ( !TAssocTool::IsSubShape( _sourceHypo->GetSourceVertex(), srcMesh ) ||
+           !TAssocTool::IsSubShape( _sourceHypo->GetTargetVertex(), tgtMesh ) ||
+           !TAssocTool::IsSubShape( _sourceHypo->GetTargetVertex(), aShape )  ||
+           !TAssocTool::IsSubShape( _sourceHypo->GetSourceVertex(),
+                                    _sourceHypo->GetSourceEdge() ))
+        aStatus = SMESH_Hypothesis::HYP_BAD_PARAMETER;
+    }
+    // check source edge
+    if ( !TAssocTool::IsSubShape( _sourceHypo->GetSourceEdge(), srcMesh ))
+      aStatus = SMESH_Hypothesis::HYP_BAD_PARAMETER;
+  }
+  else
+  {
+    aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
+  }
+  return ( aStatus == HYP_OK );
+}
+
+//=======================================================================
+//function : Compute
+//purpose  : 
+//=======================================================================
+
+bool StdMeshers_Projection_1D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape& theShape)
+{
+  if ( !_sourceHypo )
+    return false;
+
+  TopoDS_Edge tgtEdge = TopoDS::Edge( theShape.Oriented(TopAbs_FORWARD));
+  TopoDS_Edge srcEdge = TopoDS::Edge( _sourceHypo->GetSourceEdge().Oriented(TopAbs_FORWARD));
+
+  TopoDS_Vertex tgtV[2], srcV[2];
+  TopExp::Vertices( tgtEdge, tgtV[0], tgtV[1] );
+  TopExp::Vertices( srcEdge, srcV[0], srcV[1] );
+
+  SMESH_Mesh * srcMesh = _sourceHypo->GetSourceMesh(); 
+  SMESH_Mesh * tgtMesh = & theMesh;
+  if ( !srcMesh )
+    srcMesh = tgtMesh;
+
+  SMESHDS_Mesh * meshDS = theMesh.GetMeshDS();
+
+  // ---------------------------
+  // Make subshapes association
+  // ---------------------------
+
+  TAssocTool::TShapeShapeMap shape2ShapeMap;
+  TAssocTool::InitVertexAssociation( _sourceHypo, shape2ShapeMap );
+  if ( !TAssocTool::FindSubShapeAssociation( tgtEdge, tgtMesh, srcEdge, srcMesh,
+                                             shape2ShapeMap) )
+    RETURN_BAD_RESULT("FindSubShapeAssociation failed");
+
+  // ----------------------------------------------
+  // Assure that mesh on a source edge is computed
+  // ----------------------------------------------
+
+  SMESH_subMesh* srcSubMesh = srcMesh->GetSubMesh( srcEdge );
+  //SMESH_subMesh* tgtSubMesh = tgtMesh->GetSubMesh( tgtEdge );
+
+  if ( tgtMesh == srcMesh ) {
+    if ( !TAssocTool::MakeComputed( srcSubMesh ))
+      RETURN_BAD_RESULT("Impossible to compute the source mesh");
+  }
+  else {
+    if ( !srcSubMesh->IsMeshComputed() )
+      RETURN_BAD_RESULT("Source mesh is not computed");
+  }
+  // -----------------------------------------------
+  // Find out nodes distribution on the source edge
+  // -----------------------------------------------
+
+  double srcLength = EdgeLength( srcEdge );
+  double tgtLength = EdgeLength( tgtEdge );
+  
+  vector< double > params; // sorted parameters of nodes on the source edge
+  if ( !SMESH_Algo::GetNodeParamOnEdge( srcMesh->GetMeshDS(), srcEdge, params ))
+    RETURN_BAD_RESULT("Bad node params on the source edge");
+
+  int i, nbNodes = params.size();
+
+  vector< double > lengths( nbNodes - 1 ); // lengths of segments of the source edge
+  if ( srcLength > 0 )
+  {
+    BRepAdaptor_Curve curveAdaptor( srcEdge );
+    for ( i = 1; i < nbNodes; ++i )
+      lengths[ i-1 ] = GCPnts_AbscissaPoint::Length( curveAdaptor, params[i-1], params[i]);
+  }
+  else // degenerated source edge
+  {
+    for ( i = 1; i < nbNodes; ++i )
+      lengths[ i-1 ] = params[i] - params[i-1];
+    srcLength = params.back() - params[0];
+  }
+
+  bool reverse = ( srcV[0].IsSame( shape2ShapeMap( tgtV[1] )));
+  if ( shape2ShapeMap.IsBound( tgtEdge )) // case of closed edge
+    reverse = ( shape2ShapeMap( tgtEdge ).Orientation() == TopAbs_REVERSED );
+  if ( reverse ) // reverse lengths of segments
+    std::reverse( lengths.begin(), lengths.end() );
+
+  // ----------
+  // Make mesh
+  // ----------
+
+  // vector of target nodes
+  vector< const SMDS_MeshNode* > nodes ( nbNodes );
+
+  // Get the first and last nodes
+  // -----------------------------
+
+  SMESHDS_SubMesh* smV0 = meshDS->MeshElements( tgtV[0] );
+  SMESHDS_SubMesh* smV1 = meshDS->MeshElements( tgtV[1] );
+  if ( !smV0 || !smV1 )
+    RETURN_BAD_RESULT("No submeshes on vertices");
+
+  SMDS_NodeIteratorPtr nItV0 = smV0->GetNodes();
+  SMDS_NodeIteratorPtr nItV1 = smV1->GetNodes();
+  if ( !nItV0->more() || !nItV1->more() )
+    RETURN_BAD_RESULT("No nodes on vertices");
+
+  nodes.front() = nItV0->next();
+  nodes.back()  = nItV1->next();
+
+  // Compute parameters on the target edge and make internal nodes
+  // --------------------------------------------------------------
+
+  vector< double > tgtParams( nbNodes );
+
+  BRep_Tool::Range( tgtEdge, tgtParams.front(), tgtParams.back() );
+  if ( tgtLength <= 0 )
+    tgtLength = tgtParams.back() - tgtParams.front();
+  double dl = tgtLength / srcLength;
+
+  if ( tgtLength > 0 )
+  {
+    BRepAdaptor_Curve curveAdaptor( tgtEdge );
+
+    // compute params on internal nodes
+    for ( i = 1; i < nbNodes - 1; ++i )
+    {
+      // computes a point on a <curveAdaptor> at the given distance
+      // from the point at given parameter.
+      GCPnts_AbscissaPoint Discret( curveAdaptor, dl * lengths[ i-1 ], tgtParams[ i-1 ] );
+      if ( !Discret.IsDone() )
+        RETURN_BAD_RESULT(" GCPnts_AbscissaPoint failed");
+      tgtParams[ i ] = Discret.Parameter();
+    }
+    // make internal nodes 
+    for ( i = 1; i < nbNodes - 1; ++i )
+    {
+      gp_Pnt P = curveAdaptor.Value( tgtParams[ i ]);
+      SMDS_MeshNode* node = meshDS->AddNode(P.X(), P.Y(), P.Z());
+      meshDS->SetNodeOnEdge( node, tgtEdge, tgtParams[ i ]);
+      nodes[ i ] = node;
+    }
+  }
+  else // degenerated target edge
+  {
+    // compute params and make internal nodes
+    gp_Pnt P = BRep_Tool::Pnt( tgtV[0] );
+
+    for ( i = 1; i < nbNodes - 1; ++i )
+    {
+      SMDS_MeshNode* node = meshDS->AddNode(P.X(), P.Y(), P.Z());
+      tgtParams[ i ] = tgtParams[ i-1 ] + dl * lengths[ i-1 ];
+      meshDS->SetNodeOnEdge( node, tgtEdge, tgtParams[ i ]);
+      nodes[ i ] = node;
+    }
+  }
+
+  // Quadratic mesh?
+  // ----------------
+
+  bool quadratic = false;
+  SMDS_ElemIteratorPtr elemIt = srcSubMesh->GetSubMeshDS()->GetElements();
+  if ( elemIt->more() )
+    quadratic = elemIt->next()->IsQuadratic();
+  else {
+    SMDS_NodeIteratorPtr nodeIt = srcSubMesh->GetSubMeshDS()->GetNodes();
+    while ( nodeIt->more() && !quadratic )
+      quadratic = SMESH_MesherHelper::IsMedium( nodeIt->next() );
+  }
+  // enough nodes to make all edges quadratic?
+  if ( quadratic && ( nbNodes < 3 || ( nbNodes % 2 != 1 )))
+    RETURN_BAD_RESULT("Wrong nb nodes to make quadratic mesh");
+
+  // Create edges
+  // -------------
+
+  SMDS_MeshElement* edge = 0;
+  int di = quadratic ? 2 : 1;
+  for ( i = di; i < nbNodes; i += di)
+  {
+    if ( quadratic )
+      edge = meshDS->AddEdge( nodes[i-2], nodes[i], nodes[i-1] );
+    else
+      edge = meshDS->AddEdge( nodes[i-1], nodes[i] );
+    meshDS->SetMeshElementOnShape(edge, tgtEdge );
+  }
+
+  return true;
+}
+
+//=============================================================================
+/*!
+ * \brief Sets a default event listener to submesh of the source edge
+  * \param subMesh - submesh where algo is set
+ *
+ * This method is called when a submesh gets HYP_OK algo_state.
+ * After being set, event listener is notified on each event of a submesh.
+ * Arranges that CLEAN event is translated from source submesh to
+ * the submesh
+ */
+//=============================================================================
+
+void StdMeshers_Projection_1D::SetEventListener(SMESH_subMesh* subMesh)
+{
+  if ( _sourceHypo && ! _sourceHypo->GetSourceEdge().IsNull() )
+  {
+    SMESH_Mesh* srcMesh = _sourceHypo->GetSourceMesh();
+    if ( !srcMesh )
+      srcMesh = subMesh->GetFather();
+
+    SMESH_subMesh* srcEdgeSM =
+      srcMesh->GetSubMesh( _sourceHypo->GetSourceEdge() );
+
+    if ( srcEdgeSM != subMesh )
+      subMesh->SetEventListener( new SMESH_subMeshEventListener(),
+                                 SMESH_subMeshEventListenerData::MakeData( subMesh ),
+                                 srcEdgeSM );
+  }
+}
+  

src/StdMeshers/StdMeshers_Projection_1D.hxx

@@ -0,0 +1,64 @@
+//  SMESH SMESH : implementaion of SMESH idl descriptions
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+//  File   : StdMeshers_Projection_1D.hxx
+//  Module : SMESH
+
+#ifndef _SMESH_Projection_1D_HXX_
+#define _SMESH_Projection_1D_HXX_
+
+#include "SMESH_1D_Algo.hxx"
+
+
+class StdMeshers_ProjectionSource1D;
+
+class StdMeshers_Projection_1D: public SMESH_1D_Algo
+{
+public:
+  StdMeshers_Projection_1D(int hypId, int studyId, SMESH_Gen* gen);
+  virtual ~StdMeshers_Projection_1D();
+
+  virtual bool CheckHypothesis(SMESH_Mesh&                          aMesh,
+                               const TopoDS_Shape&                  aShape,
+                               SMESH_Hypothesis::Hypothesis_Status& aStatus);
+
+  virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
+
+  /*!
+   * \brief Sets a default event listener to submesh of the source edge
+   *  \param whenSetToSubMesh - submesh where algo is set
+   *
+   * After being set, event listener is notified on each event of a submesh.
+   * This method is called when a submesh gets HYP_OK algo_state.
+   * Arranges that CLEAN event is translated from source submesh to
+   * the whenSetToSubMesh submesh.
+   */
+  virtual void SetEventListener(SMESH_subMesh* whenSetToSubMesh);
+  
+protected:
+
+  const StdMeshers_ProjectionSource1D* _sourceHypo;
+
+};
+
+#endif

src/StdMeshers/StdMeshers_Projection_2D.cxx

@@ -0,0 +1,638 @@
+//  SMESH SMESH : implementaion of SMESH idl descriptions
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+// File      : StdMeshers_Projection_2D.cxx
+// Module    : SMESH
+// Created   : Fri Oct 20 11:37:07 2006
+// Author    : Edward AGAPOV (eap)
+
+
+#include "StdMeshers_Projection_2D.hxx"
+
+#include "StdMeshers_ProjectionSource2D.hxx"
+#include "StdMeshers_ProjectionUtils.hxx"
+
+#include "SMESHDS_Hypothesis.hxx"
+#include "SMESHDS_SubMesh.hxx"
+#include "SMESH_Block.hxx"
+#include "SMESH_Gen.hxx"
+#include "SMESH_Mesh.hxx"
+#include "SMESH_MeshEditor.hxx"
+#include "SMESH_Pattern.hxx"
+#include "SMESH_subMesh.hxx"
+#include "SMESH_subMeshEventListener.hxx"
+#include "SMDS_EdgePosition.hxx"
+
+#include "utilities.h"
+
+#include <TopExp.hxx>
+#include <TopoDS.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <BRep_Tool.hxx>
+
+
+
+using namespace std;
+
+#define RETURN_BAD_RESULT(msg) { MESSAGE(msg); return false; }
+
+typedef StdMeshers_ProjectionUtils TAssocTool;
+
+//=======================================================================
+//function : StdMeshers_Projection_2D
+//purpose  : 
+//=======================================================================
+
+StdMeshers_Projection_2D::StdMeshers_Projection_2D(int hypId, int studyId, SMESH_Gen* gen)
+  :SMESH_2D_Algo(hypId, studyId, gen)
+{
+  _name = "Projection_2D";
+  _shapeType = (1 << TopAbs_FACE);	// 1 bit per shape type
+
+  _compatibleHypothesis.push_back("ProjectionSource2D");
+  _sourceHypo = 0;
+}
+
+//================================================================================
+/*!
+ * \brief Destructor
+ */
+//================================================================================
+
+StdMeshers_Projection_2D::~StdMeshers_Projection_2D()
+{}
+
+//=======================================================================
+//function : CheckHypothesis
+//purpose  : 
+//=======================================================================
+
+bool StdMeshers_Projection_2D::CheckHypothesis(SMESH_Mesh&                          theMesh,
+                                               const TopoDS_Shape&                  theShape,
+                                               SMESH_Hypothesis::Hypothesis_Status& theStatus)
+{
+  list <const SMESHDS_Hypothesis * >::const_iterator itl;
+
+  const list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(theMesh, theShape);
+  if ( hyps.size() == 0 )
+  {
+    theStatus = HYP_MISSING;
+    return false;  // can't work with no hypothesis
+  }
+
+  if ( hyps.size() > 1 )
+  {
+    theStatus = HYP_ALREADY_EXIST;
+    return false;
+  }
+
+  const SMESHDS_Hypothesis *theHyp = hyps.front();
+
+  string hypName = theHyp->GetName();
+
+  theStatus = HYP_OK;
+
+  if (hypName == "ProjectionSource2D")
+  {
+    _sourceHypo = static_cast<const StdMeshers_ProjectionSource2D *>(theHyp);
+
+    // Check hypo parameters
+
+    SMESH_Mesh* srcMesh = _sourceHypo->GetSourceMesh();
+    SMESH_Mesh* tgtMesh = & theMesh;
+    if ( !srcMesh )
+      srcMesh = tgtMesh;
+
+    // check vertices
+    if ( _sourceHypo->HasVertexAssociation() )
+    {
+      // source vertices
+      TopoDS_Shape edge = TAssocTool::GetEdgeByVertices
+        ( srcMesh, _sourceHypo->GetSourceVertex(1), _sourceHypo->GetSourceVertex(2) );
+      if ( edge.IsNull() ||
+           !TAssocTool::IsSubShape( edge, srcMesh ) ||
+           !TAssocTool::IsSubShape( edge, _sourceHypo->GetSourceFace() ))
+      {
+        SCRUTE((edge.IsNull()));
+        SCRUTE((TAssocTool::IsSubShape( edge, srcMesh )));
+        SCRUTE((TAssocTool::IsSubShape( edge, _sourceHypo->GetSourceFace() )));
+        theStatus = HYP_BAD_PARAMETER;
+      }
+      else
+      {
+        // target vertices
+        edge = TAssocTool::GetEdgeByVertices
+          ( tgtMesh, _sourceHypo->GetTargetVertex(1), _sourceHypo->GetTargetVertex(2) );
+        if ( edge.IsNull() ||
+             !TAssocTool::IsSubShape( edge, tgtMesh ) ||
+             !TAssocTool::IsSubShape( edge, theShape ))
+        {
+          SCRUTE((edge.IsNull()));
+          SCRUTE((TAssocTool::IsSubShape( edge, tgtMesh )));
+          SCRUTE((TAssocTool::IsSubShape( edge, theShape )));
+          theStatus = HYP_BAD_PARAMETER;
+        }
+      }
+    }
+    // check a source face
+    if ( !TAssocTool::IsSubShape( _sourceHypo->GetSourceFace(), srcMesh )) {
+      MESSAGE("Bad source face"); 
+      theStatus = HYP_BAD_PARAMETER;
+    }
+  }
+  else
+  {
+    theStatus = HYP_INCOMPATIBLE;
+  }
+  return ( theStatus == HYP_OK );
+}
+
+namespace {
+
+
+  //================================================================================
+  /*!
+   * \brief define if a node is new or old
+    * \param node - node to check
+    * \retval bool - true if the node existed before Compute() is called
+   */
+  //================================================================================
+
+  bool isOldNode( const SMDS_MeshNode* node )
+  {
+    // old nodes are shared by edges and new ones are shared
+    // only by faces created by mapper
+    bool isOld = false;
+    SMDS_ElemIteratorPtr invElem = node->GetInverseElementIterator();
+    while ( !isOld && invElem->more() )
+      isOld = ( invElem->next()->GetType() == SMDSAbs_Edge );
+    return isOld;
+  }
+
+  //================================================================================
+  /*!
+   * \brief Class to remove mesh built by pattern mapper on edges
+   * and vertices in the case of failure of projection algo.
+   * It does it's job at destruction
+   */
+  //================================================================================
+
+  class MeshCleaner {
+    SMESH_subMesh* sm;
+  public:
+    MeshCleaner( SMESH_subMesh* faceSubMesh ): sm(faceSubMesh) {}
+    ~MeshCleaner() { Clean(sm); }
+    void Release() { sm = 0; } // mesh will not be removed
+    static void Clean( SMESH_subMesh* sm )
+    {
+      if ( !sm ) return;
+      switch ( sm->GetSubShape().ShapeType() ) {
+      case TopAbs_VERTEX:
+      case TopAbs_EDGE: {
+        SMDS_NodeIteratorPtr nIt = sm->GetSubMeshDS()->GetNodes();
+        SMESHDS_Mesh* mesh = sm->GetFather()->GetMeshDS();
+        while ( nIt->more() ) {
+          const SMDS_MeshNode* node = nIt->next();
+          if ( !isOldNode( node ) )
+            mesh->RemoveNode( node );
+        }
+        // do not break but iterate over DependsOn()
+      }
+      default:
+        const map< int, SMESH_subMesh * >& subSM = sm->DependsOn();
+        map< int, SMESH_subMesh * >::const_iterator i_sm = subSM.begin();
+        for ( ; i_sm != subSM.end(); ++i_sm )
+          Clean( i_sm->second );
+      }
+    }
+  };
+
+  //================================================================================
+  /*!
+   * \brief find new nodes belonging to one free border of mesh on face
+    * \param sm - submesh on edge or vertex containg nodes to choose from
+    * \param face - the face bound the submesh
+    * \param u2nodes - map to fill with nodes
+    * \param seamNodes - set of found nodes
+    * \retval bool - is a success
+   */
+  //================================================================================
+
+  bool getBoundaryNodes ( SMESH_subMesh*                        sm,
+                          const TopoDS_Face&                    face,
+                          map< double, const SMDS_MeshNode* > & u2nodes,
+                          set< const SMDS_MeshNode* > &         seamNodes)
+  {
+    u2nodes.clear();
+    seamNodes.clear();
+    if ( !sm || !sm->GetSubMeshDS() )
+      RETURN_BAD_RESULT("Null submesh");
+
+    SMDS_NodeIteratorPtr nIt = sm->GetSubMeshDS()->GetNodes();
+    switch ( sm->GetSubShape().ShapeType() ) {
+
+    case TopAbs_VERTEX: {
+      while ( nIt->more() ) {
+        const SMDS_MeshNode* node = nIt->next();
+        if ( isOldNode( node ) ) continue;
+        u2nodes.insert( make_pair( 0., node ));
+        seamNodes.insert( node );
+        return true;
+      }
+      break;
+    }
+    case TopAbs_EDGE: {
+      
+      // Get submeshes of sub-vertices
+      const map< int, SMESH_subMesh * >& subSM = sm->DependsOn();
+      if ( subSM.size() != 2 )
+        RETURN_BAD_RESULT("there must be 2 submeshes of sub-vertices"
+                          " but we have " << subSM.size());
+      SMESH_subMesh* smV1 = subSM.begin()->second;
+      SMESH_subMesh* smV2 = subSM.rbegin()->second;
+      if ( !smV1->IsMeshComputed() || !smV2->IsMeshComputed() )
+        RETURN_BAD_RESULT("Empty vertex submeshes");
+
+      // Look for a new node on V1
+      nIt = smV1->GetSubMeshDS()->GetNodes();
+      const SMDS_MeshNode* nV1 = 0;
+      while ( nIt->more() && !nV1 ) {
+        const SMDS_MeshNode* node = nIt->next();
+        if ( !isOldNode( node ) ) nV1 = node;
+      }
+      if ( !nV1 )
+        RETURN_BAD_RESULT("No new node found on V1");
+
+      // Find a new node connected to nV1 and belonging to edge submesh;
+      const SMDS_MeshNode* nE = 0;
+      SMESHDS_SubMesh* smDS = sm->GetSubMeshDS();
+      SMDS_ElemIteratorPtr vElems = nV1->GetInverseElementIterator();
+      while ( vElems->more() && !nE ) {
+        const SMDS_MeshElement* elem = vElems->next();
+        if ( elem->GetType() != SMDSAbs_Face )
+          continue; // new nodes are shared by faces
+        int nbNodes = elem->NbNodes();
+        if ( elem->IsQuadratic() )
+          nbNodes /= 2;
+        int iV1 = elem->GetNodeIndex( nV1 );
+        // try next aftre nV1
+        int iE = SMESH_MesherHelper::WrapIndex( iV1 + 1, nbNodes );
+        if ( smDS->Contains( elem->GetNode( iE ) ))
+          nE = elem->GetNode( iE );
+        if ( !nE ) {
+          // try node before nV1
+          iE = SMESH_MesherHelper::WrapIndex( iV1 - 1, nbNodes );
+          if ( smDS->Contains( elem->GetNode( iE )))
+            nE = elem->GetNode( iE );
+        }
+        if ( nE && elem->IsQuadratic() ) { // find medium node between nV1 and nE
+          if ( Abs( iV1 - iE ) == 1 )
+            nE = elem->GetNode( Min ( iV1, iE ) + nbNodes );
+          else
+            nE = elem->GetNode( elem->NbNodes() - 1 );
+        }
+      }
+      if ( !nE )
+        RETURN_BAD_RESULT("new node on edge not found");
+
+      // Get the whole free border of a face
+      list< const SMDS_MeshNode* > bordNodes;
+      list< const SMDS_MeshElement* > bordFaces;
+      if ( !SMESH_MeshEditor::FindFreeBorder (nV1, nE, nV1, bordNodes, bordFaces ))
+        RETURN_BAD_RESULT("free border of a face not found by nodes " <<
+                          nV1->GetID() << " " << nE->GetID() );
+
+      // Insert nodes of the free border to the map until node on V2 encountered
+      SMESHDS_SubMesh* v2smDS = smV2->GetSubMeshDS();
+      list< const SMDS_MeshNode* >::iterator bordIt = bordNodes.begin();
+      bordIt++; // skip nV1
+      for ( ; bordIt != bordNodes.end(); ++bordIt ) {
+        const SMDS_MeshNode* node = *bordIt;
+        if ( v2smDS->Contains( node ))
+          break;
+        if ( node->GetPosition()->GetTypeOfPosition() != SMDS_TOP_EDGE )
+          RETURN_BAD_RESULT("Bad node position type: node " << node->GetID() <<
+                            " pos type " << node->GetPosition()->GetTypeOfPosition());
+        const SMDS_EdgePosition* pos =
+          static_cast<const SMDS_EdgePosition*>(node->GetPosition().get());
+        u2nodes.insert( make_pair( pos->GetUParameter(), node ));
+        seamNodes.insert( node );
+      }
+      if ( u2nodes.size() != seamNodes.size() )
+        RETURN_BAD_RESULT("Bad node params on edge " << sm->GetId() <<
+                          ", " << u2nodes.size() << " != " << seamNodes.size() );
+      return true;
+    }
+    default:;
+    }
+    RETURN_BAD_RESULT ("Unexpected submesh type");
+
+  } // bool getBoundaryNodes()
+
+} // namespace
+
+//=======================================================================
+//function : Compute
+//purpose  : 
+//=======================================================================
+
+bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape& theShape)
+{
+  if ( !_sourceHypo )
+    return false;
+
+  TopoDS_Face tgtFace = TopoDS::Face( theShape.Oriented(TopAbs_FORWARD));
+  TopoDS_Face srcFace = TopoDS::Face( _sourceHypo->GetSourceFace().Oriented(TopAbs_FORWARD));
+
+  SMESH_Mesh * srcMesh = _sourceHypo->GetSourceMesh(); 
+  SMESH_Mesh * tgtMesh = & theMesh;
+  if ( !srcMesh )
+    srcMesh = tgtMesh;
+
+  SMESHDS_Mesh * meshDS = theMesh.GetMeshDS();
+
+  SMESH_MesherHelper helper( theMesh );
+  helper.SetSubShape( tgtFace );
+
+  // ---------------------------
+  // Make subshapes association
+  // ---------------------------
+
+  TAssocTool::TShapeShapeMap shape2ShapeMap;
+  TAssocTool::InitVertexAssociation( _sourceHypo, shape2ShapeMap );
+  if ( !TAssocTool::FindSubShapeAssociation( tgtFace, tgtMesh, srcFace, srcMesh,
+                                             shape2ShapeMap) )
+    RETURN_BAD_RESULT("FindSubShapeAssociation failed");
+
+  // ----------------------------------------------
+  // Assure that mesh on a source Face is computed
+  // ----------------------------------------------
+
+  SMESH_subMesh* srcSubMesh = srcMesh->GetSubMesh( srcFace );
+  SMESH_subMesh* tgtSubMesh = tgtMesh->GetSubMesh( tgtFace );
+
+  if ( tgtMesh == srcMesh ) {
+    if ( !TAssocTool::MakeComputed( srcSubMesh ))
+      RETURN_BAD_RESULT("Impossible to compute the source mesh");
+  }
+  else {
+    if ( !srcSubMesh->IsMeshComputed() )
+      RETURN_BAD_RESULT("Source mesh is not computed");
+  }
+
+  // --------------------
+  // Prepare to mapping 
+  // --------------------
+
+  // Load pattern from the source face
+  SMESH_Pattern mapper;
+  mapper.Load( srcMesh, srcFace );
+  if ( mapper.GetErrorCode() != SMESH_Pattern::ERR_OK )
+    RETURN_BAD_RESULT("SMESH_Pattern::Load() failed");
+
+  // Find the first target vertex corresponding to first vertex of the <mapper>
+  // and <theReverse> flag needed to call mapper.Apply()
+
+  TopoDS_Vertex srcV1 = TopoDS::Vertex( mapper.GetSubShape( 1 ));
+  if ( srcV1.IsNull() )
+    RETURN_BAD_RESULT("Mesh is not bound to the face");
+  if ( !shape2ShapeMap.IsBound( srcV1 ))
+    RETURN_BAD_RESULT("Not associated vertices, srcV1 " << srcV1.TShape().operator->() );
+  TopoDS_Vertex tgtV1 = TopoDS::Vertex( shape2ShapeMap( srcV1 ));
+
+  if ( !TAssocTool::IsSubShape( srcV1, srcFace ))
+    RETURN_BAD_RESULT("Wrong srcV1 " << srcV1.TShape().operator->());
+  if ( !TAssocTool::IsSubShape( tgtV1, tgtFace ))
+    RETURN_BAD_RESULT("Wrong tgtV1 " << tgtV1.TShape().operator->());
+
+  // try to find out orientation by order of edges
+  bool reverse = false;
+  list< TopoDS_Edge > tgtEdges, srcEdges;
+  list< int > nbEdgesInWires;
+  SMESH_Block::GetOrderedEdges( tgtFace, tgtV1, tgtEdges, nbEdgesInWires);
+  SMESH_Block::GetOrderedEdges( srcFace, srcV1, srcEdges, nbEdgesInWires);
+  if ( nbEdgesInWires.front() > 1 ) // possible to find out
+  {
+    TopoDS_Edge srcE1 = srcEdges.front(), tgtE1 = tgtEdges.front();
+    reverse = ( ! srcE1.IsSame( shape2ShapeMap( tgtE1 )));
+    if ( BRep_Tool::IsClosed( tgtE1, tgtFace )) {
+      reverse = ( srcE1.Orientation() == tgtE1.Orientation() );
+      if ( _sourceHypo->GetSourceFace().Orientation() != theShape.Orientation() )
+        reverse = !reverse;
+    }
+  }
+  else if ( nbEdgesInWires.front() == 1 )
+  {
+    // TODO::Compare orientation of curves in a sole edge
+    //RETURN_BAD_RESULT("Not implemented case");
+  }
+  else
+  {
+    RETURN_BAD_RESULT("Bad result from SMESH_Block::GetOrderedEdges()");
+  }
+
+  // --------------------
+  // Perform 2D mapping 
+  // --------------------
+
+  // Compute mesh on a target face
+
+  mapper.Apply( tgtFace, tgtV1, reverse );
+  if ( mapper.GetErrorCode() != SMESH_Pattern::ERR_OK )
+    RETURN_BAD_RESULT("SMESH_Pattern::Apply() failed");
+
+  // Create the mesh
+
+  const bool toCreatePolygons = false, toCreatePolyedrs = false;
+  mapper.MakeMesh( tgtMesh, toCreatePolygons, toCreatePolyedrs );
+  if ( mapper.GetErrorCode() != SMESH_Pattern::ERR_OK )
+    RETURN_BAD_RESULT("SMESH_Pattern::MakeMesh() failed");
+
+  // it will remove mesh built by pattern mapper on edges and vertices
+  // in failure case
+  MeshCleaner cleaner( tgtSubMesh );
+
+  // -------------------------------------------------------------------------
+  // mapper doesn't take care of nodes already existing on edges and vertices,
+  // so we must merge nodes created by it with existing ones 
+  // -------------------------------------------------------------------------
+
+  SMESH_MeshEditor editor( tgtMesh );
+  SMESH_MeshEditor::TListOfListOfNodes groupsOfNodes;
+
+  // Make groups of nodes to merge
+
+  // loop on edge and vertex submeshes of a target face
+  const map< int, SMESH_subMesh * >& subSM = tgtSubMesh->DependsOn();
+  map< int, SMESH_subMesh * >::const_iterator i_subSM = subSM.begin();
+  for ( ; i_subSM != subSM.end(); ++i_subSM )
+  {
+    SMESH_subMesh*     sm = i_subSM->second;
+    SMESHDS_SubMesh* smDS = sm->GetSubMeshDS();
+
+    // Sort new and old nodes of a submesh separately
+
+    bool isSeam = helper.IsSeamShape( sm->GetId() );
+
+    enum { NEW_NODES, OLD_NODES };
+    map< double, const SMDS_MeshNode* > u2nodesMaps[2], u2nodesOnSeam;
+    map< double, const SMDS_MeshNode* >::iterator u_oldNode, u_newNode, u_newOnSeam, newEnd;
+    set< const SMDS_MeshNode* > seamNodes;
+
+    // mapper puts on a seam edge nodes from 2 edges
+    if ( isSeam && ! getBoundaryNodes ( sm, tgtFace, u2nodesOnSeam, seamNodes ))
+      RETURN_BAD_RESULT("getBoundaryNodes() failed");
+
+    SMDS_NodeIteratorPtr nIt = smDS->GetNodes();
+    while ( nIt->more() )
+    {
+      const SMDS_MeshNode* node = nIt->next();
+      bool isOld = isOldNode( node );
+
+      if ( !isOld && isSeam ) { // new node on a seam edge
+        if ( seamNodes.find( node ) != seamNodes.end())
+          continue; // node is already in the map
+      }
+
+      // sort nodes on edges by its position
+      map< double, const SMDS_MeshNode* > & pos2nodes = u2nodesMaps[ isOld ];
+      switch ( node->GetPosition()->GetTypeOfPosition() )
+      {
+      case  SMDS_TOP_VERTEX: {
+        pos2nodes.insert( make_pair( 0, node ));
+        break;
+      }
+      case  SMDS_TOP_EDGE:   {
+        const SMDS_EdgePosition* pos =
+          static_cast<const SMDS_EdgePosition*>(node->GetPosition().get());
+        pos2nodes.insert( make_pair( pos->GetUParameter(), node ));
+        break;
+      }
+      default:
+        RETURN_BAD_RESULT("Wrong node position type: "<<
+                          node->GetPosition()->GetTypeOfPosition());
+      }
+    }
+    if ( u2nodesMaps[ OLD_NODES ].size() != u2nodesMaps[ NEW_NODES ].size() )
+      RETURN_BAD_RESULT("Different nb of old and new nodes " <<
+                        u2nodesMaps[ OLD_NODES ].size() << " != " <<
+                        u2nodesMaps[ NEW_NODES ].size());
+    if ( isSeam && u2nodesMaps[ OLD_NODES ].size() != u2nodesOnSeam.size() )
+      RETURN_BAD_RESULT("Different nb of old and seam nodes " <<
+                        u2nodesMaps[ OLD_NODES ].size() << " != " << u2nodesOnSeam.size());
+
+    // Make groups of nodes to merge
+    u_oldNode = u2nodesMaps[ OLD_NODES ].begin(); 
+    u_newNode = u2nodesMaps[ NEW_NODES ].begin();
+    newEnd    = u2nodesMaps[ NEW_NODES ].end();
+    u_newOnSeam = u2nodesOnSeam.begin();
+    for ( ; u_newNode != newEnd; ++u_newNode, ++u_oldNode ) {
+      groupsOfNodes.push_back( list< const SMDS_MeshNode* >() );
+      groupsOfNodes.back().push_back( u_oldNode->second );
+      groupsOfNodes.back().push_back( u_newNode->second );
+      if ( isSeam )
+        groupsOfNodes.back().push_back( (u_newOnSeam++)->second );
+    }
+  }
+
+  // Merge
+
+  editor.MergeNodes( groupsOfNodes );
+
+  // ---------------------------
+  // Check elements orientation
+  // ---------------------------
+
+  TopoDS_Face face = tgtFace;
+  if ( !theMesh.IsMainShape( tgtFace ))
+  {
+    // find the main shape
+    TopoDS_Shape mainShape = meshDS->ShapeToMesh();
+    switch ( mainShape.ShapeType() ) {
+    case TopAbs_SHELL:
+    case TopAbs_SOLID: break;
+    default:
+      TopTools_ListIteratorOfListOfShape ancestIt = theMesh.GetAncestors( face );
+      for ( ; ancestIt.More(); ancestIt.Next() ) {
+        TopAbs_ShapeEnum type = ancestIt.Value().ShapeType();
+        if ( type == TopAbs_SOLID ) {
+          mainShape = ancestIt.Value();
+          break;
+        } else if ( type == TopAbs_SHELL ) {
+          mainShape = ancestIt.Value();
+        }
+      }
+    }
+    // find tgtFace in the main solid or shell to know it's true orientation.
+    TopExp_Explorer exp( mainShape, TopAbs_FACE );
+    for ( ; exp.More(); exp.Next() ) {
+      if ( tgtFace.IsSame( exp.Current() )) {
+        face = TopoDS::Face( exp.Current() );
+        break;
+      }
+    }
+  }
+  // Fix orientation
+  if ( SMESH_Algo::IsReversedSubMesh( face, meshDS ))
+  {
+    SMDS_ElemIteratorPtr eIt = meshDS->MeshElements( face )->GetElements();
+    while ( eIt->more() ) {
+      const SMDS_MeshElement* e = eIt->next();
+      if ( e->GetType() == SMDSAbs_Face && !editor.Reorient( e ))
+        RETURN_BAD_RESULT("Pb of SMESH_MeshEditor::Reorient()");
+    }
+  }
+
+  cleaner.Release(); // do not remove mesh
+
+  return true;
+}
+
+//=============================================================================
+/*!
+ * \brief Sets a default event listener to submesh of the source face
+  * \param subMesh - submesh where algo is set
+ *
+ * This method is called when a submesh gets HYP_OK algo_state.
+ * After being set, event listener is notified on each event of a submesh.
+ * Arranges that CLEAN event is translated from source submesh to
+ * the submesh
+ */
+//=============================================================================
+
+void StdMeshers_Projection_2D::SetEventListener(SMESH_subMesh* subMesh)
+{
+  if ( _sourceHypo && ! _sourceHypo->GetSourceFace().IsNull() )
+  {
+    SMESH_Mesh* srcMesh = _sourceHypo->GetSourceMesh();
+    if ( !srcMesh )
+      srcMesh = subMesh->GetFather();
+
+    SMESH_subMesh* srcFaceSM =
+      srcMesh->GetSubMesh( _sourceHypo->GetSourceFace() );
+
+    subMesh->SetEventListener( new SMESH_subMeshEventListener(),
+                               SMESH_subMeshEventListenerData::MakeData( subMesh ),
+                               srcFaceSM );
+  }
+}

src/StdMeshers/StdMeshers_Projection_2D.hxx

@@ -0,0 +1,63 @@
+//  SMESH SMESH : implementaion of SMESH idl descriptions
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+//  File   : StdMeshers_Projection_2D.hxx
+//  Module : SMESH
+
+#ifndef _SMESH_Projection_2D_HXX_
+#define _SMESH_Projection_2D_HXX_
+
+#include "SMESH_2D_Algo.hxx"
+
+class StdMeshers_ProjectionSource2D;
+
+class StdMeshers_Projection_2D: public SMESH_2D_Algo
+{
+public:
+  StdMeshers_Projection_2D(int hypId, int studyId, SMESH_Gen* gen);
+  virtual ~StdMeshers_Projection_2D();
+
+  virtual bool CheckHypothesis(SMESH_Mesh&                          aMesh,
+                               const TopoDS_Shape&                  aShape,
+                               SMESH_Hypothesis::Hypothesis_Status& aStatus);
+
+  virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
+
+  /*!
+   * \brief Sets a default event listener to submesh of the source face
+   *  \param whenSetToSubMesh - submesh where algo is set
+   *
+   * After being set, event listener is notified on each event of a submesh.
+   * This method is called when a submesh gets HYP_OK algo_state.
+   * Arranges that CLEAN event is translated from source submesh to
+   * the whenSetToSubMesh submesh.
+   */
+  virtual void SetEventListener(SMESH_subMesh* whenSetToSubMesh);
+  
+protected:
+
+  const StdMeshers_ProjectionSource2D* _sourceHypo;
+
+};
+
+#endif

src/StdMeshers/StdMeshers_Projection_3D.cxx

@@ -0,0 +1,438 @@
+//  SMESH SMESH : implementaion of SMESH idl descriptions
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+// File      : StdMeshers_Projection_3D.cxx
+// Module    : SMESH
+// Created   : Fri Oct 20 11:37:07 2006
+// Author    : Edward AGAPOV (eap)
+
+
+#include "StdMeshers_Projection_3D.hxx"
+#include "StdMeshers_ProjectionSource3D.hxx"
+
+#include "StdMeshers_ProjectionUtils.hxx"
+
+#include "SMESHDS_Hypothesis.hxx"
+#include "SMESHDS_SubMesh.hxx"
+#include "SMESH_Block.hxx"
+#include "SMESH_Gen.hxx"
+#include "SMESH_Mesh.hxx"
+#include "SMESH_MeshEditor.hxx"
+#include "SMESH_Pattern.hxx"
+#include "SMESH_subMesh.hxx"
+#include "SMESH_subMeshEventListener.hxx"
+#include "SMESH_MesherHelper.hxx"
+#include "SMDS_VolumeTool.hxx"
+#include "SMDS_PolyhedralVolumeOfNodes.hxx"
+
+#include "utilities.h"
+
+#define RETURN_BAD_RESULT(msg) { MESSAGE(msg); return false; }
+#define gpXYZ(n) gp_XYZ(n->X(),n->Y(),n->Z())
+#define SHOWYXZ(msg, xyz) // {\
+// gp_Pnt p (xyz); \
+// cout << msg << " ("<< p.X() << "; " <<p.Y() << "; " <<p.Z() << ") " <<endl;\
+// }
+
+typedef StdMeshers_ProjectionUtils TAssocTool;
+
+
+//=======================================================================
+//function : StdMeshers_Projection_3D
+//purpose  : 
+//=======================================================================
+
+StdMeshers_Projection_3D::StdMeshers_Projection_3D(int hypId, int studyId, SMESH_Gen* gen)
+  :SMESH_3D_Algo(hypId, studyId, gen)
+{
+  _name = "Projection_3D";
+  _shapeType = (1 << TopAbs_SHELL) | (1 << TopAbs_SOLID);	// 1 bit per shape type
+
+  _compatibleHypothesis.push_back("ProjectionSource3D");
+  _sourceHypo = 0;
+}
+
+//================================================================================
+/*!
+ * \brief Destructor
+ */
+//================================================================================
+
+StdMeshers_Projection_3D::~StdMeshers_Projection_3D()
+{}
+
+//=======================================================================
+//function : CheckHypothesis
+//purpose  : 
+//=======================================================================
+
+bool StdMeshers_Projection_3D::CheckHypothesis(SMESH_Mesh&                          aMesh,
+                                               const TopoDS_Shape&                  aShape,
+                                               SMESH_Hypothesis::Hypothesis_Status& aStatus)
+{
+  // check aShape that must be a 6 faces block
+  if ( TAssocTool::Count( aShape, TopAbs_SHELL, 1 ) != 1 ||
+       TAssocTool::Count( aShape, TopAbs_FACE , 1 ) != 6 ||
+       TAssocTool::Count( aShape, TopAbs_EDGE , 1 ) != 12 ||
+       TAssocTool::Count( aShape, TopAbs_WIRE , 1 ) != 6 )
+  {
+    aStatus = HYP_BAD_GEOMETRY;
+    return false;
+  }
+
+  list <const SMESHDS_Hypothesis * >::const_iterator itl;
+
+  const list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(aMesh, aShape);
+  if ( hyps.size() == 0 )
+  {
+    aStatus = SMESH_Hypothesis::HYP_MISSING;
+    return false;  // can't work with no hypothesis
+  }
+
+  if ( hyps.size() > 1 )
+  {
+    aStatus = SMESH_Hypothesis::HYP_ALREADY_EXIST;
+    return false;
+  }
+
+  const SMESHDS_Hypothesis *theHyp = hyps.front();
+
+  string hypName = theHyp->GetName();
+
+  aStatus = SMESH_Hypothesis::HYP_OK;
+
+  if (hypName == "ProjectionSource3D")
+  {
+    _sourceHypo = static_cast<const StdMeshers_ProjectionSource3D *>(theHyp);
+    // Check hypo parameters
+
+    SMESH_Mesh* srcMesh = _sourceHypo->GetSourceMesh();
+    SMESH_Mesh* tgtMesh = & aMesh;
+    if ( !srcMesh )
+      srcMesh = tgtMesh;
+
+    // check vertices
+    if ( _sourceHypo->HasVertexAssociation() )
+    {
+      // source vertices
+      TopoDS_Shape edge = TAssocTool::GetEdgeByVertices
+        ( srcMesh, _sourceHypo->GetSourceVertex(1), _sourceHypo->GetSourceVertex(2) );
+      if ( edge.IsNull() ||
+           !TAssocTool::IsSubShape( edge, srcMesh ) ||
+           !TAssocTool::IsSubShape( edge, _sourceHypo->GetSource3DShape() ))
+      {
+        SCRUTE((edge.IsNull()));
+        SCRUTE((TAssocTool::IsSubShape( edge, srcMesh )));
+        SCRUTE((TAssocTool::IsSubShape( edge, _sourceHypo->GetSource3DShape() )));
+        aStatus = SMESH_Hypothesis::HYP_BAD_PARAMETER;
+      }
+      else
+      {
+        // target vertices
+        edge = TAssocTool::GetEdgeByVertices
+          ( tgtMesh, _sourceHypo->GetTargetVertex(1), _sourceHypo->GetTargetVertex(2) );
+        if ( edge.IsNull() ||
+             !TAssocTool::IsSubShape( edge, tgtMesh ) ||
+             !TAssocTool::IsSubShape( edge, aShape ))
+        {
+          SCRUTE((edge.IsNull()));
+          SCRUTE((TAssocTool::IsSubShape( edge, tgtMesh )));
+          SCRUTE((TAssocTool::IsSubShape( edge, aShape )));
+          aStatus = SMESH_Hypothesis::HYP_BAD_PARAMETER;
+        }
+      }
+    }
+    // check a source shape
+    if ( !TAssocTool::IsSubShape( _sourceHypo->GetSource3DShape(), srcMesh ) ||
+         ( srcMesh == tgtMesh && aShape == _sourceHypo->GetSource3DShape()))
+    {
+      SCRUTE((TAssocTool::IsSubShape( _sourceHypo->GetSource3DShape(), srcMesh)));
+      SCRUTE((srcMesh == tgtMesh));
+      SCRUTE((aShape == _sourceHypo->GetSource3DShape()));
+      aStatus = SMESH_Hypothesis::HYP_BAD_PARAMETER;
+    }
+  }
+  else
+  {
+    aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
+  }
+  return ( aStatus == HYP_OK );
+}
+
+//=======================================================================
+//function : Compute
+//purpose  : 
+//=======================================================================
+
+bool StdMeshers_Projection_3D::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
+{
+  if ( !_sourceHypo )
+    return false;
+
+  SMESH_Mesh * srcMesh = _sourceHypo->GetSourceMesh();
+  SMESH_Mesh * tgtMesh = & aMesh;
+  if ( !srcMesh )
+    srcMesh = tgtMesh;
+
+  SMESHDS_Mesh * srcMeshDS = srcMesh->GetMeshDS();
+  SMESHDS_Mesh * tgtMeshDS = tgtMesh->GetMeshDS();
+
+  // get shell from shape3D
+  TopoDS_Shell srcShell, tgtShell;
+  TopExp_Explorer exp( _sourceHypo->GetSource3DShape(), TopAbs_SHELL );
+  int nbShell;
+  for ( nbShell = 0; exp.More(); exp.Next(), ++nbShell )
+    srcShell = TopoDS::Shell( exp.Current() );
+  if ( nbShell != 1 )
+    RETURN_BAD_RESULT("There must be 1 shell in the source shape");
+
+  exp.Init( aShape, TopAbs_SHELL );
+  for ( nbShell = 0; exp.More(); exp.Next(), ++nbShell )
+    tgtShell = TopoDS::Shell( exp.Current() );
+  if ( nbShell != 1 )
+    RETURN_BAD_RESULT("There must be 1 shell in the target shape");
+
+  // Assure that mesh on a source shape is computed
+
+  SMESH_subMesh* srcSubMesh = srcMesh->GetSubMesh( _sourceHypo->GetSource3DShape() );
+  //SMESH_subMesh* tgtSubMesh = tgtMesh->GetSubMesh( aShape );
+
+  if ( tgtMesh == srcMesh && !aShape.IsSame( _sourceHypo->GetSource3DShape() )) {
+    if ( !TAssocTool::MakeComputed( srcSubMesh ))
+      RETURN_BAD_RESULT("Impossible to compute the source mesh");
+  }
+  else {
+    if ( !srcSubMesh->IsMeshComputed() )
+      RETURN_BAD_RESULT("Source mesh is not computed");
+  }
+
+  // Find 2 pairs of corresponding vertices
+
+  TopoDS_Vertex tgtV000, tgtV100, srcV000, srcV100;
+  TAssocTool::TShapeShapeMap shape2ShapeMap;
+
+  if ( _sourceHypo->HasVertexAssociation() )
+  {
+    tgtV000 = _sourceHypo->GetTargetVertex(1);
+    tgtV100 = _sourceHypo->GetTargetVertex(2);
+    srcV000 = _sourceHypo->GetSourceVertex(1);
+    srcV100 = _sourceHypo->GetSourceVertex(2);
+  }
+  else
+  {
+    if ( !TAssocTool::FindSubShapeAssociation( tgtShell, tgtMesh, srcShell, srcMesh,
+                                               shape2ShapeMap) )
+      RETURN_BAD_RESULT("FindSubShapeAssociation() failed");
+
+    exp.Init( tgtShell, TopAbs_EDGE );
+    TopExp::Vertices( TopoDS::Edge( exp.Current() ), tgtV000, tgtV100 );
+
+    if ( !shape2ShapeMap.IsBound( tgtV000 ) || !shape2ShapeMap.IsBound( tgtV100 ))
+      RETURN_BAD_RESULT("Shape associating not done");
+    srcV000 = TopoDS::Vertex( shape2ShapeMap( tgtV000 ));
+    srcV100 = TopoDS::Vertex( shape2ShapeMap( tgtV100 ));
+    if ( !TAssocTool::IsSubShape( srcV000, srcShell ) ||
+         !TAssocTool::IsSubShape( srcV100, srcShell ))
+      RETURN_BAD_RESULT("Wrong target vertices");
+  }
+
+  // Load 2 SMESH_Block's with src and tgt shells
+
+  SMESH_Block srcBlock, tgtBlock;
+  TopTools_IndexedMapOfOrientedShape scrShapes, tgtShapes;
+  if ( !tgtBlock.LoadBlockShapes( tgtShell, tgtV000, tgtV100, tgtShapes ))
+    RETURN_BAD_RESULT("SMESH_Block::LoadBlockShapes(tgtShell) failed");
+
+  if ( !srcBlock.LoadBlockShapes( srcShell, srcV000, srcV100, scrShapes ))
+    RETURN_BAD_RESULT("SMESH_Block::LoadBlockShapes(srcShell) failed");
+
+  // Find matching nodes of src and tgt shells
+
+  TNodeNodeMap src2tgtNodeMap;
+  for ( int fId = SMESH_Block::ID_FirstF; fId < SMESH_Block::ID_Shell; ++fId )
+  {
+    // Corresponding subshapes
+    TopoDS_Face srcFace = TopoDS::Face( scrShapes( fId ));
+    TopoDS_Face tgtFace = TopoDS::Face( tgtShapes( fId ));
+    if ( _sourceHypo->HasVertexAssociation() ) { // associate face subshapes
+      shape2ShapeMap.Clear();
+      vector< int > edgeIdVec;
+      SMESH_Block::GetFaceEdgesIDs( fId, edgeIdVec );
+      for ( int i = 0; i < edgeIdVec.size(); ++i ) {
+        int eID = edgeIdVec[ i ];
+        shape2ShapeMap.Bind( tgtShapes( eID ), scrShapes( eID ));
+        if ( i < 2 ) {
+          vector< int > vertexIdVec;
+          SMESH_Block::GetEdgeVertexIDs( eID, vertexIdVec );
+          shape2ShapeMap.Bind( tgtShapes( vertexIdVec[0] ), scrShapes( vertexIdVec[0] ));
+          shape2ShapeMap.Bind( tgtShapes( vertexIdVec[1] ), scrShapes( vertexIdVec[1] ));
+        }
+      }
+    }
+    // Find matching nodes of tgt and src faces
+    TNodeNodeMap faceMatchingNodes;
+    if ( ! TAssocTool::FindMatchingNodesOnFaces( srcFace, srcMesh, tgtFace, tgtMesh, 
+                                                 shape2ShapeMap, faceMatchingNodes ))
+      RETURN_BAD_RESULT("Different mesh on corresponding src and tgt faces: "
+                        << srcMeshDS->ShapeToIndex( srcFace ) << " and "
+                        << tgtMeshDS->ShapeToIndex( tgtFace ));
+
+    // put found matching nodes of 2 faces to the global map
+    src2tgtNodeMap.insert( faceMatchingNodes.begin(), faceMatchingNodes.end() );
+  }
+
+  // ------------------
+  // Make mesh
+  // ------------------
+
+  SMDS_VolumeTool volTool;
+  SMESH_MesherHelper helper( *tgtMesh );
+  helper.IsQuadraticSubMesh( aShape );
+
+  SMESHDS_SubMesh* srcSMDS = srcSubMesh->GetSubMeshDS();
+  SMDS_ElemIteratorPtr volIt = srcSMDS->GetElements();
+  while ( volIt->more() ) // loop on source volumes
+  {
+    const SMDS_MeshElement* srcVol = volIt->next();
+    if ( !srcVol || srcVol->GetType() != SMDSAbs_Volume )
+        continue;
+    int nbNodes = srcVol->NbNodes();
+    SMDS_VolumeTool::VolumeType  volType = volTool.GetType( nbNodes );
+    if ( srcVol->IsQuadratic() )
+      nbNodes = volTool.NbCornerNodes( volType );
+
+    // Find or create a new tgt node for each node of a src volume
+
+    vector< const SMDS_MeshNode* > nodes( nbNodes );
+    for ( int i = 0; i < nbNodes; ++i )
+    {
+      const SMDS_MeshNode* srcNode = srcVol->GetNode( i );
+      const SMDS_MeshNode* tgtNode = 0;
+      TNodeNodeMap::iterator sN_tN = src2tgtNodeMap.find( srcNode );
+      if ( sN_tN != src2tgtNodeMap.end() ) // found
+      {
+        tgtNode = sN_tN->second;
+      }
+      else // Create a new tgt node
+      {
+        // compute normalized parameters of source node in srcBlock
+        gp_Pnt srcCoord = gpXYZ( srcNode );
+        gp_XYZ srcParam;
+        if ( !srcBlock.ComputeParameters( srcCoord, srcParam ))
+          RETURN_BAD_RESULT("srcBlock.ComputeParameters() failed");
+        // compute coordinates of target node by srcParam
+        gp_XYZ tgtXYZ;
+        if ( !tgtBlock.ShellPoint( srcParam, tgtXYZ ))
+          RETURN_BAD_RESULT("tgtBlock.ShellPoint() failed");
+        // add node
+        SMDS_MeshNode* newNode = tgtMeshDS->AddNode( tgtXYZ.X(), tgtXYZ.Y(), tgtXYZ.Z() );
+        tgtMeshDS->SetNodeInVolume( newNode, helper.GetSubShapeID() );
+        tgtNode = newNode;
+        src2tgtNodeMap.insert( make_pair( srcNode, tgtNode ));
+      }
+      nodes[ i ] = tgtNode;
+    }
+
+    // Create a new volume
+
+    SMDS_MeshVolume * tgtVol = 0;
+    switch ( volType ) {
+    case SMDS_VolumeTool::TETRA     :
+    case SMDS_VolumeTool::QUAD_TETRA:
+      tgtVol = helper.AddVolume( nodes[0],
+                                 nodes[1],
+                                 nodes[2],
+                                 nodes[3]); break;
+    case SMDS_VolumeTool::PYRAM     :
+    case SMDS_VolumeTool::QUAD_PYRAM:
+      tgtVol = helper.AddVolume( nodes[0],
+                                 nodes[1],
+                                 nodes[2],
+                                 nodes[3],
+                                 nodes[4]); break;
+    case SMDS_VolumeTool::PENTA     :
+    case SMDS_VolumeTool::QUAD_PENTA:
+      tgtVol = helper.AddVolume( nodes[0],
+                                 nodes[1],
+                                 nodes[2],
+                                 nodes[3],
+                                 nodes[4],
+                                 nodes[5]); break;
+    case SMDS_VolumeTool::HEXA      :
+    case SMDS_VolumeTool::QUAD_HEXA :
+      tgtVol = helper.AddVolume( nodes[0],
+                                 nodes[1],
+                                 nodes[2],
+                                 nodes[3],
+                                 nodes[4],
+                                 nodes[5],
+                                 nodes[6],
+                                 nodes[7]); break;
+    default: // polyhedron
+      const SMDS_PolyhedralVolumeOfNodes * poly =
+        dynamic_cast<const SMDS_PolyhedralVolumeOfNodes*>( srcVol );
+      if ( !poly )
+        RETURN_BAD_RESULT("Unexpected volume type");
+      vector<int> quantities( poly->NbFaces(), 0 );
+      for ( int i = 0; i < quantities.size(); ++i )
+        quantities[ i ] = poly->NbFaceNodes( i + 1 );
+      tgtVol = tgtMeshDS->AddPolyhedralVolume( nodes, quantities );
+    }
+    if ( tgtVol ) {
+      tgtMeshDS->SetMeshElementOnShape( tgtVol, helper.GetSubShapeID() );
+    }
+  } // loop on volumes of src shell
+
+  return true;
+}
+
+//=============================================================================
+/*!
+ * \brief Sets a default event listener to submesh of the source shape
+  * \param subMesh - submesh where algo is set
+ *
+ * This method is called when a submesh gets HYP_OK algo_state.
+ * After being set, event listener is notified on each event of a submesh.
+ * Arranges that CLEAN event is translated from source submesh to
+ * the submesh
+ */
+//=============================================================================
+
+void StdMeshers_Projection_3D::SetEventListener(SMESH_subMesh* subMesh)
+{
+  if ( _sourceHypo && ! _sourceHypo->GetSource3DShape().IsNull() )
+  {
+    SMESH_Mesh* srcMesh = _sourceHypo->GetSourceMesh();
+    if ( !srcMesh )
+      srcMesh = subMesh->GetFather();
+
+    SMESH_subMesh* srcShapeSM =
+      srcMesh->GetSubMesh( _sourceHypo->GetSource3DShape() );
+
+    if ( srcShapeSM != subMesh )
+      subMesh->SetEventListener( new SMESH_subMeshEventListener(),
+                                 SMESH_subMeshEventListenerData::MakeData( subMesh ),
+                                 srcShapeSM );
+  }
+}
+  

src/StdMeshers/StdMeshers_Projection_3D.hxx

@@ -0,0 +1,61 @@
+//  SMESH SMESH : implementaion of SMESH idl descriptions
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+//  File   : StdMeshers_Projection_3D.hxx
+//  Module : SMESH
+
+#ifndef _SMESH_Projection_3D_HXX_
+#define _SMESH_Projection_3D_HXX_
+
+#include "SMESH_3D_Algo.hxx"
+
+class StdMeshers_ProjectionSource3D;
+
+class StdMeshers_Projection_3D: public SMESH_3D_Algo
+{
+public:
+  StdMeshers_Projection_3D(int hypId, int studyId, SMESH_Gen* gen);
+  virtual ~StdMeshers_Projection_3D();
+
+  virtual bool CheckHypothesis(SMESH_Mesh&                          aMesh,
+                               const TopoDS_Shape&                  aShape,
+                               SMESH_Hypothesis::Hypothesis_Status& aStatus);
+
+  virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
+
+  /*!
+   * \brief Sets a default event listener to submesh of the source shape
+   *  \param whenSetToSubMesh - submesh where algo is set
+   *
+   * Arranges that CLEAN event is translated from source submesh to
+   * the whenSetToSubMesh submesh.
+   */
+  virtual void SetEventListener(SMESH_subMesh* whenSetToSubMesh);
+  
+protected:
+
+  const StdMeshers_ProjectionSource3D* _sourceHypo;
+
+};
+
+#endif

src/StdMeshers/StdMeshers_RadialPrism_3D.cxx

@@ -0,0 +1,372 @@
+//  SMESH SMESH : implementaion of SMESH idl descriptions
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+// File      : StdMeshers_RadialPrism_3D.cxx
+// Module    : SMESH
+// Created   : Fri Oct 20 11:37:07 2006
+// Author    : Edward AGAPOV (eap)
+
+
+#include "StdMeshers_RadialPrism_3D.hxx"
+
+#include "StdMeshers_ProjectionUtils.hxx"
+#include "StdMeshers_NumberOfLayers.hxx"
+#include "StdMeshers_LayerDistribution.hxx"
+#include "StdMeshers_Prism_3D.hxx"
+#include "StdMeshers_Regular_1D.hxx"
+
+#include "SMDS_MeshNode.hxx"
+#include "SMESHDS_SubMesh.hxx"
+#include "SMESH_Gen.hxx"
+#include "SMESH_Mesh.hxx"
+#include "SMESH_MeshEditor.hxx"
+#include "SMESH_MesherHelper.hxx"
+#include "SMESH_subMesh.hxx"
+
+#include "utilities.h"
+
+#include <TopoDS_Solid.hxx>
+#include <TopoDS_Shell.hxx>
+#include <BRepTools.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <gp.hxx>
+#include <gp_Pnt.hxx>
+
+
+using namespace std;
+
+#define RETURN_BAD_RESULT(msg) { MESSAGE(msg); return false; }
+#define gpXYZ(n) gp_XYZ(n->X(),n->Y(),n->Z())
+
+typedef StdMeshers_ProjectionUtils TAssocTool;
+
+//=======================================================================
+//function : StdMeshers_RadialPrism_3D
+//purpose  : 
+//=======================================================================
+
+StdMeshers_RadialPrism_3D::StdMeshers_RadialPrism_3D(int hypId, int studyId, SMESH_Gen* gen)
+  :SMESH_3D_Algo(hypId, studyId, gen)
+{
+  _name = "RadialPrism_3D";
+  _shapeType = (1 << TopAbs_SOLID);	// 1 bit per shape type
+
+  _compatibleHypothesis.push_back("LayerDistribution");
+  _compatibleHypothesis.push_back("NumberOfLayers");
+  myNbLayerHypo = 0;
+  myDistributionHypo = 0;
+}
+
+//================================================================================
+/*!
+ * \brief Destructor
+ */
+//================================================================================
+
+StdMeshers_RadialPrism_3D::~StdMeshers_RadialPrism_3D()
+{}
+
+//=======================================================================
+//function : CheckHypothesis
+//purpose  : 
+//=======================================================================
+
+bool StdMeshers_RadialPrism_3D::CheckHypothesis(SMESH_Mesh&                          aMesh,
+                                                const TopoDS_Shape&                  aShape,
+                                                SMESH_Hypothesis::Hypothesis_Status& aStatus)
+{
+  // check aShape that must have 2 shells
+  if ( TAssocTool::Count( aShape, TopAbs_SOLID, 0 ) != 1 ||
+       TAssocTool::Count( aShape, TopAbs_SHELL, 0 ) != 2 )
+  {
+    aStatus = HYP_BAD_GEOMETRY;
+    return false;
+  }
+
+  myNbLayerHypo = 0;
+  myDistributionHypo = 0;
+
+  list <const SMESHDS_Hypothesis * >::const_iterator itl;
+
+  const list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(aMesh, aShape);
+  if ( hyps.size() == 0 )
+  {
+    aStatus = SMESH_Hypothesis::HYP_MISSING;
+    return false;  // can't work with no hypothesis
+  }
+
+  if ( hyps.size() > 1 )
+  {
+    aStatus = SMESH_Hypothesis::HYP_ALREADY_EXIST;
+    return false;
+  }
+
+  const SMESHDS_Hypothesis *theHyp = hyps.front();
+
+  string hypName = theHyp->GetName();
+
+  if (hypName == "NumberOfLayers")
+  {
+    myNbLayerHypo = static_cast<const StdMeshers_NumberOfLayers *>(theHyp);
+    aStatus = SMESH_Hypothesis::HYP_OK;
+    return true;
+  }
+  if (hypName == "LayerDistribution")
+  {
+    myDistributionHypo = static_cast<const StdMeshers_LayerDistribution *>(theHyp);
+    aStatus = SMESH_Hypothesis::HYP_OK;
+    return true;
+  }
+  aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
+  return true;
+}
+
+//=======================================================================
+//function : Compute
+//purpose  : 
+//=======================================================================
+
+bool StdMeshers_RadialPrism_3D::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
+{
+  TopExp_Explorer exp;
+  SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
+
+  myHelper = new SMESH_MesherHelper( aMesh );
+  myHelper->IsQuadraticSubMesh( aShape );
+  // to delete helper at exit from Compute()
+  std::auto_ptr<SMESH_MesherHelper> helperDeleter( myHelper );
+
+  // get 2 shells 
+  TopoDS_Solid solid = TopoDS::Solid( aShape );
+  TopoDS_Shell outerShell = BRepTools::OuterShell( solid );
+  TopoDS_Shape innerShell;
+  int nbShells = 0;
+  for ( TopoDS_Iterator It (solid); It.More(); It.Next(), ++nbShells )
+    if ( !outerShell.IsSame( It.Value() ))
+      innerShell = It.Value();
+  if ( nbShells != 2 )
+    RETURN_BAD_RESULT("Must be 2 shells");
+
+  // ----------------------------------
+  // Associate subshapes of the shells
+  // ----------------------------------
+
+  TAssocTool::TShapeShapeMap shape2ShapeMap;
+  if ( !TAssocTool::FindSubShapeAssociation( outerShell, &aMesh,
+                                             innerShell, &aMesh,
+                                             shape2ShapeMap) )
+    RETURN_BAD_RESULT("FindSubShapeAssociation failed");
+
+  // ------------------
+  // Make mesh
+  // ------------------
+
+  TNode2ColumnMap node2columnMap;
+  myLayerPositions.clear();
+
+  for ( exp.Init( outerShell, TopAbs_FACE ); exp.More(); exp.Next() )
+  {
+    // Corresponding subshapes
+    TopoDS_Face outFace = TopoDS::Face( exp.Current() );
+    TopoDS_Face inFace;
+    if ( !shape2ShapeMap.IsBound( outFace )) {
+      RETURN_BAD_RESULT("Association not found for face " << meshDS->ShapeToIndex( outFace ));
+    } else {
+      inFace = TopoDS::Face( shape2ShapeMap( outFace ));
+    }
+
+    // Find matching nodes of in and out faces
+    TNodeNodeMap nodeIn2OutMap;
+    if ( ! TAssocTool::FindMatchingNodesOnFaces( inFace, &aMesh, outFace, &aMesh,
+                                                 shape2ShapeMap, nodeIn2OutMap ))
+      RETURN_BAD_RESULT("Different mesh on corresponding out and in faces: "
+                        << meshDS->ShapeToIndex( outFace ) << " and "
+                        << meshDS->ShapeToIndex( inFace ));
+    // Create volumes
+
+    SMDS_ElemIteratorPtr faceIt = meshDS->MeshElements( inFace )->GetElements();
+    while ( faceIt->more() ) // loop on faces on inFace
+    {
+      const SMDS_MeshElement* face = faceIt->next();
+      if ( !face || face->GetType() != SMDSAbs_Face )
+        continue;
+      int nbNodes = face->NbNodes();
+      if ( face->IsQuadratic() )
+        nbNodes /= 2;
+
+      // find node columns for each node
+      vector< const TNodeColumn* > columns( nbNodes );
+      for ( int i = 0; i < nbNodes; ++i )
+      {
+        const SMDS_MeshNode* n = face->GetNode( i );
+        TNode2ColumnMap::iterator n_col = node2columnMap.find( n );
+        if ( n_col != node2columnMap.end() )
+          columns[ i ] = & n_col->second;
+        else
+          columns[ i ] = makeNodeColumn( node2columnMap, n, nodeIn2OutMap[ n ] );
+      }
+
+      StdMeshers_Prism_3D::AddPrisms( columns, myHelper );
+    }
+  } // loop on faces of out shell
+
+  return true;
+}
+
+//================================================================================
+/*!
+ * \brief Create a column of nodes from outNode to inNode
+  * \param n2ColMap - map of node columns to add a created column
+  * \param outNode - botton node of a column
+  * \param inNode - top node of a column
+  * \retval const TNodeColumn* - a new column pointer
+ */
+//================================================================================
+
+TNodeColumn* StdMeshers_RadialPrism_3D::makeNodeColumn( TNode2ColumnMap&     n2ColMap,
+                                                        const SMDS_MeshNode* outNode,
+                                                        const SMDS_MeshNode* inNode)
+{
+  SMESHDS_Mesh * meshDS = myHelper->GetMeshDS();
+  int shapeID = myHelper->GetSubShapeID();
+
+  if ( myLayerPositions.empty() )
+    computeLayerPositions( gpXYZ( inNode ), gpXYZ( outNode ));
+
+  int nbSegments = myLayerPositions.size() + 1;
+
+  TNode2ColumnMap::iterator n_col =
+    n2ColMap.insert( make_pair( outNode, TNodeColumn() )).first;
+  TNodeColumn & column = n_col->second;
+  column.resize( nbSegments + 1 );
+  column.front() = outNode;
+  column.back() =  inNode;
+
+  gp_XYZ p1 = gpXYZ( outNode );
+  gp_XYZ p2 = gpXYZ( inNode );
+  for ( int z = 1; z < nbSegments; ++z )
+  {
+    double r = myLayerPositions[ z - 1 ];
+    gp_XYZ p = ( 1 - r ) * p1 + r * p2;
+    SMDS_MeshNode* n = meshDS->AddNode( p.X(), p.Y(), p.Z() );
+    meshDS->SetNodeInVolume( n, shapeID );
+    column[ z ] = n;
+  }
+
+  return & column;
+}
+
+//================================================================================
+//================================================================================
+/*!
+ * \brief Class computing layers distribution using data of
+ *        StdMeshers_LayerDistribution hypothesis
+ */
+//================================================================================
+//================================================================================
+
+class TNodeDistributor: private StdMeshers_Regular_1D
+{
+  list <const SMESHDS_Hypothesis *> myUsedHyps;
+public:
+  // -----------------------------------------------------------------------------
+  static TNodeDistributor* GetDistributor(SMESH_Mesh& aMesh)
+  {
+    const int myID = -1000;
+    map < int, SMESH_1D_Algo * > & algoMap = aMesh.GetGen()->_map1D_Algo;
+    map < int, SMESH_1D_Algo * >::iterator id_algo = algoMap.find( myID );
+    if ( id_algo == algoMap.end() )
+      return new TNodeDistributor( myID, 0, aMesh.GetGen() );
+    return static_cast< TNodeDistributor* >( id_algo->second );
+  }
+  // -----------------------------------------------------------------------------
+  bool Compute( vector< double > &                  positions,
+                gp_Pnt                              pIn,
+                gp_Pnt                              pOut,
+                SMESH_Mesh&                         aMesh,
+                const StdMeshers_LayerDistribution* hyp)
+  {
+    double len = pIn.Distance( pOut );
+    if ( len <= DBL_MIN ) RETURN_BAD_RESULT("Bad points");
+
+    if ( !hyp || !hyp->GetLayerDistribution() )
+      RETURN_BAD_RESULT("Bad StdMeshers_LayerDistribution hypothesis");
+    myUsedHyps.clear();
+    myUsedHyps.push_back( hyp->GetLayerDistribution() );
+
+    TopoDS_Edge edge = BRepBuilderAPI_MakeEdge( pIn, pOut );
+
+    SMESH_Hypothesis::Hypothesis_Status aStatus;
+    if ( !StdMeshers_Regular_1D::CheckHypothesis( aMesh, edge, aStatus ))
+      RETURN_BAD_RESULT("StdMeshers_Regular_1D::CheckHypothesis() failed with status "<<aStatus);
+
+    list< double > params;
+    if ( !StdMeshers_Regular_1D::computeInternalParameters( edge, params, false ))
+      RETURN_BAD_RESULT("StdMeshers_Regular_1D::computeInternalParameters() failed");
+
+    positions.clear();
+    positions.reserve( params.size() );
+    for (list<double>::iterator itU = params.begin(); itU != params.end(); itU++)
+      positions.push_back( *itU / len );
+    return true;
+  }
+protected:
+  // -----------------------------------------------------------------------------
+  TNodeDistributor( int hypId, int studyId, SMESH_Gen* gen)
+    : StdMeshers_Regular_1D( hypId, studyId, gen)
+  {
+  }
+  // -----------------------------------------------------------------------------
+  virtual const list <const SMESHDS_Hypothesis *> &
+    GetUsedHypothesis(SMESH_Mesh &, const TopoDS_Shape &, const bool)
+  {
+    return myUsedHyps;
+  }
+  // -----------------------------------------------------------------------------
+};
+
+//================================================================================
+/*!
+ * \brief Compute positions of nodes between the internal and the external surfaces
+  * \retval bool - is a success
+ */
+//================================================================================
+
+bool StdMeshers_RadialPrism_3D::computeLayerPositions(gp_Pnt pIn, gp_Pnt pOut)
+{
+  if ( myNbLayerHypo )
+  {
+    int nbSegments = myNbLayerHypo->GetNumberOfLayers();
+    myLayerPositions.resize( nbSegments - 1 );
+    for ( int z = 1; z < nbSegments; ++z )
+      myLayerPositions[ z - 1 ] = double( z )/ double( nbSegments );
+    return true;
+  }
+  if ( myDistributionHypo ) {
+    SMESH_Mesh * mesh = myHelper->GetMesh();
+    return TNodeDistributor::GetDistributor(*mesh)->Compute( myLayerPositions, pIn, pOut,
+                                                             *mesh, myDistributionHypo );
+  }
+  RETURN_BAD_RESULT("Bad hypothesis");  
+}

src/StdMeshers/StdMeshers_RadialPrism_3D.hxx

@@ -0,0 +1,70 @@
+//  SMESH SMESH : implementaion of SMESH idl descriptions
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+//
+//  File   : StdMeshers_RadialPrism_3D.hxx
+//  Module : SMESH
+
+#ifndef _SMESH_RadialPrism_3D_HXX_
+#define _SMESH_RadialPrism_3D_HXX_
+
+#include "SMESH_3D_Algo.hxx"
+#include "SMDS_MeshNode.hxx"
+
+#include <vector>
+#include <map>
+
+class StdMeshers_NumberOfLayers;
+class StdMeshers_LayerDistribution;
+class SMESH_MesherHelper;
+
+class StdMeshers_RadialPrism_3D: public SMESH_3D_Algo
+{
+public:
+  StdMeshers_RadialPrism_3D(int hypId, int studyId, SMESH_Gen* gen);
+  virtual ~StdMeshers_RadialPrism_3D();
+
+  virtual bool CheckHypothesis(SMESH_Mesh&                          aMesh,
+                               const TopoDS_Shape&                  aShape,
+                               SMESH_Hypothesis::Hypothesis_Status& aStatus);
+
+  virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
+
+protected:
+
+  typedef vector<const SMDS_MeshNode* >            TNodeColumn;
+  typedef map< const SMDS_MeshNode*, TNodeColumn > TNode2ColumnMap;
+
+  TNodeColumn* makeNodeColumn( TNode2ColumnMap&     n2ColMap,
+                               const SMDS_MeshNode* outNode,
+                               const SMDS_MeshNode* inNode);
+
+  bool computeLayerPositions(gp_Pnt pIn, gp_Pnt pOut);
+
+
+  const StdMeshers_NumberOfLayers*    myNbLayerHypo;
+  const StdMeshers_LayerDistribution* myDistributionHypo;
+  SMESH_MesherHelper*                 myHelper;
+  vector< double >                    myLayerPositions;
+};
+
+#endif