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

0021859: SMESH : Add conversion from QUAD8 to QUAD9 and from HEXA20 to HEXA27

Browse Source
This commit is contained in:
eap 2013-03-06 08:35:11 +00:00
parent acf3857e67
commit 91a2b8aad9
4 changed files with 91 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
src/SMESHGUI/SMESHGUI_ConvToQuadDlg.cxx
View File

@ -27,6 +27,8 @@
//
#include "SMESHGUI_ConvToQuadDlg.h"
#include "SMESHGUI_ConvToQuadOp.h"
// Qt includes
#include <QGroupBox>
#include <QCheckBox>
@ -62,14 +64,17 @@ SMESHGUI_ConvToQuadDlg::SMESHGUI_ConvToQuadDlg()
aBGLayout->setMargin(MARGIN);
aBGLayout->setSpacing(SPACING);
myRB1 = new QRadioButton( tr( "RADIOBTN_1" ), myBGBox );
myRB2 = new QRadioButton( tr( "RADIOBTN_2" ), myBGBox );
myRB2Lin = new QRadioButton( tr( "RADIOBTN_1" ), myBGBox );
myRB2Quad = new QRadioButton( tr( "RADIOBTN_2" ), myBGBox );
myRB2BiQua = new QRadioButton( tr( "RADIOBTN_3" ), myBGBox );
aBGLayout->addWidget(myRB1);
aBGLayout->addWidget(myRB2);
myBG->addButton(myRB1, 0);
myBG->addButton(myRB2, 1);
myRB1->setChecked( true );
aBGLayout->addWidget(myRB2Lin);
aBGLayout->addWidget(myRB2Quad);
aBGLayout->addWidget(myRB2BiQua);
myBG->addButton(myRB2Lin, 0);
myBG->addButton(myRB2Quad, 1);
myBG->addButton(myRB2BiQua, 2);
myRB2Lin->setChecked( true );
myWarning = new QLabel(QString("<b>%1</b>").arg(tr("NON_CONFORM_WARNING")), mainFrame());
@ -92,6 +97,11 @@ SMESHGUI_ConvToQuadDlg::~SMESHGUI_ConvToQuadDlg()
{
}
bool SMESHGUI_ConvToQuadDlg::IsBiQuadratic() const
{
return myRB2BiQua->isChecked();
}
bool SMESHGUI_ConvToQuadDlg::IsMediumNdsOnGeom() const
{
return !myMedNdsOnGeom->isChecked();
@ -133,27 +143,32 @@ bool SMESHGUI_ConvToQuadDlg::isWarningShown()
void SMESHGUI_ConvToQuadDlg::SetEnabledControls( const bool theCheck )
{
//myBGBox->setEnabled( theCheck );
myRB1->setEnabled( theCheck );
myRB2->setEnabled( theCheck );
myRB2Lin->setEnabled( theCheck );
myRB2Quad->setEnabled( theCheck );
myRB2BiQua->setEnabled( theCheck );
myMedNdsOnGeom->setEnabled( theCheck );
//setButtonEnabled( theCheck, QtxDialog::OK | QtxDialog::Apply );
}
void SMESHGUI_ConvToQuadDlg::SetEnabledRB( const int idx, const bool theCheck )
{
if(idx)
myRB2Lin ->setEnabled( idx & SMESHGUI_ConvToQuadOp::Linear );
myRB2Quad ->setEnabled( idx & SMESHGUI_ConvToQuadOp::Quadratic );
myRB2BiQua->setEnabled( idx & SMESHGUI_ConvToQuadOp::BiQuadratic );
if ( idx & SMESHGUI_ConvToQuadOp::Linear )
{
myRB2->setEnabled( theCheck );
myRB1->setEnabled( !theCheck );
myRB1->setChecked( true );
myRB2Lin->setChecked( true );
myRB2Quad->setChecked( false );
}
else
{
myRB1->setEnabled( theCheck );
myRB2->setEnabled( !theCheck );
myRB2->setChecked( true );
myRB2Lin->setChecked( false );
myRB2Quad->setChecked( true );
}
myRB2BiQua->setChecked( false );
myMedNdsOnGeom->setEnabled( theCheck );
emit onClicked( myBG->checkedId() );
}

6
src/SMESHGUI/SMESHGUI_ConvToQuadDlg.h
View File

@ -56,6 +56,7 @@ public:
int CurrentRB(); //returns the ID of the selected toggle button
void ShowWarning(bool);
bool isWarningShown();
bool IsBiQuadratic() const;
signals:
void onClicked( int );
@ -64,8 +65,9 @@ private:
QCheckBox* myMedNdsOnGeom;
QGroupBox* myBGBox;
QButtonGroup* myBG;
QRadioButton* myRB1;
QRadioButton* myRB2;
QRadioButton* myRB2Lin;
QRadioButton* myRB2Quad;
QRadioButton* myRB2BiQua;
QLabel* myWarning;
};

