src/Tools/YamsPlug/monYamsPlugDialog.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2022  EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License, or (at your option) any later version.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21 # Modules Python
  22 # Modules Eficas
  23
  24 import os, subprocess
  25 import tempfile
  26 from YamsPlugDialog_ui import Ui_YamsPlugDialog
  27 from monViewText import MonViewText
  28 from qtsalome import *
  29
  30 verbose = True
  31
  32 class MonYamsPlugDialog(Ui_YamsPlugDialog,QWidget):
  33   """
  34   """
  35   def __init__(self):
  36     QWidget.__init__(self)
  37     self.setupUi(self)
  38     self.connecterSignaux()
  39     self.fichierIn=""
  40     self.fichierOut=""
  41     self.MeshIn=""
  42     self.commande=""
  43     self.num=1
  44     self.__selectedMesh=None
  45
  46     # complex with QResources: not used
  47     # The icon are supposed to be located in the $SMESH_ROOT_DIR/share/salome/resources/smesh folder,
  48     # other solution could be in the same folder than this python module file:
  49     # iconfolder=os.path.dirname(os.path.abspath(__file__))
  50
  51     self.iconfolder=os.environ["SMESH_ROOT_DIR"]+"/share/salome/resources/smesh"
  52     #print "MGSurfOptPlugDialog iconfolder",iconfolder
  53     icon = QIcon()
  54     icon.addFile(os.path.join(self.iconfolder,"select1.png"))
  55     self.PB_LoadHyp.setIcon(icon)
  56     self.PB_LoadHyp.setToolTip("hypothesis from Salome Object Browser")
  57     self.PB_SaveHyp.setIcon(icon)
  58     self.PB_SaveHyp.setToolTip("hypothesis to Salome Object Browser")
  59     self.PB_MeshSmesh.setIcon(icon)
  60     self.PB_MeshSmesh.setToolTip("source mesh from Salome Object Browser")
  61     icon = QIcon()
  62     icon.addFile(os.path.join(self.iconfolder,"open.png"))
  63     self.PB_ParamsFileExplorer.setIcon(icon)
  64     self.PB_Load.setIcon(icon)
  65     self.PB_Load.setToolTip("hypothesis from file")
  66     self.PB_Save.setIcon(icon)
  67     self.PB_Save.setToolTip("hypothesis to file")
  68     self.PB_MeshFile.setIcon(icon)
  69     self.PB_MeshFile.setToolTip("source mesh from a file in disk")
  70
  71     #Ces parametres ne sont pas remis a rien par le clean
  72     self.paramsFile= os.path.abspath(os.path.join(os.path.expanduser("~"),".MGSurfOpt.dat"))
  73     self.LE_ParamsFile.setText(self.paramsFile)
  74     self.LE_MeshFile.setText("")
  75     self.LE_MeshSmesh.setText("")
  76
  77     v1=QDoubleValidator(self)
  78     v1.setBottom(0.)
  79     #v1.setTop(1000.) #per thousand... only if relative
  80     v1.setDecimals(3)
  81     self.SP_Tolerance.setValidator(v1)
  82     self.SP_Tolerance.titleForWarning="Chordal Tolerance"
  83
  84     self.SP_MinSize.setDecimals(5)
  85
  86     self.resize(800, 600)
  87     self.clean()
  88
  89   def connecterSignaux(self) :
  90     self.PB_Cancel.clicked.connect(self.PBCancelPressed)
  91     self.PB_Default.clicked.connect(self.clean)
  92     self.PB_Help.clicked.connect(self.PBHelpPressed)
  93     self.PB_OK.clicked.connect(self.PBOKPressed)
  94
  95     self.PB_Load.clicked.connect(self.PBLoadPressed)
  96     self.PB_Save.clicked.connect(self.PBSavePressed)
  97     self.PB_LoadHyp.clicked.connect(self.PBLoadHypPressed)
  98     self.PB_SaveHyp.clicked.connect(self.PBSaveHypPressed)
  99
 100     self.PB_MeshFile.clicked.connect(self.PBMeshFilePressed)
 101     self.PB_MeshSmesh.clicked.connect(self.PBMeshSmeshPressed)
 102     self.LE_MeshSmesh.returnPressed.connect(self.meshSmeshNameChanged)
 103     self.PB_ParamsFileExplorer.clicked.connect(self.setParamsFileName)
 104     self.LE_MeshFile.returnPressed.connect(self.meshFileNameChanged)
 105     self.LE_ParamsFile.returnPressed.connect(self.paramsFileNameChanged)
 106
 107   def PBHelpPressed(self):
 108     import SalomePyQt
 109     sgPyQt = SalomePyQt.SalomePyQt()
 110     try:
 111       mydir=os.environ["SMESH_ROOT_DIR"]
 112     except Exception:
 113       QMessageBox.warning(self, "Help", "Help unavailable $SMESH_ROOT_DIR not found")
 114       return
 115
 116     maDoc=mydir+"/share/doc/salome/gui/SMESH/yams/index.html"
 117     sgPyQt.helpContext(maDoc,"")
 118
 119     #maDoc=mydir+"/share/doc/salome/gui/SMESH/yams/_downloads/mg-surfopt_user_manual.pdf"
 120     #command="xdg-open "+maDoc+";"
 121     #subprocess.call(command, shell=True)
 122
 123   def PBOKPressed(self):
 124     if not(self.PrepareLigneCommande()):
 125       #warning done yet
 126       #QMessageBox.warning(self, "Compute", "Command not found")
 127       return
 128     maFenetre=MonViewText(self,self.commande)
 129
 130   def enregistreResultat(self):
 131     import salome
 132     import SMESH
 133     from salome.kernel import studyedit
 134     from salome.smesh import smeshBuilder
 135     smesh = smeshBuilder.New()
 136
 137     if not os.path.isfile(self.fichierOut):
 138       QMessageBox.warning(self, "Compute", "Result file "+self.fichierOut+" not found")
 139
 140     maStudy=salome.myStudy
 141     smesh.UpdateStudy()
 142     (outputMesh, status) = smesh.CreateMeshesFromGMF(self.fichierOut)
 143     name=str(self.LE_MeshSmesh.text())
 144     initialMeshFile=None
 145     initialMeshObject=None
 146     if name=="":
 147       a=str(self.fichierIn)
 148       name=os.path.basename(os.path.splitext(a)[0])
 149       initialMeshFile=a
 150     else:
 151       initialMeshObject=maStudy.FindObjectByName(name ,"SMESH")[0]
 152
 153     meshname = name+"_MGSO_"+str(self.num)
 154     smesh.SetName(outputMesh.GetMesh(), meshname)
 155     outputMesh.Compute() #no algorithms message for "Mesh_x" has been computed with warnings: -  global 1D algorithm is missing
 156
 157     self.editor = studyedit.getStudyEditor()
 158     moduleEntry=self.editor.findOrCreateComponent("SMESH","SMESH")
 159     HypReMeshEntry = self.editor.findOrCreateItem(
 160         moduleEntry, name = "Plugins Hypotheses", icon="mesh_tree_hypo.png") #, comment = "HypoForRemeshing" )
 161
 162     monStudyBuilder=maStudy.NewBuilder()
 163     monStudyBuilder.NewCommand()
 164     newStudyIter=monStudyBuilder.NewObject(HypReMeshEntry)
 165     self.editor.setAttributeValue(newStudyIter, "AttributeName", "MGSurfOpt Parameters_"+str(self.num))
 166     self.editor.setAttributeValue(newStudyIter, "AttributeComment", self.getResumeData(separator=" ; "))
 167
 168     SOMesh=maStudy.FindObjectByName(meshname ,"SMESH")[0]
 169
 170     if initialMeshFile!=None:
 171       newStudyFileName=monStudyBuilder.NewObject(SOMesh)
 172       self.editor.setAttributeValue(newStudyFileName, "AttributeName", "meshFile")
 173       self.editor.setAttributeValue(newStudyFileName, "AttributeExternalFileDef", initialMeshFile)
 174       self.editor.setAttributeValue(newStudyFileName, "AttributeComment", initialMeshFile)
 175
 176     if initialMeshObject!=None:
 177       newLink=monStudyBuilder.NewObject(SOMesh)
 178       monStudyBuilder.Addreference(newLink, initialMeshObject)
 179
 180     newLink=monStudyBuilder.NewObject(SOMesh)
 181     monStudyBuilder.Addreference(newLink, newStudyIter)
 182
 183     if salome.sg.hasDesktop(): salome.sg.updateObjBrowser()
 184     self.num+=1
 185     return True
 186
 187   def PBSavePressed(self):
 188     from datetime import datetime
 189     if not(self.PrepareLigneCommande()): return
 190     text = "# MGSurfOpt hypothesis parameters\n"
 191     text += "# Params for mesh : " +  self.LE_MeshSmesh.text() +"\n"
 192     text += datetime.now().strftime("# Date : %d/%m/%y %H:%M:%S\n")
 193     text += "# Command : "+self.commande+"\n"
 194     text += self.getResumeData(separator="\n")
 195     text += "\n\n"
 196
 197     try:
 198       f=open(self.paramsFile,"a")
 199     except:
 200       QMessageBox.warning(self, "File", "Unable to open "+self.paramsFile)
 201       return
 202     try:
 203       f.write(text)
 204     except:
 205       QMessageBox.warning(self, "File", "Unable to write "+self.paramsFile)
 206       return
 207     f.close()
 208
 209   def PBSaveHypPressed_risky(self):
 210     """
 211     save hypothesis in Object Browser outside GEOM ou MESH
 212     WARNING: at root of Object Browser is not politically correct
 213     """
 214     import salome
 215
 216     if verbose: print("save hypothesis in Object Browser")
 217
 218     name = "MGSurfOpt"
 219     #how ??? icon = "mesh_tree_hypo.png"
 220     namei = "MGSurfOpt Parameters_%i" % self.num
 221     datai = self.getResumeData(separator=" ; ")
 222
 223     myStudy = salome.myStudy
 224     myBuilder = myStudy.NewBuilder()
 225     #myStudy.IsStudyLocked()
 226     myComponent = myStudy.FindComponent(name)
 227     if myComponent == None:
 228       print("myComponent not found, create")
 229       myComponent = myBuilder.NewComponent(name)
 230     AName = myBuilder.FindOrCreateAttribute(myComponent, "AttributeName")
 231     AName.SetValue(name)
 232     ACmt = myBuilder.FindOrCreateAttribute(myComponent, "AttributeComment")
 233     ACmt.SetValue(name)
 234
 235     myObject = myBuilder.NewObject(myComponent)
 236     AName = myBuilder.FindOrCreateAttribute(myObject, "AttributeName")
 237     AName.SetValue(namei)
 238     ACmt = myBuilder.FindOrCreateAttribute(myObject, "AttributeComment")
 239     ACmt.SetValue(datai)
 240
 241     if salome.sg.hasDesktop(): salome.sg.updateObjBrowser()
 242     self.num += 1
 243     if verbose: print(("save %s in Object Browser done: %s\n%s" % (name, myObject.GetID(), datai)))
 244     return True
 245
 246   def PBSaveHypPressed(self):
 247     """
 248     save hypothesis in Object Browser
 249     bug: affichage ne marche pas si inclusion dans dans GEOM ou MESH depuis salome 730
 250     """
 251     import salome
 252     import SMESH
 253     from salome.kernel import studyedit
 254     from salome.smesh import smeshBuilder
 255     #[PAL issue tracker:issue1871] Les nouveaux objets ne s'affichent pas dans SMESH
 256     QMessageBox.warning(self, "Save", "waiting for fix: Object Browser will not display hypothesis")
 257
 258     if verbose: print("save hypothesis in Object Browser")
 259     smesh = smeshBuilder.New()
 260
 261     maStudy=salome.myStudy
 262     smesh.UpdateStudy()
 263
 264     self.editor = studyedit.getStudyEditor()
 265     moduleEntry=self.editor.findOrCreateComponent("SMESH","SMESH")
 266     HypReMeshEntry = self.editor.findOrCreateItem(
 267         moduleEntry, name = "Plugins Hypotheses", icon="mesh_tree_hypo.png")
 268     #, comment = "HypothesisForRemeshing" )
 269
 270     monStudyBuilder=maStudy.NewBuilder()
 271     monStudyBuilder.NewCommand()
 272     newStudyIter=monStudyBuilder.NewObject(HypReMeshEntry)
 273     name = "MGSurfOpt Parameters_%i" % self.num
 274     self.editor.setAttributeValue(newStudyIter, "AttributeName", name)
 275     data = self.getResumeData(separator=" ; ")
 276     self.editor.setAttributeValue(newStudyIter, "AttributeComment", data)
 277
 278     if salome.sg.hasDesktop(): salome.sg.updateObjBrowser()
 279     self.num += 1
 280     if verbose: print(("save %s in Object Browser done:\n%s" % (name, data)))
 281     return True
 282
 283   def SP_toStr(self, widget):
 284     """only for a QLineEdit widget"""
 285     #cr, pos=widget.validator().validate(res, 0) #n.b. "1,3" is acceptable !locale!
 286     try:
 287       val=float(widget.text())
 288     except:
 289       QMessageBox.warning(self, widget.titleForWarning, "float value is incorrect: '"+widget.text()+"'")
 290       res=str(widget.validator().bottom())
 291       widget.setProperty("text", res)
 292       return res
 293     valtest=widget.validator().bottom()
 294     if valtest!=None:
 295       if val<valtest:
 296         QMessageBox.warning(self, widget.titleForWarning, "float value is under minimum: "+str(val)+" < "+str(valtest))
 297         res=str(valtest)
 298         widget.setProperty("text", res)
 299         return res
 300     valtest=widget.validator().top()
 301     if valtest!=None:
 302       if val>valtest:
 303         QMessageBox.warning(self, widget.titleForWarning, "float value is over maximum: "+str(val)+" > "+str(valtest))
 304         res=str(valtest)
 305         widget.setProperty("text", res)
 306         return res
 307     return str(val)
 308
 309   def getResumeData(self, separator="\n"):
 310     text=""
 311     for RB in self.GBOptim.findChildren(QRadioButton,):
 312       if RB.isChecked()==True:
 313         text+="Optimisation="+RB.text()+separator
 314         break
 315     if self.RB_Absolute.isChecked():
 316       text+="Units=absolute"+separator
 317     else:
 318       text+="Units=relative"+separator
 319     v=self.SP_toStr(self.SP_Tolerance)
 320     text+="ChordalToleranceDeviation="+v+separator
 321     text+="RidgeDetection="+str(self.CB_Ridge.isChecked())+separator
 322     text+="SplitEdge="+str(self.CB_SplitEdge.isChecked())+separator
 323     text+="PointSmoothing="+str(self.CB_Point.isChecked())+separator
 324     text+="GeometricalApproximation="+str(self.SP_Geomapp.value())+separator
 325     text+="RidgeAngle="+str(self.SP_Ridge.value())+separator
 326     text+="MaximumSize="+str(self.SP_MaxSize.value())+separator
 327     text+="MinimumSize="+str(self.SP_MinSize.value())+separator
 328     text+="MeshGradation="+str(self.SP_Gradation.value())+separator
 329     text+="Verbosity="+str(self.SP_Verbosity.value())+separator
 330     text+="Memory="+str(self.SP_Memory.value())+separator
 331     return str(text)
 332
 333   def loadResumeData(self, hypothesis, separator="\n"):
 334     text=str(hypothesis)
 335     self.clean()
 336     for slig in reversed(text.split(separator)):
 337       lig=slig.strip()
 338       #print "load ResumeData",lig
 339       if lig=="": continue #skip blank lines
 340       if lig[0]=="#": break
 341       try:
 342         tit,value=lig.split("=")
 343         if tit=="Optimisation":
 344           #no need: exlusives QRadioButton
 345           #for RB in self.GBOptim.findChildren(QRadioButton,):
 346           #  RB.setChecked(False)
 347           for RB in self.GBOptim.findChildren(QRadioButton,):
 348             if RB.text()==value :
 349               RB.setChecked(True)
 350               break
 351         if tit=="Units":
 352           if value=="absolute":
 353             self.RB_Absolute.setChecked(True)
 354             self.RB_Relative.setChecked(False)
 355           else:
 356             self.RB_Absolute.setChecked(False)
 357             self.RB_Relative.setChecked(True)
 358         if tit=="ChordalToleranceDeviation": self.SP_Tolerance.setProperty("text", float(value))
 359         if tit=="RidgeDetection": self.CB_Ridge.setChecked(value=="True")
 360         if tit=="SplitEdge": self.CB_SplitEdge.setChecked(value=="True")
 361         if tit=="PointSmoothing": self.CB_Point.setChecked(value=="True")
 362         if tit=="GeometricalApproximation": self.SP_Geomapp.setProperty("value", float(value))
 363         if tit=="RidgeAngle": self.SP_Ridge.setProperty("value", float(value))
 364         if tit=="MaximumSize": self.SP_MaxSize.setProperty("value", float(value))
 365         if tit=="MinimumSize": self.SP_MinSize.setProperty("value", float(value))
 366         if tit=="MeshGradation": self.SP_Gradation.setProperty("value", float(value))
 367         if tit=="Verbosity": self.SP_Verbosity.setProperty("value", int(float(value)))
 368         if tit=="Memory": self.SP_Memory.setProperty("value", float(value))
 369       except:
 370         QMessageBox.warning(self, "load MGSurfOpt Hypothesis", "Problem on '"+lig+"'")
 371
 372   def PBLoadPressed(self):
 373     """load last hypothesis saved in tail of file"""
 374     try:
 375       f=open(self.paramsFile,"r")
 376     except:
 377       QMessageBox.warning(self, "File", "Unable to open "+self.paramsFile)
 378       return
 379     try:
 380       text=f.read()
 381     except:
 382       QMessageBox.warning(self, "File", "Unable to read "+self.paramsFile)
 383       return
 384     f.close()
 385     self.loadResumeData(text, separator="\n")
 386
 387   def PBLoadHypPressed(self):
 388     """load hypothesis saved in Object Browser"""
 389     #QMessageBox.warning(self, "load Object Browser MGSurfOpt hypothesis", "TODO")
 390     import salome
 391     from salome.kernel import studyedit
 392     from salome.smesh.smeshstudytools import SMeshStudyTools
 393     from salome.gui import helper as guihelper
 394     from omniORB import CORBA
 395
 396     mySObject, myEntry = guihelper.getSObjectSelected()
 397     if CORBA.is_nil(mySObject) or mySObject==None:
 398       QMessageBox.critical(self, "Hypothese", "select an Object Browser MGSurfOpt hypothesis")
 399       return
 400
 401     text=mySObject.GetComment()
 402
 403     #a verification
 404     if "Optimisation=" not in text:
 405       QMessageBox.critical(self, "Load Hypothese", "Object Browser selection not a MGSurfOptHypothesis")
 406       return
 407     self.loadResumeData(text, separator=" ; ")
 408     return
 409
 410   def PBCancelPressed(self):
 411     self.close()
 412
 413   def PBMeshFilePressed(self):
 414     fd = QFileDialog(self, "select an existing Mesh file", self.LE_MeshFile.text(), "Mesh-Files (*.mesh);;All Files (*)")
 415     if fd.exec_():
 416       infile = fd.selectedFiles()[0]
 417       self.LE_MeshFile.setText(infile)
 418       self.fichierIn=str(infile)
 419       self.MeshIn=""
 420       self.LE_MeshSmesh.setText("")
 421       self.__selectedMesh=None
 422
 423   def setParamsFileName(self):
 424     fd = QFileDialog(self, "select a file", self.LE_ParamsFile.text(), "dat Files (*.dat);;All Files (*)")
 425     if fd.exec_():
 426       infile = fd.selectedFiles()[0]
 427       self.LE_ParamsFile.setText(infile)
 428       self.paramsFile=str(infile)
 429
 430   def meshFileNameChanged(self):
 431     self.fichierIn=str(self.LE_MeshFile.text())
 432     #print "meshFileNameChanged", self.fichierIn
 433     if os.path.exists(self.fichierIn):
 434       self.__selectedMesh=None
 435       self.MeshIn=""
 436       self.LE_MeshSmesh.setText("")
 437       return
 438     QMessageBox.warning(self, "Mesh file", "File doesn't exist")
 439
 440   def meshSmeshNameChanged(self):
 441     """only change by GUI mouse selection, otherwise clear"""
 442     self.__selectedMesh = None
 443     self.MeshIn=""
 444     self.LE_MeshSmesh.setText("")
 445     self.fichierIn=""
 446     return
 447
 448   def paramsFileNameChanged(self):
 449     self.paramsFile=self.LE_ParamsFile.text()
 450
 451   def PBMeshSmeshPressed(self):
 452     from omniORB import CORBA
 453     import salome
 454     from salome.kernel import studyedit
 455     from salome.smesh.smeshstudytools import SMeshStudyTools
 456     from salome.gui import helper as guihelper
 457     from salome.smesh import smeshBuilder
 458     smesh = smeshBuilder.New()
 459
 460     mySObject, myEntry = guihelper.getSObjectSelected()
 461     if CORBA.is_nil(mySObject) or mySObject==None:
 462       QMessageBox.critical(self, "Mesh", "select an input mesh")
 463       #self.LE_MeshSmesh.setText("")
 464       #self.MeshIn=""
 465       #self.LE_MeshFile.setText("")
 466       #self.fichierIn=""
 467       return
 468     self.smeshStudyTool = SMeshStudyTools()
 469     try:
 470       self.__selectedMesh = self.smeshStudyTool.getMeshObjectFromSObject(mySObject)
 471     except:
 472       QMessageBox.critical(self, "Mesh", "select an input mesh")
 473       return
 474     if CORBA.is_nil(self.__selectedMesh):
 475       QMessageBox.critical(self, "Mesh", "select an input mesh")
 476       return
 477     myName = mySObject.GetName()
 478     #print "MeshSmeshNameChanged", myName
 479     self.MeshIn=myName
 480     self.LE_MeshSmesh.setText(myName)
 481     self.LE_MeshFile.setText("")
 482     self.fichierIn=""
 483
 484   def prepareFichier(self):
 485     self.fichierIn=tempfile.mktemp(suffix=".mesh",prefix="ForSurfOpt_")
 486     if os.path.exists(self.fichierIn):
 487         os.remove(self.fichierIn)
 488     self.__selectedMesh.ExportGMF(self.__selectedMesh, self.fichierIn, True)
 489
 490   def PrepareLigneCommande(self):
 491     if self.fichierIn=="" and self.MeshIn=="":
 492       QMessageBox.critical(self, "Mesh", "select an input mesh")
 493       return False
 494     if self.__selectedMesh!=None: self.prepareFichier()
 495     if not (os.path.isfile(self.fichierIn)):
 496       QMessageBox.critical(self, "File", "unable to read GMF Mesh in "+str(self.fichierIn))
 497       return False
 498
 499     self.commande="mg-surfopt.exe"
 500
 501     for obj in self.GBOptim.findChildren(QRadioButton,):
 502       try:
 503         if obj.isChecked():
 504           self.style=obj.objectName().remove(0,3)
 505           self.style.replace("_","-")
 506           break
 507       except:
 508         pass
 509
 510     style = str(self.style)
 511     # Translation of old Yams options to new MG-SurfOpt options
 512     if   style == "0" :
 513       self.commande+= " --optimisation only"
 514     elif style == "2" :
 515       self.commande+= " --Hausdorff_like yes"
 516     elif style == "-1":
 517       self.commande+= " --enrich no"
 518     elif style == "-2":
 519       self.commande+= " --Hausdorff_like yes --enrich no"
 520     elif style == "U" :
 521       self.commande+= " --uniform_flat_subdivision yes"
 522     elif style == "S" :
 523       self.commande+= " --sand_paper yes"
 524     elif style == "G" :
 525       self.commande+= " -O G"  # This option has not been updated to the new option style yet
 526
 527     deb=os.path.splitext(self.fichierIn)
 528     self.fichierOut=deb[0] + "_output.mesh"
 529
 530     tolerance=self.SP_toStr(self.SP_Tolerance)
 531     if not self.RB_Absolute.isChecked():
 532       tolerance+="r"
 533     self.commande+=" --chordal_error %s"%tolerance
 534
 535     if self.CB_Ridge.isChecked()    == False : self.commande+=" --compute_ridges no"
 536     if self.CB_Point.isChecked()    == False : self.commande+=" --optimisation no"
 537     if self.CB_SplitEdge.isChecked()== True  : self.commande+=" --element_order quadratic"
 538     if self.SP_Geomapp.value()      != 15.0  : self.commande+=" --geometric_approximation_angle %f"%self.SP_Geomapp.value()
 539     if self.SP_Ridge.value()        != 45.0  : self.commande+=" --ridge_angle %f"%self.SP_Ridge.value()
 540     if self.SP_MaxSize.value()      != 100   : self.commande+=" --max_size %f"   %self.SP_MaxSize.value()
 541     if self.SP_MinSize.value()      != 5     : self.commande+=" --min_size %f"   %self.SP_MinSize.value()
 542     if self.SP_Gradation.value()    != 1.3   : self.commande+=" --gradation %f"  %self.SP_Gradation.value()
 543     if self.SP_Memory.value()       != 0     : self.commande+=" --max_memory %d" %self.SP_Memory.value()
 544     if self.SP_Verbosity.value()    != 3     : self.commande+=" --verbose %d" %self.SP_Verbosity.value()
 545
 546     self.commande+=' --in "'  + self.fichierIn +'"'
 547     self.commande+=' --out "' + self.fichierOut +'"'
 548
 549     import SMeshHelper
 550     key = SMeshHelper.GetMGLicenseKey( self.fichierIn )
 551     self.commande+=' --key ' + key
 552
 553     print(self.commande)
 554     return True
 555
 556   def clean(self):
 557     self.RB_0.setChecked(True)
 558     #no need: exlusives QRadioButton
 559     #self.RB_G.setChecked(False)
 560     #self.RB_U.setChecked(False)
 561     #self.RB_S.setChecked(False)
 562     #self.RB_2.setChecked(False)
 563     #self.RB_1.setChecked(False)
 564     self.RB_Relative.setChecked(True)
 565     #no need: exlusives QRadioButton
 566     #self.RB_Absolute.setChecked(False)
 567     self.SP_Tolerance.setProperty("text", "0.001")
 568     self.SP_Geomapp.setProperty("value", 15.0)
 569     self.SP_Ridge.setProperty("value", 45.0)
 570     self.SP_Gradation.setProperty("value", 1.3)
 571     self.CB_Ridge.setChecked(True)
 572     self.CB_Point.setChecked(True)
 573     self.CB_SplitEdge.setChecked(False)
 574     self.SP_MaxSize.setProperty("value", 100)
 575     self.SP_MinSize.setProperty("value", 5)
 576     self.SP_Verbosity.setProperty("value", 3)
 577     self.SP_Memory.setProperty("value", 0)
 578     #self.PBMeshSmeshPressed() #do not that! problem if done in load surfopt hypo from object browser
 579     self.TWOptions.setCurrentIndex(0) # Reset current active tab to the first tab
 580
 581 __dialog=None
 582 def getDialog():
 583   """
 584   This function returns a singleton instance of the plugin dialog.
 585   It is mandatory in order to call show without a parent ...
 586   """
 587   global __dialog
 588   if __dialog is None:
 589     __dialog = MonYamsPlugDialog()
 590   #else :
 591   #  __dialog.clean()
 592   return __dialog
 593
 594 #
 595 # ==============================================================================
 596 # Basic use cases and unit test functions
 597 # ==============================================================================
 598 #
 599 def TEST_MonYamsPlugDialog():
 600   import sys
 601   from qtsalome import QApplication
 602   app = QApplication(sys.argv)
 603   app.lastWindowClosed.connect(app.quit)
 604
 605   dlg=MonYamsPlugDialog()
 606   dlg.show()
 607   sys.exit(app.exec_())
 608
 609 if __name__ == "__main__":
 610   TEST_MonYamsPlugDialog()
 611   pass