#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
+#include <math.h>
#include <gp_Dir.hxx>
#include <gp_Vec.hxx>
#include <gp_Ax1.hxx>
// 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() {
//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;
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 );
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];
// 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 );
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 );
// 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 );
}
makeWalls( aMesh, mapNewNodes, newElemsMap, mapElemNewNodes, theElements );
- return iErr;
+
+ return EXTR_OK;
}
//=======================================================================
// 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
// bool Contains(const TopoDS_Shape & aSubShape)
// throw (SALOME_Exception);
+ SMESH_Mesh* GetFather() { return _father; }
+
SMESHDS_SubMesh * GetSubMeshDS();
SMESHDS_SubMesh* CreateSubMeshDS();
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 );
}
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;
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 );
}
}
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"
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++)
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 ) );
}
//=======================================================================
//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 );
}
//=======================================================================
#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 );
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,
