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