Passage à MINDs 2.0.2.
[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 = 0
143 for note, verseIndex in song.iterNotes() :
144 duration = duration + note.duration
145 duration = duration * song.quarterNoteDuration # en milisecondes
146 return self._toTimeDelta(duration)
147
148 @statsresults
149 def noteEndNoteOnLatency(self) :
150 'Réactivité'
151 eIter = self.getEventsIterator()
152 latencies = []
153 lastnoteEndT = 0
154
155 for ticks, eventName, message in eIter :
156 if eventName == 'NOTEEND':
157 lastnoteEndT = ticks
158 if eventName == 'NOTEON' and lastnoteEndT :
159 latencies.append(ticks - lastnoteEndT)
160
161 return latencies
162
163 def noteOnCount(self) :
164 "retourne le nombre d'événements NOTEON"
165
166 eIter = self.getEventsIterator()
167 cpt = 0
168
169 for ticks, eventName, message in eIter :
170 if eventName == 'NOTEON' :
171 cpt = cpt + 1
172
173 return cpt
174
175 def realisationRate(self) :
176 'Taux de réalisation'
177 #taux de réalisation en nombre de note
178 #peut être supérieur à 100 % car la chanson
179 #boucle à l'infini.
180
181 songFile = self.getSongFile()
182 song = musicXml2Song(songFile)
183 songNoteCpt = 0
184 for note, verseIndex in song.iterNotes() :
185 songNoteCpt = songNoteCpt + 1
186
187 return round(self.noteOnCount() / float(songNoteCpt) * 100, 1)
188
189 def missCount(self) :
190 "Nombre d'erreurs"
191 eIter = self.getEventsIterator()
192 miss = 0
193 if self.mode in ('EASY', 'NORMAL') :
194 catchColUp = False
195 for ticks, eventName, message in eIter :
196 if eventName == 'COLDOWN' :
197 colState = message.split(None, 2)[1]
198 colState = colState == 'True'
199 if colState :
200 catchColUp = False
201 continue
202 else :
203 catchColUp = True
204 elif eventName == 'NOTEON' :
205 catchColUp = False
206 elif eventName == 'COLUP' and catchColUp :
207 miss = miss + 1
208 else :
209 for ticks, eventName, message in eIter :
210 if eventName == 'COLDOWN' :
211 colState = message.split(None, 2)[1]
212 colState = colState == 'True'
213 if not colState :
214 miss = miss + 1
215
216 return miss
217
218 @timebased
219 def getMissPerTimeFrame(self, timeFrame=10000) :
220 "Nombre d'erreurs en fonction du temps"
221 eIter = self.getEventsIterator()
222 firstTicks = self.getFirstEventTicks()
223 frames = [0]
224
225 if self.mode in ('EASY', 'NORMAL') :
226 catchColUp = False
227 for ticks, eventName, message in eIter :
228 if ticks - firstTicks > timeFrame :
229 firstTicks = ticks
230 frames.append(0)
231
232 if eventName == 'COLDOWN' :
233 colState = message.split(None, 2)[1]
234 colState = colState == 'True'
235 if colState :
236 catchColUp = False
237 continue
238 else :
239 catchColUp = True
240 elif eventName == 'NOTEON' :
241 catchColUp = False
242 elif eventName == 'COLUP' and catchColUp :
243 frames[-1] = frames[-1] + 1
244 else :
245 for ticks, eventName, message in eIter :
246 if ticks - firstTicks > timeFrame :
247 firstTicks = ticks
248 frames.append(0)
249
250 if eventName == 'COLDOWN' :
251 colState = message.split(None, 2)[1]
252 colState = colState == 'True'
253 if not colState :
254 frames[-1] = frames[-1] + 1
255
256 return frames
257
258
259
260
261
262 def main() :
263 from optparse import OptionParser
264 usage = "%prog logfile"
265 op = OptionParser(usage)
266 options, args = op.parse_args()
267 if len(args) != 1 :
268 op.error("incorrect number of arguments")
269
270
271 lfa = LogFileAnalyser(args[0])
272 pprint(lfa.analyse())
273
274 if __name__ == "__main__" :
275 from os.path import realpath, sep
276 import sys
277 minwiipath = realpath(__file__).split(sep)
278 minwiipath = minwiipath[:-2]
279 minwiipath = sep.join(minwiipath)
280 sys.path.insert(1, minwiipath)
281 main()