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', encoding='utf8') 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 open(self.pathout['classes_names.txt'], 'r', encoding='utf8') 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 open(DictPathOut['pre_rapport'], 'r', encoding='utf8') 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 open(self.dictpathout['translations.txt'], 'r', encoding='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 open(self.dictpathout[trans[1]], 'r', encoding='utf8') 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', encoding='utf8') 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.corpus.parametres['syscoding'] = 'UTF8'
 740         self.encoding = self.corpus.parametres['syscoding']
 741         self.parametres = parametres
 742         self.DictSpec, first = ReadList(self.dictpathout['tablespecf'], self.corpus.parametres['syscoding'])
 743         if os.path.exists(self.pathout['banalites.csv']) :
 744             self.dictban, firstban = ReadList(self.pathout['banalites.csv'], self.corpus.parametres['syscoding'])
 745         self.DictType, firstt = ReadList(self.dictpathout['tablespect'], self.corpus.parametres['syscoding'])
 746         self.DictEff, firsteff = ReadList(self.dictpathout['tableafcm'], self.corpus.parametres['syscoding'])
 747         self.DictEffType, firstefft = ReadList(self.dictpathout['tabletypem'], self.corpus.parametres['syscoding'])
 748         self.DictEffRelForme, firsteffrelf = ReadList(self.dictpathout['eff_relatif_forme'], self.corpus.parametres['syscoding'])
 749         self.DictEffRelType, firsteffrelt = ReadList(self.dictpathout['eff_relatif_type'], self.corpus.parametres['syscoding'])
 750         self.etoiles = firsteff[1:]
 751         #sash = SashList(ira.nb)
 752         self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
 753         self.TabStat.parametres = parametres
 754         self.ListPan = ListForSpec(ira, self, self.DictSpec, self.etoiles)
 755         if os.path.exists(self.pathout['banalites.csv']) :
 756             self.listban = ListForSpec(ira, self, self.dictban, ['eff'] + self.etoiles, usefirst = True)
 757         #self.ListPan2 = ListForSpec(sash.rightwin1, self, self.DictSpec, first)
 758         self.ListPant = ListForSpec(ira, self, self.DictType, self.etoiles)
 759         self.ListPanEff = ListForSpec(ira, self, self.DictEff, self.etoiles)
 760         self.ListPanEffType = ListForSpec(ira, self, self.DictEffType, self.etoiles)
 761         self.ListPanEffRelForme = ListForSpec(ira, self, self.DictEffRelForme, self.etoiles)
 762         self.ListPanEffRelType = ListForSpec(ira, self, self.DictEffRelType, self.etoiles)
 763         self.TabStat.AddPage(self.ListPan, _('Forms'))
 764         if os.path.exists(self.pathout['banalites.csv']) :
 765             self.TabStat.AddPage(self.listban, _('Banal forms'))
 766         self.TabStat.AddPage(self.ListPant, _('POS'))
 767         self.TabStat.AddPage(self.ListPanEff, _('Forms frequencies'))
 768         self.TabStat.AddPage(self.ListPanEffType, _('POS frequencies'))
 769         self.TabStat.AddPage(self.ListPanEffRelForme, _('Forms relative frequencies'))
 770         self.TabStat.AddPage(self.ListPanEffRelType, _('POS relative frequencies'))
 771         if self.parametres['clnb'] > 2 :
 772             self.TabAFC = aui.AuiNotebook(self.TabStat, -1, wx.DefaultPosition)
 773             list_graph=read_list_file(self.dictpathout['liste_graph_afcf'], encoding = self.encoding)
 774             self.tabAFCGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afcf', coding = self.encoding)
 775             self.TabAFC.AddPage(self.tabAFCGraph, _('CA forms'))
 776             list_graph=read_list_file(self.dictpathout['liste_graph_afct'], encoding = self.encoding)
 777             self.tabAFCTGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afct', coding=self.encoding)
 778             self.TabAFC.AddPage(self.tabAFCTGraph, _('CA POS'))
 779             self.TabStat.AddPage(self.TabAFC, _('CA'))
 780         ira.nb.AddPage(self.TabStat, ' - '.join([_('Specificities'), self.parametres['name']]))
 781         self.ira = ira
 782         self.TabStat.corpus = self.corpus
 783         self.TabStat.etoiles = self.etoiles
 784         if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenspec.csv')) :
 785             self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenspec.csv')
 786             TgenLayout(self.TabStat)
 787         self.TabStat.SetSelection(0)
 788         ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
 789         ira.ShowAPane("Tab_content")
 790
 791
 792 class StatLayout:
 793
 794     def __init__(self, ira, corpus, parametres):
 795         self.pathout = PathOut(dirout = parametres['pathout'])
 796         self.corpus = corpus
 797         self.ira = ira
 798         self.read_result() # qui va définir la propriété self.result
 799         self.parametres = parametres
 800         self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
 801         self.TabStat.parametres = parametres
 802         self.TabStat.corpus = corpus
 803         self.TabStat.pathout = self.pathout
 804 #        CHD = GraphPanel(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
 805 #        panel.TabChdSim.AddPage(CHD,'CHD')
 806         #self.TabStatTot = wx.TextCtrl(self.TabStat, -1, style=wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2)
 807         list_graph = [['zipf.png', 'zipf']]
 808         self.TabStatTot = GraphPanel(ira.nb, self.pathout, list_graph, self.result['glob'])
 809         self.TabStat.AddPage(self.TabStatTot, _('Abstract'))
 810         dictlabel = {'total' : _('Total'),
 811                      'formes_actives' : _('Actives forms'),
 812                      'formes_supplémentaires': _('Supplementary forms'),
 813                      'hapax' : _('Hapax'),
 814                      }
 815         for item in self.result:
 816             if item != 'glob':
 817                 datam = [['forme', 'nb']] #???
 818                 self.ListPan = ListPanel(ira, self, self.result[item])
 819                 self.TabStat.AddPage(self.ListPan, dictlabel[item])
 820         ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
 821         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
 822         ira.ShowAPane("Tab_content")
 823
 824     def read_result(self) :
 825         lcle = {'total' :'total.csv', 'formes_actives':'formes_actives.csv', 'formes_supplémentaires':'formes_supplémentaires.csv', 'hapax': 'hapax.csv'}
 826         self.result = {}
 827         for key in lcle :
 828             with open(self.pathout[lcle[key]], 'r', encoding='utf-8') as f :
 829                 self.result[key] = [line.split(';') for line in f.read().splitlines()]
 830                 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
 831         with open(self.pathout['glob.txt'], 'r', encoding='utf-8') as f :
 832             self.result['glob'] = f.read()
 833
 834
 835 class GraphPanelDendro(wx.Panel):
 836
 837     def __init__(self,parent, dico, list_graph, txt=False):
 838         wx.Panel.__init__(self,parent)
 839         self.graphnb = 1
 840         self.dictpathout = dico
 841         self.dirout = os.path.dirname(self.dictpathout['ira'])
 842         self.list_graph = list_graph
 843         self.parent = self.GetParent()#parent
 844         self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "Arial")) #modifié
 845         self.labels = []
 846         self.listimg = []
 847         self.tabchd = self.parent.GetParent()
 848         self.ira = self.tabchd.GetParent()
 849         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
 850         self.panel_1.SetBackgroundColour('white')
 851         self.deb = wx.StaticText(self.panel_1, -1, txt)
 852         dendro_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
 853         dendro_liste_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro_liste.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
 854         dendro_cloud_img= wx.Image(os.path.join(self.ira.images_path,'but_dendro_cloud.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
 855         self.butdendro = wx.BitmapButton(self, -1, dendro_img)
 856         self.butdendrotexte = wx.BitmapButton(self, -1, dendro_liste_img)
 857         self.butdendrocloud = wx.BitmapButton(self, -1, dendro_cloud_img)
 858         for i in range(0,len(list_graph)):
 859             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
 860                 filename, ext = os.path.splitext(list_graph[i][0])
 861                 if ext == '.svg' :
 862                     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])))
 863                 else :
 864                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
 865                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
 866         self.__set_properties()
 867         self.__do_layout()
 868
 869     def __set_properties(self):
 870         self.panel_1.EnableScrolling(True,True)
 871         #self.panel_1.SetSize((1000,1000))
 872         self.panel_1.SetScrollRate(20, 20)
 873         self.panel_1.SetFocus()
 874         self.Bind(wx.EVT_BUTTON, self.ondendro, self.butdendro)
 875         self.Bind(wx.EVT_BUTTON, self.ondendrotexte, self.butdendrotexte)
 876         self.Bind(wx.EVT_BUTTON, self.ondendrocloud, self.butdendrocloud)
 877         self.param = {'width' : 700,
 878                        'height': 500,
 879                        'type_dendro': 0,
 880                        'color_nb': 0,
 881                        'taille_classe' : True,
 882                        'type_tclasse' : 0,
 883                        'svg' : 0
 884                      }
 885         self.type_dendro = [ "phylogram", "cladogram", "fan", "unrooted", "radial" ]
 886
 887     def __do_layout(self):
 888         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
 889         self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
 890         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
 891         self.sizer_3.Add(self.deb)
 892         self.sizer_1.Add(self.butdendro, 0, 0, 0)
 893         self.sizer_1.Add(self.butdendrotexte, 0, 0, 0)
 894         self.sizer_1.Add(self.butdendrocloud, 0, 0, 0)
 895         for i in range(0, len(self.listimg)):
 896             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 897             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 898         self.panel_1.SetSizer(self.sizer_3)
 899         self.sizer_2.Add(self.sizer_1, 0, wx.EXPAND, 0)
 900         self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
 901         self.SetSizer(self.sizer_2)
 902
 903     def make_param(self, dial):
 904         self.param['width'] = dial.m_spinCtrl2.GetValue()
 905         self.param['height'] = dial.m_spinCtrl1.GetValue()
 906         self.param['type_dendro'] = dial.m_choice1.GetSelection()
 907         self.param['svg'] = dial.choice_format.GetSelection()
 908         if self.param['typedendro'] == 'classique' :
 909             self.param['color_nb'] = dial.m_radioBox1.GetSelection()
 910             self.param['taille_classe'] = dial.m_checkBox1.GetValue()
 911             self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
 912         if self.param.get('translation', False) :
 913             if dial.trans.GetSelection() == 0 :
 914                 del self.param['translation']
 915             else :
 916                 self.param['translation'] = self.param['translation'][dial.trans.GetSelection()-1][1]
 917
 918     def make_dendro(self, dendro = 'simple') :
 919         if self.param['svg'] :
 920             typefile = '.svg'
 921         else :
 922             typefile = '.png'
 923         while os.path.exists(os.path.join(self.dirout, 'dendrogramme_' + str(self.graphnb)+typefile)) :
 924             self.graphnb += 1
 925         fileout = ffr(os.path.join(self.dirout,'dendrogramme_' + str(self.graphnb)+typefile))
 926         width = self.param['width']
 927         height = self.param['height']
 928         type_dendro = self.type_dendro[self.param['type_dendro']]
 929         if self.param['taille_classe'] :
 930             tclasse = 'TRUE'
 931         else :
 932             tclasse = 'FALSE'
 933         if self.param['color_nb'] == 0 :
 934             bw = 'FALSE'
 935         else :
 936             bw = 'TRUE'
 937         if self.param['type_tclasse'] == 0 :
 938             histo='FALSE'
 939         else :
 940             histo = 'TRUE'
 941         if self.param['svg'] :
 942             svg = 'TRUE'
 943         else :
 944             svg = 'FALSE'
 945         dendro_path = self.dictpathout['Rdendro']
 946         classe_path = self.dictpathout['uce']
 947         txt = """
 948         library(ape)
 949         load("%s")
 950         source("%s")
 951         classes <- read.csv2("%s", row.names=1)
 952         classes <- classes[,1]
 953         """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']),  ffr(classe_path))
 954         if dendro == 'simple' :
 955             txt += """
 956             open_file_graph("%s", width=%i, height=%i, svg=%s)
 957             plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
 958             """ % (ffr(fileout), width, height, svg, type_dendro, histo, bw, tclasse)
 959         elif dendro == 'texte' :
 960             txt += """
 961             load("%s")
 962             source("%s")
 963             if (is.null(debsup)) {
 964                 debsup <- debet
 965             }
 966             chistable <- chistabletot[1:(debsup-1),]
 967             """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']))
 968             if self.param.get('translation', False) :
 969                 txt += """
 970                 rn <- read.csv2("%s", header=FALSE, sep='\t')
 971                 rnchis <- row.names(chistable)
 972                 commun <- intersect(rnchis, unique(rn[,2]))
 973                 idrnchis <- sapply(commun, function(x) {which(rnchis==x)})
 974                 idrn <- sapply(commun, function(x) {which(as.vector(rn[,2])==x)[1]})
 975                 rownames(chistable)[idrnchis] <- as.vector(rn[idrn,1])
 976                 """ % ffr(self.param['translation'])
 977             txt += """
 978             open_file_graph("%s", width=%i, height=%i, svg = %s)
 979             plot.dendro.prof(tree.cut1$tree.cl, classes, chistable, nbbycl = 60, type.dendro="%s", bw=%s, lab=NULL)
 980             """ % (ffr(fileout), width, height, svg, type_dendro, bw)
 981         elif dendro == 'cloud' :
 982             txt += """
 983             load("%s")
 984             source("%s")
 985             if (is.null(debsup)) {
 986                 debsup <- debet
 987             }
 988             chistable <- chistabletot[1:(debsup-1),]
 989             open_file_graph("%s", width=%i, height=%i, svg=%s)
 990             plot.dendro.cloud(tree.cut1$tree.cl, classes, chistable, nbbycl = 300, type.dendro="%s", bw=%s, lab=NULL)
 991             """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
 992         tmpfile = tempfile.mktemp()
 993         # ecriture du fichier de script à éxécuter
 994         with open(tmpfile, 'w', encoding='utf8') as f :
 995             f.write(txt)
 996         # dialogue d'attente
 997         busy = wx.BusyInfo(_("Please wait..."), self.parent)
 998         wx.SafeYield()
 999         error = exec_rcode(self.ira.RPath, tmpfile, wait=True)
