src/HOMARDGUI/MonCreateBoundaryAn.cxx

   1 // Copyright (C) 2011-2013  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 using namespace std;
  21
  22 #include "MonCreateBoundaryAn.h"
  23 #include "MonCreateCase.h"
  24
  25 #include <QFileDialog>
  26 #include <QMessageBox>
  27
  28 #include "SalomeApp_Tools.h"
  29 #include "HOMARDGUI_Utils.h"
  30 #include "HomardQtCommun.h"
  31 #include <utilities.h>
  32
  33 #include <SUIT_Desktop.h>
  34 #include <SUIT_MessageBox.h>
  35 #include <SUIT_ResourceMgr.h>
  36 #include <SUIT_Session.h>
  37 #include <SUIT_ViewManager.h>
  38
  39 #include "math.h"
  40 #define PI 3.141592653589793
  41 // ------------------------------------------------------------------------------------------------------------------------
  42 MonCreateBoundaryAn::MonCreateBoundaryAn(MonCreateCase* parent, bool modal,
  43                              HOMARD::HOMARD_Gen_var myHomardGen,
  44                              QString caseName) :
  45 // ------------------------------------------------------------------------------------------------------------------------------
  46 /* Constructs a MonCreateBoundaryAn
  47    appele pour une vraie creation
  48    initialise un cylindre et non une sphere
  49 */
  50     QDialog(0), Ui_CreateBoundaryAn(),
  51     _parent(parent),
  52     _aName (""),
  53     _aCaseName(caseName),
  54     _Xmin(0), _Xmax(0), _Xincr(0), _Ymin(0), _Ymax(0), _Yincr(0), _Zmin(0), _Zmax(0), _Zincr(0), _DMax(0),
  55     _Type(1),
  56     _BoundaryAnXcentre(0), _BoundaryAnYcentre(0), _BoundaryAnZcentre(0), _BoundaryAnRayon(0),
  57     _BoundaryAnXaxis(0), _BoundaryAnYaxis(0), _BoundaryAnZaxis(0),
  58     _Xcentre(0), _Ycentre(0), _Zcentre(0), _Rayon(0),
  59     _BoundaryAnXcone1(0), _BoundaryAnYcone1(0), _BoundaryAnZcone1(0), _BoundaryAnRayon1(0),
  60     _BoundaryAnXcone2(0), _BoundaryAnYcone2(0), _BoundaryAnZcone2(0), _BoundaryAnRayon2(0),
  61     _BoundaryAnXaxisCone(0), _BoundaryAnYaxisCone(0), _BoundaryAnZaxisCone(0),
  62     _BoundaryAngle(0),
  63     Chgt (false)
  64     {
  65       MESSAGE("Constructeur") ;
  66       _myHomardGen=HOMARD::HOMARD_Gen::_duplicate(myHomardGen);
  67       setupUi(this);
  68       setModal(modal);
  69
  70     //  Gestion des icones
  71       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
  72       QPixmap pix = resMgr->loadPixmap( "HOMARD", "spherepoint.png" );
  73       QIcon IS=QIcon(pix);
  74       RBSphere->setIcon(IS);
  75       QPixmap pix2 = resMgr->loadPixmap( "HOMARD", "cylinderpointvector.png" );
  76       QIcon IS2=QIcon(pix2);
  77       RBCylindre->setIcon(IS2);
  78       QPixmap pix3 = resMgr->loadPixmap( "HOMARD", "cone.png" );
  79       QIcon IS3=QIcon(pix3);
  80       RBCone->setIcon(IS3);
  81       QPixmap pix4 = resMgr->loadPixmap( "HOMARD", "conepointvector.png" );
  82       QIcon IS4=QIcon(pix4);
  83       RB_Def_angle->setIcon(IS4);
  84       QPixmap pix5 = resMgr->loadPixmap( "HOMARD", "conedxyz.png" );
  85       QIcon IS5=QIcon(pix5);
  86       RB_Def_radius->setIcon(IS5);
  87
  88       InitConnect( );
  89
  90       SetNewBoundaryAnName() ;
  91       InitValBoundaryAn();          // Cherche les valeurs de la boite englobante le maillage
  92       InitMinMax();                 // Initialise les bornes des boutons
  93       SetCylinder();                // Propose un cylindre en premier choix
  94     }
  95 // --------------------------------------------------------------------------------------------------------------
  96 MonCreateBoundaryAn::MonCreateBoundaryAn(MonCreateCase* parent,
  97                              HOMARD::HOMARD_Gen_var myHomardGen,
  98                              QString caseName):
  99 // --------------------------------------------------------------------------------------------------------------
 100 // Constructeur appele par MonEditBoundaryAn
 101 //
 102     QDialog(0), Ui_CreateBoundaryAn(),
 103      _myHomardGen(myHomardGen),
 104     _parent(parent),
 105     _aName (""),
 106     _aCaseName(caseName),
 107     _Type(1),
 108     _BoundaryAnXcentre(0), _BoundaryAnYcentre(0), _BoundaryAnZcentre(0), _BoundaryAnRayon(0),
 109     _BoundaryAnXaxis(0), _BoundaryAnYaxis(0), _BoundaryAnZaxis(0),
 110     // Pour affichage lors de l edition d une BoundaryAn sans nom de Cas
 111     _Xcentre(0), _Ycentre(0), _Zcentre(0), _Rayon(0),
 112     _Xmin(1), _Xmax(1), _Xincr(1), _Ymin(1), _Ymax(1), _Yincr(1), _Zmin(1), _Zmax(1), _Zincr(1), _DMax(1),
 113     Chgt (false)
 114     {
 115   //  MESSAGE("Debut de  MonCreateBoundaryAn")
 116       setupUi(this);
 117       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 118       QPixmap pix = resMgr->loadPixmap( "HOMARD", "spherepoint.png" );
 119       QIcon IS=QIcon(pix);
 120       RBSphere->setIcon(IS);
 121       QPixmap pix2 = resMgr->loadPixmap( "HOMARD", "cylinderpointvector.png" );
 122       QIcon IS2=QIcon(pix2);
 123       RBCylindre->setIcon(IS2);
 124       QPixmap pix3 = resMgr->loadPixmap( "HOMARD", "cone.png" );
 125       QIcon IS3=QIcon(pix3);
 126       RBCone->setIcon(IS3);
 127       QPixmap pix4 = resMgr->loadPixmap( "HOMARD", "conepointvector.png" );
 128       QIcon IS4=QIcon(pix4);
 129       RB_Def_angle->setIcon(IS4);
 130       QPixmap pix5 = resMgr->loadPixmap( "HOMARD", "conedxyz.png" );
 131       QIcon IS5=QIcon(pix5);
 132       RB_Def_radius->setIcon(IS5);
 133       setModal(true);
 134       InitConnect();
 135     }
 136
 137 // ------------------------------------------------------------------------
 138 MonCreateBoundaryAn::~MonCreateBoundaryAn()
 139 // ------------------------------------------------------------------------
 140 {
 141     // no need to delete child widgets, Qt does it all for us
 142 }
 143 // ------------------------------------------------------------------------
 144 void MonCreateBoundaryAn::InitConnect()
 145 // ------------------------------------------------------------------------
 146 {
 147     connect( RBCylindre,    SIGNAL(clicked()) , this, SLOT(SetCylinder()) ) ;
 148     connect( RBSphere,      SIGNAL(clicked()) , this, SLOT(SetSphere()) ) ;
 149     connect( RBCone,        SIGNAL(clicked()) , this, SLOT(SetCone()) ) ;
 150     connect( RB_Def_radius, SIGNAL(clicked()) , this, SLOT(SetConeR()) );
 151     connect( RB_Def_angle,  SIGNAL(clicked()) , this, SLOT(SetConeA()) );
 152     connect( buttonOk,     SIGNAL( pressed() ), this, SLOT( PushOnOK() ) );
 153     connect( buttonApply,  SIGNAL( pressed() ), this, SLOT( PushOnApply() ) );
 154     connect( buttonCancel, SIGNAL( pressed() ), this, SLOT( close() ) );
 155     connect( buttonHelp,   SIGNAL( pressed() ), this, SLOT( PushOnHelp() ) );
 156 }
 157 // ------------------------------------------------------------------------
 158 void MonCreateBoundaryAn::InitValBoundaryAn()
 159 // ------------------------------------------------------------------------
 160 {
 161 //
 162 //  1. Les coordonnees extremes du maillage
 163 //
 164     if (_aCaseName == QString("")) { return; }
 165
 166     HOMARD::HOMARD_Cas_var aCas = _myHomardGen->GetCase(_aCaseName.toStdString().c_str());
 167     HOMARD::extrema_var  MesExtremes = aCas->GetBoundingBox();
 168     int num = MesExtremes->length() ;
 169     ASSERT(num == 10);
 170     _Xmin=MesExtremes[0]; _Xmax=MesExtremes[1]; _Xincr=MesExtremes[2];
 171     _Ymin=MesExtremes[3]; _Ymax=MesExtremes[4]; _Yincr=MesExtremes[5];
 172     _Zmin=MesExtremes[6]; _Zmax=MesExtremes[7]; _Zincr=MesExtremes[8];
 173     _DMax=MesExtremes[9];
 174      MESSAGE ("_Xmin : " << _Xmin << " _Xmax : " << _Xmax << " _Xincr : " << _Xincr ) ;
 175      MESSAGE ("_Ymin : " << _Ymin << " _Ymax : " << _Ymax << " _Yincr : " << _Yincr ) ;
 176      MESSAGE ("_Zmin : " << _Zmin << " _Zmax : " << _Zmax << " _Zincr : " << _Zincr) ;
 177      MESSAGE ("_DMax : " << _DMax);
 178
 179 //  2. Caracteristiques des frontieres
 180 // en X
 181     _Xcentre=(_Xmin + _Xmax)/2.;
 182 // en Y
 183     _Ycentre=(_Ymin + _Ymax)/2.;
 184 // en Z
 185     _Zcentre=(_Zmin + _Zmax)/2.;
 186 // Rayon
 187     _Rayon= _DMax/4.;
 188 }
 189
 190 // ------------------------------------------------------------------------
 191 void MonCreateBoundaryAn::InitMinMax()
 192 // ------------------------------------------------------------------------
 193 {
 194   // Cylindre
 195   // . X du centre
 196   SpinBox_Xcent->setValue(_Xcentre);
 197   SpinBox_Xcent->setSingleStep(_Xincr);
 198   // . Y du centre
 199   SpinBox_Ycent->setValue(_Ycentre);
 200   SpinBox_Ycent->setSingleStep(_Yincr);
 201   // . Z du centre
 202   SpinBox_Zcent->setValue(_Zcentre);
 203   SpinBox_Zcent->setSingleStep(_Zincr);
 204   // . X de l'axe
 205   SpinBox_Xaxis->setValue(0.);
 206   SpinBox_Xaxis->setSingleStep(0.1);
 207   // . Y de l'axe
 208   SpinBox_Yaxis->setValue(0.);
 209   SpinBox_Yaxis->setSingleStep(0.1);
 210   // . Z de l'axe
 211   SpinBox_Zaxis->setValue(1.);
 212   SpinBox_Zaxis->setSingleStep(0.1);
 213   // . Rayon
 214   SpinBox_Radius->setValue(_Rayon);
 215   SpinBox_Radius->setSingleStep(_Rayon/10.);
 216   SpinBox_Radius->setMinimum(0.);
 217
 218   // Sphere
 219   // . X du centre
 220   SpinBox_Xcentre->setValue(_Xcentre);
 221   SpinBox_Xcentre->setSingleStep(_Xincr);
 222   // . Y du centre
 223   SpinBox_Ycentre->setValue(_Ycentre);
 224   SpinBox_Ycentre->setSingleStep(_Yincr);
 225   // . Z du centre
 226   SpinBox_Zcentre->setValue(_Zcentre);
 227   SpinBox_Zcentre->setSingleStep(_Zincr);
 228   // . Rayon
 229   SpinBox_Rayon->setValue(_Rayon);
 230   SpinBox_Rayon->setSingleStep(_Rayon/10.);
 231   SpinBox_Rayon->setMinimum(0.);
 232
 233   // Cone en rayons
 234   // . X des centres
 235   _BoundaryAnXcone1 = _Xcentre ;
 236   SpinBox_Cone_X1->setSingleStep(_Xincr);
 237   _BoundaryAnXcone2 = _Xcentre ;
 238   SpinBox_Cone_X2->setSingleStep(_Xincr);
 239   // . Y des centres
 240   _BoundaryAnYcone1 = _Ycentre ;
 241   SpinBox_Cone_Y1->setSingleStep(_Yincr);
 242   _BoundaryAnYcone2 = _Ycentre ;
 243   SpinBox_Cone_Y2->setSingleStep(_Yincr);
 244   // . Z des centres
 245   _BoundaryAnZcone1 = _Zmin ;
 246   SpinBox_Cone_Z1->setSingleStep(_Zincr);
 247   _BoundaryAnZcone2 = _Zmax ;
 248   SpinBox_Cone_Z2->setSingleStep(_Zincr);
 249   // . Rayons/Angles
 250   _BoundaryAnRayon1 = 0. ;
 251   SpinBox_Cone_V1->setMinimum(0.);
 252   _BoundaryAnRayon2 = _Rayon ;
 253   SpinBox_Cone_V2->setSingleStep(_Rayon/10.);
 254   SpinBox_Cone_V2->setMinimum(0.);
 255
 256   // Cone en angle
 257   convertRayonAngle(1) ;
 258   SpinBox_Cone_X1->setValue(_BoundaryAnXaxisCone);
 259   SpinBox_Cone_Y1->setValue(_BoundaryAnYaxisCone);
 260   SpinBox_Cone_Z1->setValue(_BoundaryAnZaxisCone);
 261   SpinBox_Cone_V1->setValue(_BoundaryAngle);
 262   SpinBox_Cone_X2->setValue(_BoundaryAnXorigCone);
 263   SpinBox_Cone_Y2->setValue(_BoundaryAnYorigCone);
 264   SpinBox_Cone_Z2->setValue(_BoundaryAnZorigCone);
 265 }
 266 // ------------------------------------------------------------------------
 267 bool MonCreateBoundaryAn::PushOnApply()
 268 // ------------------------------------------------------------------------
 269 // Appele lorsque l'un des boutons Ok ou Apply est presse
 270 //
 271 {
 272   std::cerr << LEBoundaryName->text().trimmed().toStdString() << std::endl;
 273   if (LEBoundaryName->text().trimmed()=="")
 274   {
 275     QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 276                               QObject::tr("HOM_BOUN_NAME") );
 277     return false;
 278   }
 279
 280   switch (_Type)
 281   {
 282       case 1 : // il s agit d un cylindre
 283       {
 284         if ((_BoundaryAnXcentre != SpinBox_Xcent->value())  or
 285             (_BoundaryAnYcentre != SpinBox_Ycent->value())  or
 286             (_BoundaryAnZcentre != SpinBox_Zcent->value())  or
 287             (_BoundaryAnRayon   != SpinBox_Radius->value()) or
 288             (_BoundaryAnXaxis   != SpinBox_Xaxis->value()) or
 289             (_BoundaryAnYaxis   != SpinBox_Yaxis->value()) or
 290             (_BoundaryAnZaxis   != SpinBox_Zaxis->value()) )
 291         {
 292           Chgt = true;
 293           _BoundaryAnXaxis= SpinBox_Xaxis->value();
 294           _BoundaryAnYaxis= SpinBox_Yaxis->value();
 295           _BoundaryAnZaxis= SpinBox_Zaxis->value();
 296           _BoundaryAnXcentre=SpinBox_Xcent->value();
 297           _BoundaryAnYcentre=SpinBox_Ycent->value();
 298           _BoundaryAnZcentre=SpinBox_Zcent->value();
 299           _BoundaryAnRayon=SpinBox_Radius->value();
 300         }
 301         break;
 302       }
 303
 304       case 2 : // il s agit d une sphere
 305       {
 306         if ((_BoundaryAnXcentre != SpinBox_Xcentre->value()) or
 307             (_BoundaryAnYcentre != SpinBox_Ycentre->value()) or
 308             (_BoundaryAnZcentre != SpinBox_Zcentre->value()) or
 309             (_BoundaryAnRayon   != SpinBox_Rayon->value())  )
 310         {
 311            Chgt = true;
 312           _BoundaryAnXcentre=SpinBox_Xcentre->value();
 313           _BoundaryAnYcentre=SpinBox_Ycentre->value();
 314           _BoundaryAnZcentre=SpinBox_Zcentre->value();
 315           _BoundaryAnRayon=SpinBox_Rayon->value();
 316         }
 317         break;
 318       }
 319
 320       case 3 : // il s agit d un cone defini par un axe et un angle
 321       {
 322         if ((_BoundaryAnXaxisCone != SpinBox_Cone_X1->value())  or
 323             (_BoundaryAnYaxisCone != SpinBox_Cone_Y1->value())  or
 324             (_BoundaryAnZaxisCone != SpinBox_Cone_Z1->value())  or
 325             (_BoundaryAnXorigCone != SpinBox_Cone_X2->value())  or
 326             (_BoundaryAnYorigCone != SpinBox_Cone_Y2->value())  or
 327             (_BoundaryAnZorigCone != SpinBox_Cone_Z2->value())  or
 328             (_BoundaryAngle       != SpinBox_Cone_V1->value()) )
 329         {
 330            Chgt = true;
 331           _BoundaryAnXaxisCone = SpinBox_Cone_X1->value() ;
 332           _BoundaryAnYaxisCone = SpinBox_Cone_Y1->value() ;
 333           _BoundaryAnZaxisCone = SpinBox_Cone_Z1->value() ;
 334           _BoundaryAnXorigCone = SpinBox_Cone_X2->value() ;
 335           _BoundaryAnYorigCone = SpinBox_Cone_Y2->value() ;
 336           _BoundaryAnZorigCone = SpinBox_Cone_Z2->value() ;
 337           _BoundaryAngle       = SpinBox_Cone_V1->value() ;
 338         }
 339         break;
 340       }
 341
 342       case 4 : // il s agit d un cone defini par les 2 rayons
 343       {
 344         if ((_BoundaryAnXcone1 != SpinBox_Cone_X1->value())  or
 345             (_BoundaryAnYcone1 != SpinBox_Cone_Y1->value())  or
 346             (_BoundaryAnZcone1 != SpinBox_Cone_Z1->value())  or
 347             (_BoundaryAnRayon1 != SpinBox_Cone_V1->value())  or
 348             (_BoundaryAnXcone2 != SpinBox_Cone_X2->value())  or
 349             (_BoundaryAnYcone2 != SpinBox_Cone_Y2->value())  or
 350             (_BoundaryAnZcone2 != SpinBox_Cone_Z2->value())  or
 351             (_BoundaryAnRayon2 != SpinBox_Cone_V2->value()) )
 352         {
 353            Chgt = true;
 354           _BoundaryAnXcone1 = SpinBox_Cone_X1->value() ;
 355           _BoundaryAnYcone1 = SpinBox_Cone_Y1->value() ;
 356           _BoundaryAnZcone1 = SpinBox_Cone_Z1->value() ;
 357           _BoundaryAnRayon1 = SpinBox_Cone_V1->value() ;
 358           _BoundaryAnXcone2 = SpinBox_Cone_X2->value() ;
 359           _BoundaryAnYcone2 = SpinBox_Cone_Y2->value() ;
 360           _BoundaryAnZcone2 = SpinBox_Cone_Z2->value() ;
 361           _BoundaryAnRayon2 = SpinBox_Cone_V2->value() ;
 362         }
 363         break;
 364       }
 365  }
 366
 367   bool bOK = CreateOrUpdateBoundaryAn();
 368
 369   if ( bOK ) { HOMARD_UTILS::updateObjBrowser() ; }
 370
 371   return bOK;
 372
 373 }
 374 // ---------------------------------------------------
 375 bool MonCreateBoundaryAn:: CreateOrUpdateBoundaryAn()
 376 //----------------------------------------------------
 377 //  Creation de l'objet boundary
 378 {
 379   _aName = LEBoundaryName->text().trimmed();
 380   switch (_Type)
 381   {
 382     case 1 : // il s agit d un cylindre
 383     {
 384       try
 385       {
 386         aBoundaryAn = _myHomardGen->CreateBoundaryCylinder(CORBA::string_dup(_aName.toStdString().c_str()), \
 387         _BoundaryAnXcentre, _BoundaryAnYcentre, _BoundaryAnZcentre, _BoundaryAnXaxis, _BoundaryAnYaxis, _BoundaryAnZaxis, _BoundaryAnRayon );
 388       }
 389       catch( SALOME::SALOME_Exception& S_ex )
 390       {
 391         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 392                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 393         return false ;
 394       }
 395       break;
 396     }
 397     case 2 : // il s agit d une sphere
 398     {
 399       try
 400       {
 401         aBoundaryAn = _myHomardGen->CreateBoundarySphere(CORBA::string_dup(_aName.toStdString().c_str()), \
 402         _BoundaryAnXcentre, _BoundaryAnYcentre, _BoundaryAnZcentre, _BoundaryAnRayon);
 403       }
 404       catch( SALOME::SALOME_Exception& S_ex )
 405       {
 406         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 407                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 408         return false ;
 409       }
 410       break;
 411     }
 412     case 3 : // il s agit d un cone defini par un axe et un angle
 413     {
 414       try
 415       {
 416         aBoundaryAn = _myHomardGen->CreateBoundaryConeA(CORBA::string_dup(_aName.toStdString().c_str()), \
 417         _BoundaryAnXaxisCone, _BoundaryAnYaxisCone, _BoundaryAnZaxisCone, _BoundaryAngle, \
 418         _BoundaryAnXorigCone, _BoundaryAnYorigCone, _BoundaryAnYorigCone);
 419       }
 420       catch( SALOME::SALOME_Exception& S_ex )
 421       {
 422         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 423                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 424         return false ;
 425       }
 426       break;
 427     }
 428     case 4 : // il s agit d un cone defini par les 2 rayons
 429     {
 430       try
 431       {
 432         aBoundaryAn = _myHomardGen->CreateBoundaryConeR(CORBA::string_dup(_aName.toStdString().c_str()), \
 433         _BoundaryAnXcone1, _BoundaryAnYcone1, _BoundaryAnZcone1, _BoundaryAnRayon1, \
 434         _BoundaryAnXcone2, _BoundaryAnYcone2, _BoundaryAnZcone2, _BoundaryAnRayon2);
 435       }
 436       catch( SALOME::SALOME_Exception& S_ex )
 437       {
 438         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 439                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 440         return false ;
 441       }
 442       break;
 443     }
 444   }
 445   _parent->AddBoundaryAn(_aName);
 446
 447   return true;
 448 }
 449 // ------------------------------------------------------------------------
 450 void MonCreateBoundaryAn::PushOnOK()
 451 // ------------------------------------------------------------------------
 452 {
 453      if (PushOnApply()) this->close();
 454 }
 455 // ------------------------------------------------------------------------
 456 void MonCreateBoundaryAn::PushOnHelp()
 457 // ------------------------------------------------------------------------
 458 {
 459   HOMARD_UTILS::PushOnHelp(QString("gui_create_boundary.html#un-cylindre") ) ;
 460 }
 461
 462 // -----------------------------------
 463 void MonCreateBoundaryAn::SetNewBoundaryAnName()
 464 // -----------------------------------
 465 {
 466 // Recherche d'un nom par defaut qui n'existe pas encore
 467
 468   HOMARD::listeBoundarys_var  MyBoundaryAns = _myHomardGen->GetAllBoundarysName();
 469   int num = 0; QString aBoundaryAnName="";
 470   while (aBoundaryAnName=="" )
 471   {
 472     aBoundaryAnName.setNum(num+1) ;
 473     aBoundaryAnName.insert(0, QString("Boun_")) ;
 474     for ( int i=0; i<MyBoundaryAns->length(); i++)
 475     {
 476       if ( aBoundaryAnName ==  QString(MyBoundaryAns[i]))
 477       {
 478           num=num+1;
 479           aBoundaryAnName="";
 480           break;
 481       }
 482    }
 483   }
 484   LEBoundaryName->clear() ;
 485   LEBoundaryName->insert(aBoundaryAnName);
 486 }
 487 // ------------------------------------------------------------------------
 488 void MonCreateBoundaryAn::SetCylinder()
 489 // ------------------------------------------------------------------------
 490 {
 491   MESSAGE("Debut de SetCylinder")
 492   gBCylindre->setVisible(1);
 493   gBSphere->setVisible(0);
 494   gBCone->setVisible(0);
 495   adjustSize();
 496   _Type=1;
 497 //   MESSAGE("Fin de SetCylinder")
 498 }
 499 // ------------------------------------------------------------------------
 500 void MonCreateBoundaryAn::SetSphere()
 501 // ------------------------------------------------------------------------
 502 {
 503   MESSAGE("Debut de SetSphere")
 504   gBCylindre->setVisible(0);
 505   gBSphere->setVisible(1);
 506   gBCone->setVisible(0);
 507   adjustSize();
 508   _Type=2;
 509 //   MESSAGE("Fin de SetSphere")
 510 }
 511 // ------------------------------------------------------------------------
 512 void MonCreateBoundaryAn::SetConeR()
 513 // ------------------------------------------------------------------------
 514 {
 515   MESSAGE("Debut de SetConeR")
 516 //
 517 // Stockage et conversion des valeurs si elles ont change
 518   if ((_BoundaryAnXaxisCone != SpinBox_Cone_X1->value())  or
 519       (_BoundaryAnYaxisCone != SpinBox_Cone_Y1->value())  or
 520       (_BoundaryAnZaxisCone != SpinBox_Cone_Z1->value())  or
 521       (_BoundaryAnXorigCone != SpinBox_Cone_X2->value())  or
 522       (_BoundaryAnYorigCone != SpinBox_Cone_Y2->value())  or
 523       (_BoundaryAnZorigCone != SpinBox_Cone_Z2->value())  or
 524       (_BoundaryAngle       != SpinBox_Cone_V1->value()) )
 525   {
 526     MESSAGE("Stockage et conversion")
 527     _BoundaryAnXaxisCone = SpinBox_Cone_X1->value() ;
 528     _BoundaryAnYaxisCone = SpinBox_Cone_Y1->value() ;
 529     _BoundaryAnZaxisCone = SpinBox_Cone_Z1->value() ;
 530     _BoundaryAnXorigCone = SpinBox_Cone_X2->value() ;
 531     _BoundaryAnYorigCone = SpinBox_Cone_Y2->value() ;
 532     _BoundaryAnZorigCone = SpinBox_Cone_Z2->value() ;
 533     _BoundaryAngle       = SpinBox_Cone_V1->value() ;
 534     convertRayonAngle(-1) ;
 535   }
 536 //
 537   _Type=4;
 538 //
 539   TLCone_X1->setText(QApplication::translate("CreateBoundaryAn", "X centre 1", 0, QApplication::UnicodeUTF8));
 540   SpinBox_Cone_X1->setValue(_BoundaryAnXcone1);
 541   TLCone_Y1->setText(QApplication::translate("CreateBoundaryAn", "Y centre 1", 0, QApplication::UnicodeUTF8));
 542   SpinBox_Cone_Y1->setValue(_BoundaryAnYcone1);
 543   TLCone_Z1->setText(QApplication::translate("CreateBoundaryAn", "Z centre 1", 0, QApplication::UnicodeUTF8));
 544   SpinBox_Cone_Z1->setValue(_BoundaryAnZcone1);
 545 //
 546   TLCone_V1->setText(QApplication::translate("CreateBoundaryAn", "Radius 1", 0, QApplication::UnicodeUTF8));
 547   SpinBox_Cone_V1->setSingleStep(_Rayon/10.);
 548   SpinBox_Cone_V1->setMaximum(100000.*_DMax);
 549   SpinBox_Cone_V1->setValue(_BoundaryAnRayon1);
 550 //
 551   TLCone_X2->setText(QApplication::translate("CreateBoundaryAn", "X centre 2", 0, QApplication::UnicodeUTF8));
 552   SpinBox_Cone_X2->setValue(_BoundaryAnXcone2);
 553   TLCone_Y2->setText(QApplication::translate("CreateBoundaryAn", "Y centre 2", 0, QApplication::UnicodeUTF8));
 554   SpinBox_Cone_Y2->setValue(_BoundaryAnYcone2);
 555   TLCone_Z2->setText(QApplication::translate("CreateBoundaryAn", "Z centre 2", 0, QApplication::UnicodeUTF8));
 556   SpinBox_Cone_Z2->setValue(_BoundaryAnZcone2);
 557 //
 558   TLCone_V2->setVisible(1);
 559   SpinBox_Cone_V2->setVisible(1);
 560   TLCone_V2->setText(QApplication::translate("CreateBoundaryAn", "Radius 2", 0, QApplication::UnicodeUTF8));
 561   SpinBox_Cone_V2->setValue(_BoundaryAnRayon2);
 562 //
 563 //   MESSAGE("Fin de SetConeR")
 564 }
 565 // ------------------------------------------------------------------------
 566 void MonCreateBoundaryAn::SetConeA()
 567 // ------------------------------------------------------------------------
 568 {
 569   MESSAGE("Debut de SetConeA")
 570 // Stockage et conversion des valeurs si elles ont change
 571   if ((_BoundaryAnXcone1 != SpinBox_Cone_X1->value())  or
 572       (_BoundaryAnYcone1 != SpinBox_Cone_Y1->value())  or
 573       (_BoundaryAnZcone1 != SpinBox_Cone_Z1->value())  or
 574       (_BoundaryAnRayon1 != SpinBox_Cone_V1->value())  or
 575       (_BoundaryAnXcone2 != SpinBox_Cone_X2->value())  or
 576       (_BoundaryAnYcone2 != SpinBox_Cone_Y2->value())  or
 577       (_BoundaryAnZcone2 != SpinBox_Cone_Z2->value())  or
 578       (_BoundaryAnRayon2 != SpinBox_Cone_V2->value()) )
 579   {
 580     MESSAGE("Stockage et conversion")
 581     _BoundaryAnXcone1 = SpinBox_Cone_X1->value() ;
 582     _BoundaryAnYcone1 = SpinBox_Cone_Y1->value() ;
 583     _BoundaryAnZcone1 = SpinBox_Cone_Z1->value() ;
 584     _BoundaryAnRayon1 = SpinBox_Cone_V1->value() ;
 585     _BoundaryAnXcone2 = SpinBox_Cone_X2->value() ;
 586     _BoundaryAnYcone2 = SpinBox_Cone_Y2->value() ;
 587     _BoundaryAnZcone2 = SpinBox_Cone_Z2->value() ;
 588     _BoundaryAnRayon2 = SpinBox_Cone_V2->value() ;
 589     convertRayonAngle(1) ;
 590   }
 591 //
 592   _Type=3;
 593 //
 594   TLCone_X1->setText(QApplication::translate("CreateBoundaryAn", "X axis", 0, QApplication::UnicodeUTF8));
 595   SpinBox_Cone_X1->setValue(_BoundaryAnXaxisCone);
 596   TLCone_Y1->setText(QApplication::translate("CreateBoundaryAn", "Y axis", 0, QApplication::UnicodeUTF8));
 597   SpinBox_Cone_Y1->setValue(_BoundaryAnYaxisCone);
 598   TLCone_Z1->setText(QApplication::translate("CreateBoundaryAn", "Z axis", 0, QApplication::UnicodeUTF8));
 599   SpinBox_Cone_Z1->setValue(_BoundaryAnZaxisCone);
 600 //
 601   TLCone_X2->setText(QApplication::translate("CreateBoundaryAn", "X centre", 0, QApplication::UnicodeUTF8));
 602   SpinBox_Cone_X2->setValue(_BoundaryAnXorigCone);
 603   TLCone_Y2->setText(QApplication::translate("CreateBoundaryAn", "Y centre", 0, QApplication::UnicodeUTF8));
 604   SpinBox_Cone_Y2->setValue(_BoundaryAnYorigCone);
 605   TLCone_Z2->setText(QApplication::translate("CreateBoundaryAn", "Z centre", 0, QApplication::UnicodeUTF8));
 606   SpinBox_Cone_Z2->setValue(_BoundaryAnZorigCone);
 607 //
 608   TLCone_V1->setText(QApplication::translate("CreateBoundaryAn", "Angle", 0, QApplication::UnicodeUTF8));
 609   SpinBox_Cone_V1->setValue(_BoundaryAngle);
 610   SpinBox_Cone_V1->setSingleStep(1.);
 611   SpinBox_Cone_V1->setMaximum(90.);
 612 //
 613   TLCone_V2->setVisible(0);
 614   SpinBox_Cone_V2->setVisible(0);
 615 //   MESSAGE("Fin de SetConeA")
 616 }
 617
 618
 619 // ------------------------------------------------------------------------
 620 void MonCreateBoundaryAn::SetCone()
 621 // ------------------------------------------------------------------------
 622 {
 623   MESSAGE("Debut de SetCone")
 624   gBCylindre->setVisible(0);
 625   gBSphere->setVisible(0);
 626   gBCone->setVisible(1);
 627 //
 628   adjustSize();
 629   if ( RB_Def_radius->isChecked() )
 630   {
 631     SetConeR();
 632   }
 633   else
 634   {
 635     SetConeA();
 636   }
 637 //   MESSAGE("Fin de SetCone")
 638 }
 639 // ------------------------------------------------------------------------
 640 void MonCreateBoundaryAn::convertRayonAngle(int option)
 641 // ------------------------------------------------------------------------
 642 // Conversion entre les deux formulations du cone :
 643 // par deux rayons ou avec un axe et un angle.
 644 // Voir sfcoi1 de HOMARD
 645 {
 646   MESSAGE("Debut de convertRayonAngle, option = "<<option)
 647 //
 648 //         o
 649 //         !    .
 650 //         !        .
 651 //       RA!            .
 652 //         !                o
 653 //         !              RB!   .
 654 //         !                !       .
 655 //         A----------------B----------O
 656 //
 657 //   Thales : RA/RB = AO/BO  ==> BO = AB*RB/(RA-RB)
 658 //   Angle  : tg(alpha) = RA/AO
 659 //
 660   double daux ;
 661 // De rayon vers angle :
 662   if ( option == 1 )
 663   {
 664     double xa, ya, za, ra ;
 665     double xb, yb, zb, rb ;
 666 // Positionnement de A vers B, avec RA>RB
 667     if ( _BoundaryAnRayon1 > _BoundaryAnRayon2 )
 668     {
 669       xa = _BoundaryAnXcone1 ;
 670       ya = _BoundaryAnYcone1 ;
 671       za = _BoundaryAnZcone1 ;
 672       ra = _BoundaryAnRayon1 ;
 673       xb = _BoundaryAnXcone2 ;
 674       yb = _BoundaryAnYcone2 ;
 675       zb = _BoundaryAnZcone2 ;
 676       rb = _BoundaryAnRayon2 ;
 677     }
 678     else
 679     {
 680       xa = _BoundaryAnXcone2 ;
 681       ya = _BoundaryAnYcone2 ;
 682       za = _BoundaryAnZcone2 ;
 683       ra = _BoundaryAnRayon2 ;
 684       xb = _BoundaryAnXcone1 ;
 685       yb = _BoundaryAnYcone1 ;
 686       zb = _BoundaryAnZcone1 ;
 687       rb = _BoundaryAnRayon1 ;
 688     }
 689 // Axe : relie les deux centres, de A vers B.  L'axe est normalise
 690     _BoundaryAnXaxisCone = xb - xa ;
 691     _BoundaryAnYaxisCone = yb - ya ;
 692     _BoundaryAnZaxisCone = zb - za ;
 693     daux = sqrt ( _BoundaryAnXaxisCone*_BoundaryAnXaxisCone + _BoundaryAnYaxisCone*_BoundaryAnYaxisCone + _BoundaryAnZaxisCone*_BoundaryAnZaxisCone ) ;
 694     _BoundaryAnXaxisCone = _BoundaryAnXaxisCone/daux ;
 695     _BoundaryAnYaxisCone = _BoundaryAnYaxisCone/daux ;
 696     _BoundaryAnZaxisCone = _BoundaryAnZaxisCone/daux ;
 697 // Origine
 698     daux = daux * rb / (ra-rb) ;
 699     _BoundaryAnXorigCone = xb + daux*_BoundaryAnXaxisCone ;
 700     _BoundaryAnYorigCone = yb + daux*_BoundaryAnYaxisCone ;
 701     _BoundaryAnZorigCone = zb + daux*_BoundaryAnZaxisCone ;
 702 // Angle en degre
 703     daux = ra / sqrt((_BoundaryAnXorigCone-xa)*(_BoundaryAnXorigCone-xa) + (_BoundaryAnYorigCone-ya)*(_BoundaryAnYorigCone-ya) + (_BoundaryAnZorigCone-za)*(_BoundaryAnZorigCone-za) ) ;
 704     _BoundaryAngle = atan(daux)*180./PI ;
 705   }
 706 // D'angle vers rayon :
 707   else
 708   {
 709     double xax, yax, zax ;
 710 // L'axe est normalise
 711     daux = sqrt ( _BoundaryAnXaxisCone*_BoundaryAnXaxisCone + _BoundaryAnYaxisCone*_BoundaryAnYaxisCone + _BoundaryAnZaxisCone*_BoundaryAnZaxisCone ) ;
 712     xax = _BoundaryAnXaxisCone/daux ;
 713     yax = _BoundaryAnYaxisCone/daux ;
 714     zax = _BoundaryAnZaxisCone/daux ;
 715 // Centre 1 : l'origine
 716     _BoundaryAnXcone1 = _BoundaryAnXorigCone ;
 717     _BoundaryAnYcone1 = _BoundaryAnYorigCone ;
 718     _BoundaryAnZcone1 = _BoundaryAnZorigCone ;
 719 // Rayon 1 : nul
 720     _BoundaryAnRayon1 = 0. ;
 721 // Centre 2 : l'origine decalee d'une longueur arbitraire le long de l'axe
 722     _BoundaryAnXcone2 = _BoundaryAnXorigCone + _DMax*xax ;
 723     _BoundaryAnYcone2 = _BoundaryAnYorigCone + _DMax*yax ;
 724     _BoundaryAnZcone2 = _BoundaryAnZorigCone + _DMax*zax ;
 725 // Rayon 2 : a calculer
 726     _BoundaryAnRayon2 = _DMax*tan(_BoundaryAngle*PI/180.) ;
 727   }
 728 //   MESSAGE("Fin de convertRayonAngle")
 729 }
 730
 731