ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-11-11 16:19:16 +05:00
Code Issues Packages Projects Releases Wiki Activity

Implement sweep mesh elements along a path (PAL7218).

Browse Source
This commit is contained in:
vsr 2005-01-20 14:50:37 +00:00
parent 910f46272c
commit 5496cb6ab1
7 changed files with 212 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

129
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -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,16 +1995,17 @@ protected:
//function : ExtrusionAlongTrack
//purpose :
//=======================================================================
int SMESH_MeshEditor::ExtrusionAlongTrack (std::set<const SMDS_MeshElement*> & theElements,
SMESH_subMesh* theTrack,
const SMDS_MeshNode* theN1,
const bool theHasAngles,
std::list<double>& theAngles,
const bool theHasRefPoint,
const gp_Pnt& theRefPoint)
SMESH_MeshEditor::Extrusion_Error
SMESH_MeshEditor::ExtrusionAlongTrack (std::set<const SMDS_MeshElement*> & theElements,
SMESH_subMesh* theTrack,
const SMDS_MeshNode* theN1,
const bool theHasAngles,
std::list<double>& theAngles,
const bool theHasRefPoint,
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,83 +2029,67 @@ 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();
if ( !aNbE ) {
iErr = 10; // nothing to do
return iErr;
}
aNbE = theElements.size();
// nothing to do
if ( !aNbE )
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 ) {
iErr = 3; // Pattern must contain links only
return iErr;
}
// Pattern must contain links only
if ( aTypeE != SMDSAbs_Edge )
return EXTR_PATH_NOT_EDGE;
}
const TopoDS_Shape& aS = theTrack->GetSubShape();
if ( aS.ShapeType() != TopAbs_EDGE) {
iErr = 3; // Sub shape for the Pattern must be an Edge
return iErr;
aTrackEdge = TopoDS::Edge( aS );
if ( BRep_Tool::Degenerated( aTrackEdge ) ) {
iErr = 4; // the Edge must not be degenerated
return iErr;
}
}
// Sub shape for the Pattern must be an Edge
if ( aS.ShapeType() != TopAbs_EDGE )
return EXTR_BAD_PATH_SHAPE;
aTrackEdge = TopoDS::Edge( aS );
// the Edge must not be degenerated
if ( BRep_Tool::Degenerated( aTrackEdge ) )
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 ) ) {
iErr = 5; // starting node must be aN1 or aN2
return iErr;
}
// starting node must be aN1 or aN2
if ( !( aN1 == theN1 || aN2 == theN1 ) )
return EXTR_BAD_STARTING_NODE;
aNbTP = pSubMeshDS->NbNodes() + 2;
// 1.2. Angles
vector<double> aAngles( aNbTP );
for ( j=0; j < aNbTP; ++j ) {
aAngles[j] = 0.;
}
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 ) {
for ( j=0; (aItD != theAngles.end()) && (j<aNbTP); ++aItD, ++j ) {
aAngle = *aItD;
aAngles[j] = aAngle;
}
}
else {
for ( j=0; j < aNbTP; ++j ) {
aAngles[j] = 0.;
}
}
// 2. Collect parameters on the track edge
aPrms.push_back( aT1 );
@ -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 ) {
iErr = 20; // can not obtain the tangent;
return iErr;
}
if ( aL2 < aTolVec2 )
return EXTR_CANT_GET_TANGENT;
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();
aZ = aPN1.X();
aY = aPN1.Y();
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;
}
//=======================================================================

24
src/SMESH/SMESH_MeshEditor.hxx
View File

@ -122,13 +122,23 @@ class SMESH_MeshEditor {
// Generate new elements by extrusion of theElements
// by theStep by theNbSteps
int ExtrusionAlongTrack (std::set<const SMDS_MeshElement*> & theElements,
SMESH_subMesh* theTrackPattern,
const SMDS_MeshNode* theNodeStart,
const bool theHasAngles,
std::list<double>& theAngles,
const bool theHasRefPoint,
const gp_Pnt& theRefPoint);
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,
std::list<double>& theAngles,
const bool theHasRefPoint,
const gp_Pnt& theRefPoint);
// Generate new elements by extrusion of theElements along path given by theTrackPattern,
// theHasAngles are the rotation angles, base point can be given by theRefPoint

2
src/SMESH/SMESH_subMesh.hxx
View File

@ -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();

58
src/SMESHGUI/SMESHGUI_ExtrusionAlongPathDlg.cxx
View File

@ -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();
aMeshEditor->ExtrusionAlongPath( anElementsId.inout(), myPathMesh, myPathShape, aNodeStart,
AnglesCheck->isChecked(), anAngles.inout(),
BasePointCheck->isChecked(), aBasePoint );
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 );
}
}

18
src/SMESHGUI/SMESH_msg_en.po
View File

@ -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"

62
src/SMESH_I/SMESH_MeshEditor_i.cxx
View File

@ -533,35 +533,52 @@ 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_Mesh_ptr thePathMesh,
GEOM::GEOM_Object_ptr thePathShape,
CORBA::Long theNodeStart,
CORBA::Boolean theHasAngles,
const SMESH::double_array & theAngles,
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct & theRefPoint)
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,
CORBA::Boolean theHasAngles,
const SMESH::double_array & theAngles,
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct & theRefPoint)
{
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,17 +606,18 @@ void SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array & theIDsOf
//purpose :
//=======================================================================
void SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr thePathMesh,
GEOM::GEOM_Object_ptr thePathShape,
CORBA::Long theNodeStart,
CORBA::Boolean theHasAngles,
const SMESH::double_array & theAngles,
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct & theRefPoint)
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,
CORBA::Boolean theHasAngles,
const SMESH::double_array & theAngles,
CORBA::Boolean theHasRefPoint,
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 );

36
src/SMESH_I/SMESH_MeshEditor_i.hxx
View File

@ -105,23 +105,25 @@ 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_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
CORBA::Long NodeStart,
CORBA::Boolean HasAngles,
const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint,
const SMESH::PointStruct & RefPoint);
void ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
CORBA::Long NodeStart,
CORBA::Boolean HasAngles,
const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint,
const SMESH::PointStruct & RefPoint);
SMESH::SMESH_MeshEditor::Extrusion_Error
ExtrusionAlongPath(const SMESH::long_array & IDsOfElements,
SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
CORBA::Long NodeStart,
CORBA::Boolean HasAngles,
const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint,
const SMESH::PointStruct & RefPoint);
SMESH::SMESH_MeshEditor::Extrusion_Error
ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
CORBA::Long NodeStart,
CORBA::Boolean HasAngles,
const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint,
const SMESH::PointStruct & RefPoint);
void Mirror(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis,