comparison Syncopation models/WNBD.py @ 1:b2da092dc2e0

The consolidated syncopation software. Have finished individual model and basic functions. Need to revise the coding in main.py, and add rhythm-input interface.

 '''
 Author: Chunyang Song
 Institution: Centre for Digital Music, Queen Mary University of London
 
-** Weighted Note-to-Beat Distance Model (WNBD) **
+'''
+from basic_functions import repeat, get_note_indices
 
-Algorithm:
+def cumu_multiply(numbers):
+	product = 1
+	for n in numbers:
+		product = product*n
+	return product
 
-Calculate the distance (d) of onset to the nearest strong beat;
-Calculate the WNBD measure (w) of each onset;
-Syncopation is the sum of WNBD measures divided by the number of onsets.
+def get_syncopation(seq, subdivision_seq, strong_beat_level, postbar_seq):
+	syncopation = None
+	
+	num_beats = cumu_multiply(subdivision_seq[0:strong_beat_level+1])	# num_beats is the number of strong beats
+	if len(seq)%num_beats != 0:
+		print 'Error: the length of sequence is not subdivable by the subdivision factor in subdivision_seq.'
+	else:
+		# Find the indices of all the strong-beats
+		beat_indices = []
+		beat_interval = len(seq)/num_beats
+		for i in range(num_beats+1):
+			beat_indices.append(i*beat_interval)
+		if postbar_seq != None:		# if there is a postbar_seq, add another two beats index for later calculation
+			beat_indices += [len(seq)+beat_interval, len(seq)+ 2* beat_interval]
 
-'''
+		note_indices = get_note_indices(seq)	# all the notes
 
-from MeterStructure import MeterStructure
+		# Calculate the WNBD measure for each note
+		def measure_pernote(note_index, nextnote_index):
+			# Find the nearest beats where this note locates - in [beat_indices[j], beat_indices[j+1]) 
+			j = 0
+			while note_index < beat_indices[j] or note_index >= beat_indices[j+1]:
+				j = j + 1
+			
+			# The distance of note to nearest beat normalised by the beat interval
+			distance_nearest_beat = min(abs(note_index - beat_indices[j]), abs(note_index - beat_indices[j+1]))/float(beat_interval)
 
-def WNBD(rhythm, time_sig, category, bar):
+			# if this note is on-beat
+			if distance_nearest_beat == 0:	
+				measure = 0
+			# or if this note is held on past the following beat, but ends on or before the later beat  
+			elif beat_indices[j+1] < nextnote_index <= beat_indices[j+2]:
+				measure = float(2)/distance_nearest_beat
+			else:
+				measure = float(1)/distance_nearest_beat
 
-	ms = MeterStructure(time_sig)
-	beat = ms.getBeats(bar) + [len(rhythm)] # the "beat" array include all "strong-beat" positions across all bars, and the downbeat position of the following bar 
-	if len(beat)!=0:
-		unit = beat[1]-beat[0]  # how many digits to represent the length of one beat
+			return measure
 
-		onsetPos = []		# The onset positions
-		d = []				# The distances of each onset to its nearest strong beat
-		beatToLeft = []		# The beat indexes of the beats that are to the left of or coincide with each onset
-		wnbdMeasures = []   # the un-normalized measures of wnbd
-		
-		# Calculate the distance of each onset to the nearest strong beat
-		l = len(rhythm) 
-		for i in range(l):
-			if rhythm[i] == 1:    # onset detected
-				onsetPos.append(i)
-				
-				# find its distance to the nearest strong beat
-				for j in range(len(beat)-1):
-					if beat[j]<= i < beat[j+1]:
-						d1 = abs(i-beat[j])
-						d2 = abs(i-beat[j+1])
-						d.append( min(d1,d2)/float(unit) ) # Normalize the distance to beat-level
-						beatToLeft.append(j)
-					else:
-						continue
-		
-		#Calculate the WNBD measure of each onset
-		n = len(onsetPos)
-		for i in range(n):
-			if d[i] ==0:	# If on-beat, measure is 0
-				wnbdMeasures.append(0)
+		total = 0
+		for i in range(len(note_indices)):
+			if i == len(note_indices)-1:# if this is the last note, end_time is the index of the following note in the next bar
+				if postbar_seq != None and postbar_seq != repeat([0],len(postbar_seq)):
+					nextnote_index = get_note_indices(postbar_seq)[0]+len(seq)
+				else:	# or if the next bar is none or full rest, end_time is the end of this sequence.
+					nextnote_index = len(seq)
 			else:
-				if i == n-1: # The last note, then 
-					if beatToLeft[i] == beat[-3]/unit:	# if the last note has more than 1- but less than 2-beat distance to the next bar
-						wnbdMeasures.append(2.0/d[i])	# measure is 2/d, else 1/d
-					else:
-						wnbdMeasures.append(1.0/d[i])	
+				nextnote_index = note_indices[i+1]
+			total += measure_pernote(note_indices[i],nextnote_index)
 
-				else:        # if its not the last note
-					if beatToLeft[i+1] == beatToLeft[i] or (beatToLeft[i+1]-beatToLeft[i]==1 and d[i+1]==0): # if this note is no more than 1-beat distance away from the next note
-						wnbdMeasures.append(1.0/d[i])
-					elif beatToLeft[i+1] - beatToLeft[i] == 1 or (beatToLeft[i+1]-beatToLeft[i]==2 and d[i+1]==0):  # if this note is no more than 2-beat distance away from the next
-						wnbdMeasures.append(2.0/d[i])
-					else:								# if the note is more than 2-beat distance away from the next note
-						wnbdMeasures.append(1.0/d[i])
+		syncopation = float(total) / len(note_indices)
 
-		syncopation = sum(wnbdMeasures)/float(n)
-		return syncopation
-	
-	else:
-		return -1
-
-
-# Retrieve the stimuli
-f = file('stimuli.txt')
-#f = file('stimuli_34only.txt')
-
-#Calculate syncopation for each rhythm pattern
-while True:
-	line = f.readline().split(';')
-	if len(line) == 1:
-		 break
-	else:
-		sti_name = line[0]
-		rhythmString = line[1].split()
-		time_sig = line[2]
-		category = line[3]
-		bar = int(line[4])
-		
-		rhythm = map(int,rhythmString[0].split(','))
-
-		print sti_name, WNBD(rhythm, time_sig, category, bar)
+	return syncopation