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 search_tools import SearchFrame
42 from dialog import PrefGraph, PrefExport, PrefSimpleFile, PrefDendro, SimpleDialog, ImageViewer
43 from guifunct import SelectColumn, PrepSimi, PrefSimi, redosimi
44 from webexport import WebExport
45 from corpus import Corpus
46 from sheet import MySheet
47 from graph_to_json import GraphToJson
55 log = logging.getLogger('iramuteq.layout')
59 class GraphPanelAfc(wx.Panel):
61 def __init__(self, parent, dico, list_graph, clnb, itempath = 'liste_graph_afc', coding = sys.getdefaultencoding()):
62 wx.Panel.__init__(self,parent)
67 self.itempath = itempath
68 self.parent = self.GetParent()
69 self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "Arial"))
73 self.list_graph = list_graph
74 self.TabCHD = self.parent.GetParent()
75 self.nb = self.TabCHD.GetParent()
76 self.ira = self.nb.GetParent()
77 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
78 afc_img = wx.Image(os.path.join(self.ira.images_path,'button_afc.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
79 self.butafc = wx.BitmapButton(self, -1, afc_img)
80 self.Bind(wx.EVT_BUTTON, self.afc_graph, self.butafc)
81 self.dirout = os.path.dirname(self.Dict['ira'])
84 for i in range(0,len(list_graph)):
85 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
86 filename, ext = os.path.splitext(list_graph[i][0])
87 if ext == '.svg' or ext == '.html':
88 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])))
90 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)))
91 self.listimg[-1].Bind(wx.EVT_RIGHT_DOWN, self.onrightclick)
92 if os.path.exists(os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')) :
93 txt = _("List of not plotted points : ") + '%s' % os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')
96 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1] + txt))
97 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = repr(i - b)))
101 self.list_graph = [graph for i, graph in enumerate(self.list_graph) if i not in todel]
102 self.param = { 'typegraph' : 0,
109 'do_select_chi_classe' : 0,
126 self.__set_properties()
129 def __set_properties(self):
130 self.panel_1.EnableScrolling(True,True)
131 #self.panel_1.SetSize((1000,1000))
132 self.panel_1.SetScrollRate(20, 20)
133 self.panel_1.SetFocus()
135 def __do_layout(self):
136 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
137 self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
138 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
139 self.sizer_2.Add(self.butafc, 0, 0, 0)
140 for i in range(0, len(self.listimg)):
141 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
142 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
143 self.sizer_3.Add(self.buts[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
144 self.Bind(wx.EVT_BUTTON, self.on_delete_image, self.buts[i])
145 self.panel_1.SetSizer(self.sizer_3)
146 self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
147 self.SetSizer(self.sizer_2)
149 def on_delete_image(self, event) :
150 image_id = int(event.GetEventObject().GetName())
151 image_path = self.list_graph[image_id][0]
152 message = _('This file will be delete : ') + '%s.\n' % os.path.join(self.dirout, image_path) + _('Are you sure ?')
153 dial = wx.MessageDialog(self, message, style = wx.YES_NO)
154 res = dial.ShowModal()
155 if res == wx.ID_YES :
157 log.info('delete image %i' % image_id)
158 oldimg = self.listimg.pop(image_id)
160 oldlab = self.labels.pop(image_id)
162 oldbut = self.buts.pop(image_id)
164 for i, but in enumerate(self.buts) :
166 self.listimg[i].SetName(repr(i))
167 todel = self.list_graph.pop(image_id)
168 os.remove(os.path.join(self.dirout, todel[0]))
169 print_liste(self.Dict[self.itempath], self.list_graph)
170 self.sizer_3.Fit(self.panel_1)
175 def onrightclick(self, event):
176 image_id = int(event.GetEventObject().GetName())
177 image_path = self.list_graph[image_id][0]
178 viewer = ImageViewer(self, {'tmpgraph' : os.path.join(self.dirout,image_path), 'svg': 'FALSE', 'wildcard': '*.*'}, self.labels[image_id].GetLabelText(), self.listimg[image_id].GetSize())
181 #print self.labels[image_id].GetLabelText()
183 def afc_graph(self,event):
184 #dirout = os.path.dirname(self.Dict['ira'])
185 dial = PrefGraph(self.parent,-1,self.param,'')
186 dial.CenterOnParent()
187 val = dial.ShowModal()
189 if dial.choix_format.GetSelection() == 0 :
193 typegraph = dial.choicetype.GetSelection()
198 if self.clnb <= 3 and typegraph == 1 :
204 while os.path.exists(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile)):
206 self.fileout = ffr(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile))
208 self.param = {'typegraph' : typegraph,
209 'width' : dial.spin1.GetValue(),
210 'height' : dial.spin2.GetValue(),
211 'what' : dial.choice1.GetSelection(),
212 'qui' : dial.choice2.GetSelection(),
213 'do_select_nb' : dial.check1.GetValue(),
214 'do_select_chi' : dial.check2.GetValue(),
215 'do_select_chi_classe' : dial.check_chic.GetValue(),
216 'select_nb' : dial.spin_nb.GetValue(),
217 'select_chi' : dial.spin_chi.GetValue(),
218 'nbchic' : dial.spin_nbchic.GetValue(),
219 'over' : dial.check3.GetValue(),
220 'cex_txt' : dial.check4.GetValue(),
221 'txt_min' : dial.spin_min.GetValue(),
222 'txt_max' : dial.spin_max.GetValue(),
223 'tchi' : dial.check_tchi.GetValue(),
224 'tchi_min' : dial.spin_min_tchi.GetValue(),
225 'tchi_max' : dial.spin_max_tchi.GetValue(),
226 'taillecar' : dial.spin3.GetValue(),
227 'facteur' : [dial.spin_f1.GetValue(),dial.spin_f2.GetValue(), dial.spin_f3.GetValue()],
229 'film' : str(dial.film.GetValue()).upper(),
230 'alpha' : dial.slider_sphere.GetValue(),
233 self.nb.parent = self.ira
234 self.DictPathOut = self.Dict
235 self.RscriptsPath = self.ira.RscriptsPath
238 """ % ffr(self.DictPathOut['RData'])
239 if self.itempath == 'liste_graph_afcf' :
242 afc_table <- afcf_table
243 chistabletot <- specfp
245 elif self.itempath == 'liste_graph_afct' :
248 afc_table <- afct_table
249 chistabletot <- spectp
251 txt += write_afc_graph(self)
252 filetmp = tempfile.mktemp()
253 with open(filetmp, 'w', encoding='utf8') as f :
255 pid = exec_rcode(self.ira.RPath, filetmp)
256 check_Rresult(self.ira, pid)
257 if self.param['typegraph'] != 1 :
259 if self.param['qui'] == 0 : value = 'actives'
260 if self.param['qui'] == 1 : value = 'supplémentaires'
261 if self.param['qui'] == 2 : value = 'étoilées'
262 if self.param['qui'] == 3 : value = 'classes'
264 if self.param['what'] == 0 : value = 'Coordonnées'
265 if self.param['what'] == 1 : value = 'Corrélations'
266 txt += value + ' - facteur %i / %i' % (self.param['facteur'][0], self.param['facteur'][1])
267 if self.param['do_select_nb'] : txt += ' - sélection de %i variables' % self.param['select_nb']
268 if self.param['do_select_chi'] : txt += ' - sélection des variables avec chi2 > %i ' % self.param['select_chi']
269 if self.param['over'] : txt += ' - Eviter les recouvrements'
270 if self.param['cex_txt'] : txt += ' - taille du texte proportionnel à la masse'
271 if self.param['tchi'] : txt += ' - taille du texte proportionnel au chi2 d\'association'
272 #list_graph = read_list_file(self.DictPathOut[self.itempath], self.coding)
273 if self.param['svg'] :
274 filename, ext = os.path.splitext(self.fileout)
275 self.fileout = filename + '.svg'
276 if self.param['typegraph'] == 2 :
277 parametres = {'gexffile' : self.fileout,
279 'nodemin': self.param['txt_min'],
280 'nodemax': self.param['txt_max'],
281 'bargraphw' : 60*int(self.param['clnb']),
283 web = WebExport(self.ira, parametres)
284 self.fileout = web.exportafc()
285 if self.param['typegraph'] == 3 :
286 fileout = os.path.join(os.path.basename(self.fileout), 'index.html')
288 fileout = os.path.basename(self.fileout)
289 self.list_graph.append([fileout, txt])
290 print_liste(self.DictPathOut[self.itempath], self.list_graph)
291 if self.param['svg'] or self.param['typegraph'] == 2:
292 self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, self.fileout, URL=self.fileout))
293 elif self.param['typegraph'] == 3 :
294 fileout = os.path.join(self.fileout,'index.html')
295 self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout))
297 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(self.fileout, wx.BITMAP_TYPE_ANY), name=repr(len(self.list_graph) - 1)))
298 self.listimg[-1].Bind(wx.EVT_RIGHT_DOWN, self.onrightclick)
299 self.sizer_3.Add( self.listimg[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
300 self.labels.append(wx.StaticText(self.panel_1,-1, txt))
301 self.sizer_3.Add(self.labels[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
302 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = repr(len(self.list_graph) - 1)))
303 self.sizer_3.Add(self.buts[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
304 self.sizer_3.Fit(self.panel_1)
307 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
308 # elif self.param['typegraph'] == 2 :
309 # parametres = {'gexffile' : self.fileout,
310 # 'titre': 'Le titre',
311 # 'nodemin': self.param['txt_min'],
312 # 'nodemax': self.param['txt_max'],
313 # 'bargraphw' : 60*int(self.param['clnb']),
315 # web = WebExport(self.ira, parametres)
316 # afcout = web.exportafc()
317 # dial = SimpleDialog(self.ira)
318 # dial.link.SetLabel(afcout)
319 # dial.link.SetURL(afcout)
324 class GraphPanel(wx.ScrolledWindow):
326 def __init__(self, parent, dico, list_graph, txt = '', style = wx.TAB_TRAVERSAL):
327 wx.ScrolledWindow.__init__(self, parent, style = style)
331 self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "Arial"))
334 self.dirout = os.path.dirname(self.Dict['ira'])
335 self.deb = wx.StaticText(self, -1, txt)
336 for i in range(0,len(list_graph)):
337 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
338 filename, ext = os.path.splitext(list_graph[i][0])
340 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])))
342 self.listimg.append(wx.StaticBitmap(self, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
343 self.labels.append(wx.StaticText(self, -1, list_graph[i][1]))
344 self.Bind(wx.EVT_MOTION, self.onMouseMove)
345 self.__set_properties()
348 def __set_properties(self):
349 self.EnableScrolling(True,True)
350 self.SetScrollRate(20, 20)
353 def __do_layout(self):
354 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
355 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
356 self.sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
357 self.sizer_1.Add(self.deb)
358 for i in range(0, len(self.listimg)):
359 self.sizer_1.Add(self.listimg[i], 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
360 self.sizer_1.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
361 self.sizer_2.Add(self.sizer_1, 1, wx.EXPAND, 0)
362 self.SetSizer(self.sizer_1)
363 self.sizer_1.Fit(self)
365 def onMouseMove(self, event):
368 def open_antiprofil(panel, AntiProfile, encoding, title = _("Antiprofiles"), translation = False, lems=None) :
370 DictAnti = ReadProfileAsDico(AntiProfile, True, encoding)
372 DictAnti = AntiProfile
373 panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
374 for i in range(0, panel.parametres['clnb']):
375 tabantiprofile = ProfListctrlPanel(panel.parent, panel, DictAnti[str(i + 1)], True, i + 1, translation = translation)
376 tabantiprofile.lems = lems
377 panel.AntiProfNB.AddPage(tabantiprofile, 'classe %s' % str(i + 1))
378 panel.TabChdSim.AddPage(panel.AntiProfNB, title)
380 def getlemgram(corpus, lem) :
381 if not lem[6] in corpus.lems :
384 return corpus.lems[lem[6]].gram
389 def __init__(self, parent, corpus, parametres, Alceste=False):
393 self.parametres = parametres
394 self.pathout = PathOut(parametres['ira'])
395 self.pathout.basefiles(ChdTxtPathOut)
396 DictPathOut = self.pathout
397 self.DictPathOut = DictPathOut
398 self.dictpathout = DictPathOut
399 self.Alceste = Alceste
400 Profile = DictPathOut['PROFILE_OUT']
401 AntiProfile = DictPathOut['ANTIPRO_OUT']
402 # self.encoding = self.parametres['encoding']
403 if isinstance(self.corpus, Corpus) :
404 self.corpus.make_ucecl_from_R(self.pathout['uce'])
405 corpname = self.corpus.parametres['corpus_name']
407 corpname = self.corpus.parametres['matrix_name']
408 if os.path.exists(self.pathout['analyse.db']) :
409 self.corpus.read_tableau(self.pathout['analyse.db'])
410 clnb = parametres['clnb']
411 dlg = progressbar(self, maxi = 4 + clnb)
413 print('lecture des profils')
414 dlg.Update(2, _("Reading profiles"))
415 DictProfile = ReadProfileAsDico(Profile, Alceste)
416 self.DictProfile = DictProfile
417 self.cluster_size = []
419 for i in range(0, clnb) :
420 clusternames[i] = ' '.join(['%i' % (i + 1), _('Cluster'), '%i' % (i + 1)])
421 if os.path.exists(self.pathout['classes_names.txt']) :
422 with open(self.pathout['classes_names.txt'], 'r', encoding='utf8') as f :
423 clusternames_ = f.read()
424 clusternames_ = dict([[i, ' '.join([repr(i + 1), line])] for i, line in enumerate(clusternames_.splitlines())])
425 clusternames.update(clusternames_)
426 #DictAnti = ReadProfileAsDico(self, AntiProfile, Alceste, self.encoding)
428 # preparation de l'affichage
430 panel = wx.Panel(parent, -1)
431 sizer1 = wx.BoxSizer(wx.VERTICAL)
432 if os.path.exists(DictPathOut['pre_rapport']):
433 with open(DictPathOut['pre_rapport'], 'r', encoding='utf8') as f :
438 # panel.chd_toolbar = wx.ToolBar(panel, -1, wx.DefaultPosition, wx.DefaultSize, wx.TB_FLAT | wx.TB_NODIVIDER)
439 # panel.chd_toolbar.SetToolBitmapSize(wx.Size(16, 16))
440 if isinstance(self.corpus, Corpus) :
441 panel.corpus = self.corpus
443 panel.tableau = self.corpus
444 #self.parent.tableau = panel.tableau
445 panel.dictpathout = self.DictPathOut
446 panel.pathout = self.DictPathOut
447 panel.parent = self.parent
448 panel.DictProfile = self.DictProfile
449 panel.cluster_size = self.cluster_size
450 panel.debtext = self.debtext
451 # self.ID_rapport = wx.NewId()
452 # #rap_img = wx.Image(os.path.join(self.parent.images_path,'icone_rap_16.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
453 # #panel.chd_toolbar.AddLabelTool(self.ID_rapport, "rapport", rap_img, shortHelp=u"Produire le rapport", longHelp=u"Exporter un rapport en texte simple")
454 # butrap = wx.Button(panel.chd_toolbar, self.ID_rapport, u"Rapport ")
455 # panel.chd_toolbar.AddControl(butrap)
456 # panel.chd_toolbar.Realize()
457 # sizer1.Add(panel.chd_toolbar,0, wx.EXPAND, 5)
458 # self.TabChdSim = wx.aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
459 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
460 panel.TabChdSim = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
461 #panel.TabChdSim = LB.LabelBook(panel, -1, agwStyle = INB_TOP|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
462 panel.TabChdSim.SetAGWWindowStyleFlag(notebook_flags)
463 panel.TabChdSim.SetArtProvider(aui.ChromeTabArt())
464 sizer1.Add(panel.TabChdSim,10, wx.EXPAND, 5)
465 panel.SetSizer(sizer1)
467 if isinstance(self.corpus, Corpus) :
468 panel.TabChdSim.corpus = corpus
469 panel.TabChdSim.corpus.dictpathout = self.DictPathOut
471 panel.TabChdSim.tableau = corpus
472 panel.TabChdSim.tableau.dictpathout = self.DictPathOut
473 panel.parametres = self.parametres
475 self.notenb = self.parent.nb.GetPageCount()
476 if os.path.exists(self.DictPathOut['liste_graph_chd']) :
477 list_graph = read_list_file(self.DictPathOut['liste_graph_chd'])
478 CHD = GraphPanelDendro(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
479 panel.TabChdSim.AddPage(CHD,'CHD')
480 # panel.ProfNB.SetArtProvider(aui.ChromeTabArt())
481 # panel.ProfNB = LB.LabelBook(panel, -1, agwStyle = INB_LEFT|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
482 # panel.ProfNB = wx.Listbook(self.parent, -1, style = wx.BK_DEFAULT)
483 # panel.ProfNB = wx.Treebook(self.parent, -1, style = wx.BK_DEFAULT)
484 # self.ProfNB.SetTabCtrlHeight(100)
485 # panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
486 if os.path.exists(DictPathOut['prof_seg']) :
487 prof_seg = ReadProfileAsDico(DictPathOut['prof_seg'], False)
488 self.prof_seg_nb = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
489 panel.ProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
490 notebook_flags |= aui.AUI_NB_WINDOWLIST_BUTTON
491 panel.ProfNB.SetAGWWindowStyleFlag(notebook_flags)
492 for i in range(0, clnb):
493 self.cluster_size.append(DictProfile[str(i + 1)][0][0:3])
494 if isinstance(self.corpus, Corpus) :
495 DictProfile[str(i + 1)][1:] = [val[0:5] + [getlemgram(self.corpus, val)] + val[6:] for val in DictProfile[str(i + 1)][1:]]
496 dlg.Update(3+i, 'Classe %i' %(i+1))
497 ind = '/'.join(DictProfile[str(i + 1)][0][0:2]).strip()
498 indpour = '\n'.join([ind, DictProfile[str(i + 1)][0][2]])
499 self.tabprofile = ProfListctrlPanel(self.parent, self.panel, DictProfile[str(i + 1)], Alceste, i + 1)
500 #self.tabantiprofile = ProfListctrlPanel(self.parent, self, DictAnti[str(i + 1)], Alceste, i + 1)
501 panel.ProfNB.AddPage(self.tabprofile, clusternames[i] + '\n%s%%' % indpour, True)
502 panel.ProfNB.SetPageTextColour(i, '#890909')
503 panel.ProfNB.SetRenamable(i, True)
504 # panel.AntiProfNB.AddPage(self.tabantiprofile, 'classe %s' % str(i + 1))
505 if os.path.exists(DictPathOut['prof_seg']) :
506 self.tab_prof_seg = ProfListctrlPanel(self.parent, self, prof_seg[str(i + 1)], False, i + 1)
507 self.prof_seg_nb.AddPage(self.tab_prof_seg, _("Cluster") + ' %i' % (i + 1))
508 panel.ProfNB.SetSelection(0)
510 self.TabAFC = aui.AuiNotebook(panel.TabChdSim, -1, wx.DefaultPosition)
512 list_graph=read_list_file(DictPathOut['liste_graph_afc'])
513 self.tabAFCGraph = GraphPanelAfc(self.TabAFC, DictPathOut, list_graph, self.clnb)
514 self.TabAFC.AddPage(self.tabAFCGraph, _("CA"))
515 if os.path.exists(self.DictPathOut['afc_facteur']) :
516 dictrow, first = ReadList(self.DictPathOut['afc_facteur'])
517 self.TabAFC_facteur = ListForSpec(self.parent, parametres, dictrow, first[1:])
518 # dictrow, first = ReadList(self.DictPathOut['afc_row'], self.encoding)
519 # self.TabAFC_ligne = ListForSpec(self.parent, self.parametres, dictrow, first)
520 # dictrow, first = ReadList(self.DictPathOut['afc_col'], self.encoding)
521 # self.TabAFC_colonne = ListForSpec(parent, self.parametres, dictrow, first)
522 self.TabAFC.AddPage(self.TabAFC_facteur, _("Factor"))
523 # self.TabAFC.AddPage(self.TabAFC_colonne, 'Colonnes')
524 # self.TabAFC.AddPage(self.TabAFC_ligne, 'Lignes')
525 sizer_3 = wx.BoxSizer(wx.VERTICAL)
526 self.parent.nb_panel_2 = wx.Panel(panel.TabChdSim, -1)
527 self.parent.button_simi = wx.Button(self.parent.nb_panel_2, -1, "Voyager")
528 self.parent.simi3dpanel = simi3d(self.parent.nb_panel_2, -1)
529 sizer_3.Add(self.parent.simi3dpanel, 1, wx.EXPAND, 0)
530 sizer_3.Add(self.parent.button_simi, 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
531 self.parent.nb_panel_2.SetSizer(sizer_3)
532 self.TabAFC.AddPage(self.parent.nb_panel_2, _("3D graph"))
533 self.parent.Bind(wx.EVT_BUTTON, self.onsimi, self.parent.button_simi)
534 panel.TabChdSim.AddPage(panel.ProfNB, _("Profiles"))
535 # panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')
536 dlg.Update(4 + self.clnb, 'Affichage...')
538 panel.TabChdSim.AddPage(self.TabAFC, _("CA"))
539 if os.path.exists(DictPathOut['prof_seg']) :
540 panel.TabChdSim.AddPage(self.prof_seg_nb, _("Repeated segments profiles"))
541 # panel.Bind(wx.EVT_BUTTON, self.ongetrapport, id = self.ID_rapport)
542 if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenchi2.csv')) :
543 self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenchi2.csv')
545 if os.path.exists(self.dictpathout['translations.txt']) :
546 with open(self.dictpathout['translations.txt'], 'r', encoding='utf8') as f:
548 translist = [line.split('\t') for line in translist.splitlines()]
549 for line in translist :
551 panel.TabChdSim.SetSelection(0)
552 self.parent.nb.AddPage(panel, _("Clustering") + ' - %s' % corpname)
553 self.parent.ShowTab(True)
554 self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
555 # for pane in self.parent._mgr.GetAllPanes() :
556 # if isinstance(pane.window, aui.AuiNotebook):
558 # nb.SetAGWWindowStyleFlag(notebook_flags)
559 # nb.SetArtProvider(aui.ChromeTabArt())
561 self.parent._mgr.Update()
563 def opentrans(self, trans) :
564 prof = ReadProfileAsDico(self.dictpathout[trans[0]], False)
565 with open(self.dictpathout[trans[1]], 'r', encoding='utf8') as f :
567 lems = [line.split('\t') for line in lems.splitlines()]
569 open_antiprofil(self.panel, prof, 'utf8', title = trans[0], translation=True, lems=lems)
570 self.panel.lems = lems
571 self.panel.TabChdSim.SetSelection(self.panel.TabChdSim.GetPageCount() - 1)
573 def onsimi(self,event):
574 outfile = print_simi3d(self)
575 error = exec_rcode(self.parent.RPath, outfile, wait = True)
577 def onclusterstat(self, evt) :
578 dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': 'Stat par classe'})
579 dial.fbb.SetValue( os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'stat_par_classe.csv'))
580 dial.CenterOnParent()
581 res = dial.ShowModal()
583 fileout = dial.fbb.GetValue()
585 self.corpus.get_stat_by_cluster(fileout)
587 dlg = wx.MessageDialog(self.parent, msg, _("Stat by cluster"), wx.OK | wx.ICON_INFORMATION)
589 if dlg.ShowModal() == wx.ID_OK :
592 #def onsearchf(self, evt) :
593 # if 'FrameSearch' not in dir(self.panel) :
594 # self.panel.FrameSearch = SearchFrame(self.parent, -1, "Rechercher...", self.corpus)
595 # self.panel.FrameSearch.Show()
597 def PrintRapport(self, corpus, parametres, istxt = True):
601 |i|R|a|M|u|T|e|Q| - %s
605 """ % datetime.datetime.now().ctime()
607 totocc = corpus.gettotocc()
608 txt += ': '.join([_('Number of texts'), '%i%s' % (corpus.getucinb(), sep)])
609 txt += ': '.join([_('Number of text segments'), '%i%s' % (corpus.getucenb(), sep)])
610 txt += ': '.join([_('Number of forms'), '%i%s' % (len(corpus.formes), sep)])
611 txt += ': '.join([_('Number of occurrences'), '%i%s' % (totocc, sep)])
612 #txt += 'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
613 txt += ': '.join([_('Number of lemmas'), '%i%s' % (len(corpus.lems), sep)])
614 txt += ': '.join([_('Number of active forms'), '%i%s' % (corpus.getactivesnb(1), sep)])
615 txt += ': '.join([_('Number of supplementary forms'), '%i%s' % (corpus.getactivesnb(2), sep)])
616 txt += ' >= '.join([_('Number of active forms with a frequency'), '%i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)])
617 txt += ': '.join([_('Mean of forms by segment'), '%f%s' % (float(totocc) / float(corpus.getucenb()), sep)])
618 if 'tailleuc1' in parametres :
619 if parametres['classif_mode'] == 0 :
620 txt += ': '.join([_('Size of rst1 / rst2'), '%i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)])
622 self.Ucenb = self.nbind
623 txt += ': '.join([_('Number of lines'), '%i%s' % (self.nbind, sep)])
624 txt += ': '.join([_('Number of clusters'), '%i%s' % (self.clnb, sep)])
626 txt += ': '.join([_('Number of clusters'), '%i%s' % (parametres['clnb'], sep)])
627 if parametres['classif_mode'] == 0 or parametres['classif_mode'] == 1 :
628 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)])
629 elif self.parametres['classif_mode'] == 2 :
630 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)])
632 txt += ' '.join(['%i' % self.ucecla, _('line classified on'), '%i (%.2f%%)%s' % (self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)])
634 txt += ''.join([sep, '###########################', sep, _('time'), ' : %s' % parametres.get('time', ''), sep, '###########################', sep])
635 # ecriture du resultat dans le fichier
636 with open(self.pathout['pre_rapport'], 'w', encoding='utf8') as f :
640 class SashList(wx.Panel) :
642 def __init__(self, parent) :
643 wx.Panel.__init__(self, parent, -1)
646 #self.gparent=gparent
650 # A window to the left of the client window
651 #self.listlex = listlex
652 self.leftwin1 = wx.SashLayoutWindow(
653 self, -1, wx.DefaultPosition, (200, 300),
654 wx.NO_BORDER|wx.SW_3D
656 self.leftwin1.SetDefaultSize((120, 1000))
657 self.leftwin1.SetOrientation(wx.LAYOUT_VERTICAL)
658 self.leftwin1.SetAlignment(wx.LAYOUT_LEFT)
659 self.leftwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
660 self.leftwin1.SetSashVisible(wx.SASH_RIGHT, True)
661 self.leftwin1.SetExtraBorderSize(10)
662 #textWindow = wx.TextCtrl(
663 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
664 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
666 #textWindow.SetValue("A sub window")
667 self.leftWindow1 = self.leftwin1
668 winids.append(self.leftwin1.GetId())
669 rightwin1 = wx.SashLayoutWindow(
670 self, -1, wx.DefaultPosition, (200, 300),
671 wx.NO_BORDER|wx.SW_3D
673 rightwin1.SetDefaultSize((120, 1000))
674 rightwin1.SetOrientation(wx.LAYOUT_VERTICAL)
675 rightwin1.SetAlignment(wx.LAYOUT_LEFT)
676 rightwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
677 rightwin1.SetSashVisible(wx.SASH_RIGHT, True)
678 rightwin1.SetExtraBorderSize(10)
679 #textWindow = wx.TextCtrl(
680 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
681 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
683 #textWindow.SetValue("A sub window")
684 self.rightwin1 = rightwin1
685 winids.append(rightwin1.GetId())
690 def __init__(self, page):
692 parametres = self.page.parametres
693 ira = wx.GetApp().GetTopWindow()
694 tgenpath = os.path.join(parametres['pathout'], 'tgen.csv')
695 self.page.tgens, etoiles = ReadList(parametres['tgenspec'], ira.syscoding, sep="\t")
696 tgen = TGen(path = tgenpath, encoding = 'UTF-8')
698 tgenlempath = os.path.join(parametres['pathout'], 'tgenlemchi2.csv')
699 if os.path.exists(tgenlempath) :
700 self.page.parametres['tgenlemspec'] = tgenlempath
701 self.page.tgenlem, etoiles = ReadList(self.page.parametres['tgenlemspec'], ira.syscoding, sep="\t")
704 if 'TabChdSim' in dir(page) :
705 page = page.TabChdSim
706 for i in range(page.GetPageCount()) :
707 tab = page.GetPage(i)
708 if 'gparent' in dir(tab) :
709 if tab.gparent is not None :
710 gparent = tab.gparent
711 if 'tgen' in dir(tab) :
716 self.page.tgentab.RefreshData(self.page.tgens)
717 self.page.tgentab.tgens = tgen.tgen
718 self.page.tgentab.tgenlem = self.page.tgenlem
721 self.page.tgentab = ListForSpec(ira, gparent, self.page.tgens, etoiles[1:])
722 self.page.tgentab.tgen = True
723 self.page.tgentab.tgens = tgen.tgen
724 if os.path.exists(tgenlempath) :
725 self.page.tgentab.tgenlem = self.page.tgenlem
726 page.AddPage(self.page.tgentab, _('Tgens Specificities'))
727 page.SetSelection(page.GetPageCount() - 1)
732 def __init__(self, ira, corpus, parametres):
733 self.pathout = PathOut(dirout = parametres['pathout'])
735 self.dictpathout = StatTxtPathOut(parametres['pathout'])
736 #self.corpus.read_corpus_from_shelves(self.corpus.dictpathout['db'])
738 self.corpus.parametres['syscoding'] = 'UTF8'
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 open(self.pathout[lcle[key]], 'r', encoding='utf-8') 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', encoding='utf-8') 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', encoding='utf8') 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', encoding='utf8') 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', encoding='utf8') 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")
1402 class SimiMatLayout(DefaultMatLayout) :
1405 self.pathout.basefiles(simipath)
1406 self.indices = indices_simi
1407 if os.path.exists(self.pathout['liste_graph']) :
1408 list_graph = read_list_file(self.pathout['liste_graph'])
1410 list_graph = [['','']]
1411 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1412 self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1413 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1414 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1415 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1416 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1417 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1418 self.graphpan.Bind(wx.EVT_BUTTON, self.blender, self.graphpan.butblender)
1419 self.tabsimi.AddPage(self.graphpan, _('Graph'))
1420 self.tabsimi.parametres = self.parametres
1421 self.parent.nb.AddPage(self.tabsimi, ' - '.join([_('Graph analysis'), self.parametres['name']]))
1422 #self.parent.ShowTab(True)
1423 #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1425 def redosimi(self,evt) :
1426 with open(self.pathout['selected.csv'],'r', encoding='utf8') as f :
1428 selected = [int(val) for val in selected.splitlines()]
1429 #if self.actives is None :
1430 # with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1431 # self.actives = f.read()
1432 # self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1434 actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1436 actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1437 #self.tableau.make_listactives()
1438 actives = dict([[i, val] for i, val in enumerate(actives)])
1440 #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1441 self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1442 self.dial.CenterOnParent()
1443 self.val = self.dial.ShowModal()
1444 if self.val == wx.ID_OK :
1445 last = self.dial.listcol.GetFirstSelected()
1446 lastl = [self.dial.listcol.GetFirstSelected()]
1447 indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1448 while self.dial.listcol.GetNextSelected(last) != -1:
1449 last = self.dial.listcol.GetNextSelected(last)
1451 indexes.append(self.dial.listcol.getColumnText(last,0))
1452 self.column = [self.tableau.listactives.index(val) for val in indexes]
1454 with open(self.pathout['selected.csv'], 'w', encoding='utf8') as f :
1455 f.write('\n'.join([repr(val) for val in self.column]))
1458 self.script = PrintSimiScript(self)
1459 self.script.make_script()
1460 self.tmpfile = self.script.scriptout
1461 dlg = progressbar(self, maxi = 2)
1464 if self.parametres['type_graph'] == 1:
1465 if self.parametres['svg'] :
1466 filename, ext = os.path.splitext(self.script.filename)
1467 fileout = filename + '.svg'
1469 fileout = self.script.filename
1470 fileout = normpath_win32(fileout)
1471 if os.path.exists(self.pathout['liste_graph']):
1472 graph_simi = read_list_file(self.pathout['liste_graph'])
1473 graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1475 graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1476 print_liste(self.pathout['liste_graph'], graph_simi)
1477 DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1478 if self.parametres['type_graph'] == 1:
1479 if self.parametres['svg'] :
1480 self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1482 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)
1483 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1484 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1485 self.graphpan.Layout()
1486 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1490 def make_param(self) :
1491 if self.parametres['first'] :
1494 keep_coord = self.dial.check_coord.GetValue()
1495 #self.select = self.dial.check_colch.GetValue()
1496 paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1497 'layout' : self.dial.choice2.GetSelection(),
1498 'type_graph' : self.dial.choice3.GetSelection(),
1499 'arbremax' : self.dial.check1.GetValue(),
1500 'coeff_tv' : self.dial.check_s_size.GetValue(),
1501 'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1502 'tvprop' : self.dial.check2.GetValue(),
1503 'tvmin' : self.dial.spin_tvmin.GetValue(),
1504 'tvmax' : self.dial.spin_tvmax.GetValue(),
1505 'coeff_te' : self.dial.check3.GetValue(),
1506 'coeff_temin' : self.dial.spin_temin.GetValue(),
1507 'coeff_temax' : self.dial.spin_temax.GetValue(),
1508 'label_e' : self.dial.check_elab.GetValue(),
1509 'label_v' : self.dial.check_vlab.GetValue(),
1510 'vcex' : self.dial.check_vcex.GetValue(),
1511 'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1512 'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1513 'cex' : self.dial.spin_cex.GetValue(),
1514 'seuil_ok' : self.dial.check_seuil.GetValue(),
1515 'seuil' : self.dial.spin_seuil.GetValue(),
1516 'cols' : self.dial.cols.GetColour(),
1517 'cola' : self.dial.cola.GetColour(),
1518 'width' : self.dial.spin_width.GetValue(),
1519 'height' : self.dial.spin_height.GetValue(),
1521 'keep_coord' : keep_coord,
1522 'alpha' : self.dial.slider_sphere.GetValue(),
1523 'film' : self.dial.film.GetValue(),
1524 'svg' : self.dial.choix_format.GetSelection(),
1525 'halo' : self.dial.halo.GetValue(),
1526 'com' : self.dial.comcheck.GetValue(),
1527 'communities' : self.dial.choix_com.GetSelection(),
1528 'edgecurved' : self.dial.check_curved.GetValue(),
1530 if 'cexfromchi' in self.parametres :
1531 paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1532 if 'sfromchi' in self.parametres :
1533 paramsimi['sfromchi'] = self.dial.checki.GetValue()
1534 if 'vlabcolor' in self.parametres :
1535 paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1536 if 'check_bystar' in dir(self.dial) :
1537 paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1538 paramsimi['stars'] = self.parametres['stars']
1539 self.parametres.update(paramsimi)
1542 if self.parametres['type_graph'] == 1 :
1548 pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1549 if self.parametres['type_graph'] == 1 :
1550 while pid.poll() == None :
1553 check_Rresult(self.parent, pid)
1555 def export(self, evt) :
1557 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1559 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1565 graph <- graph.simi$graph
1566 V(graph)$x <- graph.simi$layout[,1]
1567 V(graph)$y <- graph.simi$layout[,2]
1568 if (length(graph.simi$label.cex == 1)) {
1569 V(graph)$weight <- graph.simi$mat.eff
1571 V(graph)$weight <- graph.simi$label.cex
1573 V(graph)$color <- vertex.label.color
1574 V(graph)$frequences <- graph.simi$mat.eff
1575 V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
1576 V(graph)$label <- as.character(graph.simi$v.label)
1577 E(graph)$weight <- graph.simi$we.width
1578 write.graph(graph, fileout, format = 'graphml')
1579 #saveAsGEXF(graph, filepath = fileout)
1580 """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['simi']), fileout)
1581 filetmp = tempfile.mktemp()
1582 with open(filetmp, 'w', encoding='utf8') as f :
1584 exec_rcode(self.ira.RPath, filetmp)
1585 mss = wx.MessageDialog(self.ira, fileout, _('File exported'), wx.OK)
1586 mss.CenterOnParent()
1590 def blender(self, evt):
1594 class GraphPanelSimi(wx.Panel):
1596 def __init__(self,parent, dico, list_graph):
1597 wx.Panel.__init__(self,parent)
1600 self.dirout = os.path.dirname(self.Dict['ira'])
1601 self.parent = self.GetParent()
1602 self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "courier")) #modifié
1605 self.tabsimi = self.parent.GetParent()
1606 self.ira = self.tabsimi.GetParent()
1607 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1608 afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1609 self.butafc = wx.BitmapButton(self, -1, afc_img)
1610 export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1611 self.butexport = wx.BitmapButton(self, -1, export_img)
1612 blender_img = wx.Image(os.path.join(self.ira.images_path,'button_blender.png'), wx.BITMAP_TYPE_ANY)
1613 blender_img.Rescale(32,32)
1614 blender_img = blender_img.ConvertToBitmap()
1615 self.butblender = wx.BitmapButton(self, -1, blender_img)
1616 for i in range(0,len(list_graph)):
1617 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1618 filename, ext = os.path.splitext(list_graph[i][0])
1619 if ext in ['.svg', '.html'] :
1620 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])))
1622 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1623 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1624 self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove)
1625 self.__set_properties()
1628 def __set_properties(self):
1629 self.panel_1.EnableScrolling(True,True)
1630 #self.panel_1.SetSize((1000,1000))
1631 self.panel_1.SetScrollRate(20, 20)
1632 self.panel_1.SetFocus()
1634 def __do_layout(self):
1635 self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1636 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1637 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1638 self.sizer_2.Add(self.butafc, 0, 0, 0)
1639 self.sizer_2.Add(self.butexport, 0, 0, 0)
1640 self.sizer_2.Add(self.butblender, 0, 0, 0)
1641 for i in range(0, len(self.listimg)):
1642 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1643 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1644 self.panel_1.SetSizer(self.sizer_3)
1645 self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1646 self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1647 self.SetSizer(self.sizer_1)
1649 def onMouseMove(self, event):
1650 self.panel_1.SetFocus()