*/
interface StdMeshers_AutomaticLength : SMESH::SMESH_Hypothesis
{
+ /*!
+ * Sets Fineness parameter value
+ */
+ void SetFineness(in double theFineness)
+ raises (SALOME::SALOME_Exception);
+
+ /*!
+ * Returns <Fineness> parameter value
+ */
+ double GetFineness();
};
/*!
hyp->myDim = 1;
hyp->myCreationMethod = "AutomaticLength";
hyp->myType = "Regular_1D";
+ hyp->myArgMethods.Append( "SetFineness");
}
// 1D Python_1D ----------
else if ( hypType == "Python_1D" ) {
else if ( hypType == "QuadranglePreference" ) {
hyp->myDim = 2;
hyp->myCreationMethod = "QuadranglePreference";
- hyp->myType = "MEFISTO_2D";
+ hyp->myType = "Quadrangle_2D";
}
// 3D ----------
else if ( hypType == "NETGEN_3D") {
"""
return self.Hypothesis("Propagation")
- def AutomaticLength(self):
+ def AutomaticLength(self, fineness):
"""
Define "AutomaticLength" hypothesis
+ \param fineness for the fineness [0-1]
"""
- return self.Hypothesis("AutomaticLength")
+ hyp = self.Hypothesis("AutomaticLength")
+ hyp.SetFineness( fineness )
+ return hyp
# Public class: Mesh_Segment_Python
# ---------------------------------
_param_algo_dim = 1; // is used by SMESH_Regular_1D
_mesh = 0;
+ _fineness = 0;
}
//=============================================================================
{
}
+//================================================================================
+/*!
+ * \brief Set Fineness
+ * \param theFineness - The Fineness value [0.0-1.0],
+ * 0 - coarse mesh
+ * 1 - fine mesh
+ *
+ * Raise if theFineness is out of range
+ * The "Initial Number of Elements on the Shortest Edge" (S0)
+ * is divided by (0.5 + 4.5 x theFineness)
+ */
+//================================================================================
+
+void StdMeshers_AutomaticLength::SetFineness(double theFineness)
+ throw(SALOME_Exception)
+{
+ if ( theFineness < 0.0 || theFineness > 1.0 )
+ throw SALOME_Exception(LOCALIZED("theFineness is out of range [0.0-1.0]"));
+
+ if ( _fineness != theFineness )
+ {
+ NotifySubMeshesHypothesisModification();
+ _fineness = theFineness;
+ }
+}
+
//================================================================================
/*!
* \brief Return pointer to TopoDS_TShape
if ( tshape_length == _TShapeToLength.end() )
return 1; // it is a dgenerated edge
- return tshape_length->second;
+ return tshape_length->second / (0.5 + 4.5 * _fineness);
}
//=============================================================================
ostream & StdMeshers_AutomaticLength::SaveTo(ostream & save)
{
+ save << _fineness;
return save;
}
istream & StdMeshers_AutomaticLength::LoadFrom(istream & load)
{
+ if ( ! ( load >> _fineness ))
+ load.clear(ios::badbit | load.rdstate());
return load;
}
double GetLength(const SMESH_Mesh* aMesh, const TopoDS_Shape& anEdge)
throw(SALOME_Exception);
+ /*!
+ * \brief Set Fineness
+ * \param theFineness - The Fineness value [0.0-1.0],
+ * 0 - coarse mesh
+ * 1 - fine mesh
+ *
+ * Raise if theFineness is out of range
+ * The "Initial Number of Elements on the Shortest Edge" (S0)
+ * is divided by (0.5 + 4.5 x theFineness)
+ */
+ void SetFineness(double theFineness)
+ throw(SALOME_Exception);
+
+ /*!
+ * \brief Return mesh Fineness
+ * \retval double - Fineness value [0.0-1.0]
+ */
+ double GetFineness() const { return _fineness; }
+
virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
friend std::ostream & operator <<(std::ostream & save, StdMeshers_AutomaticLength & hyp);
protected:
std::map<const TopoDS_TShape*, double> _TShapeToLength;
const SMESH_Mesh* _mesh;
+ double _fineness;
};
#endif
hypTypeStr = "DEFLECTION1D";
else if (hypType.compare("Arithmetic1D") == 0)
hypTypeStr = "ARITHMETIC_1D";
+ else if (hypType.compare("AutomaticLength") == 0)
+ hypTypeStr = "AUTOMATIC_LENGTH";
else
return;
#include "StdMeshersGUI_Parameters.h"
-//#include "SMESHGUI_SpinBox.h" // for the sake of COORD_MAX, COORD_MIN definition
-
#include <qobject.h>
+#include <qhbox.h>
+#include <qslider.h>
+#include <qlabel.h>
+
+#include <math.h>
+//#include <float.h>
using namespace std;
(hypType.compare("MaxElementVolume") == 0) ||
(hypType.compare("StartEndLength") == 0) ||
(hypType.compare("Deflection1D") == 0) ||
+ (hypType.compare("AutomaticLength") == 0) ||
(hypType.compare("Arithmetic1D") == 0));
}
}
}
-//=======================================================================
-//function : GetParameters
-//purpose :
-//=======================================================================
+//================================================================================
+/*!
+ * \brief Macros to comfortably create SMESHGUI_aParameterPtr of different types
+ */
+//================================================================================
// SMESHGUI_doubleParameter( initValue, label, bottom, top, step, decimals )
#define DOUBLE_PARAM(v,l,b,t,s,d) SMESHGUI_aParameterPtr(new SMESHGUI_doubleParameter(v,l,b,t,s,d))
#define STR_PARAM(i,l,preview) SMESHGUI_aParameterPtr(new SMESHGUI_strParameter(i,l,preview))
#define BOOL_PARAM(i,l,preview) SMESHGUI_aParameterPtr(new SMESHGUI_boolParameter(i,l,preview))
+//================================================================================
+/*!
+ * \brief Fill parameter list with default values
+ * \param hypType - The name of hypothesis type
+ * \param paramList - The list to fill
+ */
+//================================================================================
+
void StdMeshersGUI_Parameters::GetParameters (const QString& hypType,
list<SMESHGUI_aParameterPtr> & paramList )
{
QObject::tr("SMESH_DEFLECTION1D_PARAM"),
VALUE_SMALL, VALUE_MAX, 1, 6));
}
+ else if (hypType.compare("AutomaticLength") == 0)
+ {
+ SMESHGUI_aParameter * param =
+ new StdMeshersGUI_doubleSliderParameter ( QObject::tr("SMESH_FINENESS_PARAM"),
+ "0 ", " 1",
+ 0.0, 0.0, 1.0, 0.05);
+ paramList.push_back( SMESHGUI_aParameterPtr( param ));
+ }
}
-
-//=======================================================================
-//function : GetParameters
-//purpose :
-//=======================================================================
+
+//================================================================================
+/*!
+ * \brief Fill parameter list with real values the hypothesis has
+ * \param theHyp - The hypothesis to retrieve parameter values from
+ * \param paramList - The list to fill
+ */
+//================================================================================
void StdMeshersGUI_Parameters::GetParameters (SMESH::SMESH_Hypothesis_ptr theHyp,
list<SMESHGUI_aParameterPtr> & paramList )
StdMeshers::StdMeshers_Deflection1D::_narrow(theHyp);
SetInitValue( paramList.back(), hyp->GetDeflection()) ;
}
+ else if (hypType.compare("AutomaticLength") == 0)
+ {
+ StdMeshers::StdMeshers_AutomaticLength_var hyp =
+ StdMeshers::StdMeshers_AutomaticLength::_narrow(theHyp);
+ SetInitValue( paramList.back(), hyp->GetFineness());
+ }
}
-//=======================================================================
-//function : GetParameters
-//purpose :
-//=======================================================================
-void StdMeshersGUI_Parameters::GetParameters (SMESH::SMESH_Hypothesis_ptr hyp,
- list<SMESHGUI_aParameterPtr> & paramList,
+//================================================================================
+/*!
+ * \brief Return parameter values as a string
+ * \param hyp - not used
+ * \param paramList - list of parameter values
+ * \param params - output string
+ */
+//================================================================================
+
+void StdMeshersGUI_Parameters::GetParameters (SMESH::SMESH_Hypothesis_ptr ,
+ const list<SMESHGUI_aParameterPtr>& paramList,
QString& params)
{
params = "";
- list<SMESHGUI_aParameterPtr>::iterator paramIt = paramList.begin();
+ list<SMESHGUI_aParameterPtr>::const_iterator paramIt = paramList.begin();
for ( ; paramIt != paramList.end(); paramIt++) {
if (params.compare("")) params += " ; ";
//purpose :
//=======================================================================
+//================================================================================
+/*!
+ * \brief Set parameter values from the list into a hypothesis
+ * \param theHyp - The hypothesis to modify
+ * \param paramList - list of parameter values
+ * \retval bool - true if any parameter value changed
+ */
+//================================================================================
+
bool StdMeshersGUI_Parameters::SetParameters(SMESH::SMESH_Hypothesis_ptr theHyp,
const list<SMESHGUI_aParameterPtr> & paramList )
{
modified = paramList.front()->GetNewDouble( value );
hyp->SetDeflection( value );
}
+ else if (hypType.compare("AutomaticLength") == 0)
+ {
+ StdMeshers::StdMeshers_AutomaticLength_var hyp =
+ StdMeshers::StdMeshers_AutomaticLength::_narrow(theHyp);
+ double value = hyp->GetFineness() ;
+ modified = paramList.front()->GetNewDouble( value );
+ hyp->SetFineness( value );
+ }
return modified ;
}
-
+
+//================================================================================
+/*!
+ * \brief Widget: slider with left and right labels
+ */
+//================================================================================
+
+class StdMeshersGUI_SliderWith2Lables: public QHBox
+{
+public:
+ StdMeshersGUI_SliderWith2Lables( const QString& leftLabel,
+ const QString& rightLabel,
+ QWidget * parent =0,
+ const char * name=0 );
+ QSlider * getSlider() const { return _slider; }
+private:
+ QSlider * _slider;
+};
+
+StdMeshersGUI_SliderWith2Lables::StdMeshersGUI_SliderWith2Lables( const QString& leftLabel,
+ const QString& rightLabel,
+ QWidget * parent,
+ const char * name )
+ :QHBox(parent,name)
+{
+ if ( !leftLabel.isEmpty() )
+ (new QLabel( this ))->setText( leftLabel );
+
+ _slider = new QSlider( Horizontal, this );
+
+ if ( !rightLabel.isEmpty() )
+ (new QLabel( this ))->setText( rightLabel );
+}
+
+//================================================================================
+/*!
+ * \brief Constructor
+ * \param label - main label
+ * \param leftLabel - label to the left of slider
+ * \param rightLabel - label to the right of slider
+ * \param initValue - initial slider value
+ * \param bottom - least slider value
+ * \param top - maximal slider value
+ * \param precision - slider value precision
+ */
+//================================================================================
+
+StdMeshersGUI_doubleSliderParameter::
+StdMeshersGUI_doubleSliderParameter (const QString& label,
+ const QString& leftLabel,
+ const QString& rightLabel,
+ const double initValue,
+ const double bottom,
+ const double top ,
+ const double precision)
+ :SMESHGUI_doubleParameter(initValue,label,bottom,top,precision),
+ _leftLabel(leftLabel), _rightLabel(rightLabel)
+{
+}
+
+QWidget* StdMeshersGUI_doubleSliderParameter::CreateWidget( QWidget* parent ) const
+{
+ return new StdMeshersGUI_SliderWith2Lables( _leftLabel, _rightLabel, parent );
+}
+
+void StdMeshersGUI_doubleSliderParameter::InitializeWidget( QWidget* aWidget) const
+{
+ StdMeshersGUI_SliderWith2Lables * paramWidget =
+ dynamic_cast<StdMeshersGUI_SliderWith2Lables*> (aWidget);
+ if ( paramWidget && paramWidget->getSlider() )
+ {
+ QSlider * slider = paramWidget->getSlider();
+ slider->setRange( 0, toInt( _top ));
+ slider->setValue( toInt( _initValue ));
+ }
+}
+
+void StdMeshersGUI_doubleSliderParameter::TakeValue( QWidget* aWidget)
+{
+ StdMeshersGUI_SliderWith2Lables * paramWidget =
+ dynamic_cast<StdMeshersGUI_SliderWith2Lables*> (aWidget);
+ if ( paramWidget && paramWidget->getSlider() )
+ {
+ int val = paramWidget->getSlider()->value();
+ _newValue = Bottom() + val * Step();
+ }
+}
+int StdMeshersGUI_doubleSliderParameter::toInt( double val ) const
+{
+ return (int) ceil(( val - _bottom ) / _step );
+}
static void GetParameters (SMESH::SMESH_Hypothesis_ptr hyp,
std::list<SMESHGUI_aParameterPtr> & params );
- static void GetParameters (SMESH::SMESH_Hypothesis_ptr hyp,
- std::list<SMESHGUI_aParameterPtr> & paramList,
- QString& params);
+ static void GetParameters (SMESH::SMESH_Hypothesis_ptr hyp,
+ const std::list<SMESHGUI_aParameterPtr> & paramList,
+ QString& params);
static bool SetParameters(SMESH::SMESH_Hypothesis_ptr hyp,
const std::list<SMESHGUI_aParameterPtr> & params );
static void SetInitValue(SMESHGUI_aParameterPtr param,
SMESH::double_array& initValue);
};
+
+/*!
+ * \brief This class provides double parameter with slider control
+ */
+class StdMeshersGUI_doubleSliderParameter: public SMESHGUI_doubleParameter
+{
+public:
+ StdMeshersGUI_doubleSliderParameter(const QString& label = QString::null,
+ const QString& leftLabel = QString::null,
+ const QString& rightLabel = QString::null,
+ const double initValue = 0.0,
+ const double bottom = 0,
+ const double top = 1,
+ const double precision = 0.1);
+ virtual QWidget* CreateWidget( QWidget* ) const;
+ virtual void InitializeWidget( QWidget* ) const;
+ virtual void TakeValue( QWidget* );
+ int toInt( double val ) const;
+private:
+ QString _leftLabel, _rightLabel;
+};
+
#endif
msgstr "select1.png"
-#-----------------------------------------------------------
-# Hypothesis
-#-----------------------------------------------------------
+#-----------------------------------------------------------------
+# Hypothesis creation, see StdMeshersGUI_CreateStdHypothesisDlg()
+#-----------------------------------------------------------------
#Hypo Local Length
msgid "ICON_DLG_LOCAL_LENGTH"
msgstr "mesh_hypo_length.png"
#Hypo AutomaticLength
-msgid "ICON_DLG_AUTOMATICLENGTH"
+msgid "ICON_DLG_AUTOMATIC_LENGTH"
msgstr "mesh_hypo_length.png"
msgid "SMESH_ARITHMETIC_1D_TITLE"
msgstr "Hypothesis Construction"
+
+
+# -------------- AUTOMATIC_LENGTH --------------
+
+msgid "SMESH_AUTOMATIC_LENGTH_HYPOTHESIS"
+msgstr "Automatic Length"
+
+msgid "SMESH_FINENESS_PARAM"
+msgstr "Fineness"
+
+msgid "SMESH_AUTOMATIC_LENGTH_TITLE"
+msgstr "Hypothesis Construction"
#include "StdMeshers_AutomaticLength_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Gen.hxx"
+#include "SMESH_PythonDump.hxx"
#include "Utils_CorbaException.hxx"
#include "utilities.h"
//=============================================================================
/*!
- * StdMeshers_AutomaticLength_i::SetLength
+ * StdMeshers_AutomaticLength_i::SetFineness
*
- * Set length
+ * Set Fineness
*/
//=============================================================================
-// void StdMeshers_AutomaticLength_i::SetLength( CORBA::Double theLength )
-// throw ( SALOME::SALOME_Exception )
-// {
-// MESSAGE( "StdMeshers_AutomaticLength_i::SetLength" );
-// ASSERT( myBaseImpl );
-// try {
-// this->GetImpl()->SetLength( theLength );
-// }
-// catch ( SALOME_Exception& S_ex ) {
-// THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
-// SALOME::BAD_PARAM );
-// }
-
-// // Update Python script
-// TCollection_AsciiString aStr, aStrLen ((double)theLength);
-// SMESH_Gen_i::AddObject(aStr, _this()) += ".SetLength(";
-// aStr += aStrLen + ")";
-
-// SMESH_Gen_i::AddToCurrentPyScript(aStr);
-// }
+void StdMeshers_AutomaticLength_i::SetFineness( CORBA::Double theFineness )
+ throw ( SALOME::SALOME_Exception )
+{
+ ASSERT( myBaseImpl );
+ try {
+ this->GetImpl()->SetFineness( theFineness );
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+ // Update Python script
+ SMESH::TPythonDump() << _this() << ".SetFineness( " << theFineness << " )";
+}
//=============================================================================
/*!
- * StdMeshers_AutomaticLength_i::GetLength
+ * StdMeshers_AutomaticLength_i::GetFineness
*
- * Get length
+ * Get Fineness
*/
//=============================================================================
-// CORBA::Double StdMeshers_AutomaticLength_i::GetLength()
-// {
-// MESSAGE( "StdMeshers_AutomaticLength_i::GetLength" );
-// ASSERT( myBaseImpl );
-// return this->GetImpl()->GetLength();
-// }
+CORBA::Double StdMeshers_AutomaticLength_i::GetFineness()
+{
+ ASSERT( myBaseImpl );
+ return this->GetImpl()->GetFineness();
+}
//=============================================================================
/*!
::StdMeshers_AutomaticLength* StdMeshers_AutomaticLength_i::GetImpl()
{
- MESSAGE( "StdMeshers_AutomaticLength_i::GetImpl" );
return ( ::StdMeshers_AutomaticLength* )myBaseImpl;
}
class SMESH_Gen;
-// ======================================================
-// Local Length hypothesis
-// ======================================================
+// =========================================================
+// 1D Hypothesis to compute segment length free of thinking
+// =========================================================
+
class StdMeshers_AutomaticLength_i:
public virtual POA_StdMeshers::StdMeshers_AutomaticLength,
public virtual SMESH_Hypothesis_i
// Destructor
virtual ~StdMeshers_AutomaticLength_i();
-// // Set length
-// void SetLength( CORBA::Double theLength )
-// throw ( SALOME::SALOME_Exception );
-// // Get length
-// CORBA::Double GetLength();
+ // Set Fineness
+ void SetFineness( CORBA::Double theFineness )
+ throw ( SALOME::SALOME_Exception );
+
+ // Get Fineness
+ CORBA::Double GetFineness();
// Get implementation
::StdMeshers_AutomaticLength* GetImpl();
