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