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 if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenspec.csv')) :
803 self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenspec.csv')
804 TgenLayout(self.TabStat)
805 self.TabStat.SetSelection(0)
806 ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
807 ira.ShowAPane("Tab_content")
810 def __init__(self, ira, corpus, parametres):
811 self.pathout = PathOut(dirout = parametres['pathout'])
815 self.parametres = parametres
816 self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
817 self.TabStat.parametres = parametres
818 self.TabStat.corpus = corpus
819 self.TabStat.pathout = self.pathout
820 # CHD = GraphPanel(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
821 # panel.TabChdSim.AddPage(CHD,'CHD')
823 #self.TabStatTot = wx.TextCtrl(self.TabStat, -1, style=wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2)
824 list_graph = [['zipf.png', 'zipf']]
825 self.TabStatTot = GraphPanel(ira.nb, self.pathout, list_graph, self.result['glob'])
826 self.TabStat.AddPage(self.TabStatTot, _(u'Abstract').decode('utf8'))
828 dictlabel = {'total' : _(u'Total').decode('utf8'),
829 u'formes_actives' : _(u'Actives forms').decode('utf8'),
830 u'formes_supplémentaires': _(u'Supplementary forms').decode('utf8'),
831 u'hapax' : _(u'Hapax').decode('utf8'),
834 for item in self.result:
836 datam = [['forme', 'nb']]
837 self.ListPan = ListPanel(ira, self, self.result[item])
838 self.TabStat.AddPage(self.ListPan, dictlabel[item])
839 ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
840 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
841 ira.ShowAPane("Tab_content")
843 def read_result(self) :
844 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'}
847 with codecs.open(self.pathout[lcle[key]], 'r', sys.getdefaultencoding()) as f :
848 self.result[key] = [line.split(';') for line in f.read().splitlines()]
849 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
850 with open(self.pathout['glob.txt'], 'r') as f :
851 self.result['glob'] = f.read()
853 class GraphPanelDendro(wx.Panel):
854 def __init__(self,parent, dico, list_graph, txt=False):
855 wx.Panel.__init__(self,parent)
857 self.dictpathout = dico
858 self.dirout = os.path.dirname(self.dictpathout['ira'])
859 self.list_graph = list_graph
860 self.parent = self.GetParent()#parent
861 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
864 self.tabchd = self.parent.GetParent()
865 self.ira = self.tabchd.GetParent()
866 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
867 self.panel_1.SetBackgroundColour('white')
868 self.deb = wx.StaticText(self.panel_1, -1, txt)
869 dendro_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
870 dendro_liste_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro_liste.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
871 dendro_cloud_img= wx.Image(os.path.join(self.ira.images_path,'but_dendro_cloud.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
872 self.butdendro = wx.BitmapButton(self, -1, dendro_img)
873 self.butdendrotexte = wx.BitmapButton(self, -1, dendro_liste_img)
874 self.butdendrocloud = wx.BitmapButton(self, -1, dendro_cloud_img)
876 for i in range(0,len(list_graph)):
877 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
878 filename, ext = os.path.splitext(list_graph[i][0])
880 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])))
882 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
883 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
885 self.__set_properties()
888 def __set_properties(self):
889 self.panel_1.EnableScrolling(True,True)
890 #self.panel_1.SetSize((1000,1000))
891 self.panel_1.SetScrollRate(20, 20)
892 self.panel_1.SetFocus()
893 self.Bind(wx.EVT_BUTTON, self.ondendro, self.butdendro)
894 self.Bind(wx.EVT_BUTTON, self.ondendrotexte, self.butdendrotexte)
895 self.Bind(wx.EVT_BUTTON, self.ondendrocloud, self.butdendrocloud)
896 self.param = {'width' : 700,
900 'taille_classe' : True,
904 self.type_dendro = [ u"phylogram", u"cladogram", u"fan", u"unrooted", u"radial" ]
906 def __do_layout(self):
907 self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
908 self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
909 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
910 self.sizer_3.Add(self.deb)
911 self.sizer_1.Add(self.butdendro, 0, 0, 0)
912 self.sizer_1.Add(self.butdendrotexte, 0, 0, 0)
913 self.sizer_1.Add(self.butdendrocloud, 0, 0, 0)
915 for i in range(0, len(self.listimg)):
916 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
917 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
918 self.panel_1.SetSizer(self.sizer_3)
919 self.sizer_2.Add(self.sizer_1, 0, wx.EXPAND, 0)
920 self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
921 self.SetSizer(self.sizer_2)
923 def make_param(self, dial):
924 self.param['width'] = dial.m_spinCtrl2.GetValue()
925 self.param['height'] = dial.m_spinCtrl1.GetValue()
926 self.param['type_dendro'] = dial.m_choice1.GetSelection()
927 self.param['svg'] = dial.choice_format.GetSelection()
928 if self.param['typedendro'] == 'classique' :
929 self.param['color_nb'] = dial.m_radioBox1.GetSelection()
930 self.param['taille_classe'] = dial.m_checkBox1.GetValue()
931 self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
932 if self.param.get('translation', False) :
933 if dial.trans.GetSelection() == 0 :
934 del self.param['translation']
936 self.param['translation'] = self.param['translation'][dial.trans.GetSelection()-1][1]
938 def make_dendro(self, dendro = 'simple') :
939 if self.param['svg'] :
943 while os.path.exists(os.path.join(self.dirout, 'dendrogramme_' + str(self.graphnb)+typefile)) :
945 fileout = ffr(os.path.join(self.dirout,'dendrogramme_' + str(self.graphnb)+typefile))
946 width = self.param['width']
947 height = self.param['height']
948 type_dendro = self.type_dendro[self.param['type_dendro']]
949 if self.param['taille_classe'] :
953 if self.param['color_nb'] == 0 :
957 if self.param['type_tclasse'] == 0 :
961 if self.param['svg'] :
965 dendro_path = self.dictpathout['Rdendro']
966 classe_path = self.dictpathout['uce']
971 classes <- read.csv2("%s", row.names=1)
972 classes <- classes[,1]
973 """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']), ffr(classe_path))
974 if dendro == 'simple' :
976 open_file_graph("%s", width=%i, height=%i, svg=%s)
977 plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
978 """ % (ffr(fileout), width, height, svg, type_dendro, histo, bw, tclasse)
979 elif dendro == 'texte' :
983 if (is.null(debsup)) {
986 chistable <- chistabletot[1:(debsup-1),]
987 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']))
988 if self.param.get('translation', False) :
990 rn <- read.csv2("%s", header=FALSE, sep='\t')
991 rnchis <- row.names(chistable)
992 commun <- intersect(rnchis, unique(rn[,2]))
993 idrnchis <- sapply(commun, function(x) {which(rnchis==x)})
994 idrn <- sapply(commun, function(x) {which(as.vector(rn[,2])==x)[1]})
995 rownames(chistable)[idrnchis] <- as.vector(rn[idrn,1])
996 """ % ffr(self.param['translation'])
998 open_file_graph("%s", width=%i, height=%i, svg = %s)
999 plot.dendro.prof(tree.cut1$tree.cl, classes, chistable, nbbycl = 60, type.dendro="%s", bw=%s, lab=NULL)
1000 """ % (ffr(fileout), width, height, svg, type_dendro, bw)
1001 elif dendro == 'cloud' :
1005 if (is.null(debsup)) {
1008 chistable <- chistabletot[1:(debsup-1),]
1009 open_file_graph("%s", width=%i, height=%i, svg=%s)
1010 plot.dendro.cloud(tree.cut1$tree.cl, classes, chistable, nbbycl = 300, type.dendro="%s", bw=%s, lab=NULL)
1011 """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
1014 tmpfile = tempfile.mktemp()
1015 with open(tmpfile, 'w') as f :
1017 busy = wx.BusyInfo(_("Please wait...").decode('utf8'), self.parent)
1019 error = exec_rcode(self.ira.RPath, tmpfile, wait=True)
1021 check_Rresult(self.ira, error)
1022 self.list_graph.append([fileout, 'Dendrogramme CHD1 - %s' % type_dendro])
1023 print_liste(self.dictpathout['liste_graph_chd'], self.list_graph)
1024 if self.param['svg'] :
1025 self.sizer_3.Add(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1027 self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1028 self.sizer_3.Add(wx.StaticText(self.panel_1,-1, 'Dendrogramme CHD1 - %s' % type_dendro), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1029 self.sizer_3.Fit(self.panel_1)
1031 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
1034 def ondendro(self, evt):
1035 self.param['typedendro'] = 'classique'
1036 dial = PrefDendro(self.ira, self.param)
1037 val = dial.ShowModal()
1038 if val == wx.ID_OK :
1039 self.make_param(dial)
1042 def ondendrotexte(self, evt):
1043 self.param['typedendro'] = 'texte'
1044 if os.path.exists(self.dictpathout['translations.txt']) :
1045 with codecs.open(self.dictpathout['translations.txt'], 'r', 'utf8') as f :
1048 trans = [line.split('\t')[1] for line in content.splitlines()]
1049 trans = [[val, self.dictpathout[val]] for val in trans]
1050 self.param['translation'] = trans
1051 dial = PrefDendro(self.ira, self.param)
1052 val = dial.ShowModal()
1053 if val == wx.ID_OK :
1054 self.make_param(dial)
1055 self.make_dendro(dendro = 'texte')
1057 def ondendrocloud(self, evt):
1058 self.param['typedendro'] = 'cloud'
1059 dial = PrefDendro(self.ira, self.param)
1060 val = dial.ShowModal()
1061 if val == wx.ID_OK :
1062 self.make_param(dial)
1063 self.make_dendro(dendro = 'cloud')
1066 def __init__(self, ira, parametres) :
1067 #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)
1068 self.panel = CopusPanel(ira, parametres)
1069 ira.nb.AddPage(self.panel, 'Description %s' % parametres['corpus_name'])
1070 #self.text.write(DoConf().totext(parametres))
1071 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
1072 ira.ShowAPane("Tab_content")
1075 def __init__(self, ira, matrix):
1076 #self.parent.content = self.csvtable
1077 self.sheet = MySheet(ira.nb)
1078 ira.nb.AddPage(self.sheet, matrix.parametres['matrix_name'])
1079 self.sheet.Populate(matrix.csvtable)
1080 self.sheet.parametres = matrix.parametres
1081 ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
1082 ira.ShowAPane("Tab_content")
1084 class CopusPanel(wx.Panel) :
1085 def __init__(self, parent, parametres) :
1086 wx.Panel.__init__ ( self, parent, id = wx.ID_ANY, pos = wx.DefaultPosition, size = wx.Size( 500,300 ), style = wx.TAB_TRAVERSAL )
1087 self.parametres = parametres
1088 fgSizer5 = wx.FlexGridSizer( 0, 2, 0, 0 )
1089 fgSizer5.SetFlexibleDirection( wx.BOTH )
1090 fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )
1091 self.fgSizer5 = fgSizer5
1093 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, _(u"Description of corpus").decode('utf8'), wx.DefaultPosition, wx.DefaultSize, 0 )
1095 self.m_staticText18.Wrap( -1 )
1096 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1098 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1099 self.m_staticText19.Wrap( -1 )
1100 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1102 self.m_staticText20 = wx.StaticText( self, wx.ID_ANY, u"Nom", wx.DefaultPosition, wx.DefaultSize, 0 )
1103 self.m_staticText20.Wrap( -1 )
1104 fgSizer5.Add( self.m_staticText20, 0, wx.ALL, 5 )
1106 self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, parametres['corpus_name'], wx.DefaultPosition, wx.DefaultSize, 0 )
1107 self.m_staticText21.Wrap( -1 )
1108 fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )
1110 description = {'lang' : _(u'Language').decode('utf8'),
1111 'encoding' : _(u'Characters set').decode('utf8'),
1112 'ucinb' : _(u'Number of texts').decode('utf8'),
1113 'ucenb' : _(u'Number of text segments').decode('utf8'),
1114 'formesnb' : _(u'Number of forms').decode('utf8'),
1115 'hapax' : _(u'Number of hapax').decode('utf8'),
1118 keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']
1120 self.addkeys(keys, description)
1122 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Paramètres", wx.DefaultPosition, wx.DefaultSize, 0 )
1123 self.m_staticText18.Wrap( -1 )
1124 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1126 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1127 self.m_staticText19.Wrap( -1 )
1128 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1130 keys = ['ucemethod', 'ucesize', 'keep_caract', 'expressions']
1131 self.addkeys(keys, description)
1133 self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Statistiques", wx.DefaultPosition, wx.DefaultSize, 0 )
1134 self.m_staticText18.Wrap( -1 )
1135 fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1137 self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1138 self.m_staticText19.Wrap( -1 )
1139 fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1141 keys = ['ucinb', 'ucenb', 'occurrences', 'formesnb', 'hapax']
1142 self.addkeys(keys, description)
1144 self.SetSizer( fgSizer5 )
1147 def addkeys(self, keys, description) :
1149 option = self.parametres.get(key,u'non défini')
1150 if isinstance(option, int) :
1152 text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
1154 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1156 text = wx.StaticText( self, wx.ID_ANY, option, wx.DefaultPosition, wx.DefaultSize, 0 )
1158 self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1160 class DefaultTextLayout :
1161 def __init__(self, ira, corpus, parametres, cmd = False) :
1162 self.pathout = PathOut(dirout = parametres['pathout'])
1165 self.parametres = parametres
1166 self.corpus = corpus
1170 def dolayout(self, cmd) :
1171 log.info('no layout yet')
1173 class WordCloudLayout(DefaultTextLayout):
1175 self.pathout.basefiles(simipath)
1176 self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1177 if self.parametres['svg'] :
1178 list_graph = [['nuage_1.svg', 'Nuage']]
1180 list_graph = [['nuage_1.png', 'Nuage']]
1181 self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, list_graph)
1182 self.Tab.AddPage(self.TabStatTot, 'Nuage')
1183 self.Tab.corpus = self.corpus
1184 self.Tab.parametres = self.parametres
1185 self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
1186 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1187 self.ira.ShowAPane("Tab_content")
1189 class LabbeLayout(DefaultTextLayout):
1191 self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1192 #if self.parametres['svg'] :
1193 # list_graph = [['nuage_1.svg', 'Nuage']]
1195 # list_graph = [['nuage_1.png', 'Nuage']]
1196 list_graph = [['labbe-tree.png', _(u'Ward clustering (method ward2)').decode('utf8')],
1197 ['labbe-heatmap.png', _(u'Heatmap').decode('utf8')],
1198 ['labbe-matrix.png', _(u'Matrix').decode('utf8')]]
1199 for val in list_graph :
1200 #self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, [val])
1201 self.Tab.AddPage(GraphPanel(self.Tab, self.pathout, [val]), val[1])
1202 self.Tab.corpus = self.corpus
1203 self.Tab.parametres = self.parametres
1204 self.ira.nb.AddPage(self.Tab, u'%s' % self.parametres['name'])
1205 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1206 self.ira.ShowAPane("Tab_content")
1209 nodesfile = self.pathout['nodes.csv']
1210 edgesfile = self.pathout['edges.csv']
1211 jsonout = self.pathout.makenew('graphe_json', 'json')
1216 """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['Rgraph']))
1220 """ % (ffr(nodesfile), ffr(edgesfile))
1222 if ("communities" %in% names(graph.simi)) {
1227 graph.to.file(graph.simi, nodesfile = nodesf, edgesfile = edgesf, community = community)
1229 filetmp = tempfile.mktemp()
1230 with open(filetmp, 'w') as f :
1232 exec_rcode(self.ira.RPath, filetmp)
1233 GraphToJson(nodesfile, edgesfile, jsonout)
1234 launchcommand(['/home/pierre/prog/blender-2.73-linux-glibc211-x86_64/blender', '-P', os.path.join(self.ira.AppliPath, 'network_to_blender.py'), jsonout])
1237 class SimiLayout(DefaultTextLayout) :
1238 def dolayout(self) :
1239 self.pathout.basefiles(simipath)
1241 self.indices = indices_simi
1242 if os.path.exists(self.pathout['liste_graph']) :
1243 list_graph = read_list_file(self.pathout['liste_graph'])
1245 list_graph = [['','']]
1247 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1248 self.tabsimi = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1249 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1250 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1251 self.tabsimi.corpus = self.corpus
1252 self.tabsimi.parametres = self.parametres
1253 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1254 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1255 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1256 self.graphpan.Bind(wx.EVT_BUTTON, self.blender, self.graphpan.butblender)
1257 self.tabsimi.AddPage(self.graphpan, 'Graph')
1258 self.ira.nb.AddPage(self.tabsimi, _(u'Graph analysis').decode('utf8'))
1259 self.ira.ShowTab(True)
1260 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1262 def redosimi(self, evt) :
1264 # with open(self.pathout['selected.csv'],'r') as f :
1265 # selected = f.read()
1266 # selected = [int(val) for val in selected.splitlines()]
1267 # if self.actives is None :
1268 # with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1269 # self.actives = f.read()
1270 # self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1271 # if os.path.exists(self.pathout['actives_nb.csv']) :
1272 # with open(self.pathout['actives_nb.csv'], 'r') as f :
1274 # act_nb = act_nb.splitlines()
1275 # dictcol = dict([[i, [self.actives[i], int(act_nb[i])]] for i, val in enumerate(self.actives)])
1277 # dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1278 # #res = SelectColumn(self.ira, dictcol, self.actives, self.pathout['selected.csv'], selected = selected, dlg = True)
1280 # prep = PrepSimi(self.ira, self, self.parametres,self.pathout['selected.csv'], self.actives, indices_simi, wordlist = dictcol, selected = selected)
1281 # if prep.val == wx.ID_OK :
1282 # self.parametres = prep.parametres
1284 # script = PrintSimiScript(self)
1285 # script.make_script()
1286 # pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
1287 # check_Rresult(self.ira, pid)
1288 # if self.parametres['type_graph'] in [1,3] :
1289 # if self.parametres['svg'] :
1290 # filename, ext = os.path.splitext(script.filename)
1291 # fileout = filename + '.svg'
1292 # elif self.parametres['type_graph'] == 3 :
1293 # fileout = script.filename
1294 # parametres = {'gexffile' : fileout,
1295 # 'dirout' : os.path.dirname(fileout),
1296 # 'titre': 'Le titre',
1297 # #'nodemin': self.param['txt_min'],
1298 # #'nodemax': self.param['txt_max'],
1299 # #'bargraphw' : 60*int(self.param['clnb']),
1301 # web = WebExport(self.ira, parametres)
1302 # fileout = web.exportsimi()
1304 # fileout = script.filename
1305 # if os.path.exists(self.pathout['liste_graph']):
1306 # graph_simi = read_list_file(self.pathout['liste_graph'])
1307 # graph_simi.append([os.path.basename(fileout), script.txtgraph])
1309 # graph_simi = [[os.path.basename(fileout), script.txtgraph]]
1310 # print_liste(self.pathout['liste_graph'], graph_simi)
1311 # DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1312 # if self.parametres['type_graph'] in [1,3] :
1313 # if self.parametres['svg'] or self.parametres['type_graph'] == 3 :
1314 # self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1316 # 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)
1317 # self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1318 # self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1319 # self.graphpan.Layout()
1320 # self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1322 def export(self, evt) :
1324 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1326 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1332 graph <- graph.simi$graph
1333 V(graph)$x <- graph.simi$layout[,1]
1334 V(graph)$y <- graph.simi$layout[,2]
1335 if (length(graph.simi$label.cex == 1)) {
1336 V(graph)$weight <- graph.simi$eff
1338 V(graph)$weight <- graph.simi$label.cex
1340 V(graph)$rcolor <- vertex.label.color
1341 V(graph)$frequences <- graph.simi$mat.eff
1342 V(graph)$label <- as.character(graph.simi$v.label)
1343 E(graph)$weight <- graph.simi$we.width
1344 write.graph(graph, fileout, format = 'graphml')
1345 #saveAsGEXF(graph, filepath = fileout)
1346 """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['simi']), fileout)
1347 filetmp = tempfile.mktemp()
1348 with open(filetmp, 'w') as f :
1350 exec_rcode(self.ira.RPath, filetmp)
1351 mss = wx.MessageDialog(self.ira, fileout, _(u'File exported').decode('utf8'), wx.OK)
1352 mss.CenterOnParent()
1356 def blender(self, evt):
1360 class DefaultMatLayout :
1361 def __init__(self, parent, tableau, parametres) :
1362 self.pathout = PathOut(dirout = parametres['pathout'])
1364 self.parent = parent
1365 self.tableau = tableau
1366 self.parametres = parametres
1367 if os.path.exists(self.pathout['analyse.db']) :
1368 self.tableau.read_tableau(self.pathout['analyse.db'])
1370 self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1371 self.ira.ShowAPane("Tab_content")
1373 def dolayout(self) :
1376 class FreqLayout(DefaultMatLayout) :
1377 def dolayout(self) :
1378 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1379 #self.tab = wx.html2.WebView.New(self)
1380 res = normpath_win32(self.pathout['resultats.html']).replace('\\','/')
1381 self.tab.LoadPage(res)
1382 #self.tab.LoadURL(res)
1383 self.tab.parametres = self.parametres
1384 self.ira.nb.AddPage(self.tab, ' - '.join([_(u"Frequency").decode('utf8'), self.parametres['name']]))
1387 class Chi2Layout(DefaultMatLayout) :
1389 self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1390 if "gtk2" in wx.PlatformInfo:
1391 self.tab.SetStandardFonts()
1392 res = normpath_win32(self.pathout['resultats-chi2.html']).replace('\\','/')
1393 self.tab.LoadPage(res)
1394 self.tab.parametres = self.parametres
1395 self.ira.nb.AddPage(self.tab, ' - '.join([u"Chi2", self.parametres['name']]))
1396 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1397 #self.ira.ShowAPane("Tab_content")
1400 class ProtoLayout(DefaultMatLayout) :
1401 def dolayout(self) :
1402 list_graph = [['proto.png', _(u'Prototypical analysis').decode('utf8')]]
1403 #self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1404 #if self.parametres['svg'] :
1405 # list_graph = [['nuage_1.svg', 'Nuage']]
1407 # list_graph = [['nuage_1.png', 'Nuage']]
1408 self.TabProto = GraphPanel(self.ira.nb, self.pathout, list_graph)
1409 #self.Tab.AddPage(self.TabProto, 'Analyse Prototypique')
1410 #self.Tab.corpus = self.corpus
1411 self.TabProto.parametres = self.parametres
1412 self.ira.nb.AddPage(self.TabProto, ' - '.join([_(u'Prototypical analysis').decode('utf8'), self.parametres['name']]))
1413 #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1414 #self.ira.ShowAPane("Tab_content")
1417 class SimiMatLayout(DefaultMatLayout) :
1419 self.pathout.basefiles(simipath)
1420 self.indices = indices_simi
1421 if os.path.exists(self.pathout['liste_graph']) :
1422 list_graph = read_list_file(self.pathout['liste_graph'])
1424 list_graph = [['','']]
1425 notebook_flags = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1426 self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1427 self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1428 self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1429 self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1430 self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1431 self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1432 self.graphpan.Bind(wx.EVT_BUTTON, self.blender, self.graphpan.butblender)
1433 self.tabsimi.AddPage(self.graphpan, 'Graph')
1434 self.tabsimi.parametres = self.parametres
1435 self.parent.nb.AddPage(self.tabsimi, ' - '.join([_(u'Graph analysis').decode('utf8'), self.parametres['name']]))
1436 #self.parent.ShowTab(True)
1437 #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1439 def redosimi(self,evt) :
1440 with open(self.pathout['selected.csv'],'r') as f :
1442 selected = [int(val) for val in selected.splitlines()]
1443 #if self.actives is None :
1444 # with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1445 # self.actives = f.read()
1446 # self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1448 actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1450 actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1452 #self.tableau.make_listactives()
1453 actives = dict([[i, val] for i, val in enumerate(actives)])
1454 #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1455 self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1456 self.dial.CenterOnParent()
1457 self.val = self.dial.ShowModal()
1458 if self.val == wx.ID_OK :
1459 last = self.dial.listcol.GetFirstSelected()
1460 lastl = [self.dial.listcol.GetFirstSelected()]
1461 indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1462 while self.dial.listcol.GetNextSelected(last) != -1:
1463 last = self.dial.listcol.GetNextSelected(last)
1465 indexes.append(self.dial.listcol.getColumnText(last,0))
1466 self.column = [self.tableau.listactives.index(val) for val in indexes]
1468 with open(self.pathout['selected.csv'], 'w') as f :
1469 f.write('\n'.join([`val` for val in self.column]))
1472 self.script = PrintSimiScript(self)
1473 self.script.make_script()
1474 self.tmpfile = self.script.scriptout
1475 dlg = progressbar(self, maxi = 2)
1478 if self.parametres['type_graph'] == 1:
1479 if self.parametres['svg'] :
1480 filename, ext = os.path.splitext(self.script.filename)
1481 fileout = filename + '.svg'
1483 fileout = self.script.filename
1484 fileout = normpath_win32(fileout)
1485 if os.path.exists(self.pathout['liste_graph']):
1486 graph_simi = read_list_file(self.pathout['liste_graph'])
1487 graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1489 graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1490 print_liste(self.pathout['liste_graph'], graph_simi)
1491 DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1492 if self.parametres['type_graph'] == 1:
1493 if self.parametres['svg'] :
1494 self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1496 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)
1497 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1498 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1499 self.graphpan.Layout()
1500 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1505 def make_param(self) :
1506 if self.parametres['first'] :
1509 keep_coord = self.dial.check_coord.GetValue()
1510 #self.select = self.dial.check_colch.GetValue()
1512 paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1513 'layout' : self.dial.choice2.GetSelection(),
1514 'type_graph' : self.dial.choice3.GetSelection(),
1515 'arbremax' : self.dial.check1.GetValue(),
1516 'coeff_tv' : self.dial.check_s_size.GetValue(),
1517 'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1518 'tvprop' : self.dial.check2.GetValue(),
1519 'tvmin' : self.dial.spin_tvmin.GetValue(),
1520 'tvmax' : self.dial.spin_tvmax.GetValue(),
1521 'coeff_te' : self.dial.check3.GetValue(),
1522 'coeff_temin' : self.dial.spin_temin.GetValue(),
1523 'coeff_temax' : self.dial.spin_temax.GetValue(),
1524 'label_e' : self.dial.check_elab.GetValue(),
1525 'label_v' : self.dial.check_vlab.GetValue(),
1526 'vcex' : self.dial.check_vcex.GetValue(),
1527 'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1528 'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1529 'cex' : self.dial.spin_cex.GetValue(),
1530 'seuil_ok' : self.dial.check_seuil.GetValue(),
1531 'seuil' : self.dial.spin_seuil.GetValue(),
1532 'cols' : self.dial.cols.GetColour(),
1533 'cola' : self.dial.cola.GetColour(),
1534 'width' : self.dial.spin_width.GetValue(),
1535 'height' : self.dial.spin_height.GetValue(),
1537 'keep_coord' : keep_coord,
1538 'alpha' : self.dial.slider_sphere.GetValue(),
1539 'film' : self.dial.film.GetValue(),
1540 'svg' : self.dial.choix_format.GetSelection(),
1541 'halo' : self.dial.halo.GetValue(),
1542 'com' : self.dial.comcheck.GetValue(),
1543 'communities' : self.dial.choix_com.GetSelection(),
1544 'edgecurved' : self.dial.check_curved.GetValue(),
1546 if 'cexfromchi' in self.parametres :
1547 paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1548 if 'sfromchi' in self.parametres :
1549 paramsimi['sfromchi'] = self.dial.checki.GetValue()
1550 if 'vlabcolor' in self.parametres :
1551 paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1552 if 'check_bystar' in dir(self.dial) :
1553 paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1554 paramsimi['stars'] = self.parametres['stars']
1555 self.parametres.update(paramsimi)
1558 if self.parametres['type_graph'] == 1 :
1564 pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1565 if self.parametres['type_graph'] == 1 :
1566 while pid.poll() == None :
1569 check_Rresult(self.parent, pid)
1571 def export(self, evt) :
1573 while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1575 fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1581 graph <- graph.simi$graph
1582 V(graph)$x <- graph.simi$layout[,1]
1583 V(graph)$y <- graph.simi$layout[,2]
1584 if (length(graph.simi$label.cex == 1)) {
1585 V(graph)$weight <- graph.simi$mat.eff
1587 V(graph)$weight <- graph.simi$label.cex
1589 V(graph)$color <- vertex.label.color
1590 V(graph)$frequences <- graph.simi$mat.eff
1591 V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
1592 V(graph)$label <- as.character(graph.simi$v.label)
1593 E(graph)$weight <- graph.simi$we.width
1594 write.graph(graph, fileout, format = 'graphml')
1595 #saveAsGEXF(graph, filepath = fileout)
1596 """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['simi']), fileout)
1597 filetmp = tempfile.mktemp()
1598 with open(filetmp, 'w') as f :
1600 exec_rcode(self.ira.RPath, filetmp)
1601 mss = wx.MessageDialog(self.ira, fileout, _(u'File exported').decode('utf8'), wx.OK)
1602 mss.CenterOnParent()
1606 def blender(self, evt):
1610 class GraphPanelSimi(wx.Panel):
1611 def __init__(self,parent, dico, list_graph):
1612 wx.Panel.__init__(self,parent)
1615 self.dirout = os.path.dirname(self.Dict['ira'])
1616 self.parent = self.GetParent()#parent
1617 self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "courier"))
1620 self.tabsimi = self.parent.GetParent()
1621 self.ira = self.tabsimi.GetParent()
1622 self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1623 afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1624 self.butafc = wx.BitmapButton(self, -1, afc_img)
1625 export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1626 self.butexport = wx.BitmapButton(self, -1, export_img)
1627 blender_img = wx.Image(os.path.join(self.ira.images_path,'button_blender.png'), wx.BITMAP_TYPE_ANY)
1628 blender_img.Rescale(32,32)
1629 blender_img = blender_img.ConvertToBitmap()
1630 self.butblender = wx.BitmapButton(self, -1, blender_img)
1631 for i in range(0,len(list_graph)):
1632 if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1633 filename, ext = os.path.splitext(list_graph[i][0])
1634 if ext in ['.svg', '.html'] :
1635 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])))
1637 self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1638 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1639 self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove)
1640 self.__set_properties()
1643 def __set_properties(self):
1644 self.panel_1.EnableScrolling(True,True)
1645 #self.panel_1.SetSize((1000,1000))
1646 self.panel_1.SetScrollRate(20, 20)
1647 self.panel_1.SetFocus()
1649 def __do_layout(self):
1650 self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1651 self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1652 self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1653 self.sizer_2.Add(self.butafc, 0, 0, 0)
1654 self.sizer_2.Add(self.butexport, 0, 0, 0)
1655 self.sizer_2.Add(self.butblender, 0, 0, 0)
1656 for i in range(0, len(self.listimg)):
1657 self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1658 self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1659 self.panel_1.SetSizer(self.sizer_3)
1660 self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1661 self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1662 self.SetSizer(self.sizer_1)
1664 def onMouseMove(self, event):
1665 self.panel_1.SetFocus()