comparison Syncopation models/readmidi.py @ 10:a3ed7d2b57d8

updating main py files to point at new
file names

 """
 
 from midiparser import MidiFile, MidiTrack, DeltaTime, MidiEvent
 #from RhythmParser import Bar
 
-from MusicObjects import *
+from music_objects import *
 
 
 
 
 
-def readMidiFile(filename):
+def read_midi_file(filename):
 	""" open and read a MIDI file, return a MidiFile object """
 
 	#create a midifile object, open and read a midi file
 	midiFile = MidiFile()
 	midiFile.open(filename, 'rb')
 	midiFile.read()
 	midiFile.close()
 
 	return midiFile
 
-def getBars(midiFile, trackindex=1):
+# def get_bars(midiFile, trackindex=1):
+# 	""" returns a list of bar objects from a MidiFile object """
 
-	track = midiFile.tracks[trackindex] # ignore dummy track 0
-	eventIdx = 0
-	numNotes = 0
+# 	# select a track to extract (default = 1, ignoring dummy track 0)
+# 	track = midiFile.tracks[trackindex] 
+# 	eventIndex = 0
+# 	numNotes = 0
 
-	noteonlist = []
-	noteOnFound==True
+# 	noteonlist = []
+# 	noteOnFound==True
 
-	while noteOnFound==True:
-		(noteOnIdx, noteOnDelta, noteOnFound) = self.findEvent(track, eventIdx, lambda e: e.type == 'NOTE_ON')
-		noteEvent = track.events[noteOnIdx]
-		eventIdx = noteOnIdx + 1
+# 	while noteOnFound==True:
+# 		(noteOnIndex, noteOnDelta, noteOnFound) = self.find_event(track, eventIndex, lambda e: e.type == 'NOTE_ON')
+# 		noteEvent = track.events[noteOnIndex]
+# 		eventIndex = noteOnIndex + 1
             	
 
 
 
 
 
-def findEvent(track, eventStartIdx, lambdaExpr):
+def find_event(track, eventStartIndex, lambdaExpr):
 	'''
 	From code by Csaba Sulyok:
 	Finds MIDI event based on lambda expression, starting from a given index.
 	Returns a tuple of the following 3 elements:
 	1. event index where the lambda expression is true
 	2. aggregate delta time from event start index until the found event
 	3. flag whether or not any value was found, or we've reached the end of the event queue
 	'''
 
-	eventIdx = eventStartIdx
+	eventIndex = eventStartIndex
 	deltaTime = 0
-	while eventIdx < len(track.events) and not lambdaExpr(track.events[eventIdx]):
-	    if track.events[eventIdx].type == 'DeltaTime':
-	        deltaTime += track.events[eventIdx].time
-	    eventIdx += 1
+	while eventIndex < len(track.events) and not lambdaExpr(track.events[eventIndex]):
+	    if track.events[eventIndex].type == 'DeltaTime':
+	        deltaTime += track.events[eventIndex].time
+	    eventIndex += 1
 
-	success = eventIdx < len(track.events)
-	return (eventIdx, deltaTime, success)
+	success = eventIndex < len(track.events)
+	return (eventIndex, deltaTime, success)