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 #Lisense: GNU/GPL
   6
   7 import os
   8 import wx
   9 import wx.lib.hyperlink as hl
  10 if wx.__version__ >= '2.11' :
  11     import wx.lib.agw.aui as aui
  12 else :
  13     import aui
  14 from chemins import ConstructPathOut, ChdTxtPathOut, FFF, ffr, PathOut, StatTxtPathOut, simipath
  15 from ConfigParser import ConfigParser
  16 from functions import ReadProfileAsDico, GetTxtProfile, read_list_file, ReadList, exec_rcode, print_liste, BugReport, DoConf, indices_simi, check_Rresult, progressbar
  17 from ProfList import ProfListctrlPanel
  18 from guiparam3d import param3d, simi3d
  19 from PrintRScript import write_afc_graph, print_simi3d, PrintSimiScript
  20 from profile_segment import ProfileSegment
  21 from functions import ReadList
  22 from listlex import *
  23 from Liste import *
  24 from search_tools import SearchFrame
  25 from dialog import PrefGraph, PrefExport, PrefSimpleFile, PrefDendro
  26 from guifunct import SelectColumn, PrepSimi, PrefSimi
  27 from corpus import Corpus
  28 import datetime
  29 import sys
  30 import tempfile
  31 from time import sleep
  32 import shutil
  33 import codecs
  34 import logging
  35
  36 log = logging.getLogger('iramuteq.layout')
  37
  38
  39 class GraphPanelAfc(wx.Panel):
  40     def __init__(self, parent, dico, list_graph, clnb, itempath = 'liste_graph_afc', coding = sys.getdefaultencoding()):
  41         wx.Panel.__init__(self,parent)
  42         self.afcnb = 1
  43         self.clnb = clnb
  44         self.Dict = dico
  45         self.coding = coding
  46         self.itempath = itempath
  47         self.parent = self.GetParent()#parent
  48         self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
  49         self.labels = []
  50         self.listimg = []
  51         self.buts = []
  52         self.list_graph = list_graph
  53         self.TabCHD = self.parent.GetParent()
  54         self.nb = self.TabCHD.GetParent()
  55         self.ira = self.nb.GetParent()
  56         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
  57         afc_img = wx.Image(os.path.join(self.ira.images_path,'button_afc.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
  58         self.butafc = wx.BitmapButton(self, -1, afc_img)
  59         self.Bind(wx.EVT_BUTTON, self.afc_graph, self.butafc)
  60         self.dirout = os.path.dirname(self.Dict['ira'])
  61         b = 0
  62         todel = []
  63         for i in range(0,len(list_graph)):
  64             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
  65                 filename, ext = os.path.splitext(list_graph[i][0])
  66                 if ext == '.svg' :
  67                     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])))
  68                 else :
  69                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
  70                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
  71                 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = `i - b`))
  72             else :
  73                 todel.append(i)
  74                 b += 1
  75         self.list_graph = [graph for i, graph in enumerate(self.list_graph) if i not in todel]
  76
  77         self.param = { 'typegraph' : 0,
  78               'width' : 800,
  79               'height' : 800,
  80               'what' : 0,
  81               'qui' : 0,
  82               'do_select_nb' : 0,
  83               'do_select_chi' : 0,
  84               'do_select_chi_classe' : 0,
  85               'select_nb' : 50,
  86               'select_chi' : 4,
  87               'nbchic' : 30,
  88               'over' : 0,
  89               'cex_txt' : 0,
  90               'txt_min' : 5,
  91               'txt_max' : 40,
  92               'tchi' : 0,
  93               'tchi_min' : 5,
  94               'tchi_max' : 40,
  95               'taillecar' : 9,
  96               'facteur' : [1,2,3],
  97               'alpha' : 10,
  98               'clnb' : clnb,
  99               'svg' : 0,
 100             }
 101
 102         self.__set_properties()
 103         self.__do_layout()
 104
 105     def __set_properties(self):
 106         self.panel_1.EnableScrolling(True,True)
 107         #self.panel_1.SetSize((1000,1000))
 108         self.panel_1.SetScrollRate(20, 20)
 109
 110     def __do_layout(self):
 111         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
 112         self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
 113         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
 114         self.sizer_2.Add(self.butafc, 0, 0, 0)
 115         for i in range(0, len(self.listimg)):
 116             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 117             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 118             self.sizer_3.Add(self.buts[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 119             self.Bind(wx.EVT_BUTTON, self.on_delete_image, self.buts[i])
 120         self.panel_1.SetSizer(self.sizer_3)
 121         self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
 122         self.SetSizer(self.sizer_2)
 123
 124     def on_delete_image(self, event) :
 125         image_id = int(event.GetEventObject().GetName())
 126         image_path = self.list_graph[image_id][0]
 127         message = 'This file will be delete : %s.\nAre you sure ?' % os.path.join(self.dirout, image_path)
 128         dial = wx.MessageDialog(self, message, style = wx.YES_NO)
 129         res = dial.ShowModal()
 130         if res == wx.ID_YES :
 131             dial.Destroy()
 132             log.info('delete image %i' % image_id)
 133             oldimg = self.listimg.pop(image_id)
 134             oldimg.Destroy()
 135             oldlab = self.labels.pop(image_id)
 136             oldlab.Destroy()
 137             oldbut = self.buts.pop(image_id)
 138             oldbut.Show(False)
 139             for i, but in enumerate(self.buts) :
 140                 but.SetName(`i`)
 141             todel = self.list_graph.pop(image_id)
 142             os.remove(os.path.join(self.dirout, todel[0]))
 143             print_liste(self.Dict[self.itempath], self.list_graph)
 144             self.sizer_3.Fit(self.panel_1)
 145             self.Layout()
 146         else :
 147             dial.Destroy()
 148
 149
 150     def afc_graph(self,event):
 151         #dirout = os.path.dirname(self.Dict['ira'])
 152         while os.path.exists(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+'.png')):
 153             self.afcnb +=1
 154         self.fileout = ffr(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+'.png'))
 155         dial = PrefGraph(self.parent,-1,self.param,'')
 156         dial.CenterOnParent()
 157         val = dial.ShowModal()
 158         if val == wx.ID_OK :
 159             if dial.choix_format.GetSelection() == 0 :
 160                 svg = 0
 161             else :
 162                 svg = 1
 163             self.param = {'typegraph' : dial.choicetype.GetSelection(),
 164                           'width' : dial.spin1.GetValue(),
 165                           'height' : dial.spin2.GetValue(),
 166                           'what' : dial.choice1.GetSelection(),
 167                           'qui' : dial.choice2.GetSelection(),
 168                           'do_select_nb' : dial.check1.GetValue(),
 169                           'do_select_chi' : dial.check2.GetValue(),
 170                           'do_select_chi_classe' : dial.check_chic.GetValue(),
 171                           'select_nb' : dial.spin_nb.GetValue(),
 172                           'select_chi' : dial.spin_chi.GetValue(),
 173                           'nbchic' : dial.spin_nbchic.GetValue(),
 174                           'over' : dial.check3.GetValue(),
 175                           'cex_txt' : dial.check4.GetValue(),
 176                           'txt_min' : dial.spin_min.GetValue(),
 177                           'txt_max' : dial.spin_max.GetValue(),
 178                           'tchi' : dial.check_tchi.GetValue(),
 179                           'tchi_min' : dial.spin_min_tchi.GetValue(),
 180                           'tchi_max' : dial.spin_max_tchi.GetValue(),
 181                           'taillecar' : dial.spin3.GetValue(),
 182                           'facteur' : [dial.spin_f1.GetValue(),dial.spin_f2.GetValue(), dial.spin_f3.GetValue()],
 183                           'clnb' : self.clnb,
 184                           'film' : str(dial.film.GetValue()).upper(),
 185                           'alpha' : dial.slider_sphere.GetValue(),
 186                           'svg' : svg
 187                         }
 188             self.nb.parent = self.ira
 189             self.DictPathOut = self.Dict
 190             self.RscriptsPath = self.ira.RscriptsPath
 191             txt = """
 192             load("%s")
 193             """ % self.DictPathOut['RData']
 194             if self.itempath == 'liste_graph_afcf' :
 195                 txt += """
 196                 afc <- afcf
 197                 afc_table <- afcf_table
 198                 chistabletot <- specfp
 199                 """
 200             elif self.itempath == 'liste_graph_afct' :
 201                 txt +="""
 202                 afc <- afct
 203                 afc_table <- afct_table
 204                 chistabletot <- spectp
 205                 """
 206             txt += write_afc_graph(self)
 207             filetmp = tempfile.mktemp()
 208             with open(filetmp, 'w') as f :
 209                 f.write(txt)
 210             pid = exec_rcode(self.ira.RPath, filetmp)
 211             check_Rresult(self.ira, pid)
 212             if self.param['typegraph'] == 0 :
 213                 txt = 'Variables '
 214                 if self.param['qui'] == 0 : value = u'actives'
 215                 if self.param['qui'] == 1 : value = u'supplémentaires'
 216                 if self.param['qui'] == 2 : value = u'étoilées'
 217                 if self.param['qui'] == 3 : value = u'classes'
 218                 txt += value + ' - '
 219                 if self.param['what'] == 0 : value = u'Coordonnées'
 220                 if self.param['what'] == 1 : value = u'Corrélations'
 221                 txt += value + u' - facteur %i / %i' % (self.param['facteur'][0], self.param['facteur'][1])
 222                 if self.param['do_select_nb'] : txt += u' - sélection de %i variables' % self.param['select_nb']
 223                 if self.param['do_select_chi'] : txt += u' - sélection des variables avec chi2 > %i ' % self.param['select_chi']
 224                 if self.param['over'] : txt += u' - Eviter les recouvrements'
 225                 if self.param['cex_txt'] : txt += u' - taille du texte proportionnel à la masse'
 226                 if self.param['tchi'] : txt += u' - taille du texte proportionnel au chi2 d\'association'
 227                 #list_graph = read_list_file(self.DictPathOut[self.itempath], self.coding)
 228                 if self.param['svg'] :
 229                     filename, ext = os.path.splitext(self.fileout)
 230                     self.fileout = filename + '.svg'
 231                 self.list_graph.append([os.path.basename(self.fileout), txt])
 232                 print_liste(self.DictPathOut[self.itempath], self.list_graph)
 233                 if not self.param['svg'] :
 234                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(self.fileout, wx.BITMAP_TYPE_ANY)))
 235                 else :
 236                     self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, self.fileout, URL=self.fileout))
 237                 self.sizer_3.Add( self.listimg[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 238                 self.labels.append(wx.StaticText(self.panel_1,-1, txt))
 239                 self.sizer_3.Add(self.labels[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 240                 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = `len(self.list_graph) - 1`))
 241                 self.sizer_3.Add(self.buts[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 242                 self.sizer_3.Fit(self.panel_1)
 243                 self.Layout()
 244
 245                 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
 246
 247
 248 class GraphPanel(wx.ScrolledWindow):
 249     def __init__(self, parent, dico, list_graph, txt = '', style = wx.TAB_TRAVERSAL):
 250         wx.ScrolledWindow.__init__(self, parent, style = style)
 251         self.Dict = dico
 252         self.txt = txt
 253         self.parent = parent
 254         self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
 255         self.labels = []
 256         self.listimg = []
 257         self.dirout = os.path.dirname(self.Dict['ira'])
 258         self.deb = wx.StaticText(self, -1, txt)
 259         for i in range(0,len(list_graph)):
 260             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
 261                 self.listimg.append(wx.StaticBitmap(self, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
 262                 self.labels.append(wx.StaticText(self, -1, list_graph[i][1]))
 263
 264         self.__set_properties()
 265         self.__do_layout()
 266
 267     def __set_properties(self):
 268         self.SetScrollRate(20, 20)
 269
 270     def __do_layout(self):
 271         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
 272         self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
 273         self.sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
 274         self.sizer_1.Add(self.deb)
 275         for i in range(0, len(self.listimg)):
 276             self.sizer_1.Add(self.listimg[i], 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
 277             self.sizer_1.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 278         self.sizer_2.Add(self.sizer_1, 1, wx.EXPAND, 0)
 279         self.SetSizer(self.sizer_1)
 280         self.sizer_1.Fit(self)
 281
 282
 283 def open_antiprofil(panel, AntiProfile, encoding) :
 284     DictAnti = ReadProfileAsDico(AntiProfile, True, encoding)
 285     panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 286     for i in range(0, panel.parametres['clnb']):
 287         tabantiprofile = ProfListctrlPanel(panel, panel, DictAnti[str(i + 1)], True, i + 1)
 288         panel.AntiProfNB.AddPage(tabantiprofile, 'classe %s' % str(i + 1))
 289     panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')
 290
 291
 292
 293 class OpenCHDS():
 294     def __init__(self, parent, corpus, parametres, Alceste=False):
 295        #sep = u'\n '
 296        sep=' '
 297        self.parent = parent
 298        self.corpus = corpus
 299        self.parametres = parametres
 300        self.pathout = PathOut(parametres['ira'])
 301        self.pathout.basefiles(ChdTxtPathOut)
 302        DictPathOut = self.pathout
 303        self.DictPathOut = DictPathOut
 304        self.dictpathout = DictPathOut
 305        self.parent = parent
 306
 307        Profile = DictPathOut['PROFILE_OUT']
 308        AntiProfile = DictPathOut['ANTIPRO_OUT']
 309        self.encoding = self.corpus.parametres['syscoding']
 310        if isinstance(self.corpus, Corpus) :
 311             self.corpus.make_ucecl_from_R(self.pathout['uce'])
 312             corpname = self.corpus.parametres['corpus_name']
 313        else :
 314            corpname = self.corpus.parametres['name']
 315
 316        clnb = parametres['clnb']
 317        dlg = progressbar(self, maxi = 4 + clnb)
 318        self.clnb = clnb
 319        print 'lecture des profils'
 320        dlg.Update(2, u'lecture des profils')
 321
 322        DictProfile = ReadProfileAsDico(Profile, Alceste, self.encoding)
 323        self.DictProfile = DictProfile
 324        self.cluster_size = []
 325        #print 'lecture des antiprofils'
 326        #DictAnti = ReadProfileAsDico(self, AntiProfile, Alceste, self.encoding)
 327
 328        panel = wx.Panel(parent, -1)
 329        sizer1 = wx.BoxSizer(wx.VERTICAL)
 330
 331        if os.path.exists(DictPathOut['pre_rapport']):
 332            with codecs.open(DictPathOut['pre_rapport'], 'r', self.encoding) as f :
 333                 txt = f.read()
 334            self.debtext = txt
 335        else :
 336            self.debtext = ''
 337 #       panel.chd_toolbar = wx.ToolBar(panel, -1, wx.DefaultPosition, wx.DefaultSize, wx.TB_FLAT | wx.TB_NODIVIDER)
 338 #       panel.chd_toolbar.SetToolBitmapSize(wx.Size(16, 16))
 339
 340        if isinstance(self.corpus, Corpus) :
 341            panel.corpus = self.corpus
 342        else :
 343            panel.tableau = self.corpus
 344            #self.parent.tableau = panel.tableau
 345        panel.dictpathout = self.DictPathOut
 346        panel.pathout = self.DictPathOut
 347        panel.parent = self.parent
 348        panel.DictProfile = self.DictProfile
 349        panel.cluster_size = self.cluster_size
 350        panel.debtext = self.debtext
 351
 352 #       self.ID_rapport = wx.NewId()
 353 #       #rap_img = wx.Image(os.path.join(self.parent.images_path,'icone_rap_16.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
 354 #       #panel.chd_toolbar.AddLabelTool(self.ID_rapport, "rapport", rap_img, shortHelp=u"Produire le rapport", longHelp=u"Exporter un rapport en texte simple")
 355 #       butrap = wx.Button(panel.chd_toolbar, self.ID_rapport, u"Rapport ")
 356 #       panel.chd_toolbar.AddControl(butrap)
 357 #
 358 #       panel.chd_toolbar.Realize()
 359 #       sizer1.Add(panel.chd_toolbar,0, wx.EXPAND, 5)
 360
 361        #self.TabChdSim = wx.aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
 362        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
 363        panel.TabChdSim = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 364        panel.TabChdSim.SetAGWWindowStyleFlag(notebook_flags)
 365        panel.TabChdSim.SetArtProvider(aui.ChromeTabArt())
 366        sizer1.Add(panel.TabChdSim,10, wx.EXPAND, 5)
 367        panel.SetSizer(sizer1)
 368        sizer1.Fit(panel)
 369
 370
 371        if isinstance(self.corpus, Corpus) :
 372            panel.TabChdSim.corpus = corpus
 373            panel.TabChdSim.corpus.dictpathout = self.DictPathOut
 374        else :
 375            panel.TabChdSim.tableau = corpus
 376            panel.TabChdSim.tableau.dictpathout = self.DictPathOut
 377        panel.parametres = self.parametres
 378        self.panel = panel
 379
 380        self.notenb = self.parent.nb.GetPageCount()
 381
 382
 383        if os.path.exists(self.DictPathOut['liste_graph_chd']) :
 384            list_graph = read_list_file(self.DictPathOut['liste_graph_chd'], self.encoding)
 385            CHD = GraphPanelDendro(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
 386            panel.TabChdSim.AddPage(CHD,'CHD')
 387
 388        panel.ProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 389        panel.ProfNB.SetArtProvider(aui.ChromeTabArt())
 390        #self.ProfNB.SetTabCtrlHeight(100)
 391        #panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 392        if os.path.exists(DictPathOut['prof_seg']) :
 393             prof_seg = ReadProfileAsDico(DictPathOut['prof_seg'], False, self.encoding)
 394             self.prof_seg_nb = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 395        for i in range(0, clnb):
 396             self.cluster_size.append(DictProfile[str(i + 1)][0][0:3])
 397             dlg.Update(3+i, 'Classe %i' %(i+1))
 398             ind = '/'.join(DictProfile[str(i + 1)][0][0:2])
 399             indpour = ' - '.join([ind, DictProfile[str(i + 1)][0][2]])
 400             self.tabprofile = ProfListctrlPanel(self.parent, self.panel, DictProfile[str(i + 1)], Alceste, i + 1)
 401             #self.tabantiprofile = ProfListctrlPanel(self.parent, self, DictAnti[str(i + 1)], Alceste, i + 1)
 402             panel.ProfNB.AddPage(self.tabprofile, 'classe %s %s(%s%%)' % (str(i + 1), sep, indpour))
 403             #panel.AntiProfNB.AddPage(self.tabantiprofile, 'classe %s' % str(i + 1))
 404             if os.path.exists(DictPathOut['prof_seg']) :
 405                 self.tab_prof_seg = ProfListctrlPanel(self.parent, self, prof_seg[str(i + 1)], False, i + 1)
 406                 self.prof_seg_nb.AddPage(self.tab_prof_seg, 'classe %i' % (i + 1))
 407
 408        if clnb > 2 :
 409            self.TabAFC = aui.AuiNotebook(panel.TabChdSim, -1, wx.DefaultPosition)
 410            log.info('read AFC')
 411            list_graph=read_list_file(DictPathOut['liste_graph_afc'], self.encoding)
 412            self.tabAFCGraph = GraphPanelAfc(self.TabAFC, DictPathOut, list_graph, self.clnb, coding=self.encoding)
 413            self.TabAFC.AddPage(self.tabAFCGraph, 'AFC')
 414
 415            if os.path.exists(self.DictPathOut['afc_facteur']) :
 416                dictrow, first = ReadList(self.DictPathOut['afc_facteur'], self.encoding)
 417                self.TabAFC_facteur = ListForSpec(self.parent, parametres, dictrow, first)
 418                #dictrow, first = ReadList(self.DictPathOut['afc_row'], self.encoding)
 419                #self.TabAFC_ligne = ListForSpec(self.parent, self.parametres, dictrow, first)
 420                #dictrow, first = ReadList(self.DictPathOut['afc_col'], self.encoding)
 421                #self.TabAFC_colonne = ListForSpec(parent, self.parametres, dictrow, first)
 422                self.TabAFC.AddPage(self.TabAFC_facteur, 'Facteurs')
 423                #self.TabAFC.AddPage(self.TabAFC_colonne, u'Colonnes')
 424                #self.TabAFC.AddPage(self.TabAFC_ligne, u'Lignes')
 425
 426            sizer_3 = wx.BoxSizer(wx.VERTICAL)
 427            self.parent.nb_panel_2 = wx.Panel(panel.TabChdSim, -1)
 428            self.parent.button_simi = wx.Button(self.parent.nb_panel_2, -1, "Voyager")
 429            self.parent.simi3dpanel = simi3d(self.parent.nb_panel_2, -1)
 430            sizer_3.Add(self.parent.simi3dpanel, 1, wx.EXPAND, 0)
 431            sizer_3.Add(self.parent.button_simi, 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 432            self.parent.nb_panel_2.SetSizer(sizer_3)
 433            self.TabAFC.AddPage(self.parent.nb_panel_2, "graph 3D")
 434            self.parent.Bind(wx.EVT_BUTTON, self.onsimi, self.parent.button_simi)
 435
 436        panel.TabChdSim.AddPage(panel.ProfNB, 'Profils')
 437        #panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')
 438        dlg.Update(4 + self.clnb, 'Affichage...')
 439        if clnb > 2 :
 440            panel.TabChdSim.AddPage(self.TabAFC, 'AFC')
 441        if os.path.exists(DictPathOut['prof_seg']) :
 442            panel.TabChdSim.AddPage(self.prof_seg_nb, u'Profils des segments répétés')
 443
 444 #       panel.Bind(wx.EVT_BUTTON, self.ongetrapport, id = self.ID_rapport)
 445        self.parent.nb.AddPage(panel, 'Classification - %s' % corpname)
 446        self.parent.ShowTab(True)
 447        self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
 448        #for pane in self.parent._mgr.GetAllPanes() :
 449        #     if isinstance(pane.window, aui.AuiNotebook):
 450        #         nb = pane.window
 451        #         nb.SetAGWWindowStyleFlag(notebook_flags)
 452        #         nb.SetArtProvider(aui.ChromeTabArt())
 453        dlg.Destroy()
 454        self.parent._mgr.Update()
 455
 456     def onsimi(self,event):
 457         outfile = print_simi3d(self)
 458         error = exec_rcode(self.parent.RPath, outfile, wait = True)
 459
 460 #    def ongetrapport(self, event) :
 461 #        dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.txt', 'title': 'Rapport'})
 462 #        dial.fbb.SetValue(self.DictPathOut['rapport'])
 463 #        dial.CenterOnParent()
 464 #        res = dial.ShowModal()
 465 #        if res == wx.ID_OK :
 466 #            fileout = dial.fbb.GetValue()
 467 #            dial.Destroy()
 468 #            with open(fileout, 'w') as f :
 469 #                f.write(self.debtext + '\n' + GetTxtProfile(self.DictProfile, self.cluster_size))
 470 #            msg = u"Fini !"
 471 #            dlg = wx.MessageDialog(self.parent, msg, u"Rapport", wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
 472 #            dlg.CenterOnParent()
 473 #            dlg.ShowModal()
 474 #            dlg.Destroy()
 475 #        else :
 476 #            dial.Destroy()
 477
 478 #    def on_export_classes(self, event) :
 479 #        corpus = self.parent.nb.GetPage(self.parent.nb.GetSelection()).corpus
 480 #        dial = PrefExport(self, self.parent)
 481 #        dial.fbb.SetValue(os.path.join(os.path.dirname(corpus.dictpathout['ira']), 'export_corpus.txt'))
 482 #        dial.CenterOnParent()
 483 #        res = dial.ShowModal()
 484 #        if res == wx.ID_OK :
 485 #            if dial.radio_type.GetSelection() == 0 : alc = True
 486 #            else : alc = False
 487 #            if dial.radio_lem.GetSelection() == 0 : lem = True
 488 #            else : lem = False
 489 #            self.corpus.export_corpus_classes(dial.fbb.GetValue(), alc = alc, lem = lem)
 490 #            msg = u"Fini !"
 491 #            dial.Destroy()
 492 #            dlg = wx.MessageDialog(self.parent, msg, u"Export", wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
 493 #            dlg.CenterOnParent()
 494 #            dlg.ShowModal()
 495 #            dlg.Destroy()
 496
 497 #    def onprofseg(self, event):
 498 #        #try :
 499 #            print 'plus de bug profseg'
 500 #            print self.parametres
 501 #            corpus = self.parent.nb.GetPage(self.parent.nb.GetSelection()).corpus
 502 #            ProfileSegment(self.parent, self.dictpathout, self.parametres, corpus)
 503 #        #except :
 504 #        #    BugReport(self.parent)
 505 #
 506 #    def onproftype(self, event):
 507 #        try :
 508 #            corpus = self.parent.nb.GetPage(self.parent.nb.GetSelection()).corpus
 509 #            ProfilType(self.parent, corpus)
 510 #        except :
 511 #            BugReport(self.parent)
 512 #
 513 #    def oncolored(self,evt) :
 514 #        dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.html', 'title': 'Corpus en couleur'})
 515 #        dial.fbb.SetValue(os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'corpus_couleur.html'))
 516 #        dial.CenterOnParent()
 517 #        res = dial.ShowModal()
 518 #        if res == wx.ID_OK :
 519 #            fileout = dial.fbb.GetValue()
 520 #            dial.Destroy()
 521 #            txt = self.corpus.make_colored_corpus()
 522 #            with open(fileout, 'w') as f :
 523 #                f.write(txt)
 524 #            msg = u"Fini !\nVoulez-vous ouvrir le corpus dans votre navigateur ?"
 525 #            dlg = wx.MessageDialog(self.parent, msg, u"Corpus en couleur", wx.NO | wx.YES | wx.NO_DEFAULT | wx.ICON_QUESTION)
 526 #            dlg.CenterOnParent()
 527 #            if dlg.ShowModal() == wx.ID_YES :
 528 #                webbrowser.open(fileout)
 529 #            dlg.Destroy()
 530
 531     def onclusterstat(self, evt) :
 532         dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': 'Stat par classe'})
 533         dial.fbb.SetValue( os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'stat_par_classe.csv'))
 534         dial.CenterOnParent()
 535         res = dial.ShowModal()
 536         if res == wx.ID_OK :
 537             fileout = dial.fbb.GetValue()
 538             dial.Destroy()
 539             self.corpus.get_stat_by_cluster(fileout)
 540             msg = u"Fini !"
 541             dlg = wx.MessageDialog(self.parent, msg, u"Stat par classe", wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
 542             dlg.CenterOnParent()
 543             if dlg.ShowModal() == wx.ID_OK :
 544                 dlg.Destroy()
 545
 546     #def onsearchf(self, evt) :
 547     #    if 'FrameSearch' not in dir(self.panel) :
 548     #        self.panel.FrameSearch = SearchFrame(self.parent, -1, u"Rechercher...", self.corpus)
 549     #    self.panel.FrameSearch.Show()
 550
 551
 552
 553 def PrintRapport(self, corpus, parametres, istxt = True):
 554     #if sys.platform == 'win32':
 555     #    sep = '\r\n'
 556     #else:
 557     sep = '\n'
 558     txt = """
 559 +-+-+-+-+-+-+-+-+
 560 |i|R|a|M|u|T|e|Q| - %s
 561 +-+-+-+-+-+-+-+-+
 562
 563
 564 """ % datetime.datetime.now().ctime()
 565     if istxt :
 566         totocc = corpus.gettotocc()
 567         txt += u'nombre de textes: %i%s' % (corpus.getucinb(), sep)
 568         txt += u'nombre de segments de textes: %i%s' % (corpus.getucenb(), sep)
 569         txt += u'nombre de formes: %i%s' % (len(corpus.formes), sep)
 570         txt += u'nombre d\'occurrences: %i%s' % (totocc, sep)
 571         txt += u'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
 572         txt += u'nombre de lemmes: %i%s' % (len(corpus.lems), sep)
 573         txt += u'nombre de formes actives: %i%s' % (corpus.getactivesnb(1), sep)
 574         txt += u'nombre de formes supplémentaires: %i%s' % (corpus.getactivesnb(2), sep)
 575         txt += u'nombre de formes actives de fréquence >= %i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)
 576         txt += u'moyenne d\'occurrences par uce :%f%s' % (float(totocc) / float(corpus.getucenb()), sep)
 577         if 'tailleuc1' in parametres :
 578             if parametres['classif_mode'] == 0 :
 579                 txt += u'taille rst1 / rst2: %i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)
 580     else :
 581         self.Ucenb = self.nbind
 582         txt += u'nombre d\'individus : %i%s' % (self.nbind, sep)
 583         txt += u'nombre de classes : %i%s' % (self.clnb, sep)
 584     if istxt :
 585         txt += u'nombre de classes : %i%s' % (parametres['clnb'], sep)
 586         if parametres['classif_mode'] == 0 or parametres['classif_mode'] == 1 :
 587             txt += u'%i segments classés sur %i (%.2f%%)%s' % (sum([len(cl) for cl in corpus.lc]), corpus.getucenb(), (float(sum([len(cl) for cl in corpus.lc])) / float(corpus.getucenb())) * 100, sep)
 588         elif self.parametres['classif_mode'] == 2 :
 589             txt += u'%i textes classés sur %i (%.2f%%)%s' % (sum([len(cl) for cl in corpus.lc]), corpus.getucinb(), (float(sum([len(cl) for cl in corpus.lc]))) / float(corpus.getucinb()) * 100, sep)
 590     else :
 591         txt += u'%i uce classées sur %i (%.2f%%)%s' % (self.ucecla, self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)
 592
 593     txt += """
 594 ###########################
 595 temps d'analyse : %s
 596 ###########################
 597 """ % parametres.get('time', '')
 598     with open(self.pathout['pre_rapport'], 'w') as f :
 599         f.write(txt)
 600
 601 class dolexlayout :
 602     def __init__(self, ira, corpus, parametres):
 603         self.pathout = PathOut(dirout = parametres['pathout'])
 604         self.corpus = corpus
 605         self.dictpathout = StatTxtPathOut(parametres['pathout'])
 606         #self.corpus.read_corpus_from_shelves(self.corpus.dictpathout['db'])
 607         self.parent = ira
 608         self.encoding = self.corpus.parametres['syscoding']
 609         self.parametres = parametres
 610
 611         self.DictSpec, first = ReadList(self.dictpathout['tablespecf'], self.corpus.parametres['syscoding'])
 612         self.DictType, firstt = ReadList(self.dictpathout['tablespect'], self.corpus.parametres['syscoding'])
 613         self.DictEff, firsteff = ReadList(self.dictpathout['tableafcm'], self.corpus.parametres['syscoding'])
 614         self.DictEffType, firstefft = ReadList(self.dictpathout['tabletypem'], self.corpus.parametres['syscoding'])
 615         self.DictEffRelForme, firsteffrelf = ReadList(self.dictpathout['eff_relatif_forme'], self.corpus.parametres['syscoding'])
 616         self.DictEffRelType, firsteffrelt = ReadList(self.dictpathout['eff_relatif_type'], self.corpus.parametres['syscoding'])
 617
 618         self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
 619         self.TabStat.parametres = parametres
 620         self.ListPan = ListForSpec(ira, self.parent, self.DictSpec, first)
 621         self.ListPant = ListForSpec(ira, self.parent, self.DictType, firstt)
 622         self.ListPanEff = ListForSpec(ira, self.parent, self.DictEff, firsteff)
 623         self.ListPanEffType = ListForSpec(ira, self.parent, self.DictEffType, firstefft)
 624         self.ListPanEffRelForme = ListForSpec(ira, self.parent, self.DictEffRelForme, firsteffrelf)
 625         self.ListPanEffRelType = ListForSpec(ira, self.parent, self.DictEffRelType, firsteffrelt)
 626
 627         self.TabStat.AddPage(self.ListPan, u'formes')
 628         self.TabStat.AddPage(self.ListPant, u'Types')
 629         self.TabStat.AddPage(self.ListPanEff, u'Effectifs formes')
 630         self.TabStat.AddPage(self.ListPanEffType, u'Effectifs Type')
 631         self.TabStat.AddPage(self.ListPanEffRelForme, u'Effectifs relatifs formes')
 632         self.TabStat.AddPage(self.ListPanEffRelType, u'Effectifs relatifs Type')
 633         if self.parametres['clnb'] > 2 :
 634            self.TabAFC = aui.AuiNotebook(self.TabStat, -1, wx.DefaultPosition)
 635            list_graph=read_list_file(self.dictpathout['liste_graph_afcf'], encoding = self.encoding)
 636            self.tabAFCGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afcf', coding = self.encoding)
 637            self.TabAFC.AddPage(self.tabAFCGraph, 'AFC formes')
 638            list_graph=read_list_file(self.dictpathout['liste_graph_afct'], encoding = self.encoding)
 639            self.tabAFCTGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afct', coding=self.encoding)
 640            self.TabAFC.AddPage(self.tabAFCTGraph, 'AFC type')
 641            self.TabStat.AddPage(self.TabAFC, 'AFC')
 642
 643
 644         ira.nb.AddPage(self.TabStat, u'Spécificités')
 645
 646         self.TabStat.corpus = self.corpus
 647         ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
 648         ira.ShowAPane("Tab_content")
 649
 650 class StatLayout:
 651     def __init__(self, ira, corpus, parametres):
 652         self.pathout = PathOut(dirout = parametres['pathout'])
 653         self.corpus = corpus
 654         self.ira = ira
 655         self.read_result()
 656         self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
 657         self.TabStat.parametres = parametres
 658         self.TabStat.corpus = corpus
 659         self.TabStat.pathout = self.pathout
 660 #        CHD = GraphPanel(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
 661          #      panel.TabChdSim.AddPage(CHD,'CHD')
 662
 663         #self.TabStatTot = wx.TextCtrl(self.TabStat, -1, style=wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2)
 664         list_graph = [['zipf.png', 'zipf']]
 665         self.TabStatTot = GraphPanel(ira.nb, self.pathout, list_graph, self.result['glob'])
 666         self.TabStat.AddPage(self.TabStatTot, 'global')
 667         for item in self.result:
 668             if item != 'glob':
 669                 datam = [['forme', 'nb']]
 670                 self.ListPan = ListPanel(ira, self, self.result[item])
 671                 self.TabStat.AddPage(self.ListPan, ' '.join(item.split('_')))
 672         ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
 673         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
 674         ira.ShowAPane("Tab_content")
 675
 676     def read_result(self) :
 677         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'}
 678         self.result = {}
 679         for key in lcle :
 680             with open(self.pathout[lcle[key]], 'r') as f :
 681                 self.result[key] = [line.split(';') for line in f.read().splitlines()]
 682                 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
 683         with open(self.pathout['glob.txt'], 'r') as f :
 684             self.result['glob'] = f.read()
 685
 686 class GraphPanelDendro(wx.Panel):
 687     def __init__(self,parent, dico, list_graph, txt=False):
 688         wx.Panel.__init__(self,parent)
 689         self.graphnb = 1
 690         self.dictpathout = dico
 691         self.dirout = os.path.dirname(self.dictpathout['ira'])
 692         self.list_graph = list_graph
 693         self.parent = self.GetParent()#parent
 694         self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
 695         self.labels = []
 696         self.listimg = []
 697         self.tabchd = self.parent.GetParent()
 698         self.ira = self.tabchd.GetParent()
 699         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
 700         self.panel_1.SetBackgroundColour('white')
 701         self.deb = wx.StaticText(self.panel_1, -1, txt)
 702         dendro_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
 703         self.butdendro = wx.BitmapButton(self, -1, dendro_img)
 704
 705         for i in range(0,len(list_graph)):
 706             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
 707                 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
 708                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
 709
 710         self.__set_properties()
 711         self.__do_layout()
 712
 713     def __set_properties(self):
 714         self.panel_1.EnableScrolling(True,True)
 715         #self.panel_1.SetSize((1000,1000))
 716         self.panel_1.SetScrollRate(20, 20)
 717         self.Bind(wx.EVT_BUTTON, self.ondendro, self.butdendro)
 718         self.param = {'width' : 700,
 719                        'height': 500,
 720                        'type_dendro': 0,
 721                        'color_nb': 0,
 722                        'taille_classe' : True,
 723                        'type_tclasse' : 0
 724                      }
 725         self.type_dendro = [ u"phylogram", u"cladogram", u"fan", u"unrooted", u"radial" ]
 726
 727     def __do_layout(self):
 728         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
 729         self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
 730         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
 731         self.sizer_3.Add(self.deb)
 732         self.sizer_2.Add(self.butdendro, 0, 0, 0)
 733         for i in range(0, len(self.listimg)):
 734             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 735             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 736         self.panel_1.SetSizer(self.sizer_3)
 737         self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
 738         self.SetSizer(self.sizer_2)
 739
 740     def make_param(self, dial):
 741         self.param['width'] = dial.m_spinCtrl2.GetValue()
 742         self.param['height'] = dial.m_spinCtrl1.GetValue()
 743         self.param['type_dendro'] = dial.m_choice1.GetSelection()
 744         self.param['color_nb'] = dial.m_radioBox1.GetSelection()
 745         self.param['taille_classe'] = dial.m_checkBox1.GetValue()
 746         self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
 747
 748     def make_dendro(self) :
 749         while os.path.exists(os.path.join(self.dirout, 'dendrogamme_' + str(self.graphnb)+'.png')) :
 750             self.graphnb += 1
 751         fileout = ffr(os.path.join(self.dirout,'dendrogamme_' + str(self.graphnb)+'.png'))
 752         width = self.param['width']
 753         height = self.param['height']
 754         type_dendro = self.type_dendro[self.param['type_dendro']]
 755         if self.param['taille_classe'] :
 756             tclasse = 'TRUE'
 757         else :
 758             tclasse = 'FALSE'
 759         if self.param['color_nb'] == 0 :
 760             bw = 'FALSE'
 761         else :
 762             bw = 'TRUE'
 763         if self.param['type_tclasse'] == 0 :
 764             histo='FALSE'
 765         else :
 766             histo = 'TRUE'
 767         dendro_path = self.dictpathout['Rdendro']
 768         classe_path = self.dictpathout['uce']
 769         txt = """
 770         library(ape)
 771         load("%s")
 772         source("%s")
 773         classes <- read.csv2("%s", row.names=1)
 774         classes <- classes[,1]
 775         open_file_graph("%s", width=%i, height=%i)
 776         plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
 777         """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']), ffr(classe_path), ffr(fileout), width, height, type_dendro, histo, bw, tclasse)
 778
 779         tmpfile = tempfile.mktemp()
 780         with open(tmpfile, 'w') as f :
 781             f.write(txt)
 782         error = exec_rcode(self.ira.RPath, tmpfile, wait=True)
 783         check_Rresult(self.ira, error)
 784         self.list_graph.append([fileout, 'Dendrogramme CHD1 - %s' %  type_dendro])
 785         print_liste(self.dictpathout['liste_graph_chd'], self.list_graph)
 786         self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 787         self.sizer_3.Add(wx.StaticText(self.panel_1,-1, 'Dendrogramme CHD1 - %s' %  type_dendro), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 788         self.sizer_3.Fit(self.panel_1)
 789         self.Layout()
 790         self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
 791
 792
 793     def ondendro(self, evt):
 794         dial = PrefDendro(self.ira, self.param)
 795         val = dial.ShowModal()
 796         if val == wx.ID_OK :
 797             self.make_param(dial)
 798             self.make_dendro()
 799
 800
 801
 802 class OpenCorpus :
 803     def __init__(self, ira, parametres) :
 804         #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)
 805         self.panel = CopusPanel(ira, parametres)
 806         ira.nb.AddPage(self.panel, 'Description %s' % parametres['corpus_name'])
 807         #self.text.write(DoConf().totext(parametres))
 808         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
 809         ira.ShowAPane("Tab_content")
 810
 811 class CopusPanel(wx.Panel) :
 812     def __init__(self, parent, parametres) :
 813         wx.Panel.__init__ ( self, parent, id = wx.ID_ANY, pos = wx.DefaultPosition, size = wx.Size( 500,300 ), style = wx.TAB_TRAVERSAL )
 814         self.parametres = parametres
 815         fgSizer5 = wx.FlexGridSizer( 0, 2, 0, 0 )
 816         fgSizer5.SetFlexibleDirection( wx.BOTH )
 817         fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )
 818         self.fgSizer5 = fgSizer5
 819
 820         self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Description du corpus", wx.DefaultPosition, wx.DefaultSize, 0 )
 821
 822         self.m_staticText18.Wrap( -1 )
 823         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
 824
 825         self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
 826         self.m_staticText19.Wrap( -1 )
 827         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
 828
 829         self.m_staticText20 = wx.StaticText( self, wx.ID_ANY, u"Nom", wx.DefaultPosition, wx.DefaultSize, 0 )
 830         self.m_staticText20.Wrap( -1 )
 831         fgSizer5.Add( self.m_staticText20, 0, wx.ALL, 5 )
 832
 833         self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, parametres['corpus_name'], wx.DefaultPosition, wx.DefaultSize, 0 )
 834         self.m_staticText21.Wrap( -1 )
 835         fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )
 836
 837         description = {'lang' : u'langue',
 838                         'encoding' : u'encodage'}
 839
 840         keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']
 841
 842         self.addkeys(keys, description)
 843
 844         self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Paramètres", wx.DefaultPosition, wx.DefaultSize, 0 )
 845         self.m_staticText18.Wrap( -1 )
 846         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
 847
 848         self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
 849         self.m_staticText19.Wrap( -1 )
 850         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
 851
 852         keys = ['ucemethod', 'ucesize', 'keep_caract', 'expressions']
 853         self.addkeys(keys, description)
 854
 855         self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Statistiques", wx.DefaultPosition, wx.DefaultSize, 0 )
 856         self.m_staticText18.Wrap( -1 )
 857         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
 858
 859         self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
 860         self.m_staticText19.Wrap( -1 )
 861         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
 862
 863         keys = ['ucinb', 'ucenb', 'occurrences', 'formesnb', 'hapax']
 864         self.addkeys(keys, description)
 865
 866         self.SetSizer( fgSizer5 )
 867         self.Layout()
 868
 869     def addkeys(self, keys, description) :
 870         for key in keys :
 871             option = self.parametres.get(key,u'non défnini')
 872             if isinstance(option, int) :
 873                 option = `option`
 874             text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
 875             text.Wrap( -1 )
 876             self.fgSizer5.Add( text, 0, wx.ALL, 5 )
 877
 878             text = wx.StaticText( self, wx.ID_ANY, option, wx.DefaultPosition, wx.DefaultSize, 0 )
 879             text.Wrap( -1 )
 880             self.fgSizer5.Add( text, 0, wx.ALL, 5 )
 881
 882 class DefaultTextLayout :
 883     def __init__(self, ira, corpus, parametres) :
 884         self.pathout = PathOut(dirout = parametres['pathout'])
 885         self.ira = ira
 886         self.parent = ira
 887         self.parametres = parametres
 888         self.corpus = corpus
 889         self.dolayout()
 890
 891     def dolayout(self) :
 892         log.info('no layout yet')
 893
 894 class WordCloudLayout(DefaultTextLayout):
 895     def dolayout(self):
 896         #self.dictpathout = parent.corpus.dictpathout
 897         #self.pathout = os.path.dirname(filename)
 898         #self.corpus = parent.corpus
 899     #    self.read_result()
 900         self.pathout.basefiles(simipath)
 901         self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
 902 #        if os.path.exists(self.pathout['liste_graph']) :
 903 #            list_graph = read_list_file(self.pathout['liste_graph'])
 904 #        else :
 905 #            list_graph = [['','']]
 906         list_graph = [['nuage_1.png', 'Nuage']]
 907         self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, list_graph)
 908         #self.TabStatTot.write(self.result['glob'])
 909         self.Tab.AddPage(self.TabStatTot, 'Nuage')
 910         self.Tab.corpus = self.corpus
 911         self.Tab.parametres = self.parametres
 912         self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
 913         self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
 914         self.ira.ShowAPane("Tab_content")
 915
 916 class SimiLayout(DefaultTextLayout) :
 917     def dolayout(self) :
 918         self.pathout.basefiles(simipath)
 919         self.actives = None
 920         self.indices = indices_simi
 921         if os.path.exists(self.pathout['liste_graph']) :
 922             list_graph = read_list_file(self.pathout['liste_graph'])
 923         else :
 924             list_graph = [['','']]
 925         notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
 926         self.tabsimi = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
 927         self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
 928         self.tabsimi.SetArtProvider(aui.ChromeTabArt())
 929         self.tabsimi.corpus = self.corpus
 930         self.tabsimi.parametres = self.parametres
 931         self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
 932         self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
 933         self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
 934         self.tabsimi.AddPage(self.graphpan, 'Graph')
 935         self.ira.nb.AddPage(self.tabsimi, 'Analyse de graph')
 936         self.ira.ShowTab(True)
 937         self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
 938
 939     def redosimi(self, evt) :
 940         with open(self.pathout['selected.csv'],'r') as f :
 941             selected = f.read()
 942         selected = [int(val) for val in selected.splitlines()]
 943         if self.actives is None :
 944             with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
 945                 self.actives = f.read()
 946             self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
 947         if os.path.exists(self.pathout['actives_nb.csv']) :
 948             with open(self.pathout['actives_nb.csv'], 'r') as f :
 949                 act_nb = f.read()
 950                 act_nb = act_nb.splitlines()
 951             dictcol = dict([[i, [self.actives[i], int(act_nb[i])]] for i, val in enumerate(self.actives)])
 952         else :
 953             dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
 954         #res = SelectColumn(self.ira, dictcol, self.actives, self.pathout['selected.csv'], selected = selected, dlg = True)
 955         #if res.ok :
 956         prep = PrepSimi(self.ira, self, self.parametres,self.pathout['selected.csv'], self.actives, indices_simi, wordlist = dictcol, selected = selected)
 957         if prep.val == wx.ID_OK :
 958             self.parametres = prep.parametres
 959
 960             script = PrintSimiScript(self)
 961             script.make_script()
 962             pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
 963             check_Rresult(self.ira, pid)
 964             if self.parametres['type_graph'] == 1:
 965                 if self.parametres['svg'] :
 966                     filename, ext = os.path.splitext(script.filename)
 967                     fileout = filename + '.svg'
 968                 else :
 969                     fileout = script.filename
 970                 if os.path.exists(self.pathout['liste_graph']):
 971                     graph_simi = read_list_file(self.pathout['liste_graph'])
 972                     graph_simi.append([os.path.basename(fileout), script.txtgraph])
 973                 else :
 974                     graph_simi = [[os.path.basename(fileout), script.txtgraph]]
 975                 print_liste(self.pathout['liste_graph'], graph_simi)
 976             DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
 977             if self.parametres['type_graph'] == 1:
 978                 if self.parametres['svg'] :
 979                     self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 980                 else :
 981                     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)
 982                 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 983                 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
 984                 self.graphpan.Layout()
 985                 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
 986
 987     def export(self, evt) :
 988         nb = 1
 989         while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
 990             nb +=1
 991         fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
 992         txt = """
 993         library(igraph)
 994         load("%s")
 995         fileout <- "%s"
 996         graph <- graph.simi$graph
 997         V(graph)$x <- graph.simi$layout[,1]
 998         V(graph)$y <- graph.simi$layout[,2]
 999         V(graph)$weight <- graph.simi$label.cex
1000         V(graph)$colors <- vertex.label.color
1001         E(graph)$weigth <- graph.simi$we.width
1002         write.graph(graph, fileout, format = 'graphml')
1003         """ % (self.pathout['RData.RData'], fileout)
1004         filetmp = tempfile.mktemp()
1005         with open(filetmp, 'w') as f :
1006             f.write(txt)
1007         exec_rcode(self.ira.RPath, filetmp)
1008         mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
1009         mss.CenterOnParent()
1010         mss.ShowModal()
1011         mss.Destroy()
1012
1013 class DefaultMatLayout :
1014     def __init__(self, parent, tableau, parametres) :
1015         self.pathout = PathOut(dirout = parametres['pathout'])
1016         self.ira = parent
1017         self.parent = parent
1018         self.tableau = tableau
1019         self.parametres = parametres
1020         self.dolayout()
1021
1022     def dolayout(self) :
1023         pass
1024
1025 class SimiMatLayout(DefaultMatLayout) :
1026     def dolayout(self):
1027         self.pathout.basefiles(simipath)
1028         self.indices = indices_simi
1029         if os.path.exists(self.pathout['liste_graph']) :
1030             list_graph = read_list_file(self.pathout['liste_graph'])
1031         else :
1032             list_graph = [['','']]
1033         notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1034         self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1035         self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1036         self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1037         self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1038         self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1039         self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1040         self.tabsimi.AddPage(self.graphpan, 'Graph')
1041         self.tabsimi.parametres = self.parametres
1042         self.parent.nb.AddPage(self.tabsimi, 'Analyse de graph')
1043         self.parent.ShowTab(True)
1044         self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1045
1046     def redosimi(self,evt) :
1047         with open(self.pathout['selected.csv'],'r') as f :
1048             selected = f.read()
1049         selected = [int(val) for val in selected.splitlines()]
1050         #if self.actives is None :
1051         #    with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1052         #        self.actives = f.read()
1053         #    self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1054         try :
1055             actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1056         except :
1057             actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1058
1059         #self.tableau.make_listactives()
1060         actives = dict([[i, val] for i, val in enumerate(actives)])
1061         #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1062         self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1063         self.dial.CenterOnParent()
1064         self.val = self.dial.ShowModal()
1065         if self.val == wx.ID_OK :
1066             last = self.dial.listcol.GetFirstSelected()
1067             lastl = [self.dial.listcol.GetFirstSelected()]
1068             indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1069             while self.dial.listcol.GetNextSelected(last) != -1:
1070                 last = self.dial.listcol.GetNextSelected(last)
1071                 lastl.append(last)
1072                 indexes.append(self.dial.listcol.getColumnText(last,0))
1073             self.column = [self.tableau.listactives.index(val) for val in indexes]
1074             self.column.sort()
1075             with open(self.pathout['selected.csv'], 'w') as f :
1076                 f.write('\n'.join([`val` for val in self.column]))
1077             self.make_param()
1078             self.dial.Destroy()
1079             self.script = PrintSimiScript(self)
1080             self.script.make_script()
1081             self.tmpfile = self.script.scriptout
1082             dlg = progressbar(self, maxi = 2)
1083             self.DoR(dlg)
1084             dlg.Destroy()
1085             if self.parametres['type_graph'] == 1:
1086                 if self.parametres['svg'] :
1087                     filename, ext = os.path.splitext(self.script.filename)
1088                     fileout = filename + '.svg'
1089                 else :
1090                     fileout = self.script.filename
1091                 if os.path.exists(self.pathout['liste_graph']):
1092                     graph_simi = read_list_file(self.pathout['liste_graph'])
1093                     graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1094                 else :
1095                     graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1096                 print_liste(self.pathout['liste_graph'], graph_simi)
1097             DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1098             if self.parametres['type_graph'] == 1:
1099                 if self.parametres['svg'] :
1100                     self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1101                 else :
1102                     self.graphpan.sizer_3.Add(wx.StaticBitmap(self.graphpan.panel_1, -1, wx.Bitmap(self.script.filename, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1103                 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1104                 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1105                 self.graphpan.Layout()
1106                 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1107         else :
1108             self.dial.Destroy()
1109
1110
1111     def make_param(self) :
1112         if self.parametres['first'] :
1113             keep_coord = False
1114         else :
1115             keep_coord = self.dial.check_coord.GetValue()
1116         #self.select = self.dial.check_colch.GetValue()
1117
1118         paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1119                           'layout' : self.dial.choice2.GetSelection(),
1120                           'type_graph' : self.dial.choice3.GetSelection(),
1121                           'arbremax' : self.dial.check1.GetValue(),
1122                           'coeff_tv' : self.dial.check_s_size.GetValue(),
1123                           'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1124                           'tvprop' : self.dial.check2.GetValue(),
1125                           'tvmin' : self.dial.spin_tvmin.GetValue(),
1126                           'tvmax' : self.dial.spin_tvmax.GetValue(),
1127                           'coeff_te' : self.dial.check3.GetValue(),
1128                           'coeff_temin' : self.dial.spin_temin.GetValue(),
1129                           'coeff_temax' : self.dial.spin_temax.GetValue(),
1130                           'label_e' : self.dial.check_elab.GetValue(),
1131                           'label_v' : self.dial.check_vlab.GetValue(),
1132                           'vcex' : self.dial.check_vcex.GetValue(),
1133                           'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1134                           'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1135                           'cex' : self.dial.spin_cex.GetValue(),
1136                           'seuil_ok' : self.dial.check_seuil.GetValue(),
1137                           'seuil' : self.dial.spin_seuil.GetValue(),
1138                           'cols' : self.dial.cols.GetColour(),
1139                           'cola' : self.dial.cola.GetColour(),
1140                           'width' : self.dial.spin_width.GetValue(),
1141                           'height' : self.dial.spin_height.GetValue(),
1142                           'first' : False,
1143                           'keep_coord' : keep_coord,
1144                           'alpha' : self.dial.slider_sphere.GetValue(),
1145                           'film' : self.dial.film.GetValue(),
1146                           'svg' : self.dial.choix_format.GetSelection(),
1147                           'halo' : self.dial.halo.GetValue(),
1148                           'com' : self.dial.comcheck.GetValue(),
1149                           'communities' : self.dial.choix_com.GetSelection(),
1150                           }
1151         if 'cexfromchi' in self.parametres :
1152             paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1153         if 'sfromchi' in self.parametres :
1154             paramsimi['sfromchi'] = self.dial.checki.GetValue()
1155         if 'vlabcolor' in self.parametres :
1156            paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1157         if 'check_bystar' in dir(self.dial) :
1158             paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1159             paramsimi['stars'] = self.parametres['stars']
1160         self.parametres.update(paramsimi)
1161
1162     def DoR(self, dlg):
1163         if self.parametres['type_graph'] == 1 :
1164             graph = False
1165             wait = False
1166         else :
1167             graph = True
1168             wait = True
1169         pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1170         if self.parametres['type_graph'] == 1 :
1171             while pid.poll() == None :
1172                 dlg.Pulse(u'R ...')
1173                 sleep(0.2)
1174             check_Rresult(self.parent, pid)
1175
1176     def export(self, evt) :
1177         nb = 1
1178         while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1179             nb +=1
1180         fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1181         txt = """
1182         library(igraph)
1183         load("%s")
1184         fileout <- "%s"
1185         graph <- graph.simi$graph
1186         V(graph)$x <- graph.simi$layout[,1]
1187         V(graph)$y <- graph.simi$layout[,2]
1188         V(graph)$weight <- graph.simi$label.cex
1189         V(graph)$colors <- vertex.label.color
1190         E(graph)$weigth <- graph.simi$we.width
1191         write.graph(graph, fileout, format = 'graphml')
1192         """ % (self.pathout['RData.RData'], fileout)
1193         filetmp = tempfile.mktemp()
1194         with open(filetmp, 'w') as f :
1195             f.write(txt)
1196         exec_rcode(self.ira.RPath, filetmp)
1197         mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
1198         mss.CenterOnParent()
1199         mss.ShowModal()
1200         mss.Destroy()
1201
1202
1203 class GraphPanelSimi(wx.Panel):
1204     def __init__(self,parent, dico, list_graph):
1205         wx.Panel.__init__(self,parent)
1206         self.afcnb = 1
1207         self.Dict = dico
1208         self.dirout = os.path.dirname(self.Dict['ira'])
1209         self.parent = self.GetParent()#parent
1210         self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "courier"))
1211         self.labels = []
1212         self.listimg = []
1213         self.tabsimi = self.parent.GetParent()
1214         self.ira = self.tabsimi.GetParent()
1215         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1216         afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1217         self.butafc = wx.BitmapButton(self, -1, afc_img)
1218         export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1219         self.butexport = wx.BitmapButton(self, -1, export_img)
1220         for i in range(0,len(list_graph)):
1221             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1222                 filename, ext = os.path.splitext(list_graph[i][0])
1223                 if ext == '.svg' :
1224                     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])))
1225                 else :
1226                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1227                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1228
1229         self.__set_properties()
1230         self.__do_layout()
1231
1232     def __set_properties(self):
1233         self.panel_1.EnableScrolling(True,True)
1234         #self.panel_1.SetSize((1000,1000))
1235         self.panel_1.SetScrollRate(20, 20)
1236
1237     def __do_layout(self):
1238         self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1239         self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1240         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1241         self.sizer_2.Add(self.butafc, 0, 0, 0)
1242         self.sizer_2.Add(self.butexport, 0, 0, 0)
1243         for i in range(0, len(self.listimg)):
1244             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1245             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1246         self.panel_1.SetSizer(self.sizer_3)
1247         self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1248         self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1249         self.SetSizer(self.sizer_1)