src/Tools/blocFissure/ihm/fissureGenerale_plugin.py

   1 # -*- coding: utf-8 -*-
   2
   3 # Copyright (C) 2006-2020  EDF R&D
   4 #
   5 # This library is free software; you can redistribute it and/or
   6 # modify it under the terms of the GNU Lesser General Public
   7 # License as published by the Free Software Foundation; either
   8 # version 2.1 of the License, or (at your option) any later version.
   9 #
  10 # This library is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 # Lesser General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU Lesser General Public
  16 # License along with this library; if not, write to the Free Software
  17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18 #
  19 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  20 #
  21
  22 """Pilotage de la fenêtre de dialogue"""
  23
  24 # if you already have plugins defined in a salome_plugins.py file, add this file at the end.
  25 # if not, copy this file as ${HOME}/Plugins/smesh_plugins.py or ${APPLI}/Plugins/smesh_plugins.py
  26
  27 import sys
  28 import traceback
  29 from blocFissure import gmu
  30
  31 def fissureGeneraleDlg(context):
  32   """get context study, salomeGui"""
  33   study = context.study
  34   sg = context.sg
  35
  36   import os
  37   #import subprocess
  38   #import tempfile
  39   from PyQt5 import QtCore
  40   from PyQt5 import QtWidgets
  41   from PyQt5 import QtGui
  42   from PyQt5.QtWidgets import QFileDialog
  43   from PyQt5.QtWidgets import QMessageBox
  44   from PyQt5.QtGui import QPalette
  45   from PyQt5.QtGui import QColor
  46   from blocFissure.ihm.fissureGenerale_ui import Ui_Dialog
  47
  48   class fissureGeneraleDialog(QtWidgets.QDialog):
  49     """classe du dialogue"""
  50
  51     def __init__(self):
  52       print("__init__")
  53       QtWidgets.QDialog.__init__(self)
  54       # Set up the user interface from Designer.
  55       self.ui = Ui_Dialog()
  56       self.ui.setupUi(self)
  57
  58       self.blackPalette = self.ui.dsb_influence.palette()
  59       self.redPalette = QPalette()
  60       self.redPalette.setColor(QPalette.Text, QColor(255,0,0))
  61       self.NOK = False
  62
  63       self.initDefaut()
  64       self.initDialog(self.defaut)
  65       self.ui.lb_calcul.hide()
  66
  67       # Connect up the buttons.
  68
  69       self.ui.pb_exemple.clicked.connect(self.genereExemples)
  70       self.ui.pb_valPrec.clicked.connect(self.readValPrec)
  71       self.ui.pb_reset.clicked.connect(self.resetVal)
  72       self.ui.pb_recharger.clicked.connect(self.recharger)
  73       self.ui.pb_sauver.clicked.connect(self.sauver)
  74       self.ui.pb_maillage.clicked.connect(self.selectMaillage)
  75       self.ui.pb_facefiss.clicked.connect(self.selectFacefiss)
  76       self.ui.pb_reptrav.clicked.connect(self.selectReptrav)
  77       self.ui.bb_OkCancel.accepted.disconnect(self.accept)
  78       self.ui.bb_OkCancel.accepted.connect(self.execute)
  79
  80     def initDefaut(self):
  81       self.defaut = dict( \
  82         nomCas            = "angleCube", \
  83         maillageSain      = os.path.join(gmu.pathBloc, "materielCasTests", "CubeAngle.med"), \
  84         CAOFaceFissure    = os.path.join(gmu.pathBloc, "materielCasTests", "CubeAngleFiss.brep"), \
  85         edgeFiss          = [3], \
  86         lgInfluence       = 20, \
  87         meshBrep          = (5,10), \
  88         rayonPipe         = 5, \
  89         lenSegPipe        = 2.5, \
  90         nbSegRad          = 5, \
  91         nbSegCercle       = 32, \
  92         areteFaceFissure  = 10, \
  93         areteVives        = 0, \
  94         reptrav           = os.curdir, \
  95         nomres            = "maillage_avec_fissure", \
  96         verbosite         = 0)
  97
  98
  99     def initDialog(self, dico):
 100       self.ui.le_maillage.setText(dico['maillageSain'])
 101       self.ui.le_facefiss.setText(dico['CAOFaceFissure'])
 102       self.ui.le_fondfiss.setText(str(dico['edgeFiss']))
 103       self.ui.dsb_influence.setValue(dico['lgInfluence'])
 104       self.ui.dsb_meshBrepMin.setValue(dico['meshBrep'][0])
 105       self.ui.dsb_meshBrepMax.setValue(dico['meshBrep'][1])
 106       self.ui.dsb_rayonPipe.setValue(dico['rayonPipe'])
 107       self.ui.dsb_lenSegPipe.setValue(dico['lenSegPipe'])
 108       self.ui.sb_couronnes.setValue(dico['nbSegRad'])
 109       self.ui.sb_secteurs.setValue(dico['nbSegCercle'])
 110       self.ui.dsb_areteFaceFissure.setValue(dico['areteFaceFissure'])
 111       if 'aretesVives' in dico:
 112         self.ui.dsb_aretesVives.setValue(dico['aretesVives'])
 113       else:
 114         self.ui.dsb_aretesVives.setValue(0)
 115       self.ui.le_reptrav.setText(os.path.abspath(dico['reptrav']))
 116       self.ui.le_nomres.setText(os.path.split(dico['nomres'])[1])
 117       self.ui.cb_log.setCurrentIndex(dico['verbosite'])
 118       #incomplet = self.testval(dico)
 119
 120     def testval(self, dico):
 121       incomplet = False
 122       if not os.path.lexists(dico['maillageSain']):
 123         self.ui.le_maillage.setPalette(self.redPalette)
 124         incomplet = True
 125       else:
 126         self.ui.le_maillage.setPalette(self.blackPalette)
 127       cao_file = dico['CAOFaceFissure']
 128       if not os.path.lexists(cao_file):
 129         self.ui.le_facefiss.setPalette(self.redPalette)
 130         incomplet = True
 131       else:
 132         suffix = os.path.basename(cao_file).split(".")[-1]
 133         if ( suffix.upper() not in ("BREP","XAO") ):
 134           print ("Suffixe inconnu pour le fichier {}".format(cao_file))
 135           self.ui.le_facefiss.setPalette(self.redPalette)
 136           incomplet = True
 137         else:
 138           self.ui.le_facefiss.setPalette(self.blackPalette)
 139       if dico['edgeFiss']:
 140         edgeFissOK=True
 141         param_0 = dico['edgeFiss'][0]
 142         type_param_id = type(param_0)
 143         for param in dico['edgeFiss'][1:]:
 144           if not isinstance(param,type_param_id):
 145             print ("La donnée {} n'est pas du même type que la première de la liste : {}.".format(param,type(param)))
 146             incomplet = True
 147             edgeFissOK=False
 148         if edgeFissOK:
 149           if isinstance(param_0, int):
 150             pass
 151           elif isinstance(param_0, str):
 152             pass
 153           else:
 154             print("Il faut une liste de noms de groupes d'arêtes ou une liste d'IDs d'arêtes.")
 155             incomplet = True
 156             edgeFissOK=False
 157       else:
 158         incomplet = True
 159         edgeFissOK=False
 160       if edgeFissOK:
 161         self.ui.le_fondfiss.setPalette(self.blackPalette)
 162       else:
 163         self.ui.le_fondfiss.setPalette(self.redPalette)
 164       if dico['meshBrep'][0] == 0:
 165         self.ui.dsb_meshBrepMin.setPalette(self.redPalette)
 166         incomplet = True
 167       else:
 168         self.ui.dsb_meshBrepMin.setPalette(self.blackPalette)
 169       if dico['meshBrep'][1] == 0:
 170         self.ui.dsb_meshBrepMax.setPalette(self.redPalette)
 171         incomplet = True
 172       else:
 173         self.ui.dsb_meshBrepMax.setPalette(self.blackPalette)
 174       if dico['rayonPipe'] == 0:
 175         self.ui.dsb_rayonPipe.setPalette(self.redPalette)
 176         incomplet = True
 177       else:
 178         self.ui.dsb_rayonPipe.setPalette(self.blackPalette)
 179       if dico['lenSegPipe'] == 0:
 180         self.ui.dsb_lenSegPipe.setPalette(self.redPalette)
 181         incomplet = True
 182       else:
 183         self.ui.dsb_lenSegPipe.setPalette(self.blackPalette)
 184       if dico['areteFaceFissure'] == 0:
 185         self.ui.dsb_areteFaceFissure.setPalette(self.redPalette)
 186         incomplet = True
 187       else:
 188         self.ui.dsb_areteFaceFissure.setPalette(self.blackPalette)
 189
 190       print("incomplet: ", incomplet)
 191       return incomplet
 192
 193     def fileDefault(self):
 194       filedef = os.path.expanduser( os.path.join(os.environ["HOME"], ".config", "salome", "dialogFissureGenerale.dic") )
 195       print(filedef)
 196       return filedef
 197
 198     def writeDefault(self, dico):
 199       filedef = self.fileDefault()
 200       with open(filedef, 'w') as fichier:
 201         fichier.write(str(dico))
 202
 203     def genereExemples(self):
 204       maillageSain      = os.path.join(gmu.pathBloc, "materielCasTests", "CubeAngle.med")
 205       CAOFaceFissure    = os.path.join(gmu.pathBloc, "materielCasTests", "CubeAngleFiss.brep")
 206       if (os.path.exists(maillageSain) and os.path.exists(CAOFaceFissure )):
 207         self.initDialog(self.defaut)
 208       else:
 209         self.ui.lb_calcul.setText("--- Generation exemples en cours ---")
 210         self.ui.lb_calcul.show()
 211         from blocFissure.materielCasTests import genereMateriel
 212         self.ui.lb_calcul.hide()
 213         self.initDialog(self.defaut)
 214
 215     def readValPrec(self):
 216       filedef = self.fileDefault()
 217       if os.path.exists(filedef):
 218         with open(filedef, 'r') as fichier:
 219           txt = fichier.read()
 220         dico = eval(txt)
 221         print(dico)
 222         self.initDialog(dico)
 223
 224     def resetVal(self):
 225       #self.initDefaut()
 226       self.initDialog(self.defaut)
 227
 228     def setLogVerbosity(self, logfile):
 229       from blocFissure.gmu import initLog # le mode de log s'initialise une seule fois
 230       print("setLogVerbosity")
 231       index = self.ui.cb_log.currentIndex()
 232       print(index)
 233       if index == 0:
 234         initLog.setRelease(logfile)
 235       elif index == 1:
 236         initLog.setVerbose(logfile)
 237       elif index == 2:
 238         initLog.setDebug(logfile)
 239
 240     def sauver(self):
 241       print("sauver")
 242       fileDiag = QFileDialog(self)
 243       fileDiag.setFileMode(QFileDialog.AnyFile)
 244       fileDiag.setNameFilter("Parametres *.dic (*.dic)")
 245       fileDiag.setViewMode(QFileDialog.List)
 246       if fileDiag.exec_() :
 247         fileNames = fileDiag.selectedFiles()
 248         print(fileNames)
 249         filedef = fileNames[0]
 250         if filedef[-4:] not in ['.dic']:
 251           filedef += '.dic'
 252         dico = self.creeDico()
 253         with open(filedef, 'w') as fichier:
 254           fichier.write(str(dico))
 255
 256     def recharger(self):
 257       print("recharger")
 258       fileDiag = QFileDialog(self)
 259       fileDiag.setFileMode(QFileDialog.ExistingFile)
 260       fileDiag.setNameFilter("Parametres *.dic (*.dic)")
 261       fileDiag.setViewMode(QFileDialog.Detail)
 262       if fileDiag.exec_() :
 263         fileNames = fileDiag.selectedFiles()
 264         filedef = fileNames[0]
 265         print(filedef)
 266         if os.path.exists(filedef):
 267           with open(filedef, 'r') as fichier:
 268             txt = fichier.read()
 269           dico = eval(txt)
 270           print(dico)
 271           self.initDialog(dico)
 272
 273     def selectMaillage(self):
 274       fileDiag = QFileDialog(self)
 275       fileDiag.setFileMode(QFileDialog.ExistingFile)
 276       fileDiag.setNameFilter("Maillage *.med (*.med)")
 277       fileDiag.setViewMode(QFileDialog.Detail)
 278       if fileDiag.exec_() :
 279         fileNames = fileDiag.selectedFiles()
 280         filedef = fileNames[0]
 281         print(filedef)
 282         self.ui.le_maillage.setText(filedef)
 283
 284     def selectFacefiss(self):
 285       fileDiag = QFileDialog(self)
 286       fileDiag.setFileMode(QFileDialog.ExistingFile)
 287       fileDiag.setNameFilter("Face fissure *.brep (*.brep)")
 288       fileDiag.setViewMode(QFileDialog.Detail)
 289       if fileDiag.exec_() :
 290         fileNames = fileDiag.selectedFiles()
 291         filedef = fileNames[0]
 292         print(filedef)
 293         self.ui.le_facefiss.setText(filedef)
 294
 295     def selectReptrav(self):
 296       fileDiag = QFileDialog(self)
 297       fileDiag.setFileMode(QFileDialog.Directory)
 298       fileDiag.setViewMode(QFileDialog.Detail)
 299       fileDiag.setDirectory(self.ui.le_reptrav.text())
 300       if fileDiag.exec_() :
 301         fileNames = fileDiag.selectedFiles()
 302         reptrav = str(fileNames[0])
 303         print("reptrav ", reptrav)
 304         self.ui.le_reptrav.setText(os.path.abspath(reptrav))
 305
 306
 307     def selectNomres(self):
 308       fileDiag = QFileDialog(self)
 309       fileDiag.setFileMode(QFileDialog.AnyFile)
 310       fileDiag.setViewMode(QFileDialog.Detail)
 311       nomres=str(os.path.split(str(self.ui.le_nomres.text()))[1])
 312       fileDiag.setDirectory(self.ui.le_reptrav.text())
 313       fileDiag.selectFile(nomres)
 314       fileDiag.setNameFilter("Maillage *.med (*.med)")
 315       self.ui.le_nomres.setText(nomres)
 316       if fileDiag.exec_() :
 317         fileNames = fileDiag.selectedFiles()
 318         tempnom = os.path.split(str(fileNames[0]))[1]
 319         print("nomres ", tempnom)
 320         self.ui.le_nomres.setText(tempnom)
 321       else:
 322         self.ui.le_nomres.setText(nomres)
 323
 324     def creeDico(self):
 325       dico = dict( \
 326                   maillageSain     = str(self.ui.le_maillage.text()), \
 327                   CAOFaceFissure   = str(self.ui.le_facefiss.text()), \
 328                   edgeFiss         = eval(str(self.ui.le_fondfiss.text())), \
 329                   lgInfluence      = self.ui.dsb_influence.value(), \
 330                   meshBrep         = [self.ui.dsb_meshBrepMin.value(),self.ui.dsb_meshBrepMax.value()], \
 331                   rayonPipe        = self.ui.dsb_rayonPipe.value(), \
 332                   lenSegPipe       = self.ui.dsb_lenSegPipe.value(), \
 333                   nbSegRad         = self.ui.sb_couronnes.value(), \
 334                   nbSegCercle      = self.ui.sb_secteurs.value(), \
 335                   areteFaceFissure = self.ui.dsb_areteFaceFissure.value(), \
 336                   aretesVives      = self.ui.dsb_aretesVives.value(), \
 337                   reptrav          = str(self.ui.le_reptrav.text()), \
 338                   nomres           = str(self.ui.le_nomres.text()), \
 339                   verbosite        = self.ui.cb_log.currentIndex() \
 340                   )
 341       print(dico)
 342       return dico
 343
 344     def checkValues(self):
 345       return self.NOK
 346
 347     def execute(self):
 348       print("execute")
 349       dico = self.creeDico()
 350       NOK = self.testval(dico)
 351       if not(NOK):
 352         self.writeDefault(dico)
 353         self.ui.lb_calcul.setText("--- Calcul en cours ---")
 354         self.ui.lb_calcul.show()
 355         logfile=os.path.join(dico['reptrav'], dico['nomres']+".log")
 356         self.setLogVerbosity(logfile)
 357         from blocFissure.gmu import geomsmesh               # après intialisation log dans setLogVerbosity
 358         from blocFissure.gmu.casStandard import casStandard # après intialisation log dans setLogVerbosity
 359         from blocFissure.gmu.fissError import fissError
 360         try:
 361           execInstance = casStandard(dico)
 362         except fissError as erreur:
 363           print('-'*60)
 364           print(type(erreur))
 365           print('-'*60)
 366           print(erreur.msg)
 367           print('-'*60)
 368           for ligne in erreur.pile:
 369             print(repr(ligne))
 370           print('-'*60)
 371           texte = erreur.msg
 372 #           texte += +"<br>" +'-'*60 +"<br>"
 373 #           for ligne in erreur.pile:
 374 #             texte += repr(ligne) +"<br>"
 375           mbox = QMessageBox(self)
 376           mbox.setWindowTitle("erreur blocFissure")
 377           mbox.setText(str(texte))
 378           mbox.exec_()
 379 #        except Exception as erreur:
 380 #          print "exception non répertoriée"
 381       self.NOK = NOK
 382       self.ui.lb_calcul.hide()
 383       #self.accept()
 384
 385 # ----------------------------------------------------------------------------
 386
 387   print("main")
 388   window = fissureGeneraleDialog()
 389   retry = True
 390   while(retry):
 391     retry = False
 392     window.exec_()
 393     result = window.result()
 394     if result:
 395       # dialog accepted
 396       print("dialog accepted, check")
 397       retry = window.checkValues()
 398     else:
 399       print("dialog rejected, exit")