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        panel.dictpathout = self.DictPathOut
 345        panel.pathout = self.DictPathOut
 346        panel.parent = self.parent
 347        panel.DictProfile = self.DictProfile
 348        panel.cluster_size = self.cluster_size
 349        panel.debtext = self.debtext
 350
 351 #       self.ID_rapport = wx.NewId()
 352 #       #rap_img = wx.Image(os.path.join(self.parent.images_path,'icone_rap_16.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
 353 #       #panel.chd_toolbar.AddLabelTool(self.ID_rapport, "rapport", rap_img, shortHelp=u"Produire le rapport", longHelp=u"Exporter un rapport en texte simple")
 354 #       butrap = wx.Button(panel.chd_toolbar, self.ID_rapport, u"Rapport ")
 355 #       panel.chd_toolbar.AddControl(butrap)
 356 #
 357 #       panel.chd_toolbar.Realize()
 358 #       sizer1.Add(panel.chd_toolbar,0, wx.EXPAND, 5)
 359
 360        #self.TabChdSim = wx.aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
 361        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
 362        panel.TabChdSim = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 363        panel.TabChdSim.SetAGWWindowStyleFlag(notebook_flags)
 364        panel.TabChdSim.SetArtProvider(aui.ChromeTabArt())
 365        sizer1.Add(panel.TabChdSim,10, wx.EXPAND, 5)
 366        panel.SetSizer(sizer1)
 367        sizer1.Fit(panel)
 368
 369
 370        if isinstance(self.corpus, Corpus) :
 371            panel.TabChdSim.corpus = corpus
 372            panel.TabChdSim.corpus.dictpathout = self.DictPathOut
 373        else :
 374            panel.TabChdSim.tableau = corpus
 375            panel.TabChdSim.tableau.dictpathout = self.DictPathOut
 376        panel.parametres = self.parametres
 377        self.panel = panel
 378
 379        self.notenb = self.parent.nb.GetPageCount()
 380
 381
 382        if os.path.exists(self.DictPathOut['liste_graph_chd']) :
 383            list_graph = read_list_file(self.DictPathOut['liste_graph_chd'], self.encoding)
 384            CHD = GraphPanelDendro(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
 385            panel.TabChdSim.AddPage(CHD,'CHD')
 386
 387        panel.ProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 388        panel.ProfNB.SetArtProvider(aui.ChromeTabArt())
 389        #self.ProfNB.SetTabCtrlHeight(100)
 390        #panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 391        if os.path.exists(DictPathOut['prof_seg']) :
 392             prof_seg = ReadProfileAsDico(DictPathOut['prof_seg'], False, self.encoding)
 393             self.prof_seg_nb = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
 394        for i in range(0, clnb):
 395             self.cluster_size.append(DictProfile[str(i + 1)][0][0:3])
 396             dlg.Update(3+i, 'Classe %i' %(i+1))
 397             ind = '/'.join(DictProfile[str(i + 1)][0][0:2])
 398             indpour = ' - '.join([ind, DictProfile[str(i + 1)][0][2]])
 399             self.tabprofile = ProfListctrlPanel(self.parent, self.panel, DictProfile[str(i + 1)], Alceste, i + 1)
 400             #self.tabantiprofile = ProfListctrlPanel(self.parent, self, DictAnti[str(i + 1)], Alceste, i + 1)
 401             panel.ProfNB.AddPage(self.tabprofile, 'classe %s %s(%s%%)' % (str(i + 1), sep, indpour))
 402             #panel.AntiProfNB.AddPage(self.tabantiprofile, 'classe %s' % str(i + 1))
 403             if os.path.exists(DictPathOut['prof_seg']) :
 404                 self.tab_prof_seg = ProfListctrlPanel(self.parent, self, prof_seg[str(i + 1)], False, i + 1)
 405                 self.prof_seg_nb.AddPage(self.tab_prof_seg, 'classe %i' % (i + 1))
 406
 407        if clnb > 2 :
 408            self.TabAFC = aui.AuiNotebook(panel.TabChdSim, -1, wx.DefaultPosition)
 409            log.info('read AFC')
 410            list_graph=read_list_file(DictPathOut['liste_graph_afc'], self.encoding)
 411            self.tabAFCGraph = GraphPanelAfc(self.TabAFC, DictPathOut, list_graph, self.clnb, coding=self.encoding)
 412            self.TabAFC.AddPage(self.tabAFCGraph, 'AFC')
 413
 414            if os.path.exists(self.DictPathOut['afc_facteur']) :
 415                dictrow, first = ReadList(self.DictPathOut['afc_facteur'], self.encoding)
 416                self.TabAFC_facteur = ListForSpec(self.parent, parametres, dictrow, first)
 417                #dictrow, first = ReadList(self.DictPathOut['afc_row'], self.encoding)
 418                #self.TabAFC_ligne = ListForSpec(self.parent, self.parametres, dictrow, first)
 419                #dictrow, first = ReadList(self.DictPathOut['afc_col'], self.encoding)
 420                #self.TabAFC_colonne = ListForSpec(parent, self.parametres, dictrow, first)
 421                self.TabAFC.AddPage(self.TabAFC_facteur, 'Facteurs')
 422                #self.TabAFC.AddPage(self.TabAFC_colonne, u'Colonnes')
 423                #self.TabAFC.AddPage(self.TabAFC_ligne, u'Lignes')
 424
 425            sizer_3 = wx.BoxSizer(wx.VERTICAL)
 426            self.parent.nb_panel_2 = wx.Panel(panel.TabChdSim, -1)
 427            self.parent.button_simi = wx.Button(self.parent.nb_panel_2, -1, "Voyager")
 428            self.parent.simi3dpanel = simi3d(self.parent.nb_panel_2, -1)
 429            sizer_3.Add(self.parent.simi3dpanel, 1, wx.EXPAND, 0)
 430            sizer_3.Add(self.parent.button_simi, 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
 431            self.parent.nb_panel_2.SetSizer(sizer_3)
 432            self.TabAFC.AddPage(self.parent.nb_panel_2, "graph 3D")
 433            self.parent.Bind(wx.EVT_BUTTON, self.onsimi, self.parent.button_simi)
 434
 435        panel.TabChdSim.AddPage(panel.ProfNB, 'Profils')
 436        #panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')
 437        dlg.Update(4 + self.clnb, 'Affichage...')
 438        if clnb > 2 :
 439            panel.TabChdSim.AddPage(self.TabAFC, 'AFC')
 440        if os.path.exists(DictPathOut['prof_seg']) :
 441            panel.TabChdSim.AddPage(self.prof_seg_nb, u'Profils des segments répétés')
 442
 443 #       panel.Bind(wx.EVT_BUTTON, self.ongetrapport, id = self.ID_rapport)
 444        self.parent.nb.AddPage(panel, 'Classification - %s' % corpname)
 445        self.parent.ShowTab(True)
 446        self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
 447        #for pane in self.parent._mgr.GetAllPanes() :
 448        #     if isinstance(pane.window, aui.AuiNotebook):
 449        #         nb = pane.window
 450        #         nb.SetAGWWindowStyleFlag(notebook_flags)
 451        #         nb.SetArtProvider(aui.ChromeTabArt())
 452        dlg.Destroy()
 453        self.parent._mgr.Update()
 454
 455     def onsimi(self,event):
 456         outfile = print_simi3d(self)
 457         error = exec_rcode(self.parent.RPath, outfile, wait = True)
 458
 459 #    def ongetrapport(self, event) :
 460 #        dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.txt', 'title': 'Rapport'})
 461 #        dial.fbb.SetValue(self.DictPathOut['rapport'])
 462 #        dial.CenterOnParent()
 463 #        res = dial.ShowModal()
 464 #        if res == wx.ID_OK :
 465 #            fileout = dial.fbb.GetValue()
 466 #            dial.Destroy()
 467 #            with open(fileout, 'w') as f :
 468 #                f.write(self.debtext + '\n' + GetTxtProfile(self.DictProfile, self.cluster_size))
 469 #            msg = u"Fini !"
 470 #            dlg = wx.MessageDialog(self.parent, msg, u"Rapport", wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
 471 #            dlg.CenterOnParent()
 472 #            dlg.ShowModal()
 473 #            dlg.Destroy()
 474 #        else :
 475 #            dial.Destroy()
 476
 477 #    def on_export_classes(self, event) :
 478 #        corpus = self.parent.nb.GetPage(self.parent.nb.GetSelection()).corpus
 479 #        dial = PrefExport(self, self.parent)
 480 #        dial.fbb.SetValue(os.path.join(os.path.dirname(corpus.dictpathout['ira']), 'export_corpus.txt'))
 481 #        dial.CenterOnParent()
 482 #        res = dial.ShowModal()
 483 #        if res == wx.ID_OK :
 484 #            if dial.radio_type.GetSelection() == 0 : alc = True
 485 #            else : alc = False
 486 #            if dial.radio_lem.GetSelection() == 0 : lem = True
 487 #            else : lem = False
 488 #            self.corpus.export_corpus_classes(dial.fbb.GetValue(), alc = alc, lem = lem)
 489 #            msg = u"Fini !"
 490 #            dial.Destroy()
 491 #            dlg = wx.MessageDialog(self.parent, msg, u"Export", wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
 492 #            dlg.CenterOnParent()
 493 #            dlg.ShowModal()
 494 #            dlg.Destroy()
 495
 496 #    def onprofseg(self, event):
 497 #        #try :
 498 #            print 'plus de bug profseg'
 499 #            print self.parametres
 500 #            corpus = self.parent.nb.GetPage(self.parent.nb.GetSelection()).corpus
 501 #            ProfileSegment(self.parent, self.dictpathout, self.parametres, corpus)
 502 #        #except :
 503 #        #    BugReport(self.parent)
 504 #
 505 #    def onproftype(self, event):
 506 #        try :
 507 #            corpus = self.parent.nb.GetPage(self.parent.nb.GetSelection()).corpus
 508 #            ProfilType(self.parent, corpus)
 509 #        except :
 510 #            BugReport(self.parent)
 511 #
 512 #    def oncolored(self,evt) :
 513 #        dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.html', 'title': 'Corpus en couleur'})
 514 #        dial.fbb.SetValue(os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'corpus_couleur.html'))
 515 #        dial.CenterOnParent()
 516 #        res = dial.ShowModal()
 517 #        if res == wx.ID_OK :
 518 #            fileout = dial.fbb.GetValue()
 519 #            dial.Destroy()
 520 #            txt = self.corpus.make_colored_corpus()
 521 #            with open(fileout, 'w') as f :
 522 #                f.write(txt)
 523 #            msg = u"Fini !\nVoulez-vous ouvrir le corpus dans votre navigateur ?"
 524 #            dlg = wx.MessageDialog(self.parent, msg, u"Corpus en couleur", wx.NO | wx.YES | wx.NO_DEFAULT | wx.ICON_QUESTION)
 525 #            dlg.CenterOnParent()
 526 #            if dlg.ShowModal() == wx.ID_YES :
 527 #                webbrowser.open(fileout)
 528 #            dlg.Destroy()
 529
 530     def onclusterstat(self, evt) :
 531         dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': 'Stat par classe'})
 532         dial.fbb.SetValue( os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'stat_par_classe.csv'))
 533         dial.CenterOnParent()
 534         res = dial.ShowModal()
 535         if res == wx.ID_OK :
 536             fileout = dial.fbb.GetValue()
 537             dial.Destroy()
 538             print fileout
 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         actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1055         #self.tableau.make_listactives()
1056         actives = dict([[i, val] for i, val in enumerate(actives)])
1057         #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1058         self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1059         self.dial.CenterOnParent()
1060         self.val = self.dial.ShowModal()
1061         if self.val == wx.ID_OK :
1062             last = self.dial.listcol.GetFirstSelected()
1063             lastl = [self.dial.listcol.GetFirstSelected()]
1064             indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1065             while self.dial.listcol.GetNextSelected(last) != -1:
1066                 last = self.dial.listcol.GetNextSelected(last)
1067                 lastl.append(last)
1068                 indexes.append(self.dial.listcol.getColumnText(last,0))
1069             self.column = [self.tableau.listactives.index(val) for val in indexes]
1070             self.column.sort()
1071             with open(self.pathout['selected.csv'], 'w') as f :
1072                 f.write('\n'.join([`val` for val in self.column]))
1073             self.make_param()
1074             self.dial.Destroy()
1075             self.script = PrintSimiScript(self)
1076             self.script.make_script()
1077             self.tmpfile = self.script.scriptout
1078             dlg = progressbar(self, maxi = 2)
1079             self.DoR(dlg)
1080             dlg.Destroy()
1081             if self.parametres['type_graph'] == 1:
1082                 if self.parametres['svg'] :
1083                     filename, ext = os.path.splitext(self.script.filename)
1084                     fileout = filename + '.svg'
1085                 else :
1086                     fileout = self.script.filename
1087                 if os.path.exists(self.pathout['liste_graph']):
1088                     graph_simi = read_list_file(self.pathout['liste_graph'])
1089                     graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1090                 else :
1091                     graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1092                 print_liste(self.pathout['liste_graph'], graph_simi)
1093             DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1094             if self.parametres['type_graph'] == 1:
1095                 if self.parametres['svg'] :
1096                     self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1097                 else :
1098                     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)
1099                 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1100                 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1101                 self.graphpan.Layout()
1102                 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1103         else :
1104             self.dial.Destroy()
1105
1106
1107     def make_param(self) :
1108         if self.parametres['first'] :
1109             keep_coord = False
1110         else :
1111             keep_coord = self.dial.check_coord.GetValue()
1112         #self.select = self.dial.check_colch.GetValue()
1113
1114         paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1115                           'layout' : self.dial.choice2.GetSelection(),
1116                           'type_graph' : self.dial.choice3.GetSelection(),
1117                           'arbremax' : self.dial.check1.GetValue(),
1118                           'coeff_tv' : self.dial.check_s_size.GetValue(),
1119                           'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1120                           'tvprop' : self.dial.check2.GetValue(),
1121                           'tvmin' : self.dial.spin_tvmin.GetValue(),
1122                           'tvmax' : self.dial.spin_tvmax.GetValue(),
1123                           'coeff_te' : self.dial.check3.GetValue(),
1124                           'coeff_temin' : self.dial.spin_temin.GetValue(),
1125                           'coeff_temax' : self.dial.spin_temax.GetValue(),
1126                           'label_e' : self.dial.check_elab.GetValue(),
1127                           'label_v' : self.dial.check_vlab.GetValue(),
1128                           'vcex' : self.dial.check_vcex.GetValue(),
1129                           'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1130                           'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1131                           'cex' : self.dial.spin_cex.GetValue(),
1132                           'seuil_ok' : self.dial.check_seuil.GetValue(),
1133                           'seuil' : self.dial.spin_seuil.GetValue(),
1134                           'cols' : self.dial.cols.GetColour(),
1135                           'cola' : self.dial.cola.GetColour(),
1136                           'width' : self.dial.spin_width.GetValue(),
1137                           'height' : self.dial.spin_height.GetValue(),
1138                           'first' : False,
1139                           'keep_coord' : keep_coord,
1140                           'alpha' : self.dial.slider_sphere.GetValue(),
1141                           'film' : self.dial.film.GetValue(),
1142                           'svg' : self.dial.choix_format.GetSelection(),
1143                           'halo' : self.dial.halo.GetValue(),
1144                           'com' : self.dial.comcheck.GetValue(),
1145                           'communities' : self.dial.choix_com.GetSelection(),
1146                           }
1147         if 'cexfromchi' in self.parametres :
1148             paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1149         if 'sfromchi' in self.parametres :
1150             paramsimi['sfromchi'] = self.dial.checki.GetValue()
1151         if 'vlabcolor' in self.parametres :
1152            paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1153         if 'check_bystar' in dir(self.dial) :
1154             paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1155             paramsimi['stars'] = self.parametres['stars']
1156         self.parametres.update(paramsimi)
1157
1158     def DoR(self, dlg):
1159         if self.parametres['type_graph'] == 1 :
1160             graph = False
1161             wait = False
1162         else :
1163             graph = True
1164             wait = True
1165         pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1166         if self.parametres['type_graph'] == 1 :
1167             while pid.poll() == None :
1168                 dlg.Pulse(u'R ...')
1169                 sleep(0.2)
1170             check_Rresult(self.parent, pid)
1171
1172     def export(self, evt) :
1173         nb = 1
1174         while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1175             nb +=1
1176         fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1177         txt = """
1178         library(igraph)
1179         load("%s")
1180         fileout <- "%s"
1181         graph <- graph.simi$graph
1182         V(graph)$x <- graph.simi$layout[,1]
1183         V(graph)$y <- graph.simi$layout[,2]
1184         V(graph)$weight <- graph.simi$label.cex
1185         V(graph)$colors <- vertex.label.color
1186         E(graph)$weigth <- graph.simi$we.width
1187         write.graph(graph, fileout, format = 'graphml')
1188         """ % (self.pathout['RData.RData'], fileout)
1189         filetmp = tempfile.mktemp()
1190         with open(filetmp, 'w') as f :
1191             f.write(txt)
1192         exec_rcode(self.ira.RPath, filetmp)
1193         mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
1194         mss.CenterOnParent()
1195         mss.ShowModal()
1196         mss.Destroy()
1197
1198
1199 class GraphPanelSimi(wx.Panel):
1200     def __init__(self,parent, dico, list_graph):
1201         wx.Panel.__init__(self,parent)
1202         self.afcnb = 1
1203         self.Dict = dico
1204         self.dirout = os.path.dirname(self.Dict['ira'])
1205         self.parent = self.GetParent()#parent
1206         self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "courier"))
1207         self.labels = []
1208         self.listimg = []
1209         self.tabsimi = self.parent.GetParent()
1210         self.ira = self.tabsimi.GetParent()
1211         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1212         afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1213         self.butafc = wx.BitmapButton(self, -1, afc_img)
1214         export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1215         self.butexport = wx.BitmapButton(self, -1, export_img)
1216         for i in range(0,len(list_graph)):
1217             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1218                 filename, ext = os.path.splitext(list_graph[i][0])
1219                 if ext == '.svg' :
1220                     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])))
1221                 else :
1222                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1223                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1224
1225         self.__set_properties()
1226         self.__do_layout()
1227
1228     def __set_properties(self):
1229         self.panel_1.EnableScrolling(True,True)
1230         #self.panel_1.SetSize((1000,1000))
1231         self.panel_1.SetScrollRate(20, 20)
1232
1233     def __do_layout(self):
1234         self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1235         self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1236         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1237         self.sizer_2.Add(self.butafc, 0, 0, 0)
1238         self.sizer_2.Add(self.butexport, 0, 0, 0)
1239         for i in range(0, len(self.listimg)):
1240             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1241             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1242         self.panel_1.SetSizer(self.sizer_3)
1243         self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1244         self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1245         self.SetSizer(self.sizer_1)