iramuteq.org Git - iramuteq/blob - layout.py

   1 #!/bin/env python
   2 # -*- coding: utf-8 -*-
   3 #Author: Pierre Ratinaud
   4 #Copyright (c) 2008-2009 Pierre Ratinaud
   5 #License: GNU/GPL
   6
   7 import os
   8 import wx
   9 import wx.lib.hyperlink as hl
  10 import wx.lib.agw.aui as aui
  11 from chemins import ConstructPathOut, ChdTxtPathOut, FFF, ffr, PathOut, StatTxtPathOut, simipath
  12 from ConfigParser import ConfigParser
  13 from functions import ReadProfileAsDico, GetTxtProfile, read_list_file, ReadList, exec_rcode, print_liste, BugReport, DoConf, indices_simi, check_Rresult, progressbar
  14 from ProfList import ProfListctrlPanel
  15 from guiparam3d import param3d, simi3d
  16 from PrintRScript import write_afc_graph, print_simi3d, PrintSimiScript
  17 from profile_segment import ProfileSegment
  18 from functions import ReadList
  19 from listlex import *
  20 from Liste import *
  21 from search_tools import SearchFrame
  22 from dialog import PrefGraph, PrefExport, PrefSimpleFile, PrefDendro, SimpleDialog
  23 from guifunct import SelectColumn, PrepSimi, PrefSimi
  24 from webexport import WebExport
  25 from corpus import Corpus
  26 from sheet import MySheet
  27 import datetime
  28 import sys
  29 import tempfile
  30 from time import sleep
  31 import shutil
  32 import codecs
  33 import logging
  34
  35 log = logging.getLogger('iramuteq.layout')
  36
  37
  38 class GraphPanelAfc(wx.Panel):
  39     def __init__(self, parent, dico, list_graph, clnb, itempath = 'liste_graph_afc', coding = sys.getdefaultencoding()):
  40         wx.Panel.__init__(self,parent)
  41         self.afcnb = 1
  42         self.clnb = clnb
  43         self.Dict = dico
  44         self.coding = coding
  45         self.itempath = itempath
  46         self.parent = self.GetParent()#parent
  47         self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
  48         self.labels = []
  49         self.listimg = []
  50         self.buts = []
  51         self.list_graph = list_graph
  52         self.TabCHD = self.parent.GetParent()
  53         self.nb = self.TabCHD.GetParent()
  54         self.ira = self.nb.GetParent()
  55         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
  56         afc_img = wx.Image(os.path.join(self.ira.images_path,'button_afc.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
  57         self.butafc = wx.BitmapButton(self, -1, afc_img)
  58         self.Bind(wx.EVT_BUTTON, self.afc_graph, self.butafc)
  59         self.dirout = os.path.dirname(self.Dict['ira'])
  60         b = 0
  61         todel = []
  62         for i in range(0,len(list_graph)):
  63             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
  64                 filename, ext = os.path.splitext(list_graph[i][0])
  65                 if ext == '.svg' or ext == '.html':
  66                     self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, os.path.join(self.dirout,list_graph[i][0]), URL=os.path.join(self.dirout,list_graph[i][0])))
  67                 else :
  68                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
  69                 if os.path.exists(os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')) :
  70                     txt = _(u"List of not plotted points : ").decode('utf8') + '%s' % os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')
  71                 else :
  72                     txt = ''
  73                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1] + txt))
  74                 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = `i - b`))
  75             else :
  76                 todel.append(i)
  77                 b += 1
  78         self.list_graph = [graph for i, graph in enumerate(self.list_graph) if i not in todel]
  79
  80         self.param = { 'typegraph' : 0,
  81               'width' : 800,
  82               'height' : 800,
  83               'what' : 0,
  84               'qui' : 0,
  85               'do_select_nb' : 0,
  86               'do_select_chi' : 0,
  87               'do_select_chi_classe' : 0,
  88               'select_nb' : 50,
  89               'select_chi' : 4,
  90               'nbchic' : 30,
  91               'over' : 0,
  92               'cex_txt' : 0,
  93               'txt_min' : 5,
  94               'txt_max' : 40,
  95               'tchi' : 0,
  96               'tchi_min' : 5,
  97               'tchi_max' : 40,
  98               'taillecar' : 9,
  99               'facteur' : [1,2,3],
 100               'alpha' : 10,
 101               'clnb' : clnb,
 102               'svg' : 0,
 103                }
 104
 105         self.__set_properties()
 106         self.__do_layout()
 107
 108     def __set_properties(self):
 109         self.panel_1.EnableScrolling(True,True)
 110         #self.panel_1.SetSize((1000,1000))
 111         self.panel_1.SetScrollRate(20, 20)
 112         self.panel_1.SetFocus()
 113
 114     def __do_layout(self):
 115         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
 116         self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
 117         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
 118         self.sizer_2.Add(self.butafc, 0, 0, 0)
 119         for i in range(0, len(self.listimg)):
 120             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 121             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 122             self.sizer_3.Add(self.buts[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 123             self.Bind(wx.EVT_BUTTON, self.on_delete_image, self.buts[i])
 124         self.panel_1.SetSizer(self.sizer_3)
 125         self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
 126         self.SetSizer(self.sizer_2)
 127
 128     def on_delete_image(self, event) :
 129         image_id = int(event.GetEventObject().GetName())
 130         image_path = self.list_graph[image_id][0]
 131         message = _(u'This file will be delete : ') + '%s.\n' % os.path.join(self.dirout, image_path) + _('Are you sure ?')
 132         dial = wx.MessageDialog(self, message, style = wx.YES_NO)
 133         res = dial.ShowModal()
 134         if res == wx.ID_YES :
 135             dial.Destroy()
 136             log.info('delete image %i' % image_id)
 137             oldimg = self.listimg.pop(image_id)
 138             oldimg.Destroy()
 139             oldlab = self.labels.pop(image_id)
 140             oldlab.Destroy()
 141             oldbut = self.buts.pop(image_id)
 142             oldbut.Show(False)
 143             for i, but in enumerate(self.buts) :
 144                 but.SetName(`i`)
 145             todel = self.list_graph.pop(image_id)
 146             os.remove(os.path.join(self.dirout, todel[0]))
 147             print_liste(self.Dict[self.itempath], self.list_graph)
 148             self.sizer_3.Fit(self.panel_1)
 149             self.Layout()
 150         else :
 151             dial.Destroy()
 152
 153
 154     def afc_graph(self,event):
 155         #dirout = os.path.dirname(self.Dict['ira'])
 156         dial = PrefGraph(self.parent,-1,self.param,'')
 157         dial.CenterOnParent()
 158         val = dial.ShowModal()
 159         if val == wx.ID_OK :
 160             if dial.choix_format.GetSelection() == 0 :
 161                 svg = 0
 162             else :
 163                 svg = 1
 164             typegraph = dial.choicetype.GetSelection()
 165             typefile = '.png'
 166             if self.clnb <= 3 and typegraph == 1 :
 167                 typegraph = 2
 168             if typegraph == 2:
 169                 typefile = '.gexf'
 170             while os.path.exists(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile)):
 171                 self.afcnb +=1
 172             self.fileout = ffr(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile))
 173
 174             self.param = {'typegraph' : typegraph,
 175                           'width' : dial.spin1.GetValue(),
 176                           'height' : dial.spin2.GetValue(),
 177                           'what' : dial.choice1.GetSelection(),
 178                           'qui' : dial.choice2.GetSelection(),
 179                           'do_select_nb' : dial.check1.GetValue(),
 180                           'do_select_chi' : dial.check2.GetValue(),
 181                           'do_select_chi_classe' : dial.check_chic.GetValue(),
 182                           'select_nb' : dial.spin_nb.GetValue(),
 183                           'select_chi' : dial.spin_chi.GetValue(),
 184                           'nbchic' : dial.spin_nbchic.GetValue(),
 185                           'over' : dial.check3.GetValue(),
 186                           'cex_txt' : dial.check4.GetValue(),
 187                           'txt_min' : dial.spin_min.GetValue(),
 188                           'txt_max' : dial.spin_max.GetValue(),
 189                           'tchi' : dial.check_tchi.GetValue(),
 190                           'tchi_min' : dial.spin_min_tchi.GetValue(),
 191                           'tchi_max' : dial.spin_max_tchi.GetValue(),
 192                           'taillecar' : dial.spin3.GetValue(),
 193                           'facteur' : [dial.spin_f1.GetValue(),dial.spin_f2.GetValue(), dial.spin_f3.GetValue()],
 194                           'clnb' : self.clnb,
 195                           'film' : str(dial.film.GetValue()).upper(),
 196                           'alpha' : dial.slider_sphere.GetValue(),
 197                           'svg' : svg
 198                         }
 199             self.nb.parent = self.ira
 200             self.DictPathOut = self.Dict
 201             self.RscriptsPath = self.ira.RscriptsPath
 202             txt = """
 203             load("%s")
 204             """ % self.DictPathOut['RData']
 205             if self.itempath == 'liste_graph_afcf' :
 206                 txt += """
 207                 afc <- afcf
 208                 afc_table <- afcf_table
 209                 chistabletot <- specfp
 210                 """
 211             elif self.itempath == 'liste_graph_afct' :
 212                 txt +="""
 213                 afc <- afct
 214                 afc_table <- afct_table
 215                 chistabletot <- spectp
 216                 """
 217             txt += write_afc_graph(self)
 218             filetmp = tempfile.mktemp()
 219             with open(filetmp, 'w') as f :
 220                 f.write(txt)
 221             pid = exec_rcode(self.ira.RPath, filetmp)
 222             check_Rresult(self.ira, pid)
 223             if self.param['typegraph'] in [0,2] :
 224                 txt = 'Variables '
 225                 if self.param['qui'] == 0 : value = u'actives'
 226                 if self.param['qui'] == 1 : value = u'supplémentaires'
 227                 if self.param['qui'] == 2 : value = u'étoilées'
 228                 if self.param['qui'] == 3 : value = u'classes'
 229                 txt += value + ' - '
 230                 if self.param['what'] == 0 : value = u'Coordonnées'
 231                 if self.param['what'] == 1 : value = u'Corrélations'
 232                 txt += value + u' - facteur %i / %i' % (self.param['facteur'][0], self.param['facteur'][1])
 233                 if self.param['do_select_nb'] : txt += u' - sélection de %i variables' % self.param['select_nb']
 234                 if self.param['do_select_chi'] : txt += u' - sélection des variables avec chi2 > %i ' % self.param['select_chi']
 235                 if self.param['over'] : txt += u' - Eviter les recouvrements'
 236                 if self.param['cex_txt'] : txt += u' - taille du texte proportionnel à la masse'
 237                 if self.param['tchi'] : txt += u' - taille du texte proportionnel au chi2 d\'association'
 238                 #list_graph = read_list_file(self.DictPathOut[self.itempath], self.coding)
 239                 if self.param['svg'] :
 240                     filename, ext = os.path.splitext(self.fileout)
 241                     self.fileout = filename + '.svg'
 242                 if self.param['typegraph'] == 2 :
 243                     parametres = {'gexffile' :  self.fileout,
 244                                   'titre': 'Le titre',
 245                                   'nodemin': self.param['txt_min'],
 246                                   'nodemax': self.param['txt_max'],
 247                                   'bargraphw' : 60*int(self.param['clnb']),
 248                     }
 249                     web = WebExport(self.ira, parametres)
 250                     self.fileout = web.exportafc()
 251                 self.list_graph.append([os.path.basename(self.fileout), txt])
 252                 print_liste(self.DictPathOut[self.itempath], self.list_graph)
 253                 if self.param['svg'] or self.param['typegraph'] == 2:
 254                     self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, self.fileout, URL=self.fileout))
 255
 256                 else :
 257                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(self.fileout, wx.BITMAP_TYPE_ANY)))
 258                 self.sizer_3.Add( self.listimg[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 259                 self.labels.append(wx.StaticText(self.panel_1,-1, txt))
 260                 self.sizer_3.Add(self.labels[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 261                 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = `len(self.list_graph) - 1`))
 262                 self.sizer_3.Add(self.buts[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 263                 self.sizer_3.Fit(self.panel_1)
 264                 self.Layout()
 265
 266                 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
 267 #             elif self.param['typegraph'] == 2 :
 268 #                 parametres = {'gexffile' :  self.fileout,
 269 #                               'titre': 'Le titre',
 270 #                               'nodemin': self.param['txt_min'],
 271 #                               'nodemax': self.param['txt_max'],
 272 #                               'bargraphw' : 60*int(self.param['clnb']),
 273 #                 }
 274 #                 web = WebExport(self.ira, parametres)
 275 #                 afcout = web.exportafc()
 276 #                 dial = SimpleDialog(self.ira)
 277 #                 dial.link.SetLabel(afcout)
 278 #                 dial.link.SetURL(afcout)
 279 #                 dial.Layout()
 280 #                 dial.ShowModal()
 281
 282
 283 class GraphPanel(wx.ScrolledWindow):
 284     def __init__(self, parent, dico, list_graph, txt = '', style = wx.TAB_TRAVERSAL):
 285         wx.ScrolledWindow.__init__(self, parent, style = style)
 286         self.Dict = dico
 287         self.txt = txt
 288         self.parent = parent
 289         self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
 290         self.labels = []
 291         self.listimg = []
 292         self.dirout = os.path.dirname(self.Dict['ira'])
 293         self.deb = wx.StaticText(self, -1, txt)
 294         for i in range(0,len(list_graph)):
 295             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
 296                 filename, ext = os.path.splitext(list_graph[i][0])
 297                 if ext == '.svg' :
 298                     self.listimg.append(hl.HyperLinkCtrl(self, -1, os.path.join(self.dirout,list_graph[i][0]), URL=os.path.join(self.dirout,list_graph[i][0])))
 299                 else :
 300                     self.listimg.append(wx.StaticBitmap(self, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
 301                 self.labels.append(wx.StaticText(self, -1, list_graph[i][1]))
 302         self.Bind(wx.EVT_MOTION, self.onMouseMove)
 303         self.__set_properties()
 304         self.__do_layout()
 305
 306     def __set_properties(self):
 307         self.EnableScrolling(True,True)
 308         self.SetScrollRate(20, 20)
 309         self.SetFocus()
 310
 311
 312     def __do_layout(self):
 313         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
 314         self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
 315         self.sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
 316         self.sizer_1.Add(self.deb)
 317         for i in range(0, len(self.listimg)):
 318             self.sizer_1.Add(self.listimg[i], 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
 319             self.sizer_1.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 320         self.sizer_2.Add(self.sizer_1, 1, wx.EXPAND, 0)
 321         self.SetSizer(self.sizer_1)
 322         self.sizer_1.Fit(self)
 323
 324     def onMouseMove(self, event):
 325         self.SetFocus()
 326
 327
 328 def open_antiprofil(panel, AntiProfile, encoding) :
 329     DictAnti = ReadProfileAsDico(AntiProfile, True, encoding)
 330     panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 331     for i in range(0, panel.parametres['clnb']):
 332         tabantiprofile = ProfListctrlPanel(panel, panel, DictAnti[str(i + 1)], True, i + 1)
 333         panel.AntiProfNB.AddPage(tabantiprofile, 'classe %s' % str(i + 1))
 334     panel.TabChdSim.AddPage(panel.AntiProfNB, _(u"Antiprofiles").decode('utf8'))
 335
 336
 337
 338 def getlemgram(corpus, lem) :
 339     if not lem[6] in corpus.lems :
 340         return lem[5]
 341     else :
 342         return corpus.lems[lem[6]].gram
 343
 344 class OpenCHDS():
 345     def __init__(self, parent, corpus, parametres, Alceste=False):
 346         #sep = u'\n '
 347         sep=' '
 348         self.parent = parent
 349         self.corpus = corpus
 350         self.parametres = parametres
 351         self.pathout = PathOut(parametres['ira'])
 352         self.pathout.basefiles(ChdTxtPathOut)
 353         DictPathOut = self.pathout
 354         self.DictPathOut = DictPathOut
 355         self.dictpathout = DictPathOut
 356         self.parent = parent
 357
 358         Profile = DictPathOut['PROFILE_OUT']
 359         AntiProfile = DictPathOut['ANTIPRO_OUT']
 360         self.encoding = self.parametres['encoding']
 361         if isinstance(self.corpus, Corpus) :
 362             self.corpus.make_ucecl_from_R(self.pathout['uce'])
 363             corpname = self.corpus.parametres['corpus_name']
 364         else :
 365             corpname = self.corpus.parametres['matrix_name']
 366             if os.path.exists(self.pathout['analyse.db']) :
 367                 self.corpus.read_tableau(self.pathout['analyse.db'])
 368
 369         clnb = parametres['clnb']
 370         dlg = progressbar(self, maxi = 4 + clnb)
 371         self.clnb = clnb
 372         print 'lecture des profils'
 373         dlg.Update(2, _(u"Reading profiles").decode('utf8'))
 374
 375         DictProfile = ReadProfileAsDico(Profile, Alceste, self.encoding)
 376         self.DictProfile = DictProfile
 377         self.cluster_size = []
 378         #print 'lecture des antiprofils'
 379         #DictAnti = ReadProfileAsDico(self, AntiProfile, Alceste, self.encoding)
 380
 381         panel = wx.Panel(parent, -1)
 382         sizer1 = wx.BoxSizer(wx.VERTICAL)
 383
 384         if os.path.exists(DictPathOut['pre_rapport']):
 385             with codecs.open(DictPathOut['pre_rapport'], 'r', self.encoding) as f :
 386                 txt = f.read()
 387             self.debtext = txt
 388         else :
 389             self.debtext = ''
 390 #       panel.chd_toolbar = wx.ToolBar(panel, -1, wx.DefaultPosition, wx.DefaultSize, wx.TB_FLAT | wx.TB_NODIVIDER)
 391 #       panel.chd_toolbar.SetToolBitmapSize(wx.Size(16, 16))
 392
 393         if isinstance(self.corpus, Corpus) :
 394             panel.corpus = self.corpus
 395         else :
 396             panel.tableau = self.corpus
 397             #self.parent.tableau = panel.tableau
 398         panel.dictpathout = self.DictPathOut
 399         panel.pathout = self.DictPathOut
 400         panel.parent = self.parent
 401         panel.DictProfile = self.DictProfile
 402         panel.cluster_size = self.cluster_size
 403         panel.debtext = self.debtext
 404
 405 #       self.ID_rapport = wx.NewId()
 406 #       #rap_img = wx.Image(os.path.join(self.parent.images_path,'icone_rap_16.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
 407 #       #panel.chd_toolbar.AddLabelTool(self.ID_rapport, "rapport", rap_img, shortHelp=u"Produire le rapport", longHelp=u"Exporter un rapport en texte simple")
 408 #       butrap = wx.Button(panel.chd_toolbar, self.ID_rapport, u"Rapport ")
 409 #       panel.chd_toolbar.AddControl(butrap)
 410 #
 411 #       panel.chd_toolbar.Realize()
 412 #       sizer1.Add(panel.chd_toolbar,0, wx.EXPAND, 5)
 413
 414         #self.TabChdSim = wx.aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
 415         notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT| wx.NO_BORDER
 416         panel.TabChdSim = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 417         panel.TabChdSim.SetAGWWindowStyleFlag(notebook_flags)
 418         panel.TabChdSim.SetArtProvider(aui.ChromeTabArt())
 419         sizer1.Add(panel.TabChdSim,10, wx.EXPAND, 5)
 420         panel.SetSizer(sizer1)
 421         sizer1.Fit(panel)
 422
 423
 424         if isinstance(self.corpus, Corpus) :
 425             panel.TabChdSim.corpus = corpus
 426             panel.TabChdSim.corpus.dictpathout = self.DictPathOut
 427         else :
 428             panel.TabChdSim.tableau = corpus
 429             panel.TabChdSim.tableau.dictpathout = self.DictPathOut
 430         panel.parametres = self.parametres
 431         self.panel = panel
 432
 433         self.notenb = self.parent.nb.GetPageCount()
 434
 435
 436         if os.path.exists(self.DictPathOut['liste_graph_chd']) :
 437             list_graph = read_list_file(self.DictPathOut['liste_graph_chd'], self.encoding)
 438             CHD = GraphPanelDendro(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
 439             panel.TabChdSim.AddPage(CHD,'CHD')
 440
 441         panel.ProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 442         panel.ProfNB.SetArtProvider(aui.ChromeTabArt())
 443         #self.ProfNB.SetTabCtrlHeight(100)
 444         #panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 445         if os.path.exists(DictPathOut['prof_seg']) :
 446             prof_seg = ReadProfileAsDico(DictPathOut['prof_seg'], False, self.encoding)
 447             self.prof_seg_nb = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 448         for i in range(0, clnb):
 449             self.cluster_size.append(DictProfile[str(i + 1)][0][0:3])
 450             if isinstance(self.corpus, Corpus) :
 451                 DictProfile[str(i + 1)][1:] = [val[0:5] + [getlemgram(self.corpus, val)] + val[6:] for val in DictProfile[str(i + 1)][1:]]
 452             dlg.Update(3+i, 'Classe %i' %(i+1))
 453             ind = '/'.join(DictProfile[str(i + 1)][0][0:2])
 454             indpour = ' - '.join([ind, DictProfile[str(i + 1)][0][2]])
 455             self.tabprofile = ProfListctrlPanel(self.parent, self.panel, DictProfile[str(i + 1)], Alceste, i + 1)
 456             #self.tabantiprofile = ProfListctrlPanel(self.parent, self, DictAnti[str(i + 1)], Alceste, i + 1)
 457             panel.ProfNB.AddPage(self.tabprofile, _(u"Cluster").decode('utf8') + ' %s %s(%s%%)' % (str(i + 1), sep, indpour))
 458             #panel.AntiProfNB.AddPage(self.tabantiprofile, 'classe %s' % str(i + 1))
 459             if os.path.exists(DictPathOut['prof_seg']) :
 460                 self.tab_prof_seg = ProfListctrlPanel(self.parent, self, prof_seg[str(i + 1)], False, i + 1)
 461                 self.prof_seg_nb.AddPage(self.tab_prof_seg, _(u"Cluster").decode('utf8') + ' %i' % (i + 1))
 462
 463         if clnb > 2 :
 464             self.TabAFC = aui.AuiNotebook(panel.TabChdSim, -1, wx.DefaultPosition)
 465             log.info('read AFC')
 466             list_graph=read_list_file(DictPathOut['liste_graph_afc'], self.encoding)
 467             self.tabAFCGraph = GraphPanelAfc(self.TabAFC, DictPathOut, list_graph, self.clnb, coding=self.encoding)
 468             self.TabAFC.AddPage(self.tabAFCGraph, _(u"CA").decode('utf8'))
 469
 470             if os.path.exists(self.DictPathOut['afc_facteur']) :
 471                 dictrow, first = ReadList(self.DictPathOut['afc_facteur'], self.encoding)
 472                 self.TabAFC_facteur = ListForSpec(self.parent, parametres, dictrow, first[1:])
 473                 #dictrow, first = ReadList(self.DictPathOut['afc_row'], self.encoding)
 474                 #self.TabAFC_ligne = ListForSpec(self.parent, self.parametres, dictrow, first)
 475                 #dictrow, first = ReadList(self.DictPathOut['afc_col'], self.encoding)
 476                 #self.TabAFC_colonne = ListForSpec(parent, self.parametres, dictrow, first)
 477                 self.TabAFC.AddPage(self.TabAFC_facteur, _(u"Factor").decode('utf8'))
 478                 #self.TabAFC.AddPage(self.TabAFC_colonne, u'Colonnes')
 479                 #self.TabAFC.AddPage(self.TabAFC_ligne, u'Lignes')
 480
 481             sizer_3 = wx.BoxSizer(wx.VERTICAL)
 482             self.parent.nb_panel_2 = wx.Panel(panel.TabChdSim, -1)
 483             self.parent.button_simi = wx.Button(self.parent.nb_panel_2, -1, "Voyager")
 484             self.parent.simi3dpanel = simi3d(self.parent.nb_panel_2, -1)
 485             sizer_3.Add(self.parent.simi3dpanel, 1, wx.EXPAND, 0)
 486             sizer_3.Add(self.parent.button_simi, 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 487             self.parent.nb_panel_2.SetSizer(sizer_3)
 488             self.TabAFC.AddPage(self.parent.nb_panel_2, _(u"3D graph").decode('utf8'))
 489             self.parent.Bind(wx.EVT_BUTTON, self.onsimi, self.parent.button_simi)
 490
 491         panel.TabChdSim.AddPage(panel.ProfNB, _(u"Profiles").decode('utf8'))
 492         #panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')
 493         dlg.Update(4 + self.clnb, 'Affichage...')
 494         if clnb > 2 :
 495             panel.TabChdSim.AddPage(self.TabAFC, _(u"CA").decode('utf8'))
 496         if os.path.exists(DictPathOut['prof_seg']) :
 497             panel.TabChdSim.AddPage(self.prof_seg_nb, _(u"Repeated segments profiles").decode('utf8'))
 498
 499 #       panel.Bind(wx.EVT_BUTTON, self.ongetrapport, id = self.ID_rapport)
 500         self.parent.nb.AddPage(panel, _(u"Clustering").decode('utf8') + ' - %s' % corpname)
 501         self.parent.ShowTab(True)
 502         self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
 503         #for pane in self.parent._mgr.GetAllPanes() :
 504         #     if isinstance(pane.window, aui.AuiNotebook):
 505         #         nb = pane.window
 506         #         nb.SetAGWWindowStyleFlag(notebook_flags)
 507         #         nb.SetArtProvider(aui.ChromeTabArt())
 508         dlg.Destroy()
 509         self.parent._mgr.Update()
 510
 511     def onsimi(self,event):
 512         outfile = print_simi3d(self)
 513         error = exec_rcode(self.parent.RPath, outfile, wait = True)
 514
 515     def onclusterstat(self, evt) :
 516         dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': 'Stat par classe'})
 517         dial.fbb.SetValue( os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'stat_par_classe.csv'))
 518         dial.CenterOnParent()
 519         res = dial.ShowModal()
 520         if res == wx.ID_OK :
 521             fileout = dial.fbb.GetValue()
 522             dial.Destroy()
 523             self.corpus.get_stat_by_cluster(fileout)
 524             msg = u"Fini !"
 525             dlg = wx.MessageDialog(self.parent, msg, _(u"Stat by cluster").decode('utf8'), wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
 526             dlg.CenterOnParent()
 527             if dlg.ShowModal() == wx.ID_OK :
 528                 dlg.Destroy()
 529
 530     #def onsearchf(self, evt) :
 531     #    if 'FrameSearch' not in dir(self.panel) :
 532     #        self.panel.FrameSearch = SearchFrame(self.parent, -1, u"Rechercher...", self.corpus)
 533     #    self.panel.FrameSearch.Show()
 534
 535 def PrintRapport(self, corpus, parametres, istxt = True):
 536     sep = '\n'
 537     txt = """
 538 +-+-+-+-+-+-+-+-+
 539 |i|R|a|M|u|T|e|Q| - %s
 540 +-+-+-+-+-+-+-+-+
 541
 542
 543 """ % datetime.datetime.now().ctime()
 544     if istxt :
 545         totocc = corpus.gettotocc()
 546         txt += u'nombre de textes: %i%s' % (corpus.getucinb(), sep)
 547         txt += u'nombre de segments de textes: %i%s' % (corpus.getucenb(), sep)
 548         txt += u'nombre de formes: %i%s' % (len(corpus.formes), sep)
 549         txt += u'nombre d\'occurrences: %i%s' % (totocc, sep)
 550         txt += u'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
 551         txt += u'nombre de lemmes: %i%s' % (len(corpus.lems), sep)
 552         txt += u'nombre de formes actives: %i%s' % (corpus.getactivesnb(1), sep)
 553         txt += u'nombre de formes supplémentaires: %i%s' % (corpus.getactivesnb(2), sep)
 554         txt += u'nombre de formes actives de fréquence >= %i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)
 555         txt += u'moyenne d\'occurrences par segments :%f%s' % (float(totocc) / float(corpus.getucenb()), sep)
 556         if 'tailleuc1' in parametres :
 557             if parametres['classif_mode'] == 0 :
 558                 txt += u'taille rst1 / rst2: %i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)
 559     else :
 560         self.Ucenb = self.nbind
 561         txt += u'nombre d\'individus : %i%s' % (self.nbind, sep)
 562         txt += u'nombre de classes : %i%s' % (self.clnb, sep)
 563     if istxt :
 564         txt += u'nombre de classes : %i%s' % (parametres['clnb'], sep)
 565         if parametres['classif_mode'] == 0 or parametres['classif_mode'] == 1 :
 566             txt += u'%i segments classés sur %i (%.2f%%)%s' % (sum([len(cl) for cl in corpus.lc]), corpus.getucenb(), (float(sum([len(cl) for cl in corpus.lc])) / float(corpus.getucenb())) * 100, sep)
 567         elif self.parametres['classif_mode'] == 2 :
 568             txt += u'%i textes classés sur %i (%.2f%%)%s' % (sum([len(cl) for cl in corpus.lc]), corpus.getucinb(), (float(sum([len(cl) for cl in corpus.lc]))) / float(corpus.getucinb()) * 100, sep)
 569     else :
 570         txt += u'%i segments classées sur %i (%.2f%%)%s' % (self.ucecla, self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)
 571
 572     txt += """
 573 ###########################
 574 temps d'analyse : %s
 575 ###########################
 576 """ % parametres.get('time', '')
 577     with open(self.pathout['pre_rapport'], 'w') as f :
 578         f.write(txt)
 579
 580
 581 class SashList(wx.Panel) :
 582     def __init__(self, parent) :
 583         wx.Panel.__init__(self, parent, -1)
 584         self.parent=parent
 585         winids = []
 586         #self.gparent=gparent
 587         #self.dlist=dlist
 588         #self.first = first
 589         #self.menu = menu
 590         # A window to the left of the client window
 591         #self.listlex = listlex
 592         self.leftwin1 =  wx.SashLayoutWindow(
 593                 self, -1, wx.DefaultPosition, (200, 300),
 594                 wx.NO_BORDER|wx.SW_3D
 595                 )
 596
 597         self.leftwin1.SetDefaultSize((120, 1000))
 598         self.leftwin1.SetOrientation(wx.LAYOUT_VERTICAL)
 599         self.leftwin1.SetAlignment(wx.LAYOUT_LEFT)
 600         self.leftwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
 601         self.leftwin1.SetSashVisible(wx.SASH_RIGHT, True)
 602         self.leftwin1.SetExtraBorderSize(10)
 603
 604         #textWindow = wx.TextCtrl(
 605         #                leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
 606         #                wx.TE_MULTILINE|wx.SUNKEN_BORDER
 607         #                )
 608
 609         #textWindow.SetValue("A sub window")
 610
 611         self.leftWindow1 = self.leftwin1
 612         winids.append(self.leftwin1.GetId())
 613
 614         rightwin1 =  wx.SashLayoutWindow(
 615                 self, -1, wx.DefaultPosition, (200, 300),
 616                 wx.NO_BORDER|wx.SW_3D
 617                 )
 618
 619         rightwin1.SetDefaultSize((120, 1000))
 620         rightwin1.SetOrientation(wx.LAYOUT_VERTICAL)
 621         rightwin1.SetAlignment(wx.LAYOUT_LEFT)
 622         rightwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
 623         rightwin1.SetSashVisible(wx.SASH_RIGHT, True)
 624         rightwin1.SetExtraBorderSize(10)
 625         #textWindow = wx.TextCtrl(
 626         #                leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
 627         #                wx.TE_MULTILINE|wx.SUNKEN_BORDER
 628         #                )
 629
 630         #textWindow.SetValue("A sub window")
 631
 632         self.rightwin1 = rightwin1
 633         winids.append(rightwin1.GetId())
 634
 635 class TgenLayout :
 636     def __init__(self, page):
 637         self.page = page
 638         parametres = self.page.parametres
 639         ira = wx.GetApp().GetTopWindow()
 640         self.page.tgens, etoiles =  ReadList(parametres['tgenspec'], ira.syscoding, sep="\t")
 641         tgentab = False
 642         for i in range(page.GetPageCount()) :
 643             tab = page.GetPage(i)
 644             if 'tgen' in dir(tab) :
 645                 if tab.tgen :
 646                     tgentab = tab
 647                     break
 648         if tgentab :
 649             self.page.tgentab.RefreshData(self.page.tgens)
 650             self.page.SetSelection(i)
 651         else :
 652             self.page.tgentab = ListForSpec(ira, None, self.page.tgens, etoiles[1:])
 653             self.page.tgentab.tgen = True
 654             self.page.AddPage(self.page.tgentab, u'Tgens Specificities')
 655             self.page.SetSelection(self.page.GetPageCount() - 1)
 656
 657 class dolexlayout :
 658     def __init__(self, ira, corpus, parametres):
 659         self.pathout = PathOut(dirout = parametres['pathout'])
 660         self.corpus = corpus
 661         self.dictpathout = StatTxtPathOut(parametres['pathout'])
 662         #self.corpus.read_corpus_from_shelves(self.corpus.dictpathout['db'])
 663         self.parent = ira
 664         self.encoding = self.corpus.parametres['syscoding']
 665         self.parametres = parametres
 666
 667         self.DictSpec, first = ReadList(self.dictpathout['tablespecf'], self.corpus.parametres['syscoding'])
 668         if os.path.exists(self.pathout['banalites.csv']) :
 669             self.dictban, firstban = ReadList(self.pathout['banalites.csv'], self.corpus.parametres['syscoding'])
 670         self.DictType, firstt = ReadList(self.dictpathout['tablespect'], self.corpus.parametres['syscoding'])
 671         self.DictEff, firsteff = ReadList(self.dictpathout['tableafcm'], self.corpus.parametres['syscoding'])
 672         self.DictEffType, firstefft = ReadList(self.dictpathout['tabletypem'], self.corpus.parametres['syscoding'])
 673         self.DictEffRelForme, firsteffrelf = ReadList(self.dictpathout['eff_relatif_forme'], self.corpus.parametres['syscoding'])
 674         self.DictEffRelType, firsteffrelt = ReadList(self.dictpathout['eff_relatif_type'], self.corpus.parametres['syscoding'])
 675         self.etoiles = firsteff[1:]
 676         #sash = SashList(ira.nb)
 677
 678
 679         self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
 680         self.TabStat.parametres = parametres
 681         self.ListPan = ListForSpec(ira, self, self.DictSpec, self.etoiles)
 682         if os.path.exists(self.pathout['banalites.csv']) :
 683             self.listban = ListForSpec(ira, self, self.dictban, ['eff'] + self.etoiles)
 684         #self.ListPan2 = ListForSpec(sash.rightwin1, self, self.DictSpec, first)
 685         self.ListPant = ListForSpec(ira, self, self.DictType, self.etoiles)
 686         self.ListPanEff = ListForSpec(ira, self, self.DictEff, self.etoiles)
 687         self.ListPanEffType = ListForSpec(ira, self, self.DictEffType, self.etoiles)
 688         self.ListPanEffRelForme = ListForSpec(ira, self, self.DictEffRelForme, self.etoiles)
 689         self.ListPanEffRelType = ListForSpec(ira, self.parent, self.DictEffRelType, self.etoiles)
 690
 691         self.TabStat.AddPage(self.ListPan, u'formes')
 692         if os.path.exists(self.pathout['banalites.csv']) :
 693             self.TabStat.AddPage(self.listban, u'banalités')
 694         self.TabStat.AddPage(self.ListPant, u'Types')
 695         self.TabStat.AddPage(self.ListPanEff, u'Effectifs formes')
 696         self.TabStat.AddPage(self.ListPanEffType, u'Effectifs Type')
 697         self.TabStat.AddPage(self.ListPanEffRelForme, u'Effectifs relatifs formes')
 698         self.TabStat.AddPage(self.ListPanEffRelType, u'Effectifs relatifs Type')
 699         if self.parametres['clnb'] > 2 :
 700             self.TabAFC = aui.AuiNotebook(self.TabStat, -1, wx.DefaultPosition)
 701             list_graph=read_list_file(self.dictpathout['liste_graph_afcf'], encoding = self.encoding)
 702             self.tabAFCGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afcf', coding = self.encoding)
 703             self.TabAFC.AddPage(self.tabAFCGraph, 'AFC formes')
 704             list_graph=read_list_file(self.dictpathout['liste_graph_afct'], encoding = self.encoding)
 705             self.tabAFCTGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afct', coding=self.encoding)
 706             self.TabAFC.AddPage(self.tabAFCTGraph, 'AFC type')
 707             self.TabStat.AddPage(self.TabAFC, 'AFC')
 708
 709
 710
 711
 712
 713         ira.nb.AddPage(self.TabStat, u'Spécificités')
 714         self.ira = ira
 715
 716         self.TabStat.corpus = self.corpus
 717         self.TabStat.etoiles = self.etoiles
 718         if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenspec.csv')) :
 719             self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenspec.csv')
 720             TgenLayout(self.TabStat)
 721         self.TabStat.SetSelection(0)
 722         ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
 723         ira.ShowAPane("Tab_content")
 724
 725 class StatLayout:
 726     def __init__(self, ira, corpus, parametres):
 727         self.pathout = PathOut(dirout = parametres['pathout'])
 728         self.corpus = corpus
 729         self.ira = ira
 730         self.read_result()
 731         self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
 732         self.TabStat.parametres = parametres
 733         self.TabStat.corpus = corpus
 734         self.TabStat.pathout = self.pathout
 735 #        CHD = GraphPanel(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
 736         #      panel.TabChdSim.AddPage(CHD,'CHD')
 737
 738         #self.TabStatTot = wx.TextCtrl(self.TabStat, -1, style=wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2)
 739         list_graph = [['zipf.png', 'zipf']]
 740         self.TabStatTot = GraphPanel(ira.nb, self.pathout, list_graph, self.result['glob'])
 741         self.TabStat.AddPage(self.TabStatTot, 'global')
 742         for item in self.result:
 743             if item != 'glob':
 744                 datam = [['forme', 'nb']]
 745                 self.ListPan = ListPanel(ira, self, self.result[item])
 746                 self.TabStat.AddPage(self.ListPan, ' '.join(item.split('_')))
 747         ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
 748         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
 749         ira.ShowAPane("Tab_content")
 750
 751     def read_result(self) :
 752         lcle = {'total' :u'total.csv', u'formes_actives':u'formes_actives.csv', u'formes_supplémentaires':u'formes_supplémentaires.csv', u'hapax': u'hapax.csv'}
 753         self.result = {}
 754         for key in lcle :
 755             with open(self.pathout[lcle[key]], 'r') as f :
 756                 self.result[key] = [line.split(';') for line in f.read().splitlines()]
 757                 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
 758         with open(self.pathout['glob.txt'], 'r') as f :
 759             self.result['glob'] = f.read()
 760
 761 class GraphPanelDendro(wx.Panel):
 762     def __init__(self,parent, dico, list_graph, txt=False):
 763         wx.Panel.__init__(self,parent)
 764         self.graphnb = 1
 765         self.dictpathout = dico
 766         self.dirout = os.path.dirname(self.dictpathout['ira'])
 767         self.list_graph = list_graph
 768         self.parent = self.GetParent()#parent
 769         self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
 770         self.labels = []
 771         self.listimg = []
 772         self.tabchd = self.parent.GetParent()
 773         self.ira = self.tabchd.GetParent()
 774         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
 775         self.panel_1.SetBackgroundColour('white')
 776         self.deb = wx.StaticText(self.panel_1, -1, txt)
 777         dendro_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
 778         self.butdendro = wx.BitmapButton(self, -1, dendro_img)
 779         self.butdendrotexte = wx.BitmapButton(self, -1, dendro_img)
 780         self.butdendrocloud = wx.BitmapButton(self, -1, dendro_img)
 781
 782         for i in range(0,len(list_graph)):
 783             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
 784                 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
 785                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
 786
 787         self.__set_properties()
 788         self.__do_layout()
 789
 790     def __set_properties(self):
 791         self.panel_1.EnableScrolling(True,True)
 792         #self.panel_1.SetSize((1000,1000))
 793         self.panel_1.SetScrollRate(20, 20)
 794         self.panel_1.SetFocus()
 795         self.Bind(wx.EVT_BUTTON, self.ondendro, self.butdendro)
 796         self.Bind(wx.EVT_BUTTON, self.ondendrotexte, self.butdendrotexte)
 797         self.Bind(wx.EVT_BUTTON, self.ondendrocloud, self.butdendrocloud)
 798         self.param = {'width' : 700,
 799                        'height': 500,
 800                        'type_dendro': 0,
 801                        'color_nb': 0,
 802                        'taille_classe' : True,
 803                        'type_tclasse' : 0
 804                      }
 805         self.type_dendro = [ u"phylogram", u"cladogram", u"fan", u"unrooted", u"radial" ]
 806
 807     def __do_layout(self):
 808         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
 809         self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
 810         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
 811         self.sizer_3.Add(self.deb)
 812         self.sizer_1.Add(self.butdendro, 0, 0, 0)
 813         self.sizer_1.Add(self.butdendrotexte, 0, 0, 0)
 814         self.sizer_1.Add(self.butdendrocloud, 0, 0, 0)
 815
 816         for i in range(0, len(self.listimg)):
 817             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 818             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 819         self.panel_1.SetSizer(self.sizer_3)
 820         self.sizer_2.Add(self.sizer_1, 0, wx.EXPAND, 0)
 821         self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
 822         self.SetSizer(self.sizer_2)
 823
 824     def make_param(self, dial):
 825         self.param['width'] = dial.m_spinCtrl2.GetValue()
 826         self.param['height'] = dial.m_spinCtrl1.GetValue()
 827         self.param['type_dendro'] = dial.m_choice1.GetSelection()
 828         self.param['color_nb'] = dial.m_radioBox1.GetSelection()
 829         self.param['taille_classe'] = dial.m_checkBox1.GetValue()
 830         self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
 831
 832     def make_dendro(self, dendro = 'simple') :
 833         while os.path.exists(os.path.join(self.dirout, 'dendrogramme_' + str(self.graphnb)+'.png')) :
 834             self.graphnb += 1
 835         fileout = ffr(os.path.join(self.dirout,'dendrogramme_' + str(self.graphnb)+'.png'))
 836         width = self.param['width']
 837         height = self.param['height']
 838         type_dendro = self.type_dendro[self.param['type_dendro']]
 839         if self.param['taille_classe'] :
 840             tclasse = 'TRUE'
 841         else :
 842             tclasse = 'FALSE'
 843         if self.param['color_nb'] == 0 :
 844             bw = 'FALSE'
 845         else :
 846             bw = 'TRUE'
 847         if self.param['type_tclasse'] == 0 :
 848             histo='FALSE'
 849         else :
 850             histo = 'TRUE'
 851         dendro_path = self.dictpathout['Rdendro']
 852         classe_path = self.dictpathout['uce']
 853         txt = """
 854         library(ape)
 855         load("%s")
 856         source("%s")
 857         classes <- read.csv2("%s", row.names=1)
 858         classes <- classes[,1]
 859         """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']),  ffr(classe_path))
 860         if dendro == 'simple' :
 861             txt += """
 862             open_file_graph("%s", width=%i, height=%i)
 863             plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
 864             """ % (ffr(fileout), width, height, type_dendro, histo, bw, tclasse)
 865         elif dendro == 'texte' :
 866             txt += """
 867             load("%s")
 868             source("%s")
 869             chistable <- chistabletot[1:(debsup-1),]
 870             open_file_graph("%s", width=%i, height=%i)
 871             plot.dendro.prof(tree.cut1$tree.cl, classes, chistable, nbbycl = 60, type.dendro="%s", bw=%s, lab=NULL)
 872             """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, type_dendro, bw)
 873         elif dendro == 'cloud' :
 874             txt += """
 875             load("%s")
 876             source("%s")
 877             chistable <- chistabletot[1:(debsup-1),]
 878             open_file_graph("%s", width=%i, height=%i)
 879             plot.dendro.cloud(tree.cut1$tree.cl, classes, chistable, nbbycl = 300, type.dendro="%s", bw=%s, lab=NULL)
 880             """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, type_dendro, bw)
 881
 882
 883         tmpfile = tempfile.mktemp()
 884         with open(tmpfile, 'w') as f :
 885             f.write(txt)
 886         error = exec_rcode(self.ira.RPath, tmpfile, wait=True)
 887         check_Rresult(self.ira, error)
 888         self.list_graph.append([fileout, 'Dendrogramme CHD1 - %s' %  type_dendro])
 889         print_liste(self.dictpathout['liste_graph_chd'], self.list_graph)
 890         self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 891         self.sizer_3.Add(wx.StaticText(self.panel_1,-1, 'Dendrogramme CHD1 - %s' %  type_dendro), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 892         self.sizer_3.Fit(self.panel_1)
 893         self.Layout()
 894         self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
 895
 896
 897     def ondendro(self, evt):
 898         dial = PrefDendro(self.ira, self.param)
 899         val = dial.ShowModal()
 900         if val == wx.ID_OK :
 901             self.make_param(dial)
 902             self.make_dendro()
 903
 904     def ondendrotexte(self, evt):
 905         dial = PrefDendro(self.ira, self.param)
 906         val = dial.ShowModal()
 907         if val == wx.ID_OK :
 908             self.make_param(dial)
 909             self.make_dendro(dendro = 'texte')
 910
 911     def ondendrocloud(self, evt):
 912         dial = PrefDendro(self.ira, self.param)
 913         val = dial.ShowModal()
 914         if val == wx.ID_OK :
 915             self.make_param(dial)
 916             self.make_dendro(dendro = 'cloud')
 917
 918 class OpenCorpus :
 919     def __init__(self, ira, parametres) :
 920         #self.text = wx.TextCtrl(ira, -1, "", wx.Point(0, 0), wx.Size(200, 200), wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2 | wx.TE_READONLY)
 921         self.panel = CopusPanel(ira, parametres)
 922         ira.nb.AddPage(self.panel, 'Description %s' % parametres['corpus_name'])
 923         #self.text.write(DoConf().totext(parametres))
 924         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
 925         ira.ShowAPane("Tab_content")
 926
 927 class MatLayout :
 928     def __init__(self, ira, matrix):
 929         #self.parent.content = self.csvtable
 930         self.sheet = MySheet(ira.nb)
 931         ira.nb.AddPage(self.sheet, matrix.parametres['matrix_name'])
 932         self.sheet.Populate(matrix.csvtable)
 933         self.sheet.parametres = matrix.parametres
 934         #self.ira.ShowMenu(_(u"View").decode('utf8'))
 935         #self.ira.ShowMenu(_(u"Matrix analysis").decode('utf8'))
 936         #self.ira.ShowMenu(_(u"Text analysis").decode('utf8'), False)
 937         #self.parent.type = "Data"
 938         #self.parent.DataPop = False
 939         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
 940         ira.ShowAPane("Tab_content")
 941         #self.ira.OnViewData('')
 942
 943
 944
 945
 946 class CopusPanel(wx.Panel) :
 947     def __init__(self, parent, parametres) :
 948         wx.Panel.__init__ ( self, parent, id = wx.ID_ANY, pos = wx.DefaultPosition, size = wx.Size( 500,300 ), style = wx.TAB_TRAVERSAL )
 949         self.parametres = parametres
 950         fgSizer5 = wx.FlexGridSizer( 0, 2, 0, 0 )
 951         fgSizer5.SetFlexibleDirection( wx.BOTH )
 952         fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )
 953         self.fgSizer5 = fgSizer5
 954
 955         self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Description du corpus", wx.DefaultPosition, wx.DefaultSize, 0 )
 956
 957         self.m_staticText18.Wrap( -1 )
 958         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
 959
 960         self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
 961         self.m_staticText19.Wrap( -1 )
 962         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
 963
 964         self.m_staticText20 = wx.StaticText( self, wx.ID_ANY, u"Nom", wx.DefaultPosition, wx.DefaultSize, 0 )
 965         self.m_staticText20.Wrap( -1 )
 966         fgSizer5.Add( self.m_staticText20, 0, wx.ALL, 5 )
 967
 968         self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, parametres['corpus_name'], wx.DefaultPosition, wx.DefaultSize, 0 )
 969         self.m_staticText21.Wrap( -1 )
 970         fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )
 971
 972         description = {'lang' : u'langue',
 973                        'encoding' : u'encodage',
 974                        'ucinb' : u'Nombre de textes',
 975                        'ucenb' : u'Nombre de segments de texte',
 976                        'formesnb' : u'Nombre de formes',
 977                        'hapax' : u'Nombre d\'hapax'
 978                       }
 979
 980         keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']
 981
 982         self.addkeys(keys, description)
 983
 984         self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Paramètres", wx.DefaultPosition, wx.DefaultSize, 0 )
 985         self.m_staticText18.Wrap( -1 )
 986         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
 987
 988         self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
 989         self.m_staticText19.Wrap( -1 )
 990         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
 991
 992         keys = ['ucemethod', 'ucesize', 'keep_caract', 'expressions']
 993         self.addkeys(keys, description)
 994
 995         self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Statistiques", wx.DefaultPosition, wx.DefaultSize, 0 )
 996         self.m_staticText18.Wrap( -1 )
 997         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
 998
 999         self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1000         self.m_staticText19.Wrap( -1 )
1001         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1002
1003         keys = ['ucinb', 'ucenb', 'occurrences', 'formesnb', 'hapax']
1004         self.addkeys(keys, description)
1005
1006         self.SetSizer( fgSizer5 )
1007         self.Layout()
1008
1009     def addkeys(self, keys, description) :
1010         for key in keys :
1011             option = self.parametres.get(key,u'non défini')
1012             if isinstance(option, int) :
1013                 option = `option`
1014             text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
1015             text.Wrap( -1 )
1016             self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1017
1018             text = wx.StaticText( self, wx.ID_ANY, option, wx.DefaultPosition, wx.DefaultSize, 0 )
1019             text.Wrap( -1 )
1020             self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1021
1022 class DefaultTextLayout :
1023     def __init__(self, ira, corpus, parametres) :
1024         self.pathout = PathOut(dirout = parametres['pathout'])
1025         self.ira = ira
1026         self.parent = ira
1027         self.parametres = parametres
1028         self.corpus = corpus
1029         self.dolayout()
1030
1031     def dolayout(self) :
1032         log.info('no layout yet')
1033
1034 class WordCloudLayout(DefaultTextLayout):
1035     def dolayout(self):
1036         self.pathout.basefiles(simipath)
1037         self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1038         if self.parametres['svg'] :
1039             list_graph = [['nuage_1.svg', 'Nuage']]
1040         else :
1041             list_graph = [['nuage_1.png', 'Nuage']]
1042         self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, list_graph)
1043         self.Tab.AddPage(self.TabStatTot, 'Nuage')
1044         self.Tab.corpus = self.corpus
1045         self.Tab.parametres = self.parametres
1046         self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
1047         self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1048         self.ira.ShowAPane("Tab_content")
1049
1050 class SimiLayout(DefaultTextLayout) :
1051     def dolayout(self) :
1052         self.pathout.basefiles(simipath)
1053         self.actives = None
1054         self.indices = indices_simi
1055         if os.path.exists(self.pathout['liste_graph']) :
1056             list_graph = read_list_file(self.pathout['liste_graph'])
1057         else :
1058             list_graph = [['','']]
1059         notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1060         self.tabsimi = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1061         self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1062         self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1063         self.tabsimi.corpus = self.corpus
1064         self.tabsimi.parametres = self.parametres
1065         self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1066         self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1067         self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1068         self.tabsimi.AddPage(self.graphpan, 'Graph')
1069         self.ira.nb.AddPage(self.tabsimi, 'Analyse de graph')
1070         self.ira.ShowTab(True)
1071         self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1072
1073     def redosimi(self, evt) :
1074         with open(self.pathout['selected.csv'],'r') as f :
1075             selected = f.read()
1076         selected = [int(val) for val in selected.splitlines()]
1077         if self.actives is None :
1078             with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1079                 self.actives = f.read()
1080             self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1081         if os.path.exists(self.pathout['actives_nb.csv']) :
1082             with open(self.pathout['actives_nb.csv'], 'r') as f :
1083                 act_nb = f.read()
1084                 act_nb = act_nb.splitlines()
1085             dictcol = dict([[i, [self.actives[i], int(act_nb[i])]] for i, val in enumerate(self.actives)])
1086         else :
1087             dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1088         #res = SelectColumn(self.ira, dictcol, self.actives, self.pathout['selected.csv'], selected = selected, dlg = True)
1089         #if res.ok :
1090         prep = PrepSimi(self.ira, self, self.parametres,self.pathout['selected.csv'], self.actives, indices_simi, wordlist = dictcol, selected = selected)
1091         if prep.val == wx.ID_OK :
1092             self.parametres = prep.parametres
1093
1094             script = PrintSimiScript(self)
1095             script.make_script()
1096             pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
1097             check_Rresult(self.ira, pid)
1098             if self.parametres['type_graph'] in [1,3] :
1099                 if self.parametres['svg'] :
1100                     filename, ext = os.path.splitext(script.filename)
1101                     fileout = filename + '.svg'
1102                 elif self.parametres['type_graph'] == 3 :
1103                     fileout = script.filename
1104                     parametres = {'gexffile' :  fileout,
1105                                   'dirout' : os.path.dirname(fileout),
1106                                   'titre': 'Le titre',
1107                                   #'nodemin': self.param['txt_min'],
1108                                   #'nodemax': self.param['txt_max'],
1109                                   #'bargraphw' : 60*int(self.param['clnb']),
1110                     }
1111                     web = WebExport(self.ira, parametres)
1112                     fileout = web.exportsimi()
1113                 else :
1114                     fileout = script.filename
1115                 if os.path.exists(self.pathout['liste_graph']):
1116                     graph_simi = read_list_file(self.pathout['liste_graph'])
1117                     graph_simi.append([os.path.basename(fileout), script.txtgraph])
1118                 else :
1119                     graph_simi = [[os.path.basename(fileout), script.txtgraph]]
1120                 print_liste(self.pathout['liste_graph'], graph_simi)
1121             DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1122             if self.parametres['type_graph'] in [1,3] :
1123                 if self.parametres['svg'] or self.parametres['type_graph'] == 3 :
1124                     self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1125                 else :
1126                     self.graphpan.sizer_3.Add(wx.StaticBitmap(self.graphpan.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1127                 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1128                 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1129                 self.graphpan.Layout()
1130                 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1131
1132     def export(self, evt) :
1133         nb = 1
1134         while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1135             nb +=1
1136         fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1137         txt = """
1138         library(igraph)
1139         load("%s")
1140         source("%s")
1141         fileout <- "%s"
1142         graph <- graph.simi$graph
1143         V(graph)$x <- graph.simi$layout[,1]
1144         V(graph)$y <- graph.simi$layout[,2]
1145         if (length(graph.simi$label.cex == 1)) {
1146             V(graph)$weight <- graph.simi$eff
1147         } else {
1148             V(graph)$weight <- graph.simi$label.cex
1149         }
1150         V(graph)$color <- vertex.label.color
1151         V(graph)$frequences <- graph.simi$mat.eff
1152         V(graph)$label <- as.character(graph.simi$v.label)
1153         E(graph)$weight <- graph.simi$we.width
1154         write.graph(graph, fileout, format = 'graphml')
1155         #saveAsGEXF(graph, filepath = fileout)
1156         """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1157         filetmp = tempfile.mktemp()
1158         with open(filetmp, 'w') as f :
1159             f.write(txt)
1160         exec_rcode(self.ira.RPath, filetmp)
1161         mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
1162         mss.CenterOnParent()
1163         mss.ShowModal()
1164         mss.Destroy()
1165
1166 class DefaultMatLayout :
1167     def __init__(self, parent, tableau, parametres) :
1168         self.pathout = PathOut(dirout = parametres['pathout'])
1169         self.ira = parent
1170         self.parent = parent
1171         self.tableau = tableau
1172         self.parametres = parametres
1173         if os.path.exists(self.pathout['analyse.db']) :
1174             self.tableau.read_tableau(self.pathout['analyse.db'])
1175         self.dolayout()
1176         self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1177         self.ira.ShowAPane("Tab_content")
1178
1179     def dolayout(self) :
1180         pass
1181
1182 class FreqLayout(DefaultMatLayout) :
1183     def dolayout(self) :
1184         self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1185         if "gtk2" in wx.PlatformInfo:
1186             self.tab.SetStandardFonts()
1187         self.tab.LoadPage(self.pathout['resultats.html'])
1188         self.tab.parametres = self.parametres
1189         self.ira.nb.AddPage(self.tab, u"Fréquences")
1190
1191
1192 class Chi2Layout(DefaultMatLayout) :
1193     def dolayout(self):
1194         self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1195         if "gtk2" in wx.PlatformInfo:
1196             self.tab.SetStandardFonts()
1197         self.tab.LoadPage(self.pathout['resultats-chi2.html'])
1198         self.tab.parametres = self.parametres
1199         self.ira.nb.AddPage(self.tab, ' - '.join([u"Chi2", "%s" % self.parametres['name']]))
1200         #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1201         #self.ira.ShowAPane("Tab_content")
1202
1203
1204 class ProtoLayout(DefaultMatLayout) :
1205     def dolayout(self) :
1206         list_graph = [['proto.png', 'Analyse prototypique']]
1207         #self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1208         #if self.parametres['svg'] :
1209         #    list_graph = [['nuage_1.svg', 'Nuage']]
1210         #else :
1211         #    list_graph = [['nuage_1.png', 'Nuage']]
1212         self.TabProto = GraphPanel(self.ira.nb, self.pathout, list_graph)
1213         #self.Tab.AddPage(self.TabProto, 'Analyse Prototypique')
1214         #self.Tab.corpus = self.corpus
1215         self.TabProto.parametres = self.parametres
1216         self.ira.nb.AddPage(self.TabProto, 'Analyse Prototypique - %s' % self.parametres['name'])
1217         #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1218         #self.ira.ShowAPane("Tab_content")
1219
1220
1221 class SimiMatLayout(DefaultMatLayout) :
1222     def dolayout(self):
1223         self.pathout.basefiles(simipath)
1224         self.indices = indices_simi
1225         if os.path.exists(self.pathout['liste_graph']) :
1226             list_graph = read_list_file(self.pathout['liste_graph'])
1227         else :
1228             list_graph = [['','']]
1229         notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1230         self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1231         self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1232         self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1233         self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1234         self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1235         self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1236         self.tabsimi.AddPage(self.graphpan, 'Graph')
1237         self.tabsimi.parametres = self.parametres
1238         self.parent.nb.AddPage(self.tabsimi, 'Analyse de graph')
1239         #self.parent.ShowTab(True)
1240         #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1241
1242     def redosimi(self,evt) :
1243         with open(self.pathout['selected.csv'],'r') as f :
1244             selected = f.read()
1245         selected = [int(val) for val in selected.splitlines()]
1246         #if self.actives is None :
1247         #    with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1248         #        self.actives = f.read()
1249         #    self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1250         try :
1251             actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1252         except :
1253             actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1254
1255         #self.tableau.make_listactives()
1256         actives = dict([[i, val] for i, val in enumerate(actives)])
1257         #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1258         self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1259         self.dial.CenterOnParent()
1260         self.val = self.dial.ShowModal()
1261         if self.val == wx.ID_OK :
1262             last = self.dial.listcol.GetFirstSelected()
1263             lastl = [self.dial.listcol.GetFirstSelected()]
1264             indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1265             while self.dial.listcol.GetNextSelected(last) != -1:
1266                 last = self.dial.listcol.GetNextSelected(last)
1267                 lastl.append(last)
1268                 indexes.append(self.dial.listcol.getColumnText(last,0))
1269             self.column = [self.tableau.listactives.index(val) for val in indexes]
1270             self.column.sort()
1271             with open(self.pathout['selected.csv'], 'w') as f :
1272                 f.write('\n'.join([`val` for val in self.column]))
1273             self.make_param()
1274             self.dial.Destroy()
1275             self.script = PrintSimiScript(self)
1276             self.script.make_script()
1277             self.tmpfile = self.script.scriptout
1278             dlg = progressbar(self, maxi = 2)
1279             self.DoR(dlg)
1280             dlg.Destroy()
1281             if self.parametres['type_graph'] == 1:
1282                 if self.parametres['svg'] :
1283                     filename, ext = os.path.splitext(self.script.filename)
1284                     fileout = filename + '.svg'
1285                 else :
1286                     fileout = self.script.filename
1287                 if os.path.exists(self.pathout['liste_graph']):
1288                     graph_simi = read_list_file(self.pathout['liste_graph'])
1289                     graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1290                 else :
1291                     graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1292                 print_liste(self.pathout['liste_graph'], graph_simi)
1293             DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1294             if self.parametres['type_graph'] == 1:
1295                 if self.parametres['svg'] :
1296                     self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1297                 else :
1298                     self.graphpan.sizer_3.Add(wx.StaticBitmap(self.graphpan.panel_1, -1, wx.Bitmap(self.script.filename, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1299                 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1300                 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1301                 self.graphpan.Layout()
1302                 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1303         else :
1304             self.dial.Destroy()
1305
1306
1307     def make_param(self) :
1308         if self.parametres['first'] :
1309             keep_coord = False
1310         else :
1311             keep_coord = self.dial.check_coord.GetValue()
1312         #self.select = self.dial.check_colch.GetValue()
1313
1314         paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1315                           'layout' : self.dial.choice2.GetSelection(),
1316                           'type_graph' : self.dial.choice3.GetSelection(),
1317                           'arbremax' : self.dial.check1.GetValue(),
1318                           'coeff_tv' : self.dial.check_s_size.GetValue(),
1319                           'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1320                           'tvprop' : self.dial.check2.GetValue(),
1321                           'tvmin' : self.dial.spin_tvmin.GetValue(),
1322                           'tvmax' : self.dial.spin_tvmax.GetValue(),
1323                           'coeff_te' : self.dial.check3.GetValue(),
1324                           'coeff_temin' : self.dial.spin_temin.GetValue(),
1325                           'coeff_temax' : self.dial.spin_temax.GetValue(),
1326                           'label_e' : self.dial.check_elab.GetValue(),
1327                           'label_v' : self.dial.check_vlab.GetValue(),
1328                           'vcex' : self.dial.check_vcex.GetValue(),
1329                           'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1330                           'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1331                           'cex' : self.dial.spin_cex.GetValue(),
1332                           'seuil_ok' : self.dial.check_seuil.GetValue(),
1333                           'seuil' : self.dial.spin_seuil.GetValue(),
1334                           'cols' : self.dial.cols.GetColour(),
1335                           'cola' : self.dial.cola.GetColour(),
1336                           'width' : self.dial.spin_width.GetValue(),
1337                           'height' : self.dial.spin_height.GetValue(),
1338                           'first' : False,
1339                           'keep_coord' : keep_coord,
1340                           'alpha' : self.dial.slider_sphere.GetValue(),
1341                           'film' : self.dial.film.GetValue(),
1342                           'svg' : self.dial.choix_format.GetSelection(),
1343                           'halo' : self.dial.halo.GetValue(),
1344                           'com' : self.dial.comcheck.GetValue(),
1345                           'communities' : self.dial.choix_com.GetSelection(),
1346                           }
1347         if 'cexfromchi' in self.parametres :
1348             paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1349         if 'sfromchi' in self.parametres :
1350             paramsimi['sfromchi'] = self.dial.checki.GetValue()
1351         if 'vlabcolor' in self.parametres :
1352             paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1353         if 'check_bystar' in dir(self.dial) :
1354             paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1355             paramsimi['stars'] = self.parametres['stars']
1356         self.parametres.update(paramsimi)
1357
1358     def DoR(self, dlg):
1359         if self.parametres['type_graph'] == 1 :
1360             graph = False
1361             wait = False
1362         else :
1363             graph = True
1364             wait = True
1365         pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1366         if self.parametres['type_graph'] == 1 :
1367             while pid.poll() == None :
1368                 dlg.Pulse(u'R ...')
1369                 sleep(0.2)
1370             check_Rresult(self.parent, pid)
1371
1372     def export(self, evt) :
1373         nb = 1
1374         while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1375             nb +=1
1376         fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1377         txt = """
1378         library(igraph)
1379         load("%s")
1380         source("%s")
1381         fileout <- "%s"
1382         graph <- graph.simi$graph
1383         V(graph)$x <- graph.simi$layout[,1]
1384         V(graph)$y <- graph.simi$layout[,2]
1385         if (length(graph.simi$label.cex == 1)) {
1386             V(graph)$weight <- graph.simi$mat.eff
1387         } else {
1388             V(graph)$weight <- graph.simi$label.cex
1389         }
1390         V(graph)$color <- vertex.label.color
1391         V(graph)$frequences <- graph.simi$mat.eff
1392         V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
1393         V(graph)$label <- as.character(graph.simi$v.label)
1394         E(graph)$weight <- graph.simi$we.width
1395         write.graph(graph, fileout, format = 'graphml')
1396         #saveAsGEXF(graph, filepath = fileout)
1397         """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1398         filetmp = tempfile.mktemp()
1399         with open(filetmp, 'w') as f :
1400             f.write(txt)
1401         exec_rcode(self.ira.RPath, filetmp)
1402         mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
1403         mss.CenterOnParent()
1404         mss.ShowModal()
1405         mss.Destroy()
1406
1407
1408 class GraphPanelSimi(wx.Panel):
1409     def __init__(self,parent, dico, list_graph):
1410         wx.Panel.__init__(self,parent)
1411         self.afcnb = 1
1412         self.Dict = dico
1413         self.dirout = os.path.dirname(self.Dict['ira'])
1414         self.parent = self.GetParent()#parent
1415         self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "courier"))
1416         self.labels = []
1417         self.listimg = []
1418         self.tabsimi = self.parent.GetParent()
1419         self.ira = self.tabsimi.GetParent()
1420         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1421         afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1422         self.butafc = wx.BitmapButton(self, -1, afc_img)
1423         export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1424         self.butexport = wx.BitmapButton(self, -1, export_img)
1425         for i in range(0,len(list_graph)):
1426             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1427                 filename, ext = os.path.splitext(list_graph[i][0])
1428                 if ext in ['.svg', '.html'] :
1429                     self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, os.path.join(self.dirout,list_graph[i][0]), URL=os.path.join(self.dirout,list_graph[i][0])))
1430                 else :
1431                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1432                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1433         self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove)
1434         self.__set_properties()
1435         self.__do_layout()
1436
1437     def __set_properties(self):
1438         self.panel_1.EnableScrolling(True,True)
1439         #self.panel_1.SetSize((1000,1000))
1440         self.panel_1.SetScrollRate(20, 20)
1441         self.panel_1.SetFocus()
1442
1443     def __do_layout(self):
1444         self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1445         self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1446         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1447         self.sizer_2.Add(self.butafc, 0, 0, 0)
1448         self.sizer_2.Add(self.butexport, 0, 0, 0)
1449         for i in range(0, len(self.listimg)):
1450             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1451             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1452         self.panel_1.SetSizer(self.sizer_3)
1453         self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1454         self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1455         self.SetSizer(self.sizer_1)
1456
1457     def onMouseMove(self, event):
1458         self.panel_1.SetFocus()