X-Git-Url: https://svn.cri.ensmp.fr/git/minwii.git/blobdiff_plain/eec2dd4ea183465c2c95546402447303ee6320e4..fd41523cab5f6d32f3222dd43c299f895a582450:/src/minwii/loganalyse.py

diff --git a/src/minwii/loganalyse.py b/src/minwii/loganalyse.py
index 4a0460a..ec1b025 100755
--- a/src/minwii/loganalyse.py
+++ b/src/minwii/loganalyse.py
@@ -5,3 +5,202 @@ Module d'analyse des fichiers de log minwii.
 $Id$
 $URL$
 """
+
+from minwii.logfilereader import LogFileReader
+from pprint import pprint
+from minwii.musicxml import musicXml2Song
+from minwii.globals import PLAYING_MODES
+from statlib import stats
+from datetime import timedelta
+
+PLAYING_MODES = dict(PLAYING_MODES)
+
+DEFAULT_STATS = (#'geometricmean',
+                 ('harmonicmean', 'Moyenne harmonique'),
+                 ('mean', 'Moyenne  '),
+                 ('median', 'Médiane'),
+                 #'medianscore',
+                 #'mode',
+                 #'moment',
+                 ('variation', 'Variation'),
+                 #'skew',
+                 ('kurtosis', 'Kurtosis'),
+                 #'itemfreq',
+                 #'histogram',
+                 #'cumfreq',
+                 #'relfreq',
+                 )
+
+def statsresults(m) :
+    def computeList(self):
+        l = m(self)
+        results = []
+        for name, label in DEFAULT_STATS :
+            results.append('%s : %s' % (label, getattr(stats, name)(l)))
+        return '\n'.join(results)
+    computeList.__name__ = m.__name__
+    computeList.__doc__ = m.__doc__
+    return computeList
+
+class LogFileAnalyser(LogFileReader) :
+
+    POSSIBLE_ANALYSES = {'BEGINNER' : ('songDuration',
+                                       'playingDuration',
+                                       'noteEndNoteOnLatency',
+                                       'realisationRate')
+                        ,'EASY'     : ('songDuration',
+                                       'playingDuration',
+                                       'noteEndNoteOnLatency',
+                                       'realisationRate',
+                                       'missCount')
+                        ,'NORMAL'   : ('songDuration',
+                                       'playingDuration',
+                                       'realisationRate',
+                                       'missCount')
+                        ,'ADVANCED' : ('songDuration',
+                                       'playingDuration',
+                                       'realisationRate',
+                                       'missCount')
+                        ,'EXPERT'   : ('songDuration',
+                                       'playingDuration',
+                                       'realisationRate',
+                                       'missCount')
+                        }
+    
+    def analyse(self) :
+        results = []
+        
+        try :
+            self.mode = mode = self.getMode()
+            results.append(('Mode de jeu', PLAYING_MODES.get(mode, mode)))
+            for name in self.POSSIBLE_ANALYSES[mode] :
+                meth = getattr(self, name)
+                results.append((meth.__doc__, meth()))
+        except :
+            raise
+        
+        return results
+    
+    def _toTimeDelta(self, milliseconds) :
+        duration = milliseconds / 1000.
+        duration = int(round(duration, 0))
+        return str(timedelta(seconds=duration))
+    
+    def playingDuration(self) :
+        'Temps de jeu'
+        #retourne la durée écoulée entre le premier et de dernier message
+        #de type événement : correspond à la durée d'interprétation.
+        
+        last = self.getLastEventTicks()
+        first = self.getFirstEventTicks()
+        return self._toTimeDelta(last - first)
+        
+    
+    def songDuration(self) :
+        'Durée de référence de la chanson'
+        #retourne la durée de référence de la chanson
+        #en prenant en compte le tempo présent dans la transcription
+        #et en effectuant toutes les répétitions des couplets / refrains.
+        
+        songFile = self.getSongFile()
+        song = musicXml2Song(songFile)
+        duration = 0
+        for note, verseIndex in song.iterNotes() :
+            duration = duration + note.duration
+        duration = duration * song.quarterNoteDuration # en milisecondes
+        return self._toTimeDelta(duration)
+    
+    @statsresults
+    def noteEndNoteOnLatency(self) :
+        'Réactivité'
+        eIter = self.getEventsIterator()
+        latencies = []
+        lastnoteEndT = 0
+        
+        for ticks, eventName, message in eIter :
+            if eventName == 'NOTEEND':
+                lastnoteEndT = ticks
+            if eventName == 'NOTEON' and lastnoteEndT :
+                latencies.append(ticks - lastnoteEndT)
+        
+        return latencies
+    
+    def noteOnCount(self) :
+        "retourne le nombre d'événements NOTEON"
+        
+        eIter = self.getEventsIterator()
+        cpt = 0        
+
+        for ticks, eventName, message in eIter :
+            if eventName == 'NOTEON' :
+                cpt = cpt + 1
+        
+        return cpt
+    
+    def realisationRate(self) :
+        'Taux de réalisation'
+        #taux de réalisation en nombre de note
+        #peut être supérieur à 100 % car la chanson
+        #boucle à l'infini.
+        
+        songFile = self.getSongFile()
+        song = musicXml2Song(songFile)
+        songNoteCpt = 0
+        for note, verseIndex in song.iterNotes() :
+            songNoteCpt = songNoteCpt + 1
+        
+        return round(self.noteOnCount() / float(songNoteCpt) * 100, 1)
+    
+    def missCount(self) :
+        "Nombre d'erreurs"
+        eIter = self.getEventsIterator()
+        miss = 0
+        if self.mode in ('EASY', 'NORMAL') :
+            catchColUp = False
+            for ticks, eventName, message in eIter :
+                if eventName == 'COLDOWN' :
+                    colState = message.split(None, 2)[1]
+                    colState = colState == 'True'
+                    if colState :
+                        catchColUp = False
+                        continue
+                    else :
+                        catchColUp = True
+                elif eventName == 'NOTEON' :
+                    catchColUp = False
+                elif eventName == 'COLUP' and catchColUp :
+                    miss = miss + 1
+        else :
+            for ticks, eventName, message in eIter :
+                if eventName == 'COLDOWN' :
+                    colState = message.split(None, 2)[1]
+                    colState = colState == 'True'
+                    if not colState :
+                        miss = miss + 1
+        
+        return miss
+                
+        
+        
+        
+
+def main() :
+    from optparse import OptionParser
+    usage = "%prog logfile"
+    op = OptionParser(usage)
+    options, args = op.parse_args()
+    if len(args) != 1 :
+        op.error("incorrect number of arguments")
+
+
+    lfa = LogFileAnalyser(args[0])
+    pprint(lfa.analyse())
+
+if __name__ == "__main__" :
+    from os.path import realpath, sep
+    import sys
+    minwiipath = realpath(__file__).split(sep)
+    minwiipath = minwiipath[:-2]
+    minwiipath = sep.join(minwiipath)
+    sys.path.insert(1, minwiipath)
+    main()