1 # -*- coding: utf-8 -*-
2 #Author: Pierre Ratinaud
3 #Copyright (c) 2008-2020 Pierre Ratinaud
4 #modification pour python 3 : Laurent Mérat, 6x7 - mai 2020
7 #------------------------------------
8 # import des modules python
9 #------------------------------------
14 from time import sleep
19 #------------------------------------
20 # import des modules wx
21 #------------------------------------
23 import wx.lib.agw.hyperlink as hl
24 import wx.lib.agw.aui as aui
25 import wx.lib.agw.labelbook as LB
26 from wx.lib.agw.fmresources import *
28 #------------------------------------
29 # import des fichiers du projet
30 #------------------------------------
31 from chemins import ConstructPathOut, ChdTxtPathOut, FFF, ffr, PathOut, StatTxtPathOut, simipath
32 from configparser import ConfigParser
33 from functions import ReadProfileAsDico, GetTxtProfile, read_list_file, ReadList, exec_rcode, print_liste, BugReport, DoConf,\
34 indices_simi, check_Rresult, progressbar, normpath_win32, TGen, ReadList, launchcommand
35 from ProfList import ProfListctrlPanel
36 from guiparam3d import param3d, simi3d
37 from PrintRScript import write_afc_graph, print_simi3d, PrintSimiScript
38 from profile_segment import ProfileSegment
41 from elcategorizator import ElCategorizator
42 from search_tools import SearchFrame
43 from dialog import PrefGraph, PrefExport, PrefSimpleFile, PrefDendro, SimpleDialog, ImageViewer
44 from guifunct import SelectColumn, PrepSimi, PrefSimi, redosimi
45 from webexport import WebExport
46 from corpus import Corpus
47 from sheet import MySheet
48 from graph_to_json import GraphToJson
56 log = logging.getLogger('iramuteq.layout')
60 class GraphPanelAfc(wx.Panel):
62 def __init__(self, parent, dico, list_graph, clnb, itempath = 'liste_graph_afc', coding = sys.getdefaultencoding()):
63 wx.Panel.__init__(self,parent)
68 self.itempath = itempath
69 self.parent = self.GetParent()
70 self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "Arial"))
74 self.list_graph = list_graph
75 self.TabCHD = self.parent.GetParent()
76 self.nb = self.TabCHD.GetParent()
77 self.ira = self.nb.GetParent()
78 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
79 afc_img = wx.Image(os.path.join(self.ira.images_path,'button_afc.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
80 self.butafc = wx.BitmapButton(self, -1, afc_img)
81 self.Bind(wx.EVT_BUTTON, self.afc_graph, self.butafc)
82 self.dirout = os.path.dirname(self.Dict['ira'])
85 for i in range(0,len(list_graph)):
86 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
87 filename, ext = os.path.splitext(list_graph[i][0])
88 if ext == '.svg' or ext == '.html':
89 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])))
91 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY), name=repr(i-b)))
92 self.listimg[-1].Bind(wx.EVT_RIGHT_DOWN, self.onrightclick)
93 if os.path.exists(os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')) :
94 txt = _("List of not plotted points : ") + '%s' % os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')
97 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1] + txt))
98 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = repr(i - b)))
102 self.list_graph = [graph for i, graph in enumerate(self.list_graph) if i not in todel]
103 self.param = { 'typegraph' : 0,
110 'do_select_chi_classe' : 0,
127 self.__set_properties()
130 def __set_properties(self):
131 self.panel_1.EnableScrolling(True,True)
132 #self.panel_1.SetSize((1000,1000))
133 self.panel_1.SetScrollRate(20, 20)
134 self.panel_1.SetFocus()
136 def __do_layout(self):
137 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
138 self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
139 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
140 self.sizer_2.Add(self.butafc, 0, 0, 0)
141 for i in range(0, len(self.listimg)):
142 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
143 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
144 self.sizer_3.Add(self.buts[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
145 self.Bind(wx.EVT_BUTTON, self.on_delete_image, self.buts[i])
146 self.panel_1.SetSizer(self.sizer_3)
147 self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
148 self.SetSizer(self.sizer_2)
150 def on_delete_image(self, event) :
151 image_id = int(event.GetEventObject().GetName())
152 image_path = self.list_graph[image_id][0]
153 message = _('This file will be delete : ') + '%s.\n' % os.path.join(self.dirout, image_path) + _('Are you sure ?')
154 dial = wx.MessageDialog(self, message, style = wx.YES_NO)
155 res = dial.ShowModal()
156 if res == wx.ID_YES :
158 log.info('delete image %i' % image_id)
159 oldimg = self.listimg.pop(image_id)
161 oldlab = self.labels.pop(image_id)
163 oldbut = self.buts.pop(image_id)
165 for i, but in enumerate(self.buts) :
167 self.listimg[i].SetName(repr(i))
168 todel = self.list_graph.pop(image_id)
169 os.remove(os.path.join(self.dirout, todel[0]))
170 print_liste(self.Dict[self.itempath], self.list_graph)
171 self.sizer_3.Fit(self.panel_1)
176 def onrightclick(self, event):
177 image_id = int(event.GetEventObject().GetName())
178 image_path = self.list_graph[image_id][0]
179 viewer = ImageViewer(self, {'tmpgraph' : os.path.join(self.dirout,image_path), 'svg': 'FALSE', 'wildcard': '*.*'}, self.labels[image_id].GetLabelText(), self.listimg[image_id].GetSize())
182 #print self.labels[image_id].GetLabelText()
184 def afc_graph(self,event):
185 #dirout = os.path.dirname(self.Dict['ira'])
186 dial = PrefGraph(self.parent,-1,self.param,'')
187 dial.CenterOnParent()
188 val = dial.ShowModal()
190 if dial.choix_format.GetSelection() == 0 :
194 typegraph = dial.choicetype.GetSelection()
199 if self.clnb <= 3 and typegraph == 1 :
205 while os.path.exists(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile)):
207 self.fileout = ffr(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile))
209 self.param = {'typegraph' : typegraph,
210 'width' : dial.spin1.GetValue(),
211 'height' : dial.spin2.GetValue(),
212 'what' : dial.choice1.GetSelection(),
213 'qui' : dial.choice2.GetSelection(),
214 'do_select_nb' : dial.check1.GetValue(),
215 'do_select_chi' : dial.check2.GetValue(),
216 'do_select_chi_classe' : dial.check_chic.GetValue(),
217 'select_nb' : dial.spin_nb.GetValue(),
218 'select_chi' : dial.spin_chi.GetValue(),
219 'nbchic' : dial.spin_nbchic.GetValue(),
220 'over' : dial.check3.GetValue(),
221 'cex_txt' : dial.check4.GetValue(),
222 'txt_min' : dial.spin_min.GetValue(),
223 'txt_max' : dial.spin_max.GetValue(),
224 'tchi' : dial.check_tchi.GetValue(),
225 'tchi_min' : dial.spin_min_tchi.GetValue(),
226 'tchi_max' : dial.spin_max_tchi.GetValue(),
227 'taillecar' : dial.spin3.GetValue(),
228 'facteur' : [dial.spin_f1.GetValue(),dial.spin_f2.GetValue(), dial.spin_f3.GetValue()],
230 'film' : str(dial.film.GetValue()).upper(),
231 'alpha' : dial.slider_sphere.GetValue(),
234 self.nb.parent = self.ira
235 self.DictPathOut = self.Dict
236 self.RscriptsPath = self.ira.RscriptsPath
239 """ % ffr(self.DictPathOut['RData'])
240 if self.itempath == 'liste_graph_afcf' :
243 afc_table <- afcf_table
244 chistabletot <- specfp
246 elif self.itempath == 'liste_graph_afct' :
249 afc_table <- afct_table
250 chistabletot <- spectp
252 txt += write_afc_graph(self)
253 filetmp = tempfile.mktemp()
254 with open(filetmp, 'w', encoding='utf8') as f :
256 pid = exec_rcode(self.ira.RPath, filetmp)
257 check_Rresult(self.ira, pid)
258 if self.param['typegraph'] != 1 :
260 if self.param['qui'] == 0 : value = 'actives'
261 if self.param['qui'] == 1 : value = 'supplémentaires'
262 if self.param['qui'] == 2 : value = 'étoilées'
263 if self.param['qui'] == 3 : value = 'classes'
265 if self.param['what'] == 0 : value = 'Coordonnées'
266 if self.param['what'] == 1 : value = 'Corrélations'
267 txt += value + ' - facteur %i / %i' % (self.param['facteur'][0], self.param['facteur'][1])
268 if self.param['do_select_nb'] : txt += ' - sélection de %i variables' % self.param['select_nb']
269 if self.param['do_select_chi'] : txt += ' - sélection des variables avec chi2 > %i ' % self.param['select_chi']
270 if self.param['over'] : txt += ' - Eviter les recouvrements'
271 if self.param['cex_txt'] : txt += ' - taille du texte proportionnel à la masse'
272 if self.param['tchi'] : txt += ' - taille du texte proportionnel au chi2 d\'association'
273 #list_graph = read_list_file(self.DictPathOut[self.itempath], self.coding)
274 if self.param['svg'] :
275 filename, ext = os.path.splitext(self.fileout)
276 self.fileout = filename + '.svg'
277 if self.param['typegraph'] == 2 :
278 parametres = {'gexffile' : self.fileout,
280 'nodemin': self.param['txt_min'],
281 'nodemax': self.param['txt_max'],
282 'bargraphw' : 60*int(self.param['clnb']),
284 web = WebExport(self.ira, parametres)
285 self.fileout = web.exportafc()
286 if self.param['typegraph'] == 3 :
287 fileout = os.path.join(os.path.basename(self.fileout), 'index.html')
289 fileout = os.path.basename(self.fileout)
290 self.list_graph.append([fileout, txt])
291 print_liste(self.DictPathOut[self.itempath], self.list_graph)
292 if self.param['svg'] or self.param['typegraph'] == 2:
293 self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, self.fileout, URL=self.fileout))
294 elif self.param['typegraph'] == 3 :
295 fileout = os.path.join(self.fileout,'index.html')
296 self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout))
298 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(self.fileout, wx.BITMAP_TYPE_ANY), name=repr(len(self.list_graph) - 1)))
299 self.listimg[-1].Bind(wx.EVT_RIGHT_DOWN, self.onrightclick)
300 self.sizer_3.Add( self.listimg[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
301 self.labels.append(wx.StaticText(self.panel_1,-1, txt))
302 self.sizer_3.Add(self.labels[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
303 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = repr(len(self.list_graph) - 1)))
304 self.sizer_3.Add(self.buts[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
305 self.sizer_3.Fit(self.panel_1)
308 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
309 # elif self.param['typegraph'] == 2 :
310 # parametres = {'gexffile' : self.fileout,
311 # 'titre': 'Le titre',
312 # 'nodemin': self.param['txt_min'],
313 # 'nodemax': self.param['txt_max'],
314 # 'bargraphw' : 60*int(self.param['clnb']),
316 # web = WebExport(self.ira, parametres)
317 # afcout = web.exportafc()
318 # dial = SimpleDialog(self.ira)
319 # dial.link.SetLabel(afcout)
320 # dial.link.SetURL(afcout)
325 class GraphPanel(wx.ScrolledWindow):
327 def __init__(self, parent, dico, list_graph, txt = '', style = wx.TAB_TRAVERSAL):
328 wx.ScrolledWindow.__init__(self, parent, style = style)
332 self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "Arial"))
335 self.dirout = os.path.dirname(self.Dict['ira'])
336 self.deb = wx.StaticText(self, -1, txt)
337 for i in range(0,len(list_graph)):
338 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
339 filename, ext = os.path.splitext(list_graph[i][0])
341 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])))
343 self.listimg.append(wx.StaticBitmap(self, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
344 self.labels.append(wx.StaticText(self, -1, list_graph[i][1]))
345 self.Bind(wx.EVT_MOTION, self.onMouseMove)
346 self.__set_properties()
349 def __set_properties(self):
350 self.EnableScrolling(True,True)
351 self.SetScrollRate(20, 20)
354 def __do_layout(self):
355 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
356 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
357 self.sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
358 self.sizer_1.Add(self.deb)
359 for i in range(0, len(self.listimg)):
360 self.sizer_1.Add(self.listimg[i], 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
361 self.sizer_1.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
362 self.sizer_2.Add(self.sizer_1, 1, wx.EXPAND, 0)
363 self.SetSizer(self.sizer_1)
364 self.sizer_1.Fit(self)
366 def onMouseMove(self, event):
369 def open_antiprofil(panel, AntiProfile, encoding, title = _("Antiprofiles"), translation = False, lems=None) :
371 DictAnti = ReadProfileAsDico(AntiProfile, True, encoding)
373 DictAnti = AntiProfile
374 panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
375 for i in range(0, panel.parametres['clnb']):
376 tabantiprofile = ProfListctrlPanel(panel.parent, panel, DictAnti[str(i + 1)], True, i + 1, translation = translation)
377 tabantiprofile.lems = lems
378 panel.AntiProfNB.AddPage(tabantiprofile, 'classe %s' % str(i + 1))
379 panel.TabChdSim.AddPage(panel.AntiProfNB, title)
381 def getlemgram(corpus, lem) :
382 if not lem[6] in corpus.lems :
385 return corpus.lems[lem[6]].gram
390 def __init__(self, parent, corpus, parametres, Alceste=False):
394 self.parametres = parametres
395 self.pathout = PathOut(parametres['ira'])
396 self.pathout.basefiles(ChdTxtPathOut)
397 DictPathOut = self.pathout
398 self.DictPathOut = DictPathOut
399 self.dictpathout = DictPathOut
400 self.Alceste = Alceste
401 Profile = DictPathOut['PROFILE_OUT']
402 AntiProfile = DictPathOut['ANTIPRO_OUT']
403 # self.encoding = self.parametres['encoding']
404 if isinstance(self.corpus, Corpus) :
405 self.corpus.make_ucecl_from_R(self.pathout['uce'])
406 corpname = self.corpus.parametres['corpus_name']
408 corpname = self.corpus.parametres['matrix_name']
409 if os.path.exists(self.pathout['analyse.db']) :
410 self.corpus.read_tableau(self.pathout['analyse.db'])
411 clnb = parametres['clnb']
412 dlg = progressbar(self, maxi = 4 + clnb)
414 print('lecture des profils')
415 dlg.Update(2, _("Reading profiles"))
416 DictProfile = ReadProfileAsDico(Profile, Alceste)
417 self.DictProfile = DictProfile
418 self.cluster_size = []
420 for i in range(0, clnb) :
421 clusternames[i] = ' '.join(['%i' % (i + 1), _('Cluster'), '%i' % (i + 1)])
422 if os.path.exists(self.pathout['classes_names.txt']) :
423 with open(self.pathout['classes_names.txt'], 'r', encoding='utf8') as f :
424 clusternames_ = f.read()
425 clusternames_ = dict([[i, ' '.join([repr(i + 1), line])] for i, line in enumerate(clusternames_.splitlines())])
426 clusternames.update(clusternames_)
427 #DictAnti = ReadProfileAsDico(self, AntiProfile, Alceste, self.encoding)
429 # preparation de l'affichage
431 panel = wx.Panel(parent, -1)
432 sizer1 = wx.BoxSizer(wx.VERTICAL)
433 if os.path.exists(DictPathOut['pre_rapport']):
434 with open(DictPathOut['pre_rapport'], 'r', encoding='utf8') as f :
439 # panel.chd_toolbar = wx.ToolBar(panel, -1, wx.DefaultPosition, wx.DefaultSize, wx.TB_FLAT | wx.TB_NODIVIDER)
440 # panel.chd_toolbar.SetToolBitmapSize(wx.Size(16, 16))
441 if isinstance(self.corpus, Corpus) :
442 panel.corpus = self.corpus
444 panel.tableau = self.corpus
445 #self.parent.tableau = panel.tableau
446 panel.dictpathout = self.DictPathOut
447 panel.pathout = self.DictPathOut
448 panel.parent = self.parent
449 panel.DictProfile = self.DictProfile
450 panel.cluster_size = self.cluster_size
451 panel.debtext = self.debtext
452 # self.ID_rapport = wx.NewId()
453 # #rap_img = wx.Image(os.path.join(self.parent.images_path,'icone_rap_16.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
454 # #panel.chd_toolbar.AddLabelTool(self.ID_rapport, "rapport", rap_img, shortHelp=u"Produire le rapport", longHelp=u"Exporter un rapport en texte simple")
455 # butrap = wx.Button(panel.chd_toolbar, self.ID_rapport, u"Rapport ")
456 # panel.chd_toolbar.AddControl(butrap)
457 # panel.chd_toolbar.Realize()
458 # sizer1.Add(panel.chd_toolbar,0, wx.EXPAND, 5)
459 # self.TabChdSim = wx.aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
460 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
461 panel.TabChdSim = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
462 #panel.TabChdSim = LB.LabelBook(panel, -1, agwStyle = INB_TOP|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
463 panel.TabChdSim.SetAGWWindowStyleFlag(notebook_flags)
464 panel.TabChdSim.SetArtProvider(aui.ChromeTabArt())
465 sizer1.Add(panel.TabChdSim,10, wx.EXPAND, 5)
466 panel.SetSizer(sizer1)
468 if isinstance(self.corpus, Corpus) :
469 panel.TabChdSim.corpus = corpus
470 panel.TabChdSim.corpus.dictpathout = self.DictPathOut
472 panel.TabChdSim.tableau = corpus
473 panel.TabChdSim.tableau.dictpathout = self.DictPathOut
474 panel.parametres = self.parametres
476 self.notenb = self.parent.nb.GetPageCount()
477 if os.path.exists(self.DictPathOut['liste_graph_chd']) :
478 list_graph = read_list_file(self.DictPathOut['liste_graph_chd'])
479 CHD = GraphPanelDendro(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
480 panel.TabChdSim.AddPage(CHD,'CHD')
481 # panel.ProfNB.SetArtProvider(aui.ChromeTabArt())
482 # panel.ProfNB = LB.LabelBook(panel, -1, agwStyle = INB_LEFT|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
483 # panel.ProfNB = wx.Listbook(self.parent, -1, style = wx.BK_DEFAULT)
484 # panel.ProfNB = wx.Treebook(self.parent, -1, style = wx.BK_DEFAULT)
485 # self.ProfNB.SetTabCtrlHeight(100)
486 # panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
487 if os.path.exists(DictPathOut['prof_seg']) :
488 prof_seg = ReadProfileAsDico(DictPathOut['prof_seg'], False)
489 self.prof_seg_nb = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
490 panel.ProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
491 notebook_flags |= aui.AUI_NB_WINDOWLIST_BUTTON
492 panel.ProfNB.SetAGWWindowStyleFlag(notebook_flags)
493 for i in range(0, clnb):
494 self.cluster_size.append(DictProfile[str(i + 1)][0][0:3])
495 if isinstance(self.corpus, Corpus) :
496 DictProfile[str(i + 1)][1:] = [val[0:5] + [getlemgram(self.corpus, val)] + val[6:] for val in DictProfile[str(i + 1)][1:]]
497 dlg.Update(3+i, 'Classe %i' %(i+1))
498 ind = '/'.join(DictProfile[str(i + 1)][0][0:2]).strip()
499 indpour = '\n'.join([ind, DictProfile[str(i + 1)][0][2]])
500 self.tabprofile = ProfListctrlPanel(self.parent, self.panel, DictProfile[str(i + 1)], Alceste, i + 1)
501 #self.tabantiprofile = ProfListctrlPanel(self.parent, self, DictAnti[str(i + 1)], Alceste, i + 1)
502 panel.ProfNB.AddPage(self.tabprofile, clusternames[i] + '\n%s%%' % indpour, True)
503 panel.ProfNB.SetPageTextColour(i, '#890909')
504 panel.ProfNB.SetRenamable(i, True)
505 # panel.AntiProfNB.AddPage(self.tabantiprofile, 'classe %s' % str(i + 1))
506 if os.path.exists(DictPathOut['prof_seg']) :
507 self.tab_prof_seg = ProfListctrlPanel(self.parent, self, prof_seg[str(i + 1)], False, i + 1)
508 self.prof_seg_nb.AddPage(self.tab_prof_seg, _("Cluster") + ' %i' % (i + 1))
509 panel.ProfNB.SetSelection(0)
511 self.TabAFC = aui.AuiNotebook(panel.TabChdSim, -1, wx.DefaultPosition)
513 list_graph=read_list_file(DictPathOut['liste_graph_afc'])
514 self.tabAFCGraph = GraphPanelAfc(self.TabAFC, DictPathOut, list_graph, self.clnb)
515 self.TabAFC.AddPage(self.tabAFCGraph, _("CA"))
516 if os.path.exists(self.DictPathOut['afc_facteur']) :
517 dictrow, first = ReadList(self.DictPathOut['afc_facteur'])
518 self.TabAFC_facteur = ListForSpec(self.parent, parametres, dictrow, first[1:])
519 # dictrow, first = ReadList(self.DictPathOut['afc_row'], self.encoding)
520 # self.TabAFC_ligne = ListForSpec(self.parent, self.parametres, dictrow, first)
521 # dictrow, first = ReadList(self.DictPathOut['afc_col'], self.encoding)
522 # self.TabAFC_colonne = ListForSpec(parent, self.parametres, dictrow, first)
523 self.TabAFC.AddPage(self.TabAFC_facteur, _("Factor"))
524 # self.TabAFC.AddPage(self.TabAFC_colonne, 'Colonnes')
525 # self.TabAFC.AddPage(self.TabAFC_ligne, 'Lignes')
526 sizer_3 = wx.BoxSizer(wx.VERTICAL)
527 self.parent.nb_panel_2 = wx.Panel(panel.TabChdSim, -1)
528 self.parent.button_simi = wx.Button(self.parent.nb_panel_2, -1, "Voyager")
529 self.parent.simi3dpanel = simi3d(self.parent.nb_panel_2, -1)
530 sizer_3.Add(self.parent.simi3dpanel, 1, wx.EXPAND, 0)
531 sizer_3.Add(self.parent.button_simi, 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
532 self.parent.nb_panel_2.SetSizer(sizer_3)
533 self.TabAFC.AddPage(self.parent.nb_panel_2, _("3D graph"))
534 self.parent.Bind(wx.EVT_BUTTON, self.onsimi, self.parent.button_simi)
535 panel.TabChdSim.AddPage(panel.ProfNB, _("Profiles"))
536 # panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')
537 dlg.Update(4 + self.clnb, 'Affichage...')
539 panel.TabChdSim.AddPage(self.TabAFC, _("CA"))
540 if os.path.exists(DictPathOut['prof_seg']) :
541 panel.TabChdSim.AddPage(self.prof_seg_nb, _("Repeated segments profiles"))
542 # panel.Bind(wx.EVT_BUTTON, self.ongetrapport, id = self.ID_rapport)
543 if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenchi2.csv')) :
544 self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenchi2.csv')
546 if os.path.exists(self.dictpathout['translations.txt']) :
547 with open(self.dictpathout['translations.txt'], 'r', encoding='utf8') as f:
549 translist = [line.split('\t') for line in translist.splitlines()]
550 for line in translist :
552 panel.TabChdSim.SetSelection(0)
553 self.parent.nb.AddPage(panel, _("Clustering") + ' - %s' % corpname)
554 self.parent.ShowTab(True)
555 self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
556 # for pane in self.parent._mgr.GetAllPanes() :
557 # if isinstance(pane.window, aui.AuiNotebook):
559 # nb.SetAGWWindowStyleFlag(notebook_flags)
560 # nb.SetArtProvider(aui.ChromeTabArt())
562 self.parent._mgr.Update()
564 def opentrans(self, trans) :
565 prof = ReadProfileAsDico(self.dictpathout[trans[0]], False)
566 with open(self.dictpathout[trans[1]], 'r', encoding='utf8') as f :
568 lems = [line.split('\t') for line in lems.splitlines()]
570 open_antiprofil(self.panel, prof, 'utf8', title = trans[0], translation=True, lems=lems)
571 self.panel.lems = lems
572 self.panel.TabChdSim.SetSelection(self.panel.TabChdSim.GetPageCount() - 1)
574 def onsimi(self,event):
575 outfile = print_simi3d(self)
576 error = exec_rcode(self.parent.RPath, outfile, wait = True)
578 def onclusterstat(self, evt) :
579 dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': 'Stat par classe'})
580 dial.fbb.SetValue( os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'stat_par_classe.csv'))
581 dial.CenterOnParent()
582 res = dial.ShowModal()
584 fileout = dial.fbb.GetValue()
586 self.corpus.get_stat_by_cluster(fileout)
588 dlg = wx.MessageDialog(self.parent, msg, _("Stat by cluster"), wx.OK | wx.ICON_INFORMATION)
590 if dlg.ShowModal() == wx.ID_OK :
593 #def onsearchf(self, evt) :
594 # if 'FrameSearch' not in dir(self.panel) :
595 # self.panel.FrameSearch = SearchFrame(self.parent, -1, "Rechercher...", self.corpus)
596 # self.panel.FrameSearch.Show()
598 def PrintRapport(self, corpus, parametres, istxt = True):
602 |i|R|a|M|u|T|e|Q| - %s
606 """ % datetime.datetime.now().ctime()
608 totocc = corpus.gettotocc()
609 txt += ': '.join([_('Number of texts'), '%i%s' % (corpus.getucinb(), sep)])
610 txt += ': '.join([_('Number of text segments'), '%i%s' % (corpus.getucenb(), sep)])
611 txt += ': '.join([_('Number of forms'), '%i%s' % (len(corpus.formes), sep)])
612 txt += ': '.join([_('Number of occurrences'), '%i%s' % (totocc, sep)])
613 #txt += 'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
614 txt += ': '.join([_('Number of lemmas'), '%i%s' % (len(corpus.lems), sep)])
615 txt += ': '.join([_('Number of active forms'), '%i%s' % (corpus.getactivesnb(1), sep)])
616 txt += ': '.join([_('Number of supplementary forms'), '%i%s' % (corpus.getactivesnb(2), sep)])
617 txt += ' >= '.join([_('Number of active forms with a frequency'), '%i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)])
618 txt += ': '.join([_('Mean of forms by segment'), '%f%s' % (float(totocc) / float(corpus.getucenb()), sep)])
619 if 'tailleuc1' in parametres :
620 if parametres['classif_mode'] == 0 :
621 txt += ': '.join([_('Size of rst1 / rst2'), '%i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)])
623 self.Ucenb = self.nbind
624 txt += ': '.join([_('Number of lines'), '%i%s' % (self.nbind, sep)])
625 txt += ': '.join([_('Number of clusters'), '%i%s' % (self.clnb, sep)])
627 txt += ': '.join([_('Number of clusters'), '%i%s' % (parametres['clnb'], sep)])
628 if parametres['classif_mode'] == 0 or parametres['classif_mode'] == 1 :
629 txt += ' '.join(['%i' % sum([len(cl) for cl in corpus.lc]), _('segments classified on'), '%i (%.2f%%)%s' % (corpus.getucenb(), (float(sum([len(cl) for cl in corpus.lc])) / float(corpus.getucenb())) * 100, sep)])
630 elif self.parametres['classif_mode'] == 2 :
631 txt += ' '.join(['%i' % sum([len(cl) for cl in corpus.lc]), _('texts classified on'), '%i (%.2f%%)%s' % (corpus.getucinb(), (float(sum([len(cl) for cl in corpus.lc]))) / float(corpus.getucinb()) * 100, sep)])
633 txt += ' '.join(['%i' % self.ucecla, _('line classified on'), '%i (%.2f%%)%s' % (self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)])
635 txt += ''.join([sep, '###########################', sep, _('time'), ' : %s' % parametres.get('time', ''), sep, '###########################', sep])
636 # ecriture du resultat dans le fichier
637 with open(self.pathout['pre_rapport'], 'w', encoding='utf8') as f :
641 class SashList(wx.Panel) :
643 def __init__(self, parent) :
644 wx.Panel.__init__(self, parent, -1)
647 #self.gparent=gparent
651 # A window to the left of the client window
652 #self.listlex = listlex
653 self.leftwin1 = wx.SashLayoutWindow(
654 self, -1, wx.DefaultPosition, (200, 300),
655 wx.NO_BORDER|wx.SW_3D
657 self.leftwin1.SetDefaultSize((120, 1000))
658 self.leftwin1.SetOrientation(wx.LAYOUT_VERTICAL)
659 self.leftwin1.SetAlignment(wx.LAYOUT_LEFT)
660 self.leftwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
661 self.leftwin1.SetSashVisible(wx.SASH_RIGHT, True)
662 self.leftwin1.SetExtraBorderSize(10)
663 #textWindow = wx.TextCtrl(
664 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
665 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
667 #textWindow.SetValue("A sub window")
668 self.leftWindow1 = self.leftwin1
669 winids.append(self.leftwin1.GetId())
670 rightwin1 = wx.SashLayoutWindow(
671 self, -1, wx.DefaultPosition, (200, 300),
672 wx.NO_BORDER|wx.SW_3D
674 rightwin1.SetDefaultSize((120, 1000))
675 rightwin1.SetOrientation(wx.LAYOUT_VERTICAL)
676 rightwin1.SetAlignment(wx.LAYOUT_LEFT)
677 rightwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
678 rightwin1.SetSashVisible(wx.SASH_RIGHT, True)
679 rightwin1.SetExtraBorderSize(10)
680 #textWindow = wx.TextCtrl(
681 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
682 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
684 #textWindow.SetValue("A sub window")
685 self.rightwin1 = rightwin1
686 winids.append(rightwin1.GetId())
691 def __init__(self, page):
693 parametres = self.page.parametres
694 ira = wx.GetApp().GetTopWindow()
695 tgenpath = os.path.join(parametres['pathout'], 'tgen.csv')
696 self.page.tgens, etoiles = ReadList(parametres['tgenspec'], ira.syscoding, sep="\t")
697 tgen = TGen(path = tgenpath, encoding = 'UTF-8')
699 tgenlempath = os.path.join(parametres['pathout'], 'tgenlemchi2.csv')
700 if os.path.exists(tgenlempath) :
701 self.page.parametres['tgenlemspec'] = tgenlempath
702 self.page.tgenlem, etoiles = ReadList(self.page.parametres['tgenlemspec'], ira.syscoding, sep="\t")
705 if 'TabChdSim' in dir(page) :
706 page = page.TabChdSim
707 for i in range(page.GetPageCount()) :
708 tab = page.GetPage(i)
709 if 'gparent' in dir(tab) :
710 if tab.gparent is not None :
711 gparent = tab.gparent
712 if 'tgen' in dir(tab) :
717 self.page.tgentab.RefreshData(self.page.tgens)
718 self.page.tgentab.tgens = tgen.tgen
719 self.page.tgentab.tgenlem = self.page.tgenlem
722 self.page.tgentab = ListForSpec(ira, gparent, self.page.tgens, etoiles[1:])
723 self.page.tgentab.tgen = True
724 self.page.tgentab.tgens = tgen.tgen
725 if os.path.exists(tgenlempath) :
726 self.page.tgentab.tgenlem = self.page.tgenlem
727 page.AddPage(self.page.tgentab, _('Tgens Specificities'))
728 page.SetSelection(page.GetPageCount() - 1)
733 def __init__(self, ira, corpus, parametres):
734 self.pathout = PathOut(dirout = parametres['pathout'])
736 self.dictpathout = StatTxtPathOut(parametres['pathout'])
737 #self.corpus.read_corpus_from_shelves(self.corpus.dictpathout['db'])
739 self.corpus.parametres['syscoding'] = 'UTF8'
740 self.encoding = self.corpus.parametres['syscoding']
741 self.parametres = parametres
742 self.DictSpec, first = ReadList(self.dictpathout['tablespecf'], self.corpus.parametres['syscoding'])
743 if os.path.exists(self.pathout['banalites.csv']) :
744 self.dictban, firstban = ReadList(self.pathout['banalites.csv'], self.corpus.parametres['syscoding'])
745 self.DictType, firstt = ReadList(self.dictpathout['tablespect'], self.corpus.parametres['syscoding'])
746 self.DictEff, firsteff = ReadList(self.dictpathout['tableafcm'], self.corpus.parametres['syscoding'])
747 self.DictEffType, firstefft = ReadList(self.dictpathout['tabletypem'], self.corpus.parametres['syscoding'])
748 self.DictEffRelForme, firsteffrelf = ReadList(self.dictpathout['eff_relatif_forme'], self.corpus.parametres['syscoding'])
749 self.DictEffRelType, firsteffrelt = ReadList(self.dictpathout['eff_relatif_type'], self.corpus.parametres['syscoding'])
750 self.etoiles = firsteff[1:]
751 #sash = SashList(ira.nb)
752 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
753 self.TabStat.parametres = parametres
754 self.ListPan = ListForSpec(ira, self, self.DictSpec, self.etoiles)
755 if os.path.exists(self.pathout['banalites.csv']) :
756 self.listban = ListForSpec(ira, self, self.dictban, ['eff'] + self.etoiles, usefirst = True)
757 #self.ListPan2 = ListForSpec(sash.rightwin1, self, self.DictSpec, first)
758 self.ListPant = ListForSpec(ira, self, self.DictType, self.etoiles)
759 self.ListPanEff = ListForSpec(ira, self, self.DictEff, self.etoiles)
760 self.ListPanEffType = ListForSpec(ira, self, self.DictEffType, self.etoiles)
761 self.ListPanEffRelForme = ListForSpec(ira, self, self.DictEffRelForme, self.etoiles)
762 self.ListPanEffRelType = ListForSpec(ira, self, self.DictEffRelType, self.etoiles)
763 self.TabStat.AddPage(self.ListPan, _('Forms'))
764 if os.path.exists(self.pathout['banalites.csv']) :
765 self.TabStat.AddPage(self.listban, _('Banal forms'))
766 self.TabStat.AddPage(self.ListPant, _('POS'))
767 self.TabStat.AddPage(self.ListPanEff, _('Forms frequencies'))
768 self.TabStat.AddPage(self.ListPanEffType, _('POS frequencies'))
769 self.TabStat.AddPage(self.ListPanEffRelForme, _('Forms relative frequencies'))
770 self.TabStat.AddPage(self.ListPanEffRelType, _('POS relative frequencies'))
771 if self.parametres['clnb'] > 2 :
772 self.TabAFC = aui.AuiNotebook(self.TabStat, -1, wx.DefaultPosition)
773 list_graph=read_list_file(self.dictpathout['liste_graph_afcf'], encoding = self.encoding)
774 self.tabAFCGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afcf', coding = self.encoding)
775 self.TabAFC.AddPage(self.tabAFCGraph, _('CA forms'))
776 list_graph=read_list_file(self.dictpathout['liste_graph_afct'], encoding = self.encoding)
777 self.tabAFCTGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afct', coding=self.encoding)
778 self.TabAFC.AddPage(self.tabAFCTGraph, _('CA POS'))
779 self.TabStat.AddPage(self.TabAFC, _('CA'))
780 ira.nb.AddPage(self.TabStat, ' - '.join([_('Specificities'), self.parametres['name']]))
782 self.TabStat.corpus = self.corpus
783 self.TabStat.etoiles = self.etoiles
784 if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenspec.csv')) :
785 self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenspec.csv')
786 TgenLayout(self.TabStat)
787 self.TabStat.SetSelection(0)
788 ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
789 ira.ShowAPane("Tab_content")
794 def __init__(self, ira, corpus, parametres):
795 self.pathout = PathOut(dirout = parametres['pathout'])
798 self.read_result() # qui va définir la propriété self.result
799 self.parametres = parametres
800 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
801 self.TabStat.parametres = parametres
802 self.TabStat.corpus = corpus
803 self.TabStat.pathout = self.pathout
804 # CHD = GraphPanel(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
805 # panel.TabChdSim.AddPage(CHD,'CHD')
806 #self.TabStatTot = wx.TextCtrl(self.TabStat, -1, style=wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2)
807 list_graph = [['zipf.png', 'zipf']]
808 self.TabStatTot = GraphPanel(ira.nb, self.pathout, list_graph, self.result['glob'])
809 self.TabStat.AddPage(self.TabStatTot, _('Abstract'))
810 dictlabel = {'total' : _('Total'),
811 'formes_actives' : _('Actives forms'),
812 'formes_supplémentaires': _('Supplementary forms'),
813 'hapax' : _('Hapax'),
815 for item in self.result:
817 datam = [['forme', 'nb']] #???
818 self.ListPan = ListPanel(ira, self, self.result[item])
819 self.TabStat.AddPage(self.ListPan, dictlabel[item])
820 ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
821 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
822 ira.ShowAPane("Tab_content")
824 def read_result(self) :
825 lcle = {'total' :'total.csv', 'formes_actives':'formes_actives.csv', 'formes_supplémentaires':'formes_supplémentaires.csv', 'hapax': 'hapax.csv'}
828 with open(self.pathout[lcle[key]], 'r', encoding='utf-8') as f :
829 self.result[key] = [line.split(';') for line in f.read().splitlines()]
830 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
831 with open(self.pathout['glob.txt'], 'r', encoding='utf-8') as f :
832 self.result['glob'] = f.read()
835 class GraphPanelDendro(wx.Panel):
837 def __init__(self,parent, dico, list_graph, txt=False):
838 wx.Panel.__init__(self,parent)
840 self.dictpathout = dico
841 self.dirout = os.path.dirname(self.dictpathout['ira'])
842 self.list_graph = list_graph
843 self.parent = self.GetParent()#parent
844 self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "Arial")) #modifié
847 self.tabchd = self.parent.GetParent()
848 self.ira = self.tabchd.GetParent()
849 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
850 self.panel_1.SetBackgroundColour('white')
851 self.deb = wx.StaticText(self.panel_1, -1, txt)
852 dendro_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
853 dendro_liste_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro_liste.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
854 dendro_cloud_img= wx.Image(os.path.join(self.ira.images_path,'but_dendro_cloud.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
855 self.butdendro = wx.BitmapButton(self, -1, dendro_img)
856 self.butdendrotexte = wx.BitmapButton(self, -1, dendro_liste_img)
857 self.butdendrocloud = wx.BitmapButton(self, -1, dendro_cloud_img)
858 for i in range(0,len(list_graph)):
859 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
860 filename, ext = os.path.splitext(list_graph[i][0])
862 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])))
864 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
865 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
866 self.__set_properties()
869 def __set_properties(self):
870 self.panel_1.EnableScrolling(True,True)
871 #self.panel_1.SetSize((1000,1000))
872 self.panel_1.SetScrollRate(20, 20)
873 self.panel_1.SetFocus()
874 self.Bind(wx.EVT_BUTTON, self.ondendro, self.butdendro)
875 self.Bind(wx.EVT_BUTTON, self.ondendrotexte, self.butdendrotexte)
876 self.Bind(wx.EVT_BUTTON, self.ondendrocloud, self.butdendrocloud)
877 self.param = {'width' : 700,
881 'taille_classe' : True,
885 self.type_dendro = [ "phylogram", "cladogram", "fan", "unrooted", "radial" ]
887 def __do_layout(self):
888 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
889 self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
890 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
891 self.sizer_3.Add(self.deb)
892 self.sizer_1.Add(self.butdendro, 0, 0, 0)
893 self.sizer_1.Add(self.butdendrotexte, 0, 0, 0)
894 self.sizer_1.Add(self.butdendrocloud, 0, 0, 0)
895 for i in range(0, len(self.listimg)):
896 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
897 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
898 self.panel_1.SetSizer(self.sizer_3)
899 self.sizer_2.Add(self.sizer_1, 0, wx.EXPAND, 0)
900 self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
901 self.SetSizer(self.sizer_2)
903 def make_param(self, dial):
904 self.param['width'] = dial.m_spinCtrl2.GetValue()
905 self.param['height'] = dial.m_spinCtrl1.GetValue()
906 self.param['type_dendro'] = dial.m_choice1.GetSelection()
907 self.param['svg'] = dial.choice_format.GetSelection()
908 if self.param['typedendro'] == 'classique' :
909 self.param['color_nb'] = dial.m_radioBox1.GetSelection()
910 self.param['taille_classe'] = dial.m_checkBox1.GetValue()
911 self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
912 if self.param.get('translation', False) :
913 if dial.trans.GetSelection() == 0 :
914 del self.param['translation']
916 self.param['translation'] = self.param['translation'][dial.trans.GetSelection()-1][1]
918 def make_dendro(self, dendro = 'simple') :
919 if self.param['svg'] :
923 while os.path.exists(os.path.join(self.dirout, 'dendrogramme_' + str(self.graphnb)+typefile)) :
925 fileout = ffr(os.path.join(self.dirout,'dendrogramme_' + str(self.graphnb)+typefile))
926 width = self.param['width']
927 height = self.param['height']
928 type_dendro = self.type_dendro[self.param['type_dendro']]
929 if self.param['taille_classe'] :
933 if self.param['color_nb'] == 0 :
937 if self.param['type_tclasse'] == 0 :
941 if self.param['svg'] :
945 dendro_path = self.dictpathout['Rdendro']
946 classe_path = self.dictpathout['uce']
951 classes <- read.csv2("%s", row.names=1)
952 classes <- classes[,1]
953 """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']), ffr(classe_path))
954 if dendro == 'simple' :
956 open_file_graph("%s", width=%i, height=%i, svg=%s)
957 plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
958 """ % (ffr(fileout), width, height, svg, type_dendro, histo, bw, tclasse)
959 elif dendro == 'texte' :
963 if (is.null(debsup)) {
966 chistable <- chistabletot[1:(debsup-1),]
967 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']))
968 if self.param.get('translation', False) :
970 rn <- read.csv2("%s", header=FALSE, sep='\t')
971 rnchis <- row.names(chistable)
972 commun <- intersect(rnchis, unique(rn[,2]))
973 idrnchis <- sapply(commun, function(x) {which(rnchis==x)})
974 idrn <- sapply(commun, function(x) {which(as.vector(rn[,2])==x)[1]})
975 rownames(chistable)[idrnchis] <- as.vector(rn[idrn,1])
976 """ % ffr(self.param['translation'])
978 open_file_graph("%s", width=%i, height=%i, svg = %s)
979 plot.dendro.prof(tree.cut1$tree.cl, classes, chistable, nbbycl = 60, type.dendro="%s", bw=%s, lab=NULL)
980 """ % (ffr(fileout), width, height, svg, type_dendro, bw)
981 elif dendro == 'cloud' :
985 if (is.null(debsup)) {
988 chistable <- chistabletot[1:(debsup-1),]
989 open_file_graph("%s", width=%i, height=%i, svg=%s)
990 plot.dendro.cloud(tree.cut1$tree.cl, classes, chistable, nbbycl = 300, type.dendro="%s", bw=%s, lab=NULL)
991 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
992 tmpfile = tempfile.mktemp()
993 # ecriture du fichier de script à éxécuter
994 with open(tmpfile, 'w', encoding='utf8') as f :
997 busy = wx.BusyInfo(_("Please wait..."), self.parent)
999 error = exec_rcode(self.ira.RPath, tmpfile, wait=True)
1002 check_Rresult(self.ira, error)
1003 self.list_graph.append([fileout, 'Dendrogramme CHD1 - %s' % type_dendro])
1004 print_liste(self.dictpathout['liste_graph_chd'], self.list_graph)
1005 if self.param['svg'] :
1006 self.sizer_3.Add(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1008 self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1009 self.sizer_3.Add(wx.StaticText(self.panel_1,-1, 'Dendrogramme CHD1 - %s' % type_dendro), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1010 self.sizer_3.Fit(self.panel_1)
1012 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
1015 def ondendro(self, evt):
1016 self.param['typedendro'] = 'classique'
1017 dial = PrefDendro(self.ira, self.param)
1018 val = dial.ShowModal()
1019 if val == wx.ID_OK :
1020 self.make_param(dial)
1023 def ondendrotexte(self, evt):
1024 self.param['typedendro'] = 'texte'
1025 if os.path.exists(self.dictpathout['translations.txt']) :
1026 with codecs.open(self.dictpathout['translations.txt'], 'r', 'utf8') as f :
1029 trans = [line.split('\t')[1] for line in content.splitlines()]
1030 trans = [[val, self.dictpathout[val]] for val in trans]
1031 self.param['translation'] = trans
1032 dial = PrefDendro(self.ira, self.param)
1033 val = dial.ShowModal()
1034 if val == wx.ID_OK :
1035 self.make_param(dial)
1036 self.make_dendro(dendro = 'texte')
1038 def ondendrocloud(self, evt):
1039 self.param['typedendro'] = 'cloud'
1040 dial = PrefDendro(self.ira, self.param)
1041 val = dial.ShowModal()
1042 if val == wx.ID_OK :
1043 self.make_param(dial)
1044 self.make_dendro(dendro = 'cloud')
1049 def __init__(self, ira, parametres) :
1050 #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)
1051 self.panel = CopusPanel(ira, parametres)
1052 ira.nb.AddPage(self.panel, 'Description %s' % parametres['corpus_name'])
1053 #self.text.write(DoConf().totext(parametres))
1054 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
1055 ira.ShowAPane("Tab_content")
1060 def __init__(self, ira, matrix):
1061 #self.parent.content = self.csvtable
1062 self.sheet = MySheet(ira.nb)
1063 ira.nb.AddPage(self.sheet, matrix.parametres['matrix_name'])
1064 self.sheet.Populate(matrix.csvtable)
1065 self.sheet.parametres = matrix.parametres
1066 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
1067 ira.ShowAPane("Tab_content")
1070 class CopusPanel(wx.Panel) :
1072 def __init__(self, parent, parametres) :
1073 wx.Panel.__init__ ( self, parent, id = wx.ID_ANY, pos = wx.DefaultPosition, size = wx.Size( 500,300 ), style = wx.TAB_TRAVERSAL )
1074 self.parametres = parametres
1075 fgSizer5 = wx.FlexGridSizer( 0, 2, 0, 0 )
1076 fgSizer5.SetFlexibleDirection( wx.BOTH )
1077 fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )
1078 self.fgSizer5 = fgSizer5
1079 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, _("Description of corpus"), wx.DefaultPosition, wx.DefaultSize, 0 )
1080 self.m_staticText18.Wrap( -1 )
1081 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1082 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, "", wx.DefaultPosition, wx.DefaultSize, 0 )
1083 self.m_staticText19.Wrap( -1 )
1084 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1085 self.m_staticText20 = wx.StaticText( self, wx.ID_ANY, "Nom", wx.DefaultPosition, wx.DefaultSize, 0 )
1086 self.m_staticText20.Wrap( -1 )
1087 fgSizer5.Add( self.m_staticText20, 0, wx.ALL, 5 )
1088 self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, parametres['corpus_name'], wx.DefaultPosition, wx.DefaultSize, 0 )
1089 self.m_staticText21.Wrap( -1 )
1090 fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )
1091 description = {'lang' : _('Language'),
1092 'encoding' : _('Characters set'),
1093 'ucinb' : _('Number of texts'),
1094 'ucenb' : _('Number of text segments'),
1095 'formesnb' : _('Number of forms'),
1096 'hapax' : _('Number of hapax'),
1098 keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']
1099 self.addkeys(keys, description)
1100 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, "Paramètres", wx.DefaultPosition, wx.DefaultSize, 0 )
1101 self.m_staticText18.Wrap( -1 )
1102 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1103 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, "", wx.DefaultPosition, wx.DefaultSize, 0 )
1104 self.m_staticText19.Wrap( -1 )
1105 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1106 keys = ['ucemethod', 'ucesize', 'keep_caract', 'expressions']
1107 self.addkeys(keys, description)
1108 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, "Statistiques", wx.DefaultPosition, wx.DefaultSize, 0 )
1109 self.m_staticText18.Wrap( -1 )
1110 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1111 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, "", wx.DefaultPosition, wx.DefaultSize, 0 )
1112 self.m_staticText19.Wrap( -1 )
1113 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1114 keys = ['ucinb', 'ucenb', 'occurrences', 'formesnb', 'hapax']
1115 self.addkeys(keys, description)
1116 self.SetSizer( fgSizer5 )
1119 def addkeys(self, keys, description) :
1121 option = self.parametres.get(key,'non défini')
1122 if isinstance(option, int) :
1123 option = repr(option)
1124 text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
1126 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1127 text = wx.StaticText( self, wx.ID_ANY, option, wx.DefaultPosition, wx.DefaultSize, 0 )
1129 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1132 class DefaultTextLayout :
1134 def __init__(self, ira, corpus, parametres, cmd = False) :
1135 self.pathout = PathOut(dirout = parametres['pathout'])
1138 self.parametres = parametres
1139 self.corpus = corpus
1143 def dolayout(self, cmd) :
1144 log.info('no layout yet')
1147 class WordCloudLayout(DefaultTextLayout):
1150 self.pathout.basefiles(simipath)
1151 self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1152 if self.parametres['svg'] :
1153 list_graph = [['nuage_1.svg', 'Nuage']]
1155 list_graph = [['nuage_1.png', 'Nuage']]
1156 self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, list_graph)
1157 self.Tab.AddPage(self.TabStatTot, 'Nuage')
1158 self.Tab.corpus = self.corpus
1159 self.Tab.parametres = self.parametres
1160 self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
1161 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1162 self.ira.ShowAPane("Tab_content")
1165 class LabbeLayout(DefaultTextLayout):
1168 self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1169 #if self.parametres['svg'] :
1170 # list_graph = [['nuage_1.svg', 'Nuage']]
1172 # list_graph = [['nuage_1.png', 'Nuage']]
1173 list_graph = [['labbe-tree.png', _('Ward clustering (method ward2)')],
1174 ['labbe-heatmap.png', _('Heatmap')],
1175 ['labbe-matrix.png', _('Matrix')]]
1176 for val in list_graph :
1177 #self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, [val])
1178 self.Tab.AddPage(GraphPanel(self.Tab, self.pathout, [val]), val[1])
1179 self.Tab.corpus = self.corpus
1180 self.Tab.parametres = self.parametres
1181 self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
1182 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1183 self.ira.ShowAPane("Tab_content")
1187 nodesfile = self.pathout['nodes.csv']
1188 edgesfile = self.pathout['edges.csv']
1189 jsonout = self.pathout.makenew('graphe_json', 'json')
1194 """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['Rgraph']))
1198 """ % (ffr(nodesfile), ffr(edgesfile))
1200 if ("communities" %in% names(graph.simi)) {
1205 graph.to.file(graph.simi, nodesfile = nodesf, edgesfile = edgesf, community = community)
1207 # ecriture du fichier de script à éxécuter
1208 filetmp = tempfile.mktemp()
1209 with open(filetmp, 'w', encoding='utf8') as f :
1211 exec_rcode(self.ira.RPath, filetmp)
1212 GraphToJson(nodesfile, edgesfile, jsonout)
1213 # une fonction à ré-activer ???
1214 # pour le moment, j'ai mis le module network_to_blender de coté
1215 # launchcommand(['/home/pierre/prog/blender-2.73-linux-glibc211-x86_64/blender', '-P', os.path.join(self.ira.AppliPath, 'network_to_blender.py'), jsonout])
1218 class SimiLayout(DefaultTextLayout) :
1220 def dolayout(self) :
1221 self.pathout.basefiles(simipath)
1223 self.indices = indices_simi
1224 if os.path.exists(self.pathout['liste_graph']) :
1225 list_graph = read_list_file(self.pathout['liste_graph'])
1227 list_graph = [['','']]
1229 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1230 self.tabsimi = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1231 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1232 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1233 self.tabsimi.corpus = self.corpus
1234 self.tabsimi.parametres = self.parametres
1235 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1236 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1237 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1238 self.graphpan.Bind(wx.EVT_BUTTON, self.blender, self.graphpan.butblender)
1239 self.tabsimi.AddPage(self.graphpan, _('Graph'))
1240 self.ira.nb.AddPage(self.tabsimi, _('Graph analysis'))
1241 self.ira.ShowTab(True)
1242 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1244 def redosimi(self, evt) :
1246 # with open(self.pathout['selected.csv'],'r') as f :
1247 # selected = f.read()
1248 # selected = [int(val) for val in selected.splitlines()]
1249 # if self.actives is None :
1250 # with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1251 # self.actives = f.read()
1252 # self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1253 # if os.path.exists(self.pathout['actives_nb.csv']) :
1254 # with open(self.pathout['actives_nb.csv'], 'r') as f :
1256 # act_nb = act_nb.splitlines()
1257 # dictcol = dict([[i, [self.actives[i], int(act_nb[i])]] for i, val in enumerate(self.actives)])
1259 # dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1260 # #res = SelectColumn(self.ira, dictcol, self.actives, self.pathout['selected.csv'], selected = selected, dlg = True)
1262 # prep = PrepSimi(self.ira, self, self.parametres,self.pathout['selected.csv'], self.actives, indices_simi, wordlist = dictcol, selected = selected)
1263 # if prep.val == wx.ID_OK :
1264 # self.parametres = prep.parametres
1265 # script = PrintSimiScript(self)
1266 # script.make_script()
1267 # pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
1268 # check_Rresult(self.ira, pid)
1269 # if self.parametres['type_graph'] in [1,3] :
1270 # if self.parametres['svg'] :
1271 # filename, ext = os.path.splitext(script.filename)
1272 # fileout = filename + '.svg'
1273 # elif self.parametres['type_graph'] == 3 :
1274 # fileout = script.filename
1275 # parametres = {'gexffile' : fileout,
1276 # 'dirout' : os.path.dirname(fileout),
1277 # 'titre': 'Le titre',
1278 # #'nodemin': self.param['txt_min'],
1279 # #'nodemax': self.param['txt_max'],
1280 # #'bargraphw' : 60*int(self.param['clnb']),
1282 # web = WebExport(self.ira, parametres)
1283 # fileout = web.exportsimi()
1285 # fileout = script.filename
1286 # if os.path.exists(self.pathout['liste_graph']):
1287 # graph_simi = read_list_file(self.pathout['liste_graph'])
1288 # graph_simi.append([os.path.basename(fileout), script.txtgraph])
1290 # graph_simi = [[os.path.basename(fileout), script.txtgraph]]
1291 # print_liste(self.pathout['liste_graph'], graph_simi)
1292 # DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1293 # if self.parametres['type_graph'] in [1,3] :
1294 # if self.parametres['svg'] or self.parametres['type_graph'] == 3 :
1295 # self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1297 # 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)
1298 # self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1299 # self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1300 # self.graphpan.Layout()
1301 # self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1303 def export(self, evt) :
1305 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1307 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1313 graph <- graph.simi$graph
1314 V(graph)$x <- graph.simi$layout[,1]
1315 V(graph)$y <- graph.simi$layout[,2]
1316 if (length(graph.simi$label.cex == 1)) {
1317 V(graph)$weight <- graph.simi$eff
1319 V(graph)$weight <- graph.simi$label.cex
1321 V(graph)$rcolor <- vertex.label.color
1322 V(graph)$frequences <- graph.simi$mat.eff
1323 V(graph)$label <- as.character(graph.simi$v.label)
1324 E(graph)$weight <- graph.simi$we.width
1325 write.graph(graph, fileout, format = 'graphml')
1326 #saveAsGEXF(graph, filepath = fileout)
1327 """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['simi']), fileout)
1328 filetmp = tempfile.mktemp()
1329 with open(filetmp, 'w', encoding='utf8') as f :
1331 exec_rcode(self.ira.RPath, filetmp)
1332 mss = wx.MessageDialog(self.ira, fileout, _('File exported'), wx.OK)
1333 mss.CenterOnParent()
1337 def blender(self, evt):
1341 class DefaultMatLayout :
1343 def __init__(self, parent, tableau, parametres) :
1344 self.pathout = PathOut(dirout = parametres['pathout'])
1346 self.parent = parent
1347 self.tableau = tableau
1348 self.parametres = parametres
1349 if os.path.exists(self.pathout['analyse.db']) :
1350 self.tableau.read_tableau(self.pathout['analyse.db'])
1352 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1353 self.ira.ShowAPane("Tab_content")
1355 def dolayout(self) :
1359 class FreqLayout(DefaultMatLayout) :
1361 def dolayout(self) :
1362 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1363 #self.tab = wx.html2.WebView.New(self)
1364 res = normpath_win32(self.pathout['resultats.html']).replace('\\','/')
1365 self.tab.LoadPage(res)
1366 #self.tab.LoadURL(res)
1367 self.tab.parametres = self.parametres
1368 self.ira.nb.AddPage(self.tab, ' - '.join([_("Frequency"), self.parametres['name']]))
1371 class Chi2Layout(DefaultMatLayout) :
1374 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1375 if "gtk2" in wx.PlatformInfo:
1376 self.tab.SetStandardFonts()
1377 res = normpath_win32(self.pathout['resultats-chi2.html']).replace('\\','/')
1378 self.tab.LoadPage(res)
1379 self.tab.parametres = self.parametres
1380 self.ira.nb.AddPage(self.tab, ' - '.join(["Chi2", self.parametres['name']]))
1381 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1382 #self.ira.ShowAPane("Tab_content")
1385 class ProtoLayout(DefaultMatLayout) :
1387 def dolayout(self) :
1388 list_graph = [['proto.png', _('Prototypical analysis')]]
1389 #self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1390 #if self.parametres['svg'] :
1391 # list_graph = [['nuage_1.svg', 'Nuage']]
1393 # list_graph = [['nuage_1.png', 'Nuage']]
1394 self.TabProto = GraphPanel(self.ira.nb, self.pathout, list_graph)
1395 #self.Tab.AddPage(self.TabProto, 'Analyse Prototypique')
1396 #self.Tab.corpus = self.corpus
1397 self.TabProto.parametres = self.parametres
1398 self.ira.nb.AddPage(self.TabProto, ' - '.join([_('Prototypical analysis'), self.parametres['name']]))
1399 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1400 #self.ira.ShowAPane("Tab_content")
1402 class CateLayout(DefaultMatLayout) :
1404 def dolayout(self) :
1405 self.tableau.read_tableau(self.pathout['analyse.db'])
1406 TabCate = ElCategorizator(self.ira.nb, self.pathout, self.tableau)
1407 self.ira.nb.AddPage(TabCate, ' - '.join([_('ElCaTeGoRiZaToR'), self.parametres['name']]))
1409 class SimiMatLayout(DefaultMatLayout) :
1412 self.pathout.basefiles(simipath)
1413 self.indices = indices_simi
1414 if os.path.exists(self.pathout['liste_graph']) :
1415 list_graph = read_list_file(self.pathout['liste_graph'])
1417 list_graph = [['','']]
1418 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1419 self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1420 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1421 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1422 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1423 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1424 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1425 self.graphpan.Bind(wx.EVT_BUTTON, self.blender, self.graphpan.butblender)
1426 self.tabsimi.AddPage(self.graphpan, _('Graph'))
1427 self.tabsimi.parametres = self.parametres
1428 self.parent.nb.AddPage(self.tabsimi, ' - '.join([_('Graph analysis'), self.parametres['name']]))
1429 #self.parent.ShowTab(True)
1430 #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1432 def redosimi(self,evt) :
1433 with open(self.pathout['selected.csv'],'r', encoding='utf8') as f :
1435 selected = [int(val) for val in selected.splitlines()]
1436 #if self.actives is None :
1437 # with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1438 # self.actives = f.read()
1439 # self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1441 actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1443 actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1444 #self.tableau.make_listactives()
1445 actives = dict([[i, val] for i, val in enumerate(actives)])
1447 #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1448 self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1449 self.dial.CenterOnParent()
1450 self.val = self.dial.ShowModal()
1451 if self.val == wx.ID_OK :
1452 last = self.dial.listcol.GetFirstSelected()
1453 lastl = [self.dial.listcol.GetFirstSelected()]
1454 indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1455 while self.dial.listcol.GetNextSelected(last) != -1:
1456 last = self.dial.listcol.GetNextSelected(last)
1458 indexes.append(self.dial.listcol.getColumnText(last,0))
1459 self.column = [self.tableau.listactives.index(val) for val in indexes]
1461 with open(self.pathout['selected.csv'], 'w', encoding='utf8') as f :
1462 f.write('\n'.join([repr(val) for val in self.column]))
1465 self.script = PrintSimiScript(self)
1466 self.script.make_script()
1467 self.tmpfile = self.script.scriptout
1468 dlg = progressbar(self, maxi = 2)
1471 if self.parametres['type_graph'] == 1:
1472 if self.parametres['svg'] :
1473 filename, ext = os.path.splitext(self.script.filename)
1474 fileout = filename + '.svg'
1476 fileout = self.script.filename
1477 fileout = normpath_win32(fileout)
1478 if os.path.exists(self.pathout['liste_graph']):
1479 graph_simi = read_list_file(self.pathout['liste_graph'])
1480 graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1482 graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1483 print_liste(self.pathout['liste_graph'], graph_simi)
1484 DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1485 if self.parametres['type_graph'] == 1:
1486 if self.parametres['svg'] :
1487 self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1489 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)
1490 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1491 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1492 self.graphpan.Layout()
1493 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1497 def make_param(self) :
1498 if self.parametres['first'] :
1501 keep_coord = self.dial.check_coord.GetValue()
1502 #self.select = self.dial.check_colch.GetValue()
1503 paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1504 'layout' : self.dial.choice2.GetSelection(),
1505 'type_graph' : self.dial.choice3.GetSelection(),
1506 'arbremax' : self.dial.check1.GetValue(),
1507 'coeff_tv' : self.dial.check_s_size.GetValue(),
1508 'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1509 'tvprop' : self.dial.check2.GetValue(),
1510 'tvmin' : self.dial.spin_tvmin.GetValue(),
1511 'tvmax' : self.dial.spin_tvmax.GetValue(),
1512 'coeff_te' : self.dial.check3.GetValue(),
1513 'coeff_temin' : self.dial.spin_temin.GetValue(),
1514 'coeff_temax' : self.dial.spin_temax.GetValue(),
1515 'label_e' : self.dial.check_elab.GetValue(),
1516 'label_v' : self.dial.check_vlab.GetValue(),
1517 'vcex' : self.dial.check_vcex.GetValue(),
1518 'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1519 'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1520 'cex' : self.dial.spin_cex.GetValue(),
1521 'seuil_ok' : self.dial.check_seuil.GetValue(),
1522 'seuil' : self.dial.spin_seuil.GetValue(),
1523 'cols' : self.dial.cols.GetColour(),
1524 'cola' : self.dial.cola.GetColour(),
1525 'width' : self.dial.spin_width.GetValue(),
1526 'height' : self.dial.spin_height.GetValue(),
1528 'keep_coord' : keep_coord,
1529 'alpha' : self.dial.slider_sphere.GetValue(),
1530 'film' : self.dial.film.GetValue(),
1531 'svg' : self.dial.choix_format.GetSelection(),
1532 'halo' : self.dial.halo.GetValue(),
1533 'com' : self.dial.comcheck.GetValue(),
1534 'communities' : self.dial.choix_com.GetSelection(),
1535 'edgecurved' : self.dial.check_curved.GetValue(),
1537 if 'cexfromchi' in self.parametres :
1538 paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1539 if 'sfromchi' in self.parametres :
1540 paramsimi['sfromchi'] = self.dial.checki.GetValue()
1541 if 'vlabcolor' in self.parametres :
1542 paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1543 if 'check_bystar' in dir(self.dial) :
1544 paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1545 paramsimi['stars'] = self.parametres['stars']
1546 self.parametres.update(paramsimi)
1549 if self.parametres['type_graph'] == 1 :
1555 pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1556 if self.parametres['type_graph'] == 1 :
1557 while pid.poll() == None :
1560 check_Rresult(self.parent, pid)
1562 def export(self, evt) :
1564 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1566 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1572 graph <- graph.simi$graph
1573 V(graph)$x <- graph.simi$layout[,1]
1574 V(graph)$y <- graph.simi$layout[,2]
1575 if (length(graph.simi$label.cex == 1)) {
1576 V(graph)$weight <- graph.simi$mat.eff
1578 V(graph)$weight <- graph.simi$label.cex
1580 V(graph)$color <- vertex.label.color
1581 V(graph)$frequences <- graph.simi$mat.eff
1582 V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
1583 V(graph)$label <- as.character(graph.simi$v.label)
1584 E(graph)$weight <- graph.simi$we.width
1585 write.graph(graph, fileout, format = 'graphml')
1586 #saveAsGEXF(graph, filepath = fileout)
1587 """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['simi']), fileout)
1588 filetmp = tempfile.mktemp()
1589 with open(filetmp, 'w', encoding='utf8') as f :
1591 exec_rcode(self.ira.RPath, filetmp)
1592 mss = wx.MessageDialog(self.ira, fileout, _('File exported'), wx.OK)
1593 mss.CenterOnParent()
1597 def blender(self, evt):
1601 class GraphPanelSimi(wx.Panel):
1603 def __init__(self,parent, dico, list_graph):
1604 wx.Panel.__init__(self,parent)
1607 self.dirout = os.path.dirname(self.Dict['ira'])
1608 self.parent = self.GetParent()
1609 self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "courier")) #modifié
1612 self.tabsimi = self.parent.GetParent()
1613 self.ira = self.tabsimi.GetParent()
1614 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1615 afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1616 self.butafc = wx.BitmapButton(self, -1, afc_img)
1617 export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1618 self.butexport = wx.BitmapButton(self, -1, export_img)
1619 blender_img = wx.Image(os.path.join(self.ira.images_path,'button_blender.png'), wx.BITMAP_TYPE_ANY)
1620 blender_img.Rescale(32,32)
1621 blender_img = blender_img.ConvertToBitmap()
1622 self.butblender = wx.BitmapButton(self, -1, blender_img)
1623 for i in range(0,len(list_graph)):
1624 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1625 filename, ext = os.path.splitext(list_graph[i][0])
1626 if ext in ['.svg', '.html'] :
1627 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])))
1629 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1630 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1631 self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove)
1632 self.__set_properties()
1635 def __set_properties(self):
1636 self.panel_1.EnableScrolling(True,True)
1637 #self.panel_1.SetSize((1000,1000))
1638 self.panel_1.SetScrollRate(20, 20)
1639 self.panel_1.SetFocus()
1641 def __do_layout(self):
1642 self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1643 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1644 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1645 self.sizer_2.Add(self.butafc, 0, 0, 0)
1646 self.sizer_2.Add(self.butexport, 0, 0, 0)
1647 self.sizer_2.Add(self.butblender, 0, 0, 0)
1648 for i in range(0, len(self.listimg)):
1649 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1650 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1651 self.panel_1.SetSizer(self.sizer_3)
1652 self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1653 self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1654 self.SetSizer(self.sizer_1)
1656 def onMouseMove(self, event):
1657 self.panel_1.SetFocus()