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 #include "MonCreateBoundaryAn.h"
  21 #include "MonCreateCase.h"
  22
  23 #include <QFileDialog>
  24 #include <QMessageBox>
  25
  26 #include "SalomeApp_Tools.h"
  27 #include "HOMARDGUI_Utils.h"
  28 #include "HomardQtCommun.h"
  29 #include <utilities.h>
  30
  31 #include <SUIT_Desktop.h>
  32 #include <SUIT_MessageBox.h>
  33 #include <SUIT_ResourceMgr.h>
  34 #include <SUIT_Session.h>
  35 #include <SUIT_ViewManager.h>
  36
  37 #include "math.h"
  38 #define PI 3.141592653589793
  39
  40 using namespace std;
  41 // ------------------------------------------------------------------------------------------------------------------------
  42 MonCreateBoundaryAn::MonCreateBoundaryAn(MonCreateCase* parent, bool modal,
  43                              HOMARD::HOMARD_Gen_var myHomardGen0,
  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(myHomardGen0);
  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       SetNewName() ;
  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 myHomardGen0,
  98                              QString caseName):
  99 // --------------------------------------------------------------------------------------------------------------
 100 // Constructeur appele par MonEditBoundaryAn
 101 //
 102     QDialog(0), Ui_CreateBoundaryAn(),
 103      myHomardGen(myHomardGen0),
 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   if (LEName->text().trimmed()=="")
 273   {
 274     QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 275                               QObject::tr("HOM_BOUN_NAME") );
 276     return false;
 277   }
 278
 279   switch (_Type)
 280   {
 281       case 1 : // il s agit d un cylindre
 282       {
 283         if ((_BoundaryAnXcentre != SpinBox_Xcent->value())  ||
 284             (_BoundaryAnYcentre != SpinBox_Ycent->value())  ||
 285             (_BoundaryAnZcentre != SpinBox_Zcent->value())  ||
 286             (_BoundaryAnRayon   != SpinBox_Radius->value()) ||
 287             (_BoundaryAnXaxis   != SpinBox_Xaxis->value()) ||
 288             (_BoundaryAnYaxis   != SpinBox_Yaxis->value()) ||
 289             (_BoundaryAnZaxis   != SpinBox_Zaxis->value()) )
 290         {
 291           Chgt = true;
 292           _BoundaryAnXaxis= SpinBox_Xaxis->value();
 293           _BoundaryAnYaxis= SpinBox_Yaxis->value();
 294           _BoundaryAnZaxis= SpinBox_Zaxis->value();
 295           _BoundaryAnXcentre=SpinBox_Xcent->value();
 296           _BoundaryAnYcentre=SpinBox_Ycent->value();
 297           _BoundaryAnZcentre=SpinBox_Zcent->value();
 298           _BoundaryAnRayon=SpinBox_Radius->value();
 299         }
 300         break;
 301       }
 302
 303       case 2 : // il s agit d une sphere
 304       {
 305         if ((_BoundaryAnXcentre != SpinBox_Xcentre->value()) ||
 306             (_BoundaryAnYcentre != SpinBox_Ycentre->value()) ||
 307             (_BoundaryAnZcentre != SpinBox_Zcentre->value()) ||
 308             (_BoundaryAnRayon   != SpinBox_Rayon->value())  )
 309         {
 310            Chgt = true;
 311           _BoundaryAnXcentre=SpinBox_Xcentre->value();
 312           _BoundaryAnYcentre=SpinBox_Ycentre->value();
 313           _BoundaryAnZcentre=SpinBox_Zcentre->value();
 314           _BoundaryAnRayon=SpinBox_Rayon->value();
 315         }
 316         break;
 317       }
 318
 319       case 3 : // il s agit d un cone defini par un axe et un angle
 320       {
 321         if ((_BoundaryAnXaxisCone != SpinBox_Cone_X1->value())  ||
 322             (_BoundaryAnYaxisCone != SpinBox_Cone_Y1->value())  ||
 323             (_BoundaryAnZaxisCone != SpinBox_Cone_Z1->value())  ||
 324             (_BoundaryAnXorigCone != SpinBox_Cone_X2->value())  ||
 325             (_BoundaryAnYorigCone != SpinBox_Cone_Y2->value())  ||
 326             (_BoundaryAnZorigCone != SpinBox_Cone_Z2->value())  ||
 327             (_BoundaryAngle       != SpinBox_Cone_V1->value()) )
 328         {
 329            Chgt = true;
 330           _BoundaryAnXaxisCone = SpinBox_Cone_X1->value() ;
 331           _BoundaryAnYaxisCone = SpinBox_Cone_Y1->value() ;
 332           _BoundaryAnZaxisCone = SpinBox_Cone_Z1->value() ;
 333           _BoundaryAnXorigCone = SpinBox_Cone_X2->value() ;
 334           _BoundaryAnYorigCone = SpinBox_Cone_Y2->value() ;
 335           _BoundaryAnZorigCone = SpinBox_Cone_Z2->value() ;
 336           _BoundaryAngle       = SpinBox_Cone_V1->value() ;
 337         }
 338         break;
 339       }
 340
 341       case 4 : // il s agit d un cone defini par les 2 rayons
 342       {
 343         if ((_BoundaryAnXcone1 != SpinBox_Cone_X1->value())  ||
 344             (_BoundaryAnYcone1 != SpinBox_Cone_Y1->value())  ||
 345             (_BoundaryAnZcone1 != SpinBox_Cone_Z1->value())  ||
 346             (_BoundaryAnRayon1 != SpinBox_Cone_V1->value())  ||
 347             (_BoundaryAnXcone2 != SpinBox_Cone_X2->value())  ||
 348             (_BoundaryAnYcone2 != SpinBox_Cone_Y2->value())  ||
 349             (_BoundaryAnZcone2 != SpinBox_Cone_Z2->value())  ||
 350             (_BoundaryAnRayon2 != SpinBox_Cone_V2->value()) )
 351         {
 352            Chgt = true;
 353           _BoundaryAnXcone1 = SpinBox_Cone_X1->value() ;
 354           _BoundaryAnYcone1 = SpinBox_Cone_Y1->value() ;
 355           _BoundaryAnZcone1 = SpinBox_Cone_Z1->value() ;
 356           _BoundaryAnRayon1 = SpinBox_Cone_V1->value() ;
 357           _BoundaryAnXcone2 = SpinBox_Cone_X2->value() ;
 358           _BoundaryAnYcone2 = SpinBox_Cone_Y2->value() ;
 359           _BoundaryAnZcone2 = SpinBox_Cone_Z2->value() ;
 360           _BoundaryAnRayon2 = SpinBox_Cone_V2->value() ;
 361         }
 362         break;
 363       }
 364  }
 365
 366   bool bOK = CreateOrUpdateBoundaryAn();
 367
 368   if ( bOK ) { HOMARD_UTILS::updateObjBrowser() ; }
 369
 370   return bOK;
 371
 372 }
 373 // ---------------------------------------------------
 374 bool MonCreateBoundaryAn:: CreateOrUpdateBoundaryAn()
 375 //----------------------------------------------------
 376 //  Creation de l'objet boundary
 377 {
 378   _aName = LEName->text().trimmed();
 379   switch (_Type)
 380   {
 381     case 1 : // il s agit d un cylindre
 382     {
 383       try
 384       {
 385         aBoundaryAn = myHomardGen->CreateBoundaryCylinder(CORBA::string_dup(_aName.toStdString().c_str()), \
 386         _BoundaryAnXcentre, _BoundaryAnYcentre, _BoundaryAnZcentre, _BoundaryAnXaxis, _BoundaryAnYaxis, _BoundaryAnZaxis, _BoundaryAnRayon );
 387       }
 388       catch( SALOME::SALOME_Exception& S_ex )
 389       {
 390         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 391                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 392         return false ;
 393       }
 394       break;
 395     }
 396     case 2 : // il s agit d une sphere
 397     {
 398       try
 399       {
 400         aBoundaryAn = myHomardGen->CreateBoundarySphere(CORBA::string_dup(_aName.toStdString().c_str()), \
 401         _BoundaryAnXcentre, _BoundaryAnYcentre, _BoundaryAnZcentre, _BoundaryAnRayon);
 402       }
 403       catch( SALOME::SALOME_Exception& S_ex )
 404       {
 405         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 406                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 407         return false ;
 408       }
 409       break;
 410     }
 411     case 3 : // il s agit d un cone defini par un axe et un angle
 412     {
 413       try
 414       {
 415         aBoundaryAn = myHomardGen->CreateBoundaryConeA(CORBA::string_dup(_aName.toStdString().c_str()), \
 416         _BoundaryAnXaxisCone, _BoundaryAnYaxisCone, _BoundaryAnZaxisCone, _BoundaryAngle, \
 417         _BoundaryAnXorigCone, _BoundaryAnYorigCone, _BoundaryAnYorigCone);
 418       }
 419       catch( SALOME::SALOME_Exception& S_ex )
 420       {
 421         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 422                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 423         return false ;
 424       }
 425       break;
 426     }
 427     case 4 : // il s agit d un cone defini par les 2 rayons
 428     {
 429       try
 430       {
 431         aBoundaryAn = myHomardGen->CreateBoundaryConeR(CORBA::string_dup(_aName.toStdString().c_str()), \
 432         _BoundaryAnXcone1, _BoundaryAnYcone1, _BoundaryAnZcone1, _BoundaryAnRayon1, \
 433         _BoundaryAnXcone2, _BoundaryAnYcone2, _BoundaryAnZcone2, _BoundaryAnRayon2);
 434       }
 435       catch( SALOME::SALOME_Exception& S_ex )
 436       {
 437         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 438                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 439         return false ;
 440       }
 441       break;
 442     }
 443   }
 444   _parent->AddBoundaryAn(_aName);
 445
 446   return true;
 447 }
 448 // ------------------------------------------------------------------------
 449 void MonCreateBoundaryAn::PushOnOK()
 450 // ------------------------------------------------------------------------
 451 {
 452      if (PushOnApply()) this->close();
 453 }
 454 // ------------------------------------------------------------------------
 455 void MonCreateBoundaryAn::PushOnHelp()
 456 // ------------------------------------------------------------------------
 457 {
 458   char* LanguageShort = myHomardGen->GetLanguageShort();
 459   HOMARD_UTILS::PushOnHelp(QString("gui_create_boundary.html"), QString("un-cylindre"), QString(LanguageShort));
 460 }
 461
 462 // -----------------------------------
 463 void MonCreateBoundaryAn::SetNewName()
 464 // -----------------------------------
 465 {
 466 // Recherche d'un nom par defaut qui n'existe pas encore
 467
 468   HOMARD::listeBoundarys_var MyObjects = myHomardGen->GetAllBoundarysName();
 469   int num = 0; QString aName="";
 470   while (aName=="" )
 471   {
 472     aName.setNum(num+1) ;
 473     aName.insert(0, QString("Boun_")) ;
 474     for ( int i=0; i<MyObjects->length(); i++)
 475     {
 476       if ( aName ==  QString(MyObjects[i]))
 477       {
 478         num ++ ;
 479         aName = "" ;
 480         break ;
 481       }
 482    }
 483   }
 484   LEName->setText(aName);
 485 }
 486 // ------------------------------------------------------------------------
 487 void MonCreateBoundaryAn::SetCylinder()
 488 // ------------------------------------------------------------------------
 489 {
 490   MESSAGE("Debut de SetCylinder")
 491   gBCylindre->setVisible(1);
 492   gBSphere->setVisible(0);
 493   gBCone->setVisible(0);
 494 //
 495   _Type=1;
 496 //
 497   adjustSize();
 498 //   MESSAGE("Fin de SetCylinder")
 499 }
 500 // ------------------------------------------------------------------------
 501 void MonCreateBoundaryAn::SetSphere()
 502 // ------------------------------------------------------------------------
 503 {
 504   MESSAGE("Debut de SetSphere")
 505   gBCylindre->setVisible(0);
 506   gBSphere->setVisible(1);
 507   gBCone->setVisible(0);
 508 //
 509   _Type=2;
 510 //
 511   adjustSize();
 512 //   MESSAGE("Fin de SetSphere")
 513 }
 514 // ------------------------------------------------------------------------
 515 void MonCreateBoundaryAn::SetConeR()
 516 // ------------------------------------------------------------------------
 517 {
 518   MESSAGE("Debut de SetConeR")
 519 //
 520 // Stockage et conversion des valeurs si elles ont change
 521   if ((_BoundaryAnXaxisCone != SpinBox_Cone_X1->value())  ||
 522       (_BoundaryAnYaxisCone != SpinBox_Cone_Y1->value())  ||
 523       (_BoundaryAnZaxisCone != SpinBox_Cone_Z1->value())  ||
 524       (_BoundaryAnXorigCone != SpinBox_Cone_X2->value())  ||
 525       (_BoundaryAnYorigCone != SpinBox_Cone_Y2->value())  ||
 526       (_BoundaryAnZorigCone != SpinBox_Cone_Z2->value())  ||
 527       (_BoundaryAngle       != SpinBox_Cone_V1->value()) )
 528   {
 529     MESSAGE("Stockage et conversion")
 530     _BoundaryAnXaxisCone = SpinBox_Cone_X1->value() ;
 531     _BoundaryAnYaxisCone = SpinBox_Cone_Y1->value() ;
 532     _BoundaryAnZaxisCone = SpinBox_Cone_Z1->value() ;
 533     _BoundaryAnXorigCone = SpinBox_Cone_X2->value() ;
 534     _BoundaryAnYorigCone = SpinBox_Cone_Y2->value() ;
 535     _BoundaryAnZorigCone = SpinBox_Cone_Z2->value() ;
 536     _BoundaryAngle       = SpinBox_Cone_V1->value() ;
 537     convertRayonAngle(-1) ;
 538   }
 539 //
 540   _Type=4;
 541 //
 542   TLCone_X1->setText(QApplication::translate("CreateBoundaryAn", "X centre 1", 0, QApplication::UnicodeUTF8));
 543   SpinBox_Cone_X1->setValue(_BoundaryAnXcone1);
 544   TLCone_Y1->setText(QApplication::translate("CreateBoundaryAn", "Y centre 1", 0, QApplication::UnicodeUTF8));
 545   SpinBox_Cone_Y1->setValue(_BoundaryAnYcone1);
 546   TLCone_Z1->setText(QApplication::translate("CreateBoundaryAn", "Z centre 1", 0, QApplication::UnicodeUTF8));
 547   SpinBox_Cone_Z1->setValue(_BoundaryAnZcone1);
 548 //
 549   TLCone_V1->setText(QApplication::translate("CreateBoundaryAn", "Radius 1", 0, QApplication::UnicodeUTF8));
 550   SpinBox_Cone_V1->setSingleStep(_Rayon/10.);
 551   SpinBox_Cone_V1->setMaximum(100000.*_DMax);
 552   SpinBox_Cone_V1->setValue(_BoundaryAnRayon1);
 553 //
 554   TLCone_X2->setText(QApplication::translate("CreateBoundaryAn", "X centre 2", 0, QApplication::UnicodeUTF8));
 555   SpinBox_Cone_X2->setValue(_BoundaryAnXcone2);
 556   TLCone_Y2->setText(QApplication::translate("CreateBoundaryAn", "Y centre 2", 0, QApplication::UnicodeUTF8));
 557   SpinBox_Cone_Y2->setValue(_BoundaryAnYcone2);
 558   TLCone_Z2->setText(QApplication::translate("CreateBoundaryAn", "Z centre 2", 0, QApplication::UnicodeUTF8));
 559   SpinBox_Cone_Z2->setValue(_BoundaryAnZcone2);
 560 //
 561   TLCone_V2->setVisible(1);
 562   SpinBox_Cone_V2->setVisible(1);
 563   TLCone_V2->setText(QApplication::translate("CreateBoundaryAn", "Radius 2", 0, QApplication::UnicodeUTF8));
 564   SpinBox_Cone_V2->setValue(_BoundaryAnRayon2);
 565 //
 566 //   MESSAGE("Fin de SetConeR")
 567 }
 568 // ------------------------------------------------------------------------
 569 void MonCreateBoundaryAn::SetConeA()
 570 // ------------------------------------------------------------------------
 571 {
 572   MESSAGE("Debut de SetConeA")
 573 // Stockage et conversion des valeurs si elles ont change
 574   if ((_BoundaryAnXcone1 != SpinBox_Cone_X1->value())  ||
 575       (_BoundaryAnYcone1 != SpinBox_Cone_Y1->value())  ||
 576       (_BoundaryAnZcone1 != SpinBox_Cone_Z1->value())  ||
 577       (_BoundaryAnRayon1 != SpinBox_Cone_V1->value())  ||
 578       (_BoundaryAnXcone2 != SpinBox_Cone_X2->value())  ||
 579       (_BoundaryAnYcone2 != SpinBox_Cone_Y2->value())  ||
 580       (_BoundaryAnZcone2 != SpinBox_Cone_Z2->value())  ||
 581       (_BoundaryAnRayon2 != SpinBox_Cone_V2->value()) )
 582   {
 583     MESSAGE("Stockage et conversion")
 584     _BoundaryAnXcone1 = SpinBox_Cone_X1->value() ;
 585     _BoundaryAnYcone1 = SpinBox_Cone_Y1->value() ;
 586     _BoundaryAnZcone1 = SpinBox_Cone_Z1->value() ;
 587     _BoundaryAnRayon1 = SpinBox_Cone_V1->value() ;
 588     _BoundaryAnXcone2 = SpinBox_Cone_X2->value() ;
 589     _BoundaryAnYcone2 = SpinBox_Cone_Y2->value() ;
 590     _BoundaryAnZcone2 = SpinBox_Cone_Z2->value() ;
 591     _BoundaryAnRayon2 = SpinBox_Cone_V2->value() ;
 592     convertRayonAngle(1) ;
 593   }
 594 //
 595   _Type=3;
 596 //
 597   TLCone_X1->setText(QApplication::translate("CreateBoundaryAn", "X axis", 0, QApplication::UnicodeUTF8));
 598   SpinBox_Cone_X1->setValue(_BoundaryAnXaxisCone);
 599   TLCone_Y1->setText(QApplication::translate("CreateBoundaryAn", "Y axis", 0, QApplication::UnicodeUTF8));
 600   SpinBox_Cone_Y1->setValue(_BoundaryAnYaxisCone);
 601   TLCone_Z1->setText(QApplication::translate("CreateBoundaryAn", "Z axis", 0, QApplication::UnicodeUTF8));
 602   SpinBox_Cone_Z1->setValue(_BoundaryAnZaxisCone);
 603 //
 604   TLCone_X2->setText(QApplication::translate("CreateBoundaryAn", "X centre", 0, QApplication::UnicodeUTF8));
 605   SpinBox_Cone_X2->setValue(_BoundaryAnXorigCone);
 606   TLCone_Y2->setText(QApplication::translate("CreateBoundaryAn", "Y centre", 0, QApplication::UnicodeUTF8));
 607   SpinBox_Cone_Y2->setValue(_BoundaryAnYorigCone);
 608   TLCone_Z2->setText(QApplication::translate("CreateBoundaryAn", "Z centre", 0, QApplication::UnicodeUTF8));
 609   SpinBox_Cone_Z2->setValue(_BoundaryAnZorigCone);
 610 //
 611   TLCone_V1->setText(QApplication::translate("CreateBoundaryAn", "Angle", 0, QApplication::UnicodeUTF8));
 612   SpinBox_Cone_V1->setValue(_BoundaryAngle);
 613   SpinBox_Cone_V1->setSingleStep(1.);
 614   SpinBox_Cone_V1->setMaximum(90.);
 615 //
 616   TLCone_V2->setVisible(0);
 617   SpinBox_Cone_V2->setVisible(0);
 618 //   MESSAGE("Fin de SetConeA")
 619 }
 620
 621
 622 // ------------------------------------------------------------------------
 623 void MonCreateBoundaryAn::SetCone()
 624 // ------------------------------------------------------------------------
 625 {
 626   MESSAGE("Debut de SetCone")
 627   gBCylindre->setVisible(0);
 628   gBSphere->setVisible(0);
 629   gBCone->setVisible(1);
 630 //
 631   if ( RB_Def_radius->isChecked() )
 632   {
 633     SetConeR();
 634   }
 635   else
 636   {
 637     SetConeA();
 638   }
 639 //
 640   adjustSize();
 641 //   MESSAGE("Fin de SetCone")
 642 }
 643 // ------------------------------------------------------------------------
 644 void MonCreateBoundaryAn::convertRayonAngle(int option)
 645 // ------------------------------------------------------------------------
 646 // Conversion entre les deux formulations du cone :
 647 // par deux rayons ou avec un axe et un angle.
 648 // Voir sfcoi1 de HOMARD
 649 {
 650   MESSAGE("Debut de convertRayonAngle, option = "<<option)
 651 //
 652 //         o
 653 //         !    .
 654 //         !        .
 655 //       RA!            .
 656 //         !                o
 657 //         !              RB!   .
 658 //         !                !       .
 659 //         A----------------B----------O
 660 //
 661 //   Thales : RA/RB = AO/BO  ==> BO = AB*RB/(RA-RB)
 662 //   Angle  : tg(alpha) = RA/AO
 663 //
 664   double daux ;
 665 // De rayon vers angle :
 666   if ( option == 1 )
 667   {
 668     double xa, ya, za, ra ;
 669     double xb, yb, zb, rb ;
 670 // Positionnement de A vers B, avec RA>RB
 671     if ( _BoundaryAnRayon1 > _BoundaryAnRayon2 )
 672     {
 673       xa = _BoundaryAnXcone1 ;
 674       ya = _BoundaryAnYcone1 ;
 675       za = _BoundaryAnZcone1 ;
 676       ra = _BoundaryAnRayon1 ;
 677       xb = _BoundaryAnXcone2 ;
 678       yb = _BoundaryAnYcone2 ;
 679       zb = _BoundaryAnZcone2 ;
 680       rb = _BoundaryAnRayon2 ;
 681     }
 682     else
 683     {
 684       xa = _BoundaryAnXcone2 ;
 685       ya = _BoundaryAnYcone2 ;
 686       za = _BoundaryAnZcone2 ;
 687       ra = _BoundaryAnRayon2 ;
 688       xb = _BoundaryAnXcone1 ;
 689       yb = _BoundaryAnYcone1 ;
 690       zb = _BoundaryAnZcone1 ;
 691       rb = _BoundaryAnRayon1 ;
 692     }
 693 // Axe : relie les deux centres, de A vers B.  L'axe est normalise
 694     _BoundaryAnXaxisCone = xb - xa ;
 695     _BoundaryAnYaxisCone = yb - ya ;
 696     _BoundaryAnZaxisCone = zb - za ;
 697     daux = sqrt ( _BoundaryAnXaxisCone*_BoundaryAnXaxisCone + _BoundaryAnYaxisCone*_BoundaryAnYaxisCone + _BoundaryAnZaxisCone*_BoundaryAnZaxisCone ) ;
 698     _BoundaryAnXaxisCone = _BoundaryAnXaxisCone/daux ;
 699     _BoundaryAnYaxisCone = _BoundaryAnYaxisCone/daux ;
 700     _BoundaryAnZaxisCone = _BoundaryAnZaxisCone/daux ;
 701 // Origine
 702     daux = daux * rb / (ra-rb) ;
 703     _BoundaryAnXorigCone = xb + daux*_BoundaryAnXaxisCone ;
 704     _BoundaryAnYorigCone = yb + daux*_BoundaryAnYaxisCone ;
 705     _BoundaryAnZorigCone = zb + daux*_BoundaryAnZaxisCone ;
 706 // Angle en degre
 707     daux = ra / sqrt((_BoundaryAnXorigCone-xa)*(_BoundaryAnXorigCone-xa) + (_BoundaryAnYorigCone-ya)*(_BoundaryAnYorigCone-ya) + (_BoundaryAnZorigCone-za)*(_BoundaryAnZorigCone-za) ) ;
 708     _BoundaryAngle = atan(daux)*180./PI ;
 709   }
 710 // D'angle vers rayon :
 711   else
 712   {
 713     double xax, yax, zax ;
 714 // L'axe est normalise
 715     daux = sqrt ( _BoundaryAnXaxisCone*_BoundaryAnXaxisCone + _BoundaryAnYaxisCone*_BoundaryAnYaxisCone + _BoundaryAnZaxisCone*_BoundaryAnZaxisCone ) ;
 716     xax = _BoundaryAnXaxisCone/daux ;
 717     yax = _BoundaryAnYaxisCone/daux ;
 718     zax = _BoundaryAnZaxisCone/daux ;
 719 // Centre 1 : l'origine
 720     _BoundaryAnXcone1 = _BoundaryAnXorigCone ;
 721     _BoundaryAnYcone1 = _BoundaryAnYorigCone ;
 722     _BoundaryAnZcone1 = _BoundaryAnZorigCone ;
 723 // Rayon 1 : nul
 724     _BoundaryAnRayon1 = 0. ;
 725 // Centre 2 : l'origine decalee d'une longueur arbitraire le long de l'axe
 726     _BoundaryAnXcone2 = _BoundaryAnXorigCone + _DMax*xax ;
 727     _BoundaryAnYcone2 = _BoundaryAnYorigCone + _DMax*yax ;
 728     _BoundaryAnZcone2 = _BoundaryAnZorigCone + _DMax*zax ;
 729 // Rayon 2 : a calculer
 730     _BoundaryAnRayon2 = _DMax*tan(_BoundaryAngle*PI/180.) ;
 731   }
 732 //   MESSAGE("Fin de convertRayonAngle")
 733 }
 734
 735