2 # -*- coding: utf-8 -*-
3 #Author: Pierre Ratinaud
4 #Copyright (c) 2008-2009 Pierre Ratinaud
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
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
23 from search_tools import SearchFrame
24 from dialog import PrefGraph, PrefExport, PrefSimpleFile, PrefDendro, SimpleDialog
25 from guifunct import SelectColumn, PrepSimi, PrefSimi
26 from webexport import WebExport
27 from corpus import Corpus
28 from sheet import MySheet
32 from time import sleep
37 log = logging.getLogger('iramuteq.layout')
40 class GraphPanelAfc(wx.Panel):
41 def __init__(self, parent, dico, list_graph, clnb, itempath = 'liste_graph_afc', coding = sys.getdefaultencoding()):
42 wx.Panel.__init__(self,parent)
47 self.itempath = itempath
48 self.parent = self.GetParent()#parent
49 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
53 self.list_graph = list_graph
54 self.TabCHD = self.parent.GetParent()
55 self.nb = self.TabCHD.GetParent()
56 self.ira = self.nb.GetParent()
57 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
58 afc_img = wx.Image(os.path.join(self.ira.images_path,'button_afc.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
59 self.butafc = wx.BitmapButton(self, -1, afc_img)
60 self.Bind(wx.EVT_BUTTON, self.afc_graph, self.butafc)
61 self.dirout = os.path.dirname(self.Dict['ira'])
64 for i in range(0,len(list_graph)):
65 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
66 filename, ext = os.path.splitext(list_graph[i][0])
67 if ext == '.svg' or ext == '.html':
68 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])))
70 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
71 if os.path.exists(os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')) :
72 txt = _(u"List of not plotted points : ").decode('utf8') + '%s' % os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')
75 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1] + txt))
76 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = `i - b`))
80 self.list_graph = [graph for i, graph in enumerate(self.list_graph) if i not in todel]
82 self.param = { 'typegraph' : 0,
89 'do_select_chi_classe' : 0,
107 self.__set_properties()
110 def __set_properties(self):
111 self.panel_1.EnableScrolling(True,True)
112 #self.panel_1.SetSize((1000,1000))
113 self.panel_1.SetScrollRate(20, 20)
114 self.panel_1.SetFocus()
116 def __do_layout(self):
117 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
118 self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
119 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
120 self.sizer_2.Add(self.butafc, 0, 0, 0)
121 for i in range(0, len(self.listimg)):
122 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
123 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
124 self.sizer_3.Add(self.buts[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
125 self.Bind(wx.EVT_BUTTON, self.on_delete_image, self.buts[i])
126 self.panel_1.SetSizer(self.sizer_3)
127 self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
128 self.SetSizer(self.sizer_2)
130 def on_delete_image(self, event) :
131 image_id = int(event.GetEventObject().GetName())
132 image_path = self.list_graph[image_id][0]
133 message = _(u'This file will be delete : ') + '%s.\n' % os.path.join(self.dirout, image_path) + _('Are you sure ?')
134 dial = wx.MessageDialog(self, message, style = wx.YES_NO)
135 res = dial.ShowModal()
136 if res == wx.ID_YES :
138 log.info('delete image %i' % image_id)
139 oldimg = self.listimg.pop(image_id)
141 oldlab = self.labels.pop(image_id)
143 oldbut = self.buts.pop(image_id)
145 for i, but in enumerate(self.buts) :
147 todel = self.list_graph.pop(image_id)
148 os.remove(os.path.join(self.dirout, todel[0]))
149 print_liste(self.Dict[self.itempath], self.list_graph)
150 self.sizer_3.Fit(self.panel_1)
156 def afc_graph(self,event):
157 #dirout = os.path.dirname(self.Dict['ira'])
158 dial = PrefGraph(self.parent,-1,self.param,'')
159 dial.CenterOnParent()
160 val = dial.ShowModal()
162 if dial.choix_format.GetSelection() == 0 :
166 typegraph = dial.choicetype.GetSelection()
168 if self.clnb <= 3 and typegraph == 1 :
172 while os.path.exists(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile)):
174 self.fileout = ffr(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile))
176 self.param = {'typegraph' : typegraph,
177 'width' : dial.spin1.GetValue(),
178 'height' : dial.spin2.GetValue(),
179 'what' : dial.choice1.GetSelection(),
180 'qui' : dial.choice2.GetSelection(),
181 'do_select_nb' : dial.check1.GetValue(),
182 'do_select_chi' : dial.check2.GetValue(),
183 'do_select_chi_classe' : dial.check_chic.GetValue(),
184 'select_nb' : dial.spin_nb.GetValue(),
185 'select_chi' : dial.spin_chi.GetValue(),
186 'nbchic' : dial.spin_nbchic.GetValue(),
187 'over' : dial.check3.GetValue(),
188 'cex_txt' : dial.check4.GetValue(),
189 'txt_min' : dial.spin_min.GetValue(),
190 'txt_max' : dial.spin_max.GetValue(),
191 'tchi' : dial.check_tchi.GetValue(),
192 'tchi_min' : dial.spin_min_tchi.GetValue(),
193 'tchi_max' : dial.spin_max_tchi.GetValue(),
194 'taillecar' : dial.spin3.GetValue(),
195 'facteur' : [dial.spin_f1.GetValue(),dial.spin_f2.GetValue(), dial.spin_f3.GetValue()],
197 'film' : str(dial.film.GetValue()).upper(),
198 'alpha' : dial.slider_sphere.GetValue(),
201 self.nb.parent = self.ira
202 self.DictPathOut = self.Dict
203 self.RscriptsPath = self.ira.RscriptsPath
206 """ % self.DictPathOut['RData']
207 if self.itempath == 'liste_graph_afcf' :
210 afc_table <- afcf_table
211 chistabletot <- specfp
213 elif self.itempath == 'liste_graph_afct' :
216 afc_table <- afct_table
217 chistabletot <- spectp
219 txt += write_afc_graph(self)
220 filetmp = tempfile.mktemp()
221 with open(filetmp, 'w') as f :
223 pid = exec_rcode(self.ira.RPath, filetmp)
224 check_Rresult(self.ira, pid)
225 if self.param['typegraph'] in [0,2] :
227 if self.param['qui'] == 0 : value = u'actives'
228 if self.param['qui'] == 1 : value = u'supplémentaires'
229 if self.param['qui'] == 2 : value = u'étoilées'
230 if self.param['qui'] == 3 : value = u'classes'
232 if self.param['what'] == 0 : value = u'Coordonnées'
233 if self.param['what'] == 1 : value = u'Corrélations'
234 txt += value + u' - facteur %i / %i' % (self.param['facteur'][0], self.param['facteur'][1])
235 if self.param['do_select_nb'] : txt += u' - sélection de %i variables' % self.param['select_nb']
236 if self.param['do_select_chi'] : txt += u' - sélection des variables avec chi2 > %i ' % self.param['select_chi']
237 if self.param['over'] : txt += u' - Eviter les recouvrements'
238 if self.param['cex_txt'] : txt += u' - taille du texte proportionnel à la masse'
239 if self.param['tchi'] : txt += u' - taille du texte proportionnel au chi2 d\'association'
240 #list_graph = read_list_file(self.DictPathOut[self.itempath], self.coding)
241 if self.param['svg'] :
242 filename, ext = os.path.splitext(self.fileout)
243 self.fileout = filename + '.svg'
244 if self.param['typegraph'] == 2 :
245 parametres = {'gexffile' : self.fileout,
247 'nodemin': self.param['txt_min'],
248 'nodemax': self.param['txt_max'],
249 'bargraphw' : 60*int(self.param['clnb']),
251 web = WebExport(self.ira, parametres)
252 self.fileout = web.exportafc()
253 self.list_graph.append([os.path.basename(self.fileout), txt])
254 print_liste(self.DictPathOut[self.itempath], self.list_graph)
255 if self.param['svg'] or self.param['typegraph'] == 2:
256 self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, self.fileout, URL=self.fileout))
259 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(self.fileout, wx.BITMAP_TYPE_ANY)))
260 self.sizer_3.Add( self.listimg[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
261 self.labels.append(wx.StaticText(self.panel_1,-1, txt))
262 self.sizer_3.Add(self.labels[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
263 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = `len(self.list_graph) - 1`))
264 self.sizer_3.Add(self.buts[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
265 self.sizer_3.Fit(self.panel_1)
268 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
269 # elif self.param['typegraph'] == 2 :
270 # parametres = {'gexffile' : self.fileout,
271 # 'titre': 'Le titre',
272 # 'nodemin': self.param['txt_min'],
273 # 'nodemax': self.param['txt_max'],
274 # 'bargraphw' : 60*int(self.param['clnb']),
276 # web = WebExport(self.ira, parametres)
277 # afcout = web.exportafc()
278 # dial = SimpleDialog(self.ira)
279 # dial.link.SetLabel(afcout)
280 # dial.link.SetURL(afcout)
285 class GraphPanel(wx.ScrolledWindow):
286 def __init__(self, parent, dico, list_graph, txt = '', style = wx.TAB_TRAVERSAL):
287 wx.ScrolledWindow.__init__(self, parent, style = style)
291 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
294 self.dirout = os.path.dirname(self.Dict['ira'])
295 self.deb = wx.StaticText(self, -1, txt)
296 for i in range(0,len(list_graph)):
297 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
298 filename, ext = os.path.splitext(list_graph[i][0])
300 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])))
302 self.listimg.append(wx.StaticBitmap(self, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
303 self.labels.append(wx.StaticText(self, -1, list_graph[i][1]))
304 self.Bind(wx.EVT_MOTION, self.onMouseMove)
305 self.__set_properties()
308 def __set_properties(self):
309 self.EnableScrolling(True,True)
310 self.SetScrollRate(20, 20)
314 def __do_layout(self):
315 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
316 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
317 self.sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
318 self.sizer_1.Add(self.deb)
319 for i in range(0, len(self.listimg)):
320 self.sizer_1.Add(self.listimg[i], 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
321 self.sizer_1.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
322 self.sizer_2.Add(self.sizer_1, 1, wx.EXPAND, 0)
323 self.SetSizer(self.sizer_1)
324 self.sizer_1.Fit(self)
326 def onMouseMove(self, event):
330 def open_antiprofil(panel, AntiProfile, encoding) :
331 DictAnti = ReadProfileAsDico(AntiProfile, True, encoding)
332 panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
333 for i in range(0, panel.parametres['clnb']):
334 tabantiprofile = ProfListctrlPanel(panel, panel, DictAnti[str(i + 1)], True, i + 1)
335 panel.AntiProfNB.AddPage(tabantiprofile, 'classe %s' % str(i + 1))
336 panel.TabChdSim.AddPage(panel.AntiProfNB, _(u"Antiprofiles").decode('utf8'))
340 def getlemgram(corpus, lem) :
341 if not lem[6] in corpus.lems :
344 return corpus.lems[lem[6]].gram
347 def __init__(self, parent, corpus, parametres, Alceste=False):
352 self.parametres = parametres
353 self.pathout = PathOut(parametres['ira'])
354 self.pathout.basefiles(ChdTxtPathOut)
355 DictPathOut = self.pathout
356 self.DictPathOut = DictPathOut
357 self.dictpathout = DictPathOut
360 Profile = DictPathOut['PROFILE_OUT']
361 AntiProfile = DictPathOut['ANTIPRO_OUT']
362 self.encoding = self.parametres['encoding']
363 if isinstance(self.corpus, Corpus) :
364 self.corpus.make_ucecl_from_R(self.pathout['uce'])
365 corpname = self.corpus.parametres['corpus_name']
367 corpname = self.corpus.parametres['matrix_name']
368 if os.path.exists(self.pathout['analyse.db']) :
369 self.corpus.read_tableau(self.pathout['analyse.db'])
371 clnb = parametres['clnb']
372 dlg = progressbar(self, maxi = 4 + clnb)
374 print 'lecture des profils'
375 dlg.Update(2, _(u"Reading profiles").decode('utf8'))
377 DictProfile = ReadProfileAsDico(Profile, Alceste, self.encoding)
378 self.DictProfile = DictProfile
379 self.cluster_size = []
381 for i in range(0, clnb) :
382 clusternames[i] = ' '.join([u'%i' % (i + 1), _(u'Cluster').decode('utf8'), u'%i' % (i + 1)])
383 if os.path.exists(self.pathout['classes_names.txt']) :
384 with codecs.open(self.pathout['classes_names.txt'], 'r', self.parent.syscoding) as f :
385 clusternames_ = f.read()
386 clusternames_ = dict([[i, ' '.join([`i + 1`, line])] for i, line in enumerate(clusternames_.splitlines())])
387 clusternames.update(clusternames_)
388 #print 'lecture des antiprofils'
389 #DictAnti = ReadProfileAsDico(self, AntiProfile, Alceste, self.encoding)
391 panel = wx.Panel(parent, -1)
392 sizer1 = wx.BoxSizer(wx.VERTICAL)
394 if os.path.exists(DictPathOut['pre_rapport']):
395 with codecs.open(DictPathOut['pre_rapport'], 'r', self.encoding) as f :
400 # panel.chd_toolbar = wx.ToolBar(panel, -1, wx.DefaultPosition, wx.DefaultSize, wx.TB_FLAT | wx.TB_NODIVIDER)
401 # panel.chd_toolbar.SetToolBitmapSize(wx.Size(16, 16))
403 if isinstance(self.corpus, Corpus) :
404 panel.corpus = self.corpus
406 panel.tableau = self.corpus
407 #self.parent.tableau = panel.tableau
408 panel.dictpathout = self.DictPathOut
409 panel.pathout = self.DictPathOut
410 panel.parent = self.parent
411 panel.DictProfile = self.DictProfile
412 panel.cluster_size = self.cluster_size
413 panel.debtext = self.debtext
415 # self.ID_rapport = wx.NewId()
416 # #rap_img = wx.Image(os.path.join(self.parent.images_path,'icone_rap_16.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
417 # #panel.chd_toolbar.AddLabelTool(self.ID_rapport, "rapport", rap_img, shortHelp=u"Produire le rapport", longHelp=u"Exporter un rapport en texte simple")
418 # butrap = wx.Button(panel.chd_toolbar, self.ID_rapport, u"Rapport ")
419 # panel.chd_toolbar.AddControl(butrap)
421 # panel.chd_toolbar.Realize()
422 # sizer1.Add(panel.chd_toolbar,0, wx.EXPAND, 5)
424 #self.TabChdSim = wx.aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
425 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
426 panel.TabChdSim = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
427 #panel.TabChdSim = LB.LabelBook(panel, -1, agwStyle = INB_TOP|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
428 panel.TabChdSim.SetAGWWindowStyleFlag(notebook_flags)
429 panel.TabChdSim.SetArtProvider(aui.ChromeTabArt())
430 sizer1.Add(panel.TabChdSim,10, wx.EXPAND, 5)
431 panel.SetSizer(sizer1)
435 if isinstance(self.corpus, Corpus) :
436 panel.TabChdSim.corpus = corpus
437 panel.TabChdSim.corpus.dictpathout = self.DictPathOut
439 panel.TabChdSim.tableau = corpus
440 panel.TabChdSim.tableau.dictpathout = self.DictPathOut
441 panel.parametres = self.parametres
444 self.notenb = self.parent.nb.GetPageCount()
447 if os.path.exists(self.DictPathOut['liste_graph_chd']) :
448 list_graph = read_list_file(self.DictPathOut['liste_graph_chd'], self.encoding)
449 CHD = GraphPanelDendro(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
450 panel.TabChdSim.AddPage(CHD,'CHD')
452 panel.ProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
453 notebook_flags |= aui.AUI_NB_WINDOWLIST_BUTTON
454 panel.ProfNB.SetAGWWindowStyleFlag(notebook_flags)
455 #panel.ProfNB.SetArtProvider(aui.ChromeTabArt())
456 #panel.ProfNB = LB.LabelBook(panel, -1, agwStyle = INB_LEFT|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
457 #panel.ProfNB = wx.Listbook(self.parent, -1, style = wx.BK_DEFAULT)
458 #panel.ProfNB = wx.Treebook(self.parent, -1, style = wx.BK_DEFAULT)
459 #self.ProfNB.SetTabCtrlHeight(100)
460 #panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
461 if os.path.exists(DictPathOut['prof_seg']) :
462 prof_seg = ReadProfileAsDico(DictPathOut['prof_seg'], False, self.encoding)
463 self.prof_seg_nb = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
464 for i in range(0, clnb):
465 self.cluster_size.append(DictProfile[str(i + 1)][0][0:3])
466 if isinstance(self.corpus, Corpus) :
467 DictProfile[str(i + 1)][1:] = [val[0:5] + [getlemgram(self.corpus, val)] + val[6:] for val in DictProfile[str(i + 1)][1:]]
468 dlg.Update(3+i, 'Classe %i' %(i+1))
469 ind = '/'.join(DictProfile[str(i + 1)][0][0:2]).strip()
470 indpour = '\n'.join([ind, DictProfile[str(i + 1)][0][2]])
471 self.tabprofile = ProfListctrlPanel(self.parent, self.panel, DictProfile[str(i + 1)], Alceste, i + 1)
472 #self.tabantiprofile = ProfListctrlPanel(self.parent, self, DictAnti[str(i + 1)], Alceste, i + 1)
473 panel.ProfNB.AddPage(self.tabprofile, clusternames[i] + '\n%s%%' % indpour, True)
474 panel.ProfNB.SetPageTextColour(i, '#890909')
475 panel.ProfNB.SetRenamable(i, True)
476 #panel.AntiProfNB.AddPage(self.tabantiprofile, 'classe %s' % str(i + 1))
477 if os.path.exists(DictPathOut['prof_seg']) :
478 self.tab_prof_seg = ProfListctrlPanel(self.parent, self, prof_seg[str(i + 1)], False, i + 1)
479 self.prof_seg_nb.AddPage(self.tab_prof_seg, _(u"Cluster").decode('utf8') + ' %i' % (i + 1))
480 panel.ProfNB.SetSelection(0)
483 self.TabAFC = aui.AuiNotebook(panel.TabChdSim, -1, wx.DefaultPosition)
485 list_graph=read_list_file(DictPathOut['liste_graph_afc'], self.encoding)
486 self.tabAFCGraph = GraphPanelAfc(self.TabAFC, DictPathOut, list_graph, self.clnb, coding=self.encoding)
487 self.TabAFC.AddPage(self.tabAFCGraph, _(u"CA").decode('utf8'))
489 if os.path.exists(self.DictPathOut['afc_facteur']) :
490 dictrow, first = ReadList(self.DictPathOut['afc_facteur'], self.encoding)
491 self.TabAFC_facteur = ListForSpec(self.parent, parametres, dictrow, first[1:])
492 #dictrow, first = ReadList(self.DictPathOut['afc_row'], self.encoding)
493 #self.TabAFC_ligne = ListForSpec(self.parent, self.parametres, dictrow, first)
494 #dictrow, first = ReadList(self.DictPathOut['afc_col'], self.encoding)
495 #self.TabAFC_colonne = ListForSpec(parent, self.parametres, dictrow, first)
496 self.TabAFC.AddPage(self.TabAFC_facteur, _(u"Factor").decode('utf8'))
497 #self.TabAFC.AddPage(self.TabAFC_colonne, u'Colonnes')
498 #self.TabAFC.AddPage(self.TabAFC_ligne, u'Lignes')
500 sizer_3 = wx.BoxSizer(wx.VERTICAL)
501 self.parent.nb_panel_2 = wx.Panel(panel.TabChdSim, -1)
502 self.parent.button_simi = wx.Button(self.parent.nb_panel_2, -1, "Voyager")
503 self.parent.simi3dpanel = simi3d(self.parent.nb_panel_2, -1)
504 sizer_3.Add(self.parent.simi3dpanel, 1, wx.EXPAND, 0)
505 sizer_3.Add(self.parent.button_simi, 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
506 self.parent.nb_panel_2.SetSizer(sizer_3)
507 self.TabAFC.AddPage(self.parent.nb_panel_2, _(u"3D graph").decode('utf8'))
508 self.parent.Bind(wx.EVT_BUTTON, self.onsimi, self.parent.button_simi)
510 panel.TabChdSim.AddPage(panel.ProfNB, _(u"Profiles").decode('utf8'))
511 #panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')
512 dlg.Update(4 + self.clnb, 'Affichage...')
514 panel.TabChdSim.AddPage(self.TabAFC, _(u"CA").decode('utf8'))
515 if os.path.exists(DictPathOut['prof_seg']) :
516 panel.TabChdSim.AddPage(self.prof_seg_nb, _(u"Repeated segments profiles").decode('utf8'))
518 # panel.Bind(wx.EVT_BUTTON, self.ongetrapport, id = self.ID_rapport)
519 self.parent.nb.AddPage(panel, _(u"Clustering").decode('utf8') + ' - %s' % corpname)
520 self.parent.ShowTab(True)
521 self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
522 #for pane in self.parent._mgr.GetAllPanes() :
523 # if isinstance(pane.window, aui.AuiNotebook):
525 # nb.SetAGWWindowStyleFlag(notebook_flags)
526 # nb.SetArtProvider(aui.ChromeTabArt())
528 self.parent._mgr.Update()
530 def onsimi(self,event):
531 outfile = print_simi3d(self)
532 error = exec_rcode(self.parent.RPath, outfile, wait = True)
534 def onclusterstat(self, evt) :
535 dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': 'Stat par classe'})
536 dial.fbb.SetValue( os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'stat_par_classe.csv'))
537 dial.CenterOnParent()
538 res = dial.ShowModal()
540 fileout = dial.fbb.GetValue()
542 self.corpus.get_stat_by_cluster(fileout)
544 dlg = wx.MessageDialog(self.parent, msg, _(u"Stat by cluster").decode('utf8'), wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
546 if dlg.ShowModal() == wx.ID_OK :
549 #def onsearchf(self, evt) :
550 # if 'FrameSearch' not in dir(self.panel) :
551 # self.panel.FrameSearch = SearchFrame(self.parent, -1, u"Rechercher...", self.corpus)
552 # self.panel.FrameSearch.Show()
554 def PrintRapport(self, corpus, parametres, istxt = True):
558 |i|R|a|M|u|T|e|Q| - %s
562 """ % datetime.datetime.now().ctime()
564 totocc = corpus.gettotocc()
565 txt += u'nombre de textes: %i%s' % (corpus.getucinb(), sep)
566 txt += u'nombre de segments de textes: %i%s' % (corpus.getucenb(), sep)
567 txt += u'nombre de formes: %i%s' % (len(corpus.formes), sep)
568 txt += u'nombre d\'occurrences: %i%s' % (totocc, sep)
569 txt += u'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
570 txt += u'nombre de lemmes: %i%s' % (len(corpus.lems), sep)
571 txt += u'nombre de formes actives: %i%s' % (corpus.getactivesnb(1), sep)
572 txt += u'nombre de formes supplémentaires: %i%s' % (corpus.getactivesnb(2), sep)
573 txt += u'nombre de formes actives de fréquence >= %i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)
574 txt += u'moyenne d\'occurrences par segments :%f%s' % (float(totocc) / float(corpus.getucenb()), sep)
575 if 'tailleuc1' in parametres :
576 if parametres['classif_mode'] == 0 :
577 txt += u'taille rst1 / rst2: %i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)
579 self.Ucenb = self.nbind
580 txt += u'nombre d\'individus : %i%s' % (self.nbind, sep)
581 txt += u'nombre de classes : %i%s' % (self.clnb, sep)
583 txt += u'nombre de classes : %i%s' % (parametres['clnb'], sep)
584 if parametres['classif_mode'] == 0 or parametres['classif_mode'] == 1 :
585 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)
586 elif self.parametres['classif_mode'] == 2 :
587 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)
589 txt += u'%i segments classées sur %i (%.2f%%)%s' % (self.ucecla, self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)
592 ###########################
594 ###########################
595 """ % parametres.get('time', '')
596 with open(self.pathout['pre_rapport'], 'w') as f :
600 class SashList(wx.Panel) :
601 def __init__(self, parent) :
602 wx.Panel.__init__(self, parent, -1)
605 #self.gparent=gparent
609 # A window to the left of the client window
610 #self.listlex = listlex
611 self.leftwin1 = wx.SashLayoutWindow(
612 self, -1, wx.DefaultPosition, (200, 300),
613 wx.NO_BORDER|wx.SW_3D
616 self.leftwin1.SetDefaultSize((120, 1000))
617 self.leftwin1.SetOrientation(wx.LAYOUT_VERTICAL)
618 self.leftwin1.SetAlignment(wx.LAYOUT_LEFT)
619 self.leftwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
620 self.leftwin1.SetSashVisible(wx.SASH_RIGHT, True)
621 self.leftwin1.SetExtraBorderSize(10)
623 #textWindow = wx.TextCtrl(
624 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
625 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
628 #textWindow.SetValue("A sub window")
630 self.leftWindow1 = self.leftwin1
631 winids.append(self.leftwin1.GetId())
633 rightwin1 = wx.SashLayoutWindow(
634 self, -1, wx.DefaultPosition, (200, 300),
635 wx.NO_BORDER|wx.SW_3D
638 rightwin1.SetDefaultSize((120, 1000))
639 rightwin1.SetOrientation(wx.LAYOUT_VERTICAL)
640 rightwin1.SetAlignment(wx.LAYOUT_LEFT)
641 rightwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
642 rightwin1.SetSashVisible(wx.SASH_RIGHT, True)
643 rightwin1.SetExtraBorderSize(10)
644 #textWindow = wx.TextCtrl(
645 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
646 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
649 #textWindow.SetValue("A sub window")
651 self.rightwin1 = rightwin1
652 winids.append(rightwin1.GetId())
655 def __init__(self, page):
657 parametres = self.page.parametres
658 ira = wx.GetApp().GetTopWindow()
659 self.page.tgens, etoiles = ReadList(parametres['tgenspec'], ira.syscoding, sep="\t")
661 for i in range(page.GetPageCount()) :
662 tab = page.GetPage(i)
663 if 'tgen' in dir(tab) :
668 self.page.tgentab.RefreshData(self.page.tgens)
669 self.page.SetSelection(i)
671 self.page.tgentab = ListForSpec(ira, None, self.page.tgens, etoiles[1:])
672 self.page.tgentab.tgen = True
673 self.page.AddPage(self.page.tgentab, u'Tgens Specificities')
674 self.page.SetSelection(self.page.GetPageCount() - 1)
677 def __init__(self, ira, corpus, parametres):
678 self.pathout = PathOut(dirout = parametres['pathout'])
680 self.dictpathout = StatTxtPathOut(parametres['pathout'])
681 #self.corpus.read_corpus_from_shelves(self.corpus.dictpathout['db'])
683 self.encoding = self.corpus.parametres['syscoding']
684 self.parametres = parametres
686 self.DictSpec, first = ReadList(self.dictpathout['tablespecf'], self.corpus.parametres['syscoding'])
687 if os.path.exists(self.pathout['banalites.csv']) :
688 self.dictban, firstban = ReadList(self.pathout['banalites.csv'], self.corpus.parametres['syscoding'])
689 self.DictType, firstt = ReadList(self.dictpathout['tablespect'], self.corpus.parametres['syscoding'])
690 self.DictEff, firsteff = ReadList(self.dictpathout['tableafcm'], self.corpus.parametres['syscoding'])
691 self.DictEffType, firstefft = ReadList(self.dictpathout['tabletypem'], self.corpus.parametres['syscoding'])
692 self.DictEffRelForme, firsteffrelf = ReadList(self.dictpathout['eff_relatif_forme'], self.corpus.parametres['syscoding'])
693 self.DictEffRelType, firsteffrelt = ReadList(self.dictpathout['eff_relatif_type'], self.corpus.parametres['syscoding'])
694 self.etoiles = firsteff[1:]
695 #sash = SashList(ira.nb)
698 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
699 self.TabStat.parametres = parametres
700 self.ListPan = ListForSpec(ira, self, self.DictSpec, self.etoiles)
701 if os.path.exists(self.pathout['banalites.csv']) :
702 self.listban = ListForSpec(ira, self, self.dictban, ['eff'] + self.etoiles)
703 #self.ListPan2 = ListForSpec(sash.rightwin1, self, self.DictSpec, first)
704 self.ListPant = ListForSpec(ira, self, self.DictType, self.etoiles)
705 self.ListPanEff = ListForSpec(ira, self, self.DictEff, self.etoiles)
706 self.ListPanEffType = ListForSpec(ira, self, self.DictEffType, self.etoiles)
707 self.ListPanEffRelForme = ListForSpec(ira, self, self.DictEffRelForme, self.etoiles)
708 self.ListPanEffRelType = ListForSpec(ira, self.parent, self.DictEffRelType, self.etoiles)
710 self.TabStat.AddPage(self.ListPan, u'formes')
711 if os.path.exists(self.pathout['banalites.csv']) :
712 self.TabStat.AddPage(self.listban, u'banalités')
713 self.TabStat.AddPage(self.ListPant, u'Types')
714 self.TabStat.AddPage(self.ListPanEff, u'Effectifs formes')
715 self.TabStat.AddPage(self.ListPanEffType, u'Effectifs Type')
716 self.TabStat.AddPage(self.ListPanEffRelForme, u'Effectifs relatifs formes')
717 self.TabStat.AddPage(self.ListPanEffRelType, u'Effectifs relatifs Type')
718 if self.parametres['clnb'] > 2 :
719 self.TabAFC = aui.AuiNotebook(self.TabStat, -1, wx.DefaultPosition)
720 list_graph=read_list_file(self.dictpathout['liste_graph_afcf'], encoding = self.encoding)
721 self.tabAFCGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afcf', coding = self.encoding)
722 self.TabAFC.AddPage(self.tabAFCGraph, 'AFC formes')
723 list_graph=read_list_file(self.dictpathout['liste_graph_afct'], encoding = self.encoding)
724 self.tabAFCTGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afct', coding=self.encoding)
725 self.TabAFC.AddPage(self.tabAFCTGraph, 'AFC type')
726 self.TabStat.AddPage(self.TabAFC, 'AFC')
732 ira.nb.AddPage(self.TabStat, u'Spécificités')
735 self.TabStat.corpus = self.corpus
736 self.TabStat.etoiles = self.etoiles
737 if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenspec.csv')) :
738 self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenspec.csv')
739 TgenLayout(self.TabStat)
740 self.TabStat.SetSelection(0)
741 ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
742 ira.ShowAPane("Tab_content")
745 def __init__(self, ira, corpus, parametres):
746 self.pathout = PathOut(dirout = parametres['pathout'])
750 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
751 self.TabStat.parametres = parametres
752 self.TabStat.corpus = corpus
753 self.TabStat.pathout = self.pathout
754 # CHD = GraphPanel(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
755 # panel.TabChdSim.AddPage(CHD,'CHD')
757 #self.TabStatTot = wx.TextCtrl(self.TabStat, -1, style=wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2)
758 list_graph = [['zipf.png', 'zipf']]
759 self.TabStatTot = GraphPanel(ira.nb, self.pathout, list_graph, self.result['glob'])
760 self.TabStat.AddPage(self.TabStatTot, 'global')
761 for item in self.result:
763 datam = [['forme', 'nb']]
764 self.ListPan = ListPanel(ira, self, self.result[item])
765 self.TabStat.AddPage(self.ListPan, ' '.join(item.split('_')))
766 ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
767 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
768 ira.ShowAPane("Tab_content")
770 def read_result(self) :
771 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'}
774 with open(self.pathout[lcle[key]], 'r') as f :
775 self.result[key] = [line.split(';') for line in f.read().splitlines()]
776 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
777 with open(self.pathout['glob.txt'], 'r') as f :
778 self.result['glob'] = f.read()
780 class GraphPanelDendro(wx.Panel):
781 def __init__(self,parent, dico, list_graph, txt=False):
782 wx.Panel.__init__(self,parent)
784 self.dictpathout = dico
785 self.dirout = os.path.dirname(self.dictpathout['ira'])
786 self.list_graph = list_graph
787 self.parent = self.GetParent()#parent
788 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
791 self.tabchd = self.parent.GetParent()
792 self.ira = self.tabchd.GetParent()
793 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
794 self.panel_1.SetBackgroundColour('white')
795 self.deb = wx.StaticText(self.panel_1, -1, txt)
796 dendro_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
797 self.butdendro = wx.BitmapButton(self, -1, dendro_img)
798 self.butdendrotexte = wx.BitmapButton(self, -1, dendro_img)
799 self.butdendrocloud = wx.BitmapButton(self, -1, dendro_img)
801 for i in range(0,len(list_graph)):
802 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
803 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
804 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
806 self.__set_properties()
809 def __set_properties(self):
810 self.panel_1.EnableScrolling(True,True)
811 #self.panel_1.SetSize((1000,1000))
812 self.panel_1.SetScrollRate(20, 20)
813 self.panel_1.SetFocus()
814 self.Bind(wx.EVT_BUTTON, self.ondendro, self.butdendro)
815 self.Bind(wx.EVT_BUTTON, self.ondendrotexte, self.butdendrotexte)
816 self.Bind(wx.EVT_BUTTON, self.ondendrocloud, self.butdendrocloud)
817 self.param = {'width' : 700,
821 'taille_classe' : True,
824 self.type_dendro = [ u"phylogram", u"cladogram", u"fan", u"unrooted", u"radial" ]
826 def __do_layout(self):
827 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
828 self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
829 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
830 self.sizer_3.Add(self.deb)
831 self.sizer_1.Add(self.butdendro, 0, 0, 0)
832 self.sizer_1.Add(self.butdendrotexte, 0, 0, 0)
833 self.sizer_1.Add(self.butdendrocloud, 0, 0, 0)
835 for i in range(0, len(self.listimg)):
836 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
837 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
838 self.panel_1.SetSizer(self.sizer_3)
839 self.sizer_2.Add(self.sizer_1, 0, wx.EXPAND, 0)
840 self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
841 self.SetSizer(self.sizer_2)
843 def make_param(self, dial):
844 self.param['width'] = dial.m_spinCtrl2.GetValue()
845 self.param['height'] = dial.m_spinCtrl1.GetValue()
846 self.param['type_dendro'] = dial.m_choice1.GetSelection()
847 self.param['color_nb'] = dial.m_radioBox1.GetSelection()
848 self.param['taille_classe'] = dial.m_checkBox1.GetValue()
849 self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
851 def make_dendro(self, dendro = 'simple') :
852 while os.path.exists(os.path.join(self.dirout, 'dendrogramme_' + str(self.graphnb)+'.png')) :
854 fileout = ffr(os.path.join(self.dirout,'dendrogramme_' + str(self.graphnb)+'.png'))
855 width = self.param['width']
856 height = self.param['height']
857 type_dendro = self.type_dendro[self.param['type_dendro']]
858 if self.param['taille_classe'] :
862 if self.param['color_nb'] == 0 :
866 if self.param['type_tclasse'] == 0 :
870 dendro_path = self.dictpathout['Rdendro']
871 classe_path = self.dictpathout['uce']
876 classes <- read.csv2("%s", row.names=1)
877 classes <- classes[,1]
878 """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']), ffr(classe_path))
879 if dendro == 'simple' :
881 open_file_graph("%s", width=%i, height=%i)
882 plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
883 """ % (ffr(fileout), width, height, type_dendro, histo, bw, tclasse)
884 elif dendro == 'texte' :
888 chistable <- chistabletot[1:(debsup-1),]
889 open_file_graph("%s", width=%i, height=%i)
890 plot.dendro.prof(tree.cut1$tree.cl, classes, chistable, nbbycl = 60, type.dendro="%s", bw=%s, lab=NULL)
891 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, type_dendro, bw)
892 elif dendro == 'cloud' :
896 chistable <- chistabletot[1:(debsup-1),]
897 open_file_graph("%s", width=%i, height=%i)
898 plot.dendro.cloud(tree.cut1$tree.cl, classes, chistable, nbbycl = 300, type.dendro="%s", bw=%s, lab=NULL)
899 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, type_dendro, bw)
902 tmpfile = tempfile.mktemp()
903 with open(tmpfile, 'w') as f :
905 error = exec_rcode(self.ira.RPath, tmpfile, wait=True)
906 check_Rresult(self.ira, error)
907 self.list_graph.append([fileout, 'Dendrogramme CHD1 - %s' % type_dendro])
908 print_liste(self.dictpathout['liste_graph_chd'], self.list_graph)
909 self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
910 self.sizer_3.Add(wx.StaticText(self.panel_1,-1, 'Dendrogramme CHD1 - %s' % type_dendro), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
911 self.sizer_3.Fit(self.panel_1)
913 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
916 def ondendro(self, evt):
917 dial = PrefDendro(self.ira, self.param)
918 val = dial.ShowModal()
920 self.make_param(dial)
923 def ondendrotexte(self, evt):
924 dial = PrefDendro(self.ira, self.param)
925 val = dial.ShowModal()
927 self.make_param(dial)
928 self.make_dendro(dendro = 'texte')
930 def ondendrocloud(self, evt):
931 dial = PrefDendro(self.ira, self.param)
932 val = dial.ShowModal()
934 self.make_param(dial)
935 self.make_dendro(dendro = 'cloud')
938 def __init__(self, ira, parametres) :
939 #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)
940 self.panel = CopusPanel(ira, parametres)
941 ira.nb.AddPage(self.panel, 'Description %s' % parametres['corpus_name'])
942 #self.text.write(DoConf().totext(parametres))
943 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
944 ira.ShowAPane("Tab_content")
947 def __init__(self, ira, matrix):
948 #self.parent.content = self.csvtable
949 self.sheet = MySheet(ira.nb)
950 ira.nb.AddPage(self.sheet, matrix.parametres['matrix_name'])
951 self.sheet.Populate(matrix.csvtable)
952 self.sheet.parametres = matrix.parametres
953 #self.ira.ShowMenu(_(u"View").decode('utf8'))
954 #self.ira.ShowMenu(_(u"Matrix analysis").decode('utf8'))
955 #self.ira.ShowMenu(_(u"Text analysis").decode('utf8'), False)
956 #self.parent.type = "Data"
957 #self.parent.DataPop = False
958 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
959 ira.ShowAPane("Tab_content")
960 #self.ira.OnViewData('')
965 class CopusPanel(wx.Panel) :
966 def __init__(self, parent, parametres) :
967 wx.Panel.__init__ ( self, parent, id = wx.ID_ANY, pos = wx.DefaultPosition, size = wx.Size( 500,300 ), style = wx.TAB_TRAVERSAL )
968 self.parametres = parametres
969 fgSizer5 = wx.FlexGridSizer( 0, 2, 0, 0 )
970 fgSizer5.SetFlexibleDirection( wx.BOTH )
971 fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )
972 self.fgSizer5 = fgSizer5
974 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Description du corpus", wx.DefaultPosition, wx.DefaultSize, 0 )
976 self.m_staticText18.Wrap( -1 )
977 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
979 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
980 self.m_staticText19.Wrap( -1 )
981 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
983 self.m_staticText20 = wx.StaticText( self, wx.ID_ANY, u"Nom", wx.DefaultPosition, wx.DefaultSize, 0 )
984 self.m_staticText20.Wrap( -1 )
985 fgSizer5.Add( self.m_staticText20, 0, wx.ALL, 5 )
987 self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, parametres['corpus_name'], wx.DefaultPosition, wx.DefaultSize, 0 )
988 self.m_staticText21.Wrap( -1 )
989 fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )
991 description = {'lang' : u'langue',
992 'encoding' : u'encodage',
993 'ucinb' : u'Nombre de textes',
994 'ucenb' : u'Nombre de segments de texte',
995 'formesnb' : u'Nombre de formes',
996 'hapax' : u'Nombre d\'hapax'
999 keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']
1001 self.addkeys(keys, description)
1003 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Paramètres", wx.DefaultPosition, wx.DefaultSize, 0 )
1004 self.m_staticText18.Wrap( -1 )
1005 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1007 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1008 self.m_staticText19.Wrap( -1 )
1009 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1011 keys = ['ucemethod', 'ucesize', 'keep_caract', 'expressions']
1012 self.addkeys(keys, description)
1014 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Statistiques", wx.DefaultPosition, wx.DefaultSize, 0 )
1015 self.m_staticText18.Wrap( -1 )
1016 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1018 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1019 self.m_staticText19.Wrap( -1 )
1020 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1022 keys = ['ucinb', 'ucenb', 'occurrences', 'formesnb', 'hapax']
1023 self.addkeys(keys, description)
1025 self.SetSizer( fgSizer5 )
1028 def addkeys(self, keys, description) :
1030 option = self.parametres.get(key,u'non défini')
1031 if isinstance(option, int) :
1033 text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
1035 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1037 text = wx.StaticText( self, wx.ID_ANY, option, wx.DefaultPosition, wx.DefaultSize, 0 )
1039 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1041 class DefaultTextLayout :
1042 def __init__(self, ira, corpus, parametres) :
1043 self.pathout = PathOut(dirout = parametres['pathout'])
1046 self.parametres = parametres
1047 self.corpus = corpus
1050 def dolayout(self) :
1051 log.info('no layout yet')
1053 class WordCloudLayout(DefaultTextLayout):
1055 self.pathout.basefiles(simipath)
1056 self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1057 if self.parametres['svg'] :
1058 list_graph = [['nuage_1.svg', 'Nuage']]
1060 list_graph = [['nuage_1.png', 'Nuage']]
1061 self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, list_graph)
1062 self.Tab.AddPage(self.TabStatTot, 'Nuage')
1063 self.Tab.corpus = self.corpus
1064 self.Tab.parametres = self.parametres
1065 self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
1066 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1067 self.ira.ShowAPane("Tab_content")
1069 class SimiLayout(DefaultTextLayout) :
1070 def dolayout(self) :
1071 self.pathout.basefiles(simipath)
1073 self.indices = indices_simi
1074 if os.path.exists(self.pathout['liste_graph']) :
1075 list_graph = read_list_file(self.pathout['liste_graph'])
1077 list_graph = [['','']]
1078 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1079 self.tabsimi = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1080 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1081 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1082 self.tabsimi.corpus = self.corpus
1083 self.tabsimi.parametres = self.parametres
1084 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1085 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1086 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1087 self.tabsimi.AddPage(self.graphpan, 'Graph')
1088 self.ira.nb.AddPage(self.tabsimi, 'Analyse de graph')
1089 self.ira.ShowTab(True)
1090 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1092 def redosimi(self, evt) :
1093 with open(self.pathout['selected.csv'],'r') as f :
1095 selected = [int(val) for val in selected.splitlines()]
1096 if self.actives is None :
1097 with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1098 self.actives = f.read()
1099 self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1100 if os.path.exists(self.pathout['actives_nb.csv']) :
1101 with open(self.pathout['actives_nb.csv'], 'r') as f :
1103 act_nb = act_nb.splitlines()
1104 dictcol = dict([[i, [self.actives[i], int(act_nb[i])]] for i, val in enumerate(self.actives)])
1106 dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1107 #res = SelectColumn(self.ira, dictcol, self.actives, self.pathout['selected.csv'], selected = selected, dlg = True)
1109 prep = PrepSimi(self.ira, self, self.parametres,self.pathout['selected.csv'], self.actives, indices_simi, wordlist = dictcol, selected = selected)
1110 if prep.val == wx.ID_OK :
1111 self.parametres = prep.parametres
1113 script = PrintSimiScript(self)
1114 script.make_script()
1115 pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
1116 check_Rresult(self.ira, pid)
1117 if self.parametres['type_graph'] in [1,3] :
1118 if self.parametres['svg'] :
1119 filename, ext = os.path.splitext(script.filename)
1120 fileout = filename + '.svg'
1121 elif self.parametres['type_graph'] == 3 :
1122 fileout = script.filename
1123 parametres = {'gexffile' : fileout,
1124 'dirout' : os.path.dirname(fileout),
1125 'titre': 'Le titre',
1126 #'nodemin': self.param['txt_min'],
1127 #'nodemax': self.param['txt_max'],
1128 #'bargraphw' : 60*int(self.param['clnb']),
1130 web = WebExport(self.ira, parametres)
1131 fileout = web.exportsimi()
1133 fileout = script.filename
1134 if os.path.exists(self.pathout['liste_graph']):
1135 graph_simi = read_list_file(self.pathout['liste_graph'])
1136 graph_simi.append([os.path.basename(fileout), script.txtgraph])
1138 graph_simi = [[os.path.basename(fileout), script.txtgraph]]
1139 print_liste(self.pathout['liste_graph'], graph_simi)
1140 DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1141 if self.parametres['type_graph'] in [1,3] :
1142 if self.parametres['svg'] or self.parametres['type_graph'] == 3 :
1143 self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1145 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)
1146 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1147 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1148 self.graphpan.Layout()
1149 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1151 def export(self, evt) :
1153 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1155 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1161 graph <- graph.simi$graph
1162 V(graph)$x <- graph.simi$layout[,1]
1163 V(graph)$y <- graph.simi$layout[,2]
1164 if (length(graph.simi$label.cex == 1)) {
1165 V(graph)$weight <- graph.simi$eff
1167 V(graph)$weight <- graph.simi$label.cex
1169 V(graph)$color <- vertex.label.color
1170 V(graph)$frequences <- graph.simi$mat.eff
1171 V(graph)$label <- as.character(graph.simi$v.label)
1172 E(graph)$weight <- graph.simi$we.width
1173 write.graph(graph, fileout, format = 'graphml')
1174 #saveAsGEXF(graph, filepath = fileout)
1175 """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1176 filetmp = tempfile.mktemp()
1177 with open(filetmp, 'w') as f :
1179 exec_rcode(self.ira.RPath, filetmp)
1180 mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
1181 mss.CenterOnParent()
1185 class DefaultMatLayout :
1186 def __init__(self, parent, tableau, parametres) :
1187 self.pathout = PathOut(dirout = parametres['pathout'])
1189 self.parent = parent
1190 self.tableau = tableau
1191 self.parametres = parametres
1192 if os.path.exists(self.pathout['analyse.db']) :
1193 self.tableau.read_tableau(self.pathout['analyse.db'])
1195 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1196 self.ira.ShowAPane("Tab_content")
1198 def dolayout(self) :
1201 class FreqLayout(DefaultMatLayout) :
1202 def dolayout(self) :
1203 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1204 if "gtk2" in wx.PlatformInfo:
1205 self.tab.SetStandardFonts()
1206 self.tab.LoadPage(self.pathout['resultats.html'])
1207 self.tab.parametres = self.parametres
1208 self.ira.nb.AddPage(self.tab, u"Fréquences")
1211 class Chi2Layout(DefaultMatLayout) :
1213 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1214 if "gtk2" in wx.PlatformInfo:
1215 self.tab.SetStandardFonts()
1216 self.tab.LoadPage(self.pathout['resultats-chi2.html'])
1217 self.tab.parametres = self.parametres
1218 self.ira.nb.AddPage(self.tab, ' - '.join([u"Chi2", "%s" % self.parametres['name']]))
1219 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1220 #self.ira.ShowAPane("Tab_content")
1223 class ProtoLayout(DefaultMatLayout) :
1224 def dolayout(self) :
1225 list_graph = [['proto.png', 'Analyse prototypique']]
1226 #self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1227 #if self.parametres['svg'] :
1228 # list_graph = [['nuage_1.svg', 'Nuage']]
1230 # list_graph = [['nuage_1.png', 'Nuage']]
1231 self.TabProto = GraphPanel(self.ira.nb, self.pathout, list_graph)
1232 #self.Tab.AddPage(self.TabProto, 'Analyse Prototypique')
1233 #self.Tab.corpus = self.corpus
1234 self.TabProto.parametres = self.parametres
1235 self.ira.nb.AddPage(self.TabProto, 'Analyse Prototypique - %s' % self.parametres['name'])
1236 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1237 #self.ira.ShowAPane("Tab_content")
1240 class SimiMatLayout(DefaultMatLayout) :
1242 self.pathout.basefiles(simipath)
1243 self.indices = indices_simi
1244 if os.path.exists(self.pathout['liste_graph']) :
1245 list_graph = read_list_file(self.pathout['liste_graph'])
1247 list_graph = [['','']]
1248 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1249 self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1250 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1251 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1252 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1253 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1254 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1255 self.tabsimi.AddPage(self.graphpan, 'Graph')
1256 self.tabsimi.parametres = self.parametres
1257 self.parent.nb.AddPage(self.tabsimi, 'Analyse de graph')
1258 #self.parent.ShowTab(True)
1259 #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1261 def redosimi(self,evt) :
1262 with open(self.pathout['selected.csv'],'r') as f :
1264 selected = [int(val) for val in selected.splitlines()]
1265 #if self.actives is None :
1266 # with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1267 # self.actives = f.read()
1268 # self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1270 actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1272 actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1274 #self.tableau.make_listactives()
1275 actives = dict([[i, val] for i, val in enumerate(actives)])
1276 #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1277 self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1278 self.dial.CenterOnParent()
1279 self.val = self.dial.ShowModal()
1280 if self.val == wx.ID_OK :
1281 last = self.dial.listcol.GetFirstSelected()
1282 lastl = [self.dial.listcol.GetFirstSelected()]
1283 indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1284 while self.dial.listcol.GetNextSelected(last) != -1:
1285 last = self.dial.listcol.GetNextSelected(last)
1287 indexes.append(self.dial.listcol.getColumnText(last,0))
1288 self.column = [self.tableau.listactives.index(val) for val in indexes]
1290 with open(self.pathout['selected.csv'], 'w') as f :
1291 f.write('\n'.join([`val` for val in self.column]))
1294 self.script = PrintSimiScript(self)
1295 self.script.make_script()
1296 self.tmpfile = self.script.scriptout
1297 dlg = progressbar(self, maxi = 2)
1300 if self.parametres['type_graph'] == 1:
1301 if self.parametres['svg'] :
1302 filename, ext = os.path.splitext(self.script.filename)
1303 fileout = filename + '.svg'
1305 fileout = self.script.filename
1306 if os.path.exists(self.pathout['liste_graph']):
1307 graph_simi = read_list_file(self.pathout['liste_graph'])
1308 graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1310 graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1311 print_liste(self.pathout['liste_graph'], graph_simi)
1312 DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1313 if self.parametres['type_graph'] == 1:
1314 if self.parametres['svg'] :
1315 self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1317 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)
1318 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1319 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1320 self.graphpan.Layout()
1321 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1326 def make_param(self) :
1327 if self.parametres['first'] :
1330 keep_coord = self.dial.check_coord.GetValue()
1331 #self.select = self.dial.check_colch.GetValue()
1333 paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1334 'layout' : self.dial.choice2.GetSelection(),
1335 'type_graph' : self.dial.choice3.GetSelection(),
1336 'arbremax' : self.dial.check1.GetValue(),
1337 'coeff_tv' : self.dial.check_s_size.GetValue(),
1338 'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1339 'tvprop' : self.dial.check2.GetValue(),
1340 'tvmin' : self.dial.spin_tvmin.GetValue(),
1341 'tvmax' : self.dial.spin_tvmax.GetValue(),
1342 'coeff_te' : self.dial.check3.GetValue(),
1343 'coeff_temin' : self.dial.spin_temin.GetValue(),
1344 'coeff_temax' : self.dial.spin_temax.GetValue(),
1345 'label_e' : self.dial.check_elab.GetValue(),
1346 'label_v' : self.dial.check_vlab.GetValue(),
1347 'vcex' : self.dial.check_vcex.GetValue(),
1348 'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1349 'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1350 'cex' : self.dial.spin_cex.GetValue(),
1351 'seuil_ok' : self.dial.check_seuil.GetValue(),
1352 'seuil' : self.dial.spin_seuil.GetValue(),
1353 'cols' : self.dial.cols.GetColour(),
1354 'cola' : self.dial.cola.GetColour(),
1355 'width' : self.dial.spin_width.GetValue(),
1356 'height' : self.dial.spin_height.GetValue(),
1358 'keep_coord' : keep_coord,
1359 'alpha' : self.dial.slider_sphere.GetValue(),
1360 'film' : self.dial.film.GetValue(),
1361 'svg' : self.dial.choix_format.GetSelection(),
1362 'halo' : self.dial.halo.GetValue(),
1363 'com' : self.dial.comcheck.GetValue(),
1364 'communities' : self.dial.choix_com.GetSelection(),
1366 if 'cexfromchi' in self.parametres :
1367 paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1368 if 'sfromchi' in self.parametres :
1369 paramsimi['sfromchi'] = self.dial.checki.GetValue()
1370 if 'vlabcolor' in self.parametres :
1371 paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1372 if 'check_bystar' in dir(self.dial) :
1373 paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1374 paramsimi['stars'] = self.parametres['stars']
1375 self.parametres.update(paramsimi)
1378 if self.parametres['type_graph'] == 1 :
1384 pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1385 if self.parametres['type_graph'] == 1 :
1386 while pid.poll() == None :
1389 check_Rresult(self.parent, pid)
1391 def export(self, evt) :
1393 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1395 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1401 graph <- graph.simi$graph
1402 V(graph)$x <- graph.simi$layout[,1]
1403 V(graph)$y <- graph.simi$layout[,2]
1404 if (length(graph.simi$label.cex == 1)) {
1405 V(graph)$weight <- graph.simi$mat.eff
1407 V(graph)$weight <- graph.simi$label.cex
1409 V(graph)$color <- vertex.label.color
1410 V(graph)$frequences <- graph.simi$mat.eff
1411 V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
1412 V(graph)$label <- as.character(graph.simi$v.label)
1413 E(graph)$weight <- graph.simi$we.width
1414 write.graph(graph, fileout, format = 'graphml')
1415 #saveAsGEXF(graph, filepath = fileout)
1416 """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1417 filetmp = tempfile.mktemp()
1418 with open(filetmp, 'w') as f :
1420 exec_rcode(self.ira.RPath, filetmp)
1421 mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
1422 mss.CenterOnParent()
1427 class GraphPanelSimi(wx.Panel):
1428 def __init__(self,parent, dico, list_graph):
1429 wx.Panel.__init__(self,parent)
1432 self.dirout = os.path.dirname(self.Dict['ira'])
1433 self.parent = self.GetParent()#parent
1434 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "courier"))
1437 self.tabsimi = self.parent.GetParent()
1438 self.ira = self.tabsimi.GetParent()
1439 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1440 afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1441 self.butafc = wx.BitmapButton(self, -1, afc_img)
1442 export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1443 self.butexport = wx.BitmapButton(self, -1, export_img)
1444 for i in range(0,len(list_graph)):
1445 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1446 filename, ext = os.path.splitext(list_graph[i][0])
1447 if ext in ['.svg', '.html'] :
1448 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])))
1450 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1451 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1452 self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove)
1453 self.__set_properties()
1456 def __set_properties(self):
1457 self.panel_1.EnableScrolling(True,True)
1458 #self.panel_1.SetSize((1000,1000))
1459 self.panel_1.SetScrollRate(20, 20)
1460 self.panel_1.SetFocus()
1462 def __do_layout(self):
1463 self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1464 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1465 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1466 self.sizer_2.Add(self.butafc, 0, 0, 0)
1467 self.sizer_2.Add(self.butexport, 0, 0, 0)
1468 for i in range(0, len(self.listimg)):
1469 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1470 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1471 self.panel_1.SetSizer(self.sizer_3)
1472 self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1473 self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1474 self.SetSizer(self.sizer_1)
1476 def onMouseMove(self, event):
1477 self.panel_1.SetFocus()