Implement sweep mesh elements along a path (PAL7218).

src/SMESH/SMESH_MeshEditor.cxx

@@ -41,6 +41,7 @@
 
 #include <TopTools_ListIteratorOfListOfShape.hxx>
 #include <TopTools_ListOfShape.hxx>
+#include <math.h>
 #include <gp_Dir.hxx>
 #include <gp_Vec.hxx>
 #include <gp_Ax1.hxx>
@@ -1943,11 +1944,13 @@ void SMESH_MeshEditor::ExtrusionSweep(set<const SMDS_MeshElement*> & theElems,
     // make new elements
     sweepElement( aMesh, elem, newNodesItVec, newElemsMap[elem] );
   }
-
   makeWalls( aMesh, mapNewNodes, newElemsMap, mapElemNewNodes, theElems );
-
 }
 
+//=======================================================================
+//class    : SMESH_MeshEditor_PathPoint
+//purpose  : auxiliary class 
+//=======================================================================
 class SMESH_MeshEditor_PathPoint {
 public:
   SMESH_MeshEditor_PathPoint() {
@@ -1992,7 +1995,8 @@ protected:
 //function : ExtrusionAlongTrack
 //purpose  : 
 //=======================================================================
-int SMESH_MeshEditor::ExtrusionAlongTrack (std::set<const SMDS_MeshElement*> & theElements,
+SMESH_MeshEditor::Extrusion_Error 
+  SMESH_MeshEditor::ExtrusionAlongTrack (std::set<const SMDS_MeshElement*> & theElements,
 					 SMESH_subMesh* theTrack,
 					 const SMDS_MeshNode* theN1,
 					 const bool theHasAngles,
@@ -2001,7 +2005,7 @@ int SMESH_MeshEditor::ExtrusionAlongTrack (std::set<const SMDS_MeshElement*> & t
 					 const gp_Pnt& theRefPoint)
 {
   MESSAGE("SMESH_MeshEditor::ExtrusionAlongTrack")
-  int j, iErr, aNbTP, aNbAngles, aNbE, aNb;
+  int j, aNbTP, aNbE, aNb;
   double aT1, aT2, aT, aAngle, aX, aY, aZ;
   std::list<double> aPrms;
   std::list<double>::iterator aItD;
@@ -2025,82 +2029,66 @@ int SMESH_MeshEditor::ExtrusionAlongTrack (std::set<const SMDS_MeshElement*> & t
 
   aTolVec=1.e-7;
   aTolVec2=aTolVec*aTolVec;
-  iErr=0;
 
   // 1. Check data
-  aNbE=theElements.size();
+  aNbE = theElements.size();
-  if ( !aNbE ) {
+  // nothing to do
-    iErr = 10; // nothing to do
+  if ( !aNbE )
-    return iErr;
+    return EXTR_NO_ELEMENTS;
-  }
 
   // 1.1 Track Pattern
   ASSERT( theTrack );
 
   SMESHDS_SubMesh* pSubMeshDS=theTrack->GetSubMeshDS();
 
-  if ( !pSubMeshDS->Contains( theN1 ) ) {
-    iErr = 2; // No match found for start node
-    return iErr;
-  }
-
   aItE = pSubMeshDS->GetElements();
   while ( aItE->more() ) {
     const SMDS_MeshElement* pE = aItE->next();
     aTypeE = pE->GetType();
-    if ( aTypeE != SMDSAbs_Edge ) {
+    // Pattern must contain links only
-      iErr = 3; // Pattern must contain links only
+    if ( aTypeE != SMDSAbs_Edge )
-      return iErr;
+      return EXTR_PATH_NOT_EDGE;
-    }
   }
 
   const TopoDS_Shape& aS = theTrack->GetSubShape();
-  if ( aS.ShapeType() != TopAbs_EDGE) {
+  // Sub shape for the Pattern must be an Edge
-    iErr = 3; // Sub shape for the Pattern must be an Edge
+  if ( aS.ShapeType() != TopAbs_EDGE )
-    return iErr;
+    return EXTR_BAD_PATH_SHAPE;
+
   aTrackEdge = TopoDS::Edge( aS );
-    if ( BRep_Tool::Degenerated( aTrackEdge ) ) {
+  // the Edge must not be degenerated
-      iErr = 4; // the Edge must not be degenerated
+  if ( BRep_Tool::Degenerated( aTrackEdge ) )
-      return iErr;
+    return EXTR_BAD_PATH_SHAPE;
-    }
-  }
 
   TopExp::Vertices( aTrackEdge, aV1, aV2 );
   aT1=BRep_Tool::Parameter( aV1, aTrackEdge );
   aT2=BRep_Tool::Parameter( aV2, aTrackEdge );
 
-  aItN = myMesh->GetSubMesh( aV1 )->GetSubMeshDS()->GetNodes();
+  aItN = theTrack->GetFather()->GetSubMesh( aV1 )->GetSubMeshDS()->GetNodes();
   const SMDS_MeshNode* aN1 = aItN->next();
 
-  aItN = myMesh->GetSubMesh( aV2 )->GetSubMeshDS()->GetNodes();
+  aItN = theTrack->GetFather()->GetSubMesh( aV2 )->GetSubMeshDS()->GetNodes();
   const SMDS_MeshNode* aN2 = aItN->next();
 
-  if ( !( aN1 == theN1 || aN2 == theN1 ) ) {
+  // starting node must be aN1 or aN2 
-    iErr = 5; // starting node must be aN1 or aN2 
+  if ( !( aN1 == theN1 || aN2 == theN1 ) )
-    return iErr;
+    return EXTR_BAD_STARTING_NODE;
-  }
 
   aNbTP = pSubMeshDS->NbNodes() + 2;
 
   // 1.2. Angles
   vector<double> aAngles( aNbTP );
 
-  if ( theHasAngles ) {
-    aNbAngles = theAngles.size();
-    if ( aNbTP != aNbAngles ) {
-      iErr = 6; // number of Angles does not match to the number of track points
-      return iErr;
-    }
-    aItD = theAngles.begin();
-    for ( j=0; aItD != aPrms.end(); ++aItD, ++j ) {
-      aAngle = *aItD;
-      aAngles[j] = aAngle;
-    }
-  }
-  else {
   for ( j=0; j < aNbTP; ++j ) {
     aAngles[j] = 0.;
   }
+  
+  if ( theHasAngles ) {
+    aItD = theAngles.begin();
+    for ( j=0; (aItD != theAngles.end()) && (j<aNbTP); ++aItD, ++j ) {
+      aAngle = *aItD;
+      aAngles[j] = aAngle;
+    }
   }
 
   // 2. Collect parameters on the track edge  
@@ -2140,10 +2128,9 @@ int SMESH_MeshEditor::ExtrusionAlongTrack (std::set<const SMDS_MeshElement*> & t
     aT = *aItD;
     aC3D->D1( aT, aP3D, aVec );
     aL2 = aVec.SquareMagnitude();
-    if ( aL2 < aTolVec2 ) {
+    if ( aL2 < aTolVec2 )
-      iErr = 20; // can not obtain the tangent;
+      return EXTR_CANT_GET_TANGENT;
-      return iErr;
+
-    }
     gp_Dir aTgt( aVec );
     aAngle = aAngles[j];
 
@@ -2214,23 +2201,27 @@ int SMESH_MeshEditor::ExtrusionAlongTrack (std::set<const SMDS_MeshElement*> & t
 	// make new nodes
 	aX = node->X();  aY = node->Y(); aZ = node->Z();
 	
-	Standard_Real aAngle1x;
+	Standard_Real aAngle1x, aAngleT1T0, aTolAng;
 	gp_Pnt aP0x, aP1x, aPN0, aPN1, aV0x, aV1x;
-	gp_Ax1 anAx1;
+	gp_Ax1 anAx1, anAxT1T0;
+	gp_Dir aDT1x, aDT0x, aDT1T0;
+
+	aTolAng=1.e-4;
 
 	aV0x = aV0;
 	aPN0.SetCoord(aX, aY, aZ);
 
 	const SMESH_MeshEditor_PathPoint& aPP0 = aPPs[0];
 	aP0x = aPP0.Pnt();
+	aDT0x= aPP0.Tangent();
 
 	for ( j = 1; j < aNbTP; ++j ) {
 	  const SMESH_MeshEditor_PathPoint& aPP1 = aPPs[j];
 	  aP1x = aPP1.Pnt();
-	  const gp_Dir& aDT1x = aPP1.Tangent();
+	  aDT1x = aPP1.Tangent();
 	  aAngle1x = aPP1.Angle();
 	  
-	  gp_Trsf aTrsf, aTrsfRot; 
+	  gp_Trsf aTrsf, aTrsfRot, aTrsfRotT1T0; 
 	  // Translation
 	  gp_Vec aV01x( aP0x, aP1x );
 	  aTrsf.SetTranslation( aV01x );
@@ -2239,6 +2230,18 @@ int SMESH_MeshEditor::ExtrusionAlongTrack (std::set<const SMDS_MeshElement*> & t
 	  aV1x = aV0x.Transformed( aTrsf );
 	  aPN1 = aPN0.Transformed( aTrsf );
 	  
+	  // rotation 1 [ T1,T0 ]
+	  aAngleT1T0=-aDT1x.Angle( aDT0x );
+	  if (fabs(aAngleT1T0) > aTolAng) {
+	    aDT1T0=aDT1x^aDT0x;
+	    anAxT1T0.SetLocation( aV1x );
+	    anAxT1T0.SetDirection( aDT1T0 );
+	    aTrsfRotT1T0.SetRotation( anAxT1T0, aAngleT1T0 );
+	    
+	    aPN1 = aPN1.Transformed( aTrsfRotT1T0 );
+	  }
+
+	  // rotation 2
 	  if ( theHasAngles ) {
 	    anAx1.SetLocation( aV1x );
 	    anAx1.SetDirection( aDT1x );
@@ -2249,14 +2252,15 @@ int SMESH_MeshEditor::ExtrusionAlongTrack (std::set<const SMDS_MeshElement*> & t
 
 	  // make new node
 	  aX = aPN1.X();
-	  aY = aPN1.X();
+	  aY = aPN1.Y();
-	  aZ = aPN1.X();
+	  aZ = aPN1.Z();
 	  const SMDS_MeshNode* newNode = aMesh->AddNode( aX, aY, aZ );
 	  listNewNodes.push_back( newNode );
 	  
 	  aPN0 = aPN1;
 	  aP0x = aP1x;
 	  aV0x = aV1x;
+	  aDT0x = aDT1x;
 	}
       }
       newNodesItVec.push_back( nIt );
@@ -2266,7 +2270,8 @@ int SMESH_MeshEditor::ExtrusionAlongTrack (std::set<const SMDS_MeshElement*> & t
   }
   
   makeWalls( aMesh, mapNewNodes, newElemsMap, mapElemNewNodes, theElements );
-  return iErr;
+
+  return EXTR_OK;
 }
 
 //=======================================================================

src/SMESH/SMESH_MeshEditor.hxx

@@ -122,7 +122,17 @@ class SMESH_MeshEditor {
   // Generate new elements by extrusion of theElements 
   // by theStep by theNbSteps
 
-  int ExtrusionAlongTrack (std::set<const SMDS_MeshElement*> & theElements,
+  enum Extrusion_Error {
+    EXTR_OK,
+    EXTR_NO_ELEMENTS, 
+    EXTR_PATH_NOT_EDGE,
+    EXTR_BAD_PATH_SHAPE,
+    EXTR_BAD_STARTING_NODE,
+    EXTR_BAD_ANGLES_NUMBER,
+    EXTR_CANT_GET_TANGENT
+    };
+  
+  Extrusion_Error ExtrusionAlongTrack (std::set<const SMDS_MeshElement*> & theElements,
                                        SMESH_subMesh*                      theTrackPattern,
                                        const SMDS_MeshNode*                theNodeStart,
                                        const bool                          theHasAngles,

src/SMESH/SMESH_subMesh.hxx

@@ -58,6 +58,8 @@ class SMESH_subMesh
   //   bool Contains(const TopoDS_Shape & aSubShape)
   //     throw (SALOME_Exception);
 
+  SMESH_Mesh* GetFather() { return _father; }
+  
   SMESHDS_SubMesh * GetSubMeshDS();
 
   SMESHDS_SubMesh* CreateSubMeshDS();

src/SMESHGUI/SMESHGUI_ExtrusionAlongPathDlg.cxx

@@ -579,9 +579,9 @@ bool SMESHGUI_ExtrusionAlongPathDlg::ClickOnApply()
     int j = 0;
     bool bOk;
     for ( int i = 0; i < AnglesList->count(); i++ ) {
-      long angle = AnglesList->text( i ).toLong( &bOk );
+      double angle = AnglesList->text( i ).toDouble( &bOk );
       if  ( bOk )
-	anAngles[ j++ ] = angle;
+	anAngles[ j++ ] = angle*PI/180;
     }
     anAngles->length( j );
   }
@@ -597,9 +597,52 @@ bool SMESHGUI_ExtrusionAlongPathDlg::ClickOnApply()
   try {
     QAD_WaitCursor wc;
     SMESH::SMESH_MeshEditor_var aMeshEditor = myMesh->GetMeshEditor();
+    SMESH::SMESH_MeshEditor::Extrusion_Error retVal = 
       aMeshEditor->ExtrusionAlongPath( anElementsId.inout(), myPathMesh, myPathShape, aNodeStart, 
 				       AnglesCheck->isChecked(), anAngles.inout(), 
 				       BasePointCheck->isChecked(), aBasePoint );
+
+    wc.stop();
+    switch ( retVal ) {
+    case SMESH::SMESH_MeshEditor::EXTR_NO_ELEMENTS:
+      QAD_MessageBox::warn1( QAD_Application::getDesktop(),
+			     tr( "SMESH_ERROR" ),
+			     tr( "NO_ELEMENTS_SELECTED" ),
+			     tr( "SMESH_BUT_OK" ) );
+      return false; break;
+    case SMESH::SMESH_MeshEditor::EXTR_PATH_NOT_EDGE:
+      QAD_MessageBox::warn1( QAD_Application::getDesktop(),
+			     tr( "SMESH_ERROR" ),
+			     tr( "SELECTED_PATH_IS_NOT_EDGE" ),
+			     tr( "SMESH_BUT_OK" ) );
+      return false; break;
+    case SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE:
+      QAD_MessageBox::warn1( QAD_Application::getDesktop(),
+			     tr( "SMESH_ERROR" ),
+			     tr( "BAD_SHAPE_TYPE" ),
+			     tr( "SMESH_BUT_OK" ) );
+      return false; break;
+    case SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE:
+      QAD_MessageBox::warn1( QAD_Application::getDesktop(),
+			     tr( "SMESH_ERROR" ),
+			     tr( "EXTR_BAD_STARTING_NODE" ),
+			     tr( "SMESH_BUT_OK" ) );
+      return false; break;
+    case SMESH::SMESH_MeshEditor::EXTR_BAD_ANGLES_NUMBER:
+      QAD_MessageBox::warn1( QAD_Application::getDesktop(),
+			     tr( "SMESH_ERROR" ),
+			     tr( "WRONG_ANGLES_NUMBER" ),
+			     tr( "SMESH_BUT_OK" ) );
+      return false; break;
+    case SMESH::SMESH_MeshEditor::EXTR_CANT_GET_TANGENT:
+      QAD_MessageBox::warn1( QAD_Application::getDesktop(),
+			     tr( "SMESH_ERROR" ),
+			     tr( "CANT_GET_TANGENT" ),
+			     tr( "SMESH_BUT_OK" ) );
+      return false; break;
+    case SMESH::SMESH_MeshEditor::EXTR_OK:
+      break;
+    }
   }
   catch( ... ) {
     return false;
@@ -937,14 +980,11 @@ void SMESHGUI_ExtrusionAlongPathDlg::SetEditCurrentArgument( QToolButton* button
     QAD_Application::getDesktop()->SetSelectionMode( ActorSelection );
 
     if ( !myPathMesh->_is_nil() ) {
-      TColStd_MapOfInteger aTypes;
-      aTypes.Add( TopAbs_EDGE );
-      aTypes.Add( TopAbs_WIRE );
       GEOM::GEOM_Object_var aMainShape = myPathMesh->GetShapeToMesh();
       SMESH_Actor* aPathActor = SMESH::FindActorByObject( myPathMesh );
 
       if ( !aMainShape->_is_nil() && aPathActor )
-	mySelection->AddFilter( new SMESH_NumberFilter( "GEOM", TopAbs_SHAPE, -1, aTypes, aMainShape ) );
+	mySelection->AddFilter( new SMESH_NumberFilter( "GEOM", TopAbs_SHAPE, -1, TopAbs_EDGE, aMainShape ) );
 	//SMESH::SetPickable( aPathActor );
     }
   }

src/SMESHGUI/SMESH_msg_en.po

@@ -1476,6 +1476,24 @@ msgstr "Use Base Point"
 msgid "SMESHGUI_ExtrusionAlongPathDlg::SMESH_BASE_POINT"
 msgstr "Base Point"
 
+msgid "SMESHGUI_ExtrusionAlongPathDlg::NO_ELEMENTS_SELECTED"
+msgstr "No mesh elements are selected for extrusion"
+
+msgid "SMESHGUI_ExtrusionAlongPathDlg::SELECTED_PATH_IS_NOT_EDGE"
+msgstr "Path mesh should be of edge type"
+
+msgid "SMESHGUI_ExtrusionAlongPathDlg::BAD_SHAPE_TYPE"
+msgstr "The shape selected for the path is not edge"
+
+msgid "SMESHGUI_ExtrusionAlongPathDlg::EXTR_BAD_STARTING_NODE"
+msgstr "Wrong path starting node"
+
+msgid "SMESHGUI_ExtrusionAlongPathDlg::WRONG_ANGLES_NUMBER"
+msgstr "The number of angles should correspond to the number of path nodes"
+
+msgid "SMESHGUI_ExtrusionAlongPathDlg::CANT_GET_TANGENT"
+msgstr "Can't get tangent for one of the path nodes"
+
 #----------------------------------------------------
 
 msgid "SMESHGUI_RevolutionDlg::REVOLUTION_AROUND_AXIS"

src/SMESH_I/SMESH_MeshEditor_i.cxx

@@ -533,12 +533,29 @@ void SMESH_MeshEditor_i::ExtrusionSweepObject(SMESH::SMESH_IDSource_ptr theObjec
   ExtrusionSweep(anElementsId, theStepVector, theNbOfSteps);
 }
 
+#define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
+
+static SMESH::SMESH_MeshEditor::Extrusion_Error convExtrError( const::SMESH_MeshEditor::Extrusion_Error e )
+{
+  switch ( e ) {
+  RETCASE( EXTR_OK );
+  RETCASE( EXTR_NO_ELEMENTS );
+  RETCASE( EXTR_PATH_NOT_EDGE );
+  RETCASE( EXTR_BAD_PATH_SHAPE );
+  RETCASE( EXTR_BAD_STARTING_NODE );
+  RETCASE( EXTR_BAD_ANGLES_NUMBER );
+  RETCASE( EXTR_CANT_GET_TANGENT );
+  }
+  return SMESH::SMESH_MeshEditor::EXTR_OK;
+}
+
 //=======================================================================
 //function : ExtrusionAlongPath
 //purpose  : 
 //=======================================================================
 
-void SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array &   theIDsOfElements,
+SMESH::SMESH_MeshEditor::Extrusion_Error
+  SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array &   theIDsOfElements,
 					 SMESH::SMESH_Mesh_ptr       thePathMesh,
 					 GEOM::GEOM_Object_ptr       thePathShape,
 					 CORBA::Long                 theNodeStart,
@@ -550,18 +567,18 @@ void SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array &   theIDsOf
   SMESHDS_Mesh*  aMesh = GetMeshDS();
 
   if ( thePathMesh->_is_nil() || thePathShape->_is_nil() )
-    return;
+    return SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
 
   SMESH_Mesh_i* aMeshImp = dynamic_cast<SMESH_Mesh_i*>( SMESH_Gen_i::GetServant( thePathMesh ).in() );
   TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
   SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
 
   if ( !aSubMesh )
-    return;
+    return SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
 
   SMDS_MeshNode* nodeStart = (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(theNodeStart);
   if ( !nodeStart )
-    return;
+    return SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
 
   set<const SMDS_MeshElement*> elements;
   for (int i = 0; i < theIDsOfElements.length(); i++)
@@ -581,7 +598,7 @@ void SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array &   theIDsOf
   gp_Pnt refPnt( theRefPoint.x, theRefPoint.y, theRefPoint.z );
 
   ::SMESH_MeshEditor anEditor( _myMesh );
-  int res = anEditor.ExtrusionAlongTrack( elements, aSubMesh, nodeStart, theHasAngles, angles, theHasRefPoint, refPnt );
+  return convExtrError( anEditor.ExtrusionAlongTrack( elements, aSubMesh, nodeStart, theHasAngles, angles, theHasRefPoint, refPnt ) );
 }
 
 //=======================================================================
@@ -589,7 +606,8 @@ void SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array &   theIDsOf
 //purpose  : 
 //=======================================================================
 
-void SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr   theObject,
+SMESH::SMESH_MeshEditor::Extrusion_Error
+  SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr   theObject,
 					       SMESH::SMESH_Mesh_ptr       thePathMesh,
 					       GEOM::GEOM_Object_ptr       thePathShape,
 					       CORBA::Long                 theNodeStart,
@@ -599,7 +617,7 @@ void SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr   th
 					       const SMESH::PointStruct &  theRefPoint)
 {
   SMESH::long_array_var anElementsId = theObject->GetIDs();
-  ExtrusionAlongPath( anElementsId, thePathMesh, thePathShape, theNodeStart, theHasAngles, theAngles, theHasRefPoint, theRefPoint );
+  return ExtrusionAlongPath( anElementsId, thePathMesh, thePathShape, theNodeStart, theHasAngles, theAngles, theHasRefPoint, theRefPoint );
 }
 
 //=======================================================================
@@ -815,7 +833,7 @@ void SMESH_MeshEditor_i::MergeEqualElements()
 
 #define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
 
-SMESH::SMESH_MeshEditor::Sew_Error convError( const::SMESH_MeshEditor::Sew_Error e )
+static SMESH::SMESH_MeshEditor::Sew_Error convError( const::SMESH_MeshEditor::Sew_Error e )
 {
   switch ( e ) {
   RETCASE( SEW_OK );

src/SMESH_I/SMESH_MeshEditor_i.hxx

@@ -105,7 +105,8 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
 			    const SMESH::DirStruct &  StepVector,
 			    CORBA::Long               NbOfSteps);
   
-  void ExtrusionAlongPath(const SMESH::long_array &   IDsOfElements,
+  SMESH::SMESH_MeshEditor::Extrusion_Error
+    ExtrusionAlongPath(const SMESH::long_array &   IDsOfElements,
                        SMESH::SMESH_Mesh_ptr       PathMesh,
                        GEOM::GEOM_Object_ptr       PathShape,
                        CORBA::Long                 NodeStart,
@@ -114,7 +115,8 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
                        CORBA::Boolean              HasRefPoint,
                        const SMESH::PointStruct &  RefPoint);
   
-  void ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr   theObject,
+  SMESH::SMESH_MeshEditor::Extrusion_Error
+    ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr   theObject,
                              SMESH::SMESH_Mesh_ptr       PathMesh,
                              GEOM::GEOM_Object_ptr       PathShape,
                              CORBA::Long                 NodeStart,