-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "SMESHGUI.h"
#include "SMESHGUI_HypothesesUtils.h"
-#include "SMESHGUI_Utils.h"
#include "SMESHGUI_SpinBox.h"
+#include "SMESHGUI_Utils.h"
+#include "SMESHGUI_VTKUtils.h"
+#include "SMESH_Actor.h"
+#include "SMESH_TypeDefs.hxx"
// SALOME KERNEL includes
#include <SALOMEDSClient_Study.hxx>
#include <utilities.h>
// SALOME GUI includes
-#include <SUIT_Session.h>
+#include <LightApp_Application.h>
#include <SUIT_MessageBox.h>
+#include <SUIT_OverrideCursor.h>
#include <SUIT_ResourceMgr.h>
-#include <LightApp_Application.h>
+#include <SUIT_Session.h>
#include <SalomeApp_IntSpinBox.h>
+#include <SalomeApp_Tools.h>
+#include <SVTK_ViewWindow.h>
// Qt includes
#include <QFrame>
#define SPACING 6
#define MARGIN 11
-//To disable automatic genericobj management, the following line should be commented.
-//Otherwise, it should be uncommented. Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
-#define WITHGENERICOBJ
-
SMESHGUI_GenericHypothesisCreator::SMESHGUI_GenericHypothesisCreator( const QString& theHypType )
- : myHypType( theHypType ), myIsCreate( false ), myDlg( 0 )
+ : myToDeleteInitParamsHypo( false ),
+ myHypType( theHypType ),
+ myIsCreate( false ),
+ myDlg( 0 )
{
}
SMESHGUI_GenericHypothesisCreator::~SMESHGUI_GenericHypothesisCreator()
{
+ if ( myToDeleteInitParamsHypo && !myInitParamsHypo->_is_nil() )
+ myInitParamsHypo->UnRegister();
}
void SMESHGUI_GenericHypothesisCreator::setInitParamsHypothesis(SMESH::SMESH_Hypothesis_ptr hyp)
{
- if ( !CORBA::is_nil( hyp ) && hypType() == hyp->GetName() )
- myInitParamsHypo = SMESH::SMESH_Hypothesis::_duplicate( hyp );
+ if ( !CORBA::is_nil( hyp ) ) {
+ if ( myToDeleteInitParamsHypo && !myInitParamsHypo->_is_nil() )
+ myInitParamsHypo->UnRegister();
+ CORBA::String_var hypName = hyp->GetName();
+ if ( hypType() == hypName.in() )
+ {
+ myInitParamsHypo = SMESH::SMESH_Hypothesis::_duplicate( hyp );
+ myToDeleteInitParamsHypo = !SMESH::FindSObject( myInitParamsHypo );
+ }
+ }
}
void SMESHGUI_GenericHypothesisCreator::create( SMESH::SMESH_Hypothesis_ptr initParamsHyp,
const QString& theHypName,
QWidget* parent, QObject* obj, const QString& slot )
{
- MESSAGE( "Creation of hypothesis with initial params" );
setInitParamsHypothesis( initParamsHyp );
create( false, theHypName, parent, obj, slot );
}
-void SMESHGUI_GenericHypothesisCreator::create( bool isAlgo,
+void SMESHGUI_GenericHypothesisCreator::create( bool isAlgo,
const QString& theHypName,
- QWidget* theParent, QObject* obj, const QString& slot )
+ QWidget* theParent,
+ QObject* obj,
+ const QString& slot )
{
- MESSAGE( "Creation of hypothesis" );
-
myIsCreate = true;
// Create hypothesis/algorithm
if (isAlgo) {
SMESH::SMESH_Hypothesis_var anAlgo =
SMESH::CreateHypothesis( hypType(), theHypName, isAlgo );
-#ifdef WITHGENERICOBJ
- if (!CORBA::is_nil(anAlgo))
- anAlgo->UnRegister();
-#endif
+ anAlgo.out(); // avoid unused variable warning
}
else {
SMESH::SMESH_Hypothesis_var aHypothesis =
SMESH::CreateHypothesis( hypType(), theHypName, false );
editHypothesis( aHypothesis.in(), theHypName, theParent, obj, slot );
-#ifdef WITHGENERICOBJ
- if (!CORBA::is_nil(aHypothesis))
- aHypothesis->UnRegister();
-#endif
}
}
void SMESHGUI_GenericHypothesisCreator::edit( SMESH::SMESH_Hypothesis_ptr theHypothesis,
- const QString& theHypName,
+ const QString& theHypName,
QWidget* theParent, QObject* obj, const QString& slot )
{
if( CORBA::is_nil( theHypothesis ) )
return;
- MESSAGE("Edition of hypothesis");
-
myIsCreate = false;
editHypothesis( theHypothesis, theHypName, theParent, obj, slot );
{
myHypName = theHypName;
myHypo = SMESH::SMESH_Hypothesis::_duplicate( h );
-#ifdef WITHGENERICOBJ
myHypo->Register();
-#endif
SMESHGUI_HypothesisDlg* Dlg = new SMESHGUI_HypothesisDlg( this, theParent );
connect( Dlg, SIGNAL( finished( int ) ), this, SLOT( onDialogFinished( int ) ) );
Dlg->setWindowTitle( caption() );
Dlg->setObjectName( theHypName );
Dlg->setHIcon( icon() );
- Dlg->setType( type() );
+ if ( theHypName == HypothesesSet::getCommonHypoSetHypoType() )
+ Dlg->setType( tr( HypothesesSet::getCommonHypoSetHypoType()) );
+ else
+ Dlg->setType( type() );
retrieveParams();
- Dlg->show();
+ Dlg->show(); // w/o this Dlg blocks selection
Dlg->resize( Dlg->minimumSizeHint() );
+ Dlg->exec(); // w/o this we cant wait until edition ends when applying a hypo-set
}
else {
emit finished( QDialog::Accepted );
- delete myDlg;
+ delete myDlg;
}
}
GroupC1Layout->setMargin( MARGIN );
ListOfStdParams::const_iterator anIt = params.begin(), aLast = params.end();
- for( int i=0; anIt!=aLast; anIt++, i++ )
+ for( int i = 0; anIt != aLast; anIt++, i++ )
{
- QLabel* lab = new QLabel( (*anIt).myName, GroupC1 );
- GroupC1Layout->addWidget( lab, i, 0 );
+ QLabel* lab = anIt->hasName() ? new QLabel( anIt->myName, GroupC1 ) : NULL;
+ if ( lab )
+ GroupC1Layout->addWidget( lab, i, 0 );
+ myParamLabels << lab;
QWidget* w = getCustomWidget( *anIt, GroupC1, i );
if ( !w )
case QVariant::String:
{
if((*anIt).isVariable) {
- _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
+ _PTR(Study) aStudy = SMESH::getStudy();
QString aVar = (*anIt).myValue.toString();
if(aStudy->IsInteger(aVar.toLatin1().constData())){
SalomeApp_IntSpinBox* sb = new SalomeApp_IntSpinBox( GroupC1 );
}
}
break;
- }
- if( w )
+ default:;
+ } // switch( (*anIt).myValue.type() )
+
+ if ( w )
{
- GroupC1Layout->addWidget( w, i, 1 );
+ if ( lab )
+ GroupC1Layout->addWidget( w, i, 1 );
+ else
+ GroupC1Layout->addWidget( w, i, 0, 1, 2 );
changeWidgets().append( w );
}
}
+ if ( QWidget* w = getHelperWidget() )
+ {
+ w->setParent( fr );
+ w->move( QPoint( 0, 0 ) );
+ lay->addWidget( w );
+ }
return fr;
}
bool res = result==QDialog::Accepted;
if( res )
{
- /*QString paramValues = */storeParams();
+ try
+ {
+ SUIT_OverrideCursor wc;
+ storeParams();
// No longer needed since NoteBook appears and "Value" OB field shows names of variable
-// if ( !paramValues.isEmpty() ) {
-// if ( _PTR(SObject) SHyp = SMESH::FindSObject( myHypo ))
-// SMESH::SetValue( SHyp, paramValues );
-// }
+ // QString paramValues = storeParams();
+ // if ( !paramValues.isEmpty() ) {
+ // if ( _PTR(SObject) SHyp = SMESH::FindSObject( myHypo ))
+ // SMESH::SetValue( SHyp, paramValues );
+ // }
+ }
+ catch ( const SALOME::SALOME_Exception& S_ex ) {
+ SalomeApp_Tools::QtCatchCorbaException( S_ex );
+ }
}
changeWidgets().clear();
{
//remove just created hypothesis
_PTR(SObject) aHypSObject = SMESH::FindSObject( myHypo );
- _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
+ _PTR(Study) aStudy = SMESH::getStudy();
if( aStudy && !aStudy->GetProperties()->IsLocked() )
{
_PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
{
SMESH::SObjectList listSOmesh = SMESH::GetMeshesUsingAlgoOrHypothesis( myHypo );
if( listSOmesh.size() > 0 )
- for( int i = 0; i < listSOmesh.size(); i++ )
+ for( size_t i = 0; i < listSOmesh.size(); i++ )
{
_PTR(SObject) submSO = listSOmesh[i];
SMESH::SMESH_Mesh_var aMesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( submSO );
if( !aSubMesh->_is_nil() )
aMesh = aSubMesh->GetFather();
_PTR(SObject) meshSO = SMESH::FindSObject( aMesh );
- SMESH::ModifiedMesh( meshSO, false, aMesh->NbNodes()==0);
+ SMESH_Actor* actor = SMESH::FindActorByEntry( meshSO->GetID().c_str() );
+ if( actor && actor->GetVisibility() )
+ actor->Update();
}
}
SMESHGUI::GetSMESHGUI()->updateObjBrowser( true, 0 );
-#ifdef WITHGENERICOBJ
myHypo->UnRegister();
-#endif
myHypo = SMESH::SMESH_Hypothesis::_nil();
myInitParamsHypo = SMESH::SMESH_Hypothesis::_nil();
myDlg->close();
//delete myDlg; since WA_DeleteOnClose==true
myDlg = 0;
+ if (SVTK_ViewWindow* vf = SMESH::GetCurrentVtkView()) {
+ vf->Repaint();
+ }
emit finished( result );
}
{
QString valueStr = "";
ListOfStdParams::const_iterator param = params.begin(), aLast = params.end();
- uint len0 = 0;
- for( int i=0; param!=aLast; param++, i++ )
+ int len0 = 0;
+ for ( ; param != aLast; param++ )
{
if ( valueStr.length() > len0 ) {
valueStr += "; ";
return myParamWidgets;
}
+//================================================================================
+/*!
+ * \brief Returns a QLabel of a specified parameter.
+ * If isCreation(), the 1st label (supposed to be "Name") is not countered.
+ */
+//================================================================================
+
+QLabel* SMESHGUI_GenericHypothesisCreator::getLabel(int i) const
+{
+ if ( isCreation() )
+ i++;
+ if ( i < myParamLabels.size() )
+ return (QLabel*) myParamLabels.at(i);
+ return NULL;
+}
+
QtxDialog* SMESHGUI_GenericHypothesisCreator:: dlg() const
{
return myDlg;
{
return 0;
}
+//================================================================================
+/*!
+ * \brief Returns a widget representing not a hypothesis parameter but some helper widget
+ */
+//================================================================================
+
+QWidget* SMESHGUI_GenericHypothesisCreator::getHelperWidget() const
+{
+ return 0;
+}
+
bool SMESHGUI_GenericHypothesisCreator::getParamFromCustomWidget( StdParam&, QWidget* ) const
{
return false;
QString aHypType = hypType();
QString aHelpFileName = "";
if ( aHypType == "LocalLength" )
- aHelpFileName = "a1d_meshing_hypo_page.html#average_length_anchor";
+ aHelpFileName = "1d_meshing_hypo.html#average-length-anchor";
else if ( aHypType == "MaxLength" )
- aHelpFileName = "a1d_meshing_hypo_page.html#max_length_anchor";
+ aHelpFileName = "1d_meshing_hypo.html#max-length-anchor";
else if ( aHypType == "Arithmetic1D")
- aHelpFileName = "a1d_meshing_hypo_page.html#arithmetic_1d_anchor";
+ aHelpFileName = "1d_meshing_hypo.html#arithmetic-1d-anchor";
+ else if ( aHypType == "GeometricProgression")
+ aHelpFileName = "1d_meshing_hypo.html#geometric-1d-anchor";
else if ( aHypType == "FixedPoints1D")
- aHelpFileName = "a1d_meshing_hypo_page.html#fixed_points_1d_anchor";
+ aHelpFileName = "1d_meshing_hypo.html#fixed-points-1d-anchor";
else if ( aHypType == "MaxElementArea")
- aHelpFileName = "a2d_meshing_hypo_page.html#max_element_area_anchor";
+ aHelpFileName = "2d_meshing_hypo.html#max-element-area-anchor";
else if ( aHypType == "MaxElementVolume")
- aHelpFileName = "max_element_volume_hypo_page.html";
+ aHelpFileName = "max_element_volume_hypo.html";
else if ( aHypType == "StartEndLength")
- aHelpFileName = "a1d_meshing_hypo_page.html#start_and_end_length_anchor";
+ aHelpFileName = "1d_meshing_hypo.html#start-and-end-length-anchor";
else if ( aHypType == "Deflection1D")
- aHelpFileName = "a1d_meshing_hypo_page.html#deflection_1d_anchor";
+ aHelpFileName = "1d_meshing_hypo.html#deflection-1d-anchor";
+ else if ( aHypType == "Adaptive1D")
+ aHelpFileName = "1d_meshing_hypo.html#adaptive-1d-anchor";
else if ( aHypType == "AutomaticLength")
- aHelpFileName = "a1d_meshing_hypo_page.html#automatic_length_anchor";
+ aHelpFileName = "1d_meshing_hypo.html#automatic-length-anchor";
else if ( aHypType == "NumberOfSegments")
- aHelpFileName = "a1d_meshing_hypo_page.html#number_of_segments_anchor";
+ aHelpFileName = "1d_meshing_hypo.html#number-of-segments-anchor";
else if ( aHypType == "ProjectionSource1D")
- aHelpFileName = "projection_algos_page.html";
+ aHelpFileName = "projection_algos.html";
else if ( aHypType == "ProjectionSource2D")
- aHelpFileName = "projection_algos_page.html";
+ aHelpFileName = "projection_algos.html";
else if ( aHypType == "ProjectionSource3D")
- aHelpFileName = "projection_algos_page.html";
+ aHelpFileName = "projection_algos.html";
else if ( aHypType == "NumberOfLayers")
- aHelpFileName = "radial_prism_algo_page.html";
+ aHelpFileName = "radial_prism_algo.html";
else if ( aHypType == "NumberOfLayers2D")
- aHelpFileName = "radial_quadrangle_1D2D_algo_page.html";
+ aHelpFileName = "radial_quadrangle_1D2D_algo.html";
else if ( aHypType == "LayerDistribution")
- aHelpFileName = "radial_prism_algo_page.html";
+ aHelpFileName = "radial_prism_algo.html";
else if ( aHypType == "LayerDistribution2D")
- aHelpFileName = "radial_quadrangle_1D2D_algo_page.html";
+ aHelpFileName = "radial_quadrangle_1D2D_algo.html";
else if ( aHypType == "SegmentLengthAroundVertex")
- aHelpFileName = "segments_around_vertex_algo_page.html";
+ aHelpFileName = "segments_around_vertex_algo.html";
else if ( aHypType == "QuadrangleParams")
- aHelpFileName = "a2d_meshing_hypo_page.html#hypo_quad_params_anchor";
+ aHelpFileName = "2d_meshing_hypo.html#hypo-quad-params-anchor";
else if ( aHypType == "ViscousLayers")
- aHelpFileName = "additional_hypo_page.html#viscous_layers_anchor";
+ aHelpFileName = "additional_hypo.html#viscous-layers-anchor";
else if ( aHypType == "ViscousLayers2D")
- aHelpFileName = "additional_hypo_page.html#viscous_layers_anchor";
+ aHelpFileName = "additional_hypo.html#viscous-layers-anchor";
else if ( aHypType == "ImportSource1D" || aHypType == "ImportSource2D")
- aHelpFileName = "import_algos_page.html";
+ aHelpFileName = "use_existing_algos.html";
return aHelpFileName;
}
delete myCreator;
}
+void SMESHGUI_HypothesisDlg::showEvent(QShowEvent *event)
+{
+ // resize( minimumSizeHint() );
+ // adjustSize();
+
+ QtxDialog::showEvent( event );
+}
+
void SMESHGUI_HypothesisDlg::setCustomFrame( QFrame* f )
{
if( f )
void SMESHGUI_HypothesisDlg::accept()
{
+ SUIT_OverrideCursor wc; // some creators temporary set params to a hyp which can be long
QString msg;
if ( myCreator && !myCreator->checkParams( msg ) )
{
if (app) {
QString name = "SMESH";
if(myCreator) {
- QVariant pluginName = myCreator->property( PLUGIN_NAME );
+ QVariant pluginName = myCreator->property( SMESH::Plugin_Name() );
if( pluginName.isValid() ) {
QString rootDir = pluginName.toString() + "PLUGIN_ROOT_DIR";
QString varValue = QString( getenv(rootDir.toLatin1().constData()));
myTypeLabel->setText( t );
}
-HypothesisData::HypothesisData( const QString& theTypeName,
- const QString& thePluginName,
- const QString& theServerLibName,
- const QString& theClientLibName,
- const QString& theLabel,
- const QString& theIconId,
- const QList<int>& theDim,
- const bool theIsAux,
- const QStringList& theNeededHypos,
+HypothesisData::HypothesisData( const QString& theTypeName,
+ const QString& thePluginName,
+ const QString& theServerLibName,
+ const QString& theClientLibName,
+ const QString& theLabel,
+ const QString& theIconId,
+ const QString& theContext,
+ const int theGroupID,
+ const int thePriority,
+ const QList<int>& theDim,
+ const bool theIsAuxOrNeedHyp,
+ const QStringList& theBasicHypos,
const QStringList& theOptionalHypos,
const QStringList& theInputTypes,
const QStringList& theOutputTypes,
- const bool theIsNeedGeometry,
- const bool supportSub)
+ const int theIsNeedGeometry,
+ const bool theSupportSub)
: TypeName( theTypeName ),
PluginName( thePluginName ),
ServerLibName( theServerLibName ),
ClientLibName( theClientLibName ),
Label( theLabel ),
IconId( theIconId ),
+ Context( theContext ),
+ GroupID( theGroupID ),
+ Priority( thePriority ),
Dim( theDim ),
- IsAux( theIsAux ),
- NeededHypos( theNeededHypos ),
+ IsAuxOrNeedHyp( theIsAuxOrNeedHyp ),
+ IsNeedGeometry( theIsNeedGeometry ),
+ IsSupportSubmeshes( theSupportSub ),
+ BasicHypos( theBasicHypos ),
OptionalHypos( theOptionalHypos ),
InputTypes( theInputTypes ),
- OutputTypes( theOutputTypes ),
- IsNeedGeometry( theIsNeedGeometry ),
- IsSupportSubmeshes( supportSub )
-{
-}
-
-HypothesesSet::HypothesesSet( const QString& theSetName )
- : myHypoSetName( theSetName ),
- myIsAlgo( false ),
- myIsCustom( false )
-{
-}
-
-HypothesesSet::HypothesesSet( const QString& theSetName,
- const QStringList& theHypoList,
- const QStringList& theAlgoList )
- : myHypoSetName( theSetName ),
- myHypoList( theHypoList ),
- myAlgoList( theAlgoList ),
+ OutputTypes( theOutputTypes )
+{
+}
+
+// HypothesesSet::HypothesesSet( const QString& theSetName )
+// : myHypoSetName( theSetName ),
+// myIsAlgo( false ),
+// myIsCustom( false )
+// {
+// }
+
+HypothesesSet::HypothesesSet( const QString& theSetName,
+ bool useCommonSize, bool isQuadDominated,
+ const QStringList& mainHypos, const QStringList& mainAlgos,
+ const QStringList& altHypos, const QStringList& altAlgos,
+ const QStringList& intHypos, const QStringList& intAlgos )
+ : myUseCommonSize( useCommonSize ),
+ myQuadDominated( isQuadDominated ),
+ myHypoSetName( theSetName ),
+ myHypoList { mainHypos, altHypos, intHypos },
+ myAlgoList { mainAlgos, altAlgos, intAlgos },
myIsAlgo( false ),
- myIsCustom( false )
+ myIsCustom( false ),
+ myIndex( 0 )
{
+ for ( myHypType = MAIN; myHypType < NB_HYP_TYPES; SMESHUtils::Increment( myHypType ))
+ for ( int isAlgo = myIsAlgo = 0; isAlgo < 2; myIsAlgo = ++isAlgo )
+ {
+ QStringList& hyps = *list();
+ for ( int i = 0; i < hyps.count(); ++i )
+ hyps[ i ] = hyps[ i ].trimmed();
+ }
}
-QStringList* HypothesesSet::list(bool is_algo) const
+QStringList* HypothesesSet::list( bool is_algo, SetType setType) const
{
- return const_cast<QStringList*>( &( is_algo ? myAlgoList : myHypoList ) );
+ return const_cast<QStringList*>( &( is_algo ? myAlgoList[setType] : myHypoList[setType] ));
}
QStringList* HypothesesSet::list() const
{
- return list( myIsAlgo );
+ return list( myIsAlgo, myHypType );
}
QString HypothesesSet::name() const
return myHypoSetName;
}
-void HypothesesSet::set( bool isAlgo, const QStringList& lst )
-{
- *list(isAlgo) = lst;
-}
+// void HypothesesSet::set( bool isAlgo, const QStringList& lst )
+// {
+// *list(isAlgo) = lst;
+// }
-int HypothesesSet::count( bool isAlgo ) const
-{
- return list(isAlgo)->count();
-}
+// int HypothesesSet::count( bool isAlgo, SetType setType ) const
+// {
+// return list(isAlgo,setType)->count();
+// }
-bool HypothesesSet::isAlgo() const
-{
- return myIsAlgo;
-}
+// bool HypothesesSet::isAlgo() const
+// {
+// return myIsAlgo;
+// }
-void HypothesesSet::init( bool isAlgo )
+void HypothesesSet::init( bool isAlgo, SetType setType )
{
+ myHypType = setType;
myIsAlgo = isAlgo;
- myIndex = -1;
+ myIndex = 0;
}
bool HypothesesSet::more() const
return myIsCustom;
}
+void HypothesesSet::setAlgoAvailable( SetType type, bool isAvailable )
+{
+ if ( MAIN <= type && type < NB_HYP_TYPES )
+ myIsAlgoAvailable[ type ] = isAvailable;
+}
+
+bool HypothesesSet::getAlgoAvailable( SetType type )
+{
+ bool isAva = false;
+ if ( MAIN <= type && type < NB_HYP_TYPES )
+ isAva = myIsAlgoAvailable[ type ];
+ return isAva;
+}
+
+HypothesesSet::SetType HypothesesSet::getPreferredHypType()
+{
+ SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
+ int useAltHypos = !resMgr->booleanValue( "SMESH", "use-meshgems-hypo-sets", false );
+ return ( HypothesesSet::SetType ) useAltHypos;
+}
+
int HypothesesSet::maxDim() const
{
HypothesesSet * thisSet = (HypothesesSet*) this;
int dim = -1;
- for ( int isAlgo = 0; isAlgo < 2; ++isAlgo )
- {
- thisSet->init( isAlgo );
- while ( thisSet->next(), thisSet->more() )
- if ( HypothesisData* hypData = SMESH::GetHypothesisData( thisSet->current() ))
- for ( int i = 0; i < hypData->Dim.count(); ++i )
- dim = qMax( dim, hypData->Dim[i] );
- }
+ for ( int setType = 0; setType < 2; ++setType )
+ for ( int isAlgo = 0; isAlgo < 2; ++isAlgo )
+ {
+ for ( thisSet->init( isAlgo, SetType( setType )); thisSet->more(); thisSet->next() )
+ if ( HypothesisData* hypData = SMESH::GetHypothesisData( thisSet->current() ))
+ for ( int i = 0; i < hypData->Dim.count(); ++i )
+ dim = qMax( dim, hypData->Dim[i] );
+ }
return dim;
}
+
+const char* HypothesesSet::getCommonHypoSetHypoType()
+{
+ return "AverageLengthForHypoSet";
+}
