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 if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenchi2.csv')) :
523 self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenchi2.csv')
525 panel.TabChdSim.SetSelection(0)
526 self.parent.nb.AddPage(panel, _(u"Clustering").decode('utf8') + ' - %s' % corpname)
527 self.parent.ShowTab(True)
528 self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
529 #for pane in self.parent._mgr.GetAllPanes() :
530 # if isinstance(pane.window, aui.AuiNotebook):
532 # nb.SetAGWWindowStyleFlag(notebook_flags)
533 # nb.SetArtProvider(aui.ChromeTabArt())
535 self.parent._mgr.Update()
537 def onsimi(self,event):
538 outfile = print_simi3d(self)
539 error = exec_rcode(self.parent.RPath, outfile, wait = True)
541 def onclusterstat(self, evt) :
542 dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': 'Stat par classe'})
543 dial.fbb.SetValue( os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'stat_par_classe.csv'))
544 dial.CenterOnParent()
545 res = dial.ShowModal()
547 fileout = dial.fbb.GetValue()
549 self.corpus.get_stat_by_cluster(fileout)
551 dlg = wx.MessageDialog(self.parent, msg, _(u"Stat by cluster").decode('utf8'), wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
553 if dlg.ShowModal() == wx.ID_OK :
556 #def onsearchf(self, evt) :
557 # if 'FrameSearch' not in dir(self.panel) :
558 # self.panel.FrameSearch = SearchFrame(self.parent, -1, u"Rechercher...", self.corpus)
559 # self.panel.FrameSearch.Show()
561 def PrintRapport(self, corpus, parametres, istxt = True):
565 |i|R|a|M|u|T|e|Q| - %s
569 """ % datetime.datetime.now().ctime()
571 totocc = corpus.gettotocc()
572 txt += u'nombre de textes: %i%s' % (corpus.getucinb(), sep)
573 txt += u'nombre de segments de textes: %i%s' % (corpus.getucenb(), sep)
574 txt += u'nombre de formes: %i%s' % (len(corpus.formes), sep)
575 txt += u'nombre d\'occurrences: %i%s' % (totocc, sep)
576 txt += u'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
577 txt += u'nombre de lemmes: %i%s' % (len(corpus.lems), sep)
578 txt += u'nombre de formes actives: %i%s' % (corpus.getactivesnb(1), sep)
579 txt += u'nombre de formes supplémentaires: %i%s' % (corpus.getactivesnb(2), sep)
580 txt += u'nombre de formes actives de fréquence >= %i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)
581 txt += u'moyenne d\'occurrences par segments :%f%s' % (float(totocc) / float(corpus.getucenb()), sep)
582 if 'tailleuc1' in parametres :
583 if parametres['classif_mode'] == 0 :
584 txt += u'taille rst1 / rst2: %i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)
586 self.Ucenb = self.nbind
587 txt += u'nombre d\'individus : %i%s' % (self.nbind, sep)
588 txt += u'nombre de classes : %i%s' % (self.clnb, sep)
590 txt += u'nombre de classes : %i%s' % (parametres['clnb'], sep)
591 if parametres['classif_mode'] == 0 or parametres['classif_mode'] == 1 :
592 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)
593 elif self.parametres['classif_mode'] == 2 :
594 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)
596 txt += u'%i segments classées sur %i (%.2f%%)%s' % (self.ucecla, self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)
599 ###########################
601 ###########################
602 """ % parametres.get('time', '')
603 with open(self.pathout['pre_rapport'], 'w') as f :
607 class SashList(wx.Panel) :
608 def __init__(self, parent) :
609 wx.Panel.__init__(self, parent, -1)
612 #self.gparent=gparent
616 # A window to the left of the client window
617 #self.listlex = listlex
618 self.leftwin1 = wx.SashLayoutWindow(
619 self, -1, wx.DefaultPosition, (200, 300),
620 wx.NO_BORDER|wx.SW_3D
623 self.leftwin1.SetDefaultSize((120, 1000))
624 self.leftwin1.SetOrientation(wx.LAYOUT_VERTICAL)
625 self.leftwin1.SetAlignment(wx.LAYOUT_LEFT)
626 self.leftwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
627 self.leftwin1.SetSashVisible(wx.SASH_RIGHT, True)
628 self.leftwin1.SetExtraBorderSize(10)
630 #textWindow = wx.TextCtrl(
631 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
632 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
635 #textWindow.SetValue("A sub window")
637 self.leftWindow1 = self.leftwin1
638 winids.append(self.leftwin1.GetId())
640 rightwin1 = wx.SashLayoutWindow(
641 self, -1, wx.DefaultPosition, (200, 300),
642 wx.NO_BORDER|wx.SW_3D
645 rightwin1.SetDefaultSize((120, 1000))
646 rightwin1.SetOrientation(wx.LAYOUT_VERTICAL)
647 rightwin1.SetAlignment(wx.LAYOUT_LEFT)
648 rightwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
649 rightwin1.SetSashVisible(wx.SASH_RIGHT, True)
650 rightwin1.SetExtraBorderSize(10)
651 #textWindow = wx.TextCtrl(
652 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
653 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
656 #textWindow.SetValue("A sub window")
658 self.rightwin1 = rightwin1
659 winids.append(rightwin1.GetId())
662 def __init__(self, page):
664 parametres = self.page.parametres
665 ira = wx.GetApp().GetTopWindow()
666 tgenpath = os.path.join(parametres['pathout'], 'tgen.csv')
667 self.page.tgens, etoiles = ReadList(parametres['tgenspec'], ira.syscoding, sep="\t")
668 tgen = TGen(path = tgenpath, encoding = parametres['encoding'])
672 if 'TabChdSim' in dir(page) :
673 page = page.TabChdSim
674 for i in range(page.GetPageCount()) :
675 tab = page.GetPage(i)
676 if 'gparent' in dir(tab) :
677 if tab.gparent is not None :
678 gparent = tab.gparent
679 if 'tgen' in dir(tab) :
685 self.page.tgentab.RefreshData(self.page.tgens)
686 self.page.tgentab.tgens = tgen.tgen
689 self.page.tgentab = ListForSpec(ira, gparent, self.page.tgens, etoiles[1:])
690 self.page.tgentab.tgen = True
691 self.page.tgentab.tgens = tgen.tgen
692 page.AddPage(self.page.tgentab, u'Tgens Specificities')
693 page.SetSelection(page.GetPageCount() - 1)
696 def __init__(self, ira, corpus, parametres):
697 self.pathout = PathOut(dirout = parametres['pathout'])
699 self.dictpathout = StatTxtPathOut(parametres['pathout'])
700 #self.corpus.read_corpus_from_shelves(self.corpus.dictpathout['db'])
702 self.encoding = self.corpus.parametres['syscoding']
703 self.parametres = parametres
705 self.DictSpec, first = ReadList(self.dictpathout['tablespecf'], self.corpus.parametres['syscoding'])
706 if os.path.exists(self.pathout['banalites.csv']) :
707 self.dictban, firstban = ReadList(self.pathout['banalites.csv'], self.corpus.parametres['syscoding'])
708 self.DictType, firstt = ReadList(self.dictpathout['tablespect'], self.corpus.parametres['syscoding'])
709 self.DictEff, firsteff = ReadList(self.dictpathout['tableafcm'], self.corpus.parametres['syscoding'])
710 self.DictEffType, firstefft = ReadList(self.dictpathout['tabletypem'], self.corpus.parametres['syscoding'])
711 self.DictEffRelForme, firsteffrelf = ReadList(self.dictpathout['eff_relatif_forme'], self.corpus.parametres['syscoding'])
712 self.DictEffRelType, firsteffrelt = ReadList(self.dictpathout['eff_relatif_type'], self.corpus.parametres['syscoding'])
713 self.etoiles = firsteff[1:]
714 #sash = SashList(ira.nb)
717 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
718 self.TabStat.parametres = parametres
719 self.ListPan = ListForSpec(ira, self, self.DictSpec, self.etoiles)
720 if os.path.exists(self.pathout['banalites.csv']) :
721 self.listban = ListForSpec(ira, self, self.dictban, ['eff'] + self.etoiles, usefirst = True)
722 #self.ListPan2 = ListForSpec(sash.rightwin1, self, self.DictSpec, first)
723 self.ListPant = ListForSpec(ira, self, self.DictType, self.etoiles)
724 self.ListPanEff = ListForSpec(ira, self, self.DictEff, self.etoiles)
725 self.ListPanEffType = ListForSpec(ira, self, self.DictEffType, self.etoiles)
726 self.ListPanEffRelForme = ListForSpec(ira, self, self.DictEffRelForme, self.etoiles)
727 self.ListPanEffRelType = ListForSpec(ira, self, self.DictEffRelType, self.etoiles)
729 self.TabStat.AddPage(self.ListPan, u'formes')
730 if os.path.exists(self.pathout['banalites.csv']) :
731 self.TabStat.AddPage(self.listban, u'banalités')
732 self.TabStat.AddPage(self.ListPant, u'Types')
733 self.TabStat.AddPage(self.ListPanEff, u'Effectifs formes')
734 self.TabStat.AddPage(self.ListPanEffType, u'Effectifs Type')
735 self.TabStat.AddPage(self.ListPanEffRelForme, u'Effectifs relatifs formes')
736 self.TabStat.AddPage(self.ListPanEffRelType, u'Effectifs relatifs Type')
737 if self.parametres['clnb'] > 2 :
738 self.TabAFC = aui.AuiNotebook(self.TabStat, -1, wx.DefaultPosition)
739 list_graph=read_list_file(self.dictpathout['liste_graph_afcf'], encoding = self.encoding)
740 self.tabAFCGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afcf', coding = self.encoding)
741 self.TabAFC.AddPage(self.tabAFCGraph, 'AFC formes')
742 list_graph=read_list_file(self.dictpathout['liste_graph_afct'], encoding = self.encoding)
743 self.tabAFCTGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afct', coding=self.encoding)
744 self.TabAFC.AddPage(self.tabAFCTGraph, 'AFC type')
745 self.TabStat.AddPage(self.TabAFC, 'AFC')
747 ira.nb.AddPage(self.TabStat, u'Spécificités')
750 self.TabStat.corpus = self.corpus
751 self.TabStat.etoiles = self.etoiles
752 if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenspec.csv')) :
753 self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenspec.csv')
754 TgenLayout(self.TabStat)
755 self.TabStat.SetSelection(0)
756 ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
757 ira.ShowAPane("Tab_content")
760 def __init__(self, ira, corpus, parametres):
761 self.pathout = PathOut(dirout = parametres['pathout'])
765 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
766 self.TabStat.parametres = parametres
767 self.TabStat.corpus = corpus
768 self.TabStat.pathout = self.pathout
769 # CHD = GraphPanel(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
770 # panel.TabChdSim.AddPage(CHD,'CHD')
772 #self.TabStatTot = wx.TextCtrl(self.TabStat, -1, style=wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2)
773 list_graph = [['zipf.png', 'zipf']]
774 self.TabStatTot = GraphPanel(ira.nb, self.pathout, list_graph, self.result['glob'])
775 self.TabStat.AddPage(self.TabStatTot, 'global')
776 for item in self.result:
778 datam = [['forme', 'nb']]
779 self.ListPan = ListPanel(ira, self, self.result[item])
780 self.TabStat.AddPage(self.ListPan, ' '.join(item.split('_')))
781 ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
782 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
783 ira.ShowAPane("Tab_content")
785 def read_result(self) :
786 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'}
789 with open(self.pathout[lcle[key]], 'r') as f :
790 self.result[key] = [line.split(';') for line in f.read().splitlines()]
791 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
792 with open(self.pathout['glob.txt'], 'r') as f :
793 self.result['glob'] = f.read()
795 class GraphPanelDendro(wx.Panel):
796 def __init__(self,parent, dico, list_graph, txt=False):
797 wx.Panel.__init__(self,parent)
799 self.dictpathout = dico
800 self.dirout = os.path.dirname(self.dictpathout['ira'])
801 self.list_graph = list_graph
802 self.parent = self.GetParent()#parent
803 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
806 self.tabchd = self.parent.GetParent()
807 self.ira = self.tabchd.GetParent()
808 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
809 self.panel_1.SetBackgroundColour('white')
810 self.deb = wx.StaticText(self.panel_1, -1, txt)
811 dendro_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
812 dendro_liste_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro_liste.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
813 dendro_cloud_img= wx.Image(os.path.join(self.ira.images_path,'but_dendro_cloud.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
814 self.butdendro = wx.BitmapButton(self, -1, dendro_img)
815 self.butdendrotexte = wx.BitmapButton(self, -1, dendro_liste_img)
816 self.butdendrocloud = wx.BitmapButton(self, -1, dendro_cloud_img)
818 for i in range(0,len(list_graph)):
819 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
820 filename, ext = os.path.splitext(list_graph[i][0])
822 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])))
824 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
825 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
827 self.__set_properties()
830 def __set_properties(self):
831 self.panel_1.EnableScrolling(True,True)
832 #self.panel_1.SetSize((1000,1000))
833 self.panel_1.SetScrollRate(20, 20)
834 self.panel_1.SetFocus()
835 self.Bind(wx.EVT_BUTTON, self.ondendro, self.butdendro)
836 self.Bind(wx.EVT_BUTTON, self.ondendrotexte, self.butdendrotexte)
837 self.Bind(wx.EVT_BUTTON, self.ondendrocloud, self.butdendrocloud)
838 self.param = {'width' : 700,
842 'taille_classe' : True,
846 self.type_dendro = [ u"phylogram", u"cladogram", u"fan", u"unrooted", u"radial" ]
848 def __do_layout(self):
849 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
850 self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
851 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
852 self.sizer_3.Add(self.deb)
853 self.sizer_1.Add(self.butdendro, 0, 0, 0)
854 self.sizer_1.Add(self.butdendrotexte, 0, 0, 0)
855 self.sizer_1.Add(self.butdendrocloud, 0, 0, 0)
857 for i in range(0, len(self.listimg)):
858 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
859 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
860 self.panel_1.SetSizer(self.sizer_3)
861 self.sizer_2.Add(self.sizer_1, 0, wx.EXPAND, 0)
862 self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
863 self.SetSizer(self.sizer_2)
865 def make_param(self, dial):
866 self.param['width'] = dial.m_spinCtrl2.GetValue()
867 self.param['height'] = dial.m_spinCtrl1.GetValue()
868 self.param['type_dendro'] = dial.m_choice1.GetSelection()
869 self.param['color_nb'] = dial.m_radioBox1.GetSelection()
870 self.param['taille_classe'] = dial.m_checkBox1.GetValue()
871 self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
872 self.param['svg'] = dial.choice_format.GetSelection()
874 def make_dendro(self, dendro = 'simple') :
875 if self.param['svg'] :
879 while os.path.exists(os.path.join(self.dirout, 'dendrogramme_' + str(self.graphnb)+typefile)) :
881 fileout = ffr(os.path.join(self.dirout,'dendrogramme_' + str(self.graphnb)+typefile))
882 width = self.param['width']
883 height = self.param['height']
884 type_dendro = self.type_dendro[self.param['type_dendro']]
885 if self.param['taille_classe'] :
889 if self.param['color_nb'] == 0 :
893 if self.param['type_tclasse'] == 0 :
897 if self.param['svg'] :
901 dendro_path = self.dictpathout['Rdendro']
902 classe_path = self.dictpathout['uce']
907 classes <- read.csv2("%s", row.names=1)
908 classes <- classes[,1]
909 """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']), ffr(classe_path))
910 if dendro == 'simple' :
912 open_file_graph("%s", width=%i, height=%i)
913 plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
914 """ % (ffr(fileout), width, height, type_dendro, histo, bw, tclasse)
915 elif dendro == 'texte' :
919 if (is.null(debsup)) {
922 chistable <- chistabletot[1:(debsup-1),]
923 open_file_graph("%s", width=%i, height=%i, svg = %s)
924 plot.dendro.prof(tree.cut1$tree.cl, classes, chistable, nbbycl = 60, type.dendro="%s", bw=%s, lab=NULL)
925 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
926 elif dendro == 'cloud' :
930 if (is.null(debsup)) {
933 chistable <- chistabletot[1:(debsup-1),]
934 open_file_graph("%s", width=%i, height=%i, svg=%s)
935 plot.dendro.cloud(tree.cut1$tree.cl, classes, chistable, nbbycl = 300, type.dendro="%s", bw=%s, lab=NULL)
936 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
939 tmpfile = tempfile.mktemp()
940 with open(tmpfile, 'w') as f :
942 busy = wx.BusyInfo(_("Please wait...").decode('utf8'), self.parent)
944 error = exec_rcode(self.ira.RPath, tmpfile, wait=True)
946 check_Rresult(self.ira, error)
947 self.list_graph.append([fileout, 'Dendrogramme CHD1 - %s' % type_dendro])
948 print_liste(self.dictpathout['liste_graph_chd'], self.list_graph)
949 if self.param['svg'] :
950 self.sizer_3.Add(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
952 self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
953 self.sizer_3.Add(wx.StaticText(self.panel_1,-1, 'Dendrogramme CHD1 - %s' % type_dendro), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
954 self.sizer_3.Fit(self.panel_1)
956 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
959 def ondendro(self, evt):
960 dial = PrefDendro(self.ira, self.param)
961 val = dial.ShowModal()
963 self.make_param(dial)
966 def ondendrotexte(self, evt):
967 dial = PrefDendro(self.ira, self.param)
968 val = dial.ShowModal()
970 self.make_param(dial)
971 self.make_dendro(dendro = 'texte')
973 def ondendrocloud(self, evt):
974 dial = PrefDendro(self.ira, self.param)
975 val = dial.ShowModal()
977 self.make_param(dial)
978 self.make_dendro(dendro = 'cloud')
981 def __init__(self, ira, parametres) :
982 #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)
983 self.panel = CopusPanel(ira, parametres)
984 ira.nb.AddPage(self.panel, 'Description %s' % parametres['corpus_name'])
985 #self.text.write(DoConf().totext(parametres))
986 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
987 ira.ShowAPane("Tab_content")
990 def __init__(self, ira, matrix):
991 #self.parent.content = self.csvtable
992 self.sheet = MySheet(ira.nb)
993 ira.nb.AddPage(self.sheet, matrix.parametres['matrix_name'])
994 self.sheet.Populate(matrix.csvtable)
995 self.sheet.parametres = matrix.parametres
996 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
997 ira.ShowAPane("Tab_content")
999 class CopusPanel(wx.Panel) :
1000 def __init__(self, parent, parametres) :
1001 wx.Panel.__init__ ( self, parent, id = wx.ID_ANY, pos = wx.DefaultPosition, size = wx.Size( 500,300 ), style = wx.TAB_TRAVERSAL )
1002 self.parametres = parametres
1003 fgSizer5 = wx.FlexGridSizer( 0, 2, 0, 0 )
1004 fgSizer5.SetFlexibleDirection( wx.BOTH )
1005 fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )
1006 self.fgSizer5 = fgSizer5
1008 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Description du corpus", wx.DefaultPosition, wx.DefaultSize, 0 )
1010 self.m_staticText18.Wrap( -1 )
1011 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1013 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1014 self.m_staticText19.Wrap( -1 )
1015 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1017 self.m_staticText20 = wx.StaticText( self, wx.ID_ANY, u"Nom", wx.DefaultPosition, wx.DefaultSize, 0 )
1018 self.m_staticText20.Wrap( -1 )
1019 fgSizer5.Add( self.m_staticText20, 0, wx.ALL, 5 )
1021 self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, parametres['corpus_name'], wx.DefaultPosition, wx.DefaultSize, 0 )
1022 self.m_staticText21.Wrap( -1 )
1023 fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )
1025 description = {'lang' : u'langue',
1026 'encoding' : u'encodage',
1027 'ucinb' : u'Nombre de textes',
1028 'ucenb' : u'Nombre de segments de texte',
1029 'formesnb' : u'Nombre de formes',
1030 'hapax' : u'Nombre d\'hapax'
1033 keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']
1035 self.addkeys(keys, description)
1037 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Paramètres", wx.DefaultPosition, wx.DefaultSize, 0 )
1038 self.m_staticText18.Wrap( -1 )
1039 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1041 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1042 self.m_staticText19.Wrap( -1 )
1043 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1045 keys = ['ucemethod', 'ucesize', 'keep_caract', 'expressions']
1046 self.addkeys(keys, description)
1048 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Statistiques", wx.DefaultPosition, wx.DefaultSize, 0 )
1049 self.m_staticText18.Wrap( -1 )
1050 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1052 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1053 self.m_staticText19.Wrap( -1 )
1054 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1056 keys = ['ucinb', 'ucenb', 'occurrences', 'formesnb', 'hapax']
1057 self.addkeys(keys, description)
1059 self.SetSizer( fgSizer5 )
1062 def addkeys(self, keys, description) :
1064 option = self.parametres.get(key,u'non défini')
1065 if isinstance(option, int) :
1067 text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
1069 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1071 text = wx.StaticText( self, wx.ID_ANY, option, wx.DefaultPosition, wx.DefaultSize, 0 )
1073 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1075 class DefaultTextLayout :
1076 def __init__(self, ira, corpus, parametres) :
1077 self.pathout = PathOut(dirout = parametres['pathout'])
1080 self.parametres = parametres
1081 self.corpus = corpus
1084 def dolayout(self) :
1085 log.info('no layout yet')
1087 class WordCloudLayout(DefaultTextLayout):
1089 self.pathout.basefiles(simipath)
1090 self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1091 if self.parametres['svg'] :
1092 list_graph = [['nuage_1.svg', 'Nuage']]
1094 list_graph = [['nuage_1.png', 'Nuage']]
1095 self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, list_graph)
1096 self.Tab.AddPage(self.TabStatTot, 'Nuage')
1097 self.Tab.corpus = self.corpus
1098 self.Tab.parametres = self.parametres
1099 self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
1100 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1101 self.ira.ShowAPane("Tab_content")
1103 class SimiLayout(DefaultTextLayout) :
1104 def dolayout(self) :
1105 self.pathout.basefiles(simipath)
1107 self.indices = indices_simi
1108 if os.path.exists(self.pathout['liste_graph']) :
1109 list_graph = read_list_file(self.pathout['liste_graph'])
1111 list_graph = [['','']]
1112 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1113 self.tabsimi = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1114 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1115 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1116 self.tabsimi.corpus = self.corpus
1117 self.tabsimi.parametres = self.parametres
1118 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1119 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1120 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1121 self.tabsimi.AddPage(self.graphpan, 'Graph')
1122 self.ira.nb.AddPage(self.tabsimi, 'Analyse de graph')
1123 self.ira.ShowTab(True)
1124 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1126 def redosimi(self, evt) :
1127 with open(self.pathout['selected.csv'],'r') as f :
1129 selected = [int(val) for val in selected.splitlines()]
1130 if self.actives is None :
1131 with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1132 self.actives = f.read()
1133 self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1134 if os.path.exists(self.pathout['actives_nb.csv']) :
1135 with open(self.pathout['actives_nb.csv'], 'r') as f :
1137 act_nb = act_nb.splitlines()
1138 dictcol = dict([[i, [self.actives[i], int(act_nb[i])]] for i, val in enumerate(self.actives)])
1140 dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1141 #res = SelectColumn(self.ira, dictcol, self.actives, self.pathout['selected.csv'], selected = selected, dlg = True)
1143 prep = PrepSimi(self.ira, self, self.parametres,self.pathout['selected.csv'], self.actives, indices_simi, wordlist = dictcol, selected = selected)
1144 if prep.val == wx.ID_OK :
1145 self.parametres = prep.parametres
1147 script = PrintSimiScript(self)
1148 script.make_script()
1149 pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
1150 check_Rresult(self.ira, pid)
1151 if self.parametres['type_graph'] in [1,3] :
1152 if self.parametres['svg'] :
1153 filename, ext = os.path.splitext(script.filename)
1154 fileout = filename + '.svg'
1155 elif self.parametres['type_graph'] == 3 :
1156 fileout = script.filename
1157 parametres = {'gexffile' : fileout,
1158 'dirout' : os.path.dirname(fileout),
1159 'titre': 'Le titre',
1160 #'nodemin': self.param['txt_min'],
1161 #'nodemax': self.param['txt_max'],
1162 #'bargraphw' : 60*int(self.param['clnb']),
1164 web = WebExport(self.ira, parametres)
1165 fileout = web.exportsimi()
1167 fileout = script.filename
1168 if os.path.exists(self.pathout['liste_graph']):
1169 graph_simi = read_list_file(self.pathout['liste_graph'])
1170 graph_simi.append([os.path.basename(fileout), script.txtgraph])
1172 graph_simi = [[os.path.basename(fileout), script.txtgraph]]
1173 print_liste(self.pathout['liste_graph'], graph_simi)
1174 DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1175 if self.parametres['type_graph'] in [1,3] :
1176 if self.parametres['svg'] or self.parametres['type_graph'] == 3 :
1177 self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1179 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)
1180 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1181 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1182 self.graphpan.Layout()
1183 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1185 def export(self, evt) :
1187 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1189 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1195 graph <- graph.simi$graph
1196 V(graph)$x <- graph.simi$layout[,1]
1197 V(graph)$y <- graph.simi$layout[,2]
1198 if (length(graph.simi$label.cex == 1)) {
1199 V(graph)$weight <- graph.simi$eff
1201 V(graph)$weight <- graph.simi$label.cex
1203 V(graph)$color <- vertex.label.color
1204 V(graph)$frequences <- graph.simi$mat.eff
1205 V(graph)$label <- as.character(graph.simi$v.label)
1206 E(graph)$weight <- graph.simi$we.width
1207 write.graph(graph, fileout, format = 'graphml')
1208 #saveAsGEXF(graph, filepath = fileout)
1209 """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1210 filetmp = tempfile.mktemp()
1211 with open(filetmp, 'w') as f :
1213 exec_rcode(self.ira.RPath, filetmp)
1214 mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
1215 mss.CenterOnParent()
1219 class DefaultMatLayout :
1220 def __init__(self, parent, tableau, parametres) :
1221 self.pathout = PathOut(dirout = parametres['pathout'])
1223 self.parent = parent
1224 self.tableau = tableau
1225 self.parametres = parametres
1226 if os.path.exists(self.pathout['analyse.db']) :
1227 self.tableau.read_tableau(self.pathout['analyse.db'])
1229 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1230 self.ira.ShowAPane("Tab_content")
1232 def dolayout(self) :
1235 class FreqLayout(DefaultMatLayout) :
1236 def dolayout(self) :
1237 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1238 res = normpath_win32(self.pathout['resultats.html']).replace('\\','/')
1239 self.tab.LoadPage(res)
1240 self.tab.parametres = self.parametres
1241 self.ira.nb.AddPage(self.tab, u"Fréquences")
1244 class Chi2Layout(DefaultMatLayout) :
1246 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1247 if "gtk2" in wx.PlatformInfo:
1248 self.tab.SetStandardFonts()
1249 res = normpath_win32(self.pathout['resultats-chi2.html']).replace('\\','/')
1250 self.tab.LoadPage(res)
1251 self.tab.parametres = self.parametres
1252 self.ira.nb.AddPage(self.tab, ' - '.join([u"Chi2", "%s" % self.parametres['name']]))
1253 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1254 #self.ira.ShowAPane("Tab_content")
1257 class ProtoLayout(DefaultMatLayout) :
1258 def dolayout(self) :
1259 list_graph = [['proto.png', 'Analyse prototypique']]
1260 #self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1261 #if self.parametres['svg'] :
1262 # list_graph = [['nuage_1.svg', 'Nuage']]
1264 # list_graph = [['nuage_1.png', 'Nuage']]
1265 self.TabProto = GraphPanel(self.ira.nb, self.pathout, list_graph)
1266 #self.Tab.AddPage(self.TabProto, 'Analyse Prototypique')
1267 #self.Tab.corpus = self.corpus
1268 self.TabProto.parametres = self.parametres
1269 self.ira.nb.AddPage(self.TabProto, 'Analyse Prototypique - %s' % self.parametres['name'])
1270 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1271 #self.ira.ShowAPane("Tab_content")
1274 class SimiMatLayout(DefaultMatLayout) :
1276 self.pathout.basefiles(simipath)
1277 self.indices = indices_simi
1278 if os.path.exists(self.pathout['liste_graph']) :
1279 list_graph = read_list_file(self.pathout['liste_graph'])
1281 list_graph = [['','']]
1282 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1283 self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1284 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1285 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1286 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1287 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1288 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1289 self.tabsimi.AddPage(self.graphpan, 'Graph')
1290 self.tabsimi.parametres = self.parametres
1291 self.parent.nb.AddPage(self.tabsimi, 'Analyse de graph')
1292 #self.parent.ShowTab(True)
1293 #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1295 def redosimi(self,evt) :
1296 with open(self.pathout['selected.csv'],'r') as f :
1298 selected = [int(val) for val in selected.splitlines()]
1299 #if self.actives is None :
1300 # with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1301 # self.actives = f.read()
1302 # self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1304 actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1306 actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1308 #self.tableau.make_listactives()
1309 actives = dict([[i, val] for i, val in enumerate(actives)])
1310 #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1311 self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1312 self.dial.CenterOnParent()
1313 self.val = self.dial.ShowModal()
1314 if self.val == wx.ID_OK :
1315 last = self.dial.listcol.GetFirstSelected()
1316 lastl = [self.dial.listcol.GetFirstSelected()]
1317 indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1318 while self.dial.listcol.GetNextSelected(last) != -1:
1319 last = self.dial.listcol.GetNextSelected(last)
1321 indexes.append(self.dial.listcol.getColumnText(last,0))
1322 self.column = [self.tableau.listactives.index(val) for val in indexes]
1324 with open(self.pathout['selected.csv'], 'w') as f :
1325 f.write('\n'.join([`val` for val in self.column]))
1328 self.script = PrintSimiScript(self)
1329 self.script.make_script()
1330 self.tmpfile = self.script.scriptout
1331 dlg = progressbar(self, maxi = 2)
1334 if self.parametres['type_graph'] == 1:
1335 if self.parametres['svg'] :
1336 filename, ext = os.path.splitext(self.script.filename)
1337 fileout = filename + '.svg'
1339 fileout = self.script.filename
1340 fileout = normpath_win32(fileout)
1341 if os.path.exists(self.pathout['liste_graph']):
1342 graph_simi = read_list_file(self.pathout['liste_graph'])
1343 graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1345 graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1346 print_liste(self.pathout['liste_graph'], graph_simi)
1347 DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1348 if self.parametres['type_graph'] == 1:
1349 if self.parametres['svg'] :
1350 self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1352 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)
1353 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1354 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1355 self.graphpan.Layout()
1356 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1361 def make_param(self) :
1362 if self.parametres['first'] :
1365 keep_coord = self.dial.check_coord.GetValue()
1366 #self.select = self.dial.check_colch.GetValue()
1368 paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1369 'layout' : self.dial.choice2.GetSelection(),
1370 'type_graph' : self.dial.choice3.GetSelection(),
1371 'arbremax' : self.dial.check1.GetValue(),
1372 'coeff_tv' : self.dial.check_s_size.GetValue(),
1373 'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1374 'tvprop' : self.dial.check2.GetValue(),
1375 'tvmin' : self.dial.spin_tvmin.GetValue(),
1376 'tvmax' : self.dial.spin_tvmax.GetValue(),
1377 'coeff_te' : self.dial.check3.GetValue(),
1378 'coeff_temin' : self.dial.spin_temin.GetValue(),
1379 'coeff_temax' : self.dial.spin_temax.GetValue(),
1380 'label_e' : self.dial.check_elab.GetValue(),
1381 'label_v' : self.dial.check_vlab.GetValue(),
1382 'vcex' : self.dial.check_vcex.GetValue(),
1383 'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1384 'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1385 'cex' : self.dial.spin_cex.GetValue(),
1386 'seuil_ok' : self.dial.check_seuil.GetValue(),
1387 'seuil' : self.dial.spin_seuil.GetValue(),
1388 'cols' : self.dial.cols.GetColour(),
1389 'cola' : self.dial.cola.GetColour(),
1390 'width' : self.dial.spin_width.GetValue(),
1391 'height' : self.dial.spin_height.GetValue(),
1393 'keep_coord' : keep_coord,
1394 'alpha' : self.dial.slider_sphere.GetValue(),
1395 'film' : self.dial.film.GetValue(),
1396 'svg' : self.dial.choix_format.GetSelection(),
1397 'halo' : self.dial.halo.GetValue(),
1398 'com' : self.dial.comcheck.GetValue(),
1399 'communities' : self.dial.choix_com.GetSelection(),
1400 'edgecurved' : self.dial.check_curved.GetValue(),
1402 if 'cexfromchi' in self.parametres :
1403 paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1404 if 'sfromchi' in self.parametres :
1405 paramsimi['sfromchi'] = self.dial.checki.GetValue()
1406 if 'vlabcolor' in self.parametres :
1407 paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1408 if 'check_bystar' in dir(self.dial) :
1409 paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1410 paramsimi['stars'] = self.parametres['stars']
1411 self.parametres.update(paramsimi)
1414 if self.parametres['type_graph'] == 1 :
1420 pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1421 if self.parametres['type_graph'] == 1 :
1422 while pid.poll() == None :
1425 check_Rresult(self.parent, pid)
1427 def export(self, evt) :
1429 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1431 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1437 graph <- graph.simi$graph
1438 V(graph)$x <- graph.simi$layout[,1]
1439 V(graph)$y <- graph.simi$layout[,2]
1440 if (length(graph.simi$label.cex == 1)) {
1441 V(graph)$weight <- graph.simi$mat.eff
1443 V(graph)$weight <- graph.simi$label.cex
1445 V(graph)$color <- vertex.label.color
1446 V(graph)$frequences <- graph.simi$mat.eff
1447 V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
1448 V(graph)$label <- as.character(graph.simi$v.label)
1449 E(graph)$weight <- graph.simi$we.width
1450 write.graph(graph, fileout, format = 'graphml')
1451 #saveAsGEXF(graph, filepath = fileout)
1452 """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1453 filetmp = tempfile.mktemp()
1454 with open(filetmp, 'w') as f :
1456 exec_rcode(self.ira.RPath, filetmp)
1457 mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
1458 mss.CenterOnParent()
1463 class GraphPanelSimi(wx.Panel):
1464 def __init__(self,parent, dico, list_graph):
1465 wx.Panel.__init__(self,parent)
1468 self.dirout = os.path.dirname(self.Dict['ira'])
1469 self.parent = self.GetParent()#parent
1470 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "courier"))
1473 self.tabsimi = self.parent.GetParent()
1474 self.ira = self.tabsimi.GetParent()
1475 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1476 afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1477 self.butafc = wx.BitmapButton(self, -1, afc_img)
1478 export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1479 self.butexport = wx.BitmapButton(self, -1, export_img)
1480 for i in range(0,len(list_graph)):
1481 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1482 filename, ext = os.path.splitext(list_graph[i][0])
1483 if ext in ['.svg', '.html'] :
1484 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])))
1486 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1487 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1488 self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove)
1489 self.__set_properties()
1492 def __set_properties(self):
1493 self.panel_1.EnableScrolling(True,True)
1494 #self.panel_1.SetSize((1000,1000))
1495 self.panel_1.SetScrollRate(20, 20)
1496 self.panel_1.SetFocus()
1498 def __do_layout(self):
1499 self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1500 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1501 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1502 self.sizer_2.Add(self.butafc, 0, 0, 0)
1503 self.sizer_2.Add(self.butexport, 0, 0, 0)
1504 for i in range(0, len(self.listimg)):
1505 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1506 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1507 self.panel_1.SetSizer(self.sizer_3)
1508 self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1509 self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1510 self.SetSizer(self.sizer_1)
1512 def onMouseMove(self, event):
1513 self.panel_1.SetFocus()