1000         del busy
1001         # fin de l'attente
1002         check_Rresult(self.ira, error)
1003         self.list_graph.append([fileout, 'Dendrogramme CHD1 - %s' %  type_dendro])
1004         print_liste(self.dictpathout['liste_graph_chd'], self.list_graph)
1005         if self.param['svg'] :
1006             self.sizer_3.Add(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1007         else :
1008             self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1009         self.sizer_3.Add(wx.StaticText(self.panel_1,-1, 'Dendrogramme CHD1 - %s' %  type_dendro), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1010         self.sizer_3.Fit(self.panel_1)
1011         self.Layout()
1012         self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
1013
1014
1015     def ondendro(self, evt):
1016         self.param['typedendro'] = 'classique'
1017         dial = PrefDendro(self.ira, self.param)
1018         val = dial.ShowModal()
1019         if val == wx.ID_OK :
1020             self.make_param(dial)
1021             self.make_dendro()
1022
1023     def ondendrotexte(self, evt):
1024         self.param['typedendro'] = 'texte'
1025         if os.path.exists(self.dictpathout['translations.txt']) :
1026             with codecs.open(self.dictpathout['translations.txt'], 'r', 'utf8') as f :
1027                 content = f.read()
1028             print(content)
1029             trans = [line.split('\t')[1] for line in content.splitlines()]
1030             trans = [[val, self.dictpathout[val]] for val in trans]
1031             self.param['translation'] = trans
1032         dial = PrefDendro(self.ira, self.param)
1033         val = dial.ShowModal()
1034         if val == wx.ID_OK :
1035             self.make_param(dial)
1036             self.make_dendro(dendro = 'texte')
1037
1038     def ondendrocloud(self, evt):
1039         self.param['typedendro'] = 'cloud'
1040         dial = PrefDendro(self.ira, self.param)
1041         val = dial.ShowModal()
1042         if val == wx.ID_OK :
1043             self.make_param(dial)
1044             self.make_dendro(dendro = 'cloud')
1045
1046
1047 class OpenCorpus :
1048
1049     def __init__(self, ira, parametres) :
1050         #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)
1051         self.panel = CopusPanel(ira, parametres)
1052         ira.nb.AddPage(self.panel, 'Description %s' % parametres['corpus_name'])
1053         #self.text.write(DoConf().totext(parametres))
1054         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
1055         ira.ShowAPane("Tab_content")
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', encoding='utf8') 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', encoding='utf8') 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         self.tableau.read_tableau(self.pathout['analyse.db'])
1405         TabCate = ElCategorizator(self.ira.nb, self.pathout, self.tableau)
1406         self.ira.nb.AddPage(TabCate, ' - '.join([_('ElCaTeGoRiZaToR'), self.parametres['name']]))
1407
1408 class SimiMatLayout(DefaultMatLayout) :
1409
1410     def dolayout(self):
1411         self.pathout.basefiles(simipath)
1412         self.indices = indices_simi
1413         if os.path.exists(self.pathout['liste_graph']) :
1414             list_graph = read_list_file(self.pathout['liste_graph'])
1415         else :
1416             list_graph = [['','']]
1417         notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1418         self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1419         self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1420         self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1421         self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1422         self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1423         self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1424         self.graphpan.Bind(wx.EVT_BUTTON, self.blender, self.graphpan.butblender)
1425         self.tabsimi.AddPage(self.graphpan, _('Graph'))
1426         self.tabsimi.parametres = self.parametres
1427         self.parent.nb.AddPage(self.tabsimi, ' - '.join([_('Graph analysis'), self.parametres['name']]))
1428         #self.parent.ShowTab(True)
1429         #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1430
1431     def redosimi(self,evt) :
1432         with open(self.pathout['selected.csv'],'r', encoding='utf8') as f :
1433             selected = f.read()
1434         selected = [int(val) for val in selected.splitlines()]
1435         #if self.actives is None :
1436         #    with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1437         #        self.actives = f.read()
1438         #    self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1439         try :
1440             actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1441         except :
1442             actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1443         #self.tableau.make_listactives()
1444         actives = dict([[i, val] for i, val in enumerate(actives)])
1445         print(actives)
1446         #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1447         self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1448         self.dial.CenterOnParent()
1449         self.val = self.dial.ShowModal()
1450         if self.val == wx.ID_OK :
1451             last = self.dial.listcol.GetFirstSelected()
1452             lastl = [self.dial.listcol.GetFirstSelected()]
1453             indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1454             while self.dial.listcol.GetNextSelected(last) != -1:
1455                 last = self.dial.listcol.GetNextSelected(last)
1456                 lastl.append(last)
1457                 indexes.append(self.dial.listcol.getColumnText(last,0))
1458             self.column = [self.tableau.listactives.index(val) for val in indexes]
1459             self.column.sort()
1460             with open(self.pathout['selected.csv'], 'w', encoding='utf8') as f :
1461                 f.write('\n'.join([repr(val) for val in self.column]))
1462             self.make_param()
1463             self.dial.Destroy()
1464             self.script = PrintSimiScript(self)
1465             self.script.make_script()
1466             self.tmpfile = self.script.scriptout
1467             dlg = progressbar(self, maxi = 2)
1468             self.DoR(dlg)
1469             dlg.Destroy()
1470             if self.parametres['type_graph'] == 1:
1471                 if self.parametres['svg'] :
1472                     filename, ext = os.path.splitext(self.script.filename)
1473                     fileout = filename + '.svg'
1474                 else :
1475                     fileout = self.script.filename
1476                 fileout = normpath_win32(fileout)
1477                 if os.path.exists(self.pathout['liste_graph']):
1478                     graph_simi = read_list_file(self.pathout['liste_graph'])
1479                     graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1480                 else :
1481                     graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1482                 print_liste(self.pathout['liste_graph'], graph_simi)
1483             DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1484             if self.parametres['type_graph'] == 1:
1485                 if self.parametres['svg'] :
1486                     self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1487                 else :
1488                     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)
1489                 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1490                 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1491                 self.graphpan.Layout()
1492                 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1493         else :
1494             self.dial.Destroy()
1495
1496     def make_param(self) :
1497         if self.parametres['first'] :
1498             keep_coord = False
1499         else :
1500             keep_coord = self.dial.check_coord.GetValue()
1501         #self.select = self.dial.check_colch.GetValue()
1502         paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1503                           'layout' : self.dial.choice2.GetSelection(),
1504                           'type_graph' : self.dial.choice3.GetSelection(),
1505                           'arbremax' : self.dial.check1.GetValue(),
1506                           'coeff_tv' : self.dial.check_s_size.GetValue(),
1507                           'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1508                           'tvprop' : self.dial.check2.GetValue(),
1509                           'tvmin' : self.dial.spin_tvmin.GetValue(),
1510                           'tvmax' : self.dial.spin_tvmax.GetValue(),
1511                           'coeff_te' : self.dial.check3.GetValue(),
1512                           'coeff_temin' : self.dial.spin_temin.GetValue(),
1513                           'coeff_temax' : self.dial.spin_temax.GetValue(),
1514                           'label_e' : self.dial.check_elab.GetValue(),
1515                           'label_v' : self.dial.check_vlab.GetValue(),
1516                           'vcex' : self.dial.check_vcex.GetValue(),
1517                           'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1518                           'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1519                           'cex' : self.dial.spin_cex.GetValue(),
1520                           'seuil_ok' : self.dial.check_seuil.GetValue(),
1521                           'seuil' : self.dial.spin_seuil.GetValue(),
1522                           'cols' : self.dial.cols.GetColour(),
1523                           'cola' : self.dial.cola.GetColour(),
1524                           'width' : self.dial.spin_width.GetValue(),
1525                           'height' : self.dial.spin_height.GetValue(),
1526                           'first' : False,
1527                           'keep_coord' : keep_coord,
1528                           'alpha' : self.dial.slider_sphere.GetValue(),
1529                           'film' : self.dial.film.GetValue(),
1530                           'svg' : self.dial.choix_format.GetSelection(),
1531                           'halo' : self.dial.halo.GetValue(),
1532                           'com' : self.dial.comcheck.GetValue(),
1533                           'communities' : self.dial.choix_com.GetSelection(),
1534                           'edgecurved' : self.dial.check_curved.GetValue(),
1535                           }
1536         if 'cexfromchi' in self.parametres :
1537             paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1538         if 'sfromchi' in self.parametres :
1539             paramsimi['sfromchi'] = self.dial.checki.GetValue()
1540         if 'vlabcolor' in self.parametres :
1541             paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1542         if 'check_bystar' in dir(self.dial) :
1543             paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1544             paramsimi['stars'] = self.parametres['stars']
1545         self.parametres.update(paramsimi)
1546
1547     def DoR(self, dlg):
1548         if self.parametres['type_graph'] == 1 :
1549             graph = False
1550             wait = False
1551         else :
1552             graph = True
1553             wait = True
1554         pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1555         if self.parametres['type_graph'] == 1 :
1556             while pid.poll() == None :
1557                 dlg.Pulse('R ...')
1558                 sleep(0.2)
1559             check_Rresult(self.parent, pid)
1560
1561     def export(self, evt) :
1562         nb = 1
1563         while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1564             nb +=1
1565         fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1566         txt = """
1567         library(igraph)
1568         load("%s")
1569         source("%s")
1570         fileout <- "%s"
1571         graph <- graph.simi$graph
1572         V(graph)$x <- graph.simi$layout[,1]
1573         V(graph)$y <- graph.simi$layout[,2]
1574         if (length(graph.simi$label.cex == 1)) {
1575             V(graph)$weight <- graph.simi$mat.eff
1576         } else {
1577             V(graph)$weight <- graph.simi$label.cex
1578         }
1579         V(graph)$color <- vertex.label.color
1580         V(graph)$frequences <- graph.simi$mat.eff
1581         V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
1582         V(graph)$label <- as.character(graph.simi$v.label)
1583         E(graph)$weight <- graph.simi$we.width
1584         write.graph(graph, fileout, format = 'graphml')
1585         #saveAsGEXF(graph, filepath = fileout)
1586         """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['simi']), fileout)
1587         filetmp = tempfile.mktemp()
1588         with open(filetmp, 'w', encoding='utf8') as f :
1589             f.write(txt)
1590         exec_rcode(self.ira.RPath, filetmp)
1591         mss = wx.MessageDialog(self.ira, fileout, _('File exported'), wx.OK)
1592         mss.CenterOnParent()
1593         mss.ShowModal()
1594         mss.Destroy()
1595
1596     def blender(self, evt):
1597         blender(self)
1598
1599
1600 class GraphPanelSimi(wx.Panel):
1601
1602     def __init__(self,parent, dico, list_graph):
1603         wx.Panel.__init__(self,parent)
1604         self.afcnb = 1
1605         self.Dict = dico
1606         self.dirout = os.path.dirname(self.Dict['ira'])
1607         self.parent = self.GetParent()
1608         self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "courier")) #modifié
1609         self.labels = []
1610         self.listimg = []
1611         self.tabsimi = self.parent.GetParent()
1612         self.ira = self.tabsimi.GetParent()
1613         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1614         afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1615         self.butafc = wx.BitmapButton(self, -1, afc_img)
1616         export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1617         self.butexport = wx.BitmapButton(self, -1, export_img)
1618         blender_img = wx.Image(os.path.join(self.ira.images_path,'button_blender.png'), wx.BITMAP_TYPE_ANY)
1619         blender_img.Rescale(32,32)
1620         blender_img = blender_img.ConvertToBitmap()
1621         self.butblender = wx.BitmapButton(self, -1, blender_img)
1622         for i in range(0,len(list_graph)):
1623             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1624                 filename, ext = os.path.splitext(list_graph[i][0])
1625                 if ext in ['.svg', '.html'] :
1626                     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])))
1627                 else :
1628                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1629                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1630         self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove)
1631         self.__set_properties()
1632         self.__do_layout()
1633
1634     def __set_properties(self):
1635         self.panel_1.EnableScrolling(True,True)
1636         #self.panel_1.SetSize((1000,1000))
1637         self.panel_1.SetScrollRate(20, 20)
1638         self.panel_1.SetFocus()
1639
1640     def __do_layout(self):
1641         self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1642         self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1643         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1644         self.sizer_2.Add(self.butafc, 0, 0, 0)
1645         self.sizer_2.Add(self.butexport, 0, 0, 0)
1646         self.sizer_2.Add(self.butblender, 0, 0, 0)
1647         for i in range(0, len(self.listimg)):
1648             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1649             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1650         self.panel_1.SetSizer(self.sizer_3)
1651         self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1652         self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1653         self.SetSizer(self.sizer_1)
1654
1655     def onMouseMove(self, event):
1656         self.panel_1.SetFocus()
1657