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 += ': '.join([_(u'Number of texts').decode('utf8'), u'%i%s' % (corpus.getucinb(), sep)])
573 txt += ': '.join([_(u'Number of text segments').decode('utf8'), '%i%s' % (corpus.getucenb(), sep)])
574 txt += ': '.join([_(u'Number of forms').decode('utf8'), '%i%s' % (len(corpus.formes), sep)])
575 txt += ': '.join([_(u'Number of occurrences').decode('utf8'), '%i%s' % (totocc, sep)])
576 #txt += u'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
577 txt += ': '.join([_(u'Number of lemmas').decode('utf8'), '%i%s' % (len(corpus.lems), sep)])
578 txt += ': '.join([_(u'Number of active forms').decode('utf8'), '%i%s' % (corpus.getactivesnb(1), sep)])
579 txt += ': '.join([_(u'Number of supplementary forms').decode('utf8'), '%i%s' % (corpus.getactivesnb(2), sep)])
580 txt += ' >= '.join([_(u'Number of active forms with a frequency').decode('utf8'), '%i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)])
581 txt += ': '.join([_(u'Mean of forms by segment').decode('utf8'), '%f%s' % (float(totocc) / float(corpus.getucenb()), sep)])
582 if 'tailleuc1' in parametres :
583 if parametres['classif_mode'] == 0 :
584 txt += ': '.join([_(u'Size of rst1 / rst2').decode('utf8'), '%i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)])
586 self.Ucenb = self.nbind
587 txt += ': '.join([_(u'Number of lines').decode('utf8'), '%i%s' % (self.nbind, sep)])
588 txt += ': '.join([_(u'Number of clusters').decode('utf8'), '%i%s' % (self.clnb, sep)])
590 txt += ': '.join([_(u'Number of clusters').decode('utf8'), '%i%s' % (parametres['clnb'], sep)])
591 if parametres['classif_mode'] == 0 or parametres['classif_mode'] == 1 :
592 txt += ' '.join(['%i' % sum([len(cl) for cl in corpus.lc]), _(u'segments classified on').decode('utf8'), '%i (%.2f%%)%s' % (corpus.getucenb(), (float(sum([len(cl) for cl in corpus.lc])) / float(corpus.getucenb())) * 100, sep)])
593 elif self.parametres['classif_mode'] == 2 :
594 txt += ' '.join([u'%i' % sum([len(cl) for cl in corpus.lc]), _(u'texts classified on').decode('utf8'), '%i (%.2f%%)%s' % (corpus.getucinb(), (float(sum([len(cl) for cl in corpus.lc]))) / float(corpus.getucinb()) * 100, sep)])
596 txt += ' '.join(['%i' % self.ucecla, _(u'line classified on').decode('utf8'), '%i (%.2f%%)%s' % (self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)])
598 txt += ''.join([sep, u'###########################', sep, _(u'time').decode('utf8'), ' : %s' % parametres.get('time', ''), sep, u'###########################', sep])
600 with open(self.pathout['pre_rapport'], 'w') as f :
604 class SashList(wx.Panel) :
605 def __init__(self, parent) :
606 wx.Panel.__init__(self, parent, -1)
609 #self.gparent=gparent
613 # A window to the left of the client window
614 #self.listlex = listlex
615 self.leftwin1 = wx.SashLayoutWindow(
616 self, -1, wx.DefaultPosition, (200, 300),
617 wx.NO_BORDER|wx.SW_3D
620 self.leftwin1.SetDefaultSize((120, 1000))
621 self.leftwin1.SetOrientation(wx.LAYOUT_VERTICAL)
622 self.leftwin1.SetAlignment(wx.LAYOUT_LEFT)
623 self.leftwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
624 self.leftwin1.SetSashVisible(wx.SASH_RIGHT, True)
625 self.leftwin1.SetExtraBorderSize(10)
627 #textWindow = wx.TextCtrl(
628 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
629 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
632 #textWindow.SetValue("A sub window")
634 self.leftWindow1 = self.leftwin1
635 winids.append(self.leftwin1.GetId())
637 rightwin1 = wx.SashLayoutWindow(
638 self, -1, wx.DefaultPosition, (200, 300),
639 wx.NO_BORDER|wx.SW_3D
642 rightwin1.SetDefaultSize((120, 1000))
643 rightwin1.SetOrientation(wx.LAYOUT_VERTICAL)
644 rightwin1.SetAlignment(wx.LAYOUT_LEFT)
645 rightwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
646 rightwin1.SetSashVisible(wx.SASH_RIGHT, True)
647 rightwin1.SetExtraBorderSize(10)
648 #textWindow = wx.TextCtrl(
649 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
650 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
653 #textWindow.SetValue("A sub window")
655 self.rightwin1 = rightwin1
656 winids.append(rightwin1.GetId())
659 def __init__(self, page):
661 parametres = self.page.parametres
662 ira = wx.GetApp().GetTopWindow()
663 tgenpath = os.path.join(parametres['pathout'], 'tgen.csv')
664 self.page.tgens, etoiles = ReadList(parametres['tgenspec'], ira.syscoding, sep="\t")
665 tgen = TGen(path = tgenpath, encoding = parametres['encoding'])
669 if 'TabChdSim' in dir(page) :
670 page = page.TabChdSim
671 for i in range(page.GetPageCount()) :
672 tab = page.GetPage(i)
673 if 'gparent' in dir(tab) :
674 if tab.gparent is not None :
675 gparent = tab.gparent
676 if 'tgen' in dir(tab) :
682 self.page.tgentab.RefreshData(self.page.tgens)
683 self.page.tgentab.tgens = tgen.tgen
686 self.page.tgentab = ListForSpec(ira, gparent, self.page.tgens, etoiles[1:])
687 self.page.tgentab.tgen = True
688 self.page.tgentab.tgens = tgen.tgen
689 page.AddPage(self.page.tgentab, _(u'Tgens Specificities').decode('utf8'))
690 page.SetSelection(page.GetPageCount() - 1)
693 def __init__(self, ira, corpus, parametres):
694 self.pathout = PathOut(dirout = parametres['pathout'])
696 self.dictpathout = StatTxtPathOut(parametres['pathout'])
697 #self.corpus.read_corpus_from_shelves(self.corpus.dictpathout['db'])
699 self.encoding = self.corpus.parametres['syscoding']
700 self.parametres = parametres
702 self.DictSpec, first = ReadList(self.dictpathout['tablespecf'], self.corpus.parametres['syscoding'])
703 if os.path.exists(self.pathout['banalites.csv']) :
704 self.dictban, firstban = ReadList(self.pathout['banalites.csv'], self.corpus.parametres['syscoding'])
705 self.DictType, firstt = ReadList(self.dictpathout['tablespect'], self.corpus.parametres['syscoding'])
706 self.DictEff, firsteff = ReadList(self.dictpathout['tableafcm'], self.corpus.parametres['syscoding'])
707 self.DictEffType, firstefft = ReadList(self.dictpathout['tabletypem'], self.corpus.parametres['syscoding'])
708 self.DictEffRelForme, firsteffrelf = ReadList(self.dictpathout['eff_relatif_forme'], self.corpus.parametres['syscoding'])
709 self.DictEffRelType, firsteffrelt = ReadList(self.dictpathout['eff_relatif_type'], self.corpus.parametres['syscoding'])
710 self.etoiles = firsteff[1:]
711 #sash = SashList(ira.nb)
714 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
715 self.TabStat.parametres = parametres
716 self.ListPan = ListForSpec(ira, self, self.DictSpec, self.etoiles)
717 if os.path.exists(self.pathout['banalites.csv']) :
718 self.listban = ListForSpec(ira, self, self.dictban, ['eff'] + self.etoiles, usefirst = True)
719 #self.ListPan2 = ListForSpec(sash.rightwin1, self, self.DictSpec, first)
720 self.ListPant = ListForSpec(ira, self, self.DictType, self.etoiles)
721 self.ListPanEff = ListForSpec(ira, self, self.DictEff, self.etoiles)
722 self.ListPanEffType = ListForSpec(ira, self, self.DictEffType, self.etoiles)
723 self.ListPanEffRelForme = ListForSpec(ira, self, self.DictEffRelForme, self.etoiles)
724 self.ListPanEffRelType = ListForSpec(ira, self, self.DictEffRelType, self.etoiles)
726 self.TabStat.AddPage(self.ListPan, _(u'Forms').decode('utf8'))
727 if os.path.exists(self.pathout['banalites.csv']) :
728 self.TabStat.AddPage(self.listban, _(u'Banal forms').decode('utf8'))
729 self.TabStat.AddPage(self.ListPant, _(u'POS').decode('utf8'))
730 self.TabStat.AddPage(self.ListPanEff, _(u'Forms frequencies').decode('utf8'))
731 self.TabStat.AddPage(self.ListPanEffType, _(u'POS frequencies').decode('utf8'))
732 self.TabStat.AddPage(self.ListPanEffRelForme, _(u'Forms relative frequencies').decode('utf8'))
733 self.TabStat.AddPage(self.ListPanEffRelType, _(u'POS relative frequencies').decode('utf8'))
734 if self.parametres['clnb'] > 2 :
735 self.TabAFC = aui.AuiNotebook(self.TabStat, -1, wx.DefaultPosition)
736 list_graph=read_list_file(self.dictpathout['liste_graph_afcf'], encoding = self.encoding)
737 self.tabAFCGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afcf', coding = self.encoding)
738 self.TabAFC.AddPage(self.tabAFCGraph, _(u'CA forms').decode('utf8'))
739 list_graph=read_list_file(self.dictpathout['liste_graph_afct'], encoding = self.encoding)
740 self.tabAFCTGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afct', coding=self.encoding)
741 self.TabAFC.AddPage(self.tabAFCTGraph, _(u'CA POS').decode('utf8'))
742 self.TabStat.AddPage(self.TabAFC, _(u'CA').decode('utf8'))
744 ira.nb.AddPage(self.TabStat, ' - '.join([_(u'Specificities').decode('utf8'), self.parametres['name']]))
747 self.TabStat.corpus = self.corpus
748 self.TabStat.etoiles = self.etoiles
749 if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenspec.csv')) :
750 self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenspec.csv')
751 TgenLayout(self.TabStat)
752 self.TabStat.SetSelection(0)
753 ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
754 ira.ShowAPane("Tab_content")
757 def __init__(self, ira, corpus, parametres):
758 self.pathout = PathOut(dirout = parametres['pathout'])
762 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
763 self.TabStat.parametres = parametres
764 self.TabStat.corpus = corpus
765 self.TabStat.pathout = self.pathout
766 # CHD = GraphPanel(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
767 # panel.TabChdSim.AddPage(CHD,'CHD')
769 #self.TabStatTot = wx.TextCtrl(self.TabStat, -1, style=wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2)
770 list_graph = [['zipf.png', 'zipf']]
771 self.TabStatTot = GraphPanel(ira.nb, self.pathout, list_graph, self.result['glob'])
772 self.TabStat.AddPage(self.TabStatTot, _(u'Abstract').decode('utf8'))
774 dictlabel = {'total' : _(u'Total').decode('utf8'),
775 u'formes_actives' : _(u'Actives forms').decode('utf8'),
776 u'formes_supplémentaires': _(u'Supplementary forms').decode('utf8'),
777 u'hapax' : _(u'Hapax').decode('utf8'),
780 for item in self.result:
782 datam = [['forme', 'nb']]
783 self.ListPan = ListPanel(ira, self, self.result[item])
784 self.TabStat.AddPage(self.ListPan, dictlabel[item])
785 ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
786 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
787 ira.ShowAPane("Tab_content")
789 def read_result(self) :
790 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'}
793 with open(self.pathout[lcle[key]], 'r') as f :
794 self.result[key] = [line.split(';') for line in f.read().splitlines()]
795 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
796 with open(self.pathout['glob.txt'], 'r') as f :
797 self.result['glob'] = f.read()
799 class GraphPanelDendro(wx.Panel):
800 def __init__(self,parent, dico, list_graph, txt=False):
801 wx.Panel.__init__(self,parent)
803 self.dictpathout = dico
804 self.dirout = os.path.dirname(self.dictpathout['ira'])
805 self.list_graph = list_graph
806 self.parent = self.GetParent()#parent
807 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
810 self.tabchd = self.parent.GetParent()
811 self.ira = self.tabchd.GetParent()
812 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
813 self.panel_1.SetBackgroundColour('white')
814 self.deb = wx.StaticText(self.panel_1, -1, txt)
815 dendro_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
816 dendro_liste_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro_liste.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
817 dendro_cloud_img= wx.Image(os.path.join(self.ira.images_path,'but_dendro_cloud.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
818 self.butdendro = wx.BitmapButton(self, -1, dendro_img)
819 self.butdendrotexte = wx.BitmapButton(self, -1, dendro_liste_img)
820 self.butdendrocloud = wx.BitmapButton(self, -1, dendro_cloud_img)
822 for i in range(0,len(list_graph)):
823 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
824 filename, ext = os.path.splitext(list_graph[i][0])
826 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])))
828 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
829 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
831 self.__set_properties()
834 def __set_properties(self):
835 self.panel_1.EnableScrolling(True,True)
836 #self.panel_1.SetSize((1000,1000))
837 self.panel_1.SetScrollRate(20, 20)
838 self.panel_1.SetFocus()
839 self.Bind(wx.EVT_BUTTON, self.ondendro, self.butdendro)
840 self.Bind(wx.EVT_BUTTON, self.ondendrotexte, self.butdendrotexte)
841 self.Bind(wx.EVT_BUTTON, self.ondendrocloud, self.butdendrocloud)
842 self.param = {'width' : 700,
846 'taille_classe' : True,
850 self.type_dendro = [ u"phylogram", u"cladogram", u"fan", u"unrooted", u"radial" ]
852 def __do_layout(self):
853 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
854 self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
855 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
856 self.sizer_3.Add(self.deb)
857 self.sizer_1.Add(self.butdendro, 0, 0, 0)
858 self.sizer_1.Add(self.butdendrotexte, 0, 0, 0)
859 self.sizer_1.Add(self.butdendrocloud, 0, 0, 0)
861 for i in range(0, len(self.listimg)):
862 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
863 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
864 self.panel_1.SetSizer(self.sizer_3)
865 self.sizer_2.Add(self.sizer_1, 0, wx.EXPAND, 0)
866 self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
867 self.SetSizer(self.sizer_2)
869 def make_param(self, dial):
870 self.param['width'] = dial.m_spinCtrl2.GetValue()
871 self.param['height'] = dial.m_spinCtrl1.GetValue()
872 self.param['type_dendro'] = dial.m_choice1.GetSelection()
873 self.param['color_nb'] = dial.m_radioBox1.GetSelection()
874 self.param['taille_classe'] = dial.m_checkBox1.GetValue()
875 self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
876 self.param['svg'] = dial.choice_format.GetSelection()
878 def make_dendro(self, dendro = 'simple') :
879 if self.param['svg'] :
883 while os.path.exists(os.path.join(self.dirout, 'dendrogramme_' + str(self.graphnb)+typefile)) :
885 fileout = ffr(os.path.join(self.dirout,'dendrogramme_' + str(self.graphnb)+typefile))
886 width = self.param['width']
887 height = self.param['height']
888 type_dendro = self.type_dendro[self.param['type_dendro']]
889 if self.param['taille_classe'] :
893 if self.param['color_nb'] == 0 :
897 if self.param['type_tclasse'] == 0 :
901 if self.param['svg'] :
905 dendro_path = self.dictpathout['Rdendro']
906 classe_path = self.dictpathout['uce']
911 classes <- read.csv2("%s", row.names=1)
912 classes <- classes[,1]
913 """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']), ffr(classe_path))
914 if dendro == 'simple' :
916 open_file_graph("%s", width=%i, height=%i)
917 plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
918 """ % (ffr(fileout), width, height, type_dendro, histo, bw, tclasse)
919 elif dendro == 'texte' :
923 if (is.null(debsup)) {
926 chistable <- chistabletot[1:(debsup-1),]
927 open_file_graph("%s", width=%i, height=%i, svg = %s)
928 plot.dendro.prof(tree.cut1$tree.cl, classes, chistable, nbbycl = 60, type.dendro="%s", bw=%s, lab=NULL)
929 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
930 elif dendro == 'cloud' :
934 if (is.null(debsup)) {
937 chistable <- chistabletot[1:(debsup-1),]
938 open_file_graph("%s", width=%i, height=%i, svg=%s)
939 plot.dendro.cloud(tree.cut1$tree.cl, classes, chistable, nbbycl = 300, type.dendro="%s", bw=%s, lab=NULL)
940 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
943 tmpfile = tempfile.mktemp()
944 with open(tmpfile, 'w') as f :
946 busy = wx.BusyInfo(_("Please wait...").decode('utf8'), self.parent)
948 error = exec_rcode(self.ira.RPath, tmpfile, wait=True)
950 check_Rresult(self.ira, error)
951 self.list_graph.append([fileout, 'Dendrogramme CHD1 - %s' % type_dendro])
952 print_liste(self.dictpathout['liste_graph_chd'], self.list_graph)
953 if self.param['svg'] :
954 self.sizer_3.Add(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
956 self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
957 self.sizer_3.Add(wx.StaticText(self.panel_1,-1, 'Dendrogramme CHD1 - %s' % type_dendro), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
958 self.sizer_3.Fit(self.panel_1)
960 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
963 def ondendro(self, evt):
964 dial = PrefDendro(self.ira, self.param)
965 val = dial.ShowModal()
967 self.make_param(dial)
970 def ondendrotexte(self, evt):
971 dial = PrefDendro(self.ira, self.param)
972 val = dial.ShowModal()
974 self.make_param(dial)
975 self.make_dendro(dendro = 'texte')
977 def ondendrocloud(self, evt):
978 dial = PrefDendro(self.ira, self.param)
979 val = dial.ShowModal()
981 self.make_param(dial)
982 self.make_dendro(dendro = 'cloud')
985 def __init__(self, ira, parametres) :
986 #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)
987 self.panel = CopusPanel(ira, parametres)
988 ira.nb.AddPage(self.panel, 'Description %s' % parametres['corpus_name'])
989 #self.text.write(DoConf().totext(parametres))
990 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
991 ira.ShowAPane("Tab_content")
994 def __init__(self, ira, matrix):
995 #self.parent.content = self.csvtable
996 self.sheet = MySheet(ira.nb)
997 ira.nb.AddPage(self.sheet, matrix.parametres['matrix_name'])
998 self.sheet.Populate(matrix.csvtable)
999 self.sheet.parametres = matrix.parametres
1000 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
1001 ira.ShowAPane("Tab_content")
1003 class CopusPanel(wx.Panel) :
1004 def __init__(self, parent, parametres) :
1005 wx.Panel.__init__ ( self, parent, id = wx.ID_ANY, pos = wx.DefaultPosition, size = wx.Size( 500,300 ), style = wx.TAB_TRAVERSAL )
1006 self.parametres = parametres
1007 fgSizer5 = wx.FlexGridSizer( 0, 2, 0, 0 )
1008 fgSizer5.SetFlexibleDirection( wx.BOTH )
1009 fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )
1010 self.fgSizer5 = fgSizer5
1012 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, _(u"Description of corpus").decode('utf8'), wx.DefaultPosition, wx.DefaultSize, 0 )
1014 self.m_staticText18.Wrap( -1 )
1015 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1017 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1018 self.m_staticText19.Wrap( -1 )
1019 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1021 self.m_staticText20 = wx.StaticText( self, wx.ID_ANY, u"Nom", wx.DefaultPosition, wx.DefaultSize, 0 )
1022 self.m_staticText20.Wrap( -1 )
1023 fgSizer5.Add( self.m_staticText20, 0, wx.ALL, 5 )
1025 self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, parametres['corpus_name'], wx.DefaultPosition, wx.DefaultSize, 0 )
1026 self.m_staticText21.Wrap( -1 )
1027 fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )
1029 description = {'lang' : _(u'Language').decode('utf8'),
1030 'encoding' : _(u'Characters set').decode('utf8'),
1031 'ucinb' : _(u'Number of texts').decode('utf8'),
1032 'ucenb' : _(u'Number of text segments').decode('utf8'),
1033 'formesnb' : _(u'Number of forms').decode('utf8'),
1034 'hapax' : _(u'Number of hapax').decode('utf8'),
1037 keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']
1039 self.addkeys(keys, description)
1041 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Paramètres", wx.DefaultPosition, wx.DefaultSize, 0 )
1042 self.m_staticText18.Wrap( -1 )
1043 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1045 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1046 self.m_staticText19.Wrap( -1 )
1047 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1049 keys = ['ucemethod', 'ucesize', 'keep_caract', 'expressions']
1050 self.addkeys(keys, description)
1052 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Statistiques", wx.DefaultPosition, wx.DefaultSize, 0 )
1053 self.m_staticText18.Wrap( -1 )
1054 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1056 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1057 self.m_staticText19.Wrap( -1 )
1058 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1060 keys = ['ucinb', 'ucenb', 'occurrences', 'formesnb', 'hapax']
1061 self.addkeys(keys, description)
1063 self.SetSizer( fgSizer5 )
1066 def addkeys(self, keys, description) :
1068 option = self.parametres.get(key,u'non défini')
1069 if isinstance(option, int) :
1071 text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
1073 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1075 text = wx.StaticText( self, wx.ID_ANY, option, wx.DefaultPosition, wx.DefaultSize, 0 )
1077 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1079 class DefaultTextLayout :
1080 def __init__(self, ira, corpus, parametres) :
1081 self.pathout = PathOut(dirout = parametres['pathout'])
1084 self.parametres = parametres
1085 self.corpus = corpus
1088 def dolayout(self) :
1089 log.info('no layout yet')
1091 class WordCloudLayout(DefaultTextLayout):
1093 self.pathout.basefiles(simipath)
1094 self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1095 if self.parametres['svg'] :
1096 list_graph = [['nuage_1.svg', 'Nuage']]
1098 list_graph = [['nuage_1.png', 'Nuage']]
1099 self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, list_graph)
1100 self.Tab.AddPage(self.TabStatTot, 'Nuage')
1101 self.Tab.corpus = self.corpus
1102 self.Tab.parametres = self.parametres
1103 self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
1104 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1105 self.ira.ShowAPane("Tab_content")
1107 class SimiLayout(DefaultTextLayout) :
1108 def dolayout(self) :
1109 self.pathout.basefiles(simipath)
1111 self.indices = indices_simi
1112 if os.path.exists(self.pathout['liste_graph']) :
1113 list_graph = read_list_file(self.pathout['liste_graph'])
1115 list_graph = [['','']]
1116 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1117 self.tabsimi = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1118 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1119 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1120 self.tabsimi.corpus = self.corpus
1121 self.tabsimi.parametres = self.parametres
1122 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1123 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1124 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1125 self.tabsimi.AddPage(self.graphpan, 'Graph')
1126 self.ira.nb.AddPage(self.tabsimi, _(u'Graph analysis').decode('utf8'))
1127 self.ira.ShowTab(True)
1128 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1130 def redosimi(self, evt) :
1131 with open(self.pathout['selected.csv'],'r') as f :
1133 selected = [int(val) for val in selected.splitlines()]
1134 if self.actives is None :
1135 with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1136 self.actives = f.read()
1137 self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1138 if os.path.exists(self.pathout['actives_nb.csv']) :
1139 with open(self.pathout['actives_nb.csv'], 'r') as f :
1141 act_nb = act_nb.splitlines()
1142 dictcol = dict([[i, [self.actives[i], int(act_nb[i])]] for i, val in enumerate(self.actives)])
1144 dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1145 #res = SelectColumn(self.ira, dictcol, self.actives, self.pathout['selected.csv'], selected = selected, dlg = True)
1147 prep = PrepSimi(self.ira, self, self.parametres,self.pathout['selected.csv'], self.actives, indices_simi, wordlist = dictcol, selected = selected)
1148 if prep.val == wx.ID_OK :
1149 self.parametres = prep.parametres
1151 script = PrintSimiScript(self)
1152 script.make_script()
1153 pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
1154 check_Rresult(self.ira, pid)
1155 if self.parametres['type_graph'] in [1,3] :
1156 if self.parametres['svg'] :
1157 filename, ext = os.path.splitext(script.filename)
1158 fileout = filename + '.svg'
1159 elif self.parametres['type_graph'] == 3 :
1160 fileout = script.filename
1161 parametres = {'gexffile' : fileout,
1162 'dirout' : os.path.dirname(fileout),
1163 'titre': 'Le titre',
1164 #'nodemin': self.param['txt_min'],
1165 #'nodemax': self.param['txt_max'],
1166 #'bargraphw' : 60*int(self.param['clnb']),
1168 web = WebExport(self.ira, parametres)
1169 fileout = web.exportsimi()
1171 fileout = script.filename
1172 if os.path.exists(self.pathout['liste_graph']):
1173 graph_simi = read_list_file(self.pathout['liste_graph'])
1174 graph_simi.append([os.path.basename(fileout), script.txtgraph])
1176 graph_simi = [[os.path.basename(fileout), script.txtgraph]]
1177 print_liste(self.pathout['liste_graph'], graph_simi)
1178 DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1179 if self.parametres['type_graph'] in [1,3] :
1180 if self.parametres['svg'] or self.parametres['type_graph'] == 3 :
1181 self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1183 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)
1184 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1185 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1186 self.graphpan.Layout()
1187 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1189 def export(self, evt) :
1191 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1193 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1199 graph <- graph.simi$graph
1200 V(graph)$x <- graph.simi$layout[,1]
1201 V(graph)$y <- graph.simi$layout[,2]
1202 if (length(graph.simi$label.cex == 1)) {
1203 V(graph)$weight <- graph.simi$eff
1205 V(graph)$weight <- graph.simi$label.cex
1207 V(graph)$color <- vertex.label.color
1208 V(graph)$frequences <- graph.simi$mat.eff
1209 V(graph)$label <- as.character(graph.simi$v.label)
1210 E(graph)$weight <- graph.simi$we.width
1211 write.graph(graph, fileout, format = 'graphml')
1212 #saveAsGEXF(graph, filepath = fileout)
1213 """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1214 filetmp = tempfile.mktemp()
1215 with open(filetmp, 'w') as f :
1217 exec_rcode(self.ira.RPath, filetmp)
1218 mss = wx.MessageDialog(self.ira, fileout, _(u'File exported').decode('utf8'), wx.OK)
1219 mss.CenterOnParent()
1223 class DefaultMatLayout :
1224 def __init__(self, parent, tableau, parametres) :
1225 self.pathout = PathOut(dirout = parametres['pathout'])
1227 self.parent = parent
1228 self.tableau = tableau
1229 self.parametres = parametres
1230 if os.path.exists(self.pathout['analyse.db']) :
1231 self.tableau.read_tableau(self.pathout['analyse.db'])
1233 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1234 self.ira.ShowAPane("Tab_content")
1236 def dolayout(self) :
1239 class FreqLayout(DefaultMatLayout) :
1240 def dolayout(self) :
1241 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1242 res = normpath_win32(self.pathout['resultats.html']).replace('\\','/')
1243 self.tab.LoadPage(res)
1244 self.tab.parametres = self.parametres
1245 self.ira.nb.AddPage(self.tab, ' - '.join([_(u"Frequency").decode('utf8'), self.parametres['name']]))
1248 class Chi2Layout(DefaultMatLayout) :
1250 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1251 if "gtk2" in wx.PlatformInfo:
1252 self.tab.SetStandardFonts()
1253 res = normpath_win32(self.pathout['resultats-chi2.html']).replace('\\','/')
1254 self.tab.LoadPage(res)
1255 self.tab.parametres = self.parametres
1256 self.ira.nb.AddPage(self.tab, ' - '.join([u"Chi2", self.parametres['name']]))
1257 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1258 #self.ira.ShowAPane("Tab_content")
1261 class ProtoLayout(DefaultMatLayout) :
1262 def dolayout(self) :
1263 list_graph = [['proto.png', _(u'Prototypical analysis').decode('utf8')]]
1264 #self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1265 #if self.parametres['svg'] :
1266 # list_graph = [['nuage_1.svg', 'Nuage']]
1268 # list_graph = [['nuage_1.png', 'Nuage']]
1269 self.TabProto = GraphPanel(self.ira.nb, self.pathout, list_graph)
1270 #self.Tab.AddPage(self.TabProto, 'Analyse Prototypique')
1271 #self.Tab.corpus = self.corpus
1272 self.TabProto.parametres = self.parametres
1273 self.ira.nb.AddPage(self.TabProto, ' - '.join([_(u'Prototypical analysis').decode('utf8'), self.parametres['name']]))
1274 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1275 #self.ira.ShowAPane("Tab_content")
1278 class SimiMatLayout(DefaultMatLayout) :
1280 self.pathout.basefiles(simipath)
1281 self.indices = indices_simi
1282 if os.path.exists(self.pathout['liste_graph']) :
1283 list_graph = read_list_file(self.pathout['liste_graph'])
1285 list_graph = [['','']]
1286 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1287 self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1288 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1289 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1290 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1291 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1292 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1293 self.tabsimi.AddPage(self.graphpan, 'Graph')
1294 self.tabsimi.parametres = self.parametres
1295 self.parent.nb.AddPage(self.tabsimi, ' - '.join([_(u'Graph analysis').decode('utf8'), self.parametres['name']]))
1296 #self.parent.ShowTab(True)
1297 #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1299 def redosimi(self,evt) :
1300 with open(self.pathout['selected.csv'],'r') as f :
1302 selected = [int(val) for val in selected.splitlines()]
1303 #if self.actives is None :
1304 # with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1305 # self.actives = f.read()
1306 # self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1308 actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1310 actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1312 #self.tableau.make_listactives()
1313 actives = dict([[i, val] for i, val in enumerate(actives)])
1314 #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1315 self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1316 self.dial.CenterOnParent()
1317 self.val = self.dial.ShowModal()
1318 if self.val == wx.ID_OK :
1319 last = self.dial.listcol.GetFirstSelected()
1320 lastl = [self.dial.listcol.GetFirstSelected()]
1321 indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1322 while self.dial.listcol.GetNextSelected(last) != -1:
1323 last = self.dial.listcol.GetNextSelected(last)
1325 indexes.append(self.dial.listcol.getColumnText(last,0))
1326 self.column = [self.tableau.listactives.index(val) for val in indexes]
1328 with open(self.pathout['selected.csv'], 'w') as f :
1329 f.write('\n'.join([`val` for val in self.column]))
1332 self.script = PrintSimiScript(self)
1333 self.script.make_script()
1334 self.tmpfile = self.script.scriptout
1335 dlg = progressbar(self, maxi = 2)
1338 if self.parametres['type_graph'] == 1:
1339 if self.parametres['svg'] :
1340 filename, ext = os.path.splitext(self.script.filename)
1341 fileout = filename + '.svg'
1343 fileout = self.script.filename
1344 fileout = normpath_win32(fileout)
1345 if os.path.exists(self.pathout['liste_graph']):
1346 graph_simi = read_list_file(self.pathout['liste_graph'])
1347 graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1349 graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1350 print_liste(self.pathout['liste_graph'], graph_simi)
1351 DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1352 if self.parametres['type_graph'] == 1:
1353 if self.parametres['svg'] :
1354 self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1356 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)
1357 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1358 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1359 self.graphpan.Layout()
1360 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1365 def make_param(self) :
1366 if self.parametres['first'] :
1369 keep_coord = self.dial.check_coord.GetValue()
1370 #self.select = self.dial.check_colch.GetValue()
1372 paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1373 'layout' : self.dial.choice2.GetSelection(),
1374 'type_graph' : self.dial.choice3.GetSelection(),
1375 'arbremax' : self.dial.check1.GetValue(),
1376 'coeff_tv' : self.dial.check_s_size.GetValue(),
1377 'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1378 'tvprop' : self.dial.check2.GetValue(),
1379 'tvmin' : self.dial.spin_tvmin.GetValue(),
1380 'tvmax' : self.dial.spin_tvmax.GetValue(),
1381 'coeff_te' : self.dial.check3.GetValue(),
1382 'coeff_temin' : self.dial.spin_temin.GetValue(),
1383 'coeff_temax' : self.dial.spin_temax.GetValue(),
1384 'label_e' : self.dial.check_elab.GetValue(),
1385 'label_v' : self.dial.check_vlab.GetValue(),
1386 'vcex' : self.dial.check_vcex.GetValue(),
1387 'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1388 'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1389 'cex' : self.dial.spin_cex.GetValue(),
1390 'seuil_ok' : self.dial.check_seuil.GetValue(),
1391 'seuil' : self.dial.spin_seuil.GetValue(),
1392 'cols' : self.dial.cols.GetColour(),
1393 'cola' : self.dial.cola.GetColour(),
1394 'width' : self.dial.spin_width.GetValue(),
1395 'height' : self.dial.spin_height.GetValue(),
1397 'keep_coord' : keep_coord,
1398 'alpha' : self.dial.slider_sphere.GetValue(),
1399 'film' : self.dial.film.GetValue(),
1400 'svg' : self.dial.choix_format.GetSelection(),
1401 'halo' : self.dial.halo.GetValue(),
1402 'com' : self.dial.comcheck.GetValue(),
1403 'communities' : self.dial.choix_com.GetSelection(),
1404 'edgecurved' : self.dial.check_curved.GetValue(),
1406 if 'cexfromchi' in self.parametres :
1407 paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1408 if 'sfromchi' in self.parametres :
1409 paramsimi['sfromchi'] = self.dial.checki.GetValue()
1410 if 'vlabcolor' in self.parametres :
1411 paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1412 if 'check_bystar' in dir(self.dial) :
1413 paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1414 paramsimi['stars'] = self.parametres['stars']
1415 self.parametres.update(paramsimi)
1418 if self.parametres['type_graph'] == 1 :
1424 pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1425 if self.parametres['type_graph'] == 1 :
1426 while pid.poll() == None :
1429 check_Rresult(self.parent, pid)
1431 def export(self, evt) :
1433 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1435 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1441 graph <- graph.simi$graph
1442 V(graph)$x <- graph.simi$layout[,1]
1443 V(graph)$y <- graph.simi$layout[,2]
1444 if (length(graph.simi$label.cex == 1)) {
1445 V(graph)$weight <- graph.simi$mat.eff
1447 V(graph)$weight <- graph.simi$label.cex
1449 V(graph)$color <- vertex.label.color
1450 V(graph)$frequences <- graph.simi$mat.eff
1451 V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
1452 V(graph)$label <- as.character(graph.simi$v.label)
1453 E(graph)$weight <- graph.simi$we.width
1454 write.graph(graph, fileout, format = 'graphml')
1455 #saveAsGEXF(graph, filepath = fileout)
1456 """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1457 filetmp = tempfile.mktemp()
1458 with open(filetmp, 'w') as f :
1460 exec_rcode(self.ira.RPath, filetmp)
1461 mss = wx.MessageDialog(self.ira, fileout, _(u'File exported').decode('utf8'), wx.OK)
1462 mss.CenterOnParent()
1467 class GraphPanelSimi(wx.Panel):
1468 def __init__(self,parent, dico, list_graph):
1469 wx.Panel.__init__(self,parent)
1472 self.dirout = os.path.dirname(self.Dict['ira'])
1473 self.parent = self.GetParent()#parent
1474 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "courier"))
1477 self.tabsimi = self.parent.GetParent()
1478 self.ira = self.tabsimi.GetParent()
1479 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1480 afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1481 self.butafc = wx.BitmapButton(self, -1, afc_img)
1482 export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1483 self.butexport = wx.BitmapButton(self, -1, export_img)
1484 for i in range(0,len(list_graph)):
1485 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1486 filename, ext = os.path.splitext(list_graph[i][0])
1487 if ext in ['.svg', '.html'] :
1488 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])))
1490 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1491 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1492 self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove)
1493 self.__set_properties()
1496 def __set_properties(self):
1497 self.panel_1.EnableScrolling(True,True)
1498 #self.panel_1.SetSize((1000,1000))
1499 self.panel_1.SetScrollRate(20, 20)
1500 self.panel_1.SetFocus()
1502 def __do_layout(self):
1503 self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1504 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1505 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1506 self.sizer_2.Add(self.butafc, 0, 0, 0)
1507 self.sizer_2.Add(self.butexport, 0, 0, 0)
1508 for i in range(0, len(self.listimg)):
1509 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1510 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1511 self.panel_1.SetSizer(self.sizer_3)
1512 self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1513 self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1514 self.SetSizer(self.sizer_1)
1516 def onMouseMove(self, event):
1517 self.panel_1.SetFocus()