2 # -*- coding: utf-8 -*-
3 #Author: Pierre Ratinaud
4 #Copyright (c) 2008-2009 Pierre Ratinaud
9 import wx.lib.hyperlink as hl
10 import wx.lib.agw.aui as aui
11 import wx.lib.agw.labelbook as LB
12 from wx.lib.agw.fmresources import *
13 from chemins import ConstructPathOut, ChdTxtPathOut, FFF, ffr, PathOut, StatTxtPathOut, simipath
14 from ConfigParser import ConfigParser
15 from functions import ReadProfileAsDico, GetTxtProfile, read_list_file, ReadList, exec_rcode, print_liste, BugReport, DoConf, indices_simi, check_Rresult, progressbar, normpath_win32, TGen
16 from ProfList import ProfListctrlPanel
17 from guiparam3d import param3d, simi3d
18 from PrintRScript import write_afc_graph, print_simi3d, PrintSimiScript
19 from profile_segment import ProfileSegment
20 from functions import ReadList, launchcommand
23 from search_tools import SearchFrame
24 from dialog import PrefGraph, PrefExport, PrefSimpleFile, PrefDendro, SimpleDialog, ImageViewer
25 from guifunct import SelectColumn, PrepSimi, PrefSimi, redosimi
26 from webexport import WebExport
27 from corpus import Corpus
28 from sheet import MySheet
32 from time import sleep
37 from graph_to_json import GraphToJson
40 log = logging.getLogger('iramuteq.layout')
43 class GraphPanelAfc(wx.Panel):
44 def __init__(self, parent, dico, list_graph, clnb, itempath = 'liste_graph_afc', coding = sys.getdefaultencoding()):
45 wx.Panel.__init__(self,parent)
50 self.itempath = itempath
51 self.parent = self.GetParent()#parent
52 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
56 self.list_graph = list_graph
57 self.TabCHD = self.parent.GetParent()
58 self.nb = self.TabCHD.GetParent()
59 self.ira = self.nb.GetParent()
60 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
61 afc_img = wx.Image(os.path.join(self.ira.images_path,'button_afc.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
62 self.butafc = wx.BitmapButton(self, -1, afc_img)
63 self.Bind(wx.EVT_BUTTON, self.afc_graph, self.butafc)
64 self.dirout = os.path.dirname(self.Dict['ira'])
67 for i in range(0,len(list_graph)):
68 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
69 filename, ext = os.path.splitext(list_graph[i][0])
70 if ext == '.svg' or ext == '.html':
71 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])))
73 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=`i-b`))
74 self.listimg[-1].Bind(wx.EVT_RIGHT_DOWN, self.onrightclick)
75 if os.path.exists(os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')) :
76 txt = _(u"List of not plotted points : ").decode('utf8') + '%s' % os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')
79 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1] + txt))
80 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = `i - b`))
84 self.list_graph = [graph for i, graph in enumerate(self.list_graph) if i not in todel]
86 self.param = { 'typegraph' : 0,
93 'do_select_chi_classe' : 0,
111 self.__set_properties()
114 def __set_properties(self):
115 self.panel_1.EnableScrolling(True,True)
116 #self.panel_1.SetSize((1000,1000))
117 self.panel_1.SetScrollRate(20, 20)
118 self.panel_1.SetFocus()
120 def __do_layout(self):
121 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
122 self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
123 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
124 self.sizer_2.Add(self.butafc, 0, 0, 0)
125 for i in range(0, len(self.listimg)):
126 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
127 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
128 self.sizer_3.Add(self.buts[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
129 self.Bind(wx.EVT_BUTTON, self.on_delete_image, self.buts[i])
130 self.panel_1.SetSizer(self.sizer_3)
131 self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
132 self.SetSizer(self.sizer_2)
134 def on_delete_image(self, event) :
135 image_id = int(event.GetEventObject().GetName())
136 image_path = self.list_graph[image_id][0]
137 message = _(u'This file will be delete : ') + '%s.\n' % os.path.join(self.dirout, image_path) + _('Are you sure ?')
138 dial = wx.MessageDialog(self, message, style = wx.YES_NO)
139 res = dial.ShowModal()
140 if res == wx.ID_YES :
142 log.info('delete image %i' % image_id)
143 oldimg = self.listimg.pop(image_id)
145 oldlab = self.labels.pop(image_id)
147 oldbut = self.buts.pop(image_id)
149 for i, but in enumerate(self.buts) :
151 self.listimg[i].SetName(`i`)
152 todel = self.list_graph.pop(image_id)
153 os.remove(os.path.join(self.dirout, todel[0]))
154 print_liste(self.Dict[self.itempath], self.list_graph)
155 self.sizer_3.Fit(self.panel_1)
160 def onrightclick(self, event):
161 image_id = int(event.GetEventObject().GetName())
162 image_path = self.list_graph[image_id][0]
163 viewer = ImageViewer(self, {'tmpgraph' : os.path.join(self.dirout,image_path), 'svg': 'FALSE', 'wildcard': '*.*'}, self.labels[image_id].GetLabelText(), self.listimg[image_id].GetSize())
166 #print self.labels[image_id].GetLabelText()
168 def afc_graph(self,event):
169 #dirout = os.path.dirname(self.Dict['ira'])
170 dial = PrefGraph(self.parent,-1,self.param,'')
171 dial.CenterOnParent()
172 val = dial.ShowModal()
174 if dial.choix_format.GetSelection() == 0 :
178 typegraph = dial.choicetype.GetSelection()
183 if self.clnb <= 3 and typegraph == 1 :
189 while os.path.exists(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile)):
191 self.fileout = ffr(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile))
193 self.param = {'typegraph' : typegraph,
194 'width' : dial.spin1.GetValue(),
195 'height' : dial.spin2.GetValue(),
196 'what' : dial.choice1.GetSelection(),
197 'qui' : dial.choice2.GetSelection(),
198 'do_select_nb' : dial.check1.GetValue(),
199 'do_select_chi' : dial.check2.GetValue(),
200 'do_select_chi_classe' : dial.check_chic.GetValue(),
201 'select_nb' : dial.spin_nb.GetValue(),
202 'select_chi' : dial.spin_chi.GetValue(),
203 'nbchic' : dial.spin_nbchic.GetValue(),
204 'over' : dial.check3.GetValue(),
205 'cex_txt' : dial.check4.GetValue(),
206 'txt_min' : dial.spin_min.GetValue(),
207 'txt_max' : dial.spin_max.GetValue(),
208 'tchi' : dial.check_tchi.GetValue(),
209 'tchi_min' : dial.spin_min_tchi.GetValue(),
210 'tchi_max' : dial.spin_max_tchi.GetValue(),
211 'taillecar' : dial.spin3.GetValue(),
212 'facteur' : [dial.spin_f1.GetValue(),dial.spin_f2.GetValue(), dial.spin_f3.GetValue()],
214 'film' : str(dial.film.GetValue()).upper(),
215 'alpha' : dial.slider_sphere.GetValue(),
218 self.nb.parent = self.ira
219 self.DictPathOut = self.Dict
220 self.RscriptsPath = self.ira.RscriptsPath
223 """ % ffr(self.DictPathOut['RData'])
224 if self.itempath == 'liste_graph_afcf' :
227 afc_table <- afcf_table
228 chistabletot <- specfp
230 elif self.itempath == 'liste_graph_afct' :
233 afc_table <- afct_table
234 chistabletot <- spectp
236 txt += write_afc_graph(self)
237 filetmp = tempfile.mktemp()
238 with open(filetmp, 'w') as f :
240 pid = exec_rcode(self.ira.RPath, filetmp)
241 check_Rresult(self.ira, pid)
242 if self.param['typegraph'] != 1 :
244 if self.param['qui'] == 0 : value = u'actives'
245 if self.param['qui'] == 1 : value = u'supplémentaires'
246 if self.param['qui'] == 2 : value = u'étoilées'
247 if self.param['qui'] == 3 : value = u'classes'
249 if self.param['what'] == 0 : value = u'Coordonnées'
250 if self.param['what'] == 1 : value = u'Corrélations'
251 txt += value + u' - facteur %i / %i' % (self.param['facteur'][0], self.param['facteur'][1])
252 if self.param['do_select_nb'] : txt += u' - sélection de %i variables' % self.param['select_nb']
253 if self.param['do_select_chi'] : txt += u' - sélection des variables avec chi2 > %i ' % self.param['select_chi']
254 if self.param['over'] : txt += u' - Eviter les recouvrements'
255 if self.param['cex_txt'] : txt += u' - taille du texte proportionnel à la masse'
256 if self.param['tchi'] : txt += u' - taille du texte proportionnel au chi2 d\'association'
257 #list_graph = read_list_file(self.DictPathOut[self.itempath], self.coding)
258 if self.param['svg'] :
259 filename, ext = os.path.splitext(self.fileout)
260 self.fileout = filename + '.svg'
261 if self.param['typegraph'] == 2 :
262 parametres = {'gexffile' : self.fileout,
264 'nodemin': self.param['txt_min'],
265 'nodemax': self.param['txt_max'],
266 'bargraphw' : 60*int(self.param['clnb']),
268 web = WebExport(self.ira, parametres)
269 self.fileout = web.exportafc()
270 if self.param['typegraph'] == 3 :
271 fileout = os.path.join(os.path.basename(self.fileout), 'index.html')
273 fileout = os.path.basename(self.fileout)
274 self.list_graph.append([fileout, txt])
275 print_liste(self.DictPathOut[self.itempath], self.list_graph)
276 if self.param['svg'] or self.param['typegraph'] == 2:
277 self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, self.fileout, URL=self.fileout))
278 elif self.param['typegraph'] == 3 :
279 fileout = os.path.join(self.fileout,'index.html')
280 self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout))
282 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(self.fileout, wx.BITMAP_TYPE_ANY), name=`len(self.list_graph) - 1`))
283 self.listimg[-1].Bind(wx.EVT_RIGHT_DOWN, self.onrightclick)
284 self.sizer_3.Add( self.listimg[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
285 self.labels.append(wx.StaticText(self.panel_1,-1, txt))
286 self.sizer_3.Add(self.labels[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
287 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = `len(self.list_graph) - 1`))
288 self.sizer_3.Add(self.buts[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
289 self.sizer_3.Fit(self.panel_1)
292 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
293 # elif self.param['typegraph'] == 2 :
294 # parametres = {'gexffile' : self.fileout,
295 # 'titre': 'Le titre',
296 # 'nodemin': self.param['txt_min'],
297 # 'nodemax': self.param['txt_max'],
298 # 'bargraphw' : 60*int(self.param['clnb']),
300 # web = WebExport(self.ira, parametres)
301 # afcout = web.exportafc()
302 # dial = SimpleDialog(self.ira)
303 # dial.link.SetLabel(afcout)
304 # dial.link.SetURL(afcout)
309 class GraphPanel(wx.ScrolledWindow):
310 def __init__(self, parent, dico, list_graph, txt = '', style = wx.TAB_TRAVERSAL):
311 wx.ScrolledWindow.__init__(self, parent, style = style)
315 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
318 self.dirout = os.path.dirname(self.Dict['ira'])
319 self.deb = wx.StaticText(self, -1, txt)
320 for i in range(0,len(list_graph)):
321 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
322 filename, ext = os.path.splitext(list_graph[i][0])
324 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])))
326 self.listimg.append(wx.StaticBitmap(self, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
327 self.labels.append(wx.StaticText(self, -1, list_graph[i][1]))
328 self.Bind(wx.EVT_MOTION, self.onMouseMove)
329 self.__set_properties()
332 def __set_properties(self):
333 self.EnableScrolling(True,True)
334 self.SetScrollRate(20, 20)
338 def __do_layout(self):
339 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
340 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
341 self.sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
342 self.sizer_1.Add(self.deb)
343 for i in range(0, len(self.listimg)):
344 self.sizer_1.Add(self.listimg[i], 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
345 self.sizer_1.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
346 self.sizer_2.Add(self.sizer_1, 1, wx.EXPAND, 0)
347 self.SetSizer(self.sizer_1)
348 self.sizer_1.Fit(self)
350 def onMouseMove(self, event):
354 def open_antiprofil(panel, AntiProfile, encoding, title = _(u"Antiprofiles").decode('utf8'), translation = False, lems=None) :
356 DictAnti = ReadProfileAsDico(AntiProfile, True, encoding)
358 DictAnti = AntiProfile
359 panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
360 for i in range(0, panel.parametres['clnb']):
361 tabantiprofile = ProfListctrlPanel(panel.parent, panel, DictAnti[str(i + 1)], True, i + 1, translation = translation)
362 tabantiprofile.lems = lems
363 panel.AntiProfNB.AddPage(tabantiprofile, 'classe %s' % str(i + 1))
364 panel.TabChdSim.AddPage(panel.AntiProfNB, title)
366 def getlemgram(corpus, lem) :
367 if not lem[6] in corpus.lems :
370 return corpus.lems[lem[6]].gram
373 def __init__(self, parent, corpus, parametres, Alceste=False):
378 self.parametres = parametres
379 self.pathout = PathOut(parametres['ira'])
380 self.pathout.basefiles(ChdTxtPathOut)
381 DictPathOut = self.pathout
382 self.DictPathOut = DictPathOut
383 self.dictpathout = DictPathOut
384 self.Alceste = Alceste
386 Profile = DictPathOut['PROFILE_OUT']
387 AntiProfile = DictPathOut['ANTIPRO_OUT']
388 self.encoding = self.parametres['encoding']
389 if isinstance(self.corpus, Corpus) :
390 self.corpus.make_ucecl_from_R(self.pathout['uce'])
391 corpname = self.corpus.parametres['corpus_name']
393 corpname = self.corpus.parametres['matrix_name']
394 if os.path.exists(self.pathout['analyse.db']) :
395 self.corpus.read_tableau(self.pathout['analyse.db'])
397 clnb = parametres['clnb']
398 dlg = progressbar(self, maxi = 4 + clnb)
400 print 'lecture des profils'
401 dlg.Update(2, _(u"Reading profiles").decode('utf8'))
403 DictProfile = ReadProfileAsDico(Profile, Alceste, self.encoding)
404 self.DictProfile = DictProfile
405 self.cluster_size = []
407 for i in range(0, clnb) :
408 clusternames[i] = ' '.join([u'%i' % (i + 1), _(u'Cluster').decode('utf8'), u'%i' % (i + 1)])
409 if os.path.exists(self.pathout['classes_names.txt']) :
410 with codecs.open(self.pathout['classes_names.txt'], 'r', self.parent.syscoding) as f :
411 clusternames_ = f.read()
412 clusternames_ = dict([[i, ' '.join([`i + 1`, line])] for i, line in enumerate(clusternames_.splitlines())])
413 clusternames.update(clusternames_)
414 #print 'lecture des antiprofils'
415 #DictAnti = ReadProfileAsDico(self, AntiProfile, Alceste, self.encoding)
417 panel = wx.Panel(parent, -1)
418 sizer1 = wx.BoxSizer(wx.VERTICAL)
420 if os.path.exists(DictPathOut['pre_rapport']):
421 with codecs.open(DictPathOut['pre_rapport'], 'r', self.encoding) as f :
426 # panel.chd_toolbar = wx.ToolBar(panel, -1, wx.DefaultPosition, wx.DefaultSize, wx.TB_FLAT | wx.TB_NODIVIDER)
427 # panel.chd_toolbar.SetToolBitmapSize(wx.Size(16, 16))
429 if isinstance(self.corpus, Corpus) :
430 panel.corpus = self.corpus
432 panel.tableau = self.corpus
433 #self.parent.tableau = panel.tableau
434 panel.dictpathout = self.DictPathOut
435 panel.pathout = self.DictPathOut
436 panel.parent = self.parent
437 panel.DictProfile = self.DictProfile
438 panel.cluster_size = self.cluster_size
439 panel.debtext = self.debtext
441 # self.ID_rapport = wx.NewId()
442 # #rap_img = wx.Image(os.path.join(self.parent.images_path,'icone_rap_16.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
443 # #panel.chd_toolbar.AddLabelTool(self.ID_rapport, "rapport", rap_img, shortHelp=u"Produire le rapport", longHelp=u"Exporter un rapport en texte simple")
444 # butrap = wx.Button(panel.chd_toolbar, self.ID_rapport, u"Rapport ")
445 # panel.chd_toolbar.AddControl(butrap)
447 # panel.chd_toolbar.Realize()
448 # sizer1.Add(panel.chd_toolbar,0, wx.EXPAND, 5)
450 #self.TabChdSim = wx.aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
451 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
452 panel.TabChdSim = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
453 #panel.TabChdSim = LB.LabelBook(panel, -1, agwStyle = INB_TOP|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
454 panel.TabChdSim.SetAGWWindowStyleFlag(notebook_flags)
455 panel.TabChdSim.SetArtProvider(aui.ChromeTabArt())
456 sizer1.Add(panel.TabChdSim,10, wx.EXPAND, 5)
457 panel.SetSizer(sizer1)
461 if isinstance(self.corpus, Corpus) :
462 panel.TabChdSim.corpus = corpus
463 panel.TabChdSim.corpus.dictpathout = self.DictPathOut
465 panel.TabChdSim.tableau = corpus
466 panel.TabChdSim.tableau.dictpathout = self.DictPathOut
467 panel.parametres = self.parametres
470 self.notenb = self.parent.nb.GetPageCount()
473 if os.path.exists(self.DictPathOut['liste_graph_chd']) :
474 list_graph = read_list_file(self.DictPathOut['liste_graph_chd'], self.encoding)
475 CHD = GraphPanelDendro(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
476 panel.TabChdSim.AddPage(CHD,'CHD')
479 #panel.ProfNB.SetArtProvider(aui.ChromeTabArt())
480 #panel.ProfNB = LB.LabelBook(panel, -1, agwStyle = INB_LEFT|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
481 #panel.ProfNB = wx.Listbook(self.parent, -1, style = wx.BK_DEFAULT)
482 #panel.ProfNB = wx.Treebook(self.parent, -1, style = wx.BK_DEFAULT)
483 #self.ProfNB.SetTabCtrlHeight(100)
484 #panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
485 if os.path.exists(DictPathOut['prof_seg']) :
486 prof_seg = ReadProfileAsDico(DictPathOut['prof_seg'], False, self.encoding)
487 self.prof_seg_nb = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
490 panel.ProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
491 notebook_flags |= aui.AUI_NB_WINDOWLIST_BUTTON
492 panel.ProfNB.SetAGWWindowStyleFlag(notebook_flags)
493 for i in range(0, clnb):
494 self.cluster_size.append(DictProfile[str(i + 1)][0][0:3])
495 if isinstance(self.corpus, Corpus) :
496 DictProfile[str(i + 1)][1:] = [val[0:5] + [getlemgram(self.corpus, val)] + val[6:] for val in DictProfile[str(i + 1)][1:]]
497 dlg.Update(3+i, 'Classe %i' %(i+1))
498 ind = '/'.join(DictProfile[str(i + 1)][0][0:2]).strip()
499 indpour = '\n'.join([ind, DictProfile[str(i + 1)][0][2]])
500 self.tabprofile = ProfListctrlPanel(self.parent, self.panel, DictProfile[str(i + 1)], Alceste, i + 1)
501 #self.tabantiprofile = ProfListctrlPanel(self.parent, self, DictAnti[str(i + 1)], Alceste, i + 1)
502 panel.ProfNB.AddPage(self.tabprofile, clusternames[i] + '\n%s%%' % indpour, True)
503 panel.ProfNB.SetPageTextColour(i, '#890909')
504 panel.ProfNB.SetRenamable(i, True)
505 #panel.AntiProfNB.AddPage(self.tabantiprofile, 'classe %s' % str(i + 1))
506 if os.path.exists(DictPathOut['prof_seg']) :
507 self.tab_prof_seg = ProfListctrlPanel(self.parent, self, prof_seg[str(i + 1)], False, i + 1)
508 self.prof_seg_nb.AddPage(self.tab_prof_seg, _(u"Cluster").decode('utf8') + ' %i' % (i + 1))
509 panel.ProfNB.SetSelection(0)
512 self.TabAFC = aui.AuiNotebook(panel.TabChdSim, -1, wx.DefaultPosition)
514 list_graph=read_list_file(DictPathOut['liste_graph_afc'], self.encoding)
515 self.tabAFCGraph = GraphPanelAfc(self.TabAFC, DictPathOut, list_graph, self.clnb, coding=self.encoding)
516 self.TabAFC.AddPage(self.tabAFCGraph, _(u"CA").decode('utf8'))
518 if os.path.exists(self.DictPathOut['afc_facteur']) :
519 dictrow, first = ReadList(self.DictPathOut['afc_facteur'], self.encoding)
520 self.TabAFC_facteur = ListForSpec(self.parent, parametres, dictrow, first[1:])
521 #dictrow, first = ReadList(self.DictPathOut['afc_row'], self.encoding)
522 #self.TabAFC_ligne = ListForSpec(self.parent, self.parametres, dictrow, first)
523 #dictrow, first = ReadList(self.DictPathOut['afc_col'], self.encoding)
524 #self.TabAFC_colonne = ListForSpec(parent, self.parametres, dictrow, first)
525 self.TabAFC.AddPage(self.TabAFC_facteur, _(u"Factor").decode('utf8'))
526 #self.TabAFC.AddPage(self.TabAFC_colonne, u'Colonnes')
527 #self.TabAFC.AddPage(self.TabAFC_ligne, u'Lignes')
529 sizer_3 = wx.BoxSizer(wx.VERTICAL)
530 self.parent.nb_panel_2 = wx.Panel(panel.TabChdSim, -1)
531 self.parent.button_simi = wx.Button(self.parent.nb_panel_2, -1, "Voyager")
532 self.parent.simi3dpanel = simi3d(self.parent.nb_panel_2, -1)
533 sizer_3.Add(self.parent.simi3dpanel, 1, wx.EXPAND, 0)
534 sizer_3.Add(self.parent.button_simi, 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
535 self.parent.nb_panel_2.SetSizer(sizer_3)
536 self.TabAFC.AddPage(self.parent.nb_panel_2, _(u"3D graph").decode('utf8'))
537 self.parent.Bind(wx.EVT_BUTTON, self.onsimi, self.parent.button_simi)
539 panel.TabChdSim.AddPage(panel.ProfNB, _(u"Profiles").decode('utf8'))
540 #panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')
541 dlg.Update(4 + self.clnb, 'Affichage...')
543 panel.TabChdSim.AddPage(self.TabAFC, _(u"CA").decode('utf8'))
544 if os.path.exists(DictPathOut['prof_seg']) :
545 panel.TabChdSim.AddPage(self.prof_seg_nb, _(u"Repeated segments profiles").decode('utf8'))
547 # panel.Bind(wx.EVT_BUTTON, self.ongetrapport, id = self.ID_rapport)
548 if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenchi2.csv')) :
549 self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenchi2.csv')
552 if os.path.exists(self.dictpathout['translations.txt']) :
553 with codecs.open(self.dictpathout['translations.txt'], 'r', 'utf8') as f:
555 translist = [line.split('\t') for line in translist.splitlines()]
556 for line in translist :
559 panel.TabChdSim.SetSelection(0)
560 self.parent.nb.AddPage(panel, _(u"Clustering").decode('utf8') + ' - %s' % corpname)
561 self.parent.ShowTab(True)
562 self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
563 #for pane in self.parent._mgr.GetAllPanes() :
564 # if isinstance(pane.window, aui.AuiNotebook):
566 # nb.SetAGWWindowStyleFlag(notebook_flags)
567 # nb.SetArtProvider(aui.ChromeTabArt())
571 self.parent._mgr.Update()
573 def opentrans(self, trans) :
574 prof = ReadProfileAsDico(self.dictpathout[trans[0]], False, 'utf8')
575 with codecs.open(self.dictpathout[trans[1]], 'r', 'utf8') as f :
577 lems = [line.split('\t') for line in lems.splitlines()]
579 open_antiprofil(self.panel, prof, 'utf8', title = trans[0], translation=True, lems=lems)
580 self.panel.lems = lems
581 self.panel.TabChdSim.SetSelection(self.panel.TabChdSim.GetPageCount() - 1)
583 def onsimi(self,event):
584 outfile = print_simi3d(self)
585 error = exec_rcode(self.parent.RPath, outfile, wait = True)
587 def onclusterstat(self, evt) :
588 dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': 'Stat par classe'})
589 dial.fbb.SetValue( os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'stat_par_classe.csv'))
590 dial.CenterOnParent()
591 res = dial.ShowModal()
593 fileout = dial.fbb.GetValue()
595 self.corpus.get_stat_by_cluster(fileout)
597 dlg = wx.MessageDialog(self.parent, msg, _(u"Stat by cluster").decode('utf8'), wx.OK | wx.ICON_INFORMATION)
599 if dlg.ShowModal() == wx.ID_OK :
602 #def onsearchf(self, evt) :
603 # if 'FrameSearch' not in dir(self.panel) :
604 # self.panel.FrameSearch = SearchFrame(self.parent, -1, u"Rechercher...", self.corpus)
605 # self.panel.FrameSearch.Show()
607 def PrintRapport(self, corpus, parametres, istxt = True):
611 |i|R|a|M|u|T|e|Q| - %s
615 """ % datetime.datetime.now().ctime()
617 totocc = corpus.gettotocc()
618 txt += ': '.join([_(u'Number of texts').decode('utf8'), u'%i%s' % (corpus.getucinb(), sep)])
619 txt += ': '.join([_(u'Number of text segments').decode('utf8'), '%i%s' % (corpus.getucenb(), sep)])
620 txt += ': '.join([_(u'Number of forms').decode('utf8'), '%i%s' % (len(corpus.formes), sep)])
621 txt += ': '.join([_(u'Number of occurrences').decode('utf8'), '%i%s' % (totocc, sep)])
622 #txt += u'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
623 txt += ': '.join([_(u'Number of lemmas').decode('utf8'), '%i%s' % (len(corpus.lems), sep)])
624 txt += ': '.join([_(u'Number of active forms').decode('utf8'), '%i%s' % (corpus.getactivesnb(1), sep)])
625 txt += ': '.join([_(u'Number of supplementary forms').decode('utf8'), '%i%s' % (corpus.getactivesnb(2), sep)])
626 txt += ' >= '.join([_(u'Number of active forms with a frequency').decode('utf8'), '%i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)])
627 txt += ': '.join([_(u'Mean of forms by segment').decode('utf8'), '%f%s' % (float(totocc) / float(corpus.getucenb()), sep)])
628 if 'tailleuc1' in parametres :
629 if parametres['classif_mode'] == 0 :
630 txt += ': '.join([_(u'Size of rst1 / rst2').decode('utf8'), '%i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)])
632 self.Ucenb = self.nbind
633 txt += ': '.join([_(u'Number of lines').decode('utf8'), '%i%s' % (self.nbind, sep)])
634 txt += ': '.join([_(u'Number of clusters').decode('utf8'), '%i%s' % (self.clnb, sep)])
636 txt += ': '.join([_(u'Number of clusters').decode('utf8'), '%i%s' % (parametres['clnb'], sep)])
637 if parametres['classif_mode'] == 0 or parametres['classif_mode'] == 1 :
638 txt += ' '.join(['%i' % sum([len(cl) for cl in corpus.lc]), _(u'segments classified on').decode('utf8'), '%i (%.2f%%)%s' % (corpus.getucenb(), (float(sum([len(cl) for cl in corpus.lc])) / float(corpus.getucenb())) * 100, sep)])
639 elif self.parametres['classif_mode'] == 2 :
640 txt += ' '.join([u'%i' % sum([len(cl) for cl in corpus.lc]), _(u'texts classified on').decode('utf8'), '%i (%.2f%%)%s' % (corpus.getucinb(), (float(sum([len(cl) for cl in corpus.lc]))) / float(corpus.getucinb()) * 100, sep)])
642 txt += ' '.join(['%i' % self.ucecla, _(u'line classified on').decode('utf8'), '%i (%.2f%%)%s' % (self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)])
644 txt += ''.join([sep, u'###########################', sep, _(u'time').decode('utf8'), ' : %s' % parametres.get('time', ''), sep, u'###########################', sep])
646 with open(self.pathout['pre_rapport'], 'w') as f :
650 class SashList(wx.Panel) :
651 def __init__(self, parent) :
652 wx.Panel.__init__(self, parent, -1)
655 #self.gparent=gparent
659 # A window to the left of the client window
660 #self.listlex = listlex
661 self.leftwin1 = wx.SashLayoutWindow(
662 self, -1, wx.DefaultPosition, (200, 300),
663 wx.NO_BORDER|wx.SW_3D
666 self.leftwin1.SetDefaultSize((120, 1000))
667 self.leftwin1.SetOrientation(wx.LAYOUT_VERTICAL)
668 self.leftwin1.SetAlignment(wx.LAYOUT_LEFT)
669 self.leftwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
670 self.leftwin1.SetSashVisible(wx.SASH_RIGHT, True)
671 self.leftwin1.SetExtraBorderSize(10)
673 #textWindow = wx.TextCtrl(
674 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
675 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
678 #textWindow.SetValue("A sub window")
680 self.leftWindow1 = self.leftwin1
681 winids.append(self.leftwin1.GetId())
683 rightwin1 = wx.SashLayoutWindow(
684 self, -1, wx.DefaultPosition, (200, 300),
685 wx.NO_BORDER|wx.SW_3D
688 rightwin1.SetDefaultSize((120, 1000))
689 rightwin1.SetOrientation(wx.LAYOUT_VERTICAL)
690 rightwin1.SetAlignment(wx.LAYOUT_LEFT)
691 rightwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
692 rightwin1.SetSashVisible(wx.SASH_RIGHT, True)
693 rightwin1.SetExtraBorderSize(10)
694 #textWindow = wx.TextCtrl(
695 # leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
696 # wx.TE_MULTILINE|wx.SUNKEN_BORDER
699 #textWindow.SetValue("A sub window")
701 self.rightwin1 = rightwin1
702 winids.append(rightwin1.GetId())
705 def __init__(self, page):
707 parametres = self.page.parametres
708 ira = wx.GetApp().GetTopWindow()
709 tgenpath = os.path.join(parametres['pathout'], 'tgen.csv')
710 self.page.tgens, etoiles = ReadList(parametres['tgenspec'], ira.syscoding, sep="\t")
711 tgen = TGen(path = tgenpath, encoding = parametres['encoding'])
713 tgenlempath = os.path.join(parametres['pathout'], 'tgenlemchi2.csv')
714 if os.path.exists(tgenlempath) :
715 self.page.parametres['tgenlemspec'] = tgenlempath
716 self.page.tgenlem, etoiles = ReadList(self.page.parametres['tgenlemspec'], ira.syscoding, sep="\t")
719 if 'TabChdSim' in dir(page) :
720 page = page.TabChdSim
721 for i in range(page.GetPageCount()) :
722 tab = page.GetPage(i)
723 if 'gparent' in dir(tab) :
724 if tab.gparent is not None :
725 gparent = tab.gparent
726 if 'tgen' in dir(tab) :
732 self.page.tgentab.RefreshData(self.page.tgens)
733 self.page.tgentab.tgens = tgen.tgen
734 self.page.tgentab.tgenlem = self.page.tgenlem
737 self.page.tgentab = ListForSpec(ira, gparent, self.page.tgens, etoiles[1:])
738 self.page.tgentab.tgen = True
739 self.page.tgentab.tgens = tgen.tgen
740 if os.path.exists(tgenlempath) :
741 self.page.tgentab.tgenlem = self.page.tgenlem
742 page.AddPage(self.page.tgentab, _(u'Tgens Specificities').decode('utf8'))
743 page.SetSelection(page.GetPageCount() - 1)
746 def __init__(self, ira, corpus, parametres):
747 self.pathout = PathOut(dirout = parametres['pathout'])
749 self.dictpathout = StatTxtPathOut(parametres['pathout'])
750 #self.corpus.read_corpus_from_shelves(self.corpus.dictpathout['db'])
752 self.encoding = self.corpus.parametres['syscoding']
753 self.parametres = parametres
755 self.DictSpec, first = ReadList(self.dictpathout['tablespecf'], self.corpus.parametres['syscoding'])
756 if os.path.exists(self.pathout['banalites.csv']) :
757 self.dictban, firstban = ReadList(self.pathout['banalites.csv'], self.corpus.parametres['syscoding'])
758 self.DictType, firstt = ReadList(self.dictpathout['tablespect'], self.corpus.parametres['syscoding'])
759 self.DictEff, firsteff = ReadList(self.dictpathout['tableafcm'], self.corpus.parametres['syscoding'])
760 self.DictEffType, firstefft = ReadList(self.dictpathout['tabletypem'], self.corpus.parametres['syscoding'])
761 self.DictEffRelForme, firsteffrelf = ReadList(self.dictpathout['eff_relatif_forme'], self.corpus.parametres['syscoding'])
762 self.DictEffRelType, firsteffrelt = ReadList(self.dictpathout['eff_relatif_type'], self.corpus.parametres['syscoding'])
763 self.etoiles = firsteff[1:]
764 #sash = SashList(ira.nb)
767 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
768 self.TabStat.parametres = parametres
769 self.ListPan = ListForSpec(ira, self, self.DictSpec, self.etoiles)
770 if os.path.exists(self.pathout['banalites.csv']) :
771 self.listban = ListForSpec(ira, self, self.dictban, ['eff'] + self.etoiles, usefirst = True)
772 #self.ListPan2 = ListForSpec(sash.rightwin1, self, self.DictSpec, first)
773 self.ListPant = ListForSpec(ira, self, self.DictType, self.etoiles)
774 self.ListPanEff = ListForSpec(ira, self, self.DictEff, self.etoiles)
775 self.ListPanEffType = ListForSpec(ira, self, self.DictEffType, self.etoiles)
776 self.ListPanEffRelForme = ListForSpec(ira, self, self.DictEffRelForme, self.etoiles)
777 self.ListPanEffRelType = ListForSpec(ira, self, self.DictEffRelType, self.etoiles)
779 self.TabStat.AddPage(self.ListPan, _(u'Forms').decode('utf8'))
780 if os.path.exists(self.pathout['banalites.csv']) :
781 self.TabStat.AddPage(self.listban, _(u'Banal forms').decode('utf8'))
782 self.TabStat.AddPage(self.ListPant, _(u'POS').decode('utf8'))
783 self.TabStat.AddPage(self.ListPanEff, _(u'Forms frequencies').decode('utf8'))
784 self.TabStat.AddPage(self.ListPanEffType, _(u'POS frequencies').decode('utf8'))
785 self.TabStat.AddPage(self.ListPanEffRelForme, _(u'Forms relative frequencies').decode('utf8'))
786 self.TabStat.AddPage(self.ListPanEffRelType, _(u'POS relative frequencies').decode('utf8'))
787 if self.parametres['clnb'] > 2 :
788 self.TabAFC = aui.AuiNotebook(self.TabStat, -1, wx.DefaultPosition)
789 list_graph=read_list_file(self.dictpathout['liste_graph_afcf'], encoding = self.encoding)
790 self.tabAFCGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afcf', coding = self.encoding)
791 self.TabAFC.AddPage(self.tabAFCGraph, _(u'CA forms').decode('utf8'))
792 list_graph=read_list_file(self.dictpathout['liste_graph_afct'], encoding = self.encoding)
793 self.tabAFCTGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afct', coding=self.encoding)
794 self.TabAFC.AddPage(self.tabAFCTGraph, _(u'CA POS').decode('utf8'))
795 self.TabStat.AddPage(self.TabAFC, _(u'CA').decode('utf8'))
797 ira.nb.AddPage(self.TabStat, ' - '.join([_(u'Specificities').decode('utf8'), self.parametres['name']]))
800 self.TabStat.corpus = self.corpus
801 self.TabStat.etoiles = self.etoiles
802 self.TabStat.pathout = self.pathout
803 if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenspec.csv')) :
804 self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenspec.csv')
805 TgenLayout(self.TabStat)
806 self.TabStat.SetSelection(0)
807 ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
808 ira.ShowAPane("Tab_content")
811 def __init__(self, ira, corpus, parametres):
812 self.pathout = PathOut(dirout = parametres['pathout'])
816 self.parametres = parametres
817 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
818 self.TabStat.parametres = parametres
819 self.TabStat.corpus = corpus
820 self.TabStat.pathout = self.pathout
821 # CHD = GraphPanel(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
822 # panel.TabChdSim.AddPage(CHD,'CHD')
824 #self.TabStatTot = wx.TextCtrl(self.TabStat, -1, style=wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2)
825 list_graph = [['zipf.png', 'zipf']]
826 self.TabStatTot = GraphPanel(ira.nb, self.pathout, list_graph, self.result['glob'])
827 self.TabStat.AddPage(self.TabStatTot, _(u'Abstract').decode('utf8'))
829 dictlabel = {'total' : _(u'Total').decode('utf8'),
830 u'formes_actives' : _(u'Actives forms').decode('utf8'),
831 u'formes_supplémentaires': _(u'Supplementary forms').decode('utf8'),
832 u'hapax' : _(u'Hapax').decode('utf8'),
835 for item in self.result:
837 datam = [['forme', 'nb']]
838 self.ListPan = ListPanel(ira, self, self.result[item])
839 self.TabStat.AddPage(self.ListPan, dictlabel[item])
840 ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
841 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
842 ira.ShowAPane("Tab_content")
844 def read_result(self) :
845 lcle = {'total' :u'total.csv', u'formes_actives':u'formes_actives.csv', u'formes_supplémentaires':u'formes_supplémentaires.csv', u'hapax': u'hapax.csv'}
848 with codecs.open(self.pathout[lcle[key]], 'r', sys.getdefaultencoding()) as f :
849 self.result[key] = [line.split(';') for line in f.read().splitlines()]
850 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
851 with open(self.pathout['glob.txt'], 'r') as f :
852 self.result['glob'] = f.read()
854 class GraphPanelDendro(wx.Panel):
855 def __init__(self,parent, dico, list_graph, txt=False):
856 wx.Panel.__init__(self,parent)
858 self.dictpathout = dico
859 self.dirout = os.path.dirname(self.dictpathout['ira'])
860 self.list_graph = list_graph
861 self.parent = self.GetParent()#parent
862 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
865 self.tabchd = self.parent.GetParent()
866 self.ira = self.tabchd.GetParent()
867 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
868 self.panel_1.SetBackgroundColour('white')
869 self.deb = wx.StaticText(self.panel_1, -1, txt)
870 dendro_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
871 dendro_liste_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro_liste.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
872 dendro_cloud_img= wx.Image(os.path.join(self.ira.images_path,'but_dendro_cloud.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
873 self.butdendro = wx.BitmapButton(self, -1, dendro_img)
874 self.butdendrotexte = wx.BitmapButton(self, -1, dendro_liste_img)
875 self.butdendrocloud = wx.BitmapButton(self, -1, dendro_cloud_img)
877 for i in range(0,len(list_graph)):
878 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
879 filename, ext = os.path.splitext(list_graph[i][0])
881 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])))
883 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
884 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
886 self.__set_properties()
889 def __set_properties(self):
890 self.panel_1.EnableScrolling(True,True)
891 #self.panel_1.SetSize((1000,1000))
892 self.panel_1.SetScrollRate(20, 20)
893 self.panel_1.SetFocus()
894 self.Bind(wx.EVT_BUTTON, self.ondendro, self.butdendro)
895 self.Bind(wx.EVT_BUTTON, self.ondendrotexte, self.butdendrotexte)
896 self.Bind(wx.EVT_BUTTON, self.ondendrocloud, self.butdendrocloud)
897 self.param = {'width' : 700,
901 'taille_classe' : True,
905 self.type_dendro = [ u"phylogram", u"cladogram", u"fan", u"unrooted", u"radial" ]
907 def __do_layout(self):
908 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
909 self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
910 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
911 self.sizer_3.Add(self.deb)
912 self.sizer_1.Add(self.butdendro, 0, 0, 0)
913 self.sizer_1.Add(self.butdendrotexte, 0, 0, 0)
914 self.sizer_1.Add(self.butdendrocloud, 0, 0, 0)
916 for i in range(0, len(self.listimg)):
917 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
918 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
919 self.panel_1.SetSizer(self.sizer_3)
920 self.sizer_2.Add(self.sizer_1, 0, wx.EXPAND, 0)
921 self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
922 self.SetSizer(self.sizer_2)
924 def make_param(self, dial):
925 self.param['width'] = dial.m_spinCtrl2.GetValue()
926 self.param['height'] = dial.m_spinCtrl1.GetValue()
927 self.param['type_dendro'] = dial.m_choice1.GetSelection()
928 self.param['svg'] = dial.choice_format.GetSelection()
929 if self.param['typedendro'] == 'classique' :
930 self.param['color_nb'] = dial.m_radioBox1.GetSelection()
931 self.param['taille_classe'] = dial.m_checkBox1.GetValue()
932 self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
933 if self.param.get('translation', False) :
934 if dial.trans.GetSelection() == 0 :
935 del self.param['translation']
937 self.param['translation'] = self.param['translation'][dial.trans.GetSelection()-1][1]
939 def make_dendro(self, dendro = 'simple') :
940 if self.param['svg'] :
944 while os.path.exists(os.path.join(self.dirout, 'dendrogramme_' + str(self.graphnb)+typefile)) :
946 fileout = ffr(os.path.join(self.dirout,'dendrogramme_' + str(self.graphnb)+typefile))
947 width = self.param['width']
948 height = self.param['height']
949 type_dendro = self.type_dendro[self.param['type_dendro']]
950 if self.param['taille_classe'] :
954 if self.param['color_nb'] == 0 :
958 if self.param['type_tclasse'] == 0 :
962 if self.param['svg'] :
966 dendro_path = self.dictpathout['Rdendro']
967 classe_path = self.dictpathout['uce']
972 classes <- read.csv2("%s", row.names=1)
973 classes <- classes[,1]
974 """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']), ffr(classe_path))
975 if dendro == 'simple' :
977 open_file_graph("%s", width=%i, height=%i, svg=%s)
978 plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
979 """ % (ffr(fileout), width, height, svg, type_dendro, histo, bw, tclasse)
980 elif dendro == 'texte' :
984 if (is.null(debsup)) {
987 chistable <- chistabletot[1:(debsup-1),]
988 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']))
989 if self.param.get('translation', False) :
991 rn <- read.csv2("%s", header=FALSE, sep='\t')
992 rnchis <- row.names(chistable)
993 commun <- intersect(rnchis, unique(rn[,2]))
994 idrnchis <- sapply(commun, function(x) {which(rnchis==x)})
995 idrn <- sapply(commun, function(x) {which(as.vector(rn[,2])==x)[1]})
996 rownames(chistable)[idrnchis] <- as.vector(rn[idrn,1])
997 """ % ffr(self.param['translation'])
999 open_file_graph("%s", width=%i, height=%i, svg = %s)
1000 plot.dendro.prof(tree.cut1$tree.cl, classes, chistable, nbbycl = 60, type.dendro="%s", bw=%s, lab=NULL)
1001 """ % (ffr(fileout), width, height, svg, type_dendro, bw)
1002 elif dendro == 'cloud' :
1006 if (is.null(debsup)) {
1009 chistable <- chistabletot[1:(debsup-1),]
1010 open_file_graph("%s", width=%i, height=%i, svg=%s)
1011 plot.dendro.cloud(tree.cut1$tree.cl, classes, chistable, nbbycl = 300, type.dendro="%s", bw=%s, lab=NULL)
1012 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
1015 tmpfile = tempfile.mktemp()
1016 with open(tmpfile, 'w') as f :
1018 busy = wx.BusyInfo(_("Please wait...").decode('utf8'), self.parent)
1020 error = exec_rcode(self.ira.RPath, tmpfile, wait=True)
1022 check_Rresult(self.ira, error)
1023 self.list_graph.append([fileout, 'Dendrogramme CHD1 - %s' % type_dendro])
1024 print_liste(self.dictpathout['liste_graph_chd'], self.list_graph)
1025 if self.param['svg'] :
1026 self.sizer_3.Add(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1028 self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1029 self.sizer_3.Add(wx.StaticText(self.panel_1,-1, 'Dendrogramme CHD1 - %s' % type_dendro), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1030 self.sizer_3.Fit(self.panel_1)
1032 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
1035 def ondendro(self, evt):
1036 self.param['typedendro'] = 'classique'
1037 dial = PrefDendro(self.ira, self.param)
1038 val = dial.ShowModal()
1039 if val == wx.ID_OK :
1040 self.make_param(dial)
1043 def ondendrotexte(self, evt):
1044 self.param['typedendro'] = 'texte'
1045 if os.path.exists(self.dictpathout['translations.txt']) :
1046 with codecs.open(self.dictpathout['translations.txt'], 'r', 'utf8') as f :
1049 trans = [line.split('\t')[1] for line in content.splitlines()]
1050 trans = [[val, self.dictpathout[val]] for val in trans]
1051 self.param['translation'] = trans
1052 dial = PrefDendro(self.ira, self.param)
1053 val = dial.ShowModal()
1054 if val == wx.ID_OK :
1055 self.make_param(dial)
1056 self.make_dendro(dendro = 'texte')
1058 def ondendrocloud(self, evt):
1059 self.param['typedendro'] = 'cloud'
1060 dial = PrefDendro(self.ira, self.param)
1061 val = dial.ShowModal()
1062 if val == wx.ID_OK :
1063 self.make_param(dial)
1064 self.make_dendro(dendro = 'cloud')
1067 def __init__(self, ira, parametres) :
1068 #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)
1069 self.panel = CopusPanel(ira, parametres)
1070 ira.nb.AddPage(self.panel, 'Description %s' % parametres['corpus_name'])
1071 #self.text.write(DoConf().totext(parametres))
1072 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
1073 ira.ShowAPane("Tab_content")
1076 def __init__(self, ira, matrix):
1077 #self.parent.content = self.csvtable
1078 self.sheet = MySheet(ira.nb)
1079 ira.nb.AddPage(self.sheet, matrix.parametres['matrix_name'])
1080 self.sheet.Populate(matrix.csvtable)
1081 self.sheet.parametres = matrix.parametres
1082 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
1083 ira.ShowAPane("Tab_content")
1085 class CopusPanel(wx.Panel) :
1086 def __init__(self, parent, parametres) :
1087 wx.Panel.__init__ ( self, parent, id = wx.ID_ANY, pos = wx.DefaultPosition, size = wx.Size( 500,300 ), style = wx.TAB_TRAVERSAL )
1088 self.parametres = parametres
1089 fgSizer5 = wx.FlexGridSizer( 0, 2, 0, 0 )
1090 fgSizer5.SetFlexibleDirection( wx.BOTH )
1091 fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )
1092 self.fgSizer5 = fgSizer5
1094 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, _(u"Description of corpus").decode('utf8'), wx.DefaultPosition, wx.DefaultSize, 0 )
1096 self.m_staticText18.Wrap( -1 )
1097 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1099 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1100 self.m_staticText19.Wrap( -1 )
1101 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1103 self.m_staticText20 = wx.StaticText( self, wx.ID_ANY, u"Nom", wx.DefaultPosition, wx.DefaultSize, 0 )
1104 self.m_staticText20.Wrap( -1 )
1105 fgSizer5.Add( self.m_staticText20, 0, wx.ALL, 5 )
1107 self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, parametres['corpus_name'], wx.DefaultPosition, wx.DefaultSize, 0 )
1108 self.m_staticText21.Wrap( -1 )
1109 fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )
1111 description = {'lang' : _(u'Language').decode('utf8'),
1112 'encoding' : _(u'Characters set').decode('utf8'),
1113 'ucinb' : _(u'Number of texts').decode('utf8'),
1114 'ucenb' : _(u'Number of text segments').decode('utf8'),
1115 'formesnb' : _(u'Number of forms').decode('utf8'),
1116 'hapax' : _(u'Number of hapax').decode('utf8'),
1119 keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']
1121 self.addkeys(keys, description)
1123 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Paramètres", wx.DefaultPosition, wx.DefaultSize, 0 )
1124 self.m_staticText18.Wrap( -1 )
1125 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1127 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1128 self.m_staticText19.Wrap( -1 )
1129 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1131 keys = ['ucemethod', 'ucesize', 'keep_caract', 'expressions']
1132 self.addkeys(keys, description)
1134 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Statistiques", wx.DefaultPosition, wx.DefaultSize, 0 )
1135 self.m_staticText18.Wrap( -1 )
1136 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1138 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1139 self.m_staticText19.Wrap( -1 )
1140 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1142 keys = ['ucinb', 'ucenb', 'occurrences', 'formesnb', 'hapax']
1143 self.addkeys(keys, description)
1145 self.SetSizer( fgSizer5 )
1148 def addkeys(self, keys, description) :
1150 option = self.parametres.get(key,u'non défini')
1151 if isinstance(option, int) :
1153 text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
1155 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1157 text = wx.StaticText( self, wx.ID_ANY, option, wx.DefaultPosition, wx.DefaultSize, 0 )
1159 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1161 class DefaultTextLayout :
1162 def __init__(self, ira, corpus, parametres, cmd = False) :
1163 self.pathout = PathOut(dirout = parametres['pathout'])
1166 self.parametres = parametres
1167 self.corpus = corpus
1171 def dolayout(self, cmd) :
1172 log.info('no layout yet')
1174 class WordCloudLayout(DefaultTextLayout):
1176 self.pathout.basefiles(simipath)
1177 self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1178 if self.parametres['svg'] :
1179 list_graph = [['nuage_1.svg', 'Nuage']]
1181 list_graph = [['nuage_1.png', 'Nuage']]
1182 self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, list_graph)
1183 self.Tab.AddPage(self.TabStatTot, 'Nuage')
1184 self.Tab.corpus = self.corpus
1185 self.Tab.parametres = self.parametres
1186 self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
1187 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1188 self.ira.ShowAPane("Tab_content")
1190 class LabbeLayout(DefaultTextLayout):
1192 self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1193 #if self.parametres['svg'] :
1194 # list_graph = [['nuage_1.svg', 'Nuage']]
1196 # list_graph = [['nuage_1.png', 'Nuage']]
1197 list_graph = [['labbe-tree.png', _(u'Ward clustering (method ward2)').decode('utf8')],
1198 ['labbe-heatmap.png', _(u'Heatmap').decode('utf8')],
1199 ['labbe-matrix.png', _(u'Matrix').decode('utf8')]]
1200 for val in list_graph :
1201 #self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, [val])
1202 self.Tab.AddPage(GraphPanel(self.Tab, self.pathout, [val]), val[1])
1203 self.Tab.corpus = self.corpus
1204 self.Tab.parametres = self.parametres
1205 self.ira.nb.AddPage(self.Tab, u'%s' % self.parametres['name'])
1206 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1207 self.ira.ShowAPane("Tab_content")
1210 nodesfile = self.pathout['nodes.csv']
1211 edgesfile = self.pathout['edges.csv']
1212 jsonout = self.pathout.makenew('graphe_json', 'json')
1217 """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['Rgraph']))
1221 """ % (ffr(nodesfile), ffr(edgesfile))
1223 if ("communities" %in% names(graph.simi)) {
1228 graph.to.file(graph.simi, nodesfile = nodesf, edgesfile = edgesf, community = community)
1230 filetmp = tempfile.mktemp()
1231 with open(filetmp, 'w') as f :
1233 exec_rcode(self.ira.RPath, filetmp)
1234 GraphToJson(nodesfile, edgesfile, jsonout)
1235 launchcommand(['/home/pierre/prog/blender-2.73-linux-glibc211-x86_64/blender', '-P', os.path.join(self.ira.AppliPath, 'network_to_blender.py'), jsonout])
1238 class SimiLayout(DefaultTextLayout) :
1239 def dolayout(self) :
1240 self.pathout.basefiles(simipath)
1242 self.indices = indices_simi
1243 if os.path.exists(self.pathout['liste_graph']) :
1244 list_graph = read_list_file(self.pathout['liste_graph'])
1246 list_graph = [['','']]
1248 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1249 self.tabsimi = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1250 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1251 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1252 self.tabsimi.corpus = self.corpus
1253 self.tabsimi.parametres = self.parametres
1254 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1255 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1256 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1257 self.graphpan.Bind(wx.EVT_BUTTON, self.blender, self.graphpan.butblender)
1258 self.tabsimi.AddPage(self.graphpan, 'Graph')
1259 self.ira.nb.AddPage(self.tabsimi, _(u'Graph analysis').decode('utf8'))
1260 self.ira.ShowTab(True)
1261 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1263 def redosimi(self, evt) :
1265 # with open(self.pathout['selected.csv'],'r') as f :
1266 # selected = f.read()
1267 # selected = [int(val) for val in selected.splitlines()]
1268 # if self.actives is None :
1269 # with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1270 # self.actives = f.read()
1271 # self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1272 # if os.path.exists(self.pathout['actives_nb.csv']) :
1273 # with open(self.pathout['actives_nb.csv'], 'r') as f :
1275 # act_nb = act_nb.splitlines()
1276 # dictcol = dict([[i, [self.actives[i], int(act_nb[i])]] for i, val in enumerate(self.actives)])
1278 # dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1279 # #res = SelectColumn(self.ira, dictcol, self.actives, self.pathout['selected.csv'], selected = selected, dlg = True)
1281 # prep = PrepSimi(self.ira, self, self.parametres,self.pathout['selected.csv'], self.actives, indices_simi, wordlist = dictcol, selected = selected)
1282 # if prep.val == wx.ID_OK :
1283 # self.parametres = prep.parametres
1285 # script = PrintSimiScript(self)
1286 # script.make_script()
1287 # pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
1288 # check_Rresult(self.ira, pid)
1289 # if self.parametres['type_graph'] in [1,3] :
1290 # if self.parametres['svg'] :
1291 # filename, ext = os.path.splitext(script.filename)
1292 # fileout = filename + '.svg'
1293 # elif self.parametres['type_graph'] == 3 :
1294 # fileout = script.filename
1295 # parametres = {'gexffile' : fileout,
1296 # 'dirout' : os.path.dirname(fileout),
1297 # 'titre': 'Le titre',
1298 # #'nodemin': self.param['txt_min'],
1299 # #'nodemax': self.param['txt_max'],
1300 # #'bargraphw' : 60*int(self.param['clnb']),
1302 # web = WebExport(self.ira, parametres)
1303 # fileout = web.exportsimi()
1305 # fileout = script.filename
1306 # if os.path.exists(self.pathout['liste_graph']):
1307 # graph_simi = read_list_file(self.pathout['liste_graph'])
1308 # graph_simi.append([os.path.basename(fileout), script.txtgraph])
1310 # graph_simi = [[os.path.basename(fileout), script.txtgraph]]
1311 # print_liste(self.pathout['liste_graph'], graph_simi)
1312 # DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1313 # if self.parametres['type_graph'] in [1,3] :
1314 # if self.parametres['svg'] or self.parametres['type_graph'] == 3 :
1315 # self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1317 # 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)
1318 # self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1319 # self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1320 # self.graphpan.Layout()
1321 # self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1323 def export(self, evt) :
1325 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1327 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1333 graph <- graph.simi$graph
1334 V(graph)$x <- graph.simi$layout[,1]
1335 V(graph)$y <- graph.simi$layout[,2]
1336 if (length(graph.simi$label.cex == 1)) {
1337 V(graph)$weight <- graph.simi$eff
1339 V(graph)$weight <- graph.simi$label.cex
1341 V(graph)$rcolor <- vertex.label.color
1342 V(graph)$frequences <- graph.simi$mat.eff
1343 V(graph)$label <- as.character(graph.simi$v.label)
1344 E(graph)$weight <- graph.simi$we.width
1345 write.graph(graph, fileout, format = 'graphml')
1346 #saveAsGEXF(graph, filepath = fileout)
1347 """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['simi']), fileout)
1348 filetmp = tempfile.mktemp()
1349 with open(filetmp, 'w') as f :
1351 exec_rcode(self.ira.RPath, filetmp)
1352 mss = wx.MessageDialog(self.ira, fileout, _(u'File exported').decode('utf8'), wx.OK)
1353 mss.CenterOnParent()
1357 def blender(self, evt):
1361 class DefaultMatLayout :
1362 def __init__(self, parent, tableau, parametres) :
1363 self.pathout = PathOut(dirout = parametres['pathout'])
1365 self.parent = parent
1366 self.tableau = tableau
1367 self.parametres = parametres
1368 if os.path.exists(self.pathout['analyse.db']) :
1369 self.tableau.read_tableau(self.pathout['analyse.db'])
1371 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1372 self.ira.ShowAPane("Tab_content")
1374 def dolayout(self) :
1377 class FreqLayout(DefaultMatLayout) :
1378 def dolayout(self) :
1379 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1380 #self.tab = wx.html2.WebView.New(self)
1381 res = normpath_win32(self.pathout['resultats.html']).replace('\\','/')
1382 self.tab.LoadPage(res)
1383 #self.tab.LoadURL(res)
1384 self.tab.parametres = self.parametres
1385 self.ira.nb.AddPage(self.tab, ' - '.join([_(u"Frequency").decode('utf8'), self.parametres['name']]))
1388 class Chi2Layout(DefaultMatLayout) :
1390 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1391 if "gtk2" in wx.PlatformInfo:
1392 self.tab.SetStandardFonts()
1393 res = normpath_win32(self.pathout['resultats-chi2.html']).replace('\\','/')
1394 self.tab.LoadPage(res)
1395 self.tab.parametres = self.parametres
1396 self.ira.nb.AddPage(self.tab, ' - '.join([u"Chi2", self.parametres['name']]))
1397 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1398 #self.ira.ShowAPane("Tab_content")
1401 class ProtoLayout(DefaultMatLayout) :
1402 def dolayout(self) :
1403 list_graph = [['proto.png', _(u'Prototypical analysis').decode('utf8')]]
1404 #self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1405 #if self.parametres['svg'] :
1406 # list_graph = [['nuage_1.svg', 'Nuage']]
1408 # list_graph = [['nuage_1.png', 'Nuage']]
1409 self.TabProto = GraphPanel(self.ira.nb, self.pathout, list_graph)
1410 #self.Tab.AddPage(self.TabProto, 'Analyse Prototypique')
1411 #self.Tab.corpus = self.corpus
1412 self.TabProto.parametres = self.parametres
1413 self.ira.nb.AddPage(self.TabProto, ' - '.join([_(u'Prototypical analysis').decode('utf8'), self.parametres['name']]))
1414 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1415 #self.ira.ShowAPane("Tab_content")
1418 class SimiMatLayout(DefaultMatLayout) :
1420 self.pathout.basefiles(simipath)
1421 self.indices = indices_simi
1422 if os.path.exists(self.pathout['liste_graph']) :
1423 list_graph = read_list_file(self.pathout['liste_graph'])
1425 list_graph = [['','']]
1426 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1427 self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1428 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1429 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1430 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1431 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1432 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1433 self.graphpan.Bind(wx.EVT_BUTTON, self.blender, self.graphpan.butblender)
1434 self.tabsimi.AddPage(self.graphpan, 'Graph')
1435 self.tabsimi.parametres = self.parametres
1436 self.parent.nb.AddPage(self.tabsimi, ' - '.join([_(u'Graph analysis').decode('utf8'), self.parametres['name']]))
1437 #self.parent.ShowTab(True)
1438 #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1440 def redosimi(self,evt) :
1441 with open(self.pathout['selected.csv'],'r') as f :
1443 selected = [int(val) for val in selected.splitlines()]
1444 #if self.actives is None :
1445 # with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1446 # self.actives = f.read()
1447 # self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1449 actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1451 actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1453 #self.tableau.make_listactives()
1454 actives = dict([[i, val] for i, val in enumerate(actives)])
1455 #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1456 self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1457 self.dial.CenterOnParent()
1458 self.val = self.dial.ShowModal()
1459 if self.val == wx.ID_OK :
1460 last = self.dial.listcol.GetFirstSelected()
1461 lastl = [self.dial.listcol.GetFirstSelected()]
1462 indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1463 while self.dial.listcol.GetNextSelected(last) != -1:
1464 last = self.dial.listcol.GetNextSelected(last)
1466 indexes.append(self.dial.listcol.getColumnText(last,0))
1467 self.column = [self.tableau.listactives.index(val) for val in indexes]
1469 with open(self.pathout['selected.csv'], 'w') as f :
1470 f.write('\n'.join([`val` for val in self.column]))
1473 self.script = PrintSimiScript(self)
1474 self.script.make_script()
1475 self.tmpfile = self.script.scriptout
1476 dlg = progressbar(self, maxi = 2)
1479 if self.parametres['type_graph'] == 1:
1480 if self.parametres['svg'] :
1481 filename, ext = os.path.splitext(self.script.filename)
1482 fileout = filename + '.svg'
1484 fileout = self.script.filename
1485 fileout = normpath_win32(fileout)
1486 if os.path.exists(self.pathout['liste_graph']):
1487 graph_simi = read_list_file(self.pathout['liste_graph'])
1488 graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1490 graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1491 print_liste(self.pathout['liste_graph'], graph_simi)
1492 DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1493 if self.parametres['type_graph'] == 1:
1494 if self.parametres['svg'] :
1495 self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1497 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)
1498 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1499 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1500 self.graphpan.Layout()
1501 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1506 def make_param(self) :
1507 if self.parametres['first'] :
1510 keep_coord = self.dial.check_coord.GetValue()
1511 #self.select = self.dial.check_colch.GetValue()
1513 paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1514 'layout' : self.dial.choice2.GetSelection(),
1515 'type_graph' : self.dial.choice3.GetSelection(),
1516 'arbremax' : self.dial.check1.GetValue(),
1517 'coeff_tv' : self.dial.check_s_size.GetValue(),
1518 'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1519 'tvprop' : self.dial.check2.GetValue(),
1520 'tvmin' : self.dial.spin_tvmin.GetValue(),
1521 'tvmax' : self.dial.spin_tvmax.GetValue(),
1522 'coeff_te' : self.dial.check3.GetValue(),
1523 'coeff_temin' : self.dial.spin_temin.GetValue(),
1524 'coeff_temax' : self.dial.spin_temax.GetValue(),
1525 'label_e' : self.dial.check_elab.GetValue(),
1526 'label_v' : self.dial.check_vlab.GetValue(),
1527 'vcex' : self.dial.check_vcex.GetValue(),
1528 'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1529 'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1530 'cex' : self.dial.spin_cex.GetValue(),
1531 'seuil_ok' : self.dial.check_seuil.GetValue(),
1532 'seuil' : self.dial.spin_seuil.GetValue(),
1533 'cols' : self.dial.cols.GetColour(),
1534 'cola' : self.dial.cola.GetColour(),
1535 'width' : self.dial.spin_width.GetValue(),
1536 'height' : self.dial.spin_height.GetValue(),
1538 'keep_coord' : keep_coord,
1539 'alpha' : self.dial.slider_sphere.GetValue(),
1540 'film' : self.dial.film.GetValue(),
1541 'svg' : self.dial.choix_format.GetSelection(),
1542 'halo' : self.dial.halo.GetValue(),
1543 'com' : self.dial.comcheck.GetValue(),
1544 'communities' : self.dial.choix_com.GetSelection(),
1545 'edgecurved' : self.dial.check_curved.GetValue(),
1547 if 'cexfromchi' in self.parametres :
1548 paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1549 if 'sfromchi' in self.parametres :
1550 paramsimi['sfromchi'] = self.dial.checki.GetValue()
1551 if 'vlabcolor' in self.parametres :
1552 paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1553 if 'check_bystar' in dir(self.dial) :
1554 paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1555 paramsimi['stars'] = self.parametres['stars']
1556 self.parametres.update(paramsimi)
1559 if self.parametres['type_graph'] == 1 :
1565 pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1566 if self.parametres['type_graph'] == 1 :
1567 while pid.poll() == None :
1570 check_Rresult(self.parent, pid)
1572 def export(self, evt) :
1574 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1576 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1582 graph <- graph.simi$graph
1583 V(graph)$x <- graph.simi$layout[,1]
1584 V(graph)$y <- graph.simi$layout[,2]
1585 if (length(graph.simi$label.cex == 1)) {
1586 V(graph)$weight <- graph.simi$mat.eff
1588 V(graph)$weight <- graph.simi$label.cex
1590 V(graph)$color <- vertex.label.color
1591 V(graph)$frequences <- graph.simi$mat.eff
1592 V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
1593 V(graph)$label <- as.character(graph.simi$v.label)
1594 E(graph)$weight <- graph.simi$we.width
1595 write.graph(graph, fileout, format = 'graphml')
1596 #saveAsGEXF(graph, filepath = fileout)
1597 """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['simi']), fileout)
1598 filetmp = tempfile.mktemp()
1599 with open(filetmp, 'w') as f :
1601 exec_rcode(self.ira.RPath, filetmp)
1602 mss = wx.MessageDialog(self.ira, fileout, _(u'File exported').decode('utf8'), wx.OK)
1603 mss.CenterOnParent()
1607 def blender(self, evt):
1611 class GraphPanelSimi(wx.Panel):
1612 def __init__(self,parent, dico, list_graph):
1613 wx.Panel.__init__(self,parent)
1616 self.dirout = os.path.dirname(self.Dict['ira'])
1617 self.parent = self.GetParent()#parent
1618 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "courier"))
1621 self.tabsimi = self.parent.GetParent()
1622 self.ira = self.tabsimi.GetParent()
1623 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1624 afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1625 self.butafc = wx.BitmapButton(self, -1, afc_img)
1626 export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1627 self.butexport = wx.BitmapButton(self, -1, export_img)
1628 blender_img = wx.Image(os.path.join(self.ira.images_path,'button_blender.png'), wx.BITMAP_TYPE_ANY)
1629 blender_img.Rescale(32,32)
1630 blender_img = blender_img.ConvertToBitmap()
1631 self.butblender = wx.BitmapButton(self, -1, blender_img)
1632 for i in range(0,len(list_graph)):
1633 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1634 filename, ext = os.path.splitext(list_graph[i][0])
1635 if ext in ['.svg', '.html'] :
1636 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])))
1638 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1639 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1640 self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove)
1641 self.__set_properties()
1644 def __set_properties(self):
1645 self.panel_1.EnableScrolling(True,True)
1646 #self.panel_1.SetSize((1000,1000))
1647 self.panel_1.SetScrollRate(20, 20)
1648 self.panel_1.SetFocus()
1650 def __do_layout(self):
1651 self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1652 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1653 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1654 self.sizer_2.Add(self.butafc, 0, 0, 0)
1655 self.sizer_2.Add(self.butexport, 0, 0, 0)
1656 self.sizer_2.Add(self.butblender, 0, 0, 0)
1657 for i in range(0, len(self.listimg)):
1658 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1659 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1660 self.panel_1.SetSizer(self.sizer_3)
1661 self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1662 self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1663 self.SetSizer(self.sizer_1)
1665 def onMouseMove(self, event):
1666 self.panel_1.SetFocus()