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