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