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         if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenchi2.csv')) :
 523             self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenchi2.csv')
 524             TgenLayout(panel)
 525         panel.TabChdSim.SetSelection(0)
 526         self.parent.nb.AddPage(panel, _(u"Clustering").decode('utf8') + ' - %s' % corpname)
 527         self.parent.ShowTab(True)
 528         self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
 529         #for pane in self.parent._mgr.GetAllPanes() :
 530         #     if isinstance(pane.window, aui.AuiNotebook):
 531         #         nb = pane.window
 532         #         nb.SetAGWWindowStyleFlag(notebook_flags)
 533         #         nb.SetArtProvider(aui.ChromeTabArt())
 534         dlg.Destroy()
 535         self.parent._mgr.Update()
 536
 537     def onsimi(self,event):
 538         outfile = print_simi3d(self)
 539         error = exec_rcode(self.parent.RPath, outfile, wait = True)
 540
 541     def onclusterstat(self, evt) :
 542         dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': 'Stat par classe'})
 543         dial.fbb.SetValue( os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'stat_par_classe.csv'))
 544         dial.CenterOnParent()
 545         res = dial.ShowModal()
 546         if res == wx.ID_OK :
 547             fileout = dial.fbb.GetValue()
 548             dial.Destroy()
 549             self.corpus.get_stat_by_cluster(fileout)
 550             msg = u"Fini !"
 551             dlg = wx.MessageDialog(self.parent, msg, _(u"Stat by cluster").decode('utf8'), wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
 552             dlg.CenterOnParent()
 553             if dlg.ShowModal() == wx.ID_OK :
 554                 dlg.Destroy()
 555
 556     #def onsearchf(self, evt) :
 557     #    if 'FrameSearch' not in dir(self.panel) :
 558     #        self.panel.FrameSearch = SearchFrame(self.parent, -1, u"Rechercher...", self.corpus)
 559     #    self.panel.FrameSearch.Show()
 560
 561 def PrintRapport(self, corpus, parametres, istxt = True):
 562     sep = '\n'
 563     txt = """
 564 +-+-+-+-+-+-+-+-+
 565 |i|R|a|M|u|T|e|Q| - %s
 566 +-+-+-+-+-+-+-+-+
 567
 568
 569 """ % datetime.datetime.now().ctime()
 570     if istxt :
 571         totocc = corpus.gettotocc()
 572         txt += u'nombre de textes: %i%s' % (corpus.getucinb(), sep)
 573         txt += u'nombre de segments de textes: %i%s' % (corpus.getucenb(), sep)
 574         txt += u'nombre de formes: %i%s' % (len(corpus.formes), sep)
 575         txt += u'nombre d\'occurrences: %i%s' % (totocc, sep)
 576         txt += u'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
 577         txt += u'nombre de lemmes: %i%s' % (len(corpus.lems), sep)
 578         txt += u'nombre de formes actives: %i%s' % (corpus.getactivesnb(1), sep)
 579         txt += u'nombre de formes supplémentaires: %i%s' % (corpus.getactivesnb(2), sep)
 580         txt += u'nombre de formes actives de fréquence >= %i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)
 581         txt += u'moyenne d\'occurrences par segments :%f%s' % (float(totocc) / float(corpus.getucenb()), sep)
 582         if 'tailleuc1' in parametres :
 583             if parametres['classif_mode'] == 0 :
 584                 txt += u'taille rst1 / rst2: %i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)
 585     else :
 586         self.Ucenb = self.nbind
 587         txt += u'nombre d\'individus : %i%s' % (self.nbind, sep)
 588         txt += u'nombre de classes : %i%s' % (self.clnb, sep)
 589     if istxt :
 590         txt += u'nombre de classes : %i%s' % (parametres['clnb'], sep)
 591         if parametres['classif_mode'] == 0 or parametres['classif_mode'] == 1 :
 592             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)
 593         elif self.parametres['classif_mode'] == 2 :
 594             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)
 595     else :
 596         txt += u'%i segments classées sur %i (%.2f%%)%s' % (self.ucecla, self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)
 597
 598     txt += """
 599 ###########################
 600 temps d'analyse : %s
 601 ###########################
 602 """ % parametres.get('time', '')
 603     with open(self.pathout['pre_rapport'], 'w') as f :
 604         f.write(txt)
 605
 606
 607 class SashList(wx.Panel) :
 608     def __init__(self, parent) :
 609         wx.Panel.__init__(self, parent, -1)
 610         self.parent=parent
 611         winids = []
 612         #self.gparent=gparent
 613         #self.dlist=dlist
 614         #self.first = first
 615         #self.menu = menu
 616         # A window to the left of the client window
 617         #self.listlex = listlex
 618         self.leftwin1 =  wx.SashLayoutWindow(
 619                 self, -1, wx.DefaultPosition, (200, 300),
 620                 wx.NO_BORDER|wx.SW_3D
 621                 )
 622
 623         self.leftwin1.SetDefaultSize((120, 1000))
 624         self.leftwin1.SetOrientation(wx.LAYOUT_VERTICAL)
 625         self.leftwin1.SetAlignment(wx.LAYOUT_LEFT)
 626         self.leftwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
 627         self.leftwin1.SetSashVisible(wx.SASH_RIGHT, True)
 628         self.leftwin1.SetExtraBorderSize(10)
 629
 630         #textWindow = wx.TextCtrl(
 631         #                leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
 632         #                wx.TE_MULTILINE|wx.SUNKEN_BORDER
 633         #                )
 634
 635         #textWindow.SetValue("A sub window")
 636
 637         self.leftWindow1 = self.leftwin1
 638         winids.append(self.leftwin1.GetId())
 639
 640         rightwin1 =  wx.SashLayoutWindow(
 641                 self, -1, wx.DefaultPosition, (200, 300),
 642                 wx.NO_BORDER|wx.SW_3D
 643                 )
 644
 645         rightwin1.SetDefaultSize((120, 1000))
 646         rightwin1.SetOrientation(wx.LAYOUT_VERTICAL)
 647         rightwin1.SetAlignment(wx.LAYOUT_LEFT)
 648         rightwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
 649         rightwin1.SetSashVisible(wx.SASH_RIGHT, True)
 650         rightwin1.SetExtraBorderSize(10)
 651         #textWindow = wx.TextCtrl(
 652         #                leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
 653         #                wx.TE_MULTILINE|wx.SUNKEN_BORDER
 654         #                )
 655
 656         #textWindow.SetValue("A sub window")
 657
 658         self.rightwin1 = rightwin1
 659         winids.append(rightwin1.GetId())
 660
 661 class TgenLayout :
 662     def __init__(self, page):
 663         self.page = page
 664         parametres = self.page.parametres
 665         ira = wx.GetApp().GetTopWindow()
 666         tgenpath = os.path.join(parametres['pathout'], 'tgen.csv')
 667         self.page.tgens, etoiles =  ReadList(parametres['tgenspec'], ira.syscoding, sep="\t")
 668         tgen = TGen(path = tgenpath, encoding = parametres['encoding'])
 669         tgen.read()
 670         tgentab = False
 671         gparent = None
 672         if 'TabChdSim' in dir(page) :
 673             page = page.TabChdSim
 674         for i in range(page.GetPageCount()) :
 675             tab = page.GetPage(i)
 676             if 'gparent' in dir(tab) :
 677                 if tab.gparent is not None :
 678                     gparent = tab.gparent
 679             if 'tgen' in dir(tab) :
 680                 if tab.tgen :
 681                     tgentab = tab
 682                     break
 683
 684         if tgentab :
 685             self.page.tgentab.RefreshData(self.page.tgens)
 686             self.page.tgentab.tgens = tgen.tgen
 687             page.SetSelection(i)
 688         else :
 689             self.page.tgentab = ListForSpec(ira, gparent, self.page.tgens, etoiles[1:])
 690             self.page.tgentab.tgen = True
 691             self.page.tgentab.tgens = tgen.tgen
 692             page.AddPage(self.page.tgentab, u'Tgens Specificities')
 693             page.SetSelection(page.GetPageCount() - 1)
 694
 695 class dolexlayout :
 696     def __init__(self, ira, corpus, parametres):
 697         self.pathout = PathOut(dirout = parametres['pathout'])
 698         self.corpus = corpus
 699         self.dictpathout = StatTxtPathOut(parametres['pathout'])
 700         #self.corpus.read_corpus_from_shelves(self.corpus.dictpathout['db'])
 701         self.parent = ira
 702         self.encoding = self.corpus.parametres['syscoding']
 703         self.parametres = parametres
 704
 705         self.DictSpec, first = ReadList(self.dictpathout['tablespecf'], self.corpus.parametres['syscoding'])
 706         if os.path.exists(self.pathout['banalites.csv']) :
 707             self.dictban, firstban = ReadList(self.pathout['banalites.csv'], self.corpus.parametres['syscoding'])
 708         self.DictType, firstt = ReadList(self.dictpathout['tablespect'], self.corpus.parametres['syscoding'])
 709         self.DictEff, firsteff = ReadList(self.dictpathout['tableafcm'], self.corpus.parametres['syscoding'])
 710         self.DictEffType, firstefft = ReadList(self.dictpathout['tabletypem'], self.corpus.parametres['syscoding'])
 711         self.DictEffRelForme, firsteffrelf = ReadList(self.dictpathout['eff_relatif_forme'], self.corpus.parametres['syscoding'])
 712         self.DictEffRelType, firsteffrelt = ReadList(self.dictpathout['eff_relatif_type'], self.corpus.parametres['syscoding'])
 713         self.etoiles = firsteff[1:]
 714         #sash = SashList(ira.nb)
 715
 716
 717         self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
 718         self.TabStat.parametres = parametres
 719         self.ListPan = ListForSpec(ira, self, self.DictSpec, self.etoiles)
 720         if os.path.exists(self.pathout['banalites.csv']) :
 721             self.listban = ListForSpec(ira, self, self.dictban, ['eff'] + self.etoiles, usefirst = True)
 722         #self.ListPan2 = ListForSpec(sash.rightwin1, self, self.DictSpec, first)
 723         self.ListPant = ListForSpec(ira, self, self.DictType, self.etoiles)
 724         self.ListPanEff = ListForSpec(ira, self, self.DictEff, self.etoiles)
 725         self.ListPanEffType = ListForSpec(ira, self, self.DictEffType, self.etoiles)
 726         self.ListPanEffRelForme = ListForSpec(ira, self, self.DictEffRelForme, self.etoiles)
 727         self.ListPanEffRelType = ListForSpec(ira, self, self.DictEffRelType, self.etoiles)
 728
 729         self.TabStat.AddPage(self.ListPan, u'formes')
 730         if os.path.exists(self.pathout['banalites.csv']) :
 731             self.TabStat.AddPage(self.listban, u'banalités')
 732         self.TabStat.AddPage(self.ListPant, u'Types')
 733         self.TabStat.AddPage(self.ListPanEff, u'Effectifs formes')
 734         self.TabStat.AddPage(self.ListPanEffType, u'Effectifs Type')
 735         self.TabStat.AddPage(self.ListPanEffRelForme, u'Effectifs relatifs formes')
 736         self.TabStat.AddPage(self.ListPanEffRelType, u'Effectifs relatifs Type')
 737         if self.parametres['clnb'] > 2 :
 738             self.TabAFC = aui.AuiNotebook(self.TabStat, -1, wx.DefaultPosition)
 739             list_graph=read_list_file(self.dictpathout['liste_graph_afcf'], encoding = self.encoding)
 740             self.tabAFCGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afcf', coding = self.encoding)
 741             self.TabAFC.AddPage(self.tabAFCGraph, 'AFC formes')
 742             list_graph=read_list_file(self.dictpathout['liste_graph_afct'], encoding = self.encoding)
 743             self.tabAFCTGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afct', coding=self.encoding)
 744             self.TabAFC.AddPage(self.tabAFCTGraph, 'AFC type')
 745             self.TabStat.AddPage(self.TabAFC, 'AFC')
 746
 747         ira.nb.AddPage(self.TabStat, u'Spécificités')
 748         self.ira = ira
 749
 750         self.TabStat.corpus = self.corpus
 751         self.TabStat.etoiles = self.etoiles
 752         if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenspec.csv')) :
 753             self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenspec.csv')
 754             TgenLayout(self.TabStat)
 755         self.TabStat.SetSelection(0)
 756         ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
 757         ira.ShowAPane("Tab_content")
 758
 759 class StatLayout:
 760     def __init__(self, ira, corpus, parametres):
 761         self.pathout = PathOut(dirout = parametres['pathout'])
 762         self.corpus = corpus
 763         self.ira = ira
 764         self.read_result()
 765         self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
 766         self.TabStat.parametres = parametres
 767         self.TabStat.corpus = corpus
 768         self.TabStat.pathout = self.pathout
 769 #        CHD = GraphPanel(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
 770         #      panel.TabChdSim.AddPage(CHD,'CHD')
 771
 772         #self.TabStatTot = wx.TextCtrl(self.TabStat, -1, style=wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2)
 773         list_graph = [['zipf.png', 'zipf']]
 774         self.TabStatTot = GraphPanel(ira.nb, self.pathout, list_graph, self.result['glob'])
 775         self.TabStat.AddPage(self.TabStatTot, 'global')
 776         for item in self.result:
 777             if item != 'glob':
 778                 datam = [['forme', 'nb']]
 779                 self.ListPan = ListPanel(ira, self, self.result[item])
 780                 self.TabStat.AddPage(self.ListPan, ' '.join(item.split('_')))
 781         ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
 782         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
 783         ira.ShowAPane("Tab_content")
 784
 785     def read_result(self) :
 786         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'}
 787         self.result = {}
 788         for key in lcle :
 789             with open(self.pathout[lcle[key]], 'r') as f :
 790                 self.result[key] = [line.split(';') for line in f.read().splitlines()]
 791                 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
 792         with open(self.pathout['glob.txt'], 'r') as f :
 793             self.result['glob'] = f.read()
 794
 795 class GraphPanelDendro(wx.Panel):
 796     def __init__(self,parent, dico, list_graph, txt=False):
 797         wx.Panel.__init__(self,parent)
 798         self.graphnb = 1
 799         self.dictpathout = dico
 800         self.dirout = os.path.dirname(self.dictpathout['ira'])
 801         self.list_graph = list_graph
 802         self.parent = self.GetParent()#parent
 803         self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
 804         self.labels = []
 805         self.listimg = []
 806         self.tabchd = self.parent.GetParent()
 807         self.ira = self.tabchd.GetParent()
 808         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
 809         self.panel_1.SetBackgroundColour('white')
 810         self.deb = wx.StaticText(self.panel_1, -1, txt)
 811         dendro_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
 812         dendro_liste_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro_liste.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
 813         dendro_cloud_img= wx.Image(os.path.join(self.ira.images_path,'but_dendro_cloud.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
 814         self.butdendro = wx.BitmapButton(self, -1, dendro_img)
 815         self.butdendrotexte = wx.BitmapButton(self, -1, dendro_liste_img)
 816         self.butdendrocloud = wx.BitmapButton(self, -1, dendro_cloud_img)
 817
 818         for i in range(0,len(list_graph)):
 819             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
 820                 filename, ext = os.path.splitext(list_graph[i][0])
 821                 if ext == '.svg' :
 822                     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])))
 823                 else :
 824                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
 825                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
 826
 827         self.__set_properties()
 828         self.__do_layout()
 829
 830     def __set_properties(self):
 831         self.panel_1.EnableScrolling(True,True)
 832         #self.panel_1.SetSize((1000,1000))
 833         self.panel_1.SetScrollRate(20, 20)
 834         self.panel_1.SetFocus()
 835         self.Bind(wx.EVT_BUTTON, self.ondendro, self.butdendro)
 836         self.Bind(wx.EVT_BUTTON, self.ondendrotexte, self.butdendrotexte)
 837         self.Bind(wx.EVT_BUTTON, self.ondendrocloud, self.butdendrocloud)
 838         self.param = {'width' : 700,
 839                        'height': 500,
 840                        'type_dendro': 0,
 841                        'color_nb': 0,
 842                        'taille_classe' : True,
 843                        'type_tclasse' : 0,
 844                        'svg' : 0
 845                      }
 846         self.type_dendro = [ u"phylogram", u"cladogram", u"fan", u"unrooted", u"radial" ]
 847
 848     def __do_layout(self):
 849         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
 850         self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
 851         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
 852         self.sizer_3.Add(self.deb)
 853         self.sizer_1.Add(self.butdendro, 0, 0, 0)
 854         self.sizer_1.Add(self.butdendrotexte, 0, 0, 0)
 855         self.sizer_1.Add(self.butdendrocloud, 0, 0, 0)
 856
 857         for i in range(0, len(self.listimg)):
 858             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 859             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 860         self.panel_1.SetSizer(self.sizer_3)
 861         self.sizer_2.Add(self.sizer_1, 0, wx.EXPAND, 0)
 862         self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
 863         self.SetSizer(self.sizer_2)
 864
 865     def make_param(self, dial):
 866         self.param['width'] = dial.m_spinCtrl2.GetValue()
 867         self.param['height'] = dial.m_spinCtrl1.GetValue()
 868         self.param['type_dendro'] = dial.m_choice1.GetSelection()
 869         self.param['color_nb'] = dial.m_radioBox1.GetSelection()
 870         self.param['taille_classe'] = dial.m_checkBox1.GetValue()
 871         self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
 872         self.param['svg'] = dial.choice_format.GetSelection()
 873
 874     def make_dendro(self, dendro = 'simple') :
 875         if self.param['svg'] :
 876             typefile = '.svg'
 877         else :
 878             typefile = '.png'
 879         while os.path.exists(os.path.join(self.dirout, 'dendrogramme_' + str(self.graphnb)+typefile)) :
 880             self.graphnb += 1
 881         fileout = ffr(os.path.join(self.dirout,'dendrogramme_' + str(self.graphnb)+typefile))
 882         width = self.param['width']
 883         height = self.param['height']
 884         type_dendro = self.type_dendro[self.param['type_dendro']]
 885         if self.param['taille_classe'] :
 886             tclasse = 'TRUE'
 887         else :
 888             tclasse = 'FALSE'
 889         if self.param['color_nb'] == 0 :
 890             bw = 'FALSE'
 891         else :
 892             bw = 'TRUE'
 893         if self.param['type_tclasse'] == 0 :
 894             histo='FALSE'
 895         else :
 896             histo = 'TRUE'
 897         if self.param['svg'] :
 898             svg = 'TRUE'
 899         else :
 900             svg = 'FALSE'
 901         dendro_path = self.dictpathout['Rdendro']
 902         classe_path = self.dictpathout['uce']
 903         txt = """
 904         library(ape)
 905         load("%s")
 906         source("%s")
 907         classes <- read.csv2("%s", row.names=1)
 908         classes <- classes[,1]
 909         """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']),  ffr(classe_path))
 910         if dendro == 'simple' :
 911             txt += """
 912             open_file_graph("%s", width=%i, height=%i)
 913             plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
 914             """ % (ffr(fileout), width, height, type_dendro, histo, bw, tclasse)
 915         elif dendro == 'texte' :
 916             txt += """
 917             load("%s")
 918             source("%s")
 919             if (is.null(debsup)) {
 920                 debsup <- debet
 921             }
 922             chistable <- chistabletot[1:(debsup-1),]
 923             open_file_graph("%s", width=%i, height=%i, svg = %s)
 924             plot.dendro.prof(tree.cut1$tree.cl, classes, chistable, nbbycl = 60, type.dendro="%s", bw=%s, lab=NULL)
 925             """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
 926         elif dendro == 'cloud' :
 927             txt += """
 928             load("%s")
 929             source("%s")
 930             if (is.null(debsup)) {
 931                 debsup <- debet
 932             }
 933             chistable <- chistabletot[1:(debsup-1),]
 934             open_file_graph("%s", width=%i, height=%i, svg=%s)
 935             plot.dendro.cloud(tree.cut1$tree.cl, classes, chistable, nbbycl = 300, type.dendro="%s", bw=%s, lab=NULL)
 936             """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
 937
 938
 939         tmpfile = tempfile.mktemp()
 940         with open(tmpfile, 'w') as f :
 941             f.write(txt)
 942         busy = wx.BusyInfo(_("Please wait...").decode('utf8'), self.parent)
 943         wx.SafeYield()
 944         error = exec_rcode(self.ira.RPath, tmpfile, wait=True)
 945         del busy
 946         check_Rresult(self.ira, error)
 947         self.list_graph.append([fileout, 'Dendrogramme CHD1 - %s' %  type_dendro])
 948         print_liste(self.dictpathout['liste_graph_chd'], self.list_graph)
 949         if self.param['svg'] :
 950             self.sizer_3.Add(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 951         else :
 952             self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 953         self.sizer_3.Add(wx.StaticText(self.panel_1,-1, 'Dendrogramme CHD1 - %s' %  type_dendro), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 954         self.sizer_3.Fit(self.panel_1)
 955         self.Layout()
 956         self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
 957
 958
 959     def ondendro(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()
 965
 966     def ondendrotexte(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 = 'texte')
 972
 973     def ondendrocloud(self, evt):
 974         dial = PrefDendro(self.ira, self.param)
 975         val = dial.ShowModal()
 976         if val == wx.ID_OK :
 977             self.make_param(dial)
 978             self.make_dendro(dendro = 'cloud')
 979
 980 class OpenCorpus :
 981     def __init__(self, ira, parametres) :
 982         #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)
 983         self.panel = CopusPanel(ira, parametres)
 984         ira.nb.AddPage(self.panel, 'Description %s' % parametres['corpus_name'])
 985         #self.text.write(DoConf().totext(parametres))
 986         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
 987         ira.ShowAPane("Tab_content")
 988
 989 class MatLayout :
 990     def __init__(self, ira, matrix):
 991         #self.parent.content = self.csvtable
 992         self.sheet = MySheet(ira.nb)
 993         ira.nb.AddPage(self.sheet, matrix.parametres['matrix_name'])
 994         self.sheet.Populate(matrix.csvtable)
 995         self.sheet.parametres = matrix.parametres
 996         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
 997         ira.ShowAPane("Tab_content")
 998
 999 class CopusPanel(wx.Panel) :
1000     def __init__(self, parent, parametres) :
1001         wx.Panel.__init__ ( self, parent, id = wx.ID_ANY, pos = wx.DefaultPosition, size = wx.Size( 500,300 ), style = wx.TAB_TRAVERSAL )
1002         self.parametres = parametres
1003         fgSizer5 = wx.FlexGridSizer( 0, 2, 0, 0 )
1004         fgSizer5.SetFlexibleDirection( wx.BOTH )
1005         fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )
1006         self.fgSizer5 = fgSizer5
1007
1008         self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Description du corpus", wx.DefaultPosition, wx.DefaultSize, 0 )
1009
1010         self.m_staticText18.Wrap( -1 )
1011         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1012
1013         self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1014         self.m_staticText19.Wrap( -1 )
1015         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1016
1017         self.m_staticText20 = wx.StaticText( self, wx.ID_ANY, u"Nom", wx.DefaultPosition, wx.DefaultSize, 0 )
1018         self.m_staticText20.Wrap( -1 )
1019         fgSizer5.Add( self.m_staticText20, 0, wx.ALL, 5 )
1020
1021         self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, parametres['corpus_name'], wx.DefaultPosition, wx.DefaultSize, 0 )
1022         self.m_staticText21.Wrap( -1 )
1023         fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )
1024
1025         description = {'lang' : u'langue',
1026                        'encoding' : u'encodage',
1027                        'ucinb' : u'Nombre de textes',
1028                        'ucenb' : u'Nombre de segments de texte',
1029                        'formesnb' : u'Nombre de formes',
1030                        'hapax' : u'Nombre d\'hapax'
1031                       }
1032
1033         keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']
1034
1035         self.addkeys(keys, description)
1036
1037         self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Paramètres", wx.DefaultPosition, wx.DefaultSize, 0 )
1038         self.m_staticText18.Wrap( -1 )
1039         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1040
1041         self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1042         self.m_staticText19.Wrap( -1 )
1043         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1044
1045         keys = ['ucemethod', 'ucesize', 'keep_caract', 'expressions']
1046         self.addkeys(keys, description)
1047
1048         self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Statistiques", wx.DefaultPosition, wx.DefaultSize, 0 )
1049         self.m_staticText18.Wrap( -1 )
1050         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1051
1052         self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1053         self.m_staticText19.Wrap( -1 )
1054         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1055
1056         keys = ['ucinb', 'ucenb', 'occurrences', 'formesnb', 'hapax']
1057         self.addkeys(keys, description)
1058
1059         self.SetSizer( fgSizer5 )
1060         self.Layout()
1061
1062     def addkeys(self, keys, description) :
1063         for key in keys :
1064             option = self.parametres.get(key,u'non défini')
1065             if isinstance(option, int) :
1066                 option = `option`
1067             text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
1068             text.Wrap( -1 )
1069             self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1070
1071             text = wx.StaticText( self, wx.ID_ANY, option, wx.DefaultPosition, wx.DefaultSize, 0 )
1072             text.Wrap( -1 )
1073             self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1074
1075 class DefaultTextLayout :
1076     def __init__(self, ira, corpus, parametres) :
1077         self.pathout = PathOut(dirout = parametres['pathout'])
1078         self.ira = ira
1079         self.parent = ira
1080         self.parametres = parametres
1081         self.corpus = corpus
1082         self.dolayout()
1083
1084     def dolayout(self) :
1085         log.info('no layout yet')
1086
1087 class WordCloudLayout(DefaultTextLayout):
1088     def dolayout(self):
1089         self.pathout.basefiles(simipath)
1090         self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1091         if self.parametres['svg'] :
1092             list_graph = [['nuage_1.svg', 'Nuage']]
1093         else :
1094             list_graph = [['nuage_1.png', 'Nuage']]
1095         self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, list_graph)
1096         self.Tab.AddPage(self.TabStatTot, 'Nuage')
1097         self.Tab.corpus = self.corpus
1098         self.Tab.parametres = self.parametres
1099         self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
1100         self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1101         self.ira.ShowAPane("Tab_content")
1102
1103 class SimiLayout(DefaultTextLayout) :
1104     def dolayout(self) :
1105         self.pathout.basefiles(simipath)
1106         self.actives = None
1107         self.indices = indices_simi
1108         if os.path.exists(self.pathout['liste_graph']) :
1109             list_graph = read_list_file(self.pathout['liste_graph'])
1110         else :
1111             list_graph = [['','']]
1112         notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1113         self.tabsimi = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1114         self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1115         self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1116         self.tabsimi.corpus = self.corpus
1117         self.tabsimi.parametres = self.parametres
1118         self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1119         self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1120         self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1121         self.tabsimi.AddPage(self.graphpan, 'Graph')
1122         self.ira.nb.AddPage(self.tabsimi, 'Analyse de graph')
1123         self.ira.ShowTab(True)
1124         self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1125
1126     def redosimi(self, evt) :
1127         with open(self.pathout['selected.csv'],'r') as f :
1128             selected = f.read()
1129         selected = [int(val) for val in selected.splitlines()]
1130         if self.actives is None :
1131             with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1132                 self.actives = f.read()
1133             self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1134         if os.path.exists(self.pathout['actives_nb.csv']) :
1135             with open(self.pathout['actives_nb.csv'], 'r') as f :
1136                 act_nb = f.read()
1137                 act_nb = act_nb.splitlines()
1138             dictcol = dict([[i, [self.actives[i], int(act_nb[i])]] for i, val in enumerate(self.actives)])
1139         else :
1140             dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1141         #res = SelectColumn(self.ira, dictcol, self.actives, self.pathout['selected.csv'], selected = selected, dlg = True)
1142         #if res.ok :
1143         prep = PrepSimi(self.ira, self, self.parametres,self.pathout['selected.csv'], self.actives, indices_simi, wordlist = dictcol, selected = selected)
1144         if prep.val == wx.ID_OK :
1145             self.parametres = prep.parametres
1146
1147             script = PrintSimiScript(self)
1148             script.make_script()
1149             pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
1150             check_Rresult(self.ira, pid)
1151             if self.parametres['type_graph'] in [1,3] :
1152                 if self.parametres['svg'] :
1153                     filename, ext = os.path.splitext(script.filename)
1154                     fileout = filename + '.svg'
1155                 elif self.parametres['type_graph'] == 3 :
1156                     fileout = script.filename
1157                     parametres = {'gexffile' :  fileout,
1158                                   'dirout' : os.path.dirname(fileout),
1159                                   'titre': 'Le titre',
1160                                   #'nodemin': self.param['txt_min'],
1161                                   #'nodemax': self.param['txt_max'],
1162                                   #'bargraphw' : 60*int(self.param['clnb']),
1163                     }
1164                     web = WebExport(self.ira, parametres)
1165                     fileout = web.exportsimi()
1166                 else :
1167                     fileout = script.filename
1168                 if os.path.exists(self.pathout['liste_graph']):
1169                     graph_simi = read_list_file(self.pathout['liste_graph'])
1170                     graph_simi.append([os.path.basename(fileout), script.txtgraph])
1171                 else :
1172                     graph_simi = [[os.path.basename(fileout), script.txtgraph]]
1173                 print_liste(self.pathout['liste_graph'], graph_simi)
1174             DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1175             if self.parametres['type_graph'] in [1,3] :
1176                 if self.parametres['svg'] or self.parametres['type_graph'] == 3 :
1177                     self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1178                 else :
1179                     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)
1180                 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1181                 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1182                 self.graphpan.Layout()
1183                 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1184
1185     def export(self, evt) :
1186         nb = 1
1187         while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1188             nb +=1
1189         fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1190         txt = """
1191         library(igraph)
1192         load("%s")
1193         source("%s")
1194         fileout <- "%s"
1195         graph <- graph.simi$graph
1196         V(graph)$x <- graph.simi$layout[,1]
1197         V(graph)$y <- graph.simi$layout[,2]
1198         if (length(graph.simi$label.cex == 1)) {
1199             V(graph)$weight <- graph.simi$eff
1200         } else {
1201             V(graph)$weight <- graph.simi$label.cex
1202         }
1203         V(graph)$color <- vertex.label.color
1204         V(graph)$frequences <- graph.simi$mat.eff
1205         V(graph)$label <- as.character(graph.simi$v.label)
1206         E(graph)$weight <- graph.simi$we.width
1207         write.graph(graph, fileout, format = 'graphml')
1208         #saveAsGEXF(graph, filepath = fileout)
1209         """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1210         filetmp = tempfile.mktemp()
1211         with open(filetmp, 'w') as f :
1212             f.write(txt)
1213         exec_rcode(self.ira.RPath, filetmp)
1214         mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
1215         mss.CenterOnParent()
1216         mss.ShowModal()
1217         mss.Destroy()
1218
1219 class DefaultMatLayout :
1220     def __init__(self, parent, tableau, parametres) :
1221         self.pathout = PathOut(dirout = parametres['pathout'])
1222         self.ira = parent
1223         self.parent = parent
1224         self.tableau = tableau
1225         self.parametres = parametres
1226         if os.path.exists(self.pathout['analyse.db']) :
1227             self.tableau.read_tableau(self.pathout['analyse.db'])
1228         self.dolayout()
1229         self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1230         self.ira.ShowAPane("Tab_content")
1231
1232     def dolayout(self) :
1233         pass
1234
1235 class FreqLayout(DefaultMatLayout) :
1236     def dolayout(self) :
1237         self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1238         res = normpath_win32(self.pathout['resultats.html']).replace('\\','/')
1239         self.tab.LoadPage(res)
1240         self.tab.parametres = self.parametres
1241         self.ira.nb.AddPage(self.tab, u"Fréquences")
1242
1243
1244 class Chi2Layout(DefaultMatLayout) :
1245     def dolayout(self):
1246         self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1247         if "gtk2" in wx.PlatformInfo:
1248             self.tab.SetStandardFonts()
1249         res = normpath_win32(self.pathout['resultats-chi2.html']).replace('\\','/')
1250         self.tab.LoadPage(res)
1251         self.tab.parametres = self.parametres
1252         self.ira.nb.AddPage(self.tab, ' - '.join([u"Chi2", "%s" % self.parametres['name']]))
1253         #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1254         #self.ira.ShowAPane("Tab_content")
1255
1256
1257 class ProtoLayout(DefaultMatLayout) :
1258     def dolayout(self) :
1259         list_graph = [['proto.png', 'Analyse prototypique']]
1260         #self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1261         #if self.parametres['svg'] :
1262         #    list_graph = [['nuage_1.svg', 'Nuage']]
1263         #else :
1264         #    list_graph = [['nuage_1.png', 'Nuage']]
1265         self.TabProto = GraphPanel(self.ira.nb, self.pathout, list_graph)
1266         #self.Tab.AddPage(self.TabProto, 'Analyse Prototypique')
1267         #self.Tab.corpus = self.corpus
1268         self.TabProto.parametres = self.parametres
1269         self.ira.nb.AddPage(self.TabProto, 'Analyse Prototypique - %s' % self.parametres['name'])
1270         #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1271         #self.ira.ShowAPane("Tab_content")
1272
1273
1274 class SimiMatLayout(DefaultMatLayout) :
1275     def dolayout(self):
1276         self.pathout.basefiles(simipath)
1277         self.indices = indices_simi
1278         if os.path.exists(self.pathout['liste_graph']) :
1279             list_graph = read_list_file(self.pathout['liste_graph'])
1280         else :
1281             list_graph = [['','']]
1282         notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1283         self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1284         self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1285         self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1286         self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1287         self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1288         self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1289         self.tabsimi.AddPage(self.graphpan, 'Graph')
1290         self.tabsimi.parametres = self.parametres
1291         self.parent.nb.AddPage(self.tabsimi, 'Analyse de graph')
1292         #self.parent.ShowTab(True)
1293         #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1294
1295     def redosimi(self,evt) :
1296         with open(self.pathout['selected.csv'],'r') as f :
1297             selected = f.read()
1298         selected = [int(val) for val in selected.splitlines()]
1299         #if self.actives is None :
1300         #    with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1301         #        self.actives = f.read()
1302         #    self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1303         try :
1304             actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1305         except :
1306             actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1307
1308         #self.tableau.make_listactives()
1309         actives = dict([[i, val] for i, val in enumerate(actives)])
1310         #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1311         self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1312         self.dial.CenterOnParent()
1313         self.val = self.dial.ShowModal()
1314         if self.val == wx.ID_OK :
1315             last = self.dial.listcol.GetFirstSelected()
1316             lastl = [self.dial.listcol.GetFirstSelected()]
1317             indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1318             while self.dial.listcol.GetNextSelected(last) != -1:
1319                 last = self.dial.listcol.GetNextSelected(last)
1320                 lastl.append(last)
1321                 indexes.append(self.dial.listcol.getColumnText(last,0))
1322             self.column = [self.tableau.listactives.index(val) for val in indexes]
1323             self.column.sort()
1324             with open(self.pathout['selected.csv'], 'w') as f :
1325                 f.write('\n'.join([`val` for val in self.column]))
1326             self.make_param()
1327             self.dial.Destroy()
1328             self.script = PrintSimiScript(self)
1329             self.script.make_script()
1330             self.tmpfile = self.script.scriptout
1331             dlg = progressbar(self, maxi = 2)
1332             self.DoR(dlg)
1333             dlg.Destroy()
1334             if self.parametres['type_graph'] == 1:
1335                 if self.parametres['svg'] :
1336                     filename, ext = os.path.splitext(self.script.filename)
1337                     fileout = filename + '.svg'
1338                 else :
1339                     fileout = self.script.filename
1340                 fileout = normpath_win32(fileout)
1341                 if os.path.exists(self.pathout['liste_graph']):
1342                     graph_simi = read_list_file(self.pathout['liste_graph'])
1343                     graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1344                 else :
1345                     graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1346                 print_liste(self.pathout['liste_graph'], graph_simi)
1347             DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1348             if self.parametres['type_graph'] == 1:
1349                 if self.parametres['svg'] :
1350                     self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1351                 else :
1352                     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)
1353                 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1354                 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1355                 self.graphpan.Layout()
1356                 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1357         else :
1358             self.dial.Destroy()
1359
1360
1361     def make_param(self) :
1362         if self.parametres['first'] :
1363             keep_coord = False
1364         else :
1365             keep_coord = self.dial.check_coord.GetValue()
1366         #self.select = self.dial.check_colch.GetValue()
1367
1368         paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1369                           'layout' : self.dial.choice2.GetSelection(),
1370                           'type_graph' : self.dial.choice3.GetSelection(),
1371                           'arbremax' : self.dial.check1.GetValue(),
1372                           'coeff_tv' : self.dial.check_s_size.GetValue(),
1373                           'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1374                           'tvprop' : self.dial.check2.GetValue(),
1375                           'tvmin' : self.dial.spin_tvmin.GetValue(),
1376                           'tvmax' : self.dial.spin_tvmax.GetValue(),
1377                           'coeff_te' : self.dial.check3.GetValue(),
1378                           'coeff_temin' : self.dial.spin_temin.GetValue(),
1379                           'coeff_temax' : self.dial.spin_temax.GetValue(),
1380                           'label_e' : self.dial.check_elab.GetValue(),
1381                           'label_v' : self.dial.check_vlab.GetValue(),
1382                           'vcex' : self.dial.check_vcex.GetValue(),
1383                           'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1384                           'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1385                           'cex' : self.dial.spin_cex.GetValue(),
1386                           'seuil_ok' : self.dial.check_seuil.GetValue(),
1387                           'seuil' : self.dial.spin_seuil.GetValue(),
1388                           'cols' : self.dial.cols.GetColour(),
1389                           'cola' : self.dial.cola.GetColour(),
1390                           'width' : self.dial.spin_width.GetValue(),
1391                           'height' : self.dial.spin_height.GetValue(),
1392                           'first' : False,
1393                           'keep_coord' : keep_coord,
1394                           'alpha' : self.dial.slider_sphere.GetValue(),
1395                           'film' : self.dial.film.GetValue(),
1396                           'svg' : self.dial.choix_format.GetSelection(),
1397                           'halo' : self.dial.halo.GetValue(),
1398                           'com' : self.dial.comcheck.GetValue(),
1399                           'communities' : self.dial.choix_com.GetSelection(),
1400                           'edgecurved' : self.dial.check_curved.GetValue(),
1401                           }
1402         if 'cexfromchi' in self.parametres :
1403             paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1404         if 'sfromchi' in self.parametres :
1405             paramsimi['sfromchi'] = self.dial.checki.GetValue()
1406         if 'vlabcolor' in self.parametres :
1407             paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1408         if 'check_bystar' in dir(self.dial) :
1409             paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1410             paramsimi['stars'] = self.parametres['stars']
1411         self.parametres.update(paramsimi)
1412
1413     def DoR(self, dlg):
1414         if self.parametres['type_graph'] == 1 :
1415             graph = False
1416             wait = False
1417         else :
1418             graph = True
1419             wait = True
1420         pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1421         if self.parametres['type_graph'] == 1 :
1422             while pid.poll() == None :
1423                 dlg.Pulse(u'R ...')
1424                 sleep(0.2)
1425             check_Rresult(self.parent, pid)
1426
1427     def export(self, evt) :
1428         nb = 1
1429         while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1430             nb +=1
1431         fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1432         txt = """
1433         library(igraph)
1434         load("%s")
1435         source("%s")
1436         fileout <- "%s"
1437         graph <- graph.simi$graph
1438         V(graph)$x <- graph.simi$layout[,1]
1439         V(graph)$y <- graph.simi$layout[,2]
1440         if (length(graph.simi$label.cex == 1)) {
1441             V(graph)$weight <- graph.simi$mat.eff
1442         } else {
1443             V(graph)$weight <- graph.simi$label.cex
1444         }
1445         V(graph)$color <- vertex.label.color
1446         V(graph)$frequences <- graph.simi$mat.eff
1447         V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
1448         V(graph)$label <- as.character(graph.simi$v.label)
1449         E(graph)$weight <- graph.simi$we.width
1450         write.graph(graph, fileout, format = 'graphml')
1451         #saveAsGEXF(graph, filepath = fileout)
1452         """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1453         filetmp = tempfile.mktemp()
1454         with open(filetmp, 'w') as f :
1455             f.write(txt)
1456         exec_rcode(self.ira.RPath, filetmp)
1457         mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
1458         mss.CenterOnParent()
1459         mss.ShowModal()
1460         mss.Destroy()
1461
1462
1463 class GraphPanelSimi(wx.Panel):
1464     def __init__(self,parent, dico, list_graph):
1465         wx.Panel.__init__(self,parent)
1466         self.afcnb = 1
1467         self.Dict = dico
1468         self.dirout = os.path.dirname(self.Dict['ira'])
1469         self.parent = self.GetParent()#parent
1470         self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "courier"))
1471         self.labels = []
1472         self.listimg = []
1473         self.tabsimi = self.parent.GetParent()
1474         self.ira = self.tabsimi.GetParent()
1475         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1476         afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1477         self.butafc = wx.BitmapButton(self, -1, afc_img)
1478         export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1479         self.butexport = wx.BitmapButton(self, -1, export_img)
1480         for i in range(0,len(list_graph)):
1481             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1482                 filename, ext = os.path.splitext(list_graph[i][0])
1483                 if ext in ['.svg', '.html'] :
1484                     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])))
1485                 else :
1486                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1487                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1488         self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove)
1489         self.__set_properties()
1490         self.__do_layout()
1491
1492     def __set_properties(self):
1493         self.panel_1.EnableScrolling(True,True)
1494         #self.panel_1.SetSize((1000,1000))
1495         self.panel_1.SetScrollRate(20, 20)
1496         self.panel_1.SetFocus()
1497
1498     def __do_layout(self):
1499         self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1500         self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1501         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1502         self.sizer_2.Add(self.butafc, 0, 0, 0)
1503         self.sizer_2.Add(self.butexport, 0, 0, 0)
1504         for i in range(0, len(self.listimg)):
1505             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1506             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1507         self.panel_1.SetSizer(self.sizer_3)
1508         self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1509         self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1510         self.SetSizer(self.sizer_1)
1511
1512     def onMouseMove(self, event):
1513         self.panel_1.SetFocus()