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 ) p->InitValue() = initValue;
  69 }
  70
  71 //=======================================================================
  72 //function : SetInitValue
  73 //purpose  :
  74 //=======================================================================
  75
  76 void StdMeshersGUI_Parameters::SetInitValue(SMESHGUI_aParameterPtr param,
  77                                             double                 initValue)
  78 {
  79   SMESHGUI_doubleParameter* p = dynamic_cast<SMESHGUI_doubleParameter*>(param.get());
  80   if ( p ) p->InitValue() = initValue;
  81 }
  82
  83 //=======================================================================
  84 //function : SetInitValue
  85 //purpose  :
  86 //=======================================================================
  87
  88 void StdMeshersGUI_Parameters::SetInitValue(SMESHGUI_aParameterPtr param,
  89                                             const char*            initValue)
  90 {
  91   SMESHGUI_strParameter* p = dynamic_cast<SMESHGUI_strParameter*>(param.get());
  92   if ( p ) p->InitValue() = initValue;
  93 }
  94
  95 //=======================================================================
  96 //function : GetParameters
  97 //purpose  :
  98 //=======================================================================
  99
 100 // SMESHGUI_doubleParameter( initValue, label, bottom, top, step, decimals )
 101 #define DOUBLE_PARAM(v,l,b,t,s,d) SMESHGUI_aParameterPtr(new SMESHGUI_doubleParameter(v,l,b,t,s,d))
 102 #define INT_PARAM(v,l,b,t) SMESHGUI_aParameterPtr(new SMESHGUI_intParameter(v,l,b,t))
 103
 104 void StdMeshersGUI_Parameters::GetParameters (const QString&                 hypType,
 105                                               list<SMESHGUI_aParameterPtr> & paramList )
 106 {
 107   paramList.clear();
 108
 109   if (hypType.compare("LocalLength") == 0)
 110   {
 111     paramList.push_back( DOUBLE_PARAM (1.0,
 112                                        QObject::tr("SMESH_LOCAL_LENGTH_PARAM"),
 113                                        VALUE_SMALL, VALUE_MAX, 1.0, 6));
 114   }
 115   else if (hypType.compare("NumberOfSegments") == 0)
 116   {
 117     paramList.push_back ( INT_PARAM (3,
 118                                      QObject::tr("SMESH_NB_SEGMENTS_PARAM"),
 119                                      1, 9999 ));
 120     paramList.push_back ( DOUBLE_PARAM (1.0,
 121                                      QObject::tr("SMESH_NB_SEGMENTS_SCALE_PARAM"),
 122                                      VALUE_SMALL, VALUE_MAX, 0.1, 6 ));
 123   }
 124   else if (hypType.compare("Arithmetic1D") == 0)
 125   {
 126     paramList.push_back( DOUBLE_PARAM ( 1.0,
 127                                       QObject::tr("SMESH_START_LENGTH_PARAM"),
 128                                       VALUE_SMALL, VALUE_MAX, 1, 6));
 129     paramList.push_back( DOUBLE_PARAM ( 10.0,
 130                                        QObject::tr("SMESH_END_LENGTH_PARAM"),
 131                                        VALUE_SMALL, VALUE_MAX, 1, 6));
 132   }
 133   else if (hypType.compare("MaxElementArea") == 0)
 134   {
 135     paramList.push_back( DOUBLE_PARAM (1.0,
 136                                        QObject::tr("SMESH_MAX_ELEMENT_AREA_PARAM"),
 137                                        VALUE_SMALL_2, VALUE_MAX_2, 1.0, 6));
 138   }
 139   else if (hypType.compare("MaxElementVolume") == 0)
 140   {
 141     paramList.push_back( DOUBLE_PARAM ( 1.0,
 142                                        QObject::tr("SMESH_MAX_ELEMENT_VOLUME_PARAM"),
 143                                        VALUE_SMALL_3, VALUE_MAX_3, 1.0, 6));
 144   }
 145   else if (hypType.compare("StartEndLength") == 0)
 146   {
 147     paramList.push_back( DOUBLE_PARAM ( 1.0,
 148                                       QObject::tr("SMESH_START_LENGTH_PARAM"),
 149                                       VALUE_SMALL, VALUE_MAX, 1, 6));
 150     paramList.push_back( DOUBLE_PARAM ( 10.0,
 151                                        QObject::tr("SMESH_END_LENGTH_PARAM"),
 152                                        VALUE_SMALL, VALUE_MAX, 1, 6));
 153   }
 154   else if (hypType.compare("Deflection1D") == 0)
 155   {
 156     paramList.push_back( DOUBLE_PARAM ( 1.0,
 157                                        QObject::tr("SMESH_DEFLECTION1D_PARAM"),
 158                                        VALUE_SMALL, VALUE_MAX, 1, 6));
 159   }
 160 }
 161
 162 //=======================================================================
 163 //function : GetParameters
 164 //purpose  :
 165 //=======================================================================
 166
 167 void StdMeshersGUI_Parameters::GetParameters (SMESH::SMESH_Hypothesis_ptr    theHyp,
 168                                               list<SMESHGUI_aParameterPtr> & paramList )
 169 {
 170   paramList.clear();
 171
 172   if (theHyp->_is_nil()) return;
 173
 174   QString hypType = theHyp->GetName();
 175   GetParameters( hypType, paramList ); // get default parameters
 176   if ( paramList.empty() )
 177     return;
 178
 179   // set current values
 180   if (hypType.compare("LocalLength") == 0)
 181   {
 182     StdMeshers::StdMeshers_LocalLength_var LL =
 183       StdMeshers::StdMeshers_LocalLength::_narrow(theHyp);
 184     SetInitValue( paramList.front(), LL->GetLength() );
 185   }
 186   else if (hypType.compare("NumberOfSegments") == 0)
 187   {
 188     StdMeshers::StdMeshers_NumberOfSegments_var NOS =
 189       StdMeshers::StdMeshers_NumberOfSegments::_narrow(theHyp);
 190     SetInitValue( paramList.front(), (int) NOS->GetNumberOfSegments());
 191     SetInitValue( paramList.back(), NOS->GetScaleFactor());
 192   }
 193   else if (hypType.compare("Arithmetic1D") == 0)
 194   {
 195     StdMeshers::StdMeshers_Arithmetic1D_var hyp =
 196       StdMeshers::StdMeshers_Arithmetic1D::_narrow(theHyp);
 197     SetInitValue( paramList.front(), hyp->GetLength( true )) ;
 198     SetInitValue( paramList.back(), hyp->GetLength( false )) ;
 199   }
 200   else if (hypType.compare("MaxElementArea") == 0)
 201   {
 202     StdMeshers::StdMeshers_MaxElementArea_var MEA =
 203       StdMeshers::StdMeshers_MaxElementArea::_narrow(theHyp);
 204     SetInitValue( paramList.front(), MEA->GetMaxElementArea() );
 205   }
 206   else if (hypType.compare("MaxElementVolume") == 0)
 207   {
 208     StdMeshers::StdMeshers_MaxElementVolume_var MEV =
 209       StdMeshers::StdMeshers_MaxElementVolume::_narrow(theHyp);
 210     SetInitValue( paramList.front(), MEV->GetMaxElementVolume() );
 211   }
 212   else if (hypType.compare("StartEndLength") == 0)
 213   {
 214     StdMeshers::StdMeshers_StartEndLength_var hyp =
 215       StdMeshers::StdMeshers_StartEndLength::_narrow(theHyp);
 216     SetInitValue( paramList.front(), hyp->GetLength( true ));
 217     SetInitValue( paramList.back(),  hyp->GetLength( false ));
 218   }
 219   else if (hypType.compare("Deflection1D") == 0)
 220   {
 221     StdMeshers::StdMeshers_Deflection1D_var hyp =
 222       StdMeshers::StdMeshers_Deflection1D::_narrow(theHyp);
 223     SetInitValue( paramList.back(),  hyp->GetDeflection()) ;
 224   }
 225 }
 226
 227 //=======================================================================
 228 //function : GetParameters
 229 //purpose  :
 230 //=======================================================================
 231 void StdMeshersGUI_Parameters::GetParameters (SMESH::SMESH_Hypothesis_ptr         hyp,
 232                                               list<SMESHGUI_aParameterPtr> &      paramList,
 233                                               QString&                            params)
 234 {
 235   params = "";
 236   list<SMESHGUI_aParameterPtr>::iterator paramIt = paramList.begin();
 237   for ( ; paramIt != paramList.end(); paramIt++) {
 238     if (params.compare("")) params += " ; ";
 239
 240     if ((*paramIt)->GetType() == SMESHGUI_aParameter::DOUBLE ) {
 241       double aDoubleValue = 0.;
 242       (*paramIt)->GetNewDouble(aDoubleValue);
 243       params += QString::number(aDoubleValue);
 244     }
 245     else if ((*paramIt)->GetType() == SMESHGUI_aParameter::TEXT ) {
 246       QString aStrValue( "" );
 247       (*paramIt)->GetNewText(aStrValue);
 248       params += aStrValue.simplifyWhiteSpace();
 249     }
 250     else {
 251       int aIntValue = 0;
 252       (*paramIt)->GetNewInt(aIntValue);
 253       params += QString::number(aIntValue);
 254     }
 255   }
 256 }
 257
 258 //=======================================================================
 259 //function : SetParameters
 260 //purpose  :
 261 //=======================================================================
 262
 263 bool StdMeshersGUI_Parameters::SetParameters(SMESH::SMESH_Hypothesis_ptr          theHyp,
 264                                              const list<SMESHGUI_aParameterPtr> & paramList )
 265 {
 266   if (theHyp->_is_nil() || paramList.empty()) return false;
 267
 268   bool modified = false;
 269
 270   QString hypType = theHyp->GetName();
 271
 272   if (hypType.compare("LocalLength") == 0)
 273   {
 274     StdMeshers::StdMeshers_LocalLength_var LL =
 275       StdMeshers::StdMeshers_LocalLength::_narrow(theHyp);
 276     double length = LL->GetLength();
 277     modified = paramList.front()->GetNewDouble( length );
 278     LL->SetLength(length);
 279   }
 280   else if (hypType.compare("NumberOfSegments") == 0)
 281   {
 282     StdMeshers::StdMeshers_NumberOfSegments_var NOS =
 283       StdMeshers::StdMeshers_NumberOfSegments::_narrow(theHyp);
 284     int NbSeg = NOS->GetNumberOfSegments();
 285     double Scale = NOS->GetScaleFactor() ;
 286     modified = paramList.front()->GetNewInt( NbSeg );
 287     modified = paramList.back()->GetNewDouble( Scale ) || modified;
 288     NOS->SetNumberOfSegments(NbSeg);
 289     NOS->SetScaleFactor( Scale );
 290   }
 291   else if (hypType.compare("Arithmetic1D") == 0)
 292   {
 293     if ( paramList.size() != 2 )
 294       return false;
 295     StdMeshers::StdMeshers_Arithmetic1D_var hyp =
 296       StdMeshers::StdMeshers_Arithmetic1D::_narrow(theHyp);
 297     double begLength = hyp->GetLength( true ) ;
 298     double endLength = hyp->GetLength( false ) ;
 299     modified = paramList.front()->GetNewDouble( begLength );
 300     modified = paramList.back()->GetNewDouble( endLength ) || modified;
 301     hyp->SetLength( begLength, true );
 302     hyp->SetLength( endLength, false );
 303   }
 304   else if (hypType.compare("MaxElementArea") == 0)
 305   {
 306     StdMeshers::StdMeshers_MaxElementArea_var MEA =
 307       StdMeshers::StdMeshers_MaxElementArea::_narrow(theHyp);
 308     double MaxArea = MEA->GetMaxElementArea();
 309     modified = paramList.front()->GetNewDouble( MaxArea );
 310     MEA->SetMaxElementArea(MaxArea);
 311   }
 312   else if (hypType.compare("MaxElementVolume") == 0)
 313   {
 314     StdMeshers::StdMeshers_MaxElementVolume_var MEV =
 315       StdMeshers::StdMeshers_MaxElementVolume::_narrow(theHyp);
 316     double MaxVolume = MEV->GetMaxElementVolume() ;
 317     modified = paramList.front()->GetNewDouble( MaxVolume );
 318     MEV->SetMaxElementVolume(MaxVolume);
 319   }
 320   else if (hypType.compare("StartEndLength") == 0)
 321   {
 322     if ( paramList.size() != 2 )
 323       return false;
 324     StdMeshers::StdMeshers_StartEndLength_var hyp =
 325       StdMeshers::StdMeshers_StartEndLength::_narrow(theHyp);
 326     double begLength = hyp->GetLength( true ) ;
 327     double endLength = hyp->GetLength( false ) ;
 328     modified = paramList.front()->GetNewDouble( begLength );
 329     modified = paramList.back()->GetNewDouble( endLength ) || modified;
 330     hyp->SetLength( begLength, true );
 331     hyp->SetLength( endLength, false );
 332   }
 333   else if (hypType.compare("Deflection1D") == 0)
 334   {
 335     StdMeshers::StdMeshers_Deflection1D_var hyp =
 336       StdMeshers::StdMeshers_Deflection1D::_narrow(theHyp);
 337     double value = hyp->GetDeflection() ;
 338     modified = paramList.front()->GetNewDouble( value );
 339     hyp->SetDeflection( value );
 340   }
 341   return modified ;
 342 }
 343