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 from chemins import ConstructPathOut, ChdTxtPathOut, FFF, ffr, PathOut, StatTxtPathOut, simipath
12 from ConfigParser import ConfigParser
13 from functions import ReadProfileAsDico, GetTxtProfile, read_list_file, ReadList, exec_rcode, print_liste, BugReport, DoConf, indices_simi, check_Rresult, progressbar
14 from ProfList import ProfListctrlPanel
15 from guiparam3d import param3d, simi3d
16 from PrintRScript import write_afc_graph, print_simi3d, PrintSimiScript
17 from profile_segment import ProfileSegment
18 from functions import ReadList
21 from search_tools import SearchFrame
22 from dialog import PrefGraph, PrefExport, PrefSimpleFile, PrefDendro, SimpleDialog
23 from guifunct import SelectColumn, PrepSimi, PrefSimi
24 from webexport import WebExport
25 from corpus import Corpus
29 from time import sleep
34 log = logging.getLogger('iramuteq.layout')
37 class GraphPanelAfc(wx.Panel):
38 def __init__(self, parent, dico, list_graph, clnb, itempath = 'liste_graph_afc', coding = sys.getdefaultencoding()):
39 wx.Panel.__init__(self,parent)
44 self.itempath = itempath
45 self.parent = self.GetParent()#parent
46 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
50 self.list_graph = list_graph
51 self.TabCHD = self.parent.GetParent()
52 self.nb = self.TabCHD.GetParent()
53 self.ira = self.nb.GetParent()
54 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
55 afc_img = wx.Image(os.path.join(self.ira.images_path,'button_afc.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
56 self.butafc = wx.BitmapButton(self, -1, afc_img)
57 self.Bind(wx.EVT_BUTTON, self.afc_graph, self.butafc)
58 self.dirout = os.path.dirname(self.Dict['ira'])
61 for i in range(0,len(list_graph)):
62 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
63 filename, ext = os.path.splitext(list_graph[i][0])
64 if ext == '.svg' or ext == '.html':
65 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])))
67 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
68 if os.path.exists(os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')) :
69 txt = _(u"List of not plotted points : ").decode('utf8') + '%s' % os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')
72 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1] + txt))
73 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = `i - b`))
77 self.list_graph = [graph for i, graph in enumerate(self.list_graph) if i not in todel]
79 self.param = { 'typegraph' : 0,
86 'do_select_chi_classe' : 0,
104 self.__set_properties()
107 def __set_properties(self):
108 self.panel_1.EnableScrolling(True,True)
109 #self.panel_1.SetSize((1000,1000))
110 self.panel_1.SetScrollRate(20, 20)
111 self.panel_1.SetFocus()
113 def __do_layout(self):
114 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
115 self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
116 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
117 self.sizer_2.Add(self.butafc, 0, 0, 0)
118 for i in range(0, len(self.listimg)):
119 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
120 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
121 self.sizer_3.Add(self.buts[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
122 self.Bind(wx.EVT_BUTTON, self.on_delete_image, self.buts[i])
123 self.panel_1.SetSizer(self.sizer_3)
124 self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
125 self.SetSizer(self.sizer_2)
127 def on_delete_image(self, event) :
128 image_id = int(event.GetEventObject().GetName())
129 image_path = self.list_graph[image_id][0]
130 message = _(u'This file will be delete : ') + '%s.\n' % os.path.join(self.dirout, image_path) + _('Are you sure ?')
131 dial = wx.MessageDialog(self, message, style = wx.YES_NO)
132 res = dial.ShowModal()
133 if res == wx.ID_YES :
135 log.info('delete image %i' % image_id)
136 oldimg = self.listimg.pop(image_id)
138 oldlab = self.labels.pop(image_id)
140 oldbut = self.buts.pop(image_id)
142 for i, but in enumerate(self.buts) :
144 todel = self.list_graph.pop(image_id)
145 os.remove(os.path.join(self.dirout, todel[0]))
146 print_liste(self.Dict[self.itempath], self.list_graph)
147 self.sizer_3.Fit(self.panel_1)
153 def afc_graph(self,event):
154 #dirout = os.path.dirname(self.Dict['ira'])
155 dial = PrefGraph(self.parent,-1,self.param,'')
156 dial.CenterOnParent()
157 val = dial.ShowModal()
159 if dial.choix_format.GetSelection() == 0 :
163 typegraph = dial.choicetype.GetSelection()
165 if self.clnb <= 3 and typegraph == 1 :
169 while os.path.exists(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile)):
171 self.fileout = ffr(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile))
173 self.param = {'typegraph' : typegraph,
174 'width' : dial.spin1.GetValue(),
175 'height' : dial.spin2.GetValue(),
176 'what' : dial.choice1.GetSelection(),
177 'qui' : dial.choice2.GetSelection(),
178 'do_select_nb' : dial.check1.GetValue(),
179 'do_select_chi' : dial.check2.GetValue(),
180 'do_select_chi_classe' : dial.check_chic.GetValue(),
181 'select_nb' : dial.spin_nb.GetValue(),
182 'select_chi' : dial.spin_chi.GetValue(),
183 'nbchic' : dial.spin_nbchic.GetValue(),
184 'over' : dial.check3.GetValue(),
185 'cex_txt' : dial.check4.GetValue(),
186 'txt_min' : dial.spin_min.GetValue(),
187 'txt_max' : dial.spin_max.GetValue(),
188 'tchi' : dial.check_tchi.GetValue(),
189 'tchi_min' : dial.spin_min_tchi.GetValue(),
190 'tchi_max' : dial.spin_max_tchi.GetValue(),
191 'taillecar' : dial.spin3.GetValue(),
192 'facteur' : [dial.spin_f1.GetValue(),dial.spin_f2.GetValue(), dial.spin_f3.GetValue()],
194 'film' : str(dial.film.GetValue()).upper(),
195 'alpha' : dial.slider_sphere.GetValue(),
198 self.nb.parent = self.ira
199 self.DictPathOut = self.Dict
200 self.RscriptsPath = self.ira.RscriptsPath
203 """ % self.DictPathOut['RData']
204 if self.itempath == 'liste_graph_afcf' :
207 afc_table <- afcf_table
208 chistabletot <- specfp
210 elif self.itempath == 'liste_graph_afct' :
213 afc_table <- afct_table
214 chistabletot <- spectp
216 txt += write_afc_graph(self)
217 filetmp = tempfile.mktemp()
218 with open(filetmp, 'w') as f :
220 pid = exec_rcode(self.ira.RPath, filetmp)
221 check_Rresult(self.ira, pid)
222 if self.param['typegraph'] in [0,2] :
224 if self.param['qui'] == 0 : value = u'actives'
225 if self.param['qui'] == 1 : value = u'supplémentaires'
226 if self.param['qui'] == 2 : value = u'étoilées'
227 if self.param['qui'] == 3 : value = u'classes'
229 if self.param['what'] == 0 : value = u'Coordonnées'
230 if self.param['what'] == 1 : value = u'Corrélations'
231 txt += value + u' - facteur %i / %i' % (self.param['facteur'][0], self.param['facteur'][1])
232 if self.param['do_select_nb'] : txt += u' - sélection de %i variables' % self.param['select_nb']
233 if self.param['do_select_chi'] : txt += u' - sélection des variables avec chi2 > %i ' % self.param['select_chi']
234 if self.param['over'] : txt += u' - Eviter les recouvrements'
235 if self.param['cex_txt'] : txt += u' - taille du texte proportionnel à la masse'
236 if self.param['tchi'] : txt += u' - taille du texte proportionnel au chi2 d\'association'
237 #list_graph = read_list_file(self.DictPathOut[self.itempath], self.coding)
238 if self.param['svg'] :
239 filename, ext = os.path.splitext(self.fileout)
240 self.fileout = filename + '.svg'
241 if self.param['typegraph'] == 2 :
242 parametres = {'gexffile' : self.fileout,
244 'nodemin': self.param['txt_min'],
245 'nodemax': self.param['txt_max'],
246 'bargraphw' : 60*int(self.param['clnb']),
248 web = WebExport(self.ira, parametres)
249 self.fileout = web.exportafc()
250 self.list_graph.append([os.path.basename(self.fileout), txt])
251 print_liste(self.DictPathOut[self.itempath], self.list_graph)
252 if self.param['svg'] or self.param['typegraph'] == 2:
253 self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, self.fileout, URL=self.fileout))
256 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(self.fileout, wx.BITMAP_TYPE_ANY)))
257 self.sizer_3.Add( self.listimg[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
258 self.labels.append(wx.StaticText(self.panel_1,-1, txt))
259 self.sizer_3.Add(self.labels[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
260 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = `len(self.list_graph) - 1`))
261 self.sizer_3.Add(self.buts[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
262 self.sizer_3.Fit(self.panel_1)
265 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
266 # elif self.param['typegraph'] == 2 :
267 # parametres = {'gexffile' : self.fileout,
268 # 'titre': 'Le titre',
269 # 'nodemin': self.param['txt_min'],
270 # 'nodemax': self.param['txt_max'],
271 # 'bargraphw' : 60*int(self.param['clnb']),
273 # web = WebExport(self.ira, parametres)
274 # afcout = web.exportafc()
275 # dial = SimpleDialog(self.ira)
276 # dial.link.SetLabel(afcout)
277 # dial.link.SetURL(afcout)
282 class GraphPanel(wx.ScrolledWindow):
283 def __init__(self, parent, dico, list_graph, txt = '', style = wx.TAB_TRAVERSAL):
284 wx.ScrolledWindow.__init__(self, parent, style = style)
288 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
291 self.dirout = os.path.dirname(self.Dict['ira'])
292 self.deb = wx.StaticText(self, -1, txt)
293 for i in range(0,len(list_graph)):
294 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
295 filename, ext = os.path.splitext(list_graph[i][0])
297 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])))
299 self.listimg.append(wx.StaticBitmap(self, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
300 self.labels.append(wx.StaticText(self, -1, list_graph[i][1]))
301 self.Bind(wx.EVT_MOTION, self.onMouseMove)
302 self.__set_properties()
305 def __set_properties(self):
306 self.EnableScrolling(True,True)
307 self.SetScrollRate(20, 20)
311 def __do_layout(self):
312 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
313 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
314 self.sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
315 self.sizer_1.Add(self.deb)
316 for i in range(0, len(self.listimg)):
317 self.sizer_1.Add(self.listimg[i], 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
318 self.sizer_1.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
319 self.sizer_2.Add(self.sizer_1, 1, wx.EXPAND, 0)
320 self.SetSizer(self.sizer_1)
321 self.sizer_1.Fit(self)
323 def onMouseMove(self, event):
327 def open_antiprofil(panel, AntiProfile, encoding) :
328 DictAnti = ReadProfileAsDico(AntiProfile, True, encoding)
329 panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
330 for i in range(0, panel.parametres['clnb']):
331 tabantiprofile = ProfListctrlPanel(panel, panel, DictAnti[str(i + 1)], True, i + 1)
332 panel.AntiProfNB.AddPage(tabantiprofile, 'classe %s' % str(i + 1))
333 panel.TabChdSim.AddPage(panel.AntiProfNB, _(u"Antiprofiles").decode('utf8'))
337 def getlemgram(corpus, lem) :
338 if not lem[6] in corpus.lems :
341 return corpus.lems[lem[6]].gram
344 def __init__(self, parent, corpus, parametres, Alceste=False):
349 self.parametres = parametres
350 self.pathout = PathOut(parametres['ira'])
351 self.pathout.basefiles(ChdTxtPathOut)
352 DictPathOut = self.pathout
353 self.DictPathOut = DictPathOut
354 self.dictpathout = DictPathOut
357 Profile = DictPathOut['PROFILE_OUT']
358 AntiProfile = DictPathOut['ANTIPRO_OUT']
359 self.encoding = self.parametres['encoding']
360 if isinstance(self.corpus, Corpus) :
361 self.corpus.make_ucecl_from_R(self.pathout['uce'])
362 corpname = self.corpus.parametres['corpus_name']
364 corpname = self.corpus.parametres['name']
366 clnb = parametres['clnb']
367 dlg = progressbar(self, maxi = 4 + clnb)
369 print 'lecture des profils'
370 dlg.Update(2, _(u"Reading profiles").decode('utf8'))
372 DictProfile = ReadProfileAsDico(Profile, Alceste, self.encoding)
373 self.DictProfile = DictProfile
374 self.cluster_size = []
375 #print 'lecture des antiprofils'
376 #DictAnti = ReadProfileAsDico(self, AntiProfile, Alceste, self.encoding)
378 panel = wx.Panel(parent, -1)
379 sizer1 = wx.BoxSizer(wx.VERTICAL)
381 if os.path.exists(DictPathOut['pre_rapport']):
382 with codecs.open(DictPathOut['pre_rapport'], 'r', self.encoding) as f :
387 # panel.chd_toolbar = wx.ToolBar(panel, -1, wx.DefaultPosition, wx.DefaultSize, wx.TB_FLAT | wx.TB_NODIVIDER)
388 # panel.chd_toolbar.SetToolBitmapSize(wx.Size(16, 16))
390 if isinstance(self.corpus, Corpus) :
391 panel.corpus = self.corpus
393 panel.tableau = self.corpus
394 #self.parent.tableau = panel.tableau
395 panel.dictpathout = self.DictPathOut
396 panel.pathout = self.DictPathOut
397 panel.parent = self.parent
398 panel.DictProfile = self.DictProfile
399 panel.cluster_size = self.cluster_size
400 panel.debtext = self.debtext
402 # self.ID_rapport = wx.NewId()
403 # #rap_img = wx.Image(os.path.join(self.parent.images_path,'icone_rap_16.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
404 # #panel.chd_toolbar.AddLabelTool(self.ID_rapport, "rapport", rap_img, shortHelp=u"Produire le rapport", longHelp=u"Exporter un rapport en texte simple")
405 # butrap = wx.Button(panel.chd_toolbar, self.ID_rapport, u"Rapport ")
406 # panel.chd_toolbar.AddControl(butrap)
408 # panel.chd_toolbar.Realize()
409 # sizer1.Add(panel.chd_toolbar,0, wx.EXPAND, 5)
411 #self.TabChdSim = wx.aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
412 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
413 panel.TabChdSim = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
414 panel.TabChdSim.SetAGWWindowStyleFlag(notebook_flags)
415 panel.TabChdSim.SetArtProvider(aui.ChromeTabArt())
416 sizer1.Add(panel.TabChdSim,10, wx.EXPAND, 5)
417 panel.SetSizer(sizer1)
421 if isinstance(self.corpus, Corpus) :
422 panel.TabChdSim.corpus = corpus
423 panel.TabChdSim.corpus.dictpathout = self.DictPathOut
425 panel.TabChdSim.tableau = corpus
426 panel.TabChdSim.tableau.dictpathout = self.DictPathOut
427 panel.parametres = self.parametres
430 self.notenb = self.parent.nb.GetPageCount()
433 if os.path.exists(self.DictPathOut['liste_graph_chd']) :
434 list_graph = read_list_file(self.DictPathOut['liste_graph_chd'], self.encoding)
435 CHD = GraphPanelDendro(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
436 panel.TabChdSim.AddPage(CHD,'CHD')
438 panel.ProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
439 panel.ProfNB.SetArtProvider(aui.ChromeTabArt())
440 #self.ProfNB.SetTabCtrlHeight(100)
441 #panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
442 if os.path.exists(DictPathOut['prof_seg']) :
443 prof_seg = ReadProfileAsDico(DictPathOut['prof_seg'], False, self.encoding)
444 self.prof_seg_nb = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
445 for i in range(0, clnb):
446 self.cluster_size.append(DictProfile[str(i + 1)][0][0:3])
447 if isinstance(self.corpus, Corpus) :
448 DictProfile[str(i + 1)][1:] = [val[0:5] + [getlemgram(self.corpus, val)] + val[6:] for val in DictProfile[str(i + 1)][1:]]
449 dlg.Update(3+i, 'Classe %i' %(i+1))
450 ind = '/'.join(DictProfile[str(i + 1)][0][0:2])
451 indpour = ' - '.join([ind, DictProfile[str(i + 1)][0][2]])
452 self.tabprofile = ProfListctrlPanel(self.parent, self.panel, DictProfile[str(i + 1)], Alceste, i + 1)
453 #self.tabantiprofile = ProfListctrlPanel(self.parent, self, DictAnti[str(i + 1)], Alceste, i + 1)
454 panel.ProfNB.AddPage(self.tabprofile, _(u"Cluster").decode('utf8') + ' %s %s(%s%%)' % (str(i + 1), sep, indpour))
455 #panel.AntiProfNB.AddPage(self.tabantiprofile, 'classe %s' % str(i + 1))
456 if os.path.exists(DictPathOut['prof_seg']) :
457 self.tab_prof_seg = ProfListctrlPanel(self.parent, self, prof_seg[str(i + 1)], False, i + 1)
458 self.prof_seg_nb.AddPage(self.tab_prof_seg, _(u"Cluster").decode('utf8') + ' %i' % (i + 1))
461 self.TabAFC = aui.AuiNotebook(panel.TabChdSim, -1, wx.DefaultPosition)
463 list_graph=read_list_file(DictPathOut['liste_graph_afc'], self.encoding)
464 self.tabAFCGraph = GraphPanelAfc(self.TabAFC, DictPathOut, list_graph, self.clnb, coding=self.encoding)
465 self.TabAFC.AddPage(self.tabAFCGraph, _(u"CA").decode('utf8'))
467 if os.path.exists(self.DictPathOut['afc_facteur']) :
468 dictrow, first = ReadList(self.DictPathOut['afc_facteur'], self.encoding)
469 self.TabAFC_facteur = ListForSpec(self.parent, parametres, dictrow, first)
470 #dictrow, first = ReadList(self.DictPathOut['afc_row'], self.encoding)
471 #self.TabAFC_ligne = ListForSpec(self.parent, self.parametres, dictrow, first)
472 #dictrow, first = ReadList(self.DictPathOut['afc_col'], self.encoding)
473 #self.TabAFC_colonne = ListForSpec(parent, self.parametres, dictrow, first)
474 self.TabAFC.AddPage(self.TabAFC_facteur, _(u"Factor").decode('utf8'))
475 #self.TabAFC.AddPage(self.TabAFC_colonne, u'Colonnes')
476 #self.TabAFC.AddPage(self.TabAFC_ligne, u'Lignes')
478 sizer_3 = wx.BoxSizer(wx.VERTICAL)
479 self.parent.nb_panel_2 = wx.Panel(panel.TabChdSim, -1)
480 self.parent.button_simi = wx.Button(self.parent.nb_panel_2, -1, "Voyager")
481 self.parent.simi3dpanel = simi3d(self.parent.nb_panel_2, -1)
482 sizer_3.Add(self.parent.simi3dpanel, 1, wx.EXPAND, 0)
483 sizer_3.Add(self.parent.button_simi, 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
484 self.parent.nb_panel_2.SetSizer(sizer_3)
485 self.TabAFC.AddPage(self.parent.nb_panel_2, _(u"3D graph").decode('utf8'))
486 self.parent.Bind(wx.EVT_BUTTON, self.onsimi, self.parent.button_simi)
488 panel.TabChdSim.AddPage(panel.ProfNB, _(u"Profiles").decode('utf8'))
489 #panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')
490 dlg.Update(4 + self.clnb, 'Affichage...')
492 panel.TabChdSim.AddPage(self.TabAFC, _(u"CA").decode('utf8'))
493 if os.path.exists(DictPathOut['prof_seg']) :
494 panel.TabChdSim.AddPage(self.prof_seg_nb, _(u"Repeated segments profiles").decode('utf8'))
496 # panel.Bind(wx.EVT_BUTTON, self.ongetrapport, id = self.ID_rapport)
497 self.parent.nb.AddPage(panel, _(u"Clustering").decode('utf8') + ' - %s' % corpname)
498 self.parent.ShowTab(True)
499 self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
500 #for pane in self.parent._mgr.GetAllPanes() :
501 # if isinstance(pane.window, aui.AuiNotebook):
503 # nb.SetAGWWindowStyleFlag(notebook_flags)
504 # nb.SetArtProvider(aui.ChromeTabArt())
506 self.parent._mgr.Update()
508 def onsimi(self,event):
509 outfile = print_simi3d(self)
510 error = exec_rcode(self.parent.RPath, outfile, wait = True)
512 def onclusterstat(self, evt) :
513 dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': 'Stat par classe'})
514 dial.fbb.SetValue( os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'stat_par_classe.csv'))
515 dial.CenterOnParent()
516 res = dial.ShowModal()
518 fileout = dial.fbb.GetValue()
520 self.corpus.get_stat_by_cluster(fileout)
522 dlg = wx.MessageDialog(self.parent, msg, _(u"Stat by cluster").decode('utf8'), wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
524 if dlg.ShowModal() == wx.ID_OK :
527 #def onsearchf(self, evt) :
528 # if 'FrameSearch' not in dir(self.panel) :
529 # self.panel.FrameSearch = SearchFrame(self.parent, -1, u"Rechercher...", self.corpus)
530 # self.panel.FrameSearch.Show()
532 def PrintRapport(self, corpus, parametres, istxt = True):
536 |i|R|a|M|u|T|e|Q| - %s
540 """ % datetime.datetime.now().ctime()
542 totocc = corpus.gettotocc()
543 txt += u'nombre de textes: %i%s' % (corpus.getucinb(), sep)
544 txt += u'nombre de segments de textes: %i%s' % (corpus.getucenb(), sep)
545 txt += u'nombre de formes: %i%s' % (len(corpus.formes), sep)
546 txt += u'nombre d\'occurrences: %i%s' % (totocc, sep)
547 txt += u'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
548 txt += u'nombre de lemmes: %i%s' % (len(corpus.lems), sep)
549 txt += u'nombre de formes actives: %i%s' % (corpus.getactivesnb(1), sep)
550 txt += u'nombre de formes supplémentaires: %i%s' % (corpus.getactivesnb(2), sep)
551 txt += u'nombre de formes actives de fréquence >= %i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)
552 txt += u'moyenne d\'occurrences par segments :%f%s' % (float(totocc) / float(corpus.getucenb()), sep)
553 if 'tailleuc1' in parametres :
554 if parametres['classif_mode'] == 0 :
555 txt += u'taille rst1 / rst2: %i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)
557 self.Ucenb = self.nbind
558 txt += u'nombre d\'individus : %i%s' % (self.nbind, sep)
559 txt += u'nombre de classes : %i%s' % (self.clnb, sep)
561 txt += u'nombre de classes : %i%s' % (parametres['clnb'], sep)
562 if parametres['classif_mode'] == 0 or parametres['classif_mode'] == 1 :
563 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)
564 elif self.parametres['classif_mode'] == 2 :
565 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)
567 txt += u'%i segments classées sur %i (%.2f%%)%s' % (self.ucecla, self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)
570 ###########################
572 ###########################
573 """ % parametres.get('time', '')
574 with open(self.pathout['pre_rapport'], 'w') as f :
578 class SashList(wx.Panel) :
579 def __init__(self, parent) :
580 wx.Panel.__init__(self, parent, -1)
583 #self.gparent=gparent
587 # A window to the left of the client window
588 #self.listlex = listlex
589 self.leftwin1 = wx.SashLayoutWindow(
590 self, -1, wx.DefaultPosition, (200, 300),
591 wx.NO_BORDER|wx.SW_3D
594 self.leftwin1.SetDefaultSize((120, 1000))
595 self.leftwin1.SetOrientation(wx.LAYOUT_VERTICAL)
596 self.leftwin1.SetAlignment(wx.LAYOUT_LEFT)
597 self.leftwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
598 self.leftwin1.SetSashVisible(wx.SASH_RIGHT, True)
599 self.leftwin1.SetExtraBorderSize(10)
601 #textWindow = wx.TextCtrl(
602 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
603 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
606 #textWindow.SetValue("A sub window")
608 self.leftWindow1 = self.leftwin1
609 winids.append(self.leftwin1.GetId())
611 rightwin1 = wx.SashLayoutWindow(
612 self, -1, wx.DefaultPosition, (200, 300),
613 wx.NO_BORDER|wx.SW_3D
616 rightwin1.SetDefaultSize((120, 1000))
617 rightwin1.SetOrientation(wx.LAYOUT_VERTICAL)
618 rightwin1.SetAlignment(wx.LAYOUT_LEFT)
619 rightwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
620 rightwin1.SetSashVisible(wx.SASH_RIGHT, True)
621 rightwin1.SetExtraBorderSize(10)
622 #textWindow = wx.TextCtrl(
623 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
624 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
627 #textWindow.SetValue("A sub window")
629 self.rightwin1 = rightwin1
630 winids.append(rightwin1.GetId())
635 def __init__(self, ira, corpus, parametres):
636 self.pathout = PathOut(dirout = parametres['pathout'])
638 self.dictpathout = StatTxtPathOut(parametres['pathout'])
639 #self.corpus.read_corpus_from_shelves(self.corpus.dictpathout['db'])
641 self.encoding = self.corpus.parametres['syscoding']
642 self.parametres = parametres
644 self.DictSpec, first = ReadList(self.dictpathout['tablespecf'], self.corpus.parametres['syscoding'])
645 if os.path.exists(self.pathout['banalites.csv']) :
646 self.dictban, firstban = ReadList(self.pathout['banalites.csv'], self.corpus.parametres['syscoding'])
647 self.DictType, firstt = ReadList(self.dictpathout['tablespect'], self.corpus.parametres['syscoding'])
648 self.DictEff, firsteff = ReadList(self.dictpathout['tableafcm'], self.corpus.parametres['syscoding'])
649 self.DictEffType, firstefft = ReadList(self.dictpathout['tabletypem'], self.corpus.parametres['syscoding'])
650 self.DictEffRelForme, firsteffrelf = ReadList(self.dictpathout['eff_relatif_forme'], self.corpus.parametres['syscoding'])
651 self.DictEffRelType, firsteffrelt = ReadList(self.dictpathout['eff_relatif_type'], self.corpus.parametres['syscoding'])
653 #sash = SashList(ira.nb)
656 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
657 self.TabStat.parametres = parametres
658 self.ListPan = ListForSpec(ira, self, self.DictSpec, first)
659 if os.path.exists(self.pathout['banalites.csv']) :
660 self.listban = ListForSpec(ira, self, self.dictban, firstban)
661 #self.ListPan2 = ListForSpec(sash.rightwin1, self, self.DictSpec, first)
662 self.ListPant = ListForSpec(ira, self, self.DictType, firstt)
663 self.ListPanEff = ListForSpec(ira, self, self.DictEff, firsteff)
664 self.ListPanEffType = ListForSpec(ira, self, self.DictEffType, firstefft)
665 self.ListPanEffRelForme = ListForSpec(ira, self, self.DictEffRelForme, firsteffrelf)
666 self.ListPanEffRelType = ListForSpec(ira, self.parent, self.DictEffRelType, firsteffrelt)
668 self.TabStat.AddPage(self.ListPan, u'formes')
669 if os.path.exists(self.pathout['banalites.csv']) :
670 self.TabStat.AddPage(self.listban, u'banalités')
671 self.TabStat.AddPage(self.ListPant, u'Types')
672 self.TabStat.AddPage(self.ListPanEff, u'Effectifs formes')
673 self.TabStat.AddPage(self.ListPanEffType, u'Effectifs Type')
674 self.TabStat.AddPage(self.ListPanEffRelForme, u'Effectifs relatifs formes')
675 self.TabStat.AddPage(self.ListPanEffRelType, u'Effectifs relatifs Type')
676 if self.parametres['clnb'] > 2 :
677 self.TabAFC = aui.AuiNotebook(self.TabStat, -1, wx.DefaultPosition)
678 list_graph=read_list_file(self.dictpathout['liste_graph_afcf'], encoding = self.encoding)
679 self.tabAFCGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afcf', coding = self.encoding)
680 self.TabAFC.AddPage(self.tabAFCGraph, 'AFC formes')
681 list_graph=read_list_file(self.dictpathout['liste_graph_afct'], encoding = self.encoding)
682 self.tabAFCTGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afct', coding=self.encoding)
683 self.TabAFC.AddPage(self.tabAFCTGraph, 'AFC type')
684 self.TabStat.AddPage(self.TabAFC, 'AFC')
687 ira.nb.AddPage(self.TabStat, u'Spécificités')
689 self.TabStat.corpus = self.corpus
690 ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
691 ira.ShowAPane("Tab_content")
694 def __init__(self, ira, corpus, parametres):
695 self.pathout = PathOut(dirout = parametres['pathout'])
699 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
700 self.TabStat.parametres = parametres
701 self.TabStat.corpus = corpus
702 self.TabStat.pathout = self.pathout
703 # CHD = GraphPanel(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
704 # panel.TabChdSim.AddPage(CHD,'CHD')
706 #self.TabStatTot = wx.TextCtrl(self.TabStat, -1, style=wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2)
707 list_graph = [['zipf.png', 'zipf']]
708 self.TabStatTot = GraphPanel(ira.nb, self.pathout, list_graph, self.result['glob'])
709 self.TabStat.AddPage(self.TabStatTot, 'global')
710 for item in self.result:
712 datam = [['forme', 'nb']]
713 self.ListPan = ListPanel(ira, self, self.result[item])
714 self.TabStat.AddPage(self.ListPan, ' '.join(item.split('_')))
715 ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
716 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
717 ira.ShowAPane("Tab_content")
719 def read_result(self) :
720 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'}
723 with open(self.pathout[lcle[key]], 'r') as f :
724 self.result[key] = [line.split(';') for line in f.read().splitlines()]
725 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
726 with open(self.pathout['glob.txt'], 'r') as f :
727 self.result['glob'] = f.read()
729 class GraphPanelDendro(wx.Panel):
730 def __init__(self,parent, dico, list_graph, txt=False):
731 wx.Panel.__init__(self,parent)
733 self.dictpathout = dico
734 self.dirout = os.path.dirname(self.dictpathout['ira'])
735 self.list_graph = list_graph
736 self.parent = self.GetParent()#parent
737 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
740 self.tabchd = self.parent.GetParent()
741 self.ira = self.tabchd.GetParent()
742 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
743 self.panel_1.SetBackgroundColour('white')
744 self.deb = wx.StaticText(self.panel_1, -1, txt)
745 dendro_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
746 self.butdendro = wx.BitmapButton(self, -1, dendro_img)
747 self.butdendrotexte = wx.BitmapButton(self, -1, dendro_img)
748 self.butdendrocloud = wx.BitmapButton(self, -1, dendro_img)
750 for i in range(0,len(list_graph)):
751 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
752 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
753 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
755 self.__set_properties()
758 def __set_properties(self):
759 self.panel_1.EnableScrolling(True,True)
760 #self.panel_1.SetSize((1000,1000))
761 self.panel_1.SetScrollRate(20, 20)
762 self.panel_1.SetFocus()
763 self.Bind(wx.EVT_BUTTON, self.ondendro, self.butdendro)
764 self.Bind(wx.EVT_BUTTON, self.ondendrotexte, self.butdendrotexte)
765 self.Bind(wx.EVT_BUTTON, self.ondendrocloud, self.butdendrocloud)
766 self.param = {'width' : 700,
770 'taille_classe' : True,
773 self.type_dendro = [ u"phylogram", u"cladogram", u"fan", u"unrooted", u"radial" ]
775 def __do_layout(self):
776 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
777 self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
778 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
779 self.sizer_3.Add(self.deb)
780 self.sizer_1.Add(self.butdendro, 0, 0, 0)
781 self.sizer_1.Add(self.butdendrotexte, 0, 0, 0)
782 self.sizer_1.Add(self.butdendrocloud, 0, 0, 0)
784 for i in range(0, len(self.listimg)):
785 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
786 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
787 self.panel_1.SetSizer(self.sizer_3)
788 self.sizer_2.Add(self.sizer_1, 0, wx.EXPAND, 0)
789 self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
790 self.SetSizer(self.sizer_2)
792 def make_param(self, dial):
793 self.param['width'] = dial.m_spinCtrl2.GetValue()
794 self.param['height'] = dial.m_spinCtrl1.GetValue()
795 self.param['type_dendro'] = dial.m_choice1.GetSelection()
796 self.param['color_nb'] = dial.m_radioBox1.GetSelection()
797 self.param['taille_classe'] = dial.m_checkBox1.GetValue()
798 self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
800 def make_dendro(self, dendro = 'simple') :
801 while os.path.exists(os.path.join(self.dirout, 'dendrogamme_' + str(self.graphnb)+'.png')) :
803 fileout = ffr(os.path.join(self.dirout,'dendrogamme_' + str(self.graphnb)+'.png'))
804 width = self.param['width']
805 height = self.param['height']
806 type_dendro = self.type_dendro[self.param['type_dendro']]
807 if self.param['taille_classe'] :
811 if self.param['color_nb'] == 0 :
815 if self.param['type_tclasse'] == 0 :
819 dendro_path = self.dictpathout['Rdendro']
820 classe_path = self.dictpathout['uce']
825 classes <- read.csv2("%s", row.names=1)
826 classes <- classes[,1]
827 """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']), ffr(classe_path))
828 if dendro == 'simple' :
830 open_file_graph("%s", width=%i, height=%i)
831 plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
832 """ % (ffr(fileout), width, height, type_dendro, histo, bw, tclasse)
833 elif dendro == 'texte' :
837 chistable <- chistabletot[1:(debsup-1),]
838 open_file_graph("%s", width=%i, height=%i)
839 plot.dendro.prof(tree.cut1$tree.cl, classes, chistable, nbbycl = 60, type.dendro="%s", bw=%s, lab=NULL)
840 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, type_dendro, bw)
841 elif dendro == 'cloud' :
845 chistable <- chistabletot[1:(debsup-1),]
846 open_file_graph("%s", width=%i, height=%i)
847 plot.dendro.cloud(tree.cut1$tree.cl, classes, chistable, nbbycl = 300, type.dendro="%s", bw=%s, lab=NULL)
848 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, type_dendro, bw)
851 tmpfile = tempfile.mktemp()
852 with open(tmpfile, 'w') as f :
854 error = exec_rcode(self.ira.RPath, tmpfile, wait=True)
855 check_Rresult(self.ira, error)
856 self.list_graph.append([fileout, 'Dendrogramme CHD1 - %s' % type_dendro])
857 print_liste(self.dictpathout['liste_graph_chd'], self.list_graph)
858 self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
859 self.sizer_3.Add(wx.StaticText(self.panel_1,-1, 'Dendrogramme CHD1 - %s' % type_dendro), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
860 self.sizer_3.Fit(self.panel_1)
862 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
865 def ondendro(self, evt):
866 dial = PrefDendro(self.ira, self.param)
867 val = dial.ShowModal()
869 self.make_param(dial)
872 def ondendrotexte(self, evt):
873 dial = PrefDendro(self.ira, self.param)
874 val = dial.ShowModal()
876 self.make_param(dial)
877 self.make_dendro(dendro = 'texte')
879 def ondendrocloud(self, evt):
880 dial = PrefDendro(self.ira, self.param)
881 val = dial.ShowModal()
883 self.make_param(dial)
884 self.make_dendro(dendro = 'cloud')
887 def __init__(self, ira, parametres) :
888 #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)
889 self.panel = CopusPanel(ira, parametres)
890 ira.nb.AddPage(self.panel, 'Description %s' % parametres['corpus_name'])
891 #self.text.write(DoConf().totext(parametres))
892 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
893 ira.ShowAPane("Tab_content")
895 class CopusPanel(wx.Panel) :
896 def __init__(self, parent, parametres) :
897 wx.Panel.__init__ ( self, parent, id = wx.ID_ANY, pos = wx.DefaultPosition, size = wx.Size( 500,300 ), style = wx.TAB_TRAVERSAL )
898 self.parametres = parametres
899 fgSizer5 = wx.FlexGridSizer( 0, 2, 0, 0 )
900 fgSizer5.SetFlexibleDirection( wx.BOTH )
901 fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )
902 self.fgSizer5 = fgSizer5
904 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Description du corpus", wx.DefaultPosition, wx.DefaultSize, 0 )
906 self.m_staticText18.Wrap( -1 )
907 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
909 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
910 self.m_staticText19.Wrap( -1 )
911 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
913 self.m_staticText20 = wx.StaticText( self, wx.ID_ANY, u"Nom", wx.DefaultPosition, wx.DefaultSize, 0 )
914 self.m_staticText20.Wrap( -1 )
915 fgSizer5.Add( self.m_staticText20, 0, wx.ALL, 5 )
917 self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, parametres['corpus_name'], wx.DefaultPosition, wx.DefaultSize, 0 )
918 self.m_staticText21.Wrap( -1 )
919 fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )
921 description = {'lang' : u'langue',
922 'encoding' : u'encodage',
923 'ucinb' : u'Nombre de textes',
924 'ucenb' : u'Nombre de segments de texte',
925 'formesnb' : u'Nombre de formes',
926 'hapax' : u'Nombre d\'hapax'
929 keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']
931 self.addkeys(keys, description)
933 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Paramètres", wx.DefaultPosition, wx.DefaultSize, 0 )
934 self.m_staticText18.Wrap( -1 )
935 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
937 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
938 self.m_staticText19.Wrap( -1 )
939 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
941 keys = ['ucemethod', 'ucesize', 'keep_caract', 'expressions']
942 self.addkeys(keys, description)
944 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Statistiques", wx.DefaultPosition, wx.DefaultSize, 0 )
945 self.m_staticText18.Wrap( -1 )
946 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
948 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
949 self.m_staticText19.Wrap( -1 )
950 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
952 keys = ['ucinb', 'ucenb', 'occurrences', 'formesnb', 'hapax']
953 self.addkeys(keys, description)
955 self.SetSizer( fgSizer5 )
958 def addkeys(self, keys, description) :
960 option = self.parametres.get(key,u'non défini')
961 if isinstance(option, int) :
963 text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
965 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
967 text = wx.StaticText( self, wx.ID_ANY, option, wx.DefaultPosition, wx.DefaultSize, 0 )
969 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
971 class DefaultTextLayout :
972 def __init__(self, ira, corpus, parametres) :
973 self.pathout = PathOut(dirout = parametres['pathout'])
976 self.parametres = parametres
981 log.info('no layout yet')
983 class WordCloudLayout(DefaultTextLayout):
985 self.pathout.basefiles(simipath)
986 self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
987 if self.parametres['svg'] :
988 list_graph = [['nuage_1.svg', 'Nuage']]
990 list_graph = [['nuage_1.png', 'Nuage']]
991 self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, list_graph)
992 self.Tab.AddPage(self.TabStatTot, 'Nuage')
993 self.Tab.corpus = self.corpus
994 self.Tab.parametres = self.parametres
995 self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
996 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
997 self.ira.ShowAPane("Tab_content")
999 class SimiLayout(DefaultTextLayout) :
1000 def dolayout(self) :
1001 self.pathout.basefiles(simipath)
1003 self.indices = indices_simi
1004 if os.path.exists(self.pathout['liste_graph']) :
1005 list_graph = read_list_file(self.pathout['liste_graph'])
1007 list_graph = [['','']]
1008 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1009 self.tabsimi = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1010 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1011 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1012 self.tabsimi.corpus = self.corpus
1013 self.tabsimi.parametres = self.parametres
1014 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1015 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1016 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1017 self.tabsimi.AddPage(self.graphpan, 'Graph')
1018 self.ira.nb.AddPage(self.tabsimi, 'Analyse de graph')
1019 self.ira.ShowTab(True)
1020 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1022 def redosimi(self, evt) :
1023 with open(self.pathout['selected.csv'],'r') as f :
1025 selected = [int(val) for val in selected.splitlines()]
1026 if self.actives is None :
1027 with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1028 self.actives = f.read()
1029 self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1030 if os.path.exists(self.pathout['actives_nb.csv']) :
1031 with open(self.pathout['actives_nb.csv'], 'r') as f :
1033 act_nb = act_nb.splitlines()
1034 dictcol = dict([[i, [self.actives[i], int(act_nb[i])]] for i, val in enumerate(self.actives)])
1036 dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1037 #res = SelectColumn(self.ira, dictcol, self.actives, self.pathout['selected.csv'], selected = selected, dlg = True)
1039 prep = PrepSimi(self.ira, self, self.parametres,self.pathout['selected.csv'], self.actives, indices_simi, wordlist = dictcol, selected = selected)
1040 if prep.val == wx.ID_OK :
1041 self.parametres = prep.parametres
1043 script = PrintSimiScript(self)
1044 script.make_script()
1045 pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
1046 check_Rresult(self.ira, pid)
1047 if self.parametres['type_graph'] in [1,3] :
1048 if self.parametres['svg'] :
1049 filename, ext = os.path.splitext(script.filename)
1050 fileout = filename + '.svg'
1051 elif self.parametres['type_graph'] == 3 :
1052 fileout = script.filename
1053 parametres = {'gexffile' : fileout,
1054 'dirout' : os.path.dirname(fileout),
1055 'titre': 'Le titre',
1056 #'nodemin': self.param['txt_min'],
1057 #'nodemax': self.param['txt_max'],
1058 #'bargraphw' : 60*int(self.param['clnb']),
1060 web = WebExport(self.ira, parametres)
1061 fileout = web.exportsimi()
1063 fileout = script.filename
1064 if os.path.exists(self.pathout['liste_graph']):
1065 graph_simi = read_list_file(self.pathout['liste_graph'])
1066 graph_simi.append([os.path.basename(fileout), script.txtgraph])
1068 graph_simi = [[os.path.basename(fileout), script.txtgraph]]
1069 print_liste(self.pathout['liste_graph'], graph_simi)
1070 DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1071 if self.parametres['type_graph'] in [1,3] :
1072 if self.parametres['svg'] or self.parametres['type_graph'] == 3 :
1073 self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1075 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)
1076 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1077 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1078 self.graphpan.Layout()
1079 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1081 def export(self, evt) :
1083 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1085 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1091 graph <- graph.simi$graph
1092 V(graph)$x <- graph.simi$layout[,1]
1093 V(graph)$y <- graph.simi$layout[,2]
1094 if (length(graph.simi$label.cex == 1)) {
1095 V(graph)$weight <- graph.simi$eff
1097 V(graph)$weight <- graph.simi$label.cex
1099 V(graph)$color <- vertex.label.color
1100 V(graph)$frequences <- graph.simi$mat.eff
1101 V(graph)$label <- as.character(graph.simi$v.label)
1102 E(graph)$weight <- graph.simi$we.width
1103 write.graph(graph, fileout, format = 'graphml')
1104 #saveAsGEXF(graph, filepath = fileout)
1105 """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1106 filetmp = tempfile.mktemp()
1107 with open(filetmp, 'w') as f :
1109 exec_rcode(self.ira.RPath, filetmp)
1110 mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
1111 mss.CenterOnParent()
1115 class DefaultMatLayout :
1116 def __init__(self, parent, tableau, parametres) :
1117 self.pathout = PathOut(dirout = parametres['pathout'])
1119 self.parent = parent
1120 self.tableau = tableau
1121 self.parametres = parametres
1124 def dolayout(self) :
1127 class ProtoLayout(DefaultMatLayout) :
1128 def dolayout(self) :
1129 list_graph = [['proto.png', 'Analyse prototypique']]
1130 #self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1131 #if self.parametres['svg'] :
1132 # list_graph = [['nuage_1.svg', 'Nuage']]
1134 # list_graph = [['nuage_1.png', 'Nuage']]
1135 self.TabProto = GraphPanel(self.ira.nb, self.pathout, list_graph)
1136 #self.Tab.AddPage(self.TabProto, 'Analyse Prototypique')
1137 #self.Tab.corpus = self.corpus
1138 self.TabProto.parametres = self.parametres
1139 self.ira.nb.AddPage(self.TabProto, 'Analyse Prototypique - %s' % self.parametres['name'])
1140 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1141 self.ira.ShowAPane("Tab_content")
1144 class SimiMatLayout(DefaultMatLayout) :
1146 self.pathout.basefiles(simipath)
1147 self.indices = indices_simi
1148 if os.path.exists(self.pathout['liste_graph']) :
1149 list_graph = read_list_file(self.pathout['liste_graph'])
1151 list_graph = [['','']]
1152 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1153 self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1154 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1155 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1156 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1157 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1158 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1159 self.tabsimi.AddPage(self.graphpan, 'Graph')
1160 self.tabsimi.parametres = self.parametres
1161 self.parent.nb.AddPage(self.tabsimi, 'Analyse de graph')
1162 self.parent.ShowTab(True)
1163 self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1165 def redosimi(self,evt) :
1166 with open(self.pathout['selected.csv'],'r') as f :
1168 selected = [int(val) for val in selected.splitlines()]
1169 #if self.actives is None :
1170 # with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1171 # self.actives = f.read()
1172 # self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1174 actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1176 actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1178 #self.tableau.make_listactives()
1179 actives = dict([[i, val] for i, val in enumerate(actives)])
1180 #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1181 self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1182 self.dial.CenterOnParent()
1183 self.val = self.dial.ShowModal()
1184 if self.val == wx.ID_OK :
1185 last = self.dial.listcol.GetFirstSelected()
1186 lastl = [self.dial.listcol.GetFirstSelected()]
1187 indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1188 while self.dial.listcol.GetNextSelected(last) != -1:
1189 last = self.dial.listcol.GetNextSelected(last)
1191 indexes.append(self.dial.listcol.getColumnText(last,0))
1192 self.column = [self.tableau.listactives.index(val) for val in indexes]
1194 with open(self.pathout['selected.csv'], 'w') as f :
1195 f.write('\n'.join([`val` for val in self.column]))
1198 self.script = PrintSimiScript(self)
1199 self.script.make_script()
1200 self.tmpfile = self.script.scriptout
1201 dlg = progressbar(self, maxi = 2)
1204 if self.parametres['type_graph'] == 1:
1205 if self.parametres['svg'] :
1206 filename, ext = os.path.splitext(self.script.filename)
1207 fileout = filename + '.svg'
1209 fileout = self.script.filename
1210 if os.path.exists(self.pathout['liste_graph']):
1211 graph_simi = read_list_file(self.pathout['liste_graph'])
1212 graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1214 graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1215 print_liste(self.pathout['liste_graph'], graph_simi)
1216 DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1217 if self.parametres['type_graph'] == 1:
1218 if self.parametres['svg'] :
1219 self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1221 self.graphpan.sizer_3.Add(wx.StaticBitmap(self.graphpan.panel_1, -1, wx.Bitmap(self.script.filename, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1222 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1223 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1224 self.graphpan.Layout()
1225 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1230 def make_param(self) :
1231 if self.parametres['first'] :
1234 keep_coord = self.dial.check_coord.GetValue()
1235 #self.select = self.dial.check_colch.GetValue()
1237 paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1238 'layout' : self.dial.choice2.GetSelection(),
1239 'type_graph' : self.dial.choice3.GetSelection(),
1240 'arbremax' : self.dial.check1.GetValue(),
1241 'coeff_tv' : self.dial.check_s_size.GetValue(),
1242 'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1243 'tvprop' : self.dial.check2.GetValue(),
1244 'tvmin' : self.dial.spin_tvmin.GetValue(),
1245 'tvmax' : self.dial.spin_tvmax.GetValue(),
1246 'coeff_te' : self.dial.check3.GetValue(),
1247 'coeff_temin' : self.dial.spin_temin.GetValue(),
1248 'coeff_temax' : self.dial.spin_temax.GetValue(),
1249 'label_e' : self.dial.check_elab.GetValue(),
1250 'label_v' : self.dial.check_vlab.GetValue(),
1251 'vcex' : self.dial.check_vcex.GetValue(),
1252 'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1253 'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1254 'cex' : self.dial.spin_cex.GetValue(),
1255 'seuil_ok' : self.dial.check_seuil.GetValue(),
1256 'seuil' : self.dial.spin_seuil.GetValue(),
1257 'cols' : self.dial.cols.GetColour(),
1258 'cola' : self.dial.cola.GetColour(),
1259 'width' : self.dial.spin_width.GetValue(),
1260 'height' : self.dial.spin_height.GetValue(),
1262 'keep_coord' : keep_coord,
1263 'alpha' : self.dial.slider_sphere.GetValue(),
1264 'film' : self.dial.film.GetValue(),
1265 'svg' : self.dial.choix_format.GetSelection(),
1266 'halo' : self.dial.halo.GetValue(),
1267 'com' : self.dial.comcheck.GetValue(),
1268 'communities' : self.dial.choix_com.GetSelection(),
1270 if 'cexfromchi' in self.parametres :
1271 paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1272 if 'sfromchi' in self.parametres :
1273 paramsimi['sfromchi'] = self.dial.checki.GetValue()
1274 if 'vlabcolor' in self.parametres :
1275 paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1276 if 'check_bystar' in dir(self.dial) :
1277 paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1278 paramsimi['stars'] = self.parametres['stars']
1279 self.parametres.update(paramsimi)
1282 if self.parametres['type_graph'] == 1 :
1288 pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1289 if self.parametres['type_graph'] == 1 :
1290 while pid.poll() == None :
1293 check_Rresult(self.parent, pid)
1295 def export(self, evt) :
1297 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1299 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1305 graph <- graph.simi$graph
1306 V(graph)$x <- graph.simi$layout[,1]
1307 V(graph)$y <- graph.simi$layout[,2]
1308 if (length(graph.simi$label.cex == 1)) {
1309 V(graph)$weight <- graph.simi$mat.eff
1311 V(graph)$weight <- graph.simi$label.cex
1313 V(graph)$color <- vertex.label.color
1314 V(graph)$frequences <- graph.simi$mat.eff
1315 V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
1316 V(graph)$label <- as.character(graph.simi$v.label)
1317 E(graph)$weight <- graph.simi$we.width
1318 write.graph(graph, fileout, format = 'graphml')
1319 #saveAsGEXF(graph, filepath = fileout)
1320 """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1321 filetmp = tempfile.mktemp()
1322 with open(filetmp, 'w') as f :
1324 exec_rcode(self.ira.RPath, filetmp)
1325 mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
1326 mss.CenterOnParent()
1331 class GraphPanelSimi(wx.Panel):
1332 def __init__(self,parent, dico, list_graph):
1333 wx.Panel.__init__(self,parent)
1336 self.dirout = os.path.dirname(self.Dict['ira'])
1337 self.parent = self.GetParent()#parent
1338 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "courier"))
1341 self.tabsimi = self.parent.GetParent()
1342 self.ira = self.tabsimi.GetParent()
1343 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1344 afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1345 self.butafc = wx.BitmapButton(self, -1, afc_img)
1346 export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1347 self.butexport = wx.BitmapButton(self, -1, export_img)
1348 for i in range(0,len(list_graph)):
1349 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1350 filename, ext = os.path.splitext(list_graph[i][0])
1351 if ext in ['.svg', '.html'] :
1352 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])))
1354 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1355 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1356 self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove)
1357 self.__set_properties()
1360 def __set_properties(self):
1361 self.panel_1.EnableScrolling(True,True)
1362 #self.panel_1.SetSize((1000,1000))
1363 self.panel_1.SetScrollRate(20, 20)
1364 self.panel_1.SetFocus()
1366 def __do_layout(self):
1367 self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1368 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1369 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1370 self.sizer_2.Add(self.butafc, 0, 0, 0)
1371 self.sizer_2.Add(self.butexport, 0, 0, 0)
1372 for i in range(0, len(self.listimg)):
1373 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1374 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1375 self.panel_1.SetSizer(self.sizer_3)
1376 self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1377 self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1378 self.SetSizer(self.sizer_1)
1380 def onMouseMove(self, event):
1381 self.panel_1.SetFocus()