src/Tools/blocFissure/ihm/fissureGenerale_plugin.py

   1 # -*- coding: utf-8 -*-
   2
   3 # Copyright (C) 2006-2016  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 # if you already have plugins defined in a salome_plugins.py file, add this file at the end.
  23 # if not, copy this file as ${HOME}/Plugins/smesh_plugins.py or ${APPLI}/Plugins/smesh_plugins.py
  24
  25 import sys, traceback
  26 import math
  27 from blocFissure import gmu
  28
  29 def fissureGeneraleDlg(context):
  30   # get context study, salomeGui
  31   study = context.study
  32   sg = context.sg
  33
  34   import os
  35   #import subprocess
  36   #import tempfile
  37   from PyQt5 import QtCore
  38   from PyQt5 import QtWidgets
  39   from PyQt5 import QtGui
  40   from PyQt5.QtWidgets import QFileDialog
  41   from PyQt5.QtWidgets import QMessageBox
  42   from PyQt5.QtGui import QPalette
  43   from PyQt5.QtGui import QColor
  44   from fissureGenerale_ui import Ui_Dialog
  45
  46   class fissureGeneraleDialog(QtWidgets.QDialog):
  47
  48     def __init__(self):
  49       print "__init__"
  50       QtWidgets.QDialog.__init__(self)
  51       # Set up the user interface from Designer.
  52       self.ui = Ui_Dialog()
  53       self.ui.setupUi(self)
  54
  55       self.blackPalette = self.ui.dsb_influence.palette()
  56       self.redPalette = QPalette()
  57       self.redPalette.setColor(QPalette.Text, QColor(255,0,0))
  58       self.NOK = False
  59
  60       self.initDefaut()
  61       self.initDialog(self.defaut)
  62       self.ui.lb_calcul.hide()
  63
  64       # Connect up the buttons.
  65
  66       self.ui.pb_exemple.clicked.connect(self.genereExemples)
  67       self.ui.pb_valPrec.clicked.connect(self.readValPrec)
  68       self.ui.pb_reset.clicked.connect(self.resetVal)
  69       self.ui.pb_recharger.clicked.connect(self.recharger)
  70       self.ui.pb_sauver.clicked.connect(self.sauver)
  71       self.ui.pb_maillage.clicked.connect(self.selectMaillage)
  72       self.ui.pb_facefiss.clicked.connect(self.selectFacefiss)
  73       self.ui.pb_reptrav.clicked.connect(self.selectReptrav)
  74       self.ui.bb_OkCancel.accepted.disconnect(self.accept)
  75       self.ui.bb_OkCancel.accepted.connect(self.execute)
  76
  77     def initDefaut(self):
  78       self.defaut = dict(
  79         nomCas            = 'angleCube',
  80         maillageSain      = os.path.join(gmu.pathBloc, 'materielCasTests/CubeAngle.med'),
  81         brepFaceFissure   = os.path.join(gmu.pathBloc, "materielCasTests/CubeAngleFiss.brep"),
  82         edgeFissIds       = [4],
  83         lgInfluence       = 20,
  84         meshBrep          = (5,10),
  85         rayonPipe         = 5,
  86         lenSegPipe        = 2.5,
  87         nbSegRad          = 5,
  88         nbSegCercle       = 32,
  89         areteFaceFissure  = 10,
  90         areteVives        = 0,
  91         reptrav           = '.',
  92         nomres            = 'casStandard_fissure.med',
  93         verbosite         = 0)
  94
  95
  96     def initDialog(self, dico):
  97       self.ui.le_maillage.setText(dico['maillageSain'])
  98       self.ui.le_facefiss.setText(dico['brepFaceFissure'])
  99       self.ui.le_fondfiss.setText(str(dico['edgeFissIds']))
 100       self.ui.dsb_influence.setValue(dico['lgInfluence'])
 101       self.ui.dsb_meshBrepMin.setValue(dico['meshBrep'][0])
 102       self.ui.dsb_meshBrepMax.setValue(dico['meshBrep'][1])
 103       self.ui.dsb_rayonPipe.setValue(dico['rayonPipe'])
 104       self.ui.dsb_lenSegPipe.setValue(dico['lenSegPipe'])
 105       self.ui.sb_couronnes.setValue(dico['nbSegRad'])
 106       self.ui.sb_secteurs.setValue(dico['nbSegCercle'])
 107       self.ui.dsb_areteFaceFissure.setValue(dico['areteFaceFissure'])
 108       if dico.has_key('aretesVives'):
 109         self.ui.dsb_aretesVives.setValue(dico['aretesVives'])
 110       else:
 111         self.ui.dsb_aretesVives.setValue(0)
 112       self.ui.le_reptrav.setText(os.path.abspath(dico['reptrav']))
 113       self.ui.le_nomres.setText(os.path.split(dico['nomres'])[1])
 114       self.ui.cb_log.setCurrentIndex(dico['verbosite'])
 115       incomplet = self.testval(dico)
 116       pass
 117
 118     def testval(self, dico):
 119       incomplet = False
 120       if not os.path.lexists(dico['maillageSain']):
 121         self.ui.le_maillage.setPalette(self.redPalette)
 122         incomplet = True
 123       else:
 124         self.ui.le_maillage.setPalette(self.blackPalette)
 125       if not os.path.lexists(dico['brepFaceFissure']):
 126         self.ui.le_facefiss.setPalette(self.redPalette)
 127         incomplet = True
 128       else:
 129         self.ui.le_facefiss.setPalette(self.blackPalette)
 130       edgeFissIdsOK=True
 131       try:
 132         l = dico['edgeFissIds']
 133         for i in l:
 134           if not isinstance(i, int):
 135             print"not isinstance(i, int)"
 136             incomplet = True
 137             edgeFissIdsOK=False
 138             break
 139       except:
 140         print "except eval"
 141         incomplet = True
 142         edgeFissIdsOK=False
 143       if edgeFissIdsOK:
 144         self.ui.le_fondfiss.setPalette(self.blackPalette)
 145       else:
 146         self.ui.le_fondfiss.setPalette(self.redPalette)
 147       if dico['meshBrep'][0] == 0:
 148         self.ui.dsb_meshBrepMin.setPalette(self.redPalette)
 149         incomplet = True
 150       else:
 151         self.ui.dsb_meshBrepMin.setPalette(self.blackPalette)
 152       if dico['meshBrep'][1] == 0:
 153         self.ui.dsb_meshBrepMax.setPalette(self.redPalette)
 154         incomplet = True
 155       else:
 156         self.ui.dsb_meshBrepMax.setPalette(self.blackPalette)
 157       if dico['rayonPipe'] == 0:
 158         self.ui.dsb_rayonPipe.setPalette(self.redPalette)
 159         incomplet = True
 160       else:
 161         self.ui.dsb_rayonPipe.setPalette(self.blackPalette)
 162       if dico['lenSegPipe'] == 0:
 163         self.ui.dsb_lenSegPipe.setPalette(self.redPalette)
 164         incomplet = True
 165       else:
 166         self.ui.dsb_lenSegPipe.setPalette(self.blackPalette)
 167       if dico['areteFaceFissure'] == 0:
 168         self.ui.dsb_areteFaceFissure.setPalette(self.redPalette)
 169         incomplet = True
 170       else:
 171         self.ui.dsb_areteFaceFissure.setPalette(self.blackPalette)
 172
 173       print "incomplet: ", incomplet
 174       return incomplet
 175
 176     def fileDefault(self):
 177       filedef = os.path.expanduser("~/.config/salome/dialogFissureGenerale.dic")
 178       print filedef
 179       return filedef
 180
 181     def writeDefault(self, dico):
 182       filedef = self.fileDefault()
 183       f = open(filedef, 'w')
 184       f.write(str(dico))
 185       f.close()
 186
 187     def genereExemples(self):
 188       maillageSain      = os.path.join(gmu.pathBloc, 'materielCasTests/CubeAngle.med')
 189       brepFaceFissure   = os.path.join(gmu.pathBloc, "materielCasTests/CubeAngleFiss.brep")
 190       if (os.path.exists(maillageSain) and os.path.exists(brepFaceFissure)):
 191         self.initDialog(self.defaut)
 192       else:
 193         self.ui.lb_calcul.setText("--- Generation exemples en cours ---")
 194         self.ui.lb_calcul.show()
 195         from blocFissure.materielCasTests import genereMateriel
 196         self.ui.lb_calcul.hide()
 197         self.initDialog(self.defaut)
 198
 199     def readValPrec(self):
 200       filedef = self.fileDefault()
 201       if os.path.exists(filedef):
 202         f = open(filedef, 'r')
 203         txt = f.read()
 204         dico = eval(txt)
 205         print dico
 206         self.initDialog(dico)
 207
 208     def resetVal(self):
 209       #self.initDefaut()
 210       self.initDialog(self.defaut)
 211
 212     def setLogVerbosity(self, logfile):
 213       from blocFissure.gmu import initLog # le mode de log s'initialise une seule fois
 214       print "setLogVerbosity"
 215       index = self.ui.cb_log.currentIndex()
 216       print index
 217       if index == 0:
 218         initLog.setRelease(logfile)
 219       elif index == 1:
 220         initLog.setVerbose(logfile)
 221       elif index == 2:
 222         initLog.setDebug(logfile)
 223
 224
 225     def sauver(self):
 226       print "sauver"
 227       fileDiag = QFileDialog(self)
 228       fileDiag.setFileMode(QFileDialog.AnyFile)
 229       fileDiag.setNameFilter("Parametres *.dic (*.dic)")
 230       fileDiag.setViewMode(QFileDialog.List)
 231       if fileDiag.exec_() :
 232         fileNames = fileDiag.selectedFiles()
 233         print fileNames
 234         filedef = fileNames[0]
 235         if filedef[-4:] not in ['.dic']:
 236           filedef += '.dic'
 237         dico = self.creeDico()
 238         f = open(filedef, 'w')
 239         f.write(str(dico))
 240         f.close()
 241
 242     def recharger(self):
 243       print "recharger"
 244       fileDiag = QFileDialog(self)
 245       fileDiag.setFileMode(QFileDialog.ExistingFile)
 246       fileDiag.setNameFilter("Parametres *.dic (*.dic)")
 247       fileDiag.setViewMode(QFileDialog.Detail)
 248       if fileDiag.exec_() :
 249         fileNames = fileDiag.selectedFiles()
 250         filedef = fileNames[0]
 251         print filedef
 252         if os.path.exists(filedef):
 253           f = open(filedef, 'r')
 254           txt = f.read()
 255           dico = eval(txt)
 256           print dico
 257           self.initDialog(dico)
 258
 259     def selectMaillage(self):
 260       fileDiag = QFileDialog(self)
 261       fileDiag.setFileMode(QFileDialog.ExistingFile)
 262       fileDiag.setNameFilter("Maillage *.med (*.med)")
 263       fileDiag.setViewMode(QFileDialog.Detail)
 264       if fileDiag.exec_() :
 265         fileNames = fileDiag.selectedFiles()
 266         filedef = fileNames[0]
 267         print filedef
 268         self.ui.le_maillage.setText(filedef)
 269
 270     def selectFacefiss(self):
 271       fileDiag = QFileDialog(self)
 272       fileDiag.setFileMode(QFileDialog.ExistingFile)
 273       fileDiag.setNameFilter("Face fissure *.brep (*.brep)")
 274       fileDiag.setViewMode(QFileDialog.Detail)
 275       if fileDiag.exec_() :
 276         fileNames = fileDiag.selectedFiles()
 277         filedef = fileNames[0]
 278         print filedef
 279         self.ui.le_facefiss.setText(filedef)
 280
 281     def selectReptrav(self):
 282       fileDiag = QFileDialog(self)
 283       fileDiag.setFileMode(QFileDialog.Directory)
 284       fileDiag.setViewMode(QFileDialog.Detail)
 285       fileDiag.setDirectory(self.ui.le_reptrav.text())
 286       if fileDiag.exec_() :
 287         fileNames = fileDiag.selectedFiles()
 288         reptrav = str(fileNames[0])
 289         print "reptrav ", reptrav
 290         self.ui.le_reptrav.setText(os.path.abspath(reptrav))
 291
 292
 293     def selectNomres(self):
 294       fileDiag = QFileDialog(self)
 295       fileDiag.setFileMode(QFileDialog.AnyFile)
 296       fileDiag.setViewMode(QFileDialog.Detail)
 297       nomres=str(os.path.split(str(self.ui.le_nomres.text()))[1])
 298       fileDiag.setDirectory(self.ui.le_reptrav.text())
 299       fileDiag.selectFile(nomres)
 300       fileDiag.setNameFilter("Maillage *.med (*.med)")
 301       self.ui.le_nomres.setText(nomres)
 302       if fileDiag.exec_() :
 303         fileNames = fileDiag.selectedFiles()
 304         tempnom = os.path.split(str(fileNames[0]))[1]
 305         print "nomres ", tempnom
 306         self.ui.le_nomres.setText(tempnom)
 307       else:
 308         self.ui.le_nomres.setText(nomres)
 309
 310     def creeDico(self):
 311       dico = dict(
 312                   maillageSain     = str(self.ui.le_maillage.text()),
 313                   brepFaceFissure  = str(self.ui.le_facefiss.text()),
 314                   edgeFissIds      = eval(str(self.ui.le_fondfiss.text())),
 315                   lgInfluence      = self.ui.dsb_influence.value(),
 316                   meshBrep         = [self.ui.dsb_meshBrepMin.value(),self.ui.dsb_meshBrepMax.value()],
 317                   rayonPipe        = self.ui.dsb_rayonPipe.value(),
 318                   lenSegPipe       = self.ui.dsb_lenSegPipe.value(),
 319                   nbSegRad         = self.ui.sb_couronnes.value(),
 320                   nbSegCercle      = self.ui.sb_secteurs.value(),
 321                   areteFaceFissure = self.ui.dsb_areteFaceFissure.value(),
 322                   aretesVives      = self.ui.dsb_aretesVives.value(),
 323                   reptrav          = str(self.ui.le_reptrav.text()),
 324                   nomres           = str(self.ui.le_nomres.text()),
 325                   verbosite        = self.ui.cb_log.currentIndex()
 326                   )
 327       print dico
 328       return dico
 329
 330     def checkValues(self):
 331       return self.NOK
 332
 333     def execute(self):
 334       print "execute"
 335       dico = self.creeDico()
 336       NOK = self.testval(dico)
 337       if not(NOK):
 338         self.writeDefault(dico)
 339         self.ui.lb_calcul.setText("--- Calcul en cours ---")
 340         self.ui.lb_calcul.show()
 341         logfile=os.path.join(dico['reptrav'], dico['nomres']+".log")
 342         self.setLogVerbosity(logfile)
 343         from blocFissure.gmu import geomsmesh               # après intialisation log dans setLogVerbosity
 344         from blocFissure.gmu.casStandard import casStandard # après intialisation log dans setLogVerbosity
 345         from blocFissure.gmu.fissError import fissError
 346         try:
 347           execInstance = casStandard(dico)
 348         except fissError as erreur:
 349           print '-'*60
 350           print type(erreur)
 351           print '-'*60
 352           print erreur.msg
 353           print '-'*60
 354           for ligne in erreur.pile:
 355             print repr(ligne)
 356           print '-'*60
 357           texte = erreur.msg
 358 #           texte += +"<br>" +'-'*60 +"<br>"
 359 #           for ligne in erreur.pile:
 360 #             texte += repr(ligne) +"<br>"
 361           mbox = QMessageBox(self)
 362           mbox.setWindowTitle("erreur blocFissure")
 363           mbox.setText(str(texte))
 364           mbox.exec_()
 365 #        except Exception as erreur:
 366 #          print "exception non répertoriée"
 367       self.NOK = NOK
 368       self.ui.lb_calcul.hide()
 369       #self.accept()
 370
 371     pass
 372
 373 # ----------------------------------------------------------------------------
 374
 375   print "main"
 376   window = fissureGeneraleDialog()
 377   retry = True
 378   while(retry):
 379     retry = False
 380     window.exec_()
 381     result = window.result()
 382     if result:
 383       # dialog accepted
 384       print "dialog accepted, check"
 385       retry = window.checkValues()
 386     else:
 387       print "dialog rejected, exit"
 388   pass
 389