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, 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
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()
171 if self.clnb <= 3 and typegraph == 1 :
175 while os.path.exists(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile)):
177 self.fileout = ffr(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile))
179 self.param = {'typegraph' : typegraph,
180 'width' : dial.spin1.GetValue(),
181 'height' : dial.spin2.GetValue(),
182 'what' : dial.choice1.GetSelection(),
183 'qui' : dial.choice2.GetSelection(),
184 'do_select_nb' : dial.check1.GetValue(),
185 'do_select_chi' : dial.check2.GetValue(),
186 'do_select_chi_classe' : dial.check_chic.GetValue(),
187 'select_nb' : dial.spin_nb.GetValue(),
188 'select_chi' : dial.spin_chi.GetValue(),
189 'nbchic' : dial.spin_nbchic.GetValue(),
190 'over' : dial.check3.GetValue(),
191 'cex_txt' : dial.check4.GetValue(),
192 'txt_min' : dial.spin_min.GetValue(),
193 'txt_max' : dial.spin_max.GetValue(),
194 'tchi' : dial.check_tchi.GetValue(),
195 'tchi_min' : dial.spin_min_tchi.GetValue(),
196 'tchi_max' : dial.spin_max_tchi.GetValue(),
197 'taillecar' : dial.spin3.GetValue(),
198 'facteur' : [dial.spin_f1.GetValue(),dial.spin_f2.GetValue(), dial.spin_f3.GetValue()],
200 'film' : str(dial.film.GetValue()).upper(),
201 'alpha' : dial.slider_sphere.GetValue(),
204 self.nb.parent = self.ira
205 self.DictPathOut = self.Dict
206 self.RscriptsPath = self.ira.RscriptsPath
209 """ % ffr(self.DictPathOut['RData'])
210 if self.itempath == 'liste_graph_afcf' :
213 afc_table <- afcf_table
214 chistabletot <- specfp
216 elif self.itempath == 'liste_graph_afct' :
219 afc_table <- afct_table
220 chistabletot <- spectp
222 txt += write_afc_graph(self)
223 filetmp = tempfile.mktemp()
224 with open(filetmp, 'w') as f :
226 pid = exec_rcode(self.ira.RPath, filetmp)
227 check_Rresult(self.ira, pid)
228 if self.param['typegraph'] in [0,2] :
230 if self.param['qui'] == 0 : value = u'actives'
231 if self.param['qui'] == 1 : value = u'supplémentaires'
232 if self.param['qui'] == 2 : value = u'étoilées'
233 if self.param['qui'] == 3 : value = u'classes'
235 if self.param['what'] == 0 : value = u'Coordonnées'
236 if self.param['what'] == 1 : value = u'Corrélations'
237 txt += value + u' - facteur %i / %i' % (self.param['facteur'][0], self.param['facteur'][1])
238 if self.param['do_select_nb'] : txt += u' - sélection de %i variables' % self.param['select_nb']
239 if self.param['do_select_chi'] : txt += u' - sélection des variables avec chi2 > %i ' % self.param['select_chi']
240 if self.param['over'] : txt += u' - Eviter les recouvrements'
241 if self.param['cex_txt'] : txt += u' - taille du texte proportionnel à la masse'
242 if self.param['tchi'] : txt += u' - taille du texte proportionnel au chi2 d\'association'
243 #list_graph = read_list_file(self.DictPathOut[self.itempath], self.coding)
244 if self.param['svg'] :
245 filename, ext = os.path.splitext(self.fileout)
246 self.fileout = filename + '.svg'
247 if self.param['typegraph'] == 2 :
248 parametres = {'gexffile' : self.fileout,
250 'nodemin': self.param['txt_min'],
251 'nodemax': self.param['txt_max'],
252 'bargraphw' : 60*int(self.param['clnb']),
254 web = WebExport(self.ira, parametres)
255 self.fileout = web.exportafc()
256 self.list_graph.append([os.path.basename(self.fileout), txt])
257 print_liste(self.DictPathOut[self.itempath], self.list_graph)
258 if self.param['svg'] or self.param['typegraph'] == 2:
259 self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, self.fileout, URL=self.fileout))
262 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(self.fileout, wx.BITMAP_TYPE_ANY)))
263 self.sizer_3.Add( self.listimg[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
264 self.labels.append(wx.StaticText(self.panel_1,-1, txt))
265 self.sizer_3.Add(self.labels[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
266 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = `len(self.list_graph) - 1`))
267 self.sizer_3.Add(self.buts[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
268 self.sizer_3.Fit(self.panel_1)
271 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
272 # elif self.param['typegraph'] == 2 :
273 # parametres = {'gexffile' : self.fileout,
274 # 'titre': 'Le titre',
275 # 'nodemin': self.param['txt_min'],
276 # 'nodemax': self.param['txt_max'],
277 # 'bargraphw' : 60*int(self.param['clnb']),
279 # web = WebExport(self.ira, parametres)
280 # afcout = web.exportafc()
281 # dial = SimpleDialog(self.ira)
282 # dial.link.SetLabel(afcout)
283 # dial.link.SetURL(afcout)
288 class GraphPanel(wx.ScrolledWindow):
289 def __init__(self, parent, dico, list_graph, txt = '', style = wx.TAB_TRAVERSAL):
290 wx.ScrolledWindow.__init__(self, parent, style = style)
294 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
297 self.dirout = os.path.dirname(self.Dict['ira'])
298 self.deb = wx.StaticText(self, -1, txt)
299 for i in range(0,len(list_graph)):
300 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
301 filename, ext = os.path.splitext(list_graph[i][0])
303 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])))
305 self.listimg.append(wx.StaticBitmap(self, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
306 self.labels.append(wx.StaticText(self, -1, list_graph[i][1]))
307 self.Bind(wx.EVT_MOTION, self.onMouseMove)
308 self.__set_properties()
311 def __set_properties(self):
312 self.EnableScrolling(True,True)
313 self.SetScrollRate(20, 20)
317 def __do_layout(self):
318 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
319 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
320 self.sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
321 self.sizer_1.Add(self.deb)
322 for i in range(0, len(self.listimg)):
323 self.sizer_1.Add(self.listimg[i], 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
324 self.sizer_1.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
325 self.sizer_2.Add(self.sizer_1, 1, wx.EXPAND, 0)
326 self.SetSizer(self.sizer_1)
327 self.sizer_1.Fit(self)
329 def onMouseMove(self, event):
333 def open_antiprofil(panel, AntiProfile, encoding) :
334 DictAnti = ReadProfileAsDico(AntiProfile, True, encoding)
335 panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
336 for i in range(0, panel.parametres['clnb']):
337 tabantiprofile = ProfListctrlPanel(panel, panel, DictAnti[str(i + 1)], True, i + 1)
338 panel.AntiProfNB.AddPage(tabantiprofile, 'classe %s' % str(i + 1))
339 panel.TabChdSim.AddPage(panel.AntiProfNB, _(u"Antiprofiles").decode('utf8'))
343 def getlemgram(corpus, lem) :
344 if not lem[6] in corpus.lems :
347 return corpus.lems[lem[6]].gram
350 def __init__(self, parent, corpus, parametres, Alceste=False):
355 self.parametres = parametres
356 self.pathout = PathOut(parametres['ira'])
357 self.pathout.basefiles(ChdTxtPathOut)
358 DictPathOut = self.pathout
359 self.DictPathOut = DictPathOut
360 self.dictpathout = DictPathOut
363 Profile = DictPathOut['PROFILE_OUT']
364 AntiProfile = DictPathOut['ANTIPRO_OUT']
365 self.encoding = self.parametres['encoding']
366 if isinstance(self.corpus, Corpus) :
367 self.corpus.make_ucecl_from_R(self.pathout['uce'])
368 corpname = self.corpus.parametres['corpus_name']
370 corpname = self.corpus.parametres['matrix_name']
371 if os.path.exists(self.pathout['analyse.db']) :
372 self.corpus.read_tableau(self.pathout['analyse.db'])
374 clnb = parametres['clnb']
375 dlg = progressbar(self, maxi = 4 + clnb)
377 print 'lecture des profils'
378 dlg.Update(2, _(u"Reading profiles").decode('utf8'))
380 DictProfile = ReadProfileAsDico(Profile, Alceste, self.encoding)
381 self.DictProfile = DictProfile
382 self.cluster_size = []
384 for i in range(0, clnb) :
385 clusternames[i] = ' '.join([u'%i' % (i + 1), _(u'Cluster').decode('utf8'), u'%i' % (i + 1)])
386 if os.path.exists(self.pathout['classes_names.txt']) :
387 with codecs.open(self.pathout['classes_names.txt'], 'r', self.parent.syscoding) as f :
388 clusternames_ = f.read()
389 clusternames_ = dict([[i, ' '.join([`i + 1`, line])] for i, line in enumerate(clusternames_.splitlines())])
390 clusternames.update(clusternames_)
391 #print 'lecture des antiprofils'
392 #DictAnti = ReadProfileAsDico(self, AntiProfile, Alceste, self.encoding)
394 panel = wx.Panel(parent, -1)
395 sizer1 = wx.BoxSizer(wx.VERTICAL)
397 if os.path.exists(DictPathOut['pre_rapport']):
398 with codecs.open(DictPathOut['pre_rapport'], 'r', self.encoding) as f :
403 # panel.chd_toolbar = wx.ToolBar(panel, -1, wx.DefaultPosition, wx.DefaultSize, wx.TB_FLAT | wx.TB_NODIVIDER)
404 # panel.chd_toolbar.SetToolBitmapSize(wx.Size(16, 16))
406 if isinstance(self.corpus, Corpus) :
407 panel.corpus = self.corpus
409 panel.tableau = self.corpus
410 #self.parent.tableau = panel.tableau
411 panel.dictpathout = self.DictPathOut
412 panel.pathout = self.DictPathOut
413 panel.parent = self.parent
414 panel.DictProfile = self.DictProfile
415 panel.cluster_size = self.cluster_size
416 panel.debtext = self.debtext
418 # self.ID_rapport = wx.NewId()
419 # #rap_img = wx.Image(os.path.join(self.parent.images_path,'icone_rap_16.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
420 # #panel.chd_toolbar.AddLabelTool(self.ID_rapport, "rapport", rap_img, shortHelp=u"Produire le rapport", longHelp=u"Exporter un rapport en texte simple")
421 # butrap = wx.Button(panel.chd_toolbar, self.ID_rapport, u"Rapport ")
422 # panel.chd_toolbar.AddControl(butrap)
424 # panel.chd_toolbar.Realize()
425 # sizer1.Add(panel.chd_toolbar,0, wx.EXPAND, 5)
427 #self.TabChdSim = wx.aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
428 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
429 panel.TabChdSim = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
430 #panel.TabChdSim = LB.LabelBook(panel, -1, agwStyle = INB_TOP|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
431 panel.TabChdSim.SetAGWWindowStyleFlag(notebook_flags)
432 panel.TabChdSim.SetArtProvider(aui.ChromeTabArt())
433 sizer1.Add(panel.TabChdSim,10, wx.EXPAND, 5)
434 panel.SetSizer(sizer1)
438 if isinstance(self.corpus, Corpus) :
439 panel.TabChdSim.corpus = corpus
440 panel.TabChdSim.corpus.dictpathout = self.DictPathOut
442 panel.TabChdSim.tableau = corpus
443 panel.TabChdSim.tableau.dictpathout = self.DictPathOut
444 panel.parametres = self.parametres
447 self.notenb = self.parent.nb.GetPageCount()
450 if os.path.exists(self.DictPathOut['liste_graph_chd']) :
451 list_graph = read_list_file(self.DictPathOut['liste_graph_chd'], self.encoding)
452 CHD = GraphPanelDendro(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
453 panel.TabChdSim.AddPage(CHD,'CHD')
455 panel.ProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
456 notebook_flags |= aui.AUI_NB_WINDOWLIST_BUTTON
457 panel.ProfNB.SetAGWWindowStyleFlag(notebook_flags)
458 #panel.ProfNB.SetArtProvider(aui.ChromeTabArt())
459 #panel.ProfNB = LB.LabelBook(panel, -1, agwStyle = INB_LEFT|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
460 #panel.ProfNB = wx.Listbook(self.parent, -1, style = wx.BK_DEFAULT)
461 #panel.ProfNB = wx.Treebook(self.parent, -1, style = wx.BK_DEFAULT)
462 #self.ProfNB.SetTabCtrlHeight(100)
463 #panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
464 if os.path.exists(DictPathOut['prof_seg']) :
465 prof_seg = ReadProfileAsDico(DictPathOut['prof_seg'], False, self.encoding)
466 self.prof_seg_nb = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
467 for i in range(0, clnb):
468 self.cluster_size.append(DictProfile[str(i + 1)][0][0:3])
469 if isinstance(self.corpus, Corpus) :
470 DictProfile[str(i + 1)][1:] = [val[0:5] + [getlemgram(self.corpus, val)] + val[6:] for val in DictProfile[str(i + 1)][1:]]
471 dlg.Update(3+i, 'Classe %i' %(i+1))
472 ind = '/'.join(DictProfile[str(i + 1)][0][0:2]).strip()
473 indpour = '\n'.join([ind, DictProfile[str(i + 1)][0][2]])
474 self.tabprofile = ProfListctrlPanel(self.parent, self.panel, DictProfile[str(i + 1)], Alceste, i + 1)
475 #self.tabantiprofile = ProfListctrlPanel(self.parent, self, DictAnti[str(i + 1)], Alceste, i + 1)
476 panel.ProfNB.AddPage(self.tabprofile, clusternames[i] + '\n%s%%' % indpour, True)
477 panel.ProfNB.SetPageTextColour(i, '#890909')
478 panel.ProfNB.SetRenamable(i, True)
479 #panel.AntiProfNB.AddPage(self.tabantiprofile, 'classe %s' % str(i + 1))
480 if os.path.exists(DictPathOut['prof_seg']) :
481 self.tab_prof_seg = ProfListctrlPanel(self.parent, self, prof_seg[str(i + 1)], False, i + 1)
482 self.prof_seg_nb.AddPage(self.tab_prof_seg, _(u"Cluster").decode('utf8') + ' %i' % (i + 1))
483 panel.ProfNB.SetSelection(0)
486 self.TabAFC = aui.AuiNotebook(panel.TabChdSim, -1, wx.DefaultPosition)
488 list_graph=read_list_file(DictPathOut['liste_graph_afc'], self.encoding)
489 self.tabAFCGraph = GraphPanelAfc(self.TabAFC, DictPathOut, list_graph, self.clnb, coding=self.encoding)
490 self.TabAFC.AddPage(self.tabAFCGraph, _(u"CA").decode('utf8'))
492 if os.path.exists(self.DictPathOut['afc_facteur']) :
493 dictrow, first = ReadList(self.DictPathOut['afc_facteur'], self.encoding)
494 self.TabAFC_facteur = ListForSpec(self.parent, parametres, dictrow, first[1:])
495 #dictrow, first = ReadList(self.DictPathOut['afc_row'], self.encoding)
496 #self.TabAFC_ligne = ListForSpec(self.parent, self.parametres, dictrow, first)
497 #dictrow, first = ReadList(self.DictPathOut['afc_col'], self.encoding)
498 #self.TabAFC_colonne = ListForSpec(parent, self.parametres, dictrow, first)
499 self.TabAFC.AddPage(self.TabAFC_facteur, _(u"Factor").decode('utf8'))
500 #self.TabAFC.AddPage(self.TabAFC_colonne, u'Colonnes')
501 #self.TabAFC.AddPage(self.TabAFC_ligne, u'Lignes')
503 sizer_3 = wx.BoxSizer(wx.VERTICAL)
504 self.parent.nb_panel_2 = wx.Panel(panel.TabChdSim, -1)
505 self.parent.button_simi = wx.Button(self.parent.nb_panel_2, -1, "Voyager")
506 self.parent.simi3dpanel = simi3d(self.parent.nb_panel_2, -1)
507 sizer_3.Add(self.parent.simi3dpanel, 1, wx.EXPAND, 0)
508 sizer_3.Add(self.parent.button_simi, 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
509 self.parent.nb_panel_2.SetSizer(sizer_3)
510 self.TabAFC.AddPage(self.parent.nb_panel_2, _(u"3D graph").decode('utf8'))
511 self.parent.Bind(wx.EVT_BUTTON, self.onsimi, self.parent.button_simi)
513 panel.TabChdSim.AddPage(panel.ProfNB, _(u"Profiles").decode('utf8'))
514 #panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')
515 dlg.Update(4 + self.clnb, 'Affichage...')
517 panel.TabChdSim.AddPage(self.TabAFC, _(u"CA").decode('utf8'))
518 if os.path.exists(DictPathOut['prof_seg']) :
519 panel.TabChdSim.AddPage(self.prof_seg_nb, _(u"Repeated segments profiles").decode('utf8'))
521 # panel.Bind(wx.EVT_BUTTON, self.ongetrapport, id = self.ID_rapport)
522 self.parent.nb.AddPage(panel, _(u"Clustering").decode('utf8') + ' - %s' % corpname)
523 self.parent.ShowTab(True)
524 self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
525 #for pane in self.parent._mgr.GetAllPanes() :
526 # if isinstance(pane.window, aui.AuiNotebook):
528 # nb.SetAGWWindowStyleFlag(notebook_flags)
529 # nb.SetArtProvider(aui.ChromeTabArt())
531 self.parent._mgr.Update()
533 def onsimi(self,event):
534 outfile = print_simi3d(self)
535 error = exec_rcode(self.parent.RPath, outfile, wait = True)
537 def onclusterstat(self, evt) :
538 dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': 'Stat par classe'})
539 dial.fbb.SetValue( os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'stat_par_classe.csv'))
540 dial.CenterOnParent()
541 res = dial.ShowModal()
543 fileout = dial.fbb.GetValue()
545 self.corpus.get_stat_by_cluster(fileout)
547 dlg = wx.MessageDialog(self.parent, msg, _(u"Stat by cluster").decode('utf8'), wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
549 if dlg.ShowModal() == wx.ID_OK :
552 #def onsearchf(self, evt) :
553 # if 'FrameSearch' not in dir(self.panel) :
554 # self.panel.FrameSearch = SearchFrame(self.parent, -1, u"Rechercher...", self.corpus)
555 # self.panel.FrameSearch.Show()
557 def PrintRapport(self, corpus, parametres, istxt = True):
561 |i|R|a|M|u|T|e|Q| - %s
565 """ % datetime.datetime.now().ctime()
567 totocc = corpus.gettotocc()
568 txt += u'nombre de textes: %i%s' % (corpus.getucinb(), sep)
569 txt += u'nombre de segments de textes: %i%s' % (corpus.getucenb(), sep)
570 txt += u'nombre de formes: %i%s' % (len(corpus.formes), sep)
571 txt += u'nombre d\'occurrences: %i%s' % (totocc, sep)
572 txt += u'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
573 txt += u'nombre de lemmes: %i%s' % (len(corpus.lems), sep)
574 txt += u'nombre de formes actives: %i%s' % (corpus.getactivesnb(1), sep)
575 txt += u'nombre de formes supplémentaires: %i%s' % (corpus.getactivesnb(2), sep)
576 txt += u'nombre de formes actives de fréquence >= %i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)
577 txt += u'moyenne d\'occurrences par segments :%f%s' % (float(totocc) / float(corpus.getucenb()), sep)
578 if 'tailleuc1' in parametres :
579 if parametres['classif_mode'] == 0 :
580 txt += u'taille rst1 / rst2: %i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)
582 self.Ucenb = self.nbind
583 txt += u'nombre d\'individus : %i%s' % (self.nbind, sep)
584 txt += u'nombre de classes : %i%s' % (self.clnb, sep)
586 txt += u'nombre de classes : %i%s' % (parametres['clnb'], sep)
587 if parametres['classif_mode'] == 0 or parametres['classif_mode'] == 1 :
588 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)
589 elif self.parametres['classif_mode'] == 2 :
590 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)
592 txt += u'%i segments classées sur %i (%.2f%%)%s' % (self.ucecla, self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)
595 ###########################
597 ###########################
598 """ % parametres.get('time', '')
599 with open(self.pathout['pre_rapport'], 'w') as f :
603 class SashList(wx.Panel) :
604 def __init__(self, parent) :
605 wx.Panel.__init__(self, parent, -1)
608 #self.gparent=gparent
612 # A window to the left of the client window
613 #self.listlex = listlex
614 self.leftwin1 = wx.SashLayoutWindow(
615 self, -1, wx.DefaultPosition, (200, 300),
616 wx.NO_BORDER|wx.SW_3D
619 self.leftwin1.SetDefaultSize((120, 1000))
620 self.leftwin1.SetOrientation(wx.LAYOUT_VERTICAL)
621 self.leftwin1.SetAlignment(wx.LAYOUT_LEFT)
622 self.leftwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
623 self.leftwin1.SetSashVisible(wx.SASH_RIGHT, True)
624 self.leftwin1.SetExtraBorderSize(10)
626 #textWindow = wx.TextCtrl(
627 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
628 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
631 #textWindow.SetValue("A sub window")
633 self.leftWindow1 = self.leftwin1
634 winids.append(self.leftwin1.GetId())
636 rightwin1 = wx.SashLayoutWindow(
637 self, -1, wx.DefaultPosition, (200, 300),
638 wx.NO_BORDER|wx.SW_3D
641 rightwin1.SetDefaultSize((120, 1000))
642 rightwin1.SetOrientation(wx.LAYOUT_VERTICAL)
643 rightwin1.SetAlignment(wx.LAYOUT_LEFT)
644 rightwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
645 rightwin1.SetSashVisible(wx.SASH_RIGHT, True)
646 rightwin1.SetExtraBorderSize(10)
647 #textWindow = wx.TextCtrl(
648 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
649 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
652 #textWindow.SetValue("A sub window")
654 self.rightwin1 = rightwin1
655 winids.append(rightwin1.GetId())
658 def __init__(self, page):
660 parametres = self.page.parametres
661 ira = wx.GetApp().GetTopWindow()
662 tgenpath = os.path.join(parametres['pathout'], 'tgen.csv')
663 self.page.tgens, etoiles = ReadList(parametres['tgenspec'], ira.syscoding, sep="\t")
664 tgen = TGen(path = tgenpath, encoding = parametres['encoding'])
668 for i in range(page.GetPageCount()) :
669 tab = page.GetPage(i)
670 if 'gparent' in dir(tab) :
671 if tab.gparent is not None :
672 gparent = tab.gparent
673 if 'tgen' in dir(tab) :
678 self.page.tgentab.RefreshData(self.page.tgens)
679 self.page.tgentab.tgens = tgen.tgen
680 self.page.SetSelection(i)
682 self.page.tgentab = ListForSpec(ira, gparent, self.page.tgens, etoiles[1:])
683 self.page.tgentab.tgen = True
684 self.page.tgentab.tgens = tgen.tgen
685 self.page.AddPage(self.page.tgentab, u'Tgens Specificities')
686 self.page.SetSelection(self.page.GetPageCount() - 1)
689 def __init__(self, ira, corpus, parametres):
690 self.pathout = PathOut(dirout = parametres['pathout'])
692 self.dictpathout = StatTxtPathOut(parametres['pathout'])
693 #self.corpus.read_corpus_from_shelves(self.corpus.dictpathout['db'])
695 self.encoding = self.corpus.parametres['syscoding']
696 self.parametres = parametres
698 self.DictSpec, first = ReadList(self.dictpathout['tablespecf'], self.corpus.parametres['syscoding'])
699 if os.path.exists(self.pathout['banalites.csv']) :
700 self.dictban, firstban = ReadList(self.pathout['banalites.csv'], self.corpus.parametres['syscoding'])
701 self.DictType, firstt = ReadList(self.dictpathout['tablespect'], self.corpus.parametres['syscoding'])
702 self.DictEff, firsteff = ReadList(self.dictpathout['tableafcm'], self.corpus.parametres['syscoding'])
703 self.DictEffType, firstefft = ReadList(self.dictpathout['tabletypem'], self.corpus.parametres['syscoding'])
704 self.DictEffRelForme, firsteffrelf = ReadList(self.dictpathout['eff_relatif_forme'], self.corpus.parametres['syscoding'])
705 self.DictEffRelType, firsteffrelt = ReadList(self.dictpathout['eff_relatif_type'], self.corpus.parametres['syscoding'])
706 self.etoiles = firsteff[1:]
707 #sash = SashList(ira.nb)
710 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
711 self.TabStat.parametres = parametres
712 self.ListPan = ListForSpec(ira, self, self.DictSpec, self.etoiles)
713 if os.path.exists(self.pathout['banalites.csv']) :
714 self.listban = ListForSpec(ira, self, self.dictban, ['eff'] + self.etoiles, usefirst = True)
715 #self.ListPan2 = ListForSpec(sash.rightwin1, self, self.DictSpec, first)
716 self.ListPant = ListForSpec(ira, self, self.DictType, self.etoiles)
717 self.ListPanEff = ListForSpec(ira, self, self.DictEff, self.etoiles)
718 self.ListPanEffType = ListForSpec(ira, self, self.DictEffType, self.etoiles)
719 self.ListPanEffRelForme = ListForSpec(ira, self, self.DictEffRelForme, self.etoiles)
720 self.ListPanEffRelType = ListForSpec(ira, self, self.DictEffRelType, self.etoiles)
722 self.TabStat.AddPage(self.ListPan, u'formes')
723 if os.path.exists(self.pathout['banalites.csv']) :
724 self.TabStat.AddPage(self.listban, u'banalités')
725 self.TabStat.AddPage(self.ListPant, u'Types')
726 self.TabStat.AddPage(self.ListPanEff, u'Effectifs formes')
727 self.TabStat.AddPage(self.ListPanEffType, u'Effectifs Type')
728 self.TabStat.AddPage(self.ListPanEffRelForme, u'Effectifs relatifs formes')
729 self.TabStat.AddPage(self.ListPanEffRelType, u'Effectifs relatifs Type')
730 if self.parametres['clnb'] > 2 :
731 self.TabAFC = aui.AuiNotebook(self.TabStat, -1, wx.DefaultPosition)
732 list_graph=read_list_file(self.dictpathout['liste_graph_afcf'], encoding = self.encoding)
733 self.tabAFCGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afcf', coding = self.encoding)
734 self.TabAFC.AddPage(self.tabAFCGraph, 'AFC formes')
735 list_graph=read_list_file(self.dictpathout['liste_graph_afct'], encoding = self.encoding)
736 self.tabAFCTGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afct', coding=self.encoding)
737 self.TabAFC.AddPage(self.tabAFCTGraph, 'AFC type')
738 self.TabStat.AddPage(self.TabAFC, 'AFC')
740 ira.nb.AddPage(self.TabStat, u'Spécificités')
743 self.TabStat.corpus = self.corpus
744 self.TabStat.etoiles = self.etoiles
745 if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenspec.csv')) :
746 self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenspec.csv')
747 TgenLayout(self.TabStat)
748 self.TabStat.SetSelection(0)
749 ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
750 ira.ShowAPane("Tab_content")
753 def __init__(self, ira, corpus, parametres):
754 self.pathout = PathOut(dirout = parametres['pathout'])
758 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
759 self.TabStat.parametres = parametres
760 self.TabStat.corpus = corpus
761 self.TabStat.pathout = self.pathout
762 # CHD = GraphPanel(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
763 # panel.TabChdSim.AddPage(CHD,'CHD')
765 #self.TabStatTot = wx.TextCtrl(self.TabStat, -1, style=wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2)
766 list_graph = [['zipf.png', 'zipf']]
767 self.TabStatTot = GraphPanel(ira.nb, self.pathout, list_graph, self.result['glob'])
768 self.TabStat.AddPage(self.TabStatTot, 'global')
769 for item in self.result:
771 datam = [['forme', 'nb']]
772 self.ListPan = ListPanel(ira, self, self.result[item])
773 self.TabStat.AddPage(self.ListPan, ' '.join(item.split('_')))
774 ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
775 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
776 ira.ShowAPane("Tab_content")
778 def read_result(self) :
779 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'}
782 with open(self.pathout[lcle[key]], 'r') as f :
783 self.result[key] = [line.split(';') for line in f.read().splitlines()]
784 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
785 with open(self.pathout['glob.txt'], 'r') as f :
786 self.result['glob'] = f.read()
788 class GraphPanelDendro(wx.Panel):
789 def __init__(self,parent, dico, list_graph, txt=False):
790 wx.Panel.__init__(self,parent)
792 self.dictpathout = dico
793 self.dirout = os.path.dirname(self.dictpathout['ira'])
794 self.list_graph = list_graph
795 self.parent = self.GetParent()#parent
796 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
799 self.tabchd = self.parent.GetParent()
800 self.ira = self.tabchd.GetParent()
801 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
802 self.panel_1.SetBackgroundColour('white')
803 self.deb = wx.StaticText(self.panel_1, -1, txt)
804 dendro_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
805 dendro_liste_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro_liste.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
806 dendro_cloud_img= wx.Image(os.path.join(self.ira.images_path,'but_dendro_cloud.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
807 self.butdendro = wx.BitmapButton(self, -1, dendro_img)
808 self.butdendrotexte = wx.BitmapButton(self, -1, dendro_liste_img)
809 self.butdendrocloud = wx.BitmapButton(self, -1, dendro_cloud_img)
811 for i in range(0,len(list_graph)):
812 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
813 filename, ext = os.path.splitext(list_graph[i][0])
815 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])))
817 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
818 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
820 self.__set_properties()
823 def __set_properties(self):
824 self.panel_1.EnableScrolling(True,True)
825 #self.panel_1.SetSize((1000,1000))
826 self.panel_1.SetScrollRate(20, 20)
827 self.panel_1.SetFocus()
828 self.Bind(wx.EVT_BUTTON, self.ondendro, self.butdendro)
829 self.Bind(wx.EVT_BUTTON, self.ondendrotexte, self.butdendrotexte)
830 self.Bind(wx.EVT_BUTTON, self.ondendrocloud, self.butdendrocloud)
831 self.param = {'width' : 700,
835 'taille_classe' : True,
839 self.type_dendro = [ u"phylogram", u"cladogram", u"fan", u"unrooted", u"radial" ]
841 def __do_layout(self):
842 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
843 self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
844 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
845 self.sizer_3.Add(self.deb)
846 self.sizer_1.Add(self.butdendro, 0, 0, 0)
847 self.sizer_1.Add(self.butdendrotexte, 0, 0, 0)
848 self.sizer_1.Add(self.butdendrocloud, 0, 0, 0)
850 for i in range(0, len(self.listimg)):
851 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
852 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
853 self.panel_1.SetSizer(self.sizer_3)
854 self.sizer_2.Add(self.sizer_1, 0, wx.EXPAND, 0)
855 self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
856 self.SetSizer(self.sizer_2)
858 def make_param(self, dial):
859 self.param['width'] = dial.m_spinCtrl2.GetValue()
860 self.param['height'] = dial.m_spinCtrl1.GetValue()
861 self.param['type_dendro'] = dial.m_choice1.GetSelection()
862 self.param['color_nb'] = dial.m_radioBox1.GetSelection()
863 self.param['taille_classe'] = dial.m_checkBox1.GetValue()
864 self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
865 self.param['svg'] = dial.choice_format.GetSelection()
867 def make_dendro(self, dendro = 'simple') :
868 if self.param['svg'] :
872 while os.path.exists(os.path.join(self.dirout, 'dendrogramme_' + str(self.graphnb)+typefile)) :
874 fileout = ffr(os.path.join(self.dirout,'dendrogramme_' + str(self.graphnb)+typefile))
875 width = self.param['width']
876 height = self.param['height']
877 type_dendro = self.type_dendro[self.param['type_dendro']]
878 if self.param['taille_classe'] :
882 if self.param['color_nb'] == 0 :
886 if self.param['type_tclasse'] == 0 :
890 if self.param['svg'] :
894 dendro_path = self.dictpathout['Rdendro']
895 classe_path = self.dictpathout['uce']
900 classes <- read.csv2("%s", row.names=1)
901 classes <- classes[,1]
902 """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']), ffr(classe_path))
903 if dendro == 'simple' :
905 open_file_graph("%s", width=%i, height=%i)
906 plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
907 """ % (ffr(fileout), width, height, type_dendro, histo, bw, tclasse)
908 elif dendro == 'texte' :
912 if (is.null(debsup)) {
915 chistable <- chistabletot[1:(debsup-1),]
916 open_file_graph("%s", width=%i, height=%i, svg = %s)
917 plot.dendro.prof(tree.cut1$tree.cl, classes, chistable, nbbycl = 60, type.dendro="%s", bw=%s, lab=NULL)
918 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
919 elif dendro == 'cloud' :
923 if (is.null(debsup)) {
926 chistable <- chistabletot[1:(debsup-1),]
927 open_file_graph("%s", width=%i, height=%i, svg=%s)
928 plot.dendro.cloud(tree.cut1$tree.cl, classes, chistable, nbbycl = 300, type.dendro="%s", bw=%s, lab=NULL)
929 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
932 tmpfile = tempfile.mktemp()
933 with open(tmpfile, 'w') as f :
935 busy = wx.BusyInfo(_("Please wait...").decode('utf8'), self.parent)
937 error = exec_rcode(self.ira.RPath, tmpfile, wait=True)
939 check_Rresult(self.ira, error)
940 self.list_graph.append([fileout, 'Dendrogramme CHD1 - %s' % type_dendro])
941 print_liste(self.dictpathout['liste_graph_chd'], self.list_graph)
942 if self.param['svg'] :
943 self.sizer_3.Add(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
945 self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
946 self.sizer_3.Add(wx.StaticText(self.panel_1,-1, 'Dendrogramme CHD1 - %s' % type_dendro), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
947 self.sizer_3.Fit(self.panel_1)
949 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
952 def ondendro(self, evt):
953 dial = PrefDendro(self.ira, self.param)
954 val = dial.ShowModal()
956 self.make_param(dial)
959 def ondendrotexte(self, evt):
960 dial = PrefDendro(self.ira, self.param)
961 val = dial.ShowModal()
963 self.make_param(dial)
964 self.make_dendro(dendro = 'texte')
966 def ondendrocloud(self, evt):
967 dial = PrefDendro(self.ira, self.param)
968 val = dial.ShowModal()
970 self.make_param(dial)
971 self.make_dendro(dendro = 'cloud')
974 def __init__(self, ira, parametres) :
975 #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)
976 self.panel = CopusPanel(ira, parametres)
977 ira.nb.AddPage(self.panel, 'Description %s' % parametres['corpus_name'])
978 #self.text.write(DoConf().totext(parametres))
979 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
980 ira.ShowAPane("Tab_content")
983 def __init__(self, ira, matrix):
984 #self.parent.content = self.csvtable
985 self.sheet = MySheet(ira.nb)
986 ira.nb.AddPage(self.sheet, matrix.parametres['matrix_name'])
987 self.sheet.Populate(matrix.csvtable)
988 self.sheet.parametres = matrix.parametres
989 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
990 ira.ShowAPane("Tab_content")
992 class CopusPanel(wx.Panel) :
993 def __init__(self, parent, parametres) :
994 wx.Panel.__init__ ( self, parent, id = wx.ID_ANY, pos = wx.DefaultPosition, size = wx.Size( 500,300 ), style = wx.TAB_TRAVERSAL )
995 self.parametres = parametres
996 fgSizer5 = wx.FlexGridSizer( 0, 2, 0, 0 )
997 fgSizer5.SetFlexibleDirection( wx.BOTH )
998 fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )
999 self.fgSizer5 = fgSizer5
1001 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Description du corpus", wx.DefaultPosition, wx.DefaultSize, 0 )
1003 self.m_staticText18.Wrap( -1 )
1004 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1006 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1007 self.m_staticText19.Wrap( -1 )
1008 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1010 self.m_staticText20 = wx.StaticText( self, wx.ID_ANY, u"Nom", wx.DefaultPosition, wx.DefaultSize, 0 )
1011 self.m_staticText20.Wrap( -1 )
1012 fgSizer5.Add( self.m_staticText20, 0, wx.ALL, 5 )
1014 self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, parametres['corpus_name'], wx.DefaultPosition, wx.DefaultSize, 0 )
1015 self.m_staticText21.Wrap( -1 )
1016 fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )
1018 description = {'lang' : u'langue',
1019 'encoding' : u'encodage',
1020 'ucinb' : u'Nombre de textes',
1021 'ucenb' : u'Nombre de segments de texte',
1022 'formesnb' : u'Nombre de formes',
1023 'hapax' : u'Nombre d\'hapax'
1026 keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']
1028 self.addkeys(keys, description)
1030 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Paramètres", wx.DefaultPosition, wx.DefaultSize, 0 )
1031 self.m_staticText18.Wrap( -1 )
1032 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1034 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1035 self.m_staticText19.Wrap( -1 )
1036 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1038 keys = ['ucemethod', 'ucesize', 'keep_caract', 'expressions']
1039 self.addkeys(keys, description)
1041 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Statistiques", wx.DefaultPosition, wx.DefaultSize, 0 )
1042 self.m_staticText18.Wrap( -1 )
1043 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1045 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1046 self.m_staticText19.Wrap( -1 )
1047 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1049 keys = ['ucinb', 'ucenb', 'occurrences', 'formesnb', 'hapax']
1050 self.addkeys(keys, description)
1052 self.SetSizer( fgSizer5 )
1055 def addkeys(self, keys, description) :
1057 option = self.parametres.get(key,u'non défini')
1058 if isinstance(option, int) :
1060 text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
1062 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1064 text = wx.StaticText( self, wx.ID_ANY, option, wx.DefaultPosition, wx.DefaultSize, 0 )
1066 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1068 class DefaultTextLayout :
1069 def __init__(self, ira, corpus, parametres) :
1070 self.pathout = PathOut(dirout = parametres['pathout'])
1073 self.parametres = parametres
1074 self.corpus = corpus
1077 def dolayout(self) :
1078 log.info('no layout yet')
1080 class WordCloudLayout(DefaultTextLayout):
1082 self.pathout.basefiles(simipath)
1083 self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1084 if self.parametres['svg'] :
1085 list_graph = [['nuage_1.svg', 'Nuage']]
1087 list_graph = [['nuage_1.png', 'Nuage']]
1088 self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, list_graph)
1089 self.Tab.AddPage(self.TabStatTot, 'Nuage')
1090 self.Tab.corpus = self.corpus
1091 self.Tab.parametres = self.parametres
1092 self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
1093 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1094 self.ira.ShowAPane("Tab_content")
1096 class SimiLayout(DefaultTextLayout) :
1097 def dolayout(self) :
1098 self.pathout.basefiles(simipath)
1100 self.indices = indices_simi
1101 if os.path.exists(self.pathout['liste_graph']) :
1102 list_graph = read_list_file(self.pathout['liste_graph'])
1104 list_graph = [['','']]
1105 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1106 self.tabsimi = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1107 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1108 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1109 self.tabsimi.corpus = self.corpus
1110 self.tabsimi.parametres = self.parametres
1111 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1112 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1113 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1114 self.tabsimi.AddPage(self.graphpan, 'Graph')
1115 self.ira.nb.AddPage(self.tabsimi, 'Analyse de graph')
1116 self.ira.ShowTab(True)
1117 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1119 def redosimi(self, evt) :
1120 with open(self.pathout['selected.csv'],'r') as f :
1122 selected = [int(val) for val in selected.splitlines()]
1123 if self.actives is None :
1124 with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1125 self.actives = f.read()
1126 self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1127 if os.path.exists(self.pathout['actives_nb.csv']) :
1128 with open(self.pathout['actives_nb.csv'], 'r') as f :
1130 act_nb = act_nb.splitlines()
1131 dictcol = dict([[i, [self.actives[i], int(act_nb[i])]] for i, val in enumerate(self.actives)])
1133 dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1134 #res = SelectColumn(self.ira, dictcol, self.actives, self.pathout['selected.csv'], selected = selected, dlg = True)
1136 prep = PrepSimi(self.ira, self, self.parametres,self.pathout['selected.csv'], self.actives, indices_simi, wordlist = dictcol, selected = selected)
1137 if prep.val == wx.ID_OK :
1138 self.parametres = prep.parametres
1140 script = PrintSimiScript(self)
1141 script.make_script()
1142 pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
1143 check_Rresult(self.ira, pid)
1144 if self.parametres['type_graph'] in [1,3] :
1145 if self.parametres['svg'] :
1146 filename, ext = os.path.splitext(script.filename)
1147 fileout = filename + '.svg'
1148 elif self.parametres['type_graph'] == 3 :
1149 fileout = script.filename
1150 parametres = {'gexffile' : fileout,
1151 'dirout' : os.path.dirname(fileout),
1152 'titre': 'Le titre',
1153 #'nodemin': self.param['txt_min'],
1154 #'nodemax': self.param['txt_max'],
1155 #'bargraphw' : 60*int(self.param['clnb']),
1157 web = WebExport(self.ira, parametres)
1158 fileout = web.exportsimi()
1160 fileout = script.filename
1161 if os.path.exists(self.pathout['liste_graph']):
1162 graph_simi = read_list_file(self.pathout['liste_graph'])
1163 graph_simi.append([os.path.basename(fileout), script.txtgraph])
1165 graph_simi = [[os.path.basename(fileout), script.txtgraph]]
1166 print_liste(self.pathout['liste_graph'], graph_simi)
1167 DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1168 if self.parametres['type_graph'] in [1,3] :
1169 if self.parametres['svg'] or self.parametres['type_graph'] == 3 :
1170 self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1172 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)
1173 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1174 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1175 self.graphpan.Layout()
1176 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1178 def export(self, evt) :
1180 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1182 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1188 graph <- graph.simi$graph
1189 V(graph)$x <- graph.simi$layout[,1]
1190 V(graph)$y <- graph.simi$layout[,2]
1191 if (length(graph.simi$label.cex == 1)) {
1192 V(graph)$weight <- graph.simi$eff
1194 V(graph)$weight <- graph.simi$label.cex
1196 V(graph)$color <- vertex.label.color
1197 V(graph)$frequences <- graph.simi$mat.eff
1198 V(graph)$label <- as.character(graph.simi$v.label)
1199 E(graph)$weight <- graph.simi$we.width
1200 write.graph(graph, fileout, format = 'graphml')
1201 #saveAsGEXF(graph, filepath = fileout)
1202 """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1203 filetmp = tempfile.mktemp()
1204 with open(filetmp, 'w') as f :
1206 exec_rcode(self.ira.RPath, filetmp)
1207 mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
1208 mss.CenterOnParent()
1212 class DefaultMatLayout :
1213 def __init__(self, parent, tableau, parametres) :
1214 self.pathout = PathOut(dirout = parametres['pathout'])
1216 self.parent = parent
1217 self.tableau = tableau
1218 self.parametres = parametres
1219 if os.path.exists(self.pathout['analyse.db']) :
1220 self.tableau.read_tableau(self.pathout['analyse.db'])
1222 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1223 self.ira.ShowAPane("Tab_content")
1225 def dolayout(self) :
1228 class FreqLayout(DefaultMatLayout) :
1229 def dolayout(self) :
1230 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1231 res = normpath_win32(self.pathout['resultats.html']).replace('\\','/')
1232 self.tab.LoadPage(res)
1233 self.tab.parametres = self.parametres
1234 self.ira.nb.AddPage(self.tab, u"Fréquences")
1237 class Chi2Layout(DefaultMatLayout) :
1239 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1240 if "gtk2" in wx.PlatformInfo:
1241 self.tab.SetStandardFonts()
1242 res = normpath_win32(self.pathout['resultats-chi2.html']).replace('\\','/')
1243 self.tab.LoadPage(res)
1244 self.tab.parametres = self.parametres
1245 self.ira.nb.AddPage(self.tab, ' - '.join([u"Chi2", "%s" % self.parametres['name']]))
1246 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1247 #self.ira.ShowAPane("Tab_content")
1250 class ProtoLayout(DefaultMatLayout) :
1251 def dolayout(self) :
1252 list_graph = [['proto.png', 'Analyse prototypique']]
1253 #self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1254 #if self.parametres['svg'] :
1255 # list_graph = [['nuage_1.svg', 'Nuage']]
1257 # list_graph = [['nuage_1.png', 'Nuage']]
1258 self.TabProto = GraphPanel(self.ira.nb, self.pathout, list_graph)
1259 #self.Tab.AddPage(self.TabProto, 'Analyse Prototypique')
1260 #self.Tab.corpus = self.corpus
1261 self.TabProto.parametres = self.parametres
1262 self.ira.nb.AddPage(self.TabProto, 'Analyse Prototypique - %s' % self.parametres['name'])
1263 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1264 #self.ira.ShowAPane("Tab_content")
1267 class SimiMatLayout(DefaultMatLayout) :
1269 self.pathout.basefiles(simipath)
1270 self.indices = indices_simi
1271 if os.path.exists(self.pathout['liste_graph']) :
1272 list_graph = read_list_file(self.pathout['liste_graph'])
1274 list_graph = [['','']]
1275 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1276 self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1277 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1278 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1279 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1280 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1281 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1282 self.tabsimi.AddPage(self.graphpan, 'Graph')
1283 self.tabsimi.parametres = self.parametres
1284 self.parent.nb.AddPage(self.tabsimi, 'Analyse de graph')
1285 #self.parent.ShowTab(True)
1286 #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1288 def redosimi(self,evt) :
1289 with open(self.pathout['selected.csv'],'r') as f :
1291 selected = [int(val) for val in selected.splitlines()]
1292 #if self.actives is None :
1293 # with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1294 # self.actives = f.read()
1295 # self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1297 actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1299 actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1301 #self.tableau.make_listactives()
1302 actives = dict([[i, val] for i, val in enumerate(actives)])
1303 #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1304 self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1305 self.dial.CenterOnParent()
1306 self.val = self.dial.ShowModal()
1307 if self.val == wx.ID_OK :
1308 last = self.dial.listcol.GetFirstSelected()
1309 lastl = [self.dial.listcol.GetFirstSelected()]
1310 indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1311 while self.dial.listcol.GetNextSelected(last) != -1:
1312 last = self.dial.listcol.GetNextSelected(last)
1314 indexes.append(self.dial.listcol.getColumnText(last,0))
1315 self.column = [self.tableau.listactives.index(val) for val in indexes]
1317 with open(self.pathout['selected.csv'], 'w') as f :
1318 f.write('\n'.join([`val` for val in self.column]))
1321 self.script = PrintSimiScript(self)
1322 self.script.make_script()
1323 self.tmpfile = self.script.scriptout
1324 dlg = progressbar(self, maxi = 2)
1327 if self.parametres['type_graph'] == 1:
1328 if self.parametres['svg'] :
1329 filename, ext = os.path.splitext(self.script.filename)
1330 fileout = filename + '.svg'
1332 fileout = self.script.filename
1333 fileout = normpath_win32(fileout)
1334 if os.path.exists(self.pathout['liste_graph']):
1335 graph_simi = read_list_file(self.pathout['liste_graph'])
1336 graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1338 graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1339 print_liste(self.pathout['liste_graph'], graph_simi)
1340 DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1341 if self.parametres['type_graph'] == 1:
1342 if self.parametres['svg'] :
1343 self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1345 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)
1346 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1347 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1348 self.graphpan.Layout()
1349 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1354 def make_param(self) :
1355 if self.parametres['first'] :
1358 keep_coord = self.dial.check_coord.GetValue()
1359 #self.select = self.dial.check_colch.GetValue()
1361 paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1362 'layout' : self.dial.choice2.GetSelection(),
1363 'type_graph' : self.dial.choice3.GetSelection(),
1364 'arbremax' : self.dial.check1.GetValue(),
1365 'coeff_tv' : self.dial.check_s_size.GetValue(),
1366 'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1367 'tvprop' : self.dial.check2.GetValue(),
1368 'tvmin' : self.dial.spin_tvmin.GetValue(),
1369 'tvmax' : self.dial.spin_tvmax.GetValue(),
1370 'coeff_te' : self.dial.check3.GetValue(),
1371 'coeff_temin' : self.dial.spin_temin.GetValue(),
1372 'coeff_temax' : self.dial.spin_temax.GetValue(),
1373 'label_e' : self.dial.check_elab.GetValue(),
1374 'label_v' : self.dial.check_vlab.GetValue(),
1375 'vcex' : self.dial.check_vcex.GetValue(),
1376 'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1377 'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1378 'cex' : self.dial.spin_cex.GetValue(),
1379 'seuil_ok' : self.dial.check_seuil.GetValue(),
1380 'seuil' : self.dial.spin_seuil.GetValue(),
1381 'cols' : self.dial.cols.GetColour(),
1382 'cola' : self.dial.cola.GetColour(),
1383 'width' : self.dial.spin_width.GetValue(),
1384 'height' : self.dial.spin_height.GetValue(),
1386 'keep_coord' : keep_coord,
1387 'alpha' : self.dial.slider_sphere.GetValue(),
1388 'film' : self.dial.film.GetValue(),
1389 'svg' : self.dial.choix_format.GetSelection(),
1390 'halo' : self.dial.halo.GetValue(),
1391 'com' : self.dial.comcheck.GetValue(),
1392 'communities' : self.dial.choix_com.GetSelection(),
1394 if 'cexfromchi' in self.parametres :
1395 paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1396 if 'sfromchi' in self.parametres :
1397 paramsimi['sfromchi'] = self.dial.checki.GetValue()
1398 if 'vlabcolor' in self.parametres :
1399 paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1400 if 'check_bystar' in dir(self.dial) :
1401 paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1402 paramsimi['stars'] = self.parametres['stars']
1403 self.parametres.update(paramsimi)
1406 if self.parametres['type_graph'] == 1 :
1412 pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1413 if self.parametres['type_graph'] == 1 :
1414 while pid.poll() == None :
1417 check_Rresult(self.parent, pid)
1419 def export(self, evt) :
1421 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1423 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1429 graph <- graph.simi$graph
1430 V(graph)$x <- graph.simi$layout[,1]
1431 V(graph)$y <- graph.simi$layout[,2]
1432 if (length(graph.simi$label.cex == 1)) {
1433 V(graph)$weight <- graph.simi$mat.eff
1435 V(graph)$weight <- graph.simi$label.cex
1437 V(graph)$color <- vertex.label.color
1438 V(graph)$frequences <- graph.simi$mat.eff
1439 V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
1440 V(graph)$label <- as.character(graph.simi$v.label)
1441 E(graph)$weight <- graph.simi$we.width
1442 write.graph(graph, fileout, format = 'graphml')
1443 #saveAsGEXF(graph, filepath = fileout)
1444 """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1445 filetmp = tempfile.mktemp()
1446 with open(filetmp, 'w') as f :
1448 exec_rcode(self.ira.RPath, filetmp)
1449 mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
1450 mss.CenterOnParent()
1455 class GraphPanelSimi(wx.Panel):
1456 def __init__(self,parent, dico, list_graph):
1457 wx.Panel.__init__(self,parent)
1460 self.dirout = os.path.dirname(self.Dict['ira'])
1461 self.parent = self.GetParent()#parent
1462 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "courier"))
1465 self.tabsimi = self.parent.GetParent()
1466 self.ira = self.tabsimi.GetParent()
1467 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1468 afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1469 self.butafc = wx.BitmapButton(self, -1, afc_img)
1470 export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1471 self.butexport = wx.BitmapButton(self, -1, export_img)
1472 for i in range(0,len(list_graph)):
1473 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1474 filename, ext = os.path.splitext(list_graph[i][0])
1475 if ext in ['.svg', '.html'] :
1476 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])))
1478 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1479 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1480 self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove)
1481 self.__set_properties()
1484 def __set_properties(self):
1485 self.panel_1.EnableScrolling(True,True)
1486 #self.panel_1.SetSize((1000,1000))
1487 self.panel_1.SetScrollRate(20, 20)
1488 self.panel_1.SetFocus()
1490 def __do_layout(self):
1491 self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1492 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1493 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1494 self.sizer_2.Add(self.butafc, 0, 0, 0)
1495 self.sizer_2.Add(self.butexport, 0, 0, 0)
1496 for i in range(0, len(self.listimg)):
1497 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1498 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1499 self.panel_1.SetSizer(self.sizer_3)
1500 self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1501 self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1502 self.SetSizer(self.sizer_1)
1504 def onMouseMove(self, event):
1505 self.panel_1.SetFocus()