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

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