src/StdMeshersGUI/StdMeshersGUI_Parameters.cxx

   1 //  SMESH StdMeshersGUI : GUI for standard meshers
   2 //
   3 //  Copyright (C) 2003  CEA
   4 //
   5 //  This library is free software; you can redistribute it and/or
   6 //  modify it under the terms of the GNU Lesser General Public
   7 //  License as published by the Free Software Foundation; either
   8 //  version 2.1 of the License.
   9 //
  10 //  This library is distributed in the hope that it will be useful,
  11 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 //  Lesser General Public License for more details.
  14 //
  15 //  You should have received a copy of the GNU Lesser General Public
  16 //  License along with this library; if not, write to the Free Software
  17 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18 //
  19 //  See http://www.salome-platform.org or email : webmaster.salome@opencascade.org
  20 //
  21 //
  22 //
  23 //  File   : StdMeshersGUI_Parameters.cxx
  24 //  Module : SMESH
  25 //  $Header$
  26
  27 #include "StdMeshersGUI_Parameters.h"
  28
  29 //#include "SMESHGUI_SpinBox.h" // for the sake of COORD_MAX, COORD_MIN definition
  30
  31 #include <qobject.h>
  32
  33 using namespace std;
  34
  35 #define VALUE_MAX   1.0e+15 // COORD_MAX
  36 #define VALUE_MAX_2 (VALUE_MAX*VALUE_MAX)
  37 #define VALUE_MAX_3 (VALUE_MAX*VALUE_MAX*VALUE_MAX)
  38
  39 #define VALUE_SMALL   1.0e-15
  40 #define VALUE_SMALL_2 (VALUE_SMALL*VALUE_SMALL)
  41 #define VALUE_SMALL_3 (VALUE_SMALL*VALUE_SMALL*VALUE_SMALL)
  42
  43 //=======================================================================
  44 //function : HasParameters
  45 //purpose  :
  46 //=======================================================================
  47
  48 bool StdMeshersGUI_Parameters::HasParameters (const QString& hypType)
  49 {
  50   return ((hypType.compare("LocalLength") == 0) ||
  51           (hypType.compare("NumberOfSegments") == 0) ||
  52           (hypType.compare("MaxElementArea") == 0) ||
  53           (hypType.compare("MaxElementVolume") == 0) ||
  54           (hypType.compare("StartEndLength") == 0) ||
  55           (hypType.compare("Deflection1D") == 0) ||
  56           (hypType.compare("Arithmetic1D") == 0));
  57 }
  58
  59 //=======================================================================
  60 //function : SetInitValue
  61 //purpose  :
  62 //=======================================================================
  63
  64 void StdMeshersGUI_Parameters::SetInitValue(SMESHGUI_aParameterPtr param,
  65                                             int                    initValue)
  66 {
  67   SMESHGUI_intParameter* p = dynamic_cast<SMESHGUI_intParameter*>(param.get());
  68   if ( p )
  69   {
  70     p->InitValue() = initValue;
  71     return;
  72   }
  73
  74   SMESHGUI_enumParameter* q = dynamic_cast<SMESHGUI_enumParameter*>(param.get());
  75   if( q )
  76   {
  77     q->InitValue() = initValue;
  78     return;
  79   }
  80
  81   SMESHGUI_boolParameter* b = dynamic_cast<SMESHGUI_boolParameter*>(param.get());
  82   if( b )
  83   {
  84     b->InitValue() = (bool)initValue;
  85     return;
  86   }
  87 }
  88
  89 //=======================================================================
  90 //function : SetInitValue
  91 //purpose  :
  92 //=======================================================================
  93
  94 void StdMeshersGUI_Parameters::SetInitValue(SMESHGUI_aParameterPtr param,
  95                                             double                 initValue)
  96 {
  97   SMESHGUI_doubleParameter* p = dynamic_cast<SMESHGUI_doubleParameter*>(param.get());
  98   if ( p ) p->InitValue() = initValue;
  99 }
 100
 101 //=======================================================================
 102 //function : SetInitValue
 103 //purpose  :
 104 //=======================================================================
 105
 106 void StdMeshersGUI_Parameters::SetInitValue(SMESHGUI_aParameterPtr param,
 107                                             const char*            initValue)
 108 {
 109   SMESHGUI_strParameter* p = dynamic_cast<SMESHGUI_strParameter*>(param.get());
 110   if ( p ) p->InitValue() = initValue;
 111 }
 112
 113 //=======================================================================
 114 //function : SetInitValue
 115 //purpose  :
 116 //=======================================================================
 117 void StdMeshersGUI_Parameters::SetInitValue( SMESHGUI_aParameterPtr param,
 118                                              SMESH::double_array&   initValue)
 119 {
 120   SMESHGUI_tableParameter* p = dynamic_cast<SMESHGUI_tableParameter*>(param.get());
 121   if( p )
 122   {
 123     p->setRowCount( initValue.length()/2 );
 124     p->setData( initValue );
 125   }
 126 }
 127
 128 //=======================================================================
 129 //function : GetParameters
 130 //purpose  :
 131 //=======================================================================
 132
 133 // SMESHGUI_doubleParameter( initValue, label, bottom, top, step, decimals )
 134 #define DOUBLE_PARAM(v,l,b,t,s,d) SMESHGUI_aParameterPtr(new SMESHGUI_doubleParameter(v,l,b,t,s,d))
 135 #define INT_PARAM(v,l,b,t) SMESHGUI_aParameterPtr(new SMESHGUI_intParameter(v,l,b,t))
 136 #define ENUM_PARAM(v,i,l) SMESHGUI_aParameterPtr(new SMESHGUI_enumParameter(v,i,l))
 137 #define STR_PARAM(i,l,preview) SMESHGUI_aParameterPtr(new SMESHGUI_strParameter(i,l,preview))
 138 #define BOOL_PARAM(i,l,preview) SMESHGUI_aParameterPtr(new SMESHGUI_boolParameter(i,l,preview))
 139
 140 void StdMeshersGUI_Parameters::GetParameters (const QString&                 hypType,
 141                                               list<SMESHGUI_aParameterPtr> & paramList )
 142 {
 143   paramList.clear();
 144
 145   if (hypType.compare("LocalLength") == 0)
 146   {
 147     paramList.push_back( DOUBLE_PARAM (1.0,
 148                                        QObject::tr("SMESH_LOCAL_LENGTH_PARAM"),
 149                                        VALUE_SMALL, VALUE_MAX, 1.0, 6));
 150   }
 151   else if (hypType.compare("NumberOfSegments") == 0)
 152   {
 153     //0-th parameter in list
 154     paramList.push_back ( INT_PARAM (3,
 155                                      QObject::tr("SMESH_NB_SEGMENTS_PARAM"),
 156                                      1, 9999 ));
 157     QStringList types;
 158     types.append( QObject::tr( "SMESH_DISTR_REGULAR" ) );
 159     types.append( QObject::tr( "SMESH_DISTR_SCALE"   ) );
 160     types.append( QObject::tr( "SMESH_DISTR_TAB"     ) );
 161     types.append( QObject::tr( "SMESH_DISTR_EXPR"    ) );
 162     //string description of distribution types
 163
 164     SMESHGUI_enumParameter* type = new SMESHGUI_enumParameter( types, 0, QObject::tr( "SMESH_DISTR_TYPE" ) );
 165     SMESHGUI_dependParameter::ShownMap& aMap = type->shownMap();
 166     aMap[0].append( 0 ); // if DistrType=0 (regular), then number of segments and types are shown (0-th and 1-th)
 167     aMap[0].append( 1 );
 168     aMap[1].append( 0 ); // if DistrType=1 (scale), then number of segments, types and scale are shown
 169     aMap[1].append( 1 );
 170     aMap[1].append( 2 );
 171     aMap[2].append( 0 ); // if DistrType=2 (table), then number of segments, types, table and exponent are shown
 172     aMap[2].append( 1 );
 173     aMap[2].append( 3 );
 174     aMap[2].append( 5 );
 175     aMap[3].append( 0 ); // if DistrType=3 (expression), then number of segments, types, expression and exponent are shown
 176     aMap[3].append( 1 );
 177     aMap[3].append( 4 );
 178     aMap[3].append( 5 );
 179     //1-th parameter in list
 180     paramList.push_back ( SMESHGUI_aParameterPtr( type ) );
 181
 182     //2-th parameter in list
 183     paramList.push_back ( DOUBLE_PARAM (1.0,
 184                                      QObject::tr("SMESH_NB_SEGMENTS_SCALE_PARAM"),
 185                                      VALUE_SMALL, VALUE_MAX, 0.1, 6 ));
 186     SMESHGUI_tableParameter* tab = new SMESHGUI_tableParameter( 0.0, QObject::tr( "SMESH_TAB_FUNC" ), true );
 187     tab->setRowCount( 5 );
 188     tab->setColCount( 2 );
 189     //default size of table: 5x2
 190
 191     tab->setColName( 0, "t" );
 192     tab->setColName( 1, "f(t)" );
 193     tab->setValidator( 0, 0.0, 1.0, 3 );
 194     tab->setValidator( 1, 1E-7, 1E+300, 3 );
 195     tab->setEditRows( true );
 196
 197     //3-th parameter in list
 198     paramList.push_back ( SMESHGUI_aParameterPtr( tab ) );
 199
 200     //4-th parameter in list
 201     paramList.push_back ( STR_PARAM ( "", QObject::tr( "SMESH_EXPR_FUNC" ), true ) );
 202
 203     //5-th parameter in list
 204     paramList.push_back ( BOOL_PARAM ( false, QObject::tr( "SMESH_EXP_MODE" ), true ) );
 205   }
 206   else if (hypType.compare("Arithmetic1D") == 0)
 207   {
 208     paramList.push_back( DOUBLE_PARAM ( 1.0,
 209                                       QObject::tr("SMESH_START_LENGTH_PARAM"),
 210                                       VALUE_SMALL, VALUE_MAX, 1, 6));
 211     paramList.push_back( DOUBLE_PARAM ( 10.0,
 212                                        QObject::tr("SMESH_END_LENGTH_PARAM"),
 213                                        VALUE_SMALL, VALUE_MAX, 1, 6));
 214   }
 215   else if (hypType.compare("MaxElementArea") == 0)
 216   {
 217     paramList.push_back( DOUBLE_PARAM (1.0,
 218                                        QObject::tr("SMESH_MAX_ELEMENT_AREA_PARAM"),
 219                                        VALUE_SMALL_2, VALUE_MAX_2, 1.0, 6));
 220   }
 221   else if (hypType.compare("MaxElementVolume") == 0)
 222   {
 223     paramList.push_back( DOUBLE_PARAM ( 1.0,
 224                                        QObject::tr("SMESH_MAX_ELEMENT_VOLUME_PARAM"),
 225                                        VALUE_SMALL_3, VALUE_MAX_3, 1.0, 6));
 226   }
 227   else if (hypType.compare("StartEndLength") == 0)
 228   {
 229     paramList.push_back( DOUBLE_PARAM ( 1.0,
 230                                       QObject::tr("SMESH_START_LENGTH_PARAM"),
 231                                       VALUE_SMALL, VALUE_MAX, 1, 6));
 232     paramList.push_back( DOUBLE_PARAM ( 10.0,
 233                                        QObject::tr("SMESH_END_LENGTH_PARAM"),
 234                                        VALUE_SMALL, VALUE_MAX, 1, 6));
 235   }
 236   else if (hypType.compare("Deflection1D") == 0)
 237   {
 238     paramList.push_back( DOUBLE_PARAM ( 1.0,
 239                                        QObject::tr("SMESH_DEFLECTION1D_PARAM"),
 240                                        VALUE_SMALL, VALUE_MAX, 1, 6));
 241   }
 242 }
 243
 244 //=======================================================================
 245 //function : GetParameters
 246 //purpose  :
 247 //=======================================================================
 248
 249 void StdMeshersGUI_Parameters::GetParameters (SMESH::SMESH_Hypothesis_ptr    theHyp,
 250                                               list<SMESHGUI_aParameterPtr> & paramList )
 251 {
 252   paramList.clear();
 253
 254   if (theHyp->_is_nil()) return;
 255
 256   QString hypType = theHyp->GetName();
 257   GetParameters( hypType, paramList ); // get default parameters
 258   if ( paramList.empty() )
 259     return;
 260
 261   // set current values
 262   if (hypType.compare("LocalLength") == 0)
 263   {
 264     StdMeshers::StdMeshers_LocalLength_var LL =
 265       StdMeshers::StdMeshers_LocalLength::_narrow(theHyp);
 266     SetInitValue( paramList.front(), LL->GetLength() );
 267   }
 268   else if (hypType.compare("NumberOfSegments") == 0)
 269   {
 270     StdMeshers::StdMeshers_NumberOfSegments_var NOS =
 271       StdMeshers::StdMeshers_NumberOfSegments::_narrow(theHyp);
 272
 273     list<SMESHGUI_aParameterPtr>::iterator anIt = paramList.begin();
 274     SetInitValue( *anIt, (int) NOS->GetNumberOfSegments()); anIt++;
 275     int DType = (int) NOS->GetDistrType();
 276     SetInitValue( *anIt, DType ); anIt++;
 277
 278     if( DType==1 )
 279       SetInitValue( *anIt, NOS->GetScaleFactor());
 280     anIt++;
 281
 282     if( DType==2 )
 283     {
 284       SMESH::double_array* tab_func = NOS->GetTableFunction();
 285       SetInitValue( *anIt, *tab_func );
 286       delete tab_func;
 287     }
 288     anIt++;
 289
 290     if( DType==3 )
 291     {
 292       char* expr_func = NOS->GetExpressionFunction();
 293       SetInitValue( *anIt, expr_func );
 294       //delete expr_func;
 295     }
 296     anIt++;
 297
 298     if( DType==2 || DType==3 )
 299       SetInitValue( *anIt, (bool)NOS->IsExponentMode());
 300   }
 301   else if (hypType.compare("Arithmetic1D") == 0)
 302   {
 303     StdMeshers::StdMeshers_Arithmetic1D_var hyp =
 304       StdMeshers::StdMeshers_Arithmetic1D::_narrow(theHyp);
 305     SetInitValue( paramList.front(), hyp->GetLength( true )) ;
 306     SetInitValue( paramList.back(), hyp->GetLength( false )) ;
 307   }
 308   else if (hypType.compare("MaxElementArea") == 0)
 309   {
 310     StdMeshers::StdMeshers_MaxElementArea_var MEA =
 311       StdMeshers::StdMeshers_MaxElementArea::_narrow(theHyp);
 312     SetInitValue( paramList.front(), MEA->GetMaxElementArea() );
 313   }
 314   else if (hypType.compare("MaxElementVolume") == 0)
 315   {
 316     StdMeshers::StdMeshers_MaxElementVolume_var MEV =
 317       StdMeshers::StdMeshers_MaxElementVolume::_narrow(theHyp);
 318     SetInitValue( paramList.front(), MEV->GetMaxElementVolume() );
 319   }
 320   else if (hypType.compare("StartEndLength") == 0)
 321   {
 322     StdMeshers::StdMeshers_StartEndLength_var hyp =
 323       StdMeshers::StdMeshers_StartEndLength::_narrow(theHyp);
 324     SetInitValue( paramList.front(), hyp->GetLength( true ));
 325     SetInitValue( paramList.back(),  hyp->GetLength( false ));
 326   }
 327   else if (hypType.compare("Deflection1D") == 0)
 328   {
 329     StdMeshers::StdMeshers_Deflection1D_var hyp =
 330       StdMeshers::StdMeshers_Deflection1D::_narrow(theHyp);
 331     SetInitValue( paramList.back(),  hyp->GetDeflection()) ;
 332   }
 333 }
 334
 335 //=======================================================================
 336 //function : GetParameters
 337 //purpose  :
 338 //=======================================================================
 339 void StdMeshersGUI_Parameters::GetParameters (SMESH::SMESH_Hypothesis_ptr         hyp,
 340                                               list<SMESHGUI_aParameterPtr> &      paramList,
 341                                               QString&                            params)
 342 {
 343   params = "";
 344   list<SMESHGUI_aParameterPtr>::iterator paramIt = paramList.begin();
 345   for ( ; paramIt != paramList.end(); paramIt++) {
 346     if (params.compare("")) params += " ; ";
 347
 348     SMESHGUI_aParameter::Type t = (*paramIt)->GetType();
 349     if( t==SMESHGUI_aParameter::DOUBLE )
 350     {
 351       double aDoubleValue = 0.;
 352       (*paramIt)->GetNewDouble(aDoubleValue);
 353       params += QString::number(aDoubleValue);
 354     }
 355     else if( t==SMESHGUI_aParameter::STRING || t==SMESHGUI_aParameter::ENUM )
 356     {
 357       QString aStrValue( "" );
 358       (*paramIt)->GetNewText(aStrValue);
 359       params += aStrValue.simplifyWhiteSpace();
 360     }
 361     else if( t==SMESHGUI_aParameter::TABLE )
 362     {
 363       params += "TABLE";
 364     }
 365     else
 366     {
 367       int aIntValue = 0;
 368       (*paramIt)->GetNewInt(aIntValue);
 369       params += QString::number(aIntValue);
 370     }
 371   }
 372 }
 373
 374 //=======================================================================
 375 //function : SetParameters
 376 //purpose  :
 377 //=======================================================================
 378
 379 bool StdMeshersGUI_Parameters::SetParameters(SMESH::SMESH_Hypothesis_ptr          theHyp,
 380                                              const list<SMESHGUI_aParameterPtr> & paramList )
 381 {
 382   if (theHyp->_is_nil() || paramList.empty()) return false;
 383
 384   bool modified = false;
 385
 386   QString hypType = theHyp->GetName();
 387
 388   if (hypType.compare("LocalLength") == 0)
 389   {
 390     StdMeshers::StdMeshers_LocalLength_var LL =
 391       StdMeshers::StdMeshers_LocalLength::_narrow(theHyp);
 392     double length = LL->GetLength();
 393     modified = paramList.front()->GetNewDouble( length );
 394     LL->SetLength(length);
 395   }
 396   else if (hypType.compare("NumberOfSegments") == 0)
 397   {
 398     StdMeshers::StdMeshers_NumberOfSegments_var NOS =
 399       StdMeshers::StdMeshers_NumberOfSegments::_narrow(theHyp);
 400
 401     list<SMESHGUI_aParameterPtr>::const_iterator anIt = paramList.begin();
 402     int NbSeg, DType;
 403     double Scale;
 404     SMESH::double_array TabF;
 405     QString exprF;
 406     int expType;
 407
 408     modified = (*anIt)->GetNewInt( NbSeg ); anIt++;
 409     modified = (*anIt)->GetNewInt( DType ) || modified; anIt++;
 410     modified = (*anIt)->GetNewDouble( Scale ) || modified; anIt++;
 411     SMESHGUI_aParameterPtr p = *anIt;
 412     ((SMESHGUI_tableParameter*)p.get())->data( TabF ); anIt++; modified = true;
 413     modified = (*anIt)->GetNewText( exprF ) || modified; anIt++;
 414     modified = (*anIt)->GetNewInt( expType ) || modified;
 415
 416     NOS->SetNumberOfSegments( NbSeg );
 417     NOS->SetDistrType( DType );
 418     if( DType==1 )
 419       NOS->SetScaleFactor( Scale );
 420     if( DType==2 )
 421       NOS->SetTableFunction( TabF );
 422     if( DType==3 )
 423       NOS->SetExpressionFunction( CORBA::string_dup( exprF.latin1() ) );
 424     if( DType==2 || DType==3 )
 425       NOS->SetExponentMode( (bool)expType );
 426   }
 427   else if (hypType.compare("Arithmetic1D") == 0)
 428   {
 429     if ( paramList.size() != 2 )
 430       return false;
 431     StdMeshers::StdMeshers_Arithmetic1D_var hyp =
 432       StdMeshers::StdMeshers_Arithmetic1D::_narrow(theHyp);
 433     double begLength = hyp->GetLength( true ) ;
 434     double endLength = hyp->GetLength( false ) ;
 435     modified = paramList.front()->GetNewDouble( begLength );
 436     modified = paramList.back()->GetNewDouble( endLength ) || modified;
 437     hyp->SetLength( begLength, true );
 438     hyp->SetLength( endLength, false );
 439   }
 440   else if (hypType.compare("MaxElementArea") == 0)
 441   {
 442     StdMeshers::StdMeshers_MaxElementArea_var MEA =
 443       StdMeshers::StdMeshers_MaxElementArea::_narrow(theHyp);
 444     double MaxArea = MEA->GetMaxElementArea();
 445     modified = paramList.front()->GetNewDouble( MaxArea );
 446     MEA->SetMaxElementArea(MaxArea);
 447   }
 448   else if (hypType.compare("MaxElementVolume") == 0)
 449   {
 450     StdMeshers::StdMeshers_MaxElementVolume_var MEV =
 451       StdMeshers::StdMeshers_MaxElementVolume::_narrow(theHyp);
 452     double MaxVolume = MEV->GetMaxElementVolume() ;
 453     modified = paramList.front()->GetNewDouble( MaxVolume );
 454     MEV->SetMaxElementVolume(MaxVolume);
 455   }
 456   else if (hypType.compare("StartEndLength") == 0)
 457   {
 458     if ( paramList.size() != 2 )
 459       return false;
 460     StdMeshers::StdMeshers_StartEndLength_var hyp =
 461       StdMeshers::StdMeshers_StartEndLength::_narrow(theHyp);
 462     double begLength = hyp->GetLength( true ) ;
 463     double endLength = hyp->GetLength( false ) ;
 464     modified = paramList.front()->GetNewDouble( begLength );
 465     modified = paramList.back()->GetNewDouble( endLength ) || modified;
 466     hyp->SetLength( begLength, true );
 467     hyp->SetLength( endLength, false );
 468   }
 469   else if (hypType.compare("Deflection1D") == 0)
 470   {
 471     StdMeshers::StdMeshers_Deflection1D_var hyp =
 472       StdMeshers::StdMeshers_Deflection1D::_narrow(theHyp);
 473     double value = hyp->GetDeflection() ;
 474     modified = paramList.front()->GetNewDouble( value );
 475     hyp->SetDeflection( value );
 476   }
 477   return modified ;
 478 }
 479