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') 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 codecs.open(self.pathout['classes_names.txt'], 'r', self.parent.syscoding) 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 codecs.open(DictPathOut['pre_rapport'], 'r') 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 codecs.open(self.dictpathout['translations.txt'], 'r', '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 codecs.open(self.dictpathout[trans[1]], 'r') 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') 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.encoding = self.corpus.parametres['syscoding']
740 self.parametres = parametres
741 self.DictSpec, first = ReadList(self.dictpathout['tablespecf'], self.corpus.parametres['syscoding'])
742 if os.path.exists(self.pathout['banalites.csv']) :
743 self.dictban, firstban = ReadList(self.pathout['banalites.csv'], self.corpus.parametres['syscoding'])
744 self.DictType, firstt = ReadList(self.dictpathout['tablespect'], self.corpus.parametres['syscoding'])
745 self.DictEff, firsteff = ReadList(self.dictpathout['tableafcm'], self.corpus.parametres['syscoding'])
746 self.DictEffType, firstefft = ReadList(self.dictpathout['tabletypem'], self.corpus.parametres['syscoding'])
747 self.DictEffRelForme, firsteffrelf = ReadList(self.dictpathout['eff_relatif_forme'], self.corpus.parametres['syscoding'])
748 self.DictEffRelType, firsteffrelt = ReadList(self.dictpathout['eff_relatif_type'], self.corpus.parametres['syscoding'])
749 self.etoiles = firsteff[1:]
750 #sash = SashList(ira.nb)
751 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
752 self.TabStat.parametres = parametres
753 self.ListPan = ListForSpec(ira, self, self.DictSpec, self.etoiles)
754 if os.path.exists(self.pathout['banalites.csv']) :
755 self.listban = ListForSpec(ira, self, self.dictban, ['eff'] + self.etoiles, usefirst = True)
756 #self.ListPan2 = ListForSpec(sash.rightwin1, self, self.DictSpec, first)
757 self.ListPant = ListForSpec(ira, self, self.DictType, self.etoiles)
758 self.ListPanEff = ListForSpec(ira, self, self.DictEff, self.etoiles)
759 self.ListPanEffType = ListForSpec(ira, self, self.DictEffType, self.etoiles)
760 self.ListPanEffRelForme = ListForSpec(ira, self, self.DictEffRelForme, self.etoiles)
761 self.ListPanEffRelType = ListForSpec(ira, self, self.DictEffRelType, self.etoiles)
762 self.TabStat.AddPage(self.ListPan, _('Forms'))
763 if os.path.exists(self.pathout['banalites.csv']) :
764 self.TabStat.AddPage(self.listban, _('Banal forms'))
765 self.TabStat.AddPage(self.ListPant, _('POS'))
766 self.TabStat.AddPage(self.ListPanEff, _('Forms frequencies'))
767 self.TabStat.AddPage(self.ListPanEffType, _('POS frequencies'))
768 self.TabStat.AddPage(self.ListPanEffRelForme, _('Forms relative frequencies'))
769 self.TabStat.AddPage(self.ListPanEffRelType, _('POS relative frequencies'))
770 if self.parametres['clnb'] > 2 :
771 self.TabAFC = aui.AuiNotebook(self.TabStat, -1, wx.DefaultPosition)
772 list_graph=read_list_file(self.dictpathout['liste_graph_afcf'], encoding = self.encoding)
773 self.tabAFCGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afcf', coding = self.encoding)
774 self.TabAFC.AddPage(self.tabAFCGraph, _('CA forms'))
775 list_graph=read_list_file(self.dictpathout['liste_graph_afct'], encoding = self.encoding)
776 self.tabAFCTGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afct', coding=self.encoding)
777 self.TabAFC.AddPage(self.tabAFCTGraph, _('CA POS'))
778 self.TabStat.AddPage(self.TabAFC, _('CA'))
779 ira.nb.AddPage(self.TabStat, ' - '.join([_('Specificities'), self.parametres['name']]))
781 self.TabStat.corpus = self.corpus
782 self.TabStat.etoiles = self.etoiles
783 if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenspec.csv')) :
784 self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenspec.csv')
785 TgenLayout(self.TabStat)
786 self.TabStat.SetSelection(0)
787 ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
788 ira.ShowAPane("Tab_content")
793 def __init__(self, ira, corpus, parametres):
794 self.pathout = PathOut(dirout = parametres['pathout'])
797 self.read_result() # qui va définir la propriété self.result
798 self.parametres = parametres
799 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
800 self.TabStat.parametres = parametres
801 self.TabStat.corpus = corpus
802 self.TabStat.pathout = self.pathout
803 # CHD = GraphPanel(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
804 # panel.TabChdSim.AddPage(CHD,'CHD')
805 #self.TabStatTot = wx.TextCtrl(self.TabStat, -1, style=wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2)
806 list_graph = [['zipf.png', 'zipf']]
807 self.TabStatTot = GraphPanel(ira.nb, self.pathout, list_graph, self.result['glob'])
808 self.TabStat.AddPage(self.TabStatTot, _('Abstract'))
809 dictlabel = {'total' : _('Total'),
810 'formes_actives' : _('Actives forms'),
811 'formes_supplémentaires': _('Supplementary forms'),
812 'hapax' : _('Hapax'),
814 for item in self.result:
816 datam = [['forme', 'nb']] #???
817 self.ListPan = ListPanel(ira, self, self.result[item])
818 self.TabStat.AddPage(self.ListPan, dictlabel[item])
819 ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
820 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
821 ira.ShowAPane("Tab_content")
823 def read_result(self) :
824 lcle = {'total' :'total.csv', 'formes_actives':'formes_actives.csv', 'formes_supplémentaires':'formes_supplémentaires.csv', 'hapax': 'hapax.csv'}
827 with codecs.open(self.pathout[lcle[key]], 'r', sys.getdefaultencoding()) as f :
828 self.result[key] = [line.split(';') for line in f.read().splitlines()]
829 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
830 with open(self.pathout['glob.txt'], 'r') as f :
831 self.result['glob'] = f.read()
834 class GraphPanelDendro(wx.Panel):
836 def __init__(self,parent, dico, list_graph, txt=False):
837 wx.Panel.__init__(self,parent)
839 self.dictpathout = dico
840 self.dirout = os.path.dirname(self.dictpathout['ira'])
841 self.list_graph = list_graph
842 self.parent = self.GetParent()#parent
843 self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "Arial")) #modifié
846 self.tabchd = self.parent.GetParent()
847 self.ira = self.tabchd.GetParent()
848 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
849 self.panel_1.SetBackgroundColour('white')
850 self.deb = wx.StaticText(self.panel_1, -1, txt)
851 dendro_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
852 dendro_liste_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro_liste.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
853 dendro_cloud_img= wx.Image(os.path.join(self.ira.images_path,'but_dendro_cloud.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
854 self.butdendro = wx.BitmapButton(self, -1, dendro_img)
855 self.butdendrotexte = wx.BitmapButton(self, -1, dendro_liste_img)
856 self.butdendrocloud = wx.BitmapButton(self, -1, dendro_cloud_img)
857 for i in range(0,len(list_graph)):
858 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
859 filename, ext = os.path.splitext(list_graph[i][0])
861 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])))
863 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
864 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
865 self.__set_properties()
868 def __set_properties(self):
869 self.panel_1.EnableScrolling(True,True)
870 #self.panel_1.SetSize((1000,1000))
871 self.panel_1.SetScrollRate(20, 20)
872 self.panel_1.SetFocus()
873 self.Bind(wx.EVT_BUTTON, self.ondendro, self.butdendro)
874 self.Bind(wx.EVT_BUTTON, self.ondendrotexte, self.butdendrotexte)
875 self.Bind(wx.EVT_BUTTON, self.ondendrocloud, self.butdendrocloud)
876 self.param = {'width' : 700,
880 'taille_classe' : True,
884 self.type_dendro = [ "phylogram", "cladogram", "fan", "unrooted", "radial" ]
886 def __do_layout(self):
887 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
888 self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
889 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
890 self.sizer_3.Add(self.deb)
891 self.sizer_1.Add(self.butdendro, 0, 0, 0)
892 self.sizer_1.Add(self.butdendrotexte, 0, 0, 0)
893 self.sizer_1.Add(self.butdendrocloud, 0, 0, 0)
894 for i in range(0, len(self.listimg)):
895 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
896 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
897 self.panel_1.SetSizer(self.sizer_3)
898 self.sizer_2.Add(self.sizer_1, 0, wx.EXPAND, 0)
899 self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
900 self.SetSizer(self.sizer_2)
902 def make_param(self, dial):
903 self.param['width'] = dial.m_spinCtrl2.GetValue()
904 self.param['height'] = dial.m_spinCtrl1.GetValue()
905 self.param['type_dendro'] = dial.m_choice1.GetSelection()
906 self.param['svg'] = dial.choice_format.GetSelection()
907 if self.param['typedendro'] == 'classique' :
908 self.param['color_nb'] = dial.m_radioBox1.GetSelection()
909 self.param['taille_classe'] = dial.m_checkBox1.GetValue()
910 self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
911 if self.param.get('translation', False) :
912 if dial.trans.GetSelection() == 0 :
913 del self.param['translation']
915 self.param['translation'] = self.param['translation'][dial.trans.GetSelection()-1][1]
917 def make_dendro(self, dendro = 'simple') :
918 if self.param['svg'] :
922 while os.path.exists(os.path.join(self.dirout, 'dendrogramme_' + str(self.graphnb)+typefile)) :
924 fileout = ffr(os.path.join(self.dirout,'dendrogramme_' + str(self.graphnb)+typefile))
925 width = self.param['width']
926 height = self.param['height']
927 type_dendro = self.type_dendro[self.param['type_dendro']]
928 if self.param['taille_classe'] :
932 if self.param['color_nb'] == 0 :
936 if self.param['type_tclasse'] == 0 :
940 if self.param['svg'] :
944 dendro_path = self.dictpathout['Rdendro']
945 classe_path = self.dictpathout['uce']
950 classes <- read.csv2("%s", row.names=1)
951 classes <- classes[,1]
952 """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']), ffr(classe_path))
953 if dendro == 'simple' :
955 open_file_graph("%s", width=%i, height=%i, svg=%s)
956 plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
957 """ % (ffr(fileout), width, height, svg, type_dendro, histo, bw, tclasse)
958 elif dendro == 'texte' :
962 if (is.null(debsup)) {
965 chistable <- chistabletot[1:(debsup-1),]
966 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']))
967 if self.param.get('translation', False) :
969 rn <- read.csv2("%s", header=FALSE, sep='\t')
970 rnchis <- row.names(chistable)
971 commun <- intersect(rnchis, unique(rn[,2]))
972 idrnchis <- sapply(commun, function(x) {which(rnchis==x)})
973 idrn <- sapply(commun, function(x) {which(as.vector(rn[,2])==x)[1]})
974 rownames(chistable)[idrnchis] <- as.vector(rn[idrn,1])
975 """ % ffr(self.param['translation'])
977 open_file_graph("%s", width=%i, height=%i, svg = %s)
978 plot.dendro.prof(tree.cut1$tree.cl, classes, chistable, nbbycl = 60, type.dendro="%s", bw=%s, lab=NULL)
979 """ % (ffr(fileout), width, height, svg, type_dendro, bw)
980 elif dendro == 'cloud' :
984 if (is.null(debsup)) {
987 chistable <- chistabletot[1:(debsup-1),]
988 open_file_graph("%s", width=%i, height=%i, svg=%s)
989 plot.dendro.cloud(tree.cut1$tree.cl, classes, chistable, nbbycl = 300, type.dendro="%s", bw=%s, lab=NULL)
990 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
991 tmpfile = tempfile.mktemp()
992 # ecriture du fichier de script à éxécuter
993 with open(tmpfile, 'w') as f :
996 busy = wx.BusyInfo(_("Please wait..."), self.parent)
998 error = exec_rcode(self.ira.RPath, tmpfile, wait=True)
1001 check_Rresult(self.ira, error)
1002 self.list_graph.append([fileout, 'Dendrogramme CHD1 - %s' % type_dendro])
1003 print_liste(self.dictpathout['liste_graph_chd'], self.list_graph)
1004 if self.param['svg'] :
1005 self.sizer_3.Add(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1007 self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1008 self.sizer_3.Add(wx.StaticText(self.panel_1,-1, 'Dendrogramme CHD1 - %s' % type_dendro), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1009 self.sizer_3.Fit(self.panel_1)
1011 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
1014 def ondendro(self, evt):
1015 self.param['typedendro'] = 'classique'
1016 dial = PrefDendro(self.ira, self.param)
1017 val = dial.ShowModal()
1018 if val == wx.ID_OK :
1019 self.make_param(dial)
1022 def ondendrotexte(self, evt):
1023 self.param['typedendro'] = 'texte'
1024 if os.path.exists(self.dictpathout['translations.txt']) :
1025 with codecs.open(self.dictpathout['translations.txt'], 'r', 'utf8') as f :
1028 trans = [line.split('\t')[1] for line in content.splitlines()]
1029 trans = [[val, self.dictpathout[val]] for val in trans]
1030 self.param['translation'] = trans
1031 dial = PrefDendro(self.ira, self.param)
1032 val = dial.ShowModal()
1033 if val == wx.ID_OK :
1034 self.make_param(dial)
1035 self.make_dendro(dendro = 'texte')
1037 def ondendrocloud(self, evt):
1038 self.param['typedendro'] = 'cloud'
1039 dial = PrefDendro(self.ira, self.param)
1040 val = dial.ShowModal()
1041 if val == wx.ID_OK :
1042 self.make_param(dial)
1043 self.make_dendro(dendro = 'cloud')
1048 def __init__(self, ira, parametres) :
1049 #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)
1050 self.panel = CopusPanel(ira, parametres)
1051 ira.nb.AddPage(self.panel, 'Description %s' % parametres['corpus_name'])
1052 #self.text.write(DoConf().totext(parametres))
1053 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
1054 ira.ShowAPane("Tab_content")
1059 def __init__(self, ira, matrix):
1060 #self.parent.content = self.csvtable
1061 self.sheet = MySheet(ira.nb)
1062 ira.nb.AddPage(self.sheet, matrix.parametres['matrix_name'])
1063 self.sheet.Populate(matrix.csvtable)
1064 self.sheet.parametres = matrix.parametres
1065 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
1066 ira.ShowAPane("Tab_content")
1069 class CopusPanel(wx.Panel) :
1071 def __init__(self, parent, parametres) :
1072 wx.Panel.__init__ ( self, parent, id = wx.ID_ANY, pos = wx.DefaultPosition, size = wx.Size( 500,300 ), style = wx.TAB_TRAVERSAL )
1073 self.parametres = parametres
1074 fgSizer5 = wx.FlexGridSizer( 0, 2, 0, 0 )
1075 fgSizer5.SetFlexibleDirection( wx.BOTH )
1076 fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )
1077 self.fgSizer5 = fgSizer5
1078 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, _("Description of corpus"), wx.DefaultPosition, wx.DefaultSize, 0 )
1079 self.m_staticText18.Wrap( -1 )
1080 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1081 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, "", wx.DefaultPosition, wx.DefaultSize, 0 )
1082 self.m_staticText19.Wrap( -1 )
1083 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1084 self.m_staticText20 = wx.StaticText( self, wx.ID_ANY, "Nom", wx.DefaultPosition, wx.DefaultSize, 0 )
1085 self.m_staticText20.Wrap( -1 )
1086 fgSizer5.Add( self.m_staticText20, 0, wx.ALL, 5 )
1087 self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, parametres['corpus_name'], wx.DefaultPosition, wx.DefaultSize, 0 )
1088 self.m_staticText21.Wrap( -1 )
1089 fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )
1090 description = {'lang' : _('Language'),
1091 'encoding' : _('Characters set'),
1092 'ucinb' : _('Number of texts'),
1093 'ucenb' : _('Number of text segments'),
1094 'formesnb' : _('Number of forms'),
1095 'hapax' : _('Number of hapax'),
1097 keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']
1098 self.addkeys(keys, description)
1099 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, "Paramètres", wx.DefaultPosition, wx.DefaultSize, 0 )
1100 self.m_staticText18.Wrap( -1 )
1101 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1102 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, "", wx.DefaultPosition, wx.DefaultSize, 0 )
1103 self.m_staticText19.Wrap( -1 )
1104 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1105 keys = ['ucemethod', 'ucesize', 'keep_caract', 'expressions']
1106 self.addkeys(keys, description)
1107 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, "Statistiques", wx.DefaultPosition, wx.DefaultSize, 0 )
1108 self.m_staticText18.Wrap( -1 )
1109 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1110 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, "", wx.DefaultPosition, wx.DefaultSize, 0 )
1111 self.m_staticText19.Wrap( -1 )
1112 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1113 keys = ['ucinb', 'ucenb', 'occurrences', 'formesnb', 'hapax']
1114 self.addkeys(keys, description)
1115 self.SetSizer( fgSizer5 )
1118 def addkeys(self, keys, description) :
1120 option = self.parametres.get(key,'non défini')
1121 if isinstance(option, int) :
1122 option = repr(option)
1123 text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
1125 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1126 text = wx.StaticText( self, wx.ID_ANY, option, wx.DefaultPosition, wx.DefaultSize, 0 )
1128 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1131 class DefaultTextLayout :
1133 def __init__(self, ira, corpus, parametres, cmd = False) :
1134 self.pathout = PathOut(dirout = parametres['pathout'])
1137 self.parametres = parametres
1138 self.corpus = corpus
1142 def dolayout(self, cmd) :
1143 log.info('no layout yet')
1146 class WordCloudLayout(DefaultTextLayout):
1149 self.pathout.basefiles(simipath)
1150 self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1151 if self.parametres['svg'] :
1152 list_graph = [['nuage_1.svg', 'Nuage']]
1154 list_graph = [['nuage_1.png', 'Nuage']]
1155 self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, list_graph)
1156 self.Tab.AddPage(self.TabStatTot, 'Nuage')
1157 self.Tab.corpus = self.corpus
1158 self.Tab.parametres = self.parametres
1159 self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
1160 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1161 self.ira.ShowAPane("Tab_content")
1164 class LabbeLayout(DefaultTextLayout):
1167 self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1168 #if self.parametres['svg'] :
1169 # list_graph = [['nuage_1.svg', 'Nuage']]
1171 # list_graph = [['nuage_1.png', 'Nuage']]
1172 list_graph = [['labbe-tree.png', _('Ward clustering (method ward2)')],
1173 ['labbe-heatmap.png', _('Heatmap')],
1174 ['labbe-matrix.png', _('Matrix')]]
1175 for val in list_graph :
1176 #self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, [val])
1177 self.Tab.AddPage(GraphPanel(self.Tab, self.pathout, [val]), val[1])
1178 self.Tab.corpus = self.corpus
1179 self.Tab.parametres = self.parametres
1180 self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
1181 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1182 self.ira.ShowAPane("Tab_content")
1186 nodesfile = self.pathout['nodes.csv']
1187 edgesfile = self.pathout['edges.csv']
1188 jsonout = self.pathout.makenew('graphe_json', 'json')
1193 """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['Rgraph']))
1197 """ % (ffr(nodesfile), ffr(edgesfile))
1199 if ("communities" %in% names(graph.simi)) {
1204 graph.to.file(graph.simi, nodesfile = nodesf, edgesfile = edgesf, community = community)
1206 # ecriture du fichier de script à éxécuter
1207 filetmp = tempfile.mktemp()
1208 with open(filetmp, 'w') as f :
1210 exec_rcode(self.ira.RPath, filetmp)
1211 GraphToJson(nodesfile, edgesfile, jsonout)
1212 # une fonction à ré-activer ???
1213 # pour le moment, j'ai mis le module network_to_blender de coté
1214 # launchcommand(['/home/pierre/prog/blender-2.73-linux-glibc211-x86_64/blender', '-P', os.path.join(self.ira.AppliPath, 'network_to_blender.py'), jsonout])
1217 class SimiLayout(DefaultTextLayout) :
1219 def dolayout(self) :
1220 self.pathout.basefiles(simipath)
1222 self.indices = indices_simi
1223 if os.path.exists(self.pathout['liste_graph']) :
1224 list_graph = read_list_file(self.pathout['liste_graph'])
1226 list_graph = [['','']]
1228 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1229 self.tabsimi = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1230 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1231 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1232 self.tabsimi.corpus = self.corpus
1233 self.tabsimi.parametres = self.parametres
1234 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1235 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1236 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1237 self.graphpan.Bind(wx.EVT_BUTTON, self.blender, self.graphpan.butblender)
1238 self.tabsimi.AddPage(self.graphpan, _('Graph'))
1239 self.ira.nb.AddPage(self.tabsimi, _('Graph analysis'))
1240 self.ira.ShowTab(True)
1241 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1243 def redosimi(self, evt) :
1245 # with open(self.pathout['selected.csv'],'r') as f :
1246 # selected = f.read()
1247 # selected = [int(val) for val in selected.splitlines()]
1248 # if self.actives is None :
1249 # with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1250 # self.actives = f.read()
1251 # self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1252 # if os.path.exists(self.pathout['actives_nb.csv']) :
1253 # with open(self.pathout['actives_nb.csv'], 'r') as f :
1255 # act_nb = act_nb.splitlines()
1256 # dictcol = dict([[i, [self.actives[i], int(act_nb[i])]] for i, val in enumerate(self.actives)])
1258 # dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1259 # #res = SelectColumn(self.ira, dictcol, self.actives, self.pathout['selected.csv'], selected = selected, dlg = True)
1261 # prep = PrepSimi(self.ira, self, self.parametres,self.pathout['selected.csv'], self.actives, indices_simi, wordlist = dictcol, selected = selected)
1262 # if prep.val == wx.ID_OK :
1263 # self.parametres = prep.parametres
1264 # script = PrintSimiScript(self)
1265 # script.make_script()
1266 # pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
1267 # check_Rresult(self.ira, pid)
1268 # if self.parametres['type_graph'] in [1,3] :
1269 # if self.parametres['svg'] :
1270 # filename, ext = os.path.splitext(script.filename)
1271 # fileout = filename + '.svg'
1272 # elif self.parametres['type_graph'] == 3 :
1273 # fileout = script.filename
1274 # parametres = {'gexffile' : fileout,
1275 # 'dirout' : os.path.dirname(fileout),
1276 # 'titre': 'Le titre',
1277 # #'nodemin': self.param['txt_min'],
1278 # #'nodemax': self.param['txt_max'],
1279 # #'bargraphw' : 60*int(self.param['clnb']),
1281 # web = WebExport(self.ira, parametres)
1282 # fileout = web.exportsimi()
1284 # fileout = script.filename
1285 # if os.path.exists(self.pathout['liste_graph']):
1286 # graph_simi = read_list_file(self.pathout['liste_graph'])
1287 # graph_simi.append([os.path.basename(fileout), script.txtgraph])
1289 # graph_simi = [[os.path.basename(fileout), script.txtgraph]]
1290 # print_liste(self.pathout['liste_graph'], graph_simi)
1291 # DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1292 # if self.parametres['type_graph'] in [1,3] :
1293 # if self.parametres['svg'] or self.parametres['type_graph'] == 3 :
1294 # self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1296 # 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)
1297 # self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1298 # self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1299 # self.graphpan.Layout()
1300 # self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1302 def export(self, evt) :
1304 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1306 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1312 graph <- graph.simi$graph
1313 V(graph)$x <- graph.simi$layout[,1]
1314 V(graph)$y <- graph.simi$layout[,2]
1315 if (length(graph.simi$label.cex == 1)) {
1316 V(graph)$weight <- graph.simi$eff
1318 V(graph)$weight <- graph.simi$label.cex
1320 V(graph)$rcolor <- vertex.label.color
1321 V(graph)$frequences <- graph.simi$mat.eff
1322 V(graph)$label <- as.character(graph.simi$v.label)
1323 E(graph)$weight <- graph.simi$we.width
1324 write.graph(graph, fileout, format = 'graphml')
1325 #saveAsGEXF(graph, filepath = fileout)
1326 """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['simi']), fileout)
1327 filetmp = tempfile.mktemp()
1328 with open(filetmp, 'w') as f :
1330 exec_rcode(self.ira.RPath, filetmp)
1331 mss = wx.MessageDialog(self.ira, fileout, _('File exported'), wx.OK)
1332 mss.CenterOnParent()
1336 def blender(self, evt):
1340 class DefaultMatLayout :
1342 def __init__(self, parent, tableau, parametres) :
1343 self.pathout = PathOut(dirout = parametres['pathout'])
1345 self.parent = parent
1346 self.tableau = tableau
1347 self.parametres = parametres
1348 if os.path.exists(self.pathout['analyse.db']) :
1349 self.tableau.read_tableau(self.pathout['analyse.db'])
1351 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1352 self.ira.ShowAPane("Tab_content")
1354 def dolayout(self) :
1358 class FreqLayout(DefaultMatLayout) :
1360 def dolayout(self) :
1361 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1362 #self.tab = wx.html2.WebView.New(self)
1363 res = normpath_win32(self.pathout['resultats.html']).replace('\\','/')
1364 self.tab.LoadPage(res)
1365 #self.tab.LoadURL(res)
1366 self.tab.parametres = self.parametres
1367 self.ira.nb.AddPage(self.tab, ' - '.join([_("Frequency"), self.parametres['name']]))
1370 class Chi2Layout(DefaultMatLayout) :
1373 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1374 if "gtk2" in wx.PlatformInfo:
1375 self.tab.SetStandardFonts()
1376 res = normpath_win32(self.pathout['resultats-chi2.html']).replace('\\','/')
1377 self.tab.LoadPage(res)
1378 self.tab.parametres = self.parametres
1379 self.ira.nb.AddPage(self.tab, ' - '.join(["Chi2", self.parametres['name']]))
1380 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1381 #self.ira.ShowAPane("Tab_content")
1384 class ProtoLayout(DefaultMatLayout) :
1386 def dolayout(self) :
1387 list_graph = [['proto.png', _('Prototypical analysis')]]
1388 #self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1389 #if self.parametres['svg'] :
1390 # list_graph = [['nuage_1.svg', 'Nuage']]
1392 # list_graph = [['nuage_1.png', 'Nuage']]
1393 self.TabProto = GraphPanel(self.ira.nb, self.pathout, list_graph)
1394 #self.Tab.AddPage(self.TabProto, 'Analyse Prototypique')
1395 #self.Tab.corpus = self.corpus
1396 self.TabProto.parametres = self.parametres
1397 self.ira.nb.AddPage(self.TabProto, ' - '.join([_('Prototypical analysis'), self.parametres['name']]))
1398 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1399 #self.ira.ShowAPane("Tab_content")
1401 class CateLayout(DefaultMatLayout) :
1403 def dolayout(self) :
1404 TabCate = ElCategorizator(self.ira.nb, self.pathout, self.tableau)
1405 self.ira.nb.AddPage(TabCate, ' - '.join([_('ElCaTeGoRiZaToR'), self.parametres['name']]))
1407 class SimiMatLayout(DefaultMatLayout) :
1410 self.pathout.basefiles(simipath)
1411 self.indices = indices_simi
1412 if os.path.exists(self.pathout['liste_graph']) :
1413 list_graph = read_list_file(self.pathout['liste_graph'])
1415 list_graph = [['','']]
1416 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1417 self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1418 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1419 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1420 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1421 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1422 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1423 self.graphpan.Bind(wx.EVT_BUTTON, self.blender, self.graphpan.butblender)
1424 self.tabsimi.AddPage(self.graphpan, _('Graph'))
1425 self.tabsimi.parametres = self.parametres
1426 self.parent.nb.AddPage(self.tabsimi, ' - '.join([_('Graph analysis'), self.parametres['name']]))
1427 #self.parent.ShowTab(True)
1428 #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1430 def redosimi(self,evt) :
1431 with open(self.pathout['selected.csv'],'r') as f :
1433 selected = [int(val) for val in selected.splitlines()]
1434 #if self.actives is None :
1435 # with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1436 # self.actives = f.read()
1437 # self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1439 actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1441 actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1442 #self.tableau.make_listactives()
1443 actives = dict([[i, val] for i, val in enumerate(actives)])
1444 #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1445 self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1446 self.dial.CenterOnParent()
1447 self.val = self.dial.ShowModal()
1448 if self.val == wx.ID_OK :
1449 last = self.dial.listcol.GetFirstSelected()
1450 lastl = [self.dial.listcol.GetFirstSelected()]
1451 indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1452 while self.dial.listcol.GetNextSelected(last) != -1:
1453 last = self.dial.listcol.GetNextSelected(last)
1455 indexes.append(self.dial.listcol.getColumnText(last,0))
1456 self.column = [self.tableau.listactives.index(val) for val in indexes]
1458 with open(self.pathout['selected.csv'], 'w') as f :
1459 f.write('\n'.join([repr(val) for val in self.column]))
1462 self.script = PrintSimiScript(self)
1463 self.script.make_script()
1464 self.tmpfile = self.script.scriptout
1465 dlg = progressbar(self, maxi = 2)
1468 if self.parametres['type_graph'] == 1:
1469 if self.parametres['svg'] :
1470 filename, ext = os.path.splitext(self.script.filename)
1471 fileout = filename + '.svg'
1473 fileout = self.script.filename
1474 fileout = normpath_win32(fileout)
1475 if os.path.exists(self.pathout['liste_graph']):
1476 graph_simi = read_list_file(self.pathout['liste_graph'])
1477 graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1479 graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1480 print_liste(self.pathout['liste_graph'], graph_simi)
1481 DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1482 if self.parametres['type_graph'] == 1:
1483 if self.parametres['svg'] :
1484 self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1486 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)
1487 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1488 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1489 self.graphpan.Layout()
1490 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1494 def make_param(self) :
1495 if self.parametres['first'] :
1498 keep_coord = self.dial.check_coord.GetValue()
1499 #self.select = self.dial.check_colch.GetValue()
1500 paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1501 'layout' : self.dial.choice2.GetSelection(),
1502 'type_graph' : self.dial.choice3.GetSelection(),
1503 'arbremax' : self.dial.check1.GetValue(),
1504 'coeff_tv' : self.dial.check_s_size.GetValue(),
1505 'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1506 'tvprop' : self.dial.check2.GetValue(),
1507 'tvmin' : self.dial.spin_tvmin.GetValue(),
1508 'tvmax' : self.dial.spin_tvmax.GetValue(),
1509 'coeff_te' : self.dial.check3.GetValue(),
1510 'coeff_temin' : self.dial.spin_temin.GetValue(),
1511 'coeff_temax' : self.dial.spin_temax.GetValue(),
1512 'label_e' : self.dial.check_elab.GetValue(),
1513 'label_v' : self.dial.check_vlab.GetValue(),
1514 'vcex' : self.dial.check_vcex.GetValue(),
1515 'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1516 'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1517 'cex' : self.dial.spin_cex.GetValue(),
1518 'seuil_ok' : self.dial.check_seuil.GetValue(),
1519 'seuil' : self.dial.spin_seuil.GetValue(),
1520 'cols' : self.dial.cols.GetColour(),
1521 'cola' : self.dial.cola.GetColour(),
1522 'width' : self.dial.spin_width.GetValue(),
1523 'height' : self.dial.spin_height.GetValue(),
1525 'keep_coord' : keep_coord,
1526 'alpha' : self.dial.slider_sphere.GetValue(),
1527 'film' : self.dial.film.GetValue(),
1528 'svg' : self.dial.choix_format.GetSelection(),
1529 'halo' : self.dial.halo.GetValue(),
1530 'com' : self.dial.comcheck.GetValue(),
1531 'communities' : self.dial.choix_com.GetSelection(),
1532 'edgecurved' : self.dial.check_curved.GetValue(),
1534 if 'cexfromchi' in self.parametres :
1535 paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1536 if 'sfromchi' in self.parametres :
1537 paramsimi['sfromchi'] = self.dial.checki.GetValue()
1538 if 'vlabcolor' in self.parametres :
1539 paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1540 if 'check_bystar' in dir(self.dial) :
1541 paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1542 paramsimi['stars'] = self.parametres['stars']
1543 self.parametres.update(paramsimi)
1546 if self.parametres['type_graph'] == 1 :
1552 pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1553 if self.parametres['type_graph'] == 1 :
1554 while pid.poll() == None :
1557 check_Rresult(self.parent, pid)
1559 def export(self, evt) :
1561 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1563 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1569 graph <- graph.simi$graph
1570 V(graph)$x <- graph.simi$layout[,1]
1571 V(graph)$y <- graph.simi$layout[,2]
1572 if (length(graph.simi$label.cex == 1)) {
1573 V(graph)$weight <- graph.simi$mat.eff
1575 V(graph)$weight <- graph.simi$label.cex
1577 V(graph)$color <- vertex.label.color
1578 V(graph)$frequences <- graph.simi$mat.eff
1579 V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
1580 V(graph)$label <- as.character(graph.simi$v.label)
1581 E(graph)$weight <- graph.simi$we.width
1582 write.graph(graph, fileout, format = 'graphml')
1583 #saveAsGEXF(graph, filepath = fileout)
1584 """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['simi']), fileout)
1585 filetmp = tempfile.mktemp()
1586 with open(filetmp, 'w') as f :
1588 exec_rcode(self.ira.RPath, filetmp)
1589 mss = wx.MessageDialog(self.ira, fileout, _('File exported'), wx.OK)
1590 mss.CenterOnParent()
1594 def blender(self, evt):
1598 class GraphPanelSimi(wx.Panel):
1600 def __init__(self,parent, dico, list_graph):
1601 wx.Panel.__init__(self,parent)
1604 self.dirout = os.path.dirname(self.Dict['ira'])
1605 self.parent = self.GetParent()
1606 self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "courier")) #modifié
1609 self.tabsimi = self.parent.GetParent()
1610 self.ira = self.tabsimi.GetParent()
1611 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1612 afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1613 self.butafc = wx.BitmapButton(self, -1, afc_img)
1614 export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1615 self.butexport = wx.BitmapButton(self, -1, export_img)
1616 blender_img = wx.Image(os.path.join(self.ira.images_path,'button_blender.png'), wx.BITMAP_TYPE_ANY)
1617 blender_img.Rescale(32,32)
1618 blender_img = blender_img.ConvertToBitmap()
1619 self.butblender = wx.BitmapButton(self, -1, blender_img)
1620 for i in range(0,len(list_graph)):
1621 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1622 filename, ext = os.path.splitext(list_graph[i][0])
1623 if ext in ['.svg', '.html'] :
1624 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])))
1626 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1627 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1628 self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove)
1629 self.__set_properties()
1632 def __set_properties(self):
1633 self.panel_1.EnableScrolling(True,True)
1634 #self.panel_1.SetSize((1000,1000))
1635 self.panel_1.SetScrollRate(20, 20)
1636 self.panel_1.SetFocus()
1638 def __do_layout(self):
1639 self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1640 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1641 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1642 self.sizer_2.Add(self.butafc, 0, 0, 0)
1643 self.sizer_2.Add(self.butexport, 0, 0, 0)
1644 self.sizer_2.Add(self.butblender, 0, 0, 0)
1645 for i in range(0, len(self.listimg)):
1646 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1647 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1648 self.panel_1.SetSizer(self.sizer_3)
1649 self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1650 self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1651 self.SetSizer(self.sizer_1)
1653 def onMouseMove(self, event):
1654 self.panel_1.SetFocus()