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

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