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

22364: EDF SMESH: Create Mesh dialog box improvement: hide inapplicable algorithms/hypotheses

Browse Source 
1) Some fixes
  2) pass toCheckAll=true to IsApplicable() only if a shape is geom group
This commit is contained in:
eap 2014-03-11 19:46:54 +04:00
parent 28140bb1c8
commit 395112afac
3 changed files with 43 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
src/SMESHGUI/SMESHGUI_MeshOp.cxx
View File

@ -41,6 +41,7 @@
#include <GEOMBase.h> #include <GEOMBase.h>
#include <GeometryGUI.h> #include <GeometryGUI.h>
#include <GEOM_wrap.hxx> #include <GEOM_wrap.hxx>
#include <GEOMImpl_Types.hxx>
// SALOME GUI includes // SALOME GUI includes
#include <SalomeApp_Tools.h> #include <SalomeApp_Tools.h>
@ -2535,33 +2536,40 @@ void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theI
int anCurrentAvailableAlgo = 0; int anCurrentAvailableAlgo = 0;
bool isNone = true; bool isNone = true;
switch ( theIndex ) { switch ( theIndex ) {
case MT_ANY:{ case MT_ANY:
anCompareType = "ANY"; anCompareType = "ANY";
aDim = SMESH::DIM_3D; aDim = SMESH::DIM_3D;
} break;
break; case MT_TRIANGULAR:
case MT_TRIANGULAR:{
aDim = SMESH::DIM_2D; aDim = SMESH::DIM_2D;
anCompareType = "TRIA"; anCompareType = "TRIA";
} break;
break; case MT_QUADRILATERAL:
case MT_QUADRILATERAL:{
aDim = SMESH::DIM_2D; aDim = SMESH::DIM_2D;
anCompareType = "QUAD"; anCompareType = "QUAD";
} break;
break; case MT_TETRAHEDRAL:
case MT_TETRAHEDRAL:{
aDim = SMESH::DIM_3D; aDim = SMESH::DIM_3D;
anCompareType = "TETRA"; anCompareType = "TETRA";
} break;
break; case MT_HEXAHEDRAL:
case MT_HEXAHEDRAL:{
aDim = SMESH::DIM_3D; aDim = SMESH::DIM_3D;
anCompareType = "HEXA"; anCompareType = "HEXA";
} break;
break;
default:; default:;
} }
bool toCheckIsApplicableToAll = !myIsMesh;
GEOM::GEOM_Object_var aGeomVar;
QString anEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
if ( _PTR(SObject) so = studyDS()->FindObjectID( anEntry.toLatin1().data() ))
{
CORBA::Object_var obj = _CAST( SObject,so )->GetObject();
aGeomVar = GEOM::GEOM_Object::_narrow( obj );
if ( !aGeomVar->_is_nil() && toCheckIsApplicableToAll )
toCheckIsApplicableToAll = ( aGeomVar->GetType() == GEOM_GROUP );
}
if ( anCompareType == "ANY" ) if ( anCompareType == "ANY" )
{ {
for ( int dim = SMESH::DIM_2D; dim <= SMESH::DIM_3D; dim++ ) for ( int dim = SMESH::DIM_2D; dim <= SMESH::DIM_3D; dim++ )
@ -2572,7 +2580,7 @@ void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theI
availableHyps( dim, Algo, anAvailableAlgs, anAvailableAlgsData ); availableHyps( dim, Algo, anAvailableAlgs, anAvailableAlgsData );
//return current algo in current tab and set new algorithm list //return current algo in current tab and set new algorithm list
HypothesisData* algoCur; HypothesisData* algoCur;
if ( !isNone && !myAvailableHypData[dim][Algo].empty() ){ if ( !isNone && !myAvailableHypData[dim][Algo].empty() ) {
algoCur = myAvailableHypData[dim][Algo].at( currentHyp( dim, Algo ) ); algoCur = myAvailableHypData[dim][Algo].at( currentHyp( dim, Algo ) );
} }
myAvailableHypData[dim][Algo].clear(); myAvailableHypData[dim][Algo].clear();
@ -2580,19 +2588,14 @@ void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theI
for (int i = 0 ; i < anAvailableAlgsData.count(); i++) for (int i = 0 ; i < anAvailableAlgsData.count(); i++)
{ {
HypothesisData* curAlgo = anAvailableAlgsData.at(i); HypothesisData* curAlgo = anAvailableAlgsData.at(i);
QString anEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
GEOM::GEOM_Object_var aGeomVar = GEOM::GEOM_Object::_nil();
if ( _PTR(SObject) pGeom = studyDS()->FindObjectID( anEntry.toLatin1().data() ))
{
aGeomVar= GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() );
}
if ( aGeomVar->_is_nil() || if ( aGeomVar->_is_nil() ||
( !aGeomVar->_is_nil() && SMESH::IsApplicable( curAlgo->TypeName, aGeomVar, !myIsMesh ))){ SMESH::IsApplicable( curAlgo->TypeName, aGeomVar, toCheckIsApplicableToAll ))
{
anAvailableAlgs.append( curAlgo->Label ); anAvailableAlgs.append( curAlgo->Label );
myAvailableHypData[dim][Algo].append( curAlgo ); myAvailableHypData[dim][Algo].append( curAlgo );
} }
} }
if ( !isNone && algoCur ){ if ( !isNone && algoCur ) {
for (int i = 0 ; i < myAvailableHypData[dim][Algo].count(); i++) for (int i = 0 ; i < myAvailableHypData[dim][Algo].count(); i++)
{ {
HypothesisData* algoAny = myAvailableHypData[dim][Algo].at(i); HypothesisData* algoAny = myAvailableHypData[dim][Algo].at(i);
@ -2603,7 +2606,7 @@ void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theI
} }
} }
} }
else if ( !isNone ){ else if ( !isNone ) {
isAvailableChoiceAlgo = true; isAvailableChoiceAlgo = true;
anCurrentAvailableAlgo = currentHyp( dim, Algo ); anCurrentAvailableAlgo = currentHyp( dim, Algo );
} }
@ -2657,27 +2660,22 @@ void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theI
QStringList::const_iterator inElemType = algoIn->OutputTypes.begin(); QStringList::const_iterator inElemType = algoIn->OutputTypes.begin();
for ( ; inElemType != algoIn->OutputTypes.end(); inElemType++ ) for ( ; inElemType != algoIn->OutputTypes.end(); inElemType++ )
{ {
if ( *inElemType == anCurrentCompareType ){ if ( *inElemType == anCurrentCompareType ) {
isAvailableAlgo = true; isAvailableAlgo = true;
break; break;
} }
} }
if ( isAvailableAlgo || algoIn->OutputTypes.count()==0 ){ if ( isAvailableAlgo || algoIn->OutputTypes.count()==0 ) {
QString anEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
GEOM::GEOM_Object_var aGeomVar = GEOM::GEOM_Object::_nil();
if ( _PTR(SObject) pGeom = studyDS()->FindObjectID( anEntry.toLatin1().data() ))
{
aGeomVar= GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() );
}
if ( aGeomVar->_is_nil() || myMaxShapeDim != dim || if ( aGeomVar->_is_nil() || myMaxShapeDim != dim ||
( !aGeomVar->_is_nil() && SMESH::IsApplicable( algoIn->TypeName, aGeomVar, !myIsMesh ))){ SMESH::IsApplicable( algoIn->TypeName, aGeomVar, toCheckIsApplicableToAll ))
{
anAvailableAlgs.append( algoIn->Label ); anAvailableAlgs.append( algoIn->Label );
myAvailableHypData[dim][Algo].append( algoIn ); myAvailableHypData[dim][Algo].append( algoIn );
myFilteredAlgoData[dim].append( algoIn ); myFilteredAlgoData[dim].append( algoIn );
} }
} }
//algorithm will be active, if the chosen algorithm available in the current mesh type //algorithm will be active, if the chosen algorithm available in the current mesh type
if ( !isNoneAlg && isAvailableAlgo && algoIn->Label == anCurrentAlgo ){ if ( !isNoneAlg && isAvailableAlgo && algoIn->Label == anCurrentAlgo ) {
isAvailableChoiceAlgo = true; isAvailableChoiceAlgo = true;
anCurrentAvailableAlgo = anAvailableAlgs.count() - 1 ; anCurrentAvailableAlgo = anAvailableAlgs.count() - 1 ;
} }
@ -2700,7 +2698,7 @@ void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theI
} }
} }
} }
else if ( !isNone ){ else if ( !isNone ) {
if ( aDim == SMESH::DIM_2D){ if ( aDim == SMESH::DIM_2D){
myDlg->disableTab( SMESH::DIM_3D ); myDlg->disableTab( SMESH::DIM_3D );
setCurrentHyp( SMESH::DIM_3D, Algo, -1); setCurrentHyp( SMESH::DIM_3D, Algo, -1);

19
src/SMESH_SWIG/smeshBuilder.py
View File

@ -1563,25 +1563,24 @@ class Mesh:
if not geom: if not geom:
geom = self.mesh.GetShapeToMesh() geom = self.mesh.GetShapeToMesh()
pass pass
hyp_name = GetName( hyp )
geom_name = ""
if geom:
geom_name = geom.GetName()
isApplicable = True isApplicable = True
if self.mesh.HasShapeToMesh(): if self.mesh.HasShapeToMesh():
hyp_type = hyp.GetName() hyp_type = hyp.GetName()
lib_name = hyp.GetLibName() lib_name = hyp.GetLibName()
isSubMesh = ( not geom.IsSame( self.mesh.GetShapeToMesh() )) isSubMesh = ( not geom.IsSame( self.mesh.GetShapeToMesh() ))
isApplicable = self.smeshpyD.IsApplicable(hyp_name, lib_name, geom, isSubMesh) isApplicable = self.smeshpyD.IsApplicable(hyp_type, lib_name, geom, isSubMesh)
if isApplicable: if isApplicable:
AssureGeomPublished( self, geom, "shape for %s" % hyp.GetName()) AssureGeomPublished( self, geom, "shape for %s" % hyp.GetName())
status = self.mesh.AddHypothesis(geom, hyp) status = self.mesh.AddHypothesis(geom, hyp)
isAlgo = hyp._narrow( SMESH_Algo )
TreatHypoStatus( status, hyp_name, geom_name, isAlgo )
return status
else: else:
TreatHypoStatus( HYP_BAD_GEOMETRY, hyp_name, geom_name, isAlgo ) status = HYP_BAD_GEOMETRY
return HYP_BAD_GEOMETRY hyp_name = GetName( hyp )
geom_name = ""
if geom:
geom_name = geom.GetName()
isAlgo = hyp._narrow( SMESH_Algo )
TreatHypoStatus( status, hyp_name, geom_name, isAlgo )
return status
## Return True if an algorithm of hypothesis is assigned to a given shape ## Return True if an algorithm of hypothesis is assigned to a given shape
# @param hyp a hypothesis to check # @param hyp a hypothesis to check

6
src/SMESH_SWIG/smesh_algorithm.py
View File

@ -195,17 +195,11 @@ class Mesh_Algorithm:
if geom is None and mesh.mesh.HasShapeToMesh(): if geom is None and mesh.mesh.HasShapeToMesh():
raise RuntimeError, "Attemp to create " + algo + " algoritm on None shape" raise RuntimeError, "Attemp to create " + algo + " algoritm on None shape"
self.mesh = mesh self.mesh = mesh
name = ""
if not geom or geom.IsSame( mesh.geom ): if not geom or geom.IsSame( mesh.geom ):
self.geom = mesh.geom self.geom = mesh.geom
else: else:
self.geom = geom self.geom = geom
AssureGeomPublished( mesh, geom ) AssureGeomPublished( mesh, geom )
try:
name = GetName(geom)
pass
except:
pass
self.subm = mesh.mesh.GetSubMesh(geom, algo.GetName()) self.subm = mesh.mesh.GetSubMesh(geom, algo.GetName())
self.algo = algo self.algo = algo
status = mesh.AddHypothesis(self.algo, self.geom) status = mesh.AddHypothesis(self.algo, self.geom)