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