Pas la peine de faire un draw dans le constructeur.
[minwii.git] / src / minwii / loganalyse.py
1 # -*- coding: utf-8 -*-
2 """
3 Module d'analyse des fichiers de log minwii.
4
5 $Id$
6 $URL$
7 """
8
9 from minwii.logfilereader import LogFileReader
10 from pprint import pprint
11 from minwii.musicxml import musicXml2Song
12 from minwii.globals import PLAYING_MODES
13 from statlib import stats
14 from datetime import timedelta
15 from xml.etree import ElementTree
16 import os.path
17
18 PLAYING_MODES = dict(PLAYING_MODES)
19
20 DEFAULT_STATS = (#'geometricmean',
21 ('harmonicmean', 'Moyenne harmonique'),
22 ('mean', 'Moyenne '),
23 ('median', 'Médiane'),
24 #'medianscore',
25 #'mode',
26 #'moment',
27 ('variation', 'Variation'),
28 #'skew',
29 ('kurtosis', 'Kurtosis'),
30 #'itemfreq',
31 #'histogram',
32 #'cumfreq',
33 #'relfreq',
34 )
35
36 def statsresults(m) :
37 def computeList(self):
38 l = m(self)
39 results = []
40 for name, label in DEFAULT_STATS :
41 results.append('%s : %s' % (label, getattr(stats, name)(l)))
42 return '\n'.join(results)
43 computeList.__name__ = m.__name__
44 computeList.__doc__ = m.__doc__
45 return computeList
46
47 def timebased(m) :
48 m.timebased = True
49 return m
50
51 class LogFileAnalyser(LogFileReader) :
52
53 POSSIBLE_ANALYSES = {'BEGINNER' : ('songDuration',
54 'playingDuration',
55 'noteEndNoteOnLatency',
56 'realisationRate')
57
58 ,'EASY' : ('songDuration',
59 'playingDuration',
60 'noteEndNoteOnLatency',
61 'realisationRate',
62 'missCount',
63 'getMissPerTimeFrame')
64
65 ,'NORMAL' : ('songDuration',
66 'playingDuration',
67 'realisationRate',
68 'missCount',
69 'getMissPerTimeFrame')
70
71 ,'ADVANCED' : ('songDuration',
72 'playingDuration',
73 'realisationRate',
74 'missCount',
75 'getMissPerTimeFrame')
76
77 ,'EXPERT' : ('songDuration',
78 'playingDuration',
79 'realisationRate',
80 'missCount',
81 'getMissPerTimeFrame')
82 }
83
84 def analyse(self) :
85 results = []
86
87 try :
88 self.mode = mode = self.getMode()
89 results.append(('Mode de jeu', PLAYING_MODES.get(mode, mode), False))
90
91 self.songTitle = LogFileAnalyser.getSongTitle(self.getSongFile())
92 results.append(('Chanson', self.songTitle, False))
93
94 for name in self.POSSIBLE_ANALYSES[mode] :
95 meth = getattr(self, name)
96 results.append( (meth.__doc__, meth(), getattr(meth, 'timebased', False)) )
97 except :
98 raise
99
100 return results
101
102 @staticmethod
103 def getSongTitle(file) :
104 if os.path.exists(file) :
105 it = ElementTree.iterparse(file, ['start', 'end'])
106 creditFound = False
107
108 for evt, el in it :
109 if el.tag == 'credit' :
110 creditFound = True
111 if el.tag == 'credit-words' and creditFound:
112 return el.text
113 if el.tag == 'part-list' :
114 # plus de chance de trouver un titre
115 return os.path.basename(file)
116 else :
117 return os.path.basename(file)
118
119 def _toTimeDelta(self, milliseconds) :
120 duration = milliseconds / 1000.
121 duration = int(round(duration, 0))
122 return str(timedelta(seconds=duration))
123
124 def playingDuration(self) :
125 'Temps de jeu'
126 #retourne la durée écoulée entre le premier et de dernier message
127 #de type événement : correspond à la durée d'interprétation.
128
129 last = self.getLastEventTicks()
130 first = self.getFirstEventTicks()
131 return self._toTimeDelta(last - first)
132
133
134 def songDuration(self) :
135 'Durée de référence de la chanson'
136 #retourne la durée de référence de la chanson
137 #en prenant en compte le tempo présent dans la transcription
138 #et en effectuant toutes les répétitions des couplets / refrains.
139
140 songFile = self.getSongFile()
141 song = musicXml2Song(songFile)
142 duration = song.duration
143 return self._toTimeDelta(duration)
144
145 @statsresults
146 def noteEndNoteOnLatency(self) :
147 'Réactivité'
148 eIter = self.getEventsIterator()
149 latencies = []
150 lastnoteEndT = 0
151
152 for ticks, eventName, message in eIter :
153 if eventName == 'NOTEEND':
154 lastnoteEndT = ticks
155 if eventName == 'NOTEON' and lastnoteEndT :
156 latencies.append(ticks - lastnoteEndT)
157
158 return latencies
159
160 def noteOnCount(self) :
161 "retourne le nombre d'événements NOTEON"
162
163 eIter = self.getEventsIterator()
164 cpt = 0
165
166 for ticks, eventName, message in eIter :
167 if eventName == 'NOTEON' :
168 cpt = cpt + 1
169
170 return cpt
171
172 def realisationRate(self) :
173 'Taux de réalisation'
174 #taux de réalisation en nombre de note
175 #peut être supérieur à 100 % car la chanson
176 #boucle à l'infini.
177
178 songFile = self.getSongFile()
179 song = musicXml2Song(songFile)
180 songNoteCpt = 0
181 for note, verseIndex in song.iterNotes() :
182 songNoteCpt = songNoteCpt + 1
183
184 return round(self.noteOnCount() / float(songNoteCpt) * 100, 1)
185
186 def missCount(self) :
187 "Nombre d'erreurs"
188 eIter = self.getEventsIterator()
189 miss = 0
190 if self.mode in ('EASY', 'NORMAL') :
191 catchColUp = False
192 for ticks, eventName, message in eIter :
193 if eventName == 'COLDOWN' :
194 colState = message.split(None, 2)[1]
195 colState = colState == 'True'
196 if colState :
197 catchColUp = False
198 continue
199 else :
200 catchColUp = True
201 elif eventName == 'NOTEON' :
202 catchColUp = False
203 elif eventName == 'COLUP' and catchColUp :
204 miss = miss + 1
205 else :
206 for ticks, eventName, message in eIter :
207 if eventName == 'COLDOWN' :
208 colState = message.split(None, 2)[1]
209 colState = colState == 'True'
210 if not colState :
211 miss = miss + 1
212
213 return miss
214
215 @timebased
216 def getMissPerTimeFrame(self, timeFrame=10000) :
217 "Nombre d'erreurs en fonction du temps"
218 eIter = self.getEventsIterator()
219 firstTicks = self.getFirstEventTicks()
220 frames = [0]
221
222 if self.mode in ('EASY', 'NORMAL') :
223 catchColUp = False
224 for ticks, eventName, message in eIter :
225 if ticks - firstTicks > timeFrame :
226 firstTicks = ticks
227 frames.append(0)
228
229 if eventName == 'COLDOWN' :
230 colState = message.split(None, 2)[1]
231 colState = colState == 'True'
232 if colState :
233 catchColUp = False
234 continue
235 else :
236 catchColUp = True
237 elif eventName == 'NOTEON' :
238 catchColUp = False
239 elif eventName == 'COLUP' and catchColUp :
240 frames[-1] = frames[-1] + 1
241 else :
242 for ticks, eventName, message in eIter :
243 if ticks - firstTicks > timeFrame :
244 firstTicks = ticks
245 frames.append(0)
246
247 if eventName == 'COLDOWN' :
248 colState = message.split(None, 2)[1]
249 colState = colState == 'True'
250 if not colState :
251 frames[-1] = frames[-1] + 1
252
253 return frames
254
255
256
257
258
259 def main() :
260 from optparse import OptionParser
261 usage = "%prog logfile"
262 op = OptionParser(usage)
263 options, args = op.parse_args()
264 if len(args) != 1 :
265 op.error("incorrect number of arguments")
266
267
268 lfa = LogFileAnalyser(args[0])
269 pprint(lfa.analyse())
270
271 if __name__ == "__main__" :
272 from os.path import realpath, sep
273 import sys
274 minwiipath = realpath(__file__).split(sep)
275 minwiipath = minwiipath[:-2]
276 minwiipath = sep.join(minwiipath)
277 sys.path.insert(1, minwiipath)
278 main()