comparison Syncopation models/SG.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
 
-** Sioros and Guedes's Model **
-
-Algorithm:
-
-Only applicable to monorhythms.
-
-This version of implementation follows the description in authors' 2011 ISMIR paper and assumes each bar of rhythm is looped.
-Therefore each bar is calculated seperatedly in a loop-mode and summed up in the end as the total syncopation. 
-
 '''
 
-from MeterStructure import MeterStructure
-from math import pow
+from basic_functions import get_H, get_min_timeSpan
 
-def subdivide(sequence, segments_num):
-	subSeq = []
-	if len(sequence) % segments_num != 0:
-		print 'Error: rhythm segment cannot be equally subdivided '
+def get_syncopation(seq, subdivision_seq, weight_seq, L_max, rhythm_category):
+	syncopation = None
+	if rhythm_category == 'poly':
+		print 'Error: SG model cannot deal with polyrhythms.'
 	else:
-		n = len(sequence) / segments_num
-		start , end = 0, n
-		for i in range(segments_num):
-			subSeq.append(sequence[start : end])
-			start = end
-			end = end + n
-	
-	return subSeq
+		
+		seq = get_min_timeSpan(seq)	# converting to the minimum time-span format
+		
+		# checking whether the given L_max is enough to analyse the given sequence, if not, request a bigger L_max
+		new_L_max = True
+		matching_level = L_max
+		while matching_level >= 0:
+			if len(get_H(weight_seq,subdivision_seq, matching_level)) == len(seq):
+				new_L_max = False
+				break
+			else:
+				matching_level = matching_level - 1
 
+		if new_L_max == True:
+			print 'Error: needs a bigger L_max (i.e. the lowest metrical level) to match the given rhythm sequence.'
 
-def sgModel(rhythm, time_sig, category, bar):
-	ms = MeterStructure(time_sig)
-	mWeights = ms.getLHLWeights(1)
-	#print "hierarchy", mWeights
-	num_onsets = 0
-	h_min = min(mWeights)
+		else:
+			syncopation = 0
+			# generate the metrical weights of the lowest level
+			H = get_H(weight_seq,subdivision_seq, matching_level)
 
-	syncAbsolute = 0
-	syncNormM = 0
-	syncNormE = 0
-	
-	if 'poly' in category:
-		syncAbsolute = -1
-	else:
-		# segment rhythm into bars
-		rhythm_byBar = subdivide (rhythm, bar)
-
-		def measurePerBar(rhythm):
-			syncopation = 0
-			
-			def aveNeighbours(index, h):
+			# The aveDif_neighbours function calculates the (weighted) average of the difference between the note at a certain index and its neighbours in a certain metrical level
+			def aveDif_neighbours(index, level):
 				averages = []
-				parameter_k = 0.8
+				parameter_garma = 0.8
 				
-				def findPre(h_hat):
-					pre_index = index - 1
-					while(mWeights[pre_index] < h_hat):
-						pre_index = (pre_index - 1)%len(mWeights)
-					#print "h_hat and pre", h_hat, pre_index
+				# The findPre function is to calculate the index of the previous neighbour at a certain metrical level.
+				def findPre(index, level):
+					pre_index = (index - 1)%len(H)
+					while(H[pre_index] > level):
+						pre_index = (pre_index - 1)%len(H)
 					return pre_index
 
-				def findPost(h_hat):
-					post_index = (index + 1)%len(mWeights)
-					while(mWeights[post_index] < h_hat):
-						post_index = (post_index + 1)%len(mWeights)
-					#print "h_hat and post", h_hat, post_index
+				# The findPost function is to calculate the index of the next neighbour at a certain metrical level.
+				def findPost(index, level):
+					post_index = (index + 1)%len(H)
+					while(H[post_index] > level):
+						post_index = (post_index + 1)%len(H)
 					return post_index
 				
+				# The dif function is to calculate a difference level factor between two notes (at note position index1 and index 2) in velocity sequence
 				def dif(index1,index2):
 					parameter_beta = 0.5
-					pos1 = int(float(index1)/len(mWeights)*48)
-					pos2 = int(float(index2)/len(mWeights)*48)
-					dif_v = rhythm[pos1]-rhythm[pos2]
-					dif_h = abs(mWeights[index1]-mWeights[index2])
+					dif_v = seq[index1]-seq[index2]
+					dif_h = abs(H[index1]-H[index2])
 					dif = dif_v*(parameter_beta*dif_h/4+1-parameter_beta)
-					#print 'dif', dif
 					return dif
 
-				for h_hat in range(h_min,h+1):
-					ave = ( parameter_k*dif(index,findPre(h_hat))+dif(index,findPost(h_hat)) )/(1+parameter_k)
-					#print 'ave', ave
+				# From the highest to the lowest metrical levels where the current note resides, calculate the difference between the note and its neighbours at that level
+				for l in range(level, max(H)+1):
+					ave = ( parameter_garma*dif(index,findPre(index,l))+dif(index,findPost(index,l)) )/(1+parameter_garma)
 					averages.append(ave)
-
 				return averages
 
-			for pos in range(len(rhythm)):
-				if rhythm[pos] != 0: # Onset detected
-					#num_onsets += 1
-					i = int((pos/48.0*len(mWeights)))
-					h = mWeights[i]
-					potential = 1 - pow(0.5,(-h))
-					#print "intermediate", min(aveNeighbours(i,h))
-					syncopation += min(aveNeighbours(i, h))*potential
-
-			return syncopation
-
-		for r in rhythm_byBar:
-			syncAbsolute = syncAbsolute + measurePerBar(r)
-		#syncAbsolute /= 2.0
-
-	return syncAbsolute
-
-# Retrieve the stimuli
-#f = file('stimuli.txt')
-#f = file('stimuli_34only.txt')
-f = file('clave.txt')
-
-
-#Calculate syncopation for each rhythm pattern
-#while True:
-for i in range(1):
-	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, sgModel(rhythm, time_sig, category, bar)
+			# Calculate the syncopation value for each note
+			for index in range(len(seq)):
+				if seq[index] != 0: # Onset detected
+					h = H[index]
+					potential = 1 - pow(0.5,h) # Syncopation potential according to its metrical level, which is equal to the metrical weight
+					level = h 		# Metrical weight happens to be equal to its metrical level
+					syncopation += min(aveDif_neighbours(index, h))*potential
+			
+	return syncopation