#include "SALOME_Exception.idl"
#include "SMESH_Hypothesis.idl"
+#include "SMESH_Mesh.idl"
/*!
*/
long GetNumberOfSegments();
+ /*!
+ * Sets <distribution type> parameter value
+ */
+ void SetDistrType(in long typ)
+ raises (SALOME::SALOME_Exception);
+
+ /*!
+ * Returns <distribution type> parameter value
+ */
+ long GetDistrType();
+
/*!
* Sets <scale factor> parameter value
*/
/*!
* Returns <scale factor> parameter value
*/
- double GetScaleFactor();
+ double GetScaleFactor()
+ raises (SALOME::SALOME_Exception);
+
+ /*!
+ * Sets <table function> parameter value for distribution DT_TabFunc
+ */
+ void SetTableFunction(in SMESH::double_array table)
+ raises (SALOME::SALOME_Exception);
+
+ /*!
+ * Returns <table function> parameter value for distribution DT_TabFunc
+ */
+ SMESH::double_array GetTableFunction()
+ raises (SALOME::SALOME_Exception);
+
+ /*!
+ * Sets <expression function> parameter value for distribution DT_ExprFunc
+ */
+ void SetExpressionFunction(in string expr)
+ raises (SALOME::SALOME_Exception);
+
+ /*!
+ * Returns <expression function> parameter value for distribution DT_ExprFunc
+ */
+ string GetExpressionFunction()
+ raises (SALOME::SALOME_Exception);
+
+ /*!
+ * Sets <exponent mode> parameter value for functional distributions
+ */
+ void SetExponentMode(in boolean isExponent)
+ raises (SALOME::SALOME_Exception);
+
+ /*!
+ * Returns <exponent mode> parameter value for functional distributions
+ */
+ boolean IsExponentMode()
+ raises (SALOME::SALOME_Exception);
};
/*!
SMESH_GroupLyingOnGeom.py \
PAL_MESH_041_mesh.py \
PAL_MESH_043_2D.py \
- PAL_MESH_043_3D.py
+ PAL_MESH_043_3D.py \
+ SMESH_reg.py
LIB_CLIENT_IDL = SALOMEDS.idl \
SALOME_Exception.idl \
StdMeshers_Quadrangle_2D.cxx \
StdMeshers_MEFISTO_2D.cxx \
StdMeshers_Penta_3D.cxx \
- StdMeshers_Hexa_3D.cxx
+ StdMeshers_Hexa_3D.cxx
LIB_SERVER_IDL =
CPPFLAGS+= $(OCC_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome $(BOOST_CPPFLAGS)
CXXFLAGS+= $(OCC_CXXFLAGS) -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome
-LDFLAGS+= -lSMESHimpl -lMEFISTO2D -L${KERNEL_ROOT_DIR}/lib/salome -L${GEOM_ROOT_DIR}/lib/salome
+LDFLAGS+= -lSMESHimpl -lMEFISTO2D -L${CASROOT}/Linux/lib -lTKAdvTools -L${KERNEL_ROOT_DIR}/lib/salome -L${GEOM_ROOT_DIR}/lib/salome
@CONCLUDE@
using namespace std;
#include "StdMeshers_NumberOfSegments.hxx"
+#include <Standard_ErrorHandler.hxx>
+#include <TCollection_AsciiString.hxx>
+#include <ExprIntrp_GenExp.hxx>
+#include <Expr_NamedUnknown.hxx>
+
+const double PRECISION = 1e-7;
//=============================================================================
/*!
//=============================================================================
StdMeshers_NumberOfSegments::StdMeshers_NumberOfSegments(int hypId, int studyId,
- SMESH_Gen * gen):SMESH_Hypothesis(hypId, studyId, gen)
+ SMESH_Gen * gen)
+ : SMESH_Hypothesis(hypId, studyId, gen),
+ _numberOfSegments(1),
+ _distrType(DT_Regular),
+ _scaleFactor(1.),
+ _expMode(false)
{
- _numberOfSegments = 1;
- _scaleFactor = 1.0;
- _name = "NumberOfSegments";
- _param_algo_dim = 1;
+ _name = "NumberOfSegments";
+ _param_algo_dim = 1;
}
//=============================================================================
return _numberOfSegments;
}
-//=============================================================================
+//================================================================================
/*!
- *
+ *
*/
-//=============================================================================
+//================================================================================
+
+void StdMeshers_NumberOfSegments::SetDistrType(DistrType typ)
+ throw(SALOME_Exception)
+{
+ if (typ < DT_Regular || typ > DT_ExprFunc)
+ throw SALOME_Exception(LOCALIZED("distribution type is out of range"));
+
+ if (typ != _distrType)
+ {
+ _distrType = typ;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//================================================================================
+/*!
+ *
+ */
+//================================================================================
+
+StdMeshers_NumberOfSegments::DistrType StdMeshers_NumberOfSegments::GetDistrType() const
+{
+ return _distrType;
+}
+
+//================================================================================
+/*!
+ *
+ */
+//================================================================================
void StdMeshers_NumberOfSegments::SetScaleFactor(double scaleFactor)
-throw(SALOME_Exception)
+ throw(SALOME_Exception)
{
- if (scaleFactor < 0)
- throw SALOME_Exception(LOCALIZED("scale factor must be positive"));
- _scaleFactor = scaleFactor;
+ if (_distrType != DT_Scale)
+ throw SALOME_Exception(LOCALIZED("not a scale distribution"));
+ if (scaleFactor < PRECISION)
+ throw SALOME_Exception(LOCALIZED("scale factor must be positive"));
+ if (fabs(scaleFactor - 1.0) < PRECISION)
+ throw SALOME_Exception(LOCALIZED("scale factor must not be equal to 1"));
- NotifySubMeshesHypothesisModification();
+ if (fabs(_scaleFactor - scaleFactor) > PRECISION)
+ {
+ _scaleFactor = scaleFactor;
+ NotifySubMeshesHypothesisModification();
+ }
}
-//=============================================================================
+//================================================================================
/*!
- *
+ *
*/
-//=============================================================================
+//================================================================================
double StdMeshers_NumberOfSegments::GetScaleFactor() const
+ throw(SALOME_Exception)
{
- return _scaleFactor;
+ if (_distrType != DT_Scale)
+ throw SALOME_Exception(LOCALIZED("not a scale distribution"));
+ return _scaleFactor;
+}
+
+//================================================================================
+/*!
+ *
+ */
+//================================================================================
+
+void StdMeshers_NumberOfSegments::SetTableFunction(const std::vector<double>& table)
+ throw(SALOME_Exception)
+{
+ if (_distrType != DT_TabFunc)
+ throw SALOME_Exception(LOCALIZED("not a table function distribution"));
+ if ( (table.size() % 2) != 0 )
+ throw SALOME_Exception(LOCALIZED("odd size of vector of table function"));
+
+ int i;
+ double prev = -PRECISION;
+ bool isSame = table.size() == _table.size();
+
+ for (i=0; i < table.size()/2; i++) {
+ double par = table[i*2];
+ double val = table[i*2+1];
+ if ( par<0 || par > 1)
+ throw SALOME_Exception(LOCALIZED("parameter of table function is out of range [0,1]"));
+ if ( fabs(par-prev)<PRECISION )
+ throw SALOME_Exception(LOCALIZED("two parameters are the same"));
+ if (val < PRECISION)
+ throw SALOME_Exception(LOCALIZED("value of table function is not positive"));
+ if (isSame)
+ {
+ double oldpar = _table[i*2];
+ double oldval = _table[i*2+1];
+ if (fabs(par - oldpar) > PRECISION || fabs(val - oldval) > PRECISION)
+ isSame = false;
+ }
+ prev = par;
+ }
+
+ if (!isSame)
+ {
+ _table = table;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//================================================================================
+/*!
+ *
+ */
+//================================================================================
+
+const std::vector<double>& StdMeshers_NumberOfSegments::GetTableFunction() const
+ throw(SALOME_Exception)
+{
+ if (_distrType != DT_TabFunc)
+ throw SALOME_Exception(LOCALIZED("not a table function distribution"));
+ return _table;
+}
+
+//================================================================================
+/*! check if only 't' is unknown variable in expression
+ */
+//================================================================================
+bool isCorrect( const Handle( Expr_GeneralExpression )& expr )
+{
+ if( expr.IsNull() )
+ return true;
+
+ bool res = true;
+ for( int i=1, n=expr->NbSubExpressions(); i<=n && res; i++ )
+ {
+ Handle( Expr_GeneralExpression ) subexpr = expr->SubExpression( i );
+ Handle( Expr_NamedUnknown ) name = Handle( Expr_NamedUnknown )::DownCast( subexpr );
+ if( !name.IsNull() )
+ {
+ if( name->GetName()!="t" )
+ res = false;
+ }
+ else
+ res = isCorrect( subexpr );
+ }
+ return res;
+}
+
+//================================================================================
+/*! this function parses the expression 'str' in order to check if syntax is correct
+ * ( result in 'syntax' ) and if only 't' is unknown variable in expression ( result in 'args' )
+ */
+//================================================================================
+void casProcess( const TCollection_AsciiString& str, bool& syntax, bool& args )
+{
+ // check validity of expression
+ syntax = false;
+ args = false;
+ try
+ {
+ Handle( ExprIntrp_GenExp ) gen = ExprIntrp_GenExp::Create();
+ gen->Process( str );
+
+ if( gen->IsDone() )
+ {
+ syntax = true;
+ args = isCorrect( gen->Expression() );
+ }
+ }
+ catch (Standard_Failure)
+ {
+ }
+}
+
+//================================================================================
+/*!
+ *
+ */
+//================================================================================
+
+void StdMeshers_NumberOfSegments::SetExpressionFunction(const char* expr)
+ throw(SALOME_Exception)
+{
+ if (_distrType != DT_ExprFunc)
+ throw SALOME_Exception(LOCALIZED("not an expression function distribution"));
+
+ // remove white spaces
+ TCollection_AsciiString str((Standard_CString)expr);
+ str.RemoveAll(' ');
+ str.RemoveAll('\t');
+ str.RemoveAll('\r');
+ str.RemoveAll('\n');
+
+ bool syntax, args;
+ casProcess( str, syntax, args );
+ if( !syntax )
+ throw SALOME_Exception(LOCALIZED("invalid expression syntax"));
+ if( !args )
+ throw SALOME_Exception(LOCALIZED("only 't' may be used as function argument"));
+
+ string func(str.ToCString());
+ if (_func != func)
+ {
+ _func = func;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//================================================================================
+/*!
+ *
+ */
+//================================================================================
+
+const char* StdMeshers_NumberOfSegments::GetExpressionFunction() const
+ throw(SALOME_Exception)
+{
+ if (_distrType != DT_ExprFunc)
+ throw SALOME_Exception(LOCALIZED("not an expression function distribution"));
+ return _func.c_str();
+}
+
+//================================================================================
+/*!
+ *
+ */
+//================================================================================
+
+void StdMeshers_NumberOfSegments::SetExponentMode(bool isExp)
+ throw(SALOME_Exception)
+{
+ if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
+ throw SALOME_Exception(LOCALIZED("not a functional distribution"));
+
+ if (isExp != _expMode)
+ {
+ _expMode = isExp;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//================================================================================
+/*!
+ *
+ */
+//================================================================================
+
+bool StdMeshers_NumberOfSegments::IsExponentMode() const
+ throw(SALOME_Exception)
+{
+ if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
+ throw SALOME_Exception(LOCALIZED("not a functional distribution"));
+ return _expMode;
}
//=============================================================================
ostream & StdMeshers_NumberOfSegments::SaveTo(ostream & save)
{
- save << this->_numberOfSegments << " " << this->_scaleFactor;
+ save << _numberOfSegments << " " << (int)_distrType;
+ switch (_distrType)
+ {
+ case DT_Scale:
+ save << " " << _scaleFactor;
+ break;
+ case DT_TabFunc:
+ int i;
+ save << " " << _table.size();
+ for (i=0; i < _table.size(); i++)
+ save << " " << _table[i];
+ break;
+ case DT_ExprFunc:
+ save << " " << _func;
+ break;
+ case DT_Regular:
+ default:
+ break;
+ }
+
+ if (_distrType == DT_TabFunc || _distrType == DT_ExprFunc)
+ save << " " << (int)_expMode;
+
return save;
}
{
bool isOK = true;
int a;
+
+ // read number of segments
isOK = (load >> a);
if (isOK)
- this->_numberOfSegments = a;
+ _numberOfSegments = a;
else
load.clear(ios::badbit | load.rdstate());
- double b;
- isOK = (load >> b);
+
+ // read ditribution type
+ isOK = (load >> a);
if (isOK)
- this->_scaleFactor = b;
+ {
+ if (a < DT_Regular || a > DT_ExprFunc)
+ _distrType = DT_Regular;
+ else
+ _distrType = (DistrType) a;
+ }
else
load.clear(ios::badbit | load.rdstate());
+
+ // parameters of distribution
+ double b;
+ switch (_distrType)
+ {
+ case DT_Scale:
+ {
+ isOK = (load >> b);
+ if (isOK)
+ _scaleFactor = b;
+ else
+ load.clear(ios::badbit | load.rdstate());
+ }
+ break;
+ case DT_TabFunc:
+ {
+ isOK = (load >> a);
+ if (isOK)
+ _table.resize(a, 0.);
+ else
+ load.clear(ios::badbit | load.rdstate());
+ int i;
+ for (i=0; i < _table.size(); i++)
+ {
+ isOK = (load >> b);
+ if (isOK)
+ _table[i] = b;
+ else
+ load.clear(ios::badbit | load.rdstate());
+ }
+ }
+ break;
+ case DT_ExprFunc:
+ {
+ string str;
+ isOK = (load >> str);
+ if (isOK)
+ _func = str;
+ else
+ load.clear(ios::badbit | load.rdstate());
+ }
+ break;
+ case DT_Regular:
+ default:
+ break;
+ }
+
+ if (_distrType == DT_TabFunc || _distrType == DT_ExprFunc)
+ {
+ isOK = (load >> a);
+ if (isOK)
+ _expMode = (bool) a;
+ else
+ load.clear(ios::badbit | load.rdstate());
+ }
+
return load;
}
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
+#include <vector>
+/*!
+ * \brief This class represents hypothesis for 1d algorithm
+ *
+ * It provides parameters for subdivision an edge by various
+ * distribution types, considering the given number of resulting segments
+ */
class StdMeshers_NumberOfSegments:
public SMESH_Hypothesis
{
StdMeshers_NumberOfSegments(int hypId, int studyId, SMESH_Gen* gen);
virtual ~StdMeshers_NumberOfSegments();
+ /*!
+ * \brief Set the number of segments
+ * \param segmentsNumber - must be greater than zero
+ */
void SetNumberOfSegments(int segmentsNumber)
throw (SALOME_Exception);
+ /*!
+ * \brief Get the number of segments
+ */
int GetNumberOfSegments() const;
+ /*!
+ * \brief This enumeration presents available types of distribution
+ */
+ enum DistrType
+ {
+ DT_Regular, //!< equidistant distribution
+ DT_Scale, //!< scale distribution
+ DT_TabFunc, //!< distribution with density function presented by table
+ DT_ExprFunc //!< distribution with density function presented by expression
+ };
+
+ /*!
+ * \brief Set distribution type
+ */
+ void SetDistrType(DistrType typ)
+ throw (SALOME_Exception);
+
+ /*!
+ * \brief Get distribution type
+ */
+ DistrType GetDistrType() const;
+
+ /*!
+ * \brief Set scale factor for scale distribution
+ * \param scaleFactor - positive value different from 1
+ *
+ * Throws SALOME_Exception if distribution type is not DT_Scale,
+ * or scaleFactor is not a positive value different from 1
+ */
virtual void SetScaleFactor(double scaleFactor)
throw (SALOME_Exception);
- double GetScaleFactor() const;
+ /*!
+ * \brief Get scale factor for scale distribution
+ *
+ * Throws SALOME_Exception if distribution type is not DT_Scale
+ */
+ double GetScaleFactor() const
+ throw (SALOME_Exception);
+
+ /*!
+ * \brief Set table function for distribution DT_TabFunc
+ * \param table - this vector contains the pairs (parameter, value)
+ * following each by other, so the number of elements in the vector
+ * must be even. The parameters must be in range [0,1] and sorted in
+ * increase order. The values of function must be positive.
+ *
+ * Throws SALOME_Exception if distribution type is not DT_TabFunc
+ */
+ void SetTableFunction(const std::vector<double>& table)
+ throw (SALOME_Exception);
+
+ /*!
+ * \brief Get table function for distribution DT_TabFunc
+ *
+ * Throws SALOME_Exception if distribution type is not DT_TabFunc
+ */
+ const std::vector<double>& GetTableFunction() const
+ throw (SALOME_Exception);
+
+ /*!
+ * \brief Set expression function for distribution DT_ExprFunc
+ * \param expr - string containing the expression of the function
+ * f(t), e.g. "sin(t)"
+ *
+ * Throws SALOME_Exception if distribution type is not DT_ExprFunc
+ */
+ void SetExpressionFunction(const char* expr)
+ throw (SALOME_Exception);
+
+ /*!
+ * \brief Get expression function for distribution DT_ExprFunc
+ *
+ * Throws SALOME_Exception if distribution type is not DT_ExprFunc
+ */
+ const char* GetExpressionFunction() const
+ throw (SALOME_Exception);
+
+ /*!
+ * \brief When exponent mode is set, the function of distribution of density
+ * is used as an exponent of 10, i,e, 10^f(t). This mode is sensible only when
+ * function distribution is used (DT_TabFunc or DT_ExprFunc)
+ * \param isExp - boolean switching on/off the mode
+ *
+ * Throws SALOME_Exception if distribution type is not functional
+ */
+ void SetExponentMode(bool isExp)
+ throw (SALOME_Exception);
+
+ /*!
+ * \brief Returns true if the exponent mode is set
+ *
+ * Throws SALOME_Exception if distribution type is not functional
+ */
+ bool IsExponentMode() const
+ throw (SALOME_Exception);
virtual ostream & SaveTo(ostream & save);
virtual istream & LoadFrom(istream & load);
friend istream& operator >> (istream & load, StdMeshers_NumberOfSegments & hyp);
protected:
- int _numberOfSegments;
- double _scaleFactor;
+ int _numberOfSegments; //!< an edge will be split on to this number of segments
+ DistrType _distrType; //!< the type of distribution of density function
+ double _scaleFactor; //!< the scale parameter for DT_Scale
+ std::vector<double> _table; //!< the table for DT_TabFunc, a sequence of pairs of numbers
+ std::string _func; //!< the expression of the function for DT_ExprFunc
+ bool _expMode; //!< flag of exponent mode
};
#endif
#include "SMDS_EdgePosition.hxx"
#include "SMESH_subMesh.hxx"
+#include "Utils_SALOME_Exception.hxx"
#include "utilities.h"
#include <BRep_Tool.hxx>
#include <GCPnts_UniformDeflection.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Precision.hxx>
+#include <Expr_GeneralExpression.hxx>
+#include <Expr_NamedUnknown.hxx>
+#include <Expr_Array1OfNamedUnknown.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <ExprIntrp_GenExp.hxx>
#include <string>
-//#include <algorithm>
+#include <math.h>
//=============================================================================
/*!
const StdMeshers_NumberOfSegments * hyp =
dynamic_cast <const StdMeshers_NumberOfSegments * >(theHyp);
ASSERT(hyp);
- _value[ NB_SEGMENTS_IND ] = hyp->GetNumberOfSegments();
- _value[ SCALE_FACTOR_IND ] = hyp->GetScaleFactor();
- ASSERT( _value[ NB_SEGMENTS_IND ] > 0 );
+ _ivalue[ NB_SEGMENTS_IND ] = hyp->GetNumberOfSegments();
+ ASSERT( _ivalue[ NB_SEGMENTS_IND ] > 0 );
+ _ivalue[ DISTR_TYPE_IND ] = (int) hyp->GetDistrType();
+ switch (_ivalue[ DISTR_TYPE_IND ])
+ {
+ case StdMeshers_NumberOfSegments::DT_Scale:
+ _value[ SCALE_FACTOR_IND ] = hyp->GetScaleFactor();
+ break;
+ case StdMeshers_NumberOfSegments::DT_TabFunc:
+ _vvalue[ TAB_FUNC_IND ] = hyp->GetTableFunction();
+ break;
+ case StdMeshers_NumberOfSegments::DT_ExprFunc:
+ _svalue[ EXPR_FUNC_IND ] = hyp->GetExpressionFunction();
+ break;
+ case StdMeshers_NumberOfSegments::DT_Regular:
+ break;
+ default:
+ ASSERT(0);
+ break;
+ }
+ if (_ivalue[ DISTR_TYPE_IND ] == StdMeshers_NumberOfSegments::DT_TabFunc ||
+ _ivalue[ DISTR_TYPE_IND ] == StdMeshers_NumberOfSegments::DT_ExprFunc)
+ _ivalue[ EXP_MODE_IND ] = (int) hyp->IsExponentMode();
_hypType = NB_SEGMENTS;
aStatus = SMESH_Hypothesis::HYP_OK;
}
}
}
+/*!
+ * \brief This class provides interface for a density function
+ */
+class Function
+{
+public:
+ Function(bool expMode) : _expMode(expMode) {}
+ double operator() (double t) const;
+ virtual bool IsReady() const = 0;
+protected:
+ virtual double compute(double t) const = 0;
+private:
+ bool _expMode;
+};
+
+/*!
+ * \brief This class provides computation of density function given by a table
+ */
+class TabFunction: public Function
+{
+public:
+ TabFunction(const vector<double>& table, bool expMode);
+ virtual bool IsReady() const;
+protected:
+ virtual double compute(double t) const;
+private:
+ const vector<double>& _table;
+};
+
+/*!
+ * \brief This class provides computation of density function given by an expression
+ */
+class ExprFunction: public Function
+{
+public:
+ ExprFunction(const char* expr, bool expMode);
+ virtual bool IsReady() const;
+protected:
+ virtual double compute(double t) const;
+private:
+ Handle(Expr_GeneralExpression) _expression;
+ Expr_Array1OfNamedUnknown _var;
+ mutable TColStd_Array1OfReal _val;
+};
+
+double Function::operator() (double t) const
+{
+ double res = compute(t);
+ if (_expMode)
+ res = pow(10, res);
+ return res;
+}
+
+TabFunction::TabFunction(const vector<double>& table, bool expMode)
+ : Function(expMode),
+ _table(table)
+{
+}
+
+bool TabFunction::IsReady() const
+{
+ return true;
+}
+
+double TabFunction::compute (double t) const
+{
+ //find place of <t> in table
+ int i;
+ for (i=0; i < _table.size()/2; i++)
+ if (_table[i*2] > t)
+ break;
+ if (i >= _table.size()/2)
+ i = _table.size()/2 - 1;
+
+ if (i == 0)
+ return _table[1];
+
+ // interpolate function value on found interval
+ // (t - x[i-1]) / (x[i] - x[i-1]) = (y - f[i-1]) / (f[i] - f[i-1])
+ // => y = f[i-1] + (f[i] - f[i-1]) * (t - x[i-1]) / (x[i] - x[i-1])
+ double x1 = _table[(i-1)*2];
+ double x2 = _table[i*2];
+ double y1 = _table[(i-1)*2+1];
+ double y2 = _table[i*2+1];
+ if (x2 - x1 < Precision::Confusion())
+ throw SALOME_Exception("TabFunction::compute : confused points");
+ return y1 + (y2 - y1) * ((t - x1) / (x2 - x1));
+}
+
+ExprFunction::ExprFunction(const char* expr, bool expMode)
+ : Function(expMode),
+ _var(1,1),
+ _val(1,1)
+{
+ Handle( ExprIntrp_GenExp ) gen = ExprIntrp_GenExp::Create();
+ gen->Process(TCollection_AsciiString((char*)expr));
+ if (gen->IsDone())
+ {
+ _expression = gen->Expression();
+ _var(1) = new Expr_NamedUnknown("t");
+ }
+}
+
+bool ExprFunction::IsReady() const
+{
+ return !_expression.IsNull();
+}
+
+double ExprFunction::compute (double t) const
+{
+ ASSERT(!_expression.IsNull());
+ _val(1) = t;
+ return _expression->Evaluate(_var, _val);
+}
+
+//================================================================================
+/*!
+ * \brief Compute next abscissa when two previous ones are given
+ * \param sm2 - before previous abscissa
+ * \param sm1 - previous abscissa
+ * \param func - function of density
+ * \param reverse - the direction of next abscissa, increase (0) or decrease (1)
+ * \retval double - the new abscissa
+ *
+ * The abscissa s is given by the formulae
+ *
+ * ....|--------|----------------|.....
+ * sm2 sm1 s
+ *
+ * func(sm2) / func(sm1) = (sm1-sm2) / (s-sm1)
+ * => (s-sm1) * func(sm2) = (sm1-sm2) * func(sm1)
+ * => s = sm1 + (sm1-sm2) * func(sm1) / func(sm2)
+ */
+//================================================================================
+
+static double nextAbscissa(double sm2, double sm1, const Function& func, int reverse)
+{
+ if (reverse)
+ {
+ sm1 = 1.0 - sm1;
+ sm2 = 1.0 - sm2;
+ }
+ return sm1 + (sm1-sm2) * func(sm1) / func(sm2);
+}
+
+//================================================================================
+/*!
+ * \brief Compute distribution of points on a curve following the law of a function
+ * \param C3d - the curve to discretize
+ * \param first - the first parameter on the curve
+ * \param last - the last parameter on the curve
+ * \param theReverse - flag indicating that the curve must be reversed
+ * \param nbSeg - number of output segments
+ * \param func - the function f(t)
+ * \param theParams - output points
+ * \retval bool - true if success
+ */
+//================================================================================
+
+static bool computeParamByFunc(Adaptor3d_Curve& C3d, double first, double last,
+ double length, bool theReverse,
+ int nbSeg, const Function& func,
+ list<double>& theParams)
+{
+ if (!func.IsReady())
+ return false;
+ vector<double> xxx[2];
+ int nbPnt = 1 + nbSeg;
+ int rev, i;
+ for (rev=0; rev < 2; rev++)
+ {
+ // curv abscisses initialisation
+ vector<double> x(nbPnt, 0.);
+ // the first abscissa is 0.0
+
+ // The aim of the algorithm is to find a second abscisse x[1] such as the last
+ // one x[nbSeg] is very close to 1.0 with the epsilon precision
+
+ double x1_too_small = 0.0;
+ double x1_too_large = RealLast();
+ double x1 = 1.0/nbSeg;
+ while (1)
+ {
+ x[1] = x1;
+
+ // Check if the abscissa of the point 2 to N-1
+ // are in the segment ...
+
+ bool ok = true;
+ for (i=2; i <= nbSeg; i++)
+ {
+ x[i] = nextAbscissa(x[i-2], x[i-1], func, rev);
+ if (x[i] - 1.0 > Precision::Confusion())
+ {
+ x[nbSeg] = x[i];
+ ok = false;
+ break;
+ }
+ }
+ if (!ok)
+ {
+ // The segments are to large
+ // Decrease x1 ...
+ x1_too_large = x1;
+ x1 = (x1_too_small+x1_too_large)/2;
+ continue;
+ }
+
+ // Look at the abscissa of the point N
+ // which is to be close to 1.0
+
+ // break condition --> algo converged !!
+
+ if (1.0 - x[nbSeg] < Precision::Confusion())
+ break;
+
+ // not ok ...
+
+ x1_too_small = x1;
+
+ // Modify x1 value
+
+ if (x1_too_large > 1e100)
+ x1 = 2*x1;
+ else
+ x1 = (x1_too_small+x1_too_large)/2;
+ }
+ xxx[rev] = x;
+ }
+
+ // average
+ vector<double> x(nbPnt, 0.);
+ for (i=0; i < nbPnt; i++)
+ x[i] = (xxx[0][i] + (1.0 - xxx[1][nbPnt-i])) / 2;
+
+ // apply parameters in range [0,1] to the space of the curve
+ double prevU = first;
+ double sign = 1.;
+ if (theReverse)
+ {
+ prevU = last;
+ sign = -1.;
+ }
+ for (i = 1; i < nbSeg; i++)
+ {
+ double curvLength = length * (x[i] - x[i-1]) * sign;
+ GCPnts_AbscissaPoint Discret( C3d, curvLength, prevU );
+ if ( !Discret.IsDone() )
+ return false;
+ double U = Discret.Parameter();
+ if ( U > first && U < last )
+ theParams.push_back( U );
+ else
+ return false;
+ prevU = U;
+ }
+ return false;
+}
+
//=============================================================================
/*!
*
double eltSize = 1;
if ( _hypType == LOCAL_LENGTH )
{
+ // Local Length hypothesis
double nbseg = ceil(length / _value[ BEG_LENGTH_IND ]); // integer sup
if (nbseg <= 0)
nbseg = 1; // degenerated edge
}
else
{
- double epsilon = 0.001;
- if (fabs(_value[ SCALE_FACTOR_IND ] - 1.0) > epsilon)
+ // Number Of Segments hypothesis
+ switch (_ivalue[ DISTR_TYPE_IND ])
{
- double scale = _value[ SCALE_FACTOR_IND ];
- if ( theReverse )
- scale = 1. / scale;
- double alpha = pow( scale , 1.0 / (_value[ NB_SEGMENTS_IND ] - 1));
- double factor = (l - f) / (1 - pow( alpha,_value[ NB_SEGMENTS_IND ]));
-
- int i, NbPoints = 1 + (int) _value[ NB_SEGMENTS_IND ];
- for ( i = 2; i < NbPoints; i++ )
+ case StdMeshers_NumberOfSegments::DT_Scale:
{
- double param = f + factor * (1 - pow(alpha, i - 1));
- theParams.push_back( param );
+ double scale = _value[ SCALE_FACTOR_IND ];
+ if ( theReverse )
+ scale = 1. / scale;
+ double alpha = pow( scale , 1.0 / (_ivalue[ NB_SEGMENTS_IND ] - 1));
+ double factor = (l - f) / (1 - pow( alpha,_ivalue[ NB_SEGMENTS_IND ]));
+
+ int i, NbPoints = 1 + _ivalue[ NB_SEGMENTS_IND ];
+ for ( i = 2; i < NbPoints; i++ )
+ {
+ double param = f + factor * (1 - pow(alpha, i - 1));
+ theParams.push_back( param );
+ }
+ return true;
}
- return true;
- }
- else
- {
- eltSize = length / _value[ NB_SEGMENTS_IND ];
+ break;
+ case StdMeshers_NumberOfSegments::DT_TabFunc:
+ {
+ TabFunction func(_vvalue[ TAB_FUNC_IND ], (bool)_ivalue[ EXP_MODE_IND ]);
+ return computeParamByFunc(C3d, f, l, length, theReverse,
+ _ivalue[ NB_SEGMENTS_IND ], func,
+ theParams);
+ }
+ break;
+ case StdMeshers_NumberOfSegments::DT_ExprFunc:
+ {
+ ExprFunction func(_svalue[ EXPR_FUNC_IND ].c_str(), (bool)_ivalue[ EXP_MODE_IND ]);
+ return computeParamByFunc(C3d, f, l, length, theReverse,
+ _ivalue[ NB_SEGMENTS_IND ], func,
+ theParams);
+ }
+ break;
+ case StdMeshers_NumberOfSegments::DT_Regular:
+ eltSize = length / _ivalue[ NB_SEGMENTS_IND ];
+ break;
+ default:
+ return false;
}
}
enum HypothesisType { LOCAL_LENGTH, NB_SEGMENTS, BEG_END_LENGTH, DEFLECTION, ARITHMETIC_1D, NONE };
enum ValueIndex {
- NB_SEGMENTS_IND = 0,
- SCALE_FACTOR_IND = 1,
+ SCALE_FACTOR_IND = 0,
BEG_LENGTH_IND = 0,
END_LENGTH_IND = 1,
DEFLECTION_IND = 0
};
+ enum IValueIndex {
+ NB_SEGMENTS_IND = 0,
+ DISTR_TYPE_IND = 1,
+ EXP_MODE_IND = 2
+ };
+
+ enum VValueIndex {
+ TAB_FUNC_IND = 0
+ };
+
+ enum SValueIndex {
+ EXPR_FUNC_IND = 0
+ };
+
HypothesisType _hypType;
double _value[2];
+ int _ivalue[3];
+ std::vector<double> _vvalue[1];
+ std::string _svalue[1];
// a source of propagated hypothesis, is set by CheckHypothesis()
// always called before Compute()
#include "SUIT_Desktop.h"
#include "SUIT_ResourceMgr.h"
+#include <SalomeApp_Tools.h>
+
#include <qobject.h>
#include "utilities.h"
bool modified = false;
if ( SMESHGUI_aParameterDlg::Parameters( SMESHGUI::GetSMESHGUI(), paramList, QObject::tr("SMESH_VALUE")) )
- modified = StdMeshersGUI_Parameters::SetParameters( theHyp, paramList );
+ {
+ try
+ {
+ modified = StdMeshersGUI_Parameters::SetParameters( theHyp, paramList );
+ }
+ catch (const SALOME::SALOME_Exception& S_ex)
+ {
+ SalomeApp_Tools::QtCatchCorbaException(S_ex);
+ return;
+ }
+ }
if ( modified ) {
//set new Attribute Comment for hypothesis which parameters were modified
#include <qpixmap.h>
#include <qspinbox.h>
#include <qtextedit.h>
+#include <qcombobox.h>
+#include <qcheckbox.h>
using namespace std;
setCaption( theCaption );
setSizeGripEnabled( TRUE );
- QGridLayout* StdMeshersGUI_CreateHypothesisDlgLayout = new QGridLayout( this );
+ QVBoxLayout* StdMeshersGUI_CreateHypothesisDlgLayout = new QVBoxLayout( this );
StdMeshersGUI_CreateHypothesisDlgLayout->setSpacing( 6 );
StdMeshersGUI_CreateHypothesisDlgLayout->setMargin( 11 );
/***************************************************************/
- iconLabel = new QLabel( this );
+ QFrame* titFrame = new QFrame( this );
+ QHBoxLayout* titLay = new QHBoxLayout( titFrame, 0, 0 );
+
+ iconLabel = new QLabel( titFrame );
iconLabel->setPixmap( theHypIcon );
iconLabel->setScaledContents( false );
iconLabel->setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) );
- typeLabel = new QLabel( this );
+ typeLabel = new QLabel( titFrame );
typeLabel->setText( theHypTypeName );
- StdMeshersGUI_CreateHypothesisDlgLayout->addWidget( iconLabel, 0, 0 );
- StdMeshersGUI_CreateHypothesisDlgLayout->addWidget( typeLabel, 0, 1 );
+ titLay->addWidget( iconLabel, 0 );
+ titLay->addWidget( typeLabel, 0 );
+ titLay->addStretch( 1 );
+
+ StdMeshersGUI_CreateHypothesisDlgLayout->addWidget( titFrame, 0);
/***************************************************************/
GroupC1 = new QGroupBox( this, "GroupC1" );
LineEdit_NameHypothesis = new QLineEdit( GroupC1, "LineEdit_NameHypothesis" );
GroupC1Layout->addWidget( LineEdit_NameHypothesis, 0, 1 );
- myParamList.clear();
- GetParameters( myHypType, myParamList );
- ASSERT( !myParamList.empty() );
+ myParamMap.clear();
+ std::list<SMESHGUI_aParameterPtr> aParamList;
+ GetParameters( myHypType, aParamList );
+ ASSERT( !aParamList.empty() );
/* Spin boxes with labels */
- list<SMESHGUI_aParameterPtr>::iterator paramIt = myParamList.begin();
- for ( int row = 1; paramIt != myParamList.end(); paramIt++ , row++ )
+ list<SMESHGUI_aParameterPtr>::iterator paramIt = aParamList.begin();
+ for ( int row = 1; paramIt != aParamList.end(); paramIt++ , row++ )
{
SMESHGUI_aParameterPtr param = (*paramIt);
QLabel * label = new QLabel( GroupC1, "TextLabel" );
GroupC1Layout->addWidget( label, row, 0 );
label->setText( param->Label() );
- QWidget* aSpinWidget = 0;
- switch ( param->GetType() ) {
- case SMESHGUI_aParameter::DOUBLE: {
- SMESHGUI_SpinBox* spin = new SMESHGUI_SpinBox( GroupC1 );
- aSpinWidget = spin;
- spin->setPrecision( 12 );
- break;
- }
- case SMESHGUI_aParameter::INT: {
- QSpinBox* spin = new QSpinBox( GroupC1 );
- aSpinWidget = spin;
- break;
- }
- case SMESHGUI_aParameter::TEXT: {
- QTextEdit* edit = new QTextEdit( GroupC1 );
- edit->setWordWrap( QTextEdit::NoWrap );
- edit->setTextFormat( Qt::PlainText );
- aSpinWidget = edit;
- break;
- }
- default:;
- }
-
- if ( aSpinWidget ) {
- GroupC1Layout->addWidget( aSpinWidget, row, 1 );
- aSpinWidget->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Minimum ) );
- aSpinWidget->setMinimumSize( 150, 0 );
- param->InitializeWidget( aSpinWidget );
- mySpinList.push_back( aSpinWidget );
+ QWidget* aWidget = param->CreateWidget( GroupC1 );
+
+ if ( aWidget ) {
+ GroupC1Layout->addWidget( aWidget, row, 1 );
+ aWidget->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Minimum ) );
+ aWidget->setMinimumSize( 150, 0 );
+
+ QString sig = param->sigValueChanged();
+ if( !sig.isEmpty() && param->GetType()!=SMESHGUI_aParameter::TABLE )
+ connect( aWidget, sig.latin1(), this, SLOT( onValueChanged() ) );
+
+ param->InitializeWidget( aWidget );
+
+ ParamInfo info;
+ info.editor = aWidget;
+ info.label = label;
+ info.order = row-1;
+
+ myParamMap.insert( param, info );
}
}
- StdMeshersGUI_CreateHypothesisDlgLayout->addMultiCellWidget(GroupC1 , 1, 1, 0, 1 );
+ StdMeshersGUI_CreateHypothesisDlgLayout->addWidget( GroupC1, 1 );
/***************************************************************/
GroupButtons = new QGroupBox( this, "GroupButtons" );
buttonCancel->setText( tr( "SMESH_BUT_CLOSE" ) );
buttonCancel->setAutoDefault( TRUE );
GroupButtonsLayout->addWidget( buttonCancel, 0, 3 );
- StdMeshersGUI_CreateHypothesisDlgLayout->addMultiCellWidget( GroupButtons, 2, 2, 0, 1 );
+ StdMeshersGUI_CreateHypothesisDlgLayout->addWidget( GroupButtons, 0 );
/***************************************************************/
Init() ;
//=================================================================================
void StdMeshersGUI_CreateHypothesisDlg::Init()
{
+ ParameterMap::const_iterator anIt = myParamMap.begin(),
+ aLast = myParamMap.end();
+ for( ; anIt!=aLast; anIt++ )
+ UpdateShown( anIt.key() );
+
mySMESHGUI = SMESHGUI::GetSMESHGUI() ;
char* sHypType = const_cast<char*>(myHypType.latin1());
SUIT_OverrideCursor wc;
+ SMESH::SMESH_Hypothesis_var Hyp = SMESH::SMESH_Hypothesis::_narrow
+ ( SMESH::CreateHypothesis( myHypType, myHypName, false ) ); // isAlgorithm
+
try {
- SMESH::SMESH_Hypothesis_var Hyp = SMESH::SMESH_Hypothesis::_narrow
- ( SMESH::CreateHypothesis (myHypType,
- myHypName,
- false )); // isAlgorithm
-
- list<SMESHGUI_aParameterPtr>::iterator paramIt = myParamList.begin();
- list<QWidget*>::iterator widgetIt = mySpinList.begin();
- for ( ;
- paramIt != myParamList.end() && widgetIt != mySpinList.end();
- paramIt++ , widgetIt++ )
- (*paramIt)->TakeValue( *widgetIt );
- SetParameters( Hyp, myParamList );
+ list<SMESHGUI_aParameterPtr> aParamList;
+ ParameterMap::const_iterator anIt = myParamMap.begin(),
+ aLast = myParamMap.end();
+ for( int i=0; i<myParamMap.count(); i++ )
+ for( anIt=myParamMap.begin(); anIt!=aLast; anIt++ )
+ if( (*anIt).order==i )
+ {
+ anIt.key()->TakeValue( anIt.data().editor );
+ aParamList.push_back( anIt.key() );
+ break;
+ }
+
+ SetParameters( Hyp, aParamList );
//set new Attribute Comment for hypothesis which parameters were set
QString aParams = "";
- StdMeshersGUI_Parameters::GetParameters( Hyp.in(), myParamList, aParams );
+ StdMeshersGUI_Parameters::GetParameters( Hyp.in(), aParamList, aParams );
_PTR(SObject) SHyp = SMESH::FindSObject(Hyp.in());
if (SHyp)
- if (!aParams.isEmpty()) {
- SMESH::SetValue(SHyp, aParams);
- mySMESHGUI->getApp()->objectBrowser()->updateTree();
+ if (!aParams.isEmpty())
+ {
+ SMESH::SetValue(SHyp, aParams);
+ mySMESHGUI->getApp()->objectBrowser()->updateTree();
}
}
- catch (const SALOME::SALOME_Exception& S_ex) {
+ catch (const SALOME::SALOME_Exception& S_ex)
+ {
wc.suspend();
+
+ _PTR(SObject) SHyp = SMESH::FindSObject(Hyp.in());
+ _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
+ if( aStudy && !aStudy->GetProperties()->IsLocked() )
+ {
+ _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
+ aBuilder->RemoveObjectWithChildren( SHyp );
+ mySMESHGUI->updateObjBrowser( true, 0 );
+ }
+
SalomeApp_Tools::QtCatchCorbaException(S_ex);
return false;
}
mySMESHGUI->ResetState();
QDialog::closeEvent( e );
}
+
+//=================================================================================
+// function : onValueChanged()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_CreateHypothesisDlg::onValueChanged()
+{
+ if( sender()->inherits( "QWidget" ) )
+ {
+ QWidget* w = ( QWidget* )sender();
+
+ SMESHGUI_aParameterPtr param;
+
+ ParameterMap::const_iterator anIt = myParamMap.begin(),
+ aLast = myParamMap.end();
+ for( ; anIt!=aLast; anIt++ )
+ if( anIt.data().editor == w )
+ {
+ param = anIt.key();
+ param->TakeValue( w );
+ UpdateShown( param );
+ break;
+ }
+ }
+}
+
+//=================================================================================
+// function : UpdateShown()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_CreateHypothesisDlg::UpdateShown( const SMESHGUI_aParameterPtr param )
+{
+ SMESHGUI_dependParameter* depPar = dynamic_cast<SMESHGUI_enumParameter*>( param.get() );
+ if( !depPar )
+ depPar = dynamic_cast<SMESHGUI_boolParameter*>( param.get() );
+
+ if( !depPar )
+ return;
+
+ SMESHGUI_dependParameter::ShownMap& map = depPar->shownMap();
+ if( map.isEmpty() )
+ return;
+
+ int val;
+ depPar->TakeValue( myParamMap[ param ].editor );
+ depPar->GetNewInt( val );
+
+ bool hasValue = map.contains( val );
+
+ ParameterMap::const_iterator anIt = myParamMap.begin(),
+ aLast = myParamMap.end();
+ for( ; anIt!=aLast; anIt++ )
+ {
+ bool shown = hasValue && map[ val ].contains( (*anIt).order );
+ (*anIt).editor->setShown( shown );
+ (*anIt).label->setShown( shown );
+ }
+}
// QT Includes
#include <qdialog.h>
+#include <qmap.h>
+#include <qpair.h>
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
#include "SMESHGUI_aParameter.h"
-#include <list>
-
class QGroupBox;
class QLabel;
class QLineEdit;
const QPixmap & hypIcon,
const QString & hypTypeName);
- virtual void GetParameters(const QString & hypType,
- std::list<SMESHGUI_aParameterPtr> & params) = 0;
+ virtual void GetParameters( const QString& hypType,
+ std::list<SMESHGUI_aParameterPtr>& ) = 0;
- virtual bool SetParameters(SMESH::SMESH_Hypothesis_ptr theHyp,
- const std::list<SMESHGUI_aParameterPtr> & params) = 0;
+ virtual bool SetParameters( SMESH::SMESH_Hypothesis_ptr theHyp,
+ const std::list<SMESHGUI_aParameterPtr> & params ) = 0;
+protected slots:
+ virtual void onValueChanged();
+
private:
-
+ void UpdateShown( const SMESHGUI_aParameterPtr );
void Init() ;
void closeEvent( QCloseEvent* e ) ;
void enterEvent ( QEvent * ) ;
- SMESHGUI* mySMESHGUI ;
- QString myHypType ;
-
- std::list<QWidget*> mySpinList;
- std::list<SMESHGUI_aParameterPtr> myParamList;
+ SMESHGUI* mySMESHGUI;
+ QString myHypType;
+
+ typedef struct
+ {
+ QWidget* editor;
+ QLabel* label;
+ int order;
+
+ } ParamInfo;
+
+ typedef QMap< SMESHGUI_aParameterPtr, ParamInfo > ParameterMap;
+ ParameterMap myParamMap;
QLabel* iconLabel;
QLabel* typeLabel;
int initValue)
{
SMESHGUI_intParameter* p = dynamic_cast<SMESHGUI_intParameter*>(param.get());
- if ( p ) p->InitValue() = initValue;
+ if ( p )
+ {
+ p->InitValue() = initValue;
+ return;
+ }
+
+ SMESHGUI_enumParameter* q = dynamic_cast<SMESHGUI_enumParameter*>(param.get());
+ if( q )
+ {
+ q->InitValue() = initValue;
+ return;
+ }
+
+ SMESHGUI_boolParameter* b = dynamic_cast<SMESHGUI_boolParameter*>(param.get());
+ if( b )
+ {
+ b->InitValue() = (bool)initValue;
+ return;
+ }
}
//=======================================================================
if ( p ) p->InitValue() = initValue;
}
+//=======================================================================
+//function : SetInitValue
+//purpose :
+//=======================================================================
+void StdMeshersGUI_Parameters::SetInitValue( SMESHGUI_aParameterPtr param,
+ SMESH::double_array& initValue)
+{
+ SMESHGUI_tableParameter* p = dynamic_cast<SMESHGUI_tableParameter*>(param.get());
+ if( p )
+ {
+ p->setRowCount( initValue.length()/2 );
+ p->setData( initValue );
+ }
+}
+
//=======================================================================
//function : GetParameters
//purpose :
// 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 INT_PARAM(v,l,b,t) SMESHGUI_aParameterPtr(new SMESHGUI_intParameter(v,l,b,t))
+#define ENUM_PARAM(v,i,l) SMESHGUI_aParameterPtr(new SMESHGUI_enumParameter(v,i,l))
+#define STR_PARAM(i,l) SMESHGUI_aParameterPtr(new SMESHGUI_strParameter(i,l))
+#define BOOL_PARAM(i,l) SMESHGUI_aParameterPtr(new SMESHGUI_boolParameter(i,l))
void StdMeshersGUI_Parameters::GetParameters (const QString& hypType,
list<SMESHGUI_aParameterPtr> & paramList )
}
else if (hypType.compare("NumberOfSegments") == 0)
{
+ //0-th parameter in list
paramList.push_back ( INT_PARAM (3,
QObject::tr("SMESH_NB_SEGMENTS_PARAM"),
1, 9999 ));
+ QStringList types;
+ types.append( QObject::tr( "SMESH_DISTR_REGULAR" ) );
+ types.append( QObject::tr( "SMESH_DISTR_SCALE" ) );
+ types.append( QObject::tr( "SMESH_DISTR_TAB" ) );
+ types.append( QObject::tr( "SMESH_DISTR_EXPR" ) );
+ //string description of distribution types
+
+ SMESHGUI_enumParameter* type = new SMESHGUI_enumParameter( types, 0, QObject::tr( "SMESH_DISTR_TYPE" ) );
+ SMESHGUI_dependParameter::ShownMap& aMap = type->shownMap();
+ aMap[0].append( 0 ); // if DistrType=0 (regular), then number of segments and types are shown (0-th and 1-th)
+ aMap[0].append( 1 );
+ aMap[1].append( 0 ); // if DistrType=1 (scale), then number of segments, types and scale are shown
+ aMap[1].append( 1 );
+ aMap[1].append( 2 );
+ aMap[2].append( 0 ); // if DistrType=2 (table), then number of segments, types, table and exponent are shown
+ aMap[2].append( 1 );
+ aMap[2].append( 3 );
+ aMap[2].append( 5 );
+ aMap[3].append( 0 ); // if DistrType=3 (expression), then number of segments, types, expression and exponent are shown
+ aMap[3].append( 1 );
+ aMap[3].append( 4 );
+ aMap[3].append( 5 );
+ //1-th parameter in list
+ paramList.push_back ( SMESHGUI_aParameterPtr( type ) );
+
+ //2-th parameter in list
paramList.push_back ( DOUBLE_PARAM (1.0,
QObject::tr("SMESH_NB_SEGMENTS_SCALE_PARAM"),
VALUE_SMALL, VALUE_MAX, 0.1, 6 ));
+ SMESHGUI_tableParameter* tab = new SMESHGUI_tableParameter( 0.0, QObject::tr( "SMESH_TAB_FUNC" ) );
+ tab->setRowCount( 5 );
+ tab->setColCount( 2 );
+ //default size of table: 5x2
+
+ tab->setColName( 0, "t" );
+ tab->setColName( 1, "f(t)" );
+ tab->setValidator( 0, 0.0, 1.0, 3 );
+ tab->setValidator( 1, 1E-7, 1E+300, 3 );
+ tab->setEditRows( true );
+
+ //3-th parameter in list
+ paramList.push_back ( SMESHGUI_aParameterPtr( tab ) );
+
+ //4-th parameter in list
+ paramList.push_back ( STR_PARAM ( "", QObject::tr( "SMESH_EXPR_FUNC" ) ) );
+
+ //5-th parameter in list
+ paramList.push_back ( BOOL_PARAM ( false, QObject::tr( "SMESH_EXP_MODE" ) ) );
}
else if (hypType.compare("Arithmetic1D") == 0)
{
{
StdMeshers::StdMeshers_NumberOfSegments_var NOS =
StdMeshers::StdMeshers_NumberOfSegments::_narrow(theHyp);
- SetInitValue( paramList.front(), (int) NOS->GetNumberOfSegments());
- SetInitValue( paramList.back(), NOS->GetScaleFactor());
+
+ list<SMESHGUI_aParameterPtr>::iterator anIt = paramList.begin();
+ SetInitValue( *anIt, (int) NOS->GetNumberOfSegments()); anIt++;
+ int DType = (int) NOS->GetDistrType();
+ SetInitValue( *anIt, DType ); anIt++;
+
+ if( DType==1 )
+ SetInitValue( *anIt, NOS->GetScaleFactor());
+ anIt++;
+
+ if( DType==2 )
+ {
+ SMESH::double_array* tab_func = NOS->GetTableFunction();
+ SetInitValue( *anIt, *tab_func );
+ delete tab_func;
+ }
+ anIt++;
+
+ if( DType==3 )
+ {
+ char* expr_func = NOS->GetExpressionFunction();
+ SetInitValue( *anIt, expr_func );
+ delete expr_func;
+ }
+ anIt++;
+
+ if( DType==2 || DType==3 )
+ SetInitValue( *anIt, (bool)NOS->IsExponentMode());
}
else if (hypType.compare("Arithmetic1D") == 0)
{
for ( ; paramIt != paramList.end(); paramIt++) {
if (params.compare("")) params += " ; ";
- if ((*paramIt)->GetType() == SMESHGUI_aParameter::DOUBLE ) {
+ SMESHGUI_aParameter::Type t = (*paramIt)->GetType();
+ if( t==SMESHGUI_aParameter::DOUBLE )
+ {
double aDoubleValue = 0.;
(*paramIt)->GetNewDouble(aDoubleValue);
params += QString::number(aDoubleValue);
}
- else if ((*paramIt)->GetType() == SMESHGUI_aParameter::TEXT ) {
+ else if( t==SMESHGUI_aParameter::STRING || t==SMESHGUI_aParameter::ENUM )
+ {
QString aStrValue( "" );
(*paramIt)->GetNewText(aStrValue);
params += aStrValue.simplifyWhiteSpace();
}
- else {
+ else if( t==SMESHGUI_aParameter::TABLE )
+ {
+ params += "TABLE";
+ }
+ else
+ {
int aIntValue = 0;
(*paramIt)->GetNewInt(aIntValue);
params += QString::number(aIntValue);
{
StdMeshers::StdMeshers_NumberOfSegments_var NOS =
StdMeshers::StdMeshers_NumberOfSegments::_narrow(theHyp);
- int NbSeg = NOS->GetNumberOfSegments();
- double Scale = NOS->GetScaleFactor() ;
- modified = paramList.front()->GetNewInt( NbSeg );
- modified = paramList.back()->GetNewDouble( Scale ) || modified;
- NOS->SetNumberOfSegments(NbSeg);
- NOS->SetScaleFactor( Scale );
+
+ list<SMESHGUI_aParameterPtr>::const_iterator anIt = paramList.begin();
+ int NbSeg, DType;
+ double Scale;
+ SMESH::double_array TabF;
+ QString exprF;
+ int expType;
+
+ modified = (*anIt)->GetNewInt( NbSeg ); anIt++;
+ modified = (*anIt)->GetNewInt( DType ) || modified; anIt++;
+ modified = (*anIt)->GetNewDouble( Scale ) || modified; anIt++;
+ SMESHGUI_aParameterPtr p = *anIt;
+ ((SMESHGUI_tableParameter*)p.get())->data( TabF ); anIt++; modified = true;
+ modified = (*anIt)->GetNewText( exprF ) || modified; anIt++;
+ modified = (*anIt)->GetNewInt( expType ) || modified;
+
+ NOS->SetNumberOfSegments( NbSeg );
+ NOS->SetDistrType( DType );
+ if( DType==1 )
+ NOS->SetScaleFactor( Scale );
+ if( DType==2 )
+ NOS->SetTableFunction( TabF );
+ if( DType==3 )
+ NOS->SetExpressionFunction( CORBA::string_dup( exprF.latin1() ) );
+ if( DType==2 || DType==3 )
+ NOS->SetExponentMode( (bool)expType );
}
else if (hypType.compare("Arithmetic1D") == 0)
{
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+#include CORBA_SERVER_HEADER(SMESH_Mesh)
#include "SMESHGUI_aParameter.h"
#include <list>
+#include <vector>
class StdMeshersGUI_Parameters
{
double initValue);
static void SetInitValue(SMESHGUI_aParameterPtr param,
const char* initValue);
+ static void SetInitValue(SMESHGUI_aParameterPtr param,
+ SMESH::double_array& initValue);
};
#endif
msgid "SMESH_NB_SEGMENTS_PARAM"
msgstr "Number of Segments"
+msgid "SMESH_DISTR_TYPE"
+msgstr "Type of distribution"
+
+msgid "SMESH_DISTR_REGULAR"
+msgstr "Equidistant distribution"
+
+msgid "SMESH_DISTR_SCALE"
+msgstr "Scale distribution"
+
+msgid "SMESH_DISTR_TAB"
+msgstr "Distribution with table density"
+
+msgid "SMESH_DISTR_EXPR"
+msgstr "Distribution with analitic density"
+
msgid "SMESH_NB_SEGMENTS_SCALE_PARAM"
msgstr "Scale Factor"
+msgid "SMESH_TAB_FUNC"
+msgstr "Table function"
+
+msgid "SMESH_EXPR_FUNC"
+msgstr "Density function f(t) = "
+
+msgid "SMESH_EXP_MODE"
+msgstr "Exponent mode "
+
msgid "SMESH_NB_SEGMENTS_TITLE"
msgstr "Hypothesis Construction"
return this->GetImpl()->GetNumberOfSegments();
}
+//=============================================================================
+/*!
+ */
+//=============================================================================
+
+void StdMeshers_NumberOfSegments_i::SetDistrType(CORBA::Long typ)
+ throw ( SALOME::SALOME_Exception )
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::SetDistrType" );
+ ASSERT( myBaseImpl );
+ try {
+ this->GetImpl()->SetDistrType( (::StdMeshers_NumberOfSegments::DistrType) typ );
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+}
+
+//=============================================================================
+/*!
+ */
+//=============================================================================
+
+CORBA::Long StdMeshers_NumberOfSegments_i::GetDistrType()
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::GetDistrType" );
+ ASSERT( myBaseImpl );
+ return this->GetImpl()->GetDistrType();
+}
+
//=============================================================================
/*!
* StdMeshers_NumberOfSegments_i::SetScaleFactor
//=============================================================================
CORBA::Double StdMeshers_NumberOfSegments_i::GetScaleFactor()
+ throw ( SALOME::SALOME_Exception )
{
MESSAGE( "StdMeshers_NumberOfSegments_i::GetScaleFactor" );
ASSERT( myBaseImpl );
- return this->GetImpl()->GetScaleFactor();
+ double scale;
+ try {
+ scale = this->GetImpl()->GetScaleFactor();
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+ return scale;
+}
+
+//=============================================================================
+/*!
+ */
+//=============================================================================
+
+void StdMeshers_NumberOfSegments_i::SetTableFunction(const SMESH::double_array& table)
+ throw ( SALOME::SALOME_Exception )
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::SetTableFunction" );
+ ASSERT( myBaseImpl );
+ std::vector<double> tbl( table.length() );
+ for (int i = 0; i < table.length(); i++)
+ tbl[i] = table[i];
+ try {
+ this->GetImpl()->SetTableFunction( tbl );
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+}
+
+//=============================================================================
+/*!
+ */
+//=============================================================================
+
+SMESH::double_array* StdMeshers_NumberOfSegments_i::GetTableFunction()
+ throw ( SALOME::SALOME_Exception )
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::GetTableFunction" );
+ ASSERT( myBaseImpl );
+ const std::vector<double>* tbl;
+ try {
+ tbl = &this->GetImpl()->GetTableFunction();
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+ SMESH::double_array_var aRes = new SMESH::double_array();
+ aRes->length(tbl->size());
+ for (int i = 0; i < tbl->size(); i++)
+ aRes[i] = (*tbl)[i];
+ return aRes._retn();
+}
+
+//=============================================================================
+/*!
+ */
+//=============================================================================
+
+void StdMeshers_NumberOfSegments_i::SetExpressionFunction(const char* expr)
+ throw ( SALOME::SALOME_Exception )
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::SetExpressionFunction" );
+ ASSERT( myBaseImpl );
+ try {
+ this->GetImpl()->SetExpressionFunction( expr );
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+}
+
+//=============================================================================
+/*!
+ */
+//=============================================================================
+
+char* StdMeshers_NumberOfSegments_i::GetExpressionFunction()
+ throw ( SALOME::SALOME_Exception )
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::GetExpressionFunction" );
+ ASSERT( myBaseImpl );
+ const char* expr;
+ try {
+ expr = this->GetImpl()->GetExpressionFunction();
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+ return CORBA::string_dup(expr);
+}
+
+//=============================================================================
+/*!
+ */
+//=============================================================================
+
+void StdMeshers_NumberOfSegments_i::SetExponentMode(CORBA::Boolean isExp)
+ throw ( SALOME::SALOME_Exception )
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::SetExponentMode" );
+ ASSERT( myBaseImpl );
+ try {
+ this->GetImpl()->SetExponentMode( isExp );
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+}
+
+//=============================================================================
+/*!
+ */
+//=============================================================================
+
+CORBA::Boolean StdMeshers_NumberOfSegments_i::IsExponentMode()
+ throw ( SALOME::SALOME_Exception )
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::IsExponentMode" );
+ ASSERT( myBaseImpl );
+ bool isExp;
+ try {
+ isExp = this->GetImpl()->IsExponentMode();
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+ return isExp;
}
//=============================================================================
#define _SMESH_NUMBEROFSEGMENTS_I_HXX_
#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_Mesh)
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
#include "SMESH_Hypothesis_i.hxx"
// Get number of segments
CORBA::Long GetNumberOfSegments();
+ // Set distribution type
+ void SetDistrType(CORBA::Long typ)
+ throw ( SALOME::SALOME_Exception );
+ // Get distribution type
+ CORBA::Long GetDistrType();
+
// Set scalar factor
void SetScaleFactor( CORBA::Double theScaleFactor )
throw ( SALOME::SALOME_Exception );
// Get scalar factor
- CORBA::Double GetScaleFactor();
+ CORBA::Double GetScaleFactor()
+ throw ( SALOME::SALOME_Exception );
+
+ // Set table function for distribution DT_TabFunc
+ void SetTableFunction(const SMESH::double_array& table)
+ throw ( SALOME::SALOME_Exception );
+ // Get table function for distribution DT_TabFunc
+ SMESH::double_array* GetTableFunction()
+ throw ( SALOME::SALOME_Exception );
+
+ // Set expression function for distribution DT_ExprFunc
+ void SetExpressionFunction(const char* expr)
+ throw ( SALOME::SALOME_Exception );
+ // Get expression function for distribution DT_ExprFunc
+ char* GetExpressionFunction()
+ throw ( SALOME::SALOME_Exception );
+
+ // Set the exponent mode on/off
+ void SetExponentMode(CORBA::Boolean isExp)
+ throw ( SALOME::SALOME_Exception );
+ // Returns true if the exponent mode is set
+ CORBA::Boolean IsExponentMode()
+ throw ( SALOME::SALOME_Exception );
// Get implementation
::StdMeshers_NumberOfSegments* GetImpl();
