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