Remplacement du carillon par le tintinabule.

[minwii.git] / src / minwii / loganalyse.py

diff --git a/src/minwii/loganalyse.py b/src/minwii/loganalyse.py
index 952c3a7..f3e5e32 100755 (executable)
--- a/src/minwii/loganalyse.py
+++ b/src/minwii/loganalyse.py
@@ -6,21 +6,27 @@ $Id$
 $URL$
 """
 
 $URL$
 """
 

-from logfilereader import LogFileReader
+from minwii.logfilereader import LogFileReader

 from pprint import pprint
 from pprint import pprint

-from musicxml import musicXml2Song
+from minwii.musicxml import musicXml2Song
+from minwii.globals import PLAYING_MODES

 from statlib import stats
 from statlib import stats

+from datetime import timedelta
+from xml.etree import ElementTree
+import os.path

 
 

-DEFAULT_STATS = ('geometricmean',
-                 'harmonicmean',
-                 'mean',
-                 'median',
-                 'medianscore',
+PLAYING_MODES = dict(PLAYING_MODES)
+
+DEFAULT_STATS = (#'geometricmean',
+                 ('harmonicmean', 'Moyenne harmonique'),
+                 ('mean', 'Moyenne  '),
+                 ('median', 'Médiane'),
+                 #'medianscore',

                  #'mode',
                  #'mode',

-                 'moment',
-                 'variation',
-                 'skew',
-                 'kurtosis',
+                 #'moment',
+                 ('variation', 'Variation'),
+                 #'skew',
+                 ('kurtosis', 'Kurtosis'),

                  #'itemfreq',
                  #'histogram',
                  #'cumfreq',
                  #'itemfreq',
                  #'histogram',
                  #'cumfreq',


@@ -30,71 +36,118 @@ DEFAULT_STATS = ('geometricmean',
 def statsresults(m) :
     def computeList(self):
         l = m(self)
 def statsresults(m) :
     def computeList(self):
         l = m(self)

-        ret = {}
-        for name in DEFAULT_STATS :
-            ret[name] = getattr(stats, name)(l)
-        return ret
+        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
 
     return computeList
 

+def timebased(m) :
+    m.timebased = True
+    return m
+

 class LogFileAnalyser(LogFileReader) :
 
     POSSIBLE_ANALYSES = {'BEGINNER' : ('songDuration',
                                        'playingDuration',
                                        'noteEndNoteOnLatency',
                                        'realisationRate')
 class LogFileAnalyser(LogFileReader) :
 
     POSSIBLE_ANALYSES = {'BEGINNER' : ('songDuration',
                                        'playingDuration',
                                        'noteEndNoteOnLatency',
                                        'realisationRate')

+                                       

                         ,'EASY'     : ('songDuration',
                                        'playingDuration',
                                        'noteEndNoteOnLatency',
                                        'realisationRate',
                         ,'EASY'     : ('songDuration',
                                        'playingDuration',
                                        'noteEndNoteOnLatency',
                                        'realisationRate',

-                                       'missCount')
+                                       'missCount',
+                                       'getMissPerTimeFrame')
+                                       

                         ,'NORMAL'   : ('songDuration',
                                        'playingDuration',
                                        'realisationRate',
                         ,'NORMAL'   : ('songDuration',
                                        'playingDuration',
                                        'realisationRate',

-                                       'missCount')
+                                       'missCount',
+                                       'getMissPerTimeFrame')
+                                       

                         ,'ADVANCED' : ('songDuration',
                                        'playingDuration',
                                        'realisationRate',
                         ,'ADVANCED' : ('songDuration',
                                        'playingDuration',
                                        'realisationRate',

-                                       'missCount')
+                                       'missCount',
+                                       'getMissPerTimeFrame')
+                                       

                         ,'EXPERT'   : ('songDuration',
                                        'playingDuration',
                                        'realisationRate',
                         ,'EXPERT'   : ('songDuration',
                                        'playingDuration',
                                        'realisationRate',

-                                       'missCount')
+                                       'missCount',
+                                       'getMissPerTimeFrame')

                         }
     
     def analyse(self) :
                         }
     
     def analyse(self) :

-        self.mode = mode = self.getMode()
-        print 'Mode :', mode
-        
-        results = {}
+        results = []

         
         

-        for name in self.POSSIBLE_ANALYSES[mode] :
-            meth = getattr(self, name)
-            results[name] = meth()
+        try :
+            self.mode = mode = self.getMode()
+            results.append(('Mode de jeu', PLAYING_MODES.get(mode, mode), False))
+
+            self.songTitle = LogFileAnalyser.getSongTitle(self.getSongFile())
+            results.append(('Chanson', self.songTitle, False))
+
+            for name in self.POSSIBLE_ANALYSES[mode] :
+                meth = getattr(self, name)
+                results.append( (meth.__doc__, meth(), getattr(meth, 'timebased', False)) )
+        except :
+            raise

         
         

-        pprint(results)
+        return results
+    
+    @staticmethod
+    def getSongTitle(file) :
+        if os.path.exists(file) :
+            it = ElementTree.iterparse(file, ['start', 'end'])
+            creditFound = False
+
+            for evt, el in it :
+                if el.tag == 'credit' :
+                    creditFound = True
+                if el.tag == 'credit-words' and creditFound:
+                    return el.text
+                if el.tag == 'part-list' :
+                    # plus de chance de trouver un titre
+                    return os.path.basename(file)
+        else :
+            return os.path.basename(file)
+
+    def _toTimeDelta(self, milliseconds) :
+        duration = milliseconds / 1000.
+        duration = int(round(duration, 0))
+        return str(timedelta(seconds=duration))

     
     def playingDuration(self) :
     
     def playingDuration(self) :

-        """ retourne la durée écoulée entre le premier et de dernier message
-            de type événement : correspond à la durée d'interprétation.
-        """
+        '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()
         last = self.getLastEventTicks()
         first = self.getFirstEventTicks()

-        return last - first
+        return self._toTimeDelta(last - first)
+        

     
     def songDuration(self) :
     
     def songDuration(self) :

-        """ 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.
-        """
+        '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
         songFile = self.getSongFile()
         song = musicXml2Song(songFile)
         duration = 0
         for note, verseIndex in song.iterNotes() :
             duration = duration + note.duration

-        return duration * song.quarterNoteDuration
+        duration = duration * song.quarterNoteDuration # en milisecondes
+        return self._toTimeDelta(duration)

     
     @statsresults
     def noteEndNoteOnLatency(self) :
     
     @statsresults
     def noteEndNoteOnLatency(self) :

+        'Réactivité'

         eIter = self.getEventsIterator()
         latencies = []
         lastnoteEndT = 0
         eIter = self.getEventsIterator()
         latencies = []
         lastnoteEndT = 0


@@ -120,19 +173,21 @@ class LogFileAnalyser(LogFileReader) :
         return cpt
     
     def realisationRate(self) :
         return cpt
     
     def realisationRate(self) :

-        """ taux de réalisation en nombre de note
-            peut être supérieur à 100 % car la chanson
-            boucle à l'infini.
-        """
+        '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
         
         songFile = self.getSongFile()
         song = musicXml2Song(songFile)
         songNoteCpt = 0
         for note, verseIndex in song.iterNotes() :
             songNoteCpt = songNoteCpt + 1
         

-        return int(round(self.noteOnCount() / float(songNoteCpt) * 100, 0))
+        return round(self.noteOnCount() / float(songNoteCpt) * 100, 1)

     
     def missCount(self) :
     
     def missCount(self) :

+        "Nombre d'erreurs"

         eIter = self.getEventsIterator()
         miss = 0
         if self.mode in ('EASY', 'NORMAL') :
         eIter = self.getEventsIterator()
         miss = 0
         if self.mode in ('EASY', 'NORMAL') :


@@ -159,6 +214,46 @@ class LogFileAnalyser(LogFileReader) :
                         miss = miss + 1
         
         return miss
                         miss = miss + 1
         
         return miss

+    
+    @timebased
+    def getMissPerTimeFrame(self, timeFrame=10000) :
+        "Nombre d'erreurs en fonction du temps"
+        eIter = self.getEventsIterator()
+        firstTicks = self.getFirstEventTicks()
+        frames = [0]
+
+        if self.mode in ('EASY', 'NORMAL') :
+            catchColUp = False
+            for ticks, eventName, message in eIter :
+                if ticks - firstTicks > timeFrame :
+                    firstTicks = ticks
+                    frames.append(0)
+                    
+                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 :
+                    frames[-1] = frames[-1] + 1
+        else :
+            for ticks, eventName, message in eIter :
+                if ticks - firstTicks > timeFrame :
+                    firstTicks = ticks
+                    frames.append(0)
+                
+                if eventName == 'COLDOWN' :
+                    colState = message.split(None, 2)[1]
+                    colState = colState == 'True'
+                    if not colState :
+                        frames[-1] = frames[-1] + 1
+        
+        return frames

                 
         
         
                 
         
         


@@ -174,7 +269,7 @@ def main() :
 
 
     lfa = LogFileAnalyser(args[0])
 
 
     lfa = LogFileAnalyser(args[0])

-    lfa.analyse()
+    pprint(lfa.analyse())

 
 if __name__ == "__main__" :
     from os.path import realpath, sep
 
 if __name__ == "__main__" :
     from os.path import realpath, sep