78
src/SMESHGUI/SMESHGUI_ConvToQuadOp.cxx
View File

@ -142,19 +142,10 @@ void SMESHGUI_ConvToQuadOp::selectionDone()
myDlg->setButtonEnabled( false, QtxDialog::OK | QtxDialog::Apply );
return;
}
MeshType meshType = ConsistMesh( idSource );
if( meshType == SMESHGUI_ConvToQuadOp::Quadratic )
{
myDlg->SetEnabledRB( 0, false );
}
else if( meshType == SMESHGUI_ConvToQuadOp::Linear )
{
myDlg->SetEnabledRB( 1, false );
}
else
{
myDlg->SetEnabledControls( true );
}
SMESH::SMESH_Mesh_var mesh = idSource->GetMesh();
bool hasGeom = mesh->HasShapeToMesh();
MeshDestinationType meshTgtType = DestinationMesh( idSource );
myDlg->SetEnabledRB( meshTgtType, hasGeom && ( meshTgtType & ( BiQuadratic | Quadratic )));
// show warning on non-conformal result mesh
if ( ! idSource->_is_nil() )
@ -166,8 +157,9 @@ void SMESHGUI_ConvToQuadOp::selectionDone()
{
SMESH::SMESH_Mesh_var mesh = idSource->GetMesh();
idSource = SMESH::SMESH_IDSource::_narrow( mesh );
MeshType fullMeshType = ConsistMesh( idSource );
toShow = ( fullMeshType != Comp );
bool isMixOrder;
DestinationMesh( idSource, &isMixOrder );
toShow = !isMixOrder;
}
myDlg->ShowWarning( toShow );
}
@ -241,17 +233,20 @@ bool SMESHGUI_ConvToQuadOp::onApply()
SMESH::SMESH_MeshEditor_var aEditor = mesh->GetMeshEditor();
aResult = true;
SMESH::SMESH_Mesh_var sourceMesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( pObj );
if( !myDlg->CurrentRB() )
if( myDlg->CurrentRB()==1 || myDlg->CurrentRB()==2)
{
bool force3d = true;
if( myDlg->IsEnabledCheck() )
force3d = myDlg->IsMediumNdsOnGeom();
if ( sourceMesh->_is_nil() )
aEditor->ConvertToQuadraticObject( force3d, idSource );
else
aEditor->ConvertToQuadratic( force3d );
bool theToBiQuad = myDlg->IsBiQuadratic();
if ( sourceMesh->_is_nil() ) {
if ( theToBiQuad ) aEditor->ConvertToBiQuadratic ( force3d, idSource );
else aEditor->ConvertToQuadraticObject( force3d, idSource );
}
else {
if ( theToBiQuad ) aEditor->ConvertToBiQuadratic( force3d, sourceMesh );
else aEditor->ConvertToQuadratic ( force3d );
}
if ( !force3d )
{
SMESH::ComputeError_var error = aEditor->GetLastError();
@ -325,12 +320,23 @@ void SMESHGUI_ConvToQuadOp::onWarningWinFinished()
//================================================================================
/*! ConsistMesh
* Determines, what elements this mesh contains.
* Determines, what elements this mesh does not contain.
*/
//================================================================================
SMESHGUI_ConvToQuadOp::MeshType SMESHGUI_ConvToQuadOp::ConsistMesh( const SMESH::SMESH_IDSource_var& idSource) const
SMESHGUI_ConvToQuadOp::MeshDestinationType
SMESHGUI_ConvToQuadOp::DestinationMesh( const SMESH::SMESH_IDSource_var& idSource,
bool* isMixOrder) const
{
SMESH::long_array_var nbElemOfType = idSource->GetMeshInfo();
bool hasBiQuad = ( nbElemOfType[SMDSEntity_BiQuad_Quadrangle ] ||
nbElemOfType[SMDSEntity_TriQuad_Hexa ] );
bool hasLinStruct = ( nbElemOfType[SMDSEntity_Quadrangle ] ||
nbElemOfType[SMDSEntity_Hexa ] );
bool hasQuadStruct = ( nbElemOfType[SMDSEntity_Quad_Quadrangle ] ||
nbElemOfType[SMDSEntity_Quad_Hexa ] );
bool hasQuad = ( nbElemOfType[SMDSEntity_Quad_Edge ] ||
nbElemOfType[SMDSEntity_Quad_Triangle ] ||
nbElemOfType[SMDSEntity_Quad_Quadrangle] ||
@ -347,9 +353,25 @@ SMESHGUI_ConvToQuadOp::MeshType SMESHGUI_ConvToQuadOp::ConsistMesh( const SMESH:
nbElemOfType[SMDSEntity_Pyramid ] ||
nbElemOfType[SMDSEntity_Penta ] );
if ( hasQuad && hasLin )
return Comp;
return hasQuad ? Quadratic : Linear;
int tgtType = 0;
if ( hasBiQuad )
tgtType |= ( Quadratic | Linear );
if ( hasLinStruct )
tgtType |= ( BiQuadratic | Quadratic );
if ( hasQuadStruct )
tgtType |= ( BiQuadratic | Linear );
if ( hasQuad )
tgtType |= Linear;
if ( hasLin )
tgtType |= Quadratic;
if ( tgtType == 0 )
tgtType = Quadratic;
if ( isMixOrder )
*isMixOrder = ( hasLin && ( hasQuad || hasBiQuad ));
return MeshDestinationType( tgtType );
}
void SMESHGUI_ConvToQuadOp::ConnectRadioButtons( int id )
@ -364,7 +386,7 @@ void SMESHGUI_ConvToQuadOp::ConnectRadioButtons( int id )
bool hasGeom = mesh->HasShapeToMesh();
if( id || !hasGeom )
if( id==0 || !hasGeom )
myDlg->SetEnabledCheck( false );
else
myDlg->SetEnabledCheck( true );

5
src/SMESHGUI/SMESHGUI_ConvToQuadOp.h
View File

@ -44,7 +44,7 @@ class SMESHGUI_EXPORT SMESHGUI_ConvToQuadOp : public SMESHGUI_SelectionOp
Q_OBJECT
public:
enum MeshType{ Comp = 0, Linear, Quadratic };
enum MeshDestinationType { Linear = 1, Quadratic = 2, BiQuadratic = 4 };
public:
SMESHGUI_ConvToQuadOp();
@ -56,7 +56,8 @@ protected:
virtual void startOperation();
virtual void selectionDone();
virtual SUIT_SelectionFilter* createFilter( const int ) const;
MeshType ConsistMesh( const SMESH::SMESH_IDSource_var& ) const;
MeshDestinationType DestinationMesh( const SMESH::SMESH_IDSource_var& ,
bool* isMixOrder = 0) const;
protected slots:
virtual bool onApply();