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 search_tools import SearchFrame
  42 from dialog import PrefGraph, PrefExport, PrefSimpleFile, PrefDendro, SimpleDialog, ImageViewer
  43 from guifunct import SelectColumn, PrepSimi, PrefSimi, redosimi
  44 from webexport import WebExport
  45 from corpus import Corpus
  46 from sheet import MySheet
  47 from graph_to_json import GraphToJson
  48
  49
  50 import langue
  51 langue.run()
  52
  53
  54
  55 log = logging.getLogger('iramuteq.layout')
  56
  57
  58
  59 class GraphPanelAfc(wx.Panel):
  60
  61     def __init__(self, parent, dico, list_graph, clnb, itempath = 'liste_graph_afc', coding = sys.getdefaultencoding()):
  62         wx.Panel.__init__(self,parent)
  63         self.afcnb = 1
  64         self.clnb = clnb
  65         self.Dict = dico
  66         self.coding = coding
  67         self.itempath = itempath
  68         self.parent = self.GetParent()
  69         self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "Arial"))
  70         self.labels = []
  71         self.listimg = []
  72         self.buts = []
  73         self.list_graph = list_graph
  74         self.TabCHD = self.parent.GetParent()
  75         self.nb = self.TabCHD.GetParent()
  76         self.ira = self.nb.GetParent()
  77         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
  78         afc_img = wx.Image(os.path.join(self.ira.images_path,'button_afc.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
  79         self.butafc = wx.BitmapButton(self, -1, afc_img)
  80         self.Bind(wx.EVT_BUTTON, self.afc_graph, self.butafc)
  81         self.dirout = os.path.dirname(self.Dict['ira'])
  82         b = 0
  83         todel = []
  84         for i in range(0,len(list_graph)):
  85             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
  86                 filename, ext = os.path.splitext(list_graph[i][0])
  87                 if ext == '.svg' or ext == '.html':
  88                     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])))
  89                 else :
  90                     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)))
  91                     self.listimg[-1].Bind(wx.EVT_RIGHT_DOWN, self.onrightclick)
  92                 if os.path.exists(os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')) :
  93                     txt = _("List of not plotted points : ") + '%s' % os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')
  94                 else :
  95                     txt = ''
  96                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1] + txt))
  97                 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = repr(i - b)))
  98             else :
  99                 todel.append(i)
 100                 b += 1
 101         self.list_graph = [graph for i, graph in enumerate(self.list_graph) if i not in todel]
 102         self.param = { 'typegraph' : 0,
 103               'width' : 800,
 104               'height' : 800,
 105               'what' : 0,
 106               'qui' : 0,
 107               'do_select_nb' : 0,
 108               'do_select_chi' : 0,
 109               'do_select_chi_classe' : 0,
 110               'select_nb' : 50,
 111               'select_chi' : 4,
 112               'nbchic' : 30,
 113               'over' : 0,
 114               'cex_txt' : 0,
 115               'txt_min' : 5,
 116               'txt_max' : 40,
 117               'tchi' : 0,
 118               'tchi_min' : 5,
 119               'tchi_max' : 40,
 120               'taillecar' : 9,
 121               'facteur' : [1,2,3],
 122               'alpha' : 10,
 123               'clnb' : clnb,
 124               'svg' : 0,
 125                }
 126         self.__set_properties()
 127         self.__do_layout()
 128
 129     def __set_properties(self):
 130         self.panel_1.EnableScrolling(True,True)
 131         #self.panel_1.SetSize((1000,1000))
 132         self.panel_1.SetScrollRate(20, 20)
 133         self.panel_1.SetFocus()
 134
 135     def __do_layout(self):
 136         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
 137         self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
 138         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
 139         self.sizer_2.Add(self.butafc, 0, 0, 0)
 140         for i in range(0, len(self.listimg)):
 141             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 142             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 143             self.sizer_3.Add(self.buts[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 144             self.Bind(wx.EVT_BUTTON, self.on_delete_image, self.buts[i])
 145         self.panel_1.SetSizer(self.sizer_3)
 146         self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
 147         self.SetSizer(self.sizer_2)
 148
 149     def on_delete_image(self, event) :
 150         image_id = int(event.GetEventObject().GetName())
 151         image_path = self.list_graph[image_id][0]
 152         message = _('This file will be delete : ') + '%s.\n' % os.path.join(self.dirout, image_path) + _('Are you sure ?')
 153         dial = wx.MessageDialog(self, message, style = wx.YES_NO)
 154         res = dial.ShowModal()
 155         if res == wx.ID_YES :
 156             dial.Destroy()
 157             log.info('delete image %i' % image_id)
 158             oldimg = self.listimg.pop(image_id)
 159             oldimg.Destroy()
 160             oldlab = self.labels.pop(image_id)
 161             oldlab.Destroy()
 162             oldbut = self.buts.pop(image_id)
 163             oldbut.Show(False)
 164             for i, but in enumerate(self.buts) :
 165                 but.SetName(repr(i))
 166                 self.listimg[i].SetName(repr(i))
 167             todel = self.list_graph.pop(image_id)
 168             os.remove(os.path.join(self.dirout, todel[0]))
 169             print_liste(self.Dict[self.itempath], self.list_graph)
 170             self.sizer_3.Fit(self.panel_1)
 171             self.Layout()
 172         else :
 173             dial.Destroy()
 174
 175     def onrightclick(self, event):
 176         image_id = int(event.GetEventObject().GetName())
 177         image_path = self.list_graph[image_id][0]
 178         viewer = ImageViewer(self, {'tmpgraph' : os.path.join(self.dirout,image_path), 'svg': 'FALSE', 'wildcard': '*.*'}, self.labels[image_id].GetLabelText(), self.listimg[image_id].GetSize())
 179         viewer.Show()
 180         #print image_path
 181         #print self.labels[image_id].GetLabelText()
 182
 183     def afc_graph(self,event):
 184         #dirout = os.path.dirname(self.Dict['ira'])
 185         dial = PrefGraph(self.parent,-1,self.param,'')
 186         dial.CenterOnParent()
 187         val = dial.ShowModal()
 188         if val == wx.ID_OK :
 189             if dial.choix_format.GetSelection() == 0 :
 190                 svg = 0
 191             else :
 192                 svg = 1
 193             typegraph = dial.choicetype.GetSelection()
 194             if svg :
 195                 typefile = '.svg'
 196             else :
 197                 typefile = '.png'
 198             if self.clnb <= 3 and typegraph == 1 :
 199                 typegraph = 2
 200             if typegraph == 2:
 201                 typefile = '.gexf'
 202             if typegraph == 3 :
 203                 typefile = ''
 204             while os.path.exists(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile)):
 205                 self.afcnb +=1
 206             self.fileout = ffr(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile))
 207
 208             self.param = {'typegraph' : typegraph,
 209                           'width' : dial.spin1.GetValue(),
 210                           'height' : dial.spin2.GetValue(),
 211                           'what' : dial.choice1.GetSelection(),
 212                           'qui' : dial.choice2.GetSelection(),
 213                           'do_select_nb' : dial.check1.GetValue(),
 214                           'do_select_chi' : dial.check2.GetValue(),
 215                           'do_select_chi_classe' : dial.check_chic.GetValue(),
 216                           'select_nb' : dial.spin_nb.GetValue(),
 217                           'select_chi' : dial.spin_chi.GetValue(),
 218                           'nbchic' : dial.spin_nbchic.GetValue(),
 219                           'over' : dial.check3.GetValue(),
 220                           'cex_txt' : dial.check4.GetValue(),
 221                           'txt_min' : dial.spin_min.GetValue(),
 222                           'txt_max' : dial.spin_max.GetValue(),
 223                           'tchi' : dial.check_tchi.GetValue(),
 224                           'tchi_min' : dial.spin_min_tchi.GetValue(),
 225                           'tchi_max' : dial.spin_max_tchi.GetValue(),
 226                           'taillecar' : dial.spin3.GetValue(),
 227                           'facteur' : [dial.spin_f1.GetValue(),dial.spin_f2.GetValue(), dial.spin_f3.GetValue()],
 228                           'clnb' : self.clnb,
 229                           'film' : str(dial.film.GetValue()).upper(),
 230                           'alpha' : dial.slider_sphere.GetValue(),
 231                           'svg' : svg
 232                         }
 233             self.nb.parent = self.ira
 234             self.DictPathOut = self.Dict
 235             self.RscriptsPath = self.ira.RscriptsPath
 236             txt = """
 237             load("%s")
 238             """ % ffr(self.DictPathOut['RData'])
 239             if self.itempath == 'liste_graph_afcf' :
 240                 txt += """
 241                 afc <- afcf
 242                 afc_table <- afcf_table
 243                 chistabletot <- specfp
 244                 """
 245             elif self.itempath == 'liste_graph_afct' :
 246                 txt +="""
 247                 afc <- afct
 248                 afc_table <- afct_table
 249                 chistabletot <- spectp
 250                 """
 251             txt += write_afc_graph(self)
 252             filetmp = tempfile.mktemp()
 253             with open(filetmp, 'w', encoding='utf8') as f :
 254                 f.write(txt)
 255             pid = exec_rcode(self.ira.RPath, filetmp)
 256             check_Rresult(self.ira, pid)
 257             if self.param['typegraph'] != 1 :
 258                 txt = 'Variables '
 259                 if self.param['qui'] == 0 : value = 'actives'
 260                 if self.param['qui'] == 1 : value = 'supplémentaires'
 261                 if self.param['qui'] == 2 : value = 'étoilées'
 262                 if self.param['qui'] == 3 : value = 'classes'
 263                 txt += value + ' - '
 264                 if self.param['what'] == 0 : value = 'Coordonnées'
 265                 if self.param['what'] == 1 : value = 'Corrélations'
 266                 txt += value + ' - facteur %i / %i' % (self.param['facteur'][0], self.param['facteur'][1])
 267                 if self.param['do_select_nb'] : txt += ' - sélection de %i variables' % self.param['select_nb']
 268                 if self.param['do_select_chi'] : txt += ' - sélection des variables avec chi2 > %i ' % self.param['select_chi']
 269                 if self.param['over'] : txt += ' - Eviter les recouvrements'
 270                 if self.param['cex_txt'] : txt += ' - taille du texte proportionnel à la masse'
 271                 if self.param['tchi'] : txt += ' - taille du texte proportionnel au chi2 d\'association'
 272                 #list_graph = read_list_file(self.DictPathOut[self.itempath], self.coding)
 273                 if self.param['svg'] :
 274                     filename, ext = os.path.splitext(self.fileout)
 275                     self.fileout = filename + '.svg'
 276                 if self.param['typegraph'] == 2 :
 277                     parametres = {'gexffile' :  self.fileout,
 278                                   'titre': 'Le titre',
 279                                   'nodemin': self.param['txt_min'],
 280                                   'nodemax': self.param['txt_max'],
 281                                   'bargraphw' : 60*int(self.param['clnb']),
 282                     }
 283                     web = WebExport(self.ira, parametres)
 284                     self.fileout = web.exportafc()
 285                 if self.param['typegraph'] == 3 :
 286                     fileout = os.path.join(os.path.basename(self.fileout), 'index.html')
 287                 else :
 288                     fileout = os.path.basename(self.fileout)
 289                 self.list_graph.append([fileout, txt])
 290                 print_liste(self.DictPathOut[self.itempath], self.list_graph)
 291                 if self.param['svg'] or self.param['typegraph'] == 2:
 292                     self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, self.fileout, URL=self.fileout))
 293                 elif self.param['typegraph'] == 3 :
 294                     fileout = os.path.join(self.fileout,'index.html')
 295                     self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout))
 296                 else :
 297                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(self.fileout, wx.BITMAP_TYPE_ANY), name=repr(len(self.list_graph) - 1)))
 298                     self.listimg[-1].Bind(wx.EVT_RIGHT_DOWN, self.onrightclick)
 299                 self.sizer_3.Add( self.listimg[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 300                 self.labels.append(wx.StaticText(self.panel_1,-1, txt))
 301                 self.sizer_3.Add(self.labels[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 302                 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = repr(len(self.list_graph) - 1)))
 303                 self.sizer_3.Add(self.buts[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 304                 self.sizer_3.Fit(self.panel_1)
 305                 self.Layout()
 306
 307                 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
 308     #       elif self.param['typegraph'] == 2 :
 309     #           parametres = {'gexffile' :  self.fileout,
 310     #                           'titre': 'Le titre',
 311     #                           'nodemin': self.param['txt_min'],
 312     #                           'nodemax': self.param['txt_max'],
 313     #                           'bargraphw' : 60*int(self.param['clnb']),
 314     #           }
 315     #           web = WebExport(self.ira, parametres)
 316     #           afcout = web.exportafc()
 317     #           dial = SimpleDialog(self.ira)
 318     #           dial.link.SetLabel(afcout)
 319     #           dial.link.SetURL(afcout)
 320     #           dial.Layout()
 321     #           dial.ShowModal()
 322
 323
 324 class GraphPanel(wx.ScrolledWindow):
 325
 326     def __init__(self, parent, dico, list_graph, txt = '', style = wx.TAB_TRAVERSAL):
 327         wx.ScrolledWindow.__init__(self, parent, style = style)
 328         self.Dict = dico
 329         self.txt = txt
 330         self.parent = parent
 331         self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "Arial"))
 332         self.labels = []
 333         self.listimg = []
 334         self.dirout = os.path.dirname(self.Dict['ira'])
 335         self.deb = wx.StaticText(self, -1, txt)
 336         for i in range(0,len(list_graph)):
 337             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
 338                 filename, ext = os.path.splitext(list_graph[i][0])
 339                 if ext == '.svg' :
 340                     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])))
 341                 else :
 342                     self.listimg.append(wx.StaticBitmap(self, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
 343                 self.labels.append(wx.StaticText(self, -1, list_graph[i][1]))
 344         self.Bind(wx.EVT_MOTION, self.onMouseMove)
 345         self.__set_properties()
 346         self.__do_layout()
 347
 348     def __set_properties(self):
 349         self.EnableScrolling(True,True)
 350         self.SetScrollRate(20, 20)
 351         self.SetFocus()
 352
 353     def __do_layout(self):
 354         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
 355         self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
 356         self.sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
 357         self.sizer_1.Add(self.deb)
 358         for i in range(0, len(self.listimg)):
 359             self.sizer_1.Add(self.listimg[i], 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
 360             self.sizer_1.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 361         self.sizer_2.Add(self.sizer_1, 1, wx.EXPAND, 0)
 362         self.SetSizer(self.sizer_1)
 363         self.sizer_1.Fit(self)
 364
 365     def onMouseMove(self, event):
 366         self.SetFocus()
 367
 368 def open_antiprofil(panel, AntiProfile, encoding, title = _("Antiprofiles"), translation = False, lems=None) :
 369     if not translation :
 370         DictAnti = ReadProfileAsDico(AntiProfile, True, encoding)
 371     else :
 372         DictAnti = AntiProfile
 373     panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 374     for i in range(0, panel.parametres['clnb']):
 375         tabantiprofile = ProfListctrlPanel(panel.parent, panel, DictAnti[str(i + 1)], True, i + 1, translation = translation)
 376         tabantiprofile.lems = lems
 377         panel.AntiProfNB.AddPage(tabantiprofile, 'classe %s' % str(i + 1))
 378     panel.TabChdSim.AddPage(panel.AntiProfNB, title)
 379
 380 def getlemgram(corpus, lem) :
 381     if not lem[6] in corpus.lems :
 382         return lem[5]
 383     else :
 384         return corpus.lems[lem[6]].gram
 385
 386
 387 class OpenCHDS():
 388
 389     def __init__(self, parent, corpus, parametres, Alceste=False):
 390         sep=' '
 391         self.parent = parent
 392         self.corpus = corpus
 393         self.parametres = parametres
 394         self.pathout = PathOut(parametres['ira'])
 395         self.pathout.basefiles(ChdTxtPathOut)
 396         DictPathOut = self.pathout
 397         self.DictPathOut = DictPathOut
 398         self.dictpathout = DictPathOut
 399         self.Alceste = Alceste
 400         Profile = DictPathOut['PROFILE_OUT']
 401         AntiProfile = DictPathOut['ANTIPRO_OUT']
 402 #        self.encoding = self.parametres['encoding']
 403         if isinstance(self.corpus, Corpus) :
 404             self.corpus.make_ucecl_from_R(self.pathout['uce'])
 405             corpname = self.corpus.parametres['corpus_name']
 406         else :
 407             corpname = self.corpus.parametres['matrix_name']
 408             if os.path.exists(self.pathout['analyse.db']) :
 409                 self.corpus.read_tableau(self.pathout['analyse.db'])
 410         clnb = parametres['clnb']
 411         dlg = progressbar(self, maxi = 4 + clnb)
 412         self.clnb = clnb
 413         print('lecture des profils')
 414         dlg.Update(2, _("Reading profiles"))
 415         DictProfile = ReadProfileAsDico(Profile, Alceste)
 416         self.DictProfile = DictProfile
 417         self.cluster_size = []
 418         clusternames = {}
 419         for i in range(0, clnb) :
 420             clusternames[i] = ' '.join(['%i' % (i + 1), _('Cluster'),  '%i' % (i + 1)])
 421         if os.path.exists(self.pathout['classes_names.txt']) :
 422             with open(self.pathout['classes_names.txt'], 'r', encoding='utf8') as f :
 423                 clusternames_ = f.read()
 424             clusternames_ =  dict([[i, ' '.join([repr(i + 1), line])] for i, line in enumerate(clusternames_.splitlines())])
 425             clusternames.update(clusternames_)
 426         #DictAnti = ReadProfileAsDico(self, AntiProfile, Alceste, self.encoding)
 427         #
 428         # preparation de l'affichage
 429         #
 430         panel = wx.Panel(parent, -1)
 431         sizer1 = wx.BoxSizer(wx.VERTICAL)
 432         if os.path.exists(DictPathOut['pre_rapport']):
 433             with open(DictPathOut['pre_rapport'], 'r', encoding='utf8') as f :
 434                 txt = f.read()
 435             self.debtext = txt
 436         else :
 437             self.debtext = ''
 438     #   panel.chd_toolbar = wx.ToolBar(panel, -1, wx.DefaultPosition, wx.DefaultSize, wx.TB_FLAT | wx.TB_NODIVIDER)
 439     #   panel.chd_toolbar.SetToolBitmapSize(wx.Size(16, 16))
 440         if isinstance(self.corpus, Corpus) :
 441             panel.corpus = self.corpus
 442         else :
 443             panel.tableau = self.corpus
 444             #self.parent.tableau = panel.tableau
 445         panel.dictpathout = self.DictPathOut
 446         panel.pathout = self.DictPathOut
 447         panel.parent = self.parent
 448         panel.DictProfile = self.DictProfile
 449         panel.cluster_size = self.cluster_size
 450         panel.debtext = self.debtext
 451     #   self.ID_rapport = wx.NewId()
 452     #   #rap_img = wx.Image(os.path.join(self.parent.images_path,'icone_rap_16.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
 453     #   #panel.chd_toolbar.AddLabelTool(self.ID_rapport, "rapport", rap_img, shortHelp=u"Produire le rapport", longHelp=u"Exporter un rapport en texte simple")
 454     #   butrap = wx.Button(panel.chd_toolbar, self.ID_rapport, u"Rapport ")
 455     #   panel.chd_toolbar.AddControl(butrap)
 456     #   panel.chd_toolbar.Realize()
 457     #   sizer1.Add(panel.chd_toolbar,0, wx.EXPAND, 5)
 458     #    self.TabChdSim = wx.aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
 459         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
 460         panel.TabChdSim = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 461         #panel.TabChdSim = LB.LabelBook(panel, -1, agwStyle = INB_TOP|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
 462         panel.TabChdSim.SetAGWWindowStyleFlag(notebook_flags)
 463         panel.TabChdSim.SetArtProvider(aui.ChromeTabArt())
 464         sizer1.Add(panel.TabChdSim,10, wx.EXPAND, 5)
 465         panel.SetSizer(sizer1)
 466         sizer1.Fit(panel)
 467         if isinstance(self.corpus, Corpus) :
 468             panel.TabChdSim.corpus = corpus
 469             panel.TabChdSim.corpus.dictpathout = self.DictPathOut
 470         else :
 471             panel.TabChdSim.tableau = corpus
 472             panel.TabChdSim.tableau.dictpathout = self.DictPathOut
 473         panel.parametres = self.parametres
 474         self.panel = panel
 475         self.notenb = self.parent.nb.GetPageCount()
 476         if os.path.exists(self.DictPathOut['liste_graph_chd']) :
 477             list_graph = read_list_file(self.DictPathOut['liste_graph_chd'])
 478             CHD = GraphPanelDendro(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
 479             panel.TabChdSim.AddPage(CHD,'CHD')
 480     #    panel.ProfNB.SetArtProvider(aui.ChromeTabArt())
 481     #    panel.ProfNB = LB.LabelBook(panel, -1, agwStyle = INB_LEFT|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
 482     #    panel.ProfNB = wx.Listbook(self.parent, -1, style = wx.BK_DEFAULT)
 483     #    panel.ProfNB = wx.Treebook(self.parent, -1, style = wx.BK_DEFAULT)
 484     #    self.ProfNB.SetTabCtrlHeight(100)
 485     #    panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 486         if os.path.exists(DictPathOut['prof_seg']) :
 487             prof_seg = ReadProfileAsDico(DictPathOut['prof_seg'], False)
 488             self.prof_seg_nb = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 489         panel.ProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 490         notebook_flags |= aui.AUI_NB_WINDOWLIST_BUTTON
 491         panel.ProfNB.SetAGWWindowStyleFlag(notebook_flags)
 492         for i in range(0, clnb):
 493             self.cluster_size.append(DictProfile[str(i + 1)][0][0:3])
 494             if isinstance(self.corpus, Corpus) :
 495                 DictProfile[str(i + 1)][1:] = [val[0:5] + [getlemgram(self.corpus, val)] + val[6:] for val in DictProfile[str(i + 1)][1:]]
 496             dlg.Update(3+i, 'Classe %i' %(i+1))
 497             ind = '/'.join(DictProfile[str(i + 1)][0][0:2]).strip()
 498             indpour = '\n'.join([ind, DictProfile[str(i + 1)][0][2]])
 499             self.tabprofile = ProfListctrlPanel(self.parent, self.panel, DictProfile[str(i + 1)], Alceste, i + 1)
 500             #self.tabantiprofile = ProfListctrlPanel(self.parent, self, DictAnti[str(i + 1)], Alceste, i + 1)
 501             panel.ProfNB.AddPage(self.tabprofile, clusternames[i] + '\n%s%%' % indpour, True)
 502             panel.ProfNB.SetPageTextColour(i, '#890909')
 503             panel.ProfNB.SetRenamable(i, True)
 504     #       panel.AntiProfNB.AddPage(self.tabantiprofile, 'classe %s' % str(i + 1))
 505             if os.path.exists(DictPathOut['prof_seg']) :
 506                 self.tab_prof_seg = ProfListctrlPanel(self.parent, self, prof_seg[str(i + 1)], False, i + 1)
 507                 self.prof_seg_nb.AddPage(self.tab_prof_seg, _("Cluster") + ' %i' % (i + 1))
 508         panel.ProfNB.SetSelection(0)
 509         if clnb > 2 :
 510             self.TabAFC = aui.AuiNotebook(panel.TabChdSim, -1, wx.DefaultPosition)
 511             log.info('read AFC')
 512             list_graph=read_list_file(DictPathOut['liste_graph_afc'])
 513             self.tabAFCGraph = GraphPanelAfc(self.TabAFC, DictPathOut, list_graph, self.clnb)
 514             self.TabAFC.AddPage(self.tabAFCGraph, _("CA"))
 515             if os.path.exists(self.DictPathOut['afc_facteur']) :
 516                 dictrow, first = ReadList(self.DictPathOut['afc_facteur'])
 517                 self.TabAFC_facteur = ListForSpec(self.parent, parametres, dictrow, first[1:])
 518     #           dictrow, first = ReadList(self.DictPathOut['afc_row'], self.encoding)
 519     #           self.TabAFC_ligne = ListForSpec(self.parent, self.parametres, dictrow, first)
 520     #           dictrow, first = ReadList(self.DictPathOut['afc_col'], self.encoding)
 521     #           self.TabAFC_colonne = ListForSpec(parent, self.parametres, dictrow, first)
 522                 self.TabAFC.AddPage(self.TabAFC_facteur, _("Factor"))
 523     #           self.TabAFC.AddPage(self.TabAFC_colonne, 'Colonnes')
 524     #           self.TabAFC.AddPage(self.TabAFC_ligne, 'Lignes')
 525             sizer_3 = wx.BoxSizer(wx.VERTICAL)
 526             self.parent.nb_panel_2 = wx.Panel(panel.TabChdSim, -1)
 527             self.parent.button_simi = wx.Button(self.parent.nb_panel_2, -1, "Voyager")
 528             self.parent.simi3dpanel = simi3d(self.parent.nb_panel_2, -1)
 529             sizer_3.Add(self.parent.simi3dpanel, 1, wx.EXPAND, 0)
 530             sizer_3.Add(self.parent.button_simi, 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 531             self.parent.nb_panel_2.SetSizer(sizer_3)
 532             self.TabAFC.AddPage(self.parent.nb_panel_2, _("3D graph"))
 533             self.parent.Bind(wx.EVT_BUTTON, self.onsimi, self.parent.button_simi)
 534         panel.TabChdSim.AddPage(panel.ProfNB, _("Profiles"))
 535     #   panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')
 536         dlg.Update(4 + self.clnb, 'Affichage...')
 537         if clnb > 2 :
 538             panel.TabChdSim.AddPage(self.TabAFC, _("CA"))
 539         if os.path.exists(DictPathOut['prof_seg']) :
 540             panel.TabChdSim.AddPage(self.prof_seg_nb, _("Repeated segments profiles"))
 541     #   panel.Bind(wx.EVT_BUTTON, self.ongetrapport, id = self.ID_rapport)
 542         if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenchi2.csv')) :
 543             self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenchi2.csv')
 544             TgenLayout(panel)
 545         if os.path.exists(self.dictpathout['translations.txt']) :
 546             with open(self.dictpathout['translations.txt'], 'r', encoding='utf8') as f:
 547                 translist = f.read()
 548             translist = [line.split('\t') for line in translist.splitlines()]
 549             for line in translist :
 550                 self.opentrans(line)
 551         panel.TabChdSim.SetSelection(0)
 552         self.parent.nb.AddPage(panel, _("Clustering") + ' - %s' % corpname)
 553         self.parent.ShowTab(True)
 554         self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
 555     #   for pane in self.parent._mgr.GetAllPanes() :
 556     #       if isinstance(pane.window, aui.AuiNotebook):
 557     #           nb = pane.window
 558     #           nb.SetAGWWindowStyleFlag(notebook_flags)
 559     #           nb.SetArtProvider(aui.ChromeTabArt())
 560         dlg.Destroy()
 561         self.parent._mgr.Update()
 562
 563     def opentrans(self, trans) :
 564         prof = ReadProfileAsDico(self.dictpathout[trans[0]], False)
 565         with open(self.dictpathout[trans[1]], 'r', encoding='utf8') as f :
 566             lems = f.read()
 567         lems = [line.split('\t') for line in lems.splitlines()]
 568         lems = dict(lems)
 569         open_antiprofil(self.panel, prof, 'utf8', title = trans[0], translation=True, lems=lems)
 570         self.panel.lems = lems
 571         self.panel.TabChdSim.SetSelection(self.panel.TabChdSim.GetPageCount() - 1)
 572
 573     def onsimi(self,event):
 574         outfile = print_simi3d(self)
 575         error = exec_rcode(self.parent.RPath, outfile, wait = True)
 576
 577     def onclusterstat(self, evt) :
 578         dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': 'Stat par classe'})
 579         dial.fbb.SetValue( os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'stat_par_classe.csv'))
 580         dial.CenterOnParent()
 581         res = dial.ShowModal()
 582         if res == wx.ID_OK :
 583             fileout = dial.fbb.GetValue()
 584             dial.Destroy()
 585             self.corpus.get_stat_by_cluster(fileout)
 586             msg = "Fini !"
 587             dlg = wx.MessageDialog(self.parent, msg, _("Stat by cluster"), wx.OK | wx.ICON_INFORMATION)
 588             dlg.CenterOnParent()
 589             if dlg.ShowModal() == wx.ID_OK :
 590                 dlg.Destroy()
 591
 592     #def onsearchf(self, evt) :
 593     #    if 'FrameSearch' not in dir(self.panel) :
 594     #        self.panel.FrameSearch = SearchFrame(self.parent, -1, "Rechercher...", self.corpus)
 595     #    self.panel.FrameSearch.Show()
 596
 597 def PrintRapport(self, corpus, parametres, istxt = True):
 598     sep = '\n'
 599     txt = """
 600 +-+-+-+-+-+-+-+-+
 601 |i|R|a|M|u|T|e|Q| - %s
 602 +-+-+-+-+-+-+-+-+
 603
 604
 605 """ % datetime.datetime.now().ctime()
 606     if istxt :
 607         totocc = corpus.gettotocc()
 608         txt += ': '.join([_('Number of texts'),  '%i%s' % (corpus.getucinb(), sep)])
 609         txt += ': '.join([_('Number of text segments'),  '%i%s' % (corpus.getucenb(), sep)])
 610         txt += ': '.join([_('Number of forms'), '%i%s' % (len(corpus.formes), sep)])
 611         txt += ': '.join([_('Number of occurrences'), '%i%s' % (totocc, sep)])
 612         #txt += 'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
 613         txt += ': '.join([_('Number of lemmas'), '%i%s' % (len(corpus.lems), sep)])
 614         txt += ': '.join([_('Number of active forms'), '%i%s' % (corpus.getactivesnb(1), sep)])
 615         txt += ': '.join([_('Number of supplementary forms'), '%i%s' % (corpus.getactivesnb(2), sep)])
 616         txt += ' >= '.join([_('Number of active forms with a frequency'), '%i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)])
 617         txt += ': '.join([_('Mean of forms by segment'), '%f%s' % (float(totocc) / float(corpus.getucenb()), sep)])
 618         if 'tailleuc1' in parametres :
 619             if parametres['classif_mode'] == 0 :
 620                 txt += ': '.join([_('Size of rst1 / rst2'), '%i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)])
 621     else :
 622         self.Ucenb = self.nbind
 623         txt += ': '.join([_('Number of lines'), '%i%s' % (self.nbind, sep)])
 624         txt += ': '.join([_('Number of clusters'), '%i%s' % (self.clnb, sep)])
 625     if istxt :
 626         txt += ': '.join([_('Number of clusters'), '%i%s' % (parametres['clnb'], sep)])
 627         if parametres['classif_mode'] == 0 or parametres['classif_mode'] == 1 :
 628             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)])
 629         elif self.parametres['classif_mode'] == 2 :
 630             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)])
 631     else :
 632         txt += ' '.join(['%i' % self.ucecla, _('line classified on'), '%i (%.2f%%)%s' % (self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)])
 633
 634     txt += ''.join([sep, '###########################', sep, _('time'), ' : %s' % parametres.get('time', ''), sep, '###########################', sep])
 635     # ecriture du resultat dans le fichier
 636     with open(self.pathout['pre_rapport'], 'w', encoding='utf8') as f :
 637         f.write(txt)
 638
 639
 640 class SashList(wx.Panel) :
 641
 642     def __init__(self, parent) :
 643         wx.Panel.__init__(self, parent, -1)
 644         self.parent=parent
 645         winids = []
 646         #self.gparent=gparent
 647         #self.dlist=dlist
 648         #self.first = first
 649         #self.menu = menu
 650         # A window to the left of the client window
 651         #self.listlex = listlex
 652         self.leftwin1 =  wx.SashLayoutWindow(
 653                 self, -1, wx.DefaultPosition, (200, 300),
 654                 wx.NO_BORDER|wx.SW_3D
 655                 )
 656         self.leftwin1.SetDefaultSize((120, 1000))
 657         self.leftwin1.SetOrientation(wx.LAYOUT_VERTICAL)
 658         self.leftwin1.SetAlignment(wx.LAYOUT_LEFT)
 659         self.leftwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
 660         self.leftwin1.SetSashVisible(wx.SASH_RIGHT, True)
 661         self.leftwin1.SetExtraBorderSize(10)
 662         #textWindow = wx.TextCtrl(
 663         #                leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
 664         #                wx.TE_MULTILINE|wx.SUNKEN_BORDER
 665         #                )
 666         #textWindow.SetValue("A sub window")
 667         self.leftWindow1 = self.leftwin1
 668         winids.append(self.leftwin1.GetId())
 669         rightwin1 =  wx.SashLayoutWindow(
 670                 self, -1, wx.DefaultPosition, (200, 300),
 671                 wx.NO_BORDER|wx.SW_3D
 672                 )
 673         rightwin1.SetDefaultSize((120, 1000))
 674         rightwin1.SetOrientation(wx.LAYOUT_VERTICAL)
 675         rightwin1.SetAlignment(wx.LAYOUT_LEFT)
 676         rightwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
 677         rightwin1.SetSashVisible(wx.SASH_RIGHT, True)
 678         rightwin1.SetExtraBorderSize(10)
 679         #textWindow = wx.TextCtrl(
 680         #                leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
 681         #                wx.TE_MULTILINE|wx.SUNKEN_BORDER
 682         #                )
 683         #textWindow.SetValue("A sub window")
 684         self.rightwin1 = rightwin1
 685         winids.append(rightwin1.GetId())
 686
 687
 688 class TgenLayout :
 689
 690     def __init__(self, page):
 691         self.page = page
 692         parametres = self.page.parametres
 693         ira = wx.GetApp().GetTopWindow()
 694         tgenpath = os.path.join(parametres['pathout'], 'tgen.csv')
 695         self.page.tgens, etoiles =  ReadList(parametres['tgenspec'], ira.syscoding, sep="\t")
 696         tgen = TGen(path = tgenpath, encoding = 'UTF-8')
 697         tgen.read()
 698         tgenlempath = os.path.join(parametres['pathout'], 'tgenlemchi2.csv')
 699         if os.path.exists(tgenlempath) :
 700             self.page.parametres['tgenlemspec'] = tgenlempath
 701             self.page.tgenlem, etoiles = ReadList(self.page.parametres['tgenlemspec'], ira.syscoding, sep="\t")
 702         tgentab = False
 703         gparent = None
 704         if 'TabChdSim' in dir(page) :
 705             page = page.TabChdSim
 706         for i in range(page.GetPageCount()) :
 707             tab = page.GetPage(i)
 708             if 'gparent' in dir(tab) :
 709                 if tab.gparent is not None :
 710                     gparent = tab.gparent
 711             if 'tgen' in dir(tab) :
 712                 if tab.tgen :
 713                     tgentab = tab
 714                     break
 715         if tgentab :
 716             self.page.tgentab.RefreshData(self.page.tgens)
 717             self.page.tgentab.tgens = tgen.tgen
 718             self.page.tgentab.tgenlem = self.page.tgenlem
 719             page.SetSelection(i)
 720         else :
 721             self.page.tgentab = ListForSpec(ira, gparent, self.page.tgens, etoiles[1:])
 722             self.page.tgentab.tgen = True
 723             self.page.tgentab.tgens = tgen.tgen
 724             if os.path.exists(tgenlempath) :
 725                 self.page.tgentab.tgenlem = self.page.tgenlem
 726             page.AddPage(self.page.tgentab, _('Tgens Specificities'))
 727             page.SetSelection(page.GetPageCount() - 1)
 728
 729
 730 class dolexlayout :
 731
 732     def __init__(self, ira, corpus, parametres):
 733         self.pathout = PathOut(dirout = parametres['pathout'])
 734         self.corpus = corpus
 735         self.dictpathout = StatTxtPathOut(parametres['pathout'])
 736         #self.corpus.read_corpus_from_shelves(self.corpus.dictpathout['db'])
 737         self.parent = ira
 738         self.corpus.parametres['syscoding'] = 'UTF8'
 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 open(self.pathout[lcle[key]], 'r', encoding='utf-8') 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', encoding='utf-8') 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', encoding='utf8') 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', 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
1402 class SimiMatLayout(DefaultMatLayout) :
1403
1404     def dolayout(self):
1405         self.pathout.basefiles(simipath)
1406         self.indices = indices_simi
1407         if os.path.exists(self.pathout['liste_graph']) :
1408             list_graph = read_list_file(self.pathout['liste_graph'])
1409         else :
1410             list_graph = [['','']]
1411         notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1412         self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1413         self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1414         self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1415         self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1416         self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1417         self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1418         self.graphpan.Bind(wx.EVT_BUTTON, self.blender, self.graphpan.butblender)
1419         self.tabsimi.AddPage(self.graphpan, _('Graph'))
1420         self.tabsimi.parametres = self.parametres
1421         self.parent.nb.AddPage(self.tabsimi, ' - '.join([_('Graph analysis'), self.parametres['name']]))
1422         #self.parent.ShowTab(True)
1423         #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1424
1425     def redosimi(self,evt) :
1426         with open(self.pathout['selected.csv'],'r', encoding='utf8') as f :
1427             selected = f.read()
1428         selected = [int(val) for val in selected.splitlines()]
1429         #if self.actives is None :
1430         #    with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1431         #        self.actives = f.read()
1432         #    self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1433         try :
1434             actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1435         except :
1436             actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1437         #self.tableau.make_listactives()
1438         actives = dict([[i, val] for i, val in enumerate(actives)])
1439         print(actives)
1440         #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1441         self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1442         self.dial.CenterOnParent()
1443         self.val = self.dial.ShowModal()
1444         if self.val == wx.ID_OK :
1445             last = self.dial.listcol.GetFirstSelected()
1446             lastl = [self.dial.listcol.GetFirstSelected()]
1447             indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1448             while self.dial.listcol.GetNextSelected(last) != -1:
1449                 last = self.dial.listcol.GetNextSelected(last)
1450                 lastl.append(last)
1451                 indexes.append(self.dial.listcol.getColumnText(last,0))
1452             self.column = [self.tableau.listactives.index(val) for val in indexes]
1453             self.column.sort()
1454             with open(self.pathout['selected.csv'], 'w', encoding='utf8') as f :
1455                 f.write('\n'.join([repr(val) for val in self.column]))
1456             self.make_param()
1457             self.dial.Destroy()
1458             self.script = PrintSimiScript(self)
1459             self.script.make_script()
1460             self.tmpfile = self.script.scriptout
1461             dlg = progressbar(self, maxi = 2)
1462             self.DoR(dlg)
1463             dlg.Destroy()
1464             if self.parametres['type_graph'] == 1:
1465                 if self.parametres['svg'] :
1466                     filename, ext = os.path.splitext(self.script.filename)
1467                     fileout = filename + '.svg'
1468                 else :
1469                     fileout = self.script.filename
1470                 fileout = normpath_win32(fileout)
1471                 if os.path.exists(self.pathout['liste_graph']):
1472                     graph_simi = read_list_file(self.pathout['liste_graph'])
1473                     graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1474                 else :
1475                     graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1476                 print_liste(self.pathout['liste_graph'], graph_simi)
1477             DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1478             if self.parametres['type_graph'] == 1:
1479                 if self.parametres['svg'] :
1480                     self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1481                 else :
1482                     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)
1483                 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1484                 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1485                 self.graphpan.Layout()
1486                 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1487         else :
1488             self.dial.Destroy()
1489
1490     def make_param(self) :
1491         if self.parametres['first'] :
1492             keep_coord = False
1493         else :
1494             keep_coord = self.dial.check_coord.GetValue()
1495         #self.select = self.dial.check_colch.GetValue()
1496         paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1497                           'layout' : self.dial.choice2.GetSelection(),
1498                           'type_graph' : self.dial.choice3.GetSelection(),
1499                           'arbremax' : self.dial.check1.GetValue(),
1500                           'coeff_tv' : self.dial.check_s_size.GetValue(),
1501                           'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1502                           'tvprop' : self.dial.check2.GetValue(),
1503                           'tvmin' : self.dial.spin_tvmin.GetValue(),
1504                           'tvmax' : self.dial.spin_tvmax.GetValue(),
1505                           'coeff_te' : self.dial.check3.GetValue(),
1506                           'coeff_temin' : self.dial.spin_temin.GetValue(),
1507                           'coeff_temax' : self.dial.spin_temax.GetValue(),
1508                           'label_e' : self.dial.check_elab.GetValue(),
1509                           'label_v' : self.dial.check_vlab.GetValue(),
1510                           'vcex' : self.dial.check_vcex.GetValue(),
1511                           'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1512                           'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1513                           'cex' : self.dial.spin_cex.GetValue(),
1514                           'seuil_ok' : self.dial.check_seuil.GetValue(),
1515                           'seuil' : self.dial.spin_seuil.GetValue(),
1516                           'cols' : self.dial.cols.GetColour(),
1517                           'cola' : self.dial.cola.GetColour(),
1518                           'width' : self.dial.spin_width.GetValue(),
1519                           'height' : self.dial.spin_height.GetValue(),
1520                           'first' : False,
1521                           'keep_coord' : keep_coord,
1522                           'alpha' : self.dial.slider_sphere.GetValue(),
1523                           'film' : self.dial.film.GetValue(),
1524                           'svg' : self.dial.choix_format.GetSelection(),
1525                           'halo' : self.dial.halo.GetValue(),
1526                           'com' : self.dial.comcheck.GetValue(),
1527                           'communities' : self.dial.choix_com.GetSelection(),
1528                           'edgecurved' : self.dial.check_curved.GetValue(),
1529                           }
1530         if 'cexfromchi' in self.parametres :
1531             paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1532         if 'sfromchi' in self.parametres :
1533             paramsimi['sfromchi'] = self.dial.checki.GetValue()
1534         if 'vlabcolor' in self.parametres :
1535             paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1536         if 'check_bystar' in dir(self.dial) :
1537             paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1538             paramsimi['stars'] = self.parametres['stars']
1539         self.parametres.update(paramsimi)
1540
1541     def DoR(self, dlg):
1542         if self.parametres['type_graph'] == 1 :
1543             graph = False
1544             wait = False
1545         else :
1546             graph = True
1547             wait = True
1548         pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1549         if self.parametres['type_graph'] == 1 :
1550             while pid.poll() == None :
1551                 dlg.Pulse('R ...')
1552                 sleep(0.2)
1553             check_Rresult(self.parent, pid)
1554
1555     def export(self, evt) :
1556         nb = 1
1557         while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1558             nb +=1
1559         fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1560         txt = """
1561         library(igraph)
1562         load("%s")
1563         source("%s")
1564         fileout <- "%s"
1565         graph <- graph.simi$graph
1566         V(graph)$x <- graph.simi$layout[,1]
1567         V(graph)$y <- graph.simi$layout[,2]
1568         if (length(graph.simi$label.cex == 1)) {
1569             V(graph)$weight <- graph.simi$mat.eff
1570         } else {
1571             V(graph)$weight <- graph.simi$label.cex
1572         }
1573         V(graph)$color <- vertex.label.color
1574         V(graph)$frequences <- graph.simi$mat.eff
1575         V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
1576         V(graph)$label <- as.character(graph.simi$v.label)
1577         E(graph)$weight <- graph.simi$we.width
1578         write.graph(graph, fileout, format = 'graphml')
1579         #saveAsGEXF(graph, filepath = fileout)
1580         """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['simi']), fileout)
1581         filetmp = tempfile.mktemp()
1582         with open(filetmp, 'w', encoding='utf8') as f :
1583             f.write(txt)
1584         exec_rcode(self.ira.RPath, filetmp)
1585         mss = wx.MessageDialog(self.ira, fileout, _('File exported'), wx.OK)
1586         mss.CenterOnParent()
1587         mss.ShowModal()
1588         mss.Destroy()
1589
1590     def blender(self, evt):
1591         blender(self)
1592
1593
1594 class GraphPanelSimi(wx.Panel):
1595
1596     def __init__(self,parent, dico, list_graph):
1597         wx.Panel.__init__(self,parent)
1598         self.afcnb = 1
1599         self.Dict = dico
1600         self.dirout = os.path.dirname(self.Dict['ira'])
1601         self.parent = self.GetParent()
1602         self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "courier")) #modifié
1603         self.labels = []
1604         self.listimg = []
1605         self.tabsimi = self.parent.GetParent()
1606         self.ira = self.tabsimi.GetParent()
1607         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1608         afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1609         self.butafc = wx.BitmapButton(self, -1, afc_img)
1610         export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1611         self.butexport = wx.BitmapButton(self, -1, export_img)
1612         blender_img = wx.Image(os.path.join(self.ira.images_path,'button_blender.png'), wx.BITMAP_TYPE_ANY)
1613         blender_img.Rescale(32,32)
1614         blender_img = blender_img.ConvertToBitmap()
1615         self.butblender = wx.BitmapButton(self, -1, blender_img)
1616         for i in range(0,len(list_graph)):
1617             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1618                 filename, ext = os.path.splitext(list_graph[i][0])
1619                 if ext in ['.svg', '.html'] :
1620                     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])))
1621                 else :
1622                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1623                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1624         self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove)
1625         self.__set_properties()
1626         self.__do_layout()
1627
1628     def __set_properties(self):
1629         self.panel_1.EnableScrolling(True,True)
1630         #self.panel_1.SetSize((1000,1000))
1631         self.panel_1.SetScrollRate(20, 20)
1632         self.panel_1.SetFocus()
1633
1634     def __do_layout(self):
1635         self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1636         self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1637         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1638         self.sizer_2.Add(self.butafc, 0, 0, 0)
1639         self.sizer_2.Add(self.butexport, 0, 0, 0)
1640         self.sizer_2.Add(self.butblender, 0, 0, 0)
1641         for i in range(0, len(self.listimg)):
1642             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1643             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1644         self.panel_1.SetSizer(self.sizer_3)
1645         self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1646         self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1647         self.SetSizer(self.sizer_1)
1648
1649     def onMouseMove(self, event):
1650         self.panel_1.SetFocus()
1651