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
+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',
- 'moment',
- 'variation',
- 'skew',
- 'kurtosis',
+ #'moment',
+ ('variation', 'Variation'),
+ #'skew',
+ ('kurtosis', 'Kurtosis'),
#'itemfreq',
#'histogram',
#'cumfreq',
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
+def timebased(m) :
+ m.timebased = True
+ return m
+
class LogFileAnalyser(LogFileReader) :
POSSIBLE_ANALYSES = {'BEGINNER' : ('songDuration',
'playingDuration',
'noteEndNoteOnLatency',
'realisationRate')
+
,'EASY' : ('songDuration',
'playingDuration',
'noteEndNoteOnLatency',
'realisationRate',
- 'missCount')
+ 'missCount',
+ 'getMissPerTimeFrame')
+
,'NORMAL' : ('songDuration',
'playingDuration',
'realisationRate',
- 'missCount')
+ 'missCount',
+ 'getMissPerTimeFrame')
+
,'ADVANCED' : ('songDuration',
'playingDuration',
'realisationRate',
- 'missCount')
+ 'missCount',
+ 'getMissPerTimeFrame')
+
,'EXPERT' : ('songDuration',
'playingDuration',
'realisationRate',
- 'missCount')
+ 'missCount',
+ 'getMissPerTimeFrame')
}
def analyse(self) :
- results = {}
+ results = []
try :
self.mode = mode = self.getMode()
- results['playingMode'] = mode
+ 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[name] = meth()
+ results.append( (meth.__doc__, meth(), getattr(meth, 'timebased', False)) )
except :
- pass
+ raise
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) :
- """ 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()
- return last - first
+ return self._toTimeDelta(last - first)
+
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
- return duration * song.quarterNoteDuration
+ duration = duration * song.quarterNoteDuration # en milisecondes
+ return self._toTimeDelta(duration)
@statsresults
def noteEndNoteOnLatency(self) :
+ 'Réactivité'
eIter = self.getEventsIterator()
latencies = []
lastnoteEndT = 0
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
- return int(round(self.noteOnCount() / float(songNoteCpt) * 100, 0))
+ 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') :
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
projects / minwii.git / blobdiff