src/Tools/YamsPlug/monYamsPlugDialog.py

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