src/HOMARDGUI/MonCreateBoundaryAn.cxx

   1 // Copyright (C) 2011-2016  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, or (at your option) any later version.
   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 // ------------------------------------------------------------------------------------------------------------------------
  43 MonCreateBoundaryAn::MonCreateBoundaryAn(MonCreateCase* parent, bool modal,
  44                              HOMARD::HOMARD_Gen_var myHomardGen0,
  45                              QString caseName) :
  46 // ------------------------------------------------------------------------------------------------------------------------------
  47 /* Constructs a MonCreateBoundaryAn
  48    appele pour une vraie creation
  49    initialise un cylindre et non une sphere
  50 */
  51     QDialog(0), Ui_CreateBoundaryAn(),
  52     _parent(parent),
  53     _Name (""),
  54     _aCaseName(caseName),
  55     _Xmin(0), _Xmax(0), _Xincr(0), _Ymin(0), _Ymax(0), _Yincr(0), _Zmin(0), _Zmax(0), _Zincr(0), _DMax(0),
  56     _Type(1),
  57     _BoundaryAnXcentre(0), _BoundaryAnYcentre(0), _BoundaryAnZcentre(0), _BoundaryAnRayon(0),
  58     _BoundaryAnXaxis(0), _BoundaryAnYaxis(0), _BoundaryAnZaxis(0),
  59     _Xcentre(0), _Ycentre(0), _Zcentre(0), _Rayon(0),
  60     _BoundaryAnXcone1(0), _BoundaryAnYcone1(0), _BoundaryAnZcone1(0), _BoundaryAnRayon1(0),
  61     _BoundaryAnXcone2(0), _BoundaryAnYcone2(0), _BoundaryAnZcone2(0), _BoundaryAnRayon2(0),
  62     _BoundaryAnXaxisCone(0), _BoundaryAnYaxisCone(0), _BoundaryAnZaxisCone(0),
  63     _BoundaryAngle(0),
  64     _BoundaryAnToreXcentre(0), _BoundaryAnToreYcentre(0), _BoundaryAnToreZcentre(0),
  65     _BoundaryAnToreXaxe(0), _BoundaryAnToreYaxe(0), _BoundaryAnToreZaxe(0),
  66     _BoundaryAnToreRRev(0), _BoundaryAnToreRPri(0),
  67     Chgt (false)
  68     {
  69       MESSAGE("Constructeur") ;
  70       myHomardGen=HOMARD::HOMARD_Gen::_duplicate(myHomardGen0);
  71       setupUi(this);
  72       setModal(modal);
  73
  74     //  Gestion des icones
  75       QPixmap pix ;
  76       QIcon IS ;
  77       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
  78       pix = resMgr->loadPixmap( "HOMARD", "spherepoint.png" );
  79       IS=QIcon(pix);
  80       RBSphere->setIcon(IS);
  81       pix = resMgr->loadPixmap( "HOMARD", "cylinderpointvector.png" );
  82       IS=QIcon(pix);
  83       RBCylindre->setIcon(IS);
  84       pix = resMgr->loadPixmap( "HOMARD", "cone.png" );
  85       IS=QIcon(pix);
  86       RBCone->setIcon(IS);
  87       pix = resMgr->loadPixmap( "HOMARD", "conepointvector.png" );
  88       IS=QIcon(pix);
  89       RB_Def_angle->setIcon(IS);
  90       pix = resMgr->loadPixmap( "HOMARD", "conedxyz.png" );
  91       IS=QIcon(pix);
  92       RB_Def_radius->setIcon(IS);
  93       pix = resMgr->loadPixmap( "HOMARD", "toruspointvector.png" );
  94       IS=QIcon(pix);
  95       RBTore->setIcon(IS);
  96
  97       InitConnect( );
  98
  99       SetNewName() ;
 100       InitValBoundaryAn();          // Cherche les valeurs de la boite englobante le maillage
 101       InitMinMax();                 // Initialise les bornes des boutons
 102       SetCylinder();                // Propose un cylindre en premier choix
 103     }
 104 // --------------------------------------------------------------------------------------------------------------
 105 MonCreateBoundaryAn::MonCreateBoundaryAn(MonCreateCase* parent,
 106                              HOMARD::HOMARD_Gen_var myHomardGen0,
 107                              QString caseName):
 108 // --------------------------------------------------------------------------------------------------------------
 109 //
 110     QDialog(0), Ui_CreateBoundaryAn(),
 111      myHomardGen(myHomardGen0),
 112     _parent(parent),
 113     _Name (""),
 114     _aCaseName(caseName),
 115     _Type(1),
 116     _BoundaryAnXcentre(0), _BoundaryAnYcentre(0), _BoundaryAnZcentre(0), _BoundaryAnRayon(0),
 117     _BoundaryAnXaxis(0), _BoundaryAnYaxis(0), _BoundaryAnZaxis(0),
 118     // Pour affichage lors de l edition d une BoundaryAn sans nom de Cas
 119     _Xcentre(0), _Ycentre(0), _Zcentre(0), _Rayon(0),
 120     _Xmin(1), _Xmax(1), _Xincr(1), _Ymin(1), _Ymax(1), _Yincr(1), _Zmin(1), _Zmax(1), _Zincr(1), _DMax(1),
 121     Chgt (false)
 122     {
 123   //  MESSAGE("Debut de  MonCreateBoundaryAn")
 124       setupUi(this);
 125       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 126       QPixmap pix = resMgr->loadPixmap( "HOMARD", "spherepoint.png" );
 127       QIcon IS=QIcon(pix);
 128       RBSphere->setIcon(IS);
 129       QPixmap pix2 = resMgr->loadPixmap( "HOMARD", "cylinderpointvector.png" );
 130       QIcon IS2=QIcon(pix2);
 131       RBCylindre->setIcon(IS2);
 132       QPixmap pix3 = resMgr->loadPixmap( "HOMARD", "cone.png" );
 133       QIcon IS3=QIcon(pix3);
 134       RBCone->setIcon(IS3);
 135       QPixmap pix4 = resMgr->loadPixmap( "HOMARD", "conepointvector.png" );
 136       QIcon IS4=QIcon(pix4);
 137       RB_Def_angle->setIcon(IS4);
 138       QPixmap pix5 = resMgr->loadPixmap( "HOMARD", "conedxyz.png" );
 139       QIcon IS5=QIcon(pix5);
 140       RB_Def_radius->setIcon(IS5);
 141       setModal(true);
 142       InitConnect();
 143     }
 144
 145 // ------------------------------------------------------------------------
 146 MonCreateBoundaryAn::~MonCreateBoundaryAn()
 147 // ------------------------------------------------------------------------
 148 {
 149     // no need to delete child widgets, Qt does it all for us
 150 }
 151 // ------------------------------------------------------------------------
 152 void MonCreateBoundaryAn::InitConnect()
 153 // ------------------------------------------------------------------------
 154 {
 155     connect( RBCylindre,    SIGNAL(clicked()) , this, SLOT(SetCylinder()) ) ;
 156     connect( RBSphere,      SIGNAL(clicked()) , this, SLOT(SetSphere()) ) ;
 157     connect( RBCone,        SIGNAL(clicked()) , this, SLOT(SetCone()) ) ;
 158     connect( RB_Def_radius, SIGNAL(clicked()) , this, SLOT(SetConeR()) );
 159     connect( RB_Def_angle,  SIGNAL(clicked()) , this, SLOT(SetConeA()) );
 160     connect( RBTore,        SIGNAL(clicked()) , this, SLOT(SetTore()) ) ;
 161     connect( buttonOk,     SIGNAL( pressed() ), this, SLOT( PushOnOK() ) );
 162     connect( buttonApply,  SIGNAL( pressed() ), this, SLOT( PushOnApply() ) );
 163     connect( buttonCancel, SIGNAL( pressed() ), this, SLOT( close() ) );
 164     connect( buttonHelp,   SIGNAL( pressed() ), this, SLOT( PushOnHelp() ) );
 165 }
 166 // ------------------------------------------------------------------------
 167 void MonCreateBoundaryAn::InitValBoundaryAn()
 168 // ------------------------------------------------------------------------
 169 {
 170 //
 171 //  1. Les coordonnees extremes du maillage
 172 //
 173     if (_aCaseName == QString("")) { return; }
 174
 175     HOMARD::HOMARD_Cas_var aCas = myHomardGen->GetCase(_aCaseName.toStdString().c_str());
 176     HOMARD::extrema_var  MesExtremes = aCas->GetBoundingBox();
 177     int num = MesExtremes->length() ;
 178     ASSERT(num == 10);
 179     _Xmin=MesExtremes[0]; _Xmax=MesExtremes[1]; _Xincr=MesExtremes[2];
 180     _Ymin=MesExtremes[3]; _Ymax=MesExtremes[4]; _Yincr=MesExtremes[5];
 181     _Zmin=MesExtremes[6]; _Zmax=MesExtremes[7]; _Zincr=MesExtremes[8];
 182     _DMax=MesExtremes[9];
 183      MESSAGE ("_Xmin : " << _Xmin << " _Xmax : " << _Xmax << " _Xincr : " << _Xincr ) ;
 184      MESSAGE ("_Ymin : " << _Ymin << " _Ymax : " << _Ymax << " _Yincr : " << _Yincr ) ;
 185      MESSAGE ("_Zmin : " << _Zmin << " _Zmax : " << _Zmax << " _Zincr : " << _Zincr) ;
 186      MESSAGE ("_DMax : " << _DMax);
 187
 188 //  2. Caracteristiques des frontieres
 189 // en X
 190     _Xcentre=(_Xmin + _Xmax)/2.;
 191 // en Y
 192     _Ycentre=(_Ymin + _Ymax)/2.;
 193 // en Z
 194     _Zcentre=(_Zmin + _Zmax)/2.;
 195 // Rayon
 196     _Rayon= _DMax/4.;
 197 }
 198
 199 // ------------------------------------------------------------------------
 200 void MonCreateBoundaryAn::InitMinMax()
 201 // ------------------------------------------------------------------------
 202 {
 203   // Cylindre
 204   // . X du centre
 205   SpinBox_Xcent->setValue(_Xcentre);
 206   SpinBox_Xcent->setSingleStep(_Xincr);
 207   // . Y du centre
 208   SpinBox_Ycent->setValue(_Ycentre);
 209   SpinBox_Ycent->setSingleStep(_Yincr);
 210   // . Z du centre
 211   SpinBox_Zcent->setValue(_Zcentre);
 212   SpinBox_Zcent->setSingleStep(_Zincr);
 213   // . X de l'axe
 214   SpinBox_Xaxis->setValue(0.);
 215   SpinBox_Xaxis->setSingleStep(0.1);
 216   // . Y de l'axe
 217   SpinBox_Yaxis->setValue(0.);
 218   SpinBox_Yaxis->setSingleStep(0.1);
 219   // . Z de l'axe
 220   SpinBox_Zaxis->setValue(1.);
 221   SpinBox_Zaxis->setSingleStep(0.1);
 222   // . Rayon
 223   SpinBox_Radius->setValue(_Rayon);
 224   SpinBox_Radius->setSingleStep(_Rayon/10.);
 225
 226   // Sphere
 227   // . X du centre
 228   SpinBox_Xcentre->setValue(_Xcentre);
 229   SpinBox_Xcentre->setSingleStep(_Xincr);
 230   // . Y du centre
 231   SpinBox_Ycentre->setValue(_Ycentre);
 232   SpinBox_Ycentre->setSingleStep(_Yincr);
 233   // . Z du centre
 234   SpinBox_Zcentre->setValue(_Zcentre);
 235   SpinBox_Zcentre->setSingleStep(_Zincr);
 236   // . Rayon
 237   SpinBox_Rayon->setValue(_Rayon);
 238   SpinBox_Rayon->setSingleStep(_Rayon/10.);
 239
 240   // Cone en rayons
 241   // . X des centres
 242   _BoundaryAnXcone1 = _Xcentre ;
 243   SpinBox_Cone_X1->setSingleStep(_Xincr);
 244   _BoundaryAnXcone2 = _Xcentre ;
 245   SpinBox_Cone_X2->setSingleStep(_Xincr);
 246   // . Y des centres
 247   _BoundaryAnYcone1 = _Ycentre ;
 248   SpinBox_Cone_Y1->setSingleStep(_Yincr);
 249   _BoundaryAnYcone2 = _Ycentre ;
 250   SpinBox_Cone_Y2->setSingleStep(_Yincr);
 251   // . Z des centres
 252   _BoundaryAnZcone1 = _Zmin ;
 253   SpinBox_Cone_Z1->setSingleStep(_Zincr);
 254   _BoundaryAnZcone2 = _Zmax ;
 255   SpinBox_Cone_Z2->setSingleStep(_Zincr);
 256   // . Rayons/Angles
 257   _BoundaryAnRayon1 = 0. ;
 258   _BoundaryAnRayon2 = _Rayon ;
 259   SpinBox_Cone_V2->setSingleStep(_Rayon/10.);
 260
 261   // Cone en angle
 262   convertRayonAngle(1) ;
 263   SpinBox_Cone_X1->setValue(_BoundaryAnXaxisCone);
 264   SpinBox_Cone_Y1->setValue(_BoundaryAnYaxisCone);
 265   SpinBox_Cone_Z1->setValue(_BoundaryAnZaxisCone);
 266   SpinBox_Cone_V1->setValue(_BoundaryAngle);
 267   SpinBox_Cone_X2->setValue(_BoundaryAnXorigCone);
 268   SpinBox_Cone_Y2->setValue(_BoundaryAnYorigCone);
 269   SpinBox_Cone_Z2->setValue(_BoundaryAnZorigCone);
 270
 271   // Tore
 272   // . X du centre
 273   SpinBoxToreXcent->setValue(_Xcentre);
 274   SpinBoxToreXcent->setSingleStep(_Xincr);
 275   // . Y du centre
 276   SpinBoxToreYcent->setValue(_Ycentre);
 277   SpinBoxToreYcent->setSingleStep(_Yincr);
 278   // . Z du centre
 279   SpinBoxToreZcent->setValue(_Zcentre);
 280   SpinBoxToreZcent->setSingleStep(_Zincr);
 281   // . X de l'axe
 282   SpinBoxToreXaxe->setValue(0.);
 283   SpinBoxToreXaxe->setSingleStep(0.1);
 284   // . Y de l'axe
 285   SpinBoxToreYaxe->setValue(0.);
 286   SpinBoxToreYaxe->setSingleStep(0.1);
 287   // . Z de l'axe
 288   SpinBoxToreZaxe->setValue(1.);
 289   SpinBoxToreZaxe->setSingleStep(0.1);
 290   // . Rayon de revolution
 291   SpinBoxToreRRev->setValue(_Rayon);
 292   SpinBoxToreRRev->setSingleStep(_Rayon/10.);
 293   // . Rayon primaire
 294   SpinBoxToreRPri->setValue(_Rayon/3.);
 295   SpinBoxToreRPri->setSingleStep(_Rayon/20.);
 296 }
 297 // ------------------------------------------------------------------------
 298 bool MonCreateBoundaryAn::PushOnApply()
 299 // ------------------------------------------------------------------------
 300 // Appele lorsque l'un des boutons Ok ou Apply est presse
 301 //
 302 {
 303   if (LEName->text().trimmed()=="")
 304   {
 305     QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 306                               QObject::tr("HOM_BOUN_NAME") );
 307     return false;
 308   }
 309
 310   switch (_Type)
 311   {
 312       case 1 : // il s agit d un cylindre
 313       {
 314         if ((_BoundaryAnXcentre != SpinBox_Xcent->value())  ||
 315             (_BoundaryAnYcentre != SpinBox_Ycent->value())  ||
 316             (_BoundaryAnZcentre != SpinBox_Zcent->value())  ||
 317             (_BoundaryAnRayon   != SpinBox_Radius->value()) ||
 318             (_BoundaryAnXaxis   != SpinBox_Xaxis->value()) ||
 319             (_BoundaryAnYaxis   != SpinBox_Yaxis->value()) ||
 320             (_BoundaryAnZaxis   != SpinBox_Zaxis->value()) )
 321         {
 322           Chgt = true;
 323           _BoundaryAnXaxis= SpinBox_Xaxis->value();
 324           _BoundaryAnYaxis= SpinBox_Yaxis->value();
 325           _BoundaryAnZaxis= SpinBox_Zaxis->value();
 326           _BoundaryAnXcentre=SpinBox_Xcent->value();
 327           _BoundaryAnYcentre=SpinBox_Ycent->value();
 328           _BoundaryAnZcentre=SpinBox_Zcent->value();
 329           _BoundaryAnRayon=SpinBox_Radius->value();
 330         }
 331         break;
 332       }
 333
 334       case 2 : // il s agit d une sphere
 335       {
 336         if ((_BoundaryAnXcentre != SpinBox_Xcentre->value()) ||
 337             (_BoundaryAnYcentre != SpinBox_Ycentre->value()) ||
 338             (_BoundaryAnZcentre != SpinBox_Zcentre->value()) ||
 339             (_BoundaryAnRayon   != SpinBox_Rayon->value())  )
 340         {
 341            Chgt = true;
 342           _BoundaryAnXcentre=SpinBox_Xcentre->value();
 343           _BoundaryAnYcentre=SpinBox_Ycentre->value();
 344           _BoundaryAnZcentre=SpinBox_Zcentre->value();
 345           _BoundaryAnRayon=SpinBox_Rayon->value();
 346         }
 347         break;
 348       }
 349
 350       case 3 : // il s agit d un cone defini par un axe et un angle
 351       {
 352         if ((_BoundaryAnXaxisCone != SpinBox_Cone_X1->value())  ||
 353             (_BoundaryAnYaxisCone != SpinBox_Cone_Y1->value())  ||
 354             (_BoundaryAnZaxisCone != SpinBox_Cone_Z1->value())  ||
 355             (_BoundaryAnXorigCone != SpinBox_Cone_X2->value())  ||
 356             (_BoundaryAnYorigCone != SpinBox_Cone_Y2->value())  ||
 357             (_BoundaryAnZorigCone != SpinBox_Cone_Z2->value())  ||
 358             (_BoundaryAngle       != SpinBox_Cone_V1->value()) )
 359         {
 360            Chgt = true;
 361           _BoundaryAnXaxisCone = SpinBox_Cone_X1->value() ;
 362           _BoundaryAnYaxisCone = SpinBox_Cone_Y1->value() ;
 363           _BoundaryAnZaxisCone = SpinBox_Cone_Z1->value() ;
 364           _BoundaryAnXorigCone = SpinBox_Cone_X2->value() ;
 365           _BoundaryAnYorigCone = SpinBox_Cone_Y2->value() ;
 366           _BoundaryAnZorigCone = SpinBox_Cone_Z2->value() ;
 367           _BoundaryAngle       = SpinBox_Cone_V1->value() ;
 368         }
 369         break;
 370       }
 371
 372       case 4 : // il s agit d un cone defini par les 2 rayons
 373       {
 374         if ((_BoundaryAnXcone1 != SpinBox_Cone_X1->value())  ||
 375             (_BoundaryAnYcone1 != SpinBox_Cone_Y1->value())  ||
 376             (_BoundaryAnZcone1 != SpinBox_Cone_Z1->value())  ||
 377             (_BoundaryAnRayon1 != SpinBox_Cone_V1->value())  ||
 378             (_BoundaryAnXcone2 != SpinBox_Cone_X2->value())  ||
 379             (_BoundaryAnYcone2 != SpinBox_Cone_Y2->value())  ||
 380             (_BoundaryAnZcone2 != SpinBox_Cone_Z2->value())  ||
 381             (_BoundaryAnRayon2 != SpinBox_Cone_V2->value()) )
 382         {
 383            Chgt = true;
 384           _BoundaryAnXcone1 = SpinBox_Cone_X1->value() ;
 385           _BoundaryAnYcone1 = SpinBox_Cone_Y1->value() ;
 386           _BoundaryAnZcone1 = SpinBox_Cone_Z1->value() ;
 387           _BoundaryAnRayon1 = SpinBox_Cone_V1->value() ;
 388           _BoundaryAnXcone2 = SpinBox_Cone_X2->value() ;
 389           _BoundaryAnYcone2 = SpinBox_Cone_Y2->value() ;
 390           _BoundaryAnZcone2 = SpinBox_Cone_Z2->value() ;
 391           _BoundaryAnRayon2 = SpinBox_Cone_V2->value() ;
 392         }
 393         break;
 394       }
 395       case 5 : // il s agit d un tore
 396       {
 397         if ((_BoundaryAnToreXcentre != SpinBoxToreXcent->value())  ||
 398             (_BoundaryAnToreYcentre != SpinBoxToreYcent->value())  ||
 399             (_BoundaryAnToreZcentre != SpinBoxToreZcent->value())  ||
 400             (_BoundaryAnToreRRev   != SpinBoxToreRRev->value()) ||
 401             (_BoundaryAnToreRPri   != SpinBoxToreRPri->value()) ||
 402             (_BoundaryAnToreXaxe   != SpinBoxToreXaxe->value()) ||
 403             (_BoundaryAnToreYaxe   != SpinBoxToreYaxe->value()) ||
 404             (_BoundaryAnToreZaxe   != SpinBoxToreZaxe->value()) )
 405         {
 406           Chgt = true;
 407           _BoundaryAnToreXcentre= SpinBoxToreXcent->value();
 408           _BoundaryAnToreYcentre= SpinBoxToreYcent->value();
 409           _BoundaryAnToreZcentre= SpinBoxToreZcent->value();
 410           _BoundaryAnToreRRev=SpinBoxToreRRev->value();
 411           _BoundaryAnToreRPri=SpinBoxToreRPri->value();
 412           _BoundaryAnToreXaxe=SpinBoxToreXaxe->value();
 413           _BoundaryAnToreYaxe=SpinBoxToreYaxe->value();
 414           _BoundaryAnToreZaxe=SpinBoxToreZaxe->value();
 415         }
 416         break;
 417       }
 418
 419  }
 420
 421 // Controles
 422 // L'axe pour un cylindre
 423   if ( _Type == 5 )
 424   {
 425     double daux = _BoundaryAnXaxis*_BoundaryAnXaxis + _BoundaryAnYaxis*_BoundaryAnYaxis + _BoundaryAnZaxis*_BoundaryAnZaxis ;
 426     if ( daux < 0.0000001 )
 427     {
 428       QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 429                                 QObject::tr("HOM_AXE") );
 430       return false;
 431     }
 432   }
 433
 434 //
 435 // Création ou mise à jour de la frontière
 436 //
 437   bool bOK = CreateOrUpdateBoundaryAn();
 438
 439   if ( bOK ) { HOMARD_UTILS::updateObjBrowser() ; }
 440
 441   return bOK;
 442
 443 }
 444 // ---------------------------------------------------
 445 bool MonCreateBoundaryAn::CreateOrUpdateBoundaryAn()
 446 //----------------------------------------------------
 447 //  Creation de l'objet boundary
 448 {
 449   MESSAGE("Debut de CreateOrUpdateBoundaryAn avec _Type ="<<_Type<<", _Name ="<<_Name.toStdString().c_str()<<" et LEName ="<<LEName->text().trimmed().toStdString().c_str());
 450 //
 451   if (_Name != LEName->text().trimmed())
 452   {
 453     _Name = LEName->text().trimmed() ;
 454     try
 455     {
 456       switch (_Type)
 457       {
 458         case 1 : // il s agit d un cylindre
 459         { aBoundaryAn = myHomardGen->CreateBoundaryCylinder(CORBA::string_dup(_Name.toStdString().c_str()), \
 460             _BoundaryAnXcentre, _BoundaryAnYcentre, _BoundaryAnZcentre, _BoundaryAnXaxis, _BoundaryAnYaxis, _BoundaryAnZaxis, _BoundaryAnRayon );
 461           break;
 462         }
 463         case 2 : // il s agit d une sphere
 464         { aBoundaryAn = myHomardGen->CreateBoundarySphere(CORBA::string_dup(_Name.toStdString().c_str()), \
 465             _BoundaryAnXcentre, _BoundaryAnYcentre, _BoundaryAnZcentre, _BoundaryAnRayon);
 466           break;
 467        }
 468         case 3 : // il s agit d un cone defini par un axe et un angle
 469         { aBoundaryAn = myHomardGen->CreateBoundaryConeA(CORBA::string_dup(_Name.toStdString().c_str()), \
 470             _BoundaryAnXaxisCone, _BoundaryAnYaxisCone, _BoundaryAnZaxisCone, _BoundaryAngle, \
 471             _BoundaryAnXorigCone, _BoundaryAnYorigCone, _BoundaryAnYorigCone);
 472           break;
 473         }
 474         case 4 : // il s agit d un cone defini par les 2 rayons
 475         { aBoundaryAn = myHomardGen->CreateBoundaryConeR(CORBA::string_dup(_Name.toStdString().c_str()), \
 476             _BoundaryAnXcone1, _BoundaryAnYcone1, _BoundaryAnZcone1, _BoundaryAnRayon1, \
 477             _BoundaryAnXcone2, _BoundaryAnYcone2, _BoundaryAnZcone2, _BoundaryAnRayon2);
 478           break;
 479         }
 480         case 5 : // il s agit d un tore
 481         { aBoundaryAn = myHomardGen->CreateBoundaryTorus(CORBA::string_dup(_Name.toStdString().c_str()), \
 482             _BoundaryAnToreXcentre, _BoundaryAnToreYcentre, _BoundaryAnToreZcentre, _BoundaryAnToreXaxe, _BoundaryAnToreYaxe, _BoundaryAnToreZaxe, _BoundaryAnToreRRev, _BoundaryAnToreRPri );
 483           break;
 484         }
 485       }
 486     }
 487     catch( SALOME::SALOME_Exception& S_ex )
 488     {
 489       QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 490                                 QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 491       return false ;
 492     }
 493     _parent->AddBoundaryAn(_Name);
 494
 495     return true;
 496   }
 497   else {
 498     QMessageBox::warning( 0, QObject::tr("HOM_WARNING"),
 499                              QObject::tr("HOM_SELECT_OBJECT_4") );
 500     return false ;
 501   }
 502   MESSAGE("Fin de CreateOrUpdateBoundaryAn");
 503 }
 504 // ------------------------------------------------------------------------
 505 void MonCreateBoundaryAn::PushOnOK()
 506 // ------------------------------------------------------------------------
 507 {
 508      if (PushOnApply()) this->close();
 509 }
 510 // ------------------------------------------------------------------------
 511 void MonCreateBoundaryAn::PushOnHelp()
 512 // ------------------------------------------------------------------------
 513 {
 514   std::string LanguageShort = myHomardGen->GetLanguageShort();
 515   HOMARD_UTILS::PushOnHelp(QString("gui_create_boundary.html"), QString("un-cylindre"), QString(LanguageShort.c_str()));
 516 }
 517
 518 // -----------------------------------
 519 void MonCreateBoundaryAn::SetNewName()
 520 // -----------------------------------
 521 {
 522 // Recherche d'un nom par defaut qui n'existe pas encore
 523
 524   HOMARD::listeBoundarys_var MyObjects = myHomardGen->GetAllBoundarysName();
 525   int num = 0; QString aName="";
 526   while (aName=="" )
 527   {
 528     aName.setNum(num+1) ;
 529     aName.insert(0, QString("Boun_")) ;
 530     for ( int i=0; i<MyObjects->length(); i++)
 531     {
 532       if ( aName ==  QString(MyObjects[i]))
 533       {
 534         num ++ ;
 535         aName = "" ;
 536         break ;
 537       }
 538    }
 539   }
 540   LEName->setText(aName);
 541 }
 542 // ------------------------------------------------------------------------
 543 void MonCreateBoundaryAn::SetCylinder()
 544 // ------------------------------------------------------------------------
 545 {
 546   MESSAGE("Debut de SetCylinder")
 547   gBCylindre->setVisible(1);
 548   gBSphere->setVisible(0);
 549   gBCone->setVisible(0);
 550   gBTore->setVisible(0);
 551 //
 552   _Type=1;
 553 //
 554   adjustSize();
 555 //   MESSAGE("Fin de SetCylinder")
 556 }
 557 // ------------------------------------------------------------------------
 558 void MonCreateBoundaryAn::SetSphere()
 559 // ------------------------------------------------------------------------
 560 {
 561   MESSAGE("Debut de SetSphere")
 562   gBCylindre->setVisible(0);
 563   gBSphere->setVisible(1);
 564   gBCone->setVisible(0);
 565   gBTore->setVisible(0);
 566 //
 567   _Type=2;
 568 //
 569   adjustSize();
 570 //   MESSAGE("Fin de SetSphere")
 571 }
 572 // ------------------------------------------------------------------------
 573 void MonCreateBoundaryAn::SetConeR()
 574 // ------------------------------------------------------------------------
 575 {
 576   MESSAGE("Debut de SetConeR")
 577 //
 578 // Stockage et conversion des valeurs si elles ont change
 579   if ((_BoundaryAnXaxisCone != SpinBox_Cone_X1->value())  ||
 580       (_BoundaryAnYaxisCone != SpinBox_Cone_Y1->value())  ||
 581       (_BoundaryAnZaxisCone != SpinBox_Cone_Z1->value())  ||
 582       (_BoundaryAnXorigCone != SpinBox_Cone_X2->value())  ||
 583       (_BoundaryAnYorigCone != SpinBox_Cone_Y2->value())  ||
 584       (_BoundaryAnZorigCone != SpinBox_Cone_Z2->value())  ||
 585       (_BoundaryAngle       != SpinBox_Cone_V1->value()) )
 586   {
 587     MESSAGE("Stockage et conversion")
 588     _BoundaryAnXaxisCone = SpinBox_Cone_X1->value() ;
 589     _BoundaryAnYaxisCone = SpinBox_Cone_Y1->value() ;
 590     _BoundaryAnZaxisCone = SpinBox_Cone_Z1->value() ;
 591     _BoundaryAnXorigCone = SpinBox_Cone_X2->value() ;
 592     _BoundaryAnYorigCone = SpinBox_Cone_Y2->value() ;
 593     _BoundaryAnZorigCone = SpinBox_Cone_Z2->value() ;
 594     _BoundaryAngle       = SpinBox_Cone_V1->value() ;
 595     convertRayonAngle(-1) ;
 596   }
 597 //
 598   _Type=4;
 599 //
 600   TLCone_X1->setText(QApplication::translate("CreateBoundaryAn", "X centre 1", 0));
 601   SpinBox_Cone_X1->setValue(_BoundaryAnXcone1);
 602   TLCone_Y1->setText(QApplication::translate("CreateBoundaryAn", "Y centre 1", 0));
 603   SpinBox_Cone_Y1->setValue(_BoundaryAnYcone1);
 604   TLCone_Z1->setText(QApplication::translate("CreateBoundaryAn", "Z centre 1", 0));
 605   SpinBox_Cone_Z1->setValue(_BoundaryAnZcone1);
 606 //
 607   TLCone_V1->setText(QApplication::translate("CreateBoundaryAn", "Radius 1", 0));
 608   SpinBox_Cone_V1->setSingleStep(_Rayon/10.);
 609   SpinBox_Cone_V1->setMaximum(100000.*_DMax);
 610   SpinBox_Cone_V1->setValue(_BoundaryAnRayon1);
 611 //
 612   TLCone_X2->setText(QApplication::translate("CreateBoundaryAn", "X centre 2", 0));
 613   SpinBox_Cone_X2->setValue(_BoundaryAnXcone2);
 614   TLCone_Y2->setText(QApplication::translate("CreateBoundaryAn", "Y centre 2", 0));
 615   SpinBox_Cone_Y2->setValue(_BoundaryAnYcone2);
 616   TLCone_Z2->setText(QApplication::translate("CreateBoundaryAn", "Z centre 2", 0));
 617   SpinBox_Cone_Z2->setValue(_BoundaryAnZcone2);
 618 //
 619   TLCone_V2->setVisible(1);
 620   SpinBox_Cone_V2->setVisible(1);
 621   TLCone_V2->setText(QApplication::translate("CreateBoundaryAn", "Radius 2", 0));
 622   SpinBox_Cone_V2->setValue(_BoundaryAnRayon2);
 623 //
 624 //   MESSAGE("Fin de SetConeR")
 625 }
 626 // ------------------------------------------------------------------------
 627 void MonCreateBoundaryAn::SetConeA()
 628 // ------------------------------------------------------------------------
 629 {
 630   MESSAGE("Debut de SetConeA")
 631 // Stockage et conversion des valeurs si elles ont change
 632   if ((_BoundaryAnXcone1 != SpinBox_Cone_X1->value())  ||
 633       (_BoundaryAnYcone1 != SpinBox_Cone_Y1->value())  ||
 634       (_BoundaryAnZcone1 != SpinBox_Cone_Z1->value())  ||
 635       (_BoundaryAnRayon1 != SpinBox_Cone_V1->value())  ||
 636       (_BoundaryAnXcone2 != SpinBox_Cone_X2->value())  ||
 637       (_BoundaryAnYcone2 != SpinBox_Cone_Y2->value())  ||
 638       (_BoundaryAnZcone2 != SpinBox_Cone_Z2->value())  ||
 639       (_BoundaryAnRayon2 != SpinBox_Cone_V2->value()) )
 640   {
 641     MESSAGE("Stockage et conversion")
 642     _BoundaryAnXcone1 = SpinBox_Cone_X1->value() ;
 643     _BoundaryAnYcone1 = SpinBox_Cone_Y1->value() ;
 644     _BoundaryAnZcone1 = SpinBox_Cone_Z1->value() ;
 645     _BoundaryAnRayon1 = SpinBox_Cone_V1->value() ;
 646     _BoundaryAnXcone2 = SpinBox_Cone_X2->value() ;
 647     _BoundaryAnYcone2 = SpinBox_Cone_Y2->value() ;
 648     _BoundaryAnZcone2 = SpinBox_Cone_Z2->value() ;
 649     _BoundaryAnRayon2 = SpinBox_Cone_V2->value() ;
 650     convertRayonAngle(1) ;
 651   }
 652 //
 653   _Type=3;
 654 //
 655   TLCone_X1->setText(QApplication::translate("CreateBoundaryAn", "X axis", 0));
 656   SpinBox_Cone_X1->setValue(_BoundaryAnXaxisCone);
 657   TLCone_Y1->setText(QApplication::translate("CreateBoundaryAn", "Y axis", 0));
 658   SpinBox_Cone_Y1->setValue(_BoundaryAnYaxisCone);
 659   TLCone_Z1->setText(QApplication::translate("CreateBoundaryAn", "Z axis", 0));
 660   SpinBox_Cone_Z1->setValue(_BoundaryAnZaxisCone);
 661 //
 662   TLCone_X2->setText(QApplication::translate("CreateBoundaryAn", "X centre", 0));
 663   SpinBox_Cone_X2->setValue(_BoundaryAnXorigCone);
 664   TLCone_Y2->setText(QApplication::translate("CreateBoundaryAn", "Y centre", 0));
 665   SpinBox_Cone_Y2->setValue(_BoundaryAnYorigCone);
 666   TLCone_Z2->setText(QApplication::translate("CreateBoundaryAn", "Z centre", 0));
 667   SpinBox_Cone_Z2->setValue(_BoundaryAnZorigCone);
 668 //
 669   TLCone_V1->setText(QApplication::translate("CreateBoundaryAn", "Angle", 0));
 670   SpinBox_Cone_V1->setValue(_BoundaryAngle);
 671   SpinBox_Cone_V1->setSingleStep(1.);
 672   SpinBox_Cone_V1->setMaximum(90.);
 673 //
 674   TLCone_V2->setVisible(0);
 675   SpinBox_Cone_V2->setVisible(0);
 676 //   MESSAGE("Fin de SetConeA")
 677 }
 678
 679
 680 // ------------------------------------------------------------------------
 681 void MonCreateBoundaryAn::SetCone()
 682 // ------------------------------------------------------------------------
 683 {
 684   MESSAGE("Debut de SetCone")
 685   gBCylindre->setVisible(0);
 686   gBSphere->setVisible(0);
 687   gBCone->setVisible(1);
 688   gBTore->setVisible(0);
 689 //
 690   if ( RB_Def_radius->isChecked() )
 691   {
 692     SetConeR();
 693   }
 694   else
 695   {
 696     SetConeA();
 697   }
 698 //
 699   adjustSize();
 700 //   MESSAGE("Fin de SetCone")
 701 }
 702 // ------------------------------------------------------------------------
 703 void MonCreateBoundaryAn::SetTore()
 704 // ------------------------------------------------------------------------
 705 {
 706   MESSAGE("Debut de SetTore")
 707   gBCylindre->setVisible(0);
 708   gBSphere->setVisible(0);
 709   gBCone->setVisible(0);
 710   gBTore->setVisible(1);
 711 //
 712   _Type=5;
 713 //
 714   adjustSize();
 715 //   MESSAGE("Fin de SetTore")
 716 }
 717 // ------------------------------------------------------------------------
 718 void MonCreateBoundaryAn::convertRayonAngle(int option)
 719 // ------------------------------------------------------------------------
 720 // Conversion entre les deux formulations du cone :
 721 // par deux rayons ou avec un axe et un angle.
 722 // Voir sfcoi1 de HOMARD
 723 {
 724   MESSAGE("Debut de convertRayonAngle, option = "<<option)
 725 //
 726 //         o
 727 //         !    .
 728 //         !        .
 729 //       RA!            .
 730 //         !                o
 731 //         !              RB!   .
 732 //         !                !       .
 733 //         A----------------B----------O
 734 //
 735 //   Thales : RA/RB = AO/BO  ==> BO = AB*RB/(RA-RB)
 736 //   Angle  : tg(alpha) = RA/AO
 737 //
 738   double daux ;
 739 // De rayon vers angle :
 740   if ( option == 1 )
 741   {
 742     double xa, ya, za, ra ;
 743     double xb, yb, zb, rb ;
 744 // Positionnement de A vers B, avec RA>RB
 745     if ( _BoundaryAnRayon1 > _BoundaryAnRayon2 )
 746     {
 747       xa = _BoundaryAnXcone1 ;
 748       ya = _BoundaryAnYcone1 ;
 749       za = _BoundaryAnZcone1 ;
 750       ra = _BoundaryAnRayon1 ;
 751       xb = _BoundaryAnXcone2 ;
 752       yb = _BoundaryAnYcone2 ;
 753       zb = _BoundaryAnZcone2 ;
 754       rb = _BoundaryAnRayon2 ;
 755     }
 756     else
 757     {
 758       xa = _BoundaryAnXcone2 ;
 759       ya = _BoundaryAnYcone2 ;
 760       za = _BoundaryAnZcone2 ;
 761       ra = _BoundaryAnRayon2 ;
 762       xb = _BoundaryAnXcone1 ;
 763       yb = _BoundaryAnYcone1 ;
 764       zb = _BoundaryAnZcone1 ;
 765       rb = _BoundaryAnRayon1 ;
 766     }
 767 // Axe : relie les deux centres, de A vers B.  L'axe est normalise
 768     _BoundaryAnXaxisCone = xb - xa ;
 769     _BoundaryAnYaxisCone = yb - ya ;
 770     _BoundaryAnZaxisCone = zb - za ;
 771     daux = sqrt ( _BoundaryAnXaxisCone*_BoundaryAnXaxisCone + _BoundaryAnYaxisCone*_BoundaryAnYaxisCone + _BoundaryAnZaxisCone*_BoundaryAnZaxisCone ) ;
 772     _BoundaryAnXaxisCone = _BoundaryAnXaxisCone/daux ;
 773     _BoundaryAnYaxisCone = _BoundaryAnYaxisCone/daux ;
 774     _BoundaryAnZaxisCone = _BoundaryAnZaxisCone/daux ;
 775 // Origine
 776     daux = daux * rb / (ra-rb) ;
 777     _BoundaryAnXorigCone = xb + daux*_BoundaryAnXaxisCone ;
 778     _BoundaryAnYorigCone = yb + daux*_BoundaryAnYaxisCone ;
 779     _BoundaryAnZorigCone = zb + daux*_BoundaryAnZaxisCone ;
 780 // Angle en degre
 781     daux = ra / sqrt((_BoundaryAnXorigCone-xa)*(_BoundaryAnXorigCone-xa) + (_BoundaryAnYorigCone-ya)*(_BoundaryAnYorigCone-ya) + (_BoundaryAnZorigCone-za)*(_BoundaryAnZorigCone-za) ) ;
 782     _BoundaryAngle = atan(daux)*180./PI ;
 783   }
 784 // D'angle vers rayon :
 785   else
 786   {
 787     double xax, yax, zax ;
 788 // L'axe est normalise
 789     daux = sqrt ( _BoundaryAnXaxisCone*_BoundaryAnXaxisCone + _BoundaryAnYaxisCone*_BoundaryAnYaxisCone + _BoundaryAnZaxisCone*_BoundaryAnZaxisCone ) ;
 790     xax = _BoundaryAnXaxisCone/daux ;
 791     yax = _BoundaryAnYaxisCone/daux ;
 792     zax = _BoundaryAnZaxisCone/daux ;
 793 // Centre 1 : l'origine
 794     _BoundaryAnXcone1 = _BoundaryAnXorigCone ;
 795     _BoundaryAnYcone1 = _BoundaryAnYorigCone ;
 796     _BoundaryAnZcone1 = _BoundaryAnZorigCone ;
 797 // Rayon 1 : nul
 798     _BoundaryAnRayon1 = 0. ;
 799 // Centre 2 : l'origine decalee d'une longueur arbitraire le long de l'axe
 800     _BoundaryAnXcone2 = _BoundaryAnXorigCone + _DMax*xax ;
 801     _BoundaryAnYcone2 = _BoundaryAnYorigCone + _DMax*yax ;
 802     _BoundaryAnZcone2 = _BoundaryAnZorigCone + _DMax*zax ;
 803 // Rayon 2 : a calculer
 804     _BoundaryAnRayon2 = _DMax*tan(_BoundaryAngle*PI/180.) ;
 805   }
 806 //   MESSAGE("Fin de convertRayonAngle")
 807 }
 808
 809