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)
 417       self.MeshIn=""
 418       self.LE_MeshSmesh.setText("")
 419       self.__selectedMesh=None
 420
 421   def setParamsFileName(self):
 422     fd = QFileDialog(self, "select a file", self.LE_ParamsFile.text(), "dat Files (*.dat);;All Files (*)")
 423     if fd.exec_():
 424       infile = fd.selectedFiles()[0]
 425       self.LE_ParamsFile.setText(infile)
 426       self.paramsFile=str(infile)
 427
 428   def meshFileNameChanged(self):
 429     self.fichierIn=str(self.LE_MeshFile.text())
 430     #print "meshFileNameChanged", self.fichierIn
 431     if os.path.exists(self.fichierIn):
 432       self.__selectedMesh=None
 433       self.MeshIn=""
 434       self.LE_MeshSmesh.setText("")
 435       return
 436     QMessageBox.warning(self, "Mesh file", "File doesn't exist")
 437
 438   def meshSmeshNameChanged(self):
 439     """only change by GUI mouse selection, otherwise clear"""
 440     self.__selectedMesh = None
 441     self.MeshIn=""
 442     self.LE_MeshSmesh.setText("")
 443     self.fichierIn=""
 444     return
 445
 446   def paramsFileNameChanged(self):
 447     self.paramsFile=self.LE_ParamsFile.text()
 448
 449   def PBMeshSmeshPressed(self):
 450     from omniORB import CORBA
 451     import salome
 452     from salome.kernel import studyedit
 453     from salome.smesh.smeshstudytools import SMeshStudyTools
 454     from salome.gui import helper as guihelper
 455     from salome.smesh import smeshBuilder
 456     smesh = smeshBuilder.New()
 457
 458     mySObject, myEntry = guihelper.getSObjectSelected()
 459     if CORBA.is_nil(mySObject) or mySObject==None:
 460       QMessageBox.critical(self, "Mesh", "select an input mesh")
 461       #self.LE_MeshSmesh.setText("")
 462       #self.MeshIn=""
 463       #self.LE_MeshFile.setText("")
 464       #self.fichierIn=""
 465       return
 466     self.smeshStudyTool = SMeshStudyTools()
 467     try:
 468       self.__selectedMesh = self.smeshStudyTool.getMeshObjectFromSObject(mySObject)
 469     except:
 470       QMessageBox.critical(self, "Mesh", "select an input mesh")
 471       return
 472     if CORBA.is_nil(self.__selectedMesh):
 473       QMessageBox.critical(self, "Mesh", "select an input mesh")
 474       return
 475     myName = mySObject.GetName()
 476     #print "MeshSmeshNameChanged", myName
 477     self.MeshIn=myName
 478     self.LE_MeshSmesh.setText(myName)
 479     self.LE_MeshFile.setText("")
 480     self.fichierIn=""
 481
 482   def prepareFichier(self):
 483     self.fichierIn=tempfile.mktemp(suffix=".mesh",prefix="ForSurfOpt_")
 484     if os.path.exists(self.fichierIn):
 485         os.remove(self.fichierIn)
 486     self.__selectedMesh.ExportGMF(self.__selectedMesh, self.fichierIn, True)
 487
 488   def PrepareLigneCommande(self):
 489     if self.fichierIn=="" and self.MeshIn=="":
 490       QMessageBox.critical(self, "Mesh", "select an input mesh")
 491       return False
 492     if self.__selectedMesh!=None: self.prepareFichier()
 493     if not (os.path.isfile(self.fichierIn)):
 494       QMessageBox.critical(self, "File", "unable to read GMF Mesh in "+str(self.fichierIn))
 495       return False
 496
 497     self.commande="mg-surfopt.exe"
 498
 499     for obj in self.GBOptim.findChildren(QRadioButton,):
 500       try:
 501         if obj.isChecked():
 502           self.style=obj.objectName().remove(0,3)
 503           self.style.replace("_","-")
 504           break
 505       except:
 506         pass
 507
 508     style = str(self.style)
 509     # Translation of old Yams options to new MG-SurfOpt options
 510     if   style == "0" :
 511       self.commande+= " --optimisation only"
 512     elif style == "2" :
 513       self.commande+= " --Hausdorff_like yes"
 514     elif style == "-1":
 515       self.commande+= " --enrich no"
 516     elif style == "-2":
 517       self.commande+= " --Hausdorff_like yes --enrich no"
 518     elif style == "U" :
 519       self.commande+= " --uniform_flat_subdivision yes"
 520     elif style == "S" :
 521       self.commande+= " --sand_paper yes"
 522     elif style == "G" :
 523       self.commande+= " -O G"  # This option has not been updated to the new option style yet
 524
 525     deb=os.path.splitext(self.fichierIn)
 526     self.fichierOut=deb[0] + "_output.mesh"
 527
 528     tolerance=self.SP_toStr(self.SP_Tolerance)
 529     if not self.RB_Absolute.isChecked():
 530       tolerance+="r"
 531     self.commande+=" --chordal_error %s"%tolerance
 532
 533     if self.CB_Ridge.isChecked()    == False : self.commande+=" --compute_ridges no"
 534     if self.CB_Point.isChecked()    == False : self.commande+=" --optimisation no"
 535     if self.CB_SplitEdge.isChecked()== True  : self.commande+=" --element_order quadratic"
 536     if self.SP_Geomapp.value()      != 15.0  : self.commande+=" --geometric_approximation_angle %f"%self.SP_Geomapp.value()
 537     if self.SP_Ridge.value()        != 45.0  : self.commande+=" --ridge_angle %f"%self.SP_Ridge.value()
 538     if self.SP_MaxSize.value()      != 100   : self.commande+=" --max_size %f"   %self.SP_MaxSize.value()
 539     if self.SP_MinSize.value()      != 5     : self.commande+=" --min_size %f"   %self.SP_MinSize.value()
 540     if self.SP_Gradation.value()    != 1.3   : self.commande+=" --gradation %f"  %self.SP_Gradation.value()
 541     if self.SP_Memory.value()       != 0     : self.commande+=" --max_memory %d" %self.SP_Memory.value()
 542     if self.SP_Verbosity.value()    != 3     : self.commande+=" --verbose %d" %self.SP_Verbosity.value()
 543
 544     self.commande+=" --in "  + self.fichierIn
 545     self.commande+=" --out " + self.fichierOut
 546
 547     print(self.commande)
 548     return True
 549
 550   def clean(self):
 551     self.RB_0.setChecked(True)
 552     #no need: exlusives QRadioButton
 553     #self.RB_G.setChecked(False)
 554     #self.RB_U.setChecked(False)
 555     #self.RB_S.setChecked(False)
 556     #self.RB_2.setChecked(False)
 557     #self.RB_1.setChecked(False)
 558     self.RB_Relative.setChecked(True)
 559     #no need: exlusives QRadioButton
 560     #self.RB_Absolute.setChecked(False)
 561     self.SP_Tolerance.setProperty("text", "0.001")
 562     self.SP_Geomapp.setProperty("value", 15.0)
 563     self.SP_Ridge.setProperty("value", 45.0)
 564     self.SP_Gradation.setProperty("value", 1.3)
 565     self.CB_Ridge.setChecked(True)
 566     self.CB_Point.setChecked(True)
 567     self.CB_SplitEdge.setChecked(False)
 568     self.SP_MaxSize.setProperty("value", 100)
 569     self.SP_MinSize.setProperty("value", 5)
 570     self.SP_Verbosity.setProperty("value", 3)
 571     self.SP_Memory.setProperty("value", 0)
 572     #self.PBMeshSmeshPressed() #do not that! problem if done in load surfopt hypo from object browser
 573     self.TWOptions.setCurrentIndex(0) # Reset current active tab to the first tab
 574
 575 __dialog=None
 576 def getDialog():
 577   """
 578   This function returns a singleton instance of the plugin dialog.
 579   It is mandatory in order to call show without a parent ...
 580   """
 581   global __dialog
 582   if __dialog is None:
 583     __dialog = MonYamsPlugDialog()
 584   #else :
 585   #  __dialog.clean()
 586   return __dialog
 587
 588 #
 589 # ==============================================================================
 590 # Basic use cases and unit test functions
 591 # ==============================================================================
 592 #
 593 def TEST_MonYamsPlugDialog():
 594   import sys
 595   from qtsalome import QApplication
 596   app = QApplication(sys.argv)
 597   app.lastWindowClosed.connect(app.quit)
 598
 599   dlg=MonYamsPlugDialog()
 600   dlg.show()
 601   sys.exit(app.exec_())
 602
 603 if __name__ == "__main__":
 604   TEST_MonYamsPlugDialog()
 605   pass