{
if (mySMESHGUI->isActiveStudyLocked())
return false;
+
+ if (!isValid())
+ return false;
+
if (!myMesh->_is_nil()) {
+ QStringList aParameters;
+ aParameters << SpinBoxTol->text();
+
try {
SUIT_OverrideCursor aWaitCursor;
CheckBoxMerge->isChecked(),
SpinBoxTol->GetValue());
+ aCompoundMesh->SetParameters( SMESHGUI::JoinObjectParameters(aParameters) );
+
SMESH::SetName( SMESH::FindSObject( aCompoundMesh ), LineEditName->text() );
mySMESHGUI->updateObjBrowser();
} catch(...) {
TextLabelTol->setEnabled(toMerge);
SpinBoxTol->setEnabled(toMerge);
}
+
+//=================================================================================
+// function : isValid
+// purpose :
+//=================================================================================
+bool SMESHGUI_BuildCompoundDlg::isValid()
+{
+ QString msg;
+ bool ok = SpinBoxTol->isValid( msg, true ) && ok;
+
+ if( !ok ) {
+ QString str( tr( "SMESH_INCORRECT_INPUT" ) );
+ if ( !msg.isEmpty() )
+ str += "\n" + msg;
+ SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str );
+ return false;
+ }
+ return true;
+}
void hideEvent( QHideEvent* ); /* ESC key */
void keyPressEvent( QKeyEvent* );
+ bool isValid();
+
private:
SMESHGUI* mySMESHGUI; /* Current SMESHGUI object */
LightApp_SelectionMgr* mySelectionMgr; /* User shape selection */
#include <SVTK_ViewModel.h>
#include <SVTK_ViewWindow.h>
+#include <SalomeApp_IntSpinBox.h>
+
// OCCT includes
#include <TColStd_MapOfInteger.hxx>
#include <TColStd_IndexedMapOfInteger.hxx>
#include <QPushButton>
#include <QRadioButton>
#include <QCheckBox>
-#include <QSpinBox>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QGridLayout>
// Controls for nb. steps defining
TextLabelNbSteps = new QLabel(tr("SMESH_NUMBEROFSTEPS"), GroupArguments);
- SpinBox_NbSteps = new QSpinBox(GroupArguments);
+ SpinBox_NbSteps = new SalomeApp_IntSpinBox(GroupArguments);
// CheckBox for groups generation
MakeGroupsCheck = new QCheckBox(tr("SMESH_MAKE_GROUPS"), GroupArguments);
if (mySMESHGUI->isActiveStudyLocked())
return false;
+ if (!isValid())
+ return false;
+
if (myNbOkElements) {
SMESH::DirStruct aVector;
long aNbSteps = (long)SpinBox_NbSteps->value();
+ QStringList aParameters;
+ aParameters << SpinBox_Dx->text();
+ aParameters << SpinBox_Dy->text();
+ aParameters << SpinBox_Dz->text();
+ aParameters << SpinBox_NbSteps->text();
+
try {
SUIT_OverrideCursor aWaitCursor;
SMESH::SMESH_MeshEditor_var aMeshEditor = myMesh->GetMeshEditor();
else
aMeshEditor->ExtrusionSweep(myElementsId.inout(), aVector, aNbSteps);
+ myMesh->SetParameters( SMESHGUI::JoinObjectParameters(aParameters) );
+
} catch (...) {
}
ClickOnHelp();
}
}
+
+//=================================================================================
+// function : isValid
+// purpose :
+//=================================================================================
+bool SMESHGUI_ExtrusionDlg::isValid()
+{
+ QString msg;
+ bool ok = true;
+ ok = SpinBox_Dx->isValid( msg, true ) && ok;
+ ok = SpinBox_Dy->isValid( msg, true ) && ok;
+ ok = SpinBox_Dz->isValid( msg, true ) && ok;
+ ok = SpinBox_NbSteps->isValid( msg, true ) && ok;
+
+ if( !ok ) {
+ QString str( tr( "SMESH_INCORRECT_INPUT" ) );
+ if ( !msg.isEmpty() )
+ str += "\n" + msg;
+ SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str );
+ return false;
+ }
+ return true;
+}
class QLabel;
class QLineEdit;
class QCheckBox;
-class QSpinBox;
class QPushButton;
class SMESHGUI;
class SVTK_Selector;
class LightApp_SelectionMgr;
class SUIT_SelectionFilter;
+class SalomeApp_IntSpinBox;
//=================================================================================
// class : SMESHGUI_ExtrusionDlg
void keyPressEvent( QKeyEvent* );
int GetConstructorId();
+ bool isValid();
+
SMESHGUI* mySMESHGUI; /* Current SMESHGUI object */
SMESHGUI_IdValidator* myIdValidator;
LightApp_SelectionMgr* mySelectionMgr; /* User shape selection */
QLabel* TextLabelDz;
SMESHGUI_SpinBox* SpinBox_Dz;
QLabel* TextLabelNbSteps;
- QSpinBox* SpinBox_NbSteps;
+ SalomeApp_IntSpinBox* SpinBox_NbSteps;
QCheckBox* MakeGroupsCheck;
QGroupBox* GroupButtons;
return false;
}
- if ( !isValid() ) { // node id is invalid
- SUIT_MessageBox::warning( dlg(), tr( "SMESH_WRN_WARNING" ),
- tr("INVALID_ID") );
+ QString msg;
+ if ( !isValid( msg ) ) { // node id is invalid
+ if( !msg.isEmpty() )
+ SUIT_MessageBox::warning( dlg(), tr( "SMESH_WRN_WARNING" ),
+ tr("INVALID_ID") );
dlg()->show();
return false;
}
}
if (aResult)
{
+ QStringList aParameters;
+ aParameters << myDlg->myX->text();
+ aParameters << myDlg->myY->text();
+ aParameters << myDlg->myZ->text();
+ aMesh->SetParameters( SMESHGUI::JoinObjectParameters(aParameters) );
+
myDlg->myId->setText("");
SALOME_ListIO aList;
*/
//================================================================================
-bool SMESHGUI_MakeNodeAtPointOp::isValid()
+bool SMESHGUI_MakeNodeAtPointOp::isValid( QString& msg )
{
bool ok = true;
-
if ( myMeshActor &&
myDlg->myMoveRBtn->isDown() &&
!myDlg->myAutoSearchChkBox->isChecked() )
if ( id > 0 )
if (SMDS_Mesh* aMesh = myMeshActor->GetObject()->GetMesh())
ok = aMesh->FindNode( id );
+ if( !ok )
+ msg += tr("INVALID_ID") + "\n";
}
+
+ ok = myDlg->myX->isValid( msg, !myNoPreview ) && ok;
+ ok = myDlg->myY->isValid( msg, !myNoPreview ) && ok;
+ ok = myDlg->myZ->isValid( msg, !myNoPreview ) && ok;
+
return ok;
}
const bool preview = myDlg->myPreviewChkBox->isChecked();
if ( autoSearch )
myDlg->myId->setText("");
- if ( preview && ( autoSearch || isValid() ))
+ QString msg;
+ if ( preview && ( autoSearch || isValid( msg ) ))
{
try {
SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(myMeshActor->getIO());
virtual void activateSelection();
- bool isValid();
+ bool isValid( QString& );
protected slots:
virtual bool onApply();
tr("NODE_ID_IS_NOT_DEFINED"));
return false;
}
+
+ QString msg;
+ bool ok = true;
+ ok = myX->isValid( msg, theMess ) && ok;
+ ok = myY->isValid( msg, theMess ) && ok;
+ ok = myZ->isValid( msg, theMess ) && ok;
+ if( !ok ) {
+ if( theMess ) {
+ QString str( tr( "SMESH_INCORRECT_INPUT" ) );
+ if ( !msg.isEmpty() )
+ str += "\n" + msg;
+ SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str );
+ }
+ return false;
+ }
+
return true;
}
bool aResult = false;
try {
aResult = aMeshEditor->MoveNode(anId, myX->GetValue(), myY->GetValue(), myZ->GetValue());
+
+ QStringList aParameters;
+ aParameters << myX->text();
+ aParameters << myY->text();
+ aParameters << myZ->text();
+ aMesh->SetParameters( SMESHGUI::JoinObjectParameters(aParameters) );
} catch (...) {
}
// name : SMESHGUI_MultiEditDlg::isValid
// Purpose : Verify validity of input data
//=======================================================================
-bool SMESHGUI_MultiEditDlg::isValid (const bool /*theMess*/) const
+bool SMESHGUI_MultiEditDlg::isValid (const bool /*theMess*/)
{
return (!myMesh->_is_nil() &&
(myListBox->count() > 0 || (myToAllChk->isChecked() && myActor)));
{
}
+bool SMESHGUI_UnionOfTrianglesDlg::isValid (const bool theMess)
+{
+ bool ok = SMESHGUI_MultiEditDlg::isValid( theMess );
+ if( !ok )
+ return false;
+
+ QString msg;
+ ok = myMaxAngleSpin->isValid( msg, theMess );
+ if( !ok ) {
+ if( theMess ) {
+ QString str( tr( "SMESH_INCORRECT_INPUT" ) );
+ if ( !msg.isEmpty() )
+ str += "\n" + msg;
+ SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str );
+ }
+ return false;
+ }
+
+ return ok;
+}
+
bool SMESHGUI_UnionOfTrianglesDlg::process (SMESH::SMESH_MeshEditor_ptr theEditor,
const SMESH::long_array& theIds)
{
SMESH::NumericalFunctor_var aCriterion = getNumericalFunctor();
double aMaxAngle = myMaxAngleSpin->GetValue() * PI / 180.0;
- return theEditor->TriToQuad(theIds, aCriterion, aMaxAngle);
+ bool ok = theEditor->TriToQuad(theIds, aCriterion, aMaxAngle);
+ if( ok ) {
+ QStringList aParameters;
+ aParameters << myMaxAngleSpin->text();
+ myMesh->SetParameters( SMESHGUI::JoinObjectParameters(aParameters) );
+ }
+ return ok;
}
void keyPressEvent( QKeyEvent* );
QWidget* createButtonFrame( QWidget* );
QWidget* createMainFrame( QWidget*, const bool );
- bool isValid( const bool ) const;
+ virtual bool isValid( const bool );
SMESH::long_array_var getIds();
void updateButtons();
void setSelectionMode();
virtual ~SMESHGUI_UnionOfTrianglesDlg();
protected:
+ virtual bool isValid( const bool );
virtual bool process( SMESH::SMESH_MeshEditor_ptr, const SMESH::long_array& );
private:
namespace SMESH
{
- void AddNode( SMESH::SMESH_Mesh_ptr theMesh, float x, float y, float z )
+ void AddNode( SMESH::SMESH_Mesh_ptr theMesh, float x, float y, float z, const QStringList& theParameters )
{
SUIT_OverrideCursor wc;
try {
_PTR(SObject) aSobj = SMESH::FindSObject( theMesh );
SMESH::SMESH_MeshEditor_var aMeshEditor = theMesh->GetMeshEditor();
aMeshEditor->AddNode( x, y, z );
+ theMesh->SetParameters( SMESHGUI::JoinObjectParameters(theParameters) );
_PTR(Study) aStudy = GetActiveStudyDocument();
CORBA::Long anId = aStudy->StudyId();
if (TVisualObjPtr aVisualObj = SMESH::GetVisualObj( anId, aSobj->GetID().c_str() ) ) {
return false;
}
+ if( !isValid() )
+ return false;
+
/* Recup args and call method */
double x = SpinBox_X->GetValue();
double y = SpinBox_Y->GetValue();
double z = SpinBox_Z->GetValue();
+
+ QStringList aParameters;
+ aParameters << SpinBox_X->text();
+ aParameters << SpinBox_Y->text();
+ aParameters << SpinBox_Z->text();
+
mySimulation->SetVisibility( false );
- SMESH::AddNode( myMesh, x, y, z );
+ SMESH::AddNode( myMesh, x, y, z, aParameters );
SMESH::SetPointRepresentation( true );
// select myMesh
ClickOnHelp();
}
}
+
+//=================================================================================
+// function : isValid
+// purpose :
+//=================================================================================
+bool SMESHGUI_NodesDlg::isValid()
+{
+ QString msg;
+ bool ok = true;
+ ok = SpinBox_X->isValid( msg, true ) && ok;
+ ok = SpinBox_Y->isValid( msg, true ) && ok;
+ ok = SpinBox_Z->isValid( msg, true ) && ok;
+
+ if( !ok ) {
+ QString str( tr( "SMESH_INCORRECT_INPUT" ) );
+ if ( !msg.isEmpty() )
+ str += "\n" + msg;
+ SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str );
+ return false;
+ }
+ return true;
+}
void hideEvent ( QHideEvent* );
void keyPressEvent( QKeyEvent* );
+ bool isValid();
+
QGroupBox* GroupConstructors;
QRadioButton* Constructor1;
QGroupBox* GroupCoordinates;
// function : ClickOnApply()
// purpose :
//=================================================================================
-void SMESHGUI_RotationDlg::ClickOnApply()
+bool SMESHGUI_RotationDlg::ClickOnApply()
{
if (mySMESHGUI->isActiveStudyLocked())
- return;
+ return false;
+
+ if( !isValid() )
+ return false;
if (myNbOkElements && IsAxisOk()) {
QStringList aListElementsId = myElementsId.split(" ", QString::SkipEmptyParts);
anAxis.vz = SpinBox_DZ->GetValue();
double anAngle = (SpinBox_Angle->GetValue())*PI/180;
+
+ QStringList aParameters;
+ aParameters << SpinBox_X->text();
+ aParameters << SpinBox_Y->text();
+ aParameters << SpinBox_Z->text();
+ aParameters << SpinBox_DX->text();
+ aParameters << SpinBox_DY->text();
+ aParameters << SpinBox_DZ->text();
+ aParameters << SpinBox_Angle->text();
+
int actionButton = ActionGroup->checkedId();
bool makeGroups = ( MakeGroupsCheck->isEnabled() && MakeGroupsCheck->isChecked() );
try {
switch ( actionButton ) {
case MOVE_ELEMS_BUTTON:
aMeshEditor->Rotate(anElementsId, anAxis, anAngle, false);
+ if( !myMesh->_is_nil())
+ myMesh->SetParameters(SMESHGUI::JoinObjectParameters(aParameters));
break;
case COPY_ELEMS_BUTTON:
if ( makeGroups )
aMeshEditor->RotateMakeGroups(anElementsId, anAxis, anAngle);
else
aMeshEditor->Rotate(anElementsId, anAxis, anAngle, true);
+ if( !myMesh->_is_nil())
+ myMesh->SetParameters(SMESHGUI::JoinObjectParameters(aParameters));
break;
case MAKE_MESH_BUTTON:
SMESH::SMESH_Mesh_var mesh =
aMeshEditor->RotateMakeMesh(anElementsId, anAxis, anAngle, makeGroups,
LineEditNewMesh->text().toLatin1().data());
+ if( !mesh->_is_nil())
+ mesh->SetParameters(SMESHGUI::JoinObjectParameters(aParameters));
}
} catch (...) {
}
Init(false);
SelectionIntoArgument();
}
+
+ return true;
}
//=================================================================================
//=================================================================================
void SMESHGUI_RotationDlg::ClickOnOk()
{
- ClickOnApply();
- ClickOnCancel();
+ if( ClickOnApply() )
+ ClickOnCancel();
}
//=================================================================================
ClickOnHelp();
}
}
+
+//=================================================================================
+// function : isValid
+// purpose :
+//=================================================================================
+bool SMESHGUI_RotationDlg::isValid()
+{
+ bool ok = true;
+ QString msg;
+
+ ok = SpinBox_X->isValid( msg, true ) && ok;
+ ok = SpinBox_Y->isValid( msg, true ) && ok;
+ ok = SpinBox_Z->isValid( msg, true ) && ok;
+ ok = SpinBox_DX->isValid( msg, true ) && ok;
+ ok = SpinBox_DY->isValid( msg, true ) && ok;
+ ok = SpinBox_DZ->isValid( msg, true ) && ok;
+ ok = SpinBox_Angle->isValid( msg, true ) && ok;
+
+ if( !ok ) {
+ QString str( tr( "SMESH_INCORRECT_INPUT" ) );
+ if ( !msg.isEmpty() )
+ str += "\n" + msg;
+ SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str );
+ return false;
+ }
+ return true;
+}
bool IsAxisOk();
void setNewMeshName();
+ bool isValid();
+
SMESHGUI* mySMESHGUI; /* Current SMESHGUI object */
SMESHGUI_IdValidator* myIdValidator;
LightApp_SelectionMgr* mySelectionMgr; /* User shape selection */
private slots:
void ClickOnOk();
void ClickOnCancel();
- void ClickOnApply();
+ bool ClickOnApply();
void ClickOnHelp();
void SetEditCurrentArgument();
void SelectionIntoArgument();
#include <LightApp_Application.h>
#include <LightApp_SelectionMgr.h>
+#include <SalomeApp_IntSpinBox.h>
+
#include <SVTK_ViewModel.h>
#include <SVTK_Selector.h>
#include <SVTK_ViewWindow.h>
#include <QRadioButton>
#include <QComboBox>
#include <QCheckBox>
-#include <QSpinBox>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QGridLayout>
// Controls for iteration limit defining
TextLabelLimit = new QLabel(tr("ITERATION_LIMIT"), GroupArguments);
- SpinBox_IterationLimit = new QSpinBox(GroupArguments);
+ SpinBox_IterationLimit = new SalomeApp_IntSpinBox(GroupArguments);
// Controls for max. aspect ratio defining
TextLabelAspectRatio = new QLabel(tr("MAX_ASPECT_RATIO"), GroupArguments);
// function : ClickOnApply()
// purpose : Called when user presses <Apply> button
//=================================================================================
-void SMESHGUI_SmoothingDlg::ClickOnApply()
+bool SMESHGUI_SmoothingDlg::ClickOnApply()
{
if (mySMESHGUI->isActiveStudyLocked())
- return;
+ return false;
+
+ if (!isValid())
+ return false;
if (myNbOkElements && (myNbOkNodes || LineEditNodes->text().trimmed().isEmpty())) {
QStringList aListElementsId = myElementsId.split(" ", QString::SkipEmptyParts);
long anIterationLimit = (long)SpinBox_IterationLimit->value();
double aMaxAspectRatio = SpinBox_AspectRatio->GetValue();
+ QStringList aParameters;
+ aParameters << SpinBox_IterationLimit->text();
+ aParameters << SpinBox_AspectRatio->text();
+
SMESH::SMESH_MeshEditor::Smooth_Method aMethod = SMESH::SMESH_MeshEditor::LAPLACIAN_SMOOTH;
if (ComboBoxMethod->currentIndex() > 0)
aMethod = SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH;
else
aResult = aMeshEditor->Smooth(anElementsId.inout(), aNodesId.inout(),
anIterationLimit, aMaxAspectRatio, aMethod);
+
+ myMesh->SetParameters( SMESHGUI::JoinObjectParameters(aParameters) );
+
} catch (...) {
}
Init();
}
}
+
+ return true;
}
//=================================================================================
//=================================================================================
void SMESHGUI_SmoothingDlg::ClickOnOk()
{
- ClickOnApply();
- ClickOnCancel();
+ if( ClickOnApply() )
+ ClickOnCancel();
}
//=================================================================================
ClickOnHelp();
}
}
+
+//=================================================================================
+// function : isValid
+// purpose :
+//=================================================================================
+bool SMESHGUI_SmoothingDlg::isValid()
+{
+ QString msg;
+ bool ok = true;
+ ok = SpinBox_IterationLimit->isValid( msg, true ) && ok;
+ ok = SpinBox_AspectRatio->isValid( msg, true ) && ok;
+
+ if( !ok ) {
+ QString str( tr( "SMESH_INCORRECT_INPUT" ) );
+ if ( !msg.isEmpty() )
+ str += "\n" + msg;
+ SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str );
+ return false;
+ }
+ return true;
+}
class QRadioButton;
class QComboBox;
class QCheckBox;
-class QSpinBox;
+class SalomeApp_IntSpinBox;
class SMESHGUI_IdValidator;
class SMESHGUI_SpinBox;
class SMESHGUI;
void hideEvent( QHideEvent* ); /* ESC key */
void keyPressEvent( QKeyEvent* );
+ bool isValid();
+
SMESHGUI* mySMESHGUI; /* Current SMESHGUI object */
SMESHGUI_IdValidator* myIdValidator;
LightApp_SelectionMgr* mySelectionMgr; /* User shape selection */
QLabel* TextLabelMethod;
QComboBox* ComboBoxMethod;
QLabel* TextLabelLimit;
- QSpinBox* SpinBox_IterationLimit;
+ SalomeApp_IntSpinBox* SpinBox_IterationLimit;
QLabel* TextLabelAspectRatio;
SMESHGUI_SpinBox* SpinBox_AspectRatio;
QCheckBox* CheckBoxParametric;
private slots:
void ClickOnOk();
void ClickOnCancel();
- void ClickOnApply();
+ bool ClickOnApply();
void ClickOnHelp();
void SetEditCurrentArgument();
void SelectionIntoArgument();
// function : ClickOnApply()
// purpose :
//=================================================================================
-void SMESHGUI_SymmetryDlg::ClickOnApply()
+bool SMESHGUI_SymmetryDlg::ClickOnApply()
{
if (mySMESHGUI->isActiveStudyLocked())
- return;
+ return false;
+
+ if( !isValid() )
+ return false;
if (myNbOkElements && IsMirrorOk()) {
QStringList aListElementsId = myElementsId.split(" ", QString::SkipEmptyParts);
aMirror.vz = SpinBox_DZ->GetValue();
}
+ QStringList aParameters;
+ aParameters << SpinBox_X->text();
+ aParameters << SpinBox_Y->text();
+ aParameters << SpinBox_Z->text();
+ aParameters << ( GetConstructorId() == 0 ? QString::number(0) : SpinBox_DX->text() );
+ aParameters << ( GetConstructorId() == 0 ? QString::number(0) : SpinBox_DY->text() );
+ aParameters << ( GetConstructorId() == 0 ? QString::number(0) : SpinBox_DZ->text() );
SMESH::SMESH_MeshEditor::MirrorType aMirrorType;
switch ( actionButton ) {
case MOVE_ELEMS_BUTTON:
aMeshEditor->Mirror(anElementsId, aMirror, aMirrorType, false );
+ if( !myMesh->_is_nil())
+ myMesh->SetParameters(SMESHGUI::JoinObjectParameters(aParameters));
break;
case COPY_ELEMS_BUTTON:
if ( makeGroups )
aMeshEditor->MirrorMakeGroups(anElementsId, aMirror, aMirrorType);
else
aMeshEditor->Mirror(anElementsId, aMirror, aMirrorType, true);
+ if( !myMesh->_is_nil())
+ myMesh->SetParameters(SMESHGUI::JoinObjectParameters(aParameters));
break;
case MAKE_MESH_BUTTON:
SMESH::SMESH_Mesh_var mesh =
aMeshEditor->MirrorMakeMesh(anElementsId, aMirror, aMirrorType, makeGroups,
LineEditNewMesh->text().toLatin1().data());
+ if( !mesh->_is_nil())
+ mesh->SetParameters(SMESHGUI::JoinObjectParameters(aParameters));
}
} catch (...) {
}
ConstructorsClicked(GetConstructorId());
SelectionIntoArgument();
}
+
+ return true;
}
//=================================================================================
//=================================================================================
void SMESHGUI_SymmetryDlg::ClickOnOk()
{
- ClickOnApply();
- ClickOnCancel();
+ if( ClickOnApply() )
+ ClickOnCancel();
}
//=================================================================================
ClickOnHelp();
}
}
+
+//=================================================================================
+// function : isValid
+// purpose :
+//=================================================================================
+bool SMESHGUI_SymmetryDlg::isValid()
+{
+ bool ok = true;
+ QString msg;
+
+ ok = SpinBox_X->isValid( msg, true ) && ok;
+ ok = SpinBox_Y->isValid( msg, true ) && ok;
+ ok = SpinBox_Z->isValid( msg, true ) && ok;
+ if (GetConstructorId() != 0) {
+ ok = SpinBox_DX->isValid( msg, true ) && ok;
+ ok = SpinBox_DY->isValid( msg, true ) && ok;
+ ok = SpinBox_DZ->isValid( msg, true ) && ok;
+ }
+
+ if( !ok ) {
+ QString str( tr( "SMESH_INCORRECT_INPUT" ) );
+ if ( !msg.isEmpty() )
+ str += "\n" + msg;
+ SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str );
+ return false;
+ }
+ return true;
+}
bool IsMirrorOk();
void setNewMeshName();
+ bool isValid();
+
SMESHGUI* mySMESHGUI; /* Current SMESHGUI object */
SMESHGUI_IdValidator* myIdValidator;
LightApp_SelectionMgr* mySelectionMgr; /* User shape selection */
void ConstructorsClicked( int );
void ClickOnOk();
void ClickOnCancel();
- void ClickOnApply();
+ bool ClickOnApply();
void ClickOnHelp();
void SetEditCurrentArgument();
void SelectionIntoArgument();
aParameters << SpinBox1_1->text();
aParameters << SpinBox1_2->text();
aParameters << SpinBox1_3->text();
+ if (GetConstructorId() == 0) {
+ aParameters << SpinBox2_1->text();
+ aParameters << SpinBox2_2->text();
+ aParameters << SpinBox2_3->text();
+ }
int actionButton = ActionGroup->checkedId();
bool makeGroups = ( MakeGroupsCheck->isEnabled() && MakeGroupsCheck->isChecked() );
if ( sameMethods.empty() ) {
const char * names[] = {
"RemoveElements","RemoveNodes","AddNode","AddEdge","AddFace","AddPolygonalFace",
- "AddVolume","AddPolyhedralVolume","AddPolyhedralVolumeByFaces","MoveNode",
- "InverseDiag","DeleteDiag","Reorient","ReorientObject","SplitQuad","SplitQuadObject",
+ "AddVolume","AddPolyhedralVolume","AddPolyhedralVolumeByFaces","MoveNode", "MoveClosestNodeToPoint",
+ "InverseDiag","DeleteDiag","Reorient","ReorientObject","TriToQuad","SplitQuad","SplitQuadObject",
"BestSplit","Smooth","SmoothObject","SmoothParametric","SmoothParametricObject",
"ConvertToQuadratic","ConvertFromQuadratic","RenumberNodes","RenumberElements",
"RotationSweep","RotationSweepObject","ExtrusionSweep","AdvancedExtrusion",
if ( begPos < 1 )
begPos = myString.Location( "(", 1, Length() ) + 1;
- int i = 0, prevLen = 0;
+ int i = 0, prevLen = 0, nbNestings = 0;
while ( begPos != EMPTY ) {
begPos += prevLen;
+ if( myString.Value( begPos ) == '(' )
+ nbNestings++;
// check if we are looking at the closing parenthesis
while ( begPos <= Length() && isspace( myString.Value( begPos )))
++begPos;
- if ( begPos > Length() || myString.Value( begPos ) == ')' )
+ if ( begPos > Length() )
break;
+ if ( myString.Value( begPos ) == ')' ) {
+ nbNestings--;
+ if( nbNestings == 0 )
+ break;
+ }
myArgs.Append( GetWord( myString, begPos, true, true ));
SetBegPos( ARG1_IND + i, begPos );
prevLen = myArgs.Last().Length();
{
extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, false );
if ( !myPreviewMode ) {
- TPythonDump() << "stepVector = " << theStepVector;
TPythonDump() << this << ".ExtrusionSweep( "
- << theIDsOfElements << ", stepVector, " << theNbOfSteps << " )";
+ << theIDsOfElements << ", " << theStepVector <<", " << theNbOfSteps << " )";
}
}
SMESH::ListOfGroups* aGroups = extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, true );
if ( !myPreviewMode ) {
- TPythonDump() << "stepVector = " << theStepVector;
TPythonDump aPythonDump;
DumpGroupsList(aPythonDump,aGroups);
aPythonDump << this << ".ExtrusionSweepMakeGroups( "
- << theIDsOfElements << ", stepVector, " << theNbOfSteps << " )";
+ << theIDsOfElements << ", " << theStepVector <<", " << theNbOfSteps << " )";
}
return aGroups;
}
{
SMESH::ListOfGroups * aGroups = mirror(theIDsOfElements, theMirror, theMirrorType, true, true);
if ( !myPreviewMode ) {
- TPythonDump()<<"axis = "<<theMirror;
TPythonDump aPythonDump;
DumpGroupsList(aPythonDump,aGroups);
aPythonDump << this << ".MirrorMakeGroups( "
<< theIDsOfElements << ", "
- << "axis, "
+ << theMirror << ", "
<< mirrorTypeName(theMirrorType) << " )";
}
return aGroups;
SMESH::long_array_var anElementsId = theObject->GetIDs();
SMESH::ListOfGroups * aGroups = mirror(anElementsId, theMirror, theMirrorType, true, true);
if ( !myPreviewMode ) {
- TPythonDump()<<"axis = "<<theMirror;
TPythonDump aPythonDump;
DumpGroupsList(aPythonDump,aGroups);
aPythonDump << this << ".MirrorObjectMakeGroups( "
<< theObject << ", "
- << "axis, "
+ << theMirror << ", "
<< mirrorTypeName(theMirrorType) << " )";
}
return aGroups;
CORBA::Boolean theCopy)
{
if ( !myPreviewMode ) {
- TPythonDump() << "axis = " << theAxis;
TPythonDump() << this << ".Rotate( "
- << theIDsOfElements
- << ", axis, "
+ << theIDsOfElements << ", "
+ << theAxis << ", "
<< theAngle << ", "
<< theCopy << " )";
}
CORBA::Boolean theCopy)
{
if ( !myPreviewMode ) {
- TPythonDump() << "axis = " << theAxis;
TPythonDump() << this << ".RotateObject( "
- << theObject
- << ", axis, "
+ << theObject << ", "
+ << theAxis << ", "
<< theAngle << ", "
<< theCopy << " )";
}
{
SMESH::ListOfGroups * aGroups = rotate(theIDsOfElements,theAxis,theAngle,true,true);
if ( !myPreviewMode ) {
- TPythonDump() << "axis = " << theAxis;
TPythonDump aPythonDump;
DumpGroupsList(aPythonDump,aGroups);
aPythonDump << this << ".RotateMakeGroups( "
- << theIDsOfElements
- << ", axis, "
+ << theIDsOfElements << ", "
+ << theAxis << ", "
<< theAngle << " )";
}
return aGroups;
SMESH::ListOfGroups * aGroups = rotate(anElementsId,theAxis,theAngle,true,true);
if ( !myPreviewMode ) {
- TPythonDump() << "axis = " << theAxis;
TPythonDump aPythonDump;
DumpGroupsList(aPythonDump,aGroups);
aPythonDump << this << ".RotateObjectMakeGroups( "
- << theObject
- << ", axis, "
- << theAngle << " )";
+ << theObject << ", "
+ << theAxis << ", "
+ << theAngle << " )";
}
return aGroups;
}
//================================================================================
void SMESH_NoteBook::ReplaceVariables()
{
-
for(int i=0;i<_commands.size();i++) {
Handle(_pyCommand) aCmd = _commands[i];
TCollection_AsciiString aMethod = aCmd->GetMethod();
}
else if(aStates->GetObjectType().IsEqual("Mesh")) {
- if(aMethod.IsEqual("Translate") ||
+ TState aCurrentState = aStates->GetCurrectState();
+ int aCurrentStateSize = aCurrentState.size();
+ if(aMethod.IsEqual("Translate") ||
aMethod.IsEqual("TranslateMakeGroups") ||
aMethod.IsEqual("TranslateMakeMesh")) {
bool isVariableFound = false;
}
}
if(anArgIndex > 0) {
- for(int j = 0; j <= 2; j++) {
- if(!aStates->GetCurrectState().at(j).IsEmpty()) {
- isVariableFound = true;
- aCmd->SetArg(anArgIndex+j, aStates->GetCurrectState().at(j));
- }
- }
+ if(aCurrentStateSize == 3) { // translation by dx, dy, dz
+ for(int j = 0; j < aCurrentStateSize; j++) {
+ if(!aCurrentState.at(j).IsEmpty()) {
+ isVariableFound = true;
+ aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
+ }
+ }
+ }
+ else if(aCurrentStateSize == 6) { // translation by x1, x2, y1, y2, z1, z2
+ // TODO
+ }
}
if(isVariableFound) {
aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr");
}
aStates->IncrementState();
}
+ else if(aMethod.IsEqual("Rotate") ||
+ aMethod.IsEqual("RotateMakeGroups") ||
+ aMethod.IsEqual("RotateMakeMesh") ||
+ aMethod.IsEqual("Mirror") ||
+ aMethod.IsEqual("MirrorMakeGroups") ||
+ aMethod.IsEqual("MirrorMakeMesh")) {
+ bool isSubstitute = false;
+ int anArgIndex = 0;
+ for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
+ if(aCmd->GetArg(i).IsEqual("SMESH.AxisStruct")) {
+ anArgIndex = i+1;
+ break;
+ }
+ }
+ if(anArgIndex > 0) {
+ for(int j = 0; j < aCurrentStateSize; j++) {
+ if(!aCurrentState.at(j).IsEmpty()) {
+ if(j < 6) // from 0 to 5 - axis struct, 6 - angle
+ isSubstitute = true;
+ aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
+ }
+ }
+ }
+ if(isSubstitute)
+ aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".AxisStructStr");
+ aStates->IncrementState();
+ }
+ else if(aMethod.IsEqual("AddNode") ||
+ aMethod.IsEqual("MoveClosestNodeToPoint")) {
+ for(int j = 0; j < aCurrentStateSize; j++) {
+ if(!aCurrentState.at(j).IsEmpty())
+ aCmd->SetArg(j+1, aCurrentState.at(j));
+ }
+ aStates->IncrementState();
+ }
+ else if(aMethod.IsEqual("MoveNode")) {
+ for(int j = 0; j < aCurrentStateSize; j++) {
+ if(!aCurrentState.at(j).IsEmpty())
+ aCmd->SetArg(j+2, aCurrentState.at(j));
+ }
+ aStates->IncrementState();
+ }
+ else if(aMethod.IsEqual("ExtrusionSweep") ||
+ aMethod.IsEqual("ExtrusionSweepMakeGroups")) {
+ bool isSubstitute = false;
+ int anArgIndex = 0;
+ for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
+ if(aCmd->GetArg(i).IsEqual("SMESH.PointStruct")) {
+ anArgIndex = i+1;
+ break;
+ }
+ }
+ if(anArgIndex > 0) {
+ for(int j = 0; j < aCurrentStateSize; j++) {
+ if(!aCurrentState.at(j).IsEmpty()) {
+ if(j < 3) // from 0 to 2 - dir struct, 3 - number of steps
+ isSubstitute = true;
+ aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
+ }
+ }
+ }
+ if(isSubstitute) {
+ aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr");
+ aCmd->SetArg(anArgIndex - 2, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".DirStructStr");
+ }
+ aStates->IncrementState();
+ }
+ else if(aMethod.IsEqual("TriToQuad") ||
+ aMethod.IsEqual("Concatenate") ||
+ aMethod.IsEqual("ConcatenateWithGroups")) {
+ if(aCurrentStateSize && !aCurrentState.at(0).IsEmpty())
+ aCmd->SetArg(aCmd->GetNbArgs(), aCurrentState.at(0));
+ aStates->IncrementState();
+ }
+ else if(aMethod.IsEqual("Smooth") ||
+ aMethod.IsEqual("SmoothParametric")) {
+ int anArgIndex = aCmd->GetNbArgs() - 2;
+ for(int j = 0; j < aCurrentStateSize; j++) {
+ if(!aCurrentState.at(j).IsEmpty())
+ aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
+ }
+ aStates->IncrementState();
+ }
}
}
if(MYDEBUG) {
else:
self.z = zStr
+# Parametrized substitute for AxisStruct
+class AxisStructStr:
+
+ x = 0
+ y = 0
+ z = 0
+ dx = 0
+ dy = 0
+ dz = 0
+ xStr = ""
+ yStr = ""
+ zStr = ""
+ dxStr = ""
+ dyStr = ""
+ dzStr = ""
+
+ def __init__(self, xStr, yStr, zStr, dxStr, dyStr, dzStr):
+ self.xStr = xStr
+ self.yStr = yStr
+ self.zStr = zStr
+ self.dxStr = dxStr
+ self.dyStr = dyStr
+ self.dzStr = dzStr
+ if isinstance(xStr, str) and notebook.isVariable(xStr):
+ self.x = notebook.get(xStr)
+ else:
+ self.x = xStr
+ if isinstance(yStr, str) and notebook.isVariable(yStr):
+ self.y = notebook.get(yStr)
+ else:
+ self.y = yStr
+ if isinstance(zStr, str) and notebook.isVariable(zStr):
+ self.z = notebook.get(zStr)
+ else:
+ self.z = zStr
+ if isinstance(dxStr, str) and notebook.isVariable(dxStr):
+ self.dx = notebook.get(dxStr)
+ else:
+ self.dx = dxStr
+ if isinstance(dyStr, str) and notebook.isVariable(dyStr):
+ self.dy = notebook.get(dyStr)
+ else:
+ self.dy = dyStr
+ if isinstance(dzStr, str) and notebook.isVariable(dzStr):
+ self.dz = notebook.get(dzStr)
+ else:
+ self.dz = dzStr
+
# Parametrized substitute for DirStruct
class DirStructStr:
self.pointStruct = pointStruct
# Returns list of variable values from salome notebook
-def ParseDirStruct(Vector):
- pntStr = Vector.pointStruct
- pnt = PointStruct(pntStr.x, pntStr.y, pntStr.z)
- Vector = DirStruct(pnt)
- Parameters = str(pntStr.xStr) + ":" + str(pntStr.yStr) + ":" + str(pntStr.zStr)
- return Vector, Parameters
+def ParsePointStruct(Point):
+ Parameters = "::"
+ if isinstance(Point, PointStructStr):
+ Parameters = str(Point.xStr) + ":" + str(Point.yStr) + ":" + str(Point.zStr)
+ Point = PointStruct(Point.x, Point.y, Point.z)
+ return Point, Parameters
+
+# Returns list of variable values from salome notebook
+def ParseDirStruct(Dir):
+ Parameters = "::"
+ if isinstance(Dir, DirStructStr):
+ pntStr = Dir.pointStruct
+ Parameters = str(pntStr.xStr) + ":" + str(pntStr.yStr) + ":" + str(pntStr.zStr)
+ Point = PointStruct(pntStr.x, pntStr.y, pntStr.z)
+ Dir = DirStruct(Point)
+ return Dir, Parameters
+
+# Returns list of variable values from salome notebook
+def ParseAxisStruct(Axis):
+ Parameters = ":::::"
+ if isinstance(Axis, AxisStructStr):
+ Parameters = str(Axis.xStr) + ":" + str(Axis.yStr) + ":" + str(Axis.zStr) + ":"
+ Parameters += str(Axis.dxStr) + ":" + str(Axis.dyStr) + ":" + str(Axis.dzStr)
+ Axis = AxisStruct(Axis.x, Axis.y, Axis.z, Axis.dx, Axis.dy, Axis.dz)
+ return Axis, Parameters
def IsEqual(val1, val2, tol=PrecisionConfusion):
if abs(val1 - val2) < tol:
def GetPattern(self):
return SMESH._objref_SMESH_Gen.GetPattern(self)
+ ## Create a compound of Mesh objects
+ # @param theMeshArray array of Mesh objects
+ # @param theUniteIdenticalGroups flag used to unite identical mesh groups
+ # @param theMergeNodesAndElements flag used to merge mesh nodes and elements
+ # @param theMergeTolerance tolerance of merging
+ # @return a compound of Mesh objects
+ # @ingroup l1_auxiliary
+ def Concatenate( self, theMeshArray, theUniteIdenticalGroups, theMergeNodesAndElements, theMergeTolerance ):
+ theMergeTolerance,Parameters = geompyDC.ParseParameters(theMergeTolerance)
+ aMesh = SMESH._objref_SMESH_Gen.Concatenate( self, theMeshArray, theUniteIdenticalGroups, theMergeNodesAndElements, theMergeTolerance )
+ aMesh.SetParameters(Parameters)
+ return aMesh
+
+ ## Create a compound of Mesh objects
+ # @param theMeshArray array of Mesh objects
+ # @param theUniteIdenticalGroups flag used to unite identical mesh groups
+ # @param theMergeNodesAndElements flag used to merge mesh nodes and elements
+ # @param theMergeTolerance tolerance of merging
+ # @return a compound of Mesh objects
+ # @ingroup l1_auxiliary
+ def ConcatenateWithGroups( self, theMeshArray, theUniteIdenticalGroups, theMergeNodesAndElements, theMergeTolerance ):
+ theMergeTolerance,Parameters = geompyDC.ParseParameters(theMergeTolerance)
+ aMesh = SMESH._objref_SMESH_Gen.ConcatenateWithGroups( self, theMeshArray, theUniteIdenticalGroups, theMergeNodesAndElements, theMergeTolerance )
+ aMesh.SetParameters(Parameters)
+ return aMesh
+
# Filtering. Auxiliary functions:
# ------------------------------
# @return Id of the new node
# @ingroup l2_modif_add
def AddNode(self, x, y, z):
+ x,y,z,Parameters = geompyDC.ParseParameters(x,y,z)
+ self.mesh.SetParameters(Parameters)
return self.editor.AddNode( x, y, z)
## Creates a linear or quadratic edge (this is determined
# @return True if succeed else False
# @ingroup l2_modif_movenode
def MoveNode(self, NodeID, x, y, z):
+ x,y,z,Parameters = geompyDC.ParseParameters(x,y,z)
+ self.mesh.SetParameters(Parameters)
return self.editor.MoveNode(NodeID, x, y, z)
+ ## Finds the node closest to a point and moves it to a point location
+ # @param x the X coordinate of a point
+ # @param y the Y coordinate of a point
+ # @param z the Z coordinate of a point
+ # @return the ID of a node
+ # @ingroup l2_modif_throughp
+ def MoveClosestNodeToPoint(self, x, y, z, NodeID):
+ x,y,z,Parameters = geompyDC.ParseParameters(x,y,z)
+ self.mesh.SetParameters(Parameters)
+ return self.editor.MoveClosestNodeToPoint(x, y, z, NodeID)
+
## Finds the node closest to a point
# @param x the X coordinate of a point
# @param y the Y coordinate of a point
# @param theCriterion is FT_...; used to choose a neighbour to fuse with.
# @param MaxAngle is the maximum angle between element normals at which the fusion
# is still performed; theMaxAngle is mesured in radians.
+ # Also it could be a name of variable which defines angle in degrees.
# @return TRUE in case of success, FALSE otherwise.
# @ingroup l2_modif_unitetri
def TriToQuad(self, IDsOfElements, theCriterion, MaxAngle):
+ flag = False
+ if isinstance(MaxAngle,str):
+ flag = True
+ MaxAngle,Parameters = geompyDC.ParseParameters(MaxAngle)
+ if flag:
+ MaxAngle = DegreesToRadians(MaxAngle)
if IDsOfElements == []:
IDsOfElements = self.GetElementsId()
- return self.editor.TriToQuad(IDsOfElements, self.smeshpyD.GetFunctor(theCriterion), MaxAngle)
+ self.mesh.SetParameters(Parameters)
+ Functor = 0
+ if ( isinstance( theCriterion, SMESH._objref_NumericalFunctor ) ):
+ Functor = theCriterion
+ else:
+ Functor = self.smeshpyD.GetFunctor(theCriterion)
+ return self.editor.TriToQuad(IDsOfElements, Functor, MaxAngle)
## Fuses the neighbouring triangles of the object into quadrangles
# @param theObject is mesh, submesh or group
MaxNbOfIterations, MaxAspectRatio, Method):
if IDsOfElements == []:
IDsOfElements = self.GetElementsId()
+ MaxNbOfIterations,MaxAspectRatio,Parameters = geompyDC.ParseParameters(MaxNbOfIterations,MaxAspectRatio)
+ self.mesh.SetParameters(Parameters)
return self.editor.Smooth(IDsOfElements, IDsOfFixedNodes,
MaxNbOfIterations, MaxAspectRatio, Method)
MaxNbOfIterations, MaxAspectRatio, Method):
if IDsOfElements == []:
IDsOfElements = self.GetElementsId()
+ MaxNbOfIterations,MaxAspectRatio,Parameters = geompyDC.ParseParameters(MaxNbOfIterations,MaxAspectRatio)
+ self.mesh.SetParameters(Parameters)
return self.editor.SmoothParametric(IDsOfElements, IDsOfFixedNodes,
MaxNbOfIterations, MaxAspectRatio, Method)
IDsOfElements = self.GetElementsId()
if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)):
StepVector = self.smeshpyD.GetDirStruct(StepVector)
+ StepVector,StepVectorParameters = ParseDirStruct(StepVector)
+ NbOfSteps,Parameters = geompyDC.ParseParameters(NbOfSteps)
+ Parameters = StepVectorParameters + ":" + Parameters
+ self.mesh.SetParameters(Parameters)
if MakeGroups:
return self.editor.ExtrusionSweepMakeGroups(IDsOfElements, StepVector, NbOfSteps)
self.editor.ExtrusionSweep(IDsOfElements, StepVector, NbOfSteps)
IDsOfElements = self.GetElementsId()
if ( isinstance( Mirror, geompyDC.GEOM._objref_GEOM_Object)):
Mirror = self.smeshpyD.GetAxisStruct(Mirror)
+ Mirror,Parameters = ParseAxisStruct(Mirror)
+ self.mesh.SetParameters(Parameters)
if Copy and MakeGroups:
return self.editor.MirrorMakeGroups(IDsOfElements, Mirror, theMirrorType)
self.editor.Mirror(IDsOfElements, Mirror, theMirrorType, Copy)
IDsOfElements = self.GetElementsId()
if ( isinstance( Mirror, geompyDC.GEOM._objref_GEOM_Object)):
Mirror = self.smeshpyD.GetAxisStruct(Mirror)
+ Mirror,Parameters = ParseAxisStruct(Mirror)
mesh = self.editor.MirrorMakeMesh(IDsOfElements, Mirror, theMirrorType,
MakeGroups, NewMeshName)
+ mesh.SetParameters(Parameters)
return Mesh(self.smeshpyD,self.geompyD,mesh)
## Creates a symmetrical copy of the object
# @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
# @ingroup l2_modif_trsf
def Translate(self, IDsOfElements, Vector, Copy, MakeGroups=False):
- Parameters = ""
if IDsOfElements == []:
IDsOfElements = self.GetElementsId()
if ( isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object)):
Vector = self.smeshpyD.GetDirStruct(Vector)
- elif ( isinstance( Vector, DirStructStr ) ):
- Vector,Parameters = ParseDirStruct(Vector)
+ Vector,Parameters = ParseDirStruct(Vector)
+ self.mesh.SetParameters(Parameters)
if Copy and MakeGroups:
return self.editor.TranslateMakeGroups(IDsOfElements, Vector)
self.editor.Translate(IDsOfElements, Vector, Copy)
- self.mesh.SetParameters(Parameters)
return []
## Creates a new mesh of translated elements
# @return instance of Mesh class
# @ingroup l2_modif_trsf
def TranslateMakeMesh(self, IDsOfElements, Vector, MakeGroups=False, NewMeshName=""):
- Parameters = ""
if IDsOfElements == []:
IDsOfElements = self.GetElementsId()
if ( isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object)):
Vector = self.smeshpyD.GetDirStruct(Vector)
- elif ( isinstance( Vector, DirStructStr ) ):
- Vector,Parameters = ParseDirStruct(Vector)
+ Vector,Parameters = ParseDirStruct(Vector)
mesh = self.editor.TranslateMakeMesh(IDsOfElements, Vector, MakeGroups, NewMeshName)
mesh.SetParameters(Parameters)
return Mesh ( self.smeshpyD, self.geompyD, mesh )
## Rotates the elements
# @param IDsOfElements list of elements ids
# @param Axis the axis of rotation (AxisStruct or geom line)
- # @param AngleInRadians the angle of rotation (in radians)
+ # @param AngleInRadians the angle of rotation (in radians) or a name of variable which defines angle in degrees
# @param Copy allows copying the rotated elements
# @param MakeGroups forces the generation of new groups from existing ones (if Copy)
# @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
# @ingroup l2_modif_trsf
def Rotate (self, IDsOfElements, Axis, AngleInRadians, Copy, MakeGroups=False):
+ flag = False
+ if isinstance(AngleInRadians,str):
+ flag = True
+ AngleInRadians,Parameters = geompyDC.ParseParameters(AngleInRadians)
+ if flag:
+ AngleInRadians = DegreesToRadians(AngleInRadians)
if IDsOfElements == []:
IDsOfElements = self.GetElementsId()
if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)):
Axis = self.smeshpyD.GetAxisStruct(Axis)
+ Axis,AxisParameters = ParseAxisStruct(Axis)
+ Parameters = AxisParameters + ":" + Parameters
+ self.mesh.SetParameters(Parameters)
if Copy and MakeGroups:
return self.editor.RotateMakeGroups(IDsOfElements, Axis, AngleInRadians)
self.editor.Rotate(IDsOfElements, Axis, AngleInRadians, Copy)
## Creates a new mesh of rotated elements
# @param IDsOfElements list of element ids
# @param Axis the axis of rotation (AxisStruct or geom line)
- # @param AngleInRadians the angle of rotation (in radians)
+ # @param AngleInRadians the angle of rotation (in radians) or a name of variable which defines angle in degrees
# @param MakeGroups forces the generation of new groups from existing ones
# @param NewMeshName the name of the newly created mesh
# @return instance of Mesh class
# @ingroup l2_modif_trsf
def RotateMakeMesh (self, IDsOfElements, Axis, AngleInRadians, MakeGroups=0, NewMeshName=""):
+ flag = False
+ if isinstance(AngleInRadians,str):
+ flag = True
+ AngleInRadians,Parameters = geompyDC.ParseParameters(AngleInRadians)
+ if flag:
+ AngleInRadians = DegreesToRadians(AngleInRadians)
if IDsOfElements == []:
IDsOfElements = self.GetElementsId()
if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)):
Axis = self.smeshpyD.GetAxisStruct(Axis)
+ Axis,AxisParameters = ParseAxisStruct(Axis)
+ Parameters = AxisParameters + ":" + Parameters
mesh = self.editor.RotateMakeMesh(IDsOfElements, Axis, AngleInRadians,
MakeGroups, NewMeshName)
+ mesh.SetParameters(Parameters)
return Mesh( self.smeshpyD, self.geompyD, mesh )
## Rotates the object
