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 class LogFileAnalyser(LogFileReader) :
  48
  49     POSSIBLE_ANALYSES = {'BEGINNER' : ('songDuration',
  50                                        'playingDuration',
  51                                        'noteEndNoteOnLatency',
  52                                        'realisationRate')
  53                         ,'EASY'     : ('songDuration',
  54                                        'playingDuration',
  55                                        'noteEndNoteOnLatency',
  56                                        'realisationRate',
  57                                        'missCount')
  58                         ,'NORMAL'   : ('songDuration',
  59                                        'playingDuration',
  60                                        'realisationRate',
  61                                        'missCount')
  62                         ,'ADVANCED' : ('songDuration',
  63                                        'playingDuration',
  64                                        'realisationRate',
  65                                        'missCount')
  66                         ,'EXPERT'   : ('songDuration',
  67                                        'playingDuration',
  68                                        'realisationRate',
  69                                        'missCount')
  70                         }
  71
  72     def analyse(self) :
  73         results = []
  74
  75         try :
  76             self.mode = mode = self.getMode()
  77             results.append(('Mode de jeu', PLAYING_MODES.get(mode, mode)))
  78
  79             self.songTitle = LogFileAnalyser.getSongTitle(self.getSongFile())
  80             results.append(('Chanson', self.songTitle))
  81
  82             for name in self.POSSIBLE_ANALYSES[mode] :
  83                 meth = getattr(self, name)
  84                 results.append((meth.__doc__, meth()))
  85         except :
  86             raise
  87
  88         return results
  89
  90     @staticmethod
  91     def getSongTitle(file) :
  92         if os.path.exists(file) :
  93             it = ElementTree.iterparse(file, ['start', 'end'])
  94             creditFound = False
  95
  96             for evt, el in it :
  97                 if el.tag == 'credit' :
  98                     creditFound = True
  99                 if el.tag == 'credit-words' and creditFound:
 100                     return el.text
 101                 if el.tag == 'part-list' :
 102                     # plus de chance de trouver un titre
 103                     return os.path.basename(file)
 104         else :
 105             return os.path.basename(file)
 106
 107     def _toTimeDelta(self, milliseconds) :
 108         duration = milliseconds / 1000.
 109         duration = int(round(duration, 0))
 110         return str(timedelta(seconds=duration))
 111
 112     def playingDuration(self) :
 113         'Temps de jeu'
 114         #retourne la durée écoulée entre le premier et de dernier message
 115         #de type événement : correspond à la durée d'interprétation.
 116
 117         last = self.getLastEventTicks()
 118         first = self.getFirstEventTicks()
 119         return self._toTimeDelta(last - first)
 120
 121
 122     def songDuration(self) :
 123         'Durée de référence de la chanson'
 124         #retourne la durée de référence de la chanson
 125         #en prenant en compte le tempo présent dans la transcription
 126         #et en effectuant toutes les répétitions des couplets / refrains.
 127
 128         songFile = self.getSongFile()
 129         song = musicXml2Song(songFile)
 130         duration = 0
 131         for note, verseIndex in song.iterNotes() :
 132             duration = duration + note.duration
 133         duration = duration * song.quarterNoteDuration # en milisecondes
 134         return self._toTimeDelta(duration)
 135
 136     @statsresults
 137     def noteEndNoteOnLatency(self) :
 138         'Réactivité'
 139         eIter = self.getEventsIterator()
 140         latencies = []
 141         lastnoteEndT = 0
 142
 143         for ticks, eventName, message in eIter :
 144             if eventName == 'NOTEEND':
 145                 lastnoteEndT = ticks
 146             if eventName == 'NOTEON' and lastnoteEndT :
 147                 latencies.append(ticks - lastnoteEndT)
 148
 149         return latencies
 150
 151     def noteOnCount(self) :
 152         "retourne le nombre d'événements NOTEON"
 153
 154         eIter = self.getEventsIterator()
 155         cpt = 0
 156
 157         for ticks, eventName, message in eIter :
 158             if eventName == 'NOTEON' :
 159                 cpt = cpt + 1
 160
 161         return cpt
 162
 163     def realisationRate(self) :
 164         'Taux de réalisation'
 165         #taux de réalisation en nombre de note
 166         #peut être supérieur à 100 % car la chanson
 167         #boucle à l'infini.
 168
 169         songFile = self.getSongFile()
 170         song = musicXml2Song(songFile)
 171         songNoteCpt = 0
 172         for note, verseIndex in song.iterNotes() :
 173             songNoteCpt = songNoteCpt + 1
 174
 175         return round(self.noteOnCount() / float(songNoteCpt) * 100, 1)
 176
 177     def missCount(self) :
 178         "Nombre d'erreurs"
 179         eIter = self.getEventsIterator()
 180         miss = 0
 181         if self.mode in ('EASY', 'NORMAL') :
 182             catchColUp = False
 183             for ticks, eventName, message in eIter :
 184                 if eventName == 'COLDOWN' :
 185                     colState = message.split(None, 2)[1]
 186                     colState = colState == 'True'
 187                     if colState :
 188                         catchColUp = False
 189                         continue
 190                     else :
 191                         catchColUp = True
 192                 elif eventName == 'NOTEON' :
 193                     catchColUp = False
 194                 elif eventName == 'COLUP' and catchColUp :
 195                     miss = miss + 1
 196         else :
 197             for ticks, eventName, message in eIter :
 198                 if eventName == 'COLDOWN' :
 199                     colState = message.split(None, 2)[1]
 200                     colState = colState == 'True'
 201                     if not colState :
 202                         miss = miss + 1
 203
 204         return miss
 205
 206
 207
 208
 209
 210 def main() :
 211     from optparse import OptionParser
 212     usage = "%prog logfile"
 213     op = OptionParser(usage)
 214     options, args = op.parse_args()
 215     if len(args) != 1 :
 216         op.error("incorrect number of arguments")
 217
 218
 219     lfa = LogFileAnalyser(args[0])
 220     pprint(lfa.analyse())
 221
 222 if __name__ == "__main__" :
 223     from os.path import realpath, sep
 224     import sys
 225     minwiipath = realpath(__file__).split(sep)
 226     minwiipath = minwiipath[:-2]
 227     minwiipath = sep.join(minwiipath)
 228     sys.path.insert(1, minwiipath)
 229     main()