src/HOMARDGUI/MonCreateBoundaryAn.cxx

   1 // Copyright (C) 2011-2015  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 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     _BoundaryAnToreXcentre(0), _BoundaryAnToreYcentre(0), _BoundaryAnToreZcentre(0),
  64     _BoundaryAnToreXaxe(0), _BoundaryAnToreYaxe(0), _BoundaryAnToreZaxe(0),
  65     _BoundaryAnToreRRev(0), _BoundaryAnToreRPri(0),
  66     Chgt (false)
  67     {
  68       MESSAGE("Constructeur") ;
  69       myHomardGen=HOMARD::HOMARD_Gen::_duplicate(myHomardGen0);
  70       setupUi(this);
  71       setModal(modal);
  72
  73     //  Gestion des icones
  74       QPixmap pix ;
  75       QIcon IS ;
  76       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
  77       pix = resMgr->loadPixmap( "HOMARD", "spherepoint.png" );
  78       IS=QIcon(pix);
  79       RBSphere->setIcon(IS);
  80       pix = resMgr->loadPixmap( "HOMARD", "cylinderpointvector.png" );
  81       IS=QIcon(pix);
  82       RBCylindre->setIcon(IS);
  83       pix = resMgr->loadPixmap( "HOMARD", "cone.png" );
  84       IS=QIcon(pix);
  85       RBCone->setIcon(IS);
  86       pix = resMgr->loadPixmap( "HOMARD", "conepointvector.png" );
  87       IS=QIcon(pix);
  88       RB_Def_angle->setIcon(IS);
  89       pix = resMgr->loadPixmap( "HOMARD", "conedxyz.png" );
  90       IS=QIcon(pix);
  91       RB_Def_radius->setIcon(IS);
  92       pix = resMgr->loadPixmap( "HOMARD", "toruspointvector.png" );
  93       IS=QIcon(pix);
  94       RBTore->setIcon(IS);
  95
  96       InitConnect( );
  97
  98       SetNewName() ;
  99       InitValBoundaryAn();          // Cherche les valeurs de la boite englobante le maillage
 100       InitMinMax();                 // Initialise les bornes des boutons
 101       SetCylinder();                // Propose un cylindre en premier choix
 102     }
 103 // --------------------------------------------------------------------------------------------------------------
 104 MonCreateBoundaryAn::MonCreateBoundaryAn(MonCreateCase* parent,
 105                              HOMARD::HOMARD_Gen_var myHomardGen0,
 106                              QString caseName):
 107 // --------------------------------------------------------------------------------------------------------------
 108 // Constructeur appele par MonEditBoundaryAn
 109 //
 110     QDialog(0), Ui_CreateBoundaryAn(),
 111      myHomardGen(myHomardGen0),
 112     _parent(parent),
 113     _aName (""),
 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   bool bOK = CreateOrUpdateBoundaryAn();
 422
 423   if ( bOK ) { HOMARD_UTILS::updateObjBrowser() ; }
 424
 425   return bOK;
 426
 427 }
 428 // ---------------------------------------------------
 429 bool MonCreateBoundaryAn:: CreateOrUpdateBoundaryAn()
 430 //----------------------------------------------------
 431 //  Creation de l'objet boundary
 432 {
 433   _aName = LEName->text().trimmed();
 434   switch (_Type)
 435   {
 436     case 1 : // il s agit d un cylindre
 437     {
 438       try
 439       {
 440         aBoundaryAn = myHomardGen->CreateBoundaryCylinder(CORBA::string_dup(_aName.toStdString().c_str()), \
 441         _BoundaryAnXcentre, _BoundaryAnYcentre, _BoundaryAnZcentre, _BoundaryAnXaxis, _BoundaryAnYaxis, _BoundaryAnZaxis, _BoundaryAnRayon );
 442       }
 443       catch( SALOME::SALOME_Exception& S_ex )
 444       {
 445         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 446                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 447         return false ;
 448       }
 449       break;
 450     }
 451     case 2 : // il s agit d une sphere
 452     {
 453       try
 454       {
 455         aBoundaryAn = myHomardGen->CreateBoundarySphere(CORBA::string_dup(_aName.toStdString().c_str()), \
 456         _BoundaryAnXcentre, _BoundaryAnYcentre, _BoundaryAnZcentre, _BoundaryAnRayon);
 457       }
 458       catch( SALOME::SALOME_Exception& S_ex )
 459       {
 460         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 461                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 462         return false ;
 463       }
 464       break;
 465     }
 466     case 3 : // il s agit d un cone defini par un axe et un angle
 467     {
 468       try
 469       {
 470         aBoundaryAn = myHomardGen->CreateBoundaryConeA(CORBA::string_dup(_aName.toStdString().c_str()), \
 471         _BoundaryAnXaxisCone, _BoundaryAnYaxisCone, _BoundaryAnZaxisCone, _BoundaryAngle, \
 472         _BoundaryAnXorigCone, _BoundaryAnYorigCone, _BoundaryAnYorigCone);
 473       }
 474       catch( SALOME::SALOME_Exception& S_ex )
 475       {
 476         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 477                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 478         return false ;
 479       }
 480       break;
 481     }
 482     case 4 : // il s agit d un cone defini par les 2 rayons
 483     {
 484       try
 485       {
 486         aBoundaryAn = myHomardGen->CreateBoundaryConeR(CORBA::string_dup(_aName.toStdString().c_str()), \
 487         _BoundaryAnXcone1, _BoundaryAnYcone1, _BoundaryAnZcone1, _BoundaryAnRayon1, \
 488         _BoundaryAnXcone2, _BoundaryAnYcone2, _BoundaryAnZcone2, _BoundaryAnRayon2);
 489       }
 490       catch( SALOME::SALOME_Exception& S_ex )
 491       {
 492         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 493                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 494         return false ;
 495       }
 496       break;
 497     }
 498    case 5 : // il s agit d un tore
 499     {
 500       try
 501       {
 502         aBoundaryAn = myHomardGen->CreateBoundaryTorus(CORBA::string_dup(_aName.toStdString().c_str()), \
 503         _BoundaryAnToreXcentre, _BoundaryAnToreYcentre, _BoundaryAnToreZcentre, _BoundaryAnToreXaxe, _BoundaryAnToreYaxe, _BoundaryAnToreZaxe, _BoundaryAnToreRRev, _BoundaryAnToreRPri );
 504       }
 505       catch( SALOME::SALOME_Exception& S_ex )
 506       {
 507         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 508                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 509         return false ;
 510      }
 511       break;
 512     }
 513   }
 514   _parent->AddBoundaryAn(_aName);
 515
 516   return true;
 517 }
 518 // ------------------------------------------------------------------------
 519 void MonCreateBoundaryAn::PushOnOK()
 520 // ------------------------------------------------------------------------
 521 {
 522      if (PushOnApply()) this->close();
 523 }
 524 // ------------------------------------------------------------------------
 525 void MonCreateBoundaryAn::PushOnHelp()
 526 // ------------------------------------------------------------------------
 527 {
 528   std::string LanguageShort = myHomardGen->GetLanguageShort();
 529   HOMARD_UTILS::PushOnHelp(QString("gui_create_boundary.html"), QString("un-cylindre"), QString(LanguageShort.c_str()));
 530 }
 531
 532 // -----------------------------------
 533 void MonCreateBoundaryAn::SetNewName()
 534 // -----------------------------------
 535 {
 536 // Recherche d'un nom par defaut qui n'existe pas encore
 537
 538   HOMARD::listeBoundarys_var MyObjects = myHomardGen->GetAllBoundarysName();
 539   int num = 0; QString aName="";
 540   while (aName=="" )
 541   {
 542     aName.setNum(num+1) ;
 543     aName.insert(0, QString("Boun_")) ;
 544     for ( int i=0; i<MyObjects->length(); i++)
 545     {
 546       if ( aName ==  QString(MyObjects[i]))
 547       {
 548         num ++ ;
 549         aName = "" ;
 550         break ;
 551       }
 552    }
 553   }
 554   LEName->setText(aName);
 555 }
 556 // ------------------------------------------------------------------------
 557 void MonCreateBoundaryAn::SetCylinder()
 558 // ------------------------------------------------------------------------
 559 {
 560   MESSAGE("Debut de SetCylinder")
 561   gBCylindre->setVisible(1);
 562   gBSphere->setVisible(0);
 563   gBCone->setVisible(0);
 564   gBTore->setVisible(0);
 565 //
 566   _Type=1;
 567 //
 568   adjustSize();
 569 //   MESSAGE("Fin de SetCylinder")
 570 }
 571 // ------------------------------------------------------------------------
 572 void MonCreateBoundaryAn::SetSphere()
 573 // ------------------------------------------------------------------------
 574 {
 575   MESSAGE("Debut de SetSphere")
 576   gBCylindre->setVisible(0);
 577   gBSphere->setVisible(1);
 578   gBCone->setVisible(0);
 579   gBTore->setVisible(0);
 580 //
 581   _Type=2;
 582 //
 583   adjustSize();
 584 //   MESSAGE("Fin de SetSphere")
 585 }
 586 // ------------------------------------------------------------------------
 587 void MonCreateBoundaryAn::SetConeR()
 588 // ------------------------------------------------------------------------
 589 {
 590   MESSAGE("Debut de SetConeR")
 591 //
 592 // Stockage et conversion des valeurs si elles ont change
 593   if ((_BoundaryAnXaxisCone != SpinBox_Cone_X1->value())  ||
 594       (_BoundaryAnYaxisCone != SpinBox_Cone_Y1->value())  ||
 595       (_BoundaryAnZaxisCone != SpinBox_Cone_Z1->value())  ||
 596       (_BoundaryAnXorigCone != SpinBox_Cone_X2->value())  ||
 597       (_BoundaryAnYorigCone != SpinBox_Cone_Y2->value())  ||
 598       (_BoundaryAnZorigCone != SpinBox_Cone_Z2->value())  ||
 599       (_BoundaryAngle       != SpinBox_Cone_V1->value()) )
 600   {
 601     MESSAGE("Stockage et conversion")
 602     _BoundaryAnXaxisCone = SpinBox_Cone_X1->value() ;
 603     _BoundaryAnYaxisCone = SpinBox_Cone_Y1->value() ;
 604     _BoundaryAnZaxisCone = SpinBox_Cone_Z1->value() ;
 605     _BoundaryAnXorigCone = SpinBox_Cone_X2->value() ;
 606     _BoundaryAnYorigCone = SpinBox_Cone_Y2->value() ;
 607     _BoundaryAnZorigCone = SpinBox_Cone_Z2->value() ;
 608     _BoundaryAngle       = SpinBox_Cone_V1->value() ;
 609     convertRayonAngle(-1) ;
 610   }
 611 //
 612   _Type=4;
 613 //
 614   TLCone_X1->setText(QApplication::translate("CreateBoundaryAn", "X centre 1", 0, QApplication::UnicodeUTF8));
 615   SpinBox_Cone_X1->setValue(_BoundaryAnXcone1);
 616   TLCone_Y1->setText(QApplication::translate("CreateBoundaryAn", "Y centre 1", 0, QApplication::UnicodeUTF8));
 617   SpinBox_Cone_Y1->setValue(_BoundaryAnYcone1);
 618   TLCone_Z1->setText(QApplication::translate("CreateBoundaryAn", "Z centre 1", 0, QApplication::UnicodeUTF8));
 619   SpinBox_Cone_Z1->setValue(_BoundaryAnZcone1);
 620 //
 621   TLCone_V1->setText(QApplication::translate("CreateBoundaryAn", "Radius 1", 0, QApplication::UnicodeUTF8));
 622   SpinBox_Cone_V1->setSingleStep(_Rayon/10.);
 623   SpinBox_Cone_V1->setMaximum(100000.*_DMax);
 624   SpinBox_Cone_V1->setValue(_BoundaryAnRayon1);
 625 //
 626   TLCone_X2->setText(QApplication::translate("CreateBoundaryAn", "X centre 2", 0, QApplication::UnicodeUTF8));
 627   SpinBox_Cone_X2->setValue(_BoundaryAnXcone2);
 628   TLCone_Y2->setText(QApplication::translate("CreateBoundaryAn", "Y centre 2", 0, QApplication::UnicodeUTF8));
 629   SpinBox_Cone_Y2->setValue(_BoundaryAnYcone2);
 630   TLCone_Z2->setText(QApplication::translate("CreateBoundaryAn", "Z centre 2", 0, QApplication::UnicodeUTF8));
 631   SpinBox_Cone_Z2->setValue(_BoundaryAnZcone2);
 632 //
 633   TLCone_V2->setVisible(1);
 634   SpinBox_Cone_V2->setVisible(1);
 635   TLCone_V2->setText(QApplication::translate("CreateBoundaryAn", "Radius 2", 0, QApplication::UnicodeUTF8));
 636   SpinBox_Cone_V2->setValue(_BoundaryAnRayon2);
 637 //
 638 //   MESSAGE("Fin de SetConeR")
 639 }
 640 // ------------------------------------------------------------------------
 641 void MonCreateBoundaryAn::SetConeA()
 642 // ------------------------------------------------------------------------
 643 {
 644   MESSAGE("Debut de SetConeA")
 645 // Stockage et conversion des valeurs si elles ont change
 646   if ((_BoundaryAnXcone1 != SpinBox_Cone_X1->value())  ||
 647       (_BoundaryAnYcone1 != SpinBox_Cone_Y1->value())  ||
 648       (_BoundaryAnZcone1 != SpinBox_Cone_Z1->value())  ||
 649       (_BoundaryAnRayon1 != SpinBox_Cone_V1->value())  ||
 650       (_BoundaryAnXcone2 != SpinBox_Cone_X2->value())  ||
 651       (_BoundaryAnYcone2 != SpinBox_Cone_Y2->value())  ||
 652       (_BoundaryAnZcone2 != SpinBox_Cone_Z2->value())  ||
 653       (_BoundaryAnRayon2 != SpinBox_Cone_V2->value()) )
 654   {
 655     MESSAGE("Stockage et conversion")
 656     _BoundaryAnXcone1 = SpinBox_Cone_X1->value() ;
 657     _BoundaryAnYcone1 = SpinBox_Cone_Y1->value() ;
 658     _BoundaryAnZcone1 = SpinBox_Cone_Z1->value() ;
 659     _BoundaryAnRayon1 = SpinBox_Cone_V1->value() ;
 660     _BoundaryAnXcone2 = SpinBox_Cone_X2->value() ;
 661     _BoundaryAnYcone2 = SpinBox_Cone_Y2->value() ;
 662     _BoundaryAnZcone2 = SpinBox_Cone_Z2->value() ;
 663     _BoundaryAnRayon2 = SpinBox_Cone_V2->value() ;
 664     convertRayonAngle(1) ;
 665   }
 666 //
 667   _Type=3;
 668 //
 669   TLCone_X1->setText(QApplication::translate("CreateBoundaryAn", "X axis", 0, QApplication::UnicodeUTF8));
 670   SpinBox_Cone_X1->setValue(_BoundaryAnXaxisCone);
 671   TLCone_Y1->setText(QApplication::translate("CreateBoundaryAn", "Y axis", 0, QApplication::UnicodeUTF8));
 672   SpinBox_Cone_Y1->setValue(_BoundaryAnYaxisCone);
 673   TLCone_Z1->setText(QApplication::translate("CreateBoundaryAn", "Z axis", 0, QApplication::UnicodeUTF8));
 674   SpinBox_Cone_Z1->setValue(_BoundaryAnZaxisCone);
 675 //
 676   TLCone_X2->setText(QApplication::translate("CreateBoundaryAn", "X centre", 0, QApplication::UnicodeUTF8));
 677   SpinBox_Cone_X2->setValue(_BoundaryAnXorigCone);
 678   TLCone_Y2->setText(QApplication::translate("CreateBoundaryAn", "Y centre", 0, QApplication::UnicodeUTF8));
 679   SpinBox_Cone_Y2->setValue(_BoundaryAnYorigCone);
 680   TLCone_Z2->setText(QApplication::translate("CreateBoundaryAn", "Z centre", 0, QApplication::UnicodeUTF8));
 681   SpinBox_Cone_Z2->setValue(_BoundaryAnZorigCone);
 682 //
 683   TLCone_V1->setText(QApplication::translate("CreateBoundaryAn", "Angle", 0, QApplication::UnicodeUTF8));
 684   SpinBox_Cone_V1->setValue(_BoundaryAngle);
 685   SpinBox_Cone_V1->setSingleStep(1.);
 686   SpinBox_Cone_V1->setMaximum(90.);
 687 //
 688   TLCone_V2->setVisible(0);
 689   SpinBox_Cone_V2->setVisible(0);
 690 //   MESSAGE("Fin de SetConeA")
 691 }
 692
 693
 694 // ------------------------------------------------------------------------
 695 void MonCreateBoundaryAn::SetCone()
 696 // ------------------------------------------------------------------------
 697 {
 698   MESSAGE("Debut de SetCone")
 699   gBCylindre->setVisible(0);
 700   gBSphere->setVisible(0);
 701   gBCone->setVisible(1);
 702   gBTore->setVisible(0);
 703 //
 704   if ( RB_Def_radius->isChecked() )
 705   {
 706     SetConeR();
 707   }
 708   else
 709   {
 710     SetConeA();
 711   }
 712 //
 713   adjustSize();
 714 //   MESSAGE("Fin de SetCone")
 715 }
 716 // ------------------------------------------------------------------------
 717 void MonCreateBoundaryAn::SetTore()
 718 // ------------------------------------------------------------------------
 719 {
 720   MESSAGE("Debut de SetTore")
 721   gBCylindre->setVisible(0);
 722   gBSphere->setVisible(0);
 723   gBCone->setVisible(0);
 724   gBTore->setVisible(1);
 725 //
 726   _Type=5;
 727 //
 728   adjustSize();
 729 //   MESSAGE("Fin de SetTore")
 730 }
 731 // ------------------------------------------------------------------------
 732 void MonCreateBoundaryAn::convertRayonAngle(int option)
 733 // ------------------------------------------------------------------------
 734 // Conversion entre les deux formulations du cone :
 735 // par deux rayons ou avec un axe et un angle.
 736 // Voir sfcoi1 de HOMARD
 737 {
 738   MESSAGE("Debut de convertRayonAngle, option = "<<option)
 739 //
 740 //         o
 741 //         !    .
 742 //         !        .
 743 //       RA!            .
 744 //         !                o
 745 //         !              RB!   .
 746 //         !                !       .
 747 //         A----------------B----------O
 748 //
 749 //   Thales : RA/RB = AO/BO  ==> BO = AB*RB/(RA-RB)
 750 //   Angle  : tg(alpha) = RA/AO
 751 //
 752   double daux ;
 753 // De rayon vers angle :
 754   if ( option == 1 )
 755   {
 756     double xa, ya, za, ra ;
 757     double xb, yb, zb, rb ;
 758 // Positionnement de A vers B, avec RA>RB
 759     if ( _BoundaryAnRayon1 > _BoundaryAnRayon2 )
 760     {
 761       xa = _BoundaryAnXcone1 ;
 762       ya = _BoundaryAnYcone1 ;
 763       za = _BoundaryAnZcone1 ;
 764       ra = _BoundaryAnRayon1 ;
 765       xb = _BoundaryAnXcone2 ;
 766       yb = _BoundaryAnYcone2 ;
 767       zb = _BoundaryAnZcone2 ;
 768       rb = _BoundaryAnRayon2 ;
 769     }
 770     else
 771     {
 772       xa = _BoundaryAnXcone2 ;
 773       ya = _BoundaryAnYcone2 ;
 774       za = _BoundaryAnZcone2 ;
 775       ra = _BoundaryAnRayon2 ;
 776       xb = _BoundaryAnXcone1 ;
 777       yb = _BoundaryAnYcone1 ;
 778       zb = _BoundaryAnZcone1 ;
 779       rb = _BoundaryAnRayon1 ;
 780     }
 781 // Axe : relie les deux centres, de A vers B.  L'axe est normalise
 782     _BoundaryAnXaxisCone = xb - xa ;
 783     _BoundaryAnYaxisCone = yb - ya ;
 784     _BoundaryAnZaxisCone = zb - za ;
 785     daux = sqrt ( _BoundaryAnXaxisCone*_BoundaryAnXaxisCone + _BoundaryAnYaxisCone*_BoundaryAnYaxisCone + _BoundaryAnZaxisCone*_BoundaryAnZaxisCone ) ;
 786     _BoundaryAnXaxisCone = _BoundaryAnXaxisCone/daux ;
 787     _BoundaryAnYaxisCone = _BoundaryAnYaxisCone/daux ;
 788     _BoundaryAnZaxisCone = _BoundaryAnZaxisCone/daux ;
 789 // Origine
 790     daux = daux * rb / (ra-rb) ;
 791     _BoundaryAnXorigCone = xb + daux*_BoundaryAnXaxisCone ;
 792     _BoundaryAnYorigCone = yb + daux*_BoundaryAnYaxisCone ;
 793     _BoundaryAnZorigCone = zb + daux*_BoundaryAnZaxisCone ;
 794 // Angle en degre
 795     daux = ra / sqrt((_BoundaryAnXorigCone-xa)*(_BoundaryAnXorigCone-xa) + (_BoundaryAnYorigCone-ya)*(_BoundaryAnYorigCone-ya) + (_BoundaryAnZorigCone-za)*(_BoundaryAnZorigCone-za) ) ;
 796     _BoundaryAngle = atan(daux)*180./PI ;
 797   }
 798 // D'angle vers rayon :
 799   else
 800   {
 801     double xax, yax, zax ;
 802 // L'axe est normalise
 803     daux = sqrt ( _BoundaryAnXaxisCone*_BoundaryAnXaxisCone + _BoundaryAnYaxisCone*_BoundaryAnYaxisCone + _BoundaryAnZaxisCone*_BoundaryAnZaxisCone ) ;
 804     xax = _BoundaryAnXaxisCone/daux ;
 805     yax = _BoundaryAnYaxisCone/daux ;
 806     zax = _BoundaryAnZaxisCone/daux ;
 807 // Centre 1 : l'origine
 808     _BoundaryAnXcone1 = _BoundaryAnXorigCone ;
 809     _BoundaryAnYcone1 = _BoundaryAnYorigCone ;
 810     _BoundaryAnZcone1 = _BoundaryAnZorigCone ;
 811 // Rayon 1 : nul
 812     _BoundaryAnRayon1 = 0. ;
 813 // Centre 2 : l'origine decalee d'une longueur arbitraire le long de l'axe
 814     _BoundaryAnXcone2 = _BoundaryAnXorigCone + _DMax*xax ;
 815     _BoundaryAnYcone2 = _BoundaryAnYorigCone + _DMax*yax ;
 816     _BoundaryAnZcone2 = _BoundaryAnZorigCone + _DMax*zax ;
 817 // Rayon 2 : a calculer
 818     _BoundaryAnRayon2 = _DMax*tan(_BoundaryAngle*PI/180.) ;
 819   }
 820 //   MESSAGE("Fin de convertRayonAngle")
 821 }
 822
